Bump mysql-connector-java from 8.0.15 to 8.0.16

.gitignore

@@ -0,0 +1,8 @@
+# Created by .ignore support plugin (hsz.mobi)
+### JetBrains template
+# Covers JetBrains IDEs: IntelliJ, RubyMine, PhpStorm, AppCode, PyCharm, CLion, Android Studio and WebStorm
+# Reference: https://intellij-support.jetbrains.com/hc/en-us/articles/206544839
+
+.idea
+*.iml
+target

README.md

@@ -0,0 +1,54 @@
+# playground
+## **目的在于平时的学习而写的代码**
+### 1.common包
+* HttpAPIClient-http请求工具包
+* IpUtil-IP格式的互转和IP地址的一些判断
+* SysUtils-判断一个对象是否为空
+### 2.jvm目录
+* 详情参见[zhengwei.jvm.JVM.md](https://github.com/zw030301/playground/blob/master/src/main/java/zhengwei/jvm/JVM.md)
+
+### 3.hdfs包
+* HDFSClient-hdfs的客户端
+* HDFSIO-hdfs的IO操作，包含往云平台上传文件和下载文件等操作
+### 4.LeetCode包
+* 是一些平时的LeetCode的刷题代码
+* Daily-LeetCode01TwoSum-[两数之和](https://leetcode-cn.com/problems/two-sum/)
+* Daily-LeetCode02AddTwoNumbers-[两数相加](https://leetcode-cn.com/problems/add-two-numbers/)
+### 5.spark包
+* 详情参见[zhengwei.spark.Spark.md](https://github.com/zw030301/playground/blob/master/src/main/java/zhengwei/spark/Spark.md)
+
+### 6.unsafe包
+* 闲暇时看一些Java关于unsafe的文章时写的一些代码
+### 7.algorithm包-算法
+#### 自己的一些白话理解
+* 1.选择排序，时间复杂度是O(n^2),空间复杂度是O(1),不稳定的一种排序算法，
+主要思想是：遍历整个要排序的数组，要是前一个元素大于后一个元素，则调换元素位置，知道数组有序位置
+* 2.冒泡排序，时间复杂度是O(n^2),空间复杂度是O(1)，稳定的一种排序，
+主要思想：有两层循环，外循环控制着要排序的数组的长度，每完成一次比较，下次要比较的数组长度就会减小一；
+内循环控制着数组中元素的比较，如果后一个数大于前一个数就交换位置，大的数就像泡泡一样慢慢的往数组的后面跑去，随着要比较的数组长度减少，数组也逐渐有序。
+* 3.插入排序，时间复杂度O(n^2),空间复杂度O(1)，稳定的一种排序算法，
+主要思想：插入排序就像玩扑克时往手上接牌一样，刚开始牌比较少，随着牌的增多，我们把牌插入到大小合适的地方。
+插入排序同样是有两层循环，第一层循环控制着要排序数组的个数，每循环一次要比较的数组长度加一，每次加的一个元素就是要就进行比较的元素，每次新进的元素要和之前的元素进行比较，直到新进的元素大于前一个元素为止。
+插入排序适合样本较小和基本有序的元素排序，理论上效率要比选择排序和冒泡排序要高。
+### 8.设计模式
+#### 8.1 单例模式
+* 这里写了4钟单例模式的写法。
+* 1.饿汉式，线程安全，也是生产环境中比较常用的一种写法，比较简单的一种方式。这种方式主要是利用JVM只会加载一个类一次的特性来保证线程安全，当类被加载时，静态变量也会被加载；
+有一个缺点：就是不论我们是否用到了这个类的对象，JVM都会去加载这个类的实例。
+* 2.懒加载，线程不安全和线程不安全的版本都有，主要时利用synchronized关键字去加锁代码块以达到同步效果。但是效率比较低。
+* 3.静态内部类的方式，线程安全，这既达到了懒加载也时线程安全的，主要还是利用JVM只加载一次类的这个特性来保证线程安全。
+* 4.枚举的方式，真正意义上的单例模式，线程安全，不会被反序列化，这种方法还要继续深入了解下...
+#### 8.2 责任链模式
+* 可以参阅JavaEE中的过滤器
+
+#### 8.3 观察者模式
+* 观察者模式与责任链模式有些相像，都是利用面向对象的多态的这个特性；都是把每个观察者串联起来执行，但是责任链模式中可以中断链的继续执行，而观察者模式一般不中断链的执行。
+* 观察者模式有三个主要角色，1.被观察者，2.观察者，3.事件类，还有一些观察者中对于各种事件的处理逻辑的方法。
+### 9.thread线程
+* 详情参见[zhengwei.thread.Thread.md](https://github.com/zw030301/playground/blob/master/src/main/java/zhengwei/thread/Thread.md)
+
+**平时学习和工作的一些总结**
+---
+**_zhengwei AKA Sherlock_**
+---
+**闲暇之余会更新哦**

collection/src/main/resources/Collection.md

@@ -0,0 +1,294 @@
+# Java集合
+## ArrayList
+使用数组实现的List，具有自动扩容机制，在实际使用的过程中，需要尽量避免List的频繁扩容以免损失性能。
+### 重要属性
+#### 1. private static final int DEFAULT_CAPACITY = 10;
+默认的ArrayList的容量大小，如果在初始化ArrayList时没有指定初始容量，或者指定的初始容量为0时，在下一次添加数据时，将会将容量设置为该值。
+#### 2. private static final Object[] EMPTY_ELEMENTDATA = {};
+当初始化ArrayList时，指定的容量为0时，则将内部数组实例化为该值
+#### 3. private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
+默认的空数据，当使用空构造器初始化ArrayList时，内部数组被初始化该值
+#### 4. transient Object[] elementData
+ArrayList中真正存数据的数组
+#### 5. private int size
+ArrayList中的元素的个数
+### 重要方法
+#### public boolean add(E e)
+##### 1. 源码
+````java
+public boolean add(E e) {
+    //当前需要的最小容量size+1
+    ensureCapacityInternal(size + 1);  // Increments modCount!!
+    elementData[size++] = e;
+    return true;
+}
+private void ensureCapacityInternal(int minCapacity) {
+    ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
+}
+private static int calculateCapacity(Object[] elementData, int minCapacity) {
+    //如果当前数组为默认的额空数组，那么就取当前需要的最小容量和默认的容量的最大值
+    //一旦扩容过一次之后，原本存放数据的数组就不再是DEFAULTCAPACITY_EMPTY_ELEMENTDATA
+    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
+        //默认容量和当前最小容量进行比对，取较大值
+        return Math.max(DEFAULT_CAPACITY, minCapacity);
+    }
+    return minCapacity;
+}
+private void ensureExplicitCapacity(int minCapacity) {
+    //修改次数加一，方便快速失败的判断
+    modCount++;
+    // overflow-conscious code
+    //如果当前需要的最小容量大于当前存放数据的数组的长度，则进行扩容
+    if (minCapacity - elementData.length > 0)
+        //扩容
+        grow(minCapacity);
+}
+````
+##### 2. 解析
+在ArrayList的末尾添加一个元素，在添加元素之前都会对当前需要的最小容量(size+1)和当前的存储数据的数组的容量进行比对，
+如果当前需要的最小容量大于则进行扩容，否则将元素添加到数组的末尾。
+该方法会导致modCount的值加一。
+#### private void grow(int minCapacity)
+##### 1. 源码
+```java
+private void grow(int minCapacity) {
+    // overflow-conscious code
+    int oldCapacity = elementData.length;
+    //扩容为原来容量的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);
+}
+private static int hugeCapacity(int minCapacity) {
+    //如果需要的最小容量溢出了就抛出异常
+    if (minCapacity < 0) // overflow
+        throw new OutOfMemoryError();
+    //返回ArrayList的容量
+    return (minCapacity > MAX_ARRAY_SIZE) ?
+        Integer.MAX_VALUE :
+        MAX_ARRAY_SIZE;
+}
+```
+##### 2. 解析
+扩容的策略还是比较容易理解的，有以下几个步骤：
+1. 首先扩容到近似原来数组容量的1.5倍
+2. 需要的最小容量和扩容之后的大小进行比对。
+    1. 如果需要的最小容量的大小小于扩容之后的容量的话，则将旧数据拷贝到新数组中即可
+    2. 如果需要的最小容量小于扩容之后的容量的话，则将存储数据的数组容量扩容到需要的最小容量之后再进行数据拷贝
+    3. 如果需要的容量超过了最大容量，则将数组扩容到最大容量
+#### public void add(int index, E element)
+##### 1. 源码
+```java
+public void add(int index, E element) {
+    //越界检查
+    rangeCheckForAdd(index);
+    //扩容校验，最小需要的容量为size+1
+    ensureCapacityInternal(size + 1);  // Increments modCount!!
+    //将就数组中index以后的数据向后移一位
+    System.arraycopy(elementData, index, elementData, index + 1, size - index);
+    elementData[index] = element;
+    size++;
+}
+private void rangeCheckForAdd(int index) {
+    //同时检查上界和下界
+    if (index > size || index < 0)
+        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
+}
+```
+##### 2. 解析
+需要检查上界和下界，将插入的index包括index索引位的值，往后移动一位，将需要插入的元素插入到index索引位即可。
+#### public E remove(int index)
+##### 1. 源码
+```java
+public E remove(int index) {
+    //越界检查
+    rangeCheck(index);
+    //修改次数加一，方便快速失败
+    modCount++;
+    //取出旧值
+    E oldValue = elementData(index);
+    //需要移动的元素的个数
+    int numMoved = size - index - 1;
+    if (numMoved > 0)
+        //将index位置上的元素覆盖掉
+        System.arraycopy(elementData, index+1, elementData, index, numMoved);
+    //将最后一位置为null，方便GC进行回收
+    elementData[--size] = null; // clear to let GC do its work
+    return oldValue;
+}
+```
+##### 2. 解析
+移除指定索引位置上的元素，会导致修改次数加一，并且返回原来索引位上的旧值。将最后一位置为null，方便GC回收无用对象
+#### public boolean remove(Object o)
+##### 1. 源码
+```java
+public boolean remove(Object o) {   
+    //如果要删除的元素为null
+    if (o == null) {
+        for (int index = 0; index < size; index++)
+            if (elementData[index] == null) {
+                //快速删除
+                fastRemove(index);
+                return true;
+            }
+    //如果删除的元素不为null
+    } else {
+        for (int index = 0; index < size; index++)
+            if (o.equals(elementData[index])) {
+                //快速删除
+                fastRemove(index);
+                return true;
+            }
+    }
+    return false;
+}
+//快速删除，不校验边界，直接移除元素
+private void fastRemove(int index) {
+    //修改次数加一
+    modCount++;
+    int numMoved = size - index - 1;
+    if (numMoved > 0)
+        System.arraycopy(elementData, index+1, elementData, index, numMoved);
+    //最后一个元素置为null，方便GC回收无用对象
+    elementData[--size] = null; // clear to let GC do its work
+}
+```
+##### 2. 解析
+快速删除在ArrayList中第一个与Object对象相等的值
+#### public E set(int index, E element)
+##### 1. 源码
+```java
+public E set(int index, E element) {
+    //边界检查
+    rangeCheck(index);
+    //取出旧值
+    E oldValue = elementData(index);
+    //将新新值覆盖到旧值
+    elementData[index] = element;
+    //返回旧值
+    return oldValue;
+}
+E elementData(int index) {
+    return (E) elementData[index];
+}
+private void rangeCheck(int index) {
+    if (index >= size)
+        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
+}
+```
+##### 2. 解析
+将指定索引位的值修改为指定的值并返回旧值
+#### public boolean removeAll(Collection<?> c) / public boolean retainAll(Collection<?> c)
+##### 1. 源码
+```java
+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;
+}
+```
+### 内部类
+#### Itr
+Itr实现了Iterator接口，提供遍历功能
+#### 注意事项
+在使用Itr提供的迭代功能的时候，不可以使用ArrayList提供的remove方法，如果使用了ArrayList提供的方法，会导致modCount发生变化，但是Itr中的next方法中，每次都会去校验modCount和expectModCount，如果两者不相等，
+则表示List在迭代过程中发生了变化，会抛出ConcurrentModifyException。
+```java
+public E next() {
+    //校验modCount和expectModCount，校验ArrayList是否被修改过
+    checkForComodification();
+    int i = cursor;
+    if (i >= size)
+        throw new NoSuchElementException();
+    Object[] elementData = ArrayList.this.elementData;
+    if (i >= elementData.length)
+        throw new ConcurrentModificationException();
+    cursor = i + 1;
+    return (E) elementData[lastRet = i];
+}
+final void checkForComodification() {
+    if (modCount != expectedModCount)
+        throw new ConcurrentModificationException();
+}
+```
+如果想在迭代过程中删除元素，需要使用Itr提供的remove方法，实际还是调用的ArrayList中的remove方法，但此方法会在remove之后校准modCount和expect，以免下一次next时报错。
+```java
+public void remove() {
+    if (lastRet < 0)
+        throw new IllegalStateException();
+    checkForComodification();
+    try {
+        //实际调用ArrayList中的remove方法
+        ArrayList.this.remove(lastRet);
+        //将最后一个元素的下一个元素的索引往前挪一位
+        cursor = lastRet;
+        //重置最后一个元素的索引
+        lastRet = -1;
+        //校准expectModCount和modCount，以免下一次的next报错
+        expectedModCount = modCount;
+    } catch (IndexOutOfBoundsException ex) {
+        throw new ConcurrentModificationException();
+    }
+}
+```
+在Java8中新提供的forEachRemaining方法，同样的此方法不能够对元素进行移除.
+```java
+@Override
+public void forEachRemaining(Consumer<? super E> action) {
+    Objects.requireNonNull(action);
+    final int size = ArrayList.this.size;
+    int i = cursor;
+    if (i < size) {
+        final Object[] es = elementData;
+        if (i >= es.length)
+            throw new ConcurrentModificationException();
+        for (; i < size && modCount == expectedModCount; i++)
+            action.accept(elementAt(es, i));
+        // update once at end to reduce heap write traffic
+        cursor = i;
+        lastRet = i - 1;
+        checkForComodification();
+    }
+}
+```
+#### ListItr
+ListItr继承自Itr，实现了ListIterator接口，提供从后向前遍历的能力
+## LinkedList