javase_集合框架2_List、Set、Map

private transient Object[] elementData;  //存储元素
private int size;  //数组的长度

public ArrayList(int initialCapacity) { 
    if (initialCapacity > 0) {
        this.elementData = new Object[initialCapacity];
    } else if (initialCapacity == 0) {
        this.elementData = EMPTY_ELEMENTDATA;
    } else {
        throw new IllegalArgumentException("Illegal Capacity: "+initialCapacity);
    }
}
public ArrayList() {         //可变容
    this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
public ArrayList(Collection<? extends E> c) {  //大多数集合类都有该构造方法,实现集合间的相互转换
    elementData = c.toArray();
    if ((size = elementData.length) != 0) {
        if (elementData.getClass() != Object[].class)
            elementData = Arrays.copyOf(elementData, size, Object[].class);
    } else {
        this.elementData = EMPTY_ELEMENTDATA;
    }
}

public int size() {
    return size;
}

public boolean isEmpty() {
    return size == 0;
}

public boolean contains(Object o) {    //根据是否能查找到下标来判断有无
   return indexOf(o) >= 0;
}

public int indexOf(Object o) {      //可以存null,null.equals会抛异常,所有分开写
    if (o == null) {
        for (int i = 0; i < size; i++)
            if (elementData[i]==null)
                return i;
    } else {
        for (int i = 0; i < size; i++)
            if (o.equals(elementData[i]))
                return i;
    }
    return -1;
}

public int lastIndexOf(Object o) {   //逆序查找数组
    if (o == null) {
        for (int i = size-1; i >= 0; i--)
            if (elementData[i]==null)
                return i;
    } else {
        for (int i = size-1; i >= 0; i--)
            if (o.equals(elementData[i]))
                return i;
    }
    return -1;
}

public Object[] toArray() {
    return Arrays.copyOf(elementData, size);
}

public E get(int index) {
    rangeCheck(index);    //首先检查下标是否合法
    return elementData(index);
}

public E set(int index, E element) {
    rangeCheck(index);
    E oldValue = elementData(index);
    elementData[index] = element;
    return oldValue;       //返回了老的数据
}

public boolean add(E e) {
    ensureCapacityInternal(size + 1);  //自动扩容
    elementData[size++] = e;           //在尾部添加
    return true;
}

public E remove(int index) {
    rangeCheck(index);
    E oldValue = elementData(index);
    int numMoved = size - index - 1;
    if (numMoved > 0)
        System.arraycopy(elementData, index+1, elementData, index,numMoved);
    elementData[--size] = null; // clear to let GC do its work
    return oldValue;
}

public void clear() {
    for (int i = 0; i < size; i++)
        elementData[i] = null;
    size = 0;
}

transient int size = 0;
transient Node<E> first;   //存储首节点和尾节点
transient Node<E> 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;
    }
}

Node<E> node(int index) {
    if (index < (size >> 1)) {
        Node<E> x = first;
        for (int i = 0; i < index; i++)
            x = x.next;
        return x;
    } else {
        Node<E> x = last;
        for (int i = size - 1; i > index; i--)
            x = x.prev;
        return x;
    }
}

private void linkFirst(E e) {
        final Node<E> f = first;
        final Node<E> newNode = new Node<>(null, e, f);
        first = newNode;
        if (f == null)
            last = newNode;
        else
            f.prev = newNode;
        size++;
        modCount++;
}

public int hashCode() {
    int h = hash;             //String中属性hash默认是0
    if (h == 0 && value.length > 0) {   //value是char[],String底层是char[]实现
        char val[] = value;
        for (int i = 0; i < value.length; i++) {
            h = 31 * h + val[i];
        }
        hash = h;
    }
    return h;
}

public int hashCode() {
     int hashCode = 1;
     for (E e : this)     //this是当前集合
          hashCode = 31*hashCode + (e==null ? 0 : e.hashCode());
     return hashCode;
}

transient Entry<K,V>[] table;   //哈希表,Entry类型的数组来存储元素
transient Node<K,V>[] table;   //jdk8.0中明确的指出是一个链表类型的数组

static class Entry<K,V> implements Map.Entry<K,V> {
        final K key;
        V value;
        Entry<K,V> next;
        int hash;
        Entry(int h, K k, V v, Entry<K,V> n) {
            value = v;
            next = n;
            key = k;
            hash = h;
        }
        public final K getKey() {
            return key;
        }
        public final V getValue() {
            return value;
        }
        public final V setValue(V newValue) {
            V oldValue = value;
            value = newValue;
            return oldValue;
        }
        public final boolean equals(Object o) {
            if (!(o instanceof Map.Entry))
                return false;
            Map.Entry e = (Map.Entry)o;
            Object k1 = getKey();
            Object k2 = e.getKey();
            if (k1 == k2 || (k1 != null && k1.equals(k2))) {
                Object v1 = getValue();
                Object v2 = e.getValue();
                if (v1 == v2 || (v1 != null && v1.equals(v2)))
                    return true;
            }
            return false;
        }

        public final int hashCode() {
            return (key==null   ? 0 : key.hashCode()) ^
                   (value==null ? 0 : value.hashCode());
        }
        public final String toString() {
            return getKey() + "=" + getValue();
        }

    }

 public V put(K key, V value) { 
     // 如果 key 为 null,调用 putForNullKey 方法进行处理
     if (key == null) 
         return putForNullKey(value); 
     // 根据 key 的 keyCode 计算 Hash 值
     int hash = hash(key.hashCode()); 
     // 搜索指定 hash 值在对应 table 中的索引
      int i = indexFor(hash, table.length);
     // 如果 i 索引处的 Entry 不为 null,通过循环不断遍历 e 元素的下一个元素
     for (Entry<K,V> e = table[i]; e != null; e = e.next) { 
         Object k; 
         // 如果此链表下已有元素的key与要新添加元素的key,二者equals,则替换旧元素的值为新值
         if (e.hash == hash && ((k = e.key) == key || key.equals(k))) { 
             V oldValue = e.value; 
             e.value = value; 
             e.recordAccess(this); 
             return oldValue; 
         } 
     } 
     // 如果 i 索引处的 Entry 为 null,表明此处还没有 Entry 
     modCount++; 
     // 将 key、value 添加到 i 索引处
     addEntry(hash, key, value, i); 
     return null; 
 }

void addEntry(int hash, K key, V value, int bucketIndex) { 
    // 获取指定 bucketIndex 索引处的 Entry 
    Entry<K,V> e = table[bucketIndex];      // ①
    // 将新创建的 Entry 放入 bucketIndex 索引处,并让新的 Entry 指向原来的 Entry 
    table[bucketIndex] = new Entry<K,V>(hash, key, value, e); 
    // 如果 Map 中的 key-value 对的数量超过了极限
    if (size++ >= threshold) 
        // 把 table 对象的长度扩充到 2 倍.
        resize(2 * table.length);      // ②
}

 public V get(Object key) { 
     // 如果 key 是 null,调用 getForNullKey 取出对应的 value 
     if (key == null) 
         return getForNullKey(); 
     // 根据该 key 的 hashCode 值计算它的 hash 码
     int hash = hash(key.hashCode()); 
     // 直接取出 table 数组中指定索引处的值,
     for (Entry<K,V> e = table[indexFor(hash, table.length)]; e != null;e = e.next){          // ① 
         Object k; 
         // 如果该 Entry 的 key 与被搜索 key 相同
         if (e.hash == hash && ((k = e.key) == key || key.equals(k))) 
             return e.value; 
     } 
     return null; 
 }