Java 集合可分为Collection 和Map 两种体系
Collection接口：单列数据，定义了存取一组对象的方法的集合
List：元素有序、可重复的集合
Set：元素无序、不可重复的集合
Map接口：双列数据，保存具有映射关系“key-value对”的集合
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-eD0BRy3r-1593572915697)(C:\Users\23746\AppData\Roaming\Typora\typora-user-images\image-20200508142343433.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9voieAI1-1593572915700)(C:\Users\23746\AppData\Roaming\Typora\typora-user-images\image-20200508142523629.png)]
Collection 接口
Collection 接口是List、Set 和Queue 接口的父接口，该接口里定义的方法既可用于操作Set 集合，也可用于操作List 和Queue 集合。JDK不提供此接口的任何直接实现，而是提供更具体的子接口(如：Set和List)实现。在Java5 之前，Java 集合会丢失容器中所有对象的数据类型，把所有对象都当成Object 类型处理；从JDK 5.0 增加了泛型以后，Java 集合可以记住容器中对象的数据类型。1、添加
add(Objectobj)
addAll(Collectioncoll)
2、获取有效元素的个数
int size()
3、清空集合
void clear()
4、是否是空集合
boolean isEmpty()
5、是否包含某个元素
boolean contains(Objectobj)：是通过元素的equals方法来判断是否是同一个对象
boolean containsAll(Collectionc)：也是调用元素的equals方法来比较的。拿两个集合的元素挨个比较。
6、删除
boolean remove(Object obj) ：通过元素的equals方法判断是否是要删除的那个元素。只会删除找到的第一个元素
boolean removeAll(Collection coll)：取当前集合的差集
7、取两个集合的交集
boolean retainAll(Collection c)：把交集的结果存在当前集合中，不影响c
8、集合是否相等
boolean equals(Object obj)
9、转成对象数组
Object[] toArray()
10、获取集合对象的哈希值
hashCode()
11、遍历
iterator()：返回迭代器对象，用于集合遍历
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-7QewEBYn-1593572915702)(C:\Users\23746\AppData\Roaming\Typora\typora-user-images\image-20200508144214109.png)]
在调用it.next()方法之前必须要调用it.hasNext()进行检测。若不调用，且下一条记录无效，直接调用it.next()会抛出NoSuchElementException异常。
注意：
Iterator可以删除集合的元素，但是是遍历过程中通过迭代器对象的remove方法，不是集合对象的remove方法。如果还未调用next()或在上一次调用next方法之后已经调用了remove方法，再调用remove都会报IllegalStateException。List接口方法
List除了从Collection集合继承的方法外，List 集合里添加了一些根据索引来操作集合元素的方法。void add(int index, Object ele):在index位置插入ele元素boolean addAll(int index, Collection eles):从index位置开始将eles中的所有元素添加进来Object get(int index):获取指定index位置的元素int indexOf(Object obj):返回obj在集合中首次出现的位置int lastIndexOf(Object obj):返回obj在当前集合中末次出现的位置Object remove(intindex):移除指定index位置的元素，并返回此元素Object set(intindex, Object ele):设置指定index位置的元素为eleList subList(int fromIndex, int toIndex):返回从fromIndex到toIndex位置的子集合ArrayList是List 接口的典型实现类、主要实现类
本质上，ArrayList是对象引用的一个”变长”数组ArrayList的JDK1.8之前与之后的实现区别？JDK1.7：ArrayList像饿汉式，直接创建一个初始容量为10的数组JDK1.8：ArrayList像懒汉式，一开始创建一个长度为0的数组，当添加第一个元素时再创建一个始容量为10的数组Arrays.asList(…) 方法返回的List 集合，既不是ArrayList实例，也不是Vector 实例。Arrays.asList(…) 返回值是一个固定长度的List 集合对于频繁的插入或删除元素的操作，建议使用LinkedList类，效率较高
新增方法：void addFirst(Object obj)void addLast(Object obj)Object getFirst()Object getLast()Object removeFirst()Object removeLast()LinkedList：双向链表，内部没有声明数组，而是定义了Node类型的first和last，用于记录首末元素。同时，定义内部类Node，作为LinkedList中保存数据的基本结构。
Node除了保存数据，还定义了两个变量：
prev变量记录前一个元素的位置next变量记录下一个元素的位置1、ArrayList和LinkedList的异同
二者都线程不安全，相对线程安全的Vector，执行效率高。此外，ArrayList是实现了基于动态数组的数据结构，LinkedList基于链表的数据结构。对于随机访问get和set，ArrayList觉得优于LinkedList，因为LinkedList要移动指针。对于新增和删除操作add(特指插入)和remove，LinkedList比较占优势，因为ArrayList要移动数据。
2、ArrayList和Vector的区别
Vector和ArrayList几乎是完全相同的,唯一的区别在于Vector是同步类(synchronized)，属于强同步类。因此开销就比ArrayList要大，访问要慢。正常情况下,大多数的Java程序员使用ArrayList而不是Vector,因为同步完全可以由程序员自己来控制。Vector每次扩容请求其大小的2倍空间，而ArrayList是1.5倍。Vector还有一个子类Stack。
向HashSet中添加元素的过程：
当向HashSet集合中存入一个元素时，HashSet会调用该对象的hashCode()方法来得到该对象的hashCode值，然后根据hashCode值，通过某种散列函数决定该对象在HashSet底层数组中的存储位置。（这个散列函数会与底层数组的长度相计算得到在数组中的下标，并且这种散列函数计算还尽可能保证能均匀存储元素，越是散列分布，该散列函数设计的越好）如果两个元素的hashCode()值相等，会再继续调用equals方法，如果equals方法结果为true，添加失败；如果为false，那么会保存该元素，但是该数组的位置已经有元素了，那么会通过链表的方式继续链接。如果两个元素的equals() 方法返回true，但它们的hashCode() 返回值不相等，hashSet将会把它们存储在不同的位置，但依然可以添加成功以自定义的Customer类为例，何时需要重写equals()？
当一个类有自己特有的“逻辑相等”概念,当改写equals()的时候，总是要改写hashCode()，根据一个类的equals方法（改写后），两个截然不同的实例有可能在逻辑上是相等的，但是，根据Object.hashCode()方法，它们仅仅是两个对象。因此，违反了“相等的对象必须具有相等的散列码”。结论：复写equals方法的时候一般都需要同时复写hashCode方法。通常参与计算hashCode的对象的属性也应该参与到equals()中进行计算。LinkedHashSet是HashSet的子类
LinkedHashSet根据元素的hashCode值来决定元素的存储位置，但它同时使用双向链表维护元素的次序，这使得元素看起来是以插入顺序保存的。LinkedHashSet插入性能略低于HashSet，但在迭代访问Set 里的全部元素时有很好的性能。LinkedHashSet不允许集合元素重复。TreeSet是SortedSet接口的实现类，TreeSet可以确保集合元素处于排序状态。
TreeSet底层使用红黑树结构存储数据新增的方法如下：(了解)Comparator comparator()Object first()Object last()Object lower(Object e)Object higher(Object e)SortedSet subSet(fromElement, toElement)SortedSet headSet(toElement)SortedSet tailSet(fromElement)TreeSet两种排序方法：自然排序和定制排序。默认情况下，TreeSet采用自然排序TreeSet和后面要讲的TreeMap采用红黑树的存储结构
特点：有序，查询速度比List快
向TreeSet中添加元素时，只有第一个元素无须比较compareTo()方法，后面添加的所有元素都会调用compareTo()方法进行比较。
因为只有相同类的两个实例才会比较大小，所以向TreeSet中添加的应该是同一个类的对象。
对于TreeSet集合而言，它判断两个对象是否相等的唯一标准是：两个对象通过compareTo(Object obj) 方法比较返回值。
当需要把一个对象放入TreeSet中，重写该对象对应的equals() 方法时，应保证该方法与compareTo(Object obj) 方法有一致的结果：如果两个对象通过equals() 方法比较返回true，则通过compareTo(Object obj) 方法比较应返回0。否则，让人难以理解
TreeSet的自然排序要求元素所属的类实现Comparable接口，如果元素所属的类没有实现Comparable接口，或不希望按照升序(默认情况)的方式排列元素或希望按照其它属性大小进行排序，则考虑使用定制排序。定制排序，通过Comparator接口来实现。需要重写compare(T o1,T o2)方法。
利用int compare(T o1,T o2)方法，比较o1和o2的大小：如果方法返回正整数，则表示o1大于o2；如果返回0，表示相等；返回负整数，表示o1小于o2。
要实现定制排序，需要将实现Comparator接口的实例作为形参传递给TreeSet的构造器。
此时，仍然只能向TreeSet中添加类型相同的对象。否则发生ClassCastException异常。
使用定制排序判断两个元素相等的标准是：通过Comparator比较两个元素返回了0
添加、删除、修改操作：
Object put(Object key,Object value)：将指定key-value添加到(或修改)当前map对象中void putAll(Map m):将m中的所有key-value对存放到当前map中Object remove(Object key)：移除指定key的key-value对，并返回valuevoid clear()：清空当前map中的所有数据元素查询的操作：
Object get(Object key)：获取指定key对应的valueboolean containsKey(Object key)：是否包含指定的keyboolean containsValue(Object value)：是否包含指定的valueint size()：返回map中key-value对的个数boolean isEmpty()：判断当前map是否为空boolean equals(Object obj)：判断当前map和参数对象obj是否相等元视图操作的方法：
Set keySet()：返回所有key构成的Set集合Collection values()：返回所有value构成的Collection集合Set entrySet()：返回所有key-value对构成的Set集合 public static void main(String[] args) { Map map = new HashMap(); //map.put(..,..)省略 map.put(1,"a"); map.put(2,"b"); map.put(3,"c"); System.out.println("map的所有key:"); Set keys = map.keySet(); // HashSet for(Object key: keys) { System.out.println(key+ "->"+ map.get(key)); } System.out.println("map的所有的value："); Collection values= map.values(); Iterator iter= values.iterator(); while(iter.hasNext()) { System.out.println(iter.next()); } System.out.println("map所有的映射关系："); // 映射关系的类型是Map.Entry类型，它是Map接口的内部接口 Set mappings= map.entrySet(); for(Object mapping: mappings) { Map.Entry entry= (Map.Entry) mapping; System.out.println("key是："+ entry.getKey() + "，value是："+ entry.getValue()); } }JDK 7及以前版本：HashMap是数组+链表结构(即为链地址法)
JDK 8版本发布以后：HashMap是数组+链表+红黑树实现。
总结：JDK1.8相较于之前的变化：
1.HashMap map = new HashMap();//默认情况下，先不创建长度为16的数组
2.当首次调用map.put()时，再创建长度为16的数组
3.数组为Node类型，在jdk7中称为Entry类型
4.形成链表结构时，新添加的key-value对在链表的尾部（七上八下）
5.当数组指定索引位置的链表长度>8时，且map中的数组的长度> 64时，此索引位置上的所有key-value对使用红黑树进行存储。
LinkedHashMap是HashMap的子类
在HashMap存储结构的基础上，使用了一对双向链表来记录添加元素的顺序与LinkedHashSet类似，LinkedHashMap可以维护Map 的迭代顺序：迭代顺序与Key-Value 对的插入顺序一致查找、替换
Object max(Collection)：根据元素的自然顺序，返回给定集合中的最大元素Object max(Collection，Comparator)：根据Comparator 指定的顺序，返回给定集合中的最大元素Object min(Collection)Object min(Collection，Comparator)int frequency(Collection，Object)：返回指定集合中指定元素的出现次数void copy(List dest,List src)：将src中的内容复制到dest中boolean replaceAll(List list，Object oldVal，Object newVal)：使用新值替换List 对象的所有旧值Collections 类中提供了多个synchronizedXxx() 方法，该方法可使将指定集合包装成线程同步的集合，从而可以解决多线程并发访问集合时的线程安全问题
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-YZ5ui4vd-1593572915705)(C:\Users\23746\AppData\Roaming\Typora\typora-user-images\image-20200508170703444.png)]
常用 Map 子类集合对于 null 存储情况：
上面的实现类约束，都太不一样，有点不好记忆。其实只要我们在加入元素之前，主动去做空指针判断，不要在 Map 中存入 null，就可以从容避免上面问题。
尽量避免使用自定义对象作为 Map 集合 key，如果一定要使用，记得重写 hashCode 与 equals 方法。另外还要保证这是一个不可变对象，即对象创建之后，无法再修改里面字段值。
错误使用场景案例
public static void main(String[] args) throws IOException, InterruptedException { ConcurrentHashMap<String, Integer> concurrentHashMap = new ConcurrentHashMap<>(); concurrentHashMap.put("a",1); ExecutorService executorService = Executors.newFixedThreadPool(100); for (int i = 0; i < 1000; i++) { executorService.execute(()->{ //第一步：值加1 int value = concurrentHashMap.get("a") + 1; //第二步：重新设值 concurrentHashMap.put("a",value); }); } TimeUnit.SECONDS.sleep(5l); System.out.println("---------"+concurrentHashMap.get("a")); executorService.shutdown(); }上面示例代码，我们原本期望输出 1001，但是运行几次，得到结果都是小于 1001。
深入分析这个问题原因，实际上是因为第一步与第二步是一个组合逻辑，不是一个原子操作。
ConcurrentHashMap 只能保证这两步单的操作是个原子操作，线程安全。但是并不能保证两个组合逻辑线程安全，很有可能 A 线程刚通过 get 方法取到值，还未来得及加 1，线程发生了切换，B 线程也进来取到同样的值。
这个问题同样也发生在其他线程安全的容器，比如 Vector等。
上面的问题解决办法也很简单，加锁就可以解决，不过这样就会使性能大打折扣，所以不太推荐。
我们可以使用 AtomicInteger 解决以上的问题。
public static void main(String[] args) throws IOException, InterruptedException { ConcurrentHashMap<String, AtomicInteger> concurrentHashMap = new ConcurrentHashMap<>(); ExecutorService executorService = Executors.newFixedThreadPool(100); for (int i = 0; i < 1000; i++) { executorService.execute(()->{ //如果key不存在，新建AtomicInteger对象，否则内部AtomicInteger递增 concurrentHashMap.computeIfAbsent("a",s ->new AtomicInteger(1)).incrementAndGet(); }); } TimeUnit.SECONDS.sleep(5l); System.out.println("---------"+concurrentHashMap.get("a")); executorService.shutdown(); }Map 接口除了支持增删改查功能以外，还有三个特有的方法，能返回所有 key，返回所有的 value，返回所有 kv 键值对。
// 返回 key 的 set 视图 Set<K> keySet()； // 返回所有 value Collection 视图 Collection<V> values(); // 返回 key-value 的 set 视图 Set<Map.Entry<K, V>> entrySet();这三个方法创建返回新集合，底层其实都依赖的原有 Map 中数据，所以一旦 Map 中元素变动，就会同步影响返回的集合。
另外这三个方法返回新集合，是不支持的新增以及修改操作的，但是却支持 clear、remove 等操作。
public static void main(String[] args) throws IOException, InterruptedException { Map<String, Integer> hashMap = new HashMap<>(); hashMap.put("a",1); hashMap.put("b",2); hashMap.put("c",3); Collection<Integer> values = hashMap.values(); hashMap.put("d",4); Set<Map.Entry<String, Integer>> entrySet = hashMap.entrySet(); Iterator<Map.Entry<String, Integer>> iterator = entrySet.iterator(); while (iterator.hasNext()){ Map.Entry<String, Integer> entry = iterator.next(); System.out.println("key:"+entry.getKey()+",value:"+entry.getValue()); } Iterator<Integer> iterator1 = values.iterator(); while (iterator1.hasNext()){ Integer next = iterator1.next(); System.out.println("value:"+next); } }[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-QfRNXUMT-1593572915707)(C:\Users\23746\AppData\Roaming\Typora\typora-user-images\image-20200508203306744.png)]
数组转List集合，Arrays.asList，不支持增删元素，共享原始数组，修改原始数据，影响新集合，修改新集合，又会影响数组元素
public static void main(String[] args) throws IOException, InterruptedException { String[] array={"a","b","c"}; List<String> list = Arrays.asList(array); // list.add("d");//数组转成List不支持新增，java.lang.UnsupportedOperationException array[0]="aaa"; list.set(1,"bbb"); System.out.println(Arrays.toString(array)); for (String s : list) { System.out.println(s); } } //运行结果 [aaa, bbb, c] aaa bbb c知道了实际原因，修复的办法也很简单，套娃一层 ArrayList 呗！
List<String> list = new ArrayList<>(Arrays.asList(arrays));不过这么写感觉十分繁琐，推荐使用 Guava Lists 提供的方法。
List<String> list = Lists.newArrayList(arrays);通过上面两种方式，我们将新的 List 集合与原始数组解耦，不再互相影响，同时由于此时还是真正的 ArrayList，不用担心 add/remove报错了。
除了 Arrays#asList产生新集合与原始数组互相影响之外，JDK 另一个方法List#subList 生成新集合也会与原始 List 互相影响。
我们来看一个例子：
public static void main(String[] args) throws IOException, InterruptedException { ArrayList<Integer> integers = new ArrayList<>(); integers.add(1); integers.add(2); integers.add(3); List<Integer> subList = integers.subList(0, 2); integers.set(0,100); subList.set(1,200); System.out.println("list:"+integers); System.out.println("subList:"+subList); } //运行结果 list:[100, 200, 3] subList:[100, 200]这里修复的办法也很简单，跟上面一样，也来个套娃呗，加一层 ArrayList 。
为了防止 List 集合被误操作，我们可以使用 Collections#unmodifiableList 生成一个不可变（immutable）集合，进行防御性编程。
这个不可变集合只能被读取，不能做任何修改，包括增加，删除，修改，从而保护不可变集合的安全。
public static void main(String[] args) throws IOException, InterruptedException { ArrayList<String> arrayList = Lists.newArrayList(Arrays.asList("a", "b", "c")); List<String> list = Collections.unmodifiableList(arrayList); // list.add("d");//抛异常java.lang.UnsupportedOperationException arrayList.add("d");//修改原集合，从原集合生成的不可变集合也跟着改动 System.out.println(list); }可以看到这跟上面 SubList 其实是同一个问题，新集合底层实际使用了原始 List。
由于不可变集合所有修改操作都会报错，所以不可变集合不会产生任何改动，所以并不影响的原始集合。但是防过来，却不行，原始 List 随时都有可能被改动，从而影响不可变集合。
可以使用如下两种方式防止上卖弄的情况。
使用 JDK9 List#of 方法。
List<String> list = new ArrayList<>(Arrays.asList("one", "two", "three")); List<String> unmodifiableList = List.of(list.toArray(new String[]{}));使用 Guava immutable list
List<String> list = new ArrayList<>(Arrays.asList("one", "two", "three")); List<String> unmodifiableList = ImmutableList.copyOf(list);相比而言 Guava 方式比较清爽，使用也比较简单，推荐使用 Guava 这种方式生成不可变集合。
先来看一段代码：
String[] arrays = {"1", "2", "3"}; List<String> list = new ArrayList<>(Arrays.asList(arrays)); for (String str : list) { if (str.equals("1")) { list.remove(str); } }上面的代码我们使用 foreach 方式遍历 List 集合，如果符合条件，将会从集合中删除改元素。
这个程序编译正常，但是运行时，程序将会发生异常，日志如下：
java.util.ConcurrentModificationException at java.base/java.util.ArrayList$Itr.checkForComodification(ArrayList.java:939) at java.base/java.util.ArrayList$Itr.next(ArrayList.java:893)可以看到程序最终错误是由 ArrayList$Itr.next 处的代码抛出，但是代码中我们并没有调用该方法，为什么会这样?
实际是因为 foreach 这种方式实际上 Java 给我们提供的一种语法糖，编译之后将会变为另一种方式。
我们将上面的代码产生 class 文件反编来看下最后代码长的啥样。
可以看到 foreach 这种方式实际就是 Iterator 迭代器实现方式，这就是为什么foreach 被遍历的类需要实现 Iterator接口的原因。
修复的办法有两种：
使用 Iterator#remove 删除元素
public static void main(String[] args) throws IOException, InterruptedException { String[] arrays = {"1", "2", "3"}; List<String> list = new ArrayList<>(Arrays.asList(arrays)); Iterator<String> iterator = list.iterator(); while (iterator.hasNext()){ String next = iterator.next(); if(next.equals("1")){ iterator.remove(); } } System.out.println(list); }JDK1.8 List#removeIf
public static void main(String[] args) throws IOException, InterruptedException { String[] arrays = {"1", "2", "3"}; List<String> list = new ArrayList<>(Arrays.asList(arrays)); list.removeIf(s -> s.equals("1")); System.out.println(list); }第一，我们不要先入为主，想当然就认为 Arrays.asList 和 List.subList 就是一个普通，独立的 ArrayList。
如果没办法，使用了 Arrays.asList 和 List.subList ，返回给其他方法的时候，一定要记得再套娃一层真正的 java.util.ArrayList。
第二 JDK 的提供的不可变集合实际非常笨重，并且低效，还不安全，所以推荐使用 Guava 不可变集合代替。
最后，切记，不要随便在 foreach增加/删除元素。
