diff --git a/notes/Git.md b/notes/Git.md
index 4bb0a543..a096e307 100644
--- a/notes/Git.md
+++ b/notes/Git.md
@@ -1,29 +1,13 @@
-
-* [学习资料](#学习资料)
-* [集中式与分布式](#集中式与分布式)
-* [Git 的中心服务器](#git-的中心服务器)
-* [Git 工作流](#git-工作流)
-* [分支实现](#分支实现)
-* [冲突](#冲突)
-* [Fast forward](#fast-forward)
-* [分支管理策略](#分支管理策略)
-* [储藏（Stashing）](#储藏stashing)
-* [SSH 传输设置](#ssh-传输设置)
-* [.gitignore 文件](#gitignore-文件)
-* [Git 命令一览](#git-命令一览)
-
+# 学习资料
+- [Git - 简明指南](http://rogerdudler.github.io/git-guide/index.zh.html)
+- [图解 Git](http://marklodato.github.io/visual-git-guide/index-zh-cn.html)
+- [廖雪峰 : Git 教程](https://www.liaoxuefeng.com/wiki/0013739516305929606dd18361248578c67b8067c8c017b000)
+- [Learn Git Branching](https://learngitbranching.js.org/)
-# 学习资料
+# 集中式与分布式
-- [Git - 简明指南](http://rogerdudler.github.io/git-guide/index.zh.html)
-- [图解 Git](http://marklodato.github.io/visual-git-guide/index-zh-cn.html)
-- [廖雪峰 : Git 教程](https://www.liaoxuefeng.com/wiki/0013739516305929606dd18361248578c67b8067c8c017b000)
-- [Learn Git Branching](https://learngitbranching.js.org/)
-
-# 集中式与分布式
-
-Git 属于分布式版本控制系统，而 SVN 属于集中式。
+Git 属于分布式版本控制系统，而 SVN 属于集中式。
集中式版本控制只有中心服务器拥有一份代码，而分布式版本控制每个人的电脑上就有一份完整的代码。
@@ -33,125 +17,125 @@ Git 属于分布式版本控制系统，而 SVN 属于集中式。
分布式版本控制新建分支、合并分支操作速度非常快，而集中式版本控制新建一个分支相当于复制一份完整代码。
-# Git 的中心服务器
+# Git 的中心服务器
-Git 的中心服务器用来交换每个用户的修改。没有中心服务器也能工作，但是中心服务器能够 24 小时保持开机状态，这样就能更方便的交换修改。Github 就是一种 Git 中心服务器。
+Git 的中心服务器用来交换每个用户的修改。没有中心服务器也能工作，但是中心服务器能够 24 小时保持开机状态，这样就能更方便的交换修改。Github 就是一种 Git 中心服务器。
-# Git 工作流
+# Git 工作流
-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
```
-
+
```
-另一个用户浏览了含有这个内容的页面将会跳转到 domain.com 并携带了当前作用域的 Cookie。如果这个论坛网站通过 Cookie 管理用户登录状态，那么攻击者就可以通过这个 Cookie 登录被攻击者的账号了。
+另一个用户浏览了含有这个内容的页面将会跳转到 domain.com 并携带了当前作用域的 Cookie。如果这个论坛网站通过 Cookie 管理用户登录状态，那么攻击者就可以通过这个 Cookie 登录被攻击者的账号了。
-### 2. 危害
+### 2. 危害
-- 窃取用户的 Cookie 值
-- 伪造虚假的输入表单骗取个人信息
-- 显示伪造的文章或者图片
+- 窃取用户的 Cookie 值
+- 伪造虚假的输入表单骗取个人信息
+- 显示伪造的文章或者图片
-### 3. 防范手段
+### 3. 防范手段
-**（一）设置 Cookie 为 HttpOnly**
+**（一）设置 Cookie 为 HttpOnly**
-设置了 HttpOnly 的 Cookie 可以防止 JavaScript 脚本调用，在一定程度上可以防止 XSS 窃取用户的 Cookie 信息。
+设置了 HttpOnly 的 Cookie 可以防止 JavaScript 脚本调用，在一定程度上可以防止 XSS 窃取用户的 Cookie 信息。
-**（二）过滤特殊字符**
+**（二）过滤特殊字符**
-许多语言都提供了对 HTML 的过滤：
+许多语言都提供了对 HTML 的过滤：
-- PHP 的 htmlentities() 或是 htmlspecialchars()。
-- Python 的 cgi.escape()。
-- Java 的 xssprotect (Open Source Library)。
-- Node.js 的 node-validator。
+- PHP 的 htmlentities() 或是 htmlspecialchars()。
+- Python 的 cgi.escape()。
+- Java 的 xssprotect (Open Source Library)。
+- Node.js 的 node-validator。
-例如 htmlspecialchars() 可以将 `<` 转义为 `<`，将 `>` 转义为 `>`，从而避免 HTML 和 Jascript 代码的运行。
+例如 htmlspecialchars() 可以将 `<` 转义为 `<`，将 `>` 转义为 `>`，从而避免 HTML 和 Jascript 代码的运行。
-**（三）富文本编辑器的处理**
+**（三）富文本编辑器的处理**
-富文本编辑器允许用户输入 HTML 代码，就不能简单地将 `<` 等字符进行过滤了，极大地提高了 XSS 攻击的可能性。
+富文本编辑器允许用户输入 HTML 代码，就不能简单地将 `<` 等字符进行过滤了，极大地提高了 XSS 攻击的可能性。
-富文本编辑器通常采用 XSS filter 来防范 XSS 攻击，可以定义一些标签白名单或者黑名单，从而不允许有攻击性的 HTML 代码的输入。
+富文本编辑器通常采用 XSS filter 来防范 XSS 攻击，可以定义一些标签白名单或者黑名单，从而不允许有攻击性的 HTML 代码的输入。
-以下例子中，form 和 script 等标签都被转义，而 h 和 p 等标签将会保留。
+以下例子中，form 和 script 等标签都被转义，而 h 和 p 等标签将会保留。
-[XSS 过滤在线测试](http://jsxss.com/zh/try.html)
+[XSS 过滤在线测试](http://jsxss.com/zh/try.html)
```html
-XSS Demo
+XSS Demo
-
-Sanitize untrusted HTML (to prevent XSS) with a configuration specified by a Whitelist.
+
+Sanitize untrusted HTML (to prevent XSS) with a configuration specified by a Whitelist.
hello
- http
+ http
Features:
- Specifies HTML tags and their attributes allowed with whitelist
- Handle any tags or attributes using custom function
+ Specifies HTML tags and their attributes allowed with whitelist
+ Handle any tags or attributes using custom function
-
```
```html
-XSS Demo
+XSS Demo
-Sanitize untrusted HTML (to prevent XSS) with a configuration specified by a Whitelist.
+Sanitize untrusted HTML (to prevent XSS) with a configuration specified by a Whitelist.
<form>
- <input type="text" name="q" value="test">
- <button id="submit">Submit</button>
+ <input type="text" name="q" value="test">
+ <button id="submit">Submit</button>
</form>
hello
- http
+ http
Features:
- Specifies HTML tags and their attributes allowed with whitelist
- Handle any tags or attributes using custom function
+ Specifies HTML tags and their attributes allowed with whitelist
+ Handle any tags or attributes using custom function
-<script type="text/javascript">
+<script type="text/javascript">
alert(/xss/);
</script>
```
-## 跨站请求伪造
+## 跨站请求伪造
-### 1. 概念
+### 1. 概念
-跨站请求伪造（Cross-site request forgery，CSRF），是攻击者通过一些技术手段欺骗用户的浏览器去访问一个自己曾经认证过的网站并执行一些操作（如发邮件，发消息，甚至财产操作如转账和购买商品）。由于浏览器曾经认证过，所以被访问的网站会认为是真正的用户操作而去执行。这利用了 Web 中用户身份验证的一个漏洞：简单的身份验证只能保证请求发自某个用户的浏览器，却不能保证请求本身是用户自愿发出的。
+跨站请求伪造（Cross-site request forgery，CSRF），是攻击者通过一些技术手段欺骗用户的浏览器去访问一个自己曾经认证过的网站并执行一些操作（如发邮件，发消息，甚至财产操作如转账和购买商品）。由于浏览器曾经认证过，所以被访问的网站会认为是真正的用户操作而去执行。这利用了 Web 中用户身份验证的一个漏洞：简单的身份验证只能保证请求发自某个用户的浏览器，却不能保证请求本身是用户自愿发出的。
-XSS 利用的是用户对指定网站的信任，CSRF 利用的是网站对用户浏览器的信任。
+XSS 利用的是用户对指定网站的信任，CSRF 利用的是网站对用户浏览器的信任。
-假如一家银行用以执行转账操作的 URL 地址如下：
+假如一家银行用以执行转账操作的 URL 地址如下：
```
http://www.examplebank.com/withdraw?account=AccoutName&amount=1000&for=PayeeName。
@@ -848,245 +783,262 @@ http://www.examplebank.com/withdraw?account=AccoutName&amount=1000&for=PayeeName
那么，一个恶意攻击者可以在另一个网站上放置如下代码：
```
-。
```
-如果有账户名为 Alice 的用户访问了恶意站点，而她之前刚访问过银行不久，登录信息尚未过期，那么她就会损失 1000 资金。
+如果有账户名为 Alice 的用户访问了恶意站点，而她之前刚访问过银行不久，登录信息尚未过期，那么她就会损失 1000 资金。
这种恶意的网址可以有很多种形式，藏身于网页中的许多地方。此外，攻击者也不需要控制放置恶意网址的网站。例如他可以将这种地址藏在论坛，博客等任何用户生成内容的网站中。这意味着如果服务器端没有合适的防御措施的话，用户即使访问熟悉的可信网站也有受攻击的危险。
-透过例子能够看出，攻击者并不能通过 CSRF 攻击来直接获取用户的账户控制权，也不能直接窃取用户的任何信息。他们能做到的，是欺骗用户浏览器，让其以用户的名义执行操作。
+透过例子能够看出，攻击者并不能通过 CSRF 攻击来直接获取用户的账户控制权，也不能直接窃取用户的任何信息。他们能做到的，是欺骗用户浏览器，让其以用户的名义执行操作。
-### 2. 防范手段
+### 2. 防范手段
-**（一）检查 Referer 字段**
+**（一）检查 Referer 字段**
-HTTP 头中有一个 Referer 字段，这个字段用于标明请求来源于哪个地址。在处理敏感数据请求时，通常来说，Referer 字段应和请求的地址位于同一域名下。
+HTTP 头中有一个 Referer 字段，这个字段用于标明请求来源于哪个地址。在处理敏感数据请求时，通常来说，Referer 字段应和请求的地址位于同一域名下。
-这种办法简单易行，工作量低，仅需要在关键访问处增加一步校验。但这种办法也有其局限性，因其完全依赖浏览器发送正确的 Referer 字段。虽然 HTTP 协议对此字段的内容有明确的规定，但并无法保证来访的浏览器的具体实现，亦无法保证浏览器没有安全漏洞影响到此字段。并且也存在攻击者攻击某些浏览器，篡改其 Referer 字段的可能。
+这种办法简单易行，工作量低，仅需要在关键访问处增加一步校验。但这种办法也有其局限性，因其完全依赖浏览器发送正确的 Referer 字段。虽然 HTTP 协议对此字段的内容有明确的规定，但并无法保证来访的浏览器的具体实现，亦无法保证浏览器没有安全漏洞影响到此字段。并且也存在攻击者攻击某些浏览器，篡改其 Referer 字段的可能。
-**（二）添加校验 Token**
+**（二）添加校验 Token**
-由于 CSRF 的本质在于攻击者欺骗用户去访问自己设置的地址，所以如果要求在访问敏感数据请求时，要求用户浏览器提供不保存在 Cookie 中，并且攻击者无法伪造的数据作为校验，那么攻击者就无法再执行 CSRF 攻击。这种数据通常是表单中的一个数据项。服务器将其生成并附加在表单中，其内容是一个伪乱数。当客户端通过表单提交请求时，这个伪乱数也一并提交上去以供校验。正常的访问时，客户端浏览器能够正确得到并传回这个伪乱数，而通过 CSRF 传来的欺骗性攻击中，攻击者无从事先得知这个伪乱数的值，服务器端就会因为校验 Token 的值为空或者错误，拒绝这个可疑请求。
+由于 CSRF 的本质在于攻击者欺骗用户去访问自己设置的地址，所以如果要求在访问敏感数据请求时，要求用户浏览器提供不保存在 Cookie 中，并且攻击者无法伪造的数据作为校验，那么攻击者就无法再执行 CSRF 攻击。这种数据通常是表单中的一个数据项。服务器将其生成并附加在表单中，其内容是一个伪乱数。当客户端通过表单提交请求时，这个伪乱数也一并提交上去以供校验。正常的访问时，客户端浏览器能够正确得到并传回这个伪乱数，而通过 CSRF 传来的欺骗性攻击中，攻击者无从事先得知这个伪乱数的值，服务器端就会因为校验 Token 的值为空或者错误，拒绝这个可疑请求。
也可以要求用户输入验证码来进行校验。
-## SQL 注入攻击
+## SQL 注入攻击
-### 1. 概念
+### 1. 概念
-服务器上的数据库运行非法的 SQL 语句，主要通过拼接来完成。
+服务器上的数据库运行非法的 SQL 语句，主要通过拼接来完成。
-### 2. 攻击原理
+### 2. 攻击原理
-例如一个网站登录验证的 SQL 查询代码为：
+例如一个网站登录验证的 SQL 查询代码为：
```sql
-strSQL = "SELECT * FROM users WHERE (name = '" + userName + "') and (pw = '"+ passWord +"');"
+strSQL = "SELECT * FROM users WHERE (name = '" + userName + "') and (pw = '"+ passWord +"');"
```
如果填入以下内容：
```sql
-userName = "1' OR '1'='1";
-passWord = "1' OR '1'='1";
+userName = "1' OR '1'='1";
+passWord = "1' OR '1'='1";
```
-那么 SQL 查询字符串为：
+那么 SQL 查询字符串为：
```sql
-strSQL = "SELECT * FROM users WHERE (name = '1' OR '1'='1') and (pw = '1' OR '1'='1');"
+strSQL = "SELECT * FROM users WHERE (name = '1' OR '1'='1') and (pw = '1' OR '1'='1');"
```
此时无需验证通过就能执行以下查询：
```sql
-strSQL = "SELECT * FROM users;"
+strSQL = "SELECT * FROM users;"
```
-### 3. 防范手段
+### 3. 防范手段
-**（一）使用参数化查询**
+**（一）使用参数化查询**
-以下以 Java 中的 PreparedStatement 为例，它是预先编译的 SQL 语句，可以传入适当参数并且多次执行。由于没有拼接的过程，因此可以防止 SQL 注入的发生。
+以下以 Java 中的 PreparedStatement 为例，它是预先编译的 SQL 语句，可以传入适当参数并且多次执行。由于没有拼接的过程，因此可以防止 SQL 注入的发生。
```java
-PreparedStatement stmt = connection.prepareStatement("SELECT * FROM users WHERE userid=? AND password=?");
-stmt.setString(1, userid);
-stmt.setString(2, password);
-ResultSet rs = stmt.executeQuery();
+PreparedStatement stmt = connection.prepareStatement("SELECT * FROM users WHERE userid=? AND password=?");
+stmt.setString(1, userid);
+stmt.setString(2, password);
+ResultSet rs = stmt.executeQuery();
```
-**（二）单引号转换**
+**（二）单引号转换**
-将传入的参数中的单引号转换为连续两个单引号，PHP 中的 Magic quote 可以完成这个功能。
+将传入的参数中的单引号转换为连续两个单引号，PHP 中的 Magic quote 可以完成这个功能。
-## 拒绝服务攻击
+## 拒绝服务攻击
-拒绝服务攻击（denial-of-service attack，DoS），亦称洪水攻击，其目的在于使目标电脑的网络或系统资源耗尽，使服务暂时中断或停止，导致其正常用户无法访问。
+拒绝服务攻击（denial-of-service attack，DoS），亦称洪水攻击，其目的在于使目标电脑的网络或系统资源耗尽，使服务暂时中断或停止，导致其正常用户无法访问。
-分布式拒绝服务攻击（distributed denial-of-service attack，DDoS），指攻击者使用网络上两个或以上被攻陷的电脑作为“僵尸”向特定的目标发动“拒绝服务”式攻击。
+分布式拒绝服务攻击（distributed denial-of-service attack，DDoS），指攻击者使用网络上两个或以上被攻陷的电脑作为“僵尸”向特定的目标发动“拒绝服务”式攻击。
-> [维基百科：拒绝服务攻击](https://zh.wikipedia.org/wiki/%E9%98%BB%E6%96%B7%E6%9C%8D%E5%8B%99%E6%94%BB%E6%93%8A)
+> [维基百科：拒绝服务攻击](https://zh.wikipedia.org/wiki/%E9%98%BB%E6%96%B7%E6%9C%8D%E5%8B%99%E6%94%BB%E6%93%8A)
-# 八、GET 和 POST 的区别
+# 八、GET 和 POST 的区别
-## 作用
+## 作用
-GET 用于获取资源，而 POST 用于传输实体主体。
+GET 用于获取资源，而 POST 用于传输实体主体。
-## 参数
+## 参数
-GET 和 POST 的请求都能使用额外的参数，但是 GET 的参数是以查询字符串出现在 URL 中，而 POST 的参数存储在实体主体中。
+GET 和 POST 的请求都能使用额外的参数，但是 GET 的参数是以查询字符串出现在 URL 中，而 POST 的参数存储在实体主体中。
```
-GET /test/demo_form.asp?name1=value1&name2=value2 HTTP/1.1
+GET /test/demo_form.asp?name1=value1&name2=value2 HTTP/1.1
```
```
-POST /test/demo_form.asp HTTP/1.1
-Host: w3schools.com
+POST /test/demo_form.asp HTTP/1.1
+Host: w3schools.com
name1=value1&name2=value2
```
-不能因为 POST 参数存储在实体主体中就认为它的安全性更高，因为照样可以通过一些抓包工具（Fiddler）查看。
+不能因为 POST 参数存储在实体主体中就认为它的安全性更高，因为照样可以通过一些抓包工具（Fiddler）查看。
-因为 URL 只支持 ASCII 码，因此 GET 的参数中如果存在中文等字符就需要先进行编码，例如`中文`会转换为`%E4%B8%AD%E6%96%87`，而空格会转换为`%20`。POST 支持标准字符集。
+因为 URL 只支持 ASCII 码，因此 GET 的参数中如果存在中文等字符就需要先进行编码，例如`中文`会转换为`%E4%B8%AD%E6%96%87`，而空格会转换为`%20`。POST 支持标准字符集。
-## 安全
+## 安全
-安全的 HTTP 方法不会改变服务器状态，也就是说它只是可读的。
+安全的 HTTP 方法不会改变服务器状态，也就是说它只是可读的。
-GET 方法是安全的，而 POST 却不是，因为 POST 的目的是传送实体主体内容，这个内容可能是用户上传的表单数据，上传成功之后，服务器可能把这个数据存储到数据库中，因此状态也就发生了改变。
+GET 方法是安全的，而 POST 却不是，因为 POST 的目的是传送实体主体内容，这个内容可能是用户上传的表单数据，上传成功之后，服务器可能把这个数据存储到数据库中，因此状态也就发生了改变。
-安全的方法除了 GET 之外还有：HEAD、OPTIONS。
+安全的方法除了 GET 之外还有：HEAD、OPTIONS。
-不安全的方法除了 POST 之外还有 PUT、DELETE。
+不安全的方法除了 POST 之外还有 PUT、DELETE。
-## 幂等性
+## 幂等性
-幂等的 HTTP 方法，同样的请求被执行一次与连续执行多次的效果是一样的，服务器的状态也是一样的。换句话说就是，幂等方法不应该具有副作用（统计用途除外）。在正确实现的条件下，GET，HEAD，PUT 和 DELETE 等方法都是幂等的，而 POST 方法不是。所有的安全方法也都是幂等的。
+幂等的 HTTP 方法，同样的请求被执行一次与连续执行多次的效果是一样的，服务器的状态也是一样的。换句话说就是，幂等方法不应该具有副作用（统计用途除外）。在正确实现的条件下，GET，HEAD，PUT 和 DELETE 等方法都是幂等的，而 POST 方法不是。所有的安全方法也都是幂等的。
-GET /pageX HTTP/1.1 是幂等的。连续调用多次，客户端接收到的结果都是一样的：
+GET /pageX HTTP/1.1 是幂等的。连续调用多次，客户端接收到的结果都是一样的：
```
-GET /pageX HTTP/1.1
-GET /pageX HTTP/1.1
-GET /pageX HTTP/1.1
-GET /pageX HTTP/1.1
+GET /pageX HTTP/1.1
+GET /pageX HTTP/1.1
+GET /pageX HTTP/1.1
+GET /pageX HTTP/1.1
```
-POST /add_row HTTP/1.1 不是幂等的。如果调用多次，就会增加多行记录：
+POST /add_row HTTP/1.1 不是幂等的。如果调用多次，就会增加多行记录：
```
-POST /add_row HTTP/1.1
-POST /add_row HTTP/1.1 -> Adds a 2nd row
-POST /add_row HTTP/1.1 -> Adds a 3rd row
+POST /add_row HTTP/1.1
+POST /add_row HTTP/1.1 -> Adds a 2nd row
+POST /add_row HTTP/1.1 -> Adds a 3rd row
```
-DELETE /idX/delete HTTP/1.1 是幂等的，即便不同的请求接收到的状态码不一样：
+DELETE /idX/delete HTTP/1.1 是幂等的，即便不同的请求接收到的状态码不一样：
```
-DELETE /idX/delete HTTP/1.1 -> Returns 200 if idX exists
-DELETE /idX/delete HTTP/1.1 -> Returns 404 as it just got deleted
-DELETE /idX/delete HTTP/1.1 -> Returns 404
+DELETE /idX/delete HTTP/1.1 -> Returns 200 if idX exists
+DELETE /idX/delete HTTP/1.1 -> Returns 404 as it just got deleted
+DELETE /idX/delete HTTP/1.1 -> Returns 404
```
-## 可缓存
+## 可缓存
如果要对响应进行缓存，需要满足以下条件：
-- 请求报文的 HTTP 方法本身是可缓存的，包括 GET 和 HEAD，但是 PUT 和 DELETE 不可缓存，POST 在多数情况下不可缓存的。
-- 响应报文的状态码是可缓存的，包括：200, 203, 204, 206, 300, 301, 404, 405, 410, 414, and 501。
-- 响应报文的 Cache-Control 首部字段没有指定不进行缓存。
+- 请求报文的 HTTP 方法本身是可缓存的，包括 GET 和 HEAD，但是 PUT 和 DELETE 不可缓存，POST 在多数情况下不可缓存的。
+- 响应报文的状态码是可缓存的，包括：200, 203, 204, 206, 300, 301, 404, 405, 410, 414, and 501。
+- 响应报文的 Cache-Control 首部字段没有指定不进行缓存。
-## XMLHttpRequest
+## XMLHttpRequest
-为了阐述 POST 和 GET 的另一个区别，需要先了解 XMLHttpRequest：
+为了阐述 POST 和 GET 的另一个区别，需要先了解 XMLHttpRequest：
-> XMLHttpRequest 是一个 API，它为客户端提供了在客户端和服务器之间传输数据的功能。它提供了一个通过 URL 来获取数据的简单方式，并且不会使整个页面刷新。这使得网页只更新一部分页面而不会打扰到用户。XMLHttpRequest 在 AJAX 中被大量使用。
+> XMLHttpRequest 是一个 API，它为客户端提供了在客户端和服务器之间传输数据的功能。它提供了一个通过 URL 来获取数据的简单方式，并且不会使整个页面刷新。这使得网页只更新一部分页面而不会打扰到用户。XMLHttpRequest 在 AJAX 中被大量使用。
-在使用 XMLHttpRequest 的 POST 方法时，浏览器会先发送 Header 再发送 Data。但并不是所有浏览器会这么做，例如火狐就不会。而 GET 方法 Header 和 Data 会一起发送。
+在使用 XMLHttpRequest 的 POST 方法时，浏览器会先发送 Header 再发送 Data。但并不是所有浏览器会这么做，例如火狐就不会。而 GET 方法 Header 和 Data 会一起发送。
-# 九、HTTP/1.0 与 HTTP/1.1 的区别
+# 九、HTTP/1.0 与 HTTP/1.1 的区别
-> 详细内容请见上文
+> 详细内容请见上文
-- HTTP/1.1 默认是长连接
+- HTTP/1.1 默认是长连接
-- HTTP/1.1 支持管线化处理
+- HTTP/1.1 支持管线化处理
-- HTTP/1.1 支持同时打开多个 TCP 连接
+- HTTP/1.1 支持同时打开多个 TCP 连接
-- HTTP/1.1 支持虚拟主机
+- HTTP/1.1 支持虚拟主机
-- HTTP/1.1 新增状态码 100
+- HTTP/1.1 新增状态码 100
-- HTTP/1.1 支持分块传输编码
+- HTTP/1.1 支持分块传输编码
-- HTTP/1.1 新增缓存处理指令 max-age
+- HTTP/1.1 新增缓存处理指令 max-age
-# 十、HTTP/2.0
+# 十、HTTP/2.0
-## HTTP/1.x 缺陷
+## HTTP/1.x 缺陷
- HTTP/1.x 实现简单是以牺牲应用性能为代价的：
+ HTTP/1.x 实现简单是以牺牲应用性能为代价的：
-- 客户端需要使用多个连接才能实现并发和缩短延迟；
-- 不会压缩请求和响应首部，从而导致不必要的网络流量；
-- 不支持有效的资源优先级，致使底层 TCP 连接的利用率低下。
+- 客户端需要使用多个连接才能实现并发和缩短延迟；
+- 不会压缩请求和响应首部，从而导致不必要的网络流量；
+- 不支持有效的资源优先级，致使底层 TCP 连接的利用率低下。
-## 二进制分帧层
+## 二进制分帧层
-HTTP/2.0 将报文分成 HEADERS 帧和 DATA 帧，它们都是二进制格式的。
+HTTP/2.0 将报文分成 HEADERS 帧和 DATA 帧，它们都是二进制格式的。
- 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 {
- Selector selector = Selector.open();
+ public static void main(String[] args) throws IOException {
+ 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) {
- selector.select();
- Set keys = selector.selectedKeys();
- Iterator keyIterator = keys.iterator();
- while (keyIterator.hasNext()) {
- SelectionKey key = keyIterator.next();
- if (key.isAcceptable()) {
- ServerSocketChannel ssChannel1 = (ServerSocketChannel) key.channel();
- // 服务器会为每个新连接创建一个 SocketChannel
- SocketChannel sChannel = ssChannel1.accept();
- sChannel.configureBlocking(false);
- // 这个新连接主要用于从客户端读取数据
- sChannel.register(selector, SelectionKey.OP_READ);
- } else if (key.isReadable()) {
- SocketChannel sChannel = (SocketChannel) key.channel();
- System.out.println(readDataFromSocketChannel(sChannel));
- sChannel.close();
- }
- keyIterator.remove();
- }
- }
- }
+ while (true) {
+ selector.select();
+ Set keys = selector.selectedKeys();
+ Iterator keyIterator = keys.iterator();
+ while (keyIterator.hasNext()) {
+ SelectionKey key = keyIterator.next();
+ if (key.isAcceptable()) {
+ ServerSocketChannel ssChannel1 = (ServerSocketChannel) key.channel();
+ // 服务器会为每个新连接创建一个 SocketChannel
+ SocketChannel sChannel = ssChannel1.accept();
+ sChannel.configureBlocking(false);
+ // 这个新连接主要用于从客户端读取数据
+ sChannel.register(selector, SelectionKey.OP_READ);
+ } else if (key.isReadable()) {
+ SocketChannel sChannel = (SocketChannel) key.channel();
+ System.out.println(readDataFromSocketChannel(sChannel));
+ sChannel.close();
+ }
+ keyIterator.remove();
+ }
+ }
+ }
- private static String readDataFromSocketChannel(SocketChannel sChannel) throws IOException {
- ByteBuffer buffer = ByteBuffer.allocate(1024);
- StringBuffer data = new StringBuffer();
- 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();
- }
+ private static String readDataFromSocketChannel(SocketChannel sChannel) throws IOException {
+ ByteBuffer buffer = ByteBuffer.allocate(1024);
+ StringBuffer data = new StringBuffer();
+ 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();
+ }
}
```
```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 快得多。
只有文件中实际读取或者写入的部分才会映射到内存中。
-现代操作系统一般会根据需要将文件的部分映射为内存的部分，从而实现文件系统。Java 内存映射机制只不过是在底层操作系统中可以采用这种机制时，提供了对该机制的访问。
+现代操作系统一般会根据需要将文件的部分映射为内存的部分，从而实现文件系统。Java 内存映射机制只不过是在底层操作系统中可以采用这种机制时，提供了对该机制的访问。
向内存映射文件写入可能是危险的，仅只是改变数组的单个元素这样的简单操作，就可能会直接修改磁盘上的文件。修改数据与将数据保存到磁盘是没有分开的。
-下面代码行将文件的前 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 是非阻塞的。应当注意，FileChannel 不能切换到非阻塞模式，套接字 Channel 可以。
-- NIO 面向块，I/O 面向流。
+- NIO 是非阻塞的。应当注意，FileChannel 不能切换到非阻塞模式，套接字 Channel 可以。
+- NIO 面向块，I/O 面向流。
-# 八、参考资料
+# 八、参考资料
-- Eckel B, 埃克尔, 昊鹏, 等. Java 编程思想 [M]. 机械工业出版社, 2002.
-- [IBM: NIO 入门](https://www.ibm.com/developerworks/cn/education/java/j-nio/j-nio.html)
-- [深入分析 Java I/O 的工作机制](https://www.ibm.com/developerworks/cn/java/j-lo-javaio/index.html)
-- [NIO 与传统 IO 的区别](http://blog.csdn.net/shimiso/article/details/24990499)
-- [Decorator Design Pattern](http://stg-tud.github.io/sedc/Lecture/ws13-14/5.3-Decorator.html#mode=document)
-- [Socket Multicast](http://labojava.blogspot.com/2012/12/socket-multicast.html)
+- Eckel B, 埃克尔, 昊鹏, 等. Java 编程思想 [M]. 机械工业出版社, 2002.
+- [IBM: NIO 入门](https://www.ibm.com/developerworks/cn/education/java/j-nio/j-nio.html)
+- [深入分析 Java I/O 的工作机制](https://www.ibm.com/developerworks/cn/java/j-lo-javaio/index.html)
+- [NIO 与传统 IO 的区别](http://blog.csdn.net/shimiso/article/details/24990499)
+- [Decorator Design Pattern](http://stg-tud.github.io/sedc/Lecture/ws13-14/5.3-Decorator.html#mode=document)
+- [Socket Multicast](http://labojava.blogspot.com/2012/12/socket-multicast.html)
+---bottom---CyC---
+
+
+
+
+
+
+
diff --git a/notes/Java 基础.md b/notes/Java 基础.md
index 6424600a..4cede783 100644
--- a/notes/Java 基础.md
+++ b/notes/Java 基础.md
@@ -1,304 +1,269 @@
-
-* [一、关键字](#一关键字)
- * [final](#final)
- * [static](#static)
-* [二、Object 通用方法](#二object-通用方法)
- * [概览](#概览)
- * [equals()](#equals)
- * [hashCode()](#hashcode)
- * [toString()](#tostring)
- * [clone()](#clone)
-* [四、继承](#四继承)
- * [访问权限](#访问权限)
- * [抽象类与接口](#抽象类与接口)
- * [super](#super)
- * [覆盖与重载](#覆盖与重载)
-* [五、String](#五string)
- * [String, StringBuffer and StringBuilder](#string,-stringbuffer-and-stringbuilder)
- * [String 不可变的原因](#string-不可变的原因)
- * [String.intern()](#stringintern)
-* [六、基本类型与运算](#六基本类型与运算)
- * [包装类型](#包装类型)
- * [switch](#switch)
-* [七、反射](#七反射)
-* [八、异常](#八异常)
-* [九、泛型](#九泛型)
-* [十、注解](#十注解)
-* [十一、特性](#十一特性)
- * [面向对象三大特性](#面向对象三大特性)
- * [Java 各版本的新特性](#java-各版本的新特性)
- * [Java 与 C++ 的区别](#java-与-c-的区别)
- * [JRE or JDK](#jre-or-jdk)
-* [参考资料](#参考资料)
-
+# 一、关键字
+## 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 {
- private int x; // 实例变量
- public static int y; // 静态变量
+public class A {
+ private int x; // 实例变量
+ public static int y; // 静态变量
}
```
-**2. 静态方法**
+**2. 静态方法**
静态方法在类加载的时候就存在了，它不依赖于任何实例，所以静态方法必须有实现，也就是说它不能是抽象方法（abstract）。
-**3. 静态语句块**
+**3. 静态语句块**
静态语句块在类初始化时运行一次。
-**4. 静态内部类**
+**4. 静态内部类**
内部类的一种，静态内部类不依赖外部类，且不能访问外部类的非静态的变量和方法。
-**5. 静态导包**
+**5. 静态导包**
```java
-import static com.xxx.ClassName.*
+import static com.xxx.ClassName.*
```
-在使用静态变量和方法时不用再指明 ClassName，从而简化代码，但可读性大大降低。
+在使用静态变量和方法时不用再指明 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("构造函数");
}
```
存在继承的情况下，初始化顺序为：
-- 父类（静态变量、静态语句块）
-- 子类（静态变量、静态语句块）
-- 父类（实例变量、普通语句块）
-- 父类（构造函数）
-- 子类（实例变量、普通语句块）
-- 子类（构造函数）
+- 父类（静态变量、静态语句块）
+- 子类（静态变量、静态语句块）
+- 父类（实例变量、普通语句块）
+- 父类（构造函数）
+- 子类（实例变量、普通语句块）
+- 子类（构造函数）
-# 二、Object 通用方法
+# 二、Object 通用方法
-## 概览
+## 概览
```java
-public final native Class getClass()
+public final native Class getClass()
-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 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
-protected void finalize() throws Throwable {}
+protected void finalize() throws Throwable {}
```
-## equals()
+## equals()
-**1. equals() 与 == 的区别**
+**1. equals() 与 == 的区别**
-- 对于基本类型，== 判断两个值是否相等，基本类型没有 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
```
-**2. 等价关系**
+**2. 等价关系**
（一）自反性
```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.euqals(null); // false;
+x.euqals(null); // false;
```
-**3. 实现**
+**3. 实现**
-- 检查是否为同一个对象的引用，如果是直接返回 true；
-- 检查是否是同一个类型，如果不是，直接返回 false；
-- 将 Object 实例进行转型；
-- 判断每个关键域是否相等。
+- 检查是否为同一个对象的引用，如果是直接返回 true；
+- 检查是否是同一个类型，如果不是，直接返回 false；
+- 将 Object 实例进行转型；
+- 判断每个关键域是否相等。
```java
-public class EqualExample {
- private int x;
- private int y;
- private int z;
+public class EqualExample {
+ 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()
-hasCode() 返回散列值，而 equals() 是用来判断两个实例是否等价。等价的两个实例散列值一定要相同，但是散列值相同的两个实例不一定等价。
+hasCode() 返回散列值，而 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 {
- private int number;
+public class ToStringExample {
+ 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());
```
@@ -306,393 +271,393 @@ System.out.println(example.toString());
ToStringExample@4554617c
```
-## clone()
+## clone()
-**1. cloneable**
+**1. cloneable**
-clone() 是 Object 的受保护方法，这意味着，如果一个类不显式去覆盖 clone() 就没有这个方法。
+clone() 是 Object 的受保护方法，这意味着，如果一个类不显式去覆盖 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'
```
-接下来覆盖 Object 的 clone() 得到以下实现：
+接下来覆盖 Object 的 clone() 得到以下实现：
```java
-public class CloneExample {
- private int a;
- private int b;
+public class CloneExample {
+ private int a;
+ private int b;
- @Override
- protected CloneExample clone() throws CloneNotSupportedException {
- return (CloneExample)super.clone();
- }
+ @Override
+ protected 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: CloneTest
+java.lang.CloneNotSupportedException: CloneTest
```
-以上抛出了 CloneNotSupportedException，这是因为 CloneTest 没有实现 Cloneable 接口。
+以上抛出了 CloneNotSupportedException，这是因为 CloneTest 没有实现 Cloneable 接口。
```java
-public class CloneExample implements Cloneable {
- private int a;
- private int b;
+public class CloneExample implements Cloneable {
+ private int a;
+ private int b;
- @Override
- protected Object clone() throws CloneNotSupportedException {
- return super.clone();
- }
+ @Override
+ protected Object clone() throws CloneNotSupportedException {
+ return super.clone();
+ }
}
```
-应该注意的是，clone() 方法并不是 Cloneable 接口的方法，而是 Object 的一个 protected 方法。Cloneable 接口只是规定，如果一个类没有实现 Cloneable 接口又调用了 clone() 方法，就会抛出 CloneNotSupportedException。
+应该注意的是，clone() 方法并不是 Cloneable 接口的方法，而是 Object 的一个 protected 方法。Cloneable 接口只是规定，如果一个类没有实现 Cloneable 接口又调用了 clone() 方法，就会抛出 CloneNotSupportedException。
-**2. 深拷贝与浅拷贝**
+**2. 深拷贝与浅拷贝**
-- 浅拷贝：拷贝实例和原始实例的引用类型引用同一个对象；
-- 深拷贝：拷贝实例和原始实例的引用类型引用不同对象。
+- 浅拷贝：拷贝实例和原始实例的引用类型引用同一个对象；
+- 深拷贝：拷贝实例和原始实例的引用类型引用不同对象。
```java
-public class ShallowCloneExample implements Cloneable {
- private int[] arr;
+public class ShallowCloneExample implements Cloneable {
+ 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
```
```java
-public class DeepCloneExample implements Cloneable {
- private int[] arr;
+public class DeepCloneExample implements Cloneable {
+ 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
```
-使用 clone() 方法来拷贝一个对象即复杂又有风险，它会抛出异常，并且还需要类型转换。Effective Java 书上讲到，最好不要去使用 clone()，可以使用拷贝构造函数或者拷贝工厂来拷贝一个对象。
+使用 clone() 方法来拷贝一个对象即复杂又有风险，它会抛出异常，并且还需要类型转换。Effective Java 书上讲到，最好不要去使用 clone()，可以使用拷贝构造函数或者拷贝工厂来拷贝一个对象。
```java
-public class CloneConstructorExample {
- private int[] arr;
+public class CloneConstructorExample {
+ 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
```
-# 四、继承
+# 四、继承
-## 访问权限
+## 访问权限
-Java 中有三个访问权限修饰符：private、protected 以及 public，如果不加访问修饰符，表示包级可见。
+Java 中有三个访问权限修饰符：private、protected 以及 public，如果不加访问修饰符，表示包级可见。
可以对类或类中的成员（字段以及方法）加上访问修饰符。
-- 成员可见表示其它类可以用这个类的实例访问到该成员；
-- 类可见表示其它类可以用这个类创建对象。
+- 成员可见表示其它类可以用这个类的实例访问到该成员；
+- 类可见表示其它类可以用这个类创建对象。
-protected 用于修饰成员，表示在继承体系中成员对于子类可见，但是这个访问修饰符对于类没有意义。
+protected 用于修饰成员，表示在继承体系中成员对于子类可见，但是这个访问修饰符对于类没有意义。
-设计良好的模块会隐藏所有的实现细节，把它的 API 与它的实现清晰地隔离开来。模块之间只通过它们的 API 进行通信，一个模块不需要知道其他模块的内部工作情况，这个概念被称为信息隐藏或封装。因此访问权限应当尽可能地使每个类或者成员不被外界访问。
+设计良好的模块会隐藏所有的实现细节，把它的 API 与它的实现清晰地隔离开来。模块之间只通过它们的 API 进行通信，一个模块不需要知道其他模块的内部工作情况，这个概念被称为信息隐藏或封装。因此访问权限应当尽可能地使每个类或者成员不被外界访问。
如果子类的方法覆盖了父类的方法，那么子类中该方法的访问级别不允许低于父类的访问级别。这是为了确保可以使用父类实例的地方都可以使用子类实例，也就是确保满足里氏替换原则。
-字段决不能是公有的，因为这么做的话就失去了对这个字段修改行为的控制，客户端可以对其随意修改。可以使用公有的 getter 和 setter 方法来替换公有字段。
+字段决不能是公有的，因为这么做的话就失去了对这个字段修改行为的控制，客户端可以对其随意修改。可以使用公有的 getter 和 setter 方法来替换公有字段。
```java
-public class AccessExample {
- public int x;
+public class AccessExample {
+ public int x;
}
```
```java
-public class AccessExample {
- private int x;
+public class AccessExample {
+ private int x;
- public int getX() {
- return x;
- }
+ public int getX() {
+ return x;
+ }
- public void setX(int x) {
- this.x = x;
- }
+ public void setX(int x) {
+ this.x = x;
+ }
}
```
但是也有例外，如果是包级私有的类或者私有的嵌套类，那么直接暴露成员不会有特别大的影响。
```java
-public class AccessWithInnerClassExample {
- private class InnerClass {
- int x;
- }
+public class AccessWithInnerClassExample {
+ 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 {
- void func1();
+public interface InterfaceExample {
+ 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. 使用选择**
使用抽象类：
-- 需要在几个相关的类中共享代码。
-- 需要能控制继承来的方法和域的访问权限，而不是都为 public。
-- 需要继承非静态（non-static）和非常量（non-final）字段。
+- 需要在几个相关的类中共享代码。
+- 需要能控制继承来的方法和域的访问权限，而不是都为 public。
+- 需要继承非静态（non-static）和非常量（non-final）字段。
使用接口：
-- 需要让不相关的类都实现一个方法，例如不相关的类都可以实现 Compareable 接口中的 compareTo() 方法；
-- 需要使用多重继承。
+- 需要让不相关的类都实现一个方法，例如不相关的类都可以实现 Compareable 接口中的 compareTo() 方法；
+- 需要使用多重继承。
-在很多情况下，接口优先于抽象类，因为接口没有抽象类严格的类层次结构要求，可以灵活地为一个类添加行为。并且从 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 {
- protected int x;
- protected int y;
+public class SuperExample {
+ 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 {
- private int z;
+public class SuperExtendExample extends SuperExample {
+ 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();
```
@@ -701,330 +666,333 @@ 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)
-## 覆盖与重载
+## 覆盖与重载
-- 覆盖（Override）存在于继承体系中，指子类实现了一个与父类在方法声明上完全相同的一个方法；
+- 覆盖（Override）存在于继承体系中，指子类实现了一个与父类在方法声明上完全相同的一个方法；
-- 重载（Overload）存在于同一个类中，指一个方法与已经存在的方法名称上相同，但是参数类型、个数、顺序至少有一个不同。应该注意的是，返回值不同，其它都相同不算是重载。
+- 重载（Overload）存在于同一个类中，指一个方法与已经存在的方法名称上相同，但是参数类型、个数、顺序至少有一个不同。应该注意的是，返回值不同，其它都相同不算是重载。
-# 五、String
+# 五、String
-## String, StringBuffer and StringBuilder
+## String, StringBuffer and StringBuilder
-**1. 是否可变**
+**1. 是否可变**
-- String 不可变
-- StringBuffer 和 StringBuilder 可变
+- String 不可变
+- StringBuffer 和 StringBuilder 可变
-**2. 是否线程安全**
+**2. 是否线程安全**
-- String 不可变，因此是线程安全的
-- StringBuilder 不是线程安全的
-- StringBuffer 是线程安全的，内部使用 synchronized 来同步
+- String 不可变，因此是线程安全的
+- StringBuilder 不是线程安全的
+- StringBuffer 是线程安全的，内部使用 synchronized 来同步
-> [String, StringBuffer, and StringBuilder](https://stackoverflow.com/questions/2971315/string-stringbuffer-and-stringbuilder)
+> [String, StringBuffer, and StringBuilder](https://stackoverflow.com/questions/2971315/string-stringbuffer-and-stringbuilder)
-## String 不可变的原因
+## 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。
- {
- // 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)
-# 十一、特性
+# 十一、特性
-## 面向对象三大特性
+## 面向对象三大特性
-> [封装、继承、多态](https://github.com/CyC2018/Interview-Notebook/blob/master/notes/%E9%9D%A2%E5%90%91%E5%AF%B9%E8%B1%A1%E6%80%9D%E6%83%B3.md#%E5%B0%81%E8%A3%85%E7%BB%A7%E6%89%BF%E5%A4%9A%E6%80%81)
+> [封装、继承、多态](https://github.com/CyC2018/Interview-Notebook/blob/master/notes/%E9%9D%A2%E5%90%91%E5%AF%B9%E8%B1%A1%E6%80%9D%E6%83%B3.md#%E5%B0%81%E8%A3%85%E7%BB%A7%E6%89%BF%E5%A4%9A%E6%80%81)
-## 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 是纯粹的面向对象语言，所有的对象都继承自 java.lang.Object，C++ 为了兼容 C 即支持面向对象也支持面向过程。
-| Java | C++ |
-| -- | -- |
-| Java does not support pointers, templates, unions, operator overloading, structures etc. The Java language promoters initially said "No pointers!", but when many programmers questioned how you can work without pointers, the promoters began saying "Restricted pointers." Java supports what it calls "references". References act a lot like pointers in C++ languages but you cannot perform arithmetic on pointers in Java. References have types, and they're type-safe. These references cannot be interpreted as raw address and unsafe conversion is not allowed. | C++ supports structures, unions, templates, operator overloading, pointers and pointer arithmetic.|
-| Java support automatic garbage collection. It does not support destructors as C++ does. | C++ support destructors, which is automatically invoked when the object is destroyed. |
-| Java does not support conditional compilation and inclusion. | Conditional inclusion (#ifdef #ifndef type) is one of the main features of C++. |
-| Java has built in support for threads. In Java, there is a `Thread` class that you inherit to create a new thread and override the `run()` method. | C++ has no built in support for threads. C++ relies on non-standard third-party libraries for thread support. |
-| Java does not support default arguments. There is no scope resolution operator (::) in Java. The method definitions must always occur within a class, so there is no need for scope resolution there either. | C++ supports default arguments. C++ has scope resolution operator (::) which is used to to define a method outside a class and to access a global variable within from the scope where a local variable also exists with the same name. |
-| There is no _goto_ statement in Java. The keywords `const` and `goto` are reserved, even though they are not used. | C++ has _goto_ statement. However, it is not considered good practice to use of _goto_ statement. |
-| Java doesn't provide multiple inheritance, at least not in the same sense that C++ does. | C++ does support multiple inheritance. The keyword `virtual` is used to resolve ambiguities during multiple inheritance if there is any. |
-| Exception handling in Java is different because there are no destructors. Also, in Java, try/catch must be defined if the function declares that it may throw an exception. | While in C++, you may not include the try/catch even if the function throws an exception. |
-| Java has method overloading, but no operator overloading. The `String` class does use the `+` and `+=` operators to concatenate strings and `String`expressions use automatic type conversion, but that's a special built-in case. | C++ supports both method overloading and operator overloading. |
-| Java has built-in support for documentation comments (`/** ... */`); therefore, Java source files can contain their own documentation, which is read by a separate tool usually `javadoc` and reformatted into HTML. This helps keeping documentation maintained in easy way. | C++ does not support documentation comments. |
-| Java is interpreted for the most part and hence platform independent. | C++ generates object code and the same code may not run on different platforms. |
+| Java | C++ |
+| -- | -- |
+| Java does not support pointers, templates, unions, operator overloading, structures etc. The Java language promoters initially said "No pointers!", but when many programmers questioned how you can work without pointers, the promoters began saying "Restricted pointers." Java supports what it calls "references". References act a lot like pointers in C++ languages but you cannot perform arithmetic on pointers in Java. References have types, and they're type-safe. These references cannot be interpreted as raw address and unsafe conversion is not allowed. | C++ supports structures, unions, templates, operator overloading, pointers and pointer arithmetic.|
+| Java support automatic garbage collection. It does not support destructors as C++ does. | C++ support destructors, which is automatically invoked when the object is destroyed. |
+| Java does not support conditional compilation and inclusion. | Conditional inclusion (#ifdef #ifndef type) is one of the main features of C++. |
+| Java has built in support for threads. In Java, there is a `Thread` class that you inherit to create a new thread and override the `run()` method. | C++ has no built in support for threads. C++ relies on non-standard third-party libraries for thread support. |
+| Java does not support default arguments. There is no scope resolution operator (::) in Java. The method definitions must always occur within a class, so there is no need for scope resolution there either. | C++ supports default arguments. C++ has scope resolution operator (::) which is used to to define a method outside a class and to access a global variable within from the scope where a local variable also exists with the same name. |
+| There is no _goto_ statement in Java. The keywords `const` and `goto` are reserved, even though they are not used. | C++ has _goto_ statement. However, it is not considered good practice to use of _goto_ statement. |
+| Java doesn't provide multiple inheritance, at least not in the same sense that C++ does. | C++ does support multiple inheritance. The keyword `virtual` is used to resolve ambiguities during multiple inheritance if there is any. |
+| Exception handling in Java is different because there are no destructors. Also, in Java, try/catch must be defined if the function declares that it may throw an exception. | While in C++, you may not include the try/catch even if the function throws an exception. |
+| Java has method overloading, but no operator overloading. The `String` class does use the `+` and `+=` operators to concatenate strings and `String`expressions use automatic type conversion, but that's a special built-in case. | C++ supports both method overloading and operator overloading. |
+| Java has built-in support for documentation comments (`/** ... */`); therefore, Java source files can contain their own documentation, which is read by a separate tool usually `javadoc` and reformatted into HTML. This helps keeping documentation maintained in easy way. | C++ does not support documentation comments. |
+| Java is interpreted for the most part and hence platform independent. | C++ generates object code and the same code may not run on different platforms. |
-> [What are the main differences between Java and C++?](http://cs-fundamentals.com/tech-interview/java/differences-between-java-and-cpp.php)
+> [What are the main differences between Java and C++?](http://cs-fundamentals.com/tech-interview/java/differences-between-java-and-cpp.php)
-## JRE or JDK
+## JRE or JDK
-- JRE is the JVM program, Java application need to run on JRE.
-- JDK is a superset of JRE, JRE + tools for developing java programs. e.g, it provides the compiler "javac"
+- JRE is the JVM program, Java application need to run on JRE.
+- JDK is a superset of JRE, JRE + tools for developing java programs. e.g, it provides the compiler "javac"
-# 参考资料
+# 参考资料
-- Eckel B. Java 编程思想[M]. 机械工业出版社, 2002.
-- Bloch J. Effective java[M]. Addison-Wesley Professional, 2017.
+- Eckel B. Java 编程思想[M]. 机械工业出版社, 2002.
+- Bloch J. Effective java[M]. Addison-Wesley Professional, 2017.
+---bottom---CyC---
+
+
diff --git a/notes/Java 容器.md b/notes/Java 容器.md
index b34caa09..6045d378 100644
--- a/notes/Java 容器.md
+++ b/notes/Java 容器.md
@@ -1,851 +1,843 @@
-
-* [一、概览](#一概览)
- * [Collection](#collection)
- * [Map](#map)
-* [二、容器中的设计模式](#二容器中的设计模式)
- * [迭代器模式](#迭代器模式)
- * [适配器模式](#适配器模式)
-* [三、源码分析](#三源码分析)
- * [ArrayList](#arraylist)
- * [Vector](#vector)
- * [LinkedList](#linkedlist)
- * [HashMap](#hashmap)
- * [ConcurrentHashMap](#concurrenthashmap)
- * [LinkedHashMap](#linkedhashmap)
- * [TreeMap](#treemap)
-* [参考资料](#参考资料)
-
+# 一、概览
+容器主要包括 Collection 和 Map 两种，Collection 又包含了 List、Set 以及 Queue。
-# 一、概览
+## Collection
-容器主要包括 Collection 和 Map 两种，Collection 又包含了 List、Set 以及 Queue。
+
-## Collection
+### 1. Set
- list = new ArrayList<>();
+List list = new ArrayList<>();
list.add("a");
list.add("b");
-for (String item : list) {
- System.out.println(item);
+for (String item : list) {
+ System.out.println(item);
}
```
-## 适配器模式
+## 适配器模式
-java.util.Arrays#asList() 可以把数组类型转换为 List 类型。
+java.util.Arrays#asList() 可以把数组类型转换为 List 类型。
```java
@SafeVarargs
-public static List asList(T... a)
+public static List asList(T... a)
```
-如果要将数组类型转换为 List 类型，应该注意的是 asList() 的参数为泛型的变长参数，因此不能使用基本类型数组作为参数，只能使用相应的包装类型数组。
+如果要将数组类型转换为 List 类型，应该注意的是 asList() 的参数为泛型的变长参数，因此不能使用基本类型数组作为参数，只能使用相应的包装类型数组。
```java
-Integer[] arr = {1, 2, 3};
-List list = Arrays.asList(arr);
+Integer[] arr = {1, 2, 3};
+List list = Arrays.asList(arr);
```
-也可以使用以下方式生成 List。
+也可以使用以下方式生成 List。
```java
-List list = Arrays.asList(1,2,3);
+List list = Arrays.asList(1,2,3);
```
-# 三、源码分析
+# 三、源码分析
-建议先阅读 [算法-查找](https://github.com/CyC2018/Interview-Notebook/blob/master/notes/%E7%AE%97%E6%B3%95.md#%E6%9F%A5%E6%89%BE) 部分，对容器类源码的理解有很大帮助。
+建议先阅读 [算法-查找](https://github.com/CyC2018/Interview-Notebook/blob/master/notes/%E7%AE%97%E6%B3%95.md#%E6%9F%A5%E6%89%BE) 部分，对容器类源码的理解有很大帮助。
-至于 ConcurrentHashMap 的理解，需要有并发方面的知识，建议先阅读：[Java 并发](https://github.com/CyC2018/Interview-Notebook/blob/master/notes/Java%20%E5%B9%B6%E5%8F%91.md)
+至于 ConcurrentHashMap 的理解，需要有并发方面的知识，建议先阅读：[Java 并发](https://github.com/CyC2018/Interview-Notebook/blob/master/notes/Java%20%E5%B9%B6%E5%8F%91.md)
-以下源码从 JDK 1.8 提取而来，下载地址：[JDK-Source-Code](https://github.com/CyC2018/JDK-Source-Code)。
+以下源码从 JDK 1.8 提取而来，下载地址：[JDK-Source-Code](https://github.com/CyC2018/JDK-Source-Code)。
-## ArrayList
+## ArrayList
[ArrayList.java](https://github.com/CyC2018/JDK-Source-Code/tree/master/src/ArrayList.java)
-### 1. 概览
+### 1. 概览
-实现了 RandomAccess 接口，因此支持随机访问，这是理所当然的，因为 ArrayList 是基于数组实现的。
+实现了 RandomAccess 接口，因此支持随机访问，这是理所当然的，因为 ArrayList 是基于数组实现的。
```java
-public class ArrayList extends AbstractList
- implements List, RandomAccess, Cloneable, java.io.Serializable
+public class ArrayList extends AbstractList
+ implements List, RandomAccess, Cloneable, java.io.Serializable
```
-数组的默认大小为 10。
+数组的默认大小为 10。
```java
-private static final int DEFAULT_CAPACITY = 10;
+private static final int DEFAULT_CAPACITY = 10;
```
-### 2. 序列化
+### 2. 序列化
-基于数组实现，保存元素的数组使用 transient 修饰，该关键字声明数组默认不会被序列化。ArrayList 具有动态扩容特性，因此保存元素的数组不一定都会被使用，那么就没必要全部进行序列化。ArrayList 重写了 writeObject() 和 readObject() 来控制只序列化数组中有元素填充那部分内容。
+基于数组实现，保存元素的数组使用 transient 修饰，该关键字声明数组默认不会被序列化。ArrayList 具有动态扩容特性，因此保存元素的数组不一定都会被使用，那么就没必要全部进行序列化。ArrayList 重写了 writeObject() 和 readObject() 来控制只序列化数组中有元素填充那部分内容。
```java
-transient Object[] elementData; // non-private to simplify nested class access
+transient Object[] elementData; // non-private to simplify nested class access
```
-### 3. 扩容
+### 3. 扩容
-添加元素时使用 ensureCapacityInternal() 方法来保证容量足够，如果不够时，需要使用 grow() 方法进行扩容，新容量的大小为 `oldCapacity + (oldCapacity >> 1)`，也就是旧容量的 1.5 倍。
+添加元素时使用 ensureCapacityInternal() 方法来保证容量足够，如果不够时，需要使用 grow() 方法进行扩容，新容量的大小为 `oldCapacity + (oldCapacity >> 1)`，也就是旧容量的 1.5 倍。
-扩容操作需要调用 `Arrays.copyOf()` 把原数组整个复制到新数组中，因此最好在创建 ArrayList 对象时就指定大概的容量大小，减少扩容操作的次数。
+扩容操作需要调用 `Arrays.copyOf()` 把原数组整个复制到新数组中，因此最好在创建 ArrayList 对象时就指定大概的容量大小，减少扩容操作的次数。
```java
-public boolean add(E e) {
- ensureCapacityInternal(size + 1); // Increments modCount!!
- elementData[size++] = e;
- return true;
+public boolean add(E e) {
+ ensureCapacityInternal(size + 1); // Increments modCount!!
+ elementData[size++] = e;
+ return true;
}
-private void ensureCapacityInternal(int minCapacity) {
- if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
- minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
- }
+private void ensureCapacityInternal(int minCapacity) {
+ if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
+ minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
+ }
- ensureExplicitCapacity(minCapacity);
+ ensureExplicitCapacity(minCapacity);
}
-private void ensureExplicitCapacity(int minCapacity) {
- modCount++;
+private void ensureExplicitCapacity(int minCapacity) {
+ modCount++;
- // overflow-conscious code
- if (minCapacity - elementData.length > 0)
- grow(minCapacity);
+ // overflow-conscious code
+ if (minCapacity - elementData.length > 0)
+ grow(minCapacity);
}
-private void grow(int minCapacity) {
- // overflow-conscious code
- int oldCapacity = elementData.length;
- int newCapacity = oldCapacity + (oldCapacity >> 1);
- if (newCapacity - minCapacity < 0)
- newCapacity = minCapacity;
- if (newCapacity - MAX_ARRAY_SIZE > 0)
- newCapacity = hugeCapacity(minCapacity);
- // minCapacity is usually close to size, so this is a win:
- elementData = Arrays.copyOf(elementData, newCapacity);
+private void grow(int minCapacity) {
+ // overflow-conscious code
+ int oldCapacity = elementData.length;
+ int newCapacity = oldCapacity + (oldCapacity >> 1);
+ if (newCapacity - minCapacity < 0)
+ newCapacity = minCapacity;
+ if (newCapacity - MAX_ARRAY_SIZE > 0)
+ newCapacity = hugeCapacity(minCapacity);
+ // minCapacity is usually close to size, so this is a win:
+ elementData = Arrays.copyOf(elementData, newCapacity);
}
```
-### 4. 删除元素
+### 4. 删除元素
-需要调用 System.arraycopy() 将 index+1 后面的元素都复制到 index 位置上，复制的代价很高。
+需要调用 System.arraycopy() 将 index+1 后面的元素都复制到 index 位置上，复制的代价很高。
```java
-public E remove(int index) {
- rangeCheck(index);
+public E remove(int index) {
+ rangeCheck(index);
- modCount++;
- E oldValue = elementData(index);
+ modCount++;
+ E oldValue = elementData(index);
- int numMoved = size - index - 1;
- if (numMoved > 0)
- System.arraycopy(elementData, index+1, elementData, index, numMoved);
- elementData[--size] = null; // clear to let GC do its work
+ int numMoved = size - index - 1;
+ if (numMoved > 0)
+ System.arraycopy(elementData, index+1, elementData, index, numMoved);
+ elementData[--size] = null; // clear to let GC do its work
- return oldValue;
+ return oldValue;
}
```
-### 5. Fail-Fast
+### 5. Fail-Fast
-modCount 用来记录 ArrayList 结构发生变化的次数。结构发生变化是指添加或者删除至少一个元素的所有操作，或者是调整内部数组的大小，仅仅只是设置元素的值不算结构发生变化。
+modCount 用来记录 ArrayList 结构发生变化的次数。结构发生变化是指添加或者删除至少一个元素的所有操作，或者是调整内部数组的大小，仅仅只是设置元素的值不算结构发生变化。
-在进行序列化或者迭代等操作时，需要比较操作前后 modCount 是否改变，如果改变了需要抛出 ConcurrentModificationException。
+在进行序列化或者迭代等操作时，需要比较操作前后 modCount 是否改变，如果改变了需要抛出 ConcurrentModificationException。
```java
-private void writeObject(java.io.ObjectOutputStream s)
- throws java.io.IOException{
- // Write out element count, and any hidden stuff
- int expectedModCount = modCount;
- s.defaultWriteObject();
+private void writeObject(java.io.ObjectOutputStream s)
+ throws java.io.IOException{
+ // Write out element count, and any hidden stuff
+ int expectedModCount = modCount;
+ s.defaultWriteObject();
- // Write out size as capacity for behavioural compatibility with clone()
- s.writeInt(size);
+ // Write out size as capacity for behavioural compatibility with clone()
+ s.writeInt(size);
- // Write out all elements in the proper order.
- for (int i=0; i= elementCount)
- throw new ArrayIndexOutOfBoundsException(index);
+public synchronized E get(int index) {
+ if (index >= elementCount)
+ throw new ArrayIndexOutOfBoundsException(index);
- return elementData(index);
+ return elementData(index);
}
```
-### 2. ArrayList 与 Vector
+### 2. ArrayList 与 Vector
-- Vector 和 ArrayList 几乎是完全相同的，唯一的区别在于 Vector 是同步的，因此开销就比 ArrayList 要大，访问速度更慢。最好使用 ArrayList 而不是 Vector，因为同步操作完全可以由程序员自己来控制；
-- Vector 每次扩容请求其大小的 2 倍空间，而 ArrayList 是 1.5 倍。
+- Vector 和 ArrayList 几乎是完全相同的，唯一的区别在于 Vector 是同步的，因此开销就比 ArrayList 要大，访问速度更慢。最好使用 ArrayList 而不是 Vector，因为同步操作完全可以由程序员自己来控制；
+- Vector 每次扩容请求其大小的 2 倍空间，而 ArrayList 是 1.5 倍。
-### 3. Vector 替代方案
+### 3. Vector 替代方案
-为了获得线程安全的 ArrayList，可以使用 Collections.synchronizedList(); 得到一个线程安全的 ArrayList，也可以使用 concurrent 并发包下的 CopyOnWriteArrayList 类；
+为了获得线程安全的 ArrayList，可以使用 Collections.synchronizedList(); 得到一个线程安全的 ArrayList，也可以使用 concurrent 并发包下的 CopyOnWriteArrayList 类；
```java
-List list = new ArrayList<>();
-List synList = Collections.synchronizedList(list);
+List list = new ArrayList<>();
+List synList = Collections.synchronizedList(list);
```
```java
-List list = new CopyOnWriteArrayList();
+List list = new CopyOnWriteArrayList();
```
-## LinkedList
+## LinkedList
[LinkedList.java](https://github.com/CyC2018/JDK-Source-Code/tree/master/src/LinkedList.java)
-### 1. 概览
+### 1. 概览
-基于双向链表实现，内部使用 Node 来存储链表节点信息。
+基于双向链表实现，内部使用 Node 来存储链表节点信息。
```java
-private static class Node {
- E item;
- Node next;
- Node prev;
+private static class Node {
+ E item;
+ Node next;
+ Node prev;
}
```
-每个链表存储了 Head 和 Tail 指针：
+每个链表存储了 Head 和 Tail 指针：
```java
-transient Node first;
-transient Node last;
+transient Node first;
+transient Node last;
```
- implements Map.Entry {
- final K key;
- V value;
- Entry next;
- int hash;
+static class Entry implements Map.Entry {
+ final K key;
+ V value;
+ Entry next;
+ int hash;
- Entry(int h, K k, V v, Entry n) {
- value = v;
- next = n;
- key = k;
- hash = h;
- }
+ Entry(int h, K k, V v, Entry n) {
+ value = v;
+ next = n;
+ key = k;
+ hash = h;
+ }
- public final K getKey() {
- return key;
- }
+ public final K getKey() {
+ return key;
+ }
- public final V getValue() {
- return value;
- }
+ public final V getValue() {
+ return value;
+ }
- public final V setValue(V newValue) {
- V oldValue = value;
- value = newValue;
- return oldValue;
- }
+ public final V setValue(V newValue) {
+ V oldValue = value;
+ value = newValue;
+ return oldValue;
+ }
- public final boolean equals(Object o) {
- if (!(o instanceof Map.Entry))
- return false;
- Map.Entry e = (Map.Entry)o;
- Object k1 = getKey();
- Object k2 = e.getKey();
- if (k1 == k2 || (k1 != null && k1.equals(k2))) {
- Object v1 = getValue();
- Object v2 = e.getValue();
- if (v1 == v2 || (v1 != null && v1.equals(v2)))
- return true;
- }
- return false;
- }
+ public final boolean equals(Object o) {
+ if (!(o instanceof Map.Entry))
+ return false;
+ Map.Entry e = (Map.Entry)o;
+ Object k1 = getKey();
+ Object k2 = e.getKey();
+ if (k1 == k2 || (k1 != null && k1.equals(k2))) {
+ Object v1 = getValue();
+ Object v2 = e.getValue();
+ if (v1 == v2 || (v1 != null && v1.equals(v2)))
+ return true;
+ }
+ return false;
+ }
- public final int hashCode() {
- return Objects.hashCode(getKey()) ^ Objects.hashCode(getValue());
- }
+ public final int hashCode() {
+ return Objects.hashCode(getKey()) ^ Objects.hashCode(getValue());
+ }
- public final String toString() {
- return getKey() + "=" + getValue();
- }
+ public final String toString() {
+ return getKey() + "=" + getValue();
+ }
- /**
- * This method is invoked whenever the value in an entry is
- * overwritten by an invocation of put(k,v) for a key k that's already
- * in the HashMap.
- */
- void recordAccess(HashMap m) {
- }
+ /**
+ * This method is invoked whenever the value in an entry is
+ * overwritten by an invocation of put(k,v) for a key k that's already
+ * in the HashMap.
+ */
+ void recordAccess(HashMap m) {
+ }
- /**
- * This method is invoked whenever the entry is
- * removed from the table.
- */
- void recordRemoval(HashMap m) {
- }
+ /**
+ * This method is invoked whenever the entry is
+ * removed from the table.
+ */
+ void recordRemoval(HashMap m) {
+ }
}
```
-### 2. 拉链法的工作原理
+### 2. 拉链法的工作原理
```java
-HashMap map = new HashMap<>();
-map.put("K1", "V1");
-map.put("K2", "V2");
-map.put("K3", "V3");
+HashMap map = new HashMap<>();
+map.put("K1", "V1");
+map.put("K2", "V2");
+map.put("K3", "V3");
```
-- 新建一个 HashMap，默认大小为 16；
-- 插入 <K1,V1> 键值对，先计算 K1 的 hashCode 为 115，使用除留余数法得到所在的桶下标 115%16=3。
-- 插入 <K2,V2> 键值对，先计算 K2 的 hashCode 为 118，使用除留余数法得到所在的桶下标 118%16=6。
-- 插入 <K3,V3> 键值对，先计算 K3 的 hashCode 为 118，使用除留余数法得到所在的桶下标 118%16=6，插在 <K2,V2> 前面。
+- 新建一个 HashMap，默认大小为 16；
+- 插入 <K1,V1> 键值对，先计算 K1 的 hashCode 为 115，使用除留余数法得到所在的桶下标 115%16=3。
+- 插入 <K2,V2> 键值对，先计算 K2 的 hashCode 为 118，使用除留余数法得到所在的桶下标 118%16=6。
+- 插入 <K3,V3> 键值对，先计算 K3 的 hashCode 为 118，使用除留余数法得到所在的桶下标 118%16=6，插在 <K2,V2> 前面。
-应该注意到链表的插入是以头插法方式进行的，例如上面的 <K3,V3> 不是插在 <K2,V2> 后面，而是插入在链表头部。
+应该注意到链表的插入是以头插法方式进行的，例如上面的 <K3,V3> 不是插在 <K2,V2> 后面，而是插入在链表头部。
查找需要分成两步进行：
-- 计算键值对所在的桶；
-- 在链表上顺序查找，时间复杂度显然和链表的长度成正比。
+- 计算键值对所在的桶；
+- 在链表上顺序查找，时间复杂度显然和链表的长度成正比。
- e = table[i]; e != null; e = e.next) {
- Object k;
- if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
- V oldValue = e.value;
- e.value = value;
- e.recordAccess(this);
- return oldValue;
- }
- }
+public V put(K key, V value) {
+ if (table == EMPTY_TABLE) {
+ inflateTable(threshold);
+ }
+ // 键为 null 单独处理
+ if (key == null)
+ return putForNullKey(value);
+ int hash = hash(key);
+ // 确定桶下标
+ int i = indexFor(hash, table.length);
+ // 先找出是否已经存在键为 key 的键值对，如果存在的话就更新这个键值对的值为 value
+ for (Entry e = table[i]; e != null; e = e.next) {
+ Object k;
+ if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
+ V oldValue = e.value;
+ e.value = value;
+ e.recordAccess(this);
+ return oldValue;
+ }
+ }
- modCount++;
- // 插入新键值对
- addEntry(hash, key, value, i);
- return null;
+ modCount++;
+ // 插入新键值对
+ addEntry(hash, key, value, i);
+ return null;
}
```
-HashMap 允许插入键位 null 的键值对，因为无法调用 null 的 hashCode()，也就无法确定该键值对的桶下标，只能通过强制指定一个桶下标来存放。HashMap 使用第 0 个桶存放键为 null 的键值对。
+HashMap 允许插入键位 null 的键值对，因为无法调用 null 的 hashCode()，也就无法确定该键值对的桶下标，只能通过强制指定一个桶下标来存放。HashMap 使用第 0 个桶存放键为 null 的键值对。
```java
-private V putForNullKey(V value) {
- for (Entry e = table[0]; e != null; e = e.next) {
- if (e.key == null) {
- V oldValue = e.value;
- e.value = value;
- e.recordAccess(this);
- return oldValue;
- }
- }
- modCount++;
- addEntry(0, null, value, 0);
- return null;
+private V putForNullKey(V value) {
+ for (Entry e = table[0]; e != null; e = e.next) {
+ if (e.key == null) {
+ V oldValue = e.value;
+ e.value = value;
+ e.recordAccess(this);
+ return oldValue;
+ }
+ }
+ modCount++;
+ addEntry(0, null, value, 0);
+ return null;
}
```
使用链表的头插法，也就是新的键值对插在链表的头部，而不是链表的尾部。
```java
-void addEntry(int hash, K key, V value, int bucketIndex) {
- if ((size >= threshold) && (null != table[bucketIndex])) {
- resize(2 * table.length);
- hash = (null != key) ? hash(key) : 0;
- bucketIndex = indexFor(hash, table.length);
- }
+void addEntry(int hash, K key, V value, int bucketIndex) {
+ if ((size >= threshold) && (null != table[bucketIndex])) {
+ resize(2 * table.length);
+ hash = (null != key) ? hash(key) : 0;
+ bucketIndex = indexFor(hash, table.length);
+ }
- createEntry(hash, key, value, bucketIndex);
+ createEntry(hash, key, value, bucketIndex);
}
-void createEntry(int hash, K key, V value, int bucketIndex) {
- Entry e = table[bucketIndex];
- // 头插法，链表头部指向新的键值对
- table[bucketIndex] = new Entry<>(hash, key, value, e);
- size++;
+void createEntry(int hash, K key, V value, int bucketIndex) {
+ Entry e = table[bucketIndex];
+ // 头插法，链表头部指向新的键值对
+ table[bucketIndex] = new Entry<>(hash, key, value, e);
+ size++;
}
```
```java
-Entry(int h, K k, V v, Entry n) {
- value = v;
- next = n;
- key = k;
- hash = h;
+Entry(int h, K k, V v, Entry n) {
+ value = v;
+ next = n;
+ key = k;
+ hash = h;
}
```
-### 4. 确定桶下标
+### 4. 确定桶下标
很多操作都需要先确定一个键值对所在的桶下标。
```java
-int hash = hash(key);
-int i = indexFor(hash, table.length);
+int hash = hash(key);
+int i = indexFor(hash, table.length);
```
-（一）计算 hash 值
+（一）计算 hash 值
```java
-final int hash(Object k) {
- int h = hashSeed;
- if (0 != h && k instanceof String) {
- return sun.misc.Hashing.stringHash32((String) k);
- }
+final int hash(Object k) {
+ int h = hashSeed;
+ if (0 != h && k instanceof String) {
+ return sun.misc.Hashing.stringHash32((String) k);
+ }
- h ^= k.hashCode();
+ h ^= k.hashCode();
- // This function ensures that hashCodes that differ only by
- // constant multiples at each bit position have a bounded
- // number of collisions (approximately 8 at default load factor).
- h ^= (h >>> 20) ^ (h >>> 12);
- return h ^ (h >>> 7) ^ (h >>> 4);
+ // This function ensures that hashCodes that differ only by
+ // constant multiples at each bit position have a bounded
+ // number of collisions (approximately 8 at default load factor).
+ h ^= (h >>> 20) ^ (h >>> 12);
+ return h ^ (h >>> 7) ^ (h >>> 4);
}
```
```java
-public final int hashCode() {
- return Objects.hashCode(key) ^ Objects.hashCode(value);
+public final int hashCode() {
+ return Objects.hashCode(key) ^ Objects.hashCode(value);
}
```
（二）取模
-令 x = 1<<4，即 x 为 2 的 4 次方，它具有以下性质：
+令 x = 1<<4，即 x 为 2 的 4 次方，它具有以下性质：
```
-x : 00010000
-x-1 : 00001111
+x : 00010000
+x-1 : 00001111
```
-令一个数 y 与 x-1 做与运算，可以去除 y 位级表示的第 4 位以上数：
+令一个数 y 与 x-1 做与运算，可以去除 y 位级表示的第 4 位以上数：
```
-y : 10110010
-x-1 : 00001111
-y&(x-1) : 00000010
+y : 10110010
+x-1 : 00001111
+y&(x-1) : 00000010
```
-这个性质和 y 对 x 取模效果是一样的：
+这个性质和 y 对 x 取模效果是一样的：
```
-x : 00010000
-y : 10110010
-y%x : 00000010
+x : 00010000
+y : 10110010
+y%x : 00000010
```
我们知道，位运算的代价比求模运算小的多，因此在进行这种计算时能用位运算的话能带来更高的性能。
-确定桶下标的最后一步是将 key 的 hash 值对桶个数取模：hash%capacity，如果能保证 capacity 为 2 的幂次方，那么就可以将这个操作转换为位运算。
+确定桶下标的最后一步是将 key 的 hash 值对桶个数取模：hash%capacity，如果能保证 capacity 为 2 的幂次方，那么就可以将这个操作转换为位运算。
```java
-static int indexFor(int h, int length) {
- return h & (length-1);
+static int indexFor(int h, int length) {
+ return h & (length-1);
}
```
-### 5. 扩容-基本原理
+### 5. 扩容-基本原理
-设 HashMap 的 table 长度为 M，需要存储的键值对数量为 N，如果哈希函数满足均匀性的要求，那么每条链表的长度大约为 N/M，因此平均查找次数的复杂度为 O(N/M)。
+设 HashMap 的 table 长度为 M，需要存储的键值对数量为 N，如果哈希函数满足均匀性的要求，那么每条链表的长度大约为 N/M，因此平均查找次数的复杂度为 O(N/M)。
-为了让查找的成本降低，应该尽可能使得 N/M 尽可能小，因此需要保证 M 尽可能大，也就是说 table 要尽可能大。HashMap 采用动态扩容来根据当前的 N 值来调整 M 值，使得空间效率和时间效率都能得到保证。
+为了让查找的成本降低，应该尽可能使得 N/M 尽可能小，因此需要保证 M 尽可能大，也就是说 table 要尽可能大。HashMap 采用动态扩容来根据当前的 N 值来调整 M 值，使得空间效率和时间效率都能得到保证。
-和扩容相关的参数主要有：capacity、size、threshold 和 load_factor。
+和扩容相关的参数主要有：capacity、size、threshold 和 load_factor。
-| 参数 | 含义 |
-| :--: | :-- |
-| capacity | table 的容量大小，默认为 16，需要注意的是 capacity 必须保证为 2 的次方。|
-| size | table 的实际使用量。 |
-| threshold | size 的临界值，size 必须小于 threshold，如果大于等于，就必须进行扩容操作。 |
-| load_factor | table 能够使用的比例，threshold = capacity * load_factor。|
+| 参数 | 含义 |
+| :--: | :-- |
+| capacity | table 的容量大小，默认为 16，需要注意的是 capacity 必须保证为 2 的次方。|
+| size | table 的实际使用量。 |
+| threshold | size 的临界值，size 必须小于 threshold，如果大于等于，就必须进行扩容操作。 |
+| load_factor | table 能够使用的比例，threshold = capacity * load_factor。|
```java
-static final int DEFAULT_INITIAL_CAPACITY = 16;
+static final int DEFAULT_INITIAL_CAPACITY = 16;
-static final int MAXIMUM_CAPACITY = 1 << 30;
+static final int MAXIMUM_CAPACITY = 1 << 30;
-static final float DEFAULT_LOAD_FACTOR = 0.75f;
+static final float DEFAULT_LOAD_FACTOR = 0.75f;
-transient Entry[] table;
+transient Entry[] table;
-transient int size;
+transient int size;
-int threshold;
+int threshold;
-final float loadFactor;
+final float loadFactor;
-transient int modCount;
+transient int modCount;
```
-从下面的添加元素代码中可以看出，当需要扩容时，令 capacity 为原来的两倍。
+从下面的添加元素代码中可以看出，当需要扩容时，令 capacity 为原来的两倍。
```java
-void addEntry(int hash, K key, V value, int bucketIndex) {
- Entry e = table[bucketIndex];
- table[bucketIndex] = new Entry<>(hash, key, value, e);
- if (size++ >= threshold)
- resize(2 * table.length);
+void addEntry(int hash, K key, V value, int bucketIndex) {
+ Entry e = table[bucketIndex];
+ table[bucketIndex] = new Entry<>(hash, key, value, e);
+ if (size++ >= threshold)
+ resize(2 * table.length);
}
```
-扩容使用 resize() 实现，需要注意的是，扩容操作同样需要把旧 table 的所有键值对重新插入新的 table 中，因此这一步是很费时的。
+扩容使用 resize() 实现，需要注意的是，扩容操作同样需要把旧 table 的所有键值对重新插入新的 table 中，因此这一步是很费时的。
```java
-void resize(int newCapacity) {
- Entry[] oldTable = table;
- int oldCapacity = oldTable.length;
- if (oldCapacity == MAXIMUM_CAPACITY) {
- threshold = Integer.MAX_VALUE;
- return;
- }
+void resize(int newCapacity) {
+ Entry[] oldTable = table;
+ int oldCapacity = oldTable.length;
+ if (oldCapacity == MAXIMUM_CAPACITY) {
+ threshold = Integer.MAX_VALUE;
+ return;
+ }
- Entry[] newTable = new Entry[newCapacity];
- transfer(newTable);
- table = newTable;
- threshold = (int)(newCapacity * loadFactor);
+ Entry[] newTable = new Entry[newCapacity];
+ transfer(newTable);
+ table = newTable;
+ threshold = (int)(newCapacity * loadFactor);
}
-void transfer(Entry[] newTable) {
- Entry[] src = table;
- int newCapacity = newTable.length;
- for (int j = 0; j < src.length; j++) {
- Entry e = src[j];
- if (e != null) {
- src[j] = null;
- do {
- Entry next = e.next;
- int i = indexFor(e.hash, newCapacity);
- e.next = newTable[i];
- newTable[i] = e;
- e = next;
- } while (e != null);
- }
- }
+void transfer(Entry[] newTable) {
+ Entry[] src = table;
+ int newCapacity = newTable.length;
+ for (int j = 0; j < src.length; j++) {
+ Entry e = src[j];
+ if (e != null) {
+ src[j] = null;
+ do {
+ Entry next = e.next;
+ int i = indexFor(e.hash, newCapacity);
+ e.next = newTable[i];
+ newTable[i] = e;
+ e = next;
+ } while (e != null);
+ }
+ }
}
```
-### 6. 扩容-重新计算桶下标
+### 6. 扩容-重新计算桶下标
-在进行扩容时，需要把键值对重新放到对应的桶上。HashMap 使用了一个特殊的机制，可以降低重新计算桶下标的操作。
+在进行扩容时，需要把键值对重新放到对应的桶上。HashMap 使用了一个特殊的机制，可以降低重新计算桶下标的操作。
-假设原数组长度 capacity 为 8，扩容之后 new capacity 为 16：
+假设原数组长度 capacity 为 8，扩容之后 new capacity 为 16：
```html
-capacity : 00010000
-new capacity : 00100000
+capacity : 00010000
+new capacity : 00100000
```
-对于一个 Key，它的 hash 如果在第 6 位上为 0，那么取模得到的结果和之前一样；如果为 1，那么得到的结果为原来的结果 + 8。
+对于一个 Key，它的 hash 如果在第 6 位上为 0，那么取模得到的结果和之前一样；如果为 1，那么得到的结果为原来的结果 + 8。
-### 7. 扩容-计算数组容量
+### 7. 扩容-计算数组容量
-HashMap 构造函数允许用户传入的容量不是 2 的幂次方，因为它可以自动地将传入的容量转换为 2 的幂次方。
+HashMap 构造函数允许用户传入的容量不是 2 的幂次方，因为它可以自动地将传入的容量转换为 2 的幂次方。
-先考虑如何求一个数的掩码，对于 10010000，它的掩码为 11111111，可以使用以下方法得到：
+先考虑如何求一个数的掩码，对于 10010000，它的掩码为 11111111，可以使用以下方法得到：
```
-mask |= mask >> 1 11011000
-mask |= mask >> 2 11111100
-mask |= mask >> 4 11111111
+mask |= mask >> 1 11011000
+mask |= mask >> 2 11111100
+mask |= mask >> 4 11111111
```
-mask+1 是大于原始数字的最小的 2 幂次方。
+mask+1 是大于原始数字的最小的 2 幂次方。
```
-num 10010000
-mask+1 100000000
+num 10010000
+mask+1 100000000
```
-以下是 HashMap 中计算数组容量的代码：
+以下是 HashMap 中计算数组容量的代码：
```java
-static final int tableSizeFor(int cap) {
- int n = cap - 1;
- n |= n >>> 1;
- n |= n >>> 2;
- n |= n >>> 4;
- n |= n >>> 8;
- n |= n >>> 16;
- return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
+static final int tableSizeFor(int cap) {
+ int n = cap - 1;
+ n |= n >>> 1;
+ n |= n >>> 2;
+ n |= n >>> 4;
+ n |= n >>> 8;
+ n |= n >>> 16;
+ return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
}
```
-### 8. 链表转红黑树
+### 8. 链表转红黑树
-应该注意到，从 JDK 1.8 开始，一个桶存储的链表长度大于 8 时会将链表转换为红黑树。
+应该注意到，从 JDK 1.8 开始，一个桶存储的链表长度大于 8 时会将链表转换为红黑树。
-### 9. HashMap 与 HashTable
+### 9. HashMap 与 HashTable
-- HashTable 是同步的，它使用了 synchronized 来进行同步。它也是线程安全的，多个线程可以共享同一个 HashTable。HashMap 不是同步的，但是可以使用 ConcurrentHashMap，它是 HashTable 的替代，而且比 HashTable 可扩展性更好。
-- HashMap 可以插入键为 null 的 Entry。
-- HashMap 的迭代器是 fail-fast 迭代器，而 Hashtable 的 enumerator 迭代器不是 fail-fast 的。
-- 由于 Hashtable 是线程安全的也是 synchronized，所以在单线程环境下它比 HashMap 要慢。
-- HashMap 不能保证随着时间的推移 Map 中的元素次序是不变的。
+- HashTable 是同步的，它使用了 synchronized 来进行同步。它也是线程安全的，多个线程可以共享同一个 HashTable。HashMap 不是同步的，但是可以使用 ConcurrentHashMap，它是 HashTable 的替代，而且比 HashTable 可扩展性更好。
+- HashMap 可以插入键为 null 的 Entry。
+- HashMap 的迭代器是 fail-fast 迭代器，而 Hashtable 的 enumerator 迭代器不是 fail-fast 的。
+- 由于 Hashtable 是线程安全的也是 synchronized，所以在单线程环境下它比 HashMap 要慢。
+- HashMap 不能保证随着时间的推移 Map 中的元素次序是不变的。
-## ConcurrentHashMap
+## ConcurrentHashMap
[ConcurrentHashMap.java](https://github.com/CyC2018/JDK-Source-Code/blob/master/src/1.7/ConcurrentHashMap.java)
-### 1. 存储结构
+### 1. 存储结构
```java
-static final class HashEntry {
- final int hash;
- final K key;
- volatile V value;
- volatile HashEntry next;
+static final class HashEntry {
+ final int hash;
+ final K key;
+ volatile V value;
+ volatile HashEntry next;
}
```
-Segment 继承自 ReentrantLock，每个 Segment 维护着多个 HashEntry。
+Segment 继承自 ReentrantLock，每个 Segment 维护着多个 HashEntry。
-ConcurrentHashMap 和 HashMap 实现上类似，最主要的差别是 ConcurrentHashMap 采用了分段锁，每个分段锁维护着几个桶，多个线程可以同时访问不同分段锁上的桶，从而使其并发度更高（并发度就是 Segment 的个数）。
+ConcurrentHashMap 和 HashMap 实现上类似，最主要的差别是 ConcurrentHashMap 采用了分段锁，每个分段锁维护着几个桶，多个线程可以同时访问不同分段锁上的桶，从而使其并发度更高（并发度就是 Segment 的个数）。
```java
-static final class Segment extends ReentrantLock implements Serializable {
+static final class Segment extends ReentrantLock implements Serializable {
- private static final long serialVersionUID = 2249069246763182397L;
+ private static final long serialVersionUID = 2249069246763182397L;
- static final int MAX_SCAN_RETRIES =
- Runtime.getRuntime().availableProcessors() > 1 ? 64 : 1;
+ static final int MAX_SCAN_RETRIES =
+ Runtime.getRuntime().availableProcessors() > 1 ? 64 : 1;
- transient volatile HashEntry[] table;
+ transient volatile HashEntry[] table;
- transient int count;
+ transient int count;
- transient int modCount;
+ transient int modCount;
- transient int threshold;
+ transient int threshold;
- final float loadFactor;
+ final float loadFactor;
}
```
```java
-final Segment[] segments;
+final Segment[] segments;
```
-默认的并发级别为 16，也就是说默认创建 16 个 Segment。
+默认的并发级别为 16，也就是说默认创建 16 个 Segment。
```java
-static final int DEFAULT_CONCURRENCY_LEVEL = 16;
+static final int DEFAULT_CONCURRENCY_LEVEL = 16;
```
- [] segments = this.segments;
- int size;
- boolean overflow; // true if size overflows 32 bits
- long sum; // sum of modCounts
- long last = 0L; // previous sum
- int retries = -1; // first iteration isn't retry
- try {
- for (;;) {
- // 超过尝试次数，则对每个 Segment 加锁
- if (retries++ == RETRIES_BEFORE_LOCK) {
- for (int j = 0; j < segments.length; ++j)
- ensureSegment(j).lock(); // force creation
- }
- sum = 0L;
- size = 0;
- overflow = false;
- for (int j = 0; j < segments.length; ++j) {
- Segment seg = segmentAt(segments, j);
- if (seg != null) {
- sum += seg.modCount;
- int c = seg.count;
- if (c < 0 || (size += c) < 0)
- overflow = true;
- }
- }
- // 连续两次得到的结果一致，则认为这个结果是正确的
- if (sum == last)
- break;
- last = sum;
- }
- } finally {
- if (retries > RETRIES_BEFORE_LOCK) {
- for (int j = 0; j < segments.length; ++j)
- segmentAt(segments, j).unlock();
- }
- }
- return overflow ? Integer.MAX_VALUE : size;
+public int size() {
+ // Try a few times to get accurate count. On failure due to
+ // continuous async changes in table, resort to locking.
+ final Segment[] segments = this.segments;
+ int size;
+ boolean overflow; // true if size overflows 32 bits
+ long sum; // sum of modCounts
+ long last = 0L; // previous sum
+ int retries = -1; // first iteration isn't retry
+ try {
+ for (;;) {
+ // 超过尝试次数，则对每个 Segment 加锁
+ if (retries++ == RETRIES_BEFORE_LOCK) {
+ for (int j = 0; j < segments.length; ++j)
+ ensureSegment(j).lock(); // force creation
+ }
+ sum = 0L;
+ size = 0;
+ overflow = false;
+ for (int j = 0; j < segments.length; ++j) {
+ Segment seg = segmentAt(segments, j);
+ if (seg != null) {
+ sum += seg.modCount;
+ int c = seg.count;
+ if (c < 0 || (size += c) < 0)
+ overflow = true;
+ }
+ }
+ // 连续两次得到的结果一致，则认为这个结果是正确的
+ if (sum == last)
+ break;
+ last = sum;
+ }
+ } finally {
+ if (retries > RETRIES_BEFORE_LOCK) {
+ for (int j = 0; j < segments.length; ++j)
+ segmentAt(segments, j).unlock();
+ }
+ }
+ return overflow ? Integer.MAX_VALUE : size;
}
```
-### 3. JDK 1.8 的改动
+### 3. JDK 1.8 的改动
[ConcurrentHashMap.java](https://github.com/CyC2018/JDK-Source-Code/blob/master/src/ConcurrentHashMap.java)
-JDK 1.7 使用分段锁机制来实现并发更新操作，核心类为 Segment，它继承自重入锁 ReentrantLock，并发程度与 Segment 数量相等。
+JDK 1.7 使用分段锁机制来实现并发更新操作，核心类为 Segment，它继承自重入锁 ReentrantLock，并发程度与 Segment 数量相等。
-JDK 1.8 使用了 CAS 操作来支持更高的并发度，在 CAS 操作失败时使用内置锁 synchronized。
+JDK 1.8 使用了 CAS 操作来支持更高的并发度，在 CAS 操作失败时使用内置锁 synchronized。
-并且 JDK 1.8 的实现也在链表过长时会转换为红黑树。
+并且 JDK 1.8 的实现也在链表过长时会转换为红黑树。
-## LinkedHashMap
+## LinkedHashMap
[LinkedHashMap.java](https://github.com/CyC2018/JDK-Source-Code/tree/master/src/HashMap.java)
-## TreeMap
+## TreeMap
[TreeMap.java](https://github.com/CyC2018/JDK-Source-Code/tree/master/src/TreeMap.java)
-# 参考资料
+# 参考资料
-- Eckel B. Java 编程思想 [M]. 机械工业出版社, 2002.
-- [Java Collection Framework](https://www.w3resource.com/java-tutorial/java-collections.php)
-- [Iterator 模式](https://openhome.cc/Gossip/DesignPattern/IteratorPattern.htm)
-- [Java 8 系列之重新认识 HashMap](https://tech.meituan.com/java-hashmap.html)
-- [What is difference between HashMap and Hashtable in Java?](http://javarevisited.blogspot.hk/2010/10/difference-between-hashmap-and.html)
-- [Java 集合之 HashMap](http://www.zhangchangle.com/2018/02/07/Java%E9%9B%86%E5%90%88%E4%B9%8BHashMap/)
-- [The principle of ConcurrentHashMap analysis](http://www.programering.com/a/MDO3QDNwATM.html)
-- [探索 ConcurrentHashMap 高并发性的实现机制](https://www.ibm.com/developerworks/cn/java/java-lo-concurrenthashmap/)
-- [HashMap 相关面试题及其解答](https://www.jianshu.com/p/75adf47958a7)
-- [Java 集合细节（二）：asList 的缺陷](http://wiki.jikexueyuan.com/project/java-enhancement/java-thirtysix.html)
-- [Java Collection Framework – The LinkedList Class](http://javaconceptoftheday.com/java-collection-framework-linkedlist-class/)
+- Eckel B. Java 编程思想 [M]. 机械工业出版社, 2002.
+- [Java Collection Framework](https://www.w3resource.com/java-tutorial/java-collections.php)
+- [Iterator 模式](https://openhome.cc/Gossip/DesignPattern/IteratorPattern.htm)
+- [Java 8 系列之重新认识 HashMap](https://tech.meituan.com/java-hashmap.html)
+- [What is difference between HashMap and Hashtable in Java?](http://javarevisited.blogspot.hk/2010/10/difference-between-hashmap-and.html)
+- [Java 集合之 HashMap](http://www.zhangchangle.com/2018/02/07/Java%E9%9B%86%E5%90%88%E4%B9%8BHashMap/)
+- [The principle of ConcurrentHashMap analysis](http://www.programering.com/a/MDO3QDNwATM.html)
+- [探索 ConcurrentHashMap 高并发性的实现机制](https://www.ibm.com/developerworks/cn/java/java-lo-concurrenthashmap/)
+- [HashMap 相关面试题及其解答](https://www.jianshu.com/p/75adf47958a7)
+- [Java 集合细节（二）：asList 的缺陷](http://wiki.jikexueyuan.com/project/java-enhancement/java-thirtysix.html)
+- [Java Collection Framework – The LinkedList Class](http://javaconceptoftheday.com/java-collection-framework-linkedlist-class/)
+---bottom---CyC---
+
+
+
+
+
+
+
+
+
+
diff --git a/notes/Java 并发.md b/notes/Java 并发.md
index 8a2c8fcf..00fdc0a9 100644
--- a/notes/Java 并发.md
+++ b/notes/Java 并发.md
@@ -1,618 +1,559 @@
-
-* [一、线程状态转换](#一线程状态转换)
- * [新建（New）](#新建new)
- * [可运行（Runnable）](#可运行runnable)
- * [阻塞（Blocking）](#阻塞blocking)
- * [无限期等待（Waiting）](#无限期等待waiting)
- * [限期等待（Timed Waiting）](#限期等待timed-waiting)
- * [死亡（Terminated）](#死亡terminated)
-* [二、使用线程](#二使用线程)
- * [实现 Runnable 接口](#实现-runnable-接口)
- * [实现 Callable 接口](#实现-callable-接口)
- * [继承 Thread 类](#继承-thread-类)
- * [实现接口 VS 继承 Thread](#实现接口-vs-继承-thread)
-* [三、基础线程机制](#三基础线程机制)
- * [Executor](#executor)
- * [Daemon](#daemon)
- * [sleep()](#sleep)
- * [yield()](#yield)
-* [四、中断](#四中断)
- * [InterruptedException](#interruptedexception)
- * [interrupted()](#interrupted)
- * [Executor 的中断操作](#executor-的中断操作)
-* [五、互斥同步](#五互斥同步)
- * [synchronized](#synchronized)
- * [ReentrantLock](#reentrantlock)
- * [synchronized 和 ReentrantLock 比较](#synchronized-和-reentrantlock-比较)
-* [六、线程之间的协作](#六线程之间的协作)
- * [join()](#join)
- * [wait() notify() notifyAll()](#wait-notify-notifyall)
- * [await() signal() signalAll()](#await-signal-signalall)
-* [七、J.U.C - AQS](#七juc---aqs)
- * [CountdownLatch](#countdownlatch)
- * [CyclicBarrier](#cyclicbarrier)
- * [Semaphore](#semaphore)
-* [八、J.U.C - 其它组件](#八juc---其它组件)
- * [FutureTask](#futuretask)
- * [BlockingQueue](#blockingqueue)
- * [ForkJoin](#forkjoin)
-* [九、线程不安全示例](#九线程不安全示例)
-* [十、Java 内存模型](#十java-内存模型)
- * [主内存与工作内存](#主内存与工作内存)
- * [内存间交互操作](#内存间交互操作)
- * [内存模型三大特性](#内存模型三大特性)
- * [先行发生原则](#先行发生原则)
-* [十一、线程安全](#十一线程安全)
- * [线程安全定义](#线程安全定义)
- * [线程安全分类](#线程安全分类)
- * [线程安全的实现方法](#线程安全的实现方法)
-* [十二、锁优化](#十二锁优化)
- * [自旋锁](#自旋锁)
- * [锁消除](#锁消除)
- * [锁粗化](#锁粗化)
- * [轻量级锁](#轻量级锁)
- * [偏向锁](#偏向锁)
-* [十三、多线程开发良好的实践](#十三多线程开发良好的实践)
-* [参考资料](#参考资料)
-
+# 一、线程状态转换
+ {
- public Integer call() {
- return 123;
- }
+public class MyCallable implements Callable {
+ public Integer call() {
+ return 123;
+ }
}
```
```java
-public static void main(String[] args) throws ExecutionException, InterruptedException {
- MyCallable mc = new MyCallable();
- FutureTask ft = new FutureTask<>(mc);
- Thread thread = new Thread(ft);
- thread.start();
- System.out.println(ft.get());
+public static void main(String[] args) throws ExecutionException, InterruptedException {
+ MyCallable mc = new MyCallable();
+ FutureTask ft = new FutureTask<>(mc);
+ Thread thread = new Thread(ft);
+ thread.start();
+ System.out.println(ft.get());
}
```
-## 继承 Thread 类
+## 继承 Thread 类
-同样也是需要实现 run() 方法，并且最后也是调用 start() 方法来启动线程。
+同样也是需要实现 run() 方法，并且最后也是调用 start() 方法来启动线程。
```java
-public class MyThread extends Thread {
- public void run() {
- // ...
- }
+public class MyThread extends Thread {
+ public void run() {
+ // ...
+ }
}
```
```java
-public static void main(String[] args) {
- MyThread mt = new MyThread();
- mt.start();
+public static void main(String[] args) {
+ MyThread mt = new MyThread();
+ mt.start();
}
```
-## 实现接口 VS 继承 Thread
+## 实现接口 VS 继承 Thread
实现接口会更好一些，因为：
-- Java 不支持多重继承，因此继承了 Thread 类就无法继承其它类，但是可以实现多个接口；
-- 类可能只要求可执行就行，继承整个 Thread 类开销过大。
+- Java 不支持多重继承，因此继承了 Thread 类就无法继承其它类，但是可以实现多个接口；
+- 类可能只要求可执行就行，继承整个 Thread 类开销过大。
-# 三、基础线程机制
+# 三、基础线程机制
-## Executor
+## Executor
-Executor 管理多个异步任务的执行，而无需程序员显式地管理线程的生命周期。
+Executor 管理多个异步任务的执行，而无需程序员显式地管理线程的生命周期。
-主要有三种 Executor：
+主要有三种 Executor：
-- CachedThreadPool：一个任务创建一个线程；
-- FixedThreadPool：所有任务只能使用固定大小的线程；
-- SingleThreadExecutor：相当于大小为 1 的 FixedThreadPool。
+- CachedThreadPool：一个任务创建一个线程；
+- FixedThreadPool：所有任务只能使用固定大小的线程；
+- SingleThreadExecutor：相当于大小为 1 的 FixedThreadPool。
```java
-public static void main(String[] args) {
- ExecutorService executorService = Executors.newCachedThreadPool();
- for (int i = 0; i < 5; i++) {
- executorService.execute(new MyRunnable());
- }
- executorService.shutdown();
+public static void main(String[] args) {
+ ExecutorService executorService = Executors.newCachedThreadPool();
+ for (int i = 0; i < 5; i++) {
+ executorService.execute(new MyRunnable());
+ }
+ executorService.shutdown();
}
```
-## Daemon
+## Daemon
守护线程是程序运行时在后台提供服务的线程，不属于程序中不可或缺的部分。
当所有非守护线程结束时，程序也就终止，同时会杀死所有守护线程。
-main() 属于非守护线程。
+main() 属于非守护线程。
-使用 setDaemon() 方法将一个线程设置为守护线程。
+使用 setDaemon() 方法将一个线程设置为守护线程。
```java
-public static void main(String[] args) {
- Thread thread = new Thread(new MyRunnable());
- thread.setDaemon(true);
+public static void main(String[] args) {
+ Thread thread = new Thread(new MyRunnable());
+ thread.setDaemon(true);
}
```
-## sleep()
+## sleep()
-Thread.sleep(millisec) 方法会休眠当前正在执行的线程，millisec 单位为毫秒。
+Thread.sleep(millisec) 方法会休眠当前正在执行的线程，millisec 单位为毫秒。
-sleep() 可能会抛出 InterruptedException，因为异常不能跨线程传播回 main() 中，因此必须在本地进行处理。线程中抛出的其它异常也同样需要在本地进行处理。
+sleep() 可能会抛出 InterruptedException，因为异常不能跨线程传播回 main() 中，因此必须在本地进行处理。线程中抛出的其它异常也同样需要在本地进行处理。
```java
-public void run() {
- try {
- Thread.sleep(3000);
- } catch (InterruptedException e) {
- e.printStackTrace();
- }
+public void run() {
+ try {
+ Thread.sleep(3000);
+ } catch (InterruptedException e) {
+ e.printStackTrace();
+ }
}
```
-## yield()
+## yield()
-对静态方法 Thread.yield() 的调用声明了当前线程已经完成了生命周期中最重要的部分，可以切换给其它线程来执行。该方法只是对线程调度器的一个建议，而且也只是建议具有相同优先级的其它线程可以运行。
+对静态方法 Thread.yield() 的调用声明了当前线程已经完成了生命周期中最重要的部分，可以切换给其它线程来执行。该方法只是对线程调度器的一个建议，而且也只是建议具有相同优先级的其它线程可以运行。
```java
-public void run() {
- Thread.yield();
+public void run() {
+ Thread.yield();
}
```
-# 四、中断
+# 四、中断
一个线程执行完毕之后会自动结束，如果在运行过程中发生异常也会提前结束。
-## InterruptedException
+## InterruptedException
-通过调用一个线程的 interrupt() 来中断该线程，如果该线程处于阻塞、限期等待或者无限期等待状态，那么就会抛出 InterruptedException，从而提前结束该线程。但是不能中断 I/O 阻塞和 synchronized 锁阻塞。
+通过调用一个线程的 interrupt() 来中断该线程，如果该线程处于阻塞、限期等待或者无限期等待状态，那么就会抛出 InterruptedException，从而提前结束该线程。但是不能中断 I/O 阻塞和 synchronized 锁阻塞。
-对于以下代码，在 main() 中启动一个线程之后再中断它，由于线程中调用了 Thread.sleep() 方法，因此会抛出一个 InterruptedException，从而提前结束线程，不执行之后的语句。
+对于以下代码，在 main() 中启动一个线程之后再中断它，由于线程中调用了 Thread.sleep() 方法，因此会抛出一个 InterruptedException，从而提前结束线程，不执行之后的语句。
```java
-public class InterruptExample {
+public class InterruptExample {
- private static class MyThread1 extends Thread {
- @Override
- public void run() {
- try {
- Thread.sleep(2000);
- System.out.println("Thread run");
- } catch (InterruptedException e) {
- e.printStackTrace();
- }
- }
- }
+ private static class MyThread1 extends Thread {
+ @Override
+ public void run() {
+ try {
+ Thread.sleep(2000);
+ System.out.println("Thread run");
+ } catch (InterruptedException e) {
+ e.printStackTrace();
+ }
+ }
+ }
}
```
```java
-public static void main(String[] args) throws InterruptedException {
- Thread thread1 = new MyThread1();
- thread1.start();
- thread1.interrupt();
- System.out.println("Main run");
+public static void main(String[] args) throws InterruptedException {
+ Thread thread1 = new MyThread1();
+ thread1.start();
+ thread1.interrupt();
+ System.out.println("Main run");
}
```
```html
-Main run
-java.lang.InterruptedException: sleep interrupted
- at java.lang.Thread.sleep(Native Method)
- at InterruptExample.lambda$main$0(InterruptExample.java:5)
- at InterruptExample$$Lambda$1/713338599.run(Unknown Source)
- at java.lang.Thread.run(Thread.java:745)
+Main run
+java.lang.InterruptedException: sleep interrupted
+ at java.lang.Thread.sleep(Native Method)
+ at InterruptExample.lambda$main$0(InterruptExample.java:5)
+ at InterruptExample$$Lambda$1/713338599.run(Unknown Source)
+ at java.lang.Thread.run(Thread.java:745)
```
-## interrupted()
+## interrupted()
-如果一个线程的 run() 方法执行一个无限循环，并且没有执行 sleep() 等会抛出 InterruptedException 的操作，那么调用线程的 interrupt() 方法就无法使线程提前结束。
+如果一个线程的 run() 方法执行一个无限循环，并且没有执行 sleep() 等会抛出 InterruptedException 的操作，那么调用线程的 interrupt() 方法就无法使线程提前结束。
-但是调用 interrupt() 方法会设置线程的中断标记，此时调用 interrupted() 方法会返回 true。因此可以在循环体中使用 interrupted() 方法来判断线程是否处于中断状态，从而提前结束线程。
+但是调用 interrupt() 方法会设置线程的中断标记，此时调用 interrupted() 方法会返回 true。因此可以在循环体中使用 interrupted() 方法来判断线程是否处于中断状态，从而提前结束线程。
```java
-public class InterruptExample {
+public class InterruptExample {
- private static class MyThread2 extends Thread {
- @Override
- public void run() {
- while (!interrupted()) {
- // ..
- }
- System.out.println("Thread end");
- }
- }
+ private static class MyThread2 extends Thread {
+ @Override
+ public void run() {
+ while (!interrupted()) {
+ // ..
+ }
+ System.out.println("Thread end");
+ }
+ }
}
```
```java
-public static void main(String[] args) throws InterruptedException {
- Thread thread2 = new MyThread2();
- thread2.start();
- thread2.interrupt();
+public static void main(String[] args) throws InterruptedException {
+ Thread thread2 = new MyThread2();
+ thread2.start();
+ thread2.interrupt();
}
```
```html
-Thread end
+Thread end
```
-## Executor 的中断操作
+## Executor 的中断操作
-调用 Executor 的 shutdown() 方法会等待线程都执行完毕之后再关闭，但是如果调用的是 shutdownNow() 方法，则相当于调用每个线程的 interrupt() 方法。
+调用 Executor 的 shutdown() 方法会等待线程都执行完毕之后再关闭，但是如果调用的是 shutdownNow() 方法，则相当于调用每个线程的 interrupt() 方法。
-以下使用 Lambda 创建线程，相当于创建了一个匿名内部线程。
+以下使用 Lambda 创建线程，相当于创建了一个匿名内部线程。
```java
-public static void main(String[] args) {
- ExecutorService executorService = Executors.newCachedThreadPool();
- executorService.execute(() -> {
- try {
- Thread.sleep(2000);
- System.out.println("Thread run");
- } catch (InterruptedException e) {
- e.printStackTrace();
- }
- });
- executorService.shutdownNow();
- System.out.println("Main run");
+public static void main(String[] args) {
+ ExecutorService executorService = Executors.newCachedThreadPool();
+ executorService.execute(() -> {
+ try {
+ Thread.sleep(2000);
+ System.out.println("Thread run");
+ } catch (InterruptedException e) {
+ e.printStackTrace();
+ }
+ });
+ executorService.shutdownNow();
+ System.out.println("Main run");
}
```
```html
-Main run
-java.lang.InterruptedException: sleep interrupted
- at java.lang.Thread.sleep(Native Method)
- at ExecutorInterruptExample.lambda$main$0(ExecutorInterruptExample.java:9)
- at ExecutorInterruptExample$$Lambda$1/1160460865.run(Unknown Source)
- at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1142)
- at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:617)
- at java.lang.Thread.run(Thread.java:745)
+Main run
+java.lang.InterruptedException: sleep interrupted
+ at java.lang.Thread.sleep(Native Method)
+ at ExecutorInterruptExample.lambda$main$0(ExecutorInterruptExample.java:9)
+ at ExecutorInterruptExample$$Lambda$1/1160460865.run(Unknown Source)
+ at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1142)
+ at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:617)
+ at java.lang.Thread.run(Thread.java:745)
```
-如果只想中断 Executor 中的一个线程，可以通过使用 submit() 方法来提交一个线程，它会返回一个 Future 对象，通过调用该对象的 cancel(true) 方法就可以中断线程。
+如果只想中断 Executor 中的一个线程，可以通过使用 submit() 方法来提交一个线程，它会返回一个 Future 对象，通过调用该对象的 cancel(true) 方法就可以中断线程。
```java
-Future future = executorService.submit(() -> {
- // ..
+Future future = executorService.submit(() -> {
+ // ..
});
future.cancel(true);
```
-# 五、互斥同步
+# 五、互斥同步
-Java 提供了两种锁机制来控制多个线程对共享资源的互斥访问，第一个是 JVM 实现的 synchronized，而另一个是 JDK 实现的 ReentrantLock。
+Java 提供了两种锁机制来控制多个线程对共享资源的互斥访问，第一个是 JVM 实现的 synchronized，而另一个是 JDK 实现的 ReentrantLock。
-## synchronized
+## synchronized
-**1. 同步一个代码块**
+**1. 同步一个代码块**
```java
-public void func () {
- synchronized (this) {
- // ...
- }
+public void func () {
+ synchronized (this) {
+ // ...
+ }
}
```
它只作用于同一个对象，如果调用两个对象上的同步代码块，就不会进行同步。
-对于以下代码，使用 ExecutorService 执行了两个线程（这两个线程使用 Lambda 创建），由于调用的是同一个对象的同步代码块，因此这两个线程会进行同步，当一个线程进入同步语句块时，另一个线程就必须等待。
+对于以下代码，使用 ExecutorService 执行了两个线程（这两个线程使用 Lambda 创建），由于调用的是同一个对象的同步代码块，因此这两个线程会进行同步，当一个线程进入同步语句块时，另一个线程就必须等待。
```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
```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
```
-ReentrantLock 是 java.util.concurrent（J.U.C）包中的锁，相比于 synchronized，它多了以下高级功能：
+ReentrantLock 是 java.util.concurrent（J.U.C）包中的锁，相比于 synchronized，它多了以下高级功能：
-**1. 等待可中断**
+**1. 等待可中断**
当持有锁的线程长期不释放锁的时候，正在等待的线程可以选择放弃等待，改为处理其他事情，可中断特性对处理执行时间非常长的同步块很有帮助。
-**2. 可实现公平锁**
+**2. 可实现公平锁**
-公平锁是指多个线程在等待同一个锁时，必须按照申请锁的时间顺序来依次获得锁；而非公平锁则不保证这一点，在锁被释放时，任何一个等待锁的线程都有机会获得锁。synchronized 中的锁是非公平的，ReentrantLock 默认情况下也是非公平的，但可以通过带布尔值的构造函数要求使用公平锁。
+公平锁是指多个线程在等待同一个锁时，必须按照申请锁的时间顺序来依次获得锁；而非公平锁则不保证这一点，在锁被释放时，任何一个等待锁的线程都有机会获得锁。synchronized 中的锁是非公平的，ReentrantLock 默认情况下也是非公平的，但可以通过带布尔值的构造函数要求使用公平锁。
-**3. 锁绑定多个条件**
+**3. 锁绑定多个条件**
-一个 ReentrantLock 对象可以同时绑定多个 Condition 对象，而在 synchronized 中，锁对象的 wait() 和 notify() 或 notifyAll() 方法可以实现一个隐含的条件，如果要和多于一个的条件关联的时候，就不得不额外地添加一个锁，而 ReentrantLock 则无须这样做，只需要多次调用 newCondition() 方法即可。
+一个 ReentrantLock 对象可以同时绑定多个 Condition 对象，而在 synchronized 中，锁对象的 wait() 和 notify() 或 notifyAll() 方法可以实现一个隐含的条件，如果要和多于一个的条件关联的时候，就不得不额外地添加一个锁，而 ReentrantLock 则无须这样做，只需要多次调用 newCondition() 方法即可。
-## synchronized 和 ReentrantLock 比较
+## synchronized 和 ReentrantLock 比较
-**1. 锁的实现**
+**1. 锁的实现**
-synchronized 是 JVM 实现的，而 ReentrantLock 是 JDK 实现的。
+synchronized 是 JVM 实现的，而 ReentrantLock 是 JDK 实现的。
-**2. 性能**
+**2. 性能**
-从性能上来看，新版本 Java 对 synchronized 进行了很多优化，例如自旋锁等。目前来看它和 ReentrantLock 的性能基本持平了，因此性能因素不再是选择 ReentrantLock 的理由。synchronized 有更大的性能优化空间，应该优先考虑 synchronized。
+从性能上来看，新版本 Java 对 synchronized 进行了很多优化，例如自旋锁等。目前来看它和 ReentrantLock 的性能基本持平了，因此性能因素不再是选择 ReentrantLock 的理由。synchronized 有更大的性能优化空间，应该优先考虑 synchronized。
-**3. 功能**
+**3. 功能**
-ReentrantLock 多了一些高级功能。
+ReentrantLock 多了一些高级功能。
-**4. 使用选择**
+**4. 使用选择**
-除非需要使用 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();
}
```
@@ -621,40 +562,40 @@ A
B
```
-## wait() notify() notifyAll()
+## wait() notify() notifyAll()
-调用 wait() 使得线程等待某个条件满足，线程在等待时会被挂起，当其他线程的运行使得这个条件满足时，其它线程会调用 notify() 或者 notifyAll() 来唤醒挂起的线程。
+调用 wait() 使得线程等待某个条件满足，线程在等待时会被挂起，当其他线程的运行使得这个条件满足时，其它线程会调用 notify() 或者 notifyAll() 来唤醒挂起的线程。
-它们都属于 Object 的一部分，而不属于 Thread。
+它们都属于 Object 的一部分，而不属于 Thread。
-只能用在同步方法或者同步控制块中使用，否则会在运行时抛出 IllegalMonitorStateExeception。
+只能用在同步方法或者同步控制块中使用，否则会在运行时抛出 IllegalMonitorStateExeception。
-使用 wait() 挂起期间，线程会释放锁。这是因为，如果没有释放锁，那么其它线程就无法进入对象的同步方法或者同步控制块中，那么就无法执行 notify() 或者 notifyAll() 来唤醒挂起的线程，造成死锁。
+使用 wait() 挂起期间，线程会释放锁。这是因为，如果没有释放锁，那么其它线程就无法进入对象的同步方法或者同步控制块中，那么就无法执行 notify() 或者 notifyAll() 来唤醒挂起的线程，造成死锁。
```java
-public class WaitNotifyExample {
- public synchronized void before() {
- System.out.println("before");
- notifyAll();
- }
+public class WaitNotifyExample {
+ 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());
}
```
@@ -663,52 +604,52 @@ before
after
```
-**wait() 和 sleep() 的区别**
+**wait() 和 sleep() 的区别**
-1. wait() 是 Object 的方法，而 sleep() 是 Thread 的静态方法；
-2. wait() 会释放锁，sleep() 不会。
+1. wait() 是 Object 的方法，而 sleep() 是 Thread 的静态方法；
+2. wait() 会释放锁，sleep() 不会。
-## await() signal() signalAll()
+## await() signal() signalAll()
-java.util.concurrent 类库中提供了 Condition 类来实现线程之间的协调，可以在 Condition 上调用 await() 方法使线程等待，其它线程调用 signal() 或 signalAll() 方法唤醒等待的线程。相比于 wait() 这种等待方式，await() 可以指定等待的条件，因此更加灵活。
+java.util.concurrent 类库中提供了 Condition 类来实现线程之间的协调，可以在 Condition 上调用 await() 方法使线程等待，其它线程调用 signal() 或 signalAll() 方法唤醒等待的线程。相比于 wait() 这种等待方式，await() 可以指定等待的条件，因此更加灵活。
-使用 Lock 来获取一个 Condition 对象。
+使用 Lock 来获取一个 Condition 对象。
```java
-public class AwaitSignalExample {
- private Lock lock = new ReentrantLock();
- private Condition condition = lock.newCondition();
+public class AwaitSignalExample {
+ 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());
}
```
@@ -717,35 +658,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 的 get() 方法获取。
+当一个计算任务需要执行很长时间，那么就可以用 FutureTask 来封装这个任务，用一个线程去执行该任务，然后其它线程继续执行其它任务。当需要该任务的计算结果时，再通过 FutureTask 的 get() 方法获取。
```java
-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 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;
+ }
+ });
- 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、ArrayListBlockingQueue（固定长度）
-- **优先级队列** ：PriorityBlockingQueue
+- **FIFO 队列**：LinkedBlockingQueue、ArrayListBlockingQueue（固定长度）
+- **优先级队列**：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();
+ }
}
```
@@ -944,98 +885,98 @@ 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 {
- private final int threhold = 5;
- private int first;
- private int last;
+public class ForkJoinExample extends RecursiveTask {
+ private final int threhold = 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 <= threhold) {
- // 任务足够小则直接计算
- 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 <= threhold) {
+ // 任务足够小则直接计算
+ 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();
}
```
多线程环境下，应当尽量使对象成为不可变，来满足线程安全。
-### 2. 绝对线程安全
+### 2. 绝对线程安全
不管运行时环境如何，调用者都不需要任何额外的同步措施。
-### 3. 相对线程安全
+### 3. 相对线程安全
相对的线程安全需要保证对这个对象单独的操作是线程安全的，在调用的时候不需要做额外的保障措施，但是对于一些特定顺序的连续调用，就可能需要在调用端使用额外的同步手段来保证调用的正确性。
-在 Java 语言中，大部分的线程安全类都属于这种类型，例如 Vector、HashTable、Collections 的 synchronizedCollection() 方法包装的集合等。
+在 Java 语言中，大部分的线程安全类都属于这种类型，例如 Vector、HashTable、Collections 的 synchronizedCollection() 方法包装的集合等。
-对于下面的代码，如果删除元素的线程删除了一个元素，而获取元素的线程试图访问一个已经被删除的元素，那么就会抛出 ArrayIndexOutOfBoundsException。
+对于下面的代码，如果删除元素的线程删除了一个元素，而获取元素的线程试图访问一个已经被删除的元素，那么就会抛出 ArrayIndexOutOfBoundsException。
```java
-public class VectorUnsafeExample {
- private static Vector vector = new Vector<>();
+public class VectorUnsafeExample {
+ private static Vector vector = new Vector<>();
- public static void main(String[] args) {
- while (true) {
- for (int i = 0; i < 100; i++) {
- vector.add(i);
- }
- ExecutorService executorService = Executors.newCachedThreadPool();
- executorService.execute(() -> {
- for (int i = 0; i < vector.size(); i++) {
- vector.remove(i);
- }
- });
- executorService.execute(() -> {
- for (int i = 0; i < vector.size(); i++) {
- vector.get(i);
- }
- });
- executorService.shutdown();
- }
- }
+ public static void main(String[] args) {
+ while (true) {
+ for (int i = 0; i < 100; i++) {
+ vector.add(i);
+ }
+ ExecutorService executorService = Executors.newCachedThreadPool();
+ executorService.execute(() -> {
+ for (int i = 0; i < vector.size(); i++) {
+ vector.remove(i);
+ }
+ });
+ executorService.execute(() -> {
+ for (int i = 0; i < vector.size(); i++) {
+ vector.get(i);
+ }
+ });
+ executorService.shutdown();
+ }
+ }
}
```
```html
-Exception in thread "Thread-159738" java.lang.ArrayIndexOutOfBoundsException: Array index out of range: 3
- at java.util.Vector.remove(Vector.java:831)
- at VectorUnsafeExample.lambda$main$0(VectorUnsafeExample.java:14)
- at VectorUnsafeExample$$Lambda$1/713338599.run(Unknown Source)
- at java.lang.Thread.run(Thread.java:745)
+Exception in thread "Thread-159738" java.lang.ArrayIndexOutOfBoundsException: Array index out of range: 3
+ at java.util.Vector.remove(Vector.java:831)
+ at VectorUnsafeExample.lambda$main$0(VectorUnsafeExample.java:14)
+ at VectorUnsafeExample$$Lambda$1/713338599.run(Unknown Source)
+ at java.lang.Thread.run(Thread.java:745)
```
如果要保证上面的代码能正确执行下去，就需要对删除元素和获取元素的代码进行同步。
```java
-executorService.execute(() -> {
- synchronized (vector) {
- for (int i = 0; i < vector.size(); i++) {
- vector.remove(i);
- }
- }
+executorService.execute(() -> {
+ synchronized (vector) {
+ for (int i = 0; i < vector.size(); i++) {
+ vector.remove(i);
+ }
+ }
});
-executorService.execute(() -> {
- synchronized (vector) {
- for (int i = 0; i < vector.size(); i++) {
- vector.get(i);
- }
- }
+executorService.execute(() -> {
+ synchronized (vector) {
+ for (int i = 0; i < vector.size(); i++) {
+ vector.get(i);
+ }
+ }
});
```
-### 4. 线程兼容
+### 4. 线程兼容
-线程兼容是指对象本身并不是线程安全的，但是可以通过在调用端正确地使用同步手段来保证对象在并发环境中可以安全地使用，我们平常说一个类不是线程安全的，绝大多数时候指的是这一种情况。Java API 中大部分的类都是属于线程兼容的，如与前面的 Vector 和 HashTable 相对应的集合类 ArrayList 和 HashMap 等。
+线程兼容是指对象本身并不是线程安全的，但是可以通过在调用端正确地使用同步手段来保证对象在并发环境中可以安全地使用，我们平常说一个类不是线程安全的，绝大多数时候指的是这一种情况。Java API 中大部分的类都是属于线程兼容的，如与前面的 Vector 和 HashTable 相对应的集合类 ArrayList 和 HashMap 等。
-### 5. 线程对立
+### 5. 线程对立
-线程对立是指无论调用端是否采取了同步措施，都无法在多线程环境中并发使用的代码。由于 Java 语言天生就具备多线程特性，线程对立这种排斥多线程的代码是很少出现的，而且通常都是有害的，应当尽量避免。
+线程对立是指无论调用端是否采取了同步措施，都无法在多线程环境中并发使用的代码。由于 Java 语言天生就具备多线程特性，线程对立这种排斥多线程的代码是很少出现的，而且通常都是有害的，应当尽量避免。
-## 线程安全的实现方法
+## 线程安全的实现方法
-### 1. 互斥同步
+### 1. 互斥同步
-synchronized 和 ReentrantLock。
+synchronized 和 ReentrantLock。
-### 2. 非阻塞同步
+### 2. 非阻塞同步
-互斥同步最主要的问题就是进行线程阻塞和唤醒所带来的性能问题，因此这种同步也称为阻塞同步（Blocking Synchronization）。
+互斥同步最主要的问题就是进行线程阻塞和唤醒所带来的性能问题，因此这种同步也称为阻塞同步（Blocking Synchronization）。
-从处理问题的方式上说，互斥同步属于一种悲观的并发策略，总是认为只要不去做正确的同步措施（例如加锁），那就肯定会出现问题，无论共享数据是否真的会出现竞争，它都要进行加锁（这里讨论的是概念模型，实际上虚拟机会优化掉很大一部分不必要的加锁）、用户态核心态转换、维护锁计数器和检查是否有被阻塞的线程需要唤醒等操作。随着硬件指令集的发展，我们有了另外一个选择：基于冲突检测的乐观并发策略，通俗地说，就是先进行操作，如果没有其他线程争用共享数据，那操作就成功了；如果共享数据有争用，产生了冲突，那就再采取其他的补偿措施（最常见的补偿措施就是不断地重试，直到成功为止），这种乐观的并发策略的许多实现都不需要把线程挂起，因此这种同步操作称为非阻塞同步（Non-Blocking Synchronization）。
+从处理问题的方式上说，互斥同步属于一种悲观的并发策略，总是认为只要不去做正确的同步措施（例如加锁），那就肯定会出现问题，无论共享数据是否真的会出现竞争，它都要进行加锁（这里讨论的是概念模型，实际上虚拟机会优化掉很大一部分不必要的加锁）、用户态核心态转换、维护锁计数器和检查是否有被阻塞的线程需要唤醒等操作。随着硬件指令集的发展，我们有了另外一个选择：基于冲突检测的乐观并发策略，通俗地说，就是先进行操作，如果没有其他线程争用共享数据，那操作就成功了；如果共享数据有争用，产生了冲突，那就再采取其他的补偿措施（最常见的补偿措施就是不断地重试，直到成功为止），这种乐观的并发策略的许多实现都不需要把线程挂起，因此这种同步操作称为非阻塞同步（Non-Blocking Synchronization）。
乐观锁需要操作和冲突检测这两个步骤具备原子性，这里就不能再使用互斥同步来保证了，只能靠硬件来完成。硬件支持的原子性操作最典型的是：比较并交换（Compare-and-Swap，CAS）。
-CAS 指令需要有 3 个操作数，分别是内存位置（在 Java 中可以简单理解为变量的内存地址，用 V 表示）、旧的预期值（用 A 表示）和新值（用 B 表示）。CAS 指令执行时，当且仅当 V 符合旧预期值 A 时，处理器用新值 B 更新 V 的值，否则它就不执行更新。但是无论是否更新了 V 的值，都会返回 V 的旧值，上述的处理过程是一个原子操作。
+CAS 指令需要有 3 个操作数，分别是内存位置（在 Java 中可以简单理解为变量的内存地址，用 V 表示）、旧的预期值（用 A 表示）和新值（用 B 表示）。CAS 指令执行时，当且仅当 V 符合旧预期值 A 时，处理器用新值 B 更新 V 的值，否则它就不执行更新。但是无论是否更新了 V 的值，都会返回 V 的旧值，上述的处理过程是一个原子操作。
-J.U.C 包里面的整数原子类 AtomicInteger，其中的 compareAndSet() 和 getAndIncrement() 等方法都使用了 Unsafe 类的 CAS 操作。
+J.U.C 包里面的整数原子类 AtomicInteger，其中的 compareAndSet() 和 getAndIncrement() 等方法都使用了 Unsafe 类的 CAS 操作。
-在下面的代码 1 中，使用了 AtomicInteger 执行了自增的操作。代码 2 是 incrementAndGet() 的源码，它调用了 unsafe 的 getAndAddInt() 。代码 3 是 getAndAddInt() 源码，var1 指示内存位置，var2 指示新值，var4 指示操作需要加的数值，这里为 1。在代码 3 的实现中，通过 getIntVolatile(var1, var2) 得到旧的预期值。通过调用 compareAndSwapInt() 来进行 CAS 比较，如果 var2=var5，那么就更新内存地址为 var1 的变量为 var5+var4。可以看到代码 3 是在一个循环中进行，发生冲突的做法是不断的进行重试。
+在下面的代码 1 中，使用了 AtomicInteger 执行了自增的操作。代码 2 是 incrementAndGet() 的源码，它调用了 unsafe 的 getAndAddInt() 。代码 3 是 getAndAddInt() 源码，var1 指示内存位置，var2 指示新值，var4 指示操作需要加的数值，这里为 1。在代码 3 的实现中，通过 getIntVolatile(var1, var2) 得到旧的预期值。通过调用 compareAndSwapInt() 来进行 CAS 比较，如果 var2=var5，那么就更新内存地址为 var1 的变量为 var5+var4。可以看到代码 3 是在一个循环中进行，发生冲突的做法是不断的进行重试。
```java
-// 代码 1
-private AtomicInteger cnt = new AtomicInteger();
+// 代码 1
+private AtomicInteger cnt = new AtomicInteger();
-public void add() {
- cnt.incrementAndGet();
+public void add() {
+ cnt.incrementAndGet();
}
```
```java
-// 代码 2
-public final int incrementAndGet() {
- return unsafe.getAndAddInt(this, valueOffset, 1) + 1;
+// 代码 2
+public final int incrementAndGet() {
+ return unsafe.getAndAddInt(this, valueOffset, 1) + 1;
}
```
```java
-// 代码 3
-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));
+// 代码 3
+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;
}
```
-ABA ：如果一个变量初次读取的时候是 A 值，它的值被改成了 B，后来又被改回为 A，那 CAS 操作就会误认为它从来没有被改变过。J.U.C 包提供了一个带有标记的原子引用类“AtomicStampedReference”来解决这个问题，它可以通过控制变量值的版本来保证 CAS 的正确性。大部分情况下 ABA 问题不会影响程序并发的正确性，如果需要解决 ABA 问题，改用传统的互斥同步可能会比原子类更高效。
+ABA ：如果一个变量初次读取的时候是 A 值，它的值被改成了 B，后来又被改回为 A，那 CAS 操作就会误认为它从来没有被改变过。J.U.C 包提供了一个带有标记的原子引用类“AtomicStampedReference”来解决这个问题，它可以通过控制变量值的版本来保证 CAS 的正确性。大部分情况下 ABA 问题不会影响程序并发的正确性，如果需要解决 ABA 问题，改用传统的互斥同步可能会比原子类更高效。
-### 3. 无同步方案
+### 3. 无同步方案
要保证线程安全，并不是一定就要进行同步，两者没有因果关系。同步只是保证共享数据争用时的正确性的手段，如果一个方法本来就不涉及共享数据，那它自然就无须任何同步措施去保证正确性，因此会有一些代码天生就是线程安全的。
-**（一）可重入代码（Reentrant Code）**
+**（一）可重入代码（Reentrant Code）**
-这种代码也叫做纯代码（Pure Code），可以在代码执行的任何时刻中断它，转而去执行另外一段代码（包括递归调用它本身），而在控制权返回后，原来的程序不会出现任何错误。相对线程安全来说，可重入性是更基本的特性，它可以保证线程安全，即所有的可重入的代码都是线程安全的，但是并非所有的线程安全的代码都是可重入的。
+这种代码也叫做纯代码（Pure Code），可以在代码执行的任何时刻中断它，转而去执行另外一段代码（包括递归调用它本身），而在控制权返回后，原来的程序不会出现任何错误。相对线程安全来说，可重入性是更基本的特性，它可以保证线程安全，即所有的可重入的代码都是线程安全的，但是并非所有的线程安全的代码都是可重入的。
可重入代码有一些共同的特征，例如不依赖存储在堆上的数据和公用的系统资源、用到的状态量都由参数中传入、不调用非可重入的方法等。我们可以通过一个简单的原则来判断代码是否具备可重入性：如果一个方法，它的返回结果是可以预测的，只要输入了相同的数据，就都能返回相同的结果，那它就满足可重入性的要求，当然也就是线程安全的。
-**（二）栈封闭**
+**（二）栈封闭**
多个线程访问同一个方法的局部变量时，不会出现线程安全问题，因为局部变量存储在栈中，属于线程私有的。
```java
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.Executors;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
-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();
}
```
@@ -1469,37 +1410,37 @@ public static void main(String[] args) {
100
```
-**（三）线程本地存储（Thread Local Storage）**
+**（三）线程本地存储（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();
+ }
}
```
@@ -1507,85 +1448,85 @@ public class ThreadLocalExample {
1
```
-为了理解 ThreadLocal，先看以下代码：
+为了理解 ThreadLocal，先看以下代码：
```java
-public class ThreadLocalExample1 {
- public static void main(String[] args) {
- ThreadLocal threadLocal1 = new ThreadLocal();
- ThreadLocal threadLocal2 = new ThreadLocal();
- Thread thread1 = new Thread(() -> {
- threadLocal1.set(1);
- threadLocal2.set(1);
- });
- Thread thread2 = new Thread(() -> {
- threadLocal1.set(2);
- threadLocal2.set(2);
- });
- thread1.start();
- thread2.start();
- }
+public class ThreadLocalExample1 {
+ public static void main(String[] args) {
+ ThreadLocal threadLocal1 = new ThreadLocal();
+ ThreadLocal threadLocal2 = new ThreadLocal();
+ Thread thread1 = new Thread(() -> {
+ threadLocal1.set(1);
+ threadLocal2.set(1);
+ });
+ Thread thread2 = new Thread(() -> {
+ threadLocal1.set(2);
+ threadLocal2.set(2);
+ });
+ thread1.start();
+ thread2.start();
+ }
}
```
它所对应的底层结构图为：
- sf = new SoftReference(obj);
-obj = null; // 使对象只被软引用关联
+Object obj = new Object();
+SoftReference sf = new SoftReference(obj);
+obj = null; // 使对象只被软引用关联
```
-**（三）弱引用**
+**（三）弱引用**
被弱引用关联的对象一定会被垃圾收集器回收，也就是说它只能存活到下一次垃圾收集发生之前。
-使用 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;
```
-WeakHashMap 的 Entry 继承自 WeakReference，主要用来实现缓存。
+WeakHashMap 的 Entry 继承自 WeakReference，主要用来实现缓存。
```java
-private static class Entry extends WeakReference implements Map.Entry
+private static class Entry extends WeakReference implements Map.Entry
```
-Tomcat 中的 ConcurrentCache 就使用了 WeakHashMap 来实现缓存功能。ConcurrentCache 采取的是分代缓存，经常使用的对象放入 eden 中，而不常用的对象放入 longterm。eden 使用 ConcurrentHashMap 实现，longterm 使用 WeakHashMap，保证了不常使用的对象容易被回收。
+Tomcat 中的 ConcurrentCache 就使用了 WeakHashMap 来实现缓存功能。ConcurrentCache 采取的是分代缓存，经常使用的对象放入 eden 中，而不常用的对象放入 longterm。eden 使用 ConcurrentHashMap 实现，longterm 使用 WeakHashMap，保证了不常使用的对象容易被回收。
```java
-public final class ConcurrentCache {
+public final class ConcurrentCache {
- private final int size;
+ private final int size;
- private final Map eden;
+ private final Map eden;
- private final Map longterm;
+ private final Map longterm;
- public ConcurrentCache(int size) {
- this.size = size;
- this.eden = new ConcurrentHashMap<>(size);
- this.longterm = new WeakHashMap<>(size);
- }
+ public ConcurrentCache(int size) {
+ this.size = size;
+ this.eden = new ConcurrentHashMap<>(size);
+ this.longterm = new WeakHashMap<>(size);
+ }
- public V get(K k) {
- V v = this.eden.get(k);
- if (v == null) {
- v = this.longterm.get(k);
- if (v != null)
- this.eden.put(k, v);
- }
- return v;
- }
+ public V get(K k) {
+ V v = this.eden.get(k);
+ if (v == null) {
+ v = this.longterm.get(k);
+ if (v != null)
+ this.eden.put(k, v);
+ }
+ return v;
+ }
- public void put(K k, V v) {
- if (this.eden.size() >= size) {
- this.longterm.putAll(this.eden);
- this.eden.clear();
- }
- this.eden.put(k, v);
- }
+ public void put(K k, V v) {
+ if (this.eden.size() >= size) {
+ this.longterm.putAll(this.eden);
+ this.eden.clear();
+ }
+ this.eden.put(k, v);
+ }
}
```
-**（四）虚引用**
+**（四）虚引用**
又称为幽灵引用或者幻影引用。一个对象是否有虚引用的存在，完全不会对其生存时间构成影响，也无法通过虚引用取得一个对象实例。
为一个对象设置虚引用关联的唯一目的就是能在这个对象被收集器回收时收到一个系统通知。
-使用 PhantomReference 来实现虚引用。
+使用 PhantomReference 来实现虚引用。
```java
-Object obj = new Object();
-PhantomReference pf = new PhantomReference(obj);
-obj = null;
+Object obj = new Object();
+PhantomReference pf = new PhantomReference(obj);
+obj = null;
```
-### 4. 方法区的回收
+### 4. 方法区的回收
因为方法区主要存放永久代对象，而永久代对象的回收率比新生代差很多，因此在方法区上进行回收性价比不高。
@@ -250,575 +224,595 @@ obj = null;
类的卸载条件很多，需要满足以下三个条件，并且满足了也不一定会被卸载：
-- 该类所有的实例都已经被回收，也就是 Java 堆中不存在该类的任何实例。
-- 加载该类的 ClassLoader 已经被回收。
-- 该类对应的 java.lang.Class 对象没有在任何地方被引用，也就无法在任何地方通过反射访问该类方法。
+- 该类所有的实例都已经被回收，也就是 Java 堆中不存在该类的任何实例。
+- 加载该类的 ClassLoader 已经被回收。
+- 该类对应的 java.lang.Class 对象没有在任何地方被引用，也就无法在任何地方通过反射访问该类方法。
-可以通过 -Xnoclassgc 参数来控制是否对类进行卸载。
+可以通过 -Xnoclassgc 参数来控制是否对类进行卸载。
-在大量使用反射、动态代理、CGLib 等 ByteCode 框架、动态生成 JSP 以及 OSGi 这类频繁自定义 ClassLoader 的场景都需要虚拟机具备类卸载功能，以保证不会出现内存溢出。
+在大量使用反射、动态代理、CGLib 等 ByteCode 框架、动态生成 JSP 以及 OSGi 这类频繁自定义 ClassLoader 的场景都需要虚拟机具备类卸载功能，以保证不会出现内存溢出。
-### 5. finalize()
+### 5. finalize()
-finalize() 类似 C++ 的析构函数，用来做关闭外部资源等工作。但是 try-finally 等方式可以做的更好，并且该方法运行代价高昂，不确定性大，无法保证各个对象的调用顺序，因此最好不要使用。
+finalize() 类似 C++ 的析构函数，用来做关闭外部资源等工作。但是 try-finally 等方式可以做的更好，并且该方法运行代价高昂，不确定性大，无法保证各个对象的调用顺序，因此最好不要使用。
-当一个对象可被回收时，如果需要执行该对象的 finalize() 方法，那么就有可能通过在该方法中让对象重新被引用，从而实现自救。
+当一个对象可被回收时，如果需要执行该对象的 finalize() 方法，那么就有可能通过在该方法中让对象重新被引用，从而实现自救。
-## 垃圾收集算法
+## 垃圾收集算法
-### 1. 标记 - 清除
+### 1. 标记 - 清除
-2 )。
### 堆排序
-堆排序用于求解 **TopK Elements** 问题，通过维护一个大小为 K 的堆，堆中的元素就是 TopK Elements。当然它也可以用于求解 Kth Element 问题，堆顶元素就是 Kth Element。快速选择也可以求解 TopK Elements 问题，因为找到 Kth Element 之后，再遍历一次数组，所有小于等于 Kth Element 的元素都是 TopK Elements。可以看到，快速选择和堆排序都可以求解 Kth Element 和 TopK Elements 问题。
+堆排序用于求解 **TopK Elements** 问题，通过维护一个大小为 K 的堆，堆中的元素就是 TopK Elements。当然它也可以用于求解 Kth Element 问题，堆顶元素就是 Kth Element。快速选择也可以求解 TopK Elements 问题，因为找到 Kth Element 之后，再遍历一次数组，所有小于等于 Kth Element 的元素都是 TopK Elements。可以看到，快速选择和堆排序都可以求解 Kth Element 和 TopK Elements 问题。
-**Kth Element**
+**Kth Element**
[215. Kth Largest Element in an Array (Medium)](https://leetcode.com/problems/kth-largest-element-in-an-array/description/)
-**排序** ：时间复杂度 O(NlogN)，空间复杂度 O(1)
+**排序**：时间复杂度 O(NlogN)，空间复杂度 O(1)
```java
public int findKthLargest(int[] nums, int k) {
@@ -849,7 +794,7 @@ public int findKthLargest(int[] nums, int k) {
}
```
-**堆排序** ：时间复杂度 O(NlogK)，空间复杂度 O(K)。
+**堆排序**：时间复杂度 O(NlogK)，空间复杂度 O(K)。
```java
public int findKthLargest(int[] nums, int k) {
@@ -863,7 +808,7 @@ public int findKthLargest(int[] nums, int k) {
}
```
-**快速选择** ：时间复杂度 O(N)，空间复杂度 O(1)
+**快速选择**：时间复杂度 O(N)，空间复杂度 O(1)
```java
public int findKthLargest(int[] nums, int k) {
@@ -903,7 +848,7 @@ private void swap(int[] a, int i, int j) {
### 桶排序
-**出现频率最多的 k 个数**
+**出现频率最多的 k 个数**
[347. Top K Frequent Elements (Medium)](https://leetcode.com/problems/top-k-frequent-elements/description/)
@@ -936,7 +881,7 @@ public List topKFrequent(int[] nums, int k) {
}
```
-**按照字符出现次数对字符串排序**
+**按照字符出现次数对字符串排序**
[451. Sort Characters By Frequency (Medium)](https://leetcode.com/problems/sort-characters-by-frequency/description/)
@@ -983,9 +928,9 @@ public String frequencySort(String s) {
它其实是三向切分快速排序的一种变种，在三向切分快速排序中，每次切分都将数组分成三个区间：小于切分元素、等于切分元素、大于切分元素，而该算法是将数组分成三个区间：等于红色、等于白色、等于蓝色。
-i 表示第 i 个节点与根节点的距离，推导出一个结论：对于先遍历的节点 i 与后遍历的节点 j，有 di <=dj 。利用这个结论，可以求解最短路径等 **最优解** 问题：第一次遍历到目的节点，其所经过的路径为最短路径。应该注意的是，使用 BFS 只能求解无权图的最短路径。
+可以看到，每一轮遍历的节点都与根节点距离相同。设 di 表示第 i 个节点与根节点的距离，推导出一个结论：对于先遍历的节点 i 与后遍历的节点 j，有 di <=dj 。利用这个结论，可以求解最短路径等 **最优解** 问题：第一次遍历到目的节点，其所经过的路径为最短路径。应该注意的是，使用 BFS 只能求解无权图的最短路径。
在程序实现 BFS 时需要考虑以下问题：
- 队列：用来存储每一轮遍历得到的节点；
- 标记：对于遍历过的节点，应该将它标记，防止重复遍历。
-**计算在网格中从原点到特定点的最短路径长度**
+**计算在网格中从原点到特定点的最短路径长度**
```html
[[1,1,0,1],
@@ -1087,7 +1032,7 @@ public int minPathLength(int[][] grids, int tr, int tc) {
}
```
-**组成整数的最小平方数数量**
+**组成整数的最小平方数数量**
[279. Perfect Squares (Medium)](https://leetcode.com/problems/perfect-squares/description/)
@@ -1143,7 +1088,7 @@ private List generateSquares(int n) {
}
```
-**最短单词路径**
+**最短单词路径**
[127. Word Ladder (Medium)](https://leetcode.com/problems/word-ladder/description/)
@@ -1235,20 +1180,20 @@ private int getShortestPath(List[] graphic, int start, int end) {
### DFS
- ret)
}
```
-**IP 地址划分**
+**IP 地址划分**
[93. Restore IP Addresses(Medium)](https://leetcode.com/problems/restore-ip-addresses/description/)
@@ -1598,7 +1543,7 @@ private void doRestore(int k, StringBuilder path, String s, List address
}
```
-**在矩阵中寻找字符串**
+**在矩阵中寻找字符串**
[79. Word Search (Medium)](https://leetcode.com/problems/word-search/description/)
@@ -1655,7 +1600,7 @@ private boolean backtracking(char[][] board, boolean[][] visited, String word, i
}
```
-**输出二叉树中所有从根到叶子的路径**
+**输出二叉树中所有从根到叶子的路径**
[257. Binary Tree Paths (Easy)](https://leetcode.com/problems/binary-tree-paths/description/)
@@ -1709,7 +1654,7 @@ private String buildPath(List values) {
}
```
-**排列**
+**排列**
[46. Permutations (Medium)](https://leetcode.com/problems/permutations/description/)
@@ -1751,7 +1696,7 @@ private void backtracking(List permuteList, boolean[] visited, int[] nu
}
```
-**含有相同元素求排列**
+**含有相同元素求排列**
[47. Permutations II (Medium)](https://leetcode.com/problems/permutations-ii/description/)
@@ -1794,7 +1739,7 @@ private void backtracking(List permuteList, boolean[] visited, int[] nu
}
```
-**组合**
+**组合**
[77. Combinations (Medium)](https://leetcode.com/problems/combinations/description/)
@@ -1832,7 +1777,7 @@ private void backtracking(int start, int n, int k, List combineList, Li
}
```
-**组合求和**
+**组合求和**
[39. Combination Sum (Medium)](https://leetcode.com/problems/combination-sum/description/)
@@ -1864,7 +1809,7 @@ private void doCombination(int[] candidates, int target, int start, List path, int start, List > ret;
@@ -2193,7 +2138,7 @@ private void backtracking(int row) {
## 分治
-**给表达式加括号**
+**给表达式加括号**
[241. Different Ways to Add Parentheses (Medium)](https://leetcode.com/problems/different-ways-to-add-parentheses/description/)
@@ -2245,7 +2190,7 @@ public List diffWaysToCompute(String input) {
### 斐波那契数列
-**爬楼梯**
+**爬楼梯**
[70. Climbing Stairs (Easy)](https://leetcode.com/problems/climbing-stairs/description/)
@@ -2253,7 +2198,7 @@ public List diffWaysToCompute(String input) {
定义一个数组 dp 存储上楼梯的方法数（为了方便讨论，数组下标从 1 开始），dp[i] 表示走到第 i 个楼梯的方法数目。第 i 个楼梯可以从第 i-1 和 i-2 个楼梯再走一步到达，走到第 i 个楼梯的方法数为走到第 i-1 和第 i-2 个楼梯的方法数之和。
- 1 , 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[n] 时可能无法找到一个满足条件的递增子序列，此时 {Sn } 就构成了递增子序列，需要对前面的求解方程做修改，令 dp[n] 最小为 1，即：
- N 为结尾，因此 dp[N] 不是序列的最长递增子序列的长度，需要遍历 dp 数组找出最大值才是所要的结果，即 max{ dp[i] | 1 <= i <= N} 即为所求。
-**最长递增子序列**
+**最长递增子序列**
[300. Longest Increasing Subsequence (Medium)](https://leetcode.com/problems/longest-increasing-subsequence/description/)
@@ -2454,7 +2399,7 @@ private int binarySearch(int[] nums, int first, int last, int key) {
}
```
-**一组整数对能够构成的最长链**
+**一组整数对能够构成的最长链**
[646. Maximum Length of Pair Chain (Medium)](https://leetcode.com/problems/maximum-length-of-pair-chain/description/)
@@ -2491,7 +2436,7 @@ public int findLongestChain(int[][] pairs) {
}
```
-**最长摆动子序列**
+**最长摆动子序列**
[376. Wiggle Subsequence (Medium)](https://leetcode.com/problems/wiggle-subsequence/description/)
@@ -2536,7 +2481,7 @@ public int wiggleMaxLength(int[] nums) {
综上，最长公共子序列的状态转移方程为：
- 1 和 长度为 M 的序列 S2 ，dp[N][M] 就是序列 S1 和序列 S2 的最长公共子序列长度。
@@ -2573,7 +2518,7 @@ public int lengthOfLCS(int[] nums1, int[] nums2) {
综上，0-1 背包的状态转移方程为：
- wordDict) {
}
```
-**改变一组数的正负号使得它们的和为一给定数**
+**改变一组数的正负号使得它们的和为一给定数**
[494. Target Sum (Medium)](https://leetcode.com/problems/target-sum/description/)
@@ -2761,7 +2706,7 @@ private int findTargetSumWays(int[] nums, int start, int S) {
}
```
-**01 字符构成最多的字符串**
+**01 字符构成最多的字符串**
[474. Ones and Zeroes (Medium)](https://leetcode.com/problems/ones-and-zeroes/description/)
@@ -2794,7 +2739,7 @@ public int findMaxForm(String[] strs, int m, int n) {
}
```
-**找零钱**
+**找零钱**
[322. Coin Change (Medium)](https://leetcode.com/problems/coin-change/description/)
@@ -2829,7 +2774,7 @@ public int coinChange(int[] coins, int amount) {
}
```
-**组合总和**
+**组合总和**
[377. Combination Sum IV (Medium)](https://leetcode.com/problems/combination-sum-iv/description/)
@@ -2869,7 +2814,7 @@ public int combinationSum4(int[] nums, int target) {
}
```
-**只能进行 k 次的股票交易**
+**只能进行 k 次的股票交易**
[188. Best Time to Buy and Sell Stock IV (Hard)](https://leetcode.com/problems/best-time-to-buy-and-sell-stock-iv/description/)
@@ -2901,7 +2846,7 @@ public int maxProfit(int k, int[] prices) {
}
```
-**只能进行两次的股票交易**
+**只能进行两次的股票交易**
[123. Best Time to Buy and Sell Stock III (Hard)](https://leetcode.com/problems/best-time-to-buy-and-sell-stock-iii/description/)
@@ -2921,7 +2866,7 @@ public int maxProfit(int[] prices) {
### 数组区间
-**数组区间和**
+**数组区间和**
[303. Range Sum Query - Immutable (Easy)](https://leetcode.com/problems/range-sum-query-immutable/description/)
@@ -2933,7 +2878,7 @@ sumRange(2, 5) -> -1
sumRange(0, 5) -> -3
```
-求区间 i \~ j 的和，可以转换为 sum[j] - sum[i-1]，其中 sum[i] 为 0 \~ i 的和。
+求区间 i ~ j 的和，可以转换为 sum[j] - sum[i-1]，其中 sum[i] 为 0 ~ i 的和。
```java
class NumArray {
@@ -2952,7 +2897,7 @@ class NumArray {
}
```
-**子数组最大的和**
+**子数组最大的和**
[53. Maximum Subarray (Easy)](https://leetcode.com/problems/maximum-subarray/description/)
@@ -2974,7 +2919,7 @@ public int maxSubArray(int[] nums) {
}
```
-**数组中等差递增子区间的个数**
+**数组中等差递增子区间的个数**
[413. Arithmetic Slices (Medium)](https://leetcode.com/problems/arithmetic-slices/description/)
@@ -3005,7 +2950,7 @@ public int numberOfArithmeticSlices(int[] A) {
### 字符串编辑
-**删除两个字符串的字符使它们相等**
+**删除两个字符串的字符使它们相等**
[583. Delete Operation for Two Strings (Medium)](https://leetcode.com/problems/delete-operation-for-two-strings/description/)
@@ -3032,7 +2977,7 @@ public int minDistance(String word1, String word2) {
}
```
-**修改一个字符串成为另一个字符串**
+**修改一个字符串成为另一个字符串**
[72. Edit Distance (Hard)](https://leetcode.com/problems/edit-distance/description/)
@@ -3085,7 +3030,7 @@ public int minDistance(String word1, String word2) {
### 分割整数
-**分割整数的最大乘积**
+**分割整数的最大乘积**
[343. Integer Break (Medim)](https://leetcode.com/problems/integer-break/description/)
@@ -3104,7 +3049,7 @@ public int integerBreak(int n) {
}
```
-**按平方数来分割整数**
+**按平方数来分割整数**
[279. Perfect Squares(Medium)](https://leetcode.com/problems/perfect-squares/description/)
@@ -3138,7 +3083,7 @@ private List generateSquareList(int n) {
}
```
-**分割整数构成字母字符串**
+**分割整数构成字母字符串**
[91. Decode Ways (Medium)](https://leetcode.com/problems/decode-ways/description/)
@@ -3164,13 +3109,13 @@ public int numDecodings(String s) {
### 矩阵路径
-**矩阵的总路径数**
+**矩阵的总路径数**
[62. Unique Paths (Medium)](https://leetcode.com/problems/unique-paths/description/)
题目描述：统计从矩阵左上角到右下角的路径总数，每次只能向右或者向下移动。
-2 \* 31 \* 50 \* 71 \* 110 \* 130 \* 170 \* …
-**整除**
+**整除**
令 x = 2m0 \* 3m1 \* 5m2 \* 7m3 \* 11m4 \* …
@@ -3376,13 +3321,13 @@ public int minSteps(int n) {
如果 x 整除 y（y mod x == 0），则对于所有 i，mi <= ni。
-**最大公约数最小公倍数**
+**最大公约数最小公倍数**
x 和 y 的最大公约数为：gcd(x,y) = 2min(m0,n0) \* 3min(m1,n1) \* 5min(m2,n2) \* ...
x 和 y 的最小公倍数为：lcm(x,y) = 2max(m0,n0) \* 3max(m1,n1) \* 5max(m2,n2) \* ...
-**生成素数序列**
+**生成素数序列**
[204. Count Primes (Easy)](https://leetcode.com/problems/count-primes/description/)
@@ -3435,7 +3380,7 @@ int lcm(int a, int b){
### 进制转换
-**7 进制**
+**7 进制**
[504. Base 7 (Easy)](https://leetcode.com/problems/base-7/description/)
@@ -3470,7 +3415,7 @@ public String convertToBase7(int num) {
}
```
-**16 进制**
+**16 进制**
[405. Convert a Number to Hexadecimal (Easy)](https://leetcode.com/problems/convert-a-number-to-hexadecimal/description/)
@@ -3503,7 +3448,7 @@ public String toHex(int num) {
}
```
-**26 进制**
+**26 进制**
[168. Excel Sheet Column Title (Easy)](https://leetcode.com/problems/excel-sheet-column-title/description/)
@@ -3529,7 +3474,7 @@ public String convertToTitle(int n) {
### 阶乘
-**统计阶乘尾部有多少个 0**
+**统计阶乘尾部有多少个 0**
[172. Factorial Trailing Zeroes (Easy)](https://leetcode.com/problems/factorial-trailing-zeroes/description/)
@@ -3547,7 +3492,7 @@ public int trailingZeroes(int n) {
### 字符串加法减法
-**二进制加法**
+**二进制加法**
[67. Add Binary (Easy)](https://leetcode.com/problems/add-binary/description/)
@@ -3571,7 +3516,7 @@ public String addBinary(String a, String b) {
}
```
-**字符串加法**
+**字符串加法**
[415. Add Strings (Easy)](https://leetcode.com/problems/add-strings/description/)
@@ -3593,7 +3538,7 @@ public String addStrings(String num1, String num2) {
### 相遇问题
-**改变数组元素使所有的数组元素都相等**
+**改变数组元素使所有的数组元素都相等**
[462. Minimum Moves to Equal Array Elements II (Medium)](https://leetcode.com/problems/minimum-moves-to-equal-array-elements-ii/description/)
@@ -3618,7 +3563,7 @@ Only two moves are needed (remember each move increments or decrements one eleme
设数组长度为 N，则可以找到 N/2 对 a 和 b 的组合，使它们都移动到 m 的位置。
-**解法 1**
+**解法 1**
先排序，时间复杂度：O(NlogN)
@@ -3636,7 +3581,7 @@ public int minMoves2(int[] nums) {
}
```
-**解法 2**
+**解法 2**
使用快速选择找到中位数，时间复杂度 O(N)
@@ -3682,7 +3627,7 @@ private void swap(int[] nums, int i, int j) {
### 多数投票问题
-**数组中出现次数多于 n / 2 的元素**
+**数组中出现次数多于 n / 2 的元素**
[169. Majority Element (Easy)](https://leetcode.com/problems/majority-element/description/)
@@ -3710,7 +3655,7 @@ public int majorityElement(int[] nums) {
### 其它
-**平方数**
+**平方数**
[367. Valid Perfect Square (Easy)](https://leetcode.com/problems/valid-perfect-square/description/)
@@ -3736,7 +3681,7 @@ public boolean isPerfectSquare(int num) {
}
```
-**3 的 n 次方**
+**3 的 n 次方**
[326. Power of Three (Easy)](https://leetcode.com/problems/power-of-three/description/)
@@ -3746,7 +3691,7 @@ public boolean isPowerOfThree(int n) {
}
```
-**乘积数组**
+**乘积数组**
[238. Product of Array Except Self (Medium)](https://leetcode.com/problems/product-of-array-except-self/description/)
@@ -3777,7 +3722,7 @@ public int[] productExceptSelf(int[] nums) {
}
```
-**找出数组中的乘积最大的三个数**
+**找出数组中的乘积最大的三个数**
[628. Maximum Product of Three Numbers (Easy)](https://leetcode.com/problems/maximum-product-of-three-numbers/description/)
@@ -3816,7 +3761,7 @@ public int maximumProduct(int[] nums) {
## 栈和队列
-**用栈实现队列**
+**用栈实现队列**
[232. Implement Queue using Stacks (Easy)](https://leetcode.com/problems/implement-queue-using-stacks/description/)
@@ -3887,7 +3832,7 @@ class MyQueue {
}
```
-**用队列实现栈**
+**用队列实现栈**
[225. Implement Stack using Queues (Easy)](https://leetcode.com/problems/implement-stack-using-queues/description/)
@@ -3922,7 +3867,7 @@ class MyStack {
}
```
-**最小值栈**
+**最小值栈**
[155. Min Stack (Easy)](https://leetcode.com/problems/min-stack/description/)
@@ -3965,7 +3910,7 @@ class MinStack {
对于实现最小值队列问题，可以先将队列使用栈来实现，然后就将问题转换为最小值栈，这个问题出现在 编程之美：3.7。
-**用栈实现括号匹配**
+**用栈实现括号匹配**
[20. Valid Parentheses (Easy)](https://leetcode.com/problems/valid-parentheses/description/)
@@ -3993,7 +3938,7 @@ public boolean isValid(String s) {
}
```
-**数组中元素与下一个比它大的元素之间的距离**
+**数组中元素与下一个比它大的元素之间的距离**
```html
Input: [73, 74, 75, 71, 69, 72, 76, 73]
@@ -4020,7 +3965,7 @@ public int[] dailyTemperatures(int[] temperatures) {
}
```
-**在另一个数组中比当前元素大的下一个元素**
+**在另一个数组中比当前元素大的下一个元素**
[496. Next Greater Element I (Easy)](https://leetcode.com/problems/next-greater-element-i/description/)
@@ -4048,7 +3993,7 @@ public int[] nextGreaterElement(int[] nums1, int[] nums2) {
}
```
-**循环数组中比当前元素大的下一个元素**
+**循环数组中比当前元素大的下一个元素**
[503. Next Greater Element II (Medium)](https://leetcode.com/problems/next-greater-element-ii/description/)
@@ -4071,17 +4016,17 @@ public int[] nextGreaterElements(int[] nums) {
利用 Hash Table 可以快速查找一个元素是否存在等问题，但是需要一定的空间来存储。在优先考虑时间复杂度的情况下，可以利用 Hash Table 这种空间换取时间的做法。
-Java 中的 **HashSet** 用于存储一个集合，并以 O(1) 的时间复杂度查找元素是否在集合中。
+Java 中的 **HashSet** 用于存储一个集合，并以 O(1) 的时间复杂度查找元素是否在集合中。
如果元素有穷，并且范围不大，那么可以用一个布尔数组来存储一个元素是否存在，例如对于只有小写字符的元素，就可以用一个长度为 26 的布尔数组来存储一个字符集合，使得空间复杂度降低为 O(1)。
-Java 中的 **HashMap** 主要用于映射关系，从而把两个元素联系起来。
+Java 中的 **HashMap** 主要用于映射关系，从而把两个元素联系起来。
在对一个内容进行压缩或者其它转换时，利用 HashMap 可以把原始内容和转换后的内容联系起来。例如在一个简化 url 的系统中[Leetcdoe : 535. Encode and Decode TinyURL (Medium)](https://leetcode.com/problems/encode-and-decode-tinyurl/description/)，利用 HashMap 就可以存储精简后的 url 到原始 url 的映射，使得不仅可以显示简化的 url，也可以根据简化的 url 得到原始 url 从而定位到正确的资源。
HashMap 也可以用来对元素进行计数统计，此时键为元素，值为计数。和 HashSet 类似，如果元素有穷并且范围不大，可以用整型数组来进行统计。
-**数组中的两个数和为给定值**
+**数组中的两个数和为给定值**
[1. Two Sum (Easy)](https://leetcode.com/problems/two-sum/description/)
@@ -4100,7 +4045,7 @@ public int[] twoSum(int[] nums, int target) {
}
```
-**判断数组是否含有相同元素**
+**判断数组是否含有相同元素**
[217. Contains Duplicate (Easy)](https://leetcode.com/problems/contains-duplicate/description/)
@@ -4114,7 +4059,7 @@ public boolean containsDuplicate(int[] nums) {
}
```
-**最长和谐序列**
+**最长和谐序列**
[594. Longest Harmonious Subsequence (Easy)](https://leetcode.com/problems/longest-harmonious-subsequence/description/)
@@ -4142,7 +4087,7 @@ public int findLHS(int[] nums) {
}
```
-**最长连续序列**
+**最长连续序列**
[128. Longest Consecutive Sequence (Hard)](https://leetcode.com/problems/longest-consecutive-sequence/description/)
@@ -4185,7 +4130,7 @@ private int count(Map numCnts, int num) {
## 字符串
-**两个字符串包含的字符是否完全相同**
+**两个字符串包含的字符是否完全相同**
[242. Valid Anagram (Easy)](https://leetcode.com/problems/valid-anagram/description/)
@@ -4206,7 +4151,7 @@ public boolean isAnagram(String s, String t) {
}
```
-**计算一组字符集合可以组成的回文字符串的最大长度**
+**计算一组字符集合可以组成的回文字符串的最大长度**
[409. Longest Palindrome (Easy)](https://leetcode.com/problems/longest-palindrome/description/)
@@ -4229,7 +4174,7 @@ public int longestPalindrome(String s) {
}
```
-**字符串同构**
+**字符串同构**
[205. Isomorphic Strings (Easy)](https://leetcode.com/problems/isomorphic-strings/description/)
@@ -4255,7 +4200,7 @@ public boolean isIsomorphic(String s, String t) {
}
```
-**判断一个整数是否是回文数**
+**判断一个整数是否是回文数**
[9. Palindrome Number (Easy)](https://leetcode.com/problems/palindrome-number/description/)
@@ -4277,7 +4222,7 @@ public boolean isPalindrome(int x) {
}
```
-**回文子字符串**
+**回文子字符串**
[647. Palindromic Substrings (Medium)](https://leetcode.com/problems/palindromic-substrings/description/)
@@ -4308,7 +4253,7 @@ private void extendSubstrings(String s, int start, int end) {
}
```
-**统计二进制字符串中连续 1 和连续 0 数量相同的子字符串个数**
+**统计二进制字符串中连续 1 和连续 0 数量相同的子字符串个数**
[696. Count Binary Substrings (Easy)](https://leetcode.com/problems/count-binary-substrings/description/)
@@ -4333,7 +4278,7 @@ public int countBinarySubstrings(String s) {
}
```
-**字符串循环移位包含**
+**字符串循环移位包含**
[编程之美：3.1](#)
@@ -4346,7 +4291,7 @@ Return : true
s1 进行循环移位的结果是 s1s1 的子字符串，因此只要判断 s2 是否是 s1s1 的子字符串即可。
-**字符串循环移位**
+**字符串循环移位**
[编程之美：2.17](#)
@@ -4356,7 +4301,7 @@ s1 进行循环移位的结果是 s1s1 的子字符串，因此只要判断 s2
将 abcd123 中的 abcd 和 123 单独逆序，得到 dcba321，然后对整个字符串进行逆序，得到 123abcd。
-**字符串中单词的翻转**
+**字符串中单词的翻转**
[程序员代码面试指南](#)
@@ -4366,7 +4311,7 @@ s1 进行循环移位的结果是 s1s1 的子字符串，因此只要判断 s2
## 数组与矩阵
-**把数组中的 0 移到末尾**
+**把数组中的 0 移到末尾**
[283. Move Zeroes (Easy)](https://leetcode.com/problems/move-zeroes/description/)
@@ -4382,7 +4327,7 @@ public void moveZeroes(int[] nums) {
}
```
-**调整矩阵**
+**调整矩阵**
[566. Reshape the Matrix (Easy)](https://leetcode.com/problems/reshape-the-matrix/description/)
@@ -4414,7 +4359,7 @@ public int[][] matrixReshape(int[][] nums, int r, int c) {
}
```
-**找出数组中最长的连续 1**
+**找出数组中最长的连续 1**
[485. Max Consecutive Ones (Easy)](https://leetcode.com/problems/max-consecutive-ones/description/)
@@ -4429,7 +4374,7 @@ public int findMaxConsecutiveOnes(int[] nums) {
}
```
-**一个数组元素在 [1, n] 之间，其中一个数被替换为另一个数，找出丢失的数和重复的数**
+**一个数组元素在 [1, n] 之间，其中一个数被替换为另一个数，找出丢失的数和重复的数**
[645. Set Mismatch (Easy)](https://leetcode.com/problems/set-mismatch/description/)
@@ -4471,7 +4416,7 @@ private void swap(int[] nums, int i, int j) {
- [448. Find All Numbers Disappeared in an Array (Easy)](https://leetcode.com/problems/find-all-numbers-disappeared-in-an-array/description/)，寻找所有丢失的元素
- [442. Find All Duplicates in an Array (Medium)](https://leetcode.com/problems/find-all-duplicates-in-an-array/description/)，寻找所有重复的元素。
-**找出数组中重复的数，数组值在 [1, n] 之间**
+**找出数组中重复的数，数组值在 [1, n] 之间**
[287. Find the Duplicate Number (Medium)](https://leetcode.com/problems/find-the-duplicate-number/description/)
@@ -4513,7 +4458,7 @@ public int findDuplicate(int[] nums) {
}
```
-**有序矩阵查找**
+**有序矩阵查找**
[240. Search a 2D Matrix II (Medium)](https://leetcode.com/problems/search-a-2d-matrix-ii/description/)
@@ -4539,7 +4484,7 @@ public boolean searchMatrix(int[][] matrix, int target) {
}
```
-**有序矩阵的 Kth Element**
+**有序矩阵的 Kth Element**
[378. Kth Smallest Element in a Sorted Matrix ((Medium))](https://leetcode.com/problems/kth-smallest-element-in-a-sorted-matrix/description/)
@@ -4605,7 +4550,7 @@ class Tuple implements Comparable {
}
```
-**数组相邻差值的个数**
+**数组相邻差值的个数**
[667. Beautiful Arrangement II (Medium)](https://leetcode.com/problems/beautiful-arrangement-ii/description/)
@@ -4615,7 +4560,7 @@ Output: [1, 3, 2]
Explanation: The [1, 3, 2] has three different positive integers ranging from 1 to 3, and the [2, 1] has exactly 2 distinct integers: 1 and 2.
```
-题目描述：数组元素为 1\~n 的整数，要求构建数组，使得相邻元素的差值不相同的个数为 k。
+题目描述：数组元素为 1~n 的整数，要求构建数组，使得相邻元素的差值不相同的个数为 k。
让前 k+1 个元素构建出 k 个不相同的差值，序列为：1 k+1 2 k 3 k-1 ... k/2 k/2+1.
@@ -4633,7 +4578,7 @@ public int[] constructArray(int n, int k) {
}
```
-**数组的度**
+**数组的度**
[697. Degree of an Array (Easy)](https://leetcode.com/problems/degree-of-an-array/description/)
@@ -4672,7 +4617,7 @@ public int findShortestSubArray(int[] nums) {
}
```
-**对角元素相等的矩阵**
+**对角元素相等的矩阵**
[766. Toeplitz Matrix (Easy)](https://leetcode.com/problems/toeplitz-matrix/description/)
@@ -4710,7 +4655,7 @@ private boolean check(int[][] matrix, int expectValue, int row, int col) {
}
```
-**嵌套数组**
+**嵌套数组**
[565. Array Nesting (Medium)](https://leetcode.com/problems/array-nesting/description/)
@@ -4744,7 +4689,7 @@ public int arrayNesting(int[] nums) {
}
```
-**分隔数组**
+**分隔数组**
[769. Max Chunks To Make Sorted (Medium)](https://leetcode.com/problems/max-chunks-to-make-sorted/description/)
@@ -4775,7 +4720,7 @@ public int maxChunksToSorted(int[] arr) {
链表是空节点，或者有一个值和一个指向下一个链表的指针，因此很多链表问题可以用递归来处理。
-**找出两个链表的交点**
+**找出两个链表的交点**
[160. Intersection of Two Linked Lists (Easy)](https://leetcode.com/problems/intersection-of-two-linked-lists/description/)
@@ -4806,7 +4751,7 @@ public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
如果只是判断是否存在交点，那么就是另一个问题，即 [编程之美：3.6]() 的问题。有两种解法：把第一个链表的结尾连接到第二个链表的开头，看第二个链表是否存在环；或者直接比较第一个链表最后一个节点和第二个链表最后一个节点是否相同。
-**链表反转**
+**链表反转**
[206. Reverse Linked List (Easy)](https://leetcode.com/problems/reverse-linked-list/description/)
@@ -4838,7 +4783,7 @@ public ListNode reverseList(ListNode head) {
}
```
-**归并两个有序的链表**
+**归并两个有序的链表**
[21. Merge Two Sorted Lists (Easy)](https://leetcode.com/problems/merge-two-sorted-lists/description/)
@@ -4856,7 +4801,7 @@ public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
}
```
-**从有序链表中删除重复节点**
+**从有序链表中删除重复节点**
[83. Remove Duplicates from Sorted List (Easy)](https://leetcode.com/problems/remove-duplicates-from-sorted-list/description/)
@@ -4873,7 +4818,7 @@ public ListNode deleteDuplicates(ListNode head) {
}
```
-**删除链表的倒数第 n 个节点**
+**删除链表的倒数第 n 个节点**
[19. Remove Nth Node From End of List (Medium)](https://leetcode.com/problems/remove-nth-node-from-end-of-list/description/)
@@ -4900,7 +4845,7 @@ public ListNode removeNthFromEnd(ListNode head, int n) {
}
```
-**交换链表中的相邻结点**
+**交换链表中的相邻结点**
[24. Swap Nodes in Pairs (Medium)](https://leetcode.com/problems/swap-nodes-in-pairs/description/)
@@ -4927,7 +4872,7 @@ public ListNode swapPairs(ListNode head) {
}
```
-**链表求和**
+**链表求和**
[445. Add Two Numbers II (Medium)](https://leetcode.com/problems/add-two-numbers-ii/description/)
@@ -4966,7 +4911,7 @@ private Stack buildStack(ListNode l) {
}
```
-**回文链表**
+**回文链表**
[234. Palindrome Linked List (Easy)](https://leetcode.com/problems/palindrome-linked-list/description/)
@@ -5019,7 +4964,7 @@ private boolean isEqual(ListNode l1, ListNode l2) {
}
```
-**链表元素按奇偶聚集**
+**链表元素按奇偶聚集**
[328. Odd Even Linked List (Medium)](https://leetcode.com/problems/odd-even-linked-list/description/)
@@ -5046,7 +4991,7 @@ public ListNode oddEvenList(ListNode head) {
}
```
-**分隔链表**
+**分隔链表**
[725. Split Linked List in Parts(Medium)](https://leetcode.com/problems/split-linked-list-in-parts/description/)
@@ -5092,7 +5037,7 @@ public ListNode[] splitListToParts(ListNode root, int k) {
一棵树要么是空树，要么有两个指针，每个指针指向一棵树。树是一种递归结构，很多树的问题可以使用递归来处理。
-**树的高度**
+**树的高度**
[104. Maximum Depth of Binary Tree (Easy)](https://leetcode.com/problems/maximum-depth-of-binary-tree/description/)
@@ -5103,7 +5048,7 @@ public int maxDepth(TreeNode root) {
}
```
-**翻转树**
+**翻转树**
[226. Invert Binary Tree (Easy)](https://leetcode.com/problems/invert-binary-tree/description/)
@@ -5117,7 +5062,7 @@ public TreeNode invertTree(TreeNode root) {
}
```
-**归并两棵树**
+**归并两棵树**
[617. Merge Two Binary Trees (Easy)](https://leetcode.com/problems/merge-two-binary-trees/description/)
@@ -5150,7 +5095,7 @@ public TreeNode mergeTrees(TreeNode t1, TreeNode t2) {
}
```
-**判断路径和是否等于一个数**
+**判断路径和是否等于一个数**
[Leetcdoe : 112. Path Sum (Easy)](https://leetcode.com/problems/path-sum/description/)
@@ -5176,7 +5121,7 @@ public boolean hasPathSum(TreeNode root, int sum) {
}
```
-**统计路径和等于一个数的路径数量**
+**统计路径和等于一个数的路径数量**
[437. Path Sum III (Easy)](https://leetcode.com/problems/path-sum-iii/description/)
@@ -5216,7 +5161,7 @@ private int pathSumStartWithRoot(TreeNode root, int sum){
}
```
-**子树**
+**子树**
[572. Subtree of Another Tree (Easy)](https://leetcode.com/problems/subtree-of-another-tree/description/)
@@ -5263,7 +5208,7 @@ private boolean isSubtreeWithRoot(TreeNode s, TreeNode t) {
}
```
-**树的对称**
+**树的对称**
[101. Symmetric Tree (Easy)](https://leetcode.com/problems/symmetric-tree/description/)
@@ -5289,7 +5234,7 @@ private boolean isSymmetric(TreeNode t1, TreeNode t2){
}
```
-**平衡树**
+**平衡树**
[110. Balanced Binary Tree (Easy)](https://leetcode.com/problems/balanced-binary-tree/description/)
@@ -5320,7 +5265,7 @@ public int maxDepth(TreeNode root) {
}
```
-**最小路径**
+**最小路径**
[111. Minimum Depth of Binary Tree (Easy)](https://leetcode.com/problems/minimum-depth-of-binary-tree/description/)
@@ -5336,7 +5281,7 @@ public int minDepth(TreeNode root) {
}
```
-**统计左叶子节点的和**
+**统计左叶子节点的和**
[404. Sum of Left Leaves (Easy)](https://leetcode.com/problems/sum-of-left-leaves/description/)
@@ -5363,7 +5308,7 @@ private boolean isLeaf(TreeNode node){
}
```
-**修剪二叉查找树**
+**修剪二叉查找树**
[669. Trim a Binary Search Tree (Easy)](https://leetcode.com/problems/trim-a-binary-search-tree/description/)
@@ -5390,7 +5335,7 @@ Output:
二叉查找树（BST）：根节点大于等于左子树所有节点，小于等于右子树所有节点。
-只保留值在 L \~ R 之间的节点
+只保留值在 L ~ R 之间的节点
```java
public TreeNode trimBST(TreeNode root, int L, int R) {
@@ -5403,7 +5348,7 @@ public TreeNode trimBST(TreeNode root, int L, int R) {
}
```
-**从有序数组中构造二叉查找树**
+**从有序数组中构造二叉查找树**
[108. Convert Sorted Array to Binary Search Tree (Easy)](https://leetcode.com/problems/convert-sorted-array-to-binary-search-tree/description/)
@@ -5422,7 +5367,7 @@ private TreeNode toBST(int[] nums, int sIdx, int eIdx){
}
```
-**两节点的最长路径**
+**两节点的最长路径**
[543. Diameter of Binary Tree (Easy)](https://leetcode.com/problems/diameter-of-binary-tree/description/)
@@ -5454,7 +5399,7 @@ private int depth(TreeNode root) {
}
```
-**找出二叉树中第二小的节点**
+**找出二叉树中第二小的节点**
[671. Second Minimum Node In a Binary Tree (Easy)](https://leetcode.com/problems/second-minimum-node-in-a-binary-tree/description/)
@@ -5485,7 +5430,7 @@ public int findSecondMinimumValue(TreeNode root) {
}
```
-**二叉查找树的最近公共祖先**
+**二叉查找树的最近公共祖先**
[235. Lowest Common Ancestor of a Binary Search Tree (Easy)](https://leetcode.com/problems/lowest-common-ancestor-of-a-binary-search-tree/description/)
@@ -5508,7 +5453,7 @@ public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
}
```
-**二叉树的最近公共祖先**
+**二叉树的最近公共祖先**
[236. Lowest Common Ancestor of a Binary Tree (Medium) ](https://leetcode.com/problems/lowest-common-ancestor-of-a-binary-tree/description/)
@@ -5532,7 +5477,7 @@ public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
}
```
-**相同节点值的最大路径长度**
+**相同节点值的最大路径长度**
[687. Longest Univalue Path (Easy)](https://leetcode.com/problems/longest-univalue-path/)
@@ -5565,7 +5510,7 @@ private int dfs(TreeNode root){
}
```
-**间隔遍历**
+**间隔遍历**
[337. House Robber III (Medium)](https://leetcode.com/problems/house-robber-iii/description/)
@@ -5597,7 +5542,7 @@ public int rob(TreeNode root) {
使用 BFS 进行层次遍历。不需要使用两个队列来分别存储当前层的节点和下一层的节点，因为在开始遍历一层的节点时，当前队列中的节点数就是当前层的节点数，只要控制遍历这么多节点数，就能保证这次遍历的都是当前层的节点。
-**一棵树每层节点的平均数**
+**一棵树每层节点的平均数**
[637. Average of Levels in Binary Tree (Easy)](https://leetcode.com/problems/average-of-levels-in-binary-tree/description/)
@@ -5622,7 +5567,7 @@ public List averageOfLevels(TreeNode root) {
}
```
-**得到左下角的节点**
+**得到左下角的节点**
[513. Find Bottom Left Tree Value (Easy)](https://leetcode.com/problems/find-bottom-left-tree-value/description/)
@@ -5703,7 +5648,7 @@ void dfs(TreeNode root){
}
```
-**非递归实现二叉树的前序遍历**
+**非递归实现二叉树的前序遍历**
[144. Binary Tree Preorder Traversal (Medium)](https://leetcode.com/problems/binary-tree-preorder-traversal/description/)
@@ -5723,7 +5668,7 @@ public List preorderTraversal(TreeNode root) {
}
```
-**非递归实现二叉树的后序遍历**
+**非递归实现二叉树的后序遍历**
[145. Binary Tree Postorder Traversal (Medium)](https://leetcode.com/problems/binary-tree-postorder-traversal/description/)
@@ -5746,7 +5691,7 @@ public List postorderTraversal(TreeNode root) {
}
```
-**非递归实现二叉树的中序遍历**
+**非递归实现二叉树的中序遍历**
[94. Binary Tree Inorder Traversal (Medium)](https://leetcode.com/problems/binary-tree-inorder-traversal/description/)
@@ -5773,7 +5718,7 @@ public List inorderTraversal(TreeNode root) {
主要利用 BST 中序遍历有序的特点。
-**在 BST 中寻找两个节点，使它们的和为一个给定值**
+**在 BST 中寻找两个节点，使它们的和为一个给定值**
[653. Two Sum IV - Input is a BST (Easy)](https://leetcode.com/problems/two-sum-iv-input-is-a-bst/description/)
@@ -5816,7 +5761,7 @@ private void inOrder(TreeNode root, List nums){
}
```
-**在 BST 中查找两个节点之差的最小绝对值**
+**在 BST 中查找两个节点之差的最小绝对值**
[530. Minimum Absolute Difference in BST (Easy)](https://leetcode.com/problems/minimum-absolute-difference-in-bst/description/)
@@ -5852,7 +5797,7 @@ private void inorder(TreeNode node){
}
```
-**把 BST 每个节点的值都加上比它大的节点的值**
+**把 BST 每个节点的值都加上比它大的节点的值**
[Convert BST to Greater Tree (Easy)](https://leetcode.com/problems/convert-bst-to-greater-tree/description/)
@@ -5887,7 +5832,7 @@ private void traver(TreeNode root) {
}
```
-**寻找 BST 中出现次数最多的节点**
+**寻找 BST 中出现次数最多的节点**
[501. Find Mode in Binary Search Tree (Easy)](https://leetcode.com/problems/find-mode-in-binary-search-tree/description/)
@@ -5936,7 +5881,7 @@ private void inOrder(TreeNode node) {
}
```
-**寻找 BST 的第 k 个元素**
+**寻找 BST 的第 k 个元素**
[230. Kth Smallest Element in a BST (Medium)](https://leetcode.com/problems/kth-smallest-element-in-a-bst/description/)
@@ -5979,7 +5924,7 @@ private void inOrder(TreeNode node, int k) {
}
```
-**根据有序链表构造平衡的 BST**
+**根据有序链表构造平衡的 BST**
[109. Convert Sorted List to Binary Search Tree (Medium)](https://leetcode.com/problems/convert-sorted-list-to-binary-search-tree/description/)
@@ -6027,11 +5972,11 @@ private int size(ListNode node) {
### Trie
-
}
```
-**课程安排的顺序**
+**课程安排的顺序**
[210. Course Schedule II (Medium)](https://leetcode.com/problems/course-schedule-ii/description/)
@@ -6333,7 +6278,7 @@ private boolean dfs(boolean[] globalMarked, boolean[] localMarked, List
并查集可以动态地连通两个点，并且可以非常快速地判断两个点是否连通。
-**冗余连接**
+**冗余连接**
[684. Redundant Connection (Medium)](https://leetcode.com/problems/redundant-connection/description/)
@@ -6395,7 +6340,7 @@ private class UF {
## 位运算
-**1. 基本原理**
+**1. 基本原理**
0s 表示一串 0，1s 表示一串 1。
@@ -6405,15 +6350,15 @@ 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 ^ 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 的位级表示中最低的那一位。例如对于二进制表示 10110 **100** ，减去 1 得到 10110**011**，这两个数相与得到 10110**000**。
-- n-n&(\~n+1) 去除 n 的位级表示中最高的那一位。
-- n&(-n) 得到 n 的位级表示中最低的那一位。-n 得到 n 的反码加 1，对于二进制表示 10110 **100** ，-n 得到 01001**100**，相与得到 00000**100**
+- n&(n-1) 去除 n 的位级表示中最低的那一位。例如对于二进制表示 10110**100**，减去 1 得到 10110**011**，这两个数相与得到 10110**000**。
+- n-n&(~n+1) 去除 n 的位级表示中最高的那一位。
+- n&(-n) 得到 n 的位级表示中最低的那一位。-n 得到 n 的反码加 1，对于二进制表示 10110**100**，-n 得到 01001**100**，相与得到 00000**100**
移位运算：
@@ -6421,17 +6366,17 @@ x ^ x = 0 x & x = x x | x = x
- \>\>\> 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。
要得到 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 的数量
@@ -6439,7 +6384,7 @@ static int Integer.highestOneBit(); // 获得最高位
static String toBinaryString(int i); // 转换为二进制表示的字符串
```
-**统计两个数的二进制表示有多少位不同**
+**统计两个数的二进制表示有多少位不同**
[461. Hamming Distance (Easy)](https://leetcode.com/problems/hamming-distance/)
@@ -6492,7 +6437,7 @@ public int hammingDistance(int x, int y) {
}
```
-**数组中唯一一个不重复的元素**
+**数组中唯一一个不重复的元素**
[136. Single Number (Easy)](https://leetcode.com/problems/single-number/description/)
@@ -6511,7 +6456,7 @@ public int singleNumber(int[] nums) {
}
```
-**找出数组中缺失的那个数**
+**找出数组中缺失的那个数**
[268. Missing Number (Easy)](https://leetcode.com/problems/missing-number/description/)
@@ -6532,7 +6477,7 @@ public int missingNumber(int[] nums) {
}
```
-**数组中不重复的两个元素**
+**数组中不重复的两个元素**
[260. Single Number III (Medium)](https://leetcode.com/problems/single-number-iii/description/)
@@ -6557,7 +6502,7 @@ public int[] singleNumber(int[] nums) {
}
```
-**翻转一个数的比特位**
+**翻转一个数的比特位**
[190. Reverse Bits (Easy)](https://leetcode.com/problems/reverse-bits/description/)
@@ -6604,7 +6549,7 @@ private int reverseByte(byte b) {
}
```
-**不用额外变量交换两个整数**
+**不用额外变量交换两个整数**
[程序员代码面试指南 ：P317](#)
@@ -6614,7 +6559,7 @@ b = a ^ b;
a = a ^ b;
```
-**判断一个数是不是 2 的 n 次方**
+**判断一个数是不是 2 的 n 次方**
[231. Power of Two (Easy)](https://leetcode.com/problems/power-of-two/description/)
@@ -6634,7 +6579,7 @@ public boolean isPowerOfTwo(int n) {
}
```
-**判断一个数是不是 4 的 n 次方**
+**判断一个数是不是 4 的 n 次方**
[342. Power of Four (Easy)](https://leetcode.com/problems/power-of-four/)
@@ -6655,7 +6600,7 @@ public boolean isPowerOfFour(int num) {
```
-**判断一个数的位级表示是否不会出现连续的 0 和 1**
+**判断一个数的位级表示是否不会出现连续的 0 和 1**
[693. Binary Number with Alternating Bits (Easy)](https://leetcode.com/problems/binary-number-with-alternating-bits/description/)
@@ -6680,7 +6625,7 @@ public boolean hasAlternatingBits(int n) {
}
```
-**求一个数的补码**
+**求一个数的补码**
[476. Number Complement (Easy)](https://leetcode.com/problems/number-complement/description/)
@@ -6735,7 +6680,7 @@ public int findComplement(int num) {
}
```
-**实现整数的加法**
+**实现整数的加法**
[371. Sum of Two Integers (Easy)](https://leetcode.com/problems/sum-of-two-integers/description/)
@@ -6749,7 +6694,7 @@ public int getSum(int a, int b) {
}
```
-**字符串数组最大乘积**
+**字符串数组最大乘积**
[318. Maximum Product of Word Lengths (Medium)](https://leetcode.com/problems/maximum-product-of-word-lengths/description/)
@@ -6784,7 +6729,7 @@ public int maxProduct(String[] words) {
}
```
-**统计从 0 \~ n 每个数的二进制表示中 1 的个数**
+**统计从 0 ~ n 每个数的二进制表示中 1 的个数**
[338. Counting Bits (Medium)](https://leetcode.com/problems/counting-bits/description/)
diff --git a/notes/Leetcode-Database 题解.md b/notes/Leetcode-Database 题解.md
index a85d82ed..04e8c953 100644
--- a/notes/Leetcode-Database 题解.md
+++ b/notes/Leetcode-Database 题解.md
@@ -1,176 +1,158 @@
-
-* [595. Big Countries](#595-big-countries)
-* [627. Swap Salary](#627-swap-salary)
-* [620. Not Boring Movies](#620-not-boring-movies)
-* [596. Classes More Than 5 Students](#596-classes-more-than-5-students)
-* [182. Duplicate Emails](#182-duplicate-emails)
-* [196. Delete Duplicate Emails](#196-delete-duplicate-emails)
-* [175. Combine Two Tables](#175-combine-two-tables)
-* [181. Employees Earning More Than Their Managers](#181-employees-earning-more-than-their-managers)
-* [183. Customers Who Never Order](#183-customers-who-never-order)
-* [184. Department Highest Salary](#184-department-highest-salary)
-* [176. Second Highest Salary](#176-second-highest-salary)
-* [177. Nth Highest Salary](#177-nth-highest-salary)
-* [178. Rank Scores](#178-rank-scores)
-* [180. Consecutive Numbers](#180-consecutive-numbers)
-
-
-
-# 595. Big Countries
+# 595. Big Countries
https://leetcode.com/problems/big-countries/description/
-## Description
+## Description
```html
+-----------------+------------+------------+--------------+---------------+
-| name | continent | area | population | gdp |
+| name | continent | area | population | gdp |
+-----------------+------------+------------+--------------+---------------+
-| Afghanistan | Asia | 652230 | 25500100 | 20343000 |
-| Albania | Europe | 28748 | 2831741 | 12960000 |
-| Algeria | Africa | 2381741 | 37100000 | 188681000 |
-| Andorra | Europe | 468 | 78115 | 3712000 |
-| Angola | Africa | 1246700 | 20609294 | 100990000 |
+| Afghanistan | Asia | 652230 | 25500100 | 20343000 |
+| Albania | Europe | 28748 | 2831741 | 12960000 |
+| Algeria | Africa | 2381741 | 37100000 | 188681000 |
+| Andorra | Europe | 468 | 78115 | 3712000 |
+| Angola | Africa | 1246700 | 20609294 | 100990000 |
+-----------------+------------+------------+--------------+---------------+
```
-查找面积超过 3,000,000 或者人口数超过 25,000,000 的国家。
+查找面积超过 3,000,000 或者人口数超过 25,000,000 的国家。
```html
+--------------+-------------+--------------+
-| name | population | area |
+| name | population | area |
+--------------+-------------+--------------+
-| Afghanistan | 25500100 | 652230 |
-| Algeria | 37100000 | 2381741 |
+| Afghanistan | 25500100 | 652230 |
+| Algeria | 37100000 | 2381741 |
+--------------+-------------+--------------+
```
-## SQL Schema
+## SQL Schema
```sql
-DROP TABLE
+DROP TABLE
IF
- EXISTS World;
-CREATE TABLE World ( NAME VARCHAR ( 255 ), continent VARCHAR ( 255 ), area INT, population INT, gdp INT );
-INSERT INTO World ( NAME, continent, area, population, gdp )
+ EXISTS World;
+CREATE TABLE World ( NAME VARCHAR ( 255 ), continent VARCHAR ( 255 ), area INT, population INT, gdp INT );
+INSERT INTO World ( NAME, continent, area, population, gdp )
VALUES
- ( 'Afghanistan', 'Asia', '652230', '25500100', '203430000' ),
- ( 'Albania', 'Europe', '28748', '2831741', '129600000' ),
- ( 'Algeria', 'Africa', '2381741', '37100000', '1886810000' ),
- ( 'Andorra', 'Europe', '468', '78115', '37120000' ),
- ( 'Angola', 'Africa', '1246700', '20609294', '1009900000' );
+ ( 'Afghanistan', 'Asia', '652230', '25500100', '203430000' ),
+ ( 'Albania', 'Europe', '28748', '2831741', '129600000' ),
+ ( 'Algeria', 'Africa', '2381741', '37100000', '1886810000' ),
+ ( 'Andorra', 'Europe', '468', '78115', '37120000' ),
+ ( 'Angola', 'Africa', '1246700', '20609294', '1009900000' );
```
-## Solution
+## Solution
```sql
-SELECT name,
+SELECT name,
population,
area
FROM
World
WHERE
- area > 3000000
- OR population > 25000000;
+ area > 3000000
+ OR population > 25000000;
```
-# 627. Swap Salary
+# 627. Swap Salary
https://leetcode.com/problems/swap-salary/description/
-## Description
+## Description
```html
-| id | name | sex | salary |
+| id | name | sex | salary |
|----|------|-----|--------|
-| 1 | A | m | 2500 |
-| 2 | B | f | 1500 |
-| 3 | C | m | 5500 |
-| 4 | D | f | 500 |
+| 1 | A | m | 2500 |
+| 2 | B | f | 1500 |
+| 3 | C | m | 5500 |
+| 4 | D | f | 500 |
```
-只用一个 SQL 查询，将 sex 字段反转。
+只用一个 SQL 查询，将 sex 字段反转。
```html
-| id | name | sex | salary |
+| id | name | sex | salary |
|----|------|-----|--------|
-| 1 | A | m | 2500 |
-| 2 | B | f | 1500 |
-| 3 | C | m | 5500 |
-| 4 | D | f | 500 |
+| 1 | A | m | 2500 |
+| 2 | B | f | 1500 |
+| 3 | C | m | 5500 |
+| 4 | D | f | 500 |
```
-## SQL Schema
+## SQL Schema
```sql
-DROP TABLE
+DROP TABLE
IF
- EXISTS World;
-CREATE TABLE World ( NAME VARCHAR ( 255 ), continent VARCHAR ( 255 ), area INT, population INT, gdp INT );
-INSERT INTO World ( NAME, continent, area, population, gdp )
+ EXISTS World;
+CREATE TABLE World ( NAME VARCHAR ( 255 ), continent VARCHAR ( 255 ), area INT, population INT, gdp INT );
+INSERT INTO World ( NAME, continent, area, population, gdp )
VALUES
- ( 'Afghanistan', 'Asia', '652230', '25500100', '203430000' ),
- ( 'Albania', 'Europe', '28748', '2831741', '129600000' ),
- ( 'Algeria', 'Africa', '2381741', '37100000', '1886810000' ),
- ( 'Andorra', 'Europe', '468', '78115', '37120000' ),
- ( 'Angola', 'Africa', '1246700', '20609294', '1009900000' );
+ ( 'Afghanistan', 'Asia', '652230', '25500100', '203430000' ),
+ ( 'Albania', 'Europe', '28748', '2831741', '129600000' ),
+ ( 'Algeria', 'Africa', '2381741', '37100000', '1886810000' ),
+ ( 'Andorra', 'Europe', '468', '78115', '37120000' ),
+ ( 'Angola', 'Africa', '1246700', '20609294', '1009900000' );
```
-## Solution
+## Solution
```sql
-UPDATE salary
-SET sex = CHAR ( ASCII(sex) ^ ASCII( 'm' ) ^ ASCII( 'f' ) );
+UPDATE salary
+SET sex = CHAR ( ASCII(sex) ^ ASCII( 'm' ) ^ ASCII( 'f' ) );
```
-# 620. Not Boring Movies
+# 620. Not Boring Movies
https://leetcode.com/problems/not-boring-movies/description/
-## Description
+## Description
邮件地址表：
```html
+---------+-----------+--------------+-----------+
-| id | movie | description | rating |
+| id | movie | description | rating |
+---------+-----------+--------------+-----------+
-| 1 | War | great 3D | 8.9 |
-| 2 | Science | fiction | 8.5 |
-| 3 | irish | boring | 6.2 |
-| 4 | Ice song | Fantacy | 8.6 |
-| 5 | House card| Interesting| 9.1 |
+| 1 | War | great 3D | 8.9 |
+| 2 | Science | fiction | 8.5 |
+| 3 | irish | boring | 6.2 |
+| 4 | Ice song | Fantacy | 8.6 |
+| 5 | House card| Interesting| 9.1 |
+---------+-----------+--------------+-----------+
```
-查找 id 为奇数，并且 description 不是 boring 的电影，按 rating 降序。
+查找 id 为奇数，并且 description 不是 boring 的电影，按 rating 降序。
```html
+---------+-----------+--------------+-----------+
-| id | movie | description | rating |
+| id | movie | description | rating |
+---------+-----------+--------------+-----------+
-| 5 | House card| Interesting| 9.1 |
-| 1 | War | great 3D | 8.9 |
+| 5 | House card| Interesting| 9.1 |
+| 1 | War | great 3D | 8.9 |
+---------+-----------+--------------+-----------+
```
-## SQL Schema
+## SQL Schema
```sql
-DROP TABLE
+DROP TABLE
IF
- EXISTS cinema;
-CREATE TABLE cinema ( id INT, movie VARCHAR ( 255 ), description VARCHAR ( 255 ), rating FLOAT ( 2, 1 ) );
-INSERT INTO cinema ( id, movie, description, rating )
+ EXISTS cinema;
+CREATE TABLE cinema ( id INT, movie VARCHAR ( 255 ), description VARCHAR ( 255 ), rating FLOAT ( 2, 1 ) );
+INSERT INTO cinema ( id, movie, description, rating )
VALUES
- ( 1, 'War', 'great 3D', 8.9 ),
- ( 2, 'Science', 'fiction', 8.5 ),
- ( 3, 'irish', 'boring', 6.2 ),
- ( 4, 'Ice song', 'Fantacy', 8.6 ),
- ( 5, 'House card', 'Interesting', 9.1 );
+ ( 1, 'War', 'great 3D', 8.9 ),
+ ( 2, 'Science', 'fiction', 8.5 ),
+ ( 3, 'irish', 'boring', 6.2 ),
+ ( 4, 'Ice song', 'Fantacy', 8.6 ),
+ ( 5, 'House card', 'Interesting', 9.1 );
```
-## Solution
+## Solution
```sql
SELECT
@@ -178,92 +160,92 @@ SELECT
FROM
cinema
WHERE
- id % 2 = 1
- AND description != 'boring'
-ORDER BY
- rating DESC;
+ id % 2 = 1
+ AND description != 'boring'
+ORDER BY
+ rating DESC;
```
-# 596. Classes More Than 5 Students
+# 596. Classes More Than 5 Students
https://leetcode.com/problems/classes-more-than-5-students/description/
-## Description
+## Description
```html
+---------+------------+
-| student | class |
+| student | class |
+---------+------------+
-| A | Math |
-| B | English |
-| C | Math |
-| D | Biology |
-| E | Math |
-| F | Computer |
-| G | Math |
-| H | Math |
-| I | Math |
+| A | Math |
+| B | English |
+| C | Math |
+| D | Biology |
+| E | Math |
+| F | Computer |
+| G | Math |
+| H | Math |
+| I | Math |
+---------+------------+
```
-查找有五名及以上 student 的 class。
+查找有五名及以上 student 的 class。
```html
+---------+
-| Email |
+| Email |
+---------+
-| a@b.com |
+| a@b.com |
+---------+
```
-## SQL Schema
+## SQL Schema
```sql
-DROP TABLE
+DROP TABLE
IF
- EXISTS courses;
-CREATE TABLE courses ( student VARCHAR ( 255 ), class VARCHAR ( 255 ) );
-INSERT INTO courses ( student, class )
+ EXISTS courses;
+CREATE TABLE courses ( student VARCHAR ( 255 ), class VARCHAR ( 255 ) );
+INSERT INTO courses ( student, class )
VALUES
- ( 'A', 'Math' ),
- ( 'B', 'English' ),
- ( 'C', 'Math' ),
- ( 'D', 'Biology' ),
- ( 'E', 'Math' ),
- ( 'F', 'Computer' ),
- ( 'G', 'Math' ),
- ( 'H', 'Math' ),
- ( 'I', 'Math' );
+ ( 'A', 'Math' ),
+ ( 'B', 'English' ),
+ ( 'C', 'Math' ),
+ ( 'D', 'Biology' ),
+ ( 'E', 'Math' ),
+ ( 'F', 'Computer' ),
+ ( 'G', 'Math' ),
+ ( 'H', 'Math' ),
+ ( 'I', 'Math' );
```
-## Solution
+## Solution
```sql
SELECT
class
FROM
courses
-GROUP BY
+GROUP BY
class
HAVING
- count( DISTINCT student ) >= 5;
+ count( DISTINCT student ) >= 5;
```
-# 182. Duplicate Emails
+# 182. Duplicate Emails
https://leetcode.com/problems/duplicate-emails/description/
-## Description
+## Description
邮件地址表：
```html
+----+---------+
-| Id | Email |
+| Id | Email |
+----+---------+
-| 1 | a@b.com |
-| 2 | c@d.com |
-| 3 | a@b.com |
+| 1 | a@b.com |
+| 2 | c@d.com |
+| 3 | a@b.com |
+----+---------+
```
@@ -271,52 +253,52 @@ https://leetcode.com/problems/duplicate-emails/description/
```html
+---------+
-| Email |
+| Email |
+---------+
-| a@b.com |
+| a@b.com |
+---------+
```
-## SQL Schema
+## SQL Schema
```sql
-DROP TABLE
+DROP TABLE
IF
- EXISTS Person;
-CREATE TABLE Person ( Id INT, Email VARCHAR ( 255 ) );
-INSERT INTO Person ( Id, Email )
+ EXISTS Person;
+CREATE TABLE Person ( Id INT, Email VARCHAR ( 255 ) );
+INSERT INTO Person ( Id, Email )
VALUES
- ( 1, 'a@b.com' ),
- ( 2, 'c@d.com' ),
- ( 3, 'a@b.com' );
+ ( 1, 'a@b.com' ),
+ ( 2, 'c@d.com' ),
+ ( 3, 'a@b.com' );
```
-## Solution
+## Solution
```sql
SELECT
Email
FROM
Person
-GROUP BY
+GROUP BY
Email
HAVING
- COUNT( * ) >= 2;
+ COUNT( * ) >= 2;
```
-# 196. Delete Duplicate Emails
+# 196. Delete Duplicate Emails
-## Description
+## Description
邮件地址表：
```html
+----+---------+
-| Id | Email |
+| Id | Email |
+----+---------+
-| 1 | a@b.com |
-| 2 | c@d.com |
-| 3 | a@b.com |
+| 1 | a@b.com |
+| 2 | c@d.com |
+| 3 | a@b.com |
+----+---------+
```
@@ -324,28 +306,28 @@ HAVING
```html
+---------+
-| Email |
+| Email |
+---------+
-| a@b.com |
+| a@b.com |
+---------+
```
-## SQL Schema
+## SQL Schema
-与 182 相同。
+与 182 相同。
-## Solution
+## Solution
连接：
```sql
-DELETE p1
+DELETE p1
FROM
- Person p1,
- Person p2
+ Person p1,
+ Person p2
WHERE
- p1.Email = p2.Email
- AND p1.Id > p2.Id
+ p1.Email = p2.Email
+ AND p1.Id > p2.Id
```
子查询：
@@ -355,164 +337,164 @@ DELETE
FROM
Person
WHERE
- id NOT IN ( SELECT id FROM ( SELECT min( id ) AS id FROM Person GROUP BY email ) AS m );
+ id NOT IN ( SELECT id FROM ( SELECT min( id ) AS id FROM Person GROUP BY email ) AS m );
```
-应该注意的是上述解法额外嵌套了一个 SELECT 语句，如果不这么做，会出现错误：You can't specify target table 'Person' for update in FROM clause。以下演示了这种错误解法。
+应该注意的是上述解法额外嵌套了一个 SELECT 语句，如果不这么做，会出现错误：You can't specify target table 'Person' for update in FROM clause。以下演示了这种错误解法。
```sql
DELETE
FROM
Person
WHERE
- id NOT IN ( SELECT min( id ) AS id FROM Person GROUP BY email );
+ id NOT IN ( SELECT min( id ) AS id FROM Person GROUP BY email );
```
-参考：[pMySQL Error 1093 - Can't specify target table for update in FROM clause](https://stackoverflow.com/questions/45494/mysql-error-1093-cant-specify-target-table-for-update-in-from-clause)
+参考：[pMySQL Error 1093 - Can't specify target table for update in FROM clause](https://stackoverflow.com/questions/45494/mysql-error-1093-cant-specify-target-table-for-update-in-from-clause)
-# 175. Combine Two Tables
+# 175. Combine Two Tables
https://leetcode.com/problems/combine-two-tables/description/
-## Description
+## Description
-Person 表：
+Person 表：
```html
+-------------+---------+
-| Column Name | Type |
+| Column Name | Type |
+-------------+---------+
-| PersonId | int |
-| FirstName | varchar |
-| LastName | varchar |
+| PersonId | int |
+| FirstName | varchar |
+| LastName | varchar |
+-------------+---------+
-PersonId is the primary key column for this table.
+PersonId is the primary key column for this table.
```
-Address 表：
+Address 表：
```html
+-------------+---------+
-| Column Name | Type |
+| Column Name | Type |
+-------------+---------+
-| AddressId | int |
-| PersonId | int |
-| City | varchar |
-| State | varchar |
+| AddressId | int |
+| PersonId | int |
+| City | varchar |
+| State | varchar |
+-------------+---------+
-AddressId is the primary key column for this table.
+AddressId is the primary key column for this table.
```
-查找 FirstName, LastName, City, State 数据，而不管一个用户有没有填地址信息。
+查找 FirstName, LastName, City, State 数据，而不管一个用户有没有填地址信息。
-## SQL Schema
+## SQL Schema
```sql
-DROP TABLE
+DROP TABLE
IF
- EXISTS Person;
-CREATE TABLE Person ( PersonId INT, FirstName VARCHAR ( 255 ), LastName VARCHAR ( 255 ) );
-DROP TABLE
+ EXISTS Person;
+CREATE TABLE Person ( PersonId INT, FirstName VARCHAR ( 255 ), LastName VARCHAR ( 255 ) );
+DROP TABLE
IF
- EXISTS Address;
-CREATE TABLE Address ( AddressId INT, PersonId INT, City VARCHAR ( 255 ), State VARCHAR ( 255 ) );
-INSERT INTO Person ( PersonId, LastName, FirstName )
+ EXISTS Address;
+CREATE TABLE Address ( AddressId INT, PersonId INT, City VARCHAR ( 255 ), State VARCHAR ( 255 ) );
+INSERT INTO Person ( PersonId, LastName, FirstName )
VALUES
- ( 1, 'Wang', 'Allen' );
-INSERT INTO Address ( AddressId, PersonId, City, State )
+ ( 1, 'Wang', 'Allen' );
+INSERT INTO Address ( AddressId, PersonId, City, State )
VALUES
- ( 1, 2, 'New York City', 'New York' );
+ ( 1, 2, 'New York City', 'New York' );
```
-## Solution
+## Solution
使用左外连接。
```sql
SELECT
- FirstName,
- LastName,
- City,
- State
+ FirstName,
+ LastName,
+ City,
+ State
FROM
- Person P
- LEFT JOIN Address AS A ON P.PersonId = A.PersonId;
+ Person P
+ LEFT JOIN Address AS A ON P.PersonId = A.PersonId;
```
-# 181. Employees Earning More Than Their Managers
+# 181. Employees Earning More Than Their Managers
https://leetcode.com/problems/employees-earning-more-than-their-managers/description/
-## Description
+## Description
-Employee 表：
+Employee 表：
```html
+----+-------+--------+-----------+
-| Id | Name | Salary | ManagerId |
+| Id | Name | Salary | ManagerId |
+----+-------+--------+-----------+
-| 1 | Joe | 70000 | 3 |
-| 2 | Henry | 80000 | 4 |
-| 3 | Sam | 60000 | NULL |
-| 4 | Max | 90000 | NULL |
+| 1 | Joe | 70000 | 3 |
+| 2 | Henry | 80000 | 4 |
+| 3 | Sam | 60000 | NULL |
+| 4 | Max | 90000 | NULL |
+----+-------+--------+-----------+
```
查找所有员工，他们的薪资大于其经理薪资。
-## SQL Schema
+## SQL Schema
```sql
-DROP TABLE
+DROP TABLE
IF
- EXISTS Employee;
-CREATE TABLE Employee ( Id INT, NAME VARCHAR ( 255 ), Salary INT, ManagerId INT );
-INSERT INTO Employee ( Id, NAME, Salary, ManagerId )
+ EXISTS Employee;
+CREATE TABLE Employee ( Id INT, NAME VARCHAR ( 255 ), Salary INT, ManagerId INT );
+INSERT INTO Employee ( Id, NAME, Salary, ManagerId )
VALUES
- ( 1, 'Joe', 70000, 3 ),
- ( 2, 'Henry', 80000, 4 ),
- ( 3, 'Sam', 60000, NULL ),
- ( 4, 'Max', 90000, NULL );
+ ( 1, 'Joe', 70000, 3 ),
+ ( 2, 'Henry', 80000, 4 ),
+ ( 3, 'Sam', 60000, NULL ),
+ ( 4, 'Max', 90000, NULL );
```
-## Solution
+## Solution
```sql
SELECT
- E1.NAME AS Employee
+ E1.NAME AS Employee
FROM
- Employee E1
- INNER JOIN Employee E2 ON E1.ManagerId = E2.Id
- AND E1.Salary > E2.Salary;
+ Employee E1
+ INNER JOIN Employee E2 ON E1.ManagerId = E2.Id
+ AND E1.Salary > E2.Salary;
```
-# 183. Customers Who Never Order
+# 183. Customers Who Never Order
https://leetcode.com/problems/customers-who-never-order/description/
-## Description
+## Description
-Curstomers 表：
+Curstomers 表：
```html
+----+-------+
-| Id | Name |
+| Id | Name |
+----+-------+
-| 1 | Joe |
-| 2 | Henry |
-| 3 | Sam |
-| 4 | Max |
+| 1 | Joe |
+| 2 | Henry |
+| 3 | Sam |
+| 4 | Max |
+----+-------+
```
-Orders 表：
+Orders 表：
```html
+----+------------+
-| Id | CustomerId |
+| Id | CustomerId |
+----+------------+
-| 1 | 3 |
-| 2 | 1 |
+| 1 | 3 |
+| 2 | 1 |
+----+------------+
```
@@ -520,155 +502,155 @@ Orders 表：
```html
+-----------+
-| Customers |
+| Customers |
+-----------+
-| Henry |
-| Max |
+| Henry |
+| Max |
+-----------+
```
-## SQL Schema
+## SQL Schema
```sql
-DROP TABLE
+DROP TABLE
IF
- EXISTS Customers;
-CREATE TABLE Customers ( Id INT, NAME VARCHAR ( 255 ) );
-DROP TABLE
+ EXISTS Customers;
+CREATE TABLE Customers ( Id INT, NAME VARCHAR ( 255 ) );
+DROP TABLE
IF
- EXISTS Orders;
-CREATE TABLE Orders ( Id INT, CustomerId INT );
-INSERT INTO Customers ( Id, NAME )
+ EXISTS Orders;
+CREATE TABLE Orders ( Id INT, CustomerId INT );
+INSERT INTO Customers ( Id, NAME )
VALUES
- ( 1, 'Joe' ),
- ( 2, 'Henry' ),
- ( 3, 'Sam' ),
- ( 4, 'Max' );
-INSERT INTO Orders ( Id, CustomerId )
+ ( 1, 'Joe' ),
+ ( 2, 'Henry' ),
+ ( 3, 'Sam' ),
+ ( 4, 'Max' );
+INSERT INTO Orders ( Id, CustomerId )
VALUES
- ( 1, 3 ),
- ( 2, 1 );
+ ( 1, 3 ),
+ ( 2, 1 );
```
-## Solution
+## Solution
左外链接
```sql
SELECT
- C.NAME AS Customers
+ C.NAME AS Customers
FROM
- Customers C
- LEFT JOIN Orders O ON C.Id = O.CustomerId
+ Customers C
+ LEFT JOIN Orders O ON C.Id = O.CustomerId
WHERE
- O.CustomerId IS NULL;
+ O.CustomerId IS NULL;
```
子查询
```sql
SELECT
- C.NAME AS Customers
+ C.NAME AS Customers
FROM
- Customers C
+ Customers C
WHERE
- C.Id NOT IN ( SELECT CustomerId FROM Orders );
+ C.Id NOT IN ( SELECT CustomerId FROM Orders );
```
-# 184. Department Highest Salary
+# 184. Department Highest Salary
https://leetcode.com/problems/department-highest-salary/description/
-## Description
+## Description
-Employee 表：
+Employee 表：
```html
+----+-------+--------+--------------+
-| Id | Name | Salary | DepartmentId |
+| Id | Name | Salary | DepartmentId |
+----+-------+--------+--------------+
-| 1 | Joe | 70000 | 1 |
-| 2 | Henry | 80000 | 2 |
-| 3 | Sam | 60000 | 2 |
-| 4 | Max | 90000 | 1 |
+| 1 | Joe | 70000 | 1 |
+| 2 | Henry | 80000 | 2 |
+| 3 | Sam | 60000 | 2 |
+| 4 | Max | 90000 | 1 |
+----+-------+--------+--------------+
```
-Department 表：
+Department 表：
```html
+----+----------+
-| Id | Name |
+| Id | Name |
+----+----------+
-| 1 | IT |
-| 2 | Sales |
+| 1 | IT |
+| 2 | Sales |
+----+----------+
```
-查找一个 Department 中收入最高者的信息：
+查找一个 Department 中收入最高者的信息：
```html
+------------+----------+--------+
-| Department | Employee | Salary |
+| Department | Employee | Salary |
+------------+----------+--------+
-| IT | Max | 90000 |
-| Sales | Henry | 80000 |
+| IT | Max | 90000 |
+| Sales | Henry | 80000 |
+------------+----------+--------+
```
-## SQL Schema
+## SQL Schema
```sql
-DROP TABLE IF EXISTS Employee;
-CREATE TABLE Employee ( Id INT, NAME VARCHAR ( 255 ), Salary INT, DepartmentId INT );
-DROP TABLE IF EXISTS Department;
-CREATE TABLE Department ( Id INT, NAME VARCHAR ( 255 ) );
-INSERT INTO Employee ( Id, NAME, Salary, DepartmentId )
+DROP TABLE IF EXISTS Employee;
+CREATE TABLE Employee ( Id INT, NAME VARCHAR ( 255 ), Salary INT, DepartmentId INT );
+DROP TABLE IF EXISTS Department;
+CREATE TABLE Department ( Id INT, NAME VARCHAR ( 255 ) );
+INSERT INTO Employee ( Id, NAME, Salary, DepartmentId )
VALUES
- ( 1, 'Joe', 70000, 1 ),
- ( 2, 'Henry', 80000, 2 ),
- ( 3, 'Sam', 60000, 2 ),
- ( 4, 'Max', 90000, 1 );
-INSERT INTO Department ( Id, NAME )
+ ( 1, 'Joe', 70000, 1 ),
+ ( 2, 'Henry', 80000, 2 ),
+ ( 3, 'Sam', 60000, 2 ),
+ ( 4, 'Max', 90000, 1 );
+INSERT INTO Department ( Id, NAME )
VALUES
- ( 1, 'IT' ),
- ( 2, 'Sales' );
+ ( 1, 'IT' ),
+ ( 2, 'Sales' );
```
-## Solution
+## Solution
-创建一个临时表，包含了部门员工的最大薪资。可以对部门进行分组，然后使用 MAX() 汇总函数取得最大薪资。
+创建一个临时表，包含了部门员工的最大薪资。可以对部门进行分组，然后使用 MAX() 汇总函数取得最大薪资。
之后使用连接将找到一个部门中薪资等于临时表中最大薪资的员工。
```sql
SELECT
- D.NAME Department,
- E.NAME Employee,
+ D.NAME Department,
+ E.NAME Employee,
E.Salary
FROM
- Employee E,
- Department D,
- ( SELECT DepartmentId, MAX( Salary ) Salary FROM Employee GROUP BY DepartmentId ) M
+ Employee E,
+ Department D,
+ ( SELECT DepartmentId, MAX( Salary ) Salary FROM Employee GROUP BY DepartmentId ) M
WHERE
- E.DepartmentId = D.Id
- AND E.DepartmentId = M.DepartmentId
- AND E.Salary = M.Salary;
+ E.DepartmentId = D.Id
+ AND E.DepartmentId = M.DepartmentId
+ AND E.Salary = M.Salary;
```
-# 176. Second Highest Salary
+# 176. Second Highest Salary
https://leetcode.com/problems/second-highest-salary/description/
-## Description
+## Description
```html
+----+--------+
-| Id | Salary |
+| Id | Salary |
+----+--------+
-| 1 | 100 |
-| 2 | 200 |
-| 3 | 300 |
+| 1 | 100 |
+| 2 | 200 |
+| 3 | 300 |
+----+--------+
```
@@ -676,76 +658,76 @@ https://leetcode.com/problems/second-highest-salary/description/
```html
+---------------------+
-| SecondHighestSalary |
+| SecondHighestSalary |
+---------------------+
-| 200 |
+| 200 |
+---------------------+
```
-如果没有找到，那么就返回 null 而不是不返回数据。
+如果没有找到，那么就返回 null 而不是不返回数据。
-## SQL Schema
+## SQL Schema
```sql
-DROP TABLE
+DROP TABLE
IF
- EXISTS Employee;
-CREATE TABLE Employee ( Id INT, Salary INT );
-INSERT INTO Employee ( Id, Salary )
+ EXISTS Employee;
+CREATE TABLE Employee ( Id INT, Salary INT );
+INSERT INTO Employee ( Id, Salary )
VALUES
- ( 1, 100 ),
- ( 2, 200 ),
- ( 3, 300 );
+ ( 1, 100 ),
+ ( 2, 200 ),
+ ( 3, 300 );
```
-## Solution
+## Solution
-为了在没有查找到数据时返回 null，需要在查询结果外面再套一层 SELECT。
+为了在没有查找到数据时返回 null，需要在查询结果外面再套一层 SELECT。
```sql
SELECT
- ( SELECT DISTINCT Salary FROM Employee ORDER BY Salary DESC LIMIT 1, 1 ) SecondHighestSalary;
+ ( SELECT DISTINCT Salary FROM Employee ORDER BY Salary DESC LIMIT 1, 1 ) SecondHighestSalary;
```
-# 177. Nth Highest Salary
+# 177. Nth Highest Salary
-## Description
+## Description
-查找工资第 N 高的员工。
+查找工资第 N 高的员工。
-## SQL Schema
+## SQL Schema
-同 176。
+同 176。
-## Solution
+## Solution
```sql
-CREATE FUNCTION getNthHighestSalary ( N INT ) RETURNS INT BEGIN
+CREATE FUNCTION getNthHighestSalary ( N INT ) RETURNS INT BEGIN
-SET N = N - 1;
-RETURN ( SELECT ( SELECT DISTINCT Salary FROM Employee ORDER BY Salary DESC LIMIT N, 1 ) );
+SET N = N - 1;
+RETURN ( SELECT ( SELECT DISTINCT Salary FROM Employee ORDER BY Salary DESC LIMIT N, 1 ) );
END
```
-# 178. Rank Scores
+# 178. Rank Scores
https://leetcode.com/problems/rank-scores/description/
-## Description
+## Description
得分表：
```html
+----+-------+
-| Id | Score |
+| Id | Score |
+----+-------+
-| 1 | 3.50 |
-| 2 | 3.65 |
-| 3 | 4.00 |
-| 4 | 3.85 |
-| 5 | 4.00 |
-| 6 | 3.65 |
+| 1 | 3.50 |
+| 2 | 3.65 |
+| 3 | 4.00 |
+| 4 | 3.85 |
+| 5 | 4.00 |
+| 6 | 3.65 |
+----+-------+
```
@@ -753,68 +735,68 @@ https://leetcode.com/problems/rank-scores/description/
```html
+-------+------+
-| Score | Rank |
+| Score | Rank |
+-------+------+
-| 4.00 | 1 |
-| 4.00 | 1 |
-| 3.85 | 2 |
-| 3.65 | 3 |
-| 3.65 | 3 |
-| 3.50 | 4 |
+| 4.00 | 1 |
+| 4.00 | 1 |
+| 3.85 | 2 |
+| 3.65 | 3 |
+| 3.65 | 3 |
+| 3.50 | 4 |
+-------+------+
```
-## SQL Schema
+## SQL Schema
```sql
-DROP TABLE
+DROP TABLE
IF
- EXISTS Scores;
-CREATE TABLE Scores ( Id INT, Score DECIMAL ( 3, 2 ) );
-INSERT INTO Scores ( Id, Score )
+ EXISTS Scores;
+CREATE TABLE Scores ( Id INT, Score DECIMAL ( 3, 2 ) );
+INSERT INTO Scores ( Id, Score )
VALUES
- ( 1, 3.5 ),
- ( 2, 3.65 ),
- ( 3, 4.0 ),
- ( 4, 3.85 ),
- ( 5, 4.0 ),
- ( 6, 3.65 );
+ ( 1, 3.5 ),
+ ( 2, 3.65 ),
+ ( 3, 4.0 ),
+ ( 4, 3.85 ),
+ ( 5, 4.0 ),
+ ( 6, 3.65 );
```
-## Solution
+## Solution
```sql
SELECT
- S1.score,
- COUNT( DISTINCT S2.score ) Rank
+ S1.score,
+ COUNT( DISTINCT S2.score ) Rank
FROM
- Scores S1
- INNER JOIN Scores S2 ON S1.score <= S2.score
-GROUP BY
- S1.id
-ORDER BY
- S1.score DESC;
+ Scores S1
+ INNER JOIN Scores S2 ON S1.score <= S2.score
+GROUP BY
+ S1.id
+ORDER BY
+ S1.score DESC;
```
-# 180. Consecutive Numbers
+# 180. Consecutive Numbers
https://leetcode.com/problems/consecutive-numbers/description/
-## Description
+## Description
数字表：
```html
+----+-----+
-| Id | Num |
+| Id | Num |
+----+-----+
-| 1 | 1 |
-| 2 | 1 |
-| 3 | 1 |
-| 4 | 2 |
-| 5 | 1 |
-| 6 | 2 |
-| 7 | 2 |
+| 1 | 1 |
+| 2 | 1 |
+| 3 | 1 |
+| 4 | 2 |
+| 5 | 1 |
+| 6 | 2 |
+| 7 | 2 |
+----+-----+
```
@@ -822,41 +804,41 @@ https://leetcode.com/problems/consecutive-numbers/description/
```html
+-----------------+
-| ConsecutiveNums |
+| ConsecutiveNums |
+-----------------+
-| 1 |
+| 1 |
+-----------------+
```
-## SQL Schema
+## SQL Schema
```sql
-DROP TABLE
+DROP TABLE
IF
- EXISTS LOGS;
-CREATE TABLE LOGS ( Id INT, Num INT );
-INSERT INTO LOGS ( Id, Num )
+ EXISTS LOGS;
+CREATE TABLE LOGS ( Id INT, Num INT );
+INSERT INTO LOGS ( Id, Num )
VALUES
- ( 1, 1 ),
- ( 2, 1 ),
- ( 3, 1 ),
- ( 4, 2 ),
- ( 5, 1 ),
- ( 6, 2 ),
- ( 7, 2 );
+ ( 1, 1 ),
+ ( 2, 1 ),
+ ( 3, 1 ),
+ ( 4, 2 ),
+ ( 5, 1 ),
+ ( 6, 2 ),
+ ( 7, 2 );
```
-## Solution
+## Solution
```sql
SELECT
- DISTINCT L1.num ConsecutiveNums
+ DISTINCT L1.num ConsecutiveNums
FROM
- Logs L1,
- Logs L2,
- Logs L3
-WHERE L1.id = l2.id - 1
- AND L2.id = L3.id - 1
- AND L1.num = L2.num
- AND l2.num = l3.num;
+ Logs L1,
+ Logs L2,
+ Logs L3
+WHERE L1.id = l2.id - 1
+ AND L2.id = L3.id - 1
+ AND L1.num = L2.num
+ AND l2.num = l3.num;
```
diff --git a/notes/Linux.md b/notes/Linux.md
index f19f3e11..434c5ed2 100644
--- a/notes/Linux.md
+++ b/notes/Linux.md
@@ -1,1256 +1,1208 @@
-
-* [一、常用操作以及概念](#一常用操作以及概念)
- * [快捷键](#快捷键)
- * [求助](#求助)
- * [关机](#关机)
- * [PATH](#path)
- * [sudo](#sudo)
- * [包管理工具](#包管理工具)
- * [发行版](#发行版)
- * [VIM 三个模式](#vim-三个模式)
- * [GNU](#gnu)
- * [开源协议](#开源协议)
-* [二、磁盘](#二磁盘)
- * [HDD](#hdd)
- * [磁盘接口](#磁盘接口)
- * [磁盘的文件名](#磁盘的文件名)
-* [三、分区](#三分区)
- * [分区表](#分区表)
- * [开机检测程序](#开机检测程序)
-* [四、文件系统](#四文件系统)
- * [分区与文件系统](#分区与文件系统)
- * [组成](#组成)
- * [文件读取](#文件读取)
- * [磁盘碎片](#磁盘碎片)
- * [block](#block)
- * [inode](#inode)
- * [目录](#目录)
- * [日志](#日志)
- * [挂载](#挂载)
- * [目录配置](#目录配置)
-* [五、文件](#五文件)
- * [文件属性](#文件属性)
- * [文件与目录的基本操作](#文件与目录的基本操作)
- * [修改权限](#修改权限)
- * [文件默认权限](#文件默认权限)
- * [目录的权限](#目录的权限)
- * [链接](#链接)
- * [获取文件内容](#获取文件内容)
- * [指令与文件搜索](#指令与文件搜索)
-* [六、压缩与打包](#六压缩与打包)
- * [压缩文件名](#压缩文件名)
- * [压缩指令](#压缩指令)
- * [打包](#打包)
-* [七、Bash](#七bash)
- * [特性](#特性)
- * [变量操作](#变量操作)
- * [指令搜索顺序](#指令搜索顺序)
- * [数据流重定向](#数据流重定向)
-* [八、管线指令](#八管线指令)
- * [提取指令](#提取指令)
- * [排序指令](#排序指令)
- * [双向输出重定向](#双向输出重定向)
- * [字符转换指令](#字符转换指令)
- * [分区指令](#分区指令)
-* [九、正则表达式](#九正则表达式)
- * [grep](#grep)
- * [printf](#printf)
- * [awk](#awk)
-* [十、进程管理](#十进程管理)
- * [查看进程](#查看进程)
- * [进程状态](#进程状态)
- * [SIGCHLD](#sigchld)
- * [wait()](#wait)
- * [waitpid()](#waitpid)
- * [孤儿进程](#孤儿进程)
- * [僵死进程](#僵死进程)
-* [参考资料](#参考资料)
-
+# 一、常用操作以及概念
+## 快捷键
-# 一、常用操作以及概念
+- Tab：命令和文件名补全；
+- Ctrl+C：中断正在运行的程序；
+- Ctrl+D：结束键盘输入（End Of File，EOF）
-## 快捷键
+## 求助
-- Tab：命令和文件名补全；
-- Ctrl+C：中断正在运行的程序；
-- Ctrl+D：结束键盘输入（End Of File，EOF）
-
-## 求助
-
-### 1. --help
+### 1. --help
指令的基本用法与选项介绍。
-### 2. man
+### 2. man
-man 是 manual 的缩写，将指令的具体信息显示出来。
+man 是 manual 的缩写，将指令的具体信息显示出来。
-当执行`man date`时，有 DATE(1) 出现，其中的数字代表指令的类型，常用的数字及其类型如下：
+当执行`man date`时，有 DATE(1) 出现，其中的数字代表指令的类型，常用的数字及其类型如下：
-| 代号 | 类型 |
-| :--: | -- |
-| 1 | 用户在 shell 环境中可以操作的指令或者可执行文件 |
-| 5 | 配置文件 |
-| 8 | 系统管理员可以使用的管理指令 |
+| 代号 | 类型 |
+| :--: | -- |
+| 1 | 用户在 shell 环境中可以操作的指令或者可执行文件 |
+| 5 | 配置文件 |
+| 8 | 系统管理员可以使用的管理指令 |
-### 3. info
+### 3. info
-info 与 man 类似，但是 info 将文档分成一个个页面，每个页面可以进行跳转。
+info 与 man 类似，但是 info 将文档分成一个个页面，每个页面可以进行跳转。
-### 4. doc
+### 4. doc
-/usr/share/doc 存放着软件的一整套说明文件。
+/usr/share/doc 存放着软件的一整套说明文件。
-## 关机
+## 关机
-### 1. who
+### 1. who
-在关机前需要先使用 who 命令查看有没有其它用户在线。
+在关机前需要先使用 who 命令查看有没有其它用户在线。
-### 2. sync
+### 2. sync
-为了加快对磁盘文件的读写速度，位于内存中的文件数据不会立即同步到磁盘上，因此关机之前需要先进行 sync 同步操作。
+为了加快对磁盘文件的读写速度，位于内存中的文件数据不会立即同步到磁盘上，因此关机之前需要先进行 sync 同步操作。
-### 3. shutdown
+### 3. shutdown
```html
-# shutdown [-krhc] 时间 [信息]
--k ： 不会关机，只是发送警告信息，通知所有在线的用户
--r ： 将系统的服务停掉后就重新启动
--h ： 将系统的服务停掉后就立即关机
--c ： 取消已经在进行的 shutdown 指令内容
+# shutdown [-krhc] 时间 [信息]
+-k ： 不会关机，只是发送警告信息，通知所有在线的用户
+-r ： 将系统的服务停掉后就重新启动
+-h ： 将系统的服务停掉后就立即关机
+-c ： 取消已经在进行的 shutdown 指令内容
```
-## PATH
+## PATH
-可以在环境变量 PATH 中声明可执行文件的路径，路径之间用 : 分隔。
+可以在环境变量 PATH 中声明可执行文件的路径，路径之间用 : 分隔。
```html
/usr/local/bin:/usr/bin:/usr/local/sbin:/usr/sbin:/home/dmtsai/.local/bin:/home/dmtsai/bin
```
-## sudo
+## sudo
-sudo 允许一般用户使用 root 可执行的命令，不过只有在 /etc/sudoers 配置文件中添加的用户才能使用该指令。
+sudo 允许一般用户使用 root 可执行的命令，不过只有在 /etc/sudoers 配置文件中添加的用户才能使用该指令。
-## 包管理工具
+## 包管理工具
-RPM 和 DPKG 为最常见的两类软件包管理工具。RPM 全称为 Redhat Package Manager，最早由 Red Hat 公司制定实施，随后被 GNU 开源操作系统接受并成为很多 Linux 系统 (RHEL) 的既定软件标准。与 RPM 进行竞争的是基于 Debian 操作系统 (UBUNTU) 的 DEB 软件包管理工具 DPKG，全称为 Debian Package，功能方面与 RPM 相似。
+RPM 和 DPKG 为最常见的两类软件包管理工具。RPM 全称为 Redhat Package Manager，最早由 Red Hat 公司制定实施，随后被 GNU 开源操作系统接受并成为很多 Linux 系统 (RHEL) 的既定软件标准。与 RPM 进行竞争的是基于 Debian 操作系统 (UBUNTU) 的 DEB 软件包管理工具 DPKG，全称为 Debian Package，功能方面与 RPM 相似。
-YUM 基于 RPM，具有依赖管理功能，并具有软件升级的功能。
+YUM 基于 RPM，具有依赖管理功能，并具有软件升级的功能。
-## 发行版
+## 发行版
-Linux 发行版是 Linux 内核及各种应用软件的集成版本。
+Linux 发行版是 Linux 内核及各种应用软件的集成版本。
-| 基于的包管理工具 | 商业发行版 | 社区发行版 |
-| :--: | :--: | :--: |
-| RPM | Red Hat | Fedora / CentOS |
-| DPKG | Ubuntu | Debian |
+| 基于的包管理工具 | 商业发行版 | 社区发行版 |
+| :--: | :--: | :--: |
+| RPM | Red Hat | Fedora / CentOS |
+| DPKG | Ubuntu | Debian |
-## VIM 三个模式
+## VIM 三个模式
-- 一般指令模式（Command mode）：VIM 的默认模式，可以用于移动游标查看内容；
-- 编辑模式（Insert mode）：按下 "i" 等按键之后进入，可以对文本进行编辑；
-- 指令列模式（Bottom-line mode）：按下 ":" 按键之后进入，用于保存退出等操作。
+- 一般指令模式（Command mode）：VIM 的默认模式，可以用于移动游标查看内容；
+- 编辑模式（Insert mode）：按下 "i" 等按键之后进入，可以对文本进行编辑；
+- 指令列模式（Bottom-line mode）：按下 ":" 按键之后进入，用于保存退出等操作。
-33 TB = 8 ZB。
+MBR 不支持 2.2 TB 以上的硬盘，GPT 则最多支持到 233 TB = 8 ZB。
-i 和 keyi+1 ，且不为 null，则该指针指向节点的所有 key 大于等于 keyi 且小于等于 keyi+1 。
+- 所有叶节点具有相同的深度，也就是说 B-Tree 是平衡的；
+- 一个节点中的 key 从左到右非递减排列；
+- 如果某个指针的左右相邻 key 分别是 keyi 和 keyi+1 ，且不为 null，则该指针指向节点的所有 key 大于等于 keyi 且小于等于 keyi+1 。
-查找算法：首先在根节点进行二分查找，如果找到则返回对应节点的 data，否则在相应区间的指针指向的节点递归进行查找。
+查找算法：首先在根节点进行二分查找，如果找到则返回对应节点的 data，否则在相应区间的指针指向的节点递归进行查找。
-由于插入删除新的数据记录会破坏 B-Tree 的性质，因此在插入删除时，需要对树进行一个分裂、合并、转移等操作以保持 B-Tree 性质。
+由于插入删除新的数据记录会破坏 B-Tree 的性质，因此在插入删除时，需要对树进行一个分裂、合并、转移等操作以保持 B-Tree 性质。
-### 2. B+Tree
+### 2. B+Tree
-d N)，其中 d 为每个节点的出度。
+平衡树检索数据的时间复杂度等于树高 h，而树高大致为 O(h)=O(logd N)，其中 d 为每个节点的出度。
-红黑树的出度为 2，而 B+Tree 与 B-Tree 的出度一般都非常大。红黑树的树高 h 很明显比 B+Tree 和 B-Tree 大非常多，因此检索的次数也就更多。
+红黑树的出度为 2，而 B+Tree 与 B-Tree 的出度一般都非常大。红黑树的树高 h 很明显比 B+Tree 和 B-Tree 大非常多，因此检索的次数也就更多。
-B+Tree 相比于 B-Tree 更适合外存索引，因为 B+Tree 内节点去掉了 data 域，因此可以拥有更大的出度，检索效率会更高。
+B+Tree 相比于 B-Tree 更适合外存索引，因为 B+Tree 内节点去掉了 data 域，因此可以拥有更大的出度，检索效率会更高。
-**（二）利用计算机预读特性**
+**（二）利用计算机预读特性**
-为了减少磁盘 I/O，磁盘往往不是严格按需读取，而是每次都会预读。这样做的理论依据是计算机科学中著名的局部性原理：当一个数据被用到时，其附近的数据也通常会马上被使用。预读过程中，磁盘进行顺序读取，顺序读取不需要进行磁盘寻道，并且只需要很短的旋转时间，因此速度会非常快。
+为了减少磁盘 I/O，磁盘往往不是严格按需读取，而是每次都会预读。这样做的理论依据是计算机科学中著名的局部性原理：当一个数据被用到时，其附近的数据也通常会马上被使用。预读过程中，磁盘进行顺序读取，顺序读取不需要进行磁盘寻道，并且只需要很短的旋转时间，因此速度会非常快。
-操作系统一般将内存和磁盘分割成固态大小的块，每一块称为一页，内存与磁盘以页为单位交换数据。数据库系统将索引的一个节点的大小设置为页的大小，使得一次 I/O 就能完全载入一个节点，并且可以利用预读特性，临近的节点也能够被预先载入。
+操作系统一般将内存和磁盘分割成固态大小的块，每一块称为一页，内存与磁盘以页为单位交换数据。数据库系统将索引的一个节点的大小设置为页的大小，使得一次 I/O 就能完全载入一个节点，并且可以利用预读特性，临近的节点也能够被预先载入。
-更多内容请参考：[MySQL 索引背后的数据结构及算法原理](http://blog.codinglabs.org/articles/theory-of-mysql-index.html)
+更多内容请参考：[MySQL 索引背后的数据结构及算法原理](http://blog.codinglabs.org/articles/theory-of-mysql-index.html)
-## 索引分类
+## 索引分类
-### 1. B+Tree 索引
+### 1. B+Tree 索引
- scoreMap = new HashMap<>();
+// The first String is student's name
+// The Second Integer is student's score
+Map scoreMap = new HashMap<>();
```
```java
-// Student's name -> Student's score
-Map scoreMap = new HashMap<>();
+// Student's name -> Student's score
+Map scoreMap = new HashMap<>();
```
添加测试用例来说明：
```java
-// ...
-// Example: add(1, 2), return 3
-int add(int x, int y) {
- return x + y;
+// ...
+// Example: add(1, 2), return 3
+int add(int x, int y) {
+ return x + y;
}
```
在很复杂的函数调用中对每个参数标上名字：
```java
-int a = 1;
-int b = 2;
-int num = add(\* x = *\ a, \* y = *\ b);
+int a = 1;
+int b = 2;
+int num = add(\* x = *\ a, \* y = *\ b);
```
使用专业名词来缩短概念上的解释，比如用设计模式名来说明代码。
-# 七、提高控制流的可读性
+# 七、提高控制流的可读性
条件表达式中，左侧是变量，右侧是常数。比如下面第一个语句正确：
```java
-if (len < 10)
-if (10 > len)
+if (len < 10)
+if (10 > len)
```
-if / else 条件语句，逻辑的处理顺序为：① 正逻辑；② 关键逻辑；③ 简单逻辑。
+if / else 条件语句，逻辑的处理顺序为：① 正逻辑；② 关键逻辑；③ 简单逻辑。
```java
-if (a == b) {
- // 正逻辑
-} else{
- // 反逻辑
+if (a == b) {
+ // 正逻辑
+} else{
+ // 反逻辑
}
```
-只有在逻辑简单的情况下使用 ? : 三目运算符来使代码更紧凑，否则应该拆分成 if / else；
+只有在逻辑简单的情况下使用 ? : 三目运算符来使代码更紧凑，否则应该拆分成 if / else；
-do / while 的条件放在后面，不够简单明了，并且会有一些迷惑的地方，最好使用 while 来代替。
+do / while 的条件放在后面，不够简单明了，并且会有一些迷惑的地方，最好使用 while 来代替。
-如果只有一个 goto 目标，那么 goto 尚且还能接受，但是过于复杂的 goto 会让代码可读性特别差，应该避免使用 goto。
+如果只有一个 goto 目标，那么 goto 尚且还能接受，但是过于复杂的 goto 会让代码可读性特别差，应该避免使用 goto。
-在嵌套的循环中，用一些 return 语句往往能减少嵌套的层数。
+在嵌套的循环中，用一些 return 语句往往能减少嵌套的层数。
-# 八、拆分长表达式
+# 八、拆分长表达式
长表达式的可读性很差，可以引入一些解释变量从而拆分表达式：
```python
-if line.split(':')[0].strip() == "root":
- ...
+if line.split(':')[0].strip() == "root":
+ ...
```
```python
-username = line.split(':')[0].strip()
-if username == "root":
- ...
+username = line.split(':')[0].strip()
+if username == "root":
+ ...
```
使用摩根定理简化一些逻辑表达式：
```java
-if (!a && !b) {
- ...
+if (!a && !b) {
+ ...
}
```
```java
-if (!(a || b)) {
- ...
+if (!(a || b)) {
+ ...
}
```
-# 九、变量与可读性
+# 九、变量与可读性
-**去除控制流变量** 。在循环中通过使用 break 或者 return 可以减少控制流变量的使用。
+**去除控制流变量**。在循环中通过使用 break 或者 return 可以减少控制流变量的使用。
```java
-boolean done = false;
-while (/* condition */ && !done) {
- ...
- if ( ... ) {
- done = true;
- continue;
- }
+boolean done = false;
+while (/* condition */ && !done) {
+ ...
+ if ( ... ) {
+ done = true;
+ continue;
+ }
}
```
```java
-while(/* condition */) {
- ...
- if ( ... ) {
- break;
- }
+while(/* condition */) {
+ ...
+ if ( ... ) {
+ break;
+ }
}
```
-**减小变量作用域** 。作用域越小，越容易定位到变量所有使用的地方。
+**减小变量作用域**。作用域越小，越容易定位到变量所有使用的地方。
-JavaScript 可以用闭包减小作用域。以下代码中 submit_form 是函数变量，submitted 变量控制函数不会被提交两次。第一个实现中 submitted 是全局变量，第二个实现把 submitted 放到匿名函数中，从而限制了起作用域范围。
+JavaScript 可以用闭包减小作用域。以下代码中 submit_form 是函数变量，submitted 变量控制函数不会被提交两次。第一个实现中 submitted 是全局变量，第二个实现把 submitted 放到匿名函数中，从而限制了起作用域范围。
```js
-submitted = false;
-var submit_form = function(form_name) {
- if (submitted) {
- return;
- }
- submitted = true;
+submitted = false;
+var submit_form = function(form_name) {
+ if (submitted) {
+ return;
+ }
+ submitted = true;
};
```
```js
-var submit_form = (function() {
- var submitted = false;
- return function(form_name) {
- if(submitted) {
- return;
- }
- submitted = true;
- }
-}()); // () 使得外层匿名函数立即执行
+var submit_form = (function() {
+ var submitted = false;
+ return function(form_name) {
+ if(submitted) {
+ return;
+ }
+ submitted = true;
+ }
+}()); // () 使得外层匿名函数立即执行
```
-JavaScript 中没有用 var 声明的变量都是全局变量，而全局变量很容易造成迷惑，因此应当总是用 var 来声明变量。
+JavaScript 中没有用 var 声明的变量都是全局变量，而全局变量很容易造成迷惑，因此应当总是用 var 来声明变量。
变量定义的位置应当离它使用的位置最近。
-**实例解析**
+**实例解析**
在一个网页中有以下文本输入字段：
```html
-
+
+
+
```
-现在要接受一个字符串并把它放到第一个空的 input 字段中，初始实现如下：
+现在要接受一个字符串并把它放到第一个空的 input 字段中，初始实现如下：
```js
-var setFirstEmptyInput = function(new_alue) {
- var found = false;
- var i = 1;
- var elem = document.getElementById('input' + i);
- while (elem != null) {
- if (elem.value === '') {
- found = true;
- break;
- }
- i++;
- elem = document.getElementById('input' + i);
- }
- if (found) elem.value = new_value;
- return elem;
+var setFirstEmptyInput = function(new_alue) {
+ var found = false;
+ var i = 1;
+ var elem = document.getElementById('input' + i);
+ while (elem != null) {
+ if (elem.value === '') {
+ found = true;
+ break;
+ }
+ i++;
+ elem = document.getElementById('input' + i);
+ }
+ if (found) elem.value = new_value;
+ return elem;
}
```
以上实现有以下问题：
-- found 可以去除；
-- elem 作用域过大；
-- 可以用 for 循环代替 while 循环；
+- found 可以去除；
+- elem 作用域过大；
+- 可以用 for 循环代替 while 循环；
```js
-var setFirstEmptyInput = function(new_value) {
- for (var i = 1; true; i++) {
- var elem = document.getElementById('input' + i);
- if (elem === null) {
- return null;
- }
- if (elem.value === '') {
- elem.value = new_value;
- return elem;
- }
- }
+var setFirstEmptyInput = function(new_value) {
+ for (var i = 1; true; i++) {
+ var elem = document.getElementById('input' + i);
+ if (elem === null) {
+ return null;
+ }
+ if (elem.value === '') {
+ elem.value = new_value;
+ return elem;
+ }
+ }
};
```
-# 十、抽取函数
+# 十、抽取函数
工程学就是把大问题拆分成小问题再把这些问题的解决方案放回一起。
@@ -288,38 +270,38 @@ var setFirstEmptyInput = function(new_value) {
介绍性的代码：
```java
-int findClostElement(int[] arr) {
- int clostIdx;
- int clostDist = Interger.MAX_VALUE;
- for (int i = 0; i < arr.length; i++) {
- int x = ...;
- int y = ...;
- int z = ...;
- int value = x * y * z;
- int dist = Math.sqrt(Math.pow(value, 2), Math.pow(arr[i], 2));
- if (dist < clostDist) {
- clostIdx = i;
- clostDist = value;
- }
- }
- return clostIdx;
+int findClostElement(int[] arr) {
+ int clostIdx;
+ int clostDist = Interger.MAX_VALUE;
+ for (int i = 0; i < arr.length; i++) {
+ int x = ...;
+ int y = ...;
+ int z = ...;
+ int value = x * y * z;
+ int dist = Math.sqrt(Math.pow(value, 2), Math.pow(arr[i], 2));
+ if (dist < clostDist) {
+ clostIdx = i;
+ clostDist = value;
+ }
+ }
+ return clostIdx;
}
```
以上代码中循环部分主要计算距离，这部分不属于代码高层次目标，高层次目标是寻找最小距离的值，因此可以把这部分代替提取到独立的函数中。这样做也带来一个额外的好处有：可以单独进行测试、可以快速找到程序错误并修改。
```java
-public int findClostElement(int[] arr) {
- int clostIdx;
- int clostDist = Interger.MAX_VALUE;
- for (int i = 0; i < arr.length; i++) {
- int dist = computDist(arr, i);
- if (dist < clostDist) {
- clostIdx = i;
- clostDist = value;
- }
- }
- return clostIdx;
+public int findClostElement(int[] arr) {
+ int clostIdx;
+ int clostDist = Interger.MAX_VALUE;
+ for (int i = 0; i < arr.length; i++) {
+ int dist = computDist(arr, i);
+ if (dist < clostDist) {
+ clostIdx = i;
+ clostDist = value;
+ }
+ }
+ return clostIdx;
}
```
@@ -327,22 +309,22 @@ public int findClostElement(int[] arr) {
函数抽取也用于减小代码的冗余。
-# 十一、一次只做一件事
+# 十一、一次只做一件事
只做一件事的代码很容易让人知道其要做的事；
基本流程：列出代码所做的所有任务；把每个任务拆分到不同的函数，或者不同的段落。
-# 十二、用自然语言表述代码
+# 十二、用自然语言表述代码
先用自然语言书写代码逻辑，也就是伪代码，然后再写代码，这样代码逻辑会更清晰。
-# 十三、减少代码量
+# 十三、减少代码量
不要过度设计，编码过程会有很多变化，过度设计的内容到最后往往是无用的。
多用标准库实现。
-# 参考资料
+# 参考资料
-- Dustin, Boswell, Trevor, 等. 编写可读代码的艺术 [M]. 机械工业出版社, 2012.
+- Dustin, Boswell, Trevor, 等. 编写可读代码的艺术 [M]. 机械工业出版社, 2012.
\ No newline at end of file
diff --git a/notes/代码风格规范.md b/notes/代码风格规范.md
index 62049b68..a165d3fa 100644
--- a/notes/代码风格规范.md
+++ b/notes/代码风格规范.md
@@ -1,21 +1,14 @@
-
-* [Google Java Style Guide](#google-java-style-guide)
-* [Google C++ Style Guide](#google-c-style-guide)
-* [Google Python Style Guide](#google-python-style-guide)
-
+# Google Java Style Guide
+- http://www.hawstein.com/posts/google-java-style.html
+- http://google.github.io/styleguide/javaguide.html
-# Google Java Style Guide
+# Google C++ Style Guide
-- http://www.hawstein.com/posts/google-java-style.html
-- http://google.github.io/styleguide/javaguide.html
+- http://zh-google-styleguide.readthedocs.io/en/latest/google-cpp-styleguide/contents/
+- http://google.github.io/styleguide/cppguide.html
-# Google C++ Style Guide
+# Google Python Style Guide
-- http://zh-google-styleguide.readthedocs.io/en/latest/google-cpp-styleguide/contents/
-- http://google.github.io/styleguide/cppguide.html
-
-# Google Python Style Guide
-
-- http://zh-google-styleguide.readthedocs.io/en/latest/google-python-styleguide/contents/
-- http://google.github.io/styleguide/pyguide.html
+- http://zh-google-styleguide.readthedocs.io/en/latest/google-python-styleguide/contents/
+- http://google.github.io/styleguide/pyguide.html
diff --git a/notes/分布式基础.md b/notes/分布式基础.md
index ba6ecf75..e8110c87 100644
--- a/notes/分布式基础.md
+++ b/notes/分布式基础.md
@@ -1,60 +1,34 @@
-
-* [一、基本概念](#一基本概念)
- * [异常](#异常)
- * [超时](#超时)
- * [衡量指标](#衡量指标)
-* [二、数据分布](#二数据分布)
- * [哈希分布](#哈希分布)
- * [顺序分布](#顺序分布)
- * [负载均衡](#负载均衡)
-* [三、复制](#三复制)
- * [复制原理](#复制原理)
- * [复制协议](#复制协议)
- * [CAP](#cap)
- * [BASE](#base)
-* [四、容错](#四容错)
- * [故障检测](#故障检测)
- * [故障恢复](#故障恢复)
-* [五、一致性协议](#五一致性协议)
- * [Paxos 协议](#paxos-协议)
- * [Raft 协议](#raft-协议)
- * [拜占庭将军问题](#拜占庭将军问题)
-* [六、CDN 架构](#六cdn-架构)
-* [参考资料](#参考资料)
-
+# 一、基本概念
+## 异常
-# 一、基本概念
-
-## 异常
-
-### 1. 服务器宕机
+### 1. 服务器宕机
内存错误、服务器停电等都会导致服务器宕机，此时节点无法正常工作，称为不可用。
服务器宕机会导致节点失去所有内存信息，因此需要将内存信息保存到持久化介质上。
-### 2. 网络异常
+### 2. 网络异常
-有一种特殊的网络异常称为 **网络分区** ，即集群的所有节点被划分为多个区域，每个区域内部可以通信，但是区域之间无法通信。
+有一种特殊的网络异常称为 **网络分区**，即集群的所有节点被划分为多个区域，每个区域内部可以通信，但是区域之间无法通信。
-### 3. 磁盘故障
+### 3. 磁盘故障
磁盘故障是一种发生概率很高的异常。
使用冗余机制，将数据存储到多台服务器。
-## 超时
+## 超时
在分布式系统中，一个请求除了成功和失败两种状态，还存在着超时状态。
-n -1]，将该哈希空间看成一个哈希环，将每个节点都配置到哈希环上。每个数据对象通过哈希取模得到哈希值之后，存放到哈希环中顺时针方向第一个大于等于该哈希值的节点上。
+Distributed Hash Table（DHT）：对于哈希空间 [0, 2n -1]，将该哈希空间看成一个哈希环，将每个节点都配置到哈希环上。每个数据对象通过哈希取模得到哈希值之后，存放到哈希环中顺时针方向第一个大于等于该哈希值的节点上。
-n -1]，将
一个新上线的工作节点，由于其负载较低，如果不加控制，总控节点会将大量数据同时迁移到该节点上，造成该节点一段时间内无法工作。因此负载均衡操作需要平滑进行，新加入的节点需要较长的一段时间来达到比较均衡的状态。
-# 三、复制
+# 三、复制
-## 复制原理
+## 复制原理
复制是保证分布式系统高可用的基础，让一个数据存储多个副本，当某个副本所在的节点出现故障时，能够自动切换到其它副本上，从而实现故障恢复。
@@ -132,13 +106,13 @@ Distributed Hash Table（DHT）：对于哈希空间 [0, 2n -1]，将
主副本将同步操作日志发送给备副本，备副本通过回放操作日志获取最新修改。
-n -1]，将
缺点：可用性差，因为主副本需要等待，那么整个分布式系统的可用时间就会降低。
-### 2. 异步复制协议
+### 2. 异步复制协议
主副本将同步操作日志发给备副本之后不需要进行等待，直接修改主副本并通知客户端操作成功。
@@ -154,189 +128,215 @@ Distributed Hash Table（DHT）：对于哈希空间 [0, 2n -1]，将
缺点：一致性差。
-## CAP
+## CAP
-分布式存储系统不可能同时满足一致性（C：Consistency）、可用性（A：Availability）和分区容忍性（P：Partition tolerance），最多只能同时满足其中两项。
+分布式存储系统不可能同时满足一致性（C：Consistency）、可用性（A：Availability）和分区容忍性（P：Partition tolerance），最多只能同时满足其中两项。
-在设计分布式系统时，需要根据实际需求弱化某一要求。因此就有了下图中的三种设计：CA、CP 和 AP。
+在设计分布式系统时，需要根据实际需求弱化某一要求。因此就有了下图中的三种设计：CA、CP 和 AP。
需要注意的是，分区容忍性必不可少，因为需要总是假设网络是不可靠的，并且系统需要能够自动容错，因此实际上设计分布式存储系统需要在一致性和可用性之间做权衡。上一节介绍的强同步协议和异步复制协议就是在一致性和可用性做权衡得到的结果。
- printListFromTailToHead(ListNode listNode) {
- Stack stack = new Stack<>();
- while (listNode != null) {
- stack.add(listNode.val);
- listNode = listNode.next;
- }
- ArrayList ret = new ArrayList<>();
- while (!stack.isEmpty())
- ret.add(stack.pop());
- return ret;
+public ArrayList printListFromTailToHead(ListNode listNode) {
+ Stack stack = new Stack<>();
+ while (listNode != null) {
+ stack.add(listNode.val);
+ listNode = listNode.next;
+ }
+ ArrayList ret = new ArrayList<>();
+ while (!stack.isEmpty())
+ ret.add(stack.pop());
+ return ret;
}
```
-### 使用递归
+### 使用递归
```java
-public ArrayList printListFromTailToHead(ListNode listNode) {
- ArrayList ret = new ArrayList<>();
- if (listNode != null) {
- ret.addAll(printListFromTailToHead(listNode.next));
- ret.add(listNode.val);
- }
- return ret;
+public ArrayList printListFromTailToHead(ListNode listNode) {
+ ArrayList ret = new ArrayList<>();
+ if (listNode != null) {
+ ret.addAll(printListFromTailToHead(listNode.next));
+ ret.add(listNode.val);
+ }
+ return ret;
}
```
-### 使用 Collections.reverse()
+### 使用 Collections.reverse()
```java
-public ArrayList printListFromTailToHead(ListNode listNode) {
- ArrayList ret = new ArrayList<>();
- while (listNode != null) {
- ret.add(listNode.val);
- listNode = listNode.next;
- }
- Collections.reverse(ret);
- return ret;
+public ArrayList printListFromTailToHead(ListNode listNode) {
+ ArrayList ret = new ArrayList<>();
+ while (listNode != null) {
+ ret.add(listNode.val);
+ listNode = listNode.next;
+ }
+ Collections.reverse(ret);
+ return ret;
}
```
-### 使用头插法
+### 使用头插法
利用链表头插法为逆序的特点。
头结点和第一个节点的区别：头结点是在头插法中使用的一个额外节点，这个节点不存储值；第一个节点就是链表的第一个真正存储值的节点。
```java
-public ArrayList printListFromTailToHead(ListNode listNode) {
- // 头插法构建逆序链表
- ListNode head = new ListNode(-1);
- while (listNode != null) {
- ListNode memo = listNode.next;
- listNode.next = head.next;
- head.next = listNode;
- listNode = memo;
- }
- // 构建 ArrayList
- ArrayList ret = new ArrayList<>();
- head = head.next;
- while (head != null) {
- ret.add(head.val);
- head = head.next;
- }
- return ret;
+public ArrayList printListFromTailToHead(ListNode listNode) {
+ // 头插法构建逆序链表
+ ListNode head = new ListNode(-1);
+ while (listNode != null) {
+ ListNode memo = listNode.next;
+ listNode.next = head.next;
+ head.next = listNode;
+ listNode = memo;
+ }
+ // 构建 ArrayList
+ ArrayList ret = new ArrayList<>();
+ head = head.next;
+ while (head != null) {
+ ret.add(head.val);
+ head = head.next;
+ }
+ return ret;
}
```
-# 7. 重建二叉树
+# 7. 重建二叉树
[NowCoder](https://www.nowcoder.com/practice/8a19cbe657394eeaac2f6ea9b0f6fcf6?tpId=13&tqId=11157&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
-## 题目描述
+## 题目描述
根据二叉树的前序遍历和中序遍历的结果，重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。
```html
-preorder = [3,9,20,15,7]
-inorder = [9,3,15,20,7]
+preorder = [3,9,20,15,7]
+inorder = [9,3,15,20,7]
```
- inOrderNumsIndexs = new HashMap<>(); // 缓存中序遍历数组的每个值对应的索引
+private Map inOrderNumsIndexs = new HashMap<>(); // 缓存中序遍历数组的每个值对应的索引
-public TreeNode reConstructBinaryTree(int[] pre, int[] in) {
- for (int i = 0; i < in.length; i++)
- inOrderNumsIndexs.put(in[i], i);
- return reConstructBinaryTree(pre, 0, pre.length - 1, in, 0, in.length - 1);
+public TreeNode reConstructBinaryTree(int[] pre, int[] in) {
+ for (int i = 0; i < in.length; i++)
+ inOrderNumsIndexs.put(in[i], i);
+ return reConstructBinaryTree(pre, 0, pre.length - 1, in, 0, in.length - 1);
}
-private TreeNode reConstructBinaryTree(int[] pre, int preL, int preR, int[] in, int inL, int inR) {
- if (preL > preR)
- return null;
- TreeNode root = new TreeNode(pre[preL]);
- int inIndex = inOrderNumsIndexs.get(root.val);
- int leftTreeSize = inIndex - inL;
- root.left = reConstructBinaryTree(pre, preL + 1, preL + leftTreeSize, in, inL, inL + leftTreeSize - 1);
- root.right = reConstructBinaryTree(pre, preL + leftTreeSize + 1, preR, in, inL + leftTreeSize + 1, inR);
- return root;
+private TreeNode reConstructBinaryTree(int[] pre, int preL, int preR, int[] in, int inL, int inR) {
+ if (preL > preR)
+ return null;
+ TreeNode root = new TreeNode(pre[preL]);
+ int inIndex = inOrderNumsIndexs.get(root.val);
+ int leftTreeSize = inIndex - inL;
+ root.left = reConstructBinaryTree(pre, preL + 1, preL + leftTreeSize, in, inL, inL + leftTreeSize - 1);
+ root.right = reConstructBinaryTree(pre, preL + leftTreeSize + 1, preR, in, inL + leftTreeSize + 1, inR);
+ return root;
}
```
-# 8. 二叉树的下一个结点
+# 8. 二叉树的下一个结点
[NowCoder](https://www.nowcoder.com/practice/9023a0c988684a53960365b889ceaf5e?tpId=13&tqId=11210&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
-## 题目描述
+## 题目描述
给定一个二叉树和其中的一个结点，请找出中序遍历顺序的下一个结点并且返回。注意，树中的结点不仅包含左右子结点，同时包含指向父结点的指针。
-## 解题思路
+## 解题思路
-① 如果一个节点的右子树不为空，那么该节点的下一个节点是右子树的最左节点；
+① 如果一个节点的右子树不为空，那么该节点的下一个节点是右子树的最左节点；
- in = new Stack();
-Stack out = new Stack();
+Stack in = new Stack();
+Stack out = new Stack();
-public void push(int node) {
- in.push(node);
+public void push(int node) {
+ in.push(node);
}
-public int pop() throws Exception {
- if (out.isEmpty())
- while (!in.isEmpty())
- out.push(in.pop());
+public int pop() throws Exception {
+ if (out.isEmpty())
+ while (!in.isEmpty())
+ out.push(in.pop());
- if (out.isEmpty())
- throw new Exception("queue is empty");
+ if (out.isEmpty())
+ throw new Exception("queue is empty");
- return out.pop();
+ return out.pop();
}
```
-# 10.1 斐波那契数列
+# 10.1 斐波那契数列
[NowCoder](https://www.nowcoder.com/practice/c6c7742f5ba7442aada113136ddea0c3?tpId=13&tqId=11160&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
-## 题目描述
+## 题目描述
-求菲波那契数列的第 n 项，n <= 39。
+求菲波那契数列的第 n 项，n <= 39。
- n/2 可以通过递归求解，并且每递归一次，n 都减小一半，因此整个算法的时间复杂度为 O(logN)。
+因为 (x\*x)n/2 可以通过递归求解，并且每递归一次，n 都减小一半，因此整个算法的时间复杂度为 O(logN)。
```java
-public double Power(double base, int exponent) {
- if (exponent == 0)
- return 1;
- if (exponent == 1)
- return base;
- boolean isNegative = false;
- if (exponent < 0) {
- exponent = -exponent;
- isNegative = true;
- }
- double pow = Power(base * base, exponent / 2);
- if (exponent % 2 != 0)
- pow = pow * base;
- return isNegative ? 1 / pow : pow;
+public double Power(double base, int exponent) {
+ if (exponent == 0)
+ return 1;
+ if (exponent == 1)
+ return base;
+ boolean isNegative = false;
+ if (exponent < 0) {
+ exponent = -exponent;
+ isNegative = true;
+ }
+ double pow = Power(base * base, exponent / 2);
+ if (exponent % 2 != 0)
+ pow = pow * base;
+ return isNegative ? 1 / pow : pow;
}
```
-# 17. 打印从 1 到最大的 n 位数
+# 17. 打印从 1 到最大的 n 位数
-## 题目描述
+## 题目描述
-输入数字 n，按顺序打印出从 1 最大的 n 位十进制数。比如输入 3，则打印出 1、2、3 一直到最大的 3 位数即 999。
+输入数字 n，按顺序打印出从 1 最大的 n 位十进制数。比如输入 3，则打印出 1、2、3 一直到最大的 3 位数即 999。
-## 解题思路
+## 解题思路
-由于 n 可能会非常大，因此不能直接用 int 表示数字，而是用 char 数组进行存储。
+由于 n 可能会非常大，因此不能直接用 int 表示数字，而是用 char 数组进行存储。
使用回溯法得到所有的数。
```java
-public void print1ToMaxOfNDigits(int n) {
- if (n <= 0)
- return;
- char[] number = new char[n];
- print1ToMaxOfNDigits(number, -1);
+public void print1ToMaxOfNDigits(int n) {
+ if (n <= 0)
+ return;
+ char[] number = new char[n];
+ print1ToMaxOfNDigits(number, -1);
}
-private void print1ToMaxOfNDigits(char[] number, int digit) {
- if (digit == number.length - 1) {
- printNumber(number);
- return;
- }
- for (int i = 0; i < 10; i++) {
- number[digit + 1] = (char) (i + '0');
- print1ToMaxOfNDigits(number, digit + 1);
- }
+private void print1ToMaxOfNDigits(char[] number, int digit) {
+ if (digit == number.length - 1) {
+ printNumber(number);
+ return;
+ }
+ for (int i = 0; i < 10; i++) {
+ number[digit + 1] = (char) (i + '0');
+ print1ToMaxOfNDigits(number, digit + 1);
+ }
}
-private void printNumber(char[] number) {
- int index = 0;
- while (index < number.length && number[index] == '0')
- index++;
- while (index < number.length)
- System.out.print(number[index++]);
- System.out.println();
+private void printNumber(char[] number) {
+ int index = 0;
+ while (index < number.length && number[index] == '0')
+ index++;
+ while (index < number.length)
+ System.out.print(number[index++]);
+ System.out.println();
}
```
-# 18.1 在 O(1) 时间内删除链表节点
+# 18.1 在 O(1) 时间内删除链表节点
-## 解题思路
+## 解题思路
-① 如果该节点不是尾节点，那么可以直接将下一个节点的值赋给该节点，然后令该节点指向下下个节点，再删除下一个节点，时间复杂度为 O(1)。
+① 如果该节点不是尾节点，那么可以直接将下一个节点的值赋给该节点，然后令该节点指向下下个节点，再删除下一个节点，时间复杂度为 O(1)。
- printMatrix(int[][] matrix) {
- ArrayList ret = new ArrayList<>();
- int r1 = 0, r2 = matrix.length - 1, c1 = 0, c2 = matrix[0].length - 1;
- while (r1 <= r2 && c1 <= c2) {
- for (int i = c1; i <= c2; i++)
- ret.add(matrix[r1][i]);
- for (int i = r1 + 1; i <= r2; i++)
- ret.add(matrix[i][c2]);
- if (r1 != r2)
- for (int i = c2 - 1; i >= c1; i--)
- ret.add(matrix[r2][i]);
- if (c1 != c2)
- for (int i = r2 - 1; i > r1; i--)
- ret.add(matrix[i][c1]);
- r1++; r2--; c1++; c2--;
- }
- return ret;
+public ArrayList printMatrix(int[][] matrix) {
+ ArrayList ret = new ArrayList<>();
+ int r1 = 0, r2 = matrix.length - 1, c1 = 0, c2 = matrix[0].length - 1;
+ while (r1 <= r2 && c1 <= c2) {
+ for (int i = c1; i <= c2; i++)
+ ret.add(matrix[r1][i]);
+ for (int i = r1 + 1; i <= r2; i++)
+ ret.add(matrix[i][c2]);
+ if (r1 != r2)
+ for (int i = c2 - 1; i >= c1; i--)
+ ret.add(matrix[r2][i]);
+ if (c1 != c2)
+ for (int i = r2 - 1; i > r1; i--)
+ ret.add(matrix[i][c1]);
+ r1++; r2--; c1++; c2--;
+ }
+ return ret;
}
```
-# 30. 包含 min 函数的栈
+# 30. 包含 min 函数的栈
[NowCoder](https://www.nowcoder.com/practice/4c776177d2c04c2494f2555c9fcc1e49?tpId=13&tqId=11173&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
-## 题目描述
+## 题目描述
-定义栈的数据结构，请在该类型中实现一个能够得到栈最小元素的 min 函数。
+定义栈的数据结构，请在该类型中实现一个能够得到栈最小元素的 min 函数。
-## 解题思路
+## 解题思路
```java
-private Stack stack = new Stack<>();
-private Stack minStack = new Stack<>();
+private Stack stack = new Stack<>();
+private Stack minStack = new Stack<>();
-public void push(int node) {
- stack.push(node);
- minStack.push(minStack.isEmpty() ? node : Math.min(minStack.peek(), node));
+public void push(int node) {
+ stack.push(node);
+ minStack.push(minStack.isEmpty() ? node : Math.min(minStack.peek(), node));
}
-public void pop() {
- stack.pop();
- minStack.pop();
+public void pop() {
+ stack.pop();
+ minStack.pop();
}
-public int top() {
- return stack.peek();
+public int top() {
+ return stack.peek();
}
-public int min() {
- return minStack.peek();
+public int min() {
+ return minStack.peek();
}
```
-# 31. 栈的压入、弹出序列
+# 31. 栈的压入、弹出序列
[NowCoder](https://www.nowcoder.com/practice/d77d11405cc7470d82554cb392585106?tpId=13&tqId=11174&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
-## 题目描述
+## 题目描述
-输入两个整数序列，第一个序列表示栈的压入顺序，请判断第二个序列是否为该栈的弹出顺序。假设压入栈的所有数字均不相等。例如序列 1,2,3,4,5 是某栈的压入顺序，序列 4,5,3,2,1 是该压栈序列对应的一个弹出序列，但 4,3,5,1,2 就不可能是该压栈序列的弹出序列。
+输入两个整数序列，第一个序列表示栈的压入顺序，请判断第二个序列是否为该栈的弹出顺序。假设压入栈的所有数字均不相等。例如序列 1,2,3,4,5 是某栈的压入顺序，序列 4,5,3,2,1 是该压栈序列对应的一个弹出序列，但 4,3,5,1,2 就不可能是该压栈序列的弹出序列。
-## 解题思路
+## 解题思路
使用一个栈来模拟压入弹出操作。
```java
-public boolean IsPopOrder(int[] pushA, int[] popA) {
- int n = pushA.length;
- Stack stack = new Stack<>();
- for (int pushIndex = 0, popIndex = 0; pushIndex < n; pushIndex++) {
- stack.push(pushA[pushIndex]);
- while (popIndex < n && stack.peek() == popA[popIndex]) {
- stack.pop();
- popIndex++;
- }
- }
- return stack.isEmpty();
+public boolean IsPopOrder(int[] pushA, int[] popA) {
+ int n = pushA.length;
+ Stack stack = new Stack<>();
+ for (int pushIndex = 0, popIndex = 0; pushIndex < n; pushIndex++) {
+ stack.push(pushA[pushIndex]);
+ while (popIndex < n && stack.peek() == popA[popIndex]) {
+ stack.pop();
+ popIndex++;
+ }
+ }
+ return stack.isEmpty();
}
```
-# 32.1 从上往下打印二叉树
+# 32.1 从上往下打印二叉树
[NowCoder](https://www.nowcoder.com/practice/7fe2212963db4790b57431d9ed259701?tpId=13&tqId=11175&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
-## 题目描述
+## 题目描述
从上往下打印出二叉树的每个节点，同层节点从左至右打印。
例如，以下二叉树层次遍历的结果为：1,2,3,4,5,6,7
- PrintFromTopToBottom(TreeNode root) {
- Queue queue = new LinkedList<>();
- ArrayList ret = new ArrayList<>();
- if (root == null)
- return ret;
- queue.add(root);
- while (!queue.isEmpty()) {
- int cnt = queue.size();
- while (cnt-- > 0) {
- TreeNode t = queue.poll();
- if (t.left != null)
- queue.add(t.left);
- if (t.right != null)
- queue.add(t.right);
- ret.add(t.val);
- }
- }
- return ret;
+public ArrayList PrintFromTopToBottom(TreeNode root) {
+ Queue queue = new LinkedList<>();
+ ArrayList ret = new ArrayList<>();
+ if (root == null)
+ return ret;
+ queue.add(root);
+ while (!queue.isEmpty()) {
+ int cnt = queue.size();
+ while (cnt-- > 0) {
+ TreeNode t = queue.poll();
+ if (t.left != null)
+ queue.add(t.left);
+ if (t.right != null)
+ queue.add(t.right);
+ ret.add(t.val);
+ }
+ }
+ return ret;
}
```
-# 32.2 把二叉树打印成多行
+# 32.2 把二叉树打印成多行
[NowCoder](https://www.nowcoder.com/practice/445c44d982d04483b04a54f298796288?tpId=13&tqId=11213&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
-## 题目描述
+## 题目描述
和上题几乎一样。
-## 解题思路
+## 解题思路
```java
-ArrayList> Print(TreeNode pRoot) {
- ArrayList> ret = new ArrayList<>();
- if (pRoot == null)
- return ret;
- Queue queue = new LinkedList<>();
- queue.add(pRoot);
- while (!queue.isEmpty()) {
- ArrayList list = new ArrayList<>();
- int cnt = queue.size();
- while (cnt-- > 0) {
- TreeNode node = queue.poll();
- list.add(node.val);
- if (node.left != null)
- queue.add(node.left);
- if (node.right != null)
- queue.add(node.right);
- }
- ret.add(list);
- }
- return ret;
+ArrayList> Print(TreeNode pRoot) {
+ ArrayList> ret = new ArrayList<>();
+ if (pRoot == null)
+ return ret;
+ Queue queue = new LinkedList<>();
+ queue.add(pRoot);
+ while (!queue.isEmpty()) {
+ ArrayList list = new ArrayList<>();
+ int cnt = queue.size();
+ while (cnt-- > 0) {
+ TreeNode node = queue.poll();
+ list.add(node.val);
+ if (node.left != null)
+ queue.add(node.left);
+ if (node.right != null)
+ queue.add(node.right);
+ }
+ ret.add(list);
+ }
+ return ret;
}
```
-# 32.3 按之字形顺序打印二叉树
+# 32.3 按之字形顺序打印二叉树
[NowCoder](https://www.nowcoder.com/practice/91b69814117f4e8097390d107d2efbe0?tpId=13&tqId=11212&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
-## 题目描述
+## 题目描述
请实现一个函数按照之字形打印二叉树，即第一行按照从左到右的顺序打印，第二层按照从右至左的顺序打印，第三行按照从左到右的顺序打印，其他行以此类推。
-## 解题思路
+## 解题思路
```java
-public ArrayList> Print(TreeNode pRoot) {
- ArrayList> ret = new ArrayList<>();
- if (pRoot == null)
- return ret;
- Queue queue = new LinkedList<>();
- queue.add(pRoot);
- boolean reverse = false;
- while (!queue.isEmpty()) {
- ArrayList list = new ArrayList<>();
- int cnt = queue.size();
- while (cnt-- > 0) {
- TreeNode node = queue.poll();
- list.add(node.val);
- if (node.left != null)
- queue.add(node.left);
- if (node.right != null)
- queue.add(node.right);
- }
- if (reverse)
- Collections.reverse(list);
- reverse = !reverse;
- ret.add(list);
- }
- return ret;
+public ArrayList> Print(TreeNode pRoot) {
+ ArrayList> ret = new ArrayList<>();
+ if (pRoot == null)
+ return ret;
+ Queue queue = new LinkedList<>();
+ queue.add(pRoot);
+ boolean reverse = false;
+ while (!queue.isEmpty()) {
+ ArrayList list = new ArrayList<>();
+ int cnt = queue.size();
+ while (cnt-- > 0) {
+ TreeNode node = queue.poll();
+ list.add(node.val);
+ if (node.left != null)
+ queue.add(node.left);
+ if (node.right != null)
+ queue.add(node.right);
+ }
+ if (reverse)
+ Collections.reverse(list);
+ reverse = !reverse;
+ ret.add(list);
+ }
+ return ret;
}
```
-# 33. 二叉搜索树的后序遍历序列
+# 33. 二叉搜索树的后序遍历序列
[NowCoder](https://www.nowcoder.com/practice/a861533d45854474ac791d90e447bafd?tpId=13&tqId=11176&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
-## 题目描述
+## 题目描述
输入一个整数数组，判断该数组是不是某二叉搜索树的后序遍历的结果。假设输入的数组的任意两个数字都互不相同。
-例如，下图是后序遍历序列 3,1,2 所对应的二叉搜索树。
+例如，下图是后序遍历序列 3,1,2 所对应的二叉搜索树。
- > ret = new ArrayList<>();
+private ArrayList> ret = new ArrayList<>();
-public ArrayList> FindPath(TreeNode root, int target) {
- backtracking(root, target, new ArrayList<>());
- return ret;
+public ArrayList> FindPath(TreeNode root, int target) {
+ backtracking(root, target, new ArrayList<>());
+ return ret;
}
-private void backtracking(TreeNode node, int target, ArrayList path) {
- if (node == null)
- return;
- path.add(node.val);
- target -= node.val;
- if (target == 0 && node.left == null && node.right == null) {
- ret.add(new ArrayList(path));
- } else {
- backtracking(node.left, target, path);
- backtracking(node.right, target, path);
- }
- path.remove(path.size() - 1);
+private void backtracking(TreeNode node, int target, ArrayList path) {
+ if (node == null)
+ return;
+ path.add(node.val);
+ target -= node.val;
+ if (target == 0 && node.left == null && node.right == null) {
+ ret.add(new ArrayList(path));
+ } else {
+ backtracking(node.left, target, path);
+ backtracking(node.right, target, path);
+ }
+ path.remove(path.size() - 1);
}
```
-# 35. 复杂链表的复制
+# 35. 复杂链表的复制
[NowCoder](https://www.nowcoder.com/practice/f836b2c43afc4b35ad6adc41ec941dba?tpId=13&tqId=11178&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
-## 题目描述
+## 题目描述
-输入一个复杂链表（每个节点中有节点值，以及两个指针，一个指向下一个节点，另一个特殊指针指向任意一个节点），返回结果为复制后复杂链表的 head。
+输入一个复杂链表（每个节点中有节点值，以及两个指针，一个指向下一个节点，另一个特殊指针指向任意一个节点），返回结果为复制后复杂链表的 head。
- ret = new ArrayList<>();
+private ArrayList ret = new ArrayList<>();
-public ArrayList Permutation(String str) {
- if (str.length() == 0)
- return ret;
- char[] chars = str.toCharArray();
- Arrays.sort(chars);
- backtracking(chars, new boolean[chars.length], new StringBuffer());
- return ret;
+public ArrayList Permutation(String str) {
+ if (str.length() == 0)
+ return ret;
+ char[] chars = str.toCharArray();
+ Arrays.sort(chars);
+ backtracking(chars, new boolean[chars.length], new StringBuffer());
+ return ret;
}
-private void backtracking(char[] chars, boolean[] hasUsed, StringBuffer s) {
- if (s.length() == chars.length) {
- ret.add(s.toString());
- return;
- }
- for (int i = 0; i < chars.length; i++) {
- if (hasUsed[i])
- continue;
- if (i != 0 && chars[i] == chars[i - 1] && !hasUsed[i - 1]) // 保证不重复
- continue;
- hasUsed[i] = true;
- s.append(chars[i]);
- backtracking(chars, hasUsed, s);
- s.deleteCharAt(s.length() - 1);
- hasUsed[i] = false;
- }
+private void backtracking(char[] chars, boolean[] hasUsed, StringBuffer s) {
+ if (s.length() == chars.length) {
+ ret.add(s.toString());
+ return;
+ }
+ for (int i = 0; i < chars.length; i++) {
+ if (hasUsed[i])
+ continue;
+ if (i != 0 && chars[i] == chars[i - 1] && !hasUsed[i - 1]) // 保证不重复
+ continue;
+ hasUsed[i] = true;
+ s.append(chars[i]);
+ backtracking(chars, hasUsed, s);
+ s.deleteCharAt(s.length() - 1);
+ hasUsed[i] = false;
+ }
}
```
-# 39. 数组中出现次数超过一半的数字
+# 39. 数组中出现次数超过一半的数字
[NowCoder](https://www.nowcoder.com/practice/e8a1b01a2df14cb2b228b30ee6a92163?tpId=13&tqId=11181&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
-## 解题思路
+## 解题思路
-多数投票问题，可以利用 Boyer-Moore Majority Vote Algorithm 来解决这个问题，使得时间复杂度为 O(N)。
+多数投票问题，可以利用 Boyer-Moore Majority Vote Algorithm 来解决这个问题，使得时间复杂度为 O(N)。
-使用 cnt 来统计一个元素出现的次数，当遍历到的元素和统计元素不相等时，令 cnt--。如果前面查找了 i 个元素，且 cnt == 0 ，说明前 i 个元素没有 majority，或者有 majority，但是出现的次数少于 i / 2 ，因为如果多于 i / 2 的话 cnt 就一定不会为 0 。此时剩下的 n - i 个元素中，majority 的数目依然多于 (n - i) / 2，因此继续查找就能找出 majority。
+使用 cnt 来统计一个元素出现的次数，当遍历到的元素和统计元素不相等时，令 cnt--。如果前面查找了 i 个元素，且 cnt == 0 ，说明前 i 个元素没有 majority，或者有 majority，但是出现的次数少于 i / 2 ，因为如果多于 i / 2 的话 cnt 就一定不会为 0 。此时剩下的 n - i 个元素中，majority 的数目依然多于 (n - i) / 2，因此继续查找就能找出 majority。
```java
-public int MoreThanHalfNum_Solution(int[] nums) {
- int majority = nums[0];
- for (int i = 1, cnt = 1; i < nums.length; i++) {
- cnt = nums[i] == majority ? cnt + 1 : cnt - 1;
- if (cnt == 0) {
- majority = nums[i];
- cnt = 1;
- }
- }
- int cnt = 0;
- for (int val : nums)
- if (val == majority)
- cnt++;
- return cnt > nums.length / 2 ? majority : 0;
+public int MoreThanHalfNum_Solution(int[] nums) {
+ int majority = nums[0];
+ for (int i = 1, cnt = 1; i < nums.length; i++) {
+ cnt = nums[i] == majority ? cnt + 1 : cnt - 1;
+ if (cnt == 0) {
+ majority = nums[i];
+ cnt = 1;
+ }
+ }
+ int cnt = 0;
+ for (int val : nums)
+ if (val == majority)
+ cnt++;
+ return cnt > nums.length / 2 ? majority : 0;
}
```
-# 40. 最小的 K 个数
+# 40. 最小的 K 个数
[NowCoder](https://www.nowcoder.com/practice/6a296eb82cf844ca8539b57c23e6e9bf?tpId=13&tqId=11182&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
-## 解题思路
+## 解题思路
-### 快速选择
+### 快速选择
-- 复杂度：O(N) + O(1)
-- 只有当允许修改数组元素时才可以使用
+- 复杂度：O(N) + O(1)
+- 只有当允许修改数组元素时才可以使用
-快速排序的 partition() 方法，会返回一个整数 j 使得 a[l..j-1] 小于等于 a[j]，且 a[j+1..h] 大于等于 a[j]，此时 a[j] 就是数组的第 j 大元素。可以利用这个特性找出数组的第 K 个元素，这种找第 K 个元素的算法称为快速选择算法。
+快速排序的 partition() 方法，会返回一个整数 j 使得 a[l..j-1] 小于等于 a[j]，且 a[j+1..h] 大于等于 a[j]，此时 a[j] 就是数组的第 j 大元素。可以利用这个特性找出数组的第 K 个元素，这种找第 K 个元素的算法称为快速选择算法。
```java
-public ArrayList GetLeastNumbers_Solution(int[] nums, int k) {
- ArrayList ret = new ArrayList<>();
- if (k > nums.length || k <= 0)
- return ret;
- int kthSmallest = findKthSmallest(nums, k - 1);
- // findKthSmallest 会改变数组，使得前 k 个数都是最小的 k 个数
- for (int i = 0; i < k; i++)
- ret.add(nums[i]);
- return ret;
+public ArrayList GetLeastNumbers_Solution(int[] nums, int k) {
+ ArrayList ret = new ArrayList<>();
+ if (k > nums.length || k <= 0)
+ return ret;
+ int kthSmallest = findKthSmallest(nums, k - 1);
+ // findKthSmallest 会改变数组，使得前 k 个数都是最小的 k 个数
+ for (int i = 0; i < k; i++)
+ ret.add(nums[i]);
+ return ret;
}
-public int findKthSmallest(int[] nums, int k) {
- int l = 0, h = nums.length - 1;
- while (l < h) {
- int j = partition(nums, l, h);
- if (j == k)
- break;
- if (j > k)
- h = j - 1;
- else
- l = j + 1;
- }
- return nums[k];
+public int findKthSmallest(int[] nums, int k) {
+ int l = 0, h = nums.length - 1;
+ while (l < h) {
+ int j = partition(nums, l, h);
+ if (j == k)
+ break;
+ if (j > k)
+ h = j - 1;
+ else
+ l = j + 1;
+ }
+ return nums[k];
}
-private int partition(int[] nums, int l, int h) {
- // 切分元素
- int parti = nums[l];
- int i = l, j = h + 1;
- while (true) {
- while (i != h && nums[++i] < parti) ;
- while (j != l && nums[--j] > parti) ;
- if (i >= j)
- break;
- swap(nums, i, j);
- }
- swap(nums, l, j);
- return j;
+private int partition(int[] nums, int l, int h) {
+ // 切分元素
+ int parti = nums[l];
+ int i = l, j = h + 1;
+ while (true) {
+ while (i != h && nums[++i] < parti) ;
+ while (j != l && nums[--j] > parti) ;
+ if (i >= j)
+ break;
+ swap(nums, i, j);
+ }
+ swap(nums, l, j);
+ return j;
}
-private void swap(int[] nums, int i, int j) {
- int t = nums[i];
- nums[i] = nums[j];
- nums[j] = t;
+private void swap(int[] nums, int i, int j) {
+ int t = nums[i];
+ nums[i] = nums[j];
+ nums[j] = t;
}
```
-### 大小为 K 的最小堆
+### 大小为 K 的最小堆
-- 复杂度：O(NlogK) + O(K)
-- 特别适合处理海量数据
+- 复杂度：O(NlogK) + O(K)
+- 特别适合处理海量数据
应该使用大顶堆来维护最小堆，而不能直接创建一个小顶堆并设置一个大小，企图让小顶堆中的元素都是最小元素。
-维护一个大小为 K 的最小堆过程如下：在添加一个元素之后，如果大顶堆的大小大于 K，那么需要将大顶堆的堆顶元素去除。
+维护一个大小为 K 的最小堆过程如下：在添加一个元素之后，如果大顶堆的大小大于 K，那么需要将大顶堆的堆顶元素去除。
```java
-public ArrayList GetLeastNumbers_Solution(int[] nums, int k) {
- if (k > nums.length || k <= 0)
- return new ArrayList<>();
- PriorityQueue
