JavaSE——day12集合

Collection集合

    集合的继承体系图如下所示：（学习顺序是：（从上向下））

Collection是集合层次的跟接口，JDK不提供此接口的任何实现方法，也没有字段，没有构造方法，只有方法。Collection只提供两个更具体的子接口，一个是List还有一个是Set。List接口的实现类中有3个子实现类。

    数组和长度的区别？ （1）长度区别：数组长度固定，集合长度可变。 （2）内容区别：数组可以存储同一种类型的元素，集合可以存储多种类型的元素。 （3）存储类型区别：数组可以存储基本类型，也可以存储引用类型。集合只能存储应用类型。

List：有序的集合类，通常允许重复的元素。

Set：无需的集合接口，不允许存在重复元素（因为有hash和equals方法的限制）。 List的子实现类：

    ArrayList的基本功能包括增加，删除，暴力删除，包含检测，空集合检测。。。 例子：

import java.util.ArrayList;import java.util.Collection;

public class Test1 {

 public static void main(String[] args) {

  Collection<String> c = new ArrayList<String>();    //添加功能  c.add("hello");  c.add("world");  c.add("!") ;  System.out.println(c);    //删除功能  c.remove("!");  System.out.println(c);//删除了以后在原集合中就没有了    boolean b = c.contains("world") ;   System.out.println("c中包含world？"+b);    System.out.println("c的元素数："+c.size());    //暴力删除  c.clear();  System.out.println("clear 暴力清除："+c);    //判断集合是否为空  boolean emp = c.isEmpty();  System.out.println("是否为空？"+emp);//因为我们用clear方法将数组暴力清空了，所以为空    //再添加一次元素    c.add("hello");  c.add("world");  c.add("!") ;      //应用类型转换为Array数组：可方便遍历  Object[] obj = c.toArray();  for(int x  = 0 ;x < obj.length ;x ++) {//hello world !     System.out.print(obj[x]+ " ");  }    Collection<String> c1 = new ArrayList<String>() ;  c1.add("aloha");  c1.add("你好") ;  c1.add("hello");  c1.add("空你系哇") ;  c1.add("world");  c1.add("!");    System.out.println("c: "+c);  System.out.println("c1: "+c1);  

  //交集判断  boolean c1jc = c1.retainAll(c) ;  boolean cjc1 = c.retainAll(c1) ;  System.out.println("c1交c： "+ c1jc+ ", c交c1: "+ cjc1);  //结论：两个集合求交集的返回值看是谁交谁，若是相交完前者不变化，返回true，若是相交完前者不变化，返回false

  //全部包含？  boolean c1c = c1.containsAll(c);  System.out.println("c1包含c？ "+c1c);      //删除一个？  boolean c1dc = c1.removeAll(c);  System.out.println("c1删除c？ "+c1dc);  System.out.println("现在c1中没有c中的元素了："+c1);    // }

}

添加的返回值是boolean ,如果添加成功返回true。contains和equals方法的返回值也都是boolean型，规规矩矩的反馈自己完成的情况。

clear()方法是没有返回值的，暴力删除就是这么猛，不用打招呼。

ArrayList的高级功能：全部删除，包含全部判断，应用类型转换。。。

控制台输出结果：

我们还可以用toArray方法实现对集合转换成对象数组进行遍历。

迭代器Iterator

        Iterator 是一个接口，这个接口是Collection的超级接口。这个接口有两个已知子实现类。它是一个迭代器，这个接口有两个方法：hasnext():若果有元素可以迭代，那么返回true，否则返回false。next()指向集合中的下一个元素。

创建集合的迭代器：

Iterator<E>

iterator()             //这是Collection集合上的一个方法          返回在此 collection 的元素上进行迭代的迭代器。

我们可以这样创建： Iterator it = Collection的对象名.iterator() ;

注意： 这里是调用集合的方法，而不是创建集合iterator的对象！所以下面这种是错误的：

    Iterator it = new c.iterator();

            另外，由于Collection是没有实现方法的，所以我们必须先创建Collection的实例化对象，默认创建ArrayList。

    Collection c = new ArrayList() ;

这样it就是我们创建的可用来调用迭代器的对象了。

集合调用迭代器并且用两个方法遍历的例子：

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class Test3 {

	public static void main(String[] args) {

		Collection<String> c = new ArrayList<String>() ; 
		
		c.add("hello") ;
		c.add("aloha") ;
		c.add("nihao") ;
		
		//通过集合获取迭代器
		Iterator it = c.iterator();
	
		//用hasnext和next方法遍历数组
		while(it.hasNext()) {
			System.out.print(it.next()+ " ");
		}
		
	}

}
           

List集合

    List集合的特点：有序的（存储和取出一致），可以允许重复元素。     List集合的特有功能：添加、删除、获取、修改。 例子：

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;

public class Test1 {

	public static void main(String[] args) {

		List<String> c = new ArrayList<String>() ;
		
		c.add("hello") ;
		c.add("nihao") ;
		c.add("空你系哇") ;
		System.out.println("c: "+ c);
		
		//从指定位置 处添加指定元素
		c.add(1, "aloha");
		System.out.println("在c的1索引插入元素： "+c);
		
		//获取：返回列表指定元素，列表迭代器
		String s = c.get(1) ;
		System.out.println("1索引处的元素是： "+ s );
		
		/**
		 * ListIterator有hasPrevious()和previous()方法，
		 * 可以实现逆向（顺序向前）遍历。Iterator就不可以。
		 */
		//ListIterator:获取列表迭代器
		System.out.print("获取列表迭代器：");
		ListIterator<String> it = c.listIterator();
		while(it.hasNext()) {
			System.out.print(it.next() + " ");
		}
		System.out.println();
		
		
		//修该方法
		String str = c.set(1, "aolhatothis");
		System.out.println(c+"   " + str);//str便是可以保存我们1号索引修改前的元素！
		
		
	}

}
           

    ListIterator继承自Iterator，在Iterator接口功能的基础上，增加了正向遍历和逆向遍历，但是在逆向遍历之前，必须得先正向遍历。

 java.util.ConcurrentModificationException并发运行异常

    例子：

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;

public class Test2 {

	public static void main(String[] args) {

		List c = new ArrayList() ;
		Student s1 = new Student("aloha",22) ;
		Student s2 = new Student("nihao",23) ;
		Student s3 = new Student("hello",24) ;
		Student s4 = new Student("你好",25) ;
	
		List li = c;
		li.add(s1) ;
		li.add(s2) ;
		li.add(s3) ;
		
		ListIterator list = c.listIterator();
		while(list.hasNext()) {
			Student s =(Student)list.next();

			c.add(s4) ;
			System.out.println(s.getName()+"---"+s.getAge());
		}
		
	}

}

class Student {
	 private String name ;
	 private int age ;
	public Student() {
		super();
	}
	public Student(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	
	
	 
}
           

编译时期没有报错，但是运行出错了：

出错原因是： 我们在使用迭代器遍历数组的时候，加了List集合的方法add,这是造成错误的原因。所以我们在使用迭代器遍历元素的时候不能使用集合添加元素。

    解决办法：   1、使用迭代器添加，使用迭代器遍历。                         2、使用集合遍历,使用集合添加元素(普通for循环)。

ArrayLis实现是不同步的（执行效率高）单线程适用，Vector实现是同步的，是线程安全的适用于多线程。

end：

数组查询快，增删慢。 链表查询慢，增删快。List接口中的Linkedlist，由一个链连接了很多节点，节点由数据和地址值组成，在c中叫数据域和指针域，链表查询任何数据都要从头开始找。

List集合有三个子实现类:

   ArrayList

     底层数据结构式数组结构,查询快,增删慢

     从内存角度考虑:线程不安全的,不同步的,执行效率高

     多线程:synchronized :同步的意思  解决线程安全问题

       sychronized(锁对象){ 同步代码

         共享数据; 

       }

     解决线程安全问题,通过同步可以解决,但是效率低了...

   LinkedList

     :底层数据结构式链表结构,查询慢,增删块

     从内存角度考虑:线程不安全,不同步,执行效率高

   Vector:

     这是一个线程安全的类,

     底层数据结构是数组:查询快,增删慢

     线程安全的,同步,执行效率低!