集合

集合

集合与数组的区别

1. 长度区别:
   数组的长度是固定的而集合的长度是可变的

2. 存储数据类型的区别:
   数组可以存储基本数据类型 , 也可以存储引用数据类型; 而集合只能存储引用数据类型，集合只能添加引用类型：对象、字符串、基本数据类型的引用类型

3. 内容区别:
   数组只能存储同种数据类型的元素 ,集合可以存储不同类型的元素

Collection集合的继承关系

Java提出集合的概念，集合也是一种容器，集合不是某一个类，而是一个集合框架，有很多种集合构成；下面是Collection集合的继承体系：

Collection集合

​ Collection 是层次结构中的根接口，Collection 表示一组对象，这些对象也称为 collection 的元素。该集合在java.util包下。

Collection集合里的添加功能

添加功能：
	1、boolean add(Object obj)：添加一个元素
	2、boolean addAll(Collection c)：添加一个集合的元素 (给一个集合添加进另一个集合中的所有元素) 
案例1：    
	 public static void main(String[] args) {
		//父接口 接收子类的调用
    	//由于Collection是一个接口，所以需要调用它的子类对象。当前以ArrayList为例
        Collection collection=new ArrayList();
        //集合只能添加引用类型：对象、字符串、基本数据类型的引用类型
        boolean b = collection.add("aa");//返回true
        //此处的100为Integer类型，自动装箱：对于基本数据类型的操作 Integer.valueOf(100)
        collection.add(100);
        System.out.println(collection);//[aa,100]
	}
	
结果：
	[aa, 100]

	Process finished with exit code 0
案例2：
	 public static void main(String[] args) {
		Collection collection = new ArrayList();
        collection.add(100);
        collection.add(200);

        Collection collection2 = new ArrayList();
        collection2.add(300);
        collection2.add(400);
        //把两个集合中的元素，归并到一个集合里面去 返回值是有没有添加成功
        //集合合并，把collection2的元素放到collection中,collection2元素不变
        collection.addAll(collection2);
        System.out.println(collection);//[100, 200, 300, 400]
        System.out.println(collection2);//[300, 400]
     }
     
结果：
	[100, 200, 300, 400]
	[300, 400]

	Process finished with exit code 0

Collection集合的删除功能

删除功能：
    1、void clear()：移除所有元素
    2、boolean remove(Object o)：移除一个元素
    3、boolean removeAll(Collection c)：移除一个集合的元素(移除一个以上返回的就是true) 删除的元素是两个集合的交集元素 ，如果没有交集元素，则删除失败，返回false；
案例：
	 public static void main(String[] args) {
        //清空集合中的所有元素
        //collection.clear();
        Collection collection = new ArrayList();
        collection.add(100);
        collection.add(300);

        Collection collection2 = new ArrayList();
        collection2.add(300);
        collection2.add(400);
        //删除集合中的某个元素
        collection.remove(100);
        System.out.println(collection);//[300]
        //  boolean removeAll (Collection c):移除一个集合的元素(移除一个以上返回的就是true) 移除的元素是两个集合的交集元素,移除的是调用此方法的集合，被参考的集合内的元素不会移除。
        System.out.println(collection.removeAll(collection2));//true
        System.out.println(collection);//[100]
        System.out.println(collection2);//[300,400]
	}
结果：	
	[300]
	[100]
	[300,400]
	
    Process finished with exit code 0

Collection集合的判断功能

判断功能：
    1、boolean contains(Object o)：判断集合中是否包含指定的元素
    2、boolean containsAll(Collection c)：判断集合中是否包含指定的集合元素(这个集合包含另一个集合中所有的元素才算包含才返回true)【比如：1，2，3 containsAll 12=true 1,2,3 containsAll 2,3,4=false】
    3、boolean isEmpty()：判断集合是否为空
    
案例：
    public static void main(String[] args) {
        Collection collection1 = new ArrayList();
                collection.add(100);
                collection.add(300);
        System.out.println(collection1.contains(111));//false
        Collection collection2 = new ArrayList();
        collection.add(100);
        collection.add(200);
        collection.add(500);
        Collection collection3 = new ArrayList();
        collection2.add(100);
        collection2.add(200);
        System.out.println(collection2.containsAll(collection3));//true
        //判断集合是否为空
        System.out.println(collection.isEmpty());
	}
	
结果：
	false
	true
	false
	
    Process finished with exit code 0

Collection集合的获取功能和长度属性

获取功能：
    1、Iterator iterator()(重点)，迭代器可以认为是指针；
长度功能：
    1、int size():元素的个数
    
案例：    
	  public static void main(String[] args) throws ParseException {
        Collection collection = new ArrayList();
        collection.add(100);
        collection.add(200);
        collection.add(300);
        collection.add(400);
        collection.add(500);
        //获取集合中元素的个数。
        System.out.println(collection.size());
        //遍历集合中的元素  iterator对 collection 进行迭代的迭代器。
        //父接口 迭代器接收子类调用重写的接口方法
        Iterator iterator = collection.iterator();
        //把迭代器 Itr 设计为内部类，直接访问外部类的成员（数组中存储）进行迭代
        System.out.println(iterator); //java.util.ArrayList$Itr@1540e19d
      	/*hasNext ()
        如果仍有元素可以迭代，则返回 true。
        next ()
        返回迭代的下一个元素*/
        while (iterator.hasNext()) {
            //迭代的元素使用Object对象接收，因为不知道引用类型的具体类型。
            Object obj = iterator.next();
            System.out.println(obj);
            /*
            如果需要调用子类特有方法，需要向下转型
            Student student = (Student) iterator.next();
            */
        	}
    	}
	}
	
结果：
	5
	java.util.ArrayList$Itr@1540e19d
    100
    200
    300
    400
    500

    Process finished with exit code 0

迭代器

关于迭代器：
	迭代器是一种设计模式，它可以遍历并选择序列中的对象，而开发人员不需要了解该序列的底层结构（迭代器把访问逻辑从不同类型的集合类里面抽取出来，从而避免向外部暴露集合的内部结构）。迭代器通常被认为是“轻量级”对象，因为创建它的代价小。

为什么要使用迭代器？
	若不使用迭代器，访问代码和集合本身是紧密耦合的，因此无法将访问逻辑从集合类和客户端代码中分离出来。而由于不同的集合会对应不同的遍历方法，所以客户端代码无法复用。而对Iterator来说，它总是用同一种逻辑来遍历集合，使得客户端自身不需要维护集合的内部结构，所有的内部状态都由Iterator来维护。
	
迭代器的实现原理
	下面基于ArrayList的Iterator的实现分析Iterator的原理（基于JDK1.8）:在ArrayList类中有一个方法 iterator() ，此方法将返回一个iterator的实现，这里可以看出实现类交叫Itr，通过它的源码可知，这是ArrayList的一个内部类。为什么要将迭代器设置为内部类，因为内部类（无论是成员内部类还是局部内部类）可以访问外部类里面的所有成员，包括私有的成员。这样就可以遍历集合中的元素了。
	 public Iterator<E> iterator() {
        return new Itr();
    }

    /**
     * An optimized version of AbstractList.Itr
     */
    private class Itr implements Iterator<E> {
        int cursor;       // index of next element to return
        int lastRet = -1; // index of last element returned; -1 if no such
        int expectedModCount = modCount;

        Itr() {}

Collection交集功能

交集功能：
	【例如：A集合对B集合取交集，获取到的交集元素在A集合中。返回的布尔值表示的是A集合是否发生变化】
    1、boolean retainAll(Collection c)：获取两个集合的交集元素(交集：两个集合都有的元素)
把集合转换为数组：
    2、Object[] toArray()	
    
案例：
	public static void main(String[] args) throws ParseException {
        Collection collection = new ArrayList();
        collection.add(100);
        collection.add(200);
        collection.add(500);

        Collection collection2 = new ArrayList();
        collection2.add(100);
        collection2.add(200);
        collection2.add(300);
        collection2.add(400);
        //获取两个集合的交集元素，并将交集元素赋给collection的元素 ，因此collection发生变化
        System.out.println(collection.retainAll(collection2));//true
        System.out.println(collection);//[100, 200]
        System.out.println(collection2);//[100, 200, 300, 400]
        //集合转换为数组：使用object[] 接收,不确定集合中元素的具体引用类型
        Object[] objects=collection.toArray();
        System.out.println(Arrays.toString(objects));//[100, 200]
    }

结果：
	true
	[100, 200]
	[100, 200, 300, 400]
	[100, 200]

	Process finished with exit code 0
	

List子接口

元素序列有序（存取顺序一致），并且每一个元素都有索引，集合中允许元素重复。

List集合的特有功能概述：
    void add(int index,E element):在指定索引处添加元素
    remove(int index):移除指定索引处的元素 返回的是移除的元素
    get(int index):获取指定索引处的元素
    set(int index,E element):更改指定索引处的元素 返回的而是被替换的元素
    int indexOf(Object o)：返回此列表中第一次出现的指定元素的索引；如果此列表不包含该元素，则返回 -1。
    int lastIndexOf(Object o)： 返回此列表中最后出现的指定元素的索引；如果列表不包含此元素，则返回 -1。  
    
案例：    
	 public static void main(String[] args) throws ParseException {
        //在指定索引出添加元素
        List list=new ArrayList();
        list.add(100);
        list.add(100);
        list.add(1,"aaa");
        list.add(0,"aaa");
        System.out.println(list);//[aaa, 100, aaa, 100]

        //get(list.size() - 1); 通过索引来获取集合中的元素
        Object obj = list.get(list.size() - 1);
        System.out.println(obj);//100
        System.out.println(list);//[aaa, 100, aaa, 100]

        //删除元素 传入索引值remove(int index)
        //如果要删除指定元素，但是Integer类型与索引值无法区分，可以把元素包装一下。
        list.remove(Integer.valueOf(100));
        System.out.println(list);//[aaa, aaa, 100]


        //替换集合中的元素 返回的是被替换的那个旧元素 set(int index,E element)
        Object oldelement = list.set(list.size() - 1,9527);
        System.out.println(list);//[aaa, aaa, 9527]
        System.out.println(oldelement);//100

        //根据元素查找索引值  int indexOf(Object o)
        int i = list.indexOf(10);
        System.out.println(i);//-1

    }
    
结果：
    [aaa, 100, aaa, 100]
    100
    [aaa, 100, aaa, 100]
    [aaa, aaa, 100]
    [aaa, aaa, 9527]
    100
    -1

    Process finished with exit code 0

	

遍历List集合的几种方式

案例：
	public static void main(String[] args) throws ParseException {
        List list= new ArrayList();
        list.add("aaa");
        list.add(200);
        list.add(300);
        list.add(400);

        //方法一： for循环（最常用）
        for (int i = 0; i < list.size(); i++) {
            System.out.print(list.get(i)+" ");
        }
        System.out.println();
        //方法二： 使用父接口迭代器
        Iterator iterator=list.iterator();
        while (iterator.hasNext()){
            Object obj = iterator.next();
            System.out.print(obj+" ");
        }
        System.out.println();
        //方法三： 使用List自带的迭代器listIterator
        ListIterator listIterator=list.listIterator();
        while (listIterator.hasNext()){
            System.out.print(listIterator.next()+" " );
        }
        //方法四：反向遍历
        //对于同一个迭代器进行反向迭代时，先要正向迭代。
        //使得指针指向集合中的最后一个元素的后面null处，然后再反向迭代，就可以遍历到之前的元素。
        System.out.println();
        while (listIterator.hasPrevious()) {
            Object o = listIterator.previous();
            System.out.print(o+" ");
        }
    }
    
结果：
        aaa 200 300 400 
        aaa 200 300 400 
        aaa 200 300 400 
        400 300 200 aaa 
        
        Process finished with exit code 0

并发修改异常

需求：
	我有一个集合，请问，我想判断里面有没有"world"这个元素，如果有，我就添加一个"java"元素，请写代码实现。
现象：
	在使用迭代器遍历后通过list.add()方法添加元素就会出现并发修改异常
    public static void main(String[] args) {
      List list=  new ArrayList();
      list.add("aaa");
      list.add("bbb");
      list.add("world");
    ListIterator listIterator = list.listIterator();
    while (listIterator.hasNext()) {
        Object o = listIterator.next();
        if (o.equals("world")){
            //ConcurrentModificationException并发修改异常
            list.add("java");
        }
    }
        System.out.println(list);
    }
报错：
	Exception in thread "main" java.util.ConcurrentModificationException
	at java.util.ArrayList$Itr.checkForComodification(ArrayList.java:909)
	at java.util.ArrayList$Itr.next(ArrayList.java:859)
	at blog.BlogMath.main(BlogMath.java:16)
	
    Process finished with exit code 1
    
原因：当我们使用迭代器遍历集合的时候，我们的迭代器已经事先知道集合元素的个数，突然在迭代途中增加或者删除元素，就会打乱原来集合的顺序，迭代器也就无所适从，就会抛出并发修改异常；

解决方式有两种：
1、方式一：
	迭代器迭代元素，迭代器修改元素(ListIterator的特有功能add)
将`list.add("java“);`修改为`listIterator.add("java");`
	集合遍历元素，集合修改元素
案例：
	 public static void main(String[] args) {
      List list=  new ArrayList();
      list.add("aaa");
      list.add("bbb");
      list.add("world");
   		if (list.contains("world")){list.add("java");}
        System.out.println(list);
   	 	}
    }

执行结果：
	[aaa, bbb, world, java]
	
	 Process finished with exit code 0
           
2、方式二：
	使用for循环遍历，就可以使用集合自己的增加和删除方式 

	public static void main(String[] args) {
        List list=  new ArrayList();
        list.add("aaa");
        list.add("bbb");
        list.add("world");
        for (int i = 0; i < list.size(); i++) {
            if (list.get(i).equals("world"))list.add("java");
        }
        System.out.println(list);
    }
    
执行结果：

	[aaa, bbb, world, java]
	
	Process finished with exit code 0

List的三个子类的特点

List：
	数组元素有序，允许元素重复，选择哪种集合，根据自己的需求而定
	要安全还是要效率，是查找多还是增删多
List的三个子类的特点:
ArrayList:
    底层数据结构是数组，查询快，增删慢。
    线程不安全，效率高。

Vector:
    底层数据结构是数组，查询快，增删慢。
    线程安全，效率低。
    Vector相对ArrayList查询慢(线程安全的)
    Vector相对LinkedList增删慢(数组结构)

LinkedList:
    底层数据结构是链表，查询慢，增删快。
    线程不安全，效率高。

Vector和ArrayList的区别:
    Vector是线程安全的,效率低
    ArrayList是线程不安全的,效率高
    共同点:都是数组实现的

ArrayList和LinkedList的区别:
    ArrayList底层是数组结果,查询和修改快
    LinkedList底层是链表结构的,增和删比较快,查询和修改比较慢
    共同点:都是线程不安全的

List有三个儿子，到底使用谁呢?

    查询多用ArrayList
    增删多用LinkedList
    如果都多ArrayList