java中的集合(新手进)
一、java集合
1.为什么要有java集合？有数组能存多个不是足够了吗?
答:
面向对象语言中，需要经常一起操作多个对象，虽然数组也可以存储对象，但数组长度是固定的，不可变。而集合的长度是可变的。而且数组只能存储一类对象，而集合可以将多种对象存储到一起。
2.集合的特点？
答：
1.只能存储对象。(如果存储int i = 1;存进去会自动装箱成Integer类)
2.集合长度是可变的。(在初始化时不需要设定长度)
3.可以存储多种类型的对象
二、以下是针对上图，对每一个集合做简单的赘述。
首先要知道，java集合总共有两种，单列集合和双列集合。单列集合(collection)存储对象，双列集合(Map)存储键值对。
附上简单版集合框架图
1.collection接口:
1.1.特点:单列集合的根接口，
1.2.所有collection的子孙类，都能使用collection的方法。
Collection s = new ArrayList();//(接口只能实例化它的子类)
Object o=new Object();
s.add(o);//添加一个元素，添加成功返回true，失败返回false
s.remove(o);//移除一个或多个元素，成功true,失败false
s.clear();//清空集合,无返回值
s.contains(o);//检查是否包含元素，boolean
s.isEmpty();//检查集合是否为空,boolean
int a = s.size();//返回集合中元素的个数
Collection t = new ArrayList();
s.addAll(t);//将另一个单列集合t的内容全部添加到当前集合s中，booelan
s.removeAll(t);//移除s集合中也在t集合中的全部元素，boolean
s.containsAll(t);//检查s是否包含t的全部元素,boolean
s.retainAll(t);//将s与t的交集保存回s中，将s的其它元素移除1.3集合的遍历(所有单列集合均能如此遍历)
Collection s = new ArrayList();//(接口只能实例化它的子类)
s.add(1);
s.add(2);
//1.将集合转成数组
Object[] array = s.toArray();
for(int i=0;i
2.List接口
2.1.特点:
List里的元素都是有序的(先存的在List里的位置也靠前)，
List里的元素是可以重复的，你可以添加两个一模一样的元素进去
2.2.独有方法（只要是List均可使用）
List s = new ArrayList();
s.add(0,10);//在第0个位置添加一个Integer对象10
s.add(1,20);//在第1个位置添加一个Integer对象20
//s.add(3,30);//跨数添加，报错
s.add(1,30);//在已有元素的位置上添加新元素，会把原来及往后的元素挤到后面，此时[10,30,20]
s.remove(1);//移除位置1上的元素，后面的元素会往前,返回被移除的元素
s.get(1);//得到在指定位置的元素并返回
s.set(0, 100);//将第0个元素设为100，返回以前在此位置的元素2.3独有遍历机制(只要是list均可这样遍历)
//1.特有迭代器
ListIterator listIterator = s.listIterator();
while(listIterator.hasNext()) {//从前往后打印
System.out.println(listIterator.next());
}
while(listIterator.hasPrevious()) {//从后往前打印
//注意：必须先让指针从前往后遍历完，再从后往前，否则打印为空
System.out.println(listIterator.previous());
}
//2.for循环
for(int i=0;i2.4数组转list
Integer a[] = {1,2,3,4,5};
List asList = Arrays.asList(a);
for(Integer s:asList) {
System.out.println(s);
}
//注意：使用aslist得到的list，是不能进行add和remove的(仅可读的集合)
//asList.add(10); //java.lang.UnsupportedOperationException
//如果想要操作此集合，请作为参数传入到新建的ArrayList中
ArrayList as = new ArrayList(asList);
as.add(6);//成功添加
3.set接口
3.1.特点：set里面不能存放相同的元素(利用这一点，我们可以实现对集合的去重)，里面存放的元素也是无序的。
3.2.没有什么独有的方法
3.3没有什么独有的遍历方式
4.Queue接口
4.1.特点：队列是一种特殊的线性表，它只允许在表的前端进行删除操作，而在表的后端进行插入操作。通常以 FIFO（先进先出）的方式排序各个元素。
4.2.独有的方法
Queue s = new LinkedList<>();
//不推荐使用Queue提供的add()方法添加，因为可能会抛出异常
s.offer(1);//将元素插入到队列末端
s.offer(2);
s.offer(3);
//此时: 头[1,2,3]尾
s.peek();//获取队列头部元素1
s.element();//获取队列头部元素1
//不推荐使用Queue提供的remove()方法添加，因为可能会抛出异常
s.poll();//获取并移除队列头部元素1
//此时: 头[2,3]尾
5.ArrayList（线程不安全,能存且可存多个null）
5.1.特点: 没什么特点，有list的基本功能。底层是用数组实现的，增删慢，查询快
5.2.比较重要的独有方法
//构造方法ArrayList(Collection c)
//构造一个包含指定 collection 的元素的列表，其实相当于s2.addAll(s);
List s2 = new ArrayList(s);5.3.没什么独有的遍历方式
5.4所有集合实现线程安全，均可使用以下方法创建
List list = Collections.synchronizedList(new ArrayList());
6.LinkedList（线程不安全,能存且能存多个null）
5.1.特点，除了实现 List 接口外，LinkedList 类还为在列表的开头及结尾 get、remove 和 insert 元素提供了统一的命名方法。专门用于操作表头和表尾元素，可以当作堆栈、队列和双向队列使用。底层是用链表实现的，增删快，查询慢。
5.2.独有方法
5.3.独有遍历方式
Iterator des = s.descendingIterator();//获取逆序迭代器
while(des.hasNext()) {
System.out.println(des.next());//逆序打印
}
7.Vector（线程安全，能存且能存多个null）
7.1.特点：Vector与ArrayList一样，也是通过数组实现的，不同的是它支持线程的同步，即某一时刻只有一个线程能够写Vector，避免多线程同时写而引起的不一致性，但实现同步需要很高的花费，因此，访问它比访问ArrayList慢。如果集合中的元素的数目大于目前集合数组的长度时，vector增长率为目前数组长度的100%,而arraylist增长率为目前数组长度
的50%.如过在集合中使用数据量比较大的数据，用vector有一定的优势。
7.2.比较重要的方法
Vector vector = new Vector<>(10);
vector.add(1);
System.out.println(vector.capacity());//10
System.out.println(vector.size());//1
for(int i=0;i<10;i++) {//再添加10个，使集合中的元素的数目大于目前集合数组的长度
vector.add(i);
}
System.out.println(vector.capacity());//20，容量增长100%
System.out.println(vector.size());//11
8.Stack（线程安全，能存且能存多个null）
8.1.特点: Stack 类表示后进先出（LIFO）的对象堆栈。它通过五个操作对类 Vector 进行了扩展
8.2.重要方法
Stack s = new Stack();
s.push(2);
s.push(4);
s.push(6);
//底[2,4,6] 顶 ，顶的位置为1，底的位置为3
System.out.println(s.peek());//栈顶元素是6
System.out.println(s.search(2));//2在栈底，位置是3
while(!s.empty()) {//全部出栈 6,2,4
System.out.println(s.pop());
}
System.out.println(s.isEmpty());//true empty()与collection的isEmpty()方法是一样的
9.HashSet（线程不安全,能存但最多只有一个null）
9.1.特点：
①拥有基本的set特性，不允许存放相同的对象(通过hashCode()和equals()方法判定是否为同一对象),存放的对象也是无序的，没有索引，也无法保证存入和取出的顺序一致。
②通过hash值存储对象到散列单元。所以，查询快。hash值是由对象导出的一个整数值。在Object中有一个hashCode方法来得到hashCode。基本上，每一个对象都有一个默认的hashCode，其值就是对象的地址值。但也有一些类重写了hashCode()方法，比如String对象是通过对内容计算得到(所以内容相同hashCode就相同)。
Hash值可能与HashCode相等(HashTable就使用Key的hashCode直接作为Hash值)，也可能不相等(HashMap使用Key的hashCode，高16位不变，高16位与低16位做异或运算作为Hash值，这个称为Hash算法，Hash算法将元素尽可能均匀地平铺在数组上)
③HashMap实现机制，底层是数组+链表。而HashSet底层，就是HashMap。
举例:
Java默认的散列单元大小全部都是2的幂，初始值为16（2的4次幂）。则开辟一个容量为16的数组(1~16)，
存放一个hash值为24342的对象时，通过计算index，就把它放到第数组的第6个位置，(计算index方法：index = hash值 & (map.length – 1))。
[这里解释一下，有些人说通过取余来确定位置，其实通过取余来确定位置的并不是HashMap，而是HashTable(计算index的方法：index = (hash值 & 0x7FFFFFFF) % table.length)）
因为扩容的时候是2的n次方进行扩容，Hash值在2的n次方进行求余运算的结果都一样，但是&运算要快得多，而且因为扩容倍数的特殊性，导致扩容后不需要重新计算元素在数组中的位置，只需要判断Key的hash值多出来的那一位是0还是1，如果是0，新表中元素的位置和旧表一样，如果是1，新表中键值对的位置等于旧表的位置+旧表的长度]
如果，再存放一个hash值为24358的对象，再通过计算index,发现同样要落在数组第6个位置（即发生了hash碰撞），则在数组的第6个位置生成一个链表，将hash值为24358的对象放到链表头，指向刚才的hash值为24342的对象。(至于为什么要把新的放到链表头，可能设计师觉得，你新加进来的，被使用的可能性大)
如果，再存放一个一模一样的对象，在数组的第6个位置的链表中发现有一个老数据与新数据equals()=true的话，这个新数据将被视为已经加入，而不再重复丢入链表。
如果，16条链表中的75%链接有数据的时候(加载因子默认为0.75)，HahSet则开始重新散列，也就是将原来的散列结构全部抛弃，重新开辟一个散列单元大小为32（2的5次幂）的散列结果，并重新计算各个数据的存储位置。因为空间越大，取余数相同的情况就越小，也减少了hash碰撞。
④优点：
查找和增删都很快，知道了HashSet的添加对象的机制后，查找的道理一样。直接根据数据的hash码（散列码）和计算规则后，就得到了所在数组的位置，然后再查找链表中是否有这个数据即可(每个链表存储的数据很少，所以迭代起来也很快)。
⑤缺点：
但是hashSet增删的高效率是通过花费大量的空间换来的：HashSet这种算法会建立许多无用的空间。
9.2独有方法
Set a = new HashSet();
for(int i=1;i<16;i++) {//按顺序存入1~15的字符串形式
a.add(i+" ");
}
Iterator iterator = a.iterator();
//不一定按存入顺序打出
while(iterator.hasNext()) {//11 10 9 8 7 6 5 4 3 2 1 15 14 13 12
System.out.println(iterator.next());
}
10.LinkedHashSet（线程不安全,能存但最多只有一个null）
10.1.特点：LinkedHashSet集合同样是根据元素的hashCode值来决定元素的存储位置，但是它同时使用链表维护元素的次序。这样使得元素看起 来像是以插入顺序保存的，也就是说，当遍历该集合时候，LinkedHashSet将会以元素的添加顺序访问集合的元素。
Set a = new LinkedHashSet();
for(int i=0;i<16;i++) {
a.add(i+" ");
}
//按顺序打印
for(Object o:a) {//0 1 2 3 4 ...
System.out.println(o);
}
10.TreeSet（线程不安全,存null将会抛异常）
10.1.特点：一个能够对元素进行自动排序的set集合
Set a = new TreeSet();
Random random = new Random();
for(int i=0;i<16;i++) {//添加16次随机数(1~20),但不一定添加16个(有可能随机数重复)
a.add(random.nextInt(20));
}
//打印
for(Object o:a) {//1 4 6 10 11 12 13 14 15 17
System.out.println(o+" ");
}10.2.独有方法(自定义排序规则)
11.Map接口
11.1特点: 双列集合的根接口，存储键值对(key-value)，key不可重复，但可以为null(最多一个null)，value可以重复
11.2独有方法(只要是Map均可使用)
Map s = new HashMap();
//注意，Map接口(双列集合))没有add()方法
s.put("1", 16);
s.put("2",98);
System.out.println(s.get("2"));//9811.3独有遍历方式
//1.keySet 获取所有key值
Set keySet = map.keySet();
//可以使用3种对set的遍历方式遍历
//1.1转数组
Object[] array = keySet.toArray();
for(int i=0;i12.1.特点：没什么特点，拥有Map的全部功能。值得一提的是，HashSet的底层就是通过HashMap来实现的。即HashSet存值，实际上是新建了一个HashMap，将值存到key中。存入数据的时候，并不能保证存储的顺序。
Map map = new HashMap();
for(int i=0;i<20;i++) {//添加20个键值对，键为0~19，值为键的平方，均为字符串形式
map.put(i+" ", " "+i*i);
}
Set keySet = map.keySet();//并不按顺序输出
Object[] array = keySet.toArray();
for(int i=0;i没错，加了Linked，就是表示它底层是链表，它通过维护一个运行于所有条目的双向链表，LinkedHashMap保证了元素迭代的顺序。该迭代顺序可以是插入顺序或者是访问顺序。
LinkedHashMap可以认为是HashMap+LinkedList，即它既使用HashMap操作数据结构，又使用LinkedList维护插入元素的先后顺序
14.TreeMap（线程不安全,key不能为null，值可以为null）
没错，TreeMap能够对元素自动排序，实现顺序输出。
如果key是数字，默认按key值的升序输出。如果key是字符串，则按照A>...>Z>a>...>z的Ascll值输出。
Map map = new HashMap();
Random random = new Random();
for(int i=0;i<20;i++) {
map.put(random.nextInt(20), i*i);
}
Set keySet = map.keySet();//按key的顺序升序输出
Object[] array = keySet.toArray();
for(int i=0;i如果key是其他类型，则需要定义好排序规则，否则会报错。
15.HashTable（线程安全，值和key都不能为null）
HashMap和HashTable基本上是等价的，至于为什么还是要单独拿出来讲，因为面试实在问太多关于这两个类了。以下是转载的大佬的总结。
HashMap和Hashtable的区别