diff --git a/.gitattributes b/.gitattributes
new file mode 100644
index 00000000..2959201f
--- /dev/null
+++ b/.gitattributes
@@ -0,0 +1,3 @@
+*.js linguist-language=java
+*.css linguist-language=java
+*.html linguist-language=java
diff --git a/.github/FUNDING.yml b/.github/FUNDING.yml
new file mode 100644
index 00000000..cfe0b71f
--- /dev/null
+++ b/.github/FUNDING.yml
@@ -0,0 +1,12 @@
+# These are supported funding model platforms
+
+github: # Replace with up to 4 GitHub Sponsors-enabled usernames e.g., [user1, user2]
+patreon: # Replace with a single Patreon username
+open_collective: # Replace with a single Open Collective username
+ko_fi: # Replace with a single Ko-fi username
+tidelift: # Replace with a single Tidelift platform-name/package-name e.g., npm/babel
+community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry
+liberapay: # Replace with a single Liberapay username
+issuehunt: # Replace with a single IssueHunt username
+otechie: # Replace with a single Otechie username
+custom: https://raw.githubusercontent.com/frank-lam/fullstack-tutorial/master/assets/wechat/wx-green.png
diff --git a/README.md b/README.md
index f084f670..0a492743 100644
--- a/README.md
+++ b/README.md
@@ -1,77 +1,40 @@
-
-
-
-
-
-
- 嗨，欢迎来做客，即刻开始 CS 学习之旅.
-
-
- Hey, welcome to visit and start the computer science learning journey.
-
-
TODO LIST
-- HTML(5)
+- HTML5
+
+- CSS3
-- CSS(3)
+- CSS 预处理
- sass、scss、stylus
+ - sass(scss)
+ - less
+ - stylus
- CSS 框架
- BootStarp、LayUI
+ - BootStarp
+ - LayUI
- JavaScript
@@ -161,7 +140,7 @@
- JavaScript 框架
- Vue
- - React
+ - React
- Angular
- jQuery
@@ -169,22 +148,30 @@
常用 api、对象池、异常处理、进程通信、高并发
-- 静态编译
- - Flow
+- 静态类型检查
+
- TypeScript
+ - Flow
+
+- 构建/打包工具
-- 打包工具
- webpack
- - glup
+ - gulp
- rollup
-- 工具
+- 包管理工具
+
- npm
- yarn
+
+- 服务端渲染
-
-
+ - koa2
+ - express
+ - nuxt
+ - next
+
@@ -198,14 +185,18 @@
Redis 核心知识
-- MongoDB
-
- 基于分布式文件存储的数据库
-
- [SQL](notes/SQL.md)
常用 SQL 语句
+- [PostgreSQL](notes/PostgreSQL.md)
+
+ 一个开源的关系数据库，是从伯克利写的 POSTGRES 软件包发展而来的
+
+- [InfluxDB](https://www.frankfeekr.cn/2019/07/24/influxdb-tutorial-start/)
+
+ 玩转时序数据库
+
## 六、操作系统
@@ -234,7 +225,6 @@
web前后端漏洞分析与防御，XSS 攻击、CSRF 攻击、DDoS 攻击、SQL 注入
-- Socket 网络编程
@@ -248,6 +238,14 @@
微服务简介、API 网关、服务注册发现、服务通信
+- [Zookeeper](notes/分布式/Zookeeper.md)
+
+ 分布式协调服务，服务注册发现
+
+- [Kafka](notes/MicroService/kafka/README.md)
+
+ 深入浅出 Kafka，将用最极简的语言带你走进 Kafka 的消息中间件世界
+
【说明】**分布式专题** 笔者也在学习中，这里列举了一些技能列表，笔者将局部更新。敬请期待
@@ -268,7 +266,7 @@
- Zookeeper
- 分布式协调服务
+ 分布式协调服务，服务注册发现
- Dubbo、Thrift（RPC 框架）
@@ -302,6 +300,15 @@
自动化运维，持续集成、持续交付、持续部署
+
+- 分布式锁
+
+ 基于 Redis、MySQL、Zookeeper 的分布式锁实现
+
+- FastDFS
+
+ 轻量级分布式文件管理系统
+
- Go
并发的、带垃圾回收的、快速编译的语言
@@ -311,24 +318,21 @@
## 九、机器学习
-- 经典机器学习算法
-
- K 近邻算法、线性回归、梯度下降法、逻辑回归、支持向量机、决策树、集成学习
-- 基础框架
-
- Tensorflow，Scikit-learn
+- [深度学习初识](notes/DeepLearning/深度学习初识.md)
+- 经典机器学习算法
+ K 近邻算法、线性回归、梯度下降法、逻辑回归、支持向量机、决策树、集成学习
## 十、工具
-- [Git](notes/Git.md)
+- [Git](notes/git-tutorial.md)
- 基本概念，常见命令，速查表
+ 学习指引，将用最极简的语言带你进入 Git 版本控制的世界
- [Git 工作流](notes/Git工作流.md)
@@ -342,10 +346,15 @@
基于 lanproxy 穿透服务，为你定了一键启动的服务端和客户端 Docker 镜像
+- [基于 SpringBoot & IDEA & JRebel 玩转远程热部署与远程调试](https://www.frankfeekr.cn/2019/07/17/springboot-idea-jrebel-hotswap/)
+
+ 手把手带你玩转，远程调试与远程热部署
+
- [什么是 TDD 及常见的测试方法](notes/软件测试.md)
-## Learn :books:
+
+## Learn 📖
- [LEARN_LIST](notes/LEARNLIST.md)
@@ -357,73 +366,62 @@
## Talking :bulb:
- 本仓库致力于成为一个全栈开发爱好者的学习指南，给初学者一个更明确的学习方向，同时也是对自己技能的强化和巩固。在架构师这条路上，希望和大家一起成长，帮助更多的计算机爱好者能够有一个明确的学习路径。持续不间断的维护本仓库，也欢迎有更多的极客们加入。
+本仓库致力于成为一个全栈开发爱好者的学习指南，给初学者一个更明确的学习方向，同时也是对自己技能的强化和巩固。在架构师这条路上，希望和大家一起成长，帮助更多的计算机爱好者能够有一个明确的学习路径。持续不间断的维护本仓库，也欢迎有更多的极客们加入。
+
+都说好记性不如烂笔头，定期的学习和整理必然对学习巩固有所帮助，这里通过索引的方式对全栈开发技术做一个系统分类，方便随时巩固和学习，当然还有面试。在学习这条路上难免会有很多盲点和学不完的知识。有道无术，术尚可求，掌握好思维能力才能应对千变万化的技术。不要把大脑当成硬盘，也不要做高速运转的 CPU，而修行自己的大脑成为一个搜索引擎，学会分析解决问题。
+
+Since 20,May,2018
- 都说好记性不如烂笔头，定期的学习和整理必然对学习巩固有所帮助，这里通过索引的方式对全栈开发技术做一个系统分类，方便随时巩固和学习，当然还有面试。在学习这条路上难免会有很多盲点和学不完的知识。有道无术，术尚可求，掌握好思维能力才能应对千变万化的技术。不要把大脑当成硬盘，也不要做高速运转的 CPU，而修行自己的大脑成为一个搜索引擎，学会分析解决问题。
- Since 20,May,2018
+## Reference
+个人的能力有限，在编写的过程中引用了诸多优秀的 GitHub 仓库。本项目的启发来自 [@CyC2018](https://github.com/CyC2018) 的学习笔记，是一个非常优秀的开源项目，在本仓库中部分内容引用文字和图例；引用了 [@计算所的小鼠标](https://github.com/CarpenterLee) 中对于 JCF 的源码分析和理解；引用了 [阿里面试题总结](https://www.nowcoder.com/discuss/5949) 中全部的面试题，并对面经进行了整理勘误，并进行了知识拓展和修改；引用了 [牛客网](https://www.nowcoder.com) 上的面试经验贴。也引用了知乎上的热门回答和优秀博客的回答。在这里特别鸣谢，我将每篇文章中做外链引用说明。
-### Reference
+文中我也推荐了学习的书籍和学习课程，都将附着上最高清、最形象的配图进行讲解。在文中的配图都来自自己绘制的、博客、Github、PDF书籍等等，这里没法一一感谢，谢谢你们。
- 个人的能力有限，在编写的过程中引用了诸多优秀的 GitHub 仓库。本项目的启发来自 [@CyC2018](https://github.com/CyC2018) 的学习笔记，是一个非常优秀的开源项目，在本仓库中部分内容引用文字和图例；引用了 [@计算所的小鼠标](https://github.com/CarpenterLee) 中对于 JCF 的源码分析和理解；引用了 [阿里面试题总结](https://www.nowcoder.com/discuss/5949) 中全部的面试题，并对面经进行了整理勘误，并进行了知识拓展和修改；引用了 [牛客网](https://www.nowcoder.com) 上的面试经验贴。也引用了知乎上的热门回答和优秀博客的回答。在这里特别鸣谢，我将每篇文章中做外链引用说明。
+推荐一些优秀的开源项目，供大家参考，[reference](notes/reference.md)。
- 文中我也推荐了学习的书籍和学习课程，都将附着上最高清、最形象的配图进行讲解。在文中的配图都来自自己绘制的、博客、Github、PDF书籍等等，这里没法一一感谢，谢谢你们。
- 推荐一些优秀的开源项目，供大家参考，[reference](notes/reference.md)。
+## Contributors
+Thank you to all the people who already contributed to fullstack-tutorial !
-### Contributors
+Please make sure to read the [Contributing Guide/如何给我的仓库贡献](notes/docs/如何给我的仓库贡献.md) before making a pull request.
- 该项目还在萌芽起步阶段，在编写的过程中难免遇到错误和不足，你可以在 issue 中提出，或是提交你的 contribution。[【开源贡献】如何给我的仓库贡献？](notes/docs/如何给我的仓库贡献.md)
+
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+## Stargazers over time
+
-### License
- 本作品采用 [知识共享署名-非商业性使用-相同方式共享 4.0 国际许可协议](https://creativecommons.org/licenses/by-nc-sa/4.0/) 进行许可。使用者可以对本创作进行转载、节选、混编、二次创作，但不得运用于商业目的，且使用时须进行署名，采用本创作的内容必须同样采用本协议进行授权。
-
在颠覆世界的同时，也要好好关照自己。
-
-
+
@@ -431,5 +429,5 @@
from zero to hero.
-Since 2018/5/20 Fullstack Tutorial, 2... Hey, welcome to visit and start the computer science learning journey.
Hey, welcome to visit and start the computer science learning... Viewer does not support full SVG 1.1 Since 2018/5/20 Fullstack Tutorial, 2... Hey, welcome to visit and start the computer science learning journey.
Hey, welcome to visit and start the computer science learning... Viewer does not support full SVG 1.1 `创建的组件会自动生成在`app.module`中的引用，推荐使用ng命令生成组件
+
+```jsx
+//快速创建
+ng g c xxx
+```
+
+```jsx
+@Component({
+ selector: 'app-root',
+ templateUrl: './app.component.html',
+ styleUrls: ['./app.component.scss']
+})
+```
+
+@Component最常用的几个选项:
+
+**selector**：这个 CSS 选择器用于在模板中标记出该指令，并触发该指令的实例化。
+
+**template**：组件的内联模板
+
+**templateUrl**：组件模板文件的 URL
+
+**styleUrls**：组件样式文件
+
+**styles**：组件内联样式
+
+
+
+#### 3.2.2 组件生命周期
+
+ Angular 会按以下顺序执行钩子方法。你可以用它来执行以下类型的操作。
+
+| 钩子方法 | 用途 | 时机 |
+| :------------------------ | :----------------------------------------------------------- | :----------------------------------------------------------- |
+| `ngOnChanges()` | 当 Angular 设置或重新设置数据绑定的输入属性时响应。 该方法接受当前和上一属性值的 `SimpleChanges` 对象注意，这发生的非常频繁，所以你在这里执行的任何操作都会显著影响性能。 | 在 `ngOnInit()` 之前以及所绑定的一个或多个输入属性的值发生变化时都会调用。注意，如果你的组件没有输入，或者你使用它时没有提供任何输入，那么框架就不会调用 `ngOnChanges()`。 |
+| `ngOnInit()` | 在 Angular 第一次显示数据绑定和设置指令/组件的输入属性之后，初始化指令/组件。 | 在第一轮 `ngOnChanges()` 完成之后调用，只调用**一次**。 |
+| `ngDoCheck()` | 检测，并在发生 Angular 无法或不愿意自己检测的变化时作出反应。 | 紧跟在每次执行变更检测时的 `ngOnChanges()` 和 首次执行变更检测时的 `ngOnInit()` 后调用。 |
+| `ngAfterContentInit()` | 当 Angular 把外部内容投影进组件视图或指令所在的视图之后调用。 | 第一次 `ngDoCheck()` 之后调用，只调用一次。 |
+| `ngAfterContentChecked()` | 每当 Angular 检查完被投影到组件或指令中的内容之后调用 | `ngAfterContentInit()` 和每次 `ngDoCheck()` 之后调用 |
+| `ngAfterViewInit()` | 当 Angular 初始化完组件视图及其子视图或包含该指令的视图之后调用 | 第一次 `ngAfterContentChecked()` 之后调用，只调用一次。 |
+| `ngAfterViewChecked()` | 每当 Angular 做完组件视图和子视图或包含该指令的视图的变更检测之后调用。 | `ngAfterViewInit()` 和每次 `ngAfterContentChecked()` 之后调用。 |
+| `ngOnDestroy()` | 每当 Angular 每次销毁指令/组件之前调用并清扫。 在这儿反订阅可观察对象和分离事件处理器，以防内存泄漏 | 在 Angular 销毁指令或组件之前立即调用。 |
+
+#### 3.2.3 组件交互
+
+1. **@Input**
+
+ 父组件通过`@Input`给子组件绑定属性设置输入类数据
+
+ ```jsx
+ //父组件
+ 获取
+
+
+ @ViewChild('myChild') child: any;
+ constructor() { }
+
+ ngOnInit(): void {
+ }
+ getView(e:any){
+ console.log(this.child)
+ this.child.setInpValue('我是一段数据')
+ }
+ ```
+
+
+
+### 3.3 模板
+
+在 Angular 中，**模板**就是一块 HTML。在模板中，你可以通过一种特殊语法来使用 Angular 的许多功能
+
+#### 3.3.1 插值语法
+
+ 所谓 "插值" 是指将表达式嵌入到标记文本中。 默认情况下，插值会用双花括号 `{{` 和 `}}` 作为分隔符
+
+```js
+hello {{ name }}
+```
+
+ 花括号之间的文本通常是组件属性的名字。Angular 会把这个名字替换为响应组件属性的字符串值
+
+ 括号间的素材是一个**模板表达式**我们可以在`{{}}`内编写js运算
+
+```jsx
+hello {{ 1+1 }}
+```
+
+#### 3.3.2 属性绑定
+
+1. **Attribute绑定**
+
+ ```jsx
+ hello {{ 1+1 }}
+ ```
+
+2. **类绑定**
+
+ ```jsx
+ //单一类绑定
+ hello {{ 1+1 }}
+
+ //多重类绑定
+ hello {{ 1+1 }}
+ hello {{ 1+1 }}
+ hello {{ 1+1 }}
+
+ //ngClass
+ export class AppComponent {
+ isActive = true;
+ }
+
+ hello {{ 1+1 }}
+
+ ```
+
+3. **样式绑定**
+
+ ```jsx
+ //单一样式绑定
+ hello {{ 1+1 }}
+
+ //带单位的单一样式绑定
+ hello {{ 1+1 }}
+
+ //多重样式绑定
+ hello {{ 1+1 }}
+ hello {{ 1+1 }}
+
+ //ngStyle
+ export class AppComponent {
+ isMax = false;
+ }
+ hello {{ 1+1 }}
+ hello {{ 1+1 }}
+ ```
+
+#### 3.3.3 条件判断
+
+ ***ngIf**是直接影响元素是否被渲染，而非控制元素的显示和隐藏
+
+```jsx
+export class AppComponent {
+ isMax = false;
+ isMin = false;
+}
+Max title
+Min title
+
+//解析完
+
+ Max title
+
+
+
+ isMax为true
+
+
+ isMax为false
+
+```
+
+#### 3.3.4 循环语句
+
+ 解析器会把 `let color`、`let i` 和 `let odd` 翻译成命名变量 `color`、`i` 和 `odd`
+
+微语法解析器接收of，会将它的首字母大写(Of)，然后加上属性的指令名(ngFor)前缀，它最终生成的名字是 ngFor 的输入属性(colors)
+
+`NgFor` 指令在列表上循环，每个循环中都会设置和重置它自己的上下文对象上的属性。 这些属性包括 `index` 和 `odd` 以及一个特殊的属性名 `$implicit`(隐式变量)
+
+Angular 将 let-color 设置为此上下文中 $implicit 属性的值， 它是由 NgFor 用当前迭代中的 colors 初始化的
+
+```jsx
+export class AppComponent {
+ colors:Array = [ 'red', 'blue', 'yellow', 'green' ];
+}
+
+
+ {{odd}}
+ {{i}}
+ {{color}}
+
+
+//解析完
+
+ {{odd}} {{i}} {{color}}
+
+```
+
+```jsx
+export class AppComponent {
+ status = 1;
+}
+
+
+ 已支付
+ 订单已经确认
+ 已发货
+ 无效
+
+```
+
+#### 3.3.5 事件绑定
+
+ Angular 的事件绑定语法由等号左侧括号内的目标事件名和右侧引号内的模板语句组成。目标事件名是 `click` ，模板语句是 `onSave()`
+
+事件对象通过`$event`传递
+
+```jsx
+export class AppComponent {
+ onSave(){
+ console.log('点击了按钮')
+ }
+}
+
+Save
+```
+
+#### 3.3.6 双向绑定
+
+双向绑定是应用中的组件共享数据的一种方式。使用双向绑定绑定来侦听事件并在父组件和子组件之间同步更新值
+
+ngModel指令**只对表单元素有效**，所以在使用之前需要导入`FormsModule`板块
+
+```jsx
+import { FormsModule } from '@angular/forms';
+
+@NgModule({
+ // 申明组件内用到的视图
+ declarations: [
+ AppComponent,
+ HelloComponent,
+ ],
+ //引入模块需要的类
+ imports: [
+ BrowserModule,
+ AppRoutingModule,
+ FormsModule
+ ],
+ //全局服务
+ providers: [],
+ //根组件
+ bootstrap: [AppComponent]
+})
+```
+
+```jsx
+export class AppComponent {
+ userName='';
+}
+
+ 输入:
你输入了: {{userName}}
+
+```
+
+#### 3.3.7 模板引用变量
+
+模板变量可以帮助你在模板的另一部分使用这个部分的数据。使用模板变量，你可以执行某些任务，比如响应用户输入或微调应用的表单
+
+在模板中，要使用井号 `#` 来声明一个模板变量。下列模板变量 `#userName` 语法在 `Call
+
+
+export class AppComponent {
+ callUserName(v){
+ console.log(v)
+ }
+}
+```
+
+Angular 根据你所声明的变量的位置给模板变量赋值：
+
+- 如果在组件上声明变量，该变量就会引用该组件实例。
+- 如果在标准的 HTML 标记上声明变量，该变量就会引用该元素。
+- 如果你在 `` 元素上声明变量，该变量就会引用一个 `TemplateRef` 实例来代表此模板。
+
+#### 3.3.8 表单控件
+
+使用表单控件有三个步骤。
+
+1. 在你的应用中注册响应式表单模块。该模块声明了一些你要用在响应式表单中的指令。
+2. 生成一个新的 `FormControl` 实例，并把它保存在组件中。
+3. 在模板中注册这个 `FormControl`。
+
+**注册响应式表单模块**
+
+要使用响应式表单控件，就要从 `@angular/forms` 包中导入 `ReactiveFormsModule`，并把它添加到你的 NgModule 的 `imports` 数组中。
+
+```js
+import { ReactiveFormsModule } from '@angular/forms';
+
+@NgModule({
+ imports: [
+ // other imports ...
+ ReactiveFormsModule
+ ],
+})
+export class AppModule { }
+```
+
+要注册一个表单控件，就要导入 `FormControl` 类并创建一个 `FormControl` 的新实例，将其保存为类的属性。
+
+```js
+import { Component } from '@angular/core';
+import { FormControl } from '@angular/forms';
+
+@Component({
+ selector: 'app-name-editor',
+ templateUrl: './name-editor.component.html',
+ styleUrls: ['./name-editor.component.css']
+})
+export class NameEditorComponent {
+ name = new FormControl('');
+}
+
+//使用这种模板绑定语法，把该表单控件注册给了模板中名为 name 的输入元素。这样，表单控件和 DOM 元素就可以互相通讯了：视图会反映模型的变化，模型也会反映视图中的变化
+
+
+ Name:
+
+
+ Value: {{ name.value }}
+
+```
+
+修改name值可以通过`FormControl` 提供的 `setValue()` 方法
+
+```js
+updateName() {
+ this.name.setValue('Tina');
+}
+```
+
+#### 3.3.9 表单控件分组
+
+表单中通常会包含几个相互关联的控件。响应式表单提供了两种把多个相关控件分组到同一个输入表单中的方法
+
+要将表单组添加到此组件中，请执行以下步骤。
+
+1. 创建一个 `FormGroup` 实例。
+2. 把这个 `FormGroup` 模型关联到视图。
+3. 保存表单数据。
+
+**创建一个 FormGroup 实例**
+
+在组件类中创建一个名叫 `loginForm` 的属性，并设置为 `FormGroup` 的一个新实例。要初始化这个 `FormGroup`，请为构造函数提供一个由控件组成的对象，对象中的每个名字都要和表单控件的名字一一对应
+
+```js
+import { Component } from '@angular/core';
+import { FormGroup, FormControl } from '@angular/forms';
+
+@Component({
+ selector: 'app-profile-editor',
+ templateUrl: './profile-editor.component.html',
+ styleUrls: ['./profile-editor.component.css']
+})
+export class ProfileEditorComponent {
+ loginForm = new FormGroup({
+ userName: new FormControl(''),
+ password: new FormControl(''),
+ });
+}
+
+//模板渲染
+
+```
+
+
+
+#### 3.3.10 表单验证
+
+ 表单元素添加`required`关键字表示必填，通过绑定`ngModel`的引用可以拿到到当前组件的信息，通过引用获取到验证的信息
+
+```jsx
+export class AppComponent {
+ fromData={
+ name:'',
+ password:''
+ };
+
+ subBtnFUn(obj){
+ console.log(obj)
+ }
+}
+
+
+```
+
+我们还可以通过 **ngModel** 跟踪修改状态与有效性验证，它使用了三个 CSS 类来更新控件，以便反映当前状态。
+
+| 状态 | 为 true 时的类 | 为 false 时的类 |
+| :--------------- | :------------- | :-------------- |
+| 控件已经被访问过 | `ng-touched` | `ng-untouched` |
+| 控件值已经变化 | `ng-dirty` | `ng-pristine` |
+| 控件值是有效的 | `ng-valid` | `ng-invalid` |
+
+#### 3.3.11 自定义表单验证
+
+ 先引入表单的一些内置依赖
+
+```js
+import { FormGroup, FormBuilder,Validators } from '@angular/forms';
+
+//构造函数里注入FormBuilder
+constructor(private fb:FormBuilder) { }
+
+//错误提醒数据
+formErrors = {
+ 'title': '',
+ 'content': ''
+};
+
+
+//在组件类的初始化函数里对表单中的元素的校验进行定义，并调用表单的valueChanges方法，检测表单的输入的变化
+ngOnInit():void {
+ this.taskInfo.isComplete = 1;
+ this.tasksForm = this.fb.group({
+ userName: ['', [Validators.required,
+ Validators.maxLength(18),
+ Validators.minLength(6) ] ],
+ password: ['', [this.passWordVal]],
+ phone: ['', [Validators.required,this.phoneVal],]
+ });
+
+ phoneVal(phone: FormControl): object {
+ const value = phone.value || '';
+ if(!value) return {desc:'请输入手机号'}
+ const valid = /[0-9]{11}/.test(value);
+ return valid ? {} :{desc:'联系电话必须是11位数字'}
+ }
+ passWordVal(password:FormControl):object{
+ const value = password.value || '';
+ const valid = value.match(/^(?![0-9]+$)(?![a-zA-Z]+$)[0-9A-Za-z]{6,20}$/);
+ return valid ? {} : {passwordValidator: {desc:'密码至少包含 数字和英文，长度6-20'}}
+ }
+}
+```
+
+#### 3.3.12 管道
+
+ 管道的作用就是传输。不同的管道具有不同的作用。(其实就是处理数据)
+
+`angular`中自带的`pipe`函数
+
+| 管道 | 功能 |
+| ------------- | ------------------------------------------------------------ |
+| DatePipe | 日期管道，格式化日期 |
+| JsonPipe | 将输入数据对象经过JSON.stringify()方法转换后输出对象的字符串 |
+| UpperCasePipe | 将文本所有小写字母转换成大写字母 |
+| LowerCasePipe | 将文本所有大写字母转换成小写字母 |
+| DecimalPipe | 将数值按照特定的格式显示文本 |
+| CurrentcyPipe | 将数值进行货币格式化处理 |
+| SlicePipe | 将数组或者字符串裁剪成新子集 |
+| PercentPipe | 将数值转百分比格式 |
+
+`pipe`用法
+
+- {{ 输入数据 | 管道 : 管道参数}} (其中‘|’是管道操作符)
+
+- 链式管道 {{ 输入数据 | date | uppercase}}
+
+- 管道流通方向自左向右，逐层执行
+
+ 使用脚手架命令：**ng g p test**
+
+ ```js
+ import { Pipe, PipeTransform } from '@angular/core';
+
+ @Pipe({
+ name: 'testTitle'
+ })
+ export class TestPipe implements PipeTransform {
+
+ transform(value: unknown, ...args: unknown[]): unknown {
+ console.log(value)
+ return 'title';
+ }
+ }
+
+
+ {{ 'Angular' | testTitle }}
+
+ ```
+
+
+
+### 3.4 服务
+
+ angular中，把从组件内抽离出来的代码叫服务，服务的本质就是函数
+
+ 官方认为组件不应该直接获取或保存数据， 它们应该聚焦于展示数据，而把数据访问的职责委托给某个服务。而服务就充当着数据访问，逻辑处理的功能。把组件和服务区分开，以提高模块性和复用性。通过把组件中和视图有关的功能与其他类型的处理分离开，可以让组件类更加精简、高效。
+
+使用命令ng g s xxx创建一个服务，通过**@Injectable()**装饰器标识服务。
+
+```js
+//导入Injectable装饰器
+import { Injectable } from '@angular/core';
+//使用Injectable装饰器声明服务
+@Injectable({
+ //作用域设定，'root'表示默认注入，注入到AppModule里
+ providedIn: 'root',
+})
+export class TestService {
+}
+
+```
+
+组件中如何使用服务呢，必须将服务依赖注入系统、组件或者模块，才能够使用服务。我们可以用**注册提供商**和**根注入器**实现**。**
+
+ 该服务本身是 CLI 创建的一个类，并且加上了 `@Injectable()` 装饰器。默认情况下，该装饰器是用 `providedIn` 属性进行配置的，它会为该服务创建一个提供商。
+
+
+
+### 3.5 依赖注入
+
+ 在这个例子中，`providedIn: 'root'` 指定 Angular 应该在根注入器中提供该服务,从而实现**根注入器**将服务注入，它就在整个应用程序中可用了**。**
+
+**providedIn**：
+
+ 'root' ：注入到AppModule，提供该服务，所有子组件都可以使用（推荐）
+
+ null ： 不设定服务作用域（不推荐）
+
+ 组件名：只作用于该组件（懒加载模式）
+
+```js
+
+import { Injectable } from '@angular/core';
+
+@Injectable({
+ providedIn: 'root',
+})
+export class TestService {
+}
+
+
+import { Component, OnInit } from '@angular/core';
+import {HeroService} from '../hero.service'
+
+@Component({
+ selector: 'app-test',
+ templateUrl: './test.component.html',
+ styleUrls: ['./test.component.scss'],
+})
+export class TestComponent implements OnInit {
+
+ constructor(private heroService:HeroService) { }
+
+ ngOnInit(): void {
+ console.log(this.heroService.getHeroList())
+ }
+}
+```
+
+ 也可以使用 `@Component` 或 `@Directive` 内部的 `providers: []`，为特定的组件子树提供服务，这也将导致创建多个服务实例(每个组件使用一个服务实例)
+
+```js
+
+import { Injectable } from '@angular/core';
+
+@Injectable({
+ providedIn: 'root',
+})
+export class TestService {
+}
+
+
+import { Component, OnInit } from '@angular/core';
+import {HeroService} from '../hero.service'
+
+@Component({
+ selector: 'app-test',
+ templateUrl: './test.component.html',
+ styleUrls: ['./test.component.scss'],
+ providers: [HeroService]
+})
+export class TestComponent implements OnInit {
+
+ constructor(private heroService:HeroService) { }
+
+ ngOnInit(): void {
+ console.log(this.heroService.getHeroList())
+ }
+}
+```
+
+
+
+### 3.6 路由
+
+ 路由就是连接组件的筋络,它也是树形结构的.有了它,就可以在angular中实现路径的导航模式
+
+可以把路由看成是一组规则,它决定了url的变化对应着哪一种状态,具体表现就是不同视图的切换
+
+在angular中,路由是非常重要的组成部分, 组件的实例化与销毁,模块的加载,组件的某些生命周期钩子的发起,都是与它有关
+
+#### 3.6.1 路由基本使用
+
+**路由器**是一个调度中心,它是一套规则的列表,能够查询当前URL对应的规则,并呈现出相应的视图.
+
+**路由**是列表里面的一个规则,即路由定义,它有很多功能字段:
+
+- **path**字段,表示该路由中的URL路径部分
+- **Component**字段,表示与该路由相关联的组件
+
+每个带路由的Angular应用都有一个路由器服务的单例对象,通过路由定义的列表进行配置后使用。
+
+```js
+import { NgModule } from '@angular/core';
+import { RouterModule, Routes } from '@angular/router';
+import {HomeComponent} from './home/home.component'
+
+const routes: Routes = [
+ {path:'home',component:HomeComponent}
+];
+
+@NgModule({
+ imports: [RouterModule.forRoot(routes)],
+ exports: [RouterModule]
+})
+export class AppRoutingModule { }
+
+```
+
+```jsx
+//路由导航
+home
+ hello
+
+//组件渲染输出
+home Component
+hello
+app Component
+hello
+hello
+ ```
+
+ ```js
+ import {ActivatedRoute} from '@angular/router';
+ constructor(private routerinfo:ActivatedRoute) { }
+
+ ngOnInit() {
+ //id为参数名字
+ this.id=this.routerinfo.snapshot.queryParams["id"]
+ }
+ ```
+
+
+
+- **params**
+
+ 修改路由配置文件`path`,路由导航`a`标签`routerLink`后面数组的第二个参数为传递的值
+
+ 并且通过`subscribe`请阅的方式获取`name`参数
+
+ ```js
+ {
+ path: 'hello/:name',
+ component:HelloComponent,
+ },
+ ```
+
+ ```jsx
+ //我们在后面添加/:name此时name即为传递的参数名字
+ //a标签设置如下
+ hello
+ ```
+
+ ```js
+ ngOnInit() {
+ this.routerinfo.params.subscribe((params:Params)=>{
+ this.name=params['name']
+ })
+ }
+ ```
+
diff --git "a/notes/Frontend/\345\211\215\347\253\257\347\237\245\350\257\206\344\275\223\347\263\273.md" "b/notes/Frontend/\345\211\215\347\253\257\347\237\245\350\257\206\344\275\223\347\263\273.md"
new file mode 100644
index 00000000..ddd0e049
--- /dev/null
+++ "b/notes/Frontend/\345\211\215\347\253\257\347\237\245\350\257\206\344\275\223\347\263\273.md"
@@ -0,0 +1,244 @@
+
+
+- [前端知识体系](#前端知识体系)
+ - [前端三要素](#前端三要素)
+ - [结构层（HTML）](#结构层html)
+ - [表现层（CSS）](#表现层css)
+ - [什么是 CSS 预处理器](#什么是-css-预处理器)
+ - [常用的 CSS 预处理器有哪些](#常用的-css-预处理器有哪些)
+ - [行为层（JavaScript）](#行为层javascript)
+ - [Native 原生 JS 开发](#native-原生-js-开发)
+ - [TypeScript 微软的标准](#typescript-微软的标准)
+ - [JavaScript 框架](#javascript-框架)
+ - [UI 框架](#ui-框架)
+ - [JavaScript 构建工具](#javascript-构建工具)
+ - [三端统一](#三端统一)
+ - [混合开发（Hybrid App）](#混合开发hybrid-app)
+ - [微信小程序](#微信小程序)
+ - [后端技术](#后端技术)
+ - [附：当前主流前端框架](#附当前主流前端框架)
+ - [Angular](#angular)
+ - [Angular Material](#angular-material)
+ - [Vue.js](#vuejs)
+ - [iView](#iview)
+ - [ElementUI](#elementui)
+ - [ICE](#ice)
+ - [VantUI](#vantui)
+ - [AtUI](#atui)
+ - [CubeUI](#cubeui)
+ - [混合开发](#混合开发)
+ - [Flutter](#flutter)
+ - [Ionic](#ionic)
+ - [微信小程序](#微信小程序-1)
+ - [mpvue](#mpvue)
+ - [WeUI](#weui)
+
+
+
+# 前端知识体系
+
+## 前端三要素
+
+- HTML（结构）：超文本标记语言（Hyper Text Markup Language），决定网页的结构和内容
+- CSS（表现）：层叠样式表（Cascading Style Sheets），设定网页的表现样式
+- JavaScript（行为）：是一种弱类型脚本语言，其源代码不需经过编译，而是由浏览器解释运行，用于控制网页的行为
+
+### 结构层（HTML）
+
+略
+
+### 表现层（CSS）
+
+CSS 层叠样式表是一门标记语言，并不是编程语言，因此不可以自定义变量，不可以引用等，换句话说就是不具备任何语法支持，它主要缺陷如下：
+
+- 语法不够强大，比如无法嵌套书写，导致模块化开发中需要书写很多重复的选择器；
+- 没有变量和合理的样式复用机制，使得逻辑上相关的属性值必须以字面量的形式重复输出，导致难以维护；
+
+这就导致了我们在工作中无端增加了许多工作量。为了解决这个问题，前端开发人员会使用一种称之为 **【CSS 预处理器】** 的工具，提供 CSS 缺失的样式层复用机制、减少冗余代码，提高样式代码的可维护性。大大提高了前端在样式上的开发效率。
+
+#### 什么是 CSS 预处理器
+
+CSS 预处理器定义了一种新的语言，其基本思想是，用一种专门的编程语言，为 CSS 增加了一些编程的特性，将 CSS 作为目标生成文件，然后开发者就只要使用这种语言进行 CSS 的编码工作。转化成通俗易懂的话来说就是“**用一种专门的编程语言，进行 Web 页面样式设计，再通过编译器转化为正常的 CSS 文件，以供项目使用**”。
+
+#### 常用的 CSS 预处理器有哪些
+
+- SASS：基于 Ruby，通过服务端处理，功能强大。解析效率高。需要学习 Ruby 语言，上手难度高于 LESS。
+- LESS：基于 NodeJS，通过客户端处理，使用简单。功能比 SASS 简单，解析效率也低于 SASS，但在实际开发中足够了，所以我们后台人员如果需要的话，建议使用 LESS。
+
+### 行为层（JavaScript）
+
+JavaScript 一门弱类型脚本语言，其源代码在发往客户端运行之前不需经过编译，而是将文本格式的字符代码发送给浏览器由浏览器解释运行。
+
+#### Native 原生 JS 开发
+
+原生 JS 开发，也就是让我们按照 **【ECMAScript】** 标准的开发方式，简称是 ES，特点是所有浏览器都支持。截止到当前博客发布时间（2018 年 12 月 04 日），ES 标准已发布如下版本：
+
+- ES3
+- ES4（内部，未正式发布）
+- ES5（全浏览器支持）
+- ES6（常用，当前主流版本）
+- ES7
+- ES8
+- ES9（草案阶段）
+
+区别就是逐步增加新特性。
+
+#### TypeScript 微软的标准
+
+TypeScript 是一种由微软开发的自由和开源的编程语言。它是 JavaScript 的一个超集，而且本质上向这个语言添加了可选的静态类型和基于类的面向对象编程。由安德斯·海尔斯伯格（C#、Delphi、TypeScript 之父；.NET 创立者）主导。
+
+该语言的特点就是除了具备 ES 的特性之外还纳入了许多不在标准范围内的新特性，所以会导致很多浏览器不能直接支持 TypeScript 语法，需要编译后（编译成 JS）才能被浏览器正确执行。
+
+#### JavaScript 框架
+
+- jQuery：大家熟知的 JavaScript 框架，优点是简化了 DOM 操作，缺点是 DOM 操作太频繁，影响前端性能；在前端眼里使用它仅仅是为了兼容 IE6、7、8；
+- Angular：Google 收购的前端框架，由一群 Java 程序员开发，其特点是将后台的 MVC 模式搬到了前端并增加了模块化开发的理念，与微软合作，采用 TypeScript 语法开发；对后台程序员友好，对前端程序员不太友好；最大的缺点是版本迭代不合理（如：1 代 -> 2 代，除了名字，基本就是两个东西；截止发表博客时已推出了 Angular8）。Angular 作为 Google 推出的一个“重型”的框架，内置包括路由、HTTP 等常用组件，同时深度集成 TypeScript，WebPack，RxJS，angular-cli 等工具，可以方便地进行大型前端项目的开发以及调试。但是由于 Angular 引入了许多概念，增加了新手上手的复杂性。特别是组件、模块、服务、指令、依赖注入的引入，对于新手而言，厘清其中各个概念的作用域是就不是一件容易的事情。同时 RxJS 的引入，也进一步使得学习曲线变得陡峭。
+- React：Facebook 出品，一款高性能的 JS 前端框架；特点是提出了新概念 **【虚拟 DOM】** 用于减少真实 DOM 操作，在内存中模拟 DOM 操作，有效的提升了前端渲染效率；缺点是使用复杂，因为需要额外学习一门 **【JSX】** 语言；
+- `Vue`：一款渐进式 JavaScript 框架，所谓渐进式就是逐步实现新特性的意思，如实现模块化开发、路由、状态管理等新特性。其特点是综合了 Angular（模块化） 和 React（虚拟 DOM） 的优点；
+- `Axios`：前端通信框架；因为 `Vue` 的边界很明确，就是为了处理 DOM，所以并不具备通信能力，此时就需要额外使用一个通信框架与服务器交互；当然也可以直接选择使用 jQuery 提供的 AJAX 通信功能；
+
+#### UI 框架
+
+- Ant-Design：阿里巴巴出品，基于 React 的 UI 框架
+- ElementUI：饿了么出品，基于 Vue 的 UI 框架
+- Bootstrap：Twitter 推出的一个用于前端开发的开源工具包
+- AmazeUI：又叫“妹子 UI”，一款 HTML5 跨屏前端框架
+
+#### JavaScript 构建工具
+
+- Babel：JS 编译工具，主要用于浏览器不支持的 ES 新特性，比如用于编译 TypeScript
+- WebPack：模块打包器，主要作用是打包、压缩、合并及按序加载
+
+**注：以上知识点已将 WebApp 开发所需技能全部梳理完毕**
+
+## 三端统一
+
+### 混合开发（Hybrid App）
+
+主要目的是实现一套代码三端统一（PC、Android、iOS）并能够调用到设备底层硬件（如：传感器、GPS、摄像头等），打包方式主要有以下两种：
+
+- 云打包：HBuild -> HBuildX，DCloud 出品；API Cloud
+- 本地打包： Cordova（前身是 PhoneGap）
+
+### 微信小程序
+
+详见微信官网，这里就是介绍一个方便微信小程序 UI 开发的框架：WeUI
+
+## 后端技术
+
+前端人员为了方便开发也需要掌握一定的后端技术，但我们 Java 后台人员知道后台知识体系极其庞大复杂，所以为了方便前端人员开发后台应用，就出现了 NodeJS 这样的技术。
+
+NodeJS 的作者已经声称放弃 NodeJS（说是架构做的不好再加上笨重的 node_modules，可能让作者不爽了吧），开始开发全新架构的 Deno
+
+既然是后台技术，那肯定也需要框架和项目管理工具，NodeJS 框架及项目管理工具如下：
+
+- Express：NodeJS 框架
+- Koa：Express 简化版
+- NPM：项目综合管理工具，类似于 Maven
+- YARN：NPM 的替代方案，类似于 Maven 和 Gradle 的关系
+
+## 附：当前主流前端框架
+
+### Angular
+
+#### Angular Material
+
+Angular Material 是 Angular 官方团队维护的一个遵从 Material Design 的 Angular UI 库。它提供了丰富的组件库、CDK、以及内置主题，开箱即用，并且与 Angular 版本同步。
+
+- [官网地址](https://material.angular.io/)
+- [Github](https://github.com/angular/components)
+
+#### ngx-admin
+
+ngx-admin 是一款开源的 Angualr UI 库，目前仍处于维护和活跃状态。它也提供了丰富的开箱即用的组件库、内置主题，并且与 Angular 版本同步。代码风格遵循 Angular 最佳实践，也是一个不错的学习资源。
+
+- [Github](https://github.com/akveo/ngx-admin)
+
+### Vue.js
+
+#### iView
+
+iview 是一个强大的基于 Vue 的 UI 库，有很多实用的基础组件比 elementui 的组件更丰富，主要服务于 PC 界面的中后台产品。使用单文件的 Vue 组件化开发模式 基于 npm + webpack + babel 开发，支持 ES2015 高质量、功能丰富 友好的 API ，自由灵活地使用空间。
+
+- [官网地址](https://www.iviewui.com/)
+- [Github](https://github.com/TalkingData/iview-weapp)
+- [iview-admin](https://github.com/iview/iview-admin)
+
+**备注：属于前端主流框架，选型时可考虑使用，主要特点是移动端支持较多**
+
+#### ElementUI
+
+Element 是饿了么前端开源维护的 Vue UI 组件库，组件齐全，基本涵盖后台所需的所有组件，文档讲解详细，例子也很丰富。主要用于开发 PC 端的页面，是一个质量比较高的 Vue UI 组件库。
+
+- [官网地址](http://element-cn.eleme.io/#/zh-CN)
+- [Github](https://github.com/ElementUI/element-starter)
+- [vue-element-admin](https://github.com/PanJiaChen/vue-element-admin)
+
+**备注：属于前端主流框架，选型时可考虑使用，主要特点是桌面端支持较多**
+
+#### ICE
+
+飞冰是阿里巴巴团队基于 React/Angular/Vue 的中后台应用解决方案，在阿里巴巴内部，已经有 270 多个来自几乎所有 BU 的项目在使用。飞冰包含了一条从设计端到开发端的完整链路，帮助用户快速搭建属于自己的中后台应用。
+
+- [官网地址](https://alibaba.github.io/ice)
+- [Github](https://github.com/alibaba/ice)
+
+**备注：主要组件还是以 React 为主，截止 2019 年 02 月 17 日更新博客前对 Vue 的支持还不太完善，目前尚处于观望阶段**
+
+#### VantUI
+
+Vant UI 是有赞前端团队基于有赞统一的规范实现的 Vue 组件库，提供了一整套 UI 基础组件和业务组件。通过 Vant，可以快速搭建出风格统一的页面，提升开发效率。
+
+- [官网地址](https://youzan.github.io/vant/#/zh-CN/intro)
+- [Github](https://github.com/youzan/vant)
+
+#### AtUI
+
+at-ui 是一款基于 Vue 2.x 的前端 UI 组件库，主要用于快速开发 PC 网站产品。 它提供了一套 npm + webpack + babel 前端开发工作流程，CSS 样式独立，即使采用不同的框架实现都能保持统一的 UI 风格。
+
+- [官网地址](https://at-ui.github.io/at-ui/#/zh)
+- [Github](https://github.com/at-ui/at-ui)
+
+#### CubeUI
+
+cube-ui 是滴滴团队开发的基于 Vue.js 实现的精致移动端组件库。支持按需引入和后编译，轻量灵活；扩展性强，可以方便地基于现有组件实现二次开发。
+
+- [官网地址](https://didi.github.io/cube-ui/#/zh-CN)
+- [Github](https://github.com/didi/cube-ui/)
+
+### 混合开发
+
+#### Flutter
+
+Flutter 是谷歌的移动端 UI 框架，可在极短的时间内构建 Android 和 iOS 上高质量的原生级应用。Flutter 可与现有代码一起工作, 它被世界各地的开发者和组织使用, 并且 Flutter 是免费和开源的。
+
+- [官网地址](http://doc.flutter-dev.cn/)
+- [Github](https://github.com/flutter/flutter)
+
+**备注：Google 出品，主要特点是快速构建原生 APP 应用程序，如做混合应用该框架为必选框架**
+
+#### Ionic
+
+Ionic 既是一个 CSS 框架也是一个 Javascript UI 库，Ionic 是目前最有潜力的一款 HTML5 手机应用开发框架。通过 SASS 构建应用程序，它提供了很多 UI 组件来帮助开发者开发强大的应用。它使用 JavaScript MVVM 框架和 AngularJS/Vue 来增强应用。提供数据的双向绑定，使用它成为 Web 和移动开发者的共同选择。
+
+- [官网地址](https://ionicframework.com/)
+- [官网文档](https://ionicframework.com/docs/)
+- [Github](https://github.com/ionic-team/ionic)
+
+### 微信小程序
+
+#### mpvue
+
+mpvue 是美团开发的一个使用 `Vue.js` 开发小程序的前端框架，目前支持 **微信小程序**、**百度智能小程序**，**头条小程序** 和 **支付宝小程序**。 框架基于 `Vue.js`，修改了的运行时框架 `runtime` 和代码编译器 `compiler` 实现，使其可运行在小程序环境中，从而为小程序开发引入了 `Vue.js` 开发体验。
+
+- [官网地址](http://mpvue.com/)
+- [Github](https://github.com/Meituan-Dianping/mpvue)
+
+**备注：完备的 Vue 开发体验，并且支持多平台的小程序开发，推荐使用**
+
+#### WeUI
+
+WeUI 是一套同微信原生视觉体验一致的基础样式库，由微信官方设计团队为微信内网页和微信小程序量身设计，令用户的使用感知更加统一。包含 button、cell、dialog、toast、article、icon 等各式元素。
+
+- [官网地址](https://weui.io/)
+- [Github](https://github.com/weui/weui.git)
diff --git a/notes/Git.md b/notes/Git.md
index 0fa9a7fc..e2ca1f02 100644
--- a/notes/Git.md
+++ b/notes/Git.md
@@ -374,6 +374,9 @@ The key fingerprint is: # 01:0f:f4:3b:ca:85:d6:17:a1:7d:f0:68:9d:f0:a2:db your_e
到此为止，你本地的密钥对就生成了。
+(9+条消息)Mac OS 配置多个ssh-key - maoxinwen1的博客 - CSDN博客
+https://blog.csdn.net/maoxinwen1/article/details/80269299
+
### 2. 添加公钥到你的远程仓库（github）
@@ -472,3 +475,17 @@ https://blog.csdn.net/u011478909/article/details/77683754
+## 8. Git 回退到制定版本
+
+**回滚到指定的版本**
+
+```shell
+git reset --hard e377f60e28c8b84158
+```
+
+**强制提交**
+
+```shell
+git push -f origin master
+```
+
diff --git "a/notes/Git\345\221\275\344\273\244\351\200\237\346\237\245.md" "b/notes/Git\345\221\275\344\273\244\351\200\237\346\237\245.md"
new file mode 100644
index 00000000..eddac09b
--- /dev/null
+++ "b/notes/Git\345\221\275\344\273\244\351\200\237\346\237\245.md"
@@ -0,0 +1,437 @@
+# Git 命令速查
+
+> 本文参考极客时间苏玲老师的《玩转Git三剑客》
+
+
+
+## 添加配置
+```bash
+git config [--local | --global | --system] user.name 'Your name'
+git config [--local | --global | --system] user.email 'Your email'
+```
+
+
+
+
+
+## 查看配置
+
+```bash
+git config --list [--local | --global | --system]
+```
+### 区别
+```bash
+local：区域为本仓库
+global: 当前用户的所有仓库
+system: 本系统的所有用户
+```
+
+
+## `git add .` 和 `git add -u`区别
+
+```bash
+git add . ：将工作空间新增和被修改的文件添加的暂存区
+git add -u :将工作空间被修改和被删除的文件添加到暂存区(不包含没有纳入Git管理的新增文件)
+```
+
+
+
+## 创建仓库
+
+```bash
+git init [project folder name] 初始化 git 仓库
+git add [fileName] 把文件从工作目录添加到暂存区
+git commit -m'some information' 用于提交暂存区的文件
+git commit -am'Some information' 用于提交跟踪过的文件
+git log 查看历史
+git status 查看状态
+```
+
+**额外**
+git add -u 可以添加所有已经被 git 控制的文件到暂存区
+以前删除文件夹只会用 「-rf」，今天学到了 「-r」，并得知它们两个区别：「-r」 有时候会提示是否确认删除。
+
+
+
+## 给文件重命名的简便方法
+
+```bash
+git mv [old file name] [new file name]
+git commit -m 'some information'
+```
+
+
+
+## 通过`git log`查看版本演变历史
+
+```bash
+git log --all 查看所有分支的历史
+git log --all --graph 查看图形化的 log 地址
+git log --oneline 查看单行的简洁历史。
+git log --oneline -n4 查看最近的4条简洁历史。
+git log --oneline --all -n4 --graph 查看所有分支最近4条单行的图形化历史。
+git help --web log 跳转到git log 的帮助文档网页
+```
+
+```bash
+git branch -v 查看本地有多少分支
+```
+
+
+
+## 通过图形界面工具来查看版本历史
+
+```bash
+gitk
+```
+
+
+
+## 探密`.git`目录
+
+查看`.git`文件夹下的内容：
+```bash
+ls .git/ -al
+```
+如下:
+```shell
+drwxr-xr-x 1 Andy 197609 0 12月 17 22:38 ./
+drwxr-xr-x 1 Andy 197609 0 12月 17 21:50 ../
+-rw-r--r-- 1 Andy 197609 7 12月 17 22:38 COMMIT_EDITMSG
+-rw-r--r-- 1 Andy 197609 301 12月 12 22:55 config
+-rw-r--r-- 1 Andy 197609 73 12月 12 22:55 description
+-rw-r--r-- 1 Andy 197609 96 12月 19 00:00 FETCH_HEAD
+-rw-r--r-- 1 Andy 197609 23 12月 12 22:55 HEAD
+drwxr-xr-x 1 Andy 197609 0 12月 12 22:55 hooks/
+-rw-r--r-- 1 Andy 197609 249 12月 17 22:38 index
+drwxr-xr-x 1 Andy 197609 0 12月 12 22:55 info/
+drwxr-xr-x 1 Andy 197609 0 12月 12 22:55 logs/
+drwxr-xr-x 1 Andy 197609 0 12月 17 22:38 objects/
+-rw-r--r-- 1 Andy 197609 114 12月 12 22:55 packed-refs
+drwxr-xr-x 1 Andy 197609 0 12月 12 22:55 refs/
+```
+
+```bash
+cat命令主要用来查看文件内容，创建文件，文件合并，追加文件内容等功能。
+cat HEAD 查看HEAD文件的内容
+git cat-file 命令 显示版本库对象的内容、类型及大小信息。
+git cat-file -t b44dd71d62a5a8ed3 显示版本库对象的类型
+git cat-file -s b44dd71d62a5a8ed3 显示版本库对象的大小
+git cat-file -p b44dd71d62a5a8ed3 显示版本库对象的内容
+```
+
+`.git`里几个常用的如下：
+```bash
+HEAD：指向当前的工作路径
+config：存放本地仓库（local）相关的配置信息。
+refs/heads: 存放分支
+refs/heads/master/: 指向master分支最后一次commit
+refs/tags: 存放tag，又叫里程牌 （当这次commit是具有里程碑意义的 比如项目1.0的时候 就可以打tag）
+objects：核心文件，存储文件
+```
+.git/objects/ 存放所有的 git 对象，对象哈希值前 2 位作为文件夹名称，后 38 位作为对象文件名, 可通过 git cat-file -p 命令，拼接文件夹名称+文件名查看。
+
+## `commit`、`tree`和`blob`三个对象之间的关系
+
+
+```bash
+commit: 提交时的镜像
+tree: 文件夹
+blob: 文件
+```
+
+**【同学问题】** 每次commit，git 都会将当前项目的所有文件夹及文件快照保存到objects目录，如果项目文件比较大，不断迭代，commit无数次后，objects目录中文件大小是不是会变得无限大？
+**【老师解答】** Git对于内容相同的文件只会存一个blob，不同的commit的区别是commit、tree和有差异的blob，多数未变更的文件对应的blob都是相同的，这么设计对于版本管理系统来说可以省很多存储空间。其次，Git还有增量存储的机制，我估计是对于差异很小的blob设计的吧。
+
+
+
+## `分离头指针`情况下的注意事项
+
+detached HEAD
+
+
+
+## 进一步理解`HEAD`和`branch`
+
+```bash
+git checkout -b new_branch [具体分支 或 commit] 创建新分支并切换到新分支
+git diff HEAD HEAD~1 比较最近两次提交
+git diff HEAD HEAD~2 比较最近和倒数第三次提交
+git diff HEAD HEAD^ 比较最近两次提交
+git diff HEAD HEAD^^ 比较最近和倒数第三次提交
+```
+
+
+
+## 怎么删除不需要的分支？
+
+查看分支：
+```bash
+git branch -av
+```
+删除分支命令：
+```bash
+git branch -d [branch name] 删除
+git branch -D [branch name] 强制删除
+```
+
+
+
+## 怎么修改最新 commit 的 message？
+
+```bash
+git commit --amend 对最近一次的commit信息进行修改
+```
+
+
+
+## 怎么修改老旧 commit 的 message？
+
+```bash
+git rebase -i [要更改的commit的上一级commit]
+```
+接下来就是一个交互过程...
+这期间会产生一个detached HEAD，然后将改好的commit指向该detached HEAD，如下图所示：
+
+
+**git rebase工作的过程中，就是用了分离头指针。rebase意味着基于新base的commit来变更部分commits。它处理的时候，把HEAD指向base的commit，此时如果该commit没有对应branch，就处于分离头指针的状态，然后重新一个一个生成新的commit，当rebase创建完最后一个commit后，结束分离头状态，Git让变完基的分支名指向HEAD。**
+
+
+
+## 怎样把连续的多个commit整理成1个？
+
+```bash
+git rebase -i [要更改的commit的上一级commit]
+```
+```bash
+$ git log --graph
+* commit 7d3386842a2168ae630b65f687364243139c893c (HEAD -> master, origin/master, origin/HEAD)
+| Author: aimuch
+| Date: Thu Dec 20 23:34:18 2018 +0800
+|
+| update
+|
+* commit 9eb3188bbc63cae1bfed5f9dfc1593019e360a6a
+| Author: aimuch
+| Date: Wed Dec 19 20:30:14 2018 +0800
+|
+| update
+|
+* commit bbe6d53e2b477f2d2aa402af7f315ecdfc63459e
+| Author: aimuch
+| Date: Wed Dec 19 20:12:29 2018 +0800
+|
+| update
+|
+* commit 7735d66ded7f98adeca93d96fb7be12ffb67c76a
+| Author: aimuch
+| Date: Wed Dec 19 00:27:00 2018 +0800
+|
+| update
+|
+* commit d9f9d115fab425b5654f8ccfec6a996aef35b76b
+| Author: aimuch
+| Date: Wed Dec 19 00:23:36 2018 +0800
+|
+| update
+
+```
+```bash
+pick 7735d66 update #合并到该commit上
+squash bbe6d53 update
+squash 9eb3188 update
+squash 7d33868 update
+# Rebase d9f9d11..7d33868 onto d9f9d11 (4 commands)
+#
+# Commands:
+# p, pick = use commit
+# r, reword = use commit, but edit the commit message
+# e, edit = use commit, but stop for amending
+# s, squash = use commit, but meld into previous commit
+# f, fixup = like "squash", but discard this commit's log message
+# x, exec = run command (the rest of the line) using shell
+# b, break = stop here (continue rebase later with 'git rebase --continue')
+# d, drop = remove commit
+# l, label = label current HEAD with a name
+# t, reset = reset HEAD to a label
+# m, merge [-C | -c ] [# ]
+# . create a merge commit using the original merge commit's
+# . message (or the oneline, if no original merge commit was
+# . specified). Use -c to reword the commit message.
+```
+
+```bash
+# This is a combination of 4 commits.
+# This is the 1st commit message:
+
+update
+
+# This is the commit message #2:
+
+update
+
+# This is the commit message #3:
+
+update
+
+# This is the commit message #4:
+
+update
+
+```
+## git 修改.gitignore后生效
+```bash
+git rm -r --cached . #清除缓存
+git add . #重新trace file
+git commit -m "update .gitignore" #提交和注释
+git push origin master #可选，如果需要同步到remote上的话
+```
+
+
+
+## 怎么比较暂存区和HEAD所含文件的差异？
+
+```bash
+git diff --cached
+```
+或者
+```bash
+git diff --staged
+```
+
+
+
+## 怎么比较工作区和暂存区所含文件的差异？
+
+```bash
+git diff
+```
+```bash
+git diff -- [filename/pathname] #比较具体的文件或者路径
+```
+
+
+
+## 如何让暂存区恢复成和HEAD的一样？
+
+```bash
+git reset HEAD
+```
+```bash
+git reset 有三个参数
+--soft 这个只是把 HEAD 指向的 commit 恢复到你指定的 commit，暂存区 工作区不变
+--hard 这个是 把 HEAD， 暂存区， 工作区 都修改为 你指定的 commit 的时候的文件状态
+--mixed 这个是不加时候的默认参数，把 HEAD，暂存区 修改为 你指定的 commit 的时候的文件状态，工作区保持不变
+```
+
+
+
+## 如何让工作区的文件恢复为和暂存区一样？
+
+```bash
+git checkout -- ...
+```
+**恢复工作区用checkout，恢复暂存区用reset。**
+
+
+
+## 怎样取消暂存区部分文件的更改？
+
+```bash
+git reset HEAD -- ...
+```
+
+
+
+## 看看不同提交的指定文件的差异
+
+```bash
+git diff commit-id1 commit-id2 -- ...
+```
+
+
+
+## 正确删除文件的方法
+
+```bash
+git rm
+```
+
+
+
+## 开发中临时加塞了紧急任务怎么处理？
+
+```bash
+git stash list #查看stash中存放的信息
+git stash #将当前工作区内容存放到"堆栈"中
+```
+```bash
+git stash apply #把"堆栈"里面的内容弹出到工作区中，同时"堆栈"中信息还在
+```
+```bash
+git stash pop #把"堆栈"里面的内容弹出到工作区中，同时丢弃"堆栈"中最新的信息
+```
+
+
+
+## 如何指定不需要Git管理的文件？
+
+```bash
+.gitignore
+```
+**【同学提问】** 如果提交commit后，想再忽略一些已经提交的文件，怎么处理。
+**【老师回答】** The problem is that .gitignore ignores just files that weren't tracked before (by git add). Run git reset name_of_file to unstage the file and keep it. In case you want to also remove given file from the repository (after pushing), use git rm --cached name_of_file.
+把想忽略的文件添加到 .gitignore ；然后通过 git rm -- cached name_of_file 的方式删除掉git仓库里面无需跟踪的文件。
+
+
+
+## 添加远程仓库
+```bash
+git remote add [shortname] [url]
+```
+
+
+
+## 配置公私钥
+
+1、 检查是否已存在相应的`ssh key`:
+打开终端, 输入:
+
+```bash
+ls -al ~/.ssh
+```
+核对列出来的ssh key是否有已存在的，假如你没有看到列出的公私钥对，或是不想再用之前的公私钥对，你可以选择下面的步骤生成新的公私钥对.
+
+2、生成新的`ssh key`,并添加至`ssh-agent`:
+打开终端, 使用`ssh key`生成命令：
+```bash
+ssh-keygen -t rsa -b 4096 -C "your_email@example.com"
+```
+**注意** ：后面的邮箱对应相应账号的邮箱，假如是github的账号，且注册账号的邮箱为xxxx@qq.com，则命令行为：`ssh-keygen -t rsa -b 4096 -C "xxxx@qq.com`。
+
+3、接下来会提示你保存的`ssh key`的名称以及路径。默认路径是(`/Users/you/.ssh/id_rsa`) (`you`为用户个人目录)。这一步很重要，如果你使用默认的，且下一个账号也是使用默认的路径和文件名，那么之前的`ssh key`就会被后来生成的`ssh key`重写，从而导致之前的账号不可用。因此，正确的做法是给它命名，最后以应用名进行命名，因为更容易区分。以下是我个人配的：
+```bash
+/Users/andy/.ssh/github_rsa
+```
+
+4、接下来会提示设置ssh安全密码。这一步可以使用默认的（即不设置密码），直接按回车即可。倘若想了解更多关于ssh key密码设置的细节，可访问： “Working with SSH key passphrases” 。
+
+5、 `ssh key`生成后，接下来需要为`ssh key`添加代理，这是为了让请求自动对应相应的账号。网上很多文章写到需要另外配置`config`文件，经本人亲测，其实是不需要的，在生成了`ssh key`后，通过为生成的`ssh key`添加代理即可，为`ssh key`添加代理命令：`ssh-add ~/.ssh/xxx_rsa,xxx_rsa`是你生成的`ssh key`的私钥名。
+
+6、连接测试
+接下来我们测试是否配置成功，打开终端，输入:
+```bash
+ssh -T git@github.com
+```
+
+
+
+## 怎么快速淘到感兴趣的开源项目？
+
+**UI界面高级搜索**： https://github.com/search/advanced
+
+**命令高级搜索**：
+```bash
+git 最好 学习 资料 in:readme stars:>1000 language:c
+```
+上述命令的意思是搜索reademe中包含`git、最好、学习、资料`”且`star大于1000`的，用`C语言编写`的仓库。
\ No newline at end of file
diff --git "a/notes/Git\345\267\245\344\275\234\346\265\201.md" "b/notes/Git\345\267\245\344\275\234\346\265\201.md"
index f0a06ae7..5d239f5f 100644
--- "a/notes/Git\345\267\245\344\275\234\346\265\201.md"
+++ "b/notes/Git\345\267\245\344\275\234\346\265\201.md"
@@ -115,7 +115,9 @@ GitFlow 工作流通过为功能开发、发布准备和维护分配独立的分
## Forking 工作流
-Forking 工作流是分布式工作流，充分利用了 Git 在分支和克隆上的优势。可以安全可靠地管理大团队的开发者（developer），并能接受不信任贡献者（contributor）的提交。
+Forking 工作流是分布式工作流，充分利用了 Git 在分支和克隆上的优势。可以安全可靠地管理大团队的开发者（developer），并能接受不信任贡献者（contributor）的提交。x
+
+
diff --git "a/notes/JavaArchitecture/01-Java\345\237\272\347\241\200.md" "b/notes/JavaArchitecture/01-Java\345\237\272\347\241\200.md"
index 8b32a444..db256bfc 100644
--- "a/notes/JavaArchitecture/01-Java\345\237\272\347\241\200.md"
+++ "b/notes/JavaArchitecture/01-Java\345\237\272\347\241\200.md"
@@ -1,6 +1,6 @@
# 前言
-本文主要包含 Java 核心基础知识，主要根据以下部分进行节选。
+本文主要包含 Java 核心基础知识，主要根据以下部分进行节选，选择了个人认为在面试中最为核心的部分。
- 《Java程序员面试笔试宝典》何昊，薛鹏，叶向阳 著
- [《阿里面经OneNote》](https://blog.csdn.net/sinat_22797429/article/details/76293284)
@@ -248,7 +248,7 @@ public String toLocaleString() {
- 这个注解也是用来抑制编译器警告的注解，用的地方并不多。
5. @FunctionalInterface 用来指定该接口是函数式接口
- - 用该注解显示指定该接口是一个函数式接口。
+ - 用该注解显式指定该接口是一个函数式接口。
@@ -829,7 +829,7 @@ outerClass...
在成员内部类中要注意两点：
-- 成员内部类中不能存在任何 static 的变量和方法；
+- 成员内部类中不能存在`static`方法, 但是可以存在`static`域, 前提是需要使用`final`关键字进行修饰.
- 成员内部类是依附于外围类的，所以只有先创建了外围类才能够创建内部类。
@@ -2007,9 +2007,9 @@ public static void main(String[] args) {
- 当 equals 方法被重写时，通常有必要重写 hashCode 方法，以维护 hashCode 方法的常规协定，该协定声明相对等的两个对象必须有相同的 hashCode
- - object1.euqal(object2) 时为 true， object1.hashCode() == object2.hashCode() 为 true
- - object1.hashCode() == object2.hashCode() 为 false 时，object1.euqal(object2) 必定为 false
- - object1.hashCode() == object2.hashCode() 为 true时，但 object1.euqal(object2) 不一定定为 true
+ - object1.equals(object2) 时为 true， object1.hashCode() == object2.hashCode() 为 true
+ - object1.hashCode() == object2.hashCode() 为 false 时，object1.equals(object2) 必定为 false
+ - object1.hashCode() == object2.hashCode() 为 true时，但 object1.equals(object2) 不一定定为 true
- 重写 equals 不重写 hashcode 会出现什么问题
@@ -2323,4 +2323,4 @@ public class CloneExample implements Cloneable {
- 2018/7/11 v1.0 第一版
- 2018/7/31 v2.0 基础版
-- 2018/8/30-31 v3.0 初版
\ No newline at end of file
+- 2018/8/30-31 v3.0 初版
diff --git "a/notes/JavaArchitecture/02-Java\351\233\206\345\220\210\346\241\206\346\236\266.md" "b/notes/JavaArchitecture/02-Java\351\233\206\345\220\210\346\241\206\346\236\266.md"
index f94e127a..1873bcb3 100644
--- "a/notes/JavaArchitecture/02-Java\351\233\206\345\220\210\346\241\206\346\236\266.md"
+++ "b/notes/JavaArchitecture/02-Java\351\233\206\345\220\210\346\241\206\346\236\266.md"
@@ -3,45 +3,45 @@
- [前言](#前言)
- [一、概述](#一概述)
- [集合框架图](#集合框架图)
- - [Collection](#collection)
- - [Map](#map)
+ - [Collection](#Collection)
+ - [Map](#Map)
- [工具类](#工具类)
- [通用实现](#通用实现)
- [二、深入源码分析](#二深入源码分析)
- - [ArrayList](#arraylist)
+ - [ArrayList](#ArrayList)
- [1. 概览](#1-概览)
- [2. 序列化](#2-序列化)
- [3. 扩容](#3-扩容)
- [4. 删除元素](#4-删除元素)
- - [5. Fail-Fast](#5-fail-fast)
- - [Vector](#vector)
+ - [5. Fail-Fast](#5-Fail-Fast)
+ - [Vector](#Vector)
- [1. 同步](#1-同步)
- - [2. ArrayList 与 Vector](#2-arraylist-与-vector)
- - [3. Vector 替代方案](#3-vector-替代方案)
- - [synchronizedList](#synchronizedlist)
- - [CopyOnWriteArrayList](#copyonwritearraylist)
- - [LinkedList](#linkedlist)
+ - [2. ArrayList 与 Vector](#2-ArrayList-与-Vector)
+ - [3. Vector 替代方案](#3-Vector-替代方案)
+ - [synchronizedList](#synchronizedList)
+ - [CopyOnWriteArrayList](#CopyOnWriteArrayList)
+ - [LinkedList](#LinkedList)
- [1. 概览](#1-概览-1)
- [2. add()](#2-add)
- [3. remove()](#3-remove)
- [4. get()](#4-get)
- [5. 总结](#5-总结)
- - [6. ArrayList 与 LinkedList](#6-arraylist-与-linkedlist)
- - [HashMap](#hashmap)
+ - [6. ArrayList 与 LinkedList](#6-ArrayList-与-LinkedList)
+ - [HashMap](#HashMap)
- [1. 存储结构](#1-存储结构)
- [JDK1.7 的存储结构](#jdk17-的存储结构)
- [JDK1.8 的存储结构](#jdk18-的存储结构)
- [2. 重要参数](#2-重要参数)
- [3. 确定哈希桶数组索引位置](#3-确定哈希桶数组索引位置)
- - [4. 分析HashMap的put方法](#4-分析hashmap的put方法)
+ - [4. 分析HashMap的put方法](#4-分析HashMap的put方法)
- [5. 扩容机制](#5-扩容机制)
- [6. 线程安全性](#6-线程安全性)
- [7. JDK1.8与JDK1.7的性能对比](#7-jdk18与jdk17的性能对比)
- [8. Hash较均匀的情况](#8-hash较均匀的情况)
- [9. Hash极不均匀的情况](#9-hash极不均匀的情况)
- - [10. HashMap与HashTable](#10-hashmap与hashtable)
+ - [10. HashMap与Hashtable](#10-HashMap与Hashtable)
- [11. 小结](#11-小结)
- - [ConcurrentHashMap](#concurrenthashmap)
+ - [ConcurrentHashMap](#ConcurrentHashMap)
- [1. 概述](#1-概述)
- [2. 存储结构](#2-存储结构)
- [2. size 操作](#2-size-操作)
@@ -52,25 +52,25 @@
- [2. 构造函数](#2-构造函数)
- [3. add()](#3-add)
- [4. 总结](#4-总结)
- - [LinkedHashSet and LinkedHashMap](#linkedhashset-and-linkedhashmap)
+ - [LinkedHashSet and LinkedHashMap](#LinkedHashSet-and-LinkedHashMap)
- [1. 概览](#1-概览-2)
- [2. get()](#2-get)
- [3. put()](#3-put)
- [4. remove()](#4-remove)
- - [5. LinkedHashSet](#5-linkedhashset)
- - [6. LinkedHashMap经典用法](#6-linkedhashmap经典用法)
+ - [5. LinkedHashSet](#5-LinkedHashSet)
+ - [6. LinkedHashMap经典用法](#6-LinkedHashMap经典用法)
- [三、容器中的设计模式](#三容器中的设计模式)
- [迭代器模式](#迭代器模式)
- [适配器模式](#适配器模式)
- [四、面试指南](#四面试指南)
- - [1. ArrayList和LinkedList区别](#1-arraylist和linkedlist区别)
- - [2. HashMap和HashTable区别，HashMap的key类型](#2-hashmap和hashtable区别hashmap的key类型)
- - [3. HashMap和ConcurrentHashMap](#3-hashmap和concurrenthashmap)
- - [4. Hashtable的原理](#4-hashtable的原理)
+ - [1. ArrayList和LinkedList区别](#1-ArrayList和LinkedList区别)
+ - [2. HashMap和Hashtable区别，HashMap的key类型](#2-HashMap和Hashtable区别HashMap的key类型)
+ - [3. HashMap和ConcurrentHashMap](#3-HashMap和ConcurrentHashMap)
+ - [4. Hashtable的原理](#4-Hashtable的原理)
- [5. Hash冲突的解决办法](#5-hash冲突的解决办法)
- [6. 什么是迭代器](#6-什么是迭代器)
- [7. 构造相同hash的字符串进行攻击，这种情况应该怎么处理？JDK7如何处理](#7-构造相同hash的字符串进行攻击这种情况应该怎么处理jdk7如何处理)
- - [8. Hashmap为什么大小是2的幂次](#8-hashmap为什么大小是2的幂次)
+ - [8. HashMap为什么大小是2的幂次](#8-HashMap为什么大小是2的幂次)
- [更新日志](#更新日志)
@@ -127,7 +127,7 @@
- `TreeMap`：线程不同步，基于 **红黑树** （Red-Black tree）的 NavigableMap 实现，能够把它保存的记录根据键排序，默认是按键值的升序排序，也可以指定排序的比较器，当用 Iterator 遍历 TreeMap 时，得到的记录是排过序的。
- **TreeMap 底层通过红黑树（Red-Black tree）实现**，也就意味着 `containsKey()`, `get()`, `put()`, `remove()` 都有着 `log(n)` 的时间复杂度。其具体算法实现参照了《算法导论》。
-- `HashTable`：**线程安全**，HashMap 的迭代器 \(Iterator\) 是 `fail-fast` 迭代器。**HashTable 不能存储 NULL 的 key 和 value。**
+- `Hashtable`：**线程安全**，HashMap 的迭代器 \(Iterator\) 是 `fail-fast` 迭代器。**Hashtable 不能存储 NULL 的 key 和 value。**
- `HashMap`：线程不同步。根据 `key` 的 `hashcode` 进行存储，内部使用静态内部类 `Node` 的数组进行存储，默认初始大小为 16，每次扩大一倍。当发生 Hash 冲突时，采用拉链法（链表）。JDK 1.8中：**当单个桶中元素个数大于等于8时，链表实现改为红黑树实现；当元素个数小于6时，变回链表实现。由此来防止hashCode攻击。**
- Java HashMap 采用的是冲突链表方式。
- HashMap 是 Hashtable 的轻量级实现，可以接受为 null 的键值 (key\) 和值 \(value\)，而 Hashtable 不允许。
@@ -1164,9 +1164,9 @@ class Key implements Comparable {
-### 10. HashMap与HashTable
+### 10. HashMap与Hashtable
-1. HashTable 使用 synchronized 来进行同步。
+1. Hashtable 使用 synchronized 来进行同步。
2. HashMap 可以插入键为 null 的 Entry。
3. HashMap 的迭代器是 fail-fast 迭代器。
4. HashMap 不能保证随着时间的推移 Map 中的元素次序是不变的。
@@ -1196,17 +1196,17 @@ class Key implements Comparable {
### 1. 概述
- 众所周知，哈希表是中非常高效，复杂度为 O(1) 的数据结构，在 Java 开发中，我们最常见到最频繁使用的就是 HashMap 和 HashTable，但是在线程竞争激烈的并发场景中使用都不够合理。
+ 众所周知，哈希表是中非常高效，复杂度为 O(1) 的数据结构，在 Java 开发中，我们最常见到最频繁使用的就是 HashMap 和 Hashtable，但是在线程竞争激烈的并发场景中使用都不够合理。
**HashMap** ：先说 HashMap，HashMap 是**线程不安全**的，在并发环境下，可能会形成**环状链表**（扩容时可能造成），导致 get 操作时，cpu 空转，所以，在并发环境中使 用HashMap 是非常危险的。
- **HashTable** ： HashTable 和 HashMap的实现原理几乎一样，差别无非是：（1）HashTable不允许key和value为null；（2）HashTable是线程安全的。
+ **Hashtable** ： Hashtable 和 HashMap的实现原理几乎一样，差别无非是：（1）Hashtable不允许key和value为null；（2）Hashtable是线程安全的。
- 但是 HashTable 线程安全的策略实现代价却太大了，简单粗暴，get/put 所有相关操作都是 synchronized 的，这相当于给整个哈希表加了一把大锁，多线程访问时候，只要有一个线程访问或操作该对象，那其他线程只能阻塞，相当于将所有的操作串行化，在竞争激烈的并发场景中性能就会非常差。
+ 但是 Hashtable 线程安全的策略实现代价却太大了，简单粗暴，get/put 所有相关操作都是 synchronized 的，这相当于给整个哈希表加了一把大锁，多线程访问时候，只要有一个线程访问或操作该对象，那其他线程只能阻塞，相当于将所有的操作串行化，在竞争激烈的并发场景中性能就会非常差。
- HashTable 性能差主要是由于所有操作需要竞争同一把锁，而如果容器中有多把锁，每一把锁锁一段数据，这样在多线程访问时不同段的数据时，就不会存在锁竞争了，这样便可以有效地提高并发效率。这就是ConcurrentHashMap 所采用的 "**分段锁**" 思想。
+ Hashtable 性能差主要是由于所有操作需要竞争同一把锁，而如果容器中有多把锁，每一把锁锁一段数据，这样在多线程访问时不同段的数据时，就不会存在锁竞争了，这样便可以有效地提高并发效率。这就是ConcurrentHashMap 所采用的 "**分段锁**" 思想。
n ，这是为什么？indexFor这个方法解释了这个问题**
+**HashMap 始终将自己的桶保持在2n ，这是为什么？indexFor这个方法解释了这个问题**
大家都知道计算机里面位运算是基本运算，位运算的效率是远远高于取余 % 运算的
@@ -1928,4 +1928,4 @@ static int indexFor(int h, int length) {
# 更新日志
- 2018/8/3 v2.5 基础版
-- 2018/9/1 v3.0 初稿版
\ No newline at end of file
+- 2018/9/1 v3.0 初稿版
diff --git "a/notes/JavaArchitecture/03-Java\345\271\266\345\217\221\347\274\226\347\250\213.md" "b/notes/JavaArchitecture/03-Java\345\271\266\345\217\221\347\274\226\347\250\213.md"
index bf57a7c4..f90fdfb1 100644
--- "a/notes/JavaArchitecture/03-Java\345\271\266\345\217\221\347\274\226\347\250\213.md"
+++ "b/notes/JavaArchitecture/03-Java\345\271\266\345\217\221\347\274\226\347\250\213.md"
@@ -154,12 +154,6 @@
-参考资料：
-
-- 《Java并发编程实战》
-
-
-
# 第一部分：并发编程
## 1. 线程状态转换
@@ -776,7 +770,7 @@ ReentrantLock 多了一些高级功能。
- （用法）synchronized（隐式锁）：在需要同步的对象中加入此控制，synchronized 可以加在方法上，也可以加在特定代码块中，括号中表示需要锁的对象。
- （用法）lock（显示锁）：需要显示指定起始位置和终止位置。一般使用 ReentrantLock 类做为锁，多个线程中必须要使用一个 ReentrantLock 类做为对象才能保证锁的生效。且在加锁和解锁处需要通过 lock() 和 unlock() 显示指出。所以一般会在 finally 块中写 unlock() 以防死锁。
- （性能）synchronized 是托管给 JVM 执行的，而 lock 是 Java 写的控制锁的代码。在 Java1.5 中，synchronize 是性能低效的。因为这是一个重量级操作，需要调用操作接口，导致有可能加锁消耗的系统时间比加锁以外的操作还多。相比之下使用 Java 提供的 Lock 对象，性能更高一些。但是到了 Java1.6 ，发生了变化。synchronize 在语义上很清晰，可以进行很多优化，有适应自旋，锁消除，锁粗化，轻量级锁，偏向锁 等等。导致 在 Java1.6 上 synchronize 的性能并不比 Lock 差。
-- （机制）**synchronized 原始采用的是 CPU 悲观锁机制，即线程获得的是独占锁**。独占锁意味着其他线程只能依靠阻塞来等待线程释放锁。**Lock 用的是乐观锁方式**。所谓乐观锁就是，每次不加锁而是假设没有冲突而去完成某项操作，如果因为冲突失败就重试，直到成功为止。乐观锁实现的机制就是 CAS 操作（Compare and Swap）。
+- （机制）**synchronized 原始采用的是 CPU 悲观锁机制，即线程获得的是独占锁。Lock 也属于悲观锁**。独占锁意味着其他线程只能依靠阻塞来等待线程释放锁。相对而言乐观锁每次不加锁，而是假设没有冲突而去完成某项操作，如果因为冲突失败就重试，直到成功为止。乐观锁实现的机制就是 CAS 操作（Compare and Swap）。
@@ -2936,7 +2930,7 @@ synchronized 不仅保证可见性，而且还保证原子性，因为，只有
在代码中如果过度依赖 volatile 变量来控制状态的可见性，通常会比使用锁的代码更脆弱，也更难以理解。仅当 volatile 变量能简化代码的实现以及对同步策略的验证时，才应该使用它。一般来说，用同步机制会更安全些。
- - volatile 无法同时保证内存可见性和原则性：
+ - volatile 无法同时保证内存可见性和原子性：
加锁机制（即同步机制）既可以确保可见性又可以确保原子性，而 volatile 变量只能确保可见性，原因是声明为volatile的简单变量如果当前值与该变量以前的值相关，那么 volatile 关键字不起作用，也就是说如下的表达式都不是原子操作：“count++”、“count = count+1”。
@@ -3367,4 +3361,4 @@ https://blog.csdn.net/zbw18297786698/article/details/53420780
# 更新日志
-- 2018/9/2 v3.0
\ No newline at end of file
+- 2018/9/2 v3.0
diff --git a/notes/JavaArchitecture/04-Java-IO.md b/notes/JavaArchitecture/04-Java-IO.md
index d8fe9da1..b3656b93 100644
--- a/notes/JavaArchitecture/04-Java-IO.md
+++ b/notes/JavaArchitecture/04-Java-IO.md
@@ -86,7 +86,7 @@ public static void copyFile(String src, String dist) throws IOException
-At Least Once + 幂等性 = Exactly Once
+ 要启用幂等性，只需要将 Producer 的参数中 enable.idompotence 设置为 true 即可。Kafka 的幂等性实现其实就是将原来下游需要做的去重放在了数据上游。开启幂等性的 Producer 在初始化的时候会被分配一个 PID，发往同一 Partition 的消息会附带 Sequence Number。而 Broker 端会对 做缓存，当具有相同主键的消息提交时，Broker 只会持久化一条。
+
+ 但是 PID 重启就会变化，同时不同的 Partition 也具有不同主键，**所以幂等性无法保证跨分区跨会话**的 Exactly Once。
+
+
+
+## 三、Kafka 消费者
+
+### 1. 消费方式
+
+ **consumer 采用 pull（拉）模式从 broker 中读取数据。**
+
+ **push（推）模式很难适应消费速率不同的消费者，因为消息发送速率是由 broker 决定的。**它的目标是尽可能以最快速度传递消息，但是这样很容易造成 consumer 来不及处理消息，典型的表现就是拒绝服务以及网络拥塞。而 pull 模式则可以根据 consumer 的消费能力以适当的速率消费消息。
+
+ **pull 模式不足之处是，如果 kafka 没有数据，消费者可能会陷入循环中，一直返回空数据。**针对这一点，Kafka 的消费者在消费数据时会传入一个时长参数 timeout，如果当前没有数据可供消费，consumer 会等待一段时间之后再返回，这段时长即为 timeout。
+
+
+
+### 2. 分区分配策略
+
+ 一个 consumer group 中有多个 consumer，一个 topic 有多个 partition，所以必然会涉及到 partition 的分配问题，即确定那个 partition 由哪个 consumer 来消费。
+
+ Kafka 有两种分配策略，一是 **RoundRobin**，一是 **range**。
+
+
+
+
+
+ **roundrobin**根据 partition 号对 consumer 个数取模后轮循分配
+
+
+
+
+
+ **range**提前按照均匀分配的原则计算个数后直接分配。
+
+
+
+ 在订阅多个 partition 时 range 会有**不均匀**问题，kafka 默认为 range，因为不考虑多 partition 订阅时，range 效率更高。
+
+
+
+### 3. offset 的维护
+
+ 由于 consumer 在消费过程中可能会出现断电宕机等故障，consumer 恢复后，需要从故障前的位置的继续消费，所以 consumer 需要实时记录自己消费到了哪个 offset，以便故障恢复后继续消费。
+
+ group + topic + partition（GTP） 才能确定一个 offset！
+
+
+
+ Kafka 0.9 版本之前，consumer 默认将 offset 保存在 Zookeeper 中，从 0.9 版本开始，consumer 默认将 offset 保存在 Kafka 一个内置的 topic 中，该 topic 为 `__consumer_offsets`（此时消费者对于 offset 相当于生产者）。
+
+1）修改配置文件 consumer.properties
+
+```properties
+exclude.internal.topics=false
+```
+
+2）读取offset
+
+- 0.11.0.0 之前版本:
+
+```shell
+bin/kafkabin/kafka--consoleconsole--consumer.sh consumer.sh ----topic __consumer_offsets topic __consumer_offsets ----zookeeper zookeeper hadoophadoop102102:2181 :2181 ----formatter formatter
+
+"kafka.coordinator.GroupMetadataManager"kafka.coordinator.GroupMetadataManager\\$OffsetsMessageFormatter" $OffsetsMessageFormatter" ----consumer.config config/consumer.properties consumer.config config/consumer.properties ----fromfrom--beginningbeginning
+```
+
+- 0.11.0.0 之后版本(含):
+
+```shell
+bin/kafkabin/kafka--consoleconsole--consumer.sh consumer.sh ----topic __consumer_offsets topic __consumer_offsets ----zookeeper zookeeper hadoophadoop102102:2181 :2181 ----formatter formatter
+
+"kafka.coordinator.group.GroupMetadataManager"kafka.coordinator.group.GroupMetadataManager\\$OffsetsMessageForm$OffsetsMessageFormatter" atter" ----consumer.config config/consumer.propertiesconsumer.config config/consumer.properties ----fromfrom--beginningbeginning
+```
+
+ 同一个消费者组中的消费者， 同一时刻只能有一个消费者消费。
+
+
+
+## 四、Kafka 高效读写数据
+
+### 1. 顺序写磁盘
+
+ Kafka 的 producer 生产数据，要写入到 log 文件中，写的过程是一直追加到文件末端，为顺序写。官网有数据表明，同样的磁盘，顺序写能到到 600M/s，而随机写只有 100k/s。这与磁盘的机械机构有关，顺序写之所以快，是因为其省去了大量磁头寻址的时间。
+
+
+
+### 2. 零拷贝技术
+
+ 零拷贝主要的任务就是避免 CPU 将数据从一块存储拷贝到另外一块存储，主要就是利用各种零拷贝技术，避免让 CPU 做大量的数据拷贝任务，减少不必要的拷贝，或者让别的组件来做这一类简单的数据传输任务，让 CPU 解脱出来专注于别的任务。这样就可以让系统资源的利用更加有效。
+
+ 更详细，请参考：[浅析Linux中的零拷贝技术 - 简书](https://www.jianshu.com/p/fad3339e3448)
+
+
+
+
+
+
+
+## 五、Zookeeper 在 Kafka 中的作用
+
+ Kafka 集群中有一个 broker 会被选举为 Controller，负责管理集群 broker 的上下线，所有 topic 的分区副本分配和 leader 选举等工作。
+
+ Controller 的管理工作都是依赖于 Zookeeper 的。
+
+ 以下为 partition 的 leader 选举过程：
+
+
+
+
+
+## 六、Kafka 事务
+
+ Kafka 从0.11 版本开始引入了事务支持。事务可以保证 Kafka 在 Exactly Once 语义的基础上，生产和消费可以跨分区和会话，要么全部成功，要么全部失败。
+
+ **注意**：这里的事务主要谈的是生产者（Producer）的事务
+
+
+
+### 1. Producer事务事务
+
+ 为了实现跨分区跨会话的事务，需要引入一个全局唯一的 Transaction ID（**一定是客户端给的**），并将 Producer 获得的 PID 和 Transaction ID 绑定。这样当 Producer 重启后就可以通过正在进行的 Transaction ID 获得原来的 PID。
+
+ 为了管理 Transaction，Kafka 引入了一个新的组件 Transaction Coordinator。Producer 就是通过和 Transaction Coordinator 交互获得 Transaction ID 对应的任务状态。Transaction Coordinator 还负责将事务所有写入 Kafka 的一个内部 Topic，这样即使整个服务重启，由于事务状态得到保存，进行中的事务状态可以得到恢复，从而继续进行。
+
+
+
+### 2. Consumer **事务**
+
+ 上述事务机制主要是从 Producer 方面考虑，对于 Consumer 而言，事务的保证就会相对较弱，尤其时无法保证 Commit 的信息被精确消费。这是由于 Consumer 可以通过 offset 访问任意信息，而且不同的 Segment File 生命周期不同，同一事务的消息可能会出现重启后被删除的情况。
diff --git a/notes/MicroService/kafka/kafka-tutorial-5_kafka-api.md b/notes/MicroService/kafka/kafka-tutorial-5_kafka-api.md
new file mode 100644
index 00000000..67e8c006
--- /dev/null
+++ b/notes/MicroService/kafka/kafka-tutorial-5_kafka-api.md
@@ -0,0 +1,634 @@
+
+
+- [深入浅出 Kafka（五）Kafka API](#深入浅出-kafka五kafka-api)
+ - [一、Producer API](#一producer-api)
+ - [1. 消息发送流程](#1-消息发送流程)
+ - [2. 异步发送 API](#2-异步发送-api)
+ - [（1）不带回调函数的异步（AsyncProducer）](#1不带回调函数的异步asyncproducer)
+ - [（2）带回调函数的异步（CallbackProducer）](#2带回调函数的异步callbackproducer)
+ - [3. 同步发送 API](#3-同步发送-api)
+ - [（1）同步发送（SyncProducer）](#1同步发送syncproducer)
+ - [二、Consumer API](#二consumer-api)
+ - [1. 自动提交 offset](#1-自动提交-offset)
+ - [2. 手动提交 offset](#2-手动提交-offset)
+ - [（1）同步提交 commitSync offset](#1同步提交-commitsync-offset)
+ - [（2）异步提交 commitAsync offset](#2异步提交-commitasync-offset)
+ - [（3）数据漏消费和重复消费分析](#3数据漏消费和重复消费分析)
+ - [3. 自定义存储 offset](#3-自定义存储-offset)
+ - [三、自定义 Interceptor](#三自定义-interceptor)
+ - [1. 拦截器原理](#1-拦截器原理)
+ - [2. 拦截器案例](#2-拦截器案例)
+
+
+
+# 深入浅出 Kafka（五）Kafka API
+
+## 一、Producer API
+
+### 1. 消息发送流程
+
+ Kafka 的 Producer 发送消息采用的是**异步发送**的方式。
+
+ 在消息发送的过程中，涉及到了两个线程 —— main 线程和 Sender 线程，以及一个线程共享变量——RecordAccumulator（接收器）。
+
+ main 线程将消息发送给 RecordAccumulator，Sender 线程不断从 RecordAccumulator 中拉取消息发送到 Kafka broker。
+
+
+
+相关参数：
+- **batch.size**：只有数据积累到 batch.size 之后，sender 才会发送数据。
+- **linger.ms**：如果数据迟迟未达到 batch.size，sender 等待 linger.time 之后就会发送数据。
+
+
+
+
+
+
+
+### 2. 异步发送 API
+
+- **KafkaProducer** 需要创建一个生产者对象，用来发送数据
+- **ProducerConfig** 获取所需的一系列配置参数
+- **ProducerRecord** 每条数据都要封装成一个 ProducerRecord 对象
+
+```xml
+
+ org.apache.kafka
+ kafka-clients
+ 0.11.0.0
+
+```
+
+#### （1）不带回调函数的异步（AsyncProducer）
+
+```java
+package com.tian.kafka.producer;
+
+import org.apache.kafka.clients.producer.KafkaProducer;
+import org.apache.kafka.clients.producer.ProducerConfig;
+import org.apache.kafka.clients.producer.ProducerRecord;
+import org.apache.kafka.common.serialization.StringSerializer;
+
+import java.util.Properties;
+
+/**
+ * 不带回调函数的异步 Producer API
+ */
+public class AsyncProducer {
+ public static void main(String[] args) {
+ Properties props = new Properties();
+ props.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,
+ "hadoop101:9092,hadoop102:9092,hadoop103:9092");
+ props.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG,
+ StringSerializer.class.getName());
+ props.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG,
+ StringSerializer.class.getName());
+ props.put(ProducerConfig.ACKS_CONFIG, "all");
+ props.put(ProducerConfig.RETRIES_CONFIG, 1);
+ props.put(ProducerConfig.LINGER_MS_CONFIG, 1);
+ // 配置拦截器
+
+ // 通过配置创建 KafkaProducer 对象
+ KafkaProducer producer = new KafkaProducer<>(props);
+ for (int i = 0; i < 1000; i++) {
+ ProducerRecord record = new ProducerRecord<>("first", "message" + i);
+ producer.send(record);
+ }
+ producer.close();
+ }
+}
+```
+
+#### （2）带回调函数的异步（CallbackProducer）
+
+```java
+package com.tian.kafka.producer;
+
+import org.apache.kafka.clients.producer.*;
+import org.apache.kafka.common.serialization.StringSerializer;
+
+import java.util.Properties;
+
+/**
+ * 带回调函数的异步Producer API
+ */
+public class CallbackProducer {
+ public static void main(String[] args) {
+ Properties props = new Properties();
+ props.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,
+ "192.168.72.133:9092");
+ props.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG,
+ StringSerializer.class.getName());
+ props.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG,
+ StringSerializer.class.getName());
+ props.put(ProducerConfig.ACKS_CONFIG, "all");
+ props.put(ProducerConfig.RETRIES_CONFIG, 1);
+ KafkaProducer producer = new KafkaProducer<>(props);
+ for (int i = 0; i < 1000; i++) {
+ ProducerRecord record = new ProducerRecord<>("first", "message" + i);
+ producer.send(record, new Callback() {
+ @Override
+ public void onCompletion(RecordMetadata recordMetadata, Exception e) {
+ if (e == null)
+ System.out.println("success:" + recordMetadata.topic() +
+ "-" + recordMetadata.partition() +
+ "-" + recordMetadata.offset());
+ else e.printStackTrace();
+ }
+ });
+
+ }
+ producer.close();
+ }
+}
+```
+
+
+
+### 3. 同步发送 API
+
+#### （1）同步发送（SyncProducer）
+
+```java
+package com.tian.kafka.producer;
+
+import org.apache.kafka.clients.producer.KafkaProducer;
+import org.apache.kafka.clients.producer.ProducerConfig;
+import org.apache.kafka.clients.producer.ProducerRecord;
+import org.apache.kafka.clients.producer.RecordMetadata;
+import org.apache.kafka.common.serialization.StringSerializer;
+
+import java.util.Properties;
+import java.util.concurrent.ExecutionException;
+
+/**
+ * 同步 Producer API
+ */
+public class SyncProducer {
+ public static void main(String[] args) throws ExecutionException, InterruptedException {
+ // 创建 properties 对象用于存放配置
+ Properties props = new Properties();
+ // 添加配置
+ props.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "hadoop101:9092,hadoop102:9092,hadoop103:9092");
+ props.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
+ props.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
+ props.put(ProducerConfig.ACKS_CONFIG, "all");
+ props.put(ProducerConfig.RETRIES_CONFIG, 1); // 重试次数
+ props.put(ProducerConfig.LINGER_MS_CONFIG, 500);
+ // 通过已有配置创建 kafkaProducer 对象
+ KafkaProducer producer = new KafkaProducer<>(props);
+ // 循环调用 send 方法不断发送数据
+ for (int i = 0; i < 100; i++) {
+ ProducerRecord record = new ProducerRecord<>("first", "message" + i);
+ RecordMetadata metadata = producer.send(record).get();// 通过 get()方法实现同步效果
+ if (metadata != null)
+ System.out.println("success:" + metadata.topic() + "-" +
+ metadata.partition() + "-" + metadata.offset());
+ }
+ producer.close(); // 关闭生产者对象
+ }
+}
+```
+
+
+
+## 二、Consumer API
+
+ Consumer 消费数据时的可靠性是很容易保证的，因为数据在 Kafka 中是持久化的，故不用担心数据丢失问题。
+ 由于 consumer 在消费过程中可能会出现断电宕机等故障，consumer 恢复后，需要从故障前的位置的继续消费，所以 consumer 需要实时记录自己消费到了哪个 offset，以便故障恢复后继续消费。
+ 所以 offset 的维护是 Consumer 消费数据是必须考虑的问题。
+
+### 1. 自动提交 offset
+
+```xml
+
+ org.apache.kafka
+ kafka-clients
+ 0.11.0.0
+
+```
+
+- **KafkaConsumer**：需要创建一个消费者对象，用来消费数据
+- **ConsumerConfig**：获取所需的一系列配置参数
+- **ConsuemrRecord**：每条数据都要封装成一个 ConsumerRecord 对象
+
+为了使我们能够专注于自己的业务逻辑，Kafka 提供了自动提交 offset 的功能。
+
+自动提交 offset 的相关参数：
+
+- **enable.auto.commit**：是否开启自动提交 offset 功能
+- **auto.commit.interval.ms**：自动提交 offset 的时间间隔
+
+```java
+package com.tian.kafka.consumer;
+
+import org.apache.kafka.clients.consumer.ConsumerConfig;
+import org.apache.kafka.clients.consumer.ConsumerRecord;
+import org.apache.kafka.clients.consumer.ConsumerRecords;
+import org.apache.kafka.clients.consumer.KafkaConsumer;
+import org.apache.kafka.common.serialization.StringDeserializer;
+
+import java.util.Arrays;
+import java.util.Properties;
+
+/**
+ * 自动提交 offset
+ */
+public class AutoCommitOffset {
+ public static void main(String[] args) {
+ Properties props = new Properties();
+ props.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG,
+ "hadoop101:9092,hadoop102:9092");
+ props.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG,
+ StringDeserializer.class.getName());
+ props.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG,
+ StringDeserializer.class.getName());
+ props.put(ConsumerConfig.GROUP_ID_CONFIG,"tian"); // groupid
+ props.put(ConsumerConfig.AUTO_OFFSET_RESET_CONFIG,"earliest");
+ props.put(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG,true); // 自动提交
+ KafkaConsumer consumer = new KafkaConsumer<>(props);
+ consumer.subscribe(Arrays.asList("first")); // 添加需要消费的 topic
+ try {
+ while(true){
+ ConsumerRecords records = consumer.poll(100);
+ for (ConsumerRecord record : records) {
+ System.out.println(record.value());
+ }
+ }
+ } finally {
+ consumer.close();// 在死循环中无法调用 close 方法，所以需要使用 finally
+ }
+ }
+}
+```
+
+
+
+### 2. 手动提交 offset
+
+ 虽然自动提交 offset 十分简介便利，但由于其是基于时间提交的，开发人员难以把握 offset 提交的时机。因此 Kafka 还提供了手动提交 offset 的 API。
+ 手动提交 offset 的方法有两种: 分别是 **commitSync**（**同步提交**）和 **commitAsync**（**异步提交**）。两者的相同点是，都会将本次 poll 的一批数据最高的偏移量提交; 不同点是，commitSync 阻塞当前线程，一直到提交成功，并且会自动失败充实（由不可控因素导致，也会出现提交失败）; 而 commitAsync 则没有失败重试机制，故有可能提交失败。
+
+#### （1）同步提交 commitSync offset
+
+ 由于同步提交 offset 有失败重试机制，故更加可靠，以下为同步提交 offset 的示例
+
+```java
+package com.tian.kafka.consumer;
+
+import org.apache.kafka.clients.consumer.ConsumerRecord;
+import org.apache.kafka.clients.consumer.ConsumerRecords;
+import org.apache.kafka.clients.consumer.KafkaConsumer;
+
+import java.util.Arrays;
+import java.util.Properties;
+
+/**
+ * 同步手动提交 offset
+ */
+public class CustomComsumer {
+
+ public static void main(String[] args) {
+
+ Properties props = new Properties();
+ props.put("bootstrap.servers", "hadoop102:9092");//Kafka 集群
+ props.put("group.id", "test");// 消费者组，只要 group.id 相同，就属于同一个消费者组
+ props.put("enable.auto.commit", "false");// 关闭自动提交 offset
+ props.put("key.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
+ props.put("value.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
+
+ KafkaConsumer consumer = new KafkaConsumer<>(props);
+ consumer.subscribe(Arrays.asList("first"));// 消费者订阅主题
+
+ while (true) {
+ ConsumerRecords records = consumer.poll(100);// 消费者拉取数据
+ for (ConsumerRecord record : records) {
+ System.out.printf("offset = %d, key = %s, value = %s%n", record.offset(), record.key(), record.value());
+ }
+ consumer.commitSync();// 同步提交，当前线程会阻塞直到 offset 提交成功
+ }
+ }
+}
+```
+
+
+
+#### （2）异步提交 commitAsync offset
+
+ 虽然同步提交 offset 更可靠一些，但是由于其会阻塞当前线程，直到提交成功。因此吞吐量会收到很大的影响，因此更多的情况下，会选用异步提交 offset 的方式。
+
+```java
+package com.tian.kafka.consumer;
+
+import org.apache.kafka.clients.consumer.*;
+import org.apache.kafka.common.TopicPartition;
+import org.apache.kafka.common.serialization.StringDeserializer;
+
+import java.util.Arrays;
+import java.util.Map;
+import java.util.Properties;
+
+/**
+ * 异步手动提交 offset
+ */
+public class AsyncManualCommitOffset {
+ public static void main(String[] args) {
+ Properties props = new Properties();
+ props.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, "hadoop101:9092");
+ props.put(ConsumerConfig.GROUP_ID_CONFIG, "tian");
+ props.put(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG, false);
+ props.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG,
+ StringDeserializer.class.getName());
+ props.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG,
+ StringDeserializer.class.getName());
+ KafkaConsumer consumer = new KafkaConsumer(props);
+ consumer.subscribe(Arrays.asList("first"));
+ while (true) {
+ ConsumerRecords records = consumer.poll(100);
+ for (ConsumerRecord record : records) {
+ System.out.println("offset:" + record.offset() +
+ "key:" + record.key() + "value" + record.value());
+ }
+ consumer.commitAsync(new OffsetCommitCallback() {
+ public void onComplete(Map map, Exception e) {
+ if (e != null)
+ System.out.println("commit failed for" + map);
+ }
+ });// 异步提交
+ }
+ }
+}
+```
+
+
+
+#### （3）数据漏消费和重复消费分析
+
+ 无论是同步提交还是异步提交 offset，都有可能会造成数据的漏消费或者重复消费。先提交 offset 后消费，有可能造成数据的漏消费；而先消费后提交 offset，有可能会造成数据的重复消费。
+
+
+
+
+
+### 3. 自定义存储 offset
+
+ Kafka 0.9 版本之前，offset 存储在 zookeeper，0.9 版本之后，默认将 offset 存储在 Kafka 的一个内置的 topic 中。除此之外，Kafka 还可以选择自定义存储 offset。
+ offset 的维护是相当繁琐的，因为需要考虑到消费者的 Rebalance。
+ 当有新的消费者加入消费者组、已有的消费者推出消费者组或者所订阅的主题的分区发生变化，就会触发到分区的重新分配，重新分配的过程叫做 Rebalance。
+ 消费者发生 Rebalance 之后，每个消费者消费的分区就会发生变化。因此消费者要首先获取到自己被重新分配到的分区，并且定位到每个分区最近提交的 offset 位置继续消费。
+ 要实现自定义存储 offset，需要借助 ConsumerRebalanceListener，以下为示例代码，其中提交和获取 offset 的方法，需要根据所选的 offset 存储系统自行实现。
+
+```java
+package com.tian.kafka.consumer;
+
+import org.apache.kafka.clients.consumer.*;
+import org.apache.kafka.common.TopicPartition;
+
+import java.util.*;
+
+/**
+ * 自定义存储 offset
+ */
+public class CustomConsumer {
+
+ private static Map currentOffset = new HashMap<>();
+
+ public static void main(String[] args) {
+ Properties props = new Properties();
+ props.put("bootstrap.servers", "hadoop102:9092");//Kafka 集群
+ props.put("group.id", "test");// 消费者组，只要 group.id 相同，就属于同一个消费者组
+ props.put("enable.auto.commit", "false");// 关闭自动提交 offset
+ props.put("key.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
+ props.put("value.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
+
+ KafkaConsumer consumer = new KafkaConsumer<>(props);
+ // 消费者订阅主题
+ consumer.subscribe(Arrays.asList("first"), new ConsumerRebalanceListener() {
+
+ // 该方法会在 Rebalance 之前调用
+ @Override
+ public void onPartitionsRevoked(Collection partitions) {
+ commitOffset(currentOffset);
+ }
+
+ // 该方法会在 Rebalance 之后调用
+ @Override
+ public void onPartitionsAssigned(Collection partitions) {
+ currentOffset.clear();
+ for (TopicPartition partition : partitions) {
+ consumer.seek(partition, getOffset(partition));// 定位到最近提交的 offset 位置继续消费
+ }
+ }
+ });
+
+ while (true) {
+ ConsumerRecords records = consumer.poll(100);// 消费者拉取数据
+ for (ConsumerRecord record : records) {
+ System.out.printf("offset = %d, key = %s, value = %s%n", record.offset(), record.key(), record.value());
+ currentOffset.put(new TopicPartition(record.topic(), record.partition()), record.offset());
+ }
+ commitOffset(currentOffset);
+ }
+ }
+
+ // 获取某分区的最新 offset
+ private static long getOffset(TopicPartition partition) {
+ return 0;
+ }
+
+ // 提交该消费者所有分区的 offset
+ private static void commitOffset(Map currentOffset) {
+
+ }
+}
+```
+
+
+
+## 三、自定义 Interceptor
+
+### 1. 拦截器原理
+
+ Producer 拦截器 (interceptor) 是在 Kafka 0.10 版本被引入的，主要用于实现 clients 端的定制化控制逻辑。
+对于 producer 而言，interceptor 使得用户在消息发送前以及 producer 回调逻辑前有机会对消息做一些定制化需求，比如修改消息等。同时，producer 允许用户指定多个 interceptor 按序作用于同一条消息从而形成一个拦截链(interceptor chain)。Intercetpor 的实现接口是 `org.apache.kafka.clients.producer.ProducerInterceptor`，
+
+其定义的方法包括：
+
+1. configure (configs)
+ 获取配置信息和初始化数据时调用。
+2. onSend (ProducerRecord)：
+ 该方法封装进 KafkaProducer.send 方法中，即它运行在用户主线程中。Producer 确保在消息被序列化以及计算分区前调用该方法。用户可以在该方法中对消息做任何操作，但最好保证不要修改消息所属的 topic 和分区，否则会影响目标分区的计算。
+3. onAcknowledgement (RecordMetadata, Exception)：
+ 该方法会在消息从 RecordAccumulator 成功发送到 Kafka Broker 之后，或者在发送过程中失败时调用。并且通常都是在 producer 回调逻辑触发之前。onAcknowledgement 运行在 producer 的 IO 线程中，因此不要在该方法中放入很重的逻辑，否则会拖慢 producer 的消息发送效率。
+4. close：
+ 关闭 interceptor，主要用于执行一些资源清理工作
+ 如前所述，interceptor 可能被运行在多个线程中，因此在具体实现时用户需要自行确保线程安全。另外倘若指定了多个 interceptor，则 producer 将按照指定顺序调用它们，并仅仅是捕获每个 interceptor 可能抛出的异常记录到错误日志中而非在向上传递。这在使用过程中要特别留意。
+
+
+
+### 2. 拦截器案例
+
+- **需求 **
+ 实现一个简单的双 interceptor 组成的拦截链。第一个 interceptor 会在消息发送前将时间戳信息加到消息 value 的最前部；第二个 interceptor 会在消息发送后更新成功发送消息数或失败发送消息数。
+
+
+
+```java
+package com.tian.kafka.interceptor;
+
+import org.apache.kafka.clients.producer.ProducerInterceptor;
+import org.apache.kafka.clients.producer.ProducerRecord;
+import org.apache.kafka.clients.producer.RecordMetadata;
+
+import java.util.Map;
+
+/**
+ * 增加时间戳
+ */
+public class TimeInterceptor implements ProducerInterceptor {
+ /**
+ * 返回一个新的 recorder，把时间戳写入消息体的最前部
+ * @param record
+ * @return
+ */
+ @Override
+ public ProducerRecord onSend(ProducerRecord record) {
+ return new ProducerRecord(record.topic(),record.partition(),record.timestamp(),
+ record.key(),System.currentTimeMillis() + "," + record.value().toString());
+ }
+
+ @Override
+ public void onAcknowledgement(RecordMetadata recordMetadata, Exception e) {
+
+ }
+
+ @Override
+ public void close() {
+
+ }
+
+ @Override
+ public void configure(Map map) {
+
+ }
+}
+```
+
+```java
+package com.tian.kafka.interceptor;
+
+import org.apache.kafka.clients.producer.ProducerInterceptor;
+import org.apache.kafka.clients.producer.ProducerRecord;
+import org.apache.kafka.clients.producer.RecordMetadata;
+
+import java.util.Map;
+
+/**
+ * 统计发送消息成功和发送消息失败数，
+ * 并在 producer 关闭时打印这连个计时器
+ */
+public class CountInterceptor implements ProducerInterceptor {
+ private int errorCounter = 0;
+ private int successCounter = 0;
+
+ /**
+ * 直接返回传入的参量
+ * @param producerRecord
+ * @return producerRecord
+ */
+ @Override
+ public ProducerRecord onSend(ProducerRecord producerRecord) {
+ return producerRecord;
+ }
+
+ /**
+ * 统计成功和失败的次数
+ * @param recordMetadata
+ * @param e
+ */
+ @Override
+ public void onAcknowledgement(RecordMetadata recordMetadata, Exception e) {
+ if(e == null)
+ successCounter++;
+ else
+ errorCounter++;
+ }
+
+ /**
+ * 打印结果
+ */
+ @Override
+ public void close() {
+ System.out.println("Successful sent:" + successCounter);
+ System.out.println("Failed sent:" + errorCounter);
+ }
+
+ @Override
+ public void configure(Map map) {
+
+ }
+}
+```
+
+```java
+package com.tian.kafka.interceptor;
+
+import org.apache.kafka.clients.producer.KafkaProducer;
+import org.apache.kafka.clients.producer.ProducerConfig;
+import org.apache.kafka.clients.producer.ProducerRecord;
+import org.codehaus.jackson.map.ser.std.StringSerializer;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Properties;
+
+/**
+ * 主程序
+ */
+public class InterceptorProducer {
+ public static void main(String[] args) {
+ // 配置信息
+ Properties props = new Properties();
+ props.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,"hadoop101:9092");
+ props.put(ProducerConfig.ACKS_CONFIG,"all");
+ props.put(ProducerConfig.RETRIES_CONFIG,0);
+ props.put(ProducerConfig.BATCH_SIZE_CONFIG,16384);
+ props.put(ProducerConfig.LINGER_MS_CONFIG,1);
+ props.put(ProducerConfig.BUFFER_MEMORY_CONFIG,33664432);
+ props.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG,
+ StringSerializer.class.getName());
+ props.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG,
+ StringSerializer.class.getName());
+ // 构建拦截链
+ List interceptors = new ArrayList();
+ interceptors.add("com.tian.kafka.interceptor.TimeInterceptor");
+ interceptors.add("com.tian.kafka.interceptor.CountInterceptor");
+ props.put(ProducerConfig.INTERCEPTOR_CLASSES_CONFIG, interceptors);
+ String topic = "first";
+ KafkaProducer producer = new KafkaProducer<>(props);
+ // 发送消息
+ for (int i = 0; i < 100; i++) {
+ ProducerRecord record = new ProducerRecord<>(topic, "message" + 1);
+ producer.send(record);
+ }
+ // 关闭 producer
+ producer.close();
+ }
+}
+```
+
+```bash
+# 测试
+# 在 kafka 上启动消费者，然后运行客户端 java 程序。
+kafka-console-consumer.sh --bootstrap-server hadoop102:9092 --from-beginning --topic first
+# 1501904047034,message0
+# 1501904047225,message1
+# 1501904047230,message2
+# 1501904047234,message3
+# 1501904047236,message4
+# 1501904047240,message5
+# 1501904047243,message6
+# 1501904047246,message7
+# 1501904047249,message8
+# 1501904047252,message9
+```
diff --git a/notes/MicroService/kafka/kafka-tutorial-6_spring-kafka-api.md b/notes/MicroService/kafka/kafka-tutorial-6_spring-kafka-api.md
new file mode 100644
index 00000000..8c595af4
--- /dev/null
+++ b/notes/MicroService/kafka/kafka-tutorial-6_spring-kafka-api.md
@@ -0,0 +1,282 @@
+
+
+- [深入浅出 Kafka（六）Spring Kafka API](#深入浅出-kafka六spring-kafka-api)
+ - [一、Producer](#一producer)
+ - [1. KafkaProducer](#1-kafkaproducer)
+ - [2. KafkaProducerConfig](#2-kafkaproducerconfig)
+ - [二、Consumer](#二consumer)
+ - [3. KafkaConsumer](#3-kafkaconsumer)
+ - [4. KafkaConsumerConfig](#4-kafkaconsumerconfig)
+ - [三、配置文件](#三配置文件)
+ - [四、pom 依赖](#四pom-依赖)
+ - [参考资料](#参考资料)
+
+
+
+# 深入浅出 Kafka（六）Spring Kafka API
+
+ 在上一节中学习了如何通过 Kafka API 的方式进行生产者和消费者及其配置，但是主要是通过手动编写 Java 代码的方式实现。在项目开发中，我们主要会使用到 SpringBoot 框架，这里就将带你 SpringBoot 与 Kafka 整合，通过注解和配置的方式轻松集成。
+
+ 这里将列举，最常见的生产者和消费者使用方式，更完整的 API 文档，请转向 [Overview (Spring Kafka 2.2.8.RELEASE API)](https://docs.spring.io/spring-kafka/api/) 学习。
+
+ 送上本节 DEMO 项目代码，[点击预览](https://github.com/frank-lam/open-code-lab/tree/master/springboot/springboot-kafka-sample)。
+
+
+
+## 一、Producer
+
+### 1. KafkaProducer
+
+```java
+package cn.frankfeekr.springbootkafkasample.client;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.kafka.core.KafkaTemplate;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.bind.annotation.RestController;
+
+
+@RestController
+public class KafkaProducer {
+
+ private static final Logger LOG = LoggerFactory.getLogger(KafkaProducer.class);
+
+ @Autowired
+ private KafkaTemplate kafkaTemplate;
+
+ @Value("${app.topic.foo}")
+ private String topic;
+
+
+ @GetMapping("demo")
+ public String send(@RequestParam String msg){
+// LOG.info("sending message='{}' to topic='{}'", message, topic);
+ kafkaTemplate.send(topic,"key", msg);
+ return "send success";
+ }
+}
+```
+
+### 2. KafkaProducerConfig
+
+```java
+package cn.frankfeekr.springbootkafkasample.client;
+
+import org.apache.kafka.clients.producer.ProducerConfig;
+import org.apache.kafka.common.serialization.StringSerializer;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.kafka.core.DefaultKafkaProducerFactory;
+import org.springframework.kafka.core.KafkaTemplate;
+import org.springframework.kafka.core.ProducerFactory;
+
+import java.util.HashMap;
+import java.util.Map;
+
+@Configuration
+public class KafkaSenderConfig {
+
+ @Value("${spring.kafka.bootstrap-servers}")
+ private String bootstrapServers;
+
+ @Bean
+ public Map producerConfigs() {
+ Map props = new HashMap<>();
+ props.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, bootstrapServers);
+ props.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class);
+ props.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class);
+ return props;
+ }
+
+ @Bean
+ public ProducerFactory producerFactory() {
+ return new DefaultKafkaProducerFactory<>(producerConfigs());
+ }
+
+ @Bean
+ public KafkaTemplate kafkaTemplate() {
+ return new KafkaTemplate<>(producerFactory());
+ }
+
+}
+```
+
+
+
+## 二、Consumer
+
+### 3. KafkaConsumer
+
+```java
+package cn.frankfeekr.springbootkafkasample.client;
+
+import org.apache.kafka.clients.consumer.Consumer;
+import org.apache.kafka.clients.consumer.ConsumerRecord;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.kafka.annotation.KafkaListener;
+import org.springframework.kafka.support.Acknowledgment;
+import org.springframework.stereotype.Service;
+
+@Service
+public class KafkaConsumer {
+
+ private static final Logger LOG = LoggerFactory.getLogger(KafkaConsumer.class);
+
+ @KafkaListener(topics = "${app.topic.foo}")
+ public void listen(ConsumerRecord record, Acknowledgment ack, Consumer consumer) {
+ LOG.warn("topic:{},key: {},partition:{}, value: {}, record: {}",record.topic(), record.key(),record.partition(), record.value(), record);
+ if (record.topic().equalsIgnoreCase("test")){
+ throw new RuntimeException();
+ }
+ System.out.println("提交 offset ");
+ consumer.commitAsync();
+ }
+}
+```
+
+
+
+### 4. KafkaConsumerConfig
+
+```java
+package cn.frankfeekr.springbootkafkasample.client;
+
+import org.apache.kafka.clients.consumer.ConsumerConfig;
+import org.apache.kafka.common.serialization.StringDeserializer;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.kafka.annotation.EnableKafka;
+import org.springframework.kafka.config.ConcurrentKafkaListenerContainerFactory;
+import org.springframework.kafka.config.KafkaListenerContainerFactory;
+import org.springframework.kafka.core.ConsumerFactory;
+import org.springframework.kafka.core.DefaultKafkaConsumerFactory;
+import org.springframework.kafka.listener.ConcurrentMessageListenerContainer;
+import org.springframework.kafka.listener.ContainerProperties;
+
+import java.util.HashMap;
+import java.util.Map;
+
+@EnableKafka
+@Configuration
+public class KafkaConsumerConfig {
+
+ @Value("${spring.kafka.bootstrap-servers}")
+ private String bootstrapServers;
+
+ @Bean
+ public Map consumerConfigs() {
+ Map props = new HashMap<>();
+ props.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, bootstrapServers);
+ props.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class);
+ props.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class);
+ props.put(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG, false);
+ props.put(ConsumerConfig.GROUP_ID_CONFIG, "foo");
+ props.put(ConsumerConfig.AUTO_OFFSET_RESET_CONFIG, "earliest");
+
+ return props;
+ }
+
+
+ @Bean
+ public ConsumerFactory consumerFactory() {
+ return new DefaultKafkaConsumerFactory<>(consumerConfigs());
+ }
+
+ @Bean
+ public KafkaListenerContainerFactory> kafkaListenerContainerFactory() {
+ ConcurrentKafkaListenerContainerFactory factory = new ConcurrentKafkaListenerContainerFactory<>();
+ factory.setConcurrency(3);
+ factory.getContainerProperties().setAckMode(ContainerProperties.AckMode.MANUAL);
+ factory.setConsumerFactory(consumerFactory());
+ return factory;
+ }
+
+}
+```
+
+
+
+## 三、配置文件
+
+```yaml
+server:
+ port: 9090
+spring:
+ kafka:
+ bootstrap-servers: 127.0.0.1:9092
+app:
+ topic:
+ foo: frankfeekr
+```
+
+
+
+## 四、pom 依赖
+
+```xml
+
+
+ 4.0.0
+
+ org.springframework.boot
+ spring-boot-starter-parent
+ 2.1.7.RELEASE
+
+ cn.frankfeekr
+ springboot-kafka-sample
+ 0.0.1-SNAPSHOT
+ springboot-kafka-sample
+ Demo project for Spring Boot
+
+
+ 1.8
+
+
+
+
+ org.springframework.boot
+ spring-boot-starter-web
+
+
+
+ org.springframework.boot
+ spring-boot-starter-test
+ test
+
+
+
+ org.springframework.kafka
+ spring-kafka
+ 2.2.7.RELEASE
+
+
+
+
+
+
+ org.springframework.boot
+ spring-boot-maven-plugin
+
+
+
+
+
+```
+
+
+
+## 参考资料
+
+- [Spring for Apache Kafka](https://docs.spring.io/spring-kafka/reference/html)
+- [Overview (Spring Kafka 2.2.8.RELEASE API)](https://docs.spring.io/spring-kafka/docs/2.2.8.RELEASE/api/)
+- [SpringBoot整合Kafka实现发布订阅 - 简书](https://www.jianshu.com/p/7a284bf4efc9)
+- [SpringBoot 集成 Spring For Kafka 操作 Kafka 详解 · 小豆丁个人博客](http://www.mydlq.club/article/34/)
diff --git "a/notes/MicroService/kafka/kafka-tutorial-7_\347\233\221\346\216\247.md" "b/notes/MicroService/kafka/kafka-tutorial-7_\347\233\221\346\216\247.md"
new file mode 100644
index 00000000..be058c22
--- /dev/null
+++ "b/notes/MicroService/kafka/kafka-tutorial-7_\347\233\221\346\216\247.md"
@@ -0,0 +1,4 @@
+# 深入浅出 Kafka（七）监控
+
+Kafka Monitor，Kafka Manager
+
diff --git a/notes/MySQL.md b/notes/MySQL.md
index 8686af45..f9396184 100644
--- a/notes/MySQL.md
+++ b/notes/MySQL.md
@@ -41,7 +41,7 @@
- [2. 浮点数](#2-浮点数)
- [3. 字符串](#3-字符串)
- [4. 时间和日期](#4-时间和日期)
- - [DATATIME](#datatime)
+ - [DATETIME](#datetime)
- [TIMESTAMP](#timestamp)
- [8. 索引](#8-索引)
- [1. 索引使用的场景](#1-索引使用的场景)
@@ -156,7 +156,7 @@
### AUTOCOMMIT
-MySQL 默认采用自动提交模式。也就是说，如果不显式使用 `START TRANSACTION` 语句来开始一个事务，那么每个查询都会被当做一个事务自动提交
+MySQL 默认 自动提交模式。也就是说，如果不显式使用 `START TRANSACTION` 语句来开始一个事务，那么每个查询都会被当做一个事务自动提交
@@ -734,9 +734,9 @@ VARCHAR 会保留字符串末尾的空格，而 CHAR 会删除。
### 4. 时间和日期
-MySQL 提供了两种相似的日期时间类型：DATATIME 和 TIMESTAMP。
+MySQL 提供了两种相似的日期时间类型：DATETIME 和 TIMESTAMP。
-#### DATATIME
+#### DATETIME
能够保存从 1001 年到 9999 年的日期和时间，精度为秒，使用 8 字节的存储空间。
diff --git a/notes/Nginx.md b/notes/Nginx.md
new file mode 100644
index 00000000..daa70e09
--- /dev/null
+++ b/notes/Nginx.md
@@ -0,0 +1,22 @@
+# Nginx
+
+###
+
+
+
+
+
+## 负载均衡
+
+
+
+
+
+## 反向代理
+
+
+
+## 配置文件
+
+
+
diff --git a/notes/PostgreSQL.md b/notes/PostgreSQL.md
new file mode 100644
index 00000000..f7223f31
--- /dev/null
+++ b/notes/PostgreSQL.md
@@ -0,0 +1,598 @@
+
+
+- [PostgreSQL](#postgresql)
+ - [1. 什么是PostgreSql？](#1-什么是postgresql)
+ - [知识点](#知识点)
+ - [数据库排名](#数据库排名)
+ - [官方网站](#官方网站)
+ - [技术准备](#技术准备)
+ - [使用环境](#使用环境)
+ - [安装](#安装)
+ - [2. 初来乍到数据库](#2-初来乍到数据库)
+ - [知识点](#知识点-1)
+ - [实战演习](#实战演习)
+ - [3. 操作数据表](#3-操作数据表)
+ - [知识点](#知识点-2)
+ - [实战演习](#实战演习-1)
+ - [4. 字段类型](#4-字段类型)
+ - [PostgreSql的基础数据类型](#postgresql的基础数据类型)
+ - [5. 添加表约束](#5-添加表约束)
+ - [知识点](#知识点-3)
+ - [实战演习](#实战演习-2)
+ - [db.sql](#dbsql)
+ - [6. INSERT语句](#6-insert语句)
+ - [知识点](#知识点-4)
+ - [实战演习](#实战演习-3)
+ - [SQL部分](#sql部分)
+ - [7. SELECT语句](#7-select语句)
+ - [知识点](#知识点-5)
+ - [实战演习](#实战演习-4)
+ - [init.sql](#initsql)
+ - [SQL实战](#sql实战)
+ - [8. WHERE语句](#8-where语句)
+ - [知识点](#知识点-6)
+ - [实战演习](#实战演习-5)
+ - [9. 数据抽出选项](#9-数据抽出选项)
+ - [知识点](#知识点-7)
+ - [实战演习](#实战演习-6)
+ - [10. 统计抽出数据](#10-统计抽出数据)
+ - [知识点](#知识点-8)
+ - [实战演习](#实战演习-7)
+ - [11. 方便的函数](#11-方便的函数)
+ - [知识点](#知识点-9)
+ - [实战演习](#实战演习-8)
+ - [12. 更新和删除](#12-更新和删除)
+ - [知识点](#知识点-10)
+ - [实战演习](#实战演习-9)
+ - [13. 变更表结构](#13-变更表结构)
+ - [知识点](#知识点-11)
+ - [实战演习](#实战演习-10)
+ - [14. 操作多个表](#14-操作多个表)
+ - [知识点](#知识点-12)
+ - [实战演习](#实战演习-11)
+ - [renew.sql](#renewsql)
+ - [SQL实行](#sql实行)
+ - [15. 使用视图](#15-使用视图)
+ - [视图概念](#视图概念)
+ - [简单解释](#简单解释)
+ - [知识点](#知识点-13)
+ - [实战演习](#实战演习-12)
+ - [实战建议](#实战建议)
+ - [16. 使用事务](#16-使用事务)
+ - [知识点](#知识点-14)
+ - [实战演习](#实战演习-13)
+ - [参考资料](#参考资料)
+
+
+
+# PostgreSQL
+
+> 本节参考：[PostgreSql入门](http://komavideo.com/postgresql/index.html)，特别感谢小马视频的学习课程，深入浅出了 PostgreSQL。在此基础上针对自己的学习过程，修改了部分内容。
+
+
+
+本文为 PostgreSQL 入门指南，通过极简的语言，带你走进 PostgreSQL 世界的大门。
+
+## 1. 什么是PostgreSql？
+
+PostgreSQL 是一个自由的对象-关系数据库服务器(数据库管理系统)，是从伯克利写的 POSTGRES 软件包发展而来的。经过十几年的发展， PostgreSQL 是世界上可以获得的最先进的开放源码的数据库系统， 它提供了多版本并发控制，支持几乎所有SQL语句（包括子查询，事务和用户定义类型和函数），并且可以获得非常广阔范围的（开发）语言绑定 （包括C,C++,Java,perl,python,php,nodejs,ruby）。
+
+### 知识点
+
+* 面向关系的数据库
+ + Oracle
+ + MySql
+ + SQLServer
+ + PostgreSql
+* NoSql
+ + MongoDB
+ + Redis
+
+### 数据库排名
+
+https://db-engines.com/en/ranking
+
+### 官方网站
+
+https://www.postgresql.org/
+
+### 技术准备
+
+* SQL语言基础
+
+### 使用环境
+
+* Ubuntu Server 16 LTS
+* PostgreSql 9.5.x
+
+### 安装
+
+~~~bash
+$ sudo apt-get install postgresql
+$ psql --version
+~~~
+
+
+
+## 2. 初来乍到数据库
+
+### 知识点
+
+* psql的基础
+* 数据库简单操作
+* 写个SQL
+
+### 实战演习
+
+~~~bash
+$ sudo su postgres
+$ psql --version
+$ psql -l
+$ createdb komablog
+$ psql -l
+$ psql komablog
+> help
+> \h
+> \?
+> \l
+> \q
+$ psql komablog
+> select now();
+> select version();
+> \q
+$ dropdb komablog
+$ psql -l
+~~~
+
+
+
+## 3. 操作数据表
+
+### 知识点
+
+* create table
+* drop table
+* psql使用
+
+### 实战演习
+
+~~~bash
+$ sudo su postgres
+$ createdb komablog
+$ psql -l
+$ psql komablog
+> create table posts (title varchar(255), content text);
+> \dt
+> \d posts
+> alter table posts rename to komaposts;
+> \dt
+> drop table komaposts;
+> \dt
+> \q
+$ nano db.sql
+...
+create table posts (title varchar(255), content text);
+...
+$ psql komablog
+> \i db.sql
+> \dt
+~~~
+
+
+
+## 4. 字段类型
+
+ ### 知识点
+
+* PostgreSql的基础数据类型
+
+### PostgreSql的基础数据类型
+
+* 数值型：
+ + integer(int)
+ + real
+ + serial
+* 文字型：
+ + char
+ + varchar
+ + text
+* 布尔型：
+ + boolean
+* 日期型：
+ + date
+ + time
+ + timestamp
+* 特色类型：
+ + Array
+ + 网络地址型(inet)
+ + JSON型
+ + XML型
+
+参考网站：
+
+https://www.postgresql.org/docs/9.5/static/datatype.html
+
+
+
+## 5. 添加表约束
+
+### 知识点
+
+- 表子段的约束条件
+
+### 实战演习
+
+#### db.sql
+
+```sql
+create table posts (
+ id serial primary key,
+ title varchar(255) not null,
+ content text check(length(content) > 8),
+ is_draft boolean default TRUE,
+ is_del boolean default FALSE,
+ created_date timestamp default 'now'
+);
+
+-- 说明
+/*
+约束条件：
+
+not null:不能为空
+unique:在所有数据中值必须唯一
+check:字段设置条件
+default:字段默认值
+primary key(not null, unique):主键，不能为空，且不能重复
+*/
+```
+
+
+
+## 6. INSERT语句
+
+### 知识点
+
+- insert into [tablename] (field, ...) values (value, ...)
+
+### 实战演习
+
+```sql
+$ psql komablog
+> \dt
+> \d posts
+```
+
+#### SQL部分
+
+```sql
+> insert into posts (title, content) values ('', '');
+> insert into posts (title, content) values (NULL, '');
+> insert into posts (title, content) values ('title1', 'content11');
+> select * from posts;
+> insert into posts (title, content) values ('title2', 'content22');
+> insert into posts (title, content) values ('title3', 'content33');
+> select * from posts;
+```
+
+
+
+## 7. SELECT语句
+
+### 知识点
+
+- select 基本使用
+
+### 实战演习
+
+#### init.sql
+
+```sql
+create table users (
+ id serial primary key,
+ player varchar(255) not null,
+ score real,
+ team varchar(255)
+);
+
+insert into users (player, score, team) values
+('库里', 28.3, '勇士'),
+('哈登', 30.2, '火箭'),
+('阿杜', 25.6, '勇士'),
+('阿詹', 27.8, '骑士'),
+('神龟', 31.3, '雷霆'),
+('白边', 19.8, '热火');
+```
+
+#### SQL实战
+
+```bash
+$ psql komablog
+> \i init.sql
+> \dt
+> \d users
+> select * from users;
+> \x
+> select * from users;
+> \x
+> select * from users;
+> select player, score from users;
+```
+
+
+
+## 8. WHERE语句
+
+### 知识点
+
+- where语句的使用
+
+使用where语句来设定select,update,delete语句数据抽出的条件。
+
+### 实战演习
+
+```sql
+> select * from users;
+> select * from users where score > 20;
+> select * from users where score < 30;
+> select * from users where score > 20 and score < 30;
+> select * from users where team = '勇士';
+> select * from users where team != '勇士';
+> select * from users where player like '阿%';
+> select * from users where player like '阿_';
+```
+
+
+
+## 9. 数据抽出选项
+
+### 知识点
+
+select语句在抽出数据时，可以对语句设置更多的选项，已得到想要的数据。
+
+- order by
+- limit
+- offset
+
+### 实战演习
+
+```sql
+> select * from users order by score asc;
+> select * from users order by score desc;
+> select * from users order by team;
+> select * from users order by team, score;
+> select * from users order by team, score desc;
+> select * from users order by team desc, score desc;
+> select * from users order by score desc limit 3;
+> select * from users order by score desc limit 3 offset 1;
+> select * from users order by score desc limit 3 offset 2;
+> select * from users order by score desc limit 3 offset 3;
+```
+
+
+
+## 10. 统计抽出数据
+
+### 知识点
+
+- distinct
+- sum
+- max/min
+- group by/having
+
+### 实战演习
+
+```sql
+> select distinct team from users;
+> select sum(score) from users;
+> select max(score) from users;
+> select min(score) from users;
+> select * from users where score = (select max(score) from users);
+> select * from users where score = (select min(score) from users);
+> select team, max(score) from users group by team;
+> select team, max(score) from users group by team having max(score) >= 25;
+> select team, max(score) from users group by team having max(score) >= 25 order by max(score);
+```
+
+
+
+## 11. 方便的函数
+
+### 知识点
+
+- length
+- concat
+- alias
+- substring
+- random
+
+参考网站：
+
+https://www.postgresql.org/docs/9.5/static/functions.html
+
+### 实战演习
+
+```sql
+> select player, length(player) from users;
+> select player, concat(player, '/', team) from users;
+> select player, concat(player, '/', team) as "球员信息" from users;
+> select substring(team, 1, 1) as "球队首文字" from users;
+> select concat('我', substring(team, 1, 1)) as "球队首文字" from users;
+> select random();
+> select * from users order by random();
+> select * from users order by random() limit 1;
+```
+
+
+
+## 12. 更新和删除
+
+### 知识点
+
+- update [table] set [field=newvalue,...] where ...
+- delete from [table] where ...
+
+### 实战演习
+
+```sql
+> update users set score = 29.1 where player = '阿詹';
+> update users set score = score + 1 where team = '勇士';
+> update users set score = score + 100 where team IN ('勇士', '骑士');
+> delete from users where score > 30;
+```
+
+
+
+## 13. 变更表结构
+
+### 知识点
+
+- alter table [tablename] ...
+- create index ...
+- drop index ...
+
+### 实战演习
+
+```sql
+> \d users;
+> alter table users add fullname varchar(255);
+> \d users;
+> alter table users drop fullname;
+> \d users;
+> alter table users rename player to nba_player;
+> \d users;
+> alter table users alter nba_player type varchar(100);
+> \d users;
+> create index nba_player_index on users(nba_player);
+> \d users;
+> drop index nba_player_index;
+> \d users;
+```
+
+
+
+## 14. 操作多个表
+
+### 知识点
+
+- 表结合查询的基础知识
+
+### 实战演习
+
+#### renew.sql
+
+```sql
+create table users (
+ id serial primary key,
+ player varchar(255) not null,
+ score real,
+ team varchar(255)
+);
+insert into users (player, score, team) values
+('库里', 28.3, '勇士'),
+('哈登', 30.2, '火箭'),
+('阿杜', 25.6, '勇士'),
+('阿詹', 27.8, '骑士'),
+('神龟', 31.3, '雷霆'),
+('白边', 19.8, '热火');
+
+create table twitters (
+ id serial primary key,
+ user_id integer,
+ content varchar(255) not null
+);
+insert into twitters (user_id, content) values
+(1, '今天又是大胜,克莱打的真好!'),
+(2, '今晚我得了60分,哈哈!'),
+(3, '获胜咱不怕,缺谁谁尴尬.'),
+(4, '明年我也可能转会西部'),
+(5, '我都双20+了，怎么球队就是不胜呢?'),
+(1, '明年听说有条大鱼要来,谁呀?');
+```
+
+#### SQL实行
+
+```sql
+$ dropdb komablog;
+$ createdb komablog;
+$ psql komablog;
+> \i renew.sql
+> select * from users;
+> select * from twitters;
+> select users.player, twitters.content from users, twitters where users.id = twitters.user_id;
+> select u.player, t.content from users as u, twitters as t where u.id = t.user_id;
+> select u.player, t.content from users as u, twitters as t where u.id = t.user_id and u.id = 1;
+```
+
+
+
+## 15. 使用视图
+
+### 视图概念
+
+视图（View）是从一个或多个表导出的对象。视图与表不同，视图是一个虚表，即视图所对应的数据不进行实际存储，数据库中只存储视图的定义，在对视图的数据进行操作时，系统根据视图的定义去操作与视图相关联的基本表。
+
+### 简单解释
+
+视图就是一个SELECT语句，把业务系统中常用的SELECT语句简化成一个类似于表的对象，便于简单读取和开发。
+
+### 知识点
+
+- 使用数据库视图(view)
+ - create view ...
+ - drop view ...
+
+### 实战演习
+
+```sql
+> select u.player, t.content from users as u, twitters as t where u.id = t.user_id and u.id = 1;
+> create view curry_twitters as select u.player, t.content from users as u, twitters as t where u.id = t.user_id and u.id = 1;
+> \dv
+> \d curry_twitters
+> select * from curry_twitters;
+> drop view curry_twitters;
+> \dv
+```
+
+### 实战建议
+
+在自己项目中，为了提高数据查询速度，可在表中加入索引index。同时对于经常需要查询的语句，可以提前建立视图view，方便于编码和管理。
+
+
+
+## 16. 使用事务
+
+数据库事务(Database Transaction) ，是指作为单个逻辑工作单元执行的一系列操作，要么完全地执行，要么完全地不执行。 事务处理可以确保除非事务性单元内的所有操作都成功完成，否则不会永久更新面向数据的资源。通过将一组相关操作组合为一个要么全部成功要么全部失败的单元，可以简化错误恢复并使应用程序更加可靠。一个逻辑工作单元要成为事务，必须满足所谓的ACID（原子性、一致性、隔离性和持久性）属性。事务是数据库运行中的逻辑工作单位，由DBMS中的事务管理子系统负责事务的处理。
+
+### 知识点
+
+- PostgreSql数据库事务使用
+ - begin
+ - commit
+ - rollback
+
+### 实战演习
+
+```sql
+> select * from users;
+> begin;
+> update users set score = 50 where player = '库里';
+> update users set score = 60 where player = '哈登';
+> commit;
+> select * from users;
+> begin;
+> update users set score = 0 where player = '库里';
+> update users set score = 0 where player = '哈登';
+> rollback;
+> select * from users;
+```
+
+
+
+
+
+## 参考资料
+
+- [【小马技术】PostgreSql 关系型数据库入门_哔哩哔哩 (゜-゜)つロ 干杯~-bilibili](https://www.bilibili.com/video/av24590479?from=search&seid=9519508000355338670)
+
+
+
diff --git a/notes/Python/.DS_Store b/notes/Python/.DS_Store
deleted file mode 100644
index 04007c79..00000000
Binary files a/notes/Python/.DS_Store and /dev/null differ
diff --git "a/notes/Python/Python\345\256\211\350\243\205.md" "b/notes/Python/Python\345\256\211\350\243\205.md"
index 8f344f09..36a6c156 100755
--- "a/notes/Python/Python\345\256\211\350\243\205.md"
+++ "b/notes/Python/Python\345\256\211\350\243\205.md"
@@ -1,8 +1,8 @@
-#### Windows安装
+#### Windows 安装
---
-> [Python官网](https://www.python.org/)
+> [Python 官网](https://www.python.org/)
- 打开官网下载安装包
@@ -20,22 +20,21 @@
X86-64 --> 64位系统
```
-
- 安装
- > # 勾选 Add Python 3.6 to PATH ---> 自动配置环境变量
+ > # 勾选 Add Python 3.6 to PATH ---> 自动配置环境变量
- - Install Now ` 默认设置`
+ - Install Now `默认设置`
- - Customize installation ` 自定义安装选项`
+ - Customize installation `自定义安装选项`
- 
+ 
- > 勾选 pip
+ > 勾选 pip
>
> 其他可根据情况勾选
@@ -58,7 +57,7 @@
```python
#命令行界面输入
pip -V
- python # 进入后 exit()可退出
+ python # 进入后 exit()可退出
# 输出如图示
```
@@ -66,14 +65,15 @@
- 安装结束
-#### Liunx安装
+#### Liunx 安装
+
---
##### 前言
-> Liunx发行版自带Python2版本
+> Liunx 发行版自带 Python2 版本
>
-> 命令行 python2 | python 即可进入交互式界面
+> 命令行 python2 | python 即可进入交互式界面
##### 下载安装包
@@ -90,7 +90,7 @@
# 其他版本可在官网下载，以3.65为例
```
- > [Python官网](https://www.python.org/ftp/python)
+ > [Python 官网](https://www.python.org/ftp/python)
@@ -106,7 +106,7 @@
```python
# 进入解压后文件夹
- cd Python-3.6.5
+ cd Python-3.6.5
# 创建安装目录
mkdir /usr/local/python3
# 指明安装路径
@@ -121,29 +121,29 @@
```python
#为python3创建软连接
- sudo ln -s /usr/local/python3/bin/python3 /usr/bin/python3
+ sudo ln -s /usr/local/python3/bin/python3 /usr/bin/python3
#为pip3创建软连接
- sudo ln -s /usr/local/python3/bin/pip3 /usr/bin/pip3
+ sudo ln -s /usr/local/python3/bin/pip3 /usr/bin/pip3
```
##### 验证
- ```python
+```python
# shell界面 输入
python3
-# shell输入
+# shell输入
pip3 -V # V大写
- ```
+```
-
+
-
+
-##### Python2
+##### Python2
-- 前面提到Liunx自带Python2版本，但是没有pip包管理工具
+- 前面提到 Liunx 自带 Python2 版本，但是没有 pip 包管理工具
-- 安装Python2 pip包管理工具
+- 安装 Python2 pip 包管理工具
```python
# 安装依赖
@@ -158,23 +158,23 @@ pip3 -V # V大写
---
-#### Mac下安装Python
+#### Mac 下安装 Python
-> [Python官网](https://www.python.org)
+> [Python 官网](https://www.python.org)
##### 源码安装
-> Mac也是类unix系统,也可参考Liunx下安装Python方式一致
+> Mac 也是类 unix 系统,也可参考 Liunx 下安装 Python 方式一致
##### 安装包安装
-- 下载Mac安装包
+- 下载 Mac 安装包
- ------
+ ***
- > 根据系统位数,下载相应版本pkg安装即可
+ > 根据系统位数,下载相应版本 pkg 安装即可
@@ -190,4 +190,4 @@ pip -V #v 大写
python3
```
-
\ No newline at end of file
+
diff --git a/notes/Python/assets/Customize installation.png b/notes/Python/assets/Customize_installation.png
old mode 100755
new mode 100644
similarity index 100%
rename from notes/Python/assets/Customize installation.png
rename to notes/Python/assets/Customize_installation.png
diff --git "a/notes/Python/assets/liun_python \351\252\214\350\257\201.png" "b/notes/Python/assets/linux_python_\351\252\214\350\257\201.png"
old mode 100755
new mode 100644
similarity index 100%
rename from "notes/Python/assets/liun_python \351\252\214\350\257\201.png"
rename to "notes/Python/assets/linux_python_\351\252\214\350\257\201.png"
diff --git "a/notes/Python/assets/liunx_pip \351\252\214\350\257\201.png" "b/notes/Python/assets/liunx_pip_\351\252\214\350\257\201.png"
old mode 100755
new mode 100644
similarity index 100%
rename from "notes/Python/assets/liunx_pip \351\252\214\350\257\201.png"
rename to "notes/Python/assets/liunx_pip_\351\252\214\350\257\201.png"
diff --git "a/notes/Python/\346\265\201\347\225\205\347\232\204Python/README.md" "b/notes/Python/\346\265\201\347\225\205\347\232\204Python/README.md"
new file mode 100644
index 00000000..17b6150c
--- /dev/null
+++ "b/notes/Python/\346\265\201\347\225\205\347\232\204Python/README.md"
@@ -0,0 +1,39 @@
+# python 学习笔记
+
+
+
+##
+2600343820760
+
+```
+
+
+
+## NotImplementedError
+
+Python编程中raise可以实现报出错误的功能，而报错的条件可以由程序员自己去定制。
+
+在面向对象编程中，可以先预留一个方法接口不实现，在其子类中实现。
+
+如果要求其子类一定要实现，不实现的时候会导致问题，那么采用raise的方式就很好。
+
+而此时产生的问题分类是NotImplementedError
+
+
+例子：
+```python
+class ClassDemo(object):
+ def run(self):
+ raise NotImplementedError
+
+
+class ChildClass(ClassDemo):
+ def run(self):
+ print("Hello world")
+
+
+ChildClass().run()
+```
+
+ type(NotImplementedError)
+
+issubclass(NotImplementedError,Exception)
+True
+```
+
+
+
+NotImplemented 是 Python 内建命名空间内仅有的 6 个常量（Python 中没有真正的常量）之一，
+其它几个分别是 False、True、None、Ellipsis 和` __debug__`。
+
+和 Ellipsis 一样，NotImplemented 也可以被重新赋值：
+NotImplemented = "don't do this"
+
+两者是什么关系呢？答案是**“没啥关系”**。
+
+Python 中 NotImplemented 广泛应用于二元魔术方法中，比如 `__eq__()、__lt__() `等等，表示该类型无法和其它类型进行对应的二元运算
+
+
+例子：
+```python
+class A(object):
+ def __init__(self, value):
+ self.value = value
+
+ def __eq__(self, other):
+ if isinstance(other, A):
+ print('Comparing an A with an A')
+ return other.value == self.value
+ if isinstance(other, B):
+ print('Comparing an A with a B')
+ return other.value == self.value
+ print('Could not compare A with the other class')
+ return NotImplemented
+
+
+class B(object):
+ def __init__(self, value):
+ self.value = value
+
+ def __eq__(self, other):
+ # raise NotImplementedError
+ if isinstance(other, B):
+ print('Comparing a B with another B')
+ return other.value == self.value
+ print('Could not compare B with the other class')
+ return NotImplemented
+
+
+a, b = A(1), B(1)
+aa, bb = A(1), B(1)
+a == aa # True
+b == bb # True
+a == b # True
+b == a # True
+
+```
+
+运行结果：
+```
+Comparing an A with an A
+Comparing a B with another B
+Comparing an A with a B
+```
+
+
+
+说明 == 运算符执行时会先寻找 B 的 `__eq__() `方法，
+遇到 NotImplemented 返回值则反过来去寻找 A 的 `__eq__()` 方法。
+
+
+什么时候该使用 NotImplementedError？
+
+>NotImplementedError 是 RuntimeError 的子类：
+>issubclass(NotImplementedError, RuntimeError) # True
+
+>官网 的建议是当你需要一个方法必须覆盖才能使用时，其效果类似于 Java 中的接口，用于定义一个未实现的抽象方法。
\ No newline at end of file
diff --git "a/notes/Python/\346\265\201\347\225\205\347\232\204Python/python\345\255\227\350\212\202\347\240\201-\350\241\245\345\205\205\345\206\205\345\256\271.md" "b/notes/Python/\346\265\201\347\225\205\347\232\204Python/python\345\255\227\350\212\202\347\240\201-\350\241\245\345\205\205\345\206\205\345\256\271.md"
new file mode 100644
index 00000000..f9d7e513
--- /dev/null
+++ "b/notes/Python/\346\265\201\347\225\205\347\232\204Python/python\345\255\227\350\212\202\347\240\201-\350\241\245\345\205\205\345\206\205\345\256\271.md"
@@ -0,0 +1,186 @@
+# 第22章 python字节码-补充内容
+
+
+
+- [第22章 python字节码-补充内容](#%e7%ac%ac22%e7%ab%a0-python%e5%ad%97%e8%8a%82%e7%a0%81-%e8%a1%a5%e5%85%85%e5%86%85%e5%ae%b9)
+ - [python编译过程](#python%e7%bc%96%e8%af%91%e8%bf%87%e7%a8%8b)
+ - [py文件](#py%e6%96%87%e4%bb%b6)
+ - [__pycache__](#pycache)
+ - [pyc文件](#pyc%e6%96%87%e4%bb%b6)
+ - [pyo文件](#pyo%e6%96%87%e4%bb%b6)
+ - [python程序执行原理](#python%e7%a8%8b%e5%ba%8f%e6%89%a7%e8%a1%8c%e5%8e%9f%e7%90%86)
+
+
+
+
+
+## python编译过程
+
+
+在日常生活中，Python代码一般是不编译的，几个py文件复制来就能用。再加上脚本语言的名头，有些不太了解Python的朋友就以为Python没有编译这个过程。
+
+其实，虽然Python是脚本语言，但它与Java和C#一样，**`只能执行字节码`**。
+
+只是Python将编译过程隐藏起来，不大明显而已。
+
+
+这一章就详细记述一下Python的编译过程以及一些技巧。
+
+`这里使用的python版本是3.6.6`
+
+
+### py文件
+
+**py文件 就是python代码文件**
+
+这里准备两个py文件为下面分析使用
+
+mymodule.py
+```python
+class MyModule(object):
+ def say(self, name):
+ print("Say...", name)
+```
+
+demo.py
+```python
+from mymodule import MyModule
+
+test = MyModule()
+
+test.say("Hello")
+```
+
+, 'max_len': 'int>0', 'return': }
+
+```
+
+## 冻结参数的函数
+最后介绍一个可以冻结参数的功能。**Functions.partial.**
+
+在某些场景下，我们期望可以冻结一个参数，并将这个参数作用于其他参数。
+
+```python
+from functools import partial
+from operator import mul
+
+triple = partial(mul, 3) # 将第一个参数固定为3
+
+print(triple(7)) # 7*3=21
+
+print(list(map(triple, range(1, 10)))) # 1,10分别和3相乘
+
+```
\ No newline at end of file
diff --git "a/notes/Python/\346\265\201\347\225\205\347\232\204Python/\345\207\275\346\225\260\350\243\205\351\245\260\345\231\250\345\222\214\351\227\255\345\214\205.md" "b/notes/Python/\346\265\201\347\225\205\347\232\204Python/\345\207\275\346\225\260\350\243\205\351\245\260\345\231\250\345\222\214\351\227\255\345\214\205.md"
new file mode 100644
index 00000000..3e81e32d
--- /dev/null
+++ "b/notes/Python/\346\265\201\347\225\205\347\232\204Python/\345\207\275\346\225\260\350\243\205\351\245\260\345\231\250\345\222\214\351\227\255\345\214\205.md"
@@ -0,0 +1,1085 @@
+# 第7章 函数装饰器和闭包
+
+
+
+- [第7章 函数装饰器和闭包](#第7章-函数装饰器和闭包)
+ - [装饰器](#装饰器)
+ - [基本概念](#基本概念)
+ - [优点](#优点)
+ - [使用](#使用)
+ - [装饰器分类](#装饰器分类)
+ - [无参数装饰器 – 包装无参数函数](#无参数装饰器--包装无参数函数)
+ - [无参数装饰器 – 包装带参数函数](#无参数装饰器--包装带参数函数)
+ - [带参数装饰器 – 包装无参数函数](#带参数装饰器--包装无参数函数)
+ - [带参数装饰器 – 包装带参数函数](#带参数装饰器--包装带参数函数)
+ - [装饰器总结](#装饰器总结)
+ - [几个内置的装饰器](#几个内置的装饰器)
+ - [`@staticmethod`](#staticmethod)
+ - [`@classmethod`](#classmethod)
+ - [普通方法、类方法和静态方法的比较](#普通方法类方法和静态方法的比较)
+ - [`@property`](#property)
+ - [变量作用域](#变量作用域)
+ - [Local作用域](#local作用域)
+ - [Enclosing作用域](#enclosing作用域)
+ - [关键字nolocal](#关键字nolocal)
+ - [Global作用域](#global作用域)
+ - [build-in作用域](#build-in作用域)
+ - [python命名空间规则](#python命名空间规则)
+ - [可变数据类型和不可变数据类型](#可变数据类型和不可变数据类型)
+ - [可变数据类型：列表list和字典dict](#可变数据类型列表list和字典dict)
+ - [不可变数据类型：数值型、字符串型string和元组tuple](#不可变数据类型数值型字符串型string和元组tuple)
+ - [字符串不可变的原因](#字符串不可变的原因)
+ - [闭包](#闭包)
+ - [什么是闭包](#什么是闭包)
+ - [为什么要使用闭包](#为什么要使用闭包)
+ - [怎么使用闭包](#怎么使用闭包)
+
+
+## 装饰器
+
+### 基本概念
+装饰器是一个很著名的设计模式，经常被用于有切面需求的场景，较为经典的有插入日志、性能测试、事务处理, Web权限校验, Cache等。
+
+很有名的例子，就是咖啡，加糖的咖啡，加牛奶的咖啡。 本质上，还是咖啡，只是在原有的东西上，做了“装饰”，使之附加一些功能或特性。
+
+例如记录日志，需要对某些函数进行记录
+
+笨的办法，每个函数加入代码，如果代码变了，就悲催了。
+
+装饰器的办法，定义一个专门日志记录的装饰器，对需要的函数进行装饰
+
+### 优点
+抽离出大量函数中与函数功能本身无关的雷同代码并继续重用
+
+即，可以将函数“修饰”为完全不同的行为，可以有效的将业务逻辑正交分解，如用于将权限和身份验证从业务中独立出来
+
+概括的讲，**`装饰器的作用就是为已经存在的对象添加额外的功能`**
+
+### 使用
+在Python中，装饰器实现是十分方便的
+原因是：函数可以被扔来扔去。
+
+函数作为一个对象：
+
+A.可以被赋值给其他变量，可以作为返回值
+
+B.可以被定义在另外一个函数内
+
+def:
+装饰器是一个函数,一个用来包装函数的函数，装饰器在函数申明完成的时候被调用，调用之后返回一个修改之后的函数对象，将其重新赋值原来的标识符，并永久丧失对原始函数对象的访问(申明的函数被换成一个被装饰器装饰过后的函数)
+
+当我们对某个方法应用了装饰方法后， 其实就改变了被装饰函数名称所引用的函数代码块入口点，使其重新指向了由装饰方法所返回的函数入口点。
+
+由此我们可以用decorator改变某个原有函数的功能，添加各种操作，或者完全改变原有实现。
+
+### 装饰器分类
+装饰器分为无参数decorator，有参数decorator
+
+>* 无参数decorator 生成一个新的装饰器函数
+
+>* 有参decorator 有参装饰，装饰函数先处理参数，再生成一个新的装饰器函数，然后对函数进行装饰
+
+**`装饰器有参/无参，函数有参/无参，组合共4种`**
+
+#### 无参数装饰器 – 包装无参数函数
+
+```python
+def decorator(func):
+ print("hello")
+ return func
+
+@decorator
+def foo():
+ print("this is foo")
+ return "111"
+
+print(foo())
+
+# 等价于
+# foo = decorator(foo)
+# foo()
+```
+
+
+
+#### 无参数装饰器 – 包装带参数函数
+
+```python
+def decorator_func_args(func):
+ def inner(*args, **kwargs): # 处理传入函数的参数
+ print("begin")
+ ret = func(*args, **kwargs) # 函数调用
+ print("end")
+ return ret
+ return inner
+
+@decorator_func_args
+def foo2(a, b=2):
+ print(a, b)
+ return "111"
+
+print(foo2(1))
+```
+
+#### 带参数装饰器 – 包装无参数函数
+
+```python
+def decorator_with_params(arg_of_decorator): # 这里是装饰器的参数
+ print(arg_of_decorator)
+ # 最终被返回的函数
+ def newDecorator(func):
+ print(func)
+ return func
+ return newDecorator
+
+@decorator_with_params("deco_args")
+def foo3():
+ print("Hello")
+ return "111"
+
+print(foo3())
+
+```
+
+#### 带参数装饰器 – 包装带参数函数
+```python
+def decorator_whith_params_and_func_args(arg_of_decorator):
+ def handle_func(func):
+ def handle_args(*args, **kwargs):
+ print("begin")
+ func(*args, **kwargs)
+ print("end")
+ print(arg_of_decorator, func, args, kwargs)
+ return func
+ return handle_args
+ return handle_func
+
+@decorator_whith_params_and_func_args("123")
+def foo4(a, b=2):
+ print("Content")
+ return "111"
+
+print(foo4(1, b=3))
+
+```
+
+### 装饰器总结
+1.装饰器是用来装饰函数
+
+2.返回的是一个函数对象
+
+3.被修饰函数标识符 指向返回的函数对象
+
+4.语法糖 @deco
+
+### 几个内置的装饰器
+#### `@staticmethod`
+staticmethod，静态方法在调用时，对类及实例一无所知
+
+仅仅是获取传递过来的参数，没有隐含的第一个参数，在Python里基本上用处不大，你完全可以用一个模块函数替换它
+
+```python
+class Test(object):
+ # 定义类Test的属性
+ name = 'python'
+ content = '人生苦短，我用python!'
+
+ def instance_method(self):
+ print("是类{}的实例方法，只能被实例对象调用".format(Test))
+
+ @staticmethod # 静态方法，无法访问Test类的属性
+ def static_method(): # 默认没有参数？能不能给个参数？
+ print("Call static method ()\n")
+ # print(self.name, self.content) # 错误调用
+
+
+# 静态方法调用方法, 可以通过类调用，类的实例调用
+Test.static_method()
+Test().static_method()
+
+# 类的实例方法只能实例调用
+Test().instance_method()
+
+```
+
+`@staticmethod`装饰（静态方法）：**经常有一些跟类有关系的功能但在运行时又不需要实例和类参与的情况下需要用到静态方法。**
+
+ **`比如更改环境变量或者修改其他类的属性等能用到静态方法`**
+
+例子：
+```python
+class Test:
+ def __init__(self, num1, num2):
+ self.num1 = num1
+ self.num2 = num2
+
+ def plus(self):
+ result = self.num1 + self.num2
+ return result
+
+ def multiply(self):
+ result = self.num1 * self.num2
+ return result
+
+ @staticmethod
+ def sum(num1, num2):
+ s = num1 * num1 + num2 * num2
+ print(s)
+
+
+Test.sum(3, 4)
+
+```
+
+
+```python
+IND = 'ON'
+
+
+class Kls(object):
+ def __init__(self, data):
+ self.data = data
+
+ @staticmethod
+ def checkind():
+ return IND == 'ON'
+
+ def do_reset(self):
+ if self.checkind():
+ print('Reset done for: %s' % self.data)
+
+ def set_db(self):
+ if self.checkind():
+ print('DB connection made for: %s' % self.data)
+
+
+ik1 = Kls(24)
+ik1.do_reset()
+ik1.set_db()
+```
+
+```python
+class Foo(object):
+ X = 1
+ Y = 2
+
+ @staticmethod
+ def averag(*mixes):
+ return sum(mixes) / len(mixes)
+
+ @staticmethod
+ def static_method():
+ return Foo.averag(Foo.X, Foo.Y)
+
+
+foo = Foo()
+# 子类的实例继承了父类的static_method静态方法，
+# 调用该方法，还是调用的父类的方法和类属性。
+print(foo.static_method())
+```
+
+
+总结：
+
+静态方法：staticmethod修饰，无需参数，类与实例共享。
+
+无法访问类属性、实例属性，相当于一个相对独立的方法，
+
+跟类其实没什么关系，换个角度来讲，其实就是放在一个类的作用域里的函数而已。
+
+**静态方法中引用类属性的话，必须通过类对象来引用。**
+
+
+#### `@classmethod`
+
+`@classmethod` 是一个函数修饰符，它表示接下来的是一个类方法，**类方法的第一个参数cls**
+
+```python
+class Test(object):
+ # 定义类Test的属性
+ name = 'python'
+ content = '人生苦短，我用python!'
+
+ @classmethod # 类方法访问Test类的属性
+ def class_method(cls):
+ # 参数cls必须要有
+ print(cls.name, cls.content)
+
+
+class Son(Test):
+ content = "你好"
+ name = "世界"
+
+
+# 调用方法
+Test.class_method()
+Test().class_method()
+
+# 类方法有类变量cls传入，从而可以用cls做一些相关的处理。
+# 并且有子类继承时，调用该类方法时，传入的类变量cls是子类，而非父类。
+# 调用的是子类的方法和子类的类属性
+print("*" * 10)
+Son.class_method()
+Son().class_method()
+```
+
+
+#### 普通方法、类方法和静态方法的比较
+
+> 普通方法：**由对象调用。至少一个self参数**，执行普通方法时，
+自动将调用该方法的对象赋值给self
+
+>类方法：**由类调用； 至少一个cls参数**；执行类方法时，自动将调用该方法的类复制给cls
+
+>静态方法：**由类调用；无默认参数**
+
+```python
+class Foo(object):
+ # def __init__(self, name):
+ # self.name = name
+
+ def ord_func(self):
+ """ 定义普通方法，至少有一个self参数 """
+
+ # print self.name
+ print('普通方法')
+
+ @classmethod
+ def class_func(cls):
+ """ 定义类方法，至少有一个cls参数 """
+
+ print('类方法')
+
+ @staticmethod
+ def static_func():
+ """ 定义静态方法 ，无默认参数"""
+
+ print('静态方法')
+
+
+# 调用普通方法
+f = Foo()
+f.ord_func()
+
+# 调用类方法
+Foo.class_func()
+f.class_func()
+
+# 调用静态方法
+Foo.static_func()
+f.static_func()
+```
+
+
+相同点：对于所有的方法而言，均属于类（非对象）中，所以，在内存中也只保存一份。
+不同点：方法调用者不同、调用方法时自动传入的参数不同。
+
+
+使用普通方法、类方法和静态方法都可以通过对象（t）进行调用，但是静态方法和类方法无法访问对象的属性，所以**`更改对象（t）的属性仅仅只是对普通方法起作用`**
+
+```python
+class Test(object):
+ # 定义类Test的属性
+ name = 'python'
+ content = '人生苦短，我用python!'
+
+ def normal_method(self):
+ print(self.content)
+
+ @classmethod
+ def class_method(cls):
+ print(cls.content)
+
+ @staticmethod
+ def static_method():
+ print('content')
+
+
+t = Test()
+t.content = '人生苦短，及时行乐' # 设置对象t的属性
+
+t.normal_method() # 人生苦短，及时行乐
+t.class_method() # 人生苦短，我用python!
+t.static_method() # content
+
+```
+
+```python
+class P(object):
+ tip = 'Persion tips' # 类属性，类及类成员共享
+
+ @classmethod
+ def clsFunc(cls):
+ """类方法共享"""
+ return 'Welcome:' + cls.tip
+
+ def insFunc(self):
+ """实例方法"""
+ return self.__class__
+
+ @staticmethod
+ def staFunc():
+ """静态方法"""
+ return P.tip
+
+
+p = P()
+print(P.tip)
+print(p.tip)
+print(p.insFunc())
+
+p.tip = "Hello"
+print(p.clsFunc())
+print(p.staFunc())
+
+print(P.clsFunc())
+print(P.staFunc())
+```
+
+
+# 实例调用
+test = Test()
+print(test.p) # Hello World
+print(Test.p.__get__(test)) # Hello World
+
+print(test.p()) # TypeError: 'str' object is not callable
+
+```
+
+这里要看下什么是[python描述符](https://docs.python.org/3.6/howto/descriptor.html)
+
+>Test.p 返回的是一个property,它的属性是描述符.
+它是一个类,用很多魔法方法,比如`__get__,__set__...`
+
+>当property被类的实例调用时候,就会触发其中的`__get__`方法.
+所以**可以通过类调用property,也可以使用类的实例调用property**
+
+
+
+最后在重复一下@property的含义：
+>它是一个装饰器，作用是把类中的方法变成属性来进行调用。
+
+
+
+
+## 变量作用域
+
+主要有下面几种作用域
+
+**`L: Local 函数内部作用域 -局部名字空间中的名字`**
+
+**`E: Enclosing 封闭作用域-函数内部与内嵌函数之间`**
+
+**`G: Global全局作用域 -内置和全局命名空间中的名字都属于全局作用域`**
+
+**`B: build-in 内置作用域`**
+
+顺序: L>E>G>B
+
+下面分别介绍这几个作用域
+
+### Local作用域
+```python
+# 这里所有的变量都在 local 作用域
+def foo(a, b):
+ c = 1
+ d = a + b + c
+ return d
+
+```
+
+
+### Enclosing作用域
+```python
+i = 0
+
+
+def a():
+ i = 1
+
+ # 对函数b来说就是Enclosing 封闭作用域
+ def b():
+ i = 2
+
+ b()
+ print(i)
+
+
+a() # 1
+
+```
+
+#### 关键字nolocal
+修改Enclosing变量的问题，就需要使用nonlocal关键字。
+还是刚才的例子,增加一个nonlocal:
+
+```python
+i = 0
+
+
+def a():
+ i = 1
+
+ # 对函数b来说就是Enclosing 封闭作用域
+ def b():
+ nonlocal i
+ i = 2
+
+ b()
+ print(i)
+
+
+a() # 2
+
+```
+
+
+```
+
+### python命名空间规则
+
+python使用命名空间记录变量
+
+python中的命名空间就像是一个dict，key是变量的名字，value是变量的值。
+
+python中，每个函数都有一个自己的命名空间，叫做local namespace，它记录了函数的变量。
+
+python中，每个module有一个自己的命名空间，叫做global namespace，它记录了module的变量，包括 functions, classes 和其它imported modules，还有 module级别的 变量和常量。
+
+还有一个build-in 命名空间，可以被任意模块访问，这个build-in命名空间中包含了build-in function 和 exceptions。
+
+当python中的某段代码要访问一个变量x时，python会在所有的命名空间中寻找这个变量，查找的顺序为:
+>local namespace - 指的是当前函数或者当前类方法。
+>如果在当前函数中找到了变量，停止搜索
+
+>global namespace - 指的是当前的模块。如果在当前模块中找到了变量，停止搜索
+
+>build-in namespace - 如果在之前两个namespace中都找不到变量x，python会假设x是build-in的函数或者变量。
+>如果x不是内置函数或者变量，python会报错NameError。
+
+
+对于闭包来说，这里有一点区别，如果在local namespace中找不到变量的话，还会去父函数的local namespace中找变量
+
+
+直接看例子:
+```python
+len = len([])
+print("befoe global len=", len)
+
+
+def a():
+ len = 1
+
+ def b():
+ len = 2
+
+ def c():
+ len = 3
+ print('locals len:', len)
+
+ c()
+ print('enclosing function locals len:', len)
+
+ b()
+ print("after global len=", len)
+
+
+a()
+```
+
+
+运行结果:
+```
+befoe global len= 0
+locals len: 3
+enclosing function locals len: 2
+after global len= 1
+
+```
+
+* from module import 和 import module
+
+使用import module时，module本身被引入，但是保存它原有的命名空间，所以我们需要使用module.name这种方式访问它的 函数和变量。
+
+from module import这种方式，是将其它模块的函数或者变量引到当前的命名空间中
+
+所以就不需要使用module.name这种方式访问其它的模块的方法了。
+
+* if `__name__ `trick
+
+python中的module也是对象，所有的modules都有一个内置的属性`__name__`，
+
+模块的`__name__`属性的值取决于如何使用这个模块，
+
+如果import module，那么`__name__`属性的值是模块的名字
+
+如果直接执行这个模块的话，那么`__name__`属性的值就是默认值`__main_`_。
+
+
+
+## 可变数据类型和不可变数据类型
+
+
+### 可变数据类型：列表list和字典dict
+
+允许变量的值发生变化，即如果对变量进行append、+=等这种操作后，只是改变了变量的值，而不会新建一个对象，变量引用的对象的地址也不会变化
+
+不过对于相同的值的不同对象，在内存中则会存在不同的对象，即每个对象都有自己的地址，相当于内存中对于同值的对象保存了多份，这里不存在引用计数，是实实在在的对象。
+
+```python
+a = [1, 2]
+b = [1, 2]
+
+print("ID a=", id(a)) # ID a= 1236557349896
+print("ID b=", id(b)) # ID b= 1236556806216
+
+print(a == b) # 判断值是否相等 True
+
+print(a is b) # 判断地址是否一样 False
+
+```
+
+, )
+```
+
+
+print([i for i in zrange]) # [0, 1, 2]
+```
+
+在这个例子中，定义了一个生成器函数，函数返回一个生成器对象，然后就可以通过for语句进行迭代访问了。
+
+其实，生成器函数返回生成器的迭代器。 “生成器的迭代器”这个术语通常被称作”生成器”。
+要注意的是生成器就是一类特殊的迭代器。作为一个迭代器，生成器必须要定义一些方法，其中一个就是next()。
+
+如同迭代器一样，我们可以使用next()函数来获取下一个值。
+
+
+### 生成器执行过程
+
+例子：
+```python
+def Zrange(n):
+ print("begin of Zrange")
+ i = 0
+ while i < n:
+ print("before yield:", i)
+ yield i
+ i += 1
+ print("after yield:", i)
+
+ print("begin of Zrange")
+
+
+zrange = Zrange(3)
+# print(zrange)
+
+print(zrange.__next__())
+print("-" * 10)
+print(zrange.__next__())
+print("-" * 10)
+print(zrange.__next__())
+# print(zrange.__next__()) # StopIteration
+```
+
+运行结果：
+```
+begin of Zrange
+before yield: 0
+0
+----------
+after yield: 1
+before yield: 1
+1
+----------
+after yield: 2
+before yield: 2
+2
+```
+
+
+通过结果可以看到：
+* 当调用生成器函数的时候，函数只是返回了一个生成器对象，并没有 执行。
+* 当next()方法第一次被调用的时候，生成器函数才开始执行，执行到yield语句处停止
+* next()方法的返回值就是yield语句处的参数（yielded value）
+* 当继续调用next()方法的时候，函数将接着上一次停止的yield语句处继续执行，并到下一个yield处停止；如果后面没有yield就抛出StopIteration异常
+
+
+
+总结：生成器是迭代器的一种，但功能方法比迭代器多
+
+
+
+
+### 生成器创建
+
+ 生成器的创建可以使用yield关键字， 也可以使用生成器表达式
+
+```python
+(x*2 for i in range(10))
+```
+
+
+### 生成器判断
+
+判断是否为生成器函数可用isgeneratorfunction, 判断是否为生成器对象可用isgenerator
+
+```python
+from inspect import isgeneratorfunction, isgenerator
+
+g = (i for i in range(3))
+print(isgenerator(g)) # True
+
+
+def demo():
+ yield 1
+
+
+print(isgenerator(demo())) # True
+print(isgeneratorfunction(demo())) # False
+print(isgeneratorfunction(demo)) # True
+```
+
+
+### yield与协程
+
+```python
+def coroutine():
+ print("coroutine start...")
+ result = None
+ while True:
+ s = yield result
+ result = 'result:{}'.format(s)
+
+
+c = coroutine()
+c.send(None) # coroutine start...
+
+print(c.send("first")) # result:first
+print(c.send("second")) # result:second
+
+c.close()
+
+# c.send("hello") # StopIteration
+```
+
diff --git "a/notes/Python/\346\265\201\347\225\205\347\232\204Python/\345\255\227\345\205\270\345\222\214\351\233\206\345\220\210.md" "b/notes/Python/\346\265\201\347\225\205\347\232\204Python/\345\255\227\345\205\270\345\222\214\351\233\206\345\220\210.md"
new file mode 100644
index 00000000..a74b204e
--- /dev/null
+++ "b/notes/Python/\346\265\201\347\225\205\347\232\204Python/\345\255\227\345\205\270\345\222\214\351\233\206\345\220\210.md"
@@ -0,0 +1,424 @@
+# 第3章 字典和集合
+
+
+
+- [第3章 字典和集合](#第3章-字典和集合)
+ - [字典推导式](#字典推导式)
+ - [setdefault用法](#setdefault用法)
+ - [defaultdict用法](#defaultdict用法)
+ - [字典的变种](#字典的变种)
+ - [collections.Counter 用法](#collectionscounter-用法)
+ - [集合](#集合)
+ - [关于字典，列表，集合运行效率的对比](#关于字典列表集合运行效率的对比)
+
+
+
+## 字典推导式
+
+可能你见过列表推导时,却没有见过字典推导式,在2.7中才加入的:
+
+d = {key: value for (key, value) in iterable}
+
+举个例子说明：
+```python
+iterable = [(1, 'hello'), (2, 'world'), (3, 'happy')]
+d = {key: value for (key, value) in iterable}
+
+print(d) # {1: 'hello', 2: 'world', 3: 'happy'}
+
+```
+, {})
+
+print(dct["a"]) # []
+dct["a"].append("hello")
+print(dct) # defaultdict(, {'a': ['hello']})
+
+```
+
+看一个例子：
+```python
+from collections import defaultdict
+
+result = defaultdict(list)
+
+data = [("p", 1), ("p", 2), ("p", 3), ("h", 1), ("h", 2), ("h", 3)]
+
+for (key, value) in data:
+ result[key].append(value)
+
+print(result) # defaultdict(, {'p': [1, 2, 3], 'h': [1, 2, 3]})
+print(dict(result)) # {'p': [1, 2, 3], 'h': [1, 2, 3]}
+
+```
+
+再看一个例子：
+```python
+# 字典的统计
+names = ['leo', 'sam', 'jack', 'peter', 'joe', 'susan']
+# 要变成这样：{3: ['leo', 'sam', 'joe'], 4: ['jack'], 5: ['peter', 'susan']}
+
+# bad
+nums = [len(n) for n in names]
+contain = {}
+for k1, k2 in zip(nums, names):
+ print(k1, k2)
+ if k1 not in contain:
+ contain[k1] = [k2]
+ else:
+ contain[k1].append(k2)
+print(contain)
+
+print("#" * 10)
+
+# better
+from collections import defaultdict
+d = defaultdict(list)
+for name in names:
+ key = len(name)
+ d[key].append(name)
+
+print(dict(d))
+```
+.
+
+这个__repr__和__str__的作用是类似的
+
+这里要知道`__repr__和__str__`的区别在哪里 [^1]
+
+
+
+
+demo_eval = type(eval(repr(demo)))
+print(demo_eval) #
+
+# 用于重建对象，如果eval(repr(obj))会得到一个对象的拷贝。
+study = eval(repr(demo))
+study.say() # jacky
+```
+
+
+
+>>> type(repr(a))
+
+```
+
+但是这二者之间有什么区别呢？
+因为提供两个功能完全相同的内建函数是没有意义的。
+
+先看一个例子。
+
+```python
+>>> print(str('123'))
+123
+>>> print(str(123))
+123
+>>> print(repr('123'))
+'123'
+>>> print(repr(123))
+123
+```
+从例子中不难发现，当我们把一个字符串传给 str() 函数再打印到终端的时候，输出的字符不带引号。
+
+而将一个字符串传给 repr() 函数再打印到终端的时候，输出的字符带有引号。
+
+造成这两种输出形式不同的原因在于：
+
+print 语句结合 str() 函数实际上是调用了对象的` __str__ `方法来输出结果。
+而 print 结合 repr() 实际上是调用对象的` __repr__` 方法输出结果。
+
+
+下例中我们用 str 对象直接调用这两个方法，输出结果的形式与前一个例子保持一致。
+
+```python
+>>> print('123'.__repr__())
+'123'
+>>>> print('123'.__str__())
+123
+```
+, , , , )
+
+
+
+```
+
+
+执行bar方法时
+首先去A类中查找，如果A类中没有，则继续去B类中找，如果B类中么有，则继续去C类中找，如果C类中么有，则继续去D类中找，如果还是未找到，则报错
+
+所以，查找顺序：**A --> B --> C --> D**
+
+ 在上述查找bar方法的过程中，一旦找到，则寻找过程立即中断，便不会再继续找了
+
+
+再看一个例子：
+```python
+class D:
+ def __init__(self):
+ self.a = 1
+
+
+class B(D):
+ pass
+
+
+class C(B):
+ def __init__(self):
+ self.a = 2
+
+
+class A(B,C):
+ pass
+
+
+a = A()
+print (a.a) # 1
+```
+
+```python
+class D(object):
+ def __init__(self):
+ self.a = 1
+
+
+class B(D):
+ pass
+
+
+class C(D):
+ def __init__(self):
+ self.a = 2
+
+
+class A(B,C):
+ pass
+
+
+a = A()
+print (a.a) # 2
+```
+
+##### 多态
+
+Pyhon不支持Java和C#这一类强类型语言中多态的写法，但是原生多态，其Python崇尚“鸭子类型”。
+
+
+```python
+class Animal(object):
+ def run(self):
+ print('Animal is running...')
+
+
+class Dog(Animal):
+ pass
+
+
+class Cat(Animal):
+ pass
+
+
+c = Dog()
+b = Animal()
+
+isok = isinstance(c, Animal)
+print(isok)
+
+isok = isinstance(b, Dog)
+print(isok)
+
+
+def run_twice(animal):
+ animal.run()
+ animal.run()
+
+
+class Tortoise(Animal):
+ def run(self):
+ print('Tortoise is running slowly...')
+
+
+class people(object):
+ def run(self):
+ print("People run...")
+
+
+isok = run_twice(Tortoise())
+print(isok)
+
+# people这个类却和animal没有任何关系，但是其中却有run这个方法
+# 鸭子类型
+isok = run_twice(people())
+print(isok)
+```
+
+
+### 进阶篇
+
+
+#### 类的成员
+类的成员可以分为三大类：**`字段、方法和属性`**
+
+##### 字段
+
+字段包括：普通字段和静态字段，他们在定义和使用中有所区别，而最本质的区别是内存中保存的位置不同，
+
+* **`普通字段属于对象`**
+* **`静态字段属于类`**
+
+```python
+class Province:
+ # 静态字段
+ country = '中国'
+
+ def __init__(self, name):
+ # 普通字段
+ self.name = name
+
+
+# 直接访问普通字段
+obj = Province('河北省')
+print(obj.name)
+
+# 直接访问静态字段
+print(Province.country)
+
+```
+
+
+##### 方法
+
+
+##### 属性
+
+如果你已经了解Python类中的方法，那么属性就非常简单了，因为Python中的属性其实是普通方法的变种。
+对于属性，有以下三个知识点：
+
+* 属性的基本使用
+* 属性的两种定义方式
+
+
+```python
+class Goods(object):
+ @property
+ def price(self):
+ print("100")
+
+
+obj = Goods()
+obj.price
+```
+由属性的定义和调用要注意一下几点：
+* 定义时，在普通方法的基础上添加 @property 装饰器；
+* 定义时，属性仅有一个self参数
+
+* 调用时，无需括号
+方法：foo_obj.func()
+属性：foo_obj.prop
+
+
+注意：属性存在意义是：访问属性时可以制造出和访问字段完全相同的假象
+
+属性由方法变种而来，如果Python中没有属性，方法完全可以代替其功能
+
+
+
+1.特殊的类属性
+
+`class.__class__` 类的类型
+`class.__bases__` 父类名称
+`class.__dict__` 类所有属性
+`class.__module__` 类所在的模块
+
+
+
+2.特殊的实例属性
+`__class__` 实例所对应的类
+`__dict__` 实例的属性
+
+
+
+
+
+```
+
+```
+
+
+##### `__init__`
+
+构造方法，通过类创建对象时，自动触发执行。
+
+```python
+class Test(object):
+ def __init__(self, name):
+ self.name = name
+
+
+test = Test("tony") # 自动执行类中的__init__方法
+```
+
+
+# init
+
+```
+
+
+b'\xd6\xd0\xce\xc4'
+中文
+
+```
+
+print(dic)
+
+json_obj = json.dumps(dic)
+print(type(json_obj)) #
+print(json_obj)
+
+dic1 = json.loads(json_obj)
+print(type(dic1)) #
+print(dic1)
+
+```
+:1()
+ 1 0.000 0.000 0.281 0.281 demo.py:11(profile_result)
+ 1 0.141 0.141 0.281 0.281 demo.py:12()
+ 100000 0.141 0.000 0.141 0.000 demo.py:6(__init__)
+ 1 0.000 0.000 0.297 0.297 profile:0(profile_result())
+ 0 0.000 0.000 profile:0(profiler)
+
+```
+
+
+这里返回值参数意思：
+```
+其中输出每列的具体解释如下：
+
+ncalls：表示函数调用的次数；
+
+tottime：表示指定函数的总的运行时间，除掉函数中调用子函数的运行时间；
+
+percall：（第一个 percall）等于 tottime/ncalls；
+
+cumtime：表示该函数及其所有子函数的调用运行的时间，即函数开始调用到返回的时间；
+
+percall：（第二个 percall）即函数运行一次的平均时间，等于 cumtime/ncalls；
+
+filename:lineno(function)：每个函数调用的具体信息；
+```
+
+
+查看内存占用情况：
+
+```python
+# 使用 profile 进行性能分析
+from memory_profiler import profile
+
+
+class A(object):
+ def __init__(self, x, y):
+ self.x = x
+ self.y = y
+
+
+@profile
+def profile_result():
+ f = [A(1, 2) for i in range(100000)]
+
+
+if __name__ == "__main__":
+ profile_result()
+
+```
+
+返回结果：
+```python
+Filename: d:\学习\python\demo\demo.py
+Line # Mem usage Increment Line Contents
+================================================
+ 11 50.8 MiB 50.8 MiB @profile
+ 12 def profile_result():
+ 13 68.8 MiB 0.6 MiB f = [A(1, 2) for i in range(100000)]
+
+
+```
+
+, , , )
+name is wang
+name is xiaoming
+```
+
+如果把注释去掉的结果是：
+```python
+(, , , )
+name is wang
+name is xiaoming
+name is cat
+
+```
+
+, , ]
+
+ for next_class in mro[mro.index(ChildB) + 1:]:
+ print(next_class) #
+ if hasattr(next_class, '__init__'):
+ next_class.__init__(self)
+ break
+
+
+print(ChildA())
+print("#" * 10)
+print(ChildB())
+
+```
+
+
+## 问题
+
+看下面的代码：
+
+```python
+class Base(object):
+ def __init__(self):
+ print("Base created")
+
+
+class ChildA(Base):
+ def __init__(self):
+ print("ChildA init...")
+ Base.__init__(self)
+
+
+class ChildB(Base):
+ def __init__(self):
+ print("ChildB init..")
+ # super(ChildB, self).__init__()
+ # 或者更简单的写法
+ super().__init__()
+
+
+if __name__ == "__main__":
+ print(ChildA())
+ print("#" * 10)
+ print(ChildB())
+
+```
+
+返回值：
+```
+ChildA init...
+Base created
+<__main__.ChildA object at 0x000001D089FE85F8>
+##########
+ChildB init..
+Base created
+<__main__.ChildB object at 0x000001D089FE85F8>
+
+```
+
+
+
+
diff --git a/notes/SkillTree/assets/backend-skill.xmind b/notes/SkillTree/assets/backend-skill.xmind
new file mode 100644
index 00000000..f2164871
Binary files /dev/null and b/notes/SkillTree/assets/backend-skill.xmind differ
diff --git a/notes/SkillTree/backend-skill.md b/notes/SkillTree/backend-skill.md
new file mode 100644
index 00000000..b45f050d
--- /dev/null
+++ b/notes/SkillTree/backend-skill.md
@@ -0,0 +1,5 @@
+# 后台开发 技能图谱
+
+> 欢迎在 [issue#25](https://github.com/frank-lam/fullstack-tutorial/issues/25) 中留言，持续更新
+
+
\ No newline at end of file
diff --git a/notes/SpringBoot/README.md b/notes/SpringBoot/README.md
new file mode 100644
index 00000000..f54e6448
--- /dev/null
+++ b/notes/SpringBoot/README.md
@@ -0,0 +1,2 @@
+## Spring Boot 学习指南
+
diff --git a/notes/assets/20181224210950.png b/notes/assets/20181224210950.png
new file mode 100644
index 00000000..5e10a203
Binary files /dev/null and b/notes/assets/20181224210950.png differ
diff --git a/notes/assets/Travis.png b/notes/assets/Travis.png
new file mode 100644
index 00000000..1a74b430
Binary files /dev/null and b/notes/assets/Travis.png differ
diff --git a/notes/assets/ca6ddafaa8b506ae4d45dde53ee5efb6-5612127.png b/notes/assets/ca6ddafaa8b506ae4d45dde53ee5efb6-5612127.png
new file mode 100644
index 00000000..423fad95
Binary files /dev/null and b/notes/assets/ca6ddafaa8b506ae4d45dde53ee5efb6-5612127.png differ
diff --git a/notes/assets/full-stack-dev-mind.svg b/notes/assets/full-stack-dev-mind.svg
index bd20d451..f8b4daf1 100644
--- a/notes/assets/full-stack-dev-mind.svg
+++ b/notes/assets/full-stack-dev-mind.svg
@@ -1 +1,1332 @@
-
+
+
diff --git a/notes/assets/regexr-table.pdf b/notes/assets/regexr-table.pdf
new file mode 100644
index 00000000..54966e1e
Binary files /dev/null and b/notes/assets/regexr-table.pdf differ
diff --git a/notes/assets/regexr-table.png b/notes/assets/regexr-table.png
new file mode 100644
index 00000000..4cba70c1
Binary files /dev/null and b/notes/assets/regexr-table.png differ
diff --git a/notes/data-structures-and-algorithms/LeetCode.md b/notes/data-structures-and-algorithms/LeetCode.md
new file mode 100644
index 00000000..a98174fb
--- /dev/null
+++ b/notes/data-structures-and-algorithms/LeetCode.md
@@ -0,0 +1 @@
+# LeetCode
\ No newline at end of file
diff --git a/notes/data-structures-and-algorithms/README.md b/notes/data-structures-and-algorithms/README.md
new file mode 100644
index 00000000..e824a536
--- /dev/null
+++ b/notes/data-structures-and-algorithms/README.md
@@ -0,0 +1,51 @@
+# 数据结构与算法
+
+> 欢迎来到数据结构与算法的世界，带你从基础数据结构层层深入。本章以 Java 代码为例，结合 LeetCode 题解示例进行数据结构学习。
+
+
+
+## 学习目录
+
+| 部分 | 章节 | 概要 |
+| :--- | :--------------------------- | :--------------------------------------------------- |
+| Ⅰ | [数据结构](数据结构.md) | 线性表、栈和队列、树和二叉树等经典数据结构 |
+| Ⅱ | [算法思想](算法思想.md) | 排序算法、动态规划、递归、回溯法、贪心算法等经典算法 |
+| Ⅲ | [LeetCode 题解](LeetCode.md) | LeetCode 热题 HOT 100 |
+
+
+
+## 在线刷题
+
+- 题库 - 力扣 (LeetCode) 全球极客挚爱的技术成长平台
+
+ https://leetcode-cn.com/problemset/all
+
+- 牛客网 - 找工作神器|笔试题库|面试经验|实习招聘内推，求职就业一站解决
+
+ https://www.nowcoder.com/
+
+
+
+## 在线工具
+
+- VisuAlgo - visualising data structures and algorithms through animation
+
+ https://visualgo.net/en
+
+- Data Structure Visualization
+
+ https://www.cs.usfca.edu/~galles/visualization/Algorithms.html
+
+
+
+## 学习课程
+
+| 课程 | 链接 | 代码 | 推荐 |
+| ------------------------------------------------------ | ------------------------------------------------------- | ------------------------------------------------------------ | ----------------------------------------- |
+| 【慕课网】玩转数据结构 从入门到进阶（Java） | [官网](https://coding.imooc.com/class/chapter/207.html) | [代码](https://github.com/liuyubobobo/Play‑with‑Data‑Structures) | 数据结构从底层到实现，浅显易懂 |
+| 【慕课网】算法与数据结构体系课（Java） {
+
+ private E[] tree;
+ private E[] data;
+ private Merger merger;
+
+ public SegmentTree(E[] arr, Merger merger){
+
+ this.merger = merger;
+
+ data = (E[])new Object[arr.length];
+ for(int i = 0 ; i < arr.length ; i ++)
+ data[i] = arr[i];
+
+ tree = (E[])new Object[4 * arr.length];
+ buildSegmentTree(0, 0, arr.length - 1);
+ }
+
+ // 在treeIndex的位置创建表示区间[l...r]的线段树
+ private void buildSegmentTree(int treeIndex, int l, int r){
+
+ if(l == r){
+ tree[treeIndex] = data[l];
+ return;
+ }
+
+ int leftTreeIndex = leftChild(treeIndex);
+ int rightTreeIndex = rightChild(treeIndex);
+
+ // int mid = (l + r) / 2;
+ int mid = l + (r - l) / 2;
+ buildSegmentTree(leftTreeIndex, l, mid);
+ buildSegmentTree(rightTreeIndex, mid + 1, r);
+
+ tree[treeIndex] = merger.merge(tree[leftTreeIndex], tree[rightTreeIndex]);
+ }
+
+ public int getSize(){
+ return data.length;
+ }
+
+ public E get(int index){
+ if(index < 0 || index >= data.length)
+ throw new IllegalArgumentException("Index is illegal.");
+ return data[index];
+ }
+
+ // 返回完全二叉树的数组表示中，一个索引所表示的元素的左孩子节点的索引
+ private int leftChild(int index){
+ return 2*index + 1;
+ }
+
+ // 返回完全二叉树的数组表示中，一个索引所表示的元素的右孩子节点的索引
+ private int rightChild(int index){
+ return 2*index + 2;
+ }
+
+ // 返回区间[queryL, queryR]的值
+ public E query(int queryL, int queryR){
+
+ if(queryL < 0 || queryL >= data.length ||
+ queryR < 0 || queryR >= data.length || queryL > queryR)
+ throw new IllegalArgumentException("Index is illegal.");
+
+ return query(0, 0, data.length - 1, queryL, queryR);
+ }
+
+ // 在以treeIndex为根的线段树中[l...r]的范围里，搜索区间[queryL...queryR]的值
+ private E query(int treeIndex, int l, int r, int queryL, int queryR){
+
+ if(l == queryL && r == queryR)
+ return tree[treeIndex];
+
+ int mid = l + (r - l) / 2;
+ // treeIndex的节点分为[l...mid]和[mid+1...r]两部分
+
+ int leftTreeIndex = leftChild(treeIndex);
+ int rightTreeIndex = rightChild(treeIndex);
+ if(queryL >= mid + 1)
+ return query(rightTreeIndex, mid + 1, r, queryL, queryR);
+ else if(queryR <= mid)
+ return query(leftTreeIndex, l, mid, queryL, queryR);
+
+ E leftResult = query(leftTreeIndex, l, mid, queryL, mid);
+ E rightResult = query(rightTreeIndex, mid + 1, r, mid + 1, queryR);
+ return merger.merge(leftResult, rightResult);
+ }
+
+ // 将index位置的值，更新为e
+ public void set(int index, E e){
+
+ if(index < 0 || index >= data.length)
+ throw new IllegalArgumentException("Index is illegal");
+
+ data[index] = e;
+ set(0, 0, data.length - 1, index, e);
+ }
+
+ // 在以treeIndex为根的线段树中更新index的值为e
+ private void set(int treeIndex, int l, int r, int index, E e){
+
+ if(l == r){
+ tree[treeIndex] = e;
+ return;
+ }
+
+ int mid = l + (r - l) / 2;
+ // treeIndex的节点分为[l...mid]和[mid+1...r]两部分
+
+ int leftTreeIndex = leftChild(treeIndex);
+ int rightTreeIndex = rightChild(treeIndex);
+ if(index >= mid + 1)
+ set(rightTreeIndex, mid + 1, r, index, e);
+ else // index <= mid
+ set(leftTreeIndex, l, mid, index, e);
+
+ tree[treeIndex] = merger.merge(tree[leftTreeIndex], tree[rightTreeIndex]);
+ }
+
+ @Override
+ public String toString(){
+ StringBuilder res = new StringBuilder();
+ res.append('[');
+ for(int i = 0 ; i < tree.length ; i ++){
+ if(tree[i] != null)
+ res.append(tree[i]);
+ else
+ res.append("null");
+
+ if(i != tree.length - 1)
+ res.append(", ");
+ }
+ res.append(']');
+ return res.toString();
+ }
+ }
+
+ public interface Merger {
+ E merge(E a, E b);
+ }
+
+ private SegmentTree segTree;
+
+ public NumArray(int[] nums) {
+
+ if(nums.length != 0){
+ Integer[] data = new Integer[nums.length];
+ for(int i = 0 ; i < nums.length ; i ++)
+ data[i] = nums[i];
+ segTree = new SegmentTree<>(data, (a, b) -> a + b);
+ }
+ }
+
+ public void update(int i, int val) {
+ if(segTree == null)
+ throw new IllegalArgumentException("Error");
+ segTree.set(i, val);
+ }
+
+ public int sumRange(int i, int j) {
+ if(segTree == null)
+ throw new IllegalArgumentException("Error");
+ return segTree.query(i, j);
+ }
+}
+```
\ No newline at end of file
diff --git "a/notes/data-structures-and-algorithms/\346\225\260\346\215\256\347\273\223\346\236\204.md" "b/notes/data-structures-and-algorithms/\346\225\260\346\215\256\347\273\223\346\236\204.md"
new file mode 100644
index 00000000..b3ffc0cd
--- /dev/null
+++ "b/notes/data-structures-and-algorithms/\346\225\260\346\215\256\347\273\223\346\236\204.md"
@@ -0,0 +1,286 @@
+# 数据结构
+
+## 一、基础数据结构
+
+### 字符串
+
+- 标准库，解析，匹配等
+
+### 线性表
+
+- 数组
+
+- 动态数组
+
+### 栈和队列
+
+### 链表
+
+### 哈希表
+
+
+
+## 二、高级数据结构
+
+### 1. 线段树
+
+线段树（segment tree），顾名思义， 是用来存放给定区间（segment, or interval）内对应信息的一种数据结构。与树状数组（binary indexed tree）相似，线段树也用来处理数组相应的区间查询（range query）和元素更新（update）操作。与树状数组不同的是，线段树不止可以适用于区间求和的查询，也可以进行区间最大值，区间最小值（Range Minimum/Maximum Query problem）或者区间异或值的查询。
+
+对应于树状数组，线段树进行更新（update）的操作为 O(logn)，进行区间查询（range query）的操作也为 O(logn)。
+
+
+
+在线可视化：https://visualgo.net/en/segmenttree
+
+
+
+#### 303. 区域和检索 - 数组不可变 （LeetCode）
+
+
+https://leetcode-cn.com/problems/range-sum-query-immutable
+
+```java
+class NumArray {
+ private int[] data;
+
+ public NumArray(int[] nums) {
+ this.data = new int[nums.length];
+ for (int i = 0; i < nums.length; i++) {
+ this.data[i] = nums[i];
+ }
+ }
+
+ public void update(int index, int val) {
+ this.data[index] = val;
+ }
+
+ public int sumRange(int left, int right) {
+ int sum = 0;
+ for (int i = left; i <= right; i++) {
+ sum += this.data[i];
+ }
+ return sum;
+ }
+}
+```
+
+
+
+#### 307. 区域和检索 - 数组可修改 （LeetCode）
+
+https://leetcode-cn.com/problems/range-sum-query-mutable
+
+```java
+
+class NumArray {
+ public class SegmentTree {
+ private E[] tree;
+ private E[] data;
+ private Merger merger;
+
+ public SegmentTree(E[] arr, Merger merger){
+
+ this.merger = merger;
+
+ data = (E[])new Object[arr.length];
+ for(int i = 0 ; i < arr.length ; i ++)
+ data[i] = arr[i];
+
+ tree = (E[])new Object[4 * arr.length];
+ buildSegmentTree(0, 0, arr.length - 1);
+ }
+
+ // 在treeIndex的位置创建表示区间[l...r]的线段树
+ private void buildSegmentTree(int treeIndex, int l, int r){
+
+ if(l == r){
+ tree[treeIndex] = data[l];
+ return;
+ }
+
+ int leftTreeIndex = leftChild(treeIndex);
+ int rightTreeIndex = rightChild(treeIndex);
+
+ // int mid = (l + r) / 2;
+ int mid = l + (r - l) / 2;
+ buildSegmentTree(leftTreeIndex, l, mid);
+ buildSegmentTree(rightTreeIndex, mid + 1, r);
+
+ tree[treeIndex] = merger.merge(tree[leftTreeIndex], tree[rightTreeIndex]);
+ }
+
+ public int getSize(){
+ return data.length;
+ }
+
+ public E get(int index){
+ if(index < 0 || index >= data.length)
+ throw new IllegalArgumentException("Index is illegal.");
+ return data[index];
+ }
+
+ // 返回完全二叉树的数组表示中，一个索引所表示的元素的左孩子节点的索引
+ private int leftChild(int index){
+ return 2*index + 1;
+ }
+
+ // 返回完全二叉树的数组表示中，一个索引所表示的元素的右孩子节点的索引
+ private int rightChild(int index){
+ return 2*index + 2;
+ }
+
+ // 返回区间[queryL, queryR]的值
+ public E query(int queryL, int queryR){
+
+ if(queryL < 0 || queryL >= data.length ||
+ queryR < 0 || queryR >= data.length || queryL > queryR)
+ throw new IllegalArgumentException("Index is illegal.");
+
+ return query(0, 0, data.length - 1, queryL, queryR);
+ }
+
+ // 在以treeIndex为根的线段树中[l...r]的范围里，搜索区间[queryL...queryR]的值
+ private E query(int treeIndex, int l, int r, int queryL, int queryR){
+
+ if(l == queryL && r == queryR)
+ return tree[treeIndex];
+
+ int mid = l + (r - l) / 2;
+ // treeIndex的节点分为[l...mid]和[mid+1...r]两部分
+
+ int leftTreeIndex = leftChild(treeIndex);
+ int rightTreeIndex = rightChild(treeIndex);
+ if(queryL >= mid + 1)
+ return query(rightTreeIndex, mid + 1, r, queryL, queryR);
+ else if(queryR <= mid)
+ return query(leftTreeIndex, l, mid, queryL, queryR);
+
+ E leftResult = query(leftTreeIndex, l, mid, queryL, mid);
+ E rightResult = query(rightTreeIndex, mid + 1, r, mid + 1, queryR);
+ return merger.merge(leftResult, rightResult);
+ }
+
+ // 将index位置的值，更新为e
+ public void set(int index, E e){
+
+ if(index < 0 || index >= data.length)
+ throw new IllegalArgumentException("Index is illegal");
+
+ data[index] = e;
+ set(0, 0, data.length - 1, index, e);
+ }
+
+ // 在以treeIndex为根的线段树中更新index的值为e
+ private void set(int treeIndex, int l, int r, int index, E e){
+
+ if(l == r){
+ tree[treeIndex] = e;
+ return;
+ }
+
+ int mid = l + (r - l) / 2;
+ // treeIndex的节点分为[l...mid]和[mid+1...r]两部分
+
+ int leftTreeIndex = leftChild(treeIndex);
+ int rightTreeIndex = rightChild(treeIndex);
+ if(index >= mid + 1)
+ set(rightTreeIndex, mid + 1, r, index, e);
+ else // index <= mid
+ set(leftTreeIndex, l, mid, index, e);
+
+ tree[treeIndex] = merger.merge(tree[leftTreeIndex], tree[rightTreeIndex]);
+ }
+
+ @Override
+ public String toString(){
+ StringBuilder res = new StringBuilder();
+ res.append('[');
+ for(int i = 0 ; i < tree.length ; i ++){
+ if(tree[i] != null)
+ res.append(tree[i]);
+ else
+ res.append("null");
+
+ if(i != tree.length - 1)
+ res.append(", ");
+ }
+ res.append(']');
+ return res.toString();
+ }
+ }
+
+ public interface Merger {
+ E merge(E a, E b);
+ }
+
+ private SegmentTree segTree;
+
+ public NumArray(int[] nums) {
+
+ if(nums.length != 0){
+ Integer[] data = new Integer[nums.length];
+ for(int i = 0 ; i < nums.length ; i ++)
+ data[i] = nums[i];
+ segTree = new SegmentTree<>(data, (a, b) -> a + b);
+ }
+ }
+
+ public void update(int i, int val) {
+ if(segTree == null)
+ throw new IllegalArgumentException("Error");
+ segTree.set(i, val);
+ }
+
+ public int sumRange(int i, int j) {
+ if(segTree == null)
+ throw new IllegalArgumentException("Error");
+ return segTree.query(i, j);
+ }
+}
+```
+
+
+
+### 2. Trie
+
+https://blog.csdn.net/jt102605/article/details/84258314
+
+https://blog.csdn.net/longgeqiaojie304/article/details/106316103
+
+发生在微软的一个真实案例：
+
+在一个古老的手持设备中实现一个通讯录功能，但是当时的手持设备的芯片运算能力是非常低的，所以他们发现当通讯录中记录的条目非常多的时候，搜索通讯录中的内容是非常慢的。但是这个问题是被微软的一个实习生解决了。其实他解决的方式非常简单，他就是使用了这种Trie数据结构来解决的。
+
+
+
+
+### 树和二叉树
+
+- 二叉树
+
+- 二分搜索树
+
+- AVL 树
+
+- B 和 B+
+
+- 二分查找法
+ - Leetcode 704.
+
+- 红黑树
+
+
+
+### 集合和映射
+
+
+
+### 优先队列和堆
+
+
+
+
+
+### Trie
+
+### 并查集
diff --git "a/notes/data-structures-and-algorithms/\347\256\227\346\263\225\346\200\235\346\203\263.md" "b/notes/data-structures-and-algorithms/\347\256\227\346\263\225\346\200\235\346\203\263.md"
new file mode 100644
index 00000000..28a34932
--- /dev/null
+++ "b/notes/data-structures-and-algorithms/\347\256\227\346\263\225\346\200\235\346\203\263.md"
@@ -0,0 +1,730 @@
+# 算法思想
+
+## 一、排序算法
+
+### 1. 选择排序（Selection Sort）
+
+选择出数组中的最小元素，将它与数组的第一个元素交换位置。再从剩下的元素中选择出最小的元素，将它与数组的第二个元素交换位置。不断进行这样的操作，直到将整个数组排序。
+
+
+
+**代码实现**
+
+```java
+public static void sort(int[] arr) {
+ for (int i = 0; i < arr.length; i++) {
+ // 寻找[i, n)区间里的最小值的索引
+ int minIndex = i;
+ for (int j = i + 1; j < arr.length; j++) {
+ if(arr[minIndex] > arr[j]){
+ minIndex = j;
+ }
+ }
+ swap( arr , i , minIndex);
+ }
+}
+
+private static void swap(int[] arr, int i, int j) {
+ int t = arr[i];
+ arr[i] = arr[j];
+ arr[j] = t;
+}
+```
+
+**算法分析**
+
+表现最稳定的排序算法之一，因为无论什么数据进去都是O(n2)的时间复杂度，所以用到它的时候，数据规模越小越好。唯一的好处可能就是不占用额外的内存空间了吧。理论上讲，选择排序可能也是平时排序一般人想到的最多的排序方法了吧。
+
+
+
+### 2. 插入排序（Insertion Sort）
+
+插入排序从左到右进行，每次都将当前元素插入到左侧已经排序的数组中，使得插入之后左部数组依然有序。
+
+第 j 元素是通过不断向左比较并交换来实现插入过程：当第 j 元素小于第 j - 1 元素，就将它们的位置交换，然后令 j 指针向左移动一个位置，不断进行以上操作。
+
+
+
+**代码实现**
+
+```java
+public static void sort(int[] arr) {
+ for (int i = 0; i < arr.length; i++) {
+ // 选择 arr[i...n) 中的最小值
+ int minIndex = i;
+ for (int j = i + 1; j < arr.length; j++) {
+ if (arr[minIndex] > arr[j]) {
+ minIndex = j;
+ }
+ }
+ swap(arr, i, minIndex);
+ }
+}
+
+// 改进版插入排序（减少了数组元素的操作次数）
+public static void better_sort(int[] arr) {
+ for (int i = 0; i < arr.length; i++) {
+ int e = arr[i];
+ int j = i;
+ for (; j > 0; j--) {
+ if (e < arr[j - 1])
+ arr[j] = arr[j - 1];
+ else
+ break;
+ }
+ arr[j] = e;
+ }
+}
+
+private static void swap(int[] arr, int i, int j) {
+ int t = arr[i];
+ arr[i] = arr[j];
+ arr[j] = t;
+}
+```
+
+**算法分析**
+
+插入排序在实现上，通常采用 in-place 排序（即只需用到 O(1) 的额外空间的排序），因而在从后向前扫描过程中，需要反复把已排序元素逐步向后挪位，为最新元素提供插入空间。
+
+
+
+### 3. 冒泡排序（Bubble Sort）
+
+通过从左到右不断交换相邻逆序的相邻元素，在一轮的交换之后，可以让未排序的元素上浮到右侧。
+
+在一轮循环中，如果没有发生交换，就说明数组已经是有序的，此时可以直接退出。
+
+
+
+**代码实现**
+
+```java
+private static void sort(int[] arr) {
+ for (int i = arr.length - 1; i > 0; i--) { // 从最后一位开始确定
+ boolean swapped = false;
+ for (int j = 0; j < i; j++) {
+ if(arr[j] > arr[j+1]){
+ swapped = true;
+ swap(arr,j,j+1);
+ }
+ }
+ if(!swapped)
+ return;
+ }
+}
+
+private static void swap(int[] arr, int i, int j) {
+ int t = arr[i];
+ arr[i] = arr[j];
+ arr[j] = t;
+}
+```
+
+
+
+### 4. 希尔排序（Shell Sort）
+
+1959年Shell发明，第一个突破O(n2)的排序算法，是简单插入排序的改进版。它与插入排序的不同之处在于，它会优先比较距离较远的元素。希尔排序又叫**缩小增量排序**。
+
+
+
+**算法描述**
+
+先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，具体算法描述：
+
+- 选择一个增量序列t1，t2，…，tk，其中ti>tj，tk=1；
+- 按增量序列个数k，对序列进行k 趟排序；
+- 每趟排序，根据对应的增量ti，将待排序列分割成若干长度为m 的子序列，分别对各子表进行直接插入排序。仅增量因子为1 时，整个序列作为一个表来处理，表长度即为整个序列的长度。
+
+
+
+**代码实现**
+
+```java
+// 希尔排序
+public static void sort(int[] arr) {
+ int n = arr.length;
+ for (int h = n / 2; h > 0; h = h / 2) {
+ // 内部是一个插入排序
+ for (int i = 0; i < n; i = i + h) {
+
+ int e = arr[i];
+ int j = i;
+ for (; j > 0; j = j - h) {
+ if (e < arr[j - h])
+ arr[j] = arr[j - h];
+ else
+ break;
+ }
+ arr[j] = e;
+ }
+ }
+}
+
+
+// 希尔排序2
+public static void sort2(int[] arr) {
+ int n = arr.length;
+ // 计算 increment sequence: 1, 4, 13, 40, 121, 364, 1093...
+ int h = 1;
+ while (h < n / 3) h = 3 * h + 1;
+
+ System.out.println(h);
+
+ while (h >= 1) {
+ // h-sort the array
+ for (int i = h; i < n; i++) {
+
+ // 对 arr[i], arr[i-h], arr[i-2*h], arr[i-3*h]... 使用插入排序
+ int e = arr[i];
+ int j = i;
+ for (; j >= h && e < arr[j - h]; j -= h)
+ arr[j] = arr[j - h];
+ arr[j] = e;
+ }
+
+ h /= 3;
+ }
+}
+```
+
+**算法分析**
+
+对于大规模的数组，插入排序很慢，因为它只能交换相邻的元素，每次只能将逆序数量减少 1。
+
+希尔排序的出现就是为了改进插入排序的这种局限性，它通过交换不相邻的元素，每次可以将逆序数量减少大于 1。
+
+希尔排序使用插入排序对间隔 h 的序列进行排序。通过不断减小 h，最后令 h=1，就可以使得整个数组是有序的。
+
+
+
+### 5. 归并排序（Merge Sort）
+
+归并排序的思想是将数组分成两部分，分别进行排序，然后归并起来。把长度为n的输入序列分成两个长度为n/2的子序列；对这两个子序列分别采用归并排序；将两个排序好的子序列合并成一个最终的排序序列。
+
+
+
+**代码实现**
+
+> 1.归并方法
+>
+> 归并方法将数组中两个已经排序的部分归并成一个。
+
+```java
+private static void sort(int[] arr) {
+ __MergeSort(arr, 0, arr.length - 1);
+}
+
+private static void __MergeSort(int[] arr, int l, int r) {
+ if (l >= r)
+ return;
+ int mid = (l + r) / 2;
+ __MergeSort(arr, l, mid);
+ __MergeSort(arr, mid + 1, r);
+ merge(arr, l, mid, r);
+}
+
+// 将arr[l...mid]和arr[mid+1...r]两部分进行归并
+private static void merge(int[] arr, int l, int mid, int r) {
+ int[] aux = Arrays.copyOfRange(arr, l, r + 1);
+
+ // 初始化，i指向左半部分的起始索引位置l；j指向右半部分起始索引位置mid+1
+ int i = l, j = mid + 1;
+ for (int k = l; k <= r; k++) {
+ if (i > mid) { // 如果左半部分元素已经全部处理完毕
+ arr[k] = aux[j - l];
+ j++;
+ } else if (j > r) { // 如果右半部分元素已经全部处理完毕
+ arr[k] = aux[i - l];
+ i++;
+ } else if (aux[i - l] < aux[j - l]) { // 左半部分所指元素 < 右半部分所指元素
+ arr[k] = aux[i - l];
+ i++;
+ } else { // 左半部分所指元素 >= 右半部分所指元素
+ arr[k] = aux[j - l];
+ j++;
+ }
+ }
+}
+```
+
+> 2.自底向上归并排序
+
+```java
+private static void sort(int[] arr) {
+ int N = arr.length;
+ int[] aux = new int[N];
+ for (int sz = 1; sz < N; sz += sz)
+ for (int i = 0; i + sz < N; i += sz + sz)
+ merge(arr, i, i + sz - 1, Math.min(i + sz + sz - 1, N - 1));
+}
+```
+
+
+
+### 6. 快速排序（Quick Sort）
+
+快速排序可以说是20世纪最伟大的算法之一了。相信都有所耳闻，它的速度也正如它的名字那样，是一个非常快的算法了。当然它也后期经过了不断的改进和优化，才被公认为是一个值得信任的非常优秀的算法。
+
+
+
+**代码实现**
+
+#### 1. 普通快速排序
+
+```java
+// 递归使用快速排序,对arr[l...r]的范围进行排序
+public static void QuickSort(int[] arr,int l,int r){
+ if(l>=r)
+ return;
+ int p = partition(arr,l,r);
+ QuickSort(arr,l,p-1);
+ QuickSort(arr,p+1,r);
+}
+
+// 将数组通过p分割成两部分
+// 对arr[l...r]部分进行partition操作
+// 返回p, 使得arr[l...p-1] < arr[p] ; arr[p+1...r] > arr[p]
+public static int partition(int[] arr, int l, int r) {
+ swap(arr, l, (int) (Math.random() % (r - l + 1)) + l); // 加入这一行变成随机快速排序
+
+ int v = arr[l];
+ int j = l;
+ for(int i = j +1;i<=r;i++){
+ if(arr[i] < v){
+ j++;
+ swap(arr,i,j);
+ }
+ }
+ swap(arr,l,j);
+ return j;
+}
+
+public static void swap(int[] arr,int i,int j) {
+ int temp = arr[i];
+ arr[i] = arr[j];
+ arr[j] = temp;
+}
+```
+
+快速排序是原地排序，不需要辅助数组，但是递归调用需要辅助栈。
+
+快速排序最好的情况下是每次都正好能将数组对半分，这样递归调用次数才是最少的。这种情况下比较次数为 CN=2CN/2+N，复杂度为 O(NlogN)。
+
+最坏的情况下，第一次从最小的元素切分，第二次从第二小的元素切分，如此这般。因此最坏的情况下需要比较 N2/2。为了防止数组最开始就是有序的，在进行快速排序时需要随机打乱数组。
+
+
+
+#### 2. 双路快速排序
+
+若果数组中含有大量重复的元素，则partition很可能把数组划分成两个及其不平衡的两部分，时间复杂度退化成O(n²)。这时候应该把小于v和大于v放在数组两端。
+
+
+
+```java
+// 双路快速排序的partition
+// 返回p, 使得arr[l...p-1] < arr[p] ; arr[p+1...r] > arr[p]
+private static int partition(int[] arr, int l, int r) {
+
+ // 随机在arr[l...r]的范围中, 选择一个数值作为标定点pivot
+ // swap(arr, l, (int) (Math.random() % (r - l + 1)) + l);
+
+ int v = arr[l];
+
+ // arr[l+1...i) <= v; arr(j...r] >= v
+ int i = l + 1, j = r;
+ while (true) {
+ // 注意这里的边界, arr[i].compareTo(v) < 0, 不能是arr[i].compareTo(v) <= 0
+ // 思考一下为什么?
+ while (i <= r && arr[i] < v)
+ i++;
+
+ // 注意这里的边界, arr[j].compareTo(v) > 0, 不能是arr[j].compareTo(v) >= 0
+ // 思考一下为什么?
+ while (j >= l + 1 && arr[j] > v)
+ j--;
+
+ // 对于上面的两个边界的设定, 有的同学在课程的问答区有很好的回答:)
+ // 大家可以参考: http://coding.imooc.com/learn/questiondetail/4920.html
+ if (i > j)
+ break;
+
+ swap(arr, i, j);
+ i++;
+ j--;
+ }
+
+ swap(arr, l, j);
+
+ return j;
+}
+
+// 递归使用快速排序,对arr[l...r]的范围进行排序
+private static void QuickSort2Ways(int[] arr, int l, int r) {
+ // 对于小规模数组, 使用插入排序
+ if (l >= r) return;
+ int p = partition(arr, l, r);
+ QuickSort2Ways(arr, l, p - 1);
+ QuickSort2Ways(arr, p + 1, r);
+}
+```
+
+#### 3. 三路快速排序
+
+数组分成三个部分，大于v 等于v 小于v
+
+在具有大量重复键值对的情况下使用三路快排
+
+
+
+
+
+```java
+// 递归使用快速排序,对arr[l...r]的范围进行排序
+private static void QuickSort3Ways(int[] arr, int l, int r){
+
+ // 随机在arr[l...r]的范围中, 选择一个数值作为标定点pivot
+ swap( arr, l, (int)(Math.random()*(r-l+1)) + l );
+
+ int v = arr[l];
+
+ int lt = l; // arr[l+1...lt] < v
+ int gt = r + 1; // arr[gt...r] > v
+ int i = l+1; // arr[lt+1...i) == v
+ while( i < gt ){
+ if( arr[i] < v){
+ swap( arr, i, lt+1);
+ i ++;
+ lt ++;
+ }
+ else if( arr[i] > v ){
+ swap( arr, i, gt-1);
+ gt --;
+ }
+ else{ // arr[i] == v
+ i ++;
+ }
+ }
+ swap( arr, l, lt );
+
+ QuickSort3Ways(arr, l, lt-1);
+ QuickSort3Ways(arr, gt, r);
+}
+```
+
+
+
+### 7. 堆排序（Heap Sort）
+
+#### 1. 堆
+
+堆的某个节点的值总是大于等于子节点的值，并且堆是一颗完全二叉树。
+
+堆可以用数组来表示，因为堆是完全二叉树，而完全二叉树很容易就存储在数组中。位置 k 的节点的父节点位置为 k/2，而它的两个子节点的位置分别为 2k 和 2k+1。这里不使用数组索引为 0 的位置，是为了更清晰地描述节点的位置关系。
+
+
+
+#### 2. 上浮和下沉
+
+在堆中，当一个节点比父节点大，那么需要交换这个两个节点。交换后还可能比它新的父节点大，因此需要不断地进行比较和交换操作，把这种操作称为**上浮（ShiftUp）**。
+
+
+
+```java
+private void shiftUp(int k){
+ while( k > 1 && data[k/2] < data[k])){
+ swap(k, k/2);
+ k /= 2;
+ }
+}
+```
+
+
+
+类似地，当一个节点比子节点来得小，也需要不断地向下进行比较和交换操作，把这种操作称为**下沉（Shift Down）**。一个节点如果有两个子节点，应当与两个子节点中最大那么节点进行交换。
+
+
+
+```java
+private void shiftDown(int k){
+ while( 2*k <= count ){ // 当前结点有左孩子
+ int j = 2*k; // 在此轮循环中,data[k]和data[j]交换位置
+ if( j+1 <= count && data[j+1] > data[j] )
+ j ++;
+ // data[j] 是 data[2*k]和data[2*k+1]中的最大值
+
+ if( data[k] >= data[j] )
+ break;
+ swap(k, j);
+ k = j;
+ }
+}
+```
+
+#### 3.插入元素
+
+将新元素放到数组末尾，然后上浮到合适的位置。
+
+```java
+// 向最大堆中插入一个新的元素 item
+public void insert(Item item){
+ assert count + 1 <= capacity;
+ data[count+1] = item;
+ count ++;
+ shiftUp(count);
+}
+```
+
+#### 4. 删除最大元素
+
+```java
+// 从最大堆中取出堆顶元素, 即堆中所存储的最大数据
+public Item extractMax(){
+ assert count > 0;
+ Item ret = data[1];
+
+ swap( 1 , count );
+ count --;
+ shiftDown(1);
+ return ret;
+}
+```
+
+#### 5. 堆排序
+
+由于堆可以很容易得到最大的元素并删除它，不断地进行这种操作可以得到一个递减序列。如果把最大元素和当前堆中数组的最后一个元素交换位置，并且不删除它，那么就可以得到一个从尾到头的递减序列，从正向来看就是一个递增序列。因此很容易使用堆来进行排序。并且堆排序是原地排序，不占用额外空间。
+
+```java
+// 不使用一个额外的最大堆, 直接在原数组上进行原地的堆排序
+public class HeapSort {
+
+ // 对整个arr数组使用HeapSort1排序
+ // HeapSort1, 将所有的元素依次添加到堆中, 在将所有元素从堆中依次取出来, 即完成了排序
+ // 无论是创建堆的过程, 还是从堆中依次取出元素的过程, 时间复杂度均为O(nlogn)
+ // 整个堆排序的整体时间复杂度为O(nlogn)
+ public static void sort1(Comparable[] arr){
+
+ int n = arr.length;
+ MaxHeap maxHeap = new MaxHeap(n);
+ for( int i = 0 ; i < n ; i ++ )
+ maxHeap.insert(arr[i]);
+
+ for( int i = n-1 ; i >= 0 ; i -- )
+ arr[i] = maxHeap.extractMax();
+ }
+
+
+ // 只通过shiftDown操作进行排序
+ public static void sort2(Comparable[] arr){
+ int n = arr.length;
+
+ // 注意，此时我们的堆是从0开始索引的
+ // 从(最后一个元素的索引-1)/2开始
+ // 最后一个元素的索引 = n-1
+ for( int i = (n-1-1)/2 ; i >= 0 ; i -- )
+ shiftDown2(arr, n, i);
+
+ for( int i = n-1; i > 0 ; i-- ){ // 这个的目的是让序列从小到大排序
+ swap( arr, 0, i);
+ shiftDown2(arr, i, 0);
+ }
+ }
+
+ // 交换堆中索引为i和j的两个元素
+ private static void swap(Object[] arr, int i, int j){
+ Object t = arr[i];
+ arr[i] = arr[j];
+ arr[j] = t;
+ }
+
+ // 原始的shiftDown过程
+ private static void shiftDown(Comparable[] arr, int n, int k){
+ while( 2*k+1 < n ){
+ int j = 2*k+1;
+ if( j+1 < n && arr[j+1].compareTo(arr[j]) > 0 )
+ j += 1;
+
+ if( arr[k].compareTo(arr[j]) >= 0 )break;
+
+ swap( arr, k, j);
+ k = j;
+ }
+ }
+
+ // 优化的shiftDown过程, 使用赋值的方式取代不断的swap,
+ // 该优化思想和我们之前对插入排序进行优化的思路是一致的
+ private static void shiftDown2(Comparable[] arr, int n, int k){
+
+ Comparable e = arr[k];
+ while( 2*k+1 < n ){
+ int j = 2*k+1;
+ if( j+1 < n && arr[j+1].compareTo(arr[j]) > 0 )
+ j += 1;
+
+ if( e.compareTo(arr[j]) >= 0 )
+ break;
+
+ arr[k] = arr[j];
+ k = j;
+ }
+
+ arr[k] = e;
+ }
+
+ // 测试 HeapSort
+ public static void main(String[] args) {
+ Integer[] arr = {10, 91, 8, 7, 6, 5, 4, 3, 2, 1};
+ HeapSort.sort2(arr);
+ PrintHelper.printArray(arr);
+ }
+}
+```
+
+#### 6. 堆排序的应用——Top K问题
+
+例如，有1亿个浮点数，如何找出其中最大的10000个？（B326）
+
+
+
+### 8. 计数排序
+
+https://www.cnblogs.com/freedom314/p/5847092.html
+
+
+
+### 9. 排序算法总结
+
+| | 平均时间复杂度 | 原地排序 | 额外空间 | 稳定排序 |
+| :------: | :------------: | :------: | :------: | :------: |
+| 插入排序 | O(n^2) | √ | O(1) | √ |
+| 归并排序 | O(nlogn) | × | O(n) | √ |
+| 快速排序 | O(nlogn) | √ | O(logn) | × |
+| 堆排序 | O(nlogn) | √ | O(1) | × |
+
+稳定排序：对于相等的元素，在排序后，原来靠前的元素依然靠前。相等元素的相对位置没有发生变化。
+
+```java
+// 可以通过⾃自定义⽐比较函数，让排序算法不不存在稳定性的问题。
+bool operator<(const Student& otherStudent){
+ return score != otherStudent.score ?
+ score > otherStudent.score :
+ name < otherStudent.name;
+}
+```
+
+
+
+
+
+
+
+
+
+
+
+## 二、二分查找法
+
+Leetcode 704.
+
+
+
+
+
+## 三、递归和回溯法
+
+- Leetcode 70.
+
+- Leetcode 17.
+
+
+
+## 四、分治的思想
+
+
+
+
+
+## 五、动态规划
+
+- 9-1 什么是动态规划 (20:27)
+
+- 9-2 第一个动态规划问题 Climbing Stairs (14:02)
+
+ - [70. 爬楼梯](https://leetcode-cn.com/problems/climbing-stairs/)
+
+ - 【作业】[120. 三角形最小路径和](https://leetcode-cn.com/problems/triangle/)
+
+ - 【作业】[64. 最小路径和](https://leetcode-cn.com/problems/minimum-path-sum/)
+
+- 9-3 发现重叠子问题 Integer Break (25:10)
+
+ - [343. 整数拆分](https://leetcode-cn.com/problems/integer-break/)
+
+ - 【作业】279
+
+ - 【作业】91
+
+ - 【作业】62
+
+ - 【作业】63
+
+- 9-4 状态的定义和状态转移 House Robber (27:19)
+
+ - [198. 打家劫舍](https://leetcode-cn.com/problems/house-robber/)
+
+ - 【作业】213
+
+ - 【作业】337
+
+ - 【作业】309
+
+- 9-5 0-1背包问题 (32:37)
+
+- 9-6 0-1背包问题的优化和变种 (20:18)
+
+- 9-7 面试中的0-1背包问题 Partition Equal Subset Sum (27:34)
+
+- 9-8 LIS问题 Longest Increasing Subsequence (25:12)
+
+ - [300. 最长递增子序列](https://leetcode-cn.com/problems/longest-increasing-subsequence/)
+
+ - 【作业】[376. 摆动序列](https://leetcode-cn.com/problems/wiggle-subsequence/)
+
+- 9-9 LCS，最短路，求动态规划的具体解以及更多 (21:00)
+ - [1143. 最长公共子序列](https://leetcode-cn.com/problems/longest-common-subsequence/)
+
+- 9-10 动态规划的经典问题
+
+- https://www.cxyzjd.com/article/qq_42874319/115740445
+
+-
+
+## 六、贪心算法 08/10
+
+- 10-1 贪心基础 Assign Cookies (12:12)
+
+ - [455. 分发饼干](https://leetcode-cn.com/problems/assign-cookies/)
+
+ - 【作业】[392. 判断子序列](https://leetcode-cn.com/problems/is-subsequence/)
+
+- 10-2 贪心算法与动态规划的关系 Non-overlapping Intervals (17:58)
+ - [435. 无重叠区间](https://leetcode-cn.com/problems/non-overlapping-intervals/)
+
+- 10-3 贪心选择性质的证明 (15:19)
+
+
+
+## 七、模式匹配
+
+- KMP
+
+- RK
+
+
+
+## 八、搜索算法（深搜，广搜等）
+
+
+
+## 九、并查集
diff --git a/notes/git-tutorial.md b/notes/git-tutorial.md
new file mode 100644
index 00000000..bcaa8517
--- /dev/null
+++ b/notes/git-tutorial.md
@@ -0,0 +1,18 @@
+# Git Tutorial
+
+这里 Git 学习指引，包含如下几个模块，将用最极简的语言带你进入 Git 版本控制的世界。
+
+| 部分 | 章节 | 概要 |
+| :--- | :----------------------------- | :--------------------------- |
+| Ⅰ | [Git 基础知识](Git.md) | 发展历史、核心概念、场景应用 |
+| Ⅱ | [Git 命令速查](Git命令速查.md) | 命令大全，方便随时查询 |
+| Ⅲ | [Git 工作流](Git工作流.md) | 协同开发工作流 |
+
+
+
+## 参考资料
+
+- 极客时间苏玲《玩转Git三剑客》
+- [Git 工作流程 - 阮一峰的网络日志](http://www.ruanyifeng.com/blog/2015/12/git-workflow.html)
+- [git使用 · lzy的Bbbblog](https://o0chivas0o.github.io/2018/12/21/git/)
+
diff --git "a/notes/\345\205\250\346\240\210\345\274\200\345\217\221\347\245\236\345\205\265\345\210\251\345\231\250.md" "b/notes/\345\205\250\346\240\210\345\274\200\345\217\221\347\245\236\345\205\265\345\210\251\345\231\250.md"
index 49d5ee5b..0e392c8c 100644
--- "a/notes/\345\205\250\346\240\210\345\274\200\345\217\221\347\245\236\345\205\265\345\210\251\345\231\250.md"
+++ "b/notes/\345\205\250\346\240\210\345\274\200\345\217\221\347\245\236\345\205\265\345\210\251\345\231\250.md"
@@ -86,6 +86,8 @@
- [亿图](http://www.edrawsoft.cn/download-edrawmax.php)：国产综合图形图表设计软件。类似 visio 的绘图工具（[完美破解版](http://www.zdfans.com/html/17131.html)）
- [ProcessOn](https://www.processon.com/)：支持流程图、思维导图、原型图、UML、网络拓扑图、组织结构图等
- [draw.io](https://www.draw.io/)：free online diagram software for making flowcharts, process diagrams, org charts, UML, ER and network diagrams
+- [StarUML](http://staruml.io/)：A sophisticated software modeler for agile and concise modeling（总之 UML 绘图神器）
+- logomakr：https://logomakr.com
@@ -146,8 +148,6 @@
-
-
## 四、全栈开发
### 数据库管理（以Mysql为例）
diff --git "a/notes/\345\210\206\345\270\203\345\274\217/Zookeeper.md" "b/notes/\345\210\206\345\270\203\345\274\217/Zookeeper.md"
new file mode 100644
index 00000000..985c4625
--- /dev/null
+++ "b/notes/\345\210\206\345\270\203\345\274\217/Zookeeper.md"
@@ -0,0 +1,352 @@
+# Zookeeper
+- [CAP定理](#CAP定理)
+- [Zookeeper概述](#zookeeper概述)
+ - [Zookeeper特点](#zookeeper特点)
+ - [Zookeeper使用场景](#zookeeper使用场景)
+ - [Zookeeper节点状态](#zookeeper节点状态)
+ - [Zookeeper数据类型](#zookeeper数据类型)
+ - [Zookeeper数据版本](#zookeeper数据版本)
+ - [Zookeeper Watcher](#Watcher)
+ - [Zookeeper Session](#Session)
+ - [Zookeeper ACL](#ACL)
+ - [Zookeeper ZAB](#ZAB)
+ - [ZAB 选主流程](#选主流程)
+ - [ZAB 数据同步](#数据同步)
+ - [ZAB 过半同意](#过半同意)
+- [Zookeeper运维](#Zookeeper运维)
+ - [Zookeeper集群搭建](#Zookeeper集群搭建)
+ - [Zookeeper集群监控](#Zookeeper集群监控)
+ - [常用Shell操作](#常用shell操作)
+ - [开源工具推荐](#开源工具推荐)
+
+## CAP定理
+
+在了解Zookeeper之前，首先需要了解在分布式系统（distributed system）中的基本定理：CAP定理
+定义：**CAP定理指的是在一个分布式系统中，Consistency（一致性）、 Availability（可用性）、Partition tolerance（分区容错性），三者不可兼得**。CAP定理的命名就是这三个指标的首字母。
+
+- **Partition tolerance** 指的是在分布式系统中，由于不同的服务器之间可能无法通讯，所以需要一定的容错机制，默认情况下认为 Partition tolerance总是成立。
+
+- **Consistency** 指的是在分布式系统中，不同的服务器上所存储的数据需要一致，可以理解成当服务器A执行操作数据的指令后，服务器B上也要应用同样的操作以保证其所提供的数据同A中的一致。
+- **Availability** 指的是分布式系统中，每当服务端收到客户端的请求，服务端都必须给出回应。
+
+为什么说这三者不能同时满足呢，其主要原因在于Consistency 和 Availability不可能同时成立。
+假如要保证分布式系统的高数据一致性，则服务端之间一定要在同步后才能开放给客户端进行新的读写操作。即通过加锁同步操作使其可以被看成是一个原子的操作，而在锁定期间，服务端是无法提供服务的，这样服务端是无法做到高可用的，也就违背了Availability。
+假如要保证分布式系统的高可用性，则服务端必须无时无刻给客户端提供服务。而服务端间数据同步的操作由于受到网络等因素的影响，无法实时的进行同步数据，假如服务器A上的数据进行了修改而尚未同步到服务器B上，所以此时服务器B所提供的数据就不是最新的，因而违反了Consistency 。
+
+
+
+## Zookeeper概述
+
+ZooKeeper是一个分布式的、开放源码的分布式协调服务，是Google的Chubby一个开源的实现，是Hadoop和Hbase的重要组件。它是一个为分布式应用提供一致性服务的软件，提供的功能包括：配置维护、域名服务、分布式同步、组服务等。由于Hadoop生态系统中很多项目都依赖于zookeeper，如Pig，Hive等， 似乎很像一个动物园管理员，于是取名为Zookeeper。
+Zookeeper官网地址为[http://zookeeper.apache.org/](http://zookeeper.apache.org/)。
+
+
+## Zookeeper特点
+
+- 顺序一致性 从同一个客户端发起的事务请求，将会严格按照其发起顺序被应用到zookeeper中
+- 原子性 所有事物请求的处理结果在整个集群中所有机器上的应用情况是一致的，要么整个集群中所有机器都成功应用了某一事务，要么都没有应用某一事务，不会出现集群中部分机器应用了事务，另一部分没有应用的情况。
+- 单一视图 无论客户端连接的是哪个zookeeper服务端，其获取的服务端数据模型都是一致的。
+- 可靠性 一旦服务端成功的应用了一个事务，并完成对客户端的响应，那么该事务所引起的服务端状态变更将会一直保留下来，直到有另一个事务又对其进行了改变。
+- 实时性 一旦服务端成功的应用了一个事物，那客户端立刻能看到变更后的状态
+
+
+## Zookeeper使用场景
+
+- 名字服务
+- 配置管理
+- 集群管理
+- 集群选举
+- 分布式锁
+- 队列管理
+- 消息订阅
+
+## Zookeeper节点状态
+
+- LOOKING：寻找Leader状态，处于该状态需要进入选举流程
+- LEADING：领导者状态，处于该状态的节点说明是角色已经是Leader
+- FOLLOWING：跟随者状态，表示Leader已经选举出来，当前节点角色是Follower
+- OBSERVER：观察者状态，表明当前节点角色是Observer，Observer节点不参与投票，只负责同步Leader状态
+
+## Zookeeper数据类型
+
+- Zookeeper的数据结构非常类似于文件系统。是由节点组成的树形结构。不同的是文件系统是由文件夹和文件来组成的树，而Zookeeper中是由Znode来组成的树。每一个Znode里都可以存放一段数据，Znode下还可以挂载零个或多个子Znode节点，从而组成一个树形结构。
+- 节点类型
+ - 持久化节点(PERSISTENT)：znode节点的数据不会丢失，除非是客户端主动delete
+ - 持久化顺序节点(PERSISTENT_SEQUENTIAL)：znode节点会根据当前已经存在的znode节点编号自动加 1
+ - 临时节点：临时节点(EPHEMERAL)：当session中断后会被删除
+ - 临时顺序节点(EPHEMERAL_SEQUENTIAL)：znode节点编号会自动加 1，当session中断后会被删除
+
+## Zookeeper数据版本
+
+Zookeeper的每个ZNode上都会存储数据，对应到每个ZNode，Zookeeper都会为其维护一个叫做Stat的数据结构，Stat中记录的内容如下：
+
+- cZxid: 节点创建时的zxid
+- ctime: 节点创建时间
+- mZxid: 最后一次更新的zxid
+- mtime: 最后一次更新的时间
+- pZxid: 子节点的最后版本
+- cversion: 子节点数据更新次数
+- dataVersion: 节点数据更新次数
+- aclVersion: acl的变更次数
+- ephemeralOwner: 如果znode是临时节点，则值为所有者的sessionId；如果不是临时节点，则为零
+- dataLength: 节点的数据长度
+- numChildren: 子节点个数
+
+
+## Watcher
+
+Watcher(事件监听器)是 Zookeeper提供的一种 发布/订阅的机制。Zookeeper允许用户在指定节点上注册一些 Watcher，并且在一些特定事件触发的时候，Zookeeper服务端会将事件通知给订阅的客户端。该机制是 Zookeeper实现分布式协调的重要特性。
+
+- watcher特点
+ - 轻量级：一个callback函数。
+ - 异步性：不会block正常的读写请求。
+ - 主动推送：Watch被触发时，由 Zookeeper 服务端主动将更新推送给客户端。
+ - 一次性：数据变化时，Watch 只会被触发一次。如果客户端想得到后续更新的通知，必须要在 Watch 被触发后重新注册一个 Watch。
+ - 仅通知：仅通知变更类型，不附带变更后的结果。
+ - 顺序性：如果多个更新触发了多个 Watch ，那 Watch 被触发的顺序与更新顺序一致
+- watcher使用注意事项。
+ - 由于watcher是一次性的，所以需要自己去实现永久watch
+ - 如果被watch的节点频繁更新，会出现“丢数据”的情况
+ - watcher数量过多会导致性能下降
+
+
+## Session
+
+zookeeper会为每个客户端分配一个session，类似于web服务器一样，用来标识客户端的身份。
+
+- Session作用
+ - 客户端标识
+ - 超时检查
+ - 请求的顺序执行
+ - 维护临时节点的生命周期
+ - watcher通知
+- Session状态
+ - CONNECTING
+ - CONNECTED
+ - RECONNECTING
+ - RECONNECTED
+ - CLOSED
+- Session属性
+ - sessionID：会话ID，全局唯一
+ - TimeOut：会话超时时间
+ - TickTime：下次会话超时时间点
+ - isClosing：会话是否已经被关闭
+- SessionID构造
+ - 高8位代表创建Session时所在的zk节点的id
+ - 中间40位代表zk节点当前角色在创建的时候的时间戳
+ - 低16位是一个计数器，初始值为0
+
+
+## ACL
+
+在Zookeeper中，node的ACL是没有继承关系的。ACL表现形式:scheme:id:permissions。
+
+- Scheme
+ - World：它下面只有一个id, 叫anyone。world:anyone代表任何人都有权
+ - Auth：通过user:password的形式认证，支持Kerberos
+ - Digest：使用user:password的形式认证
+ - Ip：通过IP的粒度来控制权限，支持网段
+ - Super：对应的id拥有超级权限，可以做任何事情
+- Permission
+ - CREATE(c): 创建权限，可以在在当前node下创建child node
+ - DELETE(d): 删除权限，可以删除当前的node
+ - READ(r): 读权限，可以获取当前node的数据，可以list当前node所有的child nodes
+ - WRITE(w): 写权限，可以向当前node写数据
+ - ADMIN(a): 管理权限，可以设置当前node的permission
+
+
+## ZAB
+
+ZAB 是 ZooKeeper Atomic Broadcast （ZooKeeper 原子广播协议）的缩写，它是特别为 ZooKeeper 设计的崩溃可恢复的原子消息广播算法。ZooKeeper 使用 Leader来接收并处理所有事务请求，并采用 ZAB 协议，将服务器数据的状态变更以事务 Proposal 的形式广播到所有的 Follower 服务器上去。这种主备模型架构保证了同一时刻集群中只有一个服务器广播服务器的状态变更，因此能够很好的保证事物的完整性和顺序性。
+Zab协议有两种模式，它们分别是恢复模式(recovery)和广播模式(broadcast)。当服务启动或者在leader崩溃后，Zab就进入了恢复模式，当leader被选举出来，且大多数follower完成了和leader的状态同步以后， 恢复模式就结束了，ZAB开始进入广播模式。
+
+
+### 选主流程
+
+当Leader崩溃或者Leader失去大多数的Follower时，Zookeeper处于恢复模式，在恢复模式下需要重新选举出一个新的Leader，让所有的 Server都恢复到一个正确的状态。Zookeeper的选举算法有两种：一种是基于basic paxos实现的，另外一种是基于fast paxos算法实现的。系统默认的选举算法为fast paxos。
+
+- Basic paxos：当前Server发起选举的线程,向所有Server发起询问,选举线程收到所有回复,计算zxid最大Server,并推荐此为Leader，若此提议获得n/2+1票通过（过半同意）,此为Leader，否则重复上述流程，直到Leader选出。
+
+- Fast paxos:某Server首先向所有Server提议自己要成为Leader，当其它Server收到提议以后，解决epoch和 zxid的冲突，并接受对方的提议，然后向对方发送接受提议完成的消息，重复这个流程，最后一定能选举出Leader。(即提议方解决其他所有epoch和 zxid的冲突,即为Leader)。
+
+
+### 数据同步
+当集群重新选举出Leader后，所有的Follower需要和Leader同步数据，确保集群数据的一致性。
+
+- 数据同步方式
+ - SNAP-全量同步
+ - 条件：peerLastZxidminCommittedLog
+ - 说明：证明follower上有些提议proposal并未在leader上提交，follower需要回滚到zxid为minCommittedLog对应的事务操作
+ - TRUNC+DIFF-回滚+增量同步
+ - 条件：minCommittedLog<=peerLastZxid<=maxCommittedLog
+ - 说明：leader a已经将事务truncA提交到本地事务日志中，但没有成功发起proposal协议进行投票就宕机了；然后集群中剔除原leader a重新选举出新leader b，又提交了若干新的提议proposal，然后原leader a重新服务又加入到集群中说明：此时a,b都有一些对方未提交的事务，若b是leader, a需要先回滚truncA然后增量同步新leader b上的数据。
+
+
+### 过半同意
+当数据同步完成后，集群开始从恢复模式进入广播模式，开始接受客户端的事物请求。
+当只有Leader或少数机器批准执行某个任务时，则极端情况下Leader和这些少量机器挂掉，则无法保证新Leader知道之前已经批准该任务，这样就违反了数据可靠性。所以Leader在批准一个任务之前应该保证集群里大部分的机器知道这个提案，这样即使Leader挂掉，选举出来的新Leader也会从其他Follower处获取这个提案。而如果Leader要求所有Follower都同意才执行提案也不行，此时若有一个机器挂掉，Leader就无法继续工作，这样的话整个集群相当于单节点，无法保证可靠性。
+
+## Zookeeper集群搭建
+
+- 1.安装jdk，并且配置jdk的环境变量
+
+- 2.去官网下载zookeeper的安装包，上传到linux集群环境下
+
+- [微服务简介](#微服务简介)
+ - [微服务四大问题](#微服务四大问题)
+ - [简介](#简介)
+ - [1. 构建单体应用模型](#1-构建单体应用模型)
+ - [2. 走向单体地狱](#2-走向单体地狱)
+ - [3. 微服务-解决复杂问题](#3-微服务-解决复杂问题)
+ - [4. 微服务的优点](#4-微服务的优点)
+ - [5. 微服务的缺点](#5-微服务的缺点)
+ - [6. 总结](#6-总结)
+
+
+
+
# 微服务简介
> 本文参考：[《微服务：从设计到部署》](https://github.com/DocsHome/microservices)
+## 微服务四大问题
+
+> 高可用、高并发、高性能，最大的问题：网络是不可靠的
+
+1. 客户端如何访问这么多的服务？
+ - API 网关
+
+2. 服务于服务之间如何通信？
+ - 同步通信：
+ - HTTP（Apache Http Client）
+ - RPC（Dubbo 只支持 Java，Apache Thrift，gRPC）
+ - 异步通信：
+ - 消息队列
+ - Kafka
+ - RabbitMQ
+ - RocketMQ
+3. 这么多服务，如何管理？
+ - 服务治理
+ - 服务注册与发现
+ - 基于客户端的服务注册与发现（Apache Zookeeper）
+ - 基于服务端的服务注册与发现（Netflix Eureka）
+4. 服务挂了，怎么办？
+
+ - 重试机制
+ - 服务熔断
+ - 服务降级
+ - 服务限流
+
+
+
+## 简介
如今微服务倍受关注：文章、博客、社交媒体讨论和会议演讲。微服务正在迅速朝着[加德纳技术成熟度曲线（Gartner Hype cycle）](http://www.gartner.com/technology/research/methodologies/hype-cycle.jsp)的高峰前进。与此同时，也有持怀疑态度的软件社区人员认为微服务没什么新鲜可言。反对者声称它的思想只是面向服务架构（SOA）的重塑。然而，无论是炒作还是怀疑，不可否认，[微服务架构模式](http://microservices.io/patterns/microservices.html)具有非常明显的优势 — 特别是在实施敏捷开发和复杂的企业应用交付方面。
@@ -68,7 +114,7 @@
使用 Docker 部署 Trip Management 服务：
-
+
在运行时，Trip Management 服务由多个服务实例组成，每个服务实例是一个 Docker容器。为了实现高可用，容器是在多个云虚拟机上运行的。服务实例的之前是一个类似 NGINX 的负载均衡器，用于跨实例分发请求。负载均衡器也可以处理其他问题，如缓存、访问控制、API 度量和监控。
diff --git "a/notes/\346\212\200\346\234\257\344\272\244\346\265\201\347\276\244.md" "b/notes/\346\212\200\346\234\257\344\272\244\346\265\201\347\276\244.md"
index 48ad00fe..441f6716 100644
--- "a/notes/\346\212\200\346\234\257\344\272\244\346\265\201\347\276\244.md"
+++ "b/notes/\346\212\200\346\234\257\344\272\244\346\265\201\347\276\244.md"
@@ -1,6 +1,20 @@
▲ [GO HOME](https://github.com/frank-lam/2019_campus_apply)
-# 技术交流群
+# 技术交流互动
+
+
+
+## 1. 微信交流群
+
+由于微信群二维码只有七天的有效期，大家可加我的微信（**frank_lin5**），拉你进群。
+
+这里没有广告，只有纯粹的技术问题分享，不定期的干货和学习资源分享
+
+
+
+
+
+## 2. QQ 交流群
技术交流、租房交流、健身交流、恋爱交流哈哈哈。
@@ -12,4 +26,10 @@
QQ 技术交流群：862619503
-
\ No newline at end of file
+
+
+
+
+## 3. 微信订阅号
+
+
\ No newline at end of file
diff --git "a/notes/\346\214\201\347\273\255\351\233\206\346\210\220.md" "b/notes/\346\214\201\347\273\255\351\233\206\346\210\220.md"
new file mode 100644
index 00000000..adb1b9c3
--- /dev/null
+++ "b/notes/\346\214\201\347\273\255\351\233\206\346\210\220.md"
@@ -0,0 +1,6 @@
+
+
+Krishna Venkata's Blog
+https://kvenkata986.github.io/
+
+
\ No newline at end of file
diff --git "a/notes/\346\225\260\346\215\256\347\273\223\346\236\204\344\270\216\347\256\227\346\263\225.md" "b/notes/\346\225\260\346\215\256\347\273\223\346\236\204\344\270\216\347\256\227\346\263\225.md"
index e770d089..74a71393 100644
--- "a/notes/\346\225\260\346\215\256\347\273\223\346\236\204\344\270\216\347\256\227\346\263\225.md"
+++ "b/notes/\346\225\260\346\215\256\347\273\223\346\236\204\344\270\216\347\256\227\346\263\225.md"
@@ -1,73 +1,6 @@
-
-
-- [前言](#前言)
-- [第一部分：数据结构](#第一部分数据结构)
- - [一、线性表](#一线性表)
- - [二、栈和队列](#二栈和队列)
- - [三、树和二叉树](#三树和二叉树)
- - [1. 红黑树](#1-红黑树)
- - [2. 二叉树](#2-二叉树)
- - [二分查找法](#二分查找法)
- - [二叉树遍历](#二叉树遍历)
- - [3. 二分搜索树](#3-二分搜索树)
- - [深度优先遍历（前序、中序、后序遍历）](#深度优先遍历前序中序后序遍历)
- - [广度优先遍历（层序遍历）](#广度优先遍历层序遍历)
- - [4. AVL树](#4-avl树)
- - [5. B和B+](#5-b和b)
- - [四、字符串和数组](#四字符串和数组)
-- [第二部分：算法思想](#第二部分算法思想)
- - [一、排序](#一排序)
- - [1. 选择排序（Selection Sort）](#1-选择排序selection-sort)
- - [2. 插入排序（Insertion Sort）](#2-插入排序insertion-sort)
- - [3. 冒泡排序（Bubble Sort）](#3-冒泡排序bubble-sort)
- - [4. 希尔排序（Shell Sort）](#4-希尔排序shell-sort)
- - [5. 归并排序（Merge Sort）](#5-归并排序merge-sort)
- - [6. 快速排序（Quick Sort）](#6-快速排序quick-sort)
- - [1. 普通快速排序](#1-普通快速排序)
- - [2. 双路快速排序](#2-双路快速排序)
- - [3. 三路快速排序](#3-三路快速排序)
- - [7. 堆排序（Heap Sort）](#7-堆排序heap-sort)
- - [1. 堆](#1-堆)
- - [2. 上浮和下沉](#2-上浮和下沉)
- - [3.插入元素](#3插入元素)
- - [4. 删除最大元素](#4-删除最大元素)
- - [5. 堆排序](#5-堆排序)
- - [6. 堆排序的应用——Top K问题](#6-堆排序的应用top-k问题)
- - [8. 计数排序和流排序](#8-计数排序和流排序)
- - [9. 排序算法总结](#9-排序算法总结)
- - [二、递归和回溯法](#二递归和回溯法)
- - [1. 例题](#1-例题)
- - [2. 排列问题](#2-排列问题)
- - [3. 组合问题](#3-组合问题)
- - [4. 回溯法的剪枝](#4-回溯法的剪枝)
- - [5. 二维平面回溯法](#5-二维平面回溯法)
- - [6. floodfill算法](#6-floodfill算法)
- - [三、动态规划](#三动态规划)
- - [1. 斐波那契数列](#1-斐波那契数列)
- - [1.1 递归方式（自顶向下）](#11-递归方式自顶向下)
- - [1.2 记忆化搜索（自底向上）](#12-记忆化搜索自底向上)
- - [1.3 动态规划](#13-动态规划)
- - [2. 背包问题](#2-背包问题)
- - [（1）记忆化搜索](#1记忆化搜索)
- - [（2）动态规划](#2动态规划)
- - [（3）动态规划优化思路1](#3动态规划优化思路1)
- - [（4）动态规划优化思路2](#4动态规划优化思路2)
- - [（5）背包问题更多变种](#5背包问题更多变种)
- - [3. 最长上升子序列](#3-最长上升子序列)
- - [4. 最长公共子序列](#4-最长公共子序列)
- - [四、贪心算法](#四贪心算法)
- - [1. assign-cookies](#1-assign-cookies)
-- [第三部分：面试指南](#第三部分面试指南)
- - [1. 判单链表是否对称](#1-判单链表是否对称)
- - [2. 合并两个有序数组成一个有序数组](#2-合并两个有序数组成一个有序数组)
- - [3. 求二叉树中值为x的结点的层号](#3-求二叉树中值为x的结点的层号)
- - [阿里面经OneNote](#阿里面经onenote)
-- [第四部分：参考资料](#第四部分参考资料)
-
-
# 前言
-本文将系统总结算法面试和经典数据结构相关知识点，在这里分成 【数据结构】 和 【算法】 两部分展开。这里将展示主要的核心知识点，关于代码面试的Leetcode习题请转向代码仓库：[Interview-code](https://github.com/frank-lam/interview_code)
+本文将系统总结算法面试和经典数据结构相关知识点，在这里分成 【数据结构】 和 【算法】 两部分展开。这里将展示主要的核心知识点，关于代码面试的 Leetcode 习题请转向代码仓库：[Interview-code](https://github.com/frank-lam/interview_code)
@@ -94,6 +27,8 @@
- 数组
- 链表
+
+
## 二、栈和队列
@@ -132,12 +67,158 @@ https://github.com/CarpenterLee/JCFInternals/blob/049c84bb65a3114ba4b8355d83c490
#### 二分查找法
-#### 二叉树遍历
+在有序表中，通过不断的二分判断mid与目标是否一致，并缩小目标所在区间。
+
+**代码实现**
+
+```java
+// 非递归实现
+private static int search(int[] data, int l, int r, int target) {
+ int mid;
+ while(l < r) {
+ mid = (l + r) / 2;
+ if(data[mid] == target) {
+ return mid;
+ } else if(data[mid] < target) {
+ l = mid + 1;
+ } else {
+ r = mid;
+ }
+ }
+ return -1;
+}
+// 递归实现
+private static int searchDfs(int[] data, int l, int r, int target) {
+ if(l >= r) {
+ return -1;
+ }
+ int mid = (l + r) / 2;
+ if(target == data[mid]) {
+ return mid;
+ } else if(target > data[mid]) {
+ return searchDfs(data, mid + 1, r, target);
+ } else {
+ return searchDfs(data, l, mid, target);
+ }
+}
+```
+
-### 4.. 二分搜索树
+
+### 4. 二叉树遍历
#### 深度优先遍历（前序、中序、后序遍历）
+```C++
+/**
+ * 前序遍历 非递归实现
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ * int val;
+ * TreeNode *left;
+ * TreeNode *right;
+ * TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+ * };
+ */
+class Solution {
+public:
+ vector preorderTraversal(TreeNode* root) {
+ vector ans;
+ TreeNode* node = root;
+ stack s;
+ map M;
+ if(node != NULL) {
+ s.push(node);
+ while (!s.empty()) {
+ node = s.top();
+ if (!M[node]) {
+ ans.push_back(node->val);
+ M[node] = true;
+ }
+ if (node->left != NULL) {
+ s.push(node->left);
+ node->left = NULL;
+ } else if (node->right != NULL) {
+ s.push(node->right);
+ node->right = NULL;
+ } else {
+ s.pop();
+ }
+ }
+ }
+ return ans;
+ }
+};
+```
+
+```c++
+/**
+ * 中序遍历
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ * int val;
+ * TreeNode *left;
+ * TreeNode *right;
+ * TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+ * };
+ */
+class Solution {
+public:
+ vector inorderTraversal(TreeNode* root) {
+ vector ans;
+ if(root != NULL) {
+ traversal(root, ans);
+ }
+ return ans;
+ }
+
+ void traversal(TreeNode* node, vector &ans) {
+ if(node->left != NULL) {
+ traversal(node->left, ans);
+ }
+ ans.push_back(node->val);
+ if(node->right != NULL) {
+ traversal(node->right, ans);
+ }
+ }
+};
+```
+
+
+
+```c++
+/**
+ * 后序遍历
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ * int val;
+ * TreeNode *left;
+ * TreeNode *right;
+ * TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+ * };
+ */
+class Solution {
+public:
+ vector postorderTraversal(TreeNode* root) {
+ vector ans;
+ if(root != NULL) {
+ traversal(root, ans);
+ }
+ return ans;
+ }
+
+ void traversal(TreeNode* node, vector &ans) {
+ if(node->left != NULL) {
+ traversal(node->left, ans);
+ }
+ if(node->right != NULL) {
+ traversal(node->right, ans);
+ }
+ ans.push_back(node->val);
+ }
+};
+```
+
#### 广度优先遍历（层序遍历）
### 5. AVL树
@@ -154,6 +235,14 @@ https://github.com/CarpenterLee/JCFInternals/blob/049c84bb65a3114ba4b8355d83c490
+## 五、图结构
+
+### 邻接矩阵
+
+### 邻接表
+
+
+
# 第二部分：算法思想
## 一、排序
@@ -205,13 +294,15 @@ private static void swap(int[] arr, int i, int j) {
```java
public static void sort(int[] arr) {
- for (int i = 0; i < arr.length - 1; i++) {
- for (int j = i + 1; j > 0; j--) {
- if (arr[j] < arr[j - 1])
- swap(arr, j, j - 1); // 大量的交换会消耗时间
- else
- break;
+ for (int i = 0; i < arr.length; i++) {
+ // 选择 arr[i...n) 中的最小值
+ int minIndex = i;
+ for (int j = i + 1; j < arr.length; j++) {
+ if (arr[minIndex] > arr[j]) {
+ minIndex = j;
+ }
}
+ swap(arr, i, minIndex);
}
}
@@ -239,7 +330,7 @@ private static void swap(int[] arr, int i, int j) {
**算法分析**
-插入排序在实现上，通常采用in-place排序（即只需用到O(1)的额外空间的排序），因而在从后向前扫描过程中，需要反复把已排序元素逐步向后挪位，为最新元素提供插入空间。
+插入排序在实现上，通常采用 in-place 排序（即只需用到 O(1) 的额外空间的排序），因而在从后向前扫描过程中，需要反复把已排序元素逐步向后挪位，为最新元素提供插入空间。
@@ -1530,7 +1621,6 @@ void level_in_x(BinTree BT,char x,int level)
# 第四部分：参考资料
- [数据结构与算法系列 目录 - 如果天空不死 - 博客园](http://www.cnblogs.com/skywang12345/p/3603935.html)
-- [Interview-Notebook/算法.md at master · CyC2018/Interview-Notebook](https://github.com/CyC2018/Interview-Notebook/blob/master/notes/%E7%AE%97%E6%B3%95.md#%E9%80%89%E6%8B%A9%E6%8E%92%E5%BA%8F)
- [十大经典排序算法](https://www.cnblogs.com/onepixel/articles/7674659.html)
- [VisuAlgo - visualising data structures and algorithms through animation](https://visualgo.net/en)
- [Data Structure Visualization](https://www.cs.usfca.edu/~galles/visualization/Algorithms.html)
@@ -1538,4 +1628,3 @@ void level_in_x(BinTree BT,char x,int level)
-
diff --git "a/notes/\346\255\243\345\210\231\350\241\250\350\276\276\345\274\217.md" "b/notes/\346\255\243\345\210\231\350\241\250\350\276\276\345\274\217.md"
index 02d314c4..0caef439 100644
--- "a/notes/\346\255\243\345\210\231\350\241\250\350\276\276\345\274\217.md"
+++ "b/notes/\346\255\243\345\210\231\350\241\250\350\276\276\345\274\217.md"
@@ -49,4 +49,13 @@
| *? | *的懒惰模式 | yo*? | y | yo |
| {n} | 重复n次 | yo{2} | yoo | yooo |
| {n,m} | 重复n到m次 | yo{1, 3} | yo,yooo | yoooo |
-| {n,} | 重复至少n次 | yo{2,} | yoo, yooo | yo |
\ No newline at end of file
+| {n,} | 重复至少n次 | yo{2,} | yoo, yooo | yo |
+
+# Cheat Sheet
+
+[](https://si9ma.github.io/cool-cheatsheet/pdf/regexr.pdf)
+
+# 正则在线验证
+
+- [RegExr: Learn, Build, & Test RegEx](https://regexr.com/)
+- [Online regex tester, debugger with highlighting for PHP, PCRE, Python, Golang and JavaScript](https://regex101.com/)
diff --git "a/notes/\350\256\241\347\256\227\346\234\272\347\275\221\347\273\234.md" "b/notes/\350\256\241\347\256\227\346\234\272\347\275\221\347\273\234.md"
index 5b7c21a5..19d07edc 100644
--- "a/notes/\350\256\241\347\256\227\346\234\272\347\275\221\347\273\234.md"
+++ "b/notes/\350\256\241\347\256\227\346\234\272\347\275\221\347\273\234.md"
@@ -115,15 +115,6 @@
本文将总结后台开发中的核心网络知识。主要围绕网络层、传输层、应用层，核心为 TCP 和 HTTP 两部分。
-
-
-参考书籍：
-
-- 《计算机网络原理 创新教程》（韩立刚主编）
-- 《自顶向下计算机网络》（第4版）
-
-
-
# 第一部分：传输层
## 1. 说一下OSI七层模型 TCP/IP四层模型 五层协议
@@ -1336,7 +1327,7 @@ HTTP 1.1请求的大小变得越来越大，有时甚至会大于TCP窗口的初
- [一文读懂 HTTP/2 特性](https://zhuanlan.zhihu.com/p/26559480)
- [【体验http1.1和http2的性能对比动画】HTTP/2: the Future of the Internet | Akamai](HTTP/2: the Future of the Internet | Akamai)
-
+
@@ -1523,10 +1514,9 @@ IP 地址：192.168.1.199 **‐＞11000000.10101000.00000001**.11000111
-
-
-
-
# 附录：参考资料
-[OSI 七层参考模型-极客学院（4课时，47分钟）](http://www.jikexueyuan.com/course/1400.html)
\ No newline at end of file
+- [OSI 七层参考模型-极客学院（4课时，47分钟）](http://www.jikexueyuan.com/course/1400.html)
+
+- 《计算机网络原理 创新教程》（韩立刚主编）
+- 《自顶向下计算机网络》（第4版）
\ No newline at end of file
diff --git a/others/emoji.md b/others/emoji.md
index 0e3149f6..43af5d6a 100644
--- a/others/emoji.md
+++ b/others/emoji.md
@@ -34,4 +34,5 @@
| 交通 | 🚂🚃🚄🚅🚆🚇🚈🚉🚊🚝🚞🚋🚌🚍🚎🚏🚐🚑🚒🚓🚔🚕🚖🚗🚘🚚🚛🚜🚲⛽🚨🚥🚦🚧⚓⛵🚣🚤🚢✈💺🚁🚟🚠🚡🚀 |
| 建筑 | 🏠🏡🏢🏣🏤🏥🏦🏨🏩🏪🏫🏬🏭🏯🏰💒🗼🗽⛪🌆🌇🌉 |
| 办公 | 📱📲☎📞📟📠🔋🔌💻💽💾💿📀🎥📺📷📹📼🔍🔎🔬🔭📡📔📕📖📗📘📙📚📓📃📜📄📰📑🔖💳✉📧📨📩📤📥📦📫📪📬📭📮✏✒📝📁📂📅📆📇📈📉📊📋📌📍📎📏📐✂🔒🔓🔏🔐🔑 |
-| 箭头 | ⬆↗➡↘⬇↙⬅↖↕↔↩↪⤴⤵🔃🔄🔙🔚🔛🔜🔝 |
\ No newline at end of file
+| 箭头 | ⬆↗➡↘⬇↙⬅↖↕↔↩↪⤴⤵🔃🔄🔙🔚🔛🔜🔝 |
+| 数字 | 0️⃣1️⃣2️⃣3️⃣4️⃣5️⃣6️⃣7️⃣8️⃣9️⃣🔟 |
\ No newline at end of file
diff --git "a/others/reference/\345\217\202\350\200\203\350\265\204\346\226\231.md" "b/others/reference/\345\217\202\350\200\203\350\265\204\346\226\231.md"
index e9adb9da..ca5c701e 100644
--- "a/others/reference/\345\217\202\350\200\203\350\265\204\346\226\231.md"
+++ "b/others/reference/\345\217\202\350\200\203\350\265\204\346\226\231.md"
@@ -27,4 +27,7 @@
[Snailclimb/Java_Guide: Java面试通关手册（Java学习指南）](https://github.com/Snailclimb/Java_Guide) `star：94`
Introduction · 笔试面试知识整理
-https://hit-alibaba.github.io/interview/index.html
\ No newline at end of file
+https://hit-alibaba.github.io/interview/index.html
+
+[justjavac/free-programming-books-zh_CN: 免费的计算机编程类中文书籍，欢迎投稿](https://github.com/justjavac/free-programming-books-zh_CN)
+
| | 
- 感谢以下伙伴们对于本仓库的贡献，如想加入本开源项目，请联系笔者。
-
- 
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+## Stargazers over time
+
-### License
- 本作品采用 [知识共享署名-非商业性使用-相同方式共享 4.0 国际许可协议](https://creativecommons.org/licenses/by-nc-sa/4.0/) 进行许可。使用者可以对本创作进行转载、节选、混编、二次创作，但不得运用于商业目的，且使用时须进行署名，采用本创作的内容必须同样采用本协议进行授权。
- 
+## License
+
+
-
+
