diff --git a/docs/notes/Docker.md b/docs/notes/Docker.md
index 36c95c92..701d53ca 100644
--- a/docs/notes/Docker.md
+++ b/docs/notes/Docker.md
@@ -1,83 +1,95 @@
-# 一、解决的问题
+
+* [一、解决的问题](#一解决的问题)
+* [二、与虚拟机的比较](#二与虚拟机的比较)
+* [三、优势](#三优势)
+* [四、使用场景](#四使用场景)
+* [五、镜像与容器](#五镜像与容器)
+* [参考资料](#参考资料)
+
+
+
+# 一、解决的问题
由于不同的机器有不同的操作系统，以及不同的库和组件，在将一个应用部署到多台机器上需要进行大量的环境配置操作。
-Docker 主要解决环境配置问题，它是一种虚拟化技术，对进程进行隔离，被隔离的进程独立于宿主操作系统和其它隔离的进程。使用 Docker 可以不修改应用程序代码，不需要开发人员学习特定环境下的技术，就能够将现有的应用程序部署在其它机器上。
+Docker 主要解决环境配置问题，它是一种虚拟化技术，对进程进行隔离，被隔离的进程独立于宿主操作系统和其它隔离的进程。使用 Docker 可以不修改应用程序代码，不需要开发人员学习特定环境下的技术，就能够将现有的应用程序部署在其它机器上。
-⭐️欢迎关注我的公众号 CyC2018，在公众号后台回复关键字 📚 **资料** 可领取复习大纲，这份大纲是我花了一整年时间整理的面试知识点列表，不仅系统整理了面试知识点，而且标注了各个知识点的重要程度，从而帮你理清多而杂的面试知识点。可以说我基本是按照这份大纲来进行复习的，这份大纲对我拿到了 BAT 头条等 Offer 起到很大的帮助。你们完全可以和我一样根据大纲上列的知识点来进行复习，就不用看很多不重要的内容，也可以知道哪些内容很重要从而多安排一些复习时间。
+
+
+⭐️欢迎关注我的公众号 CyC2018，在公众号后台回复关键字 📚 **资料** 可领取复习大纲，这份大纲是我花了一整年时间整理的面试知识点列表，不仅系统整理了面试知识点，而且标注了各个知识点的重要程度，从而帮你理清多而杂的面试知识点。可以说我基本是按照这份大纲来进行复习的，这份大纲对我拿到了 BAT 头条等 Offer 起到很大的帮助。你们完全可以和我一样根据大纲上列的知识点来进行复习，就不用看很多不重要的内容，也可以知道哪些内容很重要从而多安排一些复习时间。
+
+## URI
-## 请求和响应报文
+URI 包含 URL 和 URN。
-### 1. 请求报文
+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
```
-⭐️欢迎关注我的公众号 CyC2018，在公众号后台回复关键字 📚 **资料** 可领取复习大纲，这份大纲是我花了一整年时间整理的面试知识点列表，不仅系统整理了面试知识点，而且标注了各个知识点的重要程度，从而帮你理清多而杂的面试知识点。可以说我基本是按照这份大纲来进行复习的，这份大纲对我拿到了 BAT 头条等 Offer 起到很大的帮助。你们完全可以和我一样根据大纲上列的知识点来进行复习，就不用看很多不重要的内容，也可以知道哪些内容很重要从而多安排一些复习时间。
+ 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)
----bottom---CyC---
-
-
-
-
-
-
-
+- 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)
+
+
+
+
+⭐️欢迎关注我的公众号 CyC2018，在公众号后台回复关键字 📚 **资料** 可领取复习大纲，这份大纲是我花了一整年时间整理的面试知识点列表，不仅系统整理了面试知识点，而且标注了各个知识点的重要程度，从而帮你理清多而杂的面试知识点。可以说我基本是按照这份大纲来进行复习的，这份大纲对我拿到了 BAT 头条等 Offer 起到很大的帮助。你们完全可以和我一样根据大纲上列的知识点来进行复习，就不用看很多不重要的内容，也可以知道哪些内容很重要从而多安排一些复习时间。
+, 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();
```
@@ -682,42 +660,15 @@ 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）**
存在于继承体系中，指子类实现了一个与父类在方法声明上完全相同的一个方法。
-为了满足里式替换原则，重写有以下三个限制：
-
-<<<<<<< HEAD
-使用 @Override 注解，可以让编译器帮忙检查是否满足上面的三个限制条件。
-
-下面的示例中，SubClass 为 SuperClass 的子类，SubClass 重写了 SuperClass 的 func() 方法。其中：
-
-- 子类方法访问权限为 public，大于父类的 protected。
-- 子类的返回类型为 ArrayList，是父类返回类型 List 的子类。
-- 子类抛出的异常类型为 Exception，是父类抛出异常 Throwable 的子类。
-- 子类重写方法使用 @Override 注解，从而让编译器自动检查是否满足限制条件。
-
-```java
-class SuperClass {
- protected List func() throws Throwable {
- return new ArrayList<>();
- }
-}
-
-class SubClass extends SuperClass {
- @Override
- public ArrayList func() throws Exception {
- return new ArrayList<>();
- }
-=======
-- 子类方法的访问权限必须大于等于父类方法；
-- 子类方法的返回类型必须是父类方法返回类型或为其子类型。
-- 子类方法抛出的异常类型必须是父类抛出异常类型或为其子类型。
+为了满足里式替换原则，重写有有以下两个限制：
使用 @Override 注解，可以让编译器帮忙检查是否满足上面的三个限制条件。
@@ -740,239 +691,238 @@ class SubClass extends SuperClass {
public ArrayList func() throws Exception {
return new ArrayList<>();
}
->>>>>>> 9f680db0cc99bd992c7f979442ecf458a33f9c1b
}
```
-**2. 重载（Overload）**
+**2. 重载（Overload）**
存在于同一个类中，指一个方法与已经存在的方法名称上相同，但是参数类型、个数、顺序至少有一个不同。
应该注意的是，返回值不同，其它都相同不算是重载。
-**3. 实例**
+**3. 实例**
```java
-class A {
- public String show(D obj) {
- return ("A and D");
- }
+class A {
+ public String show(D obj) {
+ return ("A and D");
+ }
- public String show(A obj) {
- return ("A and A");
- }
+ public String show(A obj) {
+ return ("A and A");
+ }
}
-class B extends A {
- public String show(B obj) {
- return ("B and B");
- }
+class B extends A {
+ public String show(B obj) {
+ return ("B and B");
+ }
- public String show(A obj) {
- return ("B and A");
- }
+ public String show(A obj) {
+ return ("B and A");
+ }
}
-class C extends B {
+class C extends B {
}
-class D extends B {
+class D extends B {
}
```
```java
-public class Test {
+public class Test {
- public static void main(String[] args) {
- A a1 = new A();
- A a2 = new B();
- B b = new B();
- C c = new C();
- D d = new D();
- System.out.println(a1.show(b)); // A and A
- System.out.println(a1.show(c)); // A and A
- System.out.println(a1.show(d)); // A and D
- System.out.println(a2.show(b)); // B and A
- System.out.println(a2.show(c)); // B and A
- System.out.println(a2.show(d)); // A and D
- System.out.println(b.show(b)); // B and B
- System.out.println(b.show(c)); // B and B
- System.out.println(b.show(d)); // A and D
- }
+ public static void main(String[] args) {
+ A a1 = new A();
+ A a2 = new B();
+ B b = new B();
+ C c = new C();
+ D d = new D();
+ System.out.println(a1.show(b)); // A and A
+ System.out.println(a1.show(c)); // A and A
+ System.out.println(a1.show(d)); // A and D
+ System.out.println(a2.show(b)); // B and A
+ System.out.println(a2.show(c)); // B and A
+ System.out.println(a2.show(d)); // A and D
+ System.out.println(b.show(b)); // B and B
+ System.out.println(b.show(c)); // B and B
+ System.out.println(b.show(d)); // A and D
+ }
}
```
涉及到重写时，方法调用的优先级为：
-- this.show(O)
-- super.show(O)
-- this.show((super)O)
-- super.show((super)O)
+- this.show(O)
+- super.show(O)
+- this.show((super)O)
+- super.show((super)O)
-# 五、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());
```
@@ -980,290 +930,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();
+ }
}
```
@@ -1271,198 +1221,201 @@ 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.
----bottom---CyC---
-
-
+- Eckel B. Java 编程思想[M]. 机械工业出版社, 2002.
+- Bloch J. Effective java[M]. Addison-Wesley Professional, 2017.
+
+
+
+
+⭐️欢迎关注我的公众号 CyC2018，在公众号后台回复关键字 📚 **资料** 可领取复习大纲，这份大纲是我花了一整年时间整理的面试知识点列表，不仅系统整理了面试知识点，而且标注了各个知识点的重要程度，从而帮你理清多而杂的面试知识点。可以说我基本是按照这份大纲来进行复习的，这份大纲对我拿到了 BAT 头条等 Offer 起到很大的帮助。你们完全可以和我一样根据大纲上列的知识点来进行复习，就不用看很多不重要的内容，也可以知道哪些内容很重要从而多安排一些复习时间。
+ extends AbstractList
private static final int DEFAULT_CAPACITY = 10;
```
-
+ first;
transient Node last;
```
-
+ implements Map.Entry {
@@ -470,7 +490,7 @@ map.put("K3", "V3");
- 计算键值对所在的桶；
- 在链表上顺序查找，时间复杂度显然和链表的长度成正比。
-
+ [] segments;
static final int DEFAULT_CONCURRENCY_LEVEL = 16;
```
-
+ {
- [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---
-
-
-
-
-
-
-
-
+
+
+
+
+⭐️欢迎关注我的公众号 CyC2018，在公众号后台回复关键字 📚 **资料** 可领取复习大纲，这份大纲是我花了一整年时间整理的面试知识点列表，不仅系统整理了面试知识点，而且标注了各个知识点的重要程度，从而帮你理清多而杂的面试知识点。可以说我基本是按照这份大纲来进行复习的，这份大纲对我拿到了 BAT 头条等 Offer 起到很大的帮助。你们完全可以和我一样根据大纲上列的知识点来进行复习，就不用看很多不重要的内容，也可以知道哪些内容很重要从而多安排一些复习时间。
+ {
- 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
-<<<<<<< HEAD
-通过调用一个线程的 interrupt() 来中断该线程，如果该线程处于阻塞、限期等待或者无限期等待状态，那么就会抛出 InterruptedException，从而提前结束该线程。但是不能中断 I/O 阻塞和 synchronized 锁阻塞。
-=======
-通过调用一个线程的 interrupt() 来中断该线程，如果该线程处于阻塞、有限期等待或者无限期等待状态，那么就会抛出 InterruptedException，从而提前结束该线程。但是不能中断 I/O 阻塞和 synchronized 锁阻塞。
->>>>>>> 9f680db0cc99bd992c7f979442ecf458a33f9c1b
+通过调用一个线程的 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();
}
```
@@ -638,41 +626,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());
}
```
@@ -681,55 +669,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());
}
```
@@ -738,35 +726,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();
+ }
}
```
@@ -979,99 +967,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();
}
```
@@ -1425,37 +1413,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();
+ }
}
```
@@ -1463,93 +1451,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();
+ }
}
```
它所对应的底层结构图为：
-
+⭐️欢迎关注我的公众号 CyC2018，在公众号后台回复关键字 📚 **资料** 可领取复习大纲，这份大纲是我花了一整年时间整理的面试知识点列表，不仅系统整理了面试知识点，而且标注了各个知识点的重要程度，从而帮你理清多而杂的面试知识点。可以说我基本是按照这份大纲来进行复习的，这份大纲对我拿到了 BAT 头条等 Offer 起到很大的帮助。你们完全可以和我一样根据大纲上列的知识点来进行复习，就不用看很多不重要的内容，也可以知道哪些内容很重要从而多安排一些复习时间。
+
-## 程序计数器
+# 一、运行时数据区域
+
+ 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, null);
-obj = null;
+Object obj = new Object();
+PhantomReference pf = new PhantomReference(obj, null);
+obj = null;
```
-## 垃圾收集算法
+## 垃圾收集算法
-### 1. 标记 - 清除
+### 1. 标记 - 清除
-
+ <--">
+
-### 5. 初始化
+### 5. 初始化
-">
+
-初始化阶段才真正开始执行类中定义的 Java 程序代码。初始化阶段是虚拟机执行类构造器 <clinit>() 方法的过程。在准备阶段，类变量已经赋过一次系统要求的初始值，而在初始化阶段，根据程序员通过程序制定的主观计划去初始化类变量和其它资源。
+初始化阶段才真正开始执行类中定义的 Java 程序代码。初始化阶段是虚拟机执行类构造器 <clinit>() 方法的过程。在准备阶段，类变量已经赋过一次系统要求的初始值，而在初始化阶段，根据程序员通过程序制定的主观计划去初始化类变量和其它资源。
-<<<<<<< HEAD
-<clinit>() 是由编译器自动收集类中所有类变量的赋值动作和静态语句块中的语句合并产生的，编译器收集的顺序由语句在源文件中出现的顺序决定。特别注意的是，静态语句块只能访问到定义在它之前的类变量，定义在它之后的类变量只能赋值，不能访问。例如以下代码：
-=======
<clinit>() 是由编译器自动收集类中所有类变量的赋值动作和静态语句块中的语句合并产生的，编译器收集的顺序由语句在源文件中出现的顺序决定。特别注意的是，静态语句块只能访问到定义在它之前的类变量，定义在它之后的类变量只能赋值，不能访问。例如以下代码：
->>>>>>> 9f680db0cc99bd992c7f979442ecf458a33f9c1b
```java
-public class Test {
- static {
- i = 0; // 给变量赋值可以正常编译通过
- System.out.print(i); // 这句编译器会提示“非法向前引用”
- }
- static int i = 1;
+public class Test {
+ static {
+ i = 0; // 给变量赋值可以正常编译通过
+ System.out.print(i); // 这句编译器会提示“非法向前引用”
+ }
+ static int i = 1;
}
```
-由于父类的 <clinit>() 方法先执行，也就意味着父类中定义的静态语句块的执行要优先于子类。例如以下代码：
+由于父类的 <clinit>() 方法先执行，也就意味着父类中定义的静态语句块的执行要优先于子类。例如以下代码：
```java
-static class Parent {
- public static int A = 1;
- static {
- A = 2;
- }
+static class Parent {
+ public static int A = 1;
+ static {
+ A = 2;
+ }
}
-static class Sub extends Parent {
- public static int B = A;
+static class Sub extends Parent {
+ public static int B = A;
}
-public static void main(String[] args) {
- System.out.println(Sub.B); // 2
+public static void main(String[] args) {
+ System.out.println(Sub.B); // 2
}
```
-接口中不可以使用静态语句块，但仍然有类变量初始化的赋值操作，因此接口与类一样都会生成 <clinit>() 方法。但接口与类不同的是，执行接口的 <clinit>() 方法不需要先执行父接口的 <clinit>() 方法。只有当父接口中定义的变量使用时，父接口才会初始化。另外，接口的实现类在初始化时也一样不会执行接口的 <clinit>() 方法。
+接口中不可以使用静态语句块，但仍然有类变量初始化的赋值操作，因此接口与类一样都会生成 <clinit>() 方法。但接口与类不同的是，执行接口的 <clinit>() 方法不需要先执行父接口的 <clinit>() 方法。只有当父接口中定义的变量使用时，父接口才会初始化。另外，接口的实现类在初始化时也一样不会执行接口的 <clinit>() 方法。
-虚拟机会保证一个类的 <clinit>() 方法在多线程环境下被正确的加锁和同步，如果多个线程同时初始化一个类，只会有一个线程执行这个类的 <clinit>() 方法，其它线程都会阻塞等待，直到活动线程执行 <clinit>() 方法完毕。如果在一个类的 <clinit>() 方法中有耗时的操作，就可能造成多个线程阻塞，在实际过程中此种阻塞很隐蔽。
+虚拟机会保证一个类的 <clinit>() 方法在多线程环境下被正确的加锁和同步，如果多个线程同时初始化一个类，只会有一个线程执行这个类的 <clinit>() 方法，其它线程都会阻塞等待，直到活动线程执行 <clinit>() 方法完毕。如果在一个类的 <clinit>() 方法中有耗时的操作，就可能造成多个线程阻塞，在实际过程中此种阻塞很隐蔽。
-## 类初始化时机
+## 类初始化时机
-### 1. 主动引用
+### 1. 主动引用
虚拟机规范中并没有强制约束何时进行加载，但是规范严格规定了有且只有下列五种情况必须对类进行初始化（加载、验证、准备都会随之发生）：
-- 遇到 new、getstatic、putstatic、invokestatic 这四条字节码指令时，如果类没有进行过初始化，则必须先触发其初始化。最常见的生成这 4 条指令的场景是：使用 new 关键字实例化对象的时候；读取或设置一个类的静态字段（被 final 修饰、已在编译期把结果放入常量池的静态字段除外）的时候；以及调用一个类的静态方法的时候。
+- 遇到 new、getstatic、putstatic、invokestatic 这四条字节码指令时，如果类没有进行过初始化，则必须先触发其初始化。最常见的生成这 4 条指令的场景是：使用 new 关键字实例化对象的时候；读取或设置一个类的静态字段（被 final 修饰、已在编译期把结果放入常量池的静态字段除外）的时候；以及调用一个类的静态方法的时候。
-- 使用 java.lang.reflect 包的方法对类进行反射调用的时候，如果类没有进行初始化，则需要先触发其初始化。
+- 使用 java.lang.reflect 包的方法对类进行反射调用的时候，如果类没有进行初始化，则需要先触发其初始化。
-- 当初始化一个类的时候，如果发现其父类还没有进行过初始化，则需要先触发其父类的初始化。
+- 当初始化一个类的时候，如果发现其父类还没有进行过初始化，则需要先触发其父类的初始化。
-- 当虚拟机启动时，用户需要指定一个要执行的主类（包含 main() 方法的那个类），虚拟机会先初始化这个主类；
+- 当虚拟机启动时，用户需要指定一个要执行的主类（包含 main() 方法的那个类），虚拟机会先初始化这个主类；
-- 当使用 JDK 1.7 的动态语言支持时，如果一个 java.lang.invoke.MethodHandle 实例最后的解析结果为 REF_getStatic, REF_putStatic, REF_invokeStatic 的方法句柄，并且这个方法句柄所对应的类没有进行过初始化，则需要先触发其初始化；
+- 当使用 JDK 1.7 的动态语言支持时，如果一个 java.lang.invoke.MethodHandle 实例最后的解析结果为 REF_getStatic, REF_putStatic, REF_invokeStatic 的方法句柄，并且这个方法句柄所对应的类没有进行过初始化，则需要先触发其初始化；
-### 2. 被动引用
+### 2. 被动引用
-以上 5 种场景中的行为称为对一个类进行主动引用。除此之外，所有引用类的方式都不会触发初始化，称为被动引用。被动引用的常见例子包括：
+以上 5 种场景中的行为称为对一个类进行主动引用。除此之外，所有引用类的方式都不会触发初始化，称为被动引用。被动引用的常见例子包括：
-- 通过子类引用父类的静态字段，不会导致子类初始化。
+- 通过子类引用父类的静态字段，不会导致子类初始化。
```java
-System.out.println(SubClass.value); // value 字段在 SuperClass 中定义
+System.out.println(SubClass.value); // value 字段在 SuperClass 中定义
```
-- 通过数组定义来引用类，不会触发此类的初始化。该过程会对数组类进行初始化，数组类是一个由虚拟机自动生成的、直接继承自 Object 的子类，其中包含了数组的属性和方法。
+- 通过数组定义来引用类，不会触发此类的初始化。该过程会对数组类进行初始化，数组类是一个由虚拟机自动生成的、直接继承自 Object 的子类，其中包含了数组的属性和方法。
```java
-SuperClass[] sca = new SuperClass[10];
+SuperClass[] sca = new SuperClass[10];
```
-- 常量在编译阶段会存入调用类的常量池中，本质上并没有直接引用到定义常量的类，因此不会触发定义常量的类的初始化。
+- 常量在编译阶段会存入调用类的常量池中，本质上并没有直接引用到定义常量的类，因此不会触发定义常量的类的初始化。
```java
System.out.println(ConstClass.HELLOWORLD);
```
-## 类与类加载器
+## 类与类加载器
两个类相等，需要类本身相等，并且使用同一个类加载器进行加载。这是因为每一个类加载器都拥有一个独立的类名称空间。
-这里的相等，包括类的 Class 对象的 equals() 方法、isAssignableFrom() 方法、isInstance() 方法的返回结果为 true，也包括使用 instanceof 关键字做对象所属关系判定结果为 true。
+这里的相等，包括类的 Class 对象的 equals() 方法、isAssignableFrom() 方法、isInstance() 方法的返回结果为 true，也包括使用 instanceof 关键字做对象所属关系判定结果为 true。
-## 类加载器分类
+## 类加载器分类
-从 Java 虚拟机的角度来讲，只存在以下两种不同的类加载器：
+从 Java 虚拟机的角度来讲，只存在以下两种不同的类加载器：
-- 启动类加载器（Bootstrap ClassLoader），使用 C++ 实现，是虚拟机自身的一部分；
+- 启动类加载器（Bootstrap ClassLoader），使用 C++ 实现，是虚拟机自身的一部分；
-- 所有其它类的加载器，使用 Java 实现，独立于虚拟机，继承自抽象类 java.lang.ClassLoader。
+- 所有其它类的加载器，使用 Java 实现，独立于虚拟机，继承自抽象类 java.lang.ClassLoader。
-从 Java 开发人员的角度看，类加载器可以划分得更细致一些：
+从 Java 开发人员的角度看，类加载器可以划分得更细致一些：
-- 启动类加载器（Bootstrap ClassLoader）此类加载器负责将存放在 <JRE_HOME>\lib 目录中的，或者被 -Xbootclasspath 参数所指定的路径中的，并且是虚拟机识别的（仅按照文件名识别，如 rt.jar，名字不符合的类库即使放在 lib 目录中也不会被加载）类库加载到虚拟机内存中。启动类加载器无法被 Java 程序直接引用，用户在编写自定义类加载器时，如果需要把加载请求委派给启动类加载器，直接使用 null 代替即可。
+- 启动类加载器（Bootstrap ClassLoader）此类加载器负责将存放在 <JRE_HOME>\lib 目录中的，或者被 -Xbootclasspath 参数所指定的路径中的，并且是虚拟机识别的（仅按照文件名识别，如 rt.jar，名字不符合的类库即使放在 lib 目录中也不会被加载）类库加载到虚拟机内存中。启动类加载器无法被 Java 程序直接引用，用户在编写自定义类加载器时，如果需要把加载请求委派给启动类加载器，直接使用 null 代替即可。
-- 扩展类加载器（Extension ClassLoader）这个类加载器是由 ExtClassLoader（sun.misc.Launcher$ExtClassLoader）实现的。它负责将 <JAVA_HOME>/lib/ext 或者被 java.ext.dir 系统变量所指定路径中的所有类库加载到内存中，开发者可以直接使用扩展类加载器。
+- 扩展类加载器（Extension ClassLoader）这个类加载器是由 ExtClassLoader（sun.misc.Launcher$ExtClassLoader）实现的。它负责将 <JAVA_HOME>/lib/ext 或者被 java.ext.dir 系统变量所指定路径中的所有类库加载到内存中，开发者可以直接使用扩展类加载器。
-- 应用程序类加载器（Application ClassLoader）这个类加载器是由 AppClassLoader（sun.misc.Launcher$AppClassLoader）实现的。由于这个类加载器是 ClassLoader 中的 getSystemClassLoader() 方法的返回值，因此一般称为系统类加载器。它负责加载用户类路径（ClassPath）上所指定的类库，开发者可以直接使用这个类加载器，如果应用程序中没有自定义过自己的类加载器，一般情况下这个就是程序中默认的类加载器。
+- 应用程序类加载器（Application ClassLoader）这个类加载器是由 AppClassLoader（sun.misc.Launcher$AppClassLoader）实现的。由于这个类加载器是 ClassLoader 中的 getSystemClassLoader() 方法的返回值，因此一般称为系统类加载器。它负责加载用户类路径（ClassPath）上所指定的类库，开发者可以直接使用这个类加载器，如果应用程序中没有自定义过自己的类加载器，一般情况下这个就是程序中默认的类加载器。
-
+
-## 双亲委派模型
+## 双亲委派模型
应用程序是由三种类加载器互相配合从而实现类加载，除此之外还可以加入自己定义的类加载器。
-下图展示了类加载器之间的层次关系，称为双亲委派模型（Parents Delegation Model）。该模型要求除了顶层的启动类加载器外，其它的类加载器都要有自己的父类加载器。这里的父子关系一般通过组合关系（Composition）来实现，而不是继承关系（Inheritance）。
+下图展示了类加载器之间的层次关系，称为双亲委派模型（Parents Delegation Model）。该模型要求除了顶层的启动类加载器外，其它的类加载器都要有自己的父类加载器。这里的父子关系一般通过组合关系（Composition）来实现，而不是继承关系（Inheritance）。
-
+⭐️欢迎关注我的公众号 CyC2018，在公众号后台回复关键字 📚 **资料** 可领取复习大纲，这份大纲是我花了一整年时间整理的面试知识点列表，不仅系统整理了面试知识点，而且标注了各个知识点的重要程度，从而帮你理清多而杂的面试知识点。可以说我基本是按照这份大纲来进行复习的，这份大纲对我拿到了 BAT 头条等 Offer 起到很大的帮助。你们完全可以和我一样根据大纲上列的知识点来进行复习，就不用看很多不重要的内容，也可以知道哪些内容很重要从而多安排一些复习时间。
+
diff --git a/docs/notes/Leetcode 题解 - 二分查找.md b/docs/notes/Leetcode 题解 - 二分查找.md
index 5f9da8de..72ae790f 100644
--- a/docs/notes/Leetcode 题解 - 二分查找.md
+++ b/docs/notes/Leetcode 题解 - 二分查找.md
@@ -1,277 +1,300 @@
-# 原理
+
+* [原理](#原理)
+ * [1. 正常实现](#1-正常实现)
+ * [2. 时间复杂度](#2-时间复杂度)
+ * [3. m 计算](#3-m-计算)
+ * [4. 返回值](#4-返回值)
+ * [5. 变种](#5-变种)
+* [例题](#例题)
+ * [1. 求开方](#1-求开方)
+ * [2. 大于给定元素的最小元素](#2-大于给定元素的最小元素)
+ * [3. 有序数组的 Single Element](#3-有序数组的-single-element)
+ * [4. 第一个错误的版本](#4-第一个错误的版本)
+ * [5. 旋转数组的最小数字](#5-旋转数组的最小数字)
+ * [6. 查找区间](#6-查找区间)
+
-## 1. 正常实现
+
+# 原理
+
+## 1. 正常实现
```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;
}
```
-## 2. 时间复杂度
+## 2. 时间复杂度
-二分查找也称为折半查找，每次都能将查找区间减半，这种折半特性的算法时间复杂度为 O(logN)。
+二分查找也称为折半查找，每次都能将查找区间减半，这种折半特性的算法时间复杂度为 O(logN)。
-## 3. m 计算
+## 3. 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 可能出现加法溢出，最好使用第二种方式。
-## 4. 返回值
+## 4. 返回值
-循环退出时如果仍然没有查找到 key，那么表示查找失败。可以有两种返回值：
+循环退出时如果仍然没有查找到 key，那么表示查找失败。可以有两种返回值：
-- -1：以一个错误码表示没有查找到 key
-- l：将 key 插入到 nums 中的正确位置
+- -1：以一个错误码表示没有查找到 key
+- l：将 key 插入到 nums 中的正确位置
-## 5. 变种
+## 5. 变种
-二分查找可以有很多变种，变种实现要注意边界值的判断。例如在一个有重复元素的数组中查找 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 是否相等。
-# 例题
+# 例题
-## 1. 求开方
+## 1. 求开方
-[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;
}
```
-## 2. 大于给定元素的最小元素
+## 2. 大于给定元素的最小元素
-[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];
}
```
-## 3. 有序数组的 Single Element
+## 3. 有序数组的 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];
}
```
-## 4. 第一个错误的版本
+## 4. 第一个错误的版本
-[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;
}
```
-## 5. 旋转数组的最小数字
+## 5. 旋转数组的最小数字
-[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];
}
```
-## 6. 查找区间
+## 6. 查找区间
-[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;
}
```
+
+
+
+
+⭐️欢迎关注我的公众号 CyC2018，在公众号后台回复关键字 📚 **资料** 可领取复习大纲，这份大纲是我花了一整年时间整理的面试知识点列表，不仅系统整理了面试知识点，而且标注了各个知识点的重要程度，从而帮你理清多而杂的面试知识点。可以说我基本是按照这份大纲来进行复习的，这份大纲对我拿到了 BAT 头条等 Offer 起到很大的帮助。你们完全可以和我一样根据大纲上列的知识点来进行复习，就不用看很多不重要的内容，也可以知道哪些内容很重要从而多安排一些复习时间。
+
diff --git a/docs/notes/Leetcode 题解 - 位运算.md b/docs/notes/Leetcode 题解 - 位运算.md
index 08f7f3fe..f9f1af46 100644
--- a/docs/notes/Leetcode 题解 - 位运算.md
+++ b/docs/notes/Leetcode 题解 - 位运算.md
@@ -1,405 +1,433 @@
-# 原理
+
+* [原理](#原理)
+ * [1. 基本原理](#1-基本原理)
+ * [2. mask 计算](#2-mask-计算)
+ * [3. Java 中的位操作](#3-java-中的位操作)
+* [例题](#例题)
+ * [统计两个数的二进制表示有多少位不同](#统计两个数的二进制表示有多少位不同)
+ * [数组中唯一一个不重复的元素](#数组中唯一一个不重复的元素)
+ * [找出数组中缺失的那个数](#找出数组中缺失的那个数)
+ * [数组中不重复的两个元素](#数组中不重复的两个元素)
+ * [翻转一个数的比特位](#翻转一个数的比特位)
+ * [不用额外变量交换两个整数](#不用额外变量交换两个整数)
+ * [判断一个数是不是 2 的 n 次方](#判断一个数是不是-2-的-n-次方)
+ * [判断一个数是不是 4 的 n 次方](#判断一个数是不是-4-的-n-次方)
+ * [判断一个数的位级表示是否不会出现连续的 0 和 1](#判断一个数的位级表示是否不会出现连续的-0-和-1)
+ * [求一个数的补码](#求一个数的补码)
+ * [实现整数的加法](#实现整数的加法)
+ * [字符串数组最大乘积](#字符串数组最大乘积)
+ * [统计从 0 \~ n 每个数的二进制表示中 1 的个数](#统计从-0-\~-n-每个数的二进制表示中-1-的个数)
+
-## 1. 基本原理
-0s 表示一串 0，1s 表示一串 1。
+# 原理
+
+## 1. 基本原理
+
+0s 表示一串 0，1s 表示一串 1。
```
-x ^ 0s = x x & 0s = 0 x | 0s = x
-x ^ 1s = ~x x & 1s = x x | 1s = 1s
-x ^ x = 0 x & x = x x | x = x
+x ^ 0s = x x & 0s = 0 x | 0s = x
+x ^ 1s = ~x x & 1s = x x | 1s = 1s
+x ^ x = 0 x & x = x x | x = x
```
-- 利用 x ^ 1s = ~x 的特点，可以将位级表示翻转；利用 x ^ x = 0 的特点，可以将三个数中重复的两个数去除，只留下另一个数。
-- 利用 x & 0s = 0 和 x & 1s = x 的特点，可以实现掩码操作。一个数 num 与 mask：00111100 进行位与操作，只保留 num 中与 mask 的 1 部分相对应的位。
-- 利用 x | 0s = x 和 x | 1s = 1s 的特点，可以实现设值操作。一个数 num 与 mask：00111100 进行位或操作，将 num 中与 mask 的 1 部分相对应的位都设置为 1。
+- 利用 x ^ 1s = \~x 的特点，可以将位级表示翻转；利用 x ^ x = 0 的特点，可以将三个数中重复的两个数去除，只留下另一个数。
+- 利用 x & 0s = 0 和 x & 1s = x 的特点，可以实现掩码操作。一个数 num 与 mask：00111100 进行位与操作，只保留 num 中与 mask 的 1 部分相对应的位。
+- 利用 x | 0s = x 和 x | 1s = 1s 的特点，可以实现设值操作。一个数 num 与 mask：00111100 进行位或操作，将 num 中与 mask 的 1 部分相对应的位都设置为 1。
位与运算技巧：
-- n&(n-1) 去除 n 的位级表示中最低的那一位。例如对于二进制表示 10110100，减去 1 得到 10110011，这两个数相与得到 10110000。
-- n&(-n) 得到 n 的位级表示中最低的那一位。-n 得到 n 的反码加 1，对于二进制表示 10110100，-n 得到 01001100，相与得到 00000100。
-- n-n&(~n+1) 去除 n 的位级表示中最高的那一位。
+- n&(n-1) 去除 n 的位级表示中最低的那一位。例如对于二进制表示 10110100，减去 1 得到 10110011，这两个数相与得到 10110000。
+- n&(-n) 得到 n 的位级表示中最低的那一位。-n 得到 n 的反码加 1，对于二进制表示 10110100，-n 得到 01001100，相与得到 00000100。
+- n-n&(\~n+1) 去除 n 的位级表示中最高的那一位。
移位运算：
-- \>\> n 为算术右移，相当于除以 2n ；
-- \>\>\> n 为无符号右移，左边会补上 0。
-- << n 为算术左移，相当于乘以 2n 。
+- \>\> n 为算术右移，相当于除以 2n ；
+- \>\>\> n 为无符号右移，左边会补上 0。
+- << n 为算术左移，相当于乘以 2n 。
-## 2. mask 计算
+## 2. mask 计算
-要获取 111111111，将 0 取反即可，~0。
+要获取 111111111，将 0 取反即可，\~0。
-要得到只有第 i 位为 1 的 mask，将 1 向左移动 i-1 位即可，1<<(i-1) 。例如 1<<4 得到只有第 5 位为 1 的 mask ：00010000。
+要得到只有第 i 位为 1 的 mask，将 1 向左移动 i-1 位即可，1<<(i-1) 。例如 1<<4 得到只有第 5 位为 1 的 mask ：00010000。
-要得到 1 到 i 位为 1 的 mask，1<<(i+1)-1 即可，例如将 1<<(4+1)-1 = 00010000-1 = 00001111。
+要得到 1 到 i 位为 1 的 mask，1<<(i+1)-1 即可，例如将 1<<(4+1)-1 = 00010000-1 = 00001111。
-要得到 1 到 i 位为 0 的 mask，只需将 1 到 i 位为 1 的 mask 取反，即 ~(1<<(i+1)-1)。
+要得到 1 到 i 位为 0 的 mask，只需将 1 到 i 位为 1 的 mask 取反，即 \~(1<<(i+1)-1)。
-## 3. Java 中的位操作
+## 3. Java 中的位操作
```html
-static int Integer.bitCount(); // 统计 1 的数量
-static int Integer.highestOneBit(); // 获得最高位
-static String toBinaryString(int i); // 转换为二进制表示的字符串
+static int Integer.bitCount(); // 统计 1 的数量
+static int Integer.highestOneBit(); // 获得最高位
+static String toBinaryString(int i); // 转换为二进制表示的字符串
```
-# 例题
+# 例题
-## 统计两个数的二进制表示有多少位不同
+## 统计两个数的二进制表示有多少位不同
-[461. Hamming Distance (Easy)](https://leetcode.com/problems/hamming-distance/)
+[461. Hamming Distance (Easy)](https://leetcode.com/problems/hamming-distance/)
```html
-Input: x = 1, y = 4
+Input: x = 1, y = 4
-Output: 2
+Output: 2
Explanation:
-1 (0 0 0 1)
-4 (0 1 0 0)
- ↑ ↑
+1 (0 0 0 1)
+4 (0 1 0 0)
+ ↑ ↑
-The above arrows point to positions where the corresponding bits are different.
+The above arrows point to positions where the corresponding bits are different.
```
-对两个数进行异或操作，位级表示不同的那一位为 1，统计有多少个 1 即可。
+对两个数进行异或操作，位级表示不同的那一位为 1，统计有多少个 1 即可。
```java
-public int hammingDistance(int x, int y) {
- int z = x ^ y;
- int cnt = 0;
- while(z != 0) {
- if ((z & 1) == 1) cnt++;
- z = z >> 1;
- }
- return cnt;
+public int hammingDistance(int x, int y) {
+ int z = x ^ y;
+ int cnt = 0;
+ while(z != 0) {
+ if ((z & 1) == 1) cnt++;
+ z = z >> 1;
+ }
+ return cnt;
}
```
-使用 z&(z-1) 去除 z 位级表示最低的那一位。
+使用 z&(z-1) 去除 z 位级表示最低的那一位。
```java
-public int hammingDistance(int x, int y) {
- int z = x ^ y;
- int cnt = 0;
- while (z != 0) {
- z &= (z - 1);
- cnt++;
- }
- return cnt;
+public int hammingDistance(int x, int y) {
+ int z = x ^ y;
+ int cnt = 0;
+ while (z != 0) {
+ z &= (z - 1);
+ cnt++;
+ }
+ return cnt;
}
```
-可以使用 Integer.bitcount() 来统计 1 个的个数。
+可以使用 Integer.bitcount() 来统计 1 个的个数。
```java
-public int hammingDistance(int x, int y) {
- return Integer.bitCount(x ^ y);
+public int hammingDistance(int x, int y) {
+ return Integer.bitCount(x ^ y);
}
```
-## 数组中唯一一个不重复的元素
+## 数组中唯一一个不重复的元素
-[136. Single Number (Easy)](https://leetcode.com/problems/single-number/description/)
+[136. Single Number (Easy)](https://leetcode.com/problems/single-number/description/)
```html
-Input: [4,1,2,1,2]
-Output: 4
+Input: [4,1,2,1,2]
+Output: 4
```
-两个相同的数异或的结果为 0，对所有数进行异或操作，最后的结果就是单独出现的那个数。
+两个相同的数异或的结果为 0，对所有数进行异或操作，最后的结果就是单独出现的那个数。
```java
-public int singleNumber(int[] nums) {
- int ret = 0;
- for (int n : nums) ret = ret ^ n;
- return ret;
+public int singleNumber(int[] nums) {
+ int ret = 0;
+ for (int n : nums) ret = ret ^ n;
+ return ret;
}
```
-## 找出数组中缺失的那个数
+## 找出数组中缺失的那个数
-[268. Missing Number (Easy)](https://leetcode.com/problems/missing-number/description/)
+[268. Missing Number (Easy)](https://leetcode.com/problems/missing-number/description/)
```html
-Input: [3,0,1]
-Output: 2
+Input: [3,0,1]
+Output: 2
```
-题目描述：数组元素在 0-n 之间，但是有一个数是缺失的，要求找到这个缺失的数。
+题目描述：数组元素在 0-n 之间，但是有一个数是缺失的，要求找到这个缺失的数。
```java
-public int missingNumber(int[] nums) {
- int ret = 0;
- for (int i = 0; i < nums.length; i++) {
- ret = ret ^ i ^ nums[i];
- }
- return ret ^ nums.length;
+public int missingNumber(int[] nums) {
+ int ret = 0;
+ for (int i = 0; i < nums.length; i++) {
+ ret = ret ^ i ^ nums[i];
+ }
+ return ret ^ nums.length;
}
```
-## 数组中不重复的两个元素
+## 数组中不重复的两个元素
-[260. Single Number III (Medium)](https://leetcode.com/problems/single-number-iii/description/)
+[260. Single Number III (Medium)](https://leetcode.com/problems/single-number-iii/description/)
两个不相等的元素在位级表示上必定会有一位存在不同。
将数组的所有元素异或得到的结果为不存在重复的两个元素异或的结果。
-diff &= -diff 得到出 diff 最右侧不为 0 的位，也就是不存在重复的两个元素在位级表示上最右侧不同的那一位，利用这一位就可以将两个元素区分开来。
+diff &= -diff 得到出 diff 最右侧不为 0 的位，也就是不存在重复的两个元素在位级表示上最右侧不同的那一位，利用这一位就可以将两个元素区分开来。
```java
-public int[] singleNumber(int[] nums) {
- int diff = 0;
- for (int num : nums) diff ^= num;
- diff &= -diff; // 得到最右一位
- int[] ret = new int[2];
- for (int num : nums) {
- if ((num & diff) == 0) ret[0] ^= num;
- else ret[1] ^= num;
- }
- return ret;
+public int[] singleNumber(int[] nums) {
+ int diff = 0;
+ for (int num : nums) diff ^= num;
+ diff &= -diff; // 得到最右一位
+ int[] ret = new int[2];
+ for (int num : nums) {
+ if ((num & diff) == 0) ret[0] ^= num;
+ else ret[1] ^= num;
+ }
+ return ret;
}
```
-## 翻转一个数的比特位
+## 翻转一个数的比特位
-[190. Reverse Bits (Easy)](https://leetcode.com/problems/reverse-bits/description/)
+[190. Reverse Bits (Easy)](https://leetcode.com/problems/reverse-bits/description/)
```java
-public int reverseBits(int n) {
- int ret = 0;
- for (int i = 0; i < 32; i++) {
- ret <<= 1;
- ret |= (n & 1);
- n >>>= 1;
- }
- return ret;
+public int reverseBits(int n) {
+ int ret = 0;
+ for (int i = 0; i < 32; i++) {
+ ret <<= 1;
+ ret |= (n & 1);
+ n >>>= 1;
+ }
+ return ret;
}
```
-如果该函数需要被调用很多次，可以将 int 拆成 4 个 byte，然后缓存 byte 对应的比特位翻转，最后再拼接起来。
+如果该函数需要被调用很多次，可以将 int 拆成 4 个 byte，然后缓存 byte 对应的比特位翻转，最后再拼接起来。
```java
-private static Map cache = new HashMap<>();
+private static Map cache = new HashMap<>();
-public int reverseBits(int n) {
- int ret = 0;
- for (int i = 0; i < 4; i++) {
- ret <<= 8;
- ret |= reverseByte((byte) (n & 0b11111111));
- n >>= 8;
- }
- return ret;
+public int reverseBits(int n) {
+ int ret = 0;
+ for (int i = 0; i < 4; i++) {
+ ret <<= 8;
+ ret |= reverseByte((byte) (n & 0b11111111));
+ n >>= 8;
+ }
+ return ret;
}
-private int reverseByte(byte b) {
- if (cache.containsKey(b)) return cache.get(b);
- int ret = 0;
- byte t = b;
- for (int i = 0; i < 8; i++) {
- ret <<= 1;
- ret |= t & 1;
- t >>= 1;
- }
- cache.put(b, ret);
- return ret;
+private int reverseByte(byte b) {
+ if (cache.containsKey(b)) return cache.get(b);
+ int ret = 0;
+ byte t = b;
+ for (int i = 0; i < 8; i++) {
+ ret <<= 1;
+ ret |= t & 1;
+ t >>= 1;
+ }
+ cache.put(b, ret);
+ return ret;
}
```
-## 不用额外变量交换两个整数
+## 不用额外变量交换两个整数
-[程序员代码面试指南 ：P317](#)
+[程序员代码面试指南 ：P317](#)
```java
-a = a ^ b;
-b = a ^ b;
-a = a ^ b;
+a = a ^ b;
+b = a ^ b;
+a = a ^ b;
```
-## 判断一个数是不是 2 的 n 次方
+## 判断一个数是不是 2 的 n 次方
-[231. Power of Two (Easy)](https://leetcode.com/problems/power-of-two/description/)
+[231. Power of Two (Easy)](https://leetcode.com/problems/power-of-two/description/)
-二进制表示只有一个 1 存在。
+二进制表示只有一个 1 存在。
```java
-public boolean isPowerOfTwo(int n) {
- return n > 0 && Integer.bitCount(n) == 1;
+public boolean isPowerOfTwo(int n) {
+ return n > 0 && Integer.bitCount(n) == 1;
}
```
-利用 1000 & 0111 == 0 这种性质，得到以下解法：
+利用 1000 & 0111 == 0 这种性质，得到以下解法：
```java
-public boolean isPowerOfTwo(int n) {
- return n > 0 && (n & (n - 1)) == 0;
+public boolean isPowerOfTwo(int n) {
+ return n > 0 && (n & (n - 1)) == 0;
}
```
-## 判断一个数是不是 4 的 n 次方
+## 判断一个数是不是 4 的 n 次方
-[342. Power of Four (Easy)](https://leetcode.com/problems/power-of-four/)
+[342. Power of Four (Easy)](https://leetcode.com/problems/power-of-four/)
-这种数在二进制表示中有且只有一个奇数位为 1，例如 16（10000）。
+这种数在二进制表示中有且只有一个奇数位为 1，例如 16（10000）。
```java
-public boolean isPowerOfFour(int num) {
- return num > 0 && (num & (num - 1)) == 0 && (num & 0b01010101010101010101010101010101) != 0;
+public boolean isPowerOfFour(int num) {
+ return num > 0 && (num & (num - 1)) == 0 && (num & 0b01010101010101010101010101010101) != 0;
}
```
也可以使用正则表达式进行匹配。
```java
-public boolean isPowerOfFour(int num) {
- return Integer.toString(num, 4).matches("10*");
+public boolean isPowerOfFour(int num) {
+ return Integer.toString(num, 4).matches("10*");
}
```
-## 判断一个数的位级表示是否不会出现连续的 0 和 1
+## 判断一个数的位级表示是否不会出现连续的 0 和 1
-[693. Binary Number with Alternating Bits (Easy)](https://leetcode.com/problems/binary-number-with-alternating-bits/description/)
+[693. Binary Number with Alternating Bits (Easy)](https://leetcode.com/problems/binary-number-with-alternating-bits/description/)
```html
-Input: 10
-Output: True
+Input: 10
+Output: True
Explanation:
-The binary representation of 10 is: 1010.
+The binary representation of 10 is: 1010.
-Input: 11
-Output: False
+Input: 11
+Output: False
Explanation:
-The binary representation of 11 is: 1011.
+The binary representation of 11 is: 1011.
```
-对于 1010 这种位级表示的数，把它向右移动 1 位得到 101，这两个数每个位都不同，因此异或得到的结果为 1111。
+对于 1010 这种位级表示的数，把它向右移动 1 位得到 101，这两个数每个位都不同，因此异或得到的结果为 1111。
```java
-public boolean hasAlternatingBits(int n) {
- int a = (n ^ (n >> 1));
- return (a & (a + 1)) == 0;
+public boolean hasAlternatingBits(int n) {
+ int a = (n ^ (n >> 1));
+ return (a & (a + 1)) == 0;
}
```
-## 求一个数的补码
+## 求一个数的补码
-[476. Number Complement (Easy)](https://leetcode.com/problems/number-complement/description/)
+[476. Number Complement (Easy)](https://leetcode.com/problems/number-complement/description/)
```html
-Input: 5
-Output: 2
-Explanation: The binary representation of 5 is 101 (no leading zero bits), and its complement is 010. So you need to output 2.
+Input: 5
+Output: 2
+Explanation: The binary representation of 5 is 101 (no leading zero bits), and its complement is 010. So you need to output 2.
```
-题目描述：不考虑二进制表示中的首 0 部分。
+题目描述：不考虑二进制表示中的首 0 部分。
-对于 00000101，要求补码可以将它与 00000111 进行异或操作。那么问题就转换为求掩码 00000111。
+对于 00000101，要求补码可以将它与 00000111 进行异或操作。那么问题就转换为求掩码 00000111。
```java
-public int findComplement(int num) {
- if (num == 0) return 1;
- int mask = 1 << 30;
- while ((num & mask) == 0) mask >>= 1;
- mask = (mask << 1) - 1;
- return num ^ mask;
+public int findComplement(int num) {
+ if (num == 0) return 1;
+ int mask = 1 << 30;
+ while ((num & mask) == 0) mask >>= 1;
+ mask = (mask << 1) - 1;
+ return num ^ mask;
}
```
-可以利用 Java 的 Integer.highestOneBit() 方法来获得含有首 1 的数。
+可以利用 Java 的 Integer.highestOneBit() 方法来获得含有首 1 的数。
```java
-public int findComplement(int num) {
- if (num == 0) return 1;
- int mask = Integer.highestOneBit(num);
- mask = (mask << 1) - 1;
- return num ^ mask;
+public int findComplement(int num) {
+ if (num == 0) return 1;
+ int mask = Integer.highestOneBit(num);
+ mask = (mask << 1) - 1;
+ return num ^ mask;
}
```
-对于 10000000 这样的数要扩展成 11111111，可以利用以下方法：
+对于 10000000 这样的数要扩展成 11111111，可以利用以下方法：
```html
-mask |= mask >> 1 11000000
-mask |= mask >> 2 11110000
-mask |= mask >> 4 11111111
+mask |= mask >> 1 11000000
+mask |= mask >> 2 11110000
+mask |= mask >> 4 11111111
```
```java
-public int findComplement(int num) {
- int mask = num;
- mask |= mask >> 1;
- mask |= mask >> 2;
- mask |= mask >> 4;
- mask |= mask >> 8;
- mask |= mask >> 16;
- return (mask ^ num);
+public int findComplement(int num) {
+ int mask = num;
+ mask |= mask >> 1;
+ mask |= mask >> 2;
+ mask |= mask >> 4;
+ mask |= mask >> 8;
+ mask |= mask >> 16;
+ return (mask ^ num);
}
```
-## 实现整数的加法
+## 实现整数的加法
-[371. Sum of Two Integers (Easy)](https://leetcode.com/problems/sum-of-two-integers/description/)
+[371. Sum of Two Integers (Easy)](https://leetcode.com/problems/sum-of-two-integers/description/)
-a ^ b 表示没有考虑进位的情况下两数的和，(a & b) << 1 就是进位。
+a ^ b 表示没有考虑进位的情况下两数的和，(a & b) << 1 就是进位。
-递归会终止的原因是 (a & b) << 1 最右边会多一个 0，那么继续递归，进位最右边的 0 会慢慢增多，最后进位会变为 0，递归终止。
+递归会终止的原因是 (a & b) << 1 最右边会多一个 0，那么继续递归，进位最右边的 0 会慢慢增多，最后进位会变为 0，递归终止。
```java
-public int getSum(int a, int b) {
- return b == 0 ? a : getSum((a ^ b), (a & b) << 1);
+public int getSum(int a, int b) {
+ return b == 0 ? a : getSum((a ^ b), (a & b) << 1);
}
```
-## 字符串数组最大乘积
+## 字符串数组最大乘积
-[318. Maximum Product of Word Lengths (Medium)](https://leetcode.com/problems/maximum-product-of-word-lengths/description/)
+[318. Maximum Product of Word Lengths (Medium)](https://leetcode.com/problems/maximum-product-of-word-lengths/description/)
```html
-Given ["abcw", "baz", "foo", "bar", "xtfn", "abcdef"]
-Return 16
-The two words can be "abcw", "xtfn".
+Given ["abcw", "baz", "foo", "bar", "xtfn", "abcdef"]
+Return 16
+The two words can be "abcw", "xtfn".
```
题目描述：字符串数组的字符串只含有小写字符。求解字符串数组中两个字符串长度的最大乘积，要求这两个字符串不能含有相同字符。
-本题主要问题是判断两个字符串是否含相同字符，由于字符串只含有小写字符，总共 26 位，因此可以用一个 32 位的整数来存储每个字符是否出现过。
+本题主要问题是判断两个字符串是否含相同字符，由于字符串只含有小写字符，总共 26 位，因此可以用一个 32 位的整数来存储每个字符是否出现过。
```java
-public int maxProduct(String[] words) {
- int n = words.length;
- int[] val = new int[n];
- for (int i = 0; i < n; i++) {
- for (char c : words[i].toCharArray()) {
- val[i] |= 1 << (c - 'a');
- }
- }
- int ret = 0;
- for (int i = 0; i < n; i++) {
- for (int j = i + 1; j < n; j++) {
- if ((val[i] & val[j]) == 0) {
- ret = Math.max(ret, words[i].length() * words[j].length());
- }
- }
- }
- return ret;
+public int maxProduct(String[] words) {
+ int n = words.length;
+ int[] val = new int[n];
+ for (int i = 0; i < n; i++) {
+ for (char c : words[i].toCharArray()) {
+ val[i] |= 1 << (c - 'a');
+ }
+ }
+ int ret = 0;
+ for (int i = 0; i < n; i++) {
+ for (int j = i + 1; j < n; j++) {
+ if ((val[i] & val[j]) == 0) {
+ ret = Math.max(ret, words[i].length() * words[j].length());
+ }
+ }
+ }
+ return ret;
}
```
-## 统计从 0 ~ n 每个数的二进制表示中 1 的个数
+## 统计从 0 \~ n 每个数的二进制表示中 1 的个数
-[338. Counting Bits (Medium)](https://leetcode.com/problems/counting-bits/description/)
+[338. Counting Bits (Medium)](https://leetcode.com/problems/counting-bits/description/)
-对于数字 6(110)，它可以看成是 4(100) 再加一个 2(10)，因此 dp[i] = dp[i&(i-1)] + 1;
+对于数字 6(110)，它可以看成是 4(100) 再加一个 2(10)，因此 dp[i] = dp[i&(i-1)] + 1;
```java
-public int[] countBits(int num) {
- int[] ret = new int[num + 1];
- for(int i = 1; i <= num; i++){
- ret[i] = ret[i&(i-1)] + 1;
- }
- return ret;
+public int[] countBits(int num) {
+ int[] ret = new int[num + 1];
+ for(int i = 1; i <= num; i++){
+ ret[i] = ret[i&(i-1)] + 1;
+ }
+ return ret;
}
```
+
+
+
+
+⭐️欢迎关注我的公众号 CyC2018，在公众号后台回复关键字 📚 **资料** 可领取复习大纲，这份大纲是我花了一整年时间整理的面试知识点列表，不仅系统整理了面试知识点，而且标注了各个知识点的重要程度，从而帮你理清多而杂的面试知识点。可以说我基本是按照这份大纲来进行复习的，这份大纲对我拿到了 BAT 头条等 Offer 起到很大的帮助。你们完全可以和我一样根据大纲上列的知识点来进行复习，就不用看很多不重要的内容，也可以知道哪些内容很重要从而多安排一些复习时间。
+ 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;
}
```
+
+
+
+
+⭐️欢迎关注我的公众号 CyC2018，在公众号后台回复关键字 📚 **资料** 可领取复习大纲，这份大纲是我花了一整年时间整理的面试知识点列表，不仅系统整理了面试知识点，而且标注了各个知识点的重要程度，从而帮你理清多而杂的面试知识点。可以说我基本是按照这份大纲来进行复习的，这份大纲对我拿到了 BAT 头条等 Offer 起到很大的帮助。你们完全可以和我一样根据大纲上列的知识点来进行复习，就不用看很多不重要的内容，也可以知道哪些内容很重要从而多安排一些复习时间。
+ squareList = generateSquareList(n);
- int[] dp = new int[n + 1];
- for (int i = 1; i <= n; i++) {
- int min = Integer.MAX_VALUE;
- for (int square : squareList) {
- if (square > i) {
- break;
- }
- min = Math.min(min, dp[i - square] + 1);
- }
- dp[i] = min;
- }
- return dp[n];
+public int numSquares(int n) {
+ List squareList = generateSquareList(n);
+ int[] dp = new int[n + 1];
+ for (int i = 1; i <= n; i++) {
+ int min = Integer.MAX_VALUE;
+ for (int square : squareList) {
+ if (square > i) {
+ break;
+ }
+ min = Math.min(min, dp[i - square] + 1);
+ }
+ dp[i] = min;
+ }
+ return dp[n];
}
-private List generateSquareList(int n) {
- List squareList = new ArrayList<>();
- int diff = 3;
- int square = 1;
- while (square <= n) {
- squareList.add(square);
- square += diff;
- diff += 2;
- }
- return squareList;
+private List generateSquareList(int n) {
+ List squareList = new ArrayList<>();
+ int diff = 3;
+ int square = 1;
+ while (square <= n) {
+ squareList.add(square);
+ square += diff;
+ diff += 2;
+ }
+ return squareList;
}
```
-## 分割整数构成字母字符串
+## 分割整数构成字母字符串
-[91. Decode Ways (Medium)](https://leetcode.com/problems/decode-ways/description/)
+[91. Decode Ways (Medium)](https://leetcode.com/problems/decode-ways/description/)
-题目描述：Given encoded message "12", it could be decoded as "AB" (1 2) or "L" (12).
+题目描述：Given encoded message "12", it could be decoded as "AB" (1 2) or "L" (12).
```java
-public int numDecodings(String s) {
- if (s == null || s.length() == 0) {
- return 0;
- }
- int n = s.length();
- int[] dp = new int[n + 1];
- dp[0] = 1;
- dp[1] = s.charAt(0) == '0' ? 0 : 1;
- for (int i = 2; i <= n; i++) {
- int one = Integer.valueOf(s.substring(i - 1, i));
- if (one != 0) {
- dp[i] += dp[i - 1];
- }
- if (s.charAt(i - 2) == '0') {
- continue;
- }
- int two = Integer.valueOf(s.substring(i - 2, i));
- if (two <= 26) {
- dp[i] += dp[i - 2];
- }
- }
- return dp[n];
+public int numDecodings(String s) {
+ if (s == null || s.length() == 0) {
+ return 0;
+ }
+ int n = s.length();
+ int[] dp = new int[n + 1];
+ dp[0] = 1;
+ dp[1] = s.charAt(0) == '0' ? 0 : 1;
+ for (int i = 2; i <= n; i++) {
+ int one = Integer.valueOf(s.substring(i - 1, i));
+ if (one != 0) {
+ dp[i] += dp[i - 1];
+ }
+ if (s.charAt(i - 2) == '0') {
+ continue;
+ }
+ int two = Integer.valueOf(s.substring(i - 2, i));
+ if (two <= 26) {
+ dp[i] += dp[i - 2];
+ }
+ }
+ return dp[n];
}
```
-# 最长递增子序列
+# 最长递增子序列
-已知一个序列 {S1 , S2 ,...,Sn }，取出若干数组成新的序列 {Si1 , Si2 ,..., Sim }，其中 i1、i2 ... im 保持递增，即新序列中各个数仍然保持原数列中的先后顺序，称新序列为原序列的一个**子序列**。
+已知一个序列 {S1 , S2 ,...,Sn }，取出若干数组成新的序列 {Si1 , Si2 ,..., Sim }，其中 i1、i2 ... im 保持递增，即新序列中各个数仍然保持原数列中的先后顺序，称新序列为原序列的一个 **子序列** 。
-如果在子序列中，当下标 ix > iy 时，Six > Siy ，称子序列为原序列的一个**递增子序列**。
+如果在子序列中，当下标 ix > iy 时，Six > Siy ，称子序列为原序列的一个 **递增子序列** 。
-定义一个数组 dp 存储最长递增子序列的长度，dp[n] 表示以 Sn 结尾的序列的最长递增子序列长度。对于一个递增子序列 {Si1 , Si2 ,...,Sim }，如果 im < n 并且 Sim < Sn ，此时 {Si1 , Si2 ,..., Sim , Sn } 为一个递增子序列，递增子序列的长度增加 1。满足上述条件的递增子序列中，长度最长的那个递增子序列就是要找的，在长度最长的递增子序列上加上 Sn 就构成了以 Sn 为结尾的最长递增子序列。因此 dp[n] = max{ dp[i]+1 | Si < Sn && i < n} 。
+定义一个数组 dp 存储最长递增子序列的长度，dp[n] 表示以 Sn 结尾的序列的最长递增子序列长度。对于一个递增子序列 {Si1 , Si2 ,...,Sim }，如果 im < n 并且 Sim < Sn ，此时 {Si1 , Si2 ,..., Sim , Sn } 为一个递增子序列，递增子序列的长度增加 1。满足上述条件的递增子序列中，长度最长的那个递增子序列就是要找的，在长度最长的递增子序列上加上 Sn 就构成了以 Sn 为结尾的最长递增子序列。因此 dp[n] = max{ dp[i]+1 | Si < Sn && i < n} 。
-因为在求 dp[n] 时可能无法找到一个满足条件的递增子序列，此时 {Sn } 就构成了递增子序列，需要对前面的求解方程做修改，令 dp[n] 最小为 1，即：
+因为在求 dp[n] 时可能无法找到一个满足条件的递增子序列，此时 {Sn } 就构成了递增子序列，需要对前面的求解方程做修改，令 dp[n] 最小为 1，即：
-
+
-
+N 为结尾，因此 dp[N] 不是序列的最长递增子序列的长度，需要遍历 dp 数组找出最大值才是所要的结果，max{ dp[i] | 1 <= i <= N} 即为所求。
+对于一个长度为 N 的序列，最长递增子序列并不一定会以 SN 为结尾，因此 dp[N] 不是序列的最长递增子序列的长度，需要遍历 dp 数组找出最大值才是所要的结果，max{ dp[i] | 1 <= i <= N} 即为所求。
-## 最长递增子序列
+## 最长递增子序列
-[300. Longest Increasing Subsequence (Medium)](https://leetcode.com/problems/longest-increasing-subsequence/description/)
+[300. Longest Increasing Subsequence (Medium)](https://leetcode.com/problems/longest-increasing-subsequence/description/)
```java
-public int lengthOfLIS(int[] nums) {
- int n = nums.length;
- int[] dp = new int[n];
- for (int i = 0; i < n; i++) {
- int max = 1;
- for (int j = 0; j < i; j++) {
- if (nums[i] > nums[j]) {
- max = Math.max(max, dp[j] + 1);
- }
- }
- dp[i] = max;
- }
- return Arrays.stream(dp).max().orElse(0);
+public int lengthOfLIS(int[] nums) {
+ int n = nums.length;
+ int[] dp = new int[n];
+ for (int i = 0; i < n; i++) {
+ int max = 1;
+ for (int j = 0; j < i; j++) {
+ if (nums[i] > nums[j]) {
+ max = Math.max(max, dp[j] + 1);
+ }
+ }
+ dp[i] = max;
+ }
+ return Arrays.stream(dp).max().orElse(0);
}
```
-使用 Stream 求最大值会导致运行时间过长，可以改成以下形式：
+使用 Stream 求最大值会导致运行时间过长，可以改成以下形式：
```java
-int ret = 0;
-for (int i = 0; i < n; i++) {
- ret = Math.max(ret, dp[i]);
+int ret = 0;
+for (int i = 0; i < n; i++) {
+ ret = Math.max(ret, dp[i]);
}
-return ret;
+return ret;
```
-以上解法的时间复杂度为 O(N2 )，可以使用二分查找将时间复杂度降低为 O(NlogN)。
+以上解法的时间复杂度为 O(N2 )，可以使用二分查找将时间复杂度降低为 O(NlogN)。
-定义一个 tails 数组，其中 tails[i] 存储长度为 i + 1 的最长递增子序列的最后一个元素。对于一个元素 x，
+定义一个 tails 数组，其中 tails[i] 存储长度为 i + 1 的最长递增子序列的最后一个元素。对于一个元素 x，
-- 如果它大于 tails 数组所有的值，那么把它添加到 tails 后面，表示最长递增子序列长度加 1；
-- 如果 tails[i-1] < x <= tails[i]，那么更新 tails[i] = x。
+- 如果它大于 tails 数组所有的值，那么把它添加到 tails 后面，表示最长递增子序列长度加 1；
+- 如果 tails[i-1] < x <= tails[i]，那么更新 tails[i] = x。
-例如对于数组 [4,3,6,5]，有：
+例如对于数组 [4,3,6,5]，有：
```html
-tails len num
-[] 0 4
-[4] 1 3
-[3] 1 6
-[3,6] 2 5
-[3,5] 2 null
+tails len num
+[] 0 4
+[4] 1 3
+[3] 1 6
+[3,6] 2 5
+[3,5] 2 null
```
-可以看出 tails 数组保持有序，因此在查找 Si 位于 tails 数组的位置时就可以使用二分查找。
+可以看出 tails 数组保持有序，因此在查找 Si 位于 tails 数组的位置时就可以使用二分查找。
```java
-public int lengthOfLIS(int[] nums) {
- int n = nums.length;
- int[] tails = new int[n];
- int len = 0;
- for (int num : nums) {
- int index = binarySearch(tails, len, num);
- tails[index] = num;
- if (index == len) {
- len++;
- }
- }
- return len;
+public int lengthOfLIS(int[] nums) {
+ int n = nums.length;
+ int[] tails = new int[n];
+ int len = 0;
+ for (int num : nums) {
+ int index = binarySearch(tails, len, num);
+ tails[index] = num;
+ if (index == len) {
+ len++;
+ }
+ }
+ return len;
}
-private int binarySearch(int[] tails, int len, int key) {
- int l = 0, h = len;
- while (l < h) {
- int mid = l + (h - l) / 2;
- if (tails[mid] == key) {
- return mid;
- } else if (tails[mid] > key) {
- h = mid;
- } else {
- l = mid + 1;
- }
- }
- return l;
+private int binarySearch(int[] tails, int len, int key) {
+ int l = 0, h = len;
+ while (l < h) {
+ int mid = l + (h - l) / 2;
+ if (tails[mid] == key) {
+ return mid;
+ } else if (tails[mid] > key) {
+ h = mid;
+ } else {
+ l = mid + 1;
+ }
+ }
+ return l;
}
```
-## 一组整数对能够构成的最长链
+## 一组整数对能够构成的最长链
-[646. Maximum Length of Pair Chain (Medium)](https://leetcode.com/problems/maximum-length-of-pair-chain/description/)
+[646. Maximum Length of Pair Chain (Medium)](https://leetcode.com/problems/maximum-length-of-pair-chain/description/)
```html
-Input: [[1,2], [2,3], [3,4]]
-Output: 2
-Explanation: The longest chain is [1,2] -> [3,4]
+Input: [[1,2], [2,3], [3,4]]
+Output: 2
+Explanation: The longest chain is [1,2] -> [3,4]
```
-题目描述：对于 (a, b) 和 (c, d) ，如果 b < c，则它们可以构成一条链。
+题目描述：对于 (a, b) 和 (c, d) ，如果 b < c，则它们可以构成一条链。
```java
-public int findLongestChain(int[][] pairs) {
- if (pairs == null || pairs.length == 0) {
- return 0;
- }
- Arrays.sort(pairs, (a, b) -> (a[0] - b[0]));
- int n = pairs.length;
- int[] dp = new int[n];
- Arrays.fill(dp, 1);
- for (int i = 1; i < n; i++) {
- for (int j = 0; j < i; j++) {
- if (pairs[j][1] < pairs[i][0]) {
- dp[i] = Math.max(dp[i], dp[j] + 1);
- }
- }
- }
- return Arrays.stream(dp).max().orElse(0);
+public int findLongestChain(int[][] pairs) {
+ if (pairs == null || pairs.length == 0) {
+ return 0;
+ }
+ Arrays.sort(pairs, (a, b) -> (a[0] - b[0]));
+ int n = pairs.length;
+ int[] dp = new int[n];
+ Arrays.fill(dp, 1);
+ for (int i = 1; i < n; i++) {
+ for (int j = 0; j < i; j++) {
+ if (pairs[j][1] < pairs[i][0]) {
+ dp[i] = Math.max(dp[i], dp[j] + 1);
+ }
+ }
+ }
+ return Arrays.stream(dp).max().orElse(0);
}
```
-## 最长摆动子序列
+## 最长摆动子序列
-[376. Wiggle Subsequence (Medium)](https://leetcode.com/problems/wiggle-subsequence/description/)
+[376. Wiggle Subsequence (Medium)](https://leetcode.com/problems/wiggle-subsequence/description/)
```html
-Input: [1,7,4,9,2,5]
-Output: 6
-The entire sequence is a wiggle sequence.
+Input: [1,7,4,9,2,5]
+Output: 6
+The entire sequence is a wiggle sequence.
-Input: [1,17,5,10,13,15,10,5,16,8]
-Output: 7
-There are several subsequences that achieve this length. One is [1,17,10,13,10,16,8].
+Input: [1,17,5,10,13,15,10,5,16,8]
+Output: 7
+There are several subsequences that achieve this length. One is [1,17,10,13,10,16,8].
-Input: [1,2,3,4,5,6,7,8,9]
-Output: 2
+Input: [1,2,3,4,5,6,7,8,9]
+Output: 2
```
-要求：使用 O(N) 时间复杂度求解。
+要求：使用 O(N) 时间复杂度求解。
```java
-public int wiggleMaxLength(int[] nums) {
- if (nums == null || nums.length == 0) {
- return 0;
- }
- int up = 1, down = 1;
- for (int i = 1; i < nums.length; i++) {
- if (nums[i] > nums[i - 1]) {
- up = down + 1;
- } else if (nums[i] < nums[i - 1]) {
- down = up + 1;
- }
- }
- return Math.max(up, down);
+public int wiggleMaxLength(int[] nums) {
+ if (nums == null || nums.length == 0) {
+ return 0;
+ }
+ int up = 1, down = 1;
+ for (int i = 1; i < nums.length; i++) {
+ if (nums[i] > nums[i - 1]) {
+ up = down + 1;
+ } else if (nums[i] < nums[i - 1]) {
+ down = up + 1;
+ }
+ }
+ return Math.max(up, down);
}
```
-# 最长公共子序列
+# 最长公共子序列
-对于两个子序列 S1 和 S2，找出它们最长的公共子序列。
+对于两个子序列 S1 和 S2，找出它们最长的公共子序列。
-定义一个二维数组 dp 用来存储最长公共子序列的长度，其中 dp[i][j] 表示 S1 的前 i 个字符与 S2 的前 j 个字符最长公共子序列的长度。考虑 S1i 与 S2j 值是否相等，分为两种情况：
+定义一个二维数组 dp 用来存储最长公共子序列的长度，其中 dp[i][j] 表示 S1 的前 i 个字符与 S2 的前 j 个字符最长公共子序列的长度。考虑 S1i 与 S2j 值是否相等，分为两种情况：
-- 当 S1i ==S2j 时，那么就能在 S1 的前 i-1 个字符与 S2 的前 j-1 个字符最长公共子序列的基础上再加上 S1i 这个值，最长公共子序列长度加 1，即 dp[i][j] = dp[i-1][j-1] + 1。
-- 当 S1i != S2j 时，此时最长公共子序列为 S1 的前 i-1 个字符和 S2 的前 j 个字符最长公共子序列，或者 S1 的前 i 个字符和 S2 的前 j-1 个字符最长公共子序列，取它们的最大者，即 dp[i][j] = max{ dp[i-1][j], dp[i][j-1] }。
+- 当 S1i ==S2j 时，那么就能在 S1 的前 i-1 个字符与 S2 的前 j-1 个字符最长公共子序列的基础上再加上 S1i 这个值，最长公共子序列长度加 1，即 dp[i][j] = dp[i-1][j-1] + 1。
+- 当 S1i != S2j 时，此时最长公共子序列为 S1 的前 i-1 个字符和 S2 的前 j 个字符最长公共子序列，或者 S1 的前 i 个字符和 S2 的前 j-1 个字符最长公共子序列，取它们的最大者，即 dp[i][j] = max{ dp[i-1][j], dp[i][j-1] }。
综上，最长公共子序列的状态转移方程为：
-
+
-
+1 和长度为 M 的序列 S2 ，dp[N][M] 就是序列 S1 和序列 S2 的最长公共子序列长度。
+对于长度为 N 的序列 S1 和长度为 M 的序列 S2 ，dp[N][M] 就是序列 S1 和序列 S2 的最长公共子序列长度。
与最长递增子序列相比，最长公共子序列有以下不同点：
-- 针对的是两个序列，求它们的最长公共子序列。
-- 在最长递增子序列中，dp[i] 表示以 Si 为结尾的最长递增子序列长度，子序列必须包含 Si ；在最长公共子序列中，dp[i][j] 表示 S1 中前 i 个字符与 S2 中前 j 个字符的最长公共子序列长度，不一定包含 S1i 和 S2j 。
-- 在求最终解时，最长公共子序列中 dp[N][M] 就是最终解，而最长递增子序列中 dp[N] 不是最终解，因为以 SN 为结尾的最长递增子序列不一定是整个序列最长递增子序列，需要遍历一遍 dp 数组找到最大者。
+- 针对的是两个序列，求它们的最长公共子序列。
+- 在最长递增子序列中，dp[i] 表示以 Si 为结尾的最长递增子序列长度，子序列必须包含 Si ；在最长公共子序列中，dp[i][j] 表示 S1 中前 i 个字符与 S2 中前 j 个字符的最长公共子序列长度，不一定包含 S1i 和 S2j 。
+- 在求最终解时，最长公共子序列中 dp[N][M] 就是最终解，而最长递增子序列中 dp[N] 不是最终解，因为以 SN 为结尾的最长递增子序列不一定是整个序列最长递增子序列，需要遍历一遍 dp 数组找到最大者。
```java
-public int lengthOfLCS(int[] nums1, int[] nums2) {
- int n1 = nums1.length, n2 = nums2.length;
- int[][] dp = new int[n1 + 1][n2 + 1];
- for (int i = 1; i <= n1; i++) {
- for (int j = 1; j <= n2; j++) {
- if (nums1[i - 1] == nums2[j - 1]) {
- dp[i][j] = dp[i - 1][j - 1] + 1;
- } else {
- dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
- }
- }
- }
- return dp[n1][n2];
+public int lengthOfLCS(int[] nums1, int[] nums2) {
+ int n1 = nums1.length, n2 = nums2.length;
+ int[][] dp = new int[n1 + 1][n2 + 1];
+ for (int i = 1; i <= n1; i++) {
+ for (int j = 1; j <= n2; j++) {
+ if (nums1[i - 1] == nums2[j - 1]) {
+ dp[i][j] = dp[i - 1][j - 1] + 1;
+ } else {
+ dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
+ }
+ }
+ }
+ return dp[n1][n2];
}
```
-# 0-1 背包
+# 0-1 背包
-有一个容量为 N 的背包，要用这个背包装下物品的价值最大，这些物品有两个属性：体积 w 和价值 v。
+有一个容量为 N 的背包，要用这个背包装下物品的价值最大，这些物品有两个属性：体积 w 和价值 v。
-定义一个二维数组 dp 存储最大价值，其中 dp[i][j] 表示前 i 件物品体积不超过 j 的情况下能达到的最大价值。设第 i 件物品体积为 w，价值为 v，根据第 i 件物品是否添加到背包中，可以分两种情况讨论：
+定义一个二维数组 dp 存储最大价值，其中 dp[i][j] 表示前 i 件物品体积不超过 j 的情况下能达到的最大价值。设第 i 件物品体积为 w，价值为 v，根据第 i 件物品是否添加到背包中，可以分两种情况讨论：
-- 第 i 件物品没添加到背包，总体积不超过 j 的前 i 件物品的最大价值就是总体积不超过 j 的前 i-1 件物品的最大价值，dp[i][j] = dp[i-1][j]。
-- 第 i 件物品添加到背包中，dp[i][j] = dp[i-1][j-w] + v。
+- 第 i 件物品没添加到背包，总体积不超过 j 的前 i 件物品的最大价值就是总体积不超过 j 的前 i-1 件物品的最大价值，dp[i][j] = dp[i-1][j]。
+- 第 i 件物品添加到背包中，dp[i][j] = dp[i-1][j-w] + v。
-第 i 件物品可添加也可以不添加，取决于哪种情况下最大价值更大。因此，0-1 背包的状态转移方程为：
+第 i 件物品可添加也可以不添加，取决于哪种情况下最大价值更大。因此，0-1 背包的状态转移方程为：
-
+
-
+ wordDict) {
- int n = s.length();
- boolean[] dp = new boolean[n + 1];
- dp[0] = true;
- for (int i = 1; i <= n; i++) {
- for (String word : wordDict) { // 对物品的迭代应该放在最里层
- int len = word.length();
- if (len <= i && word.equals(s.substring(i - len, i))) {
- dp[i] = dp[i] || dp[i - len];
- }
- }
- }
- return dp[n];
+public boolean wordBreak(String s, List wordDict) {
+ int n = s.length();
+ boolean[] dp = new boolean[n + 1];
+ dp[0] = true;
+ for (int i = 1; i <= n; i++) {
+ for (String word : wordDict) { // 对物品的迭代应该放在最里层
+ int len = word.length();
+ if (len <= i && word.equals(s.substring(i - len, i))) {
+ dp[i] = dp[i] || dp[i - len];
+ }
+ }
+ }
+ return dp[n];
}
```
-## 组合总和
+## 组合总和
-[377. Combination Sum IV (Medium)](https://leetcode.com/problems/combination-sum-iv/description/)
+[377. Combination Sum IV (Medium)](https://leetcode.com/problems/combination-sum-iv/description/)
```html
-nums = [1, 2, 3]
-target = 4
+nums = [1, 2, 3]
+target = 4
-The possible combination ways are:
-(1, 1, 1, 1)
-(1, 1, 2)
-(1, 2, 1)
-(1, 3)
-(2, 1, 1)
-(2, 2)
-(3, 1)
+The possible combination ways are:
+(1, 1, 1, 1)
+(1, 1, 2)
+(1, 2, 1)
+(1, 3)
+(2, 1, 1)
+(2, 2)
+(3, 1)
-Note that different sequences are counted as different combinations.
+Note that different sequences are counted as different combinations.
-Therefore the output is 7.
+Therefore the output is 7.
```
涉及顺序的完全背包。
```java
-public int combinationSum4(int[] nums, int target) {
- if (nums == null || nums.length == 0) {
- return 0;
- }
- int[] maximum = new int[target + 1];
- maximum[0] = 1;
- Arrays.sort(nums);
- for (int i = 1; i <= target; i++) {
- for (int j = 0; j < nums.length && nums[j] <= i; j++) {
- maximum[i] += maximum[i - nums[j]];
- }
- }
- return maximum[target];
+public int combinationSum4(int[] nums, int target) {
+ if (nums == null || nums.length == 0) {
+ return 0;
+ }
+ int[] maximum = new int[target + 1];
+ maximum[0] = 1;
+ Arrays.sort(nums);
+ for (int i = 1; i <= target; i++) {
+ for (int j = 0; j < nums.length && nums[j] <= i; j++) {
+ maximum[i] += maximum[i - nums[j]];
+ }
+ }
+ return maximum[target];
}
```
-# 股票交易
+# 股票交易
-## 需要冷却期的股票交易
+## 需要冷却期的股票交易
-[309. Best Time to Buy and Sell Stock with Cooldown(Medium)](https://leetcode.com/problems/best-time-to-buy-and-sell-stock-with-cooldown/description/)
+[309. Best Time to Buy and Sell Stock with Cooldown(Medium)](https://leetcode.com/problems/best-time-to-buy-and-sell-stock-with-cooldown/description/)
题目描述：交易之后需要有一天的冷却时间。
-
+⭐️欢迎关注我的公众号 CyC2018，在公众号后台回复关键字 📚 **资料** 可领取复习大纲，这份大纲是我花了一整年时间整理的面试知识点列表，不仅系统整理了面试知识点，而且标注了各个知识点的重要程度，从而帮你理清多而杂的面试知识点。可以说我基本是按照这份大纲来进行复习的，这份大纲对我拿到了 BAT 头条等 Offer 起到很大的帮助。你们完全可以和我一样根据大纲上列的知识点来进行复习，就不用看很多不重要的内容，也可以知道哪些内容很重要从而多安排一些复习时间。
+ 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();
}
```
+
+
+
+
+⭐️欢迎关注我的公众号 CyC2018，在公众号后台回复关键字 📚 **资料** 可领取复习大纲，这份大纲是我花了一整年时间整理的面试知识点列表，不仅系统整理了面试知识点，而且标注了各个知识点的重要程度，从而帮你理清多而杂的面试知识点。可以说我基本是按照这份大纲来进行复习的，这份大纲对我拿到了 BAT 头条等 Offer 起到很大的帮助。你们完全可以和我一样根据大纲上列的知识点来进行复习，就不用看很多不重要的内容，也可以知道哪些内容很重要从而多安排一些复习时间。
+ indexForNum = new HashMap<>();
- for (int i = 0; i < nums.length; i++) {
- if (indexForNum.containsKey(target - nums[i])) {
- return new int[]{indexForNum.get(target - nums[i]), i};
- } else {
- indexForNum.put(nums[i], i);
- }
- }
- return null;
+public int[] twoSum(int[] nums, int target) {
+ HashMap indexForNum = new HashMap<>();
+ for (int i = 0; i < nums.length; i++) {
+ if (indexForNum.containsKey(target - nums[i])) {
+ return new int[]{indexForNum.get(target - nums[i]), i};
+ } else {
+ indexForNum.put(nums[i], i);
+ }
+ }
+ return null;
}
```
-# 2. 判断数组是否含有重复元素
+# 2. 判断数组是否含有重复元素
-[217. Contains Duplicate (Easy)](https://leetcode.com/problems/contains-duplicate/description/)
+[217. Contains Duplicate (Easy)](https://leetcode.com/problems/contains-duplicate/description/)
```java
-public boolean containsDuplicate(int[] nums) {
- Set set = new HashSet<>();
- for (int num : nums) {
- set.add(num);
- }
- return set.size() < nums.length;
+public boolean containsDuplicate(int[] nums) {
+ Set set = new HashSet<>();
+ for (int num : nums) {
+ set.add(num);
+ }
+ return set.size() < nums.length;
}
```
-# 3. 最长和谐序列
+# 3. 最长和谐序列
-[594. Longest Harmonious Subsequence (Easy)](https://leetcode.com/problems/longest-harmonious-subsequence/description/)
+[594. Longest Harmonious Subsequence (Easy)](https://leetcode.com/problems/longest-harmonious-subsequence/description/)
```html
-Input: [1,3,2,2,5,2,3,7]
-Output: 5
-Explanation: The longest harmonious subsequence is [3,2,2,2,3].
+Input: [1,3,2,2,5,2,3,7]
+Output: 5
+Explanation: The longest harmonious subsequence is [3,2,2,2,3].
```
-和谐序列中最大数和最小数之差正好为 1，应该注意的是序列的元素不一定是数组的连续元素。
+和谐序列中最大数和最小数之差正好为 1，应该注意的是序列的元素不一定是数组的连续元素。
```java
-public int findLHS(int[] nums) {
- Map countForNum = new HashMap<>();
- for (int num : nums) {
- countForNum.put(num, countForNum.getOrDefault(num, 0) + 1);
- }
- int longest = 0;
- for (int num : countForNum.keySet()) {
- if (countForNum.containsKey(num + 1)) {
- longest = Math.max(longest, countForNum.get(num + 1) + countForNum.get(num));
- }
- }
- return longest;
+public int findLHS(int[] nums) {
+ Map countForNum = new HashMap<>();
+ for (int num : nums) {
+ countForNum.put(num, countForNum.getOrDefault(num, 0) + 1);
+ }
+ int longest = 0;
+ for (int num : countForNum.keySet()) {
+ if (countForNum.containsKey(num + 1)) {
+ longest = Math.max(longest, countForNum.get(num + 1) + countForNum.get(num));
+ }
+ }
+ return longest;
}
```
-# 4. 最长连续序列
+# 4. 最长连续序列
-[128. Longest Consecutive Sequence (Hard)](https://leetcode.com/problems/longest-consecutive-sequence/description/)
+[128. Longest Consecutive Sequence (Hard)](https://leetcode.com/problems/longest-consecutive-sequence/description/)
```html
-Given [100, 4, 200, 1, 3, 2],
-The longest consecutive elements sequence is [1, 2, 3, 4]. Return its length: 4.
+Given [100, 4, 200, 1, 3, 2],
+The longest consecutive elements sequence is [1, 2, 3, 4]. Return its length: 4.
```
-要求以 O(N) 的时间复杂度求解。
+要求以 O(N) 的时间复杂度求解。
```java
-public int longestConsecutive(int[] nums) {
- Map countForNum = new HashMap<>();
- for (int num : nums) {
- countForNum.put(num, 1);
- }
- for (int num : nums) {
- forward(countForNum, num);
- }
- return maxCount(countForNum);
+public int longestConsecutive(int[] nums) {
+ Map countForNum = new HashMap<>();
+ for (int num : nums) {
+ countForNum.put(num, 1);
+ }
+ for (int num : nums) {
+ forward(countForNum, num);
+ }
+ return maxCount(countForNum);
}
-private int forward(Map countForNum, int num) {
- if (!countForNum.containsKey(num)) {
- return 0;
- }
- int cnt = countForNum.get(num);
- if (cnt > 1) {
- return cnt;
- }
- cnt = forward(countForNum, num + 1) + 1;
- countForNum.put(num, cnt);
- return cnt;
+private int forward(Map countForNum, int num) {
+ if (!countForNum.containsKey(num)) {
+ return 0;
+ }
+ int cnt = countForNum.get(num);
+ if (cnt > 1) {
+ return cnt;
+ }
+ cnt = forward(countForNum, num + 1) + 1;
+ countForNum.put(num, cnt);
+ return cnt;
}
-private int maxCount(Map countForNum) {
- int max = 0;
- for (int num : countForNum.keySet()) {
- max = Math.max(max, countForNum.get(num));
- }
- return max;
+private int maxCount(Map countForNum) {
+ int max = 0;
+ for (int num : countForNum.keySet()) {
+ max = Math.max(max, countForNum.get(num));
+ }
+ return max;
}
```
+
+
+
+
+⭐️欢迎关注我的公众号 CyC2018，在公众号后台回复关键字 📚 **资料** 可领取复习大纲，这份大纲是我花了一整年时间整理的面试知识点列表，不仅系统整理了面试知识点，而且标注了各个知识点的重要程度，从而帮你理清多而杂的面试知识点。可以说我基本是按照这份大纲来进行复习的，这份大纲对我拿到了 BAT 头条等 Offer 起到很大的帮助。你们完全可以和我一样根据大纲上列的知识点来进行复习，就不用看很多不重要的内容，也可以知道哪些内容很重要从而多安排一些复习时间。
+[] graphic = new List[numCourses];
- for (int i = 0; i < numCourses; i++) {
- graphic[i] = new ArrayList<>();
- }
- for (int[] pre : prerequisites) {
- graphic[pre[0]].add(pre[1]);
- }
- boolean[] globalMarked = new boolean[numCourses];
- boolean[] localMarked = new boolean[numCourses];
- for (int i = 0; i < numCourses; i++) {
- if (hasCycle(globalMarked, localMarked, graphic, i)) {
- return false;
- }
- }
- return true;
+public boolean canFinish(int numCourses, int[][] prerequisites) {
+ List[] graphic = new List[numCourses];
+ for (int i = 0; i < numCourses; i++) {
+ graphic[i] = new ArrayList<>();
+ }
+ for (int[] pre : prerequisites) {
+ graphic[pre[0]].add(pre[1]);
+ }
+ boolean[] globalMarked = new boolean[numCourses];
+ boolean[] localMarked = new boolean[numCourses];
+ for (int i = 0; i < numCourses; i++) {
+ if (hasCycle(globalMarked, localMarked, graphic, i)) {
+ return false;
+ }
+ }
+ return true;
}
-private boolean hasCycle(boolean[] globalMarked, boolean[] localMarked,
- List[] graphic, int curNode) {
+private boolean hasCycle(boolean[] globalMarked, boolean[] localMarked,
+ List[] graphic, int curNode) {
- if (localMarked[curNode]) {
- return true;
- }
- if (globalMarked[curNode]) {
- return false;
- }
- globalMarked[curNode] = true;
- localMarked[curNode] = true;
- for (int nextNode : graphic[curNode]) {
- if (hasCycle(globalMarked, localMarked, graphic, nextNode)) {
- return true;
- }
- }
- localMarked[curNode] = false;
- return false;
+ if (localMarked[curNode]) {
+ return true;
+ }
+ if (globalMarked[curNode]) {
+ return false;
+ }
+ globalMarked[curNode] = true;
+ localMarked[curNode] = true;
+ for (int nextNode : graphic[curNode]) {
+ if (hasCycle(globalMarked, localMarked, graphic, nextNode)) {
+ return true;
+ }
+ }
+ localMarked[curNode] = false;
+ return false;
}
```
-## 课程安排的顺序
+## 课程安排的顺序
-[210. Course Schedule II (Medium)](https://leetcode.com/problems/course-schedule-ii/description/)
+[210. Course Schedule II (Medium)](https://leetcode.com/problems/course-schedule-ii/description/)
```html
-4, [[1,0],[2,0],[3,1],[3,2]]
-There are a total of 4 courses to take. To take course 3 you should have finished both courses 1 and 2. Both courses 1 and 2 should be taken after you finished course 0. So one correct course order is [0,1,2,3]. Another correct ordering is[0,2,1,3].
+4, [[1,0],[2,0],[3,1],[3,2]]
+There are a total of 4 courses to take. To take course 3 you should have finished both courses 1 and 2. Both courses 1 and 2 should be taken after you finished course 0. So one correct course order is [0,1,2,3]. Another correct ordering is[0,2,1,3].
```
-使用 DFS 来实现拓扑排序，使用一个栈存储后序遍历结果，这个栈的逆序结果就是拓扑排序结果。
+使用 DFS 来实现拓扑排序，使用一个栈存储后序遍历结果，这个栈的逆序结果就是拓扑排序结果。
-证明：对于任何先序关系：v->w，后序遍历结果可以保证 w 先进入栈中，因此栈的逆序结果中 v 会在 w 之前。
+证明：对于任何先序关系：v->w，后序遍历结果可以保证 w 先进入栈中，因此栈的逆序结果中 v 会在 w 之前。
```java
-public int[] findOrder(int numCourses, int[][] prerequisites) {
- List[] graphic = new List[numCourses];
- for (int i = 0; i < numCourses; i++) {
- graphic[i] = new ArrayList<>();
- }
- for (int[] pre : prerequisites) {
- graphic[pre[0]].add(pre[1]);
- }
- Stack postOrder = new Stack<>();
- boolean[] globalMarked = new boolean[numCourses];
- boolean[] localMarked = new boolean[numCourses];
- for (int i = 0; i < numCourses; i++) {
- if (hasCycle(globalMarked, localMarked, graphic, i, postOrder)) {
- return new int[0];
- }
- }
- int[] orders = new int[numCourses];
- for (int i = numCourses - 1; i >= 0; i--) {
- orders[i] = postOrder.pop();
- }
- return orders;
+public int[] findOrder(int numCourses, int[][] prerequisites) {
+ List[] graphic = new List[numCourses];
+ for (int i = 0; i < numCourses; i++) {
+ graphic[i] = new ArrayList<>();
+ }
+ for (int[] pre : prerequisites) {
+ graphic[pre[0]].add(pre[1]);
+ }
+ Stack postOrder = new Stack<>();
+ boolean[] globalMarked = new boolean[numCourses];
+ boolean[] localMarked = new boolean[numCourses];
+ for (int i = 0; i < numCourses; i++) {
+ if (hasCycle(globalMarked, localMarked, graphic, i, postOrder)) {
+ return new int[0];
+ }
+ }
+ int[] orders = new int[numCourses];
+ for (int i = numCourses - 1; i >= 0; i--) {
+ orders[i] = postOrder.pop();
+ }
+ return orders;
}
-private boolean hasCycle(boolean[] globalMarked, boolean[] localMarked, List[] graphic,
- int curNode, Stack postOrder) {
+private boolean hasCycle(boolean[] globalMarked, boolean[] localMarked, List[] graphic,
+ int curNode, Stack postOrder) {
- if (localMarked[curNode]) {
- return true;
- }
- if (globalMarked[curNode]) {
- return false;
- }
- globalMarked[curNode] = true;
- localMarked[curNode] = true;
- for (int nextNode : graphic[curNode]) {
- if (hasCycle(globalMarked, localMarked, graphic, nextNode, postOrder)) {
- return true;
- }
- }
- localMarked[curNode] = false;
- postOrder.push(curNode);
- return false;
+ if (localMarked[curNode]) {
+ return true;
+ }
+ if (globalMarked[curNode]) {
+ return false;
+ }
+ globalMarked[curNode] = true;
+ localMarked[curNode] = true;
+ for (int nextNode : graphic[curNode]) {
+ if (hasCycle(globalMarked, localMarked, graphic, nextNode, postOrder)) {
+ return true;
+ }
+ }
+ localMarked[curNode] = false;
+ postOrder.push(curNode);
+ return false;
}
```
-# 并查集
+# 并查集
并查集可以动态地连通两个点，并且可以非常快速地判断两个点是否连通。
-## 冗余连接
+## 冗余连接
-[684. Redundant Connection (Medium)](https://leetcode.com/problems/redundant-connection/description/)
+[684. Redundant Connection (Medium)](https://leetcode.com/problems/redundant-connection/description/)
```html
-Input: [[1,2], [1,3], [2,3]]
-Output: [2,3]
-Explanation: The given undirected graph will be like this:
- 1
- / \
-2 - 3
+Input: [[1,2], [1,3], [2,3]]
+Output: [2,3]
+Explanation: The given undirected graph will be like this:
+ 1
+ / \
+2 - 3
```
题目描述：有一系列的边连成的图，找出一条边，移除它之后该图能够成为一棵树。
```java
-public int[] findRedundantConnection(int[][] edges) {
- int N = edges.length;
- UF uf = new UF(N);
- for (int[] e : edges) {
- int u = e[0], v = e[1];
- if (uf.connect(u, v)) {
- return e;
- }
- uf.union(u, v);
- }
- return new int[]{-1, -1};
+public int[] findRedundantConnection(int[][] edges) {
+ int N = edges.length;
+ UF uf = new UF(N);
+ for (int[] e : edges) {
+ int u = e[0], v = e[1];
+ if (uf.connect(u, v)) {
+ return e;
+ }
+ uf.union(u, v);
+ }
+ return new int[]{-1, -1};
}
-private class UF {
+private class UF {
- private int[] id;
+ private int[] id;
- UF(int N) {
- id = new int[N + 1];
- for (int i = 0; i < id.length; i++) {
- id[i] = i;
- }
- }
+ UF(int N) {
+ id = new int[N + 1];
+ for (int i = 0; i < id.length; i++) {
+ id[i] = i;
+ }
+ }
- void union(int u, int v) {
- int uID = find(u);
- int vID = find(v);
- if (uID == vID) {
- return;
- }
- for (int i = 0; i < id.length; i++) {
- if (id[i] == uID) {
- id[i] = vID;
- }
- }
- }
+ void union(int u, int v) {
+ int uID = find(u);
+ int vID = find(v);
+ if (uID == vID) {
+ return;
+ }
+ for (int i = 0; i < id.length; i++) {
+ if (id[i] == uID) {
+ id[i] = vID;
+ }
+ }
+ }
- int find(int p) {
- return id[p];
- }
+ int find(int p) {
+ return id[p];
+ }
- boolean connect(int u, int v) {
- return find(u) == find(v);
- }
+ boolean connect(int u, int v) {
+ return find(u) == find(v);
+ }
}
```
+
+
+
+
+⭐️欢迎关注我的公众号 CyC2018，在公众号后台回复关键字 📚 **资料** 可领取复习大纲，这份大纲是我花了一整年时间整理的面试知识点列表，不仅系统整理了面试知识点，而且标注了各个知识点的重要程度，从而帮你理清多而杂的面试知识点。可以说我基本是按照这份大纲来进行复习的，这份大纲对我拿到了 BAT 头条等 Offer 起到很大的帮助。你们完全可以和我一样根据大纲上列的知识点来进行复习，就不用看很多不重要的内容，也可以知道哪些内容很重要从而多安排一些复习时间。
+
diff --git a/docs/notes/Leetcode 题解 - 字符串.md b/docs/notes/Leetcode 题解 - 字符串.md
index f01d9a40..ec64b3f6 100644
--- a/docs/notes/Leetcode 题解 - 字符串.md
+++ b/docs/notes/Leetcode 题解 - 字符串.md
@@ -1,212 +1,231 @@
-# 字符串循环移位包含
+
+* [字符串循环移位包含](#字符串循环移位包含)
+* [字符串循环移位](#字符串循环移位)
+* [字符串中单词的翻转](#字符串中单词的翻转)
+* [两个字符串包含的字符是否完全相同](#两个字符串包含的字符是否完全相同)
+* [计算一组字符集合可以组成的回文字符串的最大长度](#计算一组字符集合可以组成的回文字符串的最大长度)
+* [字符串同构](#字符串同构)
+* [回文子字符串个数](#回文子字符串个数)
+* [判断一个整数是否是回文数](#判断一个整数是否是回文数)
+* [统计二进制字符串中连续 1 和连续 0 数量相同的子字符串个数](#统计二进制字符串中连续-1-和连续-0-数量相同的子字符串个数)
+
-[编程之美 3.1](#)
+
+# 字符串循环移位包含
+
+[编程之美 3.1](#)
```html
-s1 = AABCD, s2 = CDAA
-Return : true
+s1 = AABCD, s2 = CDAA
+Return : true
```
-给定两个字符串 s1 和 s2，要求判定 s2 是否能够被 s1 做循环移位得到的字符串包含。
+给定两个字符串 s1 和 s2，要求判定 s2 是否能够被 s1 做循环移位得到的字符串包含。
-s1 进行循环移位的结果是 s1s1 的子字符串，因此只要判断 s2 是否是 s1s1 的子字符串即可。
+s1 进行循环移位的结果是 s1s1 的子字符串，因此只要判断 s2 是否是 s1s1 的子字符串即可。
-# 字符串循环移位
+# 字符串循环移位
-[编程之美 2.17](#)
+[编程之美 2.17](#)
```html
-s = "abcd123" k = 3
-Return "123abcd"
+s = "abcd123" k = 3
+Return "123abcd"
```
-将字符串向右循环移动 k 位。
+将字符串向右循环移动 k 位。
-将 abcd123 中的 abcd 和 123 单独翻转，得到 dcba321，然后对整个字符串进行翻转，得到 123abcd。
+将 abcd123 中的 abcd 和 123 单独翻转，得到 dcba321，然后对整个字符串进行翻转，得到 123abcd。
-# 字符串中单词的翻转
+# 字符串中单词的翻转
[程序员代码面试指南](#)
```html
-s = "I am a student"
-Return "student a am I"
+s = "I am a student"
+Return "student a am I"
```
将每个单词翻转，然后将整个字符串翻转。
-# 两个字符串包含的字符是否完全相同
+# 两个字符串包含的字符是否完全相同
-[242. Valid Anagram (Easy)](https://leetcode.com/problems/valid-anagram/description/)
+[242. Valid Anagram (Easy)](https://leetcode.com/problems/valid-anagram/description/)
```html
-s = "anagram", t = "nagaram", return true.
-s = "rat", t = "car", return false.
+s = "anagram", t = "nagaram", return true.
+s = "rat", t = "car", return false.
```
-可以用 HashMap 来映射字符与出现次数，然后比较两个字符串出现的字符数量是否相同。
+可以用 HashMap 来映射字符与出现次数，然后比较两个字符串出现的字符数量是否相同。
-由于本题的字符串只包含 26 个小写字符，因此可以使用长度为 26 的整型数组对字符串出现的字符进行统计，不再使用 HashMap。
+由于本题的字符串只包含 26 个小写字符，因此可以使用长度为 26 的整型数组对字符串出现的字符进行统计，不再使用 HashMap。
```java
-public boolean isAnagram(String s, String t) {
- int[] cnts = new int[26];
- for (char c : s.toCharArray()) {
- cnts[c - 'a']++;
- }
- for (char c : t.toCharArray()) {
- cnts[c - 'a']--;
- }
- for (int cnt : cnts) {
- if (cnt != 0) {
- return false;
- }
- }
- return true;
+public boolean isAnagram(String s, String t) {
+ int[] cnts = new int[26];
+ for (char c : s.toCharArray()) {
+ cnts[c - 'a']++;
+ }
+ for (char c : t.toCharArray()) {
+ cnts[c - 'a']--;
+ }
+ for (int cnt : cnts) {
+ if (cnt != 0) {
+ return false;
+ }
+ }
+ return true;
}
```
-# 计算一组字符集合可以组成的回文字符串的最大长度
+# 计算一组字符集合可以组成的回文字符串的最大长度
-[409. Longest Palindrome (Easy)](https://leetcode.com/problems/longest-palindrome/description/)
+[409. Longest Palindrome (Easy)](https://leetcode.com/problems/longest-palindrome/description/)
```html
-Input : "abccccdd"
-Output : 7
-Explanation : One longest palindrome that can be built is "dccaccd", whose length is 7.
+Input : "abccccdd"
+Output : 7
+Explanation : One longest palindrome that can be built is "dccaccd", whose length is 7.
```
-使用长度为 256 的整型数组来统计每个字符出现的个数，每个字符有偶数个可以用来构成回文字符串。
+使用长度为 256 的整型数组来统计每个字符出现的个数，每个字符有偶数个可以用来构成回文字符串。
因为回文字符串最中间的那个字符可以单独出现，所以如果有单独的字符就把它放到最中间。
```java
-public int longestPalindrome(String s) {
- int[] cnts = new int[256];
- for (char c : s.toCharArray()) {
- cnts[c]++;
- }
- int palindrome = 0;
- for (int cnt : cnts) {
- palindrome += (cnt / 2) * 2;
- }
- if (palindrome < s.length()) {
- palindrome++; // 这个条件下 s 中一定有单个未使用的字符存在，可以把这个字符放到回文的最中间
- }
- return palindrome;
+public int longestPalindrome(String s) {
+ int[] cnts = new int[256];
+ for (char c : s.toCharArray()) {
+ cnts[c]++;
+ }
+ int palindrome = 0;
+ for (int cnt : cnts) {
+ palindrome += (cnt / 2) * 2;
+ }
+ if (palindrome < s.length()) {
+ palindrome++; // 这个条件下 s 中一定有单个未使用的字符存在，可以把这个字符放到回文的最中间
+ }
+ return palindrome;
}
```
-# 字符串同构
+# 字符串同构
-[205. Isomorphic Strings (Easy)](https://leetcode.com/problems/isomorphic-strings/description/)
+[205. Isomorphic Strings (Easy)](https://leetcode.com/problems/isomorphic-strings/description/)
```html
-Given "egg", "add", return true.
-Given "foo", "bar", return false.
-Given "paper", "title", return true.
+Given "egg", "add", return true.
+Given "foo", "bar", return false.
+Given "paper", "title", return true.
```
记录一个字符上次出现的位置，如果两个字符串中的字符上次出现的位置一样，那么就属于同构。
```java
-public boolean isIsomorphic(String s, String t) {
- int[] preIndexOfS = new int[256];
- int[] preIndexOfT = new int[256];
- for (int i = 0; i < s.length(); i++) {
- char sc = s.charAt(i), tc = t.charAt(i);
- if (preIndexOfS[sc] != preIndexOfT[tc]) {
- return false;
- }
- preIndexOfS[sc] = i + 1;
- preIndexOfT[tc] = i + 1;
- }
- return true;
+public boolean isIsomorphic(String s, String t) {
+ int[] preIndexOfS = new int[256];
+ int[] preIndexOfT = new int[256];
+ for (int i = 0; i < s.length(); i++) {
+ char sc = s.charAt(i), tc = t.charAt(i);
+ if (preIndexOfS[sc] != preIndexOfT[tc]) {
+ return false;
+ }
+ preIndexOfS[sc] = i + 1;
+ preIndexOfT[tc] = i + 1;
+ }
+ return true;
}
```
-# 回文子字符串个数
+# 回文子字符串个数
-[647. Palindromic Substrings (Medium)](https://leetcode.com/problems/palindromic-substrings/description/)
+[647. Palindromic Substrings (Medium)](https://leetcode.com/problems/palindromic-substrings/description/)
```html
-Input: "aaa"
-Output: 6
-Explanation: Six palindromic strings: "a", "a", "a", "aa", "aa", "aaa".
+Input: "aaa"
+Output: 6
+Explanation: Six palindromic strings: "a", "a", "a", "aa", "aa", "aaa".
```
从字符串的某一位开始，尝试着去扩展子字符串。
```java
-private int cnt = 0;
+private int cnt = 0;
-public int countSubstrings(String s) {
- for (int i = 0; i < s.length(); i++) {
- extendSubstrings(s, i, i); // 奇数长度
- extendSubstrings(s, i, i + 1); // 偶数长度
- }
- return cnt;
+public int countSubstrings(String s) {
+ for (int i = 0; i < s.length(); i++) {
+ extendSubstrings(s, i, i); // 奇数长度
+ extendSubstrings(s, i, i + 1); // 偶数长度
+ }
+ return cnt;
}
-private void extendSubstrings(String s, int start, int end) {
- while (start >= 0 && end < s.length() && s.charAt(start) == s.charAt(end)) {
- start--;
- end++;
- cnt++;
- }
+private void extendSubstrings(String s, int start, int end) {
+ while (start >= 0 && end < s.length() && s.charAt(start) == s.charAt(end)) {
+ start--;
+ end++;
+ cnt++;
+ }
}
```
-# 判断一个整数是否是回文数
+# 判断一个整数是否是回文数
-[9. Palindrome Number (Easy)](https://leetcode.com/problems/palindrome-number/description/)
+[9. Palindrome Number (Easy)](https://leetcode.com/problems/palindrome-number/description/)
要求不能使用额外空间，也就不能将整数转换为字符串进行判断。
将整数分成左右两部分，右边那部分需要转置，然后判断这两部分是否相等。
```java
-public boolean isPalindrome(int x) {
- if (x == 0) {
- return true;
- }
- if (x < 0 || x % 10 == 0) {
- return false;
- }
- int right = 0;
- while (x > right) {
- right = right * 10 + x % 10;
- x /= 10;
- }
- return x == right || x == right / 10;
+public boolean isPalindrome(int x) {
+ if (x == 0) {
+ return true;
+ }
+ if (x < 0 || x % 10 == 0) {
+ return false;
+ }
+ int right = 0;
+ while (x > right) {
+ right = right * 10 + x % 10;
+ x /= 10;
+ }
+ return x == right || x == right / 10;
}
```
-# 统计二进制字符串中连续 1 和连续 0 数量相同的子字符串个数
+# 统计二进制字符串中连续 1 和连续 0 数量相同的子字符串个数
-[696. Count Binary Substrings (Easy)](https://leetcode.com/problems/count-binary-substrings/description/)
+[696. Count Binary Substrings (Easy)](https://leetcode.com/problems/count-binary-substrings/description/)
```html
-Input: "00110011"
-Output: 6
-Explanation: There are 6 substrings that have equal number of consecutive 1's and 0's: "0011", "01", "1100", "10", "0011", and "01".
+Input: "00110011"
+Output: 6
+Explanation: There are 6 substrings that have equal number of consecutive 1's and 0's: "0011", "01", "1100", "10", "0011", and "01".
```
```java
-public int countBinarySubstrings(String s) {
- int preLen = 0, curLen = 1, count = 0;
- for (int i = 1; i < s.length(); i++) {
- if (s.charAt(i) == s.charAt(i - 1)) {
- curLen++;
- } else {
- preLen = curLen;
- curLen = 1;
- }
+public int countBinarySubstrings(String s) {
+ int preLen = 0, curLen = 1, count = 0;
+ for (int i = 1; i < s.length(); i++) {
+ if (s.charAt(i) == s.charAt(i - 1)) {
+ curLen++;
+ } else {
+ preLen = curLen;
+ curLen = 1;
+ }
- if (preLen >= curLen) {
- count++;
- }
- }
- return count;
+ if (preLen >= curLen) {
+ count++;
+ }
+ }
+ return count;
}
```
+
+
+
+
+⭐️欢迎关注我的公众号 CyC2018，在公众号后台回复关键字 📚 **资料** 可领取复习大纲，这份大纲是我花了一整年时间整理的面试知识点列表，不仅系统整理了面试知识点，而且标注了各个知识点的重要程度，从而帮你理清多而杂的面试知识点。可以说我基本是按照这份大纲来进行复习的，这份大纲对我拿到了 BAT 头条等 Offer 起到很大的帮助。你们完全可以和我一样根据大纲上列的知识点来进行复习，就不用看很多不重要的内容，也可以知道哪些内容很重要从而多安排一些复习时间。
+
diff --git a/docs/notes/Leetcode 题解 - 排序.md b/docs/notes/Leetcode 题解 - 排序.md
index 421c423f..f5443af3 100644
--- a/docs/notes/Leetcode 题解 - 排序.md
+++ b/docs/notes/Leetcode 题解 - 排序.md
@@ -1,134 +1,146 @@
-# 快速选择
+
+* [快速选择](#快速选择)
+* [堆排序](#堆排序)
+ * [Kth Element](#kth-element)
+* [桶排序](#桶排序)
+ * [出现频率最多的 k 个数](#出现频率最多的-k-个数)
+ * [按照字符出现次数对字符串排序](#按照字符出现次数对字符串排序)
+* [荷兰国旗问题](#荷兰国旗问题)
+ * [按颜色进行排序](#按颜色进行排序)
+
-用于求解 **Kth Element** 问题，使用快速排序的 partition() 进行实现。
-需要先打乱数组，否则最坏情况下时间复杂度为 O(N2 )。
+# 快速选择
-# 堆排序
+用于求解 **Kth Element** 问题，使用快速排序的 partition() 进行实现。
-用于求解 **TopK Elements** 问题，通过维护一个大小为 K 的堆，堆中的元素就是 TopK Elements。
+需要先打乱数组，否则最坏情况下时间复杂度为 O(N2 )。
-堆排序也可以用于求解 Kth Element 问题，堆顶元素就是 Kth Element。
+# 堆排序
-快速选择也可以求解 TopK Elements 问题，因为找到 Kth Element 之后，再遍历一次数组，所有小于等于 Kth Element 的元素都是 TopK Elements。
+用于求解 **TopK Elements** 问题，通过维护一个大小为 K 的堆，堆中的元素就是 TopK Elements。
-可以看到，快速选择和堆排序都可以求解 Kth Element 和 TopK Elements 问题。
+堆排序也可以用于求解 Kth Element 问题，堆顶元素就是 Kth Element。
-## Kth Element
+快速选择也可以求解 TopK Elements 问题，因为找到 Kth Element 之后，再遍历一次数组，所有小于等于 Kth Element 的元素都是 TopK Elements。
-[215. Kth Largest Element in an Array (Medium)](https://leetcode.com/problems/kth-largest-element-in-an-array/description/)
+可以看到，快速选择和堆排序都可以求解 Kth Element 和 TopK Elements 问题。
-题目描述：找到第 k 大的元素。
+## Kth Element
-**排序**：时间复杂度 O(NlogN)，空间复杂度 O(1)
+[215. Kth Largest Element in an Array (Medium)](https://leetcode.com/problems/kth-largest-element-in-an-array/description/)
+
+题目描述：找到第 k 大的元素。
+
+**排序** ：时间复杂度 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) {
- continue;
- }
- if (buckets[i].size() <= (k - topK.size())) {
- topK.addAll(buckets[i]);
- } else {
- topK.addAll(buckets[i].subList(0, k - topK.size()));
- }
- }
- 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) {
+ continue;
+ }
+ if (buckets[i].size() <= (k - topK.size())) {
+ topK.addAll(buckets[i]);
+ } else {
+ topK.addAll(buckets[i].subList(0, k - topK.size()));
+ }
+ }
+ 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:
@@ -138,40 +150,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();
}
```
-# 荷兰国旗问题
+# 荷兰国旗问题
荷兰国旗包含三种颜色：红、白、蓝。
@@ -179,36 +191,42 @@ public String frequencySort(String s) {
它其实是三向切分快速排序的一种变种，在三向切分快速排序中，每次切分都将数组分成三个区间：小于切分元素、等于切分元素、大于切分元素，而该算法是将数组分成三个区间：等于红色、等于白色、等于蓝色。
-
+⭐️欢迎关注我的公众号 CyC2018，在公众号后台回复关键字 📚 **资料** 可领取复习大纲，这份大纲是我花了一整年时间整理的面试知识点列表，不仅系统整理了面试知识点，而且标注了各个知识点的重要程度，从而帮你理清多而杂的面试知识点。可以说我基本是按照这份大纲来进行复习的，这份大纲对我拿到了 BAT 头条等 Offer 起到很大的帮助。你们完全可以和我一样根据大纲上列的知识点来进行复习，就不用看很多不重要的内容，也可以知道哪些内容很重要从而多安排一些复习时间。
+
diff --git a/docs/notes/Leetcode 题解 - 搜索.md b/docs/notes/Leetcode 题解 - 搜索.md
index 315dcca9..1a49792f 100644
--- a/docs/notes/Leetcode 题解 - 搜索.md
+++ b/docs/notes/Leetcode 题解 - 搜索.md
@@ -1,299 +1,329 @@
+
+* [BFS](#bfs)
+ * [计算在网格中从原点到特定点的最短路径长度](#计算在网格中从原点到特定点的最短路径长度)
+ * [组成整数的最小平方数数量](#组成整数的最小平方数数量)
+ * [最短单词路径](#最短单词路径)
+* [DFS](#dfs)
+ * [查找最大的连通面积](#查找最大的连通面积)
+ * [矩阵中的连通分量数目](#矩阵中的连通分量数目)
+ * [好友关系的连通分量数目](#好友关系的连通分量数目)
+ * [填充封闭区域](#填充封闭区域)
+ * [能到达的太平洋和大西洋的区域](#能到达的太平洋和大西洋的区域)
+* [Backtracking](#backtracking)
+ * [数字键盘组合](#数字键盘组合)
+ * [IP 地址划分](#ip-地址划分)
+ * [在矩阵中寻找字符串](#在矩阵中寻找字符串)
+ * [输出二叉树中所有从根到叶子的路径](#输出二叉树中所有从根到叶子的路径)
+ * [排列](#排列)
+ * [含有相同元素求排列](#含有相同元素求排列)
+ * [组合](#组合)
+ * [组合求和](#组合求和)
+ * [含有相同元素的求组合求和](#含有相同元素的求组合求和)
+ * [1-9 数字的组合求和](#1-9-数字的组合求和)
+ * [子集](#子集)
+ * [含有相同元素求子集](#含有相同元素求子集)
+ * [分割字符串使得每个部分都是回文数](#分割字符串使得每个部分都是回文数)
+ * [数独](#数独)
+ * [N 皇后](#n-皇后)
+
+
+
深度优先搜索和广度优先搜索广泛运用于树和图中，但是它们的应用远远不止如此。
-# 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 values = new ArrayList<>();
- backtracking(root, values, paths);
- return paths;
+public List binaryTreePaths(TreeNode root) {
+ List paths = new ArrayList<>();
+ if (root == null) {
+ return paths;
+ }
+ List values = new ArrayList<>();
+ backtracking(root, values, paths);
+ return paths;
}
-private void backtracking(TreeNode node, List values, List paths) {
- if (node == null) {
- return;
- }
- values.add(node.val);
- if (isLeaf(node)) {
- paths.add(buildPath(values));
- } else {
- backtracking(node.left, values, paths);
- backtracking(node.right, values, paths);
- }
- values.remove(values.size() - 1);
+private void backtracking(TreeNode node, List values, List paths) {
+ if (node == null) {
+ return;
+ }
+ values.add(node.val);
+ if (isLeaf(node)) {
+ paths.add(buildPath(values));
+ } else {
+ backtracking(node.left, values, paths);
+ backtracking(node.right, values, paths);
+ }
+ values.remove(values.size() - 1);
}
-private boolean isLeaf(TreeNode node) {
- return node.left == null && node.right == null;
+private boolean isLeaf(TreeNode node) {
+ return node.left == null && node.right == null;
}
-private String buildPath(List values) {
- StringBuilder str = new StringBuilder();
- for (int i = 0; i < values.size(); i++) {
- str.append(values.get(i));
- if (i != values.size() - 1) {
- str.append("->");
- }
- }
- return str.toString();
+private String buildPath(List values) {
+ StringBuilder str = new StringBuilder();
+ for (int i = 0; i < values.size(); i++) {
+ str.append(values.get(i));
+ if (i != values.size() - 1) {
+ str.append("->");
+ }
+ }
+ return str.toString();
}
```
-## 排列
+## 排列
-[46. Permutations (Medium)](https://leetcode.com/problems/permutations/description/)
+[46. Permutations (Medium)](https://leetcode.com/problems/permutations/description/)
```html
-[1,2,3] have the following permutations:
+[1,2,3] have the following permutations:
[
- [1,2,3],
- [1,3,2],
- [2,1,3],
- [2,3,1],
- [3,1,2],
- [3,2,1]
+ [1,2,3],
+ [1,3,2],
+ [2,1,3],
+ [2,3,1],
+ [3,1,2],
+ [3,2,1]
]
```
```java
-public List> permute(int[] nums) {
- List> permutes = new ArrayList<>();
- List permuteList = new ArrayList<>();
- boolean[] hasVisited = new boolean[nums.length];
- backtracking(permuteList, permutes, hasVisited, nums);
- return permutes;
+public List> permute(int[] nums) {
+ List> permutes = new ArrayList<>();
+ List permuteList = new ArrayList<>();
+ boolean[] hasVisited = new boolean[nums.length];
+ backtracking(permuteList, permutes, hasVisited, nums);
+ return permutes;
}
-private void backtracking(List permuteList, List> permutes, boolean[] visited, final int[] nums) {
- if (permuteList.size() == nums.length) {
- permutes.add(new ArrayList<>(permuteList)); // 重新构造一个 List
- return;
- }
- for (int i = 0; i < visited.length; i++) {
- if (visited[i]) {
- continue;
- }
- visited[i] = true;
- permuteList.add(nums[i]);
- backtracking(permuteList, permutes, visited, nums);
- permuteList.remove(permuteList.size() - 1);
- visited[i] = false;
- }
+private void backtracking(List permuteList, List> permutes, boolean[] visited, final int[] nums) {
+ if (permuteList.size() == nums.length) {
+ permutes.add(new ArrayList<>(permuteList)); // 重新构造一个 List
+ return;
+ }
+ for (int i = 0; i < visited.length; i++) {
+ if (visited[i]) {
+ continue;
+ }
+ visited[i] = true;
+ permuteList.add(nums[i]);
+ backtracking(permuteList, permutes, visited, nums);
+ permuteList.remove(permuteList.size() - 1);
+ visited[i] = false;
+ }
}
```
-## 含有相同元素求排列
+## 含有相同元素求排列
-[47. Permutations II (Medium)](https://leetcode.com/problems/permutations-ii/description/)
+[47. Permutations II (Medium)](https://leetcode.com/problems/permutations-ii/description/)
```html
-[1,1,2] have the following unique permutations:
-[[1,1,2], [1,2,1], [2,1,1]]
+[1,1,2] have the following unique permutations:
+[[1,1,2], [1,2,1], [2,1,1]]
```
数组元素可能含有相同的元素，进行排列时就有可能出现重复的排列，要求重复的排列只返回一个。
-在实现上，和 Permutations 不同的是要先排序，然后在添加一个元素时，判断这个元素是否等于前一个元素，如果等于，并且前一个元素还未访问，那么就跳过这个元素。
+在实现上，和 Permutations 不同的是要先排序，然后在添加一个元素时，判断这个元素是否等于前一个元素，如果等于，并且前一个元素还未访问，那么就跳过这个元素。
```java
-public List> permuteUnique(int[] nums) {
- List> permutes = new ArrayList<>();
- List permuteList = new ArrayList<>();
- Arrays.sort(nums); // 排序
- boolean[] hasVisited = new boolean[nums.length];
- backtracking(permuteList, permutes, hasVisited, nums);
- return permutes;
+public List> permuteUnique(int[] nums) {
+ List> permutes = new ArrayList<>();
+ List permuteList = new ArrayList<>();
+ Arrays.sort(nums); // 排序
+ boolean[] hasVisited = new boolean[nums.length];
+ backtracking(permuteList, permutes, hasVisited, nums);
+ return permutes;
}
-private void backtracking(List permuteList, List> permutes, boolean[] visited, final int[] nums) {
- if (permuteList.size() == nums.length) {
- permutes.add(new ArrayList<>(permuteList));
- return;
- }
+private void backtracking(List permuteList, List> permutes, boolean[] visited, final int[] nums) {
+ if (permuteList.size() == nums.length) {
+ permutes.add(new ArrayList<>(permuteList));
+ return;
+ }
- for (int i = 0; i < visited.length; i++) {
- if (i != 0 && nums[i] == nums[i - 1] && !visited[i - 1]) {
- continue; // 防止重复
- }
- if (visited[i]){
- continue;
- }
- visited[i] = true;
- permuteList.add(nums[i]);
- backtracking(permuteList, permutes, visited, nums);
- permuteList.remove(permuteList.size() - 1);
- visited[i] = false;
- }
+ for (int i = 0; i < visited.length; i++) {
+ if (i != 0 && nums[i] == nums[i - 1] && !visited[i - 1]) {
+ continue; // 防止重复
+ }
+ if (visited[i]){
+ continue;
+ }
+ visited[i] = true;
+ permuteList.add(nums[i]);
+ backtracking(permuteList, permutes, visited, nums);
+ permuteList.remove(permuteList.size() - 1);
+ visited[i] = false;
+ }
}
```
-## 组合
+## 组合
-[77. Combinations (Medium)](https://leetcode.com/problems/combinations/description/)
+[77. Combinations (Medium)](https://leetcode.com/problems/combinations/description/)
```html
-If n = 4 and k = 2, a solution is:
+If n = 4 and k = 2, a solution is:
[
- [2,4],
- [3,4],
- [2,3],
- [1,2],
- [1,3],
- [1,4],
+ [2,4],
+ [3,4],
+ [2,3],
+ [1,2],
+ [1,3],
+ [1,4],
]
```
```java
-public List> combine(int n, int k) {
- List> combinations = new ArrayList<>();
- List combineList = new ArrayList<>();
- backtracking(combineList, combinations, 1, k, n);
- return combinations;
+public List> combine(int n, int k) {
+ List> combinations = new ArrayList<>();
+ List combineList = new ArrayList<>();
+ backtracking(combineList, combinations, 1, k, n);
+ return combinations;
}
-private void backtracking(List combineList, List> combinations, int start, int k, final int n) {
- if (k == 0) {
- combinations.add(new ArrayList<>(combineList));
- return;
- }
- for (int i = start; i <= n - k + 1; i++) { // 剪枝
- combineList.add(i);
- backtracking(combineList, combinations, i + 1, k - 1, n);
- combineList.remove(combineList.size() - 1);
- }
+private void backtracking(List combineList, List> combinations, int start, int k, final int n) {
+ if (k == 0) {
+ combinations.add(new ArrayList<>(combineList));
+ return;
+ }
+ for (int i = start; i <= n - k + 1; i++) { // 剪枝
+ combineList.add(i);
+ backtracking(combineList, combinations, i + 1, k - 1, n);
+ combineList.remove(combineList.size() - 1);
+ }
}
```
-## 组合求和
+## 组合求和
-[39. Combination Sum (Medium)](https://leetcode.com/problems/combination-sum/description/)
+[39. Combination Sum (Medium)](https://leetcode.com/problems/combination-sum/description/)
```html
-given candidate set [2, 3, 6, 7] and target 7,
-A solution set is:
-[[7],[2, 2, 3]]
+given candidate set [2, 3, 6, 7] and target 7,
+A solution set is:
+[[7],[2, 2, 3]]
```
```java
-public List> combinationSum(int[] candidates, int target) {
- List> combinations = new ArrayList<>();
- backtracking(new ArrayList<>(), combinations, 0, target, candidates);
- return combinations;
+public List> combinationSum(int[] candidates, int target) {
+ List> combinations = new ArrayList<>();
+ backtracking(new ArrayList<>(), combinations, 0, target, candidates);
+ return combinations;
}
-private void backtracking(List tempCombination, List> combinations,
- int start, int target, final int[] candidates) {
+private void backtracking(List tempCombination, List> combinations,
+ int start, int target, final int[] candidates) {
- if (target == 0) {
- combinations.add(new ArrayList<>(tempCombination));
- return;
- }
- for (int i = start; i < candidates.length; i++) {
- if (candidates[i] <= target) {
- tempCombination.add(candidates[i]);
- backtracking(tempCombination, combinations, i, target - candidates[i], candidates);
- tempCombination.remove(tempCombination.size() - 1);
- }
- }
+ if (target == 0) {
+ combinations.add(new ArrayList<>(tempCombination));
+ return;
+ }
+ for (int i = start; i < candidates.length; i++) {
+ if (candidates[i] <= target) {
+ tempCombination.add(candidates[i]);
+ backtracking(tempCombination, combinations, i, target - candidates[i], candidates);
+ tempCombination.remove(tempCombination.size() - 1);
+ }
+ }
}
```
-## 含有相同元素的求组合求和
+## 含有相同元素的求组合求和
-[40. Combination Sum II (Medium)](https://leetcode.com/problems/combination-sum-ii/description/)
+[40. Combination Sum II (Medium)](https://leetcode.com/problems/combination-sum-ii/description/)
```html
-For example, given candidate set [10, 1, 2, 7, 6, 1, 5] and target 8,
-A solution set is:
+For example, given candidate set [10, 1, 2, 7, 6, 1, 5] and target 8,
+A solution set is:
[
- [1, 7],
- [1, 2, 5],
- [2, 6],
- [1, 1, 6]
+ [1, 7],
+ [1, 2, 5],
+ [2, 6],
+ [1, 1, 6]
]
```
```java
-public List> combinationSum2(int[] candidates, int target) {
- List> combinations = new ArrayList<>();
- Arrays.sort(candidates);
- backtracking(new ArrayList<>(), combinations, new boolean[candidates.length], 0, target, candidates);
- return combinations;
+public List> combinationSum2(int[] candidates, int target) {
+ List> combinations = new ArrayList<>();
+ Arrays.sort(candidates);
+ backtracking(new ArrayList<>(), combinations, new boolean[candidates.length], 0, target, candidates);
+ return combinations;
}
-private void backtracking(List tempCombination, List> combinations,
- boolean[] hasVisited, int start, int target, final int[] candidates) {
+private void backtracking(List tempCombination, List> combinations,
+ boolean[] hasVisited, int start, int target, final int[] candidates) {
- if (target == 0) {
- combinations.add(new ArrayList<>(tempCombination));
- return;
- }
- for (int i = start; i < candidates.length; i++) {
- if (i != 0 && candidates[i] == candidates[i - 1] && !hasVisited[i - 1]) {
- continue;
- }
- if (candidates[i] <= target) {
- tempCombination.add(candidates[i]);
- hasVisited[i] = true;
- backtracking(tempCombination, combinations, hasVisited, i + 1, target - candidates[i], candidates);
- hasVisited[i] = false;
- tempCombination.remove(tempCombination.size() - 1);
- }
- }
+ if (target == 0) {
+ combinations.add(new ArrayList<>(tempCombination));
+ return;
+ }
+ for (int i = start; i < candidates.length; i++) {
+ if (i != 0 && candidates[i] == candidates[i - 1] && !hasVisited[i - 1]) {
+ continue;
+ }
+ if (candidates[i] <= target) {
+ tempCombination.add(candidates[i]);
+ hasVisited[i] = true;
+ backtracking(tempCombination, combinations, hasVisited, i + 1, target - candidates[i], candidates);
+ hasVisited[i] = false;
+ tempCombination.remove(tempCombination.size() - 1);
+ }
+ }
}
```
-## 1-9 数字的组合求和
+## 1-9 数字的组合求和
-[216. Combination Sum III (Medium)](https://leetcode.com/problems/combination-sum-iii/description/)
+[216. Combination Sum III (Medium)](https://leetcode.com/problems/combination-sum-iii/description/)
```html
-Input: k = 3, n = 9
+Input: k = 3, n = 9
Output:
-[[1,2,6], [1,3,5], [2,3,4]]
+[[1,2,6], [1,3,5], [2,3,4]]
```
-从 1-9 数字中选出 k 个数不重复的数，使得它们的和为 n。
+从 1-9 数字中选出 k 个数不重复的数，使得它们的和为 n。
```java
-public List> combinationSum3(int k, int n) {
- List> combinations = new ArrayList<>();
- List path = new ArrayList<>();
- backtracking(k, n, 1, path, combinations);
- return combinations;
+public List> combinationSum3(int k, int n) {
+ List> combinations = new ArrayList<>();
+ List path = new ArrayList<>();
+ backtracking(k, n, 1, path, combinations);
+ return combinations;
}
-private void backtracking(int k, int n, int start,
- List tempCombination, List> combinations) {
+private void backtracking(int k, int n, int start,
+ List 
