首先说一下集合的由来：
java中我们存储比较大量的数据的时候，我们一般用的是数组，但是有一种一下几种情况我们使用数组的话就比较麻烦了：
1.当我们不知道我们的数据到底有多少的时候，（一般我们会数值一个比较大的数组这样就造成了内存的浪费）
2.当我们向一个满的数组继续放入数据的时候，会出现越界问题，如果想继续存入我们必须将这个数组拷贝到一个更大的数组中。因此java中定义了集合，集合最最基本的特点就是：可以自动增加。当然集合还有其他特点。
集合的几个类型：list，set，map主要的就这三个。
集合和数组的区别：
1. 数组可以存储基本数据类型，也可以存储应用数据类型，存储基本数据类型的时候存储的是值，存储引用数据类型的时候存储的是地址值；
集合只能存储引用数据类型，（当存储基本数据类型的时候他会自动装箱比如int--->Integer char --->Character.....）
2. 数组长度不可变，而且存储数据的时候类型在定义的时候已经限制了
集合长度可变，而且因为所有的引用数据类型都有一个父类（object）因此集合可以放入多种引用数据类型。
各种集合继承关系：
这一点要注意，虽然都是集合但是他们的底层是不一样的。
下面开始了解一下List:
List的定义：标准的定义是 List<E> list=new List的子类<>(); （E表示list里面放的类型，就行数组前面的类型一样，注意这里不能写int这些只能写Integer） 当然亦可以不写E List list=new Lis的子类t();那么他会默认E=object
List子类共有的方法：
set(int index, E element)//在指定位置增加元素
boolean add(E e) //增加元素 boolean remove(Object o) //删除元素 void clear() //清空 boolean contains(Object o)//!!很有用的一个函数，可以确定一个元素是否在集合中存在 boolean isEmpty() //判断是否没空 int size() //打到尺寸
当然还有其他方法，可以看API
接下来说说各个集合的特点吧，先来介绍List的各个子类：
ArrayList: 最常用的一个子类，里面的数据可以重复怎么存入就怎么读写。底层的数据结构是数组，查询快，增删慢，线程不安全，效率高。
Vector: 底层也是数组，查询快，增删慢。线程安全，效率低；
LinkedList: 底层数据结构是链表，查询慢，增删快。线程不安全，效率高。这个一般不经常用。只用于大量数据增删的情况。
来解释一下线程不安全的与线程安全的大致意思吧：
假设这里有一种场景，有一个ArrayList(),然后有两个并行的线程同时对这个List进行操作，那么就会出现一种情况，线程A删了一个元素，这时候线程B想知道这个List大小的时候，就会出现问题，或许线程B中的List还没有更新，这样就导致了错误，这就是线程不安全，而Vector理论上是线程安全的。（实际上并不是的，还是会出现并发异常的问题.....怎么体现Vector并不是很安全参见https://blog.csdn.net/zlp1992/article/details/50433778）
然后介绍一些LinkedList中的一些特有方法。
* public void addFirst(E e)及addLast(E e) //在开头或者结尾增加元素 * public E getFirst()及getLast() //得到开头、结尾 * public E removeFirst()及public E removeLast() //移除开头或者结尾
因为LinkedList的底层是链表，因此很容易定位到开头和结尾
集合的第二大类：Set
set相比于list的不同：
1.list是有序的，set是无序的。即list会根据你的输入打印，打算set不会。
2.list可以放入重复的元素，但是set不能。----这也是他无序的原因，他将每个元素赋予了一个哈希值这样就保证了元素的不重复。
（但是有一点要注意，他不能比较两个类是否相同）
比如：我们又一个类 Person( name,age) 要放入set中
HashSet<Person> hs = new HashSet<>();
hs.add(new Person("张三", 23));
hs.add(new Person("张三", 23));
这样两个Person都会放入，尽管我们认为这两个类是一样的，但是hashCode函数并不会认为他们是同一个对象，因此还是都会存入set，这时候我们必须重写hashCode函数和equal()函数：
为了加深理解我们用代码解释一下：
public class Person {
private String name;
private int age;
public Person() {
super();
}
public Person(String name, int age) {
super();
this.name = name;
this.age = age;
}
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;
}
@Override
public String toString() {
return "Person [name=" + name + ", age=" + age + "]";
}
@Override
public int hashCode() {
System.out.println("asdasd");
final int prime = 31;
int result = 1;
result = prime * result + age;
result = prime * result + ((name == null) ? 0 : name.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
System.out.println("2112");
if (this == obj) //调用的对象和传入的对象是同一个对象
return true; //直接返回true
if (obj == null) //传入的对象为null
return false; //返回false
if (getClass() != obj.getClass()) //判断两个对象对应的字节码文件是否是同一个字节码
return false; //如果不是直接返回false
Person other = (Person) obj; //向下转型
if (age != other.age) //调用对象的年龄不等于传入对象的年龄
return false; //返回false
if (name == null) { //调用对象的姓名为null
if (other.name != null) //传入对象的姓名不为null
return false; //返回false
} else if (!name.equals(other.name)) //调用对象的姓名不等于传入对象的姓名
return false; //返回false
return true; //返回true
}
}
这里有一个Person类
public class Demo1_HashSet {
/**
* @param args
* Set集合,无索引,不可以重复,无序(存取不一致)
*/
public static void main(String[] args) {
//demo1();
HashSet<Person> hs = new HashSet<>();
hs.add(new Person("张三", 23));
hs.add(new Person("张三", 23));
hs.add(new Person("李四", 24));
hs.add(new Person("李四", 24));
hs.add(new Person("李四", 24));
hs.add(new Person("李四", 24));
//System.out.println(hs.size());
System.out.println(hs);
} }
重写hashCode函数是防止出现重名的对象；重写equals函数可以防止真的对象的重复，注释已经很详细了我就不在解释了。
然后是
LinkedHashSet:
因为set是无序的为了解决这个缺点我们使用了linkeHashSet，大家都知道链表是有序的，所以这个集合是有序切不能重复的。这个特点可以用来去除重复，比如“aaabbssdd”最后存进去的可以变成absd;
然后是最后一个TreeSet;
他的底层也有哈希函数，但是多了一个树！！那么他就有了一个新的特性，就是会自动排序，底层会很久哈希值对所有的元素排序。
当然：如果想认为的设置这个的顺序，需要重写compareTo函数，为什么会出现这样的情况呢？还是由于之前的问题，对于我们自定义的对象，他不会排序。
在比较的时候他会调用compareTo函数，这个函数返回值为 -1 0 1 ：也就是小于等于大于。当返回1的时候就放在左节点，返回-1的时候就放在右节点；因此才会排序；