From 069ab100c8ec47ec789349d8964810b0ac310715 Mon Sep 17 00:00:00 2001 From: CyC2018 Date: Mon, 19 Aug 2019 00:35:12 +0800 Subject: [PATCH] auto commit --- docs/notes/Java 基础.md | 4 +++- docs/notes/Java 容器.md | 49 ++++++++++++++++++++++++++++++++++---- docs/notes/MySQL.md | 2 +- notes/Java 基础.md | 18 +++----------- notes/Java 容器.md | 52 ++++++++++++++++++++++++++++++++++------- notes/MySQL.md | 2 +- 6 files changed, 97 insertions(+), 30 deletions(-) diff --git a/docs/notes/Java 基础.md b/docs/notes/Java 基础.md index 3b7d3db0..3f92265b 100644 --- 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 index 21e69d90..e22cb947 100644 --- 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 index 733d686f..4ea626b0 100644 --- 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 index 5d83daf1..c165c66c 100644 --- 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 index 8c0e9f8a..278510c8 100644 --- 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 index 02a55320..bb255fcc 100644 --- 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';