【LinkedList】
LinkedList使用了链表来实现List功能，而且是双向循环链表，它的Entry定义如下：
private static class Entry<E> { //保存放入list中的对象 E element; //当前节点的下一节点 Entry<E> next; //当前节点的上一节点 Entry<E> previous; //新构造的entry，next节点为头节点，previous为尾节点， //新插入的节点在尾节点之后 Entry(E element, Entry<E> next, Entry<E> previous) { this.element = element; this.next = next; this.previous = previous; } }
插入一个节点时：
private Entry<E> addBefore(E o, Entry<E> e) { Entry<E> newEntry = new Entry<E>(o, e, e.previous); //定义节点在链表中的链接方式，插入一个新节点 newEntry.previous.next = newEntry; newEntry.next.previous = newEntry; size++; modCount++; return newEntry; }
可见，只需要移动指针即可，当按照节点索引删除时，需要将节点先查询到：
private Entry<E> entry(int index) { if (index < 0 || index >= size) throw new IndexOutOfBoundsException("Index: "+index+ ", Size: "+size); //定位头节点 Entry<E> e = header; //如果要寻找的索引小于链表长度的一半，则从头开始找，否则从尾部开始找 if (index < (size >> 1)) { for (int i = 0; i <= index; i++) e = e.next; } else { for (int i = size; i > index; i--) e = e.previous; } return e; }
可见，此时变成了顺序查找，不过此处小小的优化了一下，如果按照对象来删除，那就成了全表扫描了，呵呵：
public boolean remove(Object o) { if (o==null) { for (Entry<E> e = header.next; e != header; e = e.next) { if (e.element==null) { remove(e); return true; } } } else { for (Entry<E> e = header.next; e != header; e = e.next) { if (o.equals(e.element)) { remove(e); return true; } } } return false; }
【ArrayList】
使用数组来实现，相对来说，通过数组下标访问效率很高，但是通过对象访问效率仍然不高，大量的使用了System.arrayCopy方法来拷贝数组。
【Vector】
和arraylis比较相似，都是使用数组来实现，不过二者空间扩展的方式不同，arraylist默认为50%+1,vector为一倍，而且操作方法都是线程安全的，不过效率要慢。
【HashMap】
HashMap的原理比以上都要复杂，可以说HashMap是集成了链表的快速增删和数组的快速随机读取功能于一身，仔细看了下HashMap的源码，其结构如下：
其内部的Entry定义：
static class Entry<K,V> implements Map.Entry<K,V> { final K key; V value; final int hash; //定义了一个指针，指向该节点的下一个节点 Entry<K,V> next; /** * Create new entry. */ Entry(int h, K k, V v, Entry<K,V> n) { value = v; next = n; key = k; hash = h; } public K getKey() { return HashMap.<K>unmaskNull(key); } public V getValue() { return value; } public V setValue(V newValue) { V oldValue = value; value = newValue; return oldValue; }
可见，entry内部定义了一个指针（引用），该引用就是指向其他节点，这不就是一个单链表吗？下面看一下往map中增加对象时的方法：
public V put(K key, V value) { if (key == null) return putForNullKey(value); //首先获取该key的hash值 int hash = hash(key.hashCode()); //通过该hash值结合hash表的长度，计算出该key应该落在数组的哪个位置 int i = indexFor(hash, table.length); //找到数组位置后，遍历该数组的entry节点，通过头节点的指针遍历所有的entry，找到目标节点 for (Entry<K,V> e = table[i]; e != null; e = e.next) { Object k; if (e.hash == hash && ((k = e.key) == key || key.equals(k))) { V oldValue = e.value; e.value = value; e.recordAccess(this); return oldValue; } } modCount++; addEntry(hash, key, value, i); return null; }
可见，hashMap的结构有点像查字典，如果想要查一个字，首先根据字的拼音(hash值)找到字所在的大体位置（数组），找到大体位置，然后一个个的去对比找到确定的位置。如这张图，左边就是数组，数组中都存放着一个entry头节点，而每个头节点后面都串联着很多entry，当要查找时，首先计算查找对象的hash值，确定该对象在哪个数组中，找到数组位置（随机访问）后，拿到entry头节点，然后线性遍历该链表，找到对应的具体节点，可见，hashmap解决冲突的办法就是链接地址法，将所有hash值相同的对象链接起来。
【linkedHashMap】
继承自HashMap,大部分功能都由HashMap来实现，不同的是其中的Entry，使用一个双向链表来维护节点插入的顺序，而且使用LRU算法来维护链表中节点的顺序，对于经常使用的节点，将其拿到链表的最前面。
private static class Entry<K,V> extends HashMap.Entry<K,V> { // These fields comprise the doubly linked list used for iteration. Entry<K,V> before, after; Entry(int hash, K key, V value, HashMap.Entry<K,V> next) { super(hash, key, value, next); } /** * Remove this entry from the linked list. */ private void remove() { before.after = after; after.before = before; }
LinkedHashMap.Entry继承自HashMap.Entry，可见，除了自身的before和after指针之外，还继承了一个next指针，其中，这三个指针的用处分别为：
before和after维护着节点的插入顺序，这就像一根线，将节点按照插入顺序穿起来，而存在一个header引用，表示头节点，而next指针仍然起着链接hash冲突的节点。当执行hash查找时，仍然使用先table再链表的形式，而当迭代时，会按照before和after指针串联的方式进行迭代，
其中有before和after指针，指针的连接标示着节点的插入顺序，当迭代的时候按照这个顺序来迭代。
我画了个图简单描述如下：
图中虚线部分就是before和after指针，实线部分就是next指针，而黑体箭头就是header节点，代表最先插入的节点或者最近用到的节点。
【TreeMap】
treemap是排序的map，背后使用了平衡二叉树来实现，具体的是红黑树，看它的entry定义：
static class Entry<K,V> implements Map.Entry<K,V> { K key; V value; Entry<K,V> left = null; Entry<K,V> right = null; Entry<K,V> parent; boolean color = BLACK; /** * Make a new cell with given key, value, and parent, and with * <tt>null</tt> child links, and BLACK color. */ Entry(K key, V value, Entry<K,V> parent) { this.key = key; this.value = value; this.parent = parent; }
可见，entry就是树的一个节点，其中定义了一个color属性，代表红黑。由于使用红黑树来实现，当插入新节点或者删除节点时，需要重新调整树，使其满足红黑规则：
public V put(K key, V value) { //首先找到root节点 Entry<K,V> t = root; //如果root为空，则新建一个节点 if (t == null) { incrementSize(); root = new Entry<K,V>(key, value, null); return null; } //依次根据root往下遍历 while (true) { //此处相当于二分查找，将当前节点和目标节点对比，如果小就往右走，否则往左走 int cmp = compare(key, t.key); if (cmp == 0) { //如果想等，直接覆盖替换 return t.setValue(value); } else if (cmp < 0) { //如果小则往左走 //如果左节点不为空，那么直接再次左移 if (t.left != null) { t = t.left; } else { //否则就增加空间，然后新建节点，将该节点插入到空的节点处 incrementSize(); t.left = new Entry<K,V>(key, value, t); //插入了新节点，打破了平衡，所以需要重新调整树使其满足红黑规则 fixAfterInsertion(t.left); return null; } } else { // cmp > 0 if (t.right != null) { t = t.right; } else { incrementSize(); t.right = new Entry<K,V>(key, value, t); fixAfterInsertion(t.right); return null; } } } }
由于使用了平衡查找树，所以查找节点时效率是很高的，就是一个二分查找树：
private Entry<K,V> getEntry(Object key) { Entry<K,V> p = root; K k = (K) key; while (p != null) { int cmp = compare(k, p.key); if (cmp == 0) return p; else if (cmp < 0) p = p.left; else p = p.right; } return null; }
【HashTable】
和HashMap差不多，不过其方法是同步的，ConcurrentHashMap和它比较类似，只是后者的get方法不需要同步，所以效率想对更高效。
【HashSet】
本质上由hashMap来实现，只是对象不能重复：
public boolean add(E o) { return map.put(o, PRESENT)==null; }
【TreeSet】
本质上默认由TreeMap来实现，默认构造函数将使用TreeMap来实现。
public TreeSet() { this(new TreeMap<E,Object>()); }
TreeSet也是排序的，可以指定排序器，如果不指定则使用默认的自然序列排序器来排序。