java中的数据结构

常用结构

1. Collection
      List

• ArrayList 数组实现

• Vector   其实就是数组实现的synchronized 版本

public synchronized E remove(int index) {
        modCount++;
        if (index >= elementCount)
            throw new ArrayIndexOutOfBoundsException(index);
        E oldValue = elementData(index);

        int numMoved = elementCount - index - 1;
        if (numMoved > 0)
            System.arraycopy(elementData, index+1, elementData, index,
                             numMoved);
        elementData[--elementCount] = null; // Let gc do its work

        return oldValue;
    }

LinkedList 双向链表 维持头和尾  Node first;/Node last

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;
        }
    }

Set
 HashSet 其内部维护一个HashMap 使用其中key的特性保证唯一性

public HashSet(Collection<? extends E> c) {
        map = new HashMap<>(Math.max((int) (c.size()/.75f) + 1, 16));
        addAll(c);
    }

TreeSet 其内部也维护一个TreeMap

Map

 HashMap 数组+链表(+红黑树java8)
 TreeMap 红黑树 
123

Queen 队列

ArrayBlockingQueue
LinkedBlockingQueue

线程安全的结构

Collections集合工具也提供内部类SynchronizedList/SynchronizedMap 其本质是利用装饰者模式，给原方法加上synchronized 悲观锁

static class SynchronizedList<E>
        extends SynchronizedCollection<E>
        implements List<E> {
      final List<E> list;
      public void add(int index, E element) {
            synchronized (mutex) {list.add(index, element);}
        }
        public E remove(int index) {
            synchronized (mutex) {return list.remove(index);}
        }
}

1.5以后的java.util.concurrent并发包下的提供了线程安全的各种list/map，其利用的是CAS乐观锁
    put时会调用compareAndSwapObject 这是个native方法，而get不会调用

     static final <K,V> boolean casTabAt(Node<K,V>[] tab, int i,
                                        Node<K,V> c, Node<K,V> v) {
        return U.compareAndSwapObject(tab, ((long)i << ASHIFT) + ABASE, c, v);
    }

原文出处