Merge branch 'master' of http://git.semsx.com/zhangxiaoyu/zxy_mark

张晓宇日记/21-12月学习日志.md

@@ -51,4 +51,16 @@ public static void sortMaoPao(int[] ints, Comparator comparator) {
                 System.out.println(book);
             }
         }
-    ```
+    ```
+* 12-20 ArrayList注意事项，（可以add null，多个重复，多线程下ArrayList不安全建议使用Vector）、ArrayList 扩容机制，每次扩容为elementData的1.5倍
+```java
+    /**
+        ArrayList 本质操作的是 elementData
+        transient 表示的是短暂的瞬时的表示该属性不会被序列化
+    **/
+    transient Object[] elementData
+```
+* 12-21 ArrayList源码分析 无参构造器创建使用ArrayList
+* 12-22 ArrayList源码分析，有参构造器（传入数值大小以及一个集合）、Vector源码分析 对比与ArrayList 的不同之处
+* 12-23 LinkedList双向链表模拟 自己建了一个Node类并进行操作、LinkedList源码追踪
+* 12-24-26 LinkedList源码分析，add，remove，set，size等操作方法，以及分析了List集合的选择、Set介绍，（无序（添加顺序与取出顺序不一致），没有索引（没有get方法），不能存放重复元素、取出的顺序是固定的）

张晓宇日记/ArrayList学习笔记.md

@@ -0,0 +1,44 @@
+# ArrayList 无参构造器创建实例
+```java
+    // 源码：无参构造器
+    public ArrayList() {
+        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
+    }
+    // add 
+    // 1、先确定是否扩容 2、然后再执行赋值
+    public boolean add(E e) {
+        ensureCapacityInternal(size + 1);  // Increments modCount!!
+        elementData[size++] = e;
+        return true;
+    }    
+    // 该方法确定最小容量 minCapacity （1）第一次扩容为10
+    private void ensureCapacityInternal(int minCapacity) {
+        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
+            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
+        }
+        ensureExplicitCapacity(minCapacity);
+    }
+    // 1、modCount++ 记录集合被修改的次数
+    // 2、如果 elementData大小不够 就调用grow 扩容
+    private void ensureExplicitCapacity(int minCapacity) {
+        modCount++;
+        // overflow-conscious code
+        if (minCapacity - elementData.length > 0)
+            grow(minCapacity);
+    }
+    // 底层真正实现扩容的 方法
+     private void grow(int minCapacity) {
+        // overflow-conscious code
+        int oldCapacity = elementData.length;
+        // 右移一位相当于 除以2 新的为 旧的1.5倍
+        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);
+    }
+
+
+```

张晓宇日记/HashSet源码笔记.md

@@ -0,0 +1,7 @@
+* HashSet源码笔记
+```java
+    // 构造器
+    public HashSet() {
+        map = new HashMap<>();
+    }
+```

张晓宇日记/LinkedList笔记.md

@@ -0,0 +1,95 @@
+* 自己写的一个Linked
+```java
+package collection_.list_.linkedList_;
+
+import java.util.LinkedList;
+
+/**
+ * 模拟一个简单的双向链表
+ */
+
+public class LinkedList01 {
+    public static void main(String[] args) {
+        Node node1 = new Node("1");
+        Node node2 = new Node("2");
+        Node node3 = new Node("3");
+        node1.next = node2;
+        node2.next = node3;
+        node2.pre = node1;
+        node3.pre = node2;
+        Node first = node1;
+        Node last = node3;
+        bianli1(first);
+        System.out.println("============");
+        // 遍历从尾到头
+        bianli2(last);
+        // 添加一个节点 在 1-2之间 1.5
+        Node node1_5 = new Node("1.5");
+        node1.next = node1_5;
+        node1_5.next = node2;
+        node2.pre = node1_5;
+        System.out.println("============");
+        bianli1(first);
+        // 删除一个节点 2
+        System.out.println("============");
+        removeNode(node1);
+        first = node1_5;
+        bianli1(first);
+
+    }
+    // 删除节点
+    private static void removeNode(Node removeNode) {
+        if(removeNode.next == null) {
+            // 最后一个
+            removeNode.pre.next = null;
+            return;
+        }
+        if(removeNode.pre == null) {
+            // 第一个
+            removeNode.next.pre = null;
+            return;
+        }
+        // 在中间 ①将上一个节点的next指向 removeNode 的后一个节点
+        removeNode.pre.next = removeNode.next;
+        // ② 将后一个节点的 pre 指向 removeNode的前一个节点
+        removeNode.next.pre = removeNode.pre;
+    }
+    private static void bianli1(Node first) {
+        // 遍历 从头到尾
+        while (true) {
+            if(first == null) {
+                break;
+            }
+            System.out.println(first);
+            // 将指针指向后面一位
+            first = first.next;
+        }
+    }
+    private static void bianli2(Node last) {
+        // 遍历 从尾到头
+        while (true) {
+            if(last == null) {
+                break;
+            }
+            System.out.println(last);
+            // 将指针指向后面一位
+            last = last.pre;
+        }
+    }
+}
+
+// 定义一个Node类，Node的对象则表示双向链表的一个节点
+class Node {
+    public Object item; //真正存放的数据
+    public Node pre; // 指向上一个节点
+    public Node next; // 指向下一个节点
+    public Node(Object name) {
+        this.item = name;
+    }
+
+    public String toString() {
+        return  "node name" + item;
+    }
+}
+
+```