List a = new ArrayList();
    List<String> b;
    List<Integer> c = a;    运行错误
 // List<Integer> d = b;  编译错误 

private void ensureCapacityInternal(int minCapacity) {
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
    }

    ensureExplicitCapacity(minCapacity);
}

private void ensureExplicitCapacity(int minCapacity) {
    modCount++;

    // overflow-conscious code
    if (minCapacity - elementData.length > 0)
        grow(minCapacity);
}

private void grow(int minCapacity) {
    // overflow-conscious code
    int oldCapacity = elementData.length;
    int newCapacity = oldCapacity + (oldCapacity >> 1);
    if (newCapacity - minCapacity < 0)
        newCapacity = minCapacity;
    if (newCapacity - MAX_ARRAY_SIZE > 0)
        newCapacity = hugeCapacity(minCapacity);
    // minCapacity is usually close to size, so this is a win:
    elementData = Arrays.copyOf(elementData, newCapacity);
}

 /**
 * Default initial capacity.
 */
private static final int DEFAULT_CAPACITY = 10;

private static class Node<E> {
    E item;
    Node<E> next;
    Node<E> prev;

    Node(Node<E> prev, E element, Node<E> next) {
        this.item = element;
        this.next = next;
        this.prev = prev;
    }
}

    public class LinkedList<E>
    extends AbstractSequentialList<E>
    implements List<E>, Deque<E>, Cloneable, java.io.Serializable {
    transient int size = 0;

    /**
     * Pointer to first node.
     */
    transient Node<E> first;

    /**
     * Pointer to last node.
     */
    transient Node<E> last;

    /*
    void dataStructureInvariants() {
        assert (size == 0)
            ? (first == null && last == null)
            : (first.prev == null && last.next == null);
    }
    */

    /**
     * Constructs an empty list.
     */
    public LinkedList() {
    }

push
pop
peek

add
poll
peek	

    List<String> list = new ArrayList<>();
    List<String> list2 = new LinkedList<>();

    for (int i = 0; i < 10; i++) {
        list.add(String.valueOf(i));
        list2.add(String.valueOf(i));
    }
    for (String item : list) {
        list.remove(item);
    }

  	for(int i = 0; i < 10; ++i) {
            list.add(String.valueOf(i));
            list2.add(String.valueOf(i));
        }

        Iterator var9 = list.iterator();
        String item;
        while(var9.hasNext()) {
            item = (String)var9.next();
            list.remove(item);
        }

    Iterator<String> iterator = list.iterator();
    while(iterator.hasNext()) {
        iterator.next();
        iterator.remove();
    }

 private Itr() {
        this.expectedModCount = AbstractList.this.modCount;
    } 设置  this.expectedModCount = AbstractList.this.modCount，迭代器模式下，如果使用list的remove，会导致  this.expectedModCount = AbstractList.this.modCount;不同步，这样在第二次执行next函数时候

    public E next() {
        this.checkForComodification();
 		...

    final void checkForComodification() {
        if (ArrayList.this.modCount != this.expectedModCount) {
            throw new ConcurrentModificationException();
        }
    }

    int size = strList.size();
    for(int i=0;i<size;i++){
        String tmp = strList.get(i);
        if(i==0){
            strList.add(3,"newStr");
            size++;
        }
  }

/**
 * The number of times this list has been <i>structurally modified</i>.
 * Structural modifications are those that change the size of the
 * list, or otherwise perturb it in such a fashion that iterations in
 * progress may yield incorrect results.
 *
 * <p>This field is used by the iterator and list iterator implementation
 * returned by the {@code iterator} and {@code listIterator} methods.
 * If the value of this field changes unexpectedly, the iterator (or list
 * iterator) will throw a {@code ConcurrentModificationException} in
 * response to the {@code next}, {@code remove}, {@code previous},
 * {@code set} or {@code add} operations.  This provides
 * <i>fail-fast</i> behavior, rather than non-deterministic behavior in
 * the face of concurrent modification during iteration.
 *
 * <p><b>Use of this field by subclasses is optional.</b> If a subclass
 * wishes to provide fail-fast iterators (and list iterators), then it
 * merely has to increment this field in its {@code add(int, E)} and
 * {@code remove(int)} methods (and any other methods that it overrides
 * that result in structural modifications to the list).  A single call to
 * {@code add(int, E)} or {@code remove(int)} must add no more than
 * one to this field, or the iterators (and list iterators) will throw
 * bogus {@code ConcurrentModificationExceptions}.  If an implementation
 * does not wish to provide fail-fast iterators, this field may be
 * ignored.
 */
protected transient int modCount = 0;

	publicintsize(file){
		intsize=0
		if(fileisdir)
			for(itmeindir)
				size+=size(item)
		elsesize=file.size;	
		returnsize
	}

insert(r,n)
	if(n.v==r.v)returnr;
	if(n.v<r.v)	r.left=insert(r.l,n)returnr;
	else		r.right=insert(r.l,n)returnr;

remove(r,n)
	if(n.v>r.v)if(r.left==null)returnr;r.left=remove(r.left,n)returnr;
	if(n.v<r.v)if(r.right==null)returnr;r.right=remove(r.right,n)returnr;
	//相等
	if(r.left==null)returnr.right;
	if(r.right==null)returnr.left;
	//找右侧最小，删除掉
	p=findMin(r.right);	remove(r.right,p)	p.right=r.right;p.left=r.left;returnp;
	
	
findMin(r)
	n=r;
while(n.left!=null){
	n=n.left
}	
returnn

	height(n)  
		
		return n==null ? -1 : n.height 

	insert(r,n)
	
		if(r==null)  n.height=0; return n;
		if(n<r.v)     r.left = insert(r.left,n) 
              if(n>r.v) 	    r.right=  insert(r.right,n)
           	<!--直接调整，看看是不是需要-->
	      return balance(r ); //调整后，节点可能变
	
	调整最多两次
	
	 balance(r){
	 	ret 
	 	heightL =high(r.left)
	 	heightR =high(r.right)
	 	if( heightL-heightR ==0 || heightL-heightR==1 || heightL-heightR==-1 ) return r ;
	      if( heightL-heightR ==2)   
	      		if(high(r.left.left)>high(r.left.right))  
	      			 ret = singleRotateWithLeftChild( r ) 
	      		else 
	      			 ret = doubleRotateWithLeftChild( r ) 
	 	if( heightL-heightR ==-2)   
	 		 if(high(r.right.left)>high(r.right.right))  
	      			 ret = doubleRotateWithRightChild
	 		else
	 			  ret = singleRotateWithRightChild( r ) 
	 			 
            ret.height = Math.max(height(ret.right) ,height(ret.left)) +1 
			
			return ret;
	 }
	
	 singleRotateWithLeftChild( r ) 
	 	
	 	p= r.left; 
	 	r.left = p.right;
	 	p.right = r;   r.height = Math.max(r.left ,r.right) +1 
	 	p.height = Math.max(r, p.left) +1 
	 	return p
	 
	高度获取:

	high(r){
		
		if(r==null)return0
		returnMath.max(high(r.left),high(r.right))+1
	}

	 remove(r,n)
	 
	 	if(n.v<r.v)  r.left = remove(r.left,n) ret =r;
	 	else if(n.v<r.v) r.right = remove(r.right,n)  ret =r;
	 	else if(n.left==null) return n.right
	 	else if(n.right ==null) return n.left;
	 	<!--完成值的替换，不用替换节点 也行-->
	 	<!--else { p = findMin(n.right)  p.left = n.left p.right=remove(n.right,p) ,ret = p}-->
	 	else { p = findMin(n.right)  ret = n n.v =p.v  ret.right =remove(n.right,p.v)}
	 	balance (ret )
		return ret;

static final int hash(Object key) {
    int h;
    return key == null ? 0 : (h = key.hashCode()) ^ h >>> 16;
}

  newCap = 16; //默认初始容量
    newThr = 12;//默认初始阈值  

	感觉是经验值，太大，后期冲突多，太小，浪费空间，效率低。

                   Node<K, V> loHead = null;
                        Node<K, V> loTail = null;
                        Node<K, V> hiHead = null;
                        Node<K, V> hiTail = null;

                        Node next;
                        do {
                            next = e.next;
                            <!--最高位，10000取与-->
                            if ((e.hash & oldCap) == 0) {
                                if (loTail == null) {
                                    loHead = e;
                                } else {
                                    loTail.next = e;
                                }

                                loTail = e;
                            } else {
                                if (hiTail == null) {
                                    hiHead = e;
                                } else {
                                    hiTail.next = e;
                                }

                                hiTail = e;
                            }

                            e = next;
                        } while(next != null);

                        if (loTail != null) {
                            loTail.next = null;
                            newTab[j] = loHead;
                        }

                        if (hiTail != null) {
                            hiTail.next = null;
                            newTab[j + oldCap] = hiHead;
                        }

final void split(HashMap<K, V> map, Node<K, V>[] tab, int index, int bit) {
            TreeNode<K, V> loHead = null;
            TreeNode<K, V> loTail = null;
            TreeNode<K, V> hiHead = null;
            TreeNode<K, V> hiTail = null;
            int lc = 0;
            int hc = 0;
	
	<!--现决定table index 高低划分-->
            TreeNode next;
            for(TreeNode<K, V> e = this; e != null; e = next) {
                next = (TreeNode)e.next;
                e.next = null;
                if ((e.hash & bit) == 0) {
                    if ((e.prev = loTail) == null) {
                        loHead = e;
                    } else {
                        loTail.next = e;
                    }

                    loTail = e;
                    ++lc;
                } else {
                    if ((e.prev = hiTail) == null) {
                        hiHead = e;
                    } else {
                        hiTail.next = e;
                    }

                    hiTail = e;
                    ++hc;
                }
            }
		<!--为低链表构建 非树 或者红黑树-->
            if (loHead != null) {
                if (lc <= 6) {
                    tab[index] = loHead.untreeify(map);
                } else {
                    tab[index] = loHead;
                    if (hiHead != null) {
                        loHead.treeify(tab);
                    }
                }
            }
	 <!--为高链表构建 非树 或者红黑树-->
            if (hiHead != null) {
                if (hc <= 6) {
                    tab[index + bit] = hiHead.untreeify(map);
                } else {
                    tab[index + bit] = hiHead;
                    if (loHead != null) {
                        hiHead.treeify(tab);
                    }
                }
            } }	

public BinaryHeap{
	
	public BinaryHeap(int capacity)	
	public BinaryHeap(AnyType[] items)  
	
	public void insert(AnyType ×) 
	
	public AnyType findMin() 
	
	public AnyType deleteMin()
	
	public boolean isEmpty) 
	
	public void makeEmpty() 
	
}

	init
		for(i to length)
			fa[i] = i;	
	
	find(x){ //找到家族
		while( fa[x]!=x){
			x= fa[x]
		 }
		 return x;
         }
         
	union(x, y ){
	 	 fa[find(x)] = find(y);
	  }

 int find(int x)//找根节点。找节点的时候压缩
	{
<!--压缩-->
    return x == fa[x] ? x : (fa[x] = find(fa[x]));
}

void t o p s o r t () throws CycleFoundException
{
	f o r (int counter = 0; counter < NUMVERTICES; counter++ )
	
	Vertex v = findNewVertex0fIndegreeZero ();
	
	 if( v == null )
			 throw new CycleFoundException( ); 
	
	 v.topNum = counter;
	
	for each Vertex w adjacent to v
        	w. indegree--;
}

void topsort() throws CycleFoundException {
    Queue<Vertex> q = new Queue<Vertex>();
    int counter = 0;
    
    for each Vertex v
        if (v.indegree == 0)
            q.enqueue(v);
    
    while (!q.isEmpty()) {
        Vertex v = q.dequeue();
        v.topNum = ++counter; // Assign next number
        
        for each Vertex w adjacent to v
            if (--w.indegree == 0)
                q.enqueue(w);
        
        if (counter != NUM_VERTICES)
            throw new CycleFoundException();
    }
}

 void unweighted( Vertexs){ 
 <!--不加权-->分层，谁先走到谁是赢家
	for each Vertex v
		v.d1st = INFINITY;
		 v.known = false;
	s.dist = 0;
for( int currDist = 0; currDist <NUM_VERTICES; currDist++ )
	for each Vertex v
		if( !v.known && v.dist == currDist)
		{
			v.known = true;
			for each Vertex w adjacent to v
				if( w.dist == INFINITY)
					w.dist = currDist + 1; w.path = v;
	}