第一：由数组的缺点来引入集合：
1.数组只能保存相同的数据类型的数据
2.数组的长度是不可变的
第二：集合的引入
1.长度可变的数组。集合的容量随着元素的个数自适应变化
2.可以保存任意类型的元素。
第三：Collection根接口和List子接口
1.Collection是根接口（是个接口）
2.List是Collection的子接口（有序的集合也称序列）：允许重复元素的出现。放入集合的数据和取出集合的数据一致，list集合有索引存在（这点跟数组一样有下标）
3.set是Collection的子接口，不能出现重复元素的集合，最多包含一个null（因为两个null就重复了）。也就是说不能包含obj.equals（obj2）==true
第四：List接口中实现类
（一）：Vector实现类:
1.用索引（下标）访问元素，
2.是一个可以自动增长的数组（其实低层就是个数组），
3.数组在定义的时候就要定义好长度，因此长度不可变。而vector如果不定义大小的话就默认开辟一个大小为10的空间（其实就是十个开间的数组，如果不够用的话就每次增长10个），用于保存十个元素。
4，由于底层是个数组，因此对于Vector来说也是用下标获取元素。 在Vector中的get（获取）方法，它调用另一个方法，另一个方法就是数组获取元素的方法。
5.Vector没有重写object的toString方法和equals方法，在 他还是打印和比较的是地址，如果想让他打印和比较的是内容的话，都要重写object的这两个方法 。
6.在多线程情况下是安全的，安全性保证了，就导致速度慢了。
7.数组的length（长度）方法是返回数组的长度，长度在new的时候已经给定了（也就是开辟的空间，例如开辟10个空间，可我就用了3个，返回的也是10），集合中的size（尺寸）返回的是元素数（例如往里面写三个元素，就返回三个，这也就是长度可变的意思）
8.vector的程序：
public static void main(String[] args) {
// TODO Auto-generated method stub
//1 创建集合Vector类的对象，该对象封装10个小空间
Vector vector = new Vector();
boolean flag1 =vector.isEmpty();
System.out.println("flag1="+flag1);
//2 容器中保存数据
vector.add("hello");
vector.add(100);
vector.add(123.23);
int size = vector.size();/**集合的长度是10（默认的），size表示的是元素的个数，因为这里输出的是3
数组中规定length方法返回的数组的长度，而不是数组中元素的个数。**/
vector.add("hello");vector.add("hello");vector.add("hello");vector.add("hello");
vector.add("hello");vector.add("hello");vector.add("hello");vector.add("hello");
int size2= vector.size();
System.out.println("size2="+size2);//这里输出的是12，因为默认长度是10不够用了，又自动增长了10
//3 获取容器中的数据
for(int x=0;x<vector.size();x++)
{
//获取集合中的元素
Object obj = vector.get(x);
System.out.println(obj);
}
//判断集合中有没有指定的元素
boolean flag = vector.contains("hello wugui");
System.out.println("flag="+flag);
//vector.equals(o) 比较集合中对应位置上的元素是否相等
//返回指定元素在集合第一次出现的位置
int index=vector.indexOf("hello");
System.out.println("index="+index);
//删除指定的元素
vector.remove(3);
for(int x=0;x<vector.size();x++)
{
//获取集合中的元素
Object obj = vector.get(x);
System.out.println(obj);
}
//将vector转化为数组
Object [] arr=vector.toArray();
System.out.println(vector);
}
（二）：ArrayList实现类
ArrayList：（此类大致上与Vector一样）:
1.不一样的地方是此类是线程不同步的，不安全（一个一个来）。
2，ArrayList没有重写object的toString方法和equals方法，在contains和remove方法中(这两个方法都需要比较两个元素内容) 他还是打印和比较的是地址，如果想让他打印和比较的是内容的话，都要重写object的这两个方法。
3.程序：
public class Student
{
private String sno;
private String name;
private int age;
public String getSno() {
return sno;
}
public void setSno(String sno) {
this.sno = sno;
}
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;
}
public Student(String sno, String name, int age) {
super();
this.sno = sno;
this.name = name;
this.age = age;
}
public Student() {
super();
// TODO Auto-generated constructor stub
}
@Override
public String toString() {
return "Student [sno=" + sno + ", name=" + name + ", age=" + age + "]";
}
public boolean equals(Object obj)
{
if(this==obj)
return true;
if(!(obj instanceof Student))
return false;
Student stu = (Student)obj;
if(this.sno.equals(stu.sno)&&
this.name.equals(stu.name)&&
this.age==stu.age)
{
return true;
}
return false;
}
}
public static void main(String[] args) {
Student stu1 = new Student("111","小强",26);
Student stu2 = new Student("112","旺财",24);
Student stu3 = new Student("113","小白",20);
Student stu4 = new Student("114","小习",24);
//1 创建集合对象
ArrayList stuList = new ArrayList();
//2 保存
stuList.add(stu1);
stuList.add(stu2);
stuList.add(stu3);
stuList.add(stu4);
//3 遍历输出
for(int x=0;x<stuList.size();x++)
{
Object obj = stuList.get(x);
System.out.println(obj);
}
Student stu5 = new Student("114","小习",24);
boolean flag = stuList.contains(stu5);//注意重写equals方法
System.out.println("flag="+flag);
Student stu6 = new Student("113","小白",20);
stuList.remove(stu6);
//3 遍历输出
for(int x=0;x<stuList.size();x++)
{
Object obj = stuList.get(x);
System.out.println(obj);
}
System.out.println(stuList.toString());
}
}
（三）LinkedList实现类：（他的底层不是数组了，而是链表（单项链表））
1.链表里面的每个小内存空间不一定是连续的（上面两个实现类的每个空间都是连续的）。链表中每个元素都包含两个内容（一个是该空间的内容， 另一个是下一个空间的地址，这就保证了空间不用连续）。2.LinkedList的方法比较多，也就是说他继承了List以外，自己特有的方法比较多。也就是针对开头（first）和结尾（last）的。
3.栈结构：先进后出，体现的就是LinkerList的开头和结尾的应用（这里也体现出他特有的方法）。多出来的方法是addFirst,addLast,getFirst,getLast,removfFirst,removeLast这六个
第五：总结：
1.vector:这个内部类里面有一个属性是“obejct类型的数组”，有一个属性是“元素的个数",还有一个是“增长量”。这跟StringBuffer很相似
2.vector是当容量不够用的时候就增加10，每次不够用都增加10个空间，vector可以保存任意类型的元素，因为返回值是object类型的数据
3.集合的放进去拿出来是最常用的操作，放进去就是add方法，拿出来就是对集合的遍历，用到size方法和get方法
4.vector类的contains(包含)这个方法首先调用了vector类的indexof方法（在集合中找指定元素对应的索引），而vector中的indexof方法又调用了vector的equals方法，而vector的equals没有重写object的equals，因此比较的是地址，为了让他比较内容，集合对象重写object类的equals方法
5.remove删除的方法，在删除的时候要先找到才能删除，因此也用到了equals方法
6.set也是Collection的子接口：不能出现重复元素的集合，最多包含一个null（因为两个null就重复了）。也就是说不能包含obj.equals（obj2）==true