集合类源码

   /**
     * Constructs an empty list with an initial capacity of ten.
     */
    public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }

    /**
     * Appends the specified element to the end of this list.
     *
     * @param e element to be appended to this list
     * @return <tt>true</tt> (as specified by {@link Collection#add})
     */
    public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }

LinkedList:
LinkedList list = new LinkedList(); 内部声明了Node类型的first和last属性，默认值为null。双向链表。

    void linkLast(E e) {
        final Node<E> l = last;
        final Node<E> newNode = new Node<>(l, e, null);
        last = newNode;
        if (l == null)
            first = newNode;
        else
            l.next = newNode;
        size++;
        modCount++;
    }

Map:

hashMap put:JDK7

首先，调用key1所在类的hashcode计算key1的哈希值，此哈希值再经过某种算法计算之后，得到在entry数组中的存放位置。
如果此位置上的数据为空，那么key1-value1添加成功。–情况1
如果此位置上的数据不为空，（意味着此位置上存在一个或者多个的数据（以链表形式存在）），则比较key1和已经存在的一个或者多个数据的hash值：
如果key1的哈希值和已经存在的数据的hash值都不相同，此时key1-value1添加成功。–情况2
如果key1的hash值和已经存在的某一个数据的哈希值相同，继续比较：调用key1所在类的equals（）方法，比较：
如果equals（）返回false：此时key1-value1添加成功。–情况3
如果equals()返回为true：key一样，使用value1替换相同key的value值。

关于情况2和情况3：此时key1-value1和原来的数据以链表的方式存储.在不断的添加过程中，会涉及到扩容问题。默认的扩容方式：扩容为原来容量的两倍，并把原有的数据赋值过来。

JDK8相较于JDK7在底层实现方面的不同：

1.new hashmap：底层没有创建一个长度为16的数组
2.JDK8底层的数组是：Node[]而非entry[]
3.put首次调用put（）方法时，底层创建长度为16的数组。
4.JDK7底层结构只有数组+链表，JDK8中的底层结构：数组+链表+红黑树。当数组的某一个索引位置上的元素以链表形式存在的数据个数 > 8 且当前数组的长度超过64，此时此索引位置上的所有数组改为使用红黑树存储。

JDK7hashmap底层源码

JDK8hashmap底层源码

    final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        Node<K,V>[] tab; Node<K,V> p; int n, i;
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;
        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);
        else {
        // e 相当于一个临时变量temp
            Node<K,V> e; K k;
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                e = p;
            else if (p instanceof TreeNode)
                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
            else {
                for (int binCount = 0; ; ++binCount) {
                    if ((e = p.next) == null) {
                        p.next = newNode(hash, key, value, null);
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                            treeifyBin(tab, hash);
                        break;
                    }
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        break;
                    p = e;
                }
            }
            //e相当于temp，用于替换操作
            if (e != null) { // existing mapping for key
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                afterNodeAccess(e);
                return oldValue;
            }
        }
        ++modCount;
        if (++size > threshold)
            resize();
        afterNodeInsertion(evict);
        return null;
    }