Iterator<String> it = list.iterator();
	while(it.hasNext()){
		String str = it.next();
		System.out.println(str);
	}

	Collection<String> coll = new ArrayList<>();
	for(String s : coll){
		System.out.println(s);
	}

	coll.forEach(s -> System.out.println(s));

	List<String> L = new ArrayList<>();  
	L.add("aaa");  
	L.add("bbb");  
	L.add("ccc");  
	  
	L.add(1,"ddd");//在指定位置插入元素，原位置以后的元素依次往后移
	//aaa ddd bbb ccc
	
	String remove = L.remove(0);//aaa
	boolean remove = L.remove("aaa");//true

public boolean add(E e) {  
    modCount++;  
    add(e, elementData, size);
    return true;  
}

private void add(E e, Object[] elementData, int s) {  
    if (s == elementData.length)  
        elementData = grow();  
    elementData[s] = e;  
    size = s + 1;  
}

private Object[] grow() {  
    return grow(size + 1);  
}

private Object[] grow(int minCapacity) {  
    int oldCapacity = elementData.length;  
    if (oldCapacity > 0 || elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        int newCapacity = ArraysSupport.newLength(oldCapacity,  
	            minCapacity - oldCapacity, /* minimum growth */  
		        oldCapacity >> 1        /*默认新增容量*/);  
        return elementData = Arrays.copyOf(elementData, newCapacity);
    } else {  
        return elementData = new Object[Math.max(DEFAULT_CAPACITY, minCapacity)];  
    }  
}

public static int newLength(int oldLength, int minGrowth, int prefGrowth) {  
    // 由于内嵌原因未勾选前提条件
    // assert oldLength >= 0    // assert minGrowth > 0  
    int prefLength = oldLength + Math.max(minGrowth, prefGrowth); // 可能会溢出来 
    if (0 < prefLength && prefLength <= SOFT_MAX_ARRAY_LENGTH) {  
        return prefLength;  
    } else {  
	        // 用另一个方法冷处理代码
        return hugeLength(oldLength, minGrowth);  
    }  
}

	System.out.println("abc".hashCode());  //96354
	System.out.println("acD".hashCode());  //96354

@Override  
public int compareTo(Student o) {  
    return this.getAge()-o.getAge();  
}
	this:表示当前要添加的元素
	o   :表示已经在红黑树存在的元素
返回值：
	负数：认为要添加的元素是小的，存左边
	正数：认为要添加的元素是大的，存右边
	0：要添加的元素已存在，舍弃

public class MyArrayList<E>{  
    Object[] obj = new Object[10];  
    int size;  
    public boolean add(E e){  
        obj[size++] = e;  
        return true;  
    }  
    public E  get(int index){  
        return (E)obj[index]; //存入ArrayList的数据都会变成Object
    }  
    @Override  
    public String toString(){  
        return Arrays.toString(obj);  
    }  
}
	//此处的E可以理解为变量，但是不是用来记录数据的，是用来记录数据类型的,一般用：K、T、V、E

public <T> boid show(T t){
	|此处的E可以理解为变量，但是不是用来记录数据的，是用来记录数据类型的,一般用：K、T、V、E|
}

public class ListUtil{  
    private ListUtil() {}  
    /*  
    *   参数一：集合  
    *   参数二：要添加的元素  
    * */  
    public static<E> void addAll(ArrayList<E> list,E...e){  
        for (E element : e) {  
            list.add(element);  
        }  
    }  
}

public class MyArrayList implements List<String> {
}

public class MyArrayList<E> implements List<E> {
}

	通配符
	<? extends E> 表示可以传递E或者E所有的子类类型
	
	<? super E> 表示可以传递E或者E所有的父类类型

	Set<String> keys = map.keySet();
	
	//遍历单列集合，得到每一个键
	for (String key : keys) {  
    System.out.println(map.get(key));  
	}
	
	//迭代器遍历
	Iterator it =  keys.iterator();  
	while(it.hasNext()){  
	    String key = (String)it.next();  
	    System.out.println(key+":"+map.get(key));  
	}
	
	//lambda表达式遍历
	keys.forEach(key -> System.out.println(map.get(key)));

	//Set存储键值对
	Set<Map.Entry<String, String>> es = map.entrySet();
	//Entry是Map的内部接口
	
	//遍历每一个键值对对象
	for (Map.Entry<String, String> e : es) {  
	
	    String  key = e.getKey();  
	    String value = e.getValue();  
	    
	    System.out.println(key + ":" + value);  
	}
	
	//遍历迭代器
	Iterator <Map.Entry<String,String>> it = es.iterator();  
	while(it.hasNext()){  
	    Map.Entry<String,String> entry = it.next();  
	    String key = entry.getKey();  
	    String value = entry.getValue();  
	    System.out.println(key+":"+value);  
	}
	
	//lambda表达式
	es.forEach(e -> System.out.println(e.getKey()+":"+e.getValue()));

	map.forEach(new BiConsumer<String, String>() {  
	    @Override  
	    public void accept(String k, String v) {  
	        System.out.println(k+ ":" +v);  
	    }  
	});
	-----------------------
	map.forEack((key,value) -> System.out.println(k+":"+v));
	

	默认的hashCode和equals方法
	@Override  
	public boolean equals(Object obj) {  
	    if(this == obj) return true;  
	    if(obj == null || getClass() != obj.getClass() ) return false;  
	    Student student = (Student)obj;  
	    return  name.equals(student.name) && age == student.age;  
	}  
	
	@Override  
	public int hashCode() {  
	    return Objects.hash(name,age);  
	}

		TreeMap<Integer,String> tm = new TreeMap<>(new Comparator<Integer>() {  
		    @Override  
		    public int compare(Integer o1, Integer o2) {  
		        //o1 : 当前要添加的元素  
		        //o2 : 当前要添加的元素        
		        //升序
				return o1 - o2;
		    }  
		});

1.1链表中的键值对对象
	包含：
			int hash;
			final K key;
			V value;
			Nodfe<K,V> next;
1.2红黑树中的键值对对象
	包含：
			int hash;
			final K key;
			V value;
			Node<K,V> right;
			boolean red;
2.添加元素
	HashMap<String,Integer> hm = new HashMap<>();
	hm.put("aaa",111);
	hm.put("bbb",222);
添加元素的时候至少考虑三种情况
2.1 数组位置为null
2.2 数组位置不为null，键重复，元素覆盖
2.3 数组位置不为null，键不重复，挂在下面形成链表或者红黑树

//参数一：键
//参数二：值
//返回值：被覆盖元素的值，如果没有覆盖，返回value
public V put(K key, V value) {  
	
	//参数一：
	return putVal(hash(key), key, value, false, true);  
}  
//利用键计算出对应的哈希值，再把哈希值进行一些处理
static final int hash(Object key) {  
    int h;  
    return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);  
}

//参数一：键的哈希值
//参数二：键
//参数三：值
//参数四：如果键重复了是否保留 
//       true->表示老元素的值保留，不会覆盖 
//       false->表示老欧元素的值不会保留，会进行覆盖
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,boolean evict) {  
	Node<K,V>[] tab; //定义一个局部变量，用来记录哈希表数组的地址值，用于优化（方法在栈里，变量在堆里，直接在栈里找地址值） null
	Node<K,V> p; //临时第三方变量，记录键值对对象的地址值
	int n, i;  //当前数组的的长度与索引
	
	//将哈希表中数组的地址值赋值给局部变量tab
	//将数组长度赋值给n
	
	if ((tab = table) == null || (n = tab.length) == 0)  //true
		//1.如果当前是第一次添加数据，底层会创建一个默认长度为16，加载因子为0.75的数组
		//2.如果不是第一次添加数据，会看数组中的元素是否达到了扩容条件
		//如果没有达到扩容条件 -> 无操作
		//如果达到了 -> 底层会把数组扩容为原先的 两倍 ，并把数据全部转移到新的哈希表中
		n = (tab = resize()).length;  
	
	//拿着数组的长度跟键的哈希值进行计算得到 -> 在数组中应存入的位置
	//获取数组中对应元素的数据（第一次为null）	
	if ((p = tab[i = (n - 1) & hash]) == null)
		添加第一个元素  
		//底层会创建一个键值对对象，直接放到数组当中
		tab[i] = newNode(hash, key, value, null);  
	else {  
		添加其他元素
		Node<K,V> e; 
		K k;   
		
		//p.hash:数组中键值对的哈希值
		//hash:当前要添加键值对的哈希值
		//如果键不一样，此时返回false
		if (p.hash == hash && 
			((k = p.key) == key || (key != null && key.equals(k)))) 
			e = p;  
		else if (p instanceof TreeNode) 
			//判断数组中获取出来的键值对是不是红黑树的节点
			//如果是，则调用putTreeVal，把当前的节点按照红黑树的规则添加到树当中
			e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);  
		else {  
			//如果数组中获取出来的键值对不是红黑树的节点
			//表示此时下面挂的是链表 
			for (int binCount = 0; ; ++binCount) {  
				if ((e = p.next) == null) { //下一个元素为null
					//此时就会创建一个新的节点，挂在下面，形成链表
					p.next = newNode(hash, key, value, null);  
					//判断当前链表长度是否超过8，如果超过，会调用treeifyBin
					//treeifyBin方法的底层还会继续判断，判断数组的长度是否大于等于64
					//如果同时满足这两个条件，就会把这个链表转成红黑树
					if (binCount >= TREEIFY_THRESHOLD - 1) //7，插入后长度为8
						treeifyBin(tab, hash);  
					break;  
				}  
				if (e.hash == hash &&  
					((k = e.key) == key || (key != null && key.equals(k)))) 
					break;  
				p = e;  
			}  
		}  
		//下一个节点不为空
		//如果e为null，表示当前不需要覆盖任何元素
		if (e != null) { 
			V oldValue = e.value;  //保存旧值
			//是否保留
			if (!onlyIfAbsent || oldValue == null) 
				//当前要添加的值
				e.value = value;  //覆盖值
			afterNodeAccess(e);  //后置处理
			return oldValue; //都返回旧值
		}   
	}  
	
	
	/*与并发修改异常有关，暂时忽略*/++modCount;  
	//threshold:记录数组的长度*0.75，哈希表的扩容时机
	//
	if (++size > threshold)  
	//扩容
		resize();  
	
	/*与LinkedHashMap有关，暂时忽略*/afterNodeInsertion(evict);
	
	return null;  //表示当前没有覆盖任何元素，返回null
}

1.hash不等 -> 绝对不是同一个Key
2.hash相等 -> 可能是同一个（冲突了），继续比较 == 或 equals
3.equals相等 -> 确定是同一个元素，执行覆盖
	因为冲突不可避免，所以 HashMap 才需要用 equals() 再次确认身份，并用链表/红黑树来安置多出来的“鸽子”。
	
扩展：为什么 `HashMap` 里的 `TREEIFY_THRESHOLD`（树化阈值）定为 8？
	根据泊松分布，在哈希函数设计合理的情况下，同一个桶位冲突达到 8 个的概率只有千万分之6

	Comparable<? super K> k = (Comparable<? super K>) key;
	//将键Key强转为Comparable接口类型
	//若无外部比较器，Key 必须实现Comparable接口，
	//否则在put时会报ClassCastException（强转失败）

	addEntry(key, value, parent, cmp < 0);
	//true:左
	//false:右