auto commit

g8cc · Aug 18, 2019 · 069ab10 · 069ab10
1 parent 532a5d8
commit 069ab10
Show file tree

Hide file tree

Showing 6 changed files with 97 additions and 30 deletions.
diff --git a/docs/notes/Java 基础.md b/docs/notes/Java 基础.md
@@ -64,9  64,11 @@ boolean 只有两个值：true、false，可以使用 1 bit 来存储，但是
 
 ```java
 Integer x = 2;     // 装箱 调用了 Integer.valueOf(2)
-int y = x;         // 拆箱 调用了 Integer.intValue(x)
 int y = x;         // 拆箱 调用了 X.intValue()
 ```
 
 - [Autoboxing and Unboxing](https://docs.oracle.com/javase/tutorial/java/data/autoboxing.html)
 
 ## 缓存池
 
 new Integer(123) 与 Integer.valueOf(123) 的区别在于：

diff --git a/docs/notes/Java 容器.md b/docs/notes/Java 容器.md
@@ -299,12  299,53 @@ public synchronized E get(int index) {
 }
 ```
 
-### 2. 与 ArrayList 的比较
 ### 2. 扩容
 
 Vector 的构造函数可以传入 capacityIncrement 参数，它的作用是在扩容时使容量 capacity 增长 capacityIncrement。如果这个参数的值小于等于 0，扩容时每次都令 capacity 为原来的两倍。
 
 ```java
 public Vector(int initialCapacity, int capacityIncrement) {
     super();
     if (initialCapacity < 0)
         throw new IllegalArgumentException("Illegal Capacity: " 
                                            initialCapacity);
     this.elementData = new Object[initialCapacity];
     this.capacityIncrement = capacityIncrement;
 }
 ```
 
 ```java
 private void grow(int minCapacity) {
     // overflow-conscious code
     int oldCapacity = elementData.length;
     int newCapacity = oldCapacity   ((capacityIncrement > 0) ?
                                      capacityIncrement : oldCapacity);
     if (newCapacity - minCapacity < 0)
         newCapacity = minCapacity;
     if (newCapacity - MAX_ARRAY_SIZE > 0)
         newCapacity = hugeCapacity(minCapacity);
     elementData = Arrays.copyOf(elementData, newCapacity);
 }
 ```
 
 调用没有 capacityIncrement 的构造函数时，capacityIncrement 值被设置为 0，也就是说默认情况下 Vector 每次扩容时容量都会翻倍。
 
 ```java
 public Vector(int initialCapacity) {
     this(initialCapacity, 0);
 }
 
 public Vector() {
     this(10);
 }
 ```
 
 ### 3. 与 ArrayList 的比较
 
 - Vector 是同步的，因此开销就比 ArrayList 要大，访问速度更慢。最好使用 ArrayList 而不是 Vector，因为同步操作完全可以由程序员自己来控制；
-- Vector 每次扩容请求其大小的 2 倍空间，而 ArrayList 是 1.5 倍。
 - Vector 每次扩容请求其大小的 2 倍（也可以通过构造函数设置增长的容量），而 ArrayList 是 1.5 倍。
 
-### 3. 替代方案
 ### 4. 替代方案
 
 可以使用 `Collections.synchronizedList();` 得到一个线程安全的 ArrayList。
 
@@ -650,7  691,7 @@ static int indexFor(int h, int length) {
 | capacity | table 的容量大小，默认为 16。需要注意的是 capacity 必须保证为 2 的 n 次方。|
 | size | 键值对数量。 |
 | threshold | size 的临界值，当 size 大于等于 threshold 就必须进行扩容操作。 |
-| loadFactor | 装载因子，table 能够使用的比例，threshold = capacity * loadFactor。|
 | loadFactor | 装载因子，table 能够使用的比例，threshold = (int)(newCapacity * loadFactor)。|
 
 ```java
 static final int DEFAULT_INITIAL_CAPACITY = 16;

diff --git a/docs/notes/MySQL.md b/docs/notes/MySQL.md
@@ -242,7  242,7 @@ do {
 - 查询本身效率也可能会有所提升。例如下面的例子中，使用 IN() 代替连接查询，可以让 MySQL 按照 ID 顺序进行查询，这可能比随机的连接要更高效。
 
 ```sql
-SELECT * FROM tab
 SELECT * FROM tag
 JOIN tag_post ON tag_post.tag_id=tag.id
 JOIN post ON tag_post.post_id=post.id
 WHERE tag.tag='mysql';

diff --git a/notes/Java 基础.md b/notes/Java 基础.md
@@ -63,15  63,12 @@ boolean 只有两个值：true、false，可以使用 1 bit 来存储，但是
 基本类型都有对应的包装类型，基本类型与其对应的包装类型之间的赋值使用自动装箱与拆箱完成。
 
 ```java
-<<<<<<< HEAD
 Integer x = 2;     // 装箱 调用了 Integer.valueOf(2)
-int y = x;         // 拆箱 调用了 Integer.intValue(x)
-=======
-Integer x = 2;     // 装箱  调用了 Integer.valueOf(2);
-int y = x;         // 拆箱  调用了 Integer.intValue(x);
->>>>>>> 7ae8fc396136c44742ab6d5e5a90a3a17fac5af7
 int y = x;         // 拆箱 调用了 X.intValue()
 ```
 
 - [Autoboxing and Unboxing](https://docs.oracle.com/javase/tutorial/java/data/autoboxing.html)
 
 ## 缓存池
 
 new Integer(123) 与 Integer.valueOf(123) 的区别在于：
@@ -83,11  80,6 @@ new Integer(123) 与 Integer.valueOf(123) 的区别在于：
 Integer x = new Integer(123);
 Integer y = new Integer(123);
 System.out.println(x == y);    // false
-
-Integer x = 123;     //调用了Integer.valueOf(123);
-Integer y = 123;  //如果数值在[-128,127]之间，便返回指向缓冲池中已经存在的对象的引用；否则创建一个新的Integer对象。
-System.out.println(x==y);     //true
-
 Integer z = Integer.valueOf(123);
 Integer k = Integer.valueOf(123);
 System.out.println(z == k);   // true
@@ -164,11  156,7 @@ System.out.println(m == n); // true
 
 ## 概览
 
-<<<<<<< HEAD
 String 被声明为 final，因此它不可被继承。(Integer 等包装类也不能被继承）
-=======
-String 被声明为 final，因此它不可被继承。(Integer等包装类也不能被继承)
->>>>>>> 7ae8fc396136c44742ab6d5e5a90a3a17fac5af7
 
 在 Java 8 中，String 内部使用 char 数组存储数据。
 

diff --git a/notes/Java 容器.md b/notes/Java 容器.md
@@ -299,12  299,53 @@ public synchronized E get(int index) {
 }
 ```
 
-### 2. 与 ArrayList 的比较
 ### 2. 扩容
 
 Vector 的构造函数可以传入 capacityIncrement 参数，它的作用是在扩容时使容量 capacity 增长 capacityIncrement。如果这个参数的值小于等于 0，扩容时每次都令 capacity 为原来的两倍。
 
 ```java
 public Vector(int initialCapacity, int capacityIncrement) {
     super();
     if (initialCapacity < 0)
         throw new IllegalArgumentException("Illegal Capacity: " 
                                            initialCapacity);
     this.elementData = new Object[initialCapacity];
     this.capacityIncrement = capacityIncrement;
 }
 ```
 
 ```java
 private void grow(int minCapacity) {
     // overflow-conscious code
     int oldCapacity = elementData.length;
     int newCapacity = oldCapacity   ((capacityIncrement > 0) ?
                                      capacityIncrement : oldCapacity);
     if (newCapacity - minCapacity < 0)
         newCapacity = minCapacity;
     if (newCapacity - MAX_ARRAY_SIZE > 0)
         newCapacity = hugeCapacity(minCapacity);
     elementData = Arrays.copyOf(elementData, newCapacity);
 }
 ```
 
 调用没有 capacityIncrement 的构造函数时，capacityIncrement 值被设置为 0，也就是说默认情况下 Vector 每次扩容时容量都会翻倍。
 
 ```java
 public Vector(int initialCapacity) {
     this(initialCapacity, 0);
 }
 
 public Vector() {
     this(10);
 }
 ```
 
 ### 3. 与 ArrayList 的比较
 
 - Vector 是同步的，因此开销就比 ArrayList 要大，访问速度更慢。最好使用 ArrayList 而不是 Vector，因为同步操作完全可以由程序员自己来控制；
-- Vector 每次扩容请求其大小的 2 倍空间，而 ArrayList 是 1.5 倍。
 - Vector 每次扩容请求其大小的 2 倍（也可以通过构造函数设置增长的容量），而 ArrayList 是 1.5 倍。
 
-### 3. 替代方案
 ### 4. 替代方案
 
 可以使用 `Collections.synchronizedList();` 得到一个线程安全的 ArrayList。
 
@@ -767,12  808,7 @@ static final int tableSizeFor(int cap) {
 
 ### 8. 链表转红黑树
 
-<<<<<<< HEAD
 从 JDK 1.8 开始，一个桶存储的链表长度大于等于 8 时会将链表转换为红黑树。
-=======
-从 JDK 1.8 开始，一个桶存储的链表长度大于 8 时会将链表转换为红黑树。
-应该是：从 JDK 1.8 开始， table的长度也就是HashMap的capacity(不是size)不能小于64而且在桶存储的链表长度为8时(准确的说是长度为7并且在继续塞第8个时),转换成红黑树,而不是超过8。
->>>>>>> 7ae8fc396136c44742ab6d5e5a90a3a17fac5af7
 
 ### 9. 与 HashTable 的比较
 

diff --git a/notes/MySQL.md b/notes/MySQL.md
@@ -242,7  242,7 @@ do {
 - 查询本身效率也可能会有所提升。例如下面的例子中，使用 IN() 代替连接查询，可以让 MySQL 按照 ID 顺序进行查询，这可能比随机的连接要更高效。
 
 ```sql
-SELECT * FROM tab
 SELECT * FROM tag
 JOIN tag_post ON tag_post.tag_id=tag.id
 JOIN post ON tag_post.post_id=post.id
 WHERE tag.tag='mysql';