集合框架结构
- 【强制】关于 hashCode 和 equals 的处理，遵循如下规则：
1） 只要重写 equals，就必须重写 hashCode。
2） 因为 Set 存储的是不重复的对象，依据 hashCode 和 equals 进行判断，所以 Set 存储的 对象必须重写这两个方法。
3） 如果自定义对象做为 Map 的键，那么必须重写 hashCode 和 equals。
说明：String 重写了 hashCode 和 equals 方法，所以我们可以非常愉快地使用 String 对象 作为 key 来使用。
理解：我们用自定义对象做Map的键的情况比较少，如果有用到，要记得这个重写hashCode 和 equals方法的要求。
- 【强制】 ArrayList的subList结果不可强转成ArrayList，否则会抛出ClassCastException 异常，即 java.util.RandomAccessSubList cannot be cast to java.util.ArrayList.
说明：subList 返回的是 ArrayList 的内部类 SubList，并不是 ArrayList ，而是 ArrayList 的一个视图，对于 SubList 子列表的所有操作最终会反映到原列表上。
理解：SubList是原来List的一个镜像，修改了SubList必然会改变原来的List
LinkedList<String> ll = new LinkedList<>();
ll.add("a");
ll.add("b");
ll.add("c");
List<String> l2 = ll.subList(1, 2);// subList是左闭右开的[)
l2.add("new");
System.out.println(ll);
System.out.println(l2);
修改原list,则sublist的所有操作会报错.
可以通过subList的clear方法删除原List的一段连续内容
list.subList(from, to).clear();
【强制】在 subList 场景中，高度注意对原集合元素个数的修改，会导致子列表的遍历、增加、 删除均会产生 ConcurrentModificationException 异常。
理解：参见上一条规约。【强制】使用集合转数组的方法，必须使用集合的 toArray(T[] array)，传入的是类型完全 一样的数组，大小就是 list.size()。
说明：使用 toArray 带参方法，入参分配的数组空间不够大时，toArray 方法内部将重新分配 内存空间，并返回新数组地址；如果数组元素大于实际所需，下标为[ list.size() ]的数组 元素将被置为 null，其它数组元素保持原值，因此最好将方法入参数组大小定义与集合元素个数一致。
正例： List<String> list = new ArrayList<String>();
list.add("guan");
list.add("bao");
String[] array = new String[];
array = list.toArray(array);
反例：直接使用 toArray 无参方法存在问题，此方法返回值只能是 Object[]类，若强转其它 类型数组将出现 ClassCastException 错误。
理解：我们在工作中可能会遇到数组和列表的转换，列表转数组可以采用正例中的方法，数组转列表也方便用java.util.Arrays的asList方法,接正例，可以如下写法：
List<String> list1 = Arrays.asList(array);
- 【强制】使用工具类 Arrays.asList()把数组转换成集合时，不能使用其修改集合相关的方法，它的 add/remove/clear 方法会抛出 UnsupportedOperationException 异常。
说明：asList的返回对象是一个Arrays内部类，并没有实现集合的修改方法。Arrays.asList体现的是适配器模式，只是转换接口，后台的数据仍是数组。
String[] str = new String[] { "you", "wu" };
List list = Arrays.asList(str);
第一种情况：list.add("yangguanbao"); 运行时异常。
第二种情况：str[0] = "gujin"; 那么 list.get(0)也会随之修改
理解：这个有点像subList的用法，只是个镜像，可以遍历，不要试图修改。
- 【强制】泛型通配符<? extends T>来接收返回的数据，此写法的泛型集合不能使用 add 方 法，而<? super T>不能使用 get 方法，做为接口调用赋值时易出错。
说明：扩展说一下 PECS(Producer Extends Consumer Super)原则：
第一、频繁往外读取内容的，适合用<? extends T>。
第二、经常往里插入的，适合用<? super T>。
理解：1、以“?”声明的集合，不能往此集合中添加元素，所以它只能作为生产者(亦即它只能被迭代)，如下：
List<?> names = Lists.newArrayList("yiifaa");
// 通配符声明的集合，获取的元素都是Object类型
List<Object> allNames = Lists.newArrayList("yiifee");
allNames.addAll(names);
// 只能以Object迭代元素
for(Object name: names) {
System.out.println(name);
}
2、以“? extends T”声明的集合，不能往此集合中添加元素，所以它也只能作为生产者，如下：
List<? extends String> names = Lists.newArrayList("yiifaa");
// 声明消费者
List<String> allNames = Lists.newArrayList("yiifee");
// 消费生产者的元素
allNames.addAll(allNames);
// 能更精确地确认元素类型，也比第一种更方便迭代
for(String name: names) {
System.out.println(name);
}
3、在通配符的表达式中，只有“? super T”能添加元素，所以它能作为消费者（消费其他通配符集 合）。
List<? super String> allNames = Lists.newArrayList("yiifaa");
List<String> names = Lists.newArrayList("yiifee");
// 可以直接添加泛型元素
allNames.addAll(names);
// 也可以添加通配符泛型元素
List<? extends String> names1 = Lists.newArrayList("yiifee");
allNames.addAll(names1);
//针对采用“? super T”通配符的集合，对其遍历时需要多一次转型，如下：
// 只能获取到Object类型
for(Object name: allNames) {
// 这里需要一次转型
System.out.println(name);
}
- 【强制】不要在 foreach 循环里进行元素的 remove/add 操作。remove 元素请使用 Iterator 方式，如果并发操作，需要对 Iterator 对象加锁。
正例： Iterator<String> iterator = list.iterator();
while (iterator.hasNext()) {
String item = iterator.next();
if (删除元素的条件) {
iterator.remove();
}
}
反例： List<String> list = new ArrayList<String>();
list.add("1");
list.add("2");
for (String item : list) {
if ("1".equals(item)) {
list.remove(item);
}
}
说明：以上代码的执行结果肯定会出乎大家的意料，那么试一下把“1”换成“2”，会是同样的 结果吗？
理解：反例这样做在其他线程进行修改时，容易出现ConcurrentModificationException，因此必须要在迭代过程中使用锁，具体见如下链接的例子。
==Java 遍历List==
- 【强制】 在 JDK7 版本及以上，Comparator 要满足如下三个条件，不然 Arrays.sort， Collections.sort 会报 IllegalArgumentException 异常。
说明：三个条件如下
1） x，y 的比较结果和 y，x 的比较结果相反。
2） x>y，y>z，则 x>z。
3） x=y，则 x，z 比较结果和 y，z 比较结果相同。
反例：下例中没有处理相等的情况，实际使用中可能会出现异常：
new Comparator<Student>() {
@Override
public int compare(Student o1, Student o2) {
return o1.getId() > o2.getId() ? 1 : -1;
}
};
理解：通过Comparator实现对任意类型集合对象进行整体排序的使用方式见如下链接。
==用 Comparator 实现排序==
==接口Comparator的使用==
- 【推荐】集合初始化时，指定集合初始值大小。
说明：HashMap 使用 HashMap(int initialCapacity) 初始化。
正例：initialCapacity = (需要存储的元素个数 / 负载因子) + 1。注意负载因子（即loader factor）默认为 0.75，如果暂时无法确定初始值大小，请设置为 16（即默认值）。
反例：HashMap 需要放置 1024 个元素，由于没有设置容量初始大小，随着元素不断增加，容 量 7 次被迫扩大，resize 需要重建 hash 表，严重影响性能
理解：// 默认构造函数。
HashMap()
// 指定“容量大小”的构造函数
HashMap(int capacity)
// 指定“容量大小”和“加载因子”的构造函数
HashMap(int capacity, float loadFactor)
// 包含“子Map”的构造函数
HashMap(Map<? extends K, ? extends V> map)
我们平时用默认构造函数，可以调整一下了：）
==Java 集合系列10之 HashMap详细介绍(源码解析)和使用示例==
- 【推荐】使用 entrySet 遍历 Map 类集合 KV，而不是 keySet 方式进行遍历。
说明：keySet 其实是遍历了 2 次，一次是转为 Iterator 对象，另一次是从 hashMap 中取出 key 所对应的 value。而 entrySet 只是遍历了一次就把 key 和 value 都放到了 entry 中，效 率更高。如果是 JDK8，使用 Map.foreach 方法。
正例：values()返回的是 V 值集合，是一个 list 集合对象；keySet()返回的是 K 值集合，是 一个 Set 集合对象；entrySet()返回的是 K-V 值组合集合
理解：entrySet()遍历Map示例如下
Map<String,String> map = new HashMap<String,String>();
map.put("01", "zhangsan");
map.put("02", "lisi");
map.put("03", "wangwu");
//通过entrySet()方法将map集合中的映射关系取出（这个关系就是Map.Entry类型）
Set<Map.Entry<String, String>> entrySet = map.entrySet();
//将关系集合entrySet进行迭代，存放到迭代器中
Iterator<Map.Entry<String, String>> it2 = entrySet.iterator();
while(it2.hasNext()){
Map.Entry<String, String> me = it2.next();//获取Map.Entry关系对象me
String key2 = me.getKey();//通过关系对象获取key
String value2 = me.getValue();//通过关系对象获取value
System.out.println("key: "+key2+"-->value: "+value2);
}
详见如下链接。
==Map集合中value（）方法与keySet（）、entrySet()区别==
- 【推荐】高度注意 Map 类集合 K/V 能不能存储 null 值的情况，如下表格:
| 集合类 | Key | Value | Super | 说明 |
| Hashtable | 不允许为 null | 不允许为 null | Dictionary | 线程安全 |
| ConcurrentHashMap | 不允许为 null | 不允许为 null | AbstractMap | 锁分段技（JDK8:CAS） |
| TreeMap | 不允许为 null | 允许为 null | AbstractMap | 线程不安全 |
| HashMap | 允许为 null | 允许为 null | AbstractMap | 线程不安全 |
反例： 由于 HashMap 的干扰，很多人认为 ConcurrentHashMap 是可以置入 null 值，而事实上， 存储 null 值时会抛出 NPE(NullPointException) 异常
理解：ConcurrentHashMap支持并发操作，另外为了避免麻烦我们在往Map中存KV时还是最好判断一下是否为null，关于HashMap和ConcurrentHashMap详细用法和区别见如下链接。
```
==[Java7/8 中的 HashMap 和 ConcurrentHashMap 全解析](http://www.importnew.com/28263.html)==
12. 【参考】合理利用好集合的有序性(sort)和稳定性(order)，避免集合的无序性(unsort)和 不稳定性(unorder)带来的负面影响。
```
说明：有序性是指遍历的结果是按某种比较规则依次排列的。稳定性指集合每次遍历的元素次序是一定的。
如：ArrayList 是 order/unsort；HashMap 是 unorder/unsort；TreeSet 是 order/sort。
理解：TreeSet是在add的时候会根据Comparable实现的接口继续拧排序，add完也就拍完序了。最终实际上用的是treemap，ArryList在add的时候是不排序的，可以通过Collections.sort(staff)的方式进行排序，当然排序前你的对象必须是重写了compareTo方法。
```
13. 【参考】利用 Set 元素唯一的特性，可以快速对一个集合进行去重操作，避免使用 List 的 contains 方法进行遍历、对比、去重操作。
```
理解：这个比较好，这里查了两个范例
一、去除数组中的重复数据
/**
* 去除数组中的重复数据
*
* @param array 泛型数组
* @param clazz 类
* @param <T> 泛型
* @return 去重之后的数据
*/
public static <T> T[] removeArrayDuplicateData(T[] array, Class<T> clazz) {
if (null == array || array.length == 0) {
return null;
}
// 利用set去重
Set<T> set = new HashSet<>();
for (int i = 0; i < array.length; i++) {
set.add(array[i]);
}
// 重新转换成数组
return (T[]) set.toArray((T[]) Array.newInstance(clazz, set.size()));
}
二、去除ArrayList中的重复数据
/**
* 去除ArrayList中的重复数据
*
* @param list 泛型List
* @param <T> 泛型
* @return 去重之后的数据
*/
public static <T> List<T> removeListDuplicateData(List<T> list) {
if (null == list || list.size() == 0) {
return null;
}
// 利用set去重
Set<T> set = new HashSet<>();
for (int i = 0; i < list.size(); i++) {
set.add(list.get(i));
}
// 清空之前的List
list.clear();
// 利用List本身的addAll方法，将Set转换成List
list.addAll(set);
return list;
}
```
