From 315655827b0a8ad267a809ff2a883857e15b7f4b Mon Sep 17 00:00:00 2001
From: CyC2018 <1029579233@qq.com>
Date: Thu, 24 Jan 2019 09:06:42 +0800
Subject: [PATCH] auto commit
---
docs/notes/Docker.md | 90 +-
docs/notes/Git.md | 143 +-
docs/notes/HTTP.md | 950 ++-
docs/notes/Java IO.md | 708 +-
docs/notes/Java 基础.md | 1439 ++---
docs/notes/Java 容器.md | 1456 +++--
docs/notes/Java 并发.md | 1809 +++---
docs/notes/Java 虚拟机.md | 750 ++-
docs/notes/Leetcode 题解.md | 8858 +++++++++++++-------------
docs/notes/Leetcode-Database 题解.md | 904 ++-
docs/notes/Linux.md | 1262 ++--
docs/notes/MySQL.md | 393 +-
docs/notes/Redis.md | 720 +--
docs/notes/SQL.md | 767 ++-
docs/notes/Socket.md | 374 +-
docs/notes/代码可读性.md | 325 +-
docs/notes/代码风格规范.md | 11 +-
docs/notes/分布式.md | 336 +-
docs/notes/剑指 offer 题解.md | 3561 +++++------
docs/notes/攻击技术.md | 152 +-
docs/notes/数据库系统原理.md | 577 +-
docs/notes/构建工具.md | 147 +-
docs/notes/正则表达式.md | 346 +-
docs/notes/消息队列.md | 62 +-
docs/notes/算法.md | 2939 ++++-----
docs/notes/系统设计基础.md | 73 +-
docs/notes/缓存.md | 307 +-
docs/notes/计算机操作系统.md | 1092 ++--
docs/notes/计算机网络.md | 898 ++-
docs/notes/设计模式.md | 3579 +++++------
docs/notes/集群.md | 152 +-
docs/notes/面向对象思想.md | 342 +-
32 files changed, 17431 insertions(+), 18091 deletions(-)
diff --git a/docs/notes/Docker.md b/docs/notes/Docker.md
index 1c200848..ffbadb83 100644
--- a/docs/notes/Docker.md
+++ b/docs/notes/Docker.md
@@ -1,92 +1,86 @@
-[🎉 面试进阶指南已上线](https://xiaozhuanlan.com/CyC2018)
-
-* [一、解决的问题](#一解决的问题)
-* [二、与虚拟机的比较](#二与虚拟机的比较)
-* [三、优势](#三优势)
-* [四、使用场景](#四使用场景)
-* [五、镜像与容器](#五镜像与容器)
-* [参考资料](#参考资料)
-
-
-
-# 一、解决的问题
+# 一、解决的问题
由于不同的机器有不同的操作系统，以及不同的库和组件，在将一个应用部署到多台机器上需要进行大量的环境配置操作。
-Docker 主要解决环境配置问题，它是一种虚拟化技术，对进程进行隔离，被隔离的进程独立于宿主操作系统和其它隔离的进程。使用 Docker 可以不修改应用程序代码，不需要开发人员学习特定环境下的技术，就能够将现有的应用程序部署在其他机器中。
+Docker 主要解决环境配置问题，它是一种虚拟化技术，对进程进行隔离，被隔离的进程独立于宿主操作系统和其它隔离的进程。使用 Docker 可以不修改应用程序代码，不需要开发人员学习特定环境下的技术，就能够将现有的应用程序部署在其他机器中。
-New File
+New File
```
-## PATCH
+## PATCH
-> 对资源进行部分修改
+> 对资源进行部分修改
-PUT 也可以用于修改资源，但是只能完全替代原始资源，PATCH 允许部分修改。
+PUT 也可以用于修改资源，但是只能完全替代原始资源，PATCH 允许部分修改。
```html
-PATCH /file.txt HTTP/1.1
-Host: www.example.com
-Content-Type: application/example
-If-Match: "e0023aa4e"
-Content-Length: 100
+PATCH /file.txt HTTP/1.1
+Host: www.example.com
+Content-Type: application/example
+If-Match: "e0023aa4e"
+Content-Length: 100
-[description of changes]
+[description of changes]
```
-## DELETE
+## DELETE
-> 删除文件
+> 删除文件
-与 PUT 功能相反，并且同样不带验证机制。
+与 PUT 功能相反，并且同样不带验证机制。
```html
-DELETE /file.html HTTP/1.1
+DELETE /file.html HTTP/1.1
```
-## OPTIONS
+## OPTIONS
-> 查询支持的方法
+> 查询支持的方法
-查询指定的 URL 能够支持的方法。
+查询指定的 URL 能够支持的方法。
-会返回 `Allow: GET, POST, HEAD, OPTIONS` 这样的内容。
+会返回 `Allow: GET, POST, HEAD, OPTIONS` 这样的内容。
-## CONNECT
+## CONNECT
-> 要求在与代理服务器通信时建立隧道
+> 要求在与代理服务器通信时建立隧道
-使用 SSL（Secure Sockets Layer，安全套接层）和 TLS（Transport Layer Security，传输层安全）协议把通信内容加密后经网络隧道传输。
+使用 SSL（Secure Sockets Layer，安全套接层）和 TLS（Transport Layer Security，传输层安全）协议把通信内容加密后经网络隧道传输。
```html
-CONNECT www.example.com:443 HTTP/1.1
+CONNECT www.example.com:443 HTTP/1.1
```
- keys = selector.selectedKeys();
-Iterator keyIterator = keys.iterator();
-while (keyIterator.hasNext()) {
- SelectionKey key = keyIterator.next();
- if (key.isAcceptable()) {
- // ...
- } else if (key.isReadable()) {
- // ...
- }
- keyIterator.remove();
+Set keys = selector.selectedKeys();
+Iterator keyIterator = keys.iterator();
+while (keyIterator.hasNext()) {
+ SelectionKey key = keyIterator.next();
+ if (key.isAcceptable()) {
+ // ...
+ } else if (key.isReadable()) {
+ // ...
+ }
+ keyIterator.remove();
}
```
-### 5. 事件循环
+### 5. 事件循环
-因为一次 select() 调用不能处理完所有的事件，并且服务器端有可能需要一直监听事件，因此服务器端处理事件的代码一般会放在一个死循环内。
+因为一次 select() 调用不能处理完所有的事件，并且服务器端有可能需要一直监听事件，因此服务器端处理事件的代码一般会放在一个死循环内。
```java
-while (true) {
- int num = selector.select();
- Set keys = selector.selectedKeys();
- Iterator keyIterator = keys.iterator();
- while (keyIterator.hasNext()) {
- SelectionKey key = keyIterator.next();
- if (key.isAcceptable()) {
- // ...
- } else if (key.isReadable()) {
- // ...
- }
- keyIterator.remove();
- }
+while (true) {
+ int num = selector.select();
+ Set keys = selector.selectedKeys();
+ Iterator keyIterator = keys.iterator();
+ while (keyIterator.hasNext()) {
+ SelectionKey key = keyIterator.next();
+ if (key.isAcceptable()) {
+ // ...
+ } else if (key.isReadable()) {
+ // ...
+ }
+ keyIterator.remove();
+ }
}
```
-## 套接字 NIO 实例
+## 套接字 NIO 实例
```java
-public class NIOServer {
+public class NIOServer {
- public static void main(String[] args) throws IOException {
+ public static void main(String[] args) throws IOException {
- Selector selector = Selector.open();
+ Selector selector = Selector.open();
- ServerSocketChannel ssChannel = ServerSocketChannel.open();
- ssChannel.configureBlocking(false);
- ssChannel.register(selector, SelectionKey.OP_ACCEPT);
+ ServerSocketChannel ssChannel = ServerSocketChannel.open();
+ ssChannel.configureBlocking(false);
+ ssChannel.register(selector, SelectionKey.OP_ACCEPT);
- ServerSocket serverSocket = ssChannel.socket();
- InetSocketAddress address = new InetSocketAddress("127.0.0.1", 8888);
- serverSocket.bind(address);
+ ServerSocket serverSocket = ssChannel.socket();
+ InetSocketAddress address = new InetSocketAddress("127.0.0.1", 8888);
+ serverSocket.bind(address);
- while (true) {
+ while (true) {
- selector.select();
- Set keys = selector.selectedKeys();
- Iterator keyIterator = keys.iterator();
+ selector.select();
+ Set keys = selector.selectedKeys();
+ Iterator keyIterator = keys.iterator();
- while (keyIterator.hasNext()) {
+ while (keyIterator.hasNext()) {
- SelectionKey key = keyIterator.next();
+ SelectionKey key = keyIterator.next();
- if (key.isAcceptable()) {
+ if (key.isAcceptable()) {
- ServerSocketChannel ssChannel1 = (ServerSocketChannel) key.channel();
+ ServerSocketChannel ssChannel1 = (ServerSocketChannel) key.channel();
- // 服务器会为每个新连接创建一个 SocketChannel
- SocketChannel sChannel = ssChannel1.accept();
- sChannel.configureBlocking(false);
+ // 服务器会为每个新连接创建一个 SocketChannel
+ SocketChannel sChannel = ssChannel1.accept();
+ sChannel.configureBlocking(false);
- // 这个新连接主要用于从客户端读取数据
- sChannel.register(selector, SelectionKey.OP_READ);
+ // 这个新连接主要用于从客户端读取数据
+ sChannel.register(selector, SelectionKey.OP_READ);
- } else if (key.isReadable()) {
+ } else if (key.isReadable()) {
- SocketChannel sChannel = (SocketChannel) key.channel();
- System.out.println(readDataFromSocketChannel(sChannel));
- sChannel.close();
- }
+ SocketChannel sChannel = (SocketChannel) key.channel();
+ System.out.println(readDataFromSocketChannel(sChannel));
+ sChannel.close();
+ }
- keyIterator.remove();
- }
- }
- }
+ keyIterator.remove();
+ }
+ }
+ }
- private static String readDataFromSocketChannel(SocketChannel sChannel) throws IOException {
+ private static String readDataFromSocketChannel(SocketChannel sChannel) throws IOException {
- ByteBuffer buffer = ByteBuffer.allocate(1024);
- StringBuilder data = new StringBuilder();
+ ByteBuffer buffer = ByteBuffer.allocate(1024);
+ StringBuilder data = new StringBuilder();
- while (true) {
+ while (true) {
- buffer.clear();
- int n = sChannel.read(buffer);
- if (n == -1) {
- break;
- }
- buffer.flip();
- int limit = buffer.limit();
- char[] dst = new char[limit];
- for (int i = 0; i < limit; i++) {
- dst[i] = (char) buffer.get(i);
- }
- data.append(dst);
- buffer.clear();
- }
- return data.toString();
- }
+ buffer.clear();
+ int n = sChannel.read(buffer);
+ if (n == -1) {
+ break;
+ }
+ buffer.flip();
+ int limit = buffer.limit();
+ char[] dst = new char[limit];
+ for (int i = 0; i < limit; i++) {
+ dst[i] = (char) buffer.get(i);
+ }
+ data.append(dst);
+ buffer.clear();
+ }
+ return data.toString();
+ }
}
```
```java
-public class NIOClient {
+public class NIOClient {
- public static void main(String[] args) throws IOException {
- Socket socket = new Socket("127.0.0.1", 8888);
- OutputStream out = socket.getOutputStream();
- String s = "hello world";
- out.write(s.getBytes());
- out.close();
- }
+ public static void main(String[] args) throws IOException {
+ Socket socket = new Socket("127.0.0.1", 8888);
+ OutputStream out = socket.getOutputStream();
+ String s = "hello world";
+ out.write(s.getBytes());
+ out.close();
+ }
}
```
-## 内存映射文件
+## 内存映射文件
-内存映射文件 I/O 是一种读和写文件数据的方法，它可以比常规的基于流或者基于通道的 I/O 快得多。
+内存映射文件 I/O 是一种读和写文件数据的方法，它可以比常规的基于流或者基于通道的 I/O 快得多。
向内存映射文件写入可能是危险的，只是改变数组的单个元素这样的简单操作，就可能会直接修改磁盘上的文件。修改数据与将数据保存到磁盘是没有分开的。
-下面代码行将文件的前 1024 个字节映射到内存中，map() 方法返回一个 MappedByteBuffer，它是 ByteBuffer 的子类。因此，可以像使用其他任何 ByteBuffer 一样使用新映射的缓冲区，操作系统会在需要时负责执行映射。
+下面代码行将文件的前 1024 个字节映射到内存中，map() 方法返回一个 MappedByteBuffer，它是 ByteBuffer 的子类。因此，可以像使用其他任何 ByteBuffer 一样使用新映射的缓冲区，操作系统会在需要时负责执行映射。
```java
-MappedByteBuffer mbb = fc.map(FileChannel.MapMode.READ_WRITE, 0, 1024);
+MappedByteBuffer mbb = fc.map(FileChannel.MapMode.READ_WRITE, 0, 1024);
```
-## 对比
+## 对比
-NIO 与普通 I/O 的区别主要有以下两点：
+NIO 与普通 I/O 的区别主要有以下两点：
-- NIO 是非阻塞的；
-- NIO 面向块，I/O 面向流。
+- NIO 是非阻塞的；
+- NIO 面向块，I/O 面向流。
-# 八、参考资料
+# 八、参考资料
-- Eckel B, 埃克尔, 昊鹏, 等. Java 编程思想 [M]. 机械工业出版社, 2002.
-- [IBM: NIO 入门](https://www.ibm.com/developerworks/cn/education/java/j-nio/j-nio.html)
-- [Java NIO Tutorial](http://tutorials.jenkov.com/java-nio/index.html)
-- [Java NIO 浅析](https://tech.meituan.com/nio.html)
-- [IBM: 深入分析 Java I/O 的工作机制](https://www.ibm.com/developerworks/cn/java/j-lo-javaio/index.html)
-- [IBM: 深入分析 Java 中的中文编码问题](https://www.ibm.com/developerworks/cn/java/j-lo-chinesecoding/index.html)
-- [IBM: Java 序列化的高级认识](https://www.ibm.com/developerworks/cn/java/j-lo-serial/index.html)
-- [NIO 与传统 IO 的区别](http://blog.csdn.net/shimiso/article/details/24990499)
-- [Decorator Design Pattern](http://stg-tud.github.io/sedc/Lecture/ws13-14/5.3-Decorator.html#mode=document)
-- [Socket Multicast](http://labojava.blogspot.com/2012/12/socket-multicast.html)
+- Eckel B, 埃克尔, 昊鹏, 等. Java 编程思想 [M]. 机械工业出版社, 2002.
+- [IBM: NIO 入门](https://www.ibm.com/developerworks/cn/education/java/j-nio/j-nio.html)
+- [Java NIO Tutorial](http://tutorials.jenkov.com/java-nio/index.html)
+- [Java NIO 浅析](https://tech.meituan.com/nio.html)
+- [IBM: 深入分析 Java I/O 的工作机制](https://www.ibm.com/developerworks/cn/java/j-lo-javaio/index.html)
+- [IBM: 深入分析 Java 中的中文编码问题](https://www.ibm.com/developerworks/cn/java/j-lo-chinesecoding/index.html)
+- [IBM: Java 序列化的高级认识](https://www.ibm.com/developerworks/cn/java/j-lo-serial/index.html)
+- [NIO 与传统 IO 的区别](http://blog.csdn.net/shimiso/article/details/24990499)
+- [Decorator Design Pattern](http://stg-tud.github.io/sedc/Lecture/ws13-14/5.3-Decorator.html#mode=document)
+- [Socket Multicast](http://labojava.blogspot.com/2012/12/socket-multicast.html)
+---bottom---CyC---
+
+
+
+
+
+
+
diff --git a/docs/notes/Java 基础.md b/docs/notes/Java 基础.md
index 22d59c03..e7052210 100644
--- a/docs/notes/Java 基础.md
+++ b/docs/notes/Java 基础.md
@@ -1,652 +1,610 @@
-[🎉 面试进阶指南已上线](https://xiaozhuanlan.com/CyC2018)
-
-* [一、数据类型](#一数据类型)
- * [包装类型](#包装类型)
- * [缓存池](#缓存池)
-* [二、String](#二string)
- * [概览](#概览)
- * [不可变的好处](#不可变的好处)
- * [String, StringBuffer and StringBuilder](#string,-stringbuffer-and-stringbuilder)
- * [String Pool](#string-pool)
- * [new String("abc")](#new-string"abc")
-* [三、运算](#三运算)
- * [参数传递](#参数传递)
- * [float 与 double](#float-与-double)
- * [隐式类型转换](#隐式类型转换)
- * [switch](#switch)
-* [四、继承](#四继承)
- * [访问权限](#访问权限)
- * [抽象类与接口](#抽象类与接口)
- * [super](#super)
- * [重写与重载](#重写与重载)
-* [五、Object 通用方法](#五object-通用方法)
- * [概览](#概览)
- * [equals()](#equals)
- * [hashCode()](#hashcode)
- * [toString()](#tostring)
- * [clone()](#clone)
-* [六、关键字](#六关键字)
- * [final](#final)
- * [static](#static)
-* [七、反射](#七反射)
-* [八、异常](#八异常)
-* [九、泛型](#九泛型)
-* [十、注解](#十注解)
-* [十一、特性](#十一特性)
- * [Java 各版本的新特性](#java-各版本的新特性)
- * [Java 与 C++ 的区别](#java-与-c-的区别)
- * [JRE or JDK](#jre-or-jdk)
-* [参考资料](#参考资料)
-
+# 一、数据类型
-
-# 一、数据类型
-
-## 包装类型
+## 包装类型
八个基本类型：
-- boolean/1
-- byte/8
-- char/16
-- short/16
-- int/32
-- float/32
-- long/64
-- double/64
+- boolean/1
+- byte/8
+- char/16
+- short/16
+- int/32
+- float/32
+- long/64
+- double/64
基本类型都有对应的包装类型，基本类型与其对应的包装类型之间的赋值使用自动装箱与拆箱完成。
```java
-Integer x = 2; // 装箱
-int y = x; // 拆箱
+Integer x = 2; // 装箱
+int y = x; // 拆箱
```
-## 缓存池
+## 缓存池
-new Integer(123) 与 Integer.valueOf(123) 的区别在于：
+new Integer(123) 与 Integer.valueOf(123) 的区别在于：
-- new Integer(123) 每次都会新建一个对象；
-- Integer.valueOf(123) 会使用缓存池中的对象，多次调用会取得同一个对象的引用。
+- new Integer(123) 每次都会新建一个对象；
+- Integer.valueOf(123) 会使用缓存池中的对象，多次调用会取得同一个对象的引用。
```java
-Integer x = new Integer(123);
-Integer y = new Integer(123);
-System.out.println(x == y); // false
-Integer z = Integer.valueOf(123);
-Integer k = Integer.valueOf(123);
-System.out.println(z == k); // true
+Integer x = new Integer(123);
+Integer y = new Integer(123);
+System.out.println(x == y); // false
+Integer z = Integer.valueOf(123);
+Integer k = Integer.valueOf(123);
+System.out.println(z == k); // true
```
-valueOf() 方法的实现比较简单，就是先判断值是否在缓存池中，如果在的话就直接返回缓存池的内容。
+valueOf() 方法的实现比较简单，就是先判断值是否在缓存池中，如果在的话就直接返回缓存池的内容。
```java
-public static Integer valueOf(int i) {
- if (i >= IntegerCache.low && i <= IntegerCache.high)
- return IntegerCache.cache[i + (-IntegerCache.low)];
- return new Integer(i);
+public static Integer valueOf(int i) {
+ if (i >= IntegerCache.low && i <= IntegerCache.high)
+ return IntegerCache.cache[i + (-IntegerCache.low)];
+ return new Integer(i);
}
```
-在 Java 8 中，Integer 缓存池的大小默认为 -128\~127。
+在 Java 8 中，Integer 缓存池的大小默认为 -128~127。
```java
-static final int low = -128;
-static final int high;
-static final Integer cache[];
+static final int low = -128;
+static final int high;
+static final Integer cache[];
-static {
- // high value may be configured by property
- int h = 127;
- String integerCacheHighPropValue =
- sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
- if (integerCacheHighPropValue != null) {
- try {
- int i = parseInt(integerCacheHighPropValue);
- i = Math.max(i, 127);
- // Maximum array size is Integer.MAX_VALUE
- h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
- } catch( NumberFormatException nfe) {
- // If the property cannot be parsed into an int, ignore it.
- }
- }
- high = h;
+static {
+ // high value may be configured by property
+ int h = 127;
+ String integerCacheHighPropValue =
+ sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
+ if (integerCacheHighPropValue != null) {
+ try {
+ int i = parseInt(integerCacheHighPropValue);
+ i = Math.max(i, 127);
+ // Maximum array size is Integer.MAX_VALUE
+ h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
+ } catch( NumberFormatException nfe) {
+ // If the property cannot be parsed into an int, ignore it.
+ }
+ }
+ high = h;
- cache = new Integer[(high - low) + 1];
- int j = low;
- for(int k = 0; k < cache.length; k++)
- cache[k] = new Integer(j++);
+ cache = new Integer[(high - low) + 1];
+ int j = low;
+ for(int k = 0; k < cache.length; k++)
+ cache[k] = new Integer(j++);
- // range [-128, 127] must be interned (JLS7 5.1.7)
- assert IntegerCache.high >= 127;
+ // range [-128, 127] must be interned (JLS7 5.1.7)
+ assert IntegerCache.high >= 127;
}
```
-编译器会在自动装箱过程调用 valueOf() 方法，因此多个 Integer 实例使用自动装箱来创建并且值相同，那么就会引用相同的对象。
+编译器会在自动装箱过程调用 valueOf() 方法，因此多个 Integer 实例使用自动装箱来创建并且值相同，那么就会引用相同的对象。
```java
-Integer m = 123;
-Integer n = 123;
-System.out.println(m == n); // true
+Integer m = 123;
+Integer n = 123;
+System.out.println(m == n); // true
```
基本类型对应的缓冲池如下：
-- boolean values true and false
-- all byte values
-- short values between -128 and 127
-- int values between -128 and 127
-- char in the range \u0000 to \u007F
+- boolean values true and false
+- all byte values
+- short values between -128 and 127
+- int values between -128 and 127
+- char in the range \u0000 to \u007F
在使用这些基本类型对应的包装类型时，就可以直接使用缓冲池中的对象。
-[StackOverflow : Differences between new Integer(123), Integer.valueOf(123) and just 123
+[StackOverflow : Differences between new Integer(123), Integer.valueOf(123) and just 123
](https://stackoverflow.com/questions/9030817/differences-between-new-integer123-integer-valueof123-and-just-123)
-# 二、String
+# 二、String
-## 概览
+## 概览
-String 被声明为 final，因此它不可被继承。
+String 被声明为 final，因此它不可被继承。
-在 Java 8 中，String 内部使用 char 数组存储数据。
+在 Java 8 中，String 内部使用 char 数组存储数据。
```java
-public final class String
- implements java.io.Serializable, Comparable, CharSequence {
- /** The value is used for character storage. */
- private final char value[];
+public final class String
+ implements java.io.Serializable, Comparable, CharSequence {
+ /** The value is used for character storage. */
+ private final char value[];
}
```
-在 Java 9 之后，String 类的实现改用 byte 数组存储字符串，同时使用 `coder` 来标识使用了哪种编码。
+在 Java 9 之后，String 类的实现改用 byte 数组存储字符串，同时使用 `coder` 来标识使用了哪种编码。
```java
-public final class String
- implements java.io.Serializable, Comparable, CharSequence {
- /** The value is used for character storage. */
- private final byte[] value;
+public final class String
+ implements java.io.Serializable, Comparable, CharSequence {
+ /** The value is used for character storage. */
+ private final byte[] value;
- /** The identifier of the encoding used to encode the bytes in {@code value}. */
- private final byte coder;
+ /** The identifier of the encoding used to encode the bytes in {@code value}. */
+ private final byte coder;
}
```
-value 数组被声明为 final，这意味着 value 数组初始化之后就不能再引用其它数组。并且 String 内部没有改变 value 数组的方法，因此可以保证 String 不可变。
+value 数组被声明为 final，这意味着 value 数组初始化之后就不能再引用其它数组。并且 String 内部没有改变 value 数组的方法，因此可以保证 String 不可变。
-## 不可变的好处
+## 不可变的好处
-**1. 可以缓存 hash 值**
+**1. 可以缓存 hash 值**
-因为 String 的 hash 值经常被使用，例如 String 用做 HashMap 的 key。不可变的特性可以使得 hash 值也不可变，因此只需要进行一次计算。
+因为 String 的 hash 值经常被使用，例如 String 用做 HashMap 的 key。不可变的特性可以使得 hash 值也不可变，因此只需要进行一次计算。
-**2. String Pool 的需要**
+**2. String Pool 的需要**
-如果一个 String 对象已经被创建过了，那么就会从 String Pool 中取得引用。只有 String 是不可变的，才可能使用 String Pool。
+如果一个 String 对象已经被创建过了，那么就会从 String Pool 中取得引用。只有 String 是不可变的，才可能使用 String Pool。
- ":(Ljava/lang/String;)V
- 9: astore_1
-// ...
+ public static void main(java.lang.String[]);
+ descriptor: ([Ljava/lang/String;)V
+ flags: ACC_PUBLIC, ACC_STATIC
+ Code:
+ stack=3, locals=2, args_size=1
+ 0: new #2 // class java/lang/String
+ 3: dup
+ 4: ldc #3 // String abc
+ 6: invokespecial #4 // Method java/lang/String."":(Ljava/lang/String;)V
+ 9: astore_1
+// ...
```
-在 Constant Pool 中，#19 存储这字符串字面量 "abc"，#3 是 String Pool 的字符串对象，它指向 #19 这个字符串字面量。在 main 方法中，0: 行使用 new #2 在堆中创建一个字符串对象，并且使用 ldc #3 将 String Pool 中的字符串对象作为 String 构造函数的参数。
+在 Constant Pool 中，#19 存储这字符串字面量 "abc"，#3 是 String Pool 的字符串对象，它指向 #19 这个字符串字面量。在 main 方法中，0: 行使用 new #2 在堆中创建一个字符串对象，并且使用 ldc #3 将 String Pool 中的字符串对象作为 String 构造函数的参数。
-以下是 String 构造函数的源码，可以看到，在将一个字符串对象作为另一个字符串对象的构造函数参数时，并不会完全复制 value 数组内容，而是都会指向同一个 value 数组。
+以下是 String 构造函数的源码，可以看到，在将一个字符串对象作为另一个字符串对象的构造函数参数时，并不会完全复制 value 数组内容，而是都会指向同一个 value 数组。
```java
-public String(String original) {
- this.value = original.value;
- this.hash = original.hash;
+public String(String original) {
+ this.value = original.value;
+ this.hash = original.hash;
}
```
-# 三、运算
+# 三、运算
-## 参数传递
+## 参数传递
-Java 的参数是以值传递的形式传入方法中，而不是引用传递。
+Java 的参数是以值传递的形式传入方法中，而不是引用传递。
-以下代码中 Dog dog 的 dog 是一个指针，存储的是对象的地址。在将一个参数传入一个方法时，本质上是将对象的地址以值的方式传递到形参中。因此在方法中使指针引用其它对象，那么这两个指针此时指向的是完全不同的对象，在一方改变其所指向对象的内容时对另一方没有影响。
+以下代码中 Dog dog 的 dog 是一个指针，存储的是对象的地址。在将一个参数传入一个方法时，本质上是将对象的地址以值的方式传递到形参中。因此在方法中使指针引用其它对象，那么这两个指针此时指向的是完全不同的对象，在一方改变其所指向对象的内容时对另一方没有影响。
```java
-public class Dog {
+public class Dog {
- String name;
+ String name;
- Dog(String name) {
- this.name = name;
- }
+ Dog(String name) {
+ this.name = name;
+ }
- String getName() {
- return this.name;
- }
+ String getName() {
+ return this.name;
+ }
- void setName(String name) {
- this.name = name;
- }
+ void setName(String name) {
+ this.name = name;
+ }
- String getObjectAddress() {
- return super.toString();
- }
+ String getObjectAddress() {
+ return super.toString();
+ }
}
```
```java
-public class PassByValueExample {
- public static void main(String[] args) {
- Dog dog = new Dog("A");
- System.out.println(dog.getObjectAddress()); // Dog@4554617c
- func(dog);
- System.out.println(dog.getObjectAddress()); // Dog@4554617c
- System.out.println(dog.getName()); // A
- }
+public class PassByValueExample {
+ public static void main(String[] args) {
+ Dog dog = new Dog("A");
+ System.out.println(dog.getObjectAddress()); // Dog@4554617c
+ func(dog);
+ System.out.println(dog.getObjectAddress()); // Dog@4554617c
+ System.out.println(dog.getName()); // A
+ }
- private static void func(Dog dog) {
- System.out.println(dog.getObjectAddress()); // Dog@4554617c
- dog = new Dog("B");
- System.out.println(dog.getObjectAddress()); // Dog@74a14482
- System.out.println(dog.getName()); // B
- }
+ private static void func(Dog dog) {
+ System.out.println(dog.getObjectAddress()); // Dog@4554617c
+ dog = new Dog("B");
+ System.out.println(dog.getObjectAddress()); // Dog@74a14482
+ System.out.println(dog.getName()); // B
+ }
}
```
如果在方法中改变对象的字段值会改变原对象该字段值，因为改变的是同一个地址指向的内容。
```java
-class PassByValueExample {
- public static void main(String[] args) {
- Dog dog = new Dog("A");
- func(dog);
- System.out.println(dog.getName()); // B
- }
+class PassByValueExample {
+ public static void main(String[] args) {
+ Dog dog = new Dog("A");
+ func(dog);
+ System.out.println(dog.getName()); // B
+ }
- private static void func(Dog dog) {
- dog.setName("B");
- }
+ private static void func(Dog dog) {
+ dog.setName("B");
+ }
}
```
-[StackOverflow: Is Java “pass-by-reference” or “pass-by-value”?](https://stackoverflow.com/questions/40480/is-java-pass-by-reference-or-pass-by-value)
+[StackOverflow: Is Java “pass-by-reference” or “pass-by-value”?](https://stackoverflow.com/questions/40480/is-java-pass-by-reference-or-pass-by-value)
-## float 与 double
+## float 与 double
-Java 不能隐式执行向下转型，因为这会使得精度降低。
+Java 不能隐式执行向下转型，因为这会使得精度降低。
-1.1 字面量属于 double 类型，不能直接将 1.1 直接赋值给 float 变量，因为这是向下转型。
+1.1 字面量属于 double 类型，不能直接将 1.1 直接赋值给 float 变量，因为这是向下转型。
```java
-// float f = 1.1;
+// float f = 1.1;
```
-1.1f 字面量才是 float 类型。
+1.1f 字面量才是 float 类型。
```java
-float f = 1.1f;
+float f = 1.1f;
```
-## 隐式类型转换
+## 隐式类型转换
-因为字面量 1 是 int 类型，它比 short 类型精度要高，因此不能隐式地将 int 类型下转型为 short 类型。
+因为字面量 1 是 int 类型，它比 short 类型精度要高，因此不能隐式地将 int 类型下转型为 short 类型。
```java
-short s1 = 1;
-// s1 = s1 + 1;
+short s1 = 1;
+// s1 = s1 + 1;
```
-但是使用 += 或者 ++ 运算符可以执行隐式类型转换。
+但是使用 += 或者 ++ 运算符可以执行隐式类型转换。
```java
-s1 += 1;
-// s1++;
+s1 += 1;
+// s1++;
```
-上面的语句相当于将 s1 + 1 的计算结果进行了向下转型：
+上面的语句相当于将 s1 + 1 的计算结果进行了向下转型：
```java
-s1 = (short) (s1 + 1);
+s1 = (short) (s1 + 1);
```
-[StackOverflow : Why don't Java's +=, -=, *=, /= compound assignment operators require casting?](https://stackoverflow.com/questions/8710619/why-dont-javas-compound-assignment-operators-require-casting)
+[StackOverflow : Why don't Java's +=, -=, *=, /= compound assignment operators require casting?](https://stackoverflow.com/questions/8710619/why-dont-javas-compound-assignment-operators-require-casting)
-## switch
+## switch
-从 Java 7 开始，可以在 switch 条件判断语句中使用 String 对象。
+从 Java 7 开始，可以在 switch 条件判断语句中使用 String 对象。
```java
-String s = "a";
-switch (s) {
- case "a":
- System.out.println("aaa");
- break;
- case "b":
- System.out.println("bbb");
- break;
+String s = "a";
+switch (s) {
+ case "a":
+ System.out.println("aaa");
+ break;
+ case "b":
+ System.out.println("bbb");
+ break;
}
```
-switch 不支持 long，是因为 switch 的设计初衷是对那些只有少数的几个值进行等值判断，如果值过于复杂，那么还是用 if 比较合适。
+switch 不支持 long，是因为 switch 的设计初衷是对那些只有少数的几个值进行等值判断，如果值过于复杂，那么还是用 if 比较合适。
```java
-// long x = 111;
-// switch (x) { // Incompatible types. Found: 'long', required: 'char, byte, short, int, Character, Byte, Short, Integer, String, or an enum'
-// case 111:
-// System.out.println(111);
-// break;
-// case 222:
-// System.out.println(222);
-// break;
-// }
+// long x = 111;
+// switch (x) { // Incompatible types. Found: 'long', required: 'char, byte, short, int, Character, Byte, Short, Integer, String, or an enum'
+// case 111:
+// System.out.println(111);
+// break;
+// case 222:
+// System.out.println(222);
+// break;
+// }
```
-[StackOverflow : Why can't your switch statement data type be long, Java?](https://stackoverflow.com/questions/2676210/why-cant-your-switch-statement-data-type-be-long-java)
+[StackOverflow : Why can't your switch statement data type be long, Java?](https://stackoverflow.com/questions/2676210/why-cant-your-switch-statement-data-type-be-long-java)
-# 四、继承
+# 四、继承
-## 访问权限
+## 访问权限
-Java 中有三个访问权限修饰符：private、protected 以及 public，如果不加访问修饰符，表示包级可见。
+Java 中有三个访问权限修饰符：private、protected 以及 public，如果不加访问修饰符，表示包级可见。
可以对类或类中的成员（字段以及方法）加上访问修饰符。
-- 类可见表示其它类可以用这个类创建实例对象。
-- 成员可见表示其它类可以用这个类的实例对象访问到该成员；
+- 类可见表示其它类可以用这个类创建实例对象。
+- 成员可见表示其它类可以用这个类的实例对象访问到该成员；
-protected 用于修饰成员，表示在继承体系中成员对于子类可见，但是这个访问修饰符对于类没有意义。
+protected 用于修饰成员，表示在继承体系中成员对于子类可见，但是这个访问修饰符对于类没有意义。
-设计良好的模块会隐藏所有的实现细节，把它的 API 与它的实现清晰地隔离开来。模块之间只通过它们的 API 进行通信，一个模块不需要知道其他模块的内部工作情况，这个概念被称为信息隐藏或封装。因此访问权限应当尽可能地使每个类或者成员不被外界访问。
+设计良好的模块会隐藏所有的实现细节，把它的 API 与它的实现清晰地隔离开来。模块之间只通过它们的 API 进行通信，一个模块不需要知道其他模块的内部工作情况，这个概念被称为信息隐藏或封装。因此访问权限应当尽可能地使每个类或者成员不被外界访问。
如果子类的方法重写了父类的方法，那么子类中该方法的访问级别不允许低于父类的访问级别。这是为了确保可以使用父类实例的地方都可以使用子类实例，也就是确保满足里氏替换原则。
-字段决不能是公有的，因为这么做的话就失去了对这个字段修改行为的控制，客户端可以对其随意修改。例如下面的例子中，AccessExample 拥有 id 公有字段，如果在某个时刻，我们想要使用 int 存储 id 字段，那么就需要修改所有的客户端代码。
+字段决不能是公有的，因为这么做的话就失去了对这个字段修改行为的控制，客户端可以对其随意修改。例如下面的例子中，AccessExample 拥有 id 公有字段，如果在某个时刻，我们想要使用 int 存储 id 字段，那么就需要修改所有的客户端代码。
```java
-public class AccessExample {
- public String id;
+public class AccessExample {
+ public String id;
}
```
-可以使用公有的 getter 和 setter 方法来替换公有字段，这样的话就可以控制对字段的修改行为。
+可以使用公有的 getter 和 setter 方法来替换公有字段，这样的话就可以控制对字段的修改行为。
```java
-public class AccessExample {
+public class AccessExample {
- private int id;
+ private int id;
- public String getId() {
- return id + "";
- }
+ public String getId() {
+ return id + "";
+ }
- public void setId(String id) {
- this.id = Integer.valueOf(id);
- }
+ public void setId(String id) {
+ this.id = Integer.valueOf(id);
+ }
}
```
但是也有例外，如果是包级私有的类或者私有的嵌套类，那么直接暴露成员不会有特别大的影响。
```java
-public class AccessWithInnerClassExample {
+public class AccessWithInnerClassExample {
- private class InnerClass {
- int x;
- }
+ private class InnerClass {
+ int x;
+ }
- private InnerClass innerClass;
+ private InnerClass innerClass;
- public AccessWithInnerClassExample() {
- innerClass = new InnerClass();
- }
+ public AccessWithInnerClassExample() {
+ innerClass = new InnerClass();
+ }
- public int getValue() {
- return innerClass.x; // 直接访问
- }
+ public int getValue() {
+ return innerClass.x; // 直接访问
+ }
}
```
-## 抽象类与接口
+## 抽象类与接口
-**1. 抽象类**
+**1. 抽象类**
-抽象类和抽象方法都使用 abstract 关键字进行声明。抽象类一般会包含抽象方法，抽象方法一定位于抽象类中。
+抽象类和抽象方法都使用 abstract 关键字进行声明。抽象类一般会包含抽象方法，抽象方法一定位于抽象类中。
抽象类和普通类最大的区别是，抽象类不能被实例化，需要继承抽象类才能实例化其子类。
```java
-public abstract class AbstractClassExample {
+public abstract class AbstractClassExample {
- protected int x;
- private int y;
+ protected int x;
+ private int y;
- public abstract void func1();
+ public abstract void func1();
- public void func2() {
- System.out.println("func2");
- }
+ public void func2() {
+ System.out.println("func2");
+ }
}
```
```java
-public class AbstractExtendClassExample extends AbstractClassExample {
- @Override
- public void func1() {
- System.out.println("func1");
- }
+public class AbstractExtendClassExample extends AbstractClassExample {
+ @Override
+ public void func1() {
+ System.out.println("func1");
+ }
}
```
```java
-// AbstractClassExample ac1 = new AbstractClassExample(); // 'AbstractClassExample' is abstract; cannot be instantiated
-AbstractClassExample ac2 = new AbstractExtendClassExample();
+// AbstractClassExample ac1 = new AbstractClassExample(); // 'AbstractClassExample' is abstract; cannot be instantiated
+AbstractClassExample ac2 = new AbstractExtendClassExample();
ac2.func1();
```
-**2. 接口**
+**2. 接口**
-接口是抽象类的延伸，在 Java 8 之前，它可以看成是一个完全抽象的类，也就是说它不能有任何的方法实现。
+接口是抽象类的延伸，在 Java 8 之前，它可以看成是一个完全抽象的类，也就是说它不能有任何的方法实现。
-从 Java 8 开始，接口也可以拥有默认的方法实现，这是因为不支持默认方法的接口的维护成本太高了。在 Java 8 之前，如果一个接口想要添加新的方法，那么要修改所有实现了该接口的类。
+从 Java 8 开始，接口也可以拥有默认的方法实现，这是因为不支持默认方法的接口的维护成本太高了。在 Java 8 之前，如果一个接口想要添加新的方法，那么要修改所有实现了该接口的类。
-接口的成员（字段 + 方法）默认都是 public 的，并且不允许定义为 private 或者 protected。
+接口的成员（字段 + 方法）默认都是 public 的，并且不允许定义为 private 或者 protected。
-接口的字段默认都是 static 和 final 的。
+接口的字段默认都是 static 和 final 的。
```java
-public interface InterfaceExample {
+public interface InterfaceExample {
- void func1();
+ void func1();
- default void func2(){
- System.out.println("func2");
- }
+ default void func2(){
+ System.out.println("func2");
+ }
- int x = 123;
- // int y; // Variable 'y' might not have been initialized
- public int z = 0; // Modifier 'public' is redundant for interface fields
- // private int k = 0; // Modifier 'private' not allowed here
- // protected int l = 0; // Modifier 'protected' not allowed here
- // private void fun3(); // Modifier 'private' not allowed here
+ int x = 123;
+ // int y; // Variable 'y' might not have been initialized
+ public int z = 0; // Modifier 'public' is redundant for interface fields
+ // private int k = 0; // Modifier 'private' not allowed here
+ // protected int l = 0; // Modifier 'protected' not allowed here
+ // private void fun3(); // Modifier 'private' not allowed here
}
```
```java
-public class InterfaceImplementExample implements InterfaceExample {
- @Override
- public void func1() {
- System.out.println("func1");
- }
+public class InterfaceImplementExample implements InterfaceExample {
+ @Override
+ public void func1() {
+ System.out.println("func1");
+ }
}
```
```java
-// InterfaceExample ie1 = new InterfaceExample(); // 'InterfaceExample' is abstract; cannot be instantiated
-InterfaceExample ie2 = new InterfaceImplementExample();
+// InterfaceExample ie1 = new InterfaceExample(); // 'InterfaceExample' is abstract; cannot be instantiated
+InterfaceExample ie2 = new InterfaceImplementExample();
ie2.func1();
System.out.println(InterfaceExample.x);
```
-**3. 比较**
+**3. 比较**
-- 从设计层面上看，抽象类提供了一种 IS-A 关系，那么就必须满足里式替换原则，即子类对象必须能够替换掉所有父类对象。而接口更像是一种 LIKE-A 关系，它只是提供一种方法实现契约，并不要求接口和实现接口的类具有 IS-A 关系。
-- 从使用上来看，一个类可以实现多个接口，但是不能继承多个抽象类。
-- 接口的字段只能是 static 和 final 类型的，而抽象类的字段没有这种限制。
-- 接口的成员只能是 public 的，而抽象类的成员可以有多种访问权限。
+- 从设计层面上看，抽象类提供了一种 IS-A 关系，那么就必须满足里式替换原则，即子类对象必须能够替换掉所有父类对象。而接口更像是一种 LIKE-A 关系，它只是提供一种方法实现契约，并不要求接口和实现接口的类具有 IS-A 关系。
+- 从使用上来看，一个类可以实现多个接口，但是不能继承多个抽象类。
+- 接口的字段只能是 static 和 final 类型的，而抽象类的字段没有这种限制。
+- 接口的成员只能是 public 的，而抽象类的成员可以有多种访问权限。
-**4. 使用选择**
+**4. 使用选择**
使用接口：
-- 需要让不相关的类都实现一个方法，例如不相关的类都可以实现 Compareable 接口中的 compareTo() 方法；
-- 需要使用多重继承。
+- 需要让不相关的类都实现一个方法，例如不相关的类都可以实现 Compareable 接口中的 compareTo() 方法；
+- 需要使用多重继承。
使用抽象类：
-- 需要在几个相关的类中共享代码。
-- 需要能控制继承来的成员的访问权限，而不是都为 public。
-- 需要继承非静态和非常量字段。
+- 需要在几个相关的类中共享代码。
+- 需要能控制继承来的成员的访问权限，而不是都为 public。
+- 需要继承非静态和非常量字段。
-在很多情况下，接口优先于抽象类。因为接口没有抽象类严格的类层次结构要求，可以灵活地为一个类添加行为。并且从 Java 8 开始，接口也可以有默认的方法实现，使得修改接口的成本也变的很低。
+在很多情况下，接口优先于抽象类。因为接口没有抽象类严格的类层次结构要求，可以灵活地为一个类添加行为。并且从 Java 8 开始，接口也可以有默认的方法实现，使得修改接口的成本也变的很低。
-- [深入理解 abstract class 和 interface](https://www.ibm.com/developerworks/cn/java/l-javainterface-abstract/)
-- [When to Use Abstract Class and Interface](https://dzone.com/articles/when-to-use-abstract-class-and-intreface)
+- [深入理解 abstract class 和 interface](https://www.ibm.com/developerworks/cn/java/l-javainterface-abstract/)
+- [When to Use Abstract Class and Interface](https://dzone.com/articles/when-to-use-abstract-class-and-intreface)
-## super
+## super
-- 访问父类的构造函数：可以使用 super() 函数访问父类的构造函数，从而委托父类完成一些初始化的工作。
-- 访问父类的成员：如果子类重写了父类的某个方法，可以通过使用 super 关键字来引用父类的方法实现。
+- 访问父类的构造函数：可以使用 super() 函数访问父类的构造函数，从而委托父类完成一些初始化的工作。
+- 访问父类的成员：如果子类重写了父类的某个方法，可以通过使用 super 关键字来引用父类的方法实现。
```java
-public class SuperExample {
+public class SuperExample {
- protected int x;
- protected int y;
+ protected int x;
+ protected int y;
- public SuperExample(int x, int y) {
- this.x = x;
- this.y = y;
- }
+ public SuperExample(int x, int y) {
+ this.x = x;
+ this.y = y;
+ }
- public void func() {
- System.out.println("SuperExample.func()");
- }
+ public void func() {
+ System.out.println("SuperExample.func()");
+ }
}
```
```java
-public class SuperExtendExample extends SuperExample {
+public class SuperExtendExample extends SuperExample {
- private int z;
+ private int z;
- public SuperExtendExample(int x, int y, int z) {
- super(x, y);
- this.z = z;
- }
+ public SuperExtendExample(int x, int y, int z) {
+ super(x, y);
+ this.z = z;
+ }
- @Override
- public void func() {
- super.func();
- System.out.println("SuperExtendExample.func()");
- }
+ @Override
+ public void func() {
+ super.func();
+ System.out.println("SuperExtendExample.func()");
+ }
}
```
```java
-SuperExample e = new SuperExtendExample(1, 2, 3);
+SuperExample e = new SuperExtendExample(1, 2, 3);
e.func();
```
@@ -655,191 +613,191 @@ SuperExample.func()
SuperExtendExample.func()
```
-[Using the Keyword super](https://docs.oracle.com/javase/tutorial/java/IandI/super.html)
+[Using the Keyword super](https://docs.oracle.com/javase/tutorial/java/IandI/super.html)
-## 重写与重载
+## 重写与重载
-**1. 重写（Override）**
+**1. 重写（Override）**
存在于继承体系中，指子类实现了一个与父类在方法声明上完全相同的一个方法。
为了满足里式替换原则，重写有有以下两个限制：
-- 子类方法的访问权限必须大于等于父类方法；
-- 子类方法的返回类型必须是父类方法返回类型或为其子类型。
+- 子类方法的访问权限必须大于等于父类方法；
+- 子类方法的返回类型必须是父类方法返回类型或为其子类型。
-使用 @Override 注解，可以让编译器帮忙检查是否满足上面的两个限制条件。
+使用 @Override 注解，可以让编译器帮忙检查是否满足上面的两个限制条件。
-**2. 重载（Overload）**
+**2. 重载（Overload）**
存在于同一个类中，指一个方法与已经存在的方法名称上相同，但是参数类型、个数、顺序至少有一个不同。
应该注意的是，返回值不同，其它都相同不算是重载。
-# 五、Object 通用方法
+# 五、Object 通用方法
-## 概览
+## 概览
```java
-public native int hashCode()
+public native int hashCode()
-public boolean equals(Object obj)
+public boolean equals(Object obj)
-protected native Object clone() throws CloneNotSupportedException
+protected native Object clone() throws CloneNotSupportedException
-public String toString()
+public String toString()
-public final native Class getClass()
+public final native Class getClass()
-protected void finalize() throws Throwable {}
+protected void finalize() throws Throwable {}
-public final native void notify()
+public final native void notify()
-public final native void notifyAll()
+public final native void notifyAll()
-public final native void wait(long timeout) throws InterruptedException
+public final native void wait(long timeout) throws InterruptedException
-public final void wait(long timeout, int nanos) throws InterruptedException
+public final void wait(long timeout, int nanos) throws InterruptedException
-public final void wait() throws InterruptedException
+public final void wait() throws InterruptedException
```
-## equals()
+## equals()
-**1. 等价关系**
+**1. 等价关系**
-Ⅰ 自反性
+Ⅰ 自反性
```java
-x.equals(x); // true
+x.equals(x); // true
```
-Ⅱ 对称性
+Ⅱ 对称性
```java
-x.equals(y) == y.equals(x); // true
+x.equals(y) == y.equals(x); // true
```
-Ⅲ 传递性
+Ⅲ 传递性
```java
-if (x.equals(y) && y.equals(z))
- x.equals(z); // true;
+if (x.equals(y) && y.equals(z))
+ x.equals(z); // true;
```
-Ⅳ 一致性
+Ⅳ 一致性
-多次调用 equals() 方法结果不变
+多次调用 equals() 方法结果不变
```java
-x.equals(y) == x.equals(y); // true
+x.equals(y) == x.equals(y); // true
```
-Ⅴ 与 null 的比较
+Ⅴ 与 null 的比较
-对任何不是 null 的对象 x 调用 x.equals(null) 结果都为 false
+对任何不是 null 的对象 x 调用 x.equals(null) 结果都为 false
```java
-x.equals(null); // false;
+x.equals(null); // false;
```
-**2. 等价与相等**
+**2. 等价与相等**
-- 对于基本类型，== 判断两个值是否相等，基本类型没有 equals() 方法。
-- 对于引用类型，== 判断两个变量是否引用同一个对象，而 equals() 判断引用的对象是否等价。
+- 对于基本类型，== 判断两个值是否相等，基本类型没有 equals() 方法。
+- 对于引用类型，== 判断两个变量是否引用同一个对象，而 equals() 判断引用的对象是否等价。
```java
-Integer x = new Integer(1);
-Integer y = new Integer(1);
-System.out.println(x.equals(y)); // true
-System.out.println(x == y); // false
+Integer x = new Integer(1);
+Integer y = new Integer(1);
+System.out.println(x.equals(y)); // true
+System.out.println(x == y); // false
```
-**3. 实现**
+**3. 实现**
-- 检查是否为同一个对象的引用，如果是直接返回 true；
-- 检查是否是同一个类型，如果不是，直接返回 false；
-- 将 Object 对象进行转型；
-- 判断每个关键域是否相等。
+- 检查是否为同一个对象的引用，如果是直接返回 true；
+- 检查是否是同一个类型，如果不是，直接返回 false；
+- 将 Object 对象进行转型；
+- 判断每个关键域是否相等。
```java
-public class EqualExample {
+public class EqualExample {
- private int x;
- private int y;
- private int z;
+ private int x;
+ private int y;
+ private int z;
- public EqualExample(int x, int y, int z) {
- this.x = x;
- this.y = y;
- this.z = z;
- }
+ public EqualExample(int x, int y, int z) {
+ this.x = x;
+ this.y = y;
+ this.z = z;
+ }
- @Override
- public boolean equals(Object o) {
- if (this == o) return true;
- if (o == null || getClass() != o.getClass()) return false;
+ @Override
+ public boolean equals(Object o) {
+ if (this == o) return true;
+ if (o == null || getClass() != o.getClass()) return false;
- EqualExample that = (EqualExample) o;
+ EqualExample that = (EqualExample) o;
- if (x != that.x) return false;
- if (y != that.y) return false;
- return z == that.z;
- }
+ if (x != that.x) return false;
+ if (y != that.y) return false;
+ return z == that.z;
+ }
}
```
-## hashCode()
+## hashCode()
-hashCode() 返回散列值，而 equals() 是用来判断两个对象是否等价。等价的两个对象散列值一定相同，但是散列值相同的两个对象不一定等价。
+hashCode() 返回散列值，而 equals() 是用来判断两个对象是否等价。等价的两个对象散列值一定相同，但是散列值相同的两个对象不一定等价。
-在覆盖 equals() 方法时应当总是覆盖 hashCode() 方法，保证等价的两个对象散列值也相等。
+在覆盖 equals() 方法时应当总是覆盖 hashCode() 方法，保证等价的两个对象散列值也相等。
-下面的代码中，新建了两个等价的对象，并将它们添加到 HashSet 中。我们希望将这两个对象当成一样的，只在集合中添加一个对象，但是因为 EqualExample 没有实现 hasCode() 方法，因此这两个对象的散列值是不同的，最终导致集合添加了两个等价的对象。
+下面的代码中，新建了两个等价的对象，并将它们添加到 HashSet 中。我们希望将这两个对象当成一样的，只在集合中添加一个对象，但是因为 EqualExample 没有实现 hasCode() 方法，因此这两个对象的散列值是不同的，最终导致集合添加了两个等价的对象。
```java
-EqualExample e1 = new EqualExample(1, 1, 1);
-EqualExample e2 = new EqualExample(1, 1, 1);
-System.out.println(e1.equals(e2)); // true
-HashSet set = new HashSet<>();
+EqualExample e1 = new EqualExample(1, 1, 1);
+EqualExample e2 = new EqualExample(1, 1, 1);
+System.out.println(e1.equals(e2)); // true
+HashSet set = new HashSet<>();
set.add(e1);
set.add(e2);
-System.out.println(set.size()); // 2
+System.out.println(set.size()); // 2
```
-理想的散列函数应当具有均匀性，即不相等的对象应当均匀分布到所有可能的散列值上。这就要求了散列函数要把所有域的值都考虑进来。可以将每个域都当成 R 进制的某一位，然后组成一个 R 进制的整数。R 一般取 31，因为它是一个奇素数，如果是偶数的话，当出现乘法溢出，信息就会丢失，因为与 2 相乘相当于向左移一位。
+理想的散列函数应当具有均匀性，即不相等的对象应当均匀分布到所有可能的散列值上。这就要求了散列函数要把所有域的值都考虑进来。可以将每个域都当成 R 进制的某一位，然后组成一个 R 进制的整数。R 一般取 31，因为它是一个奇素数，如果是偶数的话，当出现乘法溢出，信息就会丢失，因为与 2 相乘相当于向左移一位。
-一个数与 31 相乘可以转换成移位和减法：`31*x == (x<<5)-x`，编译器会自动进行这个优化。
+一个数与 31 相乘可以转换成移位和减法：`31*x == (x<<5)-x`，编译器会自动进行这个优化。
```java
@Override
-public int hashCode() {
- int result = 17;
- result = 31 * result + x;
- result = 31 * result + y;
- result = 31 * result + z;
- return result;
+public int hashCode() {
+ int result = 17;
+ result = 31 * result + x;
+ result = 31 * result + y;
+ result = 31 * result + z;
+ return result;
}
```
-## toString()
+## toString()
-默认返回 ToStringExample@4554617c 这种形式，其中 @ 后面的数值为散列码的无符号十六进制表示。
+默认返回 ToStringExample@4554617c 这种形式，其中 @ 后面的数值为散列码的无符号十六进制表示。
```java
-public class ToStringExample {
+public class ToStringExample {
- private int number;
+ private int number;
- public ToStringExample(int number) {
- this.number = number;
- }
+ public ToStringExample(int number) {
+ this.number = number;
+ }
}
```
```java
-ToStringExample example = new ToStringExample(123);
+ToStringExample example = new ToStringExample(123);
System.out.println(example.toString());
```
@@ -847,290 +805,290 @@ System.out.println(example.toString());
ToStringExample@4554617c
```
-## clone()
+## clone()
-**1. cloneable**
+**1. cloneable**
-clone() 是 Object 的 protected 方法，它不是 public，一个类不显式去重写 clone()，其它类就不能直接去调用该类实例的 clone() 方法。
+clone() 是 Object 的 protected 方法，它不是 public，一个类不显式去重写 clone()，其它类就不能直接去调用该类实例的 clone() 方法。
```java
-public class CloneExample {
- private int a;
- private int b;
+public class CloneExample {
+ private int a;
+ private int b;
}
```
```java
-CloneExample e1 = new CloneExample();
-// CloneExample e2 = e1.clone(); // 'clone()' has protected access in 'java.lang.Object'
+CloneExample e1 = new CloneExample();
+// CloneExample e2 = e1.clone(); // 'clone()' has protected access in 'java.lang.Object'
```
-重写 clone() 得到以下实现：
+重写 clone() 得到以下实现：
```java
-public class CloneExample {
- private int a;
- private int b;
+public class CloneExample {
+ private int a;
+ private int b;
- @Override
- public CloneExample clone() throws CloneNotSupportedException {
- return (CloneExample)super.clone();
- }
+ @Override
+ public CloneExample clone() throws CloneNotSupportedException {
+ return (CloneExample)super.clone();
+ }
}
```
```java
-CloneExample e1 = new CloneExample();
-try {
- CloneExample e2 = e1.clone();
-} catch (CloneNotSupportedException e) {
- e.printStackTrace();
+CloneExample e1 = new CloneExample();
+try {
+ CloneExample e2 = e1.clone();
+} catch (CloneNotSupportedException e) {
+ e.printStackTrace();
}
```
```html
-java.lang.CloneNotSupportedException: CloneExample
+java.lang.CloneNotSupportedException: CloneExample
```
-以上抛出了 CloneNotSupportedException，这是因为 CloneExample 没有实现 Cloneable 接口。
+以上抛出了 CloneNotSupportedException，这是因为 CloneExample 没有实现 Cloneable 接口。
-应该注意的是，clone() 方法并不是 Cloneable 接口的方法，而是 Object 的一个 protected 方法。Cloneable 接口只是规定，如果一个类没有实现 Cloneable 接口又调用了 clone() 方法，就会抛出 CloneNotSupportedException。
+应该注意的是，clone() 方法并不是 Cloneable 接口的方法，而是 Object 的一个 protected 方法。Cloneable 接口只是规定，如果一个类没有实现 Cloneable 接口又调用了 clone() 方法，就会抛出 CloneNotSupportedException。
```java
-public class CloneExample implements Cloneable {
- private int a;
- private int b;
+public class CloneExample implements Cloneable {
+ private int a;
+ private int b;
- @Override
- public Object clone() throws CloneNotSupportedException {
- return super.clone();
- }
+ @Override
+ public Object clone() throws CloneNotSupportedException {
+ return super.clone();
+ }
}
```
-**2. 浅拷贝**
+**2. 浅拷贝**
拷贝对象和原始对象的引用类型引用同一个对象。
```java
-public class ShallowCloneExample implements Cloneable {
+public class ShallowCloneExample implements Cloneable {
- private int[] arr;
+ private int[] arr;
- public ShallowCloneExample() {
- arr = new int[10];
- for (int i = 0; i < arr.length; i++) {
- arr[i] = i;
- }
- }
+ public ShallowCloneExample() {
+ arr = new int[10];
+ for (int i = 0; i < arr.length; i++) {
+ arr[i] = i;
+ }
+ }
- public void set(int index, int value) {
- arr[index] = value;
- }
+ public void set(int index, int value) {
+ arr[index] = value;
+ }
- public int get(int index) {
- return arr[index];
- }
+ public int get(int index) {
+ return arr[index];
+ }
- @Override
- protected ShallowCloneExample clone() throws CloneNotSupportedException {
- return (ShallowCloneExample) super.clone();
- }
+ @Override
+ protected ShallowCloneExample clone() throws CloneNotSupportedException {
+ return (ShallowCloneExample) super.clone();
+ }
}
```
```java
-ShallowCloneExample e1 = new ShallowCloneExample();
-ShallowCloneExample e2 = null;
-try {
- e2 = e1.clone();
-} catch (CloneNotSupportedException e) {
- e.printStackTrace();
+ShallowCloneExample e1 = new ShallowCloneExample();
+ShallowCloneExample e2 = null;
+try {
+ e2 = e1.clone();
+} catch (CloneNotSupportedException e) {
+ e.printStackTrace();
}
-e1.set(2, 222);
-System.out.println(e2.get(2)); // 222
+e1.set(2, 222);
+System.out.println(e2.get(2)); // 222
```
-**3. 深拷贝**
+**3. 深拷贝**
拷贝对象和原始对象的引用类型引用不同对象。
```java
-public class DeepCloneExample implements Cloneable {
+public class DeepCloneExample implements Cloneable {
- private int[] arr;
+ private int[] arr;
- public DeepCloneExample() {
- arr = new int[10];
- for (int i = 0; i < arr.length; i++) {
- arr[i] = i;
- }
- }
+ public DeepCloneExample() {
+ arr = new int[10];
+ for (int i = 0; i < arr.length; i++) {
+ arr[i] = i;
+ }
+ }
- public void set(int index, int value) {
- arr[index] = value;
- }
+ public void set(int index, int value) {
+ arr[index] = value;
+ }
- public int get(int index) {
- return arr[index];
- }
+ public int get(int index) {
+ return arr[index];
+ }
- @Override
- protected DeepCloneExample clone() throws CloneNotSupportedException {
- DeepCloneExample result = (DeepCloneExample) super.clone();
- result.arr = new int[arr.length];
- for (int i = 0; i < arr.length; i++) {
- result.arr[i] = arr[i];
- }
- return result;
- }
+ @Override
+ protected DeepCloneExample clone() throws CloneNotSupportedException {
+ DeepCloneExample result = (DeepCloneExample) super.clone();
+ result.arr = new int[arr.length];
+ for (int i = 0; i < arr.length; i++) {
+ result.arr[i] = arr[i];
+ }
+ return result;
+ }
}
```
```java
-DeepCloneExample e1 = new DeepCloneExample();
-DeepCloneExample e2 = null;
-try {
- e2 = e1.clone();
-} catch (CloneNotSupportedException e) {
- e.printStackTrace();
+DeepCloneExample e1 = new DeepCloneExample();
+DeepCloneExample e2 = null;
+try {
+ e2 = e1.clone();
+} catch (CloneNotSupportedException e) {
+ e.printStackTrace();
}
-e1.set(2, 222);
-System.out.println(e2.get(2)); // 2
+e1.set(2, 222);
+System.out.println(e2.get(2)); // 2
```
-**4. clone() 的替代方案**
+**4. clone() 的替代方案**
-使用 clone() 方法来拷贝一个对象即复杂又有风险，它会抛出异常，并且还需要类型转换。Effective Java 书上讲到，最好不要去使用 clone()，可以使用拷贝构造函数或者拷贝工厂来拷贝一个对象。
+使用 clone() 方法来拷贝一个对象即复杂又有风险，它会抛出异常，并且还需要类型转换。Effective Java 书上讲到，最好不要去使用 clone()，可以使用拷贝构造函数或者拷贝工厂来拷贝一个对象。
```java
-public class CloneConstructorExample {
+public class CloneConstructorExample {
- private int[] arr;
+ private int[] arr;
- public CloneConstructorExample() {
- arr = new int[10];
- for (int i = 0; i < arr.length; i++) {
- arr[i] = i;
- }
- }
+ public CloneConstructorExample() {
+ arr = new int[10];
+ for (int i = 0; i < arr.length; i++) {
+ arr[i] = i;
+ }
+ }
- public CloneConstructorExample(CloneConstructorExample original) {
- arr = new int[original.arr.length];
- for (int i = 0; i < original.arr.length; i++) {
- arr[i] = original.arr[i];
- }
- }
+ public CloneConstructorExample(CloneConstructorExample original) {
+ arr = new int[original.arr.length];
+ for (int i = 0; i < original.arr.length; i++) {
+ arr[i] = original.arr[i];
+ }
+ }
- public void set(int index, int value) {
- arr[index] = value;
- }
+ public void set(int index, int value) {
+ arr[index] = value;
+ }
- public int get(int index) {
- return arr[index];
- }
+ public int get(int index) {
+ return arr[index];
+ }
}
```
```java
-CloneConstructorExample e1 = new CloneConstructorExample();
-CloneConstructorExample e2 = new CloneConstructorExample(e1);
-e1.set(2, 222);
-System.out.println(e2.get(2)); // 2
+CloneConstructorExample e1 = new CloneConstructorExample();
+CloneConstructorExample e2 = new CloneConstructorExample(e1);
+e1.set(2, 222);
+System.out.println(e2.get(2)); // 2
```
-# 六、关键字
+# 六、关键字
-## final
+## final
-**1. 数据**
+**1. 数据**
声明数据为常量，可以是编译时常量，也可以是在运行时被初始化后不能被改变的常量。
-- 对于基本类型，final 使数值不变；
-- 对于引用类型，final 使引用不变，也就不能引用其它对象，但是被引用的对象本身是可以修改的。
+- 对于基本类型，final 使数值不变；
+- 对于引用类型，final 使引用不变，也就不能引用其它对象，但是被引用的对象本身是可以修改的。
```java
-final int x = 1;
-// x = 2; // cannot assign value to final variable 'x'
-final A y = new A();
-y.a = 1;
+final int x = 1;
+// x = 2; // cannot assign value to final variable 'x'
+final A y = new A();
+y.a = 1;
```
-**2. 方法**
+**2. 方法**
声明方法不能被子类重写。
-private 方法隐式地被指定为 final，如果在子类中定义的方法和基类中的一个 private 方法签名相同，此时子类的方法不是重写基类方法，而是在子类中定义了一个新的方法。
+private 方法隐式地被指定为 final，如果在子类中定义的方法和基类中的一个 private 方法签名相同，此时子类的方法不是重写基类方法，而是在子类中定义了一个新的方法。
-**3. 类**
+**3. 类**
声明类不允许被继承。
-## static
+## static
-**1. 静态变量**
+**1. 静态变量**
-- 静态变量：又称为类变量，也就是说这个变量属于类的，类所有的实例都共享静态变量，可以直接通过类名来访问它。静态变量在内存中只存在一份。
-- 实例变量：每创建一个实例就会产生一个实例变量，它与该实例同生共死。
+- 静态变量：又称为类变量，也就是说这个变量属于类的，类所有的实例都共享静态变量，可以直接通过类名来访问它。静态变量在内存中只存在一份。
+- 实例变量：每创建一个实例就会产生一个实例变量，它与该实例同生共死。
```java
-public class A {
+public class A {
- private int x; // 实例变量
- private static int y; // 静态变量
+ private int x; // 实例变量
+ private static int y; // 静态变量
- public static void main(String[] args) {
- // int x = A.x; // Non-static field 'x' cannot be referenced from a static context
- A a = new A();
- int x = a.x;
- int y = A.y;
- }
+ public static void main(String[] args) {
+ // int x = A.x; // Non-static field 'x' cannot be referenced from a static context
+ A a = new A();
+ int x = a.x;
+ int y = A.y;
+ }
}
```
-**2. 静态方法**
+**2. 静态方法**
静态方法在类加载的时候就存在了，它不依赖于任何实例。所以静态方法必须有实现，也就是说它不能是抽象方法。
```java
-public abstract class A {
- public static void func1(){
- }
- // public abstract static void func2(); // Illegal combination of modifiers: 'abstract' and 'static'
+public abstract class A {
+ public static void func1(){
+ }
+ // public abstract static void func2(); // Illegal combination of modifiers: 'abstract' and 'static'
}
```
-只能访问所属类的静态字段和静态方法，方法中不能有 this 和 super 关键字。
+只能访问所属类的静态字段和静态方法，方法中不能有 this 和 super 关键字。
```java
-public class A {
+public class A {
- private static int x;
- private int y;
+ private static int x;
+ private int y;
- public static void func1(){
- int a = x;
- // int b = y; // Non-static field 'y' cannot be referenced from a static context
- // int b = this.y; // 'A.this' cannot be referenced from a static context
- }
+ public static void func1(){
+ int a = x;
+ // int b = y; // Non-static field 'y' cannot be referenced from a static context
+ // int b = this.y; // 'A.this' cannot be referenced from a static context
+ }
}
```
-**3. 静态语句块**
+**3. 静态语句块**
静态语句块在类初始化时运行一次。
```java
-public class A {
- static {
- System.out.println("123");
- }
+public class A {
+ static {
+ System.out.println("123");
+ }
- public static void main(String[] args) {
- A a1 = new A();
- A a2 = new A();
- }
+ public static void main(String[] args) {
+ A a1 = new A();
+ A a2 = new A();
+ }
}
```
@@ -1138,195 +1096,198 @@ public class A {
123
```
-**4. 静态内部类**
+**4. 静态内部类**
非静态内部类依赖于外部类的实例，而静态内部类不需要。
```java
-public class OuterClass {
+public class OuterClass {
- class InnerClass {
- }
+ class InnerClass {
+ }
- static class StaticInnerClass {
- }
+ static class StaticInnerClass {
+ }
- public static void main(String[] args) {
- // InnerClass innerClass = new InnerClass(); // 'OuterClass.this' cannot be referenced from a static context
- OuterClass outerClass = new OuterClass();
- InnerClass innerClass = outerClass.new InnerClass();
- StaticInnerClass staticInnerClass = new StaticInnerClass();
- }
+ public static void main(String[] args) {
+ // InnerClass innerClass = new InnerClass(); // 'OuterClass.this' cannot be referenced from a static context
+ OuterClass outerClass = new OuterClass();
+ InnerClass innerClass = outerClass.new InnerClass();
+ StaticInnerClass staticInnerClass = new StaticInnerClass();
+ }
}
```
静态内部类不能访问外部类的非静态的变量和方法。
-**5. 静态导包**
+**5. 静态导包**
-在使用静态变量和方法时不用再指明 ClassName，从而简化代码，但可读性大大降低。
+在使用静态变量和方法时不用再指明 ClassName，从而简化代码，但可读性大大降低。
```java
-import static com.xxx.ClassName.*
+import static com.xxx.ClassName.*
```
-**6. 初始化顺序**
+**6. 初始化顺序**
静态变量和静态语句块优先于实例变量和普通语句块，静态变量和静态语句块的初始化顺序取决于它们在代码中的顺序。
```java
-public static String staticField = "静态变量";
+public static String staticField = "静态变量";
```
```java
-static {
- System.out.println("静态语句块");
+static {
+ System.out.println("静态语句块");
}
```
```java
-public String field = "实例变量";
+public String field = "实例变量";
```
```java
{
- System.out.println("普通语句块");
+ System.out.println("普通语句块");
}
```
最后才是构造函数的初始化。
```java
-public InitialOrderTest() {
- System.out.println("构造函数");
+public InitialOrderTest() {
+ System.out.println("构造函数");
}
```
存在继承的情况下，初始化顺序为：
-- 父类（静态变量、静态语句块）
-- 子类（静态变量、静态语句块）
-- 父类（实例变量、普通语句块）
-- 父类（构造函数）
-- 子类（实例变量、普通语句块）
-- 子类（构造函数）
+- 父类（静态变量、静态语句块）
+- 子类（静态变量、静态语句块）
+- 父类（实例变量、普通语句块）
+- 父类（构造函数）
+- 子类（实例变量、普通语句块）
+- 子类（构造函数）
-# 七、反射
+# 七、反射
-每个类都有一个 **Class** 对象，包含了与类有关的信息。当编译一个新类时，会产生一个同名的 .class 文件，该文件内容保存着 Class 对象。
+每个类都有一个 **Class** 对象，包含了与类有关的信息。当编译一个新类时，会产生一个同名的 .class 文件，该文件内容保存着 Class 对象。
-类加载相当于 Class 对象的加载，类在第一次使用时才动态加载到 JVM 中。也可以使用 `Class.forName("com.mysql.jdbc.Driver")` 这种方式来控制类的加载，该方法会返回一个 Class 对象。
+类加载相当于 Class 对象的加载，类在第一次使用时才动态加载到 JVM 中。也可以使用 `Class.forName("com.mysql.jdbc.Driver")` 这种方式来控制类的加载，该方法会返回一个 Class 对象。
-反射可以提供运行时的类信息，并且这个类可以在运行时才加载进来，甚至在编译时期该类的 .class 不存在也可以加载进来。
+反射可以提供运行时的类信息，并且这个类可以在运行时才加载进来，甚至在编译时期该类的 .class 不存在也可以加载进来。
-Class 和 java.lang.reflect 一起对反射提供了支持，java.lang.reflect 类库主要包含了以下三个类：
+Class 和 java.lang.reflect 一起对反射提供了支持，java.lang.reflect 类库主要包含了以下三个类：
-- **Field** ：可以使用 get() 和 set() 方法读取和修改 Field 对象关联的字段；
-- **Method** ：可以使用 invoke() 方法调用与 Method 对象关联的方法；
-- **Constructor** ：可以用 Constructor 创建新的对象。
+- **Field**：可以使用 get() 和 set() 方法读取和修改 Field 对象关联的字段；
+- **Method**：可以使用 invoke() 方法调用与 Method 对象关联的方法；
+- **Constructor**：可以用 Constructor 创建新的对象。
-**反射的优点：**
+**反射的优点：**
-* **可扩展性** ：应用程序可以利用全限定名创建可扩展对象的实例，来使用来自外部的用户自定义类。
-* **类浏览器和可视化开发环境** ：一个类浏览器需要可以枚举类的成员。可视化开发环境（如 IDE）可以从利用反射中可用的类型信息中受益，以帮助程序员编写正确的代码。
-* **调试器和测试工具** ： 调试器需要能够检查一个类里的私有成员。测试工具可以利用反射来自动地调用类里定义的可被发现的 API 定义，以确保一组测试中有较高的代码覆盖率。
+* **可扩展性** ：应用程序可以利用全限定名创建可扩展对象的实例，来使用来自外部的用户自定义类。
+* **类浏览器和可视化开发环境** ：一个类浏览器需要可以枚举类的成员。可视化开发环境（如 IDE）可以从利用反射中可用的类型信息中受益，以帮助程序员编写正确的代码。
+* **调试器和测试工具** ： 调试器需要能够检查一个类里的私有成员。测试工具可以利用反射来自动地调用类里定义的可被发现的 API 定义，以确保一组测试中有较高的代码覆盖率。
-**反射的缺点：**
+**反射的缺点：**
尽管反射非常强大，但也不能滥用。如果一个功能可以不用反射完成，那么最好就不用。在我们使用反射技术时，下面几条内容应该牢记于心。
-* **性能开销** ：反射涉及了动态类型的解析，所以 JVM 无法对这些代码进行优化。因此，反射操作的效率要比那些非反射操作低得多。我们应该避免在经常被执行的代码或对性能要求很高的程序中使用反射。
+* **性能开销** ：反射涉及了动态类型的解析，所以 JVM 无法对这些代码进行优化。因此，反射操作的效率要比那些非反射操作低得多。我们应该避免在经常被执行的代码或对性能要求很高的程序中使用反射。
-* **安全限制** ：使用反射技术要求程序必须在一个没有安全限制的环境中运行。如果一个程序必须在有安全限制的环境中运行，如 Applet，那么这就是个问题了。
+* **安全限制** ：使用反射技术要求程序必须在一个没有安全限制的环境中运行。如果一个程序必须在有安全限制的环境中运行，如 Applet，那么这就是个问题了。
-* **内部暴露** ：由于反射允许代码执行一些在正常情况下不被允许的操作（比如访问私有的属性和方法），所以使用反射可能会导致意料之外的副作用，这可能导致代码功能失调并破坏可移植性。反射代码破坏了抽象性，因此当平台发生改变的时候，代码的行为就有可能也随着变化。
+* **内部暴露** ：由于反射允许代码执行一些在正常情况下不被允许的操作（比如访问私有的属性和方法），所以使用反射可能会导致意料之外的副作用，这可能导致代码功能失调并破坏可移植性。反射代码破坏了抽象性，因此当平台发生改变的时候，代码的行为就有可能也随着变化。
-- [Trail: The Reflection API](https://docs.oracle.com/javase/tutorial/reflect/index.html)
-- [深入解析 Java 反射（1）- 基础](http://www.sczyh30.com/posts/Java/java-reflection-1/)
+- [Trail: The Reflection API](https://docs.oracle.com/javase/tutorial/reflect/index.html)
+- [深入解析 Java 反射（1）- 基础](http://www.sczyh30.com/posts/Java/java-reflection-1/)
-# 八、异常
+# 八、异常
-Throwable 可以用来表示任何可以作为异常抛出的类，分为两种： **Error** 和 **Exception**。其中 Error 用来表示 JVM 无法处理的错误，Exception 分为两种：
+Throwable 可以用来表示任何可以作为异常抛出的类，分为两种：**Error** 和 **Exception**。其中 Error 用来表示 JVM 无法处理的错误，Exception 分为两种：
-- **受检异常** ：需要用 try...catch... 语句捕获并进行处理，并且可以从异常中恢复；
-- **非受检异常** ：是程序运行时错误，例如除 0 会引发 Arithmetic Exception，此时程序崩溃并且无法恢复。
+- **受检异常**：需要用 try...catch... 语句捕获并进行处理，并且可以从异常中恢复；
+- **非受检异常**：是程序运行时错误，例如除 0 会引发 Arithmetic Exception，此时程序崩溃并且无法恢复。
- {
- // T stands for "Type"
- private T t;
- public void set(T t) { this.t = t; }
- public T get() { return t; }
+public class Box {
+ // T stands for "Type"
+ private T t;
+ public void set(T t) { this.t = t; }
+ public T get() { return t; }
}
```
-- [Java 泛型详解](http://www.importnew.com/24029.html)
-- [10 道 Java 泛型面试题](https://cloud.tencent.com/developer/article/1033693)
+- [Java 泛型详解](http://www.importnew.com/24029.html)
+- [10 道 Java 泛型面试题](https://cloud.tencent.com/developer/article/1033693)
-# 十、注解
+# 十、注解
-Java 注解是附加在代码中的一些元信息，用于一些工具在编译、运行时进行解析和使用，起到说明、配置的功能。注解不会也不能影响代码的实际逻辑，仅仅起到辅助性的作用。
+Java 注解是附加在代码中的一些元信息，用于一些工具在编译、运行时进行解析和使用，起到说明、配置的功能。注解不会也不能影响代码的实际逻辑，仅仅起到辅助性的作用。
-[注解 Annotation 实现原理与自定义注解例子](https://www.cnblogs.com/acm-bingzi/p/javaAnnotation.html)
+[注解 Annotation 实现原理与自定义注解例子](https://www.cnblogs.com/acm-bingzi/p/javaAnnotation.html)
-# 十一、特性
+# 十一、特性
-## Java 各版本的新特性
+## Java 各版本的新特性
-**New highlights in Java SE 8**
+**New highlights in Java SE 8**
-1. Lambda Expressions
-2. Pipelines and Streams
-3. Date and Time API
-4. Default Methods
-5. Type Annotations
-6. Nashhorn JavaScript Engine
-7. Concurrent Accumulators
-8. Parallel operations
-9. PermGen Error Removed
+1. Lambda Expressions
+2. Pipelines and Streams
+3. Date and Time API
+4. Default Methods
+5. Type Annotations
+6. Nashhorn JavaScript Engine
+7. Concurrent Accumulators
+8. Parallel operations
+9. PermGen Error Removed
-**New highlights in Java SE 7**
+**New highlights in Java SE 7**
-1. Strings in Switch Statement
-2. Type Inference for Generic Instance Creation
-3. Multiple Exception Handling
-4. Support for Dynamic Languages
-5. Try with Resources
-6. Java nio Package
-7. Binary Literals, Underscore in literals
-8. Diamond Syntax
+1. Strings in Switch Statement
+2. Type Inference for Generic Instance Creation
+3. Multiple Exception Handling
+4. Support for Dynamic Languages
+5. Try with Resources
+6. Java nio Package
+7. Binary Literals, Underscore in literals
+8. Diamond Syntax
-- [Difference between Java 1.8 and Java 1.7?](http://www.selfgrowth.com/articles/difference-between-java-18-and-java-17)
-- [Java 8 特性](http://www.importnew.com/19345.html)
+- [Difference between Java 1.8 and Java 1.7?](http://www.selfgrowth.com/articles/difference-between-java-18-and-java-17)
+- [Java 8 特性](http://www.importnew.com/19345.html)
-## Java 与 C++ 的区别
+## Java 与 C++ 的区别
-- Java 是纯粹的面向对象语言，所有的对象都继承自 java.lang.Object，C++ 为了兼容 C 即支持面向对象也支持面向过程。
-- Java 通过虚拟机从而实现跨平台特性，但是 C++ 依赖于特定的平台。
-- Java 没有指针，它的引用可以理解为安全指针，而 C++ 具有和 C 一样的指针。
-- Java 支持自动垃圾回收，而 C++ 需要手动回收。
-- Java 不支持多重继承，只能通过实现多个接口来达到相同目的，而 C++ 支持多重继承。
-- Java 不支持操作符重载，虽然可以对两个 String 对象执行加法运算，但是这是语言内置支持的操作，不属于操作符重载，而 C++ 可以。
-- Java 的 goto 是保留字，但是不可用，C++ 可以使用 goto。
-- Java 不支持条件编译，C++ 通过 #ifdef #ifndef 等预处理命令从而实现条件编译。
+- Java 是纯粹的面向对象语言，所有的对象都继承自 java.lang.Object，C++ 为了兼容 C 即支持面向对象也支持面向过程。
+- Java 通过虚拟机从而实现跨平台特性，但是 C++ 依赖于特定的平台。
+- Java 没有指针，它的引用可以理解为安全指针，而 C++ 具有和 C 一样的指针。
+- Java 支持自动垃圾回收，而 C++ 需要手动回收。
+- Java 不支持多重继承，只能通过实现多个接口来达到相同目的，而 C++ 支持多重继承。
+- Java 不支持操作符重载，虽然可以对两个 String 对象执行加法运算，但是这是语言内置支持的操作，不属于操作符重载，而 C++ 可以。
+- Java 的 goto 是保留字，但是不可用，C++ 可以使用 goto。
+- Java 不支持条件编译，C++ 通过 #ifdef #ifndef 等预处理命令从而实现条件编译。
-[What are the main differences between Java and C++?](http://cs-fundamentals.com/tech-interview/java/differences-between-java-and-cpp.php)
+[What are the main differences between Java and C++?](http://cs-fundamentals.com/tech-interview/java/differences-between-java-and-cpp.php)
-## JRE or JDK
+## JRE or JDK
-- JRE is the JVM program, Java application need to run on JRE.
-- JDK is a superset of JRE, JRE + tools for developing java programs. e.g, it provides the compiler "javac"
+- JRE is the JVM program, Java application need to run on JRE.
+- JDK is a superset of JRE, JRE + tools for developing java programs. e.g, it provides the compiler "javac"
-# 参考资料
+# 参考资料
-- Eckel B. Java 编程思想[M]. 机械工业出版社, 2002.
-- Bloch J. Effective java[M]. Addison-Wesley Professional, 2017.
+- Eckel B. Java 编程思想[M]. 机械工业出版社, 2002.
+- Bloch J. Effective java[M]. Addison-Wesley Professional, 2017.
+---bottom---CyC---
+
+
diff --git a/docs/notes/Java 容器.md b/docs/notes/Java 容器.md
index 04902d87..b64d7987 100644
--- a/docs/notes/Java 容器.md
+++ b/docs/notes/Java 容器.md
@@ -1,326 +1,304 @@
-[🎉 面试进阶指南已上线](https://xiaozhuanlan.com/CyC2018)
-
-* [一、概览](#一概览)
- * [Collection](#collection)
- * [Map](#map)
-* [二、容器中的设计模式](#二容器中的设计模式)
- * [迭代器模式](#迭代器模式)
- * [适配器模式](#适配器模式)
-* [三、源码分析](#三源码分析)
- * [ArrayList](#arraylist)
- * [Vector](#vector)
- * [CopyOnWriteArrayList](#copyonwritearraylist)
- * [LinkedList](#linkedlist)
- * [HashMap](#hashmap)
- * [ConcurrentHashMap](#concurrenthashmap)
- * [LinkedHashMap](#linkedhashmap)
- * [WeakHashMap](#weakhashmap)
-* [附录](#附录)
-* [参考资料](#参考资料)
-
+# 一、概览
+
+容器主要包括 Collection 和 Map 两种，Collection 存储着对象的集合，而 Map 存储着键值对（两个对象）的映射表。
+
+## Collection
+
+
+
+### 1. Set
+
+- TreeSet：基于红黑树实现，支持有序性操作，例如根据一个范围查找元素的操作。但是查找效率不如 HashSet，HashSet 查找的时间复杂度为 O(1)，TreeSet 则为 O(logN)。
+
+- HashSet：基于哈希表实现，支持快速查找，但不支持有序性操作。并且失去了元素的插入顺序信息，也就是说使用 Iterator 遍历 HashSet 得到的结果是不确定的。
+
+- LinkedHashSet：具有 HashSet 的查找效率，且内部使用双向链表维护元素的插入顺序。
+
+### 2. List
+
+- ArrayList：基于动态数组实现，支持随机访问。
+
+- Vector：和 ArrayList 类似，但它是线程安全的。
+
+- LinkedList：基于双向链表实现，只能顺序访问，但是可以快速地在链表中间插入和删除元素。不仅如此，LinkedList 还可以用作栈、队列和双向队列。
+
+### 3. Queue
+
+- LinkedList：可以用它来实现双向队列。
+
+- PriorityQueue：基于堆结构实现，可以用它来实现优先队列。
+
+## Map
+
+
+
+- TreeMap：基于红黑树实现。
+
+- HashMap：基于哈希表实现。
+
+- HashTable：和 HashMap 类似，但它是线程安全的，这意味着同一时刻多个线程可以同时写入 HashTable 并且不会导致数据不一致。它是遗留类，不应该去使用它。现在可以使用 ConcurrentHashMap 来支持线程安全，并且 ConcurrentHashMap 的效率会更高，因为 ConcurrentHashMap 引入了分段锁。
+
+- LinkedHashMap：使用双向链表来维护元素的顺序，顺序为插入顺序或者最近最少使用（LRU）顺序。
-# 一、概览
+# 二、容器中的设计模式
-容器主要包括 Collection 和 Map 两种，Collection 存储着对象的集合，而 Map 存储着键值对（两个对象）的映射表。
+## 迭代器模式
-## Collection
+
- list = new ArrayList<>();
+List list = new ArrayList<>();
list.add("a");
list.add("b");
-for (String item : list) {
- System.out.println(item);
+for (String item : list) {
+ System.out.println(item);
}
```
-## 适配器模式
+## 适配器模式
-java.util.Arrays#asList() 可以把数组类型转换为 List 类型。
+java.util.Arrays#asList() 可以把数组类型转换为 List 类型。
```java
@SafeVarargs
-public static List asList(T... a)
+public static List asList(T... a)
```
-应该注意的是 asList() 的参数为泛型的变长参数，不能使用基本类型数组作为参数，只能使用相应的包装类型数组。
+应该注意的是 asList() 的参数为泛型的变长参数，不能使用基本类型数组作为参数，只能使用相应的包装类型数组。
```java
-Integer[] arr = {1, 2, 3};
-List list = Arrays.asList(arr);
+Integer[] arr = {1, 2, 3};
+List list = Arrays.asList(arr);
```
-也可以使用以下方式调用 asList()：
+也可以使用以下方式调用 asList()：
```java
-List list = Arrays.asList(1, 2, 3);
+List list = Arrays.asList(1, 2, 3);
```
-# 三、源码分析
+# 三、源码分析
-如果没有特别说明，以下源码分析基于 JDK 1.8。
+如果没有特别说明，以下源码分析基于 JDK 1.8。
-在 IDEA 中 double shift 调出 Search EveryWhere，查找源码文件，找到之后就可以阅读源码。
+在 IDEA 中 double shift 调出 Search EveryWhere，查找源码文件，找到之后就可以阅读源码。
-## ArrayList
+## ArrayList
-### 1. 概览
+### 1. 概览
-实现了 RandomAccess 接口，因此支持随机访问。这是理所当然的，因为 ArrayList 是基于数组实现的。
+实现了 RandomAccess 接口，因此支持随机访问。这是理所当然的，因为 ArrayList 是基于数组实现的。
```java
-public class ArrayList extends AbstractList
- implements List, RandomAccess, Cloneable, java.io.Serializable
+public class ArrayList extends AbstractList
+ implements List, RandomAccess, Cloneable, java.io.Serializable
```
-数组的默认大小为 10。
+数组的默认大小为 10。
```java
-private static final int DEFAULT_CAPACITY = 10;
+private static final int DEFAULT_CAPACITY = 10;
```
-### 2. 扩容
+### 2. 扩容
-添加元素时使用 ensureCapacityInternal() 方法来保证容量足够，如果不够时，需要使用 grow() 方法进行扩容，新容量的大小为 `oldCapacity + (oldCapacity >> 1)`，也就是旧容量的 1.5 倍。
+添加元素时使用 ensureCapacityInternal() 方法来保证容量足够，如果不够时，需要使用 grow() 方法进行扩容，新容量的大小为 `oldCapacity + (oldCapacity >> 1)`，也就是旧容量的 1.5 倍。
-扩容操作需要调用 `Arrays.copyOf()` 把原数组整个复制到新数组中，这个操作代价很高，因此最好在创建 ArrayList 对象时就指定大概的容量大小，减少扩容操作的次数。
+扩容操作需要调用 `Arrays.copyOf()` 把原数组整个复制到新数组中，这个操作代价很高，因此最好在创建 ArrayList 对象时就指定大概的容量大小，减少扩容操作的次数。
```java
-public boolean add(E e) {
- ensureCapacityInternal(size + 1); // Increments modCount!!
- elementData[size++] = e;
- return true;
+public boolean add(E e) {
+ ensureCapacityInternal(size + 1); // Increments modCount!!
+ elementData[size++] = e;
+ return true;
}
-private void ensureCapacityInternal(int minCapacity) {
- if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
- minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
- }
- ensureExplicitCapacity(minCapacity);
+private void ensureCapacityInternal(int minCapacity) {
+ if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
+ minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
+ }
+ ensureExplicitCapacity(minCapacity);
}
-private void ensureExplicitCapacity(int minCapacity) {
- modCount++;
- // overflow-conscious code
- if (minCapacity - elementData.length > 0)
- grow(minCapacity);
+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;
- 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 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);
}
```
-### 3. 删除元素
+### 3. 删除元素
-需要调用 System.arraycopy() 将 index+1 后面的元素都复制到 index 位置上，该操作的时间复杂度为 O(N)，可以看出 ArrayList 删除元素的代价是非常高的。
+需要调用 System.arraycopy() 将 index+1 后面的元素都复制到 index 位置上，该操作的时间复杂度为 O(N)，可以看出 ArrayList 删除元素的代价是非常高的。
```java
-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 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;
}
```
-### 4. Fail-Fast
+### 4. Fail-Fast
-modCount 用来记录 ArrayList 结构发生变化的次数。结构发生变化是指添加或者删除至少一个元素的所有操作，或者是调整内部数组的大小，仅仅只是设置元素的值不算结构发生变化。
+modCount 用来记录 ArrayList 结构发生变化的次数。结构发生变化是指添加或者删除至少一个元素的所有操作，或者是调整内部数组的大小，仅仅只是设置元素的值不算结构发生变化。
-在进行序列化或者迭代等操作时，需要比较操作前后 modCount 是否改变，如果改变了需要抛出 ConcurrentModificationException。
+在进行序列化或者迭代等操作时，需要比较操作前后 modCount 是否改变，如果改变了需要抛出 ConcurrentModificationException。
```java
-private void writeObject(java.io.ObjectOutputStream s)
- throws java.io.IOException{
- // Write out element count, and any hidden stuff
- int expectedModCount = modCount;
- s.defaultWriteObject();
+private void writeObject(java.io.ObjectOutputStream s)
+ throws java.io.IOException{
+ // Write out element count, and any hidden stuff
+ int expectedModCount = modCount;
+ s.defaultWriteObject();
- // Write out size as capacity for behavioural compatibility with clone()
- s.writeInt(size);
+ // 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 0) {
- // be like clone(), allocate array based upon size not capacity
- ensureCapacityInternal(size);
+ if (size > 0) {
+ // be like clone(), allocate array based upon size not capacity
+ ensureCapacityInternal(size);
- Object[] a = elementData;
- // Read in all elements in the proper order.
- for (int i=0; i= elementCount)
- throw new ArrayIndexOutOfBoundsException(index);
+public synchronized E get(int index) {
+ if (index >= elementCount)
+ throw new ArrayIndexOutOfBoundsException(index);
- return elementData(index);
+ return elementData(index);
}
```
-### 2. 与 ArrayList 的比较
+### 2. 与 ArrayList 的比较
-- Vector 是同步的，因此开销就比 ArrayList 要大，访问速度更慢。最好使用 ArrayList 而不是 Vector，因为同步操作完全可以由程序员自己来控制；
-- Vector 每次扩容请求其大小的 2 倍空间，而 ArrayList 是 1.5 倍。
+- Vector 是同步的，因此开销就比 ArrayList 要大，访问速度更慢。最好使用 ArrayList 而不是 Vector，因为同步操作完全可以由程序员自己来控制；
+- Vector 每次扩容请求其大小的 2 倍空间，而 ArrayList 是 1.5 倍。
-### 3. 替代方案
+### 3. 替代方案
-可以使用 `Collections.synchronizedList();` 得到一个线程安全的 ArrayList。
+可以使用 `Collections.synchronizedList();` 得到一个线程安全的 ArrayList。
```java
-List list = new ArrayList<>();
-List synList = Collections.synchronizedList(list);
+List list = new ArrayList<>();
+List synList = Collections.synchronizedList(list);
```
-也可以使用 concurrent 并发包下的 CopyOnWriteArrayList 类。
+也可以使用 concurrent 并发包下的 CopyOnWriteArrayList 类。
```java
-List list = new CopyOnWriteArrayList<>();
+List list = new CopyOnWriteArrayList<>();
```
-## CopyOnWriteArrayList
+## CopyOnWriteArrayList
-### 读写分离
+### 读写分离
写操作在一个复制的数组上进行，读操作还是在原始数组中进行，读写分离，互不影响。
@@ -329,827 +307,827 @@ List list = new CopyOnWriteArrayList<>();
写操作结束之后需要把原始数组指向新的复制数组。
```java
-public boolean add(E e) {
- final ReentrantLock lock = this.lock;
- lock.lock();
- try {
- Object[] elements = getArray();
- int len = elements.length;
- Object[] newElements = Arrays.copyOf(elements, len + 1);
- newElements[len] = e;
- setArray(newElements);
- return true;
- } finally {
- lock.unlock();
- }
+public boolean add(E e) {
+ final ReentrantLock lock = this.lock;
+ lock.lock();
+ try {
+ Object[] elements = getArray();
+ int len = elements.length;
+ Object[] newElements = Arrays.copyOf(elements, len + 1);
+ newElements[len] = e;
+ setArray(newElements);
+ return true;
+ } finally {
+ lock.unlock();
+ }
}
-final void setArray(Object[] a) {
- array = a;
+final void setArray(Object[] a) {
+ array = a;
}
```
```java
@SuppressWarnings("unchecked")
-private E get(Object[] a, int index) {
- return (E) a[index];
+private E get(Object[] a, int index) {
+ return (E) a[index];
}
```
-### 适用场景
+### 适用场景
-CopyOnWriteArrayList 在写操作的同时允许读操作，大大提高了读操作的性能，因此很适合读多写少的应用场景。
+CopyOnWriteArrayList 在写操作的同时允许读操作，大大提高了读操作的性能，因此很适合读多写少的应用场景。
-但是 CopyOnWriteArrayList 有其缺陷：
+但是 CopyOnWriteArrayList 有其缺陷：
-- 内存占用：在写操作时需要复制一个新的数组，使得内存占用为原来的两倍左右；
-- 数据不一致：读操作不能读取实时性的数据，因为部分写操作的数据还未同步到读数组中。
+- 内存占用：在写操作时需要复制一个新的数组，使得内存占用为原来的两倍左右；
+- 数据不一致：读操作不能读取实时性的数据，因为部分写操作的数据还未同步到读数组中。
-所以 CopyOnWriteArrayList 不适合内存敏感以及对实时性要求很高的场景。
+所以 CopyOnWriteArrayList 不适合内存敏感以及对实时性要求很高的场景。
-## LinkedList
+## LinkedList
-### 1. 概览
+### 1. 概览
-基于双向链表实现，使用 Node 存储链表节点信息。
+基于双向链表实现，使用 Node 存储链表节点信息。
```java
-private static class Node {
- E item;
- Node next;
- Node prev;
+private static class Node {
+ E item;
+ Node next;
+ Node prev;
}
```
-每个链表存储了 first 和 last 指针：
+每个链表存储了 first 和 last 指针：
```java
-transient Node first;
-transient Node last;
+transient Node first;
+transient Node last;
```
- implements Map.Entry {
- final K key;
- V value;
- Entry next;
- int hash;
+static class Entry implements Map.Entry {
+ final K key;
+ V value;
+ Entry next;
+ int hash;
- Entry(int h, K k, V v, Entry n) {
- value = v;
- next = n;
- key = k;
- hash = h;
- }
+ Entry(int h, K k, V v, Entry n) {
+ value = v;
+ next = n;
+ key = k;
+ hash = h;
+ }
- public final K getKey() {
- return key;
- }
+ public final K getKey() {
+ return key;
+ }
- public final V getValue() {
- return value;
- }
+ public final V getValue() {
+ return value;
+ }
- public final V setValue(V newValue) {
- V oldValue = value;
- value = newValue;
- return oldValue;
- }
+ public final V setValue(V newValue) {
+ V oldValue = value;
+ value = newValue;
+ return oldValue;
+ }
- public final boolean equals(Object o) {
- if (!(o instanceof Map.Entry))
- return false;
- Map.Entry e = (Map.Entry)o;
- Object k1 = getKey();
- Object k2 = e.getKey();
- if (k1 == k2 || (k1 != null && k1.equals(k2))) {
- Object v1 = getValue();
- Object v2 = e.getValue();
- if (v1 == v2 || (v1 != null && v1.equals(v2)))
- return true;
- }
- return false;
- }
+ public final boolean equals(Object o) {
+ if (!(o instanceof Map.Entry))
+ return false;
+ Map.Entry e = (Map.Entry)o;
+ Object k1 = getKey();
+ Object k2 = e.getKey();
+ if (k1 == k2 || (k1 != null && k1.equals(k2))) {
+ Object v1 = getValue();
+ Object v2 = e.getValue();
+ if (v1 == v2 || (v1 != null && v1.equals(v2)))
+ return true;
+ }
+ return false;
+ }
- public final int hashCode() {
- return Objects.hashCode(getKey()) ^ Objects.hashCode(getValue());
- }
+ public final int hashCode() {
+ return Objects.hashCode(getKey()) ^ Objects.hashCode(getValue());
+ }
- public final String toString() {
- return getKey() + "=" + getValue();
- }
+ public final String toString() {
+ return getKey() + "=" + getValue();
+ }
}
```
-### 2. 拉链法的工作原理
+### 2. 拉链法的工作原理
```java
-HashMap map = new HashMap<>();
-map.put("K1", "V1");
-map.put("K2", "V2");
-map.put("K3", "V3");
+HashMap map = new HashMap<>();
+map.put("K1", "V1");
+map.put("K2", "V2");
+map.put("K3", "V3");
```
-- 新建一个 HashMap，默认大小为 16；
-- 插入 <K1,V1> 键值对，先计算 K1 的 hashCode 为 115，使用除留余数法得到所在的桶下标 115%16=3。
-- 插入 <K2,V2> 键值对，先计算 K2 的 hashCode 为 118，使用除留余数法得到所在的桶下标 118%16=6。
-- 插入 <K3,V3> 键值对，先计算 K3 的 hashCode 为 118，使用除留余数法得到所在的桶下标 118%16=6，插在 <K2,V2> 前面。
+- 新建一个 HashMap，默认大小为 16；
+- 插入 <K1,V1> 键值对，先计算 K1 的 hashCode 为 115，使用除留余数法得到所在的桶下标 115%16=3。
+- 插入 <K2,V2> 键值对，先计算 K2 的 hashCode 为 118，使用除留余数法得到所在的桶下标 118%16=6。
+- 插入 <K3,V3> 键值对，先计算 K3 的 hashCode 为 118，使用除留余数法得到所在的桶下标 118%16=6，插在 <K2,V2> 前面。
-应该注意到链表的插入是以头插法方式进行的，例如上面的 <K3,V3> 不是插在 <K2,V2> 后面，而是插入在链表头部。
+应该注意到链表的插入是以头插法方式进行的，例如上面的 <K3,V3> 不是插在 <K2,V2> 后面，而是插入在链表头部。
查找需要分成两步进行：
-- 计算键值对所在的桶；
-- 在链表上顺序查找，时间复杂度显然和链表的长度成正比。
+- 计算键值对所在的桶；
+- 在链表上顺序查找，时间复杂度显然和链表的长度成正比。
- e = table[i]; e != null; e = e.next) {
- Object k;
- if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
- V oldValue = e.value;
- e.value = value;
- e.recordAccess(this);
- return oldValue;
- }
- }
+public V put(K key, V value) {
+ if (table == EMPTY_TABLE) {
+ inflateTable(threshold);
+ }
+ // 键为 null 单独处理
+ if (key == null)
+ return putForNullKey(value);
+ int hash = hash(key);
+ // 确定桶下标
+ int i = indexFor(hash, table.length);
+ // 先找出是否已经存在键为 key 的键值对，如果存在的话就更新这个键值对的值为 value
+ for (Entry e = table[i]; e != null; e = e.next) {
+ Object k;
+ if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
+ V oldValue = e.value;
+ e.value = value;
+ e.recordAccess(this);
+ return oldValue;
+ }
+ }
- modCount++;
- // 插入新键值对
- addEntry(hash, key, value, i);
- return null;
+ modCount++;
+ // 插入新键值对
+ addEntry(hash, key, value, i);
+ return null;
}
```
-HashMap 允许插入键为 null 的键值对。但是因为无法调用 null 的 hashCode() 方法，也就无法确定该键值对的桶下标，只能通过强制指定一个桶下标来存放。HashMap 使用第 0 个桶存放键为 null 的键值对。
+HashMap 允许插入键为 null 的键值对。但是因为无法调用 null 的 hashCode() 方法，也就无法确定该键值对的桶下标，只能通过强制指定一个桶下标来存放。HashMap 使用第 0 个桶存放键为 null 的键值对。
```java
-private V putForNullKey(V value) {
- for (Entry e = table[0]; e != null; e = e.next) {
- if (e.key == null) {
- V oldValue = e.value;
- e.value = value;
- e.recordAccess(this);
- return oldValue;
- }
- }
- modCount++;
- addEntry(0, null, value, 0);
- return null;
+private V putForNullKey(V value) {
+ for (Entry e = table[0]; e != null; e = e.next) {
+ if (e.key == null) {
+ V oldValue = e.value;
+ e.value = value;
+ e.recordAccess(this);
+ return oldValue;
+ }
+ }
+ modCount++;
+ addEntry(0, null, value, 0);
+ return null;
}
```
使用链表的头插法，也就是新的键值对插在链表的头部，而不是链表的尾部。
```java
-void addEntry(int hash, K key, V value, int bucketIndex) {
- if ((size >= threshold) && (null != table[bucketIndex])) {
- resize(2 * table.length);
- hash = (null != key) ? hash(key) : 0;
- bucketIndex = indexFor(hash, table.length);
- }
+void addEntry(int hash, K key, V value, int bucketIndex) {
+ if ((size >= threshold) && (null != table[bucketIndex])) {
+ resize(2 * table.length);
+ hash = (null != key) ? hash(key) : 0;
+ bucketIndex = indexFor(hash, table.length);
+ }
- createEntry(hash, key, value, bucketIndex);
+ createEntry(hash, key, value, bucketIndex);
}
-void createEntry(int hash, K key, V value, int bucketIndex) {
- Entry e = table[bucketIndex];
- // 头插法，链表头部指向新的键值对
- table[bucketIndex] = new Entry<>(hash, key, value, e);
- size++;
+void createEntry(int hash, K key, V value, int bucketIndex) {
+ Entry e = table[bucketIndex];
+ // 头插法，链表头部指向新的键值对
+ table[bucketIndex] = new Entry<>(hash, key, value, e);
+ size++;
}
```
```java
-Entry(int h, K k, V v, Entry n) {
- value = v;
- next = n;
- key = k;
- hash = h;
+Entry(int h, K k, V v, Entry n) {
+ value = v;
+ next = n;
+ key = k;
+ hash = h;
}
```
-### 4. 确定桶下标
+### 4. 确定桶下标
很多操作都需要先确定一个键值对所在的桶下标。
```java
-int hash = hash(key);
-int i = indexFor(hash, table.length);
+int hash = hash(key);
+int i = indexFor(hash, table.length);
```
-**4.1 计算 hash 值**
+**4.1 计算 hash 值**
```java
-final int hash(Object k) {
- int h = hashSeed;
- if (0 != h && k instanceof String) {
- return sun.misc.Hashing.stringHash32((String) k);
- }
+final int hash(Object k) {
+ int h = hashSeed;
+ if (0 != h && k instanceof String) {
+ return sun.misc.Hashing.stringHash32((String) k);
+ }
- h ^= k.hashCode();
+ h ^= k.hashCode();
- // This function ensures that hashCodes that differ only by
- // constant multiples at each bit position have a bounded
- // number of collisions (approximately 8 at default load factor).
- h ^= (h >>> 20) ^ (h >>> 12);
- return h ^ (h >>> 7) ^ (h >>> 4);
+ // This function ensures that hashCodes that differ only by
+ // constant multiples at each bit position have a bounded
+ // number of collisions (approximately 8 at default load factor).
+ h ^= (h >>> 20) ^ (h >>> 12);
+ return h ^ (h >>> 7) ^ (h >>> 4);
}
```
```java
-public final int hashCode() {
- return Objects.hashCode(key) ^ Objects.hashCode(value);
+public final int hashCode() {
+ return Objects.hashCode(key) ^ Objects.hashCode(value);
}
```
-**4.2 取模**
+**4.2 取模**
-令 x = 1<<4，即 x 为 2 的 4 次方，它具有以下性质：
+令 x = 1<<4，即 x 为 2 的 4 次方，它具有以下性质：
```
-x : 00010000
-x-1 : 00001111
+x : 00010000
+x-1 : 00001111
```
-令一个数 y 与 x-1 做与运算，可以去除 y 位级表示的第 4 位以上数：
+令一个数 y 与 x-1 做与运算，可以去除 y 位级表示的第 4 位以上数：
```
-y : 10110010
-x-1 : 00001111
-y&(x-1) : 00000010
+y : 10110010
+x-1 : 00001111
+y&(x-1) : 00000010
```
-这个性质和 y 对 x 取模效果是一样的：
+这个性质和 y 对 x 取模效果是一样的：
```
-y : 10110010
-x : 00010000
-y%x : 00000010
+y : 10110010
+x : 00010000
+y%x : 00000010
```
我们知道，位运算的代价比求模运算小的多，因此在进行这种计算时用位运算的话能带来更高的性能。
-确定桶下标的最后一步是将 key 的 hash 值对桶个数取模：hash%capacity，如果能保证 capacity 为 2 的 n 次方，那么就可以将这个操作转换为位运算。
+确定桶下标的最后一步是将 key 的 hash 值对桶个数取模：hash%capacity，如果能保证 capacity 为 2 的 n 次方，那么就可以将这个操作转换为位运算。
```java
-static int indexFor(int h, int length) {
- return h & (length-1);
+static int indexFor(int h, int length) {
+ return h & (length-1);
}
```
-### 5. 扩容-基本原理
+### 5. 扩容-基本原理
-设 HashMap 的 table 长度为 M，需要存储的键值对数量为 N，如果哈希函数满足均匀性的要求，那么每条链表的长度大约为 N/M，因此平均查找次数的复杂度为 O(N/M)。
+设 HashMap 的 table 长度为 M，需要存储的键值对数量为 N，如果哈希函数满足均匀性的要求，那么每条链表的长度大约为 N/M，因此平均查找次数的复杂度为 O(N/M)。
-为了让查找的成本降低，应该尽可能使得 N/M 尽可能小，因此需要保证 M 尽可能大，也就是说 table 要尽可能大。HashMap 采用动态扩容来根据当前的 N 值来调整 M 值，使得空间效率和时间效率都能得到保证。
+为了让查找的成本降低，应该尽可能使得 N/M 尽可能小，因此需要保证 M 尽可能大，也就是说 table 要尽可能大。HashMap 采用动态扩容来根据当前的 N 值来调整 M 值，使得空间效率和时间效率都能得到保证。
-和扩容相关的参数主要有：capacity、size、threshold 和 load_factor。
+和扩容相关的参数主要有：capacity、size、threshold 和 load_factor。
-| 参数 | 含义 |
-| :--: | :-- |
-| capacity | table 的容量大小，默认为 16。需要注意的是 capacity 必须保证为 2 的 n 次方。|
-| size | 键值对数量。 |
-| threshold | size 的临界值，当 size 大于等于 threshold 就必须进行扩容操作。 |
-| loadFactor | 装载因子，table 能够使用的比例，threshold = capacity * loadFactor。|
+| 参数 | 含义 |
+| :--: | :-- |
+| capacity | table 的容量大小，默认为 16。需要注意的是 capacity 必须保证为 2 的 n 次方。|
+| size | 键值对数量。 |
+| threshold | size 的临界值，当 size 大于等于 threshold 就必须进行扩容操作。 |
+| loadFactor | 装载因子，table 能够使用的比例，threshold = capacity * loadFactor。|
```java
-static final int DEFAULT_INITIAL_CAPACITY = 16;
+static final int DEFAULT_INITIAL_CAPACITY = 16;
-static final int MAXIMUM_CAPACITY = 1 << 30;
+static final int MAXIMUM_CAPACITY = 1 << 30;
-static final float DEFAULT_LOAD_FACTOR = 0.75f;
+static final float DEFAULT_LOAD_FACTOR = 0.75f;
-transient Entry[] table;
+transient Entry[] table;
-transient int size;
+transient int size;
-int threshold;
+int threshold;
-final float loadFactor;
+final float loadFactor;
-transient int modCount;
+transient int modCount;
```
-从下面的添加元素代码中可以看出，当需要扩容时，令 capacity 为原来的两倍。
+从下面的添加元素代码中可以看出，当需要扩容时，令 capacity 为原来的两倍。
```java
-void addEntry(int hash, K key, V value, int bucketIndex) {
- Entry e = table[bucketIndex];
- table[bucketIndex] = new Entry<>(hash, key, value, e);
- if (size++ >= threshold)
- resize(2 * table.length);
+void addEntry(int hash, K key, V value, int bucketIndex) {
+ Entry e = table[bucketIndex];
+ table[bucketIndex] = new Entry<>(hash, key, value, e);
+ if (size++ >= threshold)
+ resize(2 * table.length);
}
```
-扩容使用 resize() 实现，需要注意的是，扩容操作同样需要把 oldTable 的所有键值对重新插入 newTable 中，因此这一步是很费时的。
+扩容使用 resize() 实现，需要注意的是，扩容操作同样需要把 oldTable 的所有键值对重新插入 newTable 中，因此这一步是很费时的。
```java
-void resize(int newCapacity) {
- Entry[] oldTable = table;
- int oldCapacity = oldTable.length;
- if (oldCapacity == MAXIMUM_CAPACITY) {
- threshold = Integer.MAX_VALUE;
- return;
- }
- Entry[] newTable = new Entry[newCapacity];
- transfer(newTable);
- table = newTable;
- threshold = (int)(newCapacity * loadFactor);
+void resize(int newCapacity) {
+ Entry[] oldTable = table;
+ int oldCapacity = oldTable.length;
+ if (oldCapacity == MAXIMUM_CAPACITY) {
+ threshold = Integer.MAX_VALUE;
+ return;
+ }
+ Entry[] newTable = new Entry[newCapacity];
+ transfer(newTable);
+ table = newTable;
+ threshold = (int)(newCapacity * loadFactor);
}
-void transfer(Entry[] newTable) {
- Entry[] src = table;
- int newCapacity = newTable.length;
- for (int j = 0; j < src.length; j++) {
- Entry e = src[j];
- if (e != null) {
- src[j] = null;
- do {
- Entry next = e.next;
- int i = indexFor(e.hash, newCapacity);
- e.next = newTable[i];
- newTable[i] = e;
- e = next;
- } while (e != null);
- }
- }
+void transfer(Entry[] newTable) {
+ Entry[] src = table;
+ int newCapacity = newTable.length;
+ for (int j = 0; j < src.length; j++) {
+ Entry e = src[j];
+ if (e != null) {
+ src[j] = null;
+ do {
+ Entry next = e.next;
+ int i = indexFor(e.hash, newCapacity);
+ e.next = newTable[i];
+ newTable[i] = e;
+ e = next;
+ } while (e != null);
+ }
+ }
}
```
-### 6. 扩容-重新计算桶下标
+### 6. 扩容-重新计算桶下标
-在进行扩容时，需要把键值对重新放到对应的桶上。HashMap 使用了一个特殊的机制，可以降低重新计算桶下标的操作。
+在进行扩容时，需要把键值对重新放到对应的桶上。HashMap 使用了一个特殊的机制，可以降低重新计算桶下标的操作。
-假设原数组长度 capacity 为 16，扩容之后 new capacity 为 32：
+假设原数组长度 capacity 为 16，扩容之后 new capacity 为 32：
```html
-capacity : 00010000
-new capacity : 00100000
+capacity : 00010000
+new capacity : 00100000
```
-对于一个 Key，
+对于一个 Key，
-- 它的哈希值如果在第 5 位上为 0，那么取模得到的结果和之前一样；
-- 如果为 1，那么得到的结果为原来的结果 +16。
+- 它的哈希值如果在第 5 位上为 0，那么取模得到的结果和之前一样；
+- 如果为 1，那么得到的结果为原来的结果 +16。
-### 7. 计算数组容量
+### 7. 计算数组容量
-HashMap 构造函数允许用户传入的容量不是 2 的 n 次方，因为它可以自动地将传入的容量转换为 2 的 n 次方。
+HashMap 构造函数允许用户传入的容量不是 2 的 n 次方，因为它可以自动地将传入的容量转换为 2 的 n 次方。
-先考虑如何求一个数的掩码，对于 10010000，它的掩码为 11111111，可以使用以下方法得到：
+先考虑如何求一个数的掩码，对于 10010000，它的掩码为 11111111，可以使用以下方法得到：
```
-mask |= mask >> 1 11011000
-mask |= mask >> 2 11111110
-mask |= mask >> 4 11111111
+mask |= mask >> 1 11011000
+mask |= mask >> 2 11111110
+mask |= mask >> 4 11111111
```
-mask+1 是大于原始数字的最小的 2 的 n 次方。
+mask+1 是大于原始数字的最小的 2 的 n 次方。
```
-num 10010000
-mask+1 100000000
+num 10010000
+mask+1 100000000
```
-以下是 HashMap 中计算数组容量的代码：
+以下是 HashMap 中计算数组容量的代码：
```java
-static final int tableSizeFor(int cap) {
- int n = cap - 1;
- n |= n >>> 1;
- n |= n >>> 2;
- n |= n >>> 4;
- n |= n >>> 8;
- n |= n >>> 16;
- return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
+static final int tableSizeFor(int cap) {
+ int n = cap - 1;
+ n |= n >>> 1;
+ n |= n >>> 2;
+ n |= n >>> 4;
+ n |= n >>> 8;
+ n |= n >>> 16;
+ return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
}
```
-### 8. 链表转红黑树
+### 8. 链表转红黑树
-从 JDK 1.8 开始，一个桶存储的链表长度大于 8 时会将链表转换为红黑树。
+从 JDK 1.8 开始，一个桶存储的链表长度大于 8 时会将链表转换为红黑树。
-### 9. 与 HashTable 的比较
+### 9. 与 HashTable 的比较
-- HashTable 使用 synchronized 来进行同步。
-- HashMap 可以插入键为 null 的 Entry。
-- HashMap 的迭代器是 fail-fast 迭代器。
-- HashMap 不能保证随着时间的推移 Map 中的元素次序是不变的。
+- HashTable 使用 synchronized 来进行同步。
+- HashMap 可以插入键为 null 的 Entry。
+- HashMap 的迭代器是 fail-fast 迭代器。
+- HashMap 不能保证随着时间的推移 Map 中的元素次序是不变的。
-## ConcurrentHashMap
+## ConcurrentHashMap
-### 1. 存储结构
+### 1. 存储结构
```java
-static final class HashEntry {
- final int hash;
- final K key;
- volatile V value;
- volatile HashEntry next;
+static final class HashEntry {
+ final int hash;
+ final K key;
+ volatile V value;
+ volatile HashEntry next;
}
```
-ConcurrentHashMap 和 HashMap 实现上类似，最主要的差别是 ConcurrentHashMap 采用了分段锁（Segment），每个分段锁维护着几个桶（HashEntry），多个线程可以同时访问不同分段锁上的桶，从而使其并发度更高（并发度就是 Segment 的个数）。
+ConcurrentHashMap 和 HashMap 实现上类似，最主要的差别是 ConcurrentHashMap 采用了分段锁（Segment），每个分段锁维护着几个桶（HashEntry），多个线程可以同时访问不同分段锁上的桶，从而使其并发度更高（并发度就是 Segment 的个数）。
-Segment 继承自 ReentrantLock。
+Segment 继承自 ReentrantLock。
```java
-static final class Segment extends ReentrantLock implements Serializable {
+static final class Segment extends ReentrantLock implements Serializable {
- private static final long serialVersionUID = 2249069246763182397L;
+ private static final long serialVersionUID = 2249069246763182397L;
- static final int MAX_SCAN_RETRIES =
- Runtime.getRuntime().availableProcessors() > 1 ? 64 : 1;
+ static final int MAX_SCAN_RETRIES =
+ Runtime.getRuntime().availableProcessors() > 1 ? 64 : 1;
- transient volatile HashEntry[] table;
+ transient volatile HashEntry[] table;
- transient int count;
+ transient int count;
- transient int modCount;
+ transient int modCount;
- transient int threshold;
+ transient int threshold;
- final float loadFactor;
+ final float loadFactor;
}
```
```java
-final Segment[] segments;
+final Segment[] segments;
```
-默认的并发级别为 16，也就是说默认创建 16 个 Segment。
+默认的并发级别为 16，也就是说默认创建 16 个 Segment。
```java
-static final int DEFAULT_CONCURRENCY_LEVEL = 16;
+static final int DEFAULT_CONCURRENCY_LEVEL = 16;
```
- [] segments = this.segments;
- int size;
- boolean overflow; // true if size overflows 32 bits
- long sum; // sum of modCounts
- long last = 0L; // previous sum
- int retries = -1; // first iteration isn't retry
- try {
- for (;;) {
- // 超过尝试次数，则对每个 Segment 加锁
- if (retries++ == RETRIES_BEFORE_LOCK) {
- for (int j = 0; j < segments.length; ++j)
- ensureSegment(j).lock(); // force creation
- }
- sum = 0L;
- size = 0;
- overflow = false;
- for (int j = 0; j < segments.length; ++j) {
- Segment seg = segmentAt(segments, j);
- if (seg != null) {
- sum += seg.modCount;
- int c = seg.count;
- if (c < 0 || (size += c) < 0)
- overflow = true;
- }
- }
- // 连续两次得到的结果一致，则认为这个结果是正确的
- if (sum == last)
- break;
- last = sum;
- }
- } finally {
- if (retries > RETRIES_BEFORE_LOCK) {
- for (int j = 0; j < segments.length; ++j)
- segmentAt(segments, j).unlock();
- }
- }
- return overflow ? Integer.MAX_VALUE : size;
+public int size() {
+ // Try a few times to get accurate count. On failure due to
+ // continuous async changes in table, resort to locking.
+ final Segment[] segments = this.segments;
+ int size;
+ boolean overflow; // true if size overflows 32 bits
+ long sum; // sum of modCounts
+ long last = 0L; // previous sum
+ int retries = -1; // first iteration isn't retry
+ try {
+ for (;;) {
+ // 超过尝试次数，则对每个 Segment 加锁
+ if (retries++ == RETRIES_BEFORE_LOCK) {
+ for (int j = 0; j < segments.length; ++j)
+ ensureSegment(j).lock(); // force creation
+ }
+ sum = 0L;
+ size = 0;
+ overflow = false;
+ for (int j = 0; j < segments.length; ++j) {
+ Segment seg = segmentAt(segments, j);
+ if (seg != null) {
+ sum += seg.modCount;
+ int c = seg.count;
+ if (c < 0 || (size += c) < 0)
+ overflow = true;
+ }
+ }
+ // 连续两次得到的结果一致，则认为这个结果是正确的
+ if (sum == last)
+ break;
+ last = sum;
+ }
+ } finally {
+ if (retries > RETRIES_BEFORE_LOCK) {
+ for (int j = 0; j < segments.length; ++j)
+ segmentAt(segments, j).unlock();
+ }
+ }
+ return overflow ? Integer.MAX_VALUE : size;
}
```
-### 3. JDK 1.8 的改动
+### 3. JDK 1.8 的改动
-JDK 1.7 使用分段锁机制来实现并发更新操作，核心类为 Segment，它继承自重入锁 ReentrantLock，并发度与 Segment 数量相等。
+JDK 1.7 使用分段锁机制来实现并发更新操作，核心类为 Segment，它继承自重入锁 ReentrantLock，并发度与 Segment 数量相等。
-JDK 1.8 使用了 CAS 操作来支持更高的并发度，在 CAS 操作失败时使用内置锁 synchronized。
+JDK 1.8 使用了 CAS 操作来支持更高的并发度，在 CAS 操作失败时使用内置锁 synchronized。
-并且 JDK 1.8 的实现也在链表过长时会转换为红黑树。
+并且 JDK 1.8 的实现也在链表过长时会转换为红黑树。
-## LinkedHashMap
+## LinkedHashMap
-### 存储结构
+### 存储结构
-继承自 HashMap，因此具有和 HashMap 一样的快速查找特性。
+继承自 HashMap，因此具有和 HashMap 一样的快速查找特性。
```java
-public class LinkedHashMap extends HashMap implements Map
+public class LinkedHashMap extends HashMap implements Map
```
-内部维护了一个双向链表，用来维护插入顺序或者 LRU 顺序。
+内部维护了一个双向链表，用来维护插入顺序或者 LRU 顺序。
```java
/**
- * The head (eldest) of the doubly linked list.
- */
-transient LinkedHashMap.Entry head;
+ * The head (eldest) of the doubly linked list.
+ */
+transient LinkedHashMap.Entry head;
/**
- * The tail (youngest) of the doubly linked list.
- */
-transient LinkedHashMap.Entry tail;
+ * The tail (youngest) of the doubly linked list.
+ */
+transient LinkedHashMap.Entry tail;
```
-accessOrder 决定了顺序，默认为 false，此时维护的是插入顺序。
+accessOrder 决定了顺序，默认为 false，此时维护的是插入顺序。
```java
-final boolean accessOrder;
+final boolean accessOrder;
```
-LinkedHashMap 最重要的是以下用于维护顺序的函数，它们会在 put、get 等方法中调用。
+LinkedHashMap 最重要的是以下用于维护顺序的函数，它们会在 put、get 等方法中调用。
```java
-void afterNodeAccess(Node p) { }
-void afterNodeInsertion(boolean evict) { }
+void afterNodeAccess(Node p) { }
+void afterNodeInsertion(boolean evict) { }
```
-### afterNodeAccess()
+### afterNodeAccess()
-当一个节点被访问时，如果 accessOrder 为 true，则会将该节点移到链表尾部。也就是说指定为 LRU 顺序之后，在每次访问一个节点时，会将这个节点移到链表尾部，保证链表尾部是最近访问的节点，那么链表首部就是最近最久未使用的节点。
+当一个节点被访问时，如果 accessOrder 为 true，则会将该节点移到链表尾部。也就是说指定为 LRU 顺序之后，在每次访问一个节点时，会将这个节点移到链表尾部，保证链表尾部是最近访问的节点，那么链表首部就是最近最久未使用的节点。
```java
-void afterNodeAccess(Node e) { // move node to last
- LinkedHashMap.Entry last;
- if (accessOrder && (last = tail) != e) {
- LinkedHashMap.Entry p =
- (LinkedHashMap.Entry)e, b = p.before, a = p.after;
- p.after = null;
- if (b == null)
- head = a;
- else
- b.after = a;
- if (a != null)
- a.before = b;
- else
- last = b;
- if (last == null)
- head = p;
- else {
- p.before = last;
- last.after = p;
- }
- tail = p;
- ++modCount;
- }
+void afterNodeAccess(Node e) { // move node to last
+ LinkedHashMap.Entry last;
+ if (accessOrder && (last = tail) != e) {
+ LinkedHashMap.Entry p =
+ (LinkedHashMap.Entry)e, b = p.before, a = p.after;
+ p.after = null;
+ if (b == null)
+ head = a;
+ else
+ b.after = a;
+ if (a != null)
+ a.before = b;
+ else
+ last = b;
+ if (last == null)
+ head = p;
+ else {
+ p.before = last;
+ last.after = p;
+ }
+ tail = p;
+ ++modCount;
+ }
}
```
-### afterNodeInsertion()
+### afterNodeInsertion()
-在 put 等操作之后执行，当 removeEldestEntry() 方法返回 true 时会移除最晚的节点，也就是链表首部节点 first。
+在 put 等操作之后执行，当 removeEldestEntry() 方法返回 true 时会移除最晚的节点，也就是链表首部节点 first。
-evict 只有在构建 Map 的时候才为 false，在这里为 true。
+evict 只有在构建 Map 的时候才为 false，在这里为 true。
```java
-void afterNodeInsertion(boolean evict) { // possibly remove eldest
- LinkedHashMap.Entry first;
- if (evict && (first = head) != null && removeEldestEntry(first)) {
- K key = first.key;
- removeNode(hash(key), key, null, false, true);
- }
+void afterNodeInsertion(boolean evict) { // possibly remove eldest
+ LinkedHashMap.Entry first;
+ if (evict && (first = head) != null && removeEldestEntry(first)) {
+ K key = first.key;
+ removeNode(hash(key), key, null, false, true);
+ }
}
```
-removeEldestEntry() 默认为 false，如果需要让它为 true，需要继承 LinkedHashMap 并且覆盖这个方法的实现，这在实现 LRU 的缓存中特别有用，通过移除最近最久未使用的节点，从而保证缓存空间足够，并且缓存的数据都是热点数据。
+removeEldestEntry() 默认为 false，如果需要让它为 true，需要继承 LinkedHashMap 并且覆盖这个方法的实现，这在实现 LRU 的缓存中特别有用，通过移除最近最久未使用的节点，从而保证缓存空间足够，并且缓存的数据都是热点数据。
```java
-protected boolean removeEldestEntry(Map.Entry eldest) {
- return false;
+protected boolean removeEldestEntry(Map.Entry eldest) {
+ return false;
}
```
-### LRU 缓存
+### LRU 缓存
-以下是使用 LinkedHashMap 实现的一个 LRU 缓存：
+以下是使用 LinkedHashMap 实现的一个 LRU 缓存：
-- 设定最大缓存空间 MAX_ENTRIES 为 3；
-- 使用 LinkedHashMap 的构造函数将 accessOrder 设置为 true，开启 LRU 顺序；
-- 覆盖 removeEldestEntry() 方法实现，在节点多于 MAX_ENTRIES 就会将最近最久未使用的数据移除。
+- 设定最大缓存空间 MAX_ENTRIES 为 3；
+- 使用 LinkedHashMap 的构造函数将 accessOrder 设置为 true，开启 LRU 顺序；
+- 覆盖 removeEldestEntry() 方法实现，在节点多于 MAX_ENTRIES 就会将最近最久未使用的数据移除。
```java
-class LRUCache extends LinkedHashMap {
- private static final int MAX_ENTRIES = 3;
+class LRUCache extends LinkedHashMap {
+ private static final int MAX_ENTRIES = 3;
- protected boolean removeEldestEntry(Map.Entry eldest) {
- return size() > MAX_ENTRIES;
- }
+ protected boolean removeEldestEntry(Map.Entry eldest) {
+ return size() > MAX_ENTRIES;
+ }
- LRUCache() {
- super(MAX_ENTRIES, 0.75f, true);
- }
+ LRUCache() {
+ super(MAX_ENTRIES, 0.75f, true);
+ }
}
```
```java
-public static void main(String[] args) {
- LRUCache cache = new LRUCache<>();
- cache.put(1, "a");
- cache.put(2, "b");
- cache.put(3, "c");
- cache.get(1);
- cache.put(4, "d");
- System.out.println(cache.keySet());
+public static void main(String[] args) {
+ LRUCache cache = new LRUCache<>();
+ cache.put(1, "a");
+ cache.put(2, "b");
+ cache.put(3, "c");
+ cache.get(1);
+ cache.put(4, "d");
+ System.out.println(cache.keySet());
}
```
```html
-[3, 1, 4]
+[3, 1, 4]
```
-## WeakHashMap
+## WeakHashMap
-### 存储结构
+### 存储结构
-WeakHashMap 的 Entry 继承自 WeakReference，被 WeakReference 关联的对象在下一次垃圾回收时会被回收。
+WeakHashMap 的 Entry 继承自 WeakReference，被 WeakReference 关联的对象在下一次垃圾回收时会被回收。
-WeakHashMap 主要用来实现缓存，通过使用 WeakHashMap 来引用缓存对象，由 JVM 对这部分缓存进行回收。
+WeakHashMap 主要用来实现缓存，通过使用 WeakHashMap 来引用缓存对象，由 JVM 对这部分缓存进行回收。
```java
-private static class Entry extends WeakReference implements Map.Entry
+private static class Entry extends WeakReference implements Map.Entry
```
-### ConcurrentCache
+### ConcurrentCache
-Tomcat 中的 ConcurrentCache 使用了 WeakHashMap 来实现缓存功能。
+Tomcat 中的 ConcurrentCache 使用了 WeakHashMap 来实现缓存功能。
-ConcurrentCache 采取的是分代缓存：
+ConcurrentCache 采取的是分代缓存：
-- 经常使用的对象放入 eden 中，eden 使用 ConcurrentHashMap 实现，不用担心会被回收（伊甸园）；
-- 不常用的对象放入 longterm，longterm 使用 WeakHashMap 实现，这些老对象会被垃圾收集器回收。
-- 当调用 get() 方法时，会先从 eden 区获取，如果没有找到的话再到 longterm 获取，当从 longterm 获取到就把对象放入 eden 中，从而保证经常被访问的节点不容易被回收。
-- 当调用 put() 方法时，如果 eden 的大小超过了 size，那么就将 eden 中的所有对象都放入 longterm 中，利用虚拟机回收掉一部分不经常使用的对象。
+- 经常使用的对象放入 eden 中，eden 使用 ConcurrentHashMap 实现，不用担心会被回收（伊甸园）；
+- 不常用的对象放入 longterm，longterm 使用 WeakHashMap 实现，这些老对象会被垃圾收集器回收。
+- 当调用 get() 方法时，会先从 eden 区获取，如果没有找到的话再到 longterm 获取，当从 longterm 获取到就把对象放入 eden 中，从而保证经常被访问的节点不容易被回收。
+- 当调用 put() 方法时，如果 eden 的大小超过了 size，那么就将 eden 中的所有对象都放入 longterm 中，利用虚拟机回收掉一部分不经常使用的对象。
```java
-public final class ConcurrentCache {
+public final class ConcurrentCache {
- private final int size;
+ private final int size;
- private final Map eden;
+ private final Map eden;
- private final Map longterm;
+ private final Map longterm;
- public ConcurrentCache(int size) {
- this.size = size;
- this.eden = new ConcurrentHashMap<>(size);
- this.longterm = new WeakHashMap<>(size);
- }
+ public ConcurrentCache(int size) {
+ this.size = size;
+ this.eden = new ConcurrentHashMap<>(size);
+ this.longterm = new WeakHashMap<>(size);
+ }
- public V get(K k) {
- V v = this.eden.get(k);
- if (v == null) {
- v = this.longterm.get(k);
- if (v != null)
- this.eden.put(k, v);
- }
- return v;
- }
+ public V get(K k) {
+ V v = this.eden.get(k);
+ if (v == null) {
+ v = this.longterm.get(k);
+ if (v != null)
+ this.eden.put(k, v);
+ }
+ return v;
+ }
- public void put(K k, V v) {
- if (this.eden.size() >= size) {
- this.longterm.putAll(this.eden);
- this.eden.clear();
- }
- this.eden.put(k, v);
- }
+ public void put(K k, V v) {
+ if (this.eden.size() >= size) {
+ this.longterm.putAll(this.eden);
+ this.eden.clear();
+ }
+ this.eden.put(k, v);
+ }
}
```
-# 附录
+# 附录
-Collection 绘图源码：
+Collection 绘图源码：
```
@startuml
-interface Collection
-interface Set
-interface List
-interface Queue
-interface SortSet
+interface Collection
+interface Set
+interface List
+interface Queue
+interface SortSet
-class HashSet
-class LinkedHashSet
-class TreeSet
-class ArrayList
-class Vector
-class LinkedList
-class PriorityQueue
+class HashSet
+class LinkedHashSet
+class TreeSet
+class ArrayList
+class Vector
+class LinkedList
+class PriorityQueue
-Collection <|-- Set
-Collection <|-- List
-Collection <|-- Queue
-Set <|-- SortSet
+Collection <|-- Set
+Collection <|-- List
+Collection <|-- Queue
+Set <|-- SortSet
-Set <|.. HashSet
-Set <|.. LinkedHashSet
-SortSet <|.. TreeSet
-List <|.. ArrayList
-List <|.. Vector
-List <|.. LinkedList
-Queue <|.. LinkedList
-Queue <|.. PriorityQueue
+Set <|.. HashSet
+Set <|.. LinkedHashSet
+SortSet <|.. TreeSet
+List <|.. ArrayList
+List <|.. Vector
+List <|.. LinkedList
+Queue <|.. LinkedList
+Queue <|.. PriorityQueue
@enduml
```
-Map 绘图源码
+Map 绘图源码
```
@startuml
-interface Map
-interface SortMap
+interface Map
+interface SortMap
-class HashTable
-class LinkedHashMap
-class HashMap
-class TreeMap
+class HashTable
+class LinkedHashMap
+class HashMap
+class TreeMap
-Map <|.. HashTable
-Map <|.. LinkedHashMap
-Map <|.. HashMap
-Map <|-- SortMap
-SortMap <|.. TreeMap
+Map <|.. HashTable
+Map <|.. LinkedHashMap
+Map <|.. HashMap
+Map <|-- SortMap
+SortMap <|.. TreeMap
@enduml
```
@@ -1159,36 +1137,44 @@ SortMap <|.. TreeMap
```
@startuml
-interface Iterable
-interface Collection
-interface List
-interface Set
-interface Queue
-interface Iterator
-interface ListIterator
+interface Iterable
+interface Collection
+interface List
+interface Set
+interface Queue
+interface Iterator
+interface ListIterator
-Iterable <|-- Collection
-Collection <|.. List
-Collection <|.. Set
-Collection <|-- Queue
-Iterator <-- Iterable
-Iterator <|.. ListIterator
-ListIterator <-- List
+Iterable <|-- Collection
+Collection <|.. List
+Collection <|.. Set
+Collection <|-- Queue
+Iterator <-- Iterable
+Iterator <|.. ListIterator
+ListIterator <-- List
@enduml
```
-# 参考资料
+# 参考资料
-- Eckel B. Java 编程思想 [M]. 机械工业出版社, 2002.
-- [Java Collection Framework](https://www.w3resource.com/java-tutorial/java-collections.php)
-- [Iterator 模式](https://openhome.cc/Gossip/DesignPattern/IteratorPattern.htm)
-- [Java 8 系列之重新认识 HashMap](https://tech.meituan.com/java_hashmap.html)
-- [What is difference between HashMap and Hashtable in Java?](http://javarevisited.blogspot.hk/2010/10/difference-between-hashmap-and.html)
-- [Java 集合之 HashMap](http://www.zhangchangle.com/2018/02/07/Java%E9%9B%86%E5%90%88%E4%B9%8BHashMap/)
-- [The principle of ConcurrentHashMap analysis](http://www.programering.com/a/MDO3QDNwATM.html)
-- [探索 ConcurrentHashMap 高并发性的实现机制](https://www.ibm.com/developerworks/cn/java/java-lo-concurrenthashmap/)
-- [HashMap 相关面试题及其解答](https://www.jianshu.com/p/75adf47958a7)
-- [Java 集合细节（二）：asList 的缺陷](http://wiki.jikexueyuan.com/project/java-enhancement/java-thirtysix.html)
-- [Java Collection Framework – The LinkedList Class](http://javaconceptoftheday.com/java-collection-framework-linkedlist-class/)
+- Eckel B. Java 编程思想 [M]. 机械工业出版社, 2002.
+- [Java Collection Framework](https://www.w3resource.com/java-tutorial/java-collections.php)
+- [Iterator 模式](https://openhome.cc/Gossip/DesignPattern/IteratorPattern.htm)
+- [Java 8 系列之重新认识 HashMap](https://tech.meituan.com/java_hashmap.html)
+- [What is difference between HashMap and Hashtable in Java?](http://javarevisited.blogspot.hk/2010/10/difference-between-hashmap-and.html)
+- [Java 集合之 HashMap](http://www.zhangchangle.com/2018/02/07/Java%E9%9B%86%E5%90%88%E4%B9%8BHashMap/)
+- [The principle of ConcurrentHashMap analysis](http://www.programering.com/a/MDO3QDNwATM.html)
+- [探索 ConcurrentHashMap 高并发性的实现机制](https://www.ibm.com/developerworks/cn/java/java-lo-concurrenthashmap/)
+- [HashMap 相关面试题及其解答](https://www.jianshu.com/p/75adf47958a7)
+- [Java 集合细节（二）：asList 的缺陷](http://wiki.jikexueyuan.com/project/java-enhancement/java-thirtysix.html)
+- [Java Collection Framework – The LinkedList Class](http://javaconceptoftheday.com/java-collection-framework-linkedlist-class/)
+---bottom---CyC---
+
+
+
+
+
+
+
diff --git a/docs/notes/Java 并发.md b/docs/notes/Java 并发.md
index b4f3693b..e12e48b2 100644
--- a/docs/notes/Java 并发.md
+++ b/docs/notes/Java 并发.md
@@ -1,624 +1,562 @@
-[🎉 面试进阶指南已上线](https://xiaozhuanlan.com/CyC2018)
-
-* [一、线程状态转换](#一线程状态转换)
- * [新建（New）](#新建new)
- * [可运行（Runnable）](#可运行runnable)
- * [阻塞（Blocking）](#阻塞blocking)
- * [无限期等待（Waiting）](#无限期等待waiting)
- * [限期等待（Timed Waiting）](#限期等待timed-waiting)
- * [死亡（Terminated）](#死亡terminated)
-* [二、使用线程](#二使用线程)
- * [实现 Runnable 接口](#实现-runnable-接口)
- * [实现 Callable 接口](#实现-callable-接口)
- * [继承 Thread 类](#继承-thread-类)
- * [实现接口 VS 继承 Thread](#实现接口-vs-继承-thread)
-* [三、基础线程机制](#三基础线程机制)
- * [Executor](#executor)
- * [Daemon](#daemon)
- * [sleep()](#sleep)
- * [yield()](#yield)
-* [四、中断](#四中断)
- * [InterruptedException](#interruptedexception)
- * [interrupted()](#interrupted)
- * [Executor 的中断操作](#executor-的中断操作)
-* [五、互斥同步](#五互斥同步)
- * [synchronized](#synchronized)
- * [ReentrantLock](#reentrantlock)
- * [比较](#比较)
- * [使用选择](#使用选择)
-* [六、线程之间的协作](#六线程之间的协作)
- * [join()](#join)
- * [wait() notify() notifyAll()](#wait-notify-notifyall)
- * [await() signal() signalAll()](#await-signal-signalall)
-* [七、J.U.C - AQS](#七juc---aqs)
- * [CountdownLatch](#countdownlatch)
- * [CyclicBarrier](#cyclicbarrier)
- * [Semaphore](#semaphore)
-* [八、J.U.C - 其它组件](#八juc---其它组件)
- * [FutureTask](#futuretask)
- * [BlockingQueue](#blockingqueue)
- * [ForkJoin](#forkjoin)
-* [九、线程不安全示例](#九线程不安全示例)
-* [十、Java 内存模型](#十java-内存模型)
- * [主内存与工作内存](#主内存与工作内存)
- * [内存间交互操作](#内存间交互操作)
- * [内存模型三大特性](#内存模型三大特性)
- * [先行发生原则](#先行发生原则)
-* [十一、线程安全](#十一线程安全)
- * [不可变](#不可变)
- * [互斥同步](#互斥同步)
- * [非阻塞同步](#非阻塞同步)
- * [无同步方案](#无同步方案)
-* [十二、锁优化](#十二锁优化)
- * [自旋锁](#自旋锁)
- * [锁消除](#锁消除)
- * [锁粗化](#锁粗化)
- * [轻量级锁](#轻量级锁)
- * [偏向锁](#偏向锁)
-* [十三、多线程开发良好的实践](#十三多线程开发良好的实践)
-* [参考资料](#参考资料)
-
+# 一、线程状态转换
+ {
- public Integer call() {
- return 123;
- }
+public class MyCallable implements Callable {
+ public Integer call() {
+ return 123;
+ }
}
```
```java
-public static void main(String[] args) throws ExecutionException, InterruptedException {
- MyCallable mc = new MyCallable();
- FutureTask ft = new FutureTask<>(mc);
- Thread thread = new Thread(ft);
- thread.start();
- System.out.println(ft.get());
+public static void main(String[] args) throws ExecutionException, InterruptedException {
+ MyCallable mc = new MyCallable();
+ FutureTask ft = new FutureTask<>(mc);
+ Thread thread = new Thread(ft);
+ thread.start();
+ System.out.println(ft.get());
}
```
-## 继承 Thread 类
+## 继承 Thread 类
-同样也是需要实现 run() 方法，因为 Thread 类也实现了 Runable 接口。
+同样也是需要实现 run() 方法，因为 Thread 类也实现了 Runable 接口。
-当调用 start() 方法启动一个线程时，虚拟机会将该线程放入就绪队列中等待被调度，当一个线程被调度时会执行该线程的 run() 方法。
+当调用 start() 方法启动一个线程时，虚拟机会将该线程放入就绪队列中等待被调度，当一个线程被调度时会执行该线程的 run() 方法。
```java
-public class MyThread extends Thread {
- public void run() {
- // ...
- }
+public class MyThread extends Thread {
+ public void run() {
+ // ...
+ }
}
```
```java
-public static void main(String[] args) {
- MyThread mt = new MyThread();
- mt.start();
+public static void main(String[] args) {
+ MyThread mt = new MyThread();
+ mt.start();
}
```
-## 实现接口 VS 继承 Thread
+## 实现接口 VS 继承 Thread
实现接口会更好一些，因为：
-- Java 不支持多重继承，因此继承了 Thread 类就无法继承其它类，但是可以实现多个接口；
-- 类可能只要求可执行就行，继承整个 Thread 类开销过大。
+- Java 不支持多重继承，因此继承了 Thread 类就无法继承其它类，但是可以实现多个接口；
+- 类可能只要求可执行就行，继承整个 Thread 类开销过大。
-# 三、基础线程机制
+# 三、基础线程机制
-## Executor
+## Executor
-Executor 管理多个异步任务的执行，而无需程序员显式地管理线程的生命周期。这里的异步是指多个任务的执行互不干扰，不需要进行同步操作。
+Executor 管理多个异步任务的执行，而无需程序员显式地管理线程的生命周期。这里的异步是指多个任务的执行互不干扰，不需要进行同步操作。
-主要有三种 Executor：
+主要有三种 Executor：
-- CachedThreadPool：一个任务创建一个线程；
-- FixedThreadPool：所有任务只能使用固定大小的线程；
-- SingleThreadExecutor：相当于大小为 1 的 FixedThreadPool。
+- CachedThreadPool：一个任务创建一个线程；
+- FixedThreadPool：所有任务只能使用固定大小的线程；
+- SingleThreadExecutor：相当于大小为 1 的 FixedThreadPool。
```java
-public static void main(String[] args) {
- ExecutorService executorService = Executors.newCachedThreadPool();
- for (int i = 0; i < 5; i++) {
- executorService.execute(new MyRunnable());
- }
- executorService.shutdown();
+public static void main(String[] args) {
+ ExecutorService executorService = Executors.newCachedThreadPool();
+ for (int i = 0; i < 5; i++) {
+ executorService.execute(new MyRunnable());
+ }
+ executorService.shutdown();
}
```
-## Daemon
+## Daemon
守护线程是程序运行时在后台提供服务的线程，不属于程序中不可或缺的部分。
当所有非守护线程结束时，程序也就终止，同时会杀死所有守护线程。
-main() 属于非守护线程。
+main() 属于非守护线程。
-使用 setDaemon() 方法将一个线程设置为守护线程。
+使用 setDaemon() 方法将一个线程设置为守护线程。
```java
-public static void main(String[] args) {
- Thread thread = new Thread(new MyRunnable());
- thread.setDaemon(true);
+public static void main(String[] args) {
+ Thread thread = new Thread(new MyRunnable());
+ thread.setDaemon(true);
}
```
-## sleep()
+## sleep()
-Thread.sleep(millisec) 方法会休眠当前正在执行的线程，millisec 单位为毫秒。
+Thread.sleep(millisec) 方法会休眠当前正在执行的线程，millisec 单位为毫秒。
-sleep() 可能会抛出 InterruptedException，因为异常不能跨线程传播回 main() 中，因此必须在本地进行处理。线程中抛出的其它异常也同样需要在本地进行处理。
+sleep() 可能会抛出 InterruptedException，因为异常不能跨线程传播回 main() 中，因此必须在本地进行处理。线程中抛出的其它异常也同样需要在本地进行处理。
```java
-public void run() {
- try {
- Thread.sleep(3000);
- } catch (InterruptedException e) {
- e.printStackTrace();
- }
+public void run() {
+ try {
+ Thread.sleep(3000);
+ } catch (InterruptedException e) {
+ e.printStackTrace();
+ }
}
```
-## yield()
+## yield()
-对静态方法 Thread.yield() 的调用声明了当前线程已经完成了生命周期中最重要的部分，可以切换给其它线程来执行。该方法只是对线程调度器的一个建议，而且也只是建议具有相同优先级的其它线程可以运行。
+对静态方法 Thread.yield() 的调用声明了当前线程已经完成了生命周期中最重要的部分，可以切换给其它线程来执行。该方法只是对线程调度器的一个建议，而且也只是建议具有相同优先级的其它线程可以运行。
```java
-public void run() {
- Thread.yield();
+public void run() {
+ Thread.yield();
}
```
-# 四、中断
+# 四、中断
一个线程执行完毕之后会自动结束，如果在运行过程中发生异常也会提前结束。
-## InterruptedException
+## InterruptedException
-通过调用一个线程的 interrupt() 来中断该线程，如果该线程处于阻塞、限期等待或者无限期等待状态，那么就会抛出 InterruptedException，从而提前结束该线程。但是不能中断 I/O 阻塞和 synchronized 锁阻塞。
+通过调用一个线程的 interrupt() 来中断该线程，如果该线程处于阻塞、限期等待或者无限期等待状态，那么就会抛出 InterruptedException，从而提前结束该线程。但是不能中断 I/O 阻塞和 synchronized 锁阻塞。
-对于以下代码，在 main() 中启动一个线程之后再中断它，由于线程中调用了 Thread.sleep() 方法，因此会抛出一个 InterruptedException，从而提前结束线程，不执行之后的语句。
+对于以下代码，在 main() 中启动一个线程之后再中断它，由于线程中调用了 Thread.sleep() 方法，因此会抛出一个 InterruptedException，从而提前结束线程，不执行之后的语句。
```java
-public class InterruptExample {
+public class InterruptExample {
- private static class MyThread1 extends Thread {
- @Override
- public void run() {
- try {
- Thread.sleep(2000);
- System.out.println("Thread run");
- } catch (InterruptedException e) {
- e.printStackTrace();
- }
- }
- }
+ private static class MyThread1 extends Thread {
+ @Override
+ public void run() {
+ try {
+ Thread.sleep(2000);
+ System.out.println("Thread run");
+ } catch (InterruptedException e) {
+ e.printStackTrace();
+ }
+ }
+ }
}
```
```java
-public static void main(String[] args) throws InterruptedException {
- Thread thread1 = new MyThread1();
- thread1.start();
- thread1.interrupt();
- System.out.println("Main run");
+public static void main(String[] args) throws InterruptedException {
+ Thread thread1 = new MyThread1();
+ thread1.start();
+ thread1.interrupt();
+ System.out.println("Main run");
}
```
```html
-Main run
-java.lang.InterruptedException: sleep interrupted
- at java.lang.Thread.sleep(Native Method)
- at InterruptExample.lambda$main$0(InterruptExample.java:5)
- at InterruptExample$$Lambda$1/713338599.run(Unknown Source)
- at java.lang.Thread.run(Thread.java:745)
+Main run
+java.lang.InterruptedException: sleep interrupted
+ at java.lang.Thread.sleep(Native Method)
+ at InterruptExample.lambda$main$0(InterruptExample.java:5)
+ at InterruptExample$$Lambda$1/713338599.run(Unknown Source)
+ at java.lang.Thread.run(Thread.java:745)
```
-## interrupted()
+## interrupted()
-如果一个线程的 run() 方法执行一个无限循环，并且没有执行 sleep() 等会抛出 InterruptedException 的操作，那么调用线程的 interrupt() 方法就无法使线程提前结束。
+如果一个线程的 run() 方法执行一个无限循环，并且没有执行 sleep() 等会抛出 InterruptedException 的操作，那么调用线程的 interrupt() 方法就无法使线程提前结束。
-但是调用 interrupt() 方法会设置线程的中断标记，此时调用 interrupted() 方法会返回 true。因此可以在循环体中使用 interrupted() 方法来判断线程是否处于中断状态，从而提前结束线程。
+但是调用 interrupt() 方法会设置线程的中断标记，此时调用 interrupted() 方法会返回 true。因此可以在循环体中使用 interrupted() 方法来判断线程是否处于中断状态，从而提前结束线程。
```java
-public class InterruptExample {
+public class InterruptExample {
- private static class MyThread2 extends Thread {
- @Override
- public void run() {
- while (!interrupted()) {
- // ..
- }
- System.out.println("Thread end");
- }
- }
+ private static class MyThread2 extends Thread {
+ @Override
+ public void run() {
+ while (!interrupted()) {
+ // ..
+ }
+ System.out.println("Thread end");
+ }
+ }
}
```
```java
-public static void main(String[] args) throws InterruptedException {
- Thread thread2 = new MyThread2();
- thread2.start();
- thread2.interrupt();
+public static void main(String[] args) throws InterruptedException {
+ Thread thread2 = new MyThread2();
+ thread2.start();
+ thread2.interrupt();
}
```
```html
-Thread end
+Thread end
```
-## Executor 的中断操作
+## Executor 的中断操作
-调用 Executor 的 shutdown() 方法会等待线程都执行完毕之后再关闭，但是如果调用的是 shutdownNow() 方法，则相当于调用每个线程的 interrupt() 方法。
+调用 Executor 的 shutdown() 方法会等待线程都执行完毕之后再关闭，但是如果调用的是 shutdownNow() 方法，则相当于调用每个线程的 interrupt() 方法。
-以下使用 Lambda 创建线程，相当于创建了一个匿名内部线程。
+以下使用 Lambda 创建线程，相当于创建了一个匿名内部线程。
```java
-public static void main(String[] args) {
- ExecutorService executorService = Executors.newCachedThreadPool();
- executorService.execute(() -> {
- try {
- Thread.sleep(2000);
- System.out.println("Thread run");
- } catch (InterruptedException e) {
- e.printStackTrace();
- }
- });
- executorService.shutdownNow();
- System.out.println("Main run");
+public static void main(String[] args) {
+ ExecutorService executorService = Executors.newCachedThreadPool();
+ executorService.execute(() -> {
+ try {
+ Thread.sleep(2000);
+ System.out.println("Thread run");
+ } catch (InterruptedException e) {
+ e.printStackTrace();
+ }
+ });
+ executorService.shutdownNow();
+ System.out.println("Main run");
}
```
```html
-Main run
-java.lang.InterruptedException: sleep interrupted
- at java.lang.Thread.sleep(Native Method)
- at ExecutorInterruptExample.lambda$main$0(ExecutorInterruptExample.java:9)
- at ExecutorInterruptExample$$Lambda$1/1160460865.run(Unknown Source)
- at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1142)
- at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:617)
- at java.lang.Thread.run(Thread.java:745)
+Main run
+java.lang.InterruptedException: sleep interrupted
+ at java.lang.Thread.sleep(Native Method)
+ at ExecutorInterruptExample.lambda$main$0(ExecutorInterruptExample.java:9)
+ at ExecutorInterruptExample$$Lambda$1/1160460865.run(Unknown Source)
+ at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1142)
+ at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:617)
+ at java.lang.Thread.run(Thread.java:745)
```
-如果只想中断 Executor 中的一个线程，可以通过使用 submit() 方法来提交一个线程，它会返回一个 Future 对象，通过调用该对象的 cancel(true) 方法就可以中断线程。
+如果只想中断 Executor 中的一个线程，可以通过使用 submit() 方法来提交一个线程，它会返回一个 Future 对象，通过调用该对象的 cancel(true) 方法就可以中断线程。
```java
-Future future = executorService.submit(() -> {
- // ..
+Future future = executorService.submit(() -> {
+ // ..
});
future.cancel(true);
```
-# 五、互斥同步
+# 五、互斥同步
-Java 提供了两种锁机制来控制多个线程对共享资源的互斥访问，第一个是 JVM 实现的 synchronized，而另一个是 JDK 实现的 ReentrantLock。
+Java 提供了两种锁机制来控制多个线程对共享资源的互斥访问，第一个是 JVM 实现的 synchronized，而另一个是 JDK 实现的 ReentrantLock。
-## synchronized
+## synchronized
-**1. 同步一个代码块**
+**1. 同步一个代码块**
```java
-public void func() {
- synchronized (this) {
- // ...
- }
+public void func() {
+ synchronized (this) {
+ // ...
+ }
}
```
它只作用于同一个对象，如果调用两个对象上的同步代码块，就不会进行同步。
-对于以下代码，使用 ExecutorService 执行了两个线程，由于调用的是同一个对象的同步代码块，因此这两个线程会进行同步，当一个线程进入同步语句块时，另一个线程就必须等待。
+对于以下代码，使用 ExecutorService 执行了两个线程，由于调用的是同一个对象的同步代码块，因此这两个线程会进行同步，当一个线程进入同步语句块时，另一个线程就必须等待。
```java
-public class SynchronizedExample {
+public class SynchronizedExample {
- public void func1() {
- synchronized (this) {
- for (int i = 0; i < 10; i++) {
- System.out.print(i + " ");
- }
- }
- }
+ public void func1() {
+ synchronized (this) {
+ for (int i = 0; i < 10; i++) {
+ System.out.print(i + " ");
+ }
+ }
+ }
}
```
```java
-public static void main(String[] args) {
- SynchronizedExample e1 = new SynchronizedExample();
- ExecutorService executorService = Executors.newCachedThreadPool();
- executorService.execute(() -> e1.func1());
- executorService.execute(() -> e1.func1());
+public static void main(String[] args) {
+ SynchronizedExample e1 = new SynchronizedExample();
+ ExecutorService executorService = Executors.newCachedThreadPool();
+ executorService.execute(() -> e1.func1());
+ executorService.execute(() -> e1.func1());
}
```
```html
-0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9
+0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9
```
对于以下代码，两个线程调用了不同对象的同步代码块，因此这两个线程就不需要同步。从输出结果可以看出，两个线程交叉执行。
```java
-public static void main(String[] args) {
- SynchronizedExample e1 = new SynchronizedExample();
- SynchronizedExample e2 = new SynchronizedExample();
- ExecutorService executorService = Executors.newCachedThreadPool();
- executorService.execute(() -> e1.func1());
- executorService.execute(() -> e2.func1());
+public static void main(String[] args) {
+ SynchronizedExample e1 = new SynchronizedExample();
+ SynchronizedExample e2 = new SynchronizedExample();
+ ExecutorService executorService = Executors.newCachedThreadPool();
+ executorService.execute(() -> e1.func1());
+ executorService.execute(() -> e2.func1());
}
```
```html
-0 0 1 1 2 2 3 3 4 4 5 5 6 6 7 7 8 8 9 9
+0 0 1 1 2 2 3 3 4 4 5 5 6 6 7 7 8 8 9 9
```
-**2. 同步一个方法**
+**2. 同步一个方法**
```java
-public synchronized void func () {
- // ...
+public synchronized void func () {
+ // ...
}
```
它和同步代码块一样，作用于同一个对象。
-**3. 同步一个类**
+**3. 同步一个类**
```java
-public void func() {
- synchronized (SynchronizedExample.class) {
- // ...
- }
+public void func() {
+ synchronized (SynchronizedExample.class) {
+ // ...
+ }
}
```
作用于整个类，也就是说两个线程调用同一个类的不同对象上的这种同步语句，也会进行同步。
```java
-public class SynchronizedExample {
+public class SynchronizedExample {
- public void func2() {
- synchronized (SynchronizedExample.class) {
- for (int i = 0; i < 10; i++) {
- System.out.print(i + " ");
- }
- }
- }
+ public void func2() {
+ synchronized (SynchronizedExample.class) {
+ for (int i = 0; i < 10; i++) {
+ System.out.print(i + " ");
+ }
+ }
+ }
}
```
```java
-public static void main(String[] args) {
- SynchronizedExample e1 = new SynchronizedExample();
- SynchronizedExample e2 = new SynchronizedExample();
- ExecutorService executorService = Executors.newCachedThreadPool();
- executorService.execute(() -> e1.func2());
- executorService.execute(() -> e2.func2());
+public static void main(String[] args) {
+ SynchronizedExample e1 = new SynchronizedExample();
+ SynchronizedExample e2 = new SynchronizedExample();
+ ExecutorService executorService = Executors.newCachedThreadPool();
+ executorService.execute(() -> e1.func2());
+ executorService.execute(() -> e2.func2());
}
```
```html
-0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9
+0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9
```
-**4. 同步一个静态方法**
+**4. 同步一个静态方法**
```java
-public synchronized static void fun() {
- // ...
+public synchronized static void fun() {
+ // ...
}
```
作用于整个类。
-## ReentrantLock
+## ReentrantLock
-ReentrantLock 是 java.util.concurrent（J.U.C）包中的锁。
+ReentrantLock 是 java.util.concurrent（J.U.C）包中的锁。
```java
-public class LockExample {
+public class LockExample {
- private Lock lock = new ReentrantLock();
+ private Lock lock = new ReentrantLock();
- public void func() {
- lock.lock();
- try {
- for (int i = 0; i < 10; i++) {
- System.out.print(i + " ");
- }
- } finally {
- lock.unlock(); // 确保释放锁，从而避免发生死锁。
- }
- }
+ public void func() {
+ lock.lock();
+ try {
+ for (int i = 0; i < 10; i++) {
+ System.out.print(i + " ");
+ }
+ } finally {
+ lock.unlock(); // 确保释放锁，从而避免发生死锁。
+ }
+ }
}
```
```java
-public static void main(String[] args) {
- LockExample lockExample = new LockExample();
- ExecutorService executorService = Executors.newCachedThreadPool();
- executorService.execute(() -> lockExample.func());
- executorService.execute(() -> lockExample.func());
+public static void main(String[] args) {
+ LockExample lockExample = new LockExample();
+ ExecutorService executorService = Executors.newCachedThreadPool();
+ executorService.execute(() -> lockExample.func());
+ executorService.execute(() -> lockExample.func());
}
```
```html
-0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9
+0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9
```
-## 比较
+## 比较
-**1. 锁的实现**
+**1. 锁的实现**
-synchronized 是 JVM 实现的，而 ReentrantLock 是 JDK 实现的。
+synchronized 是 JVM 实现的，而 ReentrantLock 是 JDK 实现的。
-**2. 性能**
+**2. 性能**
-新版本 Java 对 synchronized 进行了很多优化，例如自旋锁等，synchronized 与 ReentrantLock 大致相同。
+新版本 Java 对 synchronized 进行了很多优化，例如自旋锁等，synchronized 与 ReentrantLock 大致相同。
-**3. 等待可中断**
+**3. 等待可中断**
当持有锁的线程长期不释放锁的时候，正在等待的线程可以选择放弃等待，改为处理其他事情。
-ReentrantLock 可中断，而 synchronized 不行。
+ReentrantLock 可中断，而 synchronized 不行。
-**4. 公平锁**
+**4. 公平锁**
公平锁是指多个线程在等待同一个锁时，必须按照申请锁的时间顺序来依次获得锁。
-synchronized 中的锁是非公平的，ReentrantLock 默认情况下也是非公平的，但是也可以是公平的。
+synchronized 中的锁是非公平的，ReentrantLock 默认情况下也是非公平的，但是也可以是公平的。
-**5. 锁绑定多个条件**
+**5. 锁绑定多个条件**
-一个 ReentrantLock 可以同时绑定多个 Condition 对象。
+一个 ReentrantLock 可以同时绑定多个 Condition 对象。
-## 使用选择
+## 使用选择
-除非需要使用 ReentrantLock 的高级功能，否则优先使用 synchronized。这是因为 synchronized 是 JVM 实现的一种锁机制，JVM 原生地支持它，而 ReentrantLock 不是所有的 JDK 版本都支持。并且使用 synchronized 不用担心没有释放锁而导致死锁问题，因为 JVM 会确保锁的释放。
+除非需要使用 ReentrantLock 的高级功能，否则优先使用 synchronized。这是因为 synchronized 是 JVM 实现的一种锁机制，JVM 原生地支持它，而 ReentrantLock 不是所有的 JDK 版本都支持。并且使用 synchronized 不用担心没有释放锁而导致死锁问题，因为 JVM 会确保锁的释放。
-# 六、线程之间的协作
+# 六、线程之间的协作
当多个线程可以一起工作去解决某个问题时，如果某些部分必须在其它部分之前完成，那么就需要对线程进行协调。
-## join()
+## join()
-在线程中调用另一个线程的 join() 方法，会将当前线程挂起，而不是忙等待，直到目标线程结束。
+在线程中调用另一个线程的 join() 方法，会将当前线程挂起，而不是忙等待，直到目标线程结束。
-对于以下代码，虽然 b 线程先启动，但是因为在 b 线程中调用了 a 线程的 join() 方法，b 线程会等待 a 线程结束才继续执行，因此最后能够保证 a 线程的输出先于 b 线程的输出。
+对于以下代码，虽然 b 线程先启动，但是因为在 b 线程中调用了 a 线程的 join() 方法，b 线程会等待 a 线程结束才继续执行，因此最后能够保证 a 线程的输出先于 b 线程的输出。
```java
-public class JoinExample {
+public class JoinExample {
- private class A extends Thread {
- @Override
- public void run() {
- System.out.println("A");
- }
- }
+ private class A extends Thread {
+ @Override
+ public void run() {
+ System.out.println("A");
+ }
+ }
- private class B extends Thread {
+ private class B extends Thread {
- private A a;
+ private A a;
- B(A a) {
- this.a = a;
- }
+ B(A a) {
+ this.a = a;
+ }
- @Override
- public void run() {
- try {
- a.join();
- } catch (InterruptedException e) {
- e.printStackTrace();
- }
- System.out.println("B");
- }
- }
+ @Override
+ public void run() {
+ try {
+ a.join();
+ } catch (InterruptedException e) {
+ e.printStackTrace();
+ }
+ System.out.println("B");
+ }
+ }
- public void test() {
- A a = new A();
- B b = new B(a);
- b.start();
- a.start();
- }
+ public void test() {
+ A a = new A();
+ B b = new B(a);
+ b.start();
+ a.start();
+ }
}
```
```java
-public static void main(String[] args) {
- JoinExample example = new JoinExample();
- example.test();
+public static void main(String[] args) {
+ JoinExample example = new JoinExample();
+ example.test();
}
```
@@ -627,41 +565,41 @@ A
B
```
-## wait() notify() notifyAll()
+## wait() notify() notifyAll()
-调用 wait() 使得线程等待某个条件满足，线程在等待时会被挂起，当其他线程的运行使得这个条件满足时，其它线程会调用 notify() 或者 notifyAll() 来唤醒挂起的线程。
+调用 wait() 使得线程等待某个条件满足，线程在等待时会被挂起，当其他线程的运行使得这个条件满足时，其它线程会调用 notify() 或者 notifyAll() 来唤醒挂起的线程。
-它们都属于 Object 的一部分，而不属于 Thread。
+它们都属于 Object 的一部分，而不属于 Thread。
-只能用在同步方法或者同步控制块中使用，否则会在运行时抛出 IllegalMonitorStateException。
+只能用在同步方法或者同步控制块中使用，否则会在运行时抛出 IllegalMonitorStateException。
-使用 wait() 挂起期间，线程会释放锁。这是因为，如果没有释放锁，那么其它线程就无法进入对象的同步方法或者同步控制块中，那么就无法执行 notify() 或者 notifyAll() 来唤醒挂起的线程，造成死锁。
+使用 wait() 挂起期间，线程会释放锁。这是因为，如果没有释放锁，那么其它线程就无法进入对象的同步方法或者同步控制块中，那么就无法执行 notify() 或者 notifyAll() 来唤醒挂起的线程，造成死锁。
```java
-public class WaitNotifyExample {
+public class WaitNotifyExample {
- public synchronized void before() {
- System.out.println("before");
- notifyAll();
- }
+ public synchronized void before() {
+ System.out.println("before");
+ notifyAll();
+ }
- public synchronized void after() {
- try {
- wait();
- } catch (InterruptedException e) {
- e.printStackTrace();
- }
- System.out.println("after");
- }
+ public synchronized void after() {
+ try {
+ wait();
+ } catch (InterruptedException e) {
+ e.printStackTrace();
+ }
+ System.out.println("after");
+ }
}
```
```java
-public static void main(String[] args) {
- ExecutorService executorService = Executors.newCachedThreadPool();
- WaitNotifyExample example = new WaitNotifyExample();
- executorService.execute(() -> example.after());
- executorService.execute(() -> example.before());
+public static void main(String[] args) {
+ ExecutorService executorService = Executors.newCachedThreadPool();
+ WaitNotifyExample example = new WaitNotifyExample();
+ executorService.execute(() -> example.after());
+ executorService.execute(() -> example.before());
}
```
@@ -670,55 +608,55 @@ before
after
```
-**wait() 和 sleep() 的区别**
+**wait() 和 sleep() 的区别**
-- wait() 是 Object 的方法，而 sleep() 是 Thread 的静态方法；
-- wait() 会释放锁，sleep() 不会。
+- wait() 是 Object 的方法，而 sleep() 是 Thread 的静态方法；
+- wait() 会释放锁，sleep() 不会。
-## await() signal() signalAll()
+## await() signal() signalAll()
-java.util.concurrent 类库中提供了 Condition 类来实现线程之间的协调，可以在 Condition 上调用 await() 方法使线程等待，其它线程调用 signal() 或 signalAll() 方法唤醒等待的线程。
+java.util.concurrent 类库中提供了 Condition 类来实现线程之间的协调，可以在 Condition 上调用 await() 方法使线程等待，其它线程调用 signal() 或 signalAll() 方法唤醒等待的线程。
-相比于 wait() 这种等待方式，await() 可以指定等待的条件，因此更加灵活。
+相比于 wait() 这种等待方式，await() 可以指定等待的条件，因此更加灵活。
-使用 Lock 来获取一个 Condition 对象。
+使用 Lock 来获取一个 Condition 对象。
```java
-public class AwaitSignalExample {
+public class AwaitSignalExample {
- private Lock lock = new ReentrantLock();
- private Condition condition = lock.newCondition();
+ private Lock lock = new ReentrantLock();
+ private Condition condition = lock.newCondition();
- public void before() {
- lock.lock();
- try {
- System.out.println("before");
- condition.signalAll();
- } finally {
- lock.unlock();
- }
- }
+ public void before() {
+ lock.lock();
+ try {
+ System.out.println("before");
+ condition.signalAll();
+ } finally {
+ lock.unlock();
+ }
+ }
- public void after() {
- lock.lock();
- try {
- condition.await();
- System.out.println("after");
- } catch (InterruptedException e) {
- e.printStackTrace();
- } finally {
- lock.unlock();
- }
- }
+ public void after() {
+ lock.lock();
+ try {
+ condition.await();
+ System.out.println("after");
+ } catch (InterruptedException e) {
+ e.printStackTrace();
+ } finally {
+ lock.unlock();
+ }
+ }
}
```
```java
-public static void main(String[] args) {
- ExecutorService executorService = Executors.newCachedThreadPool();
- AwaitSignalExample example = new AwaitSignalExample();
- executorService.execute(() -> example.after());
- executorService.execute(() -> example.before());
+public static void main(String[] args) {
+ ExecutorService executorService = Executors.newCachedThreadPool();
+ AwaitSignalExample example = new AwaitSignalExample();
+ executorService.execute(() -> example.after());
+ executorService.execute(() -> example.before());
}
```
@@ -727,35 +665,35 @@ before
after
```
-# 七、J.U.C - AQS
+# 七、J.U.C - AQS
-java.util.concurrent（J.U.C）大大提高了并发性能，AQS 被认为是 J.U.C 的核心。
+java.util.concurrent（J.U.C）大大提高了并发性能，AQS 被认为是 J.U.C 的核心。
-## CountdownLatch
+## CountdownLatch
用来控制一个线程等待多个线程。
-维护了一个计数器 cnt，每次调用 countDown() 方法会让计数器的值减 1，减到 0 的时候，那些因为调用 await() 方法而在等待的线程就会被唤醒。
+维护了一个计数器 cnt，每次调用 countDown() 方法会让计数器的值减 1，减到 0 的时候，那些因为调用 await() 方法而在等待的线程就会被唤醒。
- 进行封装。FutureTask 实现了 RunnableFuture 接口，该接口继承自 Runnable 和 Future 接口，这使得 FutureTask 既可以当做一个任务执行，也可以有返回值。
+在介绍 Callable 时我们知道它可以有返回值，返回值通过 Future 进行封装。FutureTask 实现了 RunnableFuture 接口，该接口继承自 Runnable 和 Future 接口，这使得 FutureTask 既可以当做一个任务执行，也可以有返回值。
```java
-public class FutureTask implements RunnableFuture
+public class FutureTask implements RunnableFuture
```
```java
-public interface RunnableFuture extends Runnable, Future
+public interface RunnableFuture extends Runnable, Future
```
-FutureTask 可用于异步获取执行结果或取消执行任务的场景。当一个计算任务需要执行很长时间，那么就可以用 FutureTask 来封装这个任务，主线程在完成自己的任务之后再去获取结果。
+FutureTask 可用于异步获取执行结果或取消执行任务的场景。当一个计算任务需要执行很长时间，那么就可以用 FutureTask 来封装这个任务，主线程在完成自己的任务之后再去获取结果。
```java
-public class FutureTaskExample {
+public class FutureTaskExample {
- public static void main(String[] args) throws ExecutionException, InterruptedException {
- FutureTask futureTask = new FutureTask(new Callable() {
- @Override
- public Integer call() throws Exception {
- int result = 0;
- for (int i = 0; i < 100; i++) {
- Thread.sleep(10);
- result += i;
- }
- return result;
- }
- });
+ public static void main(String[] args) throws ExecutionException, InterruptedException {
+ FutureTask futureTask = new FutureTask(new Callable() {
+ @Override
+ public Integer call() throws Exception {
+ int result = 0;
+ for (int i = 0; i < 100; i++) {
+ Thread.sleep(10);
+ result += i;
+ }
+ return result;
+ }
+ });
- Thread computeThread = new Thread(futureTask);
- computeThread.start();
+ Thread computeThread = new Thread(futureTask);
+ computeThread.start();
- Thread otherThread = new Thread(() -> {
- System.out.println("other task is running...");
- try {
- Thread.sleep(1000);
- } catch (InterruptedException e) {
- e.printStackTrace();
- }
- });
- otherThread.start();
- System.out.println(futureTask.get());
- }
+ Thread otherThread = new Thread(() -> {
+ System.out.println("other task is running...");
+ try {
+ Thread.sleep(1000);
+ } catch (InterruptedException e) {
+ e.printStackTrace();
+ }
+ });
+ otherThread.start();
+ System.out.println(futureTask.get());
+ }
}
```
```html
-other task is running...
+other task is running...
4950
```
-## BlockingQueue
+## BlockingQueue
-java.util.concurrent.BlockingQueue 接口有以下阻塞队列的实现：
+java.util.concurrent.BlockingQueue 接口有以下阻塞队列的实现：
-- **FIFO 队列** ：LinkedBlockingQueue、ArrayBlockingQueue（固定长度）
-- **优先级队列** ：PriorityBlockingQueue
+- **FIFO 队列**：LinkedBlockingQueue、ArrayBlockingQueue（固定长度）
+- **优先级队列**：PriorityBlockingQueue
-提供了阻塞的 take() 和 put() 方法：如果队列为空 take() 将阻塞，直到队列中有内容；如果队列为满 put() 将阻塞，直到队列有空闲位置。
+提供了阻塞的 take() 和 put() 方法：如果队列为空 take() 将阻塞，直到队列中有内容；如果队列为满 put() 将阻塞，直到队列有空闲位置。
-**使用 BlockingQueue 实现生产者消费者问题**
+**使用 BlockingQueue 实现生产者消费者问题**
```java
-public class ProducerConsumer {
+public class ProducerConsumer {
- private static BlockingQueue queue = new ArrayBlockingQueue<>(5);
+ private static BlockingQueue queue = new ArrayBlockingQueue<>(5);
- private static class Producer extends Thread {
- @Override
- public void run() {
- try {
- queue.put("product");
- } catch (InterruptedException e) {
- e.printStackTrace();
- }
- System.out.print("produce..");
- }
- }
+ private static class Producer extends Thread {
+ @Override
+ public void run() {
+ try {
+ queue.put("product");
+ } catch (InterruptedException e) {
+ e.printStackTrace();
+ }
+ System.out.print("produce..");
+ }
+ }
- private static class Consumer extends Thread {
+ private static class Consumer extends Thread {
- @Override
- public void run() {
- try {
- String product = queue.take();
- } catch (InterruptedException e) {
- e.printStackTrace();
- }
- System.out.print("consume..");
- }
- }
+ @Override
+ public void run() {
+ try {
+ String product = queue.take();
+ } catch (InterruptedException e) {
+ e.printStackTrace();
+ }
+ System.out.print("consume..");
+ }
+ }
}
```
```java
-public static void main(String[] args) {
- for (int i = 0; i < 2; i++) {
- Producer producer = new Producer();
- producer.start();
- }
- for (int i = 0; i < 5; i++) {
- Consumer consumer = new Consumer();
- consumer.start();
- }
- for (int i = 0; i < 3; i++) {
- Producer producer = new Producer();
- producer.start();
- }
+public static void main(String[] args) {
+ for (int i = 0; i < 2; i++) {
+ Producer producer = new Producer();
+ producer.start();
+ }
+ for (int i = 0; i < 5; i++) {
+ Consumer consumer = new Consumer();
+ consumer.start();
+ }
+ for (int i = 0; i < 3; i++) {
+ Producer producer = new Producer();
+ producer.start();
+ }
}
```
@@ -970,99 +908,99 @@ public static void main(String[] args) {
produce..produce..consume..consume..produce..consume..produce..consume..produce..consume..
```
-## ForkJoin
+## ForkJoin
-主要用于并行计算中，和 MapReduce 原理类似，都是把大的计算任务拆分成多个小任务并行计算。
+主要用于并行计算中，和 MapReduce 原理类似，都是把大的计算任务拆分成多个小任务并行计算。
```java
-public class ForkJoinExample extends RecursiveTask {
+public class ForkJoinExample extends RecursiveTask {
- private final int threshold = 5;
- private int first;
- private int last;
+ private final int threshold = 5;
+ private int first;
+ private int last;
- public ForkJoinExample(int first, int last) {
- this.first = first;
- this.last = last;
- }
+ public ForkJoinExample(int first, int last) {
+ this.first = first;
+ this.last = last;
+ }
- @Override
- protected Integer compute() {
- int result = 0;
- if (last - first <= threshold) {
- // 任务足够小则直接计算
- for (int i = first; i <= last; i++) {
- result += i;
- }
- } else {
- // 拆分成小任务
- int middle = first + (last - first) / 2;
- ForkJoinExample leftTask = new ForkJoinExample(first, middle);
- ForkJoinExample rightTask = new ForkJoinExample(middle + 1, last);
- leftTask.fork();
- rightTask.fork();
- result = leftTask.join() + rightTask.join();
- }
- return result;
- }
+ @Override
+ protected Integer compute() {
+ int result = 0;
+ if (last - first <= threshold) {
+ // 任务足够小则直接计算
+ for (int i = first; i <= last; i++) {
+ result += i;
+ }
+ } else {
+ // 拆分成小任务
+ int middle = first + (last - first) / 2;
+ ForkJoinExample leftTask = new ForkJoinExample(first, middle);
+ ForkJoinExample rightTask = new ForkJoinExample(middle + 1, last);
+ leftTask.fork();
+ rightTask.fork();
+ result = leftTask.join() + rightTask.join();
+ }
+ return result;
+ }
}
```
```java
-public static void main(String[] args) throws ExecutionException, InterruptedException {
- ForkJoinExample example = new ForkJoinExample(1, 10000);
- ForkJoinPool forkJoinPool = new ForkJoinPool();
- Future result = forkJoinPool.submit(example);
- System.out.println(result.get());
+public static void main(String[] args) throws ExecutionException, InterruptedException {
+ ForkJoinExample example = new ForkJoinExample(1, 10000);
+ ForkJoinPool forkJoinPool = new ForkJoinPool();
+ Future result = forkJoinPool.submit(example);
+ System.out.println(result.get());
}
```
-ForkJoin 使用 ForkJoinPool 来启动，它是一个特殊的线程池，线程数量取决于 CPU 核数。
+ForkJoin 使用 ForkJoinPool 来启动，它是一个特殊的线程池，线程数量取决于 CPU 核数。
```java
-public class ForkJoinPool extends AbstractExecutorService
+public class ForkJoinPool extends AbstractExecutorService
```
-ForkJoinPool 实现了工作窃取算法来提高 CPU 的利用率。每个线程都维护了一个双端队列，用来存储需要执行的任务。工作窃取算法允许空闲的线程从其它线程的双端队列中窃取一个任务来执行。窃取的任务必须是最晚的任务，避免和队列所属线程发生竞争。例如下图中，Thread2 从 Thread1 的队列中拿出最晚的 Task1 任务，Thread1 会拿出 Task2 来执行，这样就避免发生竞争。但是如果队列中只有一个任务时还是会发生竞争。
+ForkJoinPool 实现了工作窃取算法来提高 CPU 的利用率。每个线程都维护了一个双端队列，用来存储需要执行的任务。工作窃取算法允许空闲的线程从其它线程的双端队列中窃取一个任务来执行。窃取的任务必须是最晚的任务，避免和队列所属线程发生竞争。例如下图中，Thread2 从 Thread1 的队列中拿出最晚的 Task1 任务，Thread1 会拿出 Task2 来执行，这样就避免发生竞争。但是如果队列中只有一个任务时还是会发生竞争。
- map = new HashMap<>();
- Map unmodifiableMap = Collections.unmodifiableMap(map);
- unmodifiableMap.put("a", 1);
- }
+public class ImmutableExample {
+ public static void main(String[] args) {
+ Map map = new HashMap<>();
+ Map unmodifiableMap = Collections.unmodifiableMap(map);
+ unmodifiableMap.put("a", 1);
+ }
}
```
```html
-Exception in thread "main" java.lang.UnsupportedOperationException
- at java.util.Collections$UnmodifiableMap.put(Collections.java:1457)
- at ImmutableExample.main(ImmutableExample.java:9)
+Exception in thread "main" java.lang.UnsupportedOperationException
+ at java.util.Collections$UnmodifiableMap.put(Collections.java:1457)
+ at ImmutableExample.main(ImmutableExample.java:9)
```
-Collections.unmodifiableXXX() 先对原始的集合进行拷贝，需要对集合进行修改的方法都直接抛出异常。
+Collections.unmodifiableXXX() 先对原始的集合进行拷贝，需要对集合进行修改的方法都直接抛出异常。
```java
-public V put(K key, V value) {
- throw new UnsupportedOperationException();
+public V put(K key, V value) {
+ throw new UnsupportedOperationException();
}
```
-## 互斥同步
+## 互斥同步
-synchronized 和 ReentrantLock。
+synchronized 和 ReentrantLock。
-## 非阻塞同步
+## 非阻塞同步
互斥同步最主要的问题就是线程阻塞和唤醒所带来的性能问题，因此这种同步也称为阻塞同步。
互斥同步属于一种悲观的并发策略，总是认为只要不去做正确的同步措施，那就肯定会出现问题。无论共享数据是否真的会出现竞争，它都要进行加锁（这里讨论的是概念模型，实际上虚拟机会优化掉很大一部分不必要的加锁）、用户态核心态转换、维护锁计数器和检查是否有被阻塞的线程需要唤醒等操作。
-### 1. CAS
+### 1. CAS
随着硬件指令集的发展，我们可以使用基于冲突检测的乐观并发策略：先进行操作，如果没有其它线程争用共享数据，那操作就成功了，否则采取补偿措施（不断地重试，直到成功为止）。这种乐观的并发策略的许多实现都不需要将线程阻塞，因此这种同步操作称为非阻塞同步。
-乐观锁需要操作和冲突检测这两个步骤具备原子性，这里就不能再使用互斥同步来保证了，只能靠硬件来完成。硬件支持的原子性操作最典型的是：比较并交换（Compare-and-Swap，CAS）。CAS 指令需要有 3 个操作数，分别是内存地址 V、旧的预期值 A 和新值 B。当执行操作时，只有当 V 的值等于 A，才将 V 的值更新为 B。
+乐观锁需要操作和冲突检测这两个步骤具备原子性，这里就不能再使用互斥同步来保证了，只能靠硬件来完成。硬件支持的原子性操作最典型的是：比较并交换（Compare-and-Swap，CAS）。CAS 指令需要有 3 个操作数，分别是内存地址 V、旧的预期值 A 和新值 B。当执行操作时，只有当 V 的值等于 A，才将 V 的值更新为 B。
-### 2. AtomicInteger
+### 2. AtomicInteger
-J.U.C 包里面的整数原子类 AtomicInteger 的方法调用了 Unsafe 类的 CAS 操作。
+J.U.C 包里面的整数原子类 AtomicInteger 的方法调用了 Unsafe 类的 CAS 操作。
-以下代码使用了 AtomicInteger 执行了自增的操作。
+以下代码使用了 AtomicInteger 执行了自增的操作。
```java
-private AtomicInteger cnt = new AtomicInteger();
+private AtomicInteger cnt = new AtomicInteger();
-public void add() {
- cnt.incrementAndGet();
+public void add() {
+ cnt.incrementAndGet();
}
```
-以下代码是 incrementAndGet() 的源码，它调用了 Unsafe 的 getAndAddInt() 。
+以下代码是 incrementAndGet() 的源码，它调用了 Unsafe 的 getAndAddInt() 。
```java
-public final int incrementAndGet() {
- return unsafe.getAndAddInt(this, valueOffset, 1) + 1;
+public final int incrementAndGet() {
+ return unsafe.getAndAddInt(this, valueOffset, 1) + 1;
}
```
-以下代码是 getAndAddInt() 源码，var1 指示对象内存地址，var2 指示该字段相对对象内存地址的偏移，var4 指示操作需要加的数值，这里为 1。通过 getIntVolatile(var1, var2) 得到旧的预期值，通过调用 compareAndSwapInt() 来进行 CAS 比较，如果该字段内存地址中的值等于 var5，那么就更新内存地址为 var1+var2 的变量为 var5+var4。
+以下代码是 getAndAddInt() 源码，var1 指示对象内存地址，var2 指示该字段相对对象内存地址的偏移，var4 指示操作需要加的数值，这里为 1。通过 getIntVolatile(var1, var2) 得到旧的预期值，通过调用 compareAndSwapInt() 来进行 CAS 比较，如果该字段内存地址中的值等于 var5，那么就更新内存地址为 var1+var2 的变量为 var5+var4。
-可以看到 getAndAddInt() 在一个循环中进行，发生冲突的做法是不断的进行重试。
+可以看到 getAndAddInt() 在一个循环中进行，发生冲突的做法是不断的进行重试。
```java
-public final int getAndAddInt(Object var1, long var2, int var4) {
- int var5;
- do {
- var5 = this.getIntVolatile(var1, var2);
- } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));
+public final int getAndAddInt(Object var1, long var2, int var4) {
+ int var5;
+ do {
+ var5 = this.getIntVolatile(var1, var2);
+ } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));
- return var5;
+ return var5;
}
```
-### 3. ABA
+### 3. ABA
-如果一个变量初次读取的时候是 A 值，它的值被改成了 B，后来又被改回为 A，那 CAS 操作就会误认为它从来没有被改变过。
+如果一个变量初次读取的时候是 A 值，它的值被改成了 B，后来又被改回为 A，那 CAS 操作就会误认为它从来没有被改变过。
-J.U.C 包提供了一个带有标记的原子引用类 AtomicStampedReference 来解决这个问题，它可以通过控制变量值的版本来保证 CAS 的正确性。大部分情况下 ABA 问题不会影响程序并发的正确性，如果需要解决 ABA 问题，改用传统的互斥同步可能会比原子类更高效。
+J.U.C 包提供了一个带有标记的原子引用类 AtomicStampedReference 来解决这个问题，它可以通过控制变量值的版本来保证 CAS 的正确性。大部分情况下 ABA 问题不会影响程序并发的正确性，如果需要解决 ABA 问题，改用传统的互斥同步可能会比原子类更高效。
-## 无同步方案
+## 无同步方案
要保证线程安全，并不是一定就要进行同步。如果一个方法本来就不涉及共享数据，那它自然就无须任何同步措施去保证正确性。
-### 1. 栈封闭
+### 1. 栈封闭
多个线程访问同一个方法的局部变量时，不会出现线程安全问题，因为局部变量存储在虚拟机栈中，属于线程私有的。
```java
-public class StackClosedExample {
- public void add100() {
- int cnt = 0;
- for (int i = 0; i < 100; i++) {
- cnt++;
- }
- System.out.println(cnt);
- }
+public class StackClosedExample {
+ public void add100() {
+ int cnt = 0;
+ for (int i = 0; i < 100; i++) {
+ cnt++;
+ }
+ System.out.println(cnt);
+ }
}
```
```java
-public static void main(String[] args) {
- StackClosedExample example = new StackClosedExample();
- ExecutorService executorService = Executors.newCachedThreadPool();
- executorService.execute(() -> example.add100());
- executorService.execute(() -> example.add100());
- executorService.shutdown();
+public static void main(String[] args) {
+ StackClosedExample example = new StackClosedExample();
+ ExecutorService executorService = Executors.newCachedThreadPool();
+ executorService.execute(() -> example.add100());
+ executorService.execute(() -> example.add100());
+ executorService.shutdown();
}
```
@@ -1416,37 +1354,37 @@ public static void main(String[] args) {
100
```
-### 2. 线程本地存储（Thread Local Storage）
+### 2. 线程本地存储（Thread Local Storage）
如果一段代码中所需要的数据必须与其他代码共享，那就看看这些共享数据的代码是否能保证在同一个线程中执行。如果能保证，我们就可以把共享数据的可见范围限制在同一个线程之内，这样，无须同步也能保证线程之间不出现数据争用的问题。
-符合这种特点的应用并不少见，大部分使用消费队列的架构模式（如“生产者-消费者”模式）都会将产品的消费过程尽量在一个线程中消费完。其中最重要的一个应用实例就是经典 Web 交互模型中的“一个请求对应一个服务器线程”（Thread-per-Request）的处理方式，这种处理方式的广泛应用使得很多 Web 服务端应用都可以使用线程本地存储来解决线程安全问题。
+符合这种特点的应用并不少见，大部分使用消费队列的架构模式（如“生产者-消费者”模式）都会将产品的消费过程尽量在一个线程中消费完。其中最重要的一个应用实例就是经典 Web 交互模型中的“一个请求对应一个服务器线程”（Thread-per-Request）的处理方式，这种处理方式的广泛应用使得很多 Web 服务端应用都可以使用线程本地存储来解决线程安全问题。
-可以使用 java.lang.ThreadLocal 类来实现线程本地存储功能。
+可以使用 java.lang.ThreadLocal 类来实现线程本地存储功能。
-对于以下代码，thread1 中设置 threadLocal 为 1，而 thread2 设置 threadLocal 为 2。过了一段时间之后，thread1 读取 threadLocal 依然是 1，不受 thread2 的影响。
+对于以下代码，thread1 中设置 threadLocal 为 1，而 thread2 设置 threadLocal 为 2。过了一段时间之后，thread1 读取 threadLocal 依然是 1，不受 thread2 的影响。
```java
-public class ThreadLocalExample {
- public static void main(String[] args) {
- ThreadLocal threadLocal = new ThreadLocal();
- Thread thread1 = new Thread(() -> {
- threadLocal.set(1);
- try {
- Thread.sleep(1000);
- } catch (InterruptedException e) {
- e.printStackTrace();
- }
- System.out.println(threadLocal.get());
- threadLocal.remove();
- });
- Thread thread2 = new Thread(() -> {
- threadLocal.set(2);
- threadLocal.remove();
- });
- thread1.start();
- thread2.start();
- }
+public class ThreadLocalExample {
+ public static void main(String[] args) {
+ ThreadLocal threadLocal = new ThreadLocal();
+ Thread thread1 = new Thread(() -> {
+ threadLocal.set(1);
+ try {
+ Thread.sleep(1000);
+ } catch (InterruptedException e) {
+ e.printStackTrace();
+ }
+ System.out.println(threadLocal.get());
+ threadLocal.remove();
+ });
+ Thread thread2 = new Thread(() -> {
+ threadLocal.set(2);
+ threadLocal.remove();
+ });
+ thread1.start();
+ thread2.start();
+ }
}
```
@@ -1454,93 +1392,93 @@ public class ThreadLocalExample {
1
```
-为了理解 ThreadLocal，先看以下代码：
+为了理解 ThreadLocal，先看以下代码：
```java
-public class ThreadLocalExample1 {
- public static void main(String[] args) {
- ThreadLocal threadLocal1 = new ThreadLocal();
- ThreadLocal threadLocal2 = new ThreadLocal();
- Thread thread1 = new Thread(() -> {
- threadLocal1.set(1);
- threadLocal2.set(1);
- });
- Thread thread2 = new Thread(() -> {
- threadLocal1.set(2);
- threadLocal2.set(2);
- });
- thread1.start();
- thread2.start();
- }
+public class ThreadLocalExample1 {
+ public static void main(String[] args) {
+ ThreadLocal threadLocal1 = new ThreadLocal();
+ ThreadLocal threadLocal2 = new ThreadLocal();
+ Thread thread1 = new Thread(() -> {
+ threadLocal1.set(1);
+ threadLocal2.set(1);
+ });
+ Thread thread2 = new Thread(() -> {
+ threadLocal1.set(2);
+ threadLocal2.set(2);
+ });
+ thread1.start();
+ thread2.start();
+ }
}
```
它所对应的底层结构图为：
- sf = new SoftReference(obj);
-obj = null; // 使对象只被软引用关联
+Object obj = new Object();
+SoftReference sf = new SoftReference(obj);
+obj = null; // 使对象只被软引用关联
```
-### 3. 弱引用
+### 3. 弱引用
被弱引用关联的对象一定会被回收，也就是说它只能存活到下一次垃圾回收发生之前。
-使用 WeakReference 类来实现弱引用。
+使用 WeakReference 类来实现弱引用。
```java
-Object obj = new Object();
-WeakReference wf = new WeakReference(obj);
-obj = null;
+Object obj = new Object();
+WeakReference wf = new WeakReference(obj);
+obj = null;
```
-### 4. 虚引用
+### 4. 虚引用
又称为幽灵引用或者幻影引用，一个对象是否有虚引用的存在，不会对其生存时间造成影响，也无法通过虚引用得到一个对象。
为一个对象设置虚引用的唯一目的是能在这个对象被回收时收到一个系统通知。
-使用 PhantomReference 来实现虚引用。
+使用 PhantomReference 来实现虚引用。
```java
-Object obj = new Object();
-PhantomReference pf = new PhantomReference(obj);
-obj = null;
+Object obj = new Object();
+PhantomReference pf = new PhantomReference(obj);
+obj = null;
```
-## 垃圾收集算法
+## 垃圾收集算法
-### 1. 标记 - 清除
+### 1. 标记 - 清除
- vowels = new HashSet<>(Arrays.asList('a', 'e', 'i', 'o', 'u', 'A', 'E', 'I', 'O', 'U'));
+private final static HashSet vowels = new HashSet<>(Arrays.asList('a', 'e', 'i', 'o', 'u', 'A', 'E', 'I', 'O', 'U'));
-public String reverseVowels(String s) {
- int i = 0, j = s.length() - 1;
- char[] result = new char[s.length()];
- while (i <= j) {
- char ci = s.charAt(i);
- char cj = s.charAt(j);
- if (!vowels.contains(ci)) {
- result[i++] = ci;
- } else if (!vowels.contains(cj)) {
- result[j--] = cj;
- } else {
- result[i++] = cj;
- result[j--] = ci;
- }
- }
- return new String(result);
+public String reverseVowels(String s) {
+ int i = 0, j = s.length() - 1;
+ char[] result = new char[s.length()];
+ while (i <= j) {
+ char ci = s.charAt(i);
+ char cj = s.charAt(j);
+ if (!vowels.contains(ci)) {
+ result[i++] = ci;
+ } else if (!vowels.contains(cj)) {
+ result[j--] = cj;
+ } else {
+ result[i++] = cj;
+ result[j--] = ci;
+ }
+ }
+ return new String(result);
}
```
-**回文字符串**
+**回文字符串**
-[680. Valid Palindrome II (Easy)](https://leetcode.com/problems/valid-palindrome-ii/description/)
+[680. Valid Palindrome II (Easy)](https://leetcode.com/problems/valid-palindrome-ii/description/)
```html
-Input: "abca"
-Output: True
-Explanation: You could delete the character 'c'.
+Input: "abca"
+Output: True
+Explanation: You could delete the character 'c'.
```
题目描述：可以删除一个字符，判断是否能构成回文字符串。
```java
-public boolean validPalindrome(String s) {
- int i = -1, j = s.length();
- while (++i < --j) {
- if (s.charAt(i) != s.charAt(j)) {
- return isPalindrome(s, i, j - 1) || isPalindrome(s, i + 1, j);
- }
- }
- return true;
+public boolean validPalindrome(String s) {
+ int i = -1, j = s.length();
+ while (++i < --j) {
+ if (s.charAt(i) != s.charAt(j)) {
+ return isPalindrome(s, i, j - 1) || isPalindrome(s, i + 1, j);
+ }
+ }
+ return true;
}
-private boolean isPalindrome(String s, int i, int j) {
- while (i < j) {
- if (s.charAt(i++) != s.charAt(j--)) {
- return false;
- }
- }
- return true;
+private boolean isPalindrome(String s, int i, int j) {
+ while (i < j) {
+ if (s.charAt(i++) != s.charAt(j--)) {
+ return false;
+ }
+ }
+ return true;
}
```
-**归并两个有序数组**
+**归并两个有序数组**
-[88. Merge Sorted Array (Easy)](https://leetcode.com/problems/merge-sorted-array/description/)
+[88. Merge Sorted Array (Easy)](https://leetcode.com/problems/merge-sorted-array/description/)
```html
Input:
-nums1 = [1,2,3,0,0,0], m = 3
-nums2 = [2,5,6], n = 3
+nums1 = [1,2,3,0,0,0], m = 3
+nums2 = [2,5,6], n = 3
-Output: [1,2,2,3,5,6]
+Output: [1,2,2,3,5,6]
```
题目描述：把归并结果存到第一个数组上。
-需要从尾开始遍历，否则在 nums1 上归并得到的值会覆盖还未进行归并比较的值。
+需要从尾开始遍历，否则在 nums1 上归并得到的值会覆盖还未进行归并比较的值。
```java
-public void merge(int[] nums1, int m, int[] nums2, int n) {
- int index1 = m - 1, index2 = n - 1;
- int indexMerge = m + n - 1;
- while (index1 >= 0 || index2 >= 0) {
- if (index1 < 0) {
- nums1[indexMerge--] = nums2[index2--];
- } else if (index2 < 0) {
- nums1[indexMerge--] = nums1[index1--];
- } else if (nums1[index1] > nums2[index2]) {
- nums1[indexMerge--] = nums1[index1--];
- } else {
- nums1[indexMerge--] = nums2[index2--];
- }
- }
+public void merge(int[] nums1, int m, int[] nums2, int n) {
+ int index1 = m - 1, index2 = n - 1;
+ int indexMerge = m + n - 1;
+ while (index1 >= 0 || index2 >= 0) {
+ if (index1 < 0) {
+ nums1[indexMerge--] = nums2[index2--];
+ } else if (index2 < 0) {
+ nums1[indexMerge--] = nums1[index1--];
+ } else if (nums1[index1] > nums2[index2]) {
+ nums1[indexMerge--] = nums1[index1--];
+ } else {
+ nums1[indexMerge--] = nums2[index2--];
+ }
+ }
}
```
-**判断链表是否存在环**
+**判断链表是否存在环**
-[141. Linked List Cycle (Easy)](https://leetcode.com/problems/linked-list-cycle/description/)
+[141. Linked List Cycle (Easy)](https://leetcode.com/problems/linked-list-cycle/description/)
使用双指针，一个指针每次移动一个节点，一个指针每次移动两个节点，如果存在环，那么这两个指针一定会相遇。
```java
-public boolean hasCycle(ListNode head) {
- if (head == null) {
- return false;
- }
- ListNode l1 = head, l2 = head.next;
- while (l1 != null && l2 != null && l2.next != null) {
- if (l1 == l2) {
- return true;
- }
- l1 = l1.next;
- l2 = l2.next.next;
- }
- return false;
+public boolean hasCycle(ListNode head) {
+ if (head == null) {
+ return false;
+ }
+ ListNode l1 = head, l2 = head.next;
+ while (l1 != null && l2 != null && l2.next != null) {
+ if (l1 == l2) {
+ return true;
+ }
+ l1 = l1.next;
+ l2 = l2.next.next;
+ }
+ return false;
}
```
-**最长子序列**
+**最长子序列**
-[524. Longest Word in Dictionary through Deleting (Medium)](https://leetcode.com/problems/longest-word-in-dictionary-through-deleting/description/)
+[524. Longest Word in Dictionary through Deleting (Medium)](https://leetcode.com/problems/longest-word-in-dictionary-through-deleting/description/)
```
Input:
-s = "abpcplea", d = ["ale","apple","monkey","plea"]
+s = "abpcplea", d = ["ale","apple","monkey","plea"]
Output:
"apple"
```
-题目描述：删除 s 中的一些字符，使得它构成字符串列表 d 中的一个字符串，找出能构成的最长字符串。如果有多个相同长度的结果，返回字典序的最小字符串。
+题目描述：删除 s 中的一些字符，使得它构成字符串列表 d 中的一个字符串，找出能构成的最长字符串。如果有多个相同长度的结果，返回字典序的最小字符串。
```java
-public String findLongestWord(String s, List d) {
- String longestWord = "";
- for (String target : d) {
- int l1 = longestWord.length(), l2 = target.length();
- if (l1 > l2 || (l1 == l2 && longestWord.compareTo(target) < 0)) {
- continue;
- }
- if (isValid(s, target)) {
- longestWord = target;
- }
- }
- return longestWord;
+public String findLongestWord(String s, List d) {
+ String longestWord = "";
+ for (String target : d) {
+ int l1 = longestWord.length(), l2 = target.length();
+ if (l1 > l2 || (l1 == l2 && longestWord.compareTo(target) < 0)) {
+ continue;
+ }
+ if (isValid(s, target)) {
+ longestWord = target;
+ }
+ }
+ return longestWord;
}
-private boolean isValid(String s, String target) {
- int i = 0, j = 0;
- while (i < s.length() && j < target.length()) {
- if (s.charAt(i) == target.charAt(j)) {
- j++;
- }
- i++;
- }
- return j == target.length();
+private boolean isValid(String s, String target) {
+ int i = 0, j = 0;
+ while (i < s.length() && j < target.length()) {
+ if (s.charAt(i) == target.charAt(j)) {
+ j++;
+ }
+ i++;
+ }
+ return j == target.length();
}
```
-## 排序
+## 排序
-### 快速选择
+### 快速选择
-用于求解 **Kth Element** 问题，使用快速排序的 partition() 进行实现。
+用于求解 **Kth Element** 问题，使用快速排序的 partition() 进行实现。
-需要先打乱数组，否则最坏情况下时间复杂度为 O(N2 )。
+需要先打乱数组，否则最坏情况下时间复杂度为 O(N2 )。
-### 堆排序
+### 堆排序
-用于求解 **TopK Elements** 问题，通过维护一个大小为 K 的堆，堆中的元素就是 TopK Elements。
+用于求解 **TopK Elements** 问题，通过维护一个大小为 K 的堆，堆中的元素就是 TopK Elements。
-堆排序也可以用于求解 Kth Element 问题，堆顶元素就是 Kth Element。
+堆排序也可以用于求解 Kth Element 问题，堆顶元素就是 Kth Element。
-快速选择也可以求解 TopK Elements 问题，因为找到 Kth Element 之后，再遍历一次数组，所有小于等于 Kth Element 的元素都是 TopK Elements。
+快速选择也可以求解 TopK Elements 问题，因为找到 Kth Element 之后，再遍历一次数组，所有小于等于 Kth Element 的元素都是 TopK Elements。
-可以看到，快速选择和堆排序都可以求解 Kth Element 和 TopK Elements 问题。
+可以看到，快速选择和堆排序都可以求解 Kth Element 和 TopK Elements 问题。
-**Kth Element**
+**Kth Element**
-[215. Kth Largest Element in an Array (Medium)](https://leetcode.com/problems/kth-largest-element-in-an-array/description/)
+[215. Kth Largest Element in an Array (Medium)](https://leetcode.com/problems/kth-largest-element-in-an-array/description/)
-题目描述：找到第 k 大的元素。
+题目描述：找到第 k 大的元素。
-**排序** ：时间复杂度 O(NlogN)，空间复杂度 O(1)
+**排序**：时间复杂度 O(NlogN)，空间复杂度 O(1)
```java
-public int findKthLargest(int[] nums, int k) {
- Arrays.sort(nums);
- return nums[nums.length - k];
+public int findKthLargest(int[] nums, int k) {
+ Arrays.sort(nums);
+ return nums[nums.length - k];
}
```
-**堆排序** ：时间复杂度 O(NlogK)，空间复杂度 O(K)。
+**堆排序**：时间复杂度 O(NlogK)，空间复杂度 O(K)。
```java
-public int findKthLargest(int[] nums, int k) {
- PriorityQueue pq = new PriorityQueue<>(); // 小顶堆
- for (int val : nums) {
- pq.add(val);
- if (pq.size() > k) // 维护堆的大小为 K
- pq.poll();
- }
- return pq.peek();
+public int findKthLargest(int[] nums, int k) {
+ PriorityQueue pq = new PriorityQueue<>(); // 小顶堆
+ for (int val : nums) {
+ pq.add(val);
+ if (pq.size() > k) // 维护堆的大小为 K
+ pq.poll();
+ }
+ return pq.peek();
}
```
-**快速选择** ：时间复杂度 O(N)，空间复杂度 O(1)
+**快速选择**：时间复杂度 O(N)，空间复杂度 O(1)
```java
-public int findKthLargest(int[] nums, int k) {
- k = nums.length - k;
- int l = 0, h = nums.length - 1;
- while (l < h) {
- int j = partition(nums, l, h);
- if (j == k) {
- break;
- } else if (j < k) {
- l = j + 1;
- } else {
- h = j - 1;
- }
- }
- return nums[k];
+public int findKthLargest(int[] nums, int k) {
+ k = nums.length - k;
+ int l = 0, h = nums.length - 1;
+ while (l < h) {
+ int j = partition(nums, l, h);
+ if (j == k) {
+ break;
+ } else if (j < k) {
+ l = j + 1;
+ } else {
+ h = j - 1;
+ }
+ }
+ return nums[k];
}
-private int partition(int[] a, int l, int h) {
- int i = l, j = h + 1;
- while (true) {
- while (a[++i] < a[l] && i < h) ;
- while (a[--j] > a[l] && j > l) ;
- if (i >= j) {
- break;
- }
- swap(a, i, j);
- }
- swap(a, l, j);
- return j;
+private int partition(int[] a, int l, int h) {
+ int i = l, j = h + 1;
+ while (true) {
+ while (a[++i] < a[l] && i < h) ;
+ while (a[--j] > a[l] && j > l) ;
+ if (i >= j) {
+ break;
+ }
+ swap(a, i, j);
+ }
+ swap(a, l, j);
+ return j;
}
-private void swap(int[] a, int i, int j) {
- int t = a[i];
- a[i] = a[j];
- a[j] = t;
+private void swap(int[] a, int i, int j) {
+ int t = a[i];
+ a[i] = a[j];
+ a[j] = t;
}
```
-### 桶排序
+### 桶排序
-**出现频率最多的 k 个数**
+**出现频率最多的 k 个数**
-[347. Top K Frequent Elements (Medium)](https://leetcode.com/problems/top-k-frequent-elements/description/)
+[347. Top K Frequent Elements (Medium)](https://leetcode.com/problems/top-k-frequent-elements/description/)
```html
-Given [1,1,1,2,2,3] and k = 2, return [1,2].
+Given [1,1,1,2,2,3] and k = 2, return [1,2].
```
-设置若干个桶，每个桶存储出现频率相同的数，并且桶的下标代表桶中数出现的频率，即第 i 个桶中存储的数出现的频率为 i。
+设置若干个桶，每个桶存储出现频率相同的数，并且桶的下标代表桶中数出现的频率，即第 i 个桶中存储的数出现的频率为 i。
-把数都放到桶之后，从后向前遍历桶，最先得到的 k 个数就是出现频率最多的的 k 个数。
+把数都放到桶之后，从后向前遍历桶，最先得到的 k 个数就是出现频率最多的的 k 个数。
```java
-public List topKFrequent(int[] nums, int k) {
- Map frequencyForNum = new HashMap<>();
- for (int num : nums) {
- frequencyForNum.put(num, frequencyForNum.getOrDefault(num, 0) + 1);
- }
- List[] buckets = new ArrayList[nums.length + 1];
- for (int key : frequencyForNum.keySet()) {
- int frequency = frequencyForNum.get(key);
- if (buckets[frequency] == null) {
- buckets[frequency] = new ArrayList<>();
- }
- buckets[frequency].add(key);
- }
- List topK = new ArrayList<>();
- for (int i = buckets.length - 1; i >= 0 && topK.size() < k; i--) {
- if (buckets[i] != null) {
- topK.addAll(buckets[i]);
- }
- }
- return topK;
+public List topKFrequent(int[] nums, int k) {
+ Map frequencyForNum = new HashMap<>();
+ for (int num : nums) {
+ frequencyForNum.put(num, frequencyForNum.getOrDefault(num, 0) + 1);
+ }
+ List[] buckets = new ArrayList[nums.length + 1];
+ for (int key : frequencyForNum.keySet()) {
+ int frequency = frequencyForNum.get(key);
+ if (buckets[frequency] == null) {
+ buckets[frequency] = new ArrayList<>();
+ }
+ buckets[frequency].add(key);
+ }
+ List topK = new ArrayList<>();
+ for (int i = buckets.length - 1; i >= 0 && topK.size() < k; i--) {
+ if (buckets[i] != null) {
+ topK.addAll(buckets[i]);
+ }
+ }
+ return topK;
}
```
-**按照字符出现次数对字符串排序**
+**按照字符出现次数对字符串排序**
-[451. Sort Characters By Frequency (Medium)](https://leetcode.com/problems/sort-characters-by-frequency/description/)
+[451. Sort Characters By Frequency (Medium)](https://leetcode.com/problems/sort-characters-by-frequency/description/)
```html
Input:
@@ -423,40 +367,40 @@ Output:
"eert"
Explanation:
-'e' appears twice while 'r' and 't' both appear once.
-So 'e' must appear before both 'r' and 't'. Therefore "eetr" is also a valid answer.
+'e' appears twice while 'r' and 't' both appear once.
+So 'e' must appear before both 'r' and 't'. Therefore "eetr" is also a valid answer.
```
```java
-public String frequencySort(String s) {
- Map frequencyForNum = new HashMap<>();
- for (char c : s.toCharArray())
- frequencyForNum.put(c, frequencyForNum.getOrDefault(c, 0) + 1);
+public String frequencySort(String s) {
+ Map frequencyForNum = new HashMap<>();
+ for (char c : s.toCharArray())
+ frequencyForNum.put(c, frequencyForNum.getOrDefault(c, 0) + 1);
- List[] frequencyBucket = new ArrayList[s.length() + 1];
- for (char c : frequencyForNum.keySet()) {
- int f = frequencyForNum.get(c);
- if (frequencyBucket[f] == null) {
- frequencyBucket[f] = new ArrayList<>();
- }
- frequencyBucket[f].add(c);
- }
- StringBuilder str = new StringBuilder();
- for (int i = frequencyBucket.length - 1; i >= 0; i--) {
- if (frequencyBucket[i] == null) {
- continue;
- }
- for (char c : frequencyBucket[i]) {
- for (int j = 0; j < i; j++) {
- str.append(c);
- }
- }
- }
- return str.toString();
+ List[] frequencyBucket = new ArrayList[s.length() + 1];
+ for (char c : frequencyForNum.keySet()) {
+ int f = frequencyForNum.get(c);
+ if (frequencyBucket[f] == null) {
+ frequencyBucket[f] = new ArrayList<>();
+ }
+ frequencyBucket[f].add(c);
+ }
+ StringBuilder str = new StringBuilder();
+ for (int i = frequencyBucket.length - 1; i >= 0; i--) {
+ if (frequencyBucket[i] == null) {
+ continue;
+ }
+ for (char c : frequencyBucket[i]) {
+ for (int j = 0; j < i; j++) {
+ str.append(c);
+ }
+ }
+ }
+ return str.toString();
}
```
-### 荷兰国旗问题
+### 荷兰国旗问题
荷兰国旗包含三种颜色：红、白、蓝。
@@ -464,96 +408,96 @@ public String frequencySort(String s) {
它其实是三向切分快速排序的一种变种，在三向切分快速排序中，每次切分都将数组分成三个区间：小于切分元素、等于切分元素、大于切分元素，而该算法是将数组分成三个区间：等于红色、等于白色、等于蓝色。
- () {
- @Override
- public int compare(Interval o1, Interval o2) {
- return o1.end - o2.end;
- }
+Arrays.sort(intervals, new Comparator() {
+ @Override
+ public int compare(Interval o1, Interval o2) {
+ return o1.end - o2.end;
+ }
});
```
-**投飞镖刺破气球**
+**投飞镖刺破气球**
-[452. Minimum Number of Arrows to Burst Balloons (Medium)](https://leetcode.com/problems/minimum-number-of-arrows-to-burst-balloons/description/)
+[452. Minimum Number of Arrows to Burst Balloons (Medium)](https://leetcode.com/problems/minimum-number-of-arrows-to-burst-balloons/description/)
```
Input:
-[[10,16], [2,8], [1,6], [7,12]]
+[[10,16], [2,8], [1,6], [7,12]]
Output:
2
@@ -608,869 +552,869 @@ Output:
题目描述：气球在一个水平数轴上摆放，可以重叠，飞镖垂直投向坐标轴，使得路径上的气球都会刺破。求解最小的投飞镖次数使所有气球都被刺破。
-也是计算不重叠的区间个数，不过和 Non-overlapping Intervals 的区别在于，[1, 2] 和 [2, 3] 在本题中算是重叠区间。
+也是计算不重叠的区间个数，不过和 Non-overlapping Intervals 的区别在于，[1, 2] 和 [2, 3] 在本题中算是重叠区间。
```java
-public int findMinArrowShots(int[][] points) {
- if (points.length == 0) {
- return 0;
- }
- Arrays.sort(points, Comparator.comparingInt(o -> o[1]));
- int cnt = 1, end = points[0][1];
- for (int i = 1; i < points.length; i++) {
- if (points[i][0] <= end) {
- continue;
- }
- cnt++;
- end = points[i][1];
- }
- return cnt;
+public int findMinArrowShots(int[][] points) {
+ if (points.length == 0) {
+ return 0;
+ }
+ Arrays.sort(points, Comparator.comparingInt(o -> o[1]));
+ int cnt = 1, end = points[0][1];
+ for (int i = 1; i < points.length; i++) {
+ if (points[i][0] <= end) {
+ continue;
+ }
+ cnt++;
+ end = points[i][1];
+ }
+ return cnt;
}
```
-**根据身高和序号重组队列**
+**根据身高和序号重组队列**
-[406. Queue Reconstruction by Height(Medium)](https://leetcode.com/problems/queue-reconstruction-by-height/description/)
+[406. Queue Reconstruction by Height(Medium)](https://leetcode.com/problems/queue-reconstruction-by-height/description/)
```html
Input:
-[[7,0], [4,4], [7,1], [5,0], [6,1], [5,2]]
+[[7,0], [4,4], [7,1], [5,0], [6,1], [5,2]]
Output:
-[[5,0], [7,0], [5,2], [6,1], [4,4], [7,1]]
+[[5,0], [7,0], [5,2], [6,1], [4,4], [7,1]]
```
-题目描述：一个学生用两个分量 (h, k) 描述，h 表示身高，k 表示排在前面的有 k 个学生的身高比他高或者和他一样高。
+题目描述：一个学生用两个分量 (h, k) 描述，h 表示身高，k 表示排在前面的有 k 个学生的身高比他高或者和他一样高。
-为了使插入操作不影响后续的操作，身高较高的学生应该先做插入操作，否则身高较小的学生原先正确插入的第 k 个位置可能会变成第 k+1 个位置。
+为了使插入操作不影响后续的操作，身高较高的学生应该先做插入操作，否则身高较小的学生原先正确插入的第 k 个位置可能会变成第 k+1 个位置。
-身高降序、k 值升序，然后按排好序的顺序插入队列的第 k 个位置中。
+身高降序、k 值升序，然后按排好序的顺序插入队列的第 k 个位置中。
```java
-public int[][] reconstructQueue(int[][] people) {
- if (people == null || people.length == 0 || people[0].length == 0) {
- return new int[0][0];
- }
- Arrays.sort(people, (a, b) -> (a[0] == b[0] ? a[1] - b[1] : b[0] - a[0]));
- List queue = new ArrayList<>();
- for (int[] p : people) {
- queue.add(p[1], p);
- }
- return queue.toArray(new int[queue.size()][]);
+public int[][] reconstructQueue(int[][] people) {
+ if (people == null || people.length == 0 || people[0].length == 0) {
+ return new int[0][0];
+ }
+ Arrays.sort(people, (a, b) -> (a[0] == b[0] ? a[1] - b[1] : b[0] - a[0]));
+ List queue = new ArrayList<>();
+ for (int[] p : people) {
+ queue.add(p[1], p);
+ }
+ return queue.toArray(new int[queue.size()][]);
}
```
-**分隔字符串使同种字符出现在一起**
+**分隔字符串使同种字符出现在一起**
-[763. Partition Labels (Medium)](https://leetcode.com/problems/partition-labels/description/)
+[763. Partition Labels (Medium)](https://leetcode.com/problems/partition-labels/description/)
```html
-Input: S = "ababcbacadefegdehijhklij"
-Output: [9,7,8]
+Input: S = "ababcbacadefegdehijhklij"
+Output: [9,7,8]
Explanation:
-The partition is "ababcbaca", "defegde", "hijhklij".
-This is a partition so that each letter appears in at most one part.
-A partition like "ababcbacadefegde", "hijhklij" is incorrect, because it splits S into less parts.
+The partition is "ababcbaca", "defegde", "hijhklij".
+This is a partition so that each letter appears in at most one part.
+A partition like "ababcbacadefegde", "hijhklij" is incorrect, because it splits S into less parts.
```
```java
-public List partitionLabels(String S) {
- int[] lastIndexsOfChar = new int[26];
- for (int i = 0; i < S.length(); i++) {
- lastIndexsOfChar[char2Index(S.charAt(i))] = i;
- }
- List partitions = new ArrayList<>();
- int firstIndex = 0;
- while (firstIndex < S.length()) {
- int lastIndex = firstIndex;
- for (int i = firstIndex; i < S.length() && i <= lastIndex; i++) {
- int index = lastIndexsOfChar[char2Index(S.charAt(i))];
- if (index > lastIndex) {
- lastIndex = index;
- }
- }
- partitions.add(lastIndex - firstIndex + 1);
- firstIndex = lastIndex + 1;
- }
- return partitions;
+public List partitionLabels(String S) {
+ int[] lastIndexsOfChar = new int[26];
+ for (int i = 0; i < S.length(); i++) {
+ lastIndexsOfChar[char2Index(S.charAt(i))] = i;
+ }
+ List partitions = new ArrayList<>();
+ int firstIndex = 0;
+ while (firstIndex < S.length()) {
+ int lastIndex = firstIndex;
+ for (int i = firstIndex; i < S.length() && i <= lastIndex; i++) {
+ int index = lastIndexsOfChar[char2Index(S.charAt(i))];
+ if (index > lastIndex) {
+ lastIndex = index;
+ }
+ }
+ partitions.add(lastIndex - firstIndex + 1);
+ firstIndex = lastIndex + 1;
+ }
+ return partitions;
}
-private int char2Index(char c) {
- return c - 'a';
+private int char2Index(char c) {
+ return c - 'a';
}
```
-**种植花朵**
+**种植花朵**
-[605. Can Place Flowers (Easy)](https://leetcode.com/problems/can-place-flowers/description/)
+[605. Can Place Flowers (Easy)](https://leetcode.com/problems/can-place-flowers/description/)
```html
-Input: flowerbed = [1,0,0,0,1], n = 1
-Output: True
+Input: flowerbed = [1,0,0,0,1], n = 1
+Output: True
```
-题目描述：花朵之间至少需要一个单位的间隔，求解是否能种下 n 朵花。
+题目描述：花朵之间至少需要一个单位的间隔，求解是否能种下 n 朵花。
```java
-public boolean canPlaceFlowers(int[] flowerbed, int n) {
- int len = flowerbed.length;
- int cnt = 0;
- for (int i = 0; i < len && cnt < n; i++) {
- if (flowerbed[i] == 1) {
- continue;
- }
- int pre = i == 0 ? 0 : flowerbed[i - 1];
- int next = i == len - 1 ? 0 : flowerbed[i + 1];
- if (pre == 0 && next == 0) {
- cnt++;
- flowerbed[i] = 1;
- }
- }
- return cnt >= n;
+public boolean canPlaceFlowers(int[] flowerbed, int n) {
+ int len = flowerbed.length;
+ int cnt = 0;
+ for (int i = 0; i < len && cnt < n; i++) {
+ if (flowerbed[i] == 1) {
+ continue;
+ }
+ int pre = i == 0 ? 0 : flowerbed[i - 1];
+ int next = i == len - 1 ? 0 : flowerbed[i + 1];
+ if (pre == 0 && next == 0) {
+ cnt++;
+ flowerbed[i] = 1;
+ }
+ }
+ return cnt >= n;
}
```
-**判断是否为子序列**
+**判断是否为子序列**
-[392. Is Subsequence (Medium)](https://leetcode.com/problems/is-subsequence/description/)
+[392. Is Subsequence (Medium)](https://leetcode.com/problems/is-subsequence/description/)
```html
-s = "abc", t = "ahbgdc"
-Return true.
+s = "abc", t = "ahbgdc"
+Return true.
```
```java
-public boolean isSubsequence(String s, String t) {
- int index = -1;
- for (char c : s.toCharArray()) {
- index = t.indexOf(c, index + 1);
- if (index == -1) {
- return false;
- }
- }
- return true;
+public boolean isSubsequence(String s, String t) {
+ int index = -1;
+ for (char c : s.toCharArray()) {
+ index = t.indexOf(c, index + 1);
+ if (index == -1) {
+ return false;
+ }
+ }
+ return true;
}
```
-**修改一个数成为非递减数组**
+**修改一个数成为非递减数组**
-[665. Non-decreasing Array (Easy)](https://leetcode.com/problems/non-decreasing-array/description/)
+[665. Non-decreasing Array (Easy)](https://leetcode.com/problems/non-decreasing-array/description/)
```html
-Input: [4,2,3]
-Output: True
-Explanation: You could modify the first 4 to 1 to get a non-decreasing array.
+Input: [4,2,3]
+Output: True
+Explanation: You could modify the first 4 to 1 to get a non-decreasing array.
```
题目描述：判断一个数组能不能只修改一个数就成为非递减数组。
-在出现 nums[i] < nums[i - 1] 时，需要考虑的是应该修改数组的哪个数，使得本次修改能使 i 之前的数组成为非递减数组，并且 **不影响后续的操作** 。优先考虑令 nums[i - 1] = nums[i]，因为如果修改 nums[i] = nums[i - 1] 的话，那么 nums[i] 这个数会变大，就有可能比 nums[i + 1] 大，从而影响了后续操作。还有一个比较特别的情况就是 nums[i] < nums[i - 2]，只修改 nums[i - 1] = nums[i] 不能使数组成为非递减数组，只能修改 nums[i] = nums[i - 1]。
+在出现 nums[i] < nums[i - 1] 时，需要考虑的是应该修改数组的哪个数，使得本次修改能使 i 之前的数组成为非递减数组，并且 **不影响后续的操作**。优先考虑令 nums[i - 1] = nums[i]，因为如果修改 nums[i] = nums[i - 1] 的话，那么 nums[i] 这个数会变大，就有可能比 nums[i + 1] 大，从而影响了后续操作。还有一个比较特别的情况就是 nums[i] < nums[i - 2]，只修改 nums[i - 1] = nums[i] 不能使数组成为非递减数组，只能修改 nums[i] = nums[i - 1]。
```java
-public boolean checkPossibility(int[] nums) {
- int cnt = 0;
- for (int i = 1; i < nums.length && cnt < 2; i++) {
- if (nums[i] >= nums[i - 1]) {
- continue;
- }
- cnt++;
- if (i - 2 >= 0 && nums[i - 2] > nums[i]) {
- nums[i] = nums[i - 1];
- } else {
- nums[i - 1] = nums[i];
- }
- }
- return cnt <= 1;
+public boolean checkPossibility(int[] nums) {
+ int cnt = 0;
+ for (int i = 1; i < nums.length && cnt < 2; i++) {
+ if (nums[i] >= nums[i - 1]) {
+ continue;
+ }
+ cnt++;
+ if (i - 2 >= 0 && nums[i - 2] > nums[i]) {
+ nums[i] = nums[i - 1];
+ } else {
+ nums[i - 1] = nums[i];
+ }
+ }
+ return cnt <= 1;
}
```
-**股票的最大收益**
+**股票的最大收益**
-[122. Best Time to Buy and Sell Stock II (Easy)](https://leetcode.com/problems/best-time-to-buy-and-sell-stock-ii/description/)
+[122. Best Time to Buy and Sell Stock II (Easy)](https://leetcode.com/problems/best-time-to-buy-and-sell-stock-ii/description/)
题目描述：一次股票交易包含买入和卖出，多个交易之间不能交叉进行。
-对于 [a, b, c, d]，如果有 a <= b <= c <= d ，那么最大收益为 d - a。而 d - a = (d - c) + (c - b) + (b - a) ，因此当访问到一个 prices[i] 且 prices[i] - prices[i-1] > 0，那么就把 prices[i] - prices[i-1] 添加到收益中，从而在局部最优的情况下也保证全局最优。
+对于 [a, b, c, d]，如果有 a <= b <= c <= d ，那么最大收益为 d - a。而 d - a = (d - c) + (c - b) + (b - a) ，因此当访问到一个 prices[i] 且 prices[i] - prices[i-1] > 0，那么就把 prices[i] - prices[i-1] 添加到收益中，从而在局部最优的情况下也保证全局最优。
```java
-public int maxProfit(int[] prices) {
- int profit = 0;
- for (int i = 1; i < prices.length; i++) {
- if (prices[i] > prices[i - 1]) {
- profit += (prices[i] - prices[i - 1]);
- }
- }
- return profit;
+public int maxProfit(int[] prices) {
+ int profit = 0;
+ for (int i = 1; i < prices.length; i++) {
+ if (prices[i] > prices[i - 1]) {
+ profit += (prices[i] - prices[i - 1]);
+ }
+ }
+ return profit;
}
```
-**子数组最大的和**
+**子数组最大的和**
-[53. Maximum Subarray (Easy)](https://leetcode.com/problems/maximum-subarray/description/)
+[53. Maximum Subarray (Easy)](https://leetcode.com/problems/maximum-subarray/description/)
```html
-For example, given the array [-2,1,-3,4,-1,2,1,-5,4],
-the contiguous subarray [4,-1,2,1] has the largest sum = 6.
+For example, given the array [-2,1,-3,4,-1,2,1,-5,4],
+the contiguous subarray [4,-1,2,1] has the largest sum = 6.
```
```java
-public int maxSubArray(int[] nums) {
- if (nums == null || nums.length == 0) {
- return 0;
- }
- int preSum = nums[0];
- int maxSum = preSum;
- for (int i = 1; i < nums.length; i++) {
- preSum = preSum > 0 ? preSum + nums[i] : nums[i];
- maxSum = Math.max(maxSum, preSum);
- }
- return maxSum;
+public int maxSubArray(int[] nums) {
+ if (nums == null || nums.length == 0) {
+ return 0;
+ }
+ int preSum = nums[0];
+ int maxSum = preSum;
+ for (int i = 1; i < nums.length; i++) {
+ preSum = preSum > 0 ? preSum + nums[i] : nums[i];
+ maxSum = Math.max(maxSum, preSum);
+ }
+ return maxSum;
}
```
-**买入和售出股票最大的收益**
+**买入和售出股票最大的收益**
-[121. Best Time to Buy and Sell Stock (Easy)](https://leetcode.com/problems/best-time-to-buy-and-sell-stock/description/)
+[121. Best Time to Buy and Sell Stock (Easy)](https://leetcode.com/problems/best-time-to-buy-and-sell-stock/description/)
题目描述：只进行一次交易。
只要记录前面的最小价格，将这个最小价格作为买入价格，然后将当前的价格作为售出价格，查看当前收益是不是最大收益。
```java
-public int maxProfit(int[] prices) {
- int n = prices.length;
- if (n == 0) return 0;
- int soFarMin = prices[0];
- int max = 0;
- for (int i = 1; i < n; i++) {
- if (soFarMin > prices[i]) soFarMin = prices[i];
- else max = Math.max(max, prices[i] - soFarMin);
- }
- return max;
+public int maxProfit(int[] prices) {
+ int n = prices.length;
+ if (n == 0) return 0;
+ int soFarMin = prices[0];
+ int max = 0;
+ for (int i = 1; i < n; i++) {
+ if (soFarMin > prices[i]) soFarMin = prices[i];
+ else max = Math.max(max, prices[i] - soFarMin);
+ }
+ return max;
}
```
-## 二分查找
+## 二分查找
-**正常实现**
+**正常实现**
```java
-public int binarySearch(int[] nums, int key) {
- int l = 0, h = nums.length - 1;
- while (l <= h) {
- int m = l + (h - l) / 2;
- if (nums[m] == key) {
- return m;
- } else if (nums[m] > key) {
- h = m - 1;
- } else {
- l = m + 1;
- }
- }
- return -1;
+public int binarySearch(int[] nums, int key) {
+ int l = 0, h = nums.length - 1;
+ while (l <= h) {
+ int m = l + (h - l) / 2;
+ if (nums[m] == key) {
+ return m;
+ } else if (nums[m] > key) {
+ h = m - 1;
+ } else {
+ l = m + 1;
+ }
+ }
+ return -1;
}
```
-**时间复杂度**
+**时间复杂度**
-二分查找也称为折半查找，每次都能将查找区间减半，这种折半特性的算法时间复杂度为 O(logN)。
+二分查找也称为折半查找，每次都能将查找区间减半，这种折半特性的算法时间复杂度为 O(logN)。
-**m 计算**
+**m 计算**
-有两种计算中值 m 的方式：
+有两种计算中值 m 的方式：
-- m = (l + h) / 2
-- m = l + (h - l) / 2
+- m = (l + h) / 2
+- m = l + (h - l) / 2
-l + h 可能出现加法溢出，最好使用第二种方式。
+l + h 可能出现加法溢出，最好使用第二种方式。
-**返回值**
+**返回值**
-循环退出时如果仍然没有查找到 key，那么表示查找失败。可以有两种返回值：
+循环退出时如果仍然没有查找到 key，那么表示查找失败。可以有两种返回值：
-- -1：以一个错误码表示没有查找到 key
-- l：将 key 插入到 nums 中的正确位置
+- -1：以一个错误码表示没有查找到 key
+- l：将 key 插入到 nums 中的正确位置
-**变种**
+**变种**
-二分查找可以有很多变种，变种实现要注意边界值的判断。例如在一个有重复元素的数组中查找 key 的最左位置的实现如下：
+二分查找可以有很多变种，变种实现要注意边界值的判断。例如在一个有重复元素的数组中查找 key 的最左位置的实现如下：
```java
-public int binarySearch(int[] nums, int key) {
- int l = 0, h = nums.length - 1;
- while (l < h) {
- int m = l + (h - l) / 2;
- if (nums[m] >= key) {
- h = m;
- } else {
- l = m + 1;
- }
- }
- return l;
+public int binarySearch(int[] nums, int key) {
+ int l = 0, h = nums.length - 1;
+ while (l < h) {
+ int m = l + (h - l) / 2;
+ if (nums[m] >= key) {
+ h = m;
+ } else {
+ l = m + 1;
+ }
+ }
+ return l;
}
```
该实现和正常实现有以下不同：
-- 循环条件为 l < h
-- h 的赋值表达式为 h = m
-- 最后返回 l 而不是 -1
+- 循环条件为 l < h
+- h 的赋值表达式为 h = m
+- 最后返回 l 而不是 -1
-在 nums[m] >= key 的情况下，可以推导出最左 key 位于 [l, m] 区间中，这是一个闭区间。h 的赋值表达式为 h = m，因为 m 位置也可能是解。
+在 nums[m] >= key 的情况下，可以推导出最左 key 位于 [l, m] 区间中，这是一个闭区间。h 的赋值表达式为 h = m，因为 m 位置也可能是解。
-在 h 的赋值表达式为 h = mid 的情况下，如果循环条件为 l <= h，那么会出现循环无法退出的情况，因此循环条件只能是 l < h。以下演示了循环条件为 l <= h 时循环无法退出的情况：
+在 h 的赋值表达式为 h = mid 的情况下，如果循环条件为 l <= h，那么会出现循环无法退出的情况，因此循环条件只能是 l < h。以下演示了循环条件为 l <= h 时循环无法退出的情况：
```text
-nums = {0, 1, 2}, key = 1
-l m h
-0 1 2 nums[m] >= key
-0 0 1 nums[m] < key
-1 1 1 nums[m] >= key
-1 1 1 nums[m] >= key
+nums = {0, 1, 2}, key = 1
+l m h
+0 1 2 nums[m] >= key
+0 0 1 nums[m] < key
+1 1 1 nums[m] >= key
+1 1 1 nums[m] >= key
...
```
-当循环体退出时，不表示没有查找到 key，因此最后返回的结果不应该为 -1。为了验证有没有查找到，需要在调用端判断一下返回位置上的值和 key 是否相等。
+当循环体退出时，不表示没有查找到 key，因此最后返回的结果不应该为 -1。为了验证有没有查找到，需要在调用端判断一下返回位置上的值和 key 是否相等。
-**求开方**
+**求开方**
-[69. Sqrt(x) (Easy)](https://leetcode.com/problems/sqrtx/description/)
+[69. Sqrt(x) (Easy)](https://leetcode.com/problems/sqrtx/description/)
```html
-Input: 4
-Output: 2
+Input: 4
+Output: 2
-Input: 8
-Output: 2
-Explanation: The square root of 8 is 2.82842..., and since we want to return an integer, the decimal part will be truncated.
+Input: 8
+Output: 2
+Explanation: The square root of 8 is 2.82842..., and since we want to return an integer, the decimal part will be truncated.
```
-一个数 x 的开方 sqrt 一定在 0 \~ x 之间，并且满足 sqrt == x / sqrt。可以利用二分查找在 0 \~ x 之间查找 sqrt。
+一个数 x 的开方 sqrt 一定在 0 ~ x 之间，并且满足 sqrt == x / sqrt。可以利用二分查找在 0 ~ x 之间查找 sqrt。
-对于 x = 8，它的开方是 2.82842...，最后应该返回 2 而不是 3。在循环条件为 l <= h 并且循环退出时，h 总是比 l 小 1，也就是说 h = 2，l = 3，因此最后的返回值应该为 h 而不是 l。
+对于 x = 8，它的开方是 2.82842...，最后应该返回 2 而不是 3。在循环条件为 l <= h 并且循环退出时，h 总是比 l 小 1，也就是说 h = 2，l = 3，因此最后的返回值应该为 h 而不是 l。
```java
-public int mySqrt(int x) {
- if (x <= 1) {
- return x;
- }
- int l = 1, h = x;
- while (l <= h) {
- int mid = l + (h - l) / 2;
- int sqrt = x / mid;
- if (sqrt == mid) {
- return mid;
- } else if (mid > sqrt) {
- h = mid - 1;
- } else {
- l = mid + 1;
- }
- }
- return h;
+public int mySqrt(int x) {
+ if (x <= 1) {
+ return x;
+ }
+ int l = 1, h = x;
+ while (l <= h) {
+ int mid = l + (h - l) / 2;
+ int sqrt = x / mid;
+ if (sqrt == mid) {
+ return mid;
+ } else if (mid > sqrt) {
+ h = mid - 1;
+ } else {
+ l = mid + 1;
+ }
+ }
+ return h;
}
```
-**大于给定元素的最小元素**
+**大于给定元素的最小元素**
-[744. Find Smallest Letter Greater Than Target (Easy)](https://leetcode.com/problems/find-smallest-letter-greater-than-target/description/)
+[744. Find Smallest Letter Greater Than Target (Easy)](https://leetcode.com/problems/find-smallest-letter-greater-than-target/description/)
```html
Input:
-letters = ["c", "f", "j"]
-target = "d"
-Output: "f"
+letters = ["c", "f", "j"]
+target = "d"
+Output: "f"
Input:
-letters = ["c", "f", "j"]
-target = "k"
-Output: "c"
+letters = ["c", "f", "j"]
+target = "k"
+Output: "c"
```
-题目描述：给定一个有序的字符数组 letters 和一个字符 target，要求找出 letters 中大于 target 的最小字符，如果找不到就返回第 1 个字符。
+题目描述：给定一个有序的字符数组 letters 和一个字符 target，要求找出 letters 中大于 target 的最小字符，如果找不到就返回第 1 个字符。
```java
-public char nextGreatestLetter(char[] letters, char target) {
- int n = letters.length;
- int l = 0, h = n - 1;
- while (l <= h) {
- int m = l + (h - l) / 2;
- if (letters[m] <= target) {
- l = m + 1;
- } else {
- h = m - 1;
- }
- }
- return l < n ? letters[l] : letters[0];
+public char nextGreatestLetter(char[] letters, char target) {
+ int n = letters.length;
+ int l = 0, h = n - 1;
+ while (l <= h) {
+ int m = l + (h - l) / 2;
+ if (letters[m] <= target) {
+ l = m + 1;
+ } else {
+ h = m - 1;
+ }
+ }
+ return l < n ? letters[l] : letters[0];
}
```
-**有序数组的 Single Element**
+**有序数组的 Single Element**
-[540. Single Element in a Sorted Array (Medium)](https://leetcode.com/problems/single-element-in-a-sorted-array/description/)
+[540. Single Element in a Sorted Array (Medium)](https://leetcode.com/problems/single-element-in-a-sorted-array/description/)
```html
-Input: [1, 1, 2, 3, 3, 4, 4, 8, 8]
-Output: 2
+Input: [1, 1, 2, 3, 3, 4, 4, 8, 8]
+Output: 2
```
-题目描述：一个有序数组只有一个数不出现两次，找出这个数。要求以 O(logN) 时间复杂度进行求解。
+题目描述：一个有序数组只有一个数不出现两次，找出这个数。要求以 O(logN) 时间复杂度进行求解。
-令 index 为 Single Element 在数组中的位置。如果 m 为偶数，并且 m + 1 < index，那么 nums[m] == nums[m + 1]；m + 1 >= index，那么 nums[m] != nums[m + 1]。
+令 index 为 Single Element 在数组中的位置。如果 m 为偶数，并且 m + 1 < index，那么 nums[m] == nums[m + 1]；m + 1 >= index，那么 nums[m] != nums[m + 1]。
-从上面的规律可以知道，如果 nums[m] == nums[m + 1]，那么 index 所在的数组位置为 [m + 2, h]，此时令 l = m + 2；如果 nums[m] != nums[m + 1]，那么 index 所在的数组位置为 [l, m]，此时令 h = m。
+从上面的规律可以知道，如果 nums[m] == nums[m + 1]，那么 index 所在的数组位置为 [m + 2, h]，此时令 l = m + 2；如果 nums[m] != nums[m + 1]，那么 index 所在的数组位置为 [l, m]，此时令 h = m。
-因为 h 的赋值表达式为 h = m，那么循环条件也就只能使用 l < h 这种形式。
+因为 h 的赋值表达式为 h = m，那么循环条件也就只能使用 l < h 这种形式。
```java
-public int singleNonDuplicate(int[] nums) {
- int l = 0, h = nums.length - 1;
- while (l < h) {
- int m = l + (h - l) / 2;
- if (m % 2 == 1) {
- m--; // 保证 l/h/m 都在偶数位，使得查找区间大小一直都是奇数
- }
- if (nums[m] == nums[m + 1]) {
- l = m + 2;
- } else {
- h = m;
- }
- }
- return nums[l];
+public int singleNonDuplicate(int[] nums) {
+ int l = 0, h = nums.length - 1;
+ while (l < h) {
+ int m = l + (h - l) / 2;
+ if (m % 2 == 1) {
+ m--; // 保证 l/h/m 都在偶数位，使得查找区间大小一直都是奇数
+ }
+ if (nums[m] == nums[m + 1]) {
+ l = m + 2;
+ } else {
+ h = m;
+ }
+ }
+ return nums[l];
}
```
-**第一个错误的版本**
+**第一个错误的版本**
-[278. First Bad Version (Easy)](https://leetcode.com/problems/first-bad-version/description/)
+[278. First Bad Version (Easy)](https://leetcode.com/problems/first-bad-version/description/)
-题目描述：给定一个元素 n 代表有 [1, 2, ..., n] 版本，可以调用 isBadVersion(int x) 知道某个版本是否错误，要求找到第一个错误的版本。
+题目描述：给定一个元素 n 代表有 [1, 2, ..., n] 版本，可以调用 isBadVersion(int x) 知道某个版本是否错误，要求找到第一个错误的版本。
-如果第 m 个版本出错，则表示第一个错误的版本在 [l, m] 之间，令 h = m；否则第一个错误的版本在 [m + 1, h] 之间，令 l = m + 1。
+如果第 m 个版本出错，则表示第一个错误的版本在 [l, m] 之间，令 h = m；否则第一个错误的版本在 [m + 1, h] 之间，令 l = m + 1。
-因为 h 的赋值表达式为 h = m，因此循环条件为 l < h。
+因为 h 的赋值表达式为 h = m，因此循环条件为 l < h。
```java
-public int firstBadVersion(int n) {
- int l = 1, h = n;
- while (l < h) {
- int mid = l + (h - l) / 2;
- if (isBadVersion(mid)) {
- h = mid;
- } else {
- l = mid + 1;
- }
- }
- return l;
+public int firstBadVersion(int n) {
+ int l = 1, h = n;
+ while (l < h) {
+ int mid = l + (h - l) / 2;
+ if (isBadVersion(mid)) {
+ h = mid;
+ } else {
+ l = mid + 1;
+ }
+ }
+ return l;
}
```
-**旋转数组的最小数字**
+**旋转数组的最小数字**
-[153. Find Minimum in Rotated Sorted Array (Medium)](https://leetcode.com/problems/find-minimum-in-rotated-sorted-array/description/)
+[153. Find Minimum in Rotated Sorted Array (Medium)](https://leetcode.com/problems/find-minimum-in-rotated-sorted-array/description/)
```html
-Input: [3,4,5,1,2],
-Output: 1
+Input: [3,4,5,1,2],
+Output: 1
```
```java
-public int findMin(int[] nums) {
- int l = 0, h = nums.length - 1;
- while (l < h) {
- int m = l + (h - l) / 2;
- if (nums[m] <= nums[h]) {
- h = m;
- } else {
- l = m + 1;
- }
- }
- return nums[l];
+public int findMin(int[] nums) {
+ int l = 0, h = nums.length - 1;
+ while (l < h) {
+ int m = l + (h - l) / 2;
+ if (nums[m] <= nums[h]) {
+ h = m;
+ } else {
+ l = m + 1;
+ }
+ }
+ return nums[l];
}
```
-**查找区间**
+**查找区间**
-[34. Search for a Range (Medium)](https://leetcode.com/problems/search-for-a-range/description/)
+[34. Search for a Range (Medium)](https://leetcode.com/problems/search-for-a-range/description/)
```html
-Input: nums = [5,7,7,8,8,10], target = 8
-Output: [3,4]
+Input: nums = [5,7,7,8,8,10], target = 8
+Output: [3,4]
-Input: nums = [5,7,7,8,8,10], target = 6
-Output: [-1,-1]
+Input: nums = [5,7,7,8,8,10], target = 6
+Output: [-1,-1]
```
```java
-public int[] searchRange(int[] nums, int target) {
- int first = binarySearch(nums, target);
- int last = binarySearch(nums, target + 1) - 1;
- if (first == nums.length || nums[first] != target) {
- return new int[]{-1, -1};
- } else {
- return new int[]{first, Math.max(first, last)};
- }
+public int[] searchRange(int[] nums, int target) {
+ int first = binarySearch(nums, target);
+ int last = binarySearch(nums, target + 1) - 1;
+ if (first == nums.length || nums[first] != target) {
+ return new int[]{-1, -1};
+ } else {
+ return new int[]{first, Math.max(first, last)};
+ }
}
-private int binarySearch(int[] nums, int target) {
- int l = 0, h = nums.length; // 注意 h 的初始值
- while (l < h) {
- int m = l + (h - l) / 2;
- if (nums[m] >= target) {
- h = m;
- } else {
- l = m + 1;
- }
- }
- return l;
+private int binarySearch(int[] nums, int target) {
+ int l = 0, h = nums.length; // 注意 h 的初始值
+ while (l < h) {
+ int m = l + (h - l) / 2;
+ if (nums[m] >= target) {
+ h = m;
+ } else {
+ l = m + 1;
+ }
+ }
+ return l;
}
```
-## 分治
+## 分治
-**给表达式加括号**
+**给表达式加括号**
-[241. Different Ways to Add Parentheses (Medium)](https://leetcode.com/problems/different-ways-to-add-parentheses/description/)
+[241. Different Ways to Add Parentheses (Medium)](https://leetcode.com/problems/different-ways-to-add-parentheses/description/)
```html
-Input: "2-1-1".
+Input: "2-1-1".
-((2-1)-1) = 0
-(2-(1-1)) = 2
+((2-1)-1) = 0
+(2-(1-1)) = 2
-Output : [0, 2]
+Output : [0, 2]
```
```java
-public List diffWaysToCompute(String input) {
- List ways = new ArrayList<>();
- for (int i = 0; i < input.length(); i++) {
- char c = input.charAt(i);
- if (c == '+' || c == '-' || c == '*') {
- List left = diffWaysToCompute(input.substring(0, i));
- List right = diffWaysToCompute(input.substring(i + 1));
- for (int l : left) {
- for (int r : right) {
- switch (c) {
- case '+':
- ways.add(l + r);
- break;
- case '-':
- ways.add(l - r);
- break;
- case '*':
- ways.add(l * r);
- break;
- }
- }
- }
- }
- }
- if (ways.size() == 0) {
- ways.add(Integer.valueOf(input));
- }
- return ways;
+public List diffWaysToCompute(String input) {
+ List ways = new ArrayList<>();
+ for (int i = 0; i < input.length(); i++) {
+ char c = input.charAt(i);
+ if (c == '+' || c == '-' || c == '*') {
+ List left = diffWaysToCompute(input.substring(0, i));
+ List right = diffWaysToCompute(input.substring(i + 1));
+ for (int l : left) {
+ for (int r : right) {
+ switch (c) {
+ case '+':
+ ways.add(l + r);
+ break;
+ case '-':
+ ways.add(l - r);
+ break;
+ case '*':
+ ways.add(l * r);
+ break;
+ }
+ }
+ }
+ }
+ }
+ if (ways.size() == 0) {
+ ways.add(Integer.valueOf(input));
+ }
+ return ways;
}
```
-## 搜索
+## 搜索
深度优先搜索和广度优先搜索广泛运用于树和图中，但是它们的应用远远不止如此。
-### BFS
+### BFS
-i 表示第 i 个节点与根节点的距离，推导出一个结论：对于先遍历的节点 i 与后遍历的节点 j，有 di <= dj 。利用这个结论，可以求解最短路径等 **最优解** 问题：第一次遍历到目的节点，其所经过的路径为最短路径。应该注意的是，使用 BFS 只能求解无权图的最短路径。
+每一层遍历的节点都与根节点距离相同。设 di 表示第 i 个节点与根节点的距离，推导出一个结论：对于先遍历的节点 i 与后遍历的节点 j，有 di <= dj 。利用这个结论，可以求解最短路径等 **最优解** 问题：第一次遍历到目的节点，其所经过的路径为最短路径。应该注意的是，使用 BFS 只能求解无权图的最短路径。
-在程序实现 BFS 时需要考虑以下问题：
+在程序实现 BFS 时需要考虑以下问题：
-- 队列：用来存储每一轮遍历得到的节点；
-- 标记：对于遍历过的节点，应该将它标记，防止重复遍历。
+- 队列：用来存储每一轮遍历得到的节点；
+- 标记：对于遍历过的节点，应该将它标记，防止重复遍历。
-**计算在网格中从原点到特定点的最短路径长度**
+**计算在网格中从原点到特定点的最短路径长度**
```html
[[1,1,0,1],
- [1,0,1,0],
- [1,1,1,1],
- [1,0,1,1]]
+ [1,0,1,0],
+ [1,1,1,1],
+ [1,0,1,1]]
```
-1 表示可以经过某个位置，求解从 (0, 0) 位置到 (tr, tc) 位置的最短路径长度。
+1 表示可以经过某个位置，求解从 (0, 0) 位置到 (tr, tc) 位置的最短路径长度。
```java
-public int minPathLength(int[][] grids, int tr, int tc) {
- final int[][] direction = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
- final int m = grids.length, n = grids[0].length;
- Queue> queue = new LinkedList<>();
- queue.add(new Pair<>(0, 0));
- int pathLength = 0;
- while (!queue.isEmpty()) {
- int size = queue.size();
- pathLength++;
- while (size-- > 0) {
- Pair cur = queue.poll();
- int cr = cur.getKey(), cc = cur.getValue();
- grids[cr][cc] = 0; // 标记
- for (int[] d : direction) {
- int nr = cr + d[0], nc = cc + d[1];
- if (nr < 0 || nr >= m || nc < 0 || nc >= n || grids[nr][nc] == 0) {
- continue;
- }
- if (nr == tr && nc == tc) {
- return pathLength;
- }
- queue.add(new Pair<>(nr, nc));
- }
- }
- }
- return -1;
+public int minPathLength(int[][] grids, int tr, int tc) {
+ final int[][] direction = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
+ final int m = grids.length, n = grids[0].length;
+ Queue> queue = new LinkedList<>();
+ queue.add(new Pair<>(0, 0));
+ int pathLength = 0;
+ while (!queue.isEmpty()) {
+ int size = queue.size();
+ pathLength++;
+ while (size-- > 0) {
+ Pair cur = queue.poll();
+ int cr = cur.getKey(), cc = cur.getValue();
+ grids[cr][cc] = 0; // 标记
+ for (int[] d : direction) {
+ int nr = cr + d[0], nc = cc + d[1];
+ if (nr < 0 || nr >= m || nc < 0 || nc >= n || grids[nr][nc] == 0) {
+ continue;
+ }
+ if (nr == tr && nc == tc) {
+ return pathLength;
+ }
+ queue.add(new Pair<>(nr, nc));
+ }
+ }
+ }
+ return -1;
}
```
-**组成整数的最小平方数数量**
+**组成整数的最小平方数数量**
-[279. Perfect Squares (Medium)](https://leetcode.com/problems/perfect-squares/description/)
+[279. Perfect Squares (Medium)](https://leetcode.com/problems/perfect-squares/description/)
```html
-For example, given n = 12, return 3 because 12 = 4 + 4 + 4; given n = 13, return 2 because 13 = 4 + 9.
+For example, given n = 12, return 3 because 12 = 4 + 4 + 4; given n = 13, return 2 because 13 = 4 + 9.
```
可以将每个整数看成图中的一个节点，如果两个整数之差为一个平方数，那么这两个整数所在的节点就有一条边。
-要求解最小的平方数数量，就是求解从节点 n 到节点 0 的最短路径。
+要求解最小的平方数数量，就是求解从节点 n 到节点 0 的最短路径。
本题也可以用动态规划求解，在之后动态规划部分中会再次出现。
```java
-public int numSquares(int n) {
- List squares = generateSquares(n);
- Queue queue = new LinkedList<>();
- boolean[] marked = new boolean[n + 1];
- queue.add(n);
- marked[n] = true;
- int level = 0;
- while (!queue.isEmpty()) {
- int size = queue.size();
- level++;
- while (size-- > 0) {
- int cur = queue.poll();
- for (int s : squares) {
- int next = cur - s;
- if (next < 0) {
- break;
- }
- if (next == 0) {
- return level;
- }
- if (marked[next]) {
- continue;
- }
- marked[next] = true;
- queue.add(next);
- }
- }
- }
- return n;
+public int numSquares(int n) {
+ List squares = generateSquares(n);
+ Queue queue = new LinkedList<>();
+ boolean[] marked = new boolean[n + 1];
+ queue.add(n);
+ marked[n] = true;
+ int level = 0;
+ while (!queue.isEmpty()) {
+ int size = queue.size();
+ level++;
+ while (size-- > 0) {
+ int cur = queue.poll();
+ for (int s : squares) {
+ int next = cur - s;
+ if (next < 0) {
+ break;
+ }
+ if (next == 0) {
+ return level;
+ }
+ if (marked[next]) {
+ continue;
+ }
+ marked[next] = true;
+ queue.add(next);
+ }
+ }
+ }
+ return n;
}
/**
- * 生成小于 n 的平方数序列
- * @return 1,4,9,...
- */
-private List generateSquares(int n) {
- List squares = new ArrayList<>();
- int square = 1;
- int diff = 3;
- while (square <= n) {
- squares.add(square);
- square += diff;
- diff += 2;
- }
- return squares;
+ * 生成小于 n 的平方数序列
+ * @return 1,4,9,...
+ */
+private List generateSquares(int n) {
+ List squares = new ArrayList<>();
+ int square = 1;
+ int diff = 3;
+ while (square <= n) {
+ squares.add(square);
+ square += diff;
+ diff += 2;
+ }
+ return squares;
}
```
-**最短单词路径**
+**最短单词路径**
-[127. Word Ladder (Medium)](https://leetcode.com/problems/word-ladder/description/)
+[127. Word Ladder (Medium)](https://leetcode.com/problems/word-ladder/description/)
```html
Input:
-beginWord = "hit",
-endWord = "cog",
-wordList = ["hot","dot","dog","lot","log","cog"]
+beginWord = "hit",
+endWord = "cog",
+wordList = ["hot","dot","dog","lot","log","cog"]
-Output: 5
+Output: 5
-Explanation: As one shortest transformation is "hit" -> "hot" -> "dot" -> "dog" -> "cog",
-return its length 5.
+Explanation: As one shortest transformation is "hit" -> "hot" -> "dot" -> "dog" -> "cog",
+return its length 5.
```
```html
Input:
-beginWord = "hit"
-endWord = "cog"
-wordList = ["hot","dot","dog","lot","log"]
+beginWord = "hit"
+endWord = "cog"
+wordList = ["hot","dot","dog","lot","log"]
-Output: 0
+Output: 0
-Explanation: The endWord "cog" is not in wordList, therefore no possible transformation.
+Explanation: The endWord "cog" is not in wordList, therefore no possible transformation.
```
-题目描述：找出一条从 beginWord 到 endWord 的最短路径，每次移动规定为改变一个字符，并且改变之后的字符串必须在 wordList 中。
+题目描述：找出一条从 beginWord 到 endWord 的最短路径，每次移动规定为改变一个字符，并且改变之后的字符串必须在 wordList 中。
```java
-public int ladderLength(String beginWord, String endWord, List wordList) {
- wordList.add(beginWord);
- int N = wordList.size();
- int start = N - 1;
- int end = 0;
- while (end < N && !wordList.get(end).equals(endWord)) {
- end++;
- }
- if (end == N) {
- return 0;
- }
- List[] graphic = buildGraphic(wordList);
- return getShortestPath(graphic, start, end);
+public int ladderLength(String beginWord, String endWord, List wordList) {
+ wordList.add(beginWord);
+ int N = wordList.size();
+ int start = N - 1;
+ int end = 0;
+ while (end < N && !wordList.get(end).equals(endWord)) {
+ end++;
+ }
+ if (end == N) {
+ return 0;
+ }
+ List[] graphic = buildGraphic(wordList);
+ return getShortestPath(graphic, start, end);
}
-private List[] buildGraphic(List wordList) {
- int N = wordList.size();
- List[] graphic = new List[N];
- for (int i = 0; i < N; i++) {
- graphic[i] = new ArrayList<>();
- for (int j = 0; j < N; j++) {
- if (isConnect(wordList.get(i), wordList.get(j))) {
- graphic[i].add(j);
- }
- }
- }
- return graphic;
+private List[] buildGraphic(List wordList) {
+ int N = wordList.size();
+ List[] graphic = new List[N];
+ for (int i = 0; i < N; i++) {
+ graphic[i] = new ArrayList<>();
+ for (int j = 0; j < N; j++) {
+ if (isConnect(wordList.get(i), wordList.get(j))) {
+ graphic[i].add(j);
+ }
+ }
+ }
+ return graphic;
}
-private boolean isConnect(String s1, String s2) {
- int diffCnt = 0;
- for (int i = 0; i < s1.length() && diffCnt <= 1; i++) {
- if (s1.charAt(i) != s2.charAt(i)) {
- diffCnt++;
- }
- }
- return diffCnt == 1;
+private boolean isConnect(String s1, String s2) {
+ int diffCnt = 0;
+ for (int i = 0; i < s1.length() && diffCnt <= 1; i++) {
+ if (s1.charAt(i) != s2.charAt(i)) {
+ diffCnt++;
+ }
+ }
+ return diffCnt == 1;
}
-private int getShortestPath(List[] graphic, int start, int end) {
- Queue queue = new LinkedList<>();
- boolean[] marked = new boolean[graphic.length];
- queue.add(start);
- marked[start] = true;
- int path = 1;
- while (!queue.isEmpty()) {
- int size = queue.size();
- path++;
- while (size-- > 0) {
- int cur = queue.poll();
- for (int next : graphic[cur]) {
- if (next == end) {
- return path;
- }
- if (marked[next]) {
- continue;
- }
- marked[next] = true;
- queue.add(next);
- }
- }
- }
- return 0;
+private int getShortestPath(List[] graphic, int start, int end) {
+ Queue queue = new LinkedList<>();
+ boolean[] marked = new boolean[graphic.length];
+ queue.add(start);
+ marked[start] = true;
+ int path = 1;
+ while (!queue.isEmpty()) {
+ int size = queue.size();
+ path++;
+ while (size-- > 0) {
+ int cur = queue.poll();
+ for (int next : graphic[cur]) {
+ if (next == end) {
+ return path;
+ }
+ if (marked[next]) {
+ continue;
+ }
+ marked[next] = true;
+ queue.add(next);
+ }
+ }
+ }
+ return 0;
}
```
-### DFS
+### DFS
- pacificAtlantic(int[][] matrix) {
- List ret = new ArrayList<>();
- if (matrix == null || matrix.length == 0) {
- return ret;
- }
+public List pacificAtlantic(int[][] matrix) {
+ List ret = new ArrayList<>();
+ if (matrix == null || matrix.length == 0) {
+ return ret;
+ }
- m = matrix.length;
- n = matrix[0].length;
- this.matrix = matrix;
- boolean[][] canReachP = new boolean[m][n];
- boolean[][] canReachA = new boolean[m][n];
+ m = matrix.length;
+ n = matrix[0].length;
+ this.matrix = matrix;
+ boolean[][] canReachP = new boolean[m][n];
+ boolean[][] canReachA = new boolean[m][n];
- for (int i = 0; i < m; i++) {
- dfs(i, 0, canReachP);
- dfs(i, n - 1, canReachA);
- }
- for (int i = 0; i < n; i++) {
- dfs(0, i, canReachP);
- dfs(m - 1, i, canReachA);
- }
+ for (int i = 0; i < m; i++) {
+ dfs(i, 0, canReachP);
+ dfs(i, n - 1, canReachA);
+ }
+ for (int i = 0; i < n; i++) {
+ dfs(0, i, canReachP);
+ dfs(m - 1, i, canReachA);
+ }
- for (int i = 0; i < m; i++) {
- for (int j = 0; j < n; j++) {
- if (canReachP[i][j] && canReachA[i][j]) {
- ret.add(new int[]{i, j});
- }
- }
- }
+ for (int i = 0; i < m; i++) {
+ for (int j = 0; j < n; j++) {
+ if (canReachP[i][j] && canReachA[i][j]) {
+ ret.add(new int[]{i, j});
+ }
+ }
+ }
- return ret;
+ return ret;
}
-private void dfs(int r, int c, boolean[][] canReach) {
- if (canReach[r][c]) {
- return;
- }
- canReach[r][c] = true;
- for (int[] d : direction) {
- int nextR = d[0] + r;
- int nextC = d[1] + c;
- if (nextR < 0 || nextR >= m || nextC < 0 || nextC >= n
- || matrix[r][c] > matrix[nextR][nextC]) {
+private void dfs(int r, int c, boolean[][] canReach) {
+ if (canReach[r][c]) {
+ return;
+ }
+ canReach[r][c] = true;
+ for (int[] d : direction) {
+ int nextR = d[0] + r;
+ int nextC = d[1] + c;
+ if (nextR < 0 || nextR >= m || nextC < 0 || nextC >= n
+ || matrix[r][c] > matrix[nextR][nextC]) {
- continue;
- }
- dfs(nextR, nextC, canReach);
- }
+ continue;
+ }
+ dfs(nextR, nextC, canReach);
+ }
}
```
-### Backtracking
+### Backtracking
-Backtracking（回溯）属于 DFS。
+Backtracking（回溯）属于 DFS。
-- 普通 DFS 主要用在 **可达性问题** ，这种问题只需要执行到特点的位置然后返回即可。
-- 而 Backtracking 主要用于求解 **排列组合** 问题，例如有 { 'a','b','c' } 三个字符，求解所有由这三个字符排列得到的字符串，这种问题在执行到特定的位置返回之后还会继续执行求解过程。
+- 普通 DFS 主要用在 **可达性问题**，这种问题只需要执行到特点的位置然后返回即可。
+- 而 Backtracking 主要用于求解 **排列组合** 问题，例如有 { 'a','b','c' } 三个字符，求解所有由这三个字符排列得到的字符串，这种问题在执行到特定的位置返回之后还会继续执行求解过程。
-因为 Backtracking 不是立即就返回，而要继续求解，因此在程序实现时，需要注意对元素的标记问题：
+因为 Backtracking 不是立即就返回，而要继续求解，因此在程序实现时，需要注意对元素的标记问题：
-- 在访问一个新元素进入新的递归调用时，需要将新元素标记为已经访问，这样才能在继续递归调用时不用重复访问该元素；
-- 但是在递归返回时，需要将元素标记为未访问，因为只需要保证在一个递归链中不同时访问一个元素，可以访问已经访问过但是不在当前递归链中的元素。
+- 在访问一个新元素进入新的递归调用时，需要将新元素标记为已经访问，这样才能在继续递归调用时不用重复访问该元素；
+- 但是在递归返回时，需要将元素标记为未访问，因为只需要保证在一个递归链中不同时访问一个元素，可以访问已经访问过但是不在当前递归链中的元素。
-**数字键盘组合**
+**数字键盘组合**
-[17. Letter Combinations of a Phone Number (Medium)](https://leetcode.com/problems/letter-combinations-of-a-phone-number/description/)
+[17. Letter Combinations of a Phone Number (Medium)](https://leetcode.com/problems/letter-combinations-of-a-phone-number/description/)
- letterCombinations(String digits) {
- List combinations = new ArrayList<>();
- if (digits == null || digits.length() == 0) {
- return combinations;
- }
- doCombination(new StringBuilder(), combinations, digits);
- return combinations;
+public List letterCombinations(String digits) {
+ List combinations = new ArrayList<>();
+ if (digits == null || digits.length() == 0) {
+ return combinations;
+ }
+ doCombination(new StringBuilder(), combinations, digits);
+ return combinations;
}
-private void doCombination(StringBuilder prefix, List combinations, final String digits) {
- if (prefix.length() == digits.length()) {
- combinations.add(prefix.toString());
- return;
- }
- int curDigits = digits.charAt(prefix.length()) - '0';
- String letters = KEYS[curDigits];
- for (char c : letters.toCharArray()) {
- prefix.append(c); // 添加
- doCombination(prefix, combinations, digits);
- prefix.deleteCharAt(prefix.length() - 1); // 删除
- }
+private void doCombination(StringBuilder prefix, List combinations, final String digits) {
+ if (prefix.length() == digits.length()) {
+ combinations.add(prefix.toString());
+ return;
+ }
+ int curDigits = digits.charAt(prefix.length()) - '0';
+ String letters = KEYS[curDigits];
+ for (char c : letters.toCharArray()) {
+ prefix.append(c); // 添加
+ doCombination(prefix, combinations, digits);
+ prefix.deleteCharAt(prefix.length() - 1); // 删除
+ }
}
```
-**IP 地址划分**
+**IP 地址划分**
-[93. Restore IP Addresses(Medium)](https://leetcode.com/problems/restore-ip-addresses/description/)
+[93. Restore IP Addresses(Medium)](https://leetcode.com/problems/restore-ip-addresses/description/)
```html
-Given "25525511135",
-return ["255.255.11.135", "255.255.111.35"].
+Given "25525511135",
+return ["255.255.11.135", "255.255.111.35"].
```
```java
-public List restoreIpAddresses(String s) {
- List addresses = new ArrayList<>();
- StringBuilder tempAddress = new StringBuilder();
- doRestore(0, tempAddress, addresses, s);
- return addresses;
+public List restoreIpAddresses(String s) {
+ List addresses = new ArrayList<>();
+ StringBuilder tempAddress = new StringBuilder();
+ doRestore(0, tempAddress, addresses, s);
+ return addresses;
}
-private void doRestore(int k, StringBuilder tempAddress, List addresses, String s) {
- if (k == 4 || s.length() == 0) {
- if (k == 4 && s.length() == 0) {
- addresses.add(tempAddress.toString());
- }
- return;
- }
- for (int i = 0; i < s.length() && i <= 2; i++) {
- if (i != 0 && s.charAt(0) == '0') {
- break;
- }
- String part = s.substring(0, i + 1);
- if (Integer.valueOf(part) <= 255) {
- if (tempAddress.length() != 0) {
- part = "." + part;
- }
- tempAddress.append(part);
- doRestore(k + 1, tempAddress, addresses, s.substring(i + 1));
- tempAddress.delete(tempAddress.length() - part.length(), tempAddress.length());
- }
- }
+private void doRestore(int k, StringBuilder tempAddress, List addresses, String s) {
+ if (k == 4 || s.length() == 0) {
+ if (k == 4 && s.length() == 0) {
+ addresses.add(tempAddress.toString());
+ }
+ return;
+ }
+ for (int i = 0; i < s.length() && i <= 2; i++) {
+ if (i != 0 && s.charAt(0) == '0') {
+ break;
+ }
+ String part = s.substring(0, i + 1);
+ if (Integer.valueOf(part) <= 255) {
+ if (tempAddress.length() != 0) {
+ part = "." + part;
+ }
+ tempAddress.append(part);
+ doRestore(k + 1, tempAddress, addresses, s.substring(i + 1));
+ tempAddress.delete(tempAddress.length() - part.length(), tempAddress.length());
+ }
+ }
}
```
-**在矩阵中寻找字符串**
+**在矩阵中寻找字符串**
-[79. Word Search (Medium)](https://leetcode.com/problems/word-search/description/)
+[79. Word Search (Medium)](https://leetcode.com/problems/word-search/description/)
```html
-For example,
-Given board =
+For example,
+Given board =
[
- ['A','B','C','E'],
- ['S','F','C','S'],
- ['A','D','E','E']
+ ['A','B','C','E'],
+ ['S','F','C','S'],
+ ['A','D','E','E']
]
-word = "ABCCED", -> returns true,
-word = "SEE", -> returns true,
-word = "ABCB", -> returns false.
+word = "ABCCED", -> returns true,
+word = "SEE", -> returns true,
+word = "ABCB", -> returns false.
```
```java
-private final static int[][] direction = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
-private int m;
-private int n;
+private final static int[][] direction = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
+private int m;
+private int n;
-public boolean exist(char[][] board, String word) {
- if (word == null || word.length() == 0) {
- return true;
- }
- if (board == null || board.length == 0 || board[0].length == 0) {
- return false;
- }
+public boolean exist(char[][] board, String word) {
+ if (word == null || word.length() == 0) {
+ return true;
+ }
+ if (board == null || board.length == 0 || board[0].length == 0) {
+ return false;
+ }
- m = board.length;
- n = board[0].length;
- boolean[][] hasVisited = new boolean[m][n];
+ m = board.length;
+ n = board[0].length;
+ boolean[][] hasVisited = new boolean[m][n];
- for (int r = 0; r < m; r++) {
- for (int c = 0; c < n; c++) {
- if (backtracking(0, r, c, hasVisited, board, word)) {
- return true;
- }
- }
- }
+ for (int r = 0; r < m; r++) {
+ for (int c = 0; c < n; c++) {
+ if (backtracking(0, r, c, hasVisited, board, word)) {
+ return true;
+ }
+ }
+ }
- return false;
+ return false;
}
-private boolean backtracking(int curLen, int r, int c, boolean[][] visited, final char[][] board, final String word) {
- if (curLen == word.length()) {
- return true;
- }
- if (r < 0 || r >= m || c < 0 || c >= n
- || board[r][c] != word.charAt(curLen) || visited[r][c]) {
+private boolean backtracking(int curLen, int r, int c, boolean[][] visited, final char[][] board, final String word) {
+ if (curLen == word.length()) {
+ return true;
+ }
+ if (r < 0 || r >= m || c < 0 || c >= n
+ || board[r][c] != word.charAt(curLen) || visited[r][c]) {
- return false;
- }
+ return false;
+ }
- visited[r][c] = true;
+ visited[r][c] = true;
- for (int[] d : direction) {
- if (backtracking(curLen + 1, r + d[0], c + d[1], visited, board, word)) {
- return true;
- }
- }
+ for (int[] d : direction) {
+ if (backtracking(curLen + 1, r + d[0], c + d[1], visited, board, word)) {
+ return true;
+ }
+ }
- visited[r][c] = false;
+ visited[r][c] = false;
- return false;
+ return false;
}
```
-**输出二叉树中所有从根到叶子的路径**
+**输出二叉树中所有从根到叶子的路径**
-[257. Binary Tree Paths (Easy)](https://leetcode.com/problems/binary-tree-paths/description/)
+[257. Binary Tree Paths (Easy)](https://leetcode.com/problems/binary-tree-paths/description/)
```html
- 1
- / \
-2 3
- \
- 5
+ 1
+ / \
+2 3
+ \
+ 5
```
```html
-["1->2->5", "1->3"]
+["1->2->5", "1->3"]
```
```java
-public List binaryTreePaths(TreeNode root) {
- List paths = new ArrayList<>();
- if (root == null) {
- return paths;
- }
- List 
