From 79f9f24bb2594628e47fff508397766657aa0c7d Mon Sep 17 00:00:00 2001
From: Air3 <c2268320@163.com>
Date: Fri, 6 Mar 2020 19:40:52 +0800
Subject: [PATCH 1/2] =?UTF-8?q?=E7=AC=AC=E4=B8=80=E5=91=A8:1,ArrayList,Lin?=
 =?UTF-8?q?kedList,HashMap=E6=BA=90=E7=A0=81=E5=88=86=E6=9E=90.=202020-03-?=
 =?UTF-8?q?06;1?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 ...20\347\240\201\345\210\206\346\236\220.md" | 510 ++++++++++++++++++
 ...20\347\240\201\345\210\206\346\236\220.md" | 175 ++++++
 ...20\347\240\201\345\210\206\346\236\220.md" | 124 +++++
 3 files changed, 809 insertions(+)
 create mode 100644 "second/week_01/85/ArrayList \346\272\220\347\240\201\345\210\206\346\236\220.md"
 create mode 100644 "second/week_01/85/HashMap\346\272\220\347\240\201\345\210\206\346\236\220.md"
 create mode 100644 "second/week_01/85/LinkedList\346\272\220\347\240\201\345\210\206\346\236\220.md"

diff --git "a/second/week_01/85/ArrayList \346\272\220\347\240\201\345\210\206\346\236\220.md" "b/second/week_01/85/ArrayList \346\272\220\347\240\201\345\210\206\346\236\220.md"
new file mode 100644
index 0000000..7fc96d7
--- /dev/null
+++ "b/second/week_01/85/ArrayList \346\272\220\347\240\201\345\210\206\346\236\220.md"	
@@ -0,0 +1,510 @@
+#ArrayList 源码分析
+
+##总结:
+    1,底层数组,基本是数组的特性,扩容随机访问,查询快,增删慢.
+
+##代码分析：
+
+1，
+```代码注释：
+   extends AbstractList<E>  继承抽象类
+   implements List<E>       实现了集合接口
+   , RandomAccess           随机访问接口
+   , Cloneable              克隆接口
+   , java.io.Serializable   序列化接口
+```
+    public class ArrayList<E> extends AbstractList<E>
+            implements List<E>, RandomAccess, Cloneable, java.io.Serializable
+    {
+        private static final long serialVersionUID = 8683452581122892189L;
+
+2，
+```代码注释：
+    默认初始容量
+```
+    private static final int DEFAULT_CAPACITY = 10;
+
+3，
+```代码注释：
+    空数组，用来置空
+```
+    private static final Object[] EMPTY_ELEMENTDATA = {};
+
+4，
+```代码注释：
+   默认空数组，用来置空
+```
+    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
+
+5，
+```代码注释：
+  瞬态元素数组（ArrayList的本质数组）是default类型，并不是public公开的
+```
+    transient Object[] elementData; // non-private to simplify nested class access
+
+6，
+```代码注释：
+  数组大小，也就是实际存储的元素个数
+```
+    private int size;
+
+7，
+```代码注释：
+   带集合初始容量的构造方法
+   <0 抛异常
+```    
+    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);
+        }
+    }
+
+8，
+```代码注释：
+   Collection<? extends E>  集合（泛型是继承自E<E是ArrayList的泛型>)
+   
+   将集合拷贝到数组中，用的是arrays的静态方法（用的是system的本地方法）
+   
+```   
+    public ArrayList(Collection<? extends E> c) {
+        elementData = c.toArray();
+        if ((size = elementData.length) != 0) {
+            // c.toArray might (incorrectly) not return Object[] (see 6260652)
+            if (elementData.getClass() != Object[].class)
+                elementData = Arrays.copyOf(elementData, size, Object[].class);
+        } else {
+            // replace with empty array.
+            this.elementData = EMPTY_ELEMENTDATA;
+        }
+    }
+
+8，
+```代码注释：
+  将数组两边删除为空的（未存储数据的部分），缩减为size大小的容量
+```  
+    public void trimToSize() {
+    
+          ** modCount是抽象方法中的属性，修改次数（modifyCount）**
+        modCount++;
+        if (size < elementData.length) {
+            elementData = (size == 0)
+              ? EMPTY_ELEMENTDATA
+              : Arrays.copyOf(elementData, size);
+        }
+    }
+
+8，
+```代码注释：
+  确认是否有最小容量的地方
+```  
+    public void ensureCapacity(int minCapacity) {
+        int minExpand = (elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA)
+            // any size if not default element table
+            ? 0
+            // larger than default for default empty table. It's already
+            // supposed to be at default size.
+            : DEFAULT_CAPACITY;
+
+        if (minCapacity > minExpand) {
+            ensureExplicitCapacity(minCapacity);
+        }
+    }
+
+    private static int calculateCapacity(Object[] elementData, int minCapacity) {
+        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
+            return Math.max(DEFAULT_CAPACITY, minCapacity);
+        }
+        return minCapacity;
+    }
+
+    private void ensureCapacityInternal(int minCapacity) {
+        ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
+    }
+
+    private void ensureExplicitCapacity(int minCapacity) {
+        modCount++;
+
+        // overflow-conscious code
+        if (minCapacity - elementData.length > 0)
+            grow(minCapacity);
+    }
+
+8，
+```代码注释：
+  127-8=119，最大容量大小，之后会扩容
+```  
+    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
+
+8，
+```代码注释：
+扩容
+```  
+    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);
+    }
+
+    private static int hugeCapacity(int minCapacity) {
+        if (minCapacity < 0) // overflow
+            throw new OutOfMemoryError();
+        return (minCapacity > MAX_ARRAY_SIZE) ?
+            Integer.MAX_VALUE :
+            MAX_ARRAY_SIZE;
+    }
+
+
+    public int size() {
+        return size;
+    }
+
+
+    public boolean isEmpty() {
+        return size == 0;
+    }
+
+    public boolean contains(Object o) {
+        return indexOf(o) >= 0;
+    }
+
+8，
+```代码注释：
+  从前查找对象，返回索引。
+```  
+    public int indexOf(Object o) {
+        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;
+    }
+
+  8，
+  ```代码注释：
+    从后查找对象，返回索引。
+  ```  
+    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;
+    }
+
+8，
+```代码注释：
+  集合自身克隆，复制一份相同的
+```  
+    public Object clone() {
+        try {
+        **采用本地方法克隆**
+            ArrayList<?> v = (ArrayList<?>) super.clone();
+            v.elementData = Arrays.copyOf(elementData, size);
+            v.modCount = 0;
+            return v;
+        } catch (CloneNotSupportedException e) {
+            // this shouldn't happen, since we are Cloneable
+            throw new InternalError(e);
+        }
+    }
+
+8，
+```代码注释：
+  将集合转换为数组
+```  
+    public Object[] toArray() {
+        return Arrays.copyOf(elementData, size);
+    }
+
+  
+    @SuppressWarnings("unchecked")
+    public <T> T[] toArray(T[] a) {
+        if (a.length < size)
+            // Make a new array of a's runtime type, but my contents:
+            return (T[]) Arrays.copyOf(elementData, size, a.getClass());
+        System.arraycopy(elementData, 0, a, 0, size);
+        if (a.length > size)
+            a[size] = null;
+        return a;
+    }
+
+
+
+
+    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);  // Increments modCount!!
+        elementData[size++] = e;
+        return true;
+    }
+
+   
+    public void add(int index, E element) {
+        //先检查添加时是否这个索引越界
+        rangeCheckForAdd(index);
+        //加入一个元素是否需要扩容
+        ensureCapacityInternal(size + 1);  // Increments modCount!!
+        System.arraycopy(elementData, index, elementData, index + 1,
+                         size - index);
+        elementData[index] = element;
+        size++;
+    }
+
+   
+    public E remove(int index) {
+        rangeCheck(index);
+
+        modCount++;
+        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 boolean remove(Object o) {
+    
+        if (o == null) {
+            for (int index = 0; index < size; index++)
+                //null 用==判空
+                if (elementData[index] == null) {
+                    fastRemove(index);
+                    return true;
+                }
+        } else {
+            for (int index = 0; index < size; index++)
+                //对象用.equals
+                if (o.equals(elementData[index])) {
+                    fastRemove(index);
+                    return true;
+                }
+        }
+        return false;
+    }
+
+   
+    private void fastRemove(int index) {
+        //修改次数+1
+        modCount++;
+        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
+    }
+
+    
+    public void clear() {
+        modCount++;
+
+        // clear to let GC do its work
+        for (int i = 0; i < size; i++)
+            elementData[i] = null;
+
+        size = 0;
+    }
+
+   
+    public boolean addAll(Collection<? extends E> c) {
+        Object[] a = c.toArray();
+        int numNew = a.length;
+        ensureCapacityInternal(size + numNew);  // Increments modCount
+        System.arraycopy(a, 0, elementData, size, numNew);
+        size += numNew;
+        return numNew != 0;
+    }
+
+
+    public boolean addAll(int index, Collection<? extends E> c) {
+        rangeCheckForAdd(index);
+
+        Object[] a = c.toArray();
+        int numNew = a.length;
+        ensureCapacityInternal(size + numNew);  // Increments modCount
+
+        int numMoved = size - index;
+        if (numMoved > 0)
+            System.arraycopy(elementData, index, elementData, index + numNew,
+                             numMoved);
+
+        System.arraycopy(a, 0, elementData, index, numNew);
+        size += numNew;
+        return numNew != 0;
+    }
+
+   
+    protected void removeRange(int fromIndex, int toIndex) {
+        modCount++;
+        int numMoved = size - toIndex;
+        System.arraycopy(elementData, toIndex, elementData, fromIndex,
+                         numMoved);
+
+        // clear to let GC do its work
+        int newSize = size - (toIndex-fromIndex);
+        for (int i = newSize; i < size; i++) {
+            elementData[i] = null;
+        }
+        size = newSize;
+    }
+
+  
+    private void rangeCheck(int index) {
+        if (index >= size)
+            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
+    }
+
+  
+    private void rangeCheckForAdd(int index) {
+        if (index > size || index < 0)
+            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
+    }
+
+
+    private String outOfBoundsMsg(int index) {
+        return "Index: "+index+", Size: "+size;
+    }
+
+   
+    public boolean removeAll(Collection<?> c) {
+        Objects.requireNonNull(c);
+        return batchRemove(c, false);
+    }
+
+    
+    public boolean retainAll(Collection<?> c) {
+        Objects.requireNonNull(c);
+        return batchRemove(c, true);
+    }
+
+    private boolean batchRemove(Collection<?> c, boolean complement) {
+        final Object[] elementData = this.elementData;
+        int r = 0, w = 0;
+        boolean modified = false;
+        try {
+            for (; r < size; r++)
+                if (c.contains(elementData[r]) == complement)
+                    elementData[w++] = elementData[r];
+        } finally {
+            // Preserve behavioral compatibility with AbstractCollection,
+            // even if c.contains() throws.
+            if (r != size) {
+                System.arraycopy(elementData, r,
+                                 elementData, w,
+                                 size - r);
+                w += size - r;
+            }
+            if (w != size) {
+                // clear to let GC do its work
+                for (int i = w; i < size; i++)
+                    elementData[i] = null;
+                modCount += size - w;
+                size = w;
+                modified = true;
+            }
+        }
+        return modified;
+    }
+
+    //集合序列化
+    private void writeObject(java.io.ObjectOutputStream s)
+        throws java.io.IOException{
+        // Write out element count, and any hidden stuff
+        
+        //参照cas自旋锁,先存修改次数,
+        int expectedModCount = modCount;
+        //序列化属性等(不包括数组)
+        s.defaultWriteObject();
+
+        // Write out size as capacity for behavioural compatibility with clone()
+        s.writeInt(size);
+
+        // Write out all elements in the proper order.
+        for (int i=0; i<size; i++) {
+            s.writeObject(elementData[i]);
+        }
+        //判断如果序列化期间被修改,就抛异常
+        if (modCount != expectedModCount) {
+            throw new ConcurrentModificationException();
+        }
+    }
+
+    //读取序列化后的集合
+    private void readObject(java.io.ObjectInputStream s)
+        throws java.io.IOException, ClassNotFoundException {
+        elementData = EMPTY_ELEMENTDATA;
+
+        // Read in size, and any hidden stuff
+        s.defaultReadObject();
+
+        // Read in capacity
+        s.readInt(); // ignored
+
+        if (size > 0) {
+            // be like clone(), allocate array based upon size not capacity
+            int capacity = calculateCapacity(elementData, size);
+            SharedSecrets.getJavaOISAccess().checkArray(s, Object[].class, capacity);
+            ensureCapacityInternal(size);
+
+            Object[] a = elementData;
+            // Read in all elements in the proper order.
+            for (int i=0; i<size; i++) {
+                a[i] = s.readObject();
+            }
+        }
+    }
+
+    //最新的集合遍历迭代器
+    public ListIterator<E> listIterator(int index) {
+        if (index < 0 || index > size)
+            throw new IndexOutOfBoundsException("Index: "+index);
+        return new ListItr(index);
+    }
+
+
+
+
+
diff --git "a/second/week_01/85/HashMap\346\272\220\347\240\201\345\210\206\346\236\220.md" "b/second/week_01/85/HashMap\346\272\220\347\240\201\345\210\206\346\236\220.md"
new file mode 100644
index 0000000..e17f1e7
--- /dev/null
+++ "b/second/week_01/85/HashMap\346\272\220\347\240\201\345\210\206\346\236\220.md"
@@ -0,0 +1,175 @@
+# HashMap 源码分析
+
+
+##总结:
+    1,底层是散列,运用链址法存储.
+    2,链表大于8采用红黑树存储
+
+## 静态内部类node节点分析
+    static class Node<K,V> implements Map.Entry<K,V> {
+    
+        //最终类型,对象的hash值
+        final int hash;
+        
+        //唯一key(唯一id)
+        final K key;
+        
+        //对象
+        V value;
+        
+        //下一个节点
+        Node<K,V> next;
+
+        
+        //获取对象的hashcode,(本地方法,有多种比如哈希值,地址,随机数)
+        public final int hashCode() {
+            return Objects.hashCode(key) ^ Objects.hashCode(value);
+        }
+
+    }
+    
+    
+## 静态内部类TreeNode节点分析(红黑树节点)  **TODO 之后再做详细分析** 
+     static final class TreeNode<K,V> extends LinkedHashMap.Entry<K,V> {
+            //可以暂时理解为平衡二叉树
+            TreeNode<K,V> parent;  // red-black tree links
+            TreeNode<K,V> left;
+            TreeNode<K,V> right;
+            TreeNode<K,V> prev;    // needed to unlink next upon deletion
+            boolean red;
+            TreeNode(int hash, K key, V val, Node<K,V> next) {
+                super(hash, key, val, next);
+            }
+    
+          
+## 代码分析
+        //最大容量
+        static final int MAXIMUM_CAPACITY = 1 << 30;
+    
+        //装载因子(指达到总数*装载因子的数量就扩容)
+        static final float DEFAULT_LOAD_FACTOR = 0.75f;
+    
+        //大于等于8个节点数,树化
+        static final int TREEIFY_THRESHOLD = 8;
+    
+        //小于等于6链表化
+        static final int UNTREEIFY_THRESHOLD = 6;
+    
+        //最小树化容量,当达到64后进行全部树化(红黑树)
+        static final int MIN_TREEIFY_CAPACITY = 64;          
+       
+        //数组节点
+        transient Node<K,V>[] table;
+        
+        //用来遍历的set集合(K值为对象,V值为final类型的object)
+        transient Set<Map.Entry<K,V>> entrySet;
+        
+        //数据存储的数量
+        transient int size;
+        
+        //被修改的次数
+        transient int modCount;
+    
+        //阈值(指达到总数*装载因子的数量就扩容)
+        int threshold;
+    
+        //可以自主修改的装载因子(一般不需要修改,默认是0.75)
+        final float loadFactor;
+       
+        //算哈希值,二次哈希使散列更离散,哈希值与前16位相与     
+        static final int hash(Object key) {
+            int h;
+            return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
+        }
+        
+        //根据Key值找Value
+        public V get(Object key) {
+                Node<K,V> e;
+                
+                return (e = getNode(hash(key), key)) == null ? null : e.value;
+            }
+            
+        //查找节点
+        final Node<K,V> getNode(int hash, Object key) {
+                Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
+                
+                    //(n-1)&hash,得到在数组的位置为first节点
+                    /**
+                           hash值,与运算,数组长度-1,(等同于求余运算;hash%(n-1))
+                    */
+                if ((tab = table) != null && (n = tab.length) > 0 &&
+                    (first = tab[(n - 1) & hash]) != null) {
+                    if (first.hash == hash && // always check first node
+                        ((k = first.key) == key || (key != null && key.equals(k))))
+                        return first;
+                    if ((e = first.next) != null) {
+                        if (first instanceof TreeNode)
+                            return ((TreeNode<K,V>)first).getTreeNode(hash, key);
+                        do {
+                            if (e.hash == hash &&
+                                ((k = e.key) == key || (key != null && key.equals(k))))
+                                return e;
+                        } while ((e = e.next) != null);
+                    }
+                }
+                return null;
+         }
+
+
+        
+        //添加节点
+         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 {
+                    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);
+                                //binCount 计数,大于=7,就将链表=>红黑树
+                                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;
+                        }
+                    }
+                    if (e != null) { // existing mapping for key
+                        //返回旧的value
+                        V oldValue = e.value;
+                        if (!onlyIfAbsent || oldValue == null)
+                            //将新的value赋值给e
+                            e.value = value;
+                        afterNodeAccess(e);
+                        return oldValue;
+                    }
+                }
+                ++modCount;
+                
+                //查看存储的容量是否 大于 阈值
+                if (++size > threshold)
+                
+                    //重建hashmap,根据hash值重新分配
+                    resize();
+                    
+                //可重写方法;可以记录节点插入之后,要做的事.可扩展方法
+                afterNodeInsertion(evict);
+                return null;
+            }
\ No newline at end of file
diff --git "a/second/week_01/85/LinkedList\346\272\220\347\240\201\345\210\206\346\236\220.md" "b/second/week_01/85/LinkedList\346\272\220\347\240\201\345\210\206\346\236\220.md"
new file mode 100644
index 0000000..58c4033
--- /dev/null
+++ "b/second/week_01/85/LinkedList\346\272\220\347\240\201\345\210\206\346\236\220.md"
@@ -0,0 +1,124 @@
+#LinkedList 源码分析
+
+##总结:
+    1,底层是双端链表,具有查询慢,增删快的特点;
+    2,而且还是双端队列(可以与栈作比较),链式栈.
+
+##代码分析：
+
+
+```代码注释：Node节点类
+  
+```
+    //私有静态内部类(只供本类使用)
+   private static class Node<E> {
+        //形参类型的元素
+        E item;
+        //next指针
+        Node<E> next;
+        //前一个的指针
+        Node<E> prev;
+        //node节点的创建
+        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;
+
+    //第一个节点(非头结点)
+    transient Node<E> first;
+
+    //最后一个节点
+    transient Node<E> last;
+
+    /**
+     * Constructs an empty list.
+     */
+    public LinkedList() {
+    }
+
+    
+    public LinkedList(Collection<? extends E> c) {
+        this();
+        addAll(c);
+    }
+
+    //采用头插法,插入在第一个位置
+    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 boolean add(E e) {
+        linkLast(e);
+        return true;
+    }
+
+    //查看第一个节点的数据
+    public E peek() {
+        final Node<E> f = first;
+        return (f == null) ? null : f.item;
+    }
+
+ 
+
+
+   
+
+  
+
+    //双端队列的添加第一个元素
+    public boolean offerFirst(E e) {
+        addFirst(e);
+        return true;
+    }
+
+    
+
+ 
+   
+   
+    //实现了栈的push,压入元素
+    public void push(E e) {
+        addFirst(e);
+    }
+
+    //实现了栈的弹出元素
+    public E pop() {
+        return removeFirst();
+    }
+
+  
+
+ 
+    //重写迭代器方法
+    private class ListItr implements ListIterator<E> {
+        private Node<E> lastReturned;
+        private Node<E> next;
+        private int nextIndex;
+        private int expectedModCount = modCount;
+
+        ListItr(int index) {
+            // assert isPositionIndex(index);
+            next = (index == size) ? null : node(index);
+            nextIndex = index;
+        }
+
+      
\ No newline at end of file
-- 
Gitee


From 05e250d5c273d1654c547591ac6ab02416d1ae3d Mon Sep 17 00:00:00 2001
From: Air3 <c2268320@163.com>
Date: Fri, 6 Mar 2020 19:48:42 +0800
Subject: [PATCH 2/2] =?UTF-8?q?=E7=AC=AC=E4=B8=80=E5=91=A8:1,ArrayList,Lin?=
 =?UTF-8?q?kedList,HashMap=E6=BA=90=E7=A0=81=E5=88=86=E6=9E=90.=20=20=20?=
 =?UTF-8?q?=20=20=20=20=20=20=20=20=20=202020-03-06;2?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 ...rrayList \346\272\220\347\240\201\345\210\206\346\236\220.md" | 1 +
 1 file changed, 1 insertion(+)

diff --git "a/second/week_01/85/ArrayList \346\272\220\347\240\201\345\210\206\346\236\220.md" "b/second/week_01/85/ArrayList \346\272\220\347\240\201\345\210\206\346\236\220.md"
index 7fc96d7..cec3495 100644
--- "a/second/week_01/85/ArrayList \346\272\220\347\240\201\345\210\206\346\236\220.md"	
+++ "b/second/week_01/85/ArrayList \346\272\220\347\240\201\345\210\206\346\236\220.md"	
@@ -3,6 +3,7 @@
 ##总结:
     1,底层数组,基本是数组的特性,扩容随机访问,查询快,增删慢.
 
+
 ##代码分析：
 
 1，
-- 
Gitee