Collection<E> c = new ArrayList<>();//因为Collection是一个接口，所以采用多态的方式创建对象

2.常用操作

boolean add(E e)//将指定的元素追加到此列表的末尾

boolean remove(Object o)//从该集合中删除指定元素

void clear()//清空集合所有元素

boolean contains(Object o)//如果此集合包含指定的元素，则返回true。

boolean isEmpty()//如果此集合没有任何元素，则返回true。

int size()//返回此列表中的元素个数。

3.遍历

Iterator<E> it = 集合对象.iterator();

while(it.hasNext()){
    E e = it.next();
    System.out.println(e);
}

三、List

public class ArrayList<E> implements List<E>{
   
    protected transient int modCount = 0;//实际修改集合次数
    
    public boolean add(E e) {
        modCount++;//每调用一次add添加元素，实际修改集合次数+1
        add(e, elementData, size);
        return true;
    }
    
    private class Itr implements Iterator<E> {
     
        int expectedModCount = modCount;//预期修改集合次数

        public boolean hasNext() {
            return cursor != size;
        }

        public E next() {
            checkForComodification();
            int i = cursor;
            if (i >= size)
                throw new NoSuchElementException();
            Object[] elementData = ArrayList.this.elementData;
            if (i >= elementData.length)
                throw new ConcurrentModificationException();
            cursor = i + 1;
            return (E) elementData[lastRet = i];
        }

        final void checkForComodification() {
            //如果实际修改集合次数不等于预期修改集合次数，就抛出异常
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
        }
    }
}

5.ListIterator（列表迭代器）

public void add(E e) {
    checkForComodification();

    try {
        int i = cursor;
        ArrayList.this.add(i, e);
        cursor = i + 1;
        lastRet = -1;
        expectedModCount = modCount;//保证实际修改次数等于期望修改次数
    } catch (IndexOutOfBoundsException ex) {
        throw new ConcurrentModificationException();
    }
        }

6.三种遍历方式

while(it.hasNext()){
    E e = it.next();
    System.out.println(e);
}

for(元素数据类型 变量名：数组名/Collecton集合){
    ...;
}

int[] arr = {1, 2, 3}; for (int i : arr) {
    System.out.println(i); }

String[] strArr = {"hello", "world", "java"};
for (String s : strArr) {
    System.out.println(s);
}

List<String> l = new ArrayList<>();
l.add("Hohai");
l.add("University");
for (String str : l) {
    System.out.println(str);
}

四、List两个常用子类——ArrayList和LinkedList

（一）ArrayList

1.特点

2.常用操作

（二）LinkedList

五、Set

2.特点

public class Generic<T>{
    private T t;
    
    public T getT(){
        return t;
    }
    
    public void setT(T t){
        this.t = t;
    }
}

GenericClass<String> gc = new GenericClass<>();
gc.setT("hello");
System.out.println(gc.getT());//"hello"

GenericClass<Integer> gc2 = new GenericClass<>();
gc2.setT(100);
System.out.println(gc2.getT());//100

GenericClass<Boolean> gc3 = new GenericClass<>();
gc3.setT(true);
System.out.println(gc3.getT());//true

List<?> l1=new ArrayList<Object>();
List<?> l2=new ArrayList<Number>();
List<?> l3=new ArrayList<Integer>();

//List<? extends Number> l4=new ArrayList<Object>();//报错，Object超出了类型通配符上限 List<? extends Number> l5=new ArrayList<Number>(); List<? extends Number> l6=new ArrayList<Integer>();

List<? super Number> l7=new ArrayList<Object>();
List<? super Number> l8=new ArrayList<Number>();
//List<? super Number> l9=new ArrayList<Integer>();//报错，Integer超出了类型通配符的下限

public int sum(int b，int... a)
//public int sum(int... a，int b)//报错

public static <T> List<T> asList(T... a)//返回由指定数组支持的固定大小的List列表。

static <E> List<E> of(E... elements)//返回包含任意数量元素的不可变List列表。

static <E> Set<E> of(E... elements)//返回包含任意数量元素的不可变Set集合。

//获取所有键
Set<String> keySet = m.keySet();
//获取每一个键
for (String key : keySet) {
    //根据键找值
    String value = m.get(key);
    //输出键值对
    System.out.println(key + "--" + value);

//获取所有的键值对
Set<Map.Entry<String, String>> kv = m.entrySet();
//获取每一对键值对
for (Map.Entry<String, String> me : kv) {
    //分别获取键和值并输出
    String key = me.getKey();
    String value = me.getValue();
    System.out.println(key + "-" + value);
}

5.Properties