集合

集合就是将许多元素组合成一个单一单元的容器对象，可以进行存储，检索，操作，传输，聚合数据。
集合框架，是用于表示和操作集合的体系结构，集合框架应包含
接口(Interfaces)：表示集合的抽象数据类型。使用接口，允许集合独立于其表示的细节进行操作
实现(Implementations)：集合接口的具体实现，包含可重用的数据结构
算法(Algorithms)：对集合执行搜索/排序等操作，是可重用的功能
即，Java提供了一套包含，多种集合类型，多种数据结构实现，以及操作处理算法的集合框架，供开发人员直接使用

java.lang.Iterable<T>
iterable接口，实现了此接口的类的对象，指出foreach循环。

java.util.Collection<E>
一个集合，表示一组被称为元素的对象
Collection接口，用于描述，最具通用性的集合，因此也包含了最具通用性的集合操作方法
Collections接口继承Iterable接口，就是说所有的集合类型都支持foreach循环语句

在Collections中主要掌握List和Set的类型的集合。
在Collections中有几个基本的方法，继承Collections接口的所有的接口都应有的方法：

boolean add(E e)，向集合添加元素。如调用更改了集合返回true，下同
boolean  addAll(Collection<? extends E> c)，向集合添加一个集合
boolean remove(Object o)，从集合移除中指定元素
boolean  removeAll(Collection<? extends E> c)，从集合移除包含指定集合
void clear()，移除集合全部元素
boolean contains(Object o)，判断集合是否包含指定元素
boolean  containsAll(Collection<? extends E> c)，判断是否包含包含指定集合
boolean isEmpty()，判断集合是否包含元素
int size() ，集合长度
T[] toArray(T[] a)，将集合转为指定类型的数组
Iterator<E> iterator()，获取迭代器
……

List

java.util.List<E>
List集合。有序的，允许包含重复元素的集合。除从Collection继承的方法外，提供基于位置索引的操作方法
void add(int index, E element)，将指定位置元素后移，添加
E set(int index, E element)，替换
E get(int index)，获取
E remove(int index)，移除
……

List集合接口基本实现类，即不同的数据结构
java.util.ArrayList<E>类，基于对象数组数据结构的实现
java.util.LinkedList<E>类，基于双向链表数据结构的实现
具体区别/使用场景/性能，后期讨论

List集合的声明和创建

List<User> user = new Array<>();
声明List集合类型变量
<>括号中声明集合中元素的类型
必须为引用类型  整型是要用Integer引用数据类型
	因为时引用数据类型，所以和其他引用数据类型一样，引用赋值的时候赋的值时地址的值。
基于对象数组存储结构ArrayList实现类
创建集合对象

// 添加不同的类型的元素时，上转型直接添加，但是下转型需要强制转换。
package com.company;
import java.util.*;
class Main{
    public static void main(String[] args) {
        List<User> suers = new ArrayList<>();
        User u1 = new User(1);
        User u2 = new Student(2);
        Student u3 = new Student(3);
        
        suers.add(u1);
        suers.add(u2);
        suers.add(u3);
        
        List<Student> students = new ArrayList<>();
        students.add(u1); // 编译错误
        students.add((Student) u1);
        students.add(u2); // 编译错误
        students.add((Student)u2);
        students.add(u3);
    }

}
class User{
    int i;
    User (int i) {
        this.i = i;
    }
}
class Student extends User {
    Student(int i) {
        super(i);
    }
}

class Main{
    public static void main(String[] args) {
        List<User> users = new ArrayList<>();
        User u1 = new User(1);
        User u2 = new Student(2);
        Student u3 = new Student(3);

        users.add(u1);
        users.add(u2);
        users.add(u3);

        for (User u : users) {
            System.out.println(u.i);
        } // 实现Collections接口的类的基本的方法，foreash循环
        for (int i = 0; i < users.size(); i ++ )  {
        	System.out.println(users.get(i).i); // for循环遍历的方式，不建议使用。
        }
        
    } 

}
class User{
    int i;
    User (int i) {
        this.i = i;
    }
}

List集合中允许包含重复的元素。

class Main{
    public static void main(String[] args) {
        List<User> users = new ArrayList<>();
        User u1 = new User(1);
        User u2 = new Student(2);
        Student u3 = new Student(3);

        users.add(u1);
        users.add(u2);
        users.add(u3);
        users.add(u1);
        for (User u : users) {
            System.out.println(u.i);
        }
    }

}
class User{
    int i;
    User (int i) {
        this.i = i;
    }
}
/*
1
2
3
1
*/

当我们试图用for循环遍历删去一些符合某些要求的元素的时候，有可能会出错。

class Main{
    public static void main(String[] args) {
        List<User> users = new ArrayList<>();
        User u1 = new User(1);
        User u2 = new Student(2);
        Student u3 = new Student(3);

        users.add(u1);
        users.add(u1);
        users.add(u2);
        users.add(u3);
        for (User u : users) {
            System.out.println(u.i);
        }
        System.out.println();
        System.out.println();
        for(int i = 0; i < users.size(); i ++) {
            if(users.get(i).i == 1) users.remove(i);
        }
        for (User u : users) {
            System.out.println(u.i);
        }
    }

}
class User{
    int i;
    User (int i) {
        this.i = i;
    }
}
/*
1
1
2
3


1
2
3
*/

为什么会出现这种情况，为什么会有一个1没有删掉，因为在remove之后size会自动变小了，一边删除一遍出现索引的变化，这里也有可能会报错，所以，正常情况下不要在for循环里出现试图改变集合的大小。

class Main{
    public static void main(String[] args) {
        List<User> users = new ArrayList<>();
        User u1 = new User(1);
        User u2 = new Student(2);
        Student u3 = new Student(3);

        users.add(u1);
        users.add(u2);
        users.add(u3);
        for (User u : users) {
            System.out.println(u.i);
        }

        User[] us = users.toArray(new User[0]);
        // 定义大小为0的数组即可，内部的方法会将需要的长度进行自动的调整。
        for (User u : us) {
            System.out.println(u.i);
        }
        List<User> uu = Array.aList(us);
        // 实际上仅仅是转换了类型，在底层仍然是数组，所以这种情况下无法执行任何修改长度的方法没否则抛出异常。
        for (User u : uu) {
            System.out.println(u.i);
        }
    }
}

ArrayList的构造函数

ArrayList()，创建空List集合。默认创建0个元素的对象数组
ArrayList(int initialCapacity)，基于指定长度创建List集合。长度仅初始化集合时使用，后期添加/移除自动容量
ArrayList(Collection<? extends E> c)，基于指定集合创建List集合

LinkedList集合