集合
集合框架图
集合与数组的区别：
数组：长度固定，可以存放基本类型和引用类型
集合：长度不固定，只能存放引用类型。因此需要包装类将基本类型包装，int变Integer
Collection父接口
Collection：无序，无下标，不能重复
1. 创建 Collection collection = new ArrayList();
2. 删除 collection.remove(); collection.clear(); collection.removeAll()
remove:删除一个
clear:全部删除
removeAll:作差，例如A.removeAll(B),A中重复元素均删除
3. 遍历元素（重点）
3.1使用增强for（因为无下标）
for(Object object : collection){
}
3.2使用迭代器
//haNext(); 有没有下一个元素
//next(); 获取下一个元素
//remove(); 删除当前元素
Iterator it = collection.iterator();
while(it.hasNext()){
String object = (String)it.next(); //强转
// 可以使用it.remove(); 进行移除元素
// collection.remove(); 不能用collection其他方法 会报并发修改异常
}
4. 判断 collection.contains(); collection.isEmpty();
List子接口
有序，有下标，元素可重复
List list = new ArrayList();
list.add(0);
list.add("hhh");
list.add(new int[]{
5,6,7});
for(int i=0; i<list.size(); i++){
System.out.println(list.get(i));
}
List<Integer> integers = new ArrayList<>();
integers.add(8);
integers.add(9);
integers.add(15);
for(Integer it : integers){
System.out.println(it);
}
Iterator<Integer> iterator1 = integers.iterator();//迭代器
while (iterator1.hasNext()){
Integer next = iterator1.next();
System.out.println(next);
}
ListIterator<Integer> iterator = integers.listIterator();//列表迭代器，可以从后往前
while (iterator.hasNext()){
System.out.println(iterator.next());
}
while (iterator.hasPrevious()){
System.out.println(iterator.previous());
}
List subList = list.subList(1,3); //返回子集合，左闭右开，返回1，2
List实现类
ArrayList
数组实现，连续空间，查询快，增删慢
线程不安全
源码分析：默认容量为10，每次扩容是之前的1.5倍
Vector
与ArrayList大体一致，除了：
线程安全，一次只有一个线程用Vector，因此速度比ArrayList慢
每次扩容是之前的2倍
Vector<String> strings = new Vector<>();
strings.add("kkk");
strings.add("ppp");
strings.add("fdfsfs");
for(String str : strings){
System.out.println(str);
}
strings.remove(2);
Iterator<String> iterator = strings.iterator();
while (iterator.hasNext()){
System.out.println(iterator.next());
}
LinkedList
链表实现，非连续空间，查询慢，增删块
Set集合
无序，无下标，元素不能重复，全部继承自Collection类
HashSet
存储结构：哈希表
1.8之前是数组+链表
1.8之后是数组+链表+红黑树 (HashSet是一个HashMap的实例)
HashSet：内部的数据结构是哈希表，是线程不安全的。
HashSet中保证集合中元素是唯一的方法：通过对象的hashCode和equals方法来完成对象唯一性的判断。
如果对象的hashCode值不同，则不用判断equals方法，就直接存到HashSet中。
如果对象的hashCode值相同，需要用equals方法进行比较，如果结果为true，则视为相同元素，不存，如果结果为false，视为不同元素，进行存储。
注意：如果元素要存储到HashCode中，必须覆盖hashCode方法和equals方法。
HashSet<Integer> integers = new HashSet<>();
integers.add(1);
integers.add(2);
integers.add(3);
integers.add(4);
for(Integer tmp : integers){
System.out.println(tmp);
}
TreeSet
使用红黑树
TreeSet：可以对Set集合中的元素进行排序，是线程不安全的。
TreeSet中判断元素唯一性的方法是：根据比较方法的返回结果是否为0，如果是0，则是相同元素，不存，如果不是0，则是不同元素，存储。
TreeSet对元素进行排序的方式：
元素自身具备比较功能，即自然排序，需要实现Comparable接口，并覆盖其compareTo方法。
元素自身不具备比较功能，则需要实现Comparator接口，并覆盖其compare方法。
TreeSet<Integer> integers = new TreeSet<>(new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
return o2 - o1;
}
});
integers.add(5);
integers.add(9);
integers.add(7);
integers.add(1);
for(Integer tmp : integers){
System.out.println(tmp);
}
Map接口
具有键值对Key-Value
键：无序，无下标，不能重复
值：无序，无下标，可以重复
Map<Integer, Integer> hashMap = new HashMap<>();
hashMap.put(56, 65);
hashMap.put(89, 89);
hashMap.put(56, 100); //替换第一个
Set<Integer> set = hashMap.keySet();
for(Integer key : set){
System.out.println(hashMap.get(key));
}
Set<Map.Entry<Integer, Integer>> set1 = hashMap.entrySet();
for(Map.Entry<Integer, Integer> entry : set1){
System.out.println(entry.getKey() + "\t" + entry.getValue());
}
HashMap
1.8之前是数组+链表
1.8之后是数组+链表+红黑树
-
刚创建时，table是null，添加第一个元素后，容量为16
-
当元素个数大于阈值（16*0.75），会扩容，大小×2，减少树的高度
-
链表长度>8，数组元素个数>=64,调整为红黑树
-
链表长度< 6,调整为链表
-
1.8之前为头插入，之后为尾插入
HashTable
线程安全，运行效率慢，不允许null作为key或者value
Properties
hashtable的子类，要求key和value都是string，用于配置文件读取
TreeMap
实现了SortedMap接口（是map的子接口），可以对key自动排序