Collection是一个接口，其继承了Java迭代器接口Iterable，是高度抽象来的集合，是单列集合的根接口，它包含了集合的基本操作和属性。

public interface Collection<E> extends Iterable<E>

image.png

------------| Collection 单例集合的根接口
----------------| List 如果是实现了List接口的集合类，具备的特点： 有序，可重复。
-------------------| ArrayList ArrayList 底层是维护了一个Object数组实现的。 特点： 查询速度快，增删慢。
-------------------| LinkedList LinkedList 底层是使用了链表数据结构实现的， 特点： 查询速度慢，增删快。
-------------------| Vector(了解即可) 底层也是维护了一个Object的数组实现的，实现与ArrayList是一样的，但是Vector是线程安全的，操作效率低。
----------------| Set 如果是实现了Set接口的集合类，具备的特点： 无序，不可重复。
-------------------| HashSet 底层是使用了哈希表来支持的，特点： 存取速度快.
-------------------| TreeSet 如果元素具备自然顺序 的特性，那么就按照元素自然顺序的特性进行排序存储。

Collection的使用：

public static void main(String[] args) {
        
    //我们这里将ArrayList集合作为 Collection 的实现类 （如果没有泛型，会报出警告，不影响运行）
    Collection<String> collection = new ArrayList<String>();
    //添加元素
    collection.add("Tom");
    collection.add("Jerry");
    collection.add("Cat and Mouse");
    collection.add("Jack");
    collection.add("Bata");
    System.out.println(collection);
    //获取集合中元素的个数
    int size = collection.size();
    System.out.println(size);
    //删除指定元素
    collection.remove("Jerry");
    System.out.println(collection);
    Collection<String> c = new ArrayList<String>();
    c.add("Tom");
    //将c全部添加到collection中
    collection.addAll(c);
    System.out.println(collection);
    //根据c删除collection中所有c的元素
    collection.removeAll(c);
    System.out.println("检查集合：" + collection);
    //检查是否存在某个元素
    boolean contain = collection.contains("Cat and Mouse");
    System.out.println(contain);
    //检查collection中是否都有c中所有元素
    boolean contains = collection.containsAll(c);
    System.out.println(contains);
    //判断是否为空
    boolean empty = collection.isEmpty();
    System.out.println(empty);
    //仅保留collection中和c相同的元素
    boolean retain = collection.retainAll(c);
        System.out.println(retain);
    //利用增强for循环遍历集合
    for(String str : collection) {
        System.out.println(str);
    }
    //利用迭代器 Iterator进行遍历
    Iterator<String> iterator = collection.iterator();
    while(iterator.hasNext()) {
        Object obj = iterator.next();
        System.out.println(obj);
    }
        //利用toArray()将集合转换成数组
    Object[] obj = collection.toArray();
    //清空集合中的元素
    collection.clear();
    System.out.println(collection);
}

迭代器 Iterator

什么是迭代器？

在Java中，有很多的数据容器，对于这些的操作有很多的共性。Java采用了迭代器来为各种容器提供了公共的操作接口。这样使得对容器的遍历操作与其具体的底层实现相隔离，达到解耦的效果。

在Iterator接口中定义了三个方法：

方法	解释
boolean hasNext()	如果仍有元素可以迭代，则返回true。
E next()	返回迭代的下一个元素
void remove()	从迭代器指向的collection中移除迭代器返回的最后一个元素（可选操作）

迭代器的使用

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class IteratorLean {
    public static void main(String[] args) {    
        List<String> list = new ArrayList<>();
        list.add("abc");
        list.add("def");
        list.add("ghi");        
        Iterator<String> iterator = list.iterator();
        while(iterator.hasNext()) {
            String string = iterator.next();
            System.out.println(string);
        }
        //迭代器使用for循环进行遍历
        for(Iterator<String> it = list.iterator(); it.hasNext();) {
            String string = it.next();
            System.out.println(string);
        }
    }
}

修改迭代器导致的异常

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class IteratorLean {
    public static void main(String[] args) {        
        List<String> list = new ArrayList<>();
        list.add("abc");
        list.add("def");
        list.add("ghi");
        list.add("jkl");        
        Iterator<String> iterator = list.iterator();
        while(iterator.hasNext()) {
            String string = iterator.next();
            if("def".equals(string)) list.remove(string);
                        System.out.println(string);
        }
    }
}

使用上述方法进行集合删除操作，编译器会报错：

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 com.day14.IteratorLean.main(IteratorLean.java:19)
当方法检测到对象的并发修改，但不允许这种修改时，抛出此异常

产生的原因是因为迭代器依赖于集合而存在的，在判断成功后，集合中添加元素或删除元素，而迭代器却不知道，所以报错，这个错叫做修改异常。
其实这个问题的描述是：普通迭代器便利元素的时候，通过集合是不能修改元素的。
解决问题：

• 迭代器迭代元素，迭代器修改元素（元素是跟在刚才迭代的元素后面的）
• 集合遍历元素，集合修改元素（元素是在最后添加的）

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class IteratorLean {
    public static void main(String[] args) {    
        List<String> list = new ArrayList<>();
        list.add("abc");
        list.add("def");
        list.add("ghi");
        list.add("jkl");
        //方式1：迭代器迭代元素，迭代器修改元素
        Iterator<String> iterator = list.iterator();
        while(iterator.hasNext()) {
            String string = iterator.next();
            if("def".equals(string)) iterator.remove();
        }
        //方式2:集合遍历，集合修改元素
        for(int i = 0; i < list.size(); i++) {
            String string = list.get(i);
            if("def".equals(string)) list.remove(string);
        }
    }
}

List接口

一个List是一个元素有序的，可以重复，可以为null的接口集合（有时我们也叫它序列）。

public interface List<E> extends Collection<E> {
    // Query Operations

Java集合框架中最常使用的几种List实现类是 ArrayList，LinkedList和Vector。在各种List中，最好的做法是以ArrayList作为默认选择。当插入，删除频繁时，使用LinkedList，Vector总是比ArrayList慢，所以要尽量避免使用它。
为什么List中的元素有序，可以重复呢？
首先List的数据结构就是一个序列，存储内容时直接在内存中开辟一块连续的空间，然后将空间地址与索引对应。

List的应用

import java.util.ArrayList;
import java.util.List;

public class ListLean {

    public static void main(String[] args) {
        
        //List的使用
        List<String> list = new ArrayList<String>();
        //尾部添加
        list.add("abc");
        list.add("def");
        list.add("ghi");
        //使用List中的添加方法 add(int index, Object obj)
        //添加的时候不能越界
        list.add(1, "jkl");
        System.out.println(list);
        //通过角标获取对应的元素
        Object object = list.get(3);
        System.out.println(object);
        //获取list的长度
        int size = list.size();
        System.out.println(size);
        //通过get方法 进行遍历
        for(int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
        //用指定元素代替序列中的元素并返回原来的元素
        Object oldObj = list.set(2, "mno");
        System.out.println(oldObj);
        //删除元素，并返回删除的元素
        Object rmObj = list.remove(2);
        System.out.println(rmObj);
        //删除指定的元素，并返回删除操作是否成功
        boolean rmBool = list.remove("abc");
        System.out.println(rmBool);
    }
}