diff --git "a/AdavancedPart/1.\347\203\255\344\277\256\345\244\215\345\256\236\347\216\260(\344\270\200).md" "b/AdavancedPart/1.\347\203\255\344\277\256\345\244\215\345\256\236\347\216\260(\344\270\200).md"
index bf052c89..1abe582f 100644
--- "a/AdavancedPart/1.\347\203\255\344\277\256\345\244\215\345\256\236\347\216\260(\344\270\200).md"
+++ "b/AdavancedPart/1.\347\203\255\344\277\256\345\244\215\345\256\236\347\216\260(\344\270\200).md"
@@ -18,7 +18,7 @@
 在一般情况下，应用程序不需要创建`ClassLoader`对象，而是使用当前环境已经存在的`ClassLoader`。因为`Java`的`Runtime`环境在初始化时，其内部会创建一个`ClassLoader`对象用于加载`Runtime`所需的各种`Java`类。    
 每个`ClassLoader`必须有一个父类，在装载`Class`文件时，子`ClassLoader`会先请求父`ClassLoader`加载该`Class`文件，只有当其父`ClassLoader`找不到该`Class`文件时，子`ClassLoader`才会继续装载该类，这是一种安全机制。    
 
-对于`Android`的应用程序，本质上虽然也是用`Java`开发，并且使用标准的`Java`编译器编译出`Class`文件，但最终的`APK`文件中包含的却是`dex`类型的文件。`dex`文件是将所需的所有`Class`文件重新打包，打包的规则不是简单的压缩，而是完全对`Class`文件内部的各种函数表、变量表等进行优化，并产生一个新的文件，这就是`dex`文件。由于`dex`文件是一种经过优化的`Class`文件，因此要加载这样特殊的`Class`文件就需要特殊的类装载器，这就是`DexClassLoader`，`Android SDK`中提供的D`exClassLoader`类就是出于这个目的。
+对于`Android`的应用程序，本质上虽然也是用`Java`开发，并且使用标准的`Java`编译器编译出`Class`文件，但最终的`APK`文件中包含的却是`dex`类型的文件。`dex`文件是将所需的所有`Class`文件重新打包，打包的规则不是简单的压缩，而是完全对`Class`文件内部的各种函数表、变量表等进行优化，并产生一个新的文件，这就是`dex`文件。由于`dex`文件是一种经过优化的`Class`文件，因此要加载这样特殊的`Class`文件就需要特殊的类装载器，这就是`DexClassLoader`，`Android SDK`中提供的`DexClassLoader`类就是出于这个目的。
 
 
 总体来说，`Android` 默认主要有三个`ClassLoader`:   
@@ -75,7 +75,7 @@ public class DexClassLoader extends BaseDexClassLoader {
 }
 ```
 注释说的太明白了，这里就不翻译了，但是我们并没有找到加载的代码，去它的父类中查找，
-因为家在都是从`loadClass()`方法中，所以我们去`ClassLoader`类中看一下`loadClass()`方法:   
+因为加载都是从`loadClass()`方法中，所以我们去`ClassLoader`类中看一下`loadClass()`方法:   
 ```java
 /**
      * Loads the class with the specified name. Invoking this method is
@@ -128,7 +128,7 @@ public class DexClassLoader extends BaseDexClassLoader {
         if (clazz == null) {
             ClassNotFoundException suppressed = null;
             try {
-            	// 先检查父ClassLoader是否已经家在过该类
+            	// 先检查父ClassLoader是否已经加载过该类
                 clazz = parent.loadClass(className, false);
             } catch (ClassNotFoundException e) {
                 suppressed = e;
diff --git a/AdavancedPart/AOP.md b/AdavancedPart/AOP.md
index 3bcc633b..c6e0916a 100644
--- a/AdavancedPart/AOP.md
+++ b/AdavancedPart/AOP.md
@@ -11,4 +11,131 @@ AOP(Aspect Oriented Programing),面向切面编程。
 而AOP，就是将各个模块中的通用逻辑抽离出来。
 我们将这些逻辑视为Aspect(切面)，然后动态地把代码插入到类的指定方法、指定位置中。 
 
+一句话概括: 在运行时，动态的将代码切入到类的指定方法、指定位置上的编程思想就是面相切面的编程。 
+
+
+一般而言，我们管切入到指定类指定方法的代码片段称为切面，而切入到哪些类、哪些方法则叫切入点。有了AOP，我们就可以把几个类共有的代码，抽取到一个切片中，等到需要时再切入对象中去，从而改变其原有的行为。
+
+
+### AOP的实现方式
+
+#### 静态AOP
+
+在编译器，切面直接以字节码的形式编译到目标字节码文件中。
+
+1. AspectJ      
+AspectJ属于静态AOP，它是在编译时进行增强，会在编译时期将AOP逻辑织入到代码中。
+
+由于是在编译器织入，所以它的优点是不影响运行时性能，缺点是不够灵活。
+
+2. AbstractProcessor     
+自定义一个AbstractProcessor，在编译期去解析编译的类，并且根据需求生成一个实现了特定接口的子类(代理类)
+
+#### 动态AOP
+1. JDK动态代理    
+通过实现InvocationHandler接口，可以实现对一个类的动态代理，通过动态代理可以生成代理类，从而在代理类方法中，在执行被代理类方法前后，添加自己的实现内容，从而实现AOP。
+
+2. 动态字节码生成    
+在运行期，目标类加载后，动态构建字节码文件生成目标类的子类，将切面逻辑加入到子类中，没有接口也可以织入，但扩展类的实例方法为final时，则无法进行织入。比如Cglib
+
+CGLIB是一个功能强大，高性能的代码生成包。它为没有实现接口的类提供代理，为JDK的动态代理提供了很好的补充。通常可以使用Java的动态代理创建代理，但当要代理的类没有实现接口或者为了更好的性能，CGLIB是一个好的选择。
+
+3. 自定义类加载器    
+在运行期，目标加载前，将切面逻辑加到目标字节码里。如：Javassist
+
+Javassist是可以动态编辑Java字节码的类库。它可以在Java程序运行时定义一个新的类，并加载到JVM中；还可以在JVM加载时修改一个类文件。
+
+4. ASM    
+ASM可以在编译期直接修改编译出的字节码文件，也可以像Javassit一样，在运行期，类文件加载前，去修改字节码。
+
+
+
+### AOP核心概念
+
+###### 1.JoinPoint(连接点)
+
+程序执行过程中可以被“插入”的点。例如:   
+
+- 方法被调用时
+- 方法执行时
+- 构造函数被调用时
+- 字段被读取/赋值时
+- 异常抛出时
+
+
+###### 2.PointCut(切点)
+
+对JoinPoint的筛选规则，告诉AOP“我要在哪些点下手”。    
+
+例如: 所有Activity的onCreate方法就是一个切点。 
+
+###### 3. Advice(通知/增强)    
+
+在切点处要执行的代码。分5种:    
+
+- @Before: 切点执行前
+- @After: 切点执行后(无论成功失败)
+- @AfterReturning: 切点正常返回后
+- @AfterThrowing: 切点抛出异常后
+- @Around: 包裹切点(最强大，可控制是否执行原方法)
+
+###### 4. Aspect(切面)
+
+切点 + 通知 = 切面     
+
+一个Java类用@Aspect标记后就是切面。   
+
+##### 5. Weaving(织入)   
+
+把切面代码插入到目标代码中的过程。 织入时机有三种:    
+
+- 编译期织入(AspectJ主流方式)
+- 类加载期织入
+- 运行期织入(JDK/CGLIB动态代理，Spring用的多)
+
+###### 6. Target(目标对象)
+
+被切面影响的对象
+
+
+### AOP在Android的实现原理
+
+###### Java/Spring的AOP vs Android的AOP
+
+Spring主要用运行时动态代理(JDK Porxy/ CGLIB)，但Android由于:   
+
+- ART/Dalvik虚拟机限制 
+- 性能要求高，运行时反射代价大
+- 类加载机制不同
+
+所以Android几乎都用AspectJ编译期自己码织入。 
+
+###### 编译期织入原理     
+
+
+```
+  ┌─────────────┐    javac    ┌─────────────┐   ajc(AspectJ)   ┌──────────────┐
+  │   .java     │ ──────────> │   .class    │ ──────────────> │ 织入后.class │
+  └─────────────┘             └─────────────┘                  └──────────────┘
+                                    ↑
+                              ┌─────────────┐
+                              │ Aspect.java │
+                              └─────────────┘
+```
+
+ajc(AspcetJ Compiler)会:    
+
+1. 扫描所有.class,找匹配切点的位置
+2. 按通知类型，在该位置直接修改字节码插入代码   
+3. 输出新的.class
+
+这意味着： AOP的开销在编译期，运行期几乎无额外开销(仅多几行字节码)。   
+
+
+
+
+
+
+
+
 
diff --git a/AdavancedPart/ARouter.md b/AdavancedPart/ARouter.md
new file mode 100644
index 00000000..f9d9cc9f
--- /dev/null
+++ b/AdavancedPart/ARouter.md
@@ -0,0 +1,71 @@
+ARouter
+---
+
+
+[ARouter](https://github.com/alibaba/ARouter)
+一个用于帮助 Android App 进行组件化改造的框架 —— 支持模块间的路由、通信、解耦
+
+
+
+
+```java
+Intent intent = new Intent(mContext, XxxActivity.class);
+intent.putExtra("key","value");
+startActivity(intent);
+        
+Intent intent = new Intent(mContext, XxxActivity.class);
+intent.putExtra("key","value");
+startActivityForResult(intent, 666);
+```
+在未使用ARouter路由框架之前的原生页面跳转方式。 
+
+
+## 原生路由方案的缺点 
+
+1. 显式: 直接的类依赖，耦合严重
+2. 隐式: 会在Manifest文件中进行集中管理，写作困难
+
+
+## ARouter的优势
+
+1. 使用注解，实现了映射关系自动注册与分布式路由管理
+2. 编译期间处理注解，并生成映射文件，没有使用反射，不影响运行时性能
+3. 映射关系按组分类，分级管理，按需初始化。
+4. 灵活的降级策略，每次跳转都会回调跳转结果，避免startActivity()一旦失败会抛出异常
+5. 自定义拦截器，自定义拦截顺序，可以对路由进行拦截，比如登录判断和埋点处理
+6. 支持依赖注入，可单独作为依赖注入框架使用，从而实现跨模块API调用
+7. 支持直接解析标准url进行跳转，并自动注入参数到目标页面中
+8. 支持多模块使用，支持组件化开发
+
+
+
+## 基本使用
+
+添加依赖并初始化后的基本使用:     
+
+```java
+// 在支持路由的页面上添加注解(必选)
+// 这里的路径需要注意的是至少需要有两级，/xx/xx
+@Route(path = "/test/activity")
+public class YourActivity extend Activity {
+    ...
+}
+
+// 1. 应用内简单的跳转(通过URL跳转在'进阶用法'中)
+ARouter.getInstance().build("/test/activity").navigation();
+
+// 2. 跳转并携带参数
+ARouter.getInstance().build("/test/1")
+    .withLong("key1", 666L)
+    .withString("key3", "888")
+    .withObject("key4", new Test("Jack", "Rose"))
+    .navigation();
+```
+
+
+
+
+
+
+
+
diff --git "a/AdavancedPart/Android\345\220\257\345\212\250\346\250\241\345\274\217\350\257\246\350\247\243.md" "b/AdavancedPart/Android\345\220\257\345\212\250\346\250\241\345\274\217\350\257\246\350\247\243.md"
index 6c5ef656..5008840f 100644
--- "a/AdavancedPart/Android\345\220\257\345\212\250\346\250\241\345\274\217\350\257\246\350\247\243.md"
+++ "b/AdavancedPart/Android\345\220\257\345\212\250\346\250\241\345\274\217\350\257\246\350\247\243.md"
@@ -31,18 +31,21 @@ Android启动模式详解
 - `singleInstance`
 
 顾名思义，是单一实例的意思，即任意时刻只允许存在唯一的`Activity`实例，而且该`Activity`所在的`task`不能容纳除该`Activity`之外的其他`Activity`实例！               
-它与`singleTask`有相同之处，也有不同之处。          
-相同之处：任意时刻，最多只允许存在一个实例。            
-不同之处：
-    - `singleTask`受`android:taskAffinity`属性的影响，而`singleInstance`不受`android:taskAffinity`的影响。 
-    - `singleTask`所在的`task`中能有其它的`Activity`，而`singleInstance`的`task`中不能有其他`Activity`。     
-    - 当跳转到`singleTask`类型的`Activity`，并且该`Activity`实例已经存在时，会删除该`Activity`所在`task`中位于该`Activity`之上的全部`Activity`实例；而跳转到`singleInstance`类型的`Activity`，并且该`Activity`已经存在时，
-	不需要删除其他`Activity`，因为它所在的`task`只有该`Activity`唯一一个`Activity`实例。
+它与`singleTask`有相同之处，也有不同之处。           
+相同之处: 任意时刻，最多只允许存在一个实例。             
+不同之处:       
 
+- `singleTask`受`android:taskAffinity`属性的影响，而`singleInstance`不受`android:taskAffinity`的影响。 
+- `singleTask`所在的`task`中能有其它的`Activity`，而`singleInstance`的`task`中不能有其他`Activity`。     
+- 当跳转到`singleTask`类型的`Activity`，并且该`Activity`实例已经存在时，会删除该`Activity`所在`task`中位于该`Activity`之上的全部`Activity`实例；而跳转到`singleInstance`类型的`Activity`，并且该`Activity`已经存在时，不需要删除其他`Activity`，因为它所在的`task`只有该`Activity`唯一一个`Activity`实例。
 
-假设我们的程序中有一个Activity是允许其他程序调用的，如果想实现其他程序和我们的程序可以共享这个Activity的实例，应该如何实现呢？使用前面3种启动模式肯定是做不到的，因为每个应用程序都会有自己的返回栈，同一个Activity在不同的返回栈中入栈时必然创建了新的实例。而使用singleInstance模式就可以解决这个问题，在这种模式下，会有一个单独的返回栈来管理这个Activity，不管是哪个应用程序来访问这个Activity，都共用同一个返回栈，也就解决了共享Activity实例的问题。
 
-假设现在有FirstActivity、SecondActivity、ThirdActivity三个Activity， SecondActivity的启动模式是SingleInstance。 
+假设我们的程序中有一个Activity是允许其他程序调用的，如果想实现其他程序和我们的程序可以共享这个Activity的实例，应该如何实现呢？         
+
+使用前面3种启动模式肯定是做不到的，因为每个应用程序都会有自己的返回栈，同一个Activity在不同的返回栈中入栈时必然创建了新的实例。         
+而使用singleInstance模式就可以解决这个问题，在这种模式下，会有一个单独的返回栈来管理这个Activity，不管是哪个应用程序来访问这个Activity，都共用同一个返回栈，也就解决了共享Activity实例的问题。
+
+假设现在有FirstActivity、SecondActivity、ThirdActivity三个Activity， SecondActivity的启动模式是SingleInstance。      
 现在FirstActivity 启动SecondActivity，SecondActivity再启动ThirdActivity。 
 
 然后我们按下Back键进行返回，你会发现ThirdActivity竟然直接返回到了FirstActivity，再按下Back键又会返回到SecondActivity，再按下Back键才会退出程序，这是为什么呢？其实原理很简单，由于FirstActivity和ThirdActivity是存放在同一个返回栈里的，当在ThirdActivity的界面按下Back键时，ThirdActivity会从返回栈中出栈，那么FirstActivity就成为了栈顶Activity显示在界面上，因此也就出现了从ThirdActivity直接返回到FirstActivity的情况。然后在FirstActivity界面再次按下Back键，这时当前的返回栈已经空了，于是就显示了另一个返回栈的栈顶Activity，即SecondActivity。最后再次按下Back键，这时所有返回栈都已经空了，也就自然退出了程序。
@@ -59,4 +62,4 @@ Android启动模式详解
 ---
 
 - 邮箱 ：charon.chui@gmail.com  
-- Good Luck! 
\ No newline at end of file
+- Good Luck! 
diff --git "a/AdavancedPart/Componse\344\275\277\347\224\250.md" "b/AdavancedPart/Componse\344\275\277\347\224\250.md"
new file mode 100644
index 00000000..6a2f0449
--- /dev/null
+++ "b/AdavancedPart/Componse\344\275\277\347\224\250.md"
@@ -0,0 +1,130 @@
+Compose使用
+===
+
+传统 Android UI 开发采用命令式模型，即通过命令驱动视图变化：findViewById 查找控件、设置属性、处理交互逻辑。代码经常伴随着多个职责耦合在一起，结构混乱，易错难测。
+
+Compose 则采用声明式模型：界面即状态的函数表达。当状态改变时，对应的 Composable 自动重新组合（Recompose）并刷新界面。这种模式更贴近现代前端（如 React/Vue）的理念。
+
+无需关心视图更新逻辑，只要状态变化，界面自然重绘，大幅降低 UI 层复杂度。
+
+
+1.3 开发效率提升点
+
+代码量平均减少 40%-60%
+
+无需 ViewHolder、Adapter 逻辑
+
+状态与 UI 同步更新，避免 UI 状态丢失
+
+支持实时预览（@Preview）、热重载、即时调试
+
+
+我们在公司项目中构建了性能对比 Benchmark（测试设备为 Pixel 6、Android 13）：
+
+2.1 滚动列表对比：RecyclerView vs LazyColumn
+
+指标  RecyclerView    LazyColumn (Compose)    差异
+平均帧率
+48 fps
+58 fps
++20%
+内存占用
+28 MB
+22 MB
+-21%
+首次绘制耗时
+320 ms
+210 ms
+-34%
+
+
+2.2 原因解析：Compose 更快的秘密
+
+SlotTable：结构快照树
+Compose 编译器会将 Composable 函数转换为组装 SlotTable 的代码。SlotTable 是一种高效的数据结构，存储了 Composable 树的结构快照。当状态发生变化时，Compose 通过对比 SlotTable 的版本，精确地定位变化范围，从而进行最小代价的重组操作（recomposition）。这一过程通过 Composer 对 Slot 表的操作实现，避免了冗余 UI 节点更新。
+
+重组与 Group 管理机制
+Compose 使用 Group（startGroup/endGroup）对 Composable 调用进行打包与标识，每个重组区域会通过重新执行对应的 Group 来进行更新，确保仅变更部分被执行。此机制在 RecomposeScopeImpl 中有体现，它能追踪每个状态依赖的作用域，从而提升重组精度。
+
+无需 ViewHolder 回收
+传统 RecyclerView 需要手动管理视图缓存与回收，而 Compose 自动处理 Composition 节点生命周期。Compose Compiler 会生成高效的 Slot 操作指令，通过“skip、reuse”策略对 UI 层进行精准控制，避免重复创建与销毁。
+
+Skia 图形引擎与 RenderNode
+Compose 绘制层基于 Skia 引擎，使用 DrawModifier 直接对 Canvas 进行渲染。它不会像传统 View 那样层层嵌套测量布局与绘制流程，而是采用测量（MeasurePass）-> 布局（LayoutPass）-> 绘制（DrawPass）的管线逻辑，通过 LayoutNode 驱动 Compose UI 树的变化。同时 Compose Layout 使用 SubcomposeLayout 实现异步测量能力，提高复杂嵌套组件的性能表现。
+
+渲染流程对比
+阶段  View System Compose
+布局树管理
+View/ViewGroup 层级
+LayoutNode 节点
+渲染方式
+Choreographer + RenderThread
+FrameClock + Skia 渲染
+状态追踪
+手动触发 invalidate
+Snapshot 自动追踪 + Diff Patch
+更新路径
+requestLayout → measure/layout
+Recomposer + SlotTable 重组
+
+注意：Compose 并非所有场景都一定更快，特别是复杂嵌套、过度组合场景仍需谨慎使用。
+
+### 简介
+
+Jetpack Compose 是用于构建 Android 界面的新款工具包。
+
+
+Jetpack Compose 是用于构建原生 Android 界面的新工具包。它使用更少的代码、强大的工具和直观的 Kotlin API，可以帮助您简化并加快 Android 界面开发，打造生动而精彩的应用。它可让您更快速、更轻松地构建 Android 界面。
+
+
+编写更少的代码会影响到所有开发阶段：作为代码撰写者，需要测试和调试的代码会更少，出现 bug 的可能性也更小，您就可以专注于解决手头的问题；作为审核人员或维护人员，您需要阅读、理解、审核和维护的代码就更少。
+
+与使用 Android View 系统（按钮、列表或动画）相比，Compose 可让您使用更少的代码实现更多的功能。无论您需要构建什么内容，现在需要编写的代码都更少了。以下是我们的一些合作伙伴的感想：
+
+“对于相同的 Button 类，代码的体量要小 10 倍。”(Twitter)
+“使用 RecyclerView 构建的任何屏幕（我们的大部分屏幕都使用它构建）的大小也显著减小。”(Monzo)
+““只需要很少几行代码就可以在应用中创建列表或动画，这一点令我们非常满意。对于每项功能，我们编写的代码行更少了，这让我们能够将更多精力放在为客户提供价值上。”(Cuvva)
+编写代码只需要采用 Kotlin，而不必拆分成 Kotlin 和 XML 部分：“当所有代码都使用同一种语言编写并且通常位于同一文件中（而不是在 Kotlin 和 XML 语言之间来回切换）时，跟踪变得更容易”(Monzo)
+
+无论您要构建什么，使用 Compose 编写的代码都很简洁且易于维护。“Compose 的布局系统在概念上更简单，因此可以更轻松地推断。查看复杂组件的代码也更轻松。”(Square)
+
+
+
+Compose 使用声明性 API，这意味着您只需描述界面，Compose 会负责完成其余工作。这类 API 十分直观 - 易于探索和使用：“我们的主题层更加直观，也更加清晰。我们能够在单个 Kotlin 文件中完成之前需要在多个 XML 文件中完成的任务，这些 XML 文件负责通过多个分层主题叠加层定义和分配属性。”(Twitter)
+
+
+Compose 与您所有的现有代码兼容：您可以从 View 调用 Compose 代码，也可以从 Compose 调用 View。大多数常用库（如 Navigation、ViewModel 和 Kotlin 协程）都适用于 Compose，因此您可以随时随地开始采用。“我们集成 Compose 的初衷是实现互操作性，我们发现这件事情已经‘水到渠成’。我们不必考虑浅色模式和深色模式等问题，整个体验无比顺畅。”(Cuvva)
+
+
+为现有应用设置 Compose
+
+首先，使用 Compose Compiler Gradle 插件配置 Compose 编译器。
+
+然后，将以下定义添加到应用的 build.gradle 文件中：
+```
+android {
+    buildFeatures {
+        compose = true
+    }
+}
+```
+在 Android BuildFeatures 代码块内将 compose 标志设置为 true 会在 Android Studio 中启用 Compose 功能。
+
+
+Compose vs HarmonyOS ArkUI 对比分析
+
+
+Jetpack Compose 和 HarmonyOS ArkUI 均采用声明式 UI 编程范式，面向多设备场景的响应式 UI 构建，二者在理念相通的同时，在架构设计、状态模型、渲染机制等方面有显著区别。
+
+
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/compose_vs_arkui.png?raw=true)        
+
+
+Jetpack Compose 是围绕可组合函数构建的。这些函数可让您以程序化方式定义应用的界面，只需描述应用界面的外观并提供数据依赖项，而不必关注界面的构建过程（初始化元素、将其附加到父项等）。如需创建可组合函数，只需将 @Composable 注解添加到函数名称中即可。
+
+
+    	
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
\ No newline at end of file
diff --git "a/AdavancedPart/ConstraintLaayout\347\256\200\344\273\213.md" "b/AdavancedPart/ConstraintLaayout\347\256\200\344\273\213.md"
index f46d2dc2..e3ccc9fc 100644
--- "a/AdavancedPart/ConstraintLaayout\347\256\200\344\273\213.md"
+++ "b/AdavancedPart/ConstraintLaayout\347\256\200\344\273\213.md"
@@ -12,8 +12,6 @@ ConstraintLaayout简介
 implementation 'com.android.support.constraint:constraint-layout:1.1.0'
 ```
 
-<img src="https://raw.githubusercontent.com/CharonChui/Pictures/master/constraintlayout_convert.png?raw=true" width = "80%" />
-
 然后会提示添加`ConstraintLayout`支持库。   
 <img src="https://raw.githubusercontent.com/CharonChui/Pictures/master/constraintlayout_convert_tip.png?raw=true" width = "80%" />
 
@@ -95,7 +93,7 @@ implementation 'com.android.support.constraint:constraint-layout:1.1.0'
 		* layout_constraintVertical_bias
 		```
 
-		下面这段代码就是让左边占30%，右边占70%（默认两边各占50%），这样左边就会短一些，如图5所示，此时代码是这样的:    
+		下面这段代码就是让左边占30%，右边占70%（默认两边各占50%），这样左边就会短一些，此时代码是这样的:    
 		```xml		
 		<android.support.constraint.ConstraintLayout ...>
 		    <Button android:id="@+id/button" ...
diff --git "a/AdavancedPart/Crash\345\217\212ANR\345\210\206\346\236\220.md" "b/AdavancedPart/Crash\345\217\212ANR\345\210\206\346\236\220.md"
index df4d8ccf..54ab11a4 100644
--- "a/AdavancedPart/Crash\345\217\212ANR\345\210\206\346\236\220.md"
+++ "b/AdavancedPart/Crash\345\217\212ANR\345\210\206\346\236\220.md"
@@ -4,9 +4,13 @@
 ## Java Crash流程
 
 1、首先发生crash所在进程，在创建之初便准备好了defaultUncaughtHandler，用来处理Uncaught Exception，并输出当前crash的基本信息；
+
 2、调用当前进程中的AMP.handleApplicationCrash；经过binder ipc机制，传递到system_server进程；
+
 3、接下来，进入system_server进程，调用binder服务端执行AMS.handleApplicationCrash；
+
 4、从mProcessNames查找到目标进程的ProcessRecord对象；并将进程crash信息输出到目录/data/system/dropbox；
+
 5、执行makeAppCrashingLocked：
 
 创建当前用户下的crash应用的error receiver，并忽略当前应用的广播；
@@ -19,8 +23,11 @@
 当1分钟内同一进程未发生连续crash两次时，则执行结束栈顶正在运行activity的流程。
 
 7、通过mUiHandler发送消息SHOW_ERROR_MSG，弹出crash对话框；
+
 8、到此，system_server进程执行完成。回到crash进程开始执行杀掉当前进程的操作；
+
 9、当crash进程被杀，通过binder死亡通知，告知system_server进程来执行appDiedLocked()；
+
 10、最后，执行清理应用相关的四大组件信息。
 
 
@@ -35,12 +42,15 @@
 
 
 
-Native Crash
+Native Crash:    
+
+- 崩溃过程：native crash 时操作系统会向进程发送信号，崩溃信息会写入到 data/tombstones 下，并在 logcat 输出崩溃日志
+
+- 定位：so 库剥离调试信息的话，只有相对位置没有具体行号，可以使用 NDK 提供的 addr2line 或 ndk-stack 来定位
 
-    崩溃过程：native crash 时操作系统会向进程发送信号，崩溃信息会写入到 data/tombstones 下，并在 logcat 输出崩溃日志
-    定位：so 库剥离调试信息的话，只有相对位置没有具体行号，可以使用 NDK 提供的 addr2line 或 ndk-stack 来定位
-    addr2line：根据有调试信息的 so 和相对位置定位实际的代码处
-    ndk-stack：可以分析 tombstone 文件，得到实际的代码调用栈
+- addr2line：根据有调试信息的 so 和相对位置定位实际的代码处
+
+- ndk-stack：可以分析 tombstone 文件，得到实际的代码调用栈
 
 
 
@@ -62,56 +72,58 @@ ANR信息输出到traces.txt文件中
 traces.txt文件是一个ANR记录文件，用于开发人员调试，目录位于/data/anr中，无需root权限即可通过pull命令获取，下面的命令可以将traces.txt文件拷贝到当前目录下
 adb pull /data/anr .
 
-ANR排查流程
-1、Log获取
-1、抓取bugreport
-adb shell bugreport > bugreport.txt
-2、直接导出/data/anr/traces.txt文件
-adb pull /data/anr/traces.txt trace.txt
-2、搜索“ANR in”处log关键点解读
+ANR排查流程:     
+1. log获取
+2. 抓取bugreport
+    adb shell bugreport > bugreport.txt
+3. 直接导出/data/anr/traces.txt文件
+    adb pull /data/anr/traces.txt trace.txt
+4. 搜索“ANR in”处log关键点解读
 
 
 发生时间（可能会延时10-20s）
 
 
-pid：当pid=0，说明在ANR之前，进程就被LMK杀死或出现了Crash，所以无法接受到系统的广播或者按键消息，因此会出现ANR
+pid：当pid=0，说明在ANR之前，进程就被LMK杀死或出现了Crash，所以无法接受到系统的广播或者按键消息，因此会出现ANR    
+
 
+cpu负载Load: 7.58 / 6.21 / 4.83     
+代表此时一分钟有平均有7.58个进程在等待    
+1、5、15分钟内系统的平均负荷     
+当系统负荷持续大于1.0，必须将值降下来     
+当系统负荷达到5.0，表面系统有很严重的问题    
 
-cpu负载Load: 7.58 / 6.21 / 4.83
-代表此时一分钟有平均有7.58个进程在等待
-1、5、15分钟内系统的平均负荷
-当系统负荷持续大于1.0，必须将值降下来
-当系统负荷达到5.0，表面系统有很严重的问题
 
+cpu使用率     
+CPU usage from 18101ms to 0ms ago     
+28% 2085/system_server: 18% user + 10% kernel / faults: 8689 minor 24 major      
+11% 752/android.hardware.sensors@1.0-service: 4% user + 6.9% kernel / faults: 2 minor     
+9.8% 780/surfaceflinger: 6.2% user + 3.5% kernel / faults: 143 minor 4 major     
 
-cpu使用率
-CPU usage from 18101ms to 0ms ago
-28% 2085/system_server: 18% user + 10% kernel / faults: 8689 minor 24 major
-11% 752/android.hardware.sensors@1.0-service: 4% user + 6.9% kernel / faults: 2 minor
-9.8% 780/surfaceflinger: 6.2% user + 3.5% kernel / faults: 143 minor 4 major
 
+上述表示Top进程的cpu占用情况。       
+注意      
+如果CPU使用量很少，说明主线程可能阻塞。    
 
-上述表示Top进程的cpu占用情况。
-注意
-如果CPU使用量很少，说明主线程可能阻塞。
-3、在bugreport.txt中根据pid和发生时间搜索到阻塞的log处
+在bugreport.txt中根据pid和发生时间搜索到阻塞的log处     
 ----- pid 10494 at 2019-11-18 15:28:29 -----
-4、往下翻找到“main”线程则可看到对应的阻塞log
+
+往下翻找到“main”线程则可看到对应的阻塞log     
 "main" prio=5 tid=1 Sleeping
 | group="main" sCount=1 dsCount=0 flags=1 obj=0x746bf7f0 self=0xe7c8f000
 | sysTid=10494 nice=-4 cgrp=default sched=0/0 handle=0xeb6784a4
 | state=S schedstat=( 5119636327 325064933 4204 ) utm=460 stm=51 core=4 HZ=100
 | stack=0xff575000-0xff577000 stackSize=8MB
 | held mutexes=
-上述关键字段的含义如下所示：
-
-tid：线程号
-sysTid：主进程线程号和进程号相同
-Waiting/Sleeping：各种线程状态
-nice：nice值越小，则优先级越高，-17~16
-schedstat：Running、Runable时间(ns)与Switch次数
-utm：该线程在用户态的执行时间(jiffies)
-stm：该线程在内核态的执行时间(jiffies)
-sCount：该线程被挂起的次数
-dsCount：该线程被调试器挂起的次数
-self：线程本身的地址
+上述关键字段的含义如下所示：      
+
+tid：线程号     
+sysTid：主进程线程号和进程号相同      
+Waiting/Sleeping：各种线程状态     
+nice：nice值越小，则优先级越高，-17~16    
+schedstat：Running、Runable时间(ns)与Switch次数     
+utm：该线程在用户态的执行时间(jiffies)     
+stm：该线程在内核态的执行时间(jiffies)     
+sCount：该线程被挂起的次数     
+dsCount：该线程被调试器挂起的次数     
+self：线程本身的地址     
diff --git a/AdavancedPart/Hilt.md b/AdavancedPart/Hilt.md
new file mode 100644
index 00000000..d38be1bd
--- /dev/null
+++ b/AdavancedPart/Hilt.md
@@ -0,0 +1,44 @@
+## Hilt
+
+Hilt是Google基于Dagger2封装的Android专用依赖注入框架
+
+
+- Dagger2的痛点: 需要手动定义Component、SubComponent，模板代码多且复杂
+- Hilt的价值: 预定义了与Android生命周期绑定的标准Component，开箱即用。 
+
+### 核心原理: 编译期代码生成
+
+Hilt的本质是注解处理器，在编译阶段扫描注解，自动生成Dagger的模板代码。 
+
+```kotlin
+// 你写的代码
+class UserRepository @Inject constructor(
+    private val api: ApiService
+)
+
+// Hilt 编译后自动生成（伪代码，实际在 build/generated 目录）
+class UserRepository_Factory : Factory<UserRepository> {
+    private val apiProvider: Provider<ApiService>
+
+    constructor(apiProvider: Provider<ApiService>) {
+        this.apiProvider = apiProvider
+    }
+
+    override fun get(): UserRepository {
+        return UserRepository(apiProvider.get())
+    }
+
+    companion object {
+        fun create(apiProvider: Provider<ApiService>) =
+            UserRepository_Factory(apiProvider)
+    }
+}
+```
+
+
+你写的注解 -> 编译器生成工厂类 -> 运行时Hilt调用工厂类创建对象并注入。   
+
+零反射，全部在编译期完成，这是Hilt/Dagger性能优于其他DI框架的根本原因。  
+
+
+
diff --git "a/AdavancedPart/KMP\345\274\200\345\217\221.md" "b/AdavancedPart/KMP\345\274\200\345\217\221.md"
new file mode 100644
index 00000000..d2f15780
--- /dev/null
+++ "b/AdavancedPart/KMP\345\274\200\345\217\221.md"
@@ -0,0 +1,30 @@
+KMP开发
+===
+
+Kotlin Multiplatform（简称 KMP）是 JetBrains 推出的开源跨平台开发框架。
+
+它可以通过共享 Kotlin 编写的业务逻辑代码实现多平台复用。
+
+
+从应用场景来看，KMP 不仅局限于移动端，它支持 iOS、Android、Web、桌面端（Windows/macOS/Linux）以及服务器端的代码共享。这种扩展性使得开发者能够用同一套代码库构建全平台应用，大幅提升开发效率。
+
+
+
+KMP 有三大编译目标，分别是： Kotlin/JVM、Kotlin/Native、Kotlin/JS。通过编译不同的目标文件实现各端的跨平台能力。除此之外，KMP 还实验性地支持 WebAssembly（Kotlin/Wasm）编译目标，不过目前实际应用场景相对较少。
+
+
+### KMP编译器
+
+
+我们知道，一个语言的编译需要经过词法分析和语法分析，解析成抽象语法树 AST。   
+而 KMP 为了将 Kotlin 源代码编译成不同的目标平台代码，就需要将 Kotlin 的编译产物进一步向不同的平台转化。    
+Kotlin 语言的编译，与向不同的平台转化，明显是不同的职责，需要解耦，所以 KMP 的编译器必然有两个部分，也就是编译器前端（Frontend）与编译器后端（Backend）。    
+Frontend 会将 AST 进一步转换为 Kotlin IR（Kotlin Intermediate Representation），是 Kotlin 源代码的中间表示形式，Kotlin IR 是编译器前端的输出，也是编译器后端的输入。     
+Backend 则会吧 Kotlin IR 转换为不同平台的中间表示形式，最终生成目标代码。
+
+
+    	
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
diff --git a/AdavancedPart/PAG.md b/AdavancedPart/PAG.md
new file mode 100644
index 00000000..40688ef2
--- /dev/null
+++ b/AdavancedPart/PAG.md
@@ -0,0 +1,471 @@
+PAG
+---
+
+PAG(Portable Animated Graphics)是腾讯开源的一套完整动效工作流解决方案，主要包含三个部分:    
+
+1. AE导出插件PAGExporter: 把After Effects动效导出为.pag二进制文件。 
+2. 桌面预览/性能监测工具PAGViewer
+3. 夸端渲染SDK libpag: iOS/Android/macOS/Windows/Web/鸿蒙
+
+广泛应用于视频模板、UI动画、贴纸等场景。     
+
+与Lottie最大的区别是:     
+
+- Lottie是纯矢量Json，只支持AE的部分特性。   
+- PAG是二进制形式+矢量/BMP预合成混合导出，能支持AE的全量特性
+
+
+### PAG的四大核心优势
+
+
+| 维度 | PAG  | Lottie |
+|-------|-------|-------|
+| 文件格式  | 二进制 TLV(Tag-Length-Value)  | Json文本 |
+| 解码速度 | 比Json快约10倍 | 慢 |
+| 文件体积 | 小约50%  | 大 |
+| AE特性覆盖 | 全量(矢量+BMP预合成混合) | 仅支持部分矢量 |
+| 资源集成 | 单文件可内嵌图片/音频 | 需外挂 |
+| 运行时编辑 | 文本、占位图、图层均可替换 | 能力有限 |
+| 性能监测 | PAGViewer内置 | 无 |
+
+
+### 实现原理
+
+
+- 最上层: PAGView、PAGImageView(UI层)
+- Java层: PAGFile、PAGPlayer、PAGSurface，该层再通过JNI进行调用
+- C++层(核心): 夸端共享     
+    - Codec: 解码
+    - Renderer: 合成、渲染
+    - RendererCache: 纹理、缓存管理
+- TGFX图形库(Tencent Graphics): 封装GPU后端(OpenGL、Metal、Vulkan)
+- 平台硬件解码: MediaCodec、VideoToolbox
+
+
+### PAG文件格式
+
+- 采用可扩展二进制TLV编码(Tag + Length + Value)
+- 每个Tag代表一种属性块(图形、关键帧、遮罩、文本、图像等)，tagLevel指明所需最低SDK版本，天然支持向前/向后兼容: 老版本SDK遇到不认识的Tag会跳过而不崩溃。   
+- 文件里可以同时承载:     
+    - 矢量数据: 形状、文本、遮罩、表达式驱动的变换等(纯矢量导出模式)
+    - BMP预合成序列帧: 通过H.264视频轨压缩存储(BMP混合模式)，专门用于那些无法矢量化的复杂AE特效(粒子、第三方插件等)     
+- 解码时按图层时间轴拉取需要的帧数据，不必一次性全量解析，首诊渲染很快。   
+
+### 导出模式     
+
+- 矢量导出(Vector Export): 逐层导出AE的shape/text/solid/mask/transform等，运行时保留图层结构，可编辑。   
+
+- BMP预合成导出(Video Sequence): 把一段无法矢量化的合成，渲染成帧序列并用H.264编码，运行时调用MediaCodec硬解。   
+
+- 混合模式: 两者在同一.pag文件里组合--可编辑的文字/占位图保留矢量，特效部分走视频序列。这是PAG能全量支持AE特性+仍能保持运行时可编辑的关键。   
+
+
+
+### 渲染流水线
+
+- 解码: Codec把TLV还原为内存中的PAGFile图形树(Composition -> Layer -> Property)
+- 组合: PAGPlayer按当前progress计算每一层的变换、关键帧插值，构建一颗渲染树。 
+- 渲染(TGFX): TGFX是PAG自研的轻量图形库，把渲染树翻译成GPU指令，通过OpenGL/Metal/Vulkan后端提交渲染
+- 输出: 渲染到PAGSurface，它的底层可以是SurfaceTexture/Surface/HardwareBuffer/离屏FBO
+- 缓存(RendererCache):    
+    - 纹理缓存: 同一帧内相同图层结果复用
+    - 视频序列缓存: MediaCodec解码出的帧写入PAGDisckCache
+    - 字形缓存: 文本按glyph光栅化后缓存
+
+### PAG诞生背景
+
+PAG方案最早就是诞生在视频编辑场景下，要让动画能够在视频编辑场景下无缝整合使用，需要解决两个问题:   
+
+- 支持离屏渲染绘制、子线程渲染。 Lottie的动画方案之所以无法应用在视频合成中，主要是因为依赖了平台相关的UI框架，开发成本较低，但是也导致了它只能渲染到UI视图上，并且无法在子线程中使用。   
+
+- PAG的整套动画方案就是基于C++跨平台架构研发的，一直从最底层的动画插值器，还原到上层的时间轴和图层渲染树系统，虽然开发成本较高，但是所有端共享同一套代码，天然的能保证夸端渲染一致性。最重要的是能直接渲染到离屏纹理上，并完美支持子线程动画渲染。  
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/pag_1.jpeg?raw=true)   
+
+
+### 为什么性能好
+
+- 二进制TLV解析无字符串解析开销
+- GPU合成+TGFX优化的批渲染
+- 硬件视频解码处理复杂特效，绕开CPU矢量光栅化瓶颈
+- RenderCache + PAGDiskCache减少重复计算与磁盘I/O
+- DisplayLink(Android用Choreographer)严格对齐VSYNC,避免丢帧     
+
+
+### 核心类
+
+- PAGFile: .pag文件的解析产物，PAGComposition子类，可查询/修改文本、图片、图层时间拉伸等。    
+
+- PAGComposition: 合成节点(可嵌套),管理子图层，支持动态增删子图层，合并多个PAG。   
+- PAGLayer: 图层基类，派生PAGTextLayer、PAGImageLayer、PAGShapeLayer、PAGSolidLayer。 
+
+- PAGImage: 位图资源封装，用来替换占位图。支持Bitmap、文件路径、纹理ID。
+
+- PAGText: 文本属性，如text/fontSize/fontFamily/fillColor/strokeColor等     
+
+- PAGFont: 注册自定义字体(TTF/OTF)，指定fontFamily与fontStyle    
+
+- PAGPlayer: 渲染驱动核心，绑定PAGComposition和PAGSurface，控制progress/scaleMode/cacheEnabled。自定义渲染时直接用它。   
+
+- PAGSurface: 渲染目标，基于GLSurface/SurfaceTexture
+
+- PAGView: 封装好的TextureView播放控件，内部驱动PAGPlayer，对齐Chorerographer。
+
+- PAGImageView: 基于位图序列的ImageView，省电，适合列表里大量循环小动效。   
+
+- PAGAnimator: 4.0引入的驱动器，自定义渲染时用来与VSYNC对齐。   
+
+- PAGDecoder: 帧解码器，把PAG逐帧解成Bitmap。  
+
+- PAGDiskCache: 磁盘缓存管理，可清缓存、改大小。   
+
+
+
+### 运行时替换文字
+
+
+- 替换文字的前提是AE侧要把文件标记为可编辑
+
+    用PAGExporter导出时，在AE图层面板要把该文本层的Editable属性勾选，这样导出后SDK里才会为这个文本分配一个editableIndex。   
+
+- 通过index替换文字内容
+
+```java
+PAGText text = pageFile.getTextData(0); // 取出第0个可编辑文本的当前属性
+text.text = "hhhh";
+text.fontSize = 40;
+text.fillColor = Color.parseColor("#ff3333");
+pageFile.replaceText(0, text);  // 回写
+```
+
+- 通过涂层面查找替换(防止索引变动)
+
+editableIndex会随导出插件排序变化，业务上更好的方式是使用AE里自定义的图层名:   
+
+```java
+PAGLayer[] layers = pagFile.getLayersByEditableIndex(0, PAGLayer.LayerTypeText);
+for (PAGLayer layer : layers) {
+  if (layer instanceof PAGTextLayer) {
+        PAGTextLayer t = (PAGTextLayer) layer;
+        if ("title_layer".equals(t.layerName())) {
+            t.setText("Ducc");
+            t.setFillColor(Color.RED);
+            t.setFontSize(48);
+        }
+    }
+}
+```
+
+替换后无需重新Load文件，调一次pagView.flush()或者等下一帧就会刷新。   
+
+- 替换图片   
+
+```java
+PAGImage pageImage = PAGImage.FromBitmap(bmp); 
+
+// 按index替换
+pageFile.replaceImage(0, pageImage);
+// 按图层名替换
+pageFile.replaceImageByName("name", pageImage);
+
+```
+
+- 换字体
+
+换字体需要先使用PAGFont.RegisterFont()方法来把本地的.ttf注册。然后再通过PAGText.fontFamily方法来使用。   
+
+
+- 视频模板
+
+视频模板就是在一个PAG文件里堆放N个可替换占位图 + 可替换文字，业务层把用户上传的素材塞进即可。   
+
+这就是PAG在一些视频编辑软件中被大量使用的场景。    
+
+
+
+- 合成与图层操作   
+
+```java
+PAGComposition root = PAGComposition.Make(720, 1280);
+root.addLayer(pageFile1);
+root.addLayer(pageFile2);
+pagView.setComposition(root);
+
+// 查询/删除图层
+
+int count = root.numChildren();
+PAGLayer child = root.getLayerAt(0);
+root.removeLayerAt(0);
+```
+
+
+
+### 问题点:   
+
+- PAGImageView与PAGView
+
+PAGImageView是基于位图序列的ImageView，省电，适合列表里大量循环小动效。     
+而PAGView中有装好的TextureView播放控件，内部驱动PAGPlayer。   
+所以对于列表中有大量小动效(点赞、表情)的情况，优先使用PAGImageView + 磁盘缓存，它把动画预解码为位图序列，几乎零CPU。    
+
+- cacheEnabled/cacheScale: 复杂动画开cacheScale < 1用降采样换内存。纯矢量不大时可以关缓存。 
+
+- 硬件解码资源: 含视频序列的PAG会占用MediaCodec实例，同屏有多个PAG动画时需要注意codec上限(一般10 - 16个)，超过会IllegalStateException。   
+
+- 字体内存: PAGFont.registerFont注册时进程级的，频繁注册大字体会OOM，业务上注册一次即可。   
+
+- 不要把PAGView放进recyclerview无节制复用，因为PAGView内部有一个TextureView，而TextureView在滑动列表中有SurfaceTexture的重建成本，建议使用PAGImageView。  
+
+- 内存释放: PAGImage.fromBitmap会引用bitmap，替换完成后如果不再使用，需要把PAGFile引用断掉。   
+
+
+
+
+
+
+------
+
+## 矢量 vs BMP
+
+矢量图和位图是图形中最基础的两种图像表达方式。     
+
+PAG之所以这么强，就在于它把两者在同一个文件里混着用。    
+
+#### 两者的本质区别
+
+###### 矢量(Vector)
+
+矢量就是用数学描述画图。    
+
+矢量图不存像素，存的是几何指令和关键帧。     
+
+例如一个红色圆:    
+`circle(center=(100,100), r=50, fillColor=#FF0000, strokeWidth=2)`
+渲染时，CPU/GPU会按这条指令实时计算出每个像素该是什么颜色。   
+
+
+它的特点是:    
+
+- 存储的内容是路径(贝塞尔曲线)、描边、填充、变换矩阵、遮罩等。 
+- 文件体积非常小
+- 可无限缩放，即使放大10被也不糊，重新按数学公式算像素
+- 可运行时编辑，改颜色/大小/文字/位置都只是改参数
+- 缺点是复杂的特效会算不动，例如一些例子、发光、烟雾等，对于一些第三方AE插件效果，如果用到矢量去模拟，要么会做不到，要么渲染一帧要几十毫秒。   
+
+
+###### 位图(Bitmap)
+
+位图就是把每个像素的颜色值都直接保存下来。    
+
+比如一个100*100的图，就是10000个RGBA值的数组。   
+
+它的特点是:   
+
+- 存储内容是纯像素颜色矩阵
+- 文件体积比较大，因为每个像素都要存，但是可以用PNG、JPEG、H.264压缩
+- 缩放会糊，放大就是像素插值，会模糊，缩小会丢信息
+- 运行时不可编辑，想改颜色只能逐像素重画
+- 有点是什么画面都能表达，不管是烟雾、粒子、3D渲染结果都可以
+
+
+#### 类比
+
+一个形象的比喻就是:    
+
+- 矢量 = 乐谱。 占的空间小，乐手按照乐谱现场演奏，音质由演奏者决定(放大不糊)
+- 位图 = 录音文件。 每一秒的声波都被采样保存下来了，文件很大。
+
+PAG的创新就是: 一首曲子里，能弹的部分用乐谱，演奏不出来的插件音效用录音片段。   
+
+
+PAG把AE里那些无法矢量化的部分(粒子、插件效果、复杂混合模式)，让AE先渲染成一段帧序列(每一帧都是一张位图)，然后用H.264视频编码压缩到.pag文件里。   
+
+- PAGExporter检测到无法矢量化
+- 调AE去渲染成PNG序列： frame_0.png/frame_1.png ...
+- 调H.264编码成一段视频
+- 作为BMP预合成图层写进.pag
+- 运行时，libpag用MediaCodec(Android)/VideoToolbox(iOS)硬件解码这段视频，逐帧纹理上屏。    
+
+
+例如有一个摇出金币的动效:    
+
+- Composition(根合成) 
+    - 背景渐变: 矢量(ShapeLayer)
+    - 文字: 矢量(TextLayer，可编辑)
+    - 用户头像占位图: 矢量(ImageLayer，可替换)
+    - 粒子金币特效: BMP预合成(一段H.264视频序列)
+
+  
+  
+  
+### Alpha通道问题
+
+H.264不支持透明通道。     
+
+PAG用了一个聪明的方法: 把视频帧水平或垂直拼成两半:    
+
+- 左半边存RGB颜色、右半边存alpha灰度
+- 解码后在shader里合并成RGBA
+
+这样就用标准的H.264编码器得到了带透明度的视频序列。    
+
+iOS的HEV支持原生alpha，新版PAG在部分平台上也会用HEVC直接带alpha编码。   
+
+下面详细介绍一下alpha通道问题:  
+
+
+H.264是2003年ITU-T定下的视频编码标准，设计目标是高效压缩自然场景视频(电影、监控、直播)。   
+它的像素模型是YUV 4：2：0，也就是亮度、色度蓝、色度红。  
+三个通道，没有Alpha。   
+
+硬件解码芯片(Adnroid MediaCodec、iOS VideoToolbox)也都是围绕YUV流水线设计的，没有第四通道的位置。   
+
+但是PAG的BMP预合成图层是要叠加在其他图层之上的，没有alpha，边缘就是一个黑色或白色的钜形背景，根本没法用。    
+
+
+那PAG的思路就是把Alpha藏进RGB通道里:    
+
+既然H.264一帧只能存RGB，那就把一帧原本 width * height 的画面，拼成一张更大的图:   
+
+- 一半区域存原始RGB值
+
+- 另一半区域存Alpha值(用R=G=B=alpha)的灰度图来表示。  
+
+编码时当成一个普通的h.264视频。    
+
+解码时得到一张大图，再用GPU Shader把RGB部分和Alpha部分按像素对齐合成RGBA。 
+
+这个技巧，行业内叫"side-by-side alpha packing"或"alpha-as-luma"，不是PAG首创，（Google的WebM Alpha、Adobe的Animate也用过类似思路），但PAG把它工程化做到了跨端、硬件解码、shader合成一体。
+
+#### 具体排布：两种打包方式
+
+PAG支持两种alpha打包方向，由PAGExporter根据视频宽高比自动选择更省空间的那个：
+
+###### 水平拼接（Left-Right）
+```
+  原画面 W×H               编码后的 H.264 帧 2W×H
+  ┌──────────┐            ┌──────────┬──────────┐
+  │   RGBA   │    ===>    │   RGB    │  Alpha   │
+  │   一帧    │            │ (原颜色) │ (灰度图) │
+  └──────────┘            └──────────┴──────────┘
+```
+
+###### 垂直拼接（Top-Bottom）
+
+```
+  原画面 W×H               编码后的 H.264 帧 W×2H
+  ┌──────────┐            ┌──────────┐
+  │   RGBA   │            │   RGB    │
+  │   一帧    │    ===>    │ (原颜色) │
+  └──────────┘            ├──────────┤
+                          │  Alpha   │
+                          │ (灰度图) │
+                          └──────────┘
+```
+选择哪种的依据：让打包后的总尺寸对H.264编码器更友好（一般是16的倍数对齐，利于宏块划分），以及让编码压缩率更高。
+
+#### 元信息如何告诉 SDK
+
+.pag文件的TLV里，这段BMP预合成图层的Tag里会带几个关键字段：
+
+``java
+VideoCompositionBlock {
+    width:          实际原始宽度 W
+    height:         实际原始高度 H
+    alphaStartX:    Alpha 区域在大图里的起始 x (水平拼接时 = W)
+    alphaStartY:    Alpha 区域在大图里的起始 y (垂直拼接时 = H)
+    hasAlpha:       bool
+    frameRate, duration, ...
+}
+``
+解码时，SDK知道"这段视频真正的画面是W×H，alpha区域从(alphaStartX, alphaStartY) 开始"，后面shader合成就按这两个偏移取样。
+
+#### 编码侧：PAGExporter 怎么做
+
+设计师在AE里导出时，PAGExporter对BMP预合成图层做如下处理:     
+
+1. 逐帧渲染：让AE把这段合成render成一组RGBA位图（每帧W×H，带透明通道）。
+2. 拆分通道：对每一帧：
+    - 取RGB部分 → 放到大图左半（或上半）；
+    - 取Alpha通道 → 复制成灰度图 (A, A, A) → 放到大图右半（或下半）。
+3. 拼帧入视频：所有帧按顺序喂给H.264编码器（PAGExporter在macOS/Windows里调的是各自平台的SDK。   
+4. 写入TLV：把H.264码流作为VideoCompositionBlock的payload写进.pag，同时记录
+  hasAlpha=true、alphaStartX/Y。
+
+  ▎ 小细节：alpha 灰度图压缩率很高（大片平坦区域），H.264
+  ▎ 对这种内容压得特别好，因此"2×面积"实际体积增加往往只有 20%~40%，远比 PNG 序列小。
+
+#### 解码侧：运行时怎么合回来
+
+这是最关键的一步，也是PAG性能好的原因。
+
+###### 硬件解码拿到大图
+```java
+// 伪代码
+MediaCodec codec = MediaCodec.createDecoderByType("video/avc");
+codec.configure(format, surface, null, 0);
+// surface 是 SurfaceTexture，解码后一帧直接以 OES 纹理形式上屏
+```
+Android上MediaCodec的输出surface是SurfaceTexture，对应一个GL_TEXTURE_EXTERNAL_OES纹理。这个纹理尺寸就是打包后的大图尺寸（2W×H 或 W×2H）。
+
+###### 自定义Fragment Shader采样两次
+
+重点是这个片段着色器（PAG源码里对应YUVBuffer.cpp/VideoComposition的渲染pipeline），简化后长这样:    
+```glsl
+  #extension GL_OES_EGL_image_external : require
+  precision mediump float;
+
+  uniform samplerExternalOES uTexture; // MediaCodec 输出的 OES 纹理
+  varying vec2 vTexCoord;              // 当前像素在"原始画面"中的归一化坐标 (0~1)
+
+  // 从 CPU 传进来的：alpha 区域起点占大图的比例
+  uniform vec2 uAlphaStart;   // 水平打包时 = (0.5, 0.0)
+  uniform vec2 uScale;        // 原画面在大图里占的归一化尺寸，水平打包时 = (0.5, 1.0)
+
+  void main() {
+      // 1) 采样 RGB：在大图的左半（或上半）
+      vec2 rgbCoord = vTexCoord * uScale;
+      vec3 rgb = texture2D(uTexture, rgbCoord).rgb;
+
+      // 2) 采样 Alpha：相同的局部坐标，但整体偏移到右半（或下半）
+      vec2 alphaCoord = rgbCoord + uAlphaStart;
+      float alpha = texture2D(uTexture, alphaCoord).r; // 灰度图 R=G=B，取 R 即可
+
+      // 3) 合并，并做 premultiplied alpha
+      gl_FragColor = vec4(rgb * alpha, alpha);
+  }
+```
+ 三个关键点：
+
+ 1. 一个像素做两次纹理采样（同一张大纹理的不同区域），代价非常低，GPU 本来就是为这个干的。
+2. 取灰度图的 R 分量当 alpha：因为编码时 R=G=B=alpha，解码回来可能因为 YUV
+  色度子采样略有误差，但灰度视觉上无感。
+3. 预乘 alpha（premultiplied）：rgb * alpha 这一步把输出变成预乘格式，方便后续和其他图层做标准blending：finalColor = src + dst * (1 - src.a)。这是 PAG 渲染树统一的颜色空间约定。
+
+###### 渲染目标
+
+Shader输出的RGBA会渲染到一个中间FBO（帧缓冲对象），它在PAG的渲染树里就是一个普通的"带透明度的图层纹理"，和矢量图层、其它BMP图层一起进入最终合成阶段，通过标准OpenGL blending叠在一起。
+
+这就是为什么PAG能做到**"BMP 图层和矢量图层无缝叠加"**——从合成器的视角看它们都是带alpha的RGBA纹理，根本不关心上游是矢量画的还是视频解出来的。
+
+
+
+
+###### 演进：iOS/macOS 上用 HEVC 原生 alpha
+
+HEVC（H.265）从 2019 年起支持 alpha auxiliary picture（Apple 叫 HEVC with
+  Alpha），可以在编码里直接带透明通道。PAG 在 iOS 11+、macOS 上已经用这个替代 side-by-side方案，好处:    
+
+- 文件小 20%+（不用冗余存一份灰度图）；
+- 解码直接得到 RGBA，省一次 shader 采样；
+- Apple VideoToolbox 原生硬解。
+
+Android端因为MediaCodec对HEVC-Alpha支持度参差不齐（部分芯片厂商不支持），目前仍以 H.264 + side-by-side 为主。
+
+
+
+  
+  
+  
+  
+  
diff --git "a/AdavancedPart/\345\261\217\345\271\225\351\200\202\351\205\215\344\271\213\347\231\276\345\210\206\346\257\224\346\226\271\346\241\210\350\257\246\350\247\243.md" "b/AdavancedPart/\345\261\217\345\271\225\351\200\202\351\205\215\344\271\213\347\231\276\345\210\206\346\257\224\346\226\271\346\241\210\350\257\246\350\247\243.md"
index a64d0fe2..e268531a 100644
--- "a/AdavancedPart/\345\261\217\345\271\225\351\200\202\351\205\215\344\271\213\347\231\276\345\210\206\346\257\224\346\226\271\346\241\210\350\257\246\350\247\243.md"
+++ "b/AdavancedPart/\345\261\217\345\271\225\351\200\202\351\205\215\344\271\213\347\231\276\345\210\206\346\257\224\346\226\271\346\241\210\350\257\246\350\247\243.md"
@@ -557,4 +557,4 @@ public void restoreLayoutParams(ViewGroup.LayoutParams params) {
 ---
 
 - 邮箱 ：charon.chui@gmail.com  
-- Good Luck! 
\ No newline at end of file
+- Good Luck! 
diff --git "a/AdavancedPart/\351\200\232\350\277\207Hardware Layer\346\217\220\351\253\230\345\212\250\347\224\273\346\200\247\350\203\275.md" "b/AdavancedPart/\351\200\232\350\277\207Hardware Layer\346\217\220\351\253\230\345\212\250\347\224\273\346\200\247\350\203\275.md"
index 46b2b118..f0871cc0 100644
--- "a/AdavancedPart/\351\200\232\350\277\207Hardware Layer\346\217\220\351\253\230\345\212\250\347\224\273\346\200\247\350\203\275.md"	
+++ "b/AdavancedPart/\351\200\232\350\277\207Hardware Layer\346\217\220\351\253\230\345\212\250\347\224\273\346\200\247\350\203\275.md"	
@@ -114,7 +114,7 @@ mView.animate().translationX(150).withLayer().start();
     
     在手机开发者选项中的*显示硬件层更新（Show hardware layers updates）*功能是追踪这个问题的开发利器。当`View`渲染`Hardware Layer`的时候闪烁绿色，它应该在动画开始的时候闪烁一次（也就是`Layer`渲染初始化的时候），然而，如果你的`View`在整个动画期间都是绿色，那就是遇到失效的问题了。
 
-- 最后，`hardware layers`使用`GPU`内存，你当然不想出现内存泄漏的问题。所以你应该在必要的时候再去使用`hardware layers`，就想播放动画时。  
+- 最后，`hardware layers`使用`GPU`内存，你当然不想出现内存泄漏的问题。所以你应该在必要的时候再去使用`hardware layers`，就像播放动画时。  
 
 
 这里也没有硬性规则。`Android`渲染系统是非常复杂的。就像所有性能问题一样，测试才是关键。通过使用“显示硬件层更新”开发者选项来确定`layers`是在帮你还是害你。
@@ -126,4 +126,4 @@ mView.animate().translationX(150).withLayer().start();
 ---
 
 - 邮箱 ：charon.chui@gmail.com  
-- Good Luck! 
\ No newline at end of file
+- Good Luck! 
diff --git "a/Algorithm/1.\345\220\210\345\271\266\344\270\244\344\270\252\346\234\211\345\272\217\346\225\260\347\273\204.md" "b/Algorithm/1.\345\220\210\345\271\266\344\270\244\344\270\252\346\234\211\345\272\217\346\225\260\347\273\204.md"
new file mode 100644
index 00000000..2dc0dda4
--- /dev/null
+++ "b/Algorithm/1.\345\220\210\345\271\266\344\270\244\344\270\252\346\234\211\345\272\217\346\225\260\347\273\204.md"
@@ -0,0 +1,85 @@
+1.合并两个有序数组
+===
+
+
+### 题目
+
+给你两个按`非递减顺序`排列的整数数组`nums1`和`nums2`，另有两个整数`m`和`n`，分别表示`nums1`和`nums2`中的元素数目。        
+
+请你`合并`nums2到nums1中，使合并后的数组同样按非递减顺序排列。     
+
+注意：最终，合并后数组不应由函数返回，而是存储在数组nums1中。为了应对这种情况，nums1的初始长度为`m + n`，其中前m个元素表示应合并的元素，后n个元素为0，应忽略。nums2的长度为n。
+
+
+
+示例 1：
+
+输入：nums1 = [1,2,3,0,0,0], m = 3, nums2 = [2,5,6], n = 3
+输出：[1,2,2,3,5,6]
+解释：需要合并 [1,2,3] 和 [2,5,6] 。
+合并结果是 [1,2,2,3,5,6] ，其中斜体加粗标注的为 nums1 中的元素。
+
+示例 2: 
+
+输入：nums1 = [1], m = 1, nums2 = [], n = 0
+输出：[1]
+解释：需要合并 [1] 和 [] 。
+合并结果是 [1] 。
+
+示例 3：
+
+输入：nums1 = [0], m = 0, nums2 = [1], n = 1
+输出：[1]
+解释：需要合并的数组是 [] 和 [1] 。
+合并结果是 [1] 。
+注意，因为 m = 0 ，所以 nums1 中没有元素。nums1 中仅存的 0 仅仅是为了确保合并结果可以顺利存放到 nums1 中。
+
+
+
+### 思路
+
+逆向双指针:   
+- nums1中是非递减的数组。
+- nums2中也是非递减数组。
+- 所以我们要做的就是把nums1中前m个元素与nums2中的元素进行倒序比较，将大的值倒序放到nums1中的后面。
+- 因为nums1中的数据已经是非递减的了，所以等nums2中的内容都放置完就可以结束。
+
+```python
+class Solution:
+    def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:
+        index = m + n - 1
+        p1 = m - 1
+        p2 = n - 1
+        while p2 >= 0:
+            if p1 >= 0 and nums1[p1] >= nums2[p2]:
+                nums1[index] = nums1[p1]
+                index += 1
+                p1 -= 1
+            else:
+                nums1[index] = nums2[p2]
+                index += 1
+                p2 -= 1
+```
+
+```kotlin
+class Solution {
+    fun merge(nums1: IntArray, m: Int, nums2: IntArray, n: Int): Unit {
+        var index = nums1.lastIndex
+        var r1 = m - 1
+        var r2 = n - 1
+        while(r2 >= 0) {
+            if (r1 >= 0 && nums1[r1] >= nums2[r2]) {
+                nums1[index --] = nums1[r1--]
+            } else {
+                nums1[index --] = nums2[r2 --]
+            } 
+        }
+    }
+}
+```
+
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	
diff --git "a/Algorithm/10.\350\267\263\350\267\203\346\270\270\346\210\217II.md" "b/Algorithm/10.\350\267\263\350\267\203\346\270\270\346\210\217II.md"
new file mode 100644
index 00000000..0e95d5fa
--- /dev/null
+++ "b/Algorithm/10.\350\267\263\350\267\203\346\270\270\346\210\217II.md"
@@ -0,0 +1,65 @@
+10.跳跃游戏II
+===
+
+
+### 题目
+
+给定一个长度为 n 的 0 索引整数数组 nums。初始位置为 nums[0]。
+
+每个元素 nums[i] 表示从索引 i 向后跳转的最大长度。换句话说，如果你在 nums[i] 处，你可以跳转到任意 nums[i + j] 处:       
+
+- 0 <= j <= nums[i] 
+- i + j < n
+返回到达 nums[n - 1] 的最小跳跃次数。生成的测试用例可以到达 nums[n - 1]。
+
+ 
+
+示例 1:
+
+- 输入: nums = [2,3,1,1,4]
+- 输出: 2
+- 解释: 跳到最后一个位置的最小跳跃数是 2。
+    - 从下标为 0 跳到下标为 1 的位置，跳 1 步，然后跳 3 步到达数组的最后一个位置。
+
+示例 2:     
+
+- 输入: nums = [2,3,0,1,4]
+- 输出: 2
+
+
+### 思路
+
+
+贪心的思路，局部最优：当前可移动距离尽可能多走，如果还没到终点，步数再加一。整体最优：一步尽可能多走，从而达到最少步数。     
+
+所以真正解题的时候，要从覆盖范围出发，不管怎么跳，覆盖范围内一定是可以跳到的，以最小的步数增加覆盖范围，覆盖范围一旦覆盖了终点，得到的就是最少步数！
+
+这里需要统计两个覆盖范围，当前这一步的最大覆盖和下一步最大覆盖。
+
+- 如下图，开始的位置是 2，可跳的范围是橙色的。然后因为 3 可以跳的更远，所以跳到 3 的位置。      
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/jump_2_1.png?raw=true)
+- 然后现在的位置就是 3 了，能跳的范围是橙色的，然后因为 4 可以跳的更远，所以下次跳到 4 的位置。     
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/jump_2_2.png?raw=true)
+
+
+```python
+
+class Solution:
+    def jump(self, nums: List[int]) -> int:
+        end = 0
+        maxPosition = 0
+        steps = 0
+        for i in range(len(nums) - 1):
+            maxPosition = max(maxPosition, i + nums[i])
+            if i == end:
+                steps += 1
+                end = maxPosition
+                
+        return steps       
+```
+
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	
diff --git "a/Algorithm/11.H\346\214\207\346\225\260.md" "b/Algorithm/11.H\346\214\207\346\225\260.md"
new file mode 100644
index 00000000..20afa38a
--- /dev/null
+++ "b/Algorithm/11.H\346\214\207\346\225\260.md"
@@ -0,0 +1,232 @@
+11.H指数
+===
+
+
+### 题目
+
+给你一个整数数组 citations ，其中 citations[i] 表示研究者的第 i 篇论文被引用的次数。计算并返回该研究者的 h 指数。
+
+根据维基百科上 h 指数的定义：h 代表“高引用次数” ，一名科研人员的 h 指数 是指他（她）至少发表了 h 篇论文，并且 至少 有 h 篇论文被引用次数大于等于 h 。如果 h 有多种可能的值，h 指数 是其中最大的那个。
+
+ 
+
+示例 1:     
+
+- 输入：citations = [3,0,6,1,5]
+- 输出：3 
+- 解释：给定数组表示研究者总共有 5 篇论文，每篇论文相应的被引用了 3, 0, 6, 1, 5 次。
+    - 由于研究者有 3 篇论文每篇 至少 被引用了 3 次，其余两篇论文每篇被引用 不多于 3 次，所以她的 h 指数是 3。
+
+示例 2:     
+
+- 输入：citations = [1,3,1]
+- 输出：1
+
+### 思路
+
+翻译： 数组中有h个不小于h的值，求最大的h
+
+
+至少有h篇论文，每一篇至少被引用次数为h，听起来很绕，但是以用例[0, 1, 3, 5, 6]来分析： 
+
+- h指数无非就是5或4或3或2或1或0
+
+- 那么如果数组中最小的引用次数都大于等于5，那么其他的不用看了，h就是取最大值5
+
+- 如果最小值不满足，那么如果数组中倒数第二小值如果大于等于4，那么一定有4个是大于等于4的
+
+- 这就是h指数
+
+
+
+
+
+##### 方法一：排序
+
+h肯定不会超过数组的长度。
+
+[0, 1, 3, 5, 6]
+
+- 从小到大排序。
+- 排序后从头开始遍历，如果最小的值，都大于数组的size，那就是size
+- 如果上面不满足，那第二小的值如果大于数组的size - 1，那就是size - 1
+- 所以遍历条件就是 for (int i = 0; i < size; i ++ ) { if (nums[i] >= size - 1)}
+- 遍历排序后的数组，如果数组中该位置的值>h，那就h++然后继续遍历下一个
+
+```java
+public int hIndex(int[] citations) {
+   Arrays.sort(citations);
+   for(int i = 0; i < citations.length; i++){
+       if( citations[i] >= (citations.length -i)){
+           return  citations.length -i;
+       }
+   }
+   return 0;
+}
+```
+
+
+最终的时间复杂度与排序算法的时间复杂度有关
+
+复杂度分析:     
+
+- 时间复杂度：O(nlogn)，其中 n 为数组 citations 的长度。即为排序的时间复杂度。
+
+- 空间复杂度：O(logn)，其中 n 为数组 citations 的长度。即为排序的空间复杂度。
+
+
+##### 方法二：计数排序
+
+根据上述解法我们发现，最终的时间复杂度与排序算法的时间复杂度有关。
+
+所以我们可以使用计数排序算法，新建并维护一个数组 counter 用来记录当前引用次数的论文有几篇。它的值可以是0 ~ n，所以数组的长度是n + 1
+
+[0, 1, 3, 5, 6]
+
+
+- 我们遍历数组 citations，将引用次数大于 n 的论文都当作引用次数为 n 的论文，然后将每篇论文的引用次数作为下标，将 cnt 中对应的元素值加 1。这样我们就统计出了每个引用次数对应的论文篇数。
+
+```
+counter[0] = 1
+counter[1] = 1
+counter[2] = 0
+counter[3] = 1
+// 无值，默认0
+counter[4] = 0
+// 引用次数为5的论文有2篇
+counter[5] = 2
+```
+
+- 最后我们可以从后向前遍历数组 counter，因为要找最大的H值，所以这个时候要倒序从n到0遍历遍历，找出从后往前遍历时第一个满足引用次数>i的值，就是最大的h值。
+
+- 注意要用累加，因为引用次数为5的2篇，一定也能满足引用次数>=3的条件
+
+```java
+public class Solution {
+    public int hIndex(int[] citations) {
+        int n = citations.length, tot = 0;
+        int[] counter = new int[n + 1];
+        for (int i = 0; i < n; i++) {
+            if (citations[i] >= n) {
+                counter[n]++;
+            } else {
+                counter[citations[i]]++;
+            }
+        }
+        for (int i = n; i >= 0; i--) {
+            tot += counter[i];
+            if (tot >= i) {
+                return i;
+            }
+        }
+        return 0;
+    }
+}
+```
+
+复杂度分析:    
+
+- 时间复杂度：O(n)，其中 n 为数组 citations 的长度。需要遍历数组 citations 一次，以及遍历长度为 n+1 的数组 counter 一次。
+
+- 空间复杂度：O(n)，其中 n 为数组 citations 的长度。需要创建长度为 n+1 的数组 counter。
+
+
+##### 方法三：二分法
+
+所谓的 h 指数是指一个具体的数值，该数值为“最大”的满足「至少发表了 x 篇论文，且每篇论文至少被引用 x 次」定义的合法数，重点是“最大”。
+
+给定所有论文的引用次数情况为[3,0,6,1,5]，可统计满足定义的数值有哪些:     
+
+```
+h=0，含义为「至少发表了 0 篇，且这 0 篇论文至少被引用 0 次」，空集即满足，恒成立；
+
+h=1，含义为「至少发表了 1 篇，且这 1 篇论文至少被引用 1 次」，可以找到这样的组合，如 [3]，成立；
+
+h=2，含义为「至少发表了 2 篇，且这 2 篇论文至少被引用 2 次」，可以找到这样的组合，如 [3, 6]，成立；
+
+h=3，含义为「至少发表了 3 篇，且这 3 篇论文至少被引用 3 次」，可以找到这样的组合，如 [3, 6, 5]，成立；
+
+h=4，含义为「至少发表了 4 篇，且这 4 篇论文至少被引用 4 次」，找不到这样的组合，不成立；
+
+h=5，含义为「至少发表了 5 篇，且这 5 篇论文至少被引用 5 次」，找不到这样的组合，不成立；
+```
+实际上，当遇到第一个无法满足的数时，更大的数值就没必要找了。
+
+
+基于此分析，我们发现对于任意的 citations数组（论文总数量为该数组长度 n），都必然对应了一个最大的 h 值，且小于等于该 h 值的情况均满足，大于该 h 值的均不满足。
+
+那么，在以最大 h 值为分割点的数轴上具有「二段性」，可通过「二分」求解该分割点（答案）。
+
+最后考虑在什么值域范围内进行二分？
+
+一个合格的二分范围，仅需确保答案在此范围内即可。
+
+再回看我们关于 h 的定义「至少发表了 x 篇论文，且每篇论文至少被引用 x 次」
+综上，我们只需要在 [0,n] 范围进行二分即可。
+
+
+设查找范围的初始左边界 left 为 0，初始右边界 right 为 n。每次在查找范围内取中点 mid，同时扫描整个数组，判断是否至少有 mid 个数大于 mid。如果有，说明要寻找的 h 在搜索区间的右边，反之则在左边。
+
+二分的本质：前半部分符合要求、后半部分不符合要求，找出符合要求的最大索引
+
+
+```java
+class Solution {
+    public int hIndex(int[] cs) {
+        int n = cs.length;
+        int l = 0, r = n;
+        while (l < r) {
+        	// 加1 是为了防止死循环
+            int mid = (l + r + 1) >> 1;
+            if (check(cs, mid)) l = mid;
+            else r = mid - 1;
+        }
+        return r;
+    }
+    // 判断是否存在至少mid篇论文的引用次数至少为mid。
+    boolean check(int[] cs, int mid) {
+        int ans = 0;
+        for (int i : cs) if (i >= mid) ans++;
+        return ans >= mid;
+    }
+}
+```
+
+
+
+###### 上面为什么要加1
+
+- 这是因为整数除法的向下取整特性。
+- 在计算mid时，如果使用(l+r)/2，当l和r相邻时（例如l=2, r=3），则mid=(2+3)/2=2（整数除法向下取整）。
+- 如果此时check(mid)为真，那么我们会执行l=mid，即l=2，然后循环继续，再次计算mid=(2+3)/2=2，这样就进入了死循环。
+
+为了避免这种死循环，我们使用(l + r + 1) / 2，使得当l和r相邻时，mid会等于r（因为(2+3+1)/2=6/2=3），然后无论走哪个分支，循环都会结束（因为执行l=3后l等于r，或执行r=mid-1=2后l等于r）。
+所以，加1是为了避免在只剩两个数时陷入死循环，因为我们要找的是右边界（最大值）。
+
+
+
+###### 例子：
+
+- citations = [3,0,6,1,5]，用上述二分法：
+- 初始化：l=0, r=5
+- mid = (0+5+1)/2 = 3，检查check(3): 统计>=3的个数，为3（3,5,6）-> 满足，所以l=3
+- 接下来：l=3, r=5，mid=(3+5+1)/2=9/2=4（整数除法取整为4），检查check(4):统计>=4的个数，有2篇（5,6）不满足4（因为需要至少4篇）
+- 所以r=3循环结束，返回3。
+
+
+
+
+复杂度分析:     
+
+- 时间复杂度：O(nlogn)，其中 n 为数组 citations 的长度。需要进行 logn 次二分搜索，每次二分搜索需要遍历数组 citations 一次。
+- 空间复杂度：O(1)，只需要常数个变量来进行二分搜索。
+
+
+
+
+
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	
diff --git "a/Algorithm/12.O(1) \346\227\266\351\227\264\346\217\222\345\205\245\343\200\201\345\210\240\351\231\244\345\222\214\350\216\267\345\217\226\351\232\217\346\234\272\345\205\203\347\264\240.md" "b/Algorithm/12.O(1) \346\227\266\351\227\264\346\217\222\345\205\245\343\200\201\345\210\240\351\231\244\345\222\214\350\216\267\345\217\226\351\232\217\346\234\272\345\205\203\347\264\240.md"
new file mode 100644
index 00000000..68b25643
--- /dev/null
+++ "b/Algorithm/12.O(1) \346\227\266\351\227\264\346\217\222\345\205\245\343\200\201\345\210\240\351\231\244\345\222\214\350\216\267\345\217\226\351\232\217\346\234\272\345\205\203\347\264\240.md"	
@@ -0,0 +1,105 @@
+12.O(1) 时间插入、删除和获取随机元素
+===
+
+
+### 题目
+
+实现RandomizedSet类:      
+
+- RandomizedSet() 初始化 RandomizedSet 对象      
+- bool insert(int val) 当元素 val 不存在时，向集合中插入该项，并返回 true ；否则，返回 false 。
+- bool remove(int val) 当元素 val 存在时，从集合中移除该项，并返回 true ；否则，返回 false 。
+- int getRandom() 随机返回现有集合中的一项（测试用例保证调用此方法时集合中至少存在一个元素）。每个元素应该有 相同的概率 被返回。
+
+你必须实现类的所有函数，并满足每个函数的 平均 时间复杂度为 O(1) 。
+
+ 
+
+示例:      
+
+- 输入["RandomizedSet", "insert", "remove", "insert", "getRandom", "remove", "insert", "getRandom"]
+- [[], [1], [2], [2], [], [1], [2], []]
+- 输出[null, true, false, true, 2, true, false, 2]
+
+解释:    
+```
+RandomizedSet randomizedSet = new RandomizedSet();
+randomizedSet.insert(1); // 向集合中插入 1 。返回 true 表示 1 被成功地插入。
+randomizedSet.remove(2); // 返回 false ，表示集合中不存在 2 。
+randomizedSet.insert(2); // 向集合中插入 2 。返回 true 。集合现在包含 [1,2] 。
+randomizedSet.getRandom(); // getRandom 应随机返回 1 或 2 。
+randomizedSet.remove(1); // 从集合中移除 1 ，返回 true 。集合现在包含 [2] 。
+randomizedSet.insert(2); // 2 已在集合中，所以返回 false 。
+randomizedSet.getRandom(); // 由于 2 是集合中唯一的数字，getRandom 总是返回 2 。
+``` 
+
+提示:       
+
+- -231 <= val <= 231 - 1
+- 最多调用 insert、remove 和 getRandom 函数 2 * 105 次
+- 在调用 getRandom 方法时，数据结构中 至少存在一个 元素。
+
+### 思路
+
+
+题目要求插入、删除、随机的时间复杂度为 O(1) 。
+
+- 变长数组可以在 O(1) 的时间内完成获取随机元素操作，但是由于无法在 O(1) 的时间内判断元素是否存在，因此不能在 O(1) 的时间内完成插入和删除操作。       
+- 哈希表可以在 O(1) 的时间内完成插入和删除操作，但是由于无法根据下标定位到特定元素，因此不能在 O(1) 的时间内完成获取随机元素操作。      
+- 为了满足插入、删除和获取随机元素操作的时间复杂度都是 O(1)，需要将变长数组和哈希表结合，变长数组中存储元素，哈希表中存储每个元素在变长数组中的下标。
+
+```java
+class RandomizedSet {
+    List<Integer> nums;
+    Map<Integer, Integer> indices;
+    Random random;
+
+    public RandomizedSet() {
+        nums = new ArrayList<Integer>();
+        indices = new HashMap<Integer, Integer>();
+        random = new Random();
+    }
+
+    public boolean insert(int val) {
+        if (indices.containsKey(val)) {
+            return false;
+        }
+        int index = nums.size();
+        nums.add(val);
+        indices.put(val, index);
+        return true;
+    }
+
+    public boolean remove(int val) {
+        if (!indices.containsKey(val)) {
+            return false;
+        }
+        int index = indices.get(val);
+        int last = nums.get(nums.size() - 1);
+        nums.set(index, last);
+        indices.put(last, index);
+        nums.remove(nums.size() - 1);
+        indices.remove(val);
+        return true;
+    }
+
+    public int getRandom() {
+        int randomIndex = random.nextInt(nums.size());
+        return nums.get(randomIndex);
+    }
+}
+```
+
+
+复杂度分析:    
+
+- 时间复杂度：初始化和各项操作的时间复杂度都是 O(1)。
+
+- 空间复杂度：O(n)，其中 n 是集合中的元素个数。存储元素的数组和哈希表需要 O(n) 的空间。
+
+
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	
diff --git "a/Algorithm/13.\351\231\244\350\207\252\350\272\253\344\273\245\345\244\226\346\225\260\347\273\204\347\232\204\344\271\230\347\247\257.md" "b/Algorithm/13.\351\231\244\350\207\252\350\272\253\344\273\245\345\244\226\346\225\260\347\273\204\347\232\204\344\271\230\347\247\257.md"
new file mode 100644
index 00000000..abff28d0
--- /dev/null
+++ "b/Algorithm/13.\351\231\244\350\207\252\350\272\253\344\273\245\345\244\226\346\225\260\347\273\204\347\232\204\344\271\230\347\247\257.md"
@@ -0,0 +1,128 @@
+13.除自身以外数组的乘积
+===
+
+
+### 题目
+
+给你一个整数数组nums，返回数组answer，其中answer[i]等于nums中除nums[i]之外其余各元素的乘积。     
+
+题目数据保证数组nums之中任意元素的全部前缀元素和后缀的乘积都在32位整数范围内。    
+
+请***不要使用除法***，且在O(n)时间复杂度内完成此题。
+
+ 
+
+示例 1:     
+
+- 输入: nums = [1,2,3,4]
+- 输出: [24,12,8,6]
+
+示例 2:    
+
+- 输入: nums = [-1,1,0,-3,3]
+- 输出: [0,0,9,0,0]
+ 
+
+提示:    
+
+- 2 <= nums.length <= 105
+- -30 <= nums[i] <= 30
+- 输入 保证 数组 answer[i] 在  32 位 整数范围内
+
+### 思路
+
+
+先计算数组中所有元素的乘积，然后将总的乘积除以数组的中每个元素x就是除自身值以外数组的乘积。     
+
+但是这样有个问题，如果数组中有一个元素是0，那这个方法就失效了，而且题目中说了不能使用除法运算。 
+
+我们可以分解为两部分： 
+
+- 得到索引左侧所有数字的乘积L
+- 得到索引右侧所有数字的乘积R
+- 两部分相乘
+
+
+```java
+
+class Solution {
+    public int[] productExceptSelf(int[] nums) {
+        int length = nums.length;
+
+        // L 和 R 分别表示左右两侧的乘积列表
+        int[] L = new int[length];
+        int[] R = new int[length];
+
+        int[] answer = new int[length];
+
+        // L[i] 为索引 i 左侧所有元素的乘积
+        // 对于索引为 '0' 的元素，因为左侧没有元素，所以 L[0] = 1
+        L[0] = 1;
+        for (int i = 1; i < length; i++) {
+            L[i] = nums[i - 1] * L[i - 1];
+        }
+
+        // R[i] 为索引 i 右侧所有元素的乘积
+        // 对于索引为 'length-1' 的元素，因为右侧没有元素，所以 R[length-1] = 1
+        R[length - 1] = 1;
+        for (int i = length - 2; i >= 0; i--) {
+            R[i] = nums[i + 1] * R[i + 1];
+        }
+
+        // 对于索引 i，除 nums[i] 之外其余各元素的乘积就是左侧所有元素的乘积乘以右侧所有元素的乘积
+        for (int i = 0; i < length; i++) {
+            answer[i] = L[i] * R[i];
+        }
+
+        return answer;
+    }
+}
+```
+
+复杂度分析:   
+
+- 时间复杂度：O(N)，其中 N 指的是数组 nums 的大小。预处理 L 和 R 数组以及最后的遍历计算都是 O(N) 的时间复杂度。
+- 空间复杂度：O(N)，其中 N 指的是数组 nums 的大小。使用了 L 和 R 数组去构造答案，L 和 R 数组的长度为数组 nums 的大小。
+
+
+尽管上面的方法已经能够很好的解决这个问题，但是空间复杂度并不为常数。
+
+- 由于输出数组不算在空间复杂度内，那么我们可以将 L 或 R 数组用输出数组来计算。也就是不再新申请L和R数组，而只是用一个变量记录索引右侧元素的乘积之和。
+- 第一遍遍历的时候将answer数组的值都填充为索引左侧元素的值(也就是上面方法中L的值)
+- 再一次后续遍历的时候取answer中的值和数组索引右侧元素乘积的和值相乘并赋值到answer中。这个时候answer中的值就已经是乘积的和值了。
+
+
+```java
+class Solution {
+   public int[] productExceptSelf(int[] nums) {
+       int n = nums.length;
+       int[] ans = new int[n];
+       //初始化ans都为1
+       for (int i = 0; i < n; i++) {
+           ans[i] = 1;
+       }
+       //左侧
+       int L = 1;
+       for(int i = 0; i < n; i++){
+           ans[i] *= L;
+           L *= nums[i];
+       }
+       //右侧
+       int R = 1;
+       for(int i = n - 1; i >= 0; i--){
+           ans[i] *= R;
+           R *= nums[i];
+       }
+       return ans;
+   } 
+}
+```
+
+
+
+
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	
diff --git "a/Algorithm/14.\345\212\240\346\262\271\347\253\231.md" "b/Algorithm/14.\345\212\240\346\262\271\347\253\231.md"
new file mode 100644
index 00000000..8debb624
--- /dev/null
+++ "b/Algorithm/14.\345\212\240\346\262\271\347\253\231.md"
@@ -0,0 +1,143 @@
+14.加油站
+===
+
+
+### 题目
+
+在一条环路上有 n 个加油站，其中第 i 个加油站有汽油 gas[i] 升。
+
+你有一辆油箱容量无限的的汽车，从第 i 个加油站开往第 i+1 个加油站需要消耗汽油 cost[i] 升。你从其中的一个加油站出发，开始时油箱为空。
+
+给定两个整数数组 gas 和 cost ，如果你可以按顺序绕环路行驶一周，则返回出发时加油站的编号，否则返回 -1 。如果存在解，则 保证 它是 唯一 的。
+
+ 
+
+示例 1:    
+
+- 输入: gas = [1,2,3,4,5], cost = [3,4,5,1,2]
+- 输出: 3
+- 解释:
+    - 从 3 号加油站(索引为 3 处)出发，可获得 4 升汽油。此时油箱有 = 0 + 4 = 4 升汽油
+    - 开往 4 号加油站，此时油箱有 4 - 1 + 5 = 8 升汽油
+    - 开往 0 号加油站，此时油箱有 8 - 2 + 1 = 7 升汽油
+    - 开往 1 号加油站，此时油箱有 7 - 3 + 2 = 6 升汽油
+    - 开往 2 号加油站，此时油箱有 6 - 4 + 3 = 5 升汽油
+    - 开往 3 号加油站，你需要消耗 5 升汽油，正好足够你返回到 3 号加油站。
+
+因此，3 可为起始索引。
+
+示例 2:      
+
+- 输入: gas = [2,3,4], cost = [3,4,3]
+- 输出: -1
+- 解释:       
+    - 你不能从 0 号或 1 号加油站出发，因为没有足够的汽油可以让你行驶到下一个加油站。
+    - 我们从 2 号加油站出发，可以获得 4 升汽油。 此时油箱有 = 0 + 4 = 4 升汽油
+    - 开往 0 号加油站，此时油箱有 4 - 3 + 2 = 3 升汽油
+    - 开往 1 号加油站，此时油箱有 3 - 3 + 3 = 3 升汽油
+    - 你无法返回 2 号加油站，因为返程需要消耗 4 升汽油，但是你的油箱只有 3 升汽油。
+
+因此，无论怎样，你都不可能绕环路行驶一周。
+ 
+
+提示:     
+
+- n == gas.length == cost.length
+- 1 <= n <= 105
+- 0 <= gas[i], cost[i] <= 104
+- 输入保证答案唯一。
+
+### 思路
+
+- 题目有一点很重要： 如果存在解，则 保证 它是 唯一 的。
+- 能跑一圈的前提有两个:     
+    - 每一站的油量都能达到下一站
+    - 一圈下来剩下的油量是大于等于0的
+
+- 我们首先检查第 0 个加油站，并试图判断能否环绕一周；如果不能，就从第一个无法到达的加油站开始继续检查。
+
+
+```python
+class Solution:
+    def canCompleteCircuit(self, gas: List[int], cost: List[int]) -> int:
+        n = len(gas)
+        start = 0
+        while start < n:
+            cur = 0
+            step = 0
+            while step < n:
+                nex = (start + step) % n
+                cur += gas[nex] - cost[nex]
+                # 走到这一步的时候当前的油量< 0了。需要更新起始的站，重新从下一站开始来计算了
+                if cur < 0:
+                    break
+                # 走下一步    
+                step += 1
+            # 走了n步，也就是一圈了
+            if step == n:
+                return start
+            else:
+                # 没走了，一圈，从当前已经走的步数继续遍历找
+                start = start + step + 1
+        return -1
+```
+
+
+##### 注意: 为什么使用 start += step + 1 而不是 start += 1？
+
+​如果从起点 start 出发，在走了 step 步后失败（无法到达第 step+1 个加油站），那么从 start 到 start+step 之间的任意一个加油站作为新起点都一定会失败。
+对于任意k在[start + 1, start + step]: 
+
+- 如果从 k 出发，我们失去了 start → k 这段路的油量积累（由问题性质决定）。
+- 由于 start → k 这段的油量积累 ​必然是非负的​（因为如果这段是负的，那在 k 之前就已经失败了）。
+- 因此，当从 k 开始时，油量比从 start 开始更少，不可能完成接下来的路程。
+
+使用 start += step + 1 是基于数学性质的优化，避免了无效的重复检查。
+改为 start += 1 虽然逻辑正确，但会退化为 O(n²) 的暴力解法，在大型数据集上效率极低。
+
+
+
+复杂度分析:      
+
+- 时间复杂度：O(N)，其中 N 为数组的长度。我们对数组进行了单次遍历。
+
+- 空间复杂度：O(1)。
+
+
+##### 方法二
+
+
+
+允许油量为负，但是总剩余油量应该大于等于0，否则不存在解的。
+
+存在解的情况下，利用贪心法的思想，找到最低点，它的下一个点出发的话，可以保证前期得到剩余油量最大，所以可以跑完全程。
+
+```java
+public int canCompleteCircuit2(int[] gas, int[] cost) {
+    // 一圈下来的总剩余油量
+    int totalNum = 0;
+    // 从某一站开始时每一站剩余的油量
+    int curNum = 0;
+    int idx = 0;
+
+    for (int i = 0; i < gas.length; i++) {
+        curNum += gas[i] - cost[i];
+        totalNum += gas[i] - cost[i];
+        if (curNum < 0) {
+            idx = (i+1) % gas.length;
+            curNum = 0;
+        }
+
+    }
+
+    if(totalNum < 0) return -1;
+    return idx;
+}
+```
+
+
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	
diff --git "a/Algorithm/15.\345\210\206\345\217\221\347\263\226\346\236\234.md" "b/Algorithm/15.\345\210\206\345\217\221\347\263\226\346\236\234.md"
new file mode 100644
index 00000000..b74a91ed
--- /dev/null
+++ "b/Algorithm/15.\345\210\206\345\217\221\347\263\226\346\236\234.md"
@@ -0,0 +1,174 @@
+15.分发糖果
+===
+
+
+### 题目
+
+n 个孩子站成一排。给你一个整数数组 ratings 表示每个孩子的评分。      
+ 
+你需要按照以下要求，给这些孩子分发糖果:    
+
+- 每个孩子至少分配到 1 个糖果。
+- 相邻两个孩子评分更高的孩子会获得更多的糖果。
+- 请你给每个孩子分发糖果，计算并返回需要准备的 最少糖果数目 。
+
+ 
+
+示例 1:    
+
+- 输入：ratings = [1,0,2]
+- 输出：5
+- 解释：你可以分别给第一个、第二个、第三个孩子分发 2、1、2 颗糖果。
+
+示例 2:   
+
+- 输入：ratings = [1,2,2]
+- 输出：4
+- 解释：你可以分别给第一个、第二个、第三个孩子分发 1、2、1 颗糖果。
+     第三个孩子只得到 1 颗糖果，这满足题面中的两个条件。
+ 
+
+提示:     
+
+- n == ratings.length
+- 1 <= n <= 2 * 104
+- 0 <= ratings[i] <= 2 * 104
+
+### 思路
+
+注意题目要求的是最少的糖果数目，且每个孩子至少分配1个糖果。      
+
+我们默认把所有小孩的糖果都是1。    
+
+那么本题我采用了两次贪心的策略:     
+
+
+- 第一次从左到右遍历，如果当前孩子评分高于左边孩子，那么当前孩子比左边多一个糖果；否则不处理，只保留一个糖果。
+    - 左规则：当`ratings[i−1]<ratings[i]`时，i号学生的糖果数量将比i−1号孩子的糖果数量多。我们让left[i]=left[i−1]+1
+- 第二次从右到左遍历，如果当前孩子评分高于右边孩子，那么取 “当前值” 与 “右侧糖果 +1” 中的最大值；否则不予处理。
+    - 右规则：当`ratings[i]>ratings[i+1]`时，i号学生的糖果数量将比i+1号孩子的糖果数量多。
+
+
+我们遍历该数组两次，处理出每一个学生分别满足左规则或右规则时，最少需要被分得的糖果数量。每个人最终分得的糖果数量即为这两个数量的最大值。
+
+在实际代码中，我们先计算出左规则left数组，在计算右规则的时候只需要用单个变量记录当前位置的右规则，同时计算答案即可。
+
+```java
+class Solution {
+    public int candy(int[] ratings) {
+        int n = ratings.length;
+        int[] left = new int[n];
+        for (int i = 0; i < n; i++) {
+            if (i > 0 && ratings[i] > ratings[i - 1]) {
+                left[i] = left[i - 1] + 1;
+            } else {
+                left[i] = 1;
+            }
+        }
+        int right = 0, ret = 0;
+        for (int i = n - 1; i >= 0; i--) {
+            if (i < n - 1 && ratings[i] > ratings[i + 1]) {
+                right++;
+            } else {
+                right = 1;
+            }
+            ret += Math.max(left[i], right);
+        }
+        return ret;
+    }
+}
+```
+
+```python
+class Solution:
+    def candy(self, ratings: List[int]) -> int:
+        n = len(ratings)
+        candies = [1] * n  # 每个孩子至少一个糖果
+
+        # 从左到右：右边评分高，则右边糖果 = 左边糖果 + 1
+        for i in range(1, n):
+            if ratings[i] > ratings[i - 1]:
+                candies[i] = candies[i - 1] + 1
+
+        # 从右到左：左边评分高，则左边糖果 = max(当前左边糖果, 右边糖果 + 1)
+        for i in range(n - 2, -1, -1):
+            if ratings[i] > ratings[i + 1]:
+                candies[i] = max(candies[i], candies[i + 1] + 1)
+
+        return sum(candies)  # 返回总糖果数
+```        
+
+
+复杂度分析:     
+
+- 时间复杂度：O(n)，其中 n 是孩子的数量。我们需要遍历两次数组以分别计算满足左规则或右规则的最少糖果数量。
+
+- 空间复杂度：O(n)，其中 n 是孩子的数量。我们需要保存所有的左规则对应的糖果数量。
+
+##### 方法二： 一次遍历
+
+
+
+在上面的方法中，我们只考虑了递增段的处理，没有考虑如何处理递减段，所以才必须使用两次遍历，那该如何将递减段的处理一同加入呢？
+
+分析一下，如果当前孩子的ratings[i]比左侧孩子的ratings[i-1]更小，到底该分配多大的值？这取决于这个递减段的长度。
+
+- 显然，如果i是最右侧的孩子，他可以只分配1颗糖果；
+- 如果i是倒数第二个孩子，右侧还有一个递减，那么他最少分配2颗糖果。
+
+核心思路：遍历数组时，跟踪当前是上升趋势、下降趋势，还是平；对于连续下降段，不立即分糖果，而是等下降结束后一次性累加。
+观察下降的规律，因为不处理的话就是默认分配1。如果下降长度为k，则需要补上1+2+....+k，即k * (k + 1) / 2颗糖果。 
+
+举个例子，假设ratings=[1,3,4,1]，从左往右处理时，得到cadies=[1,2,3]。我们发现，下降段是[4,1]，长度为1，所以补上1颗糖果，将数组变为
+candies=[1,2,3,1]。
+
+特别的，如果下降长度 >= 上升长度，需要为“山峰”孩子多加一个糖果。    
+
+举个例子，假设ratings=[1,2,4,3,2,1]，从左往右处理时，得到cadies=[1,2,3]。    
+我们发现，下降段的长度为3，比上升段还长。   
+
+如果仅按照之前的处理，得到candies=[1,2,3,3,2,1]。实际上，第一个3应该变为4，也即山峰更高才对，正确的结果是candies=[1,2,4,3,2,1]。
+
+代码如下:   
+
+
+```java
+class Solution {
+    public int candy(int[] ratings) {
+        int n = ratings.length;
+        int total = 1;      // 第一个孩子至少一个糖果
+        int up = 0;         // 上升序列长度
+        int down = 0;       // 下降序列长度
+        int peak = 0;       // 当前上升段的长度峰值
+
+        for (int i = 1; i < n; i++) {
+            if (ratings[i] > ratings[i - 1]) {  // 上升
+                up++;
+                peak = up;
+                down = 0;
+                total += 1 + up;  // 当前孩子比前一个多一颗糖果
+            } else if (ratings[i] == ratings[i - 1]) {  // 平
+                up = down = peak = 0;
+                total += 1;  // 持平，默认为1
+            } else {  // 下降
+                up = 0;
+                down++;
+                // 如果下降长度超过了之前的上升峰值，需要额外补偿
+                total += 1 + down - (peak >= down ? 1 : 0);
+            }
+        }
+
+        return total;
+    }
+}
+```
+
+- 时间复杂度： O(n)，其中 n为孩子总数
+- 空间复杂度： O(1)，仅使用常数个额外变量
+
+
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	
diff --git "a/Algorithm/16.\346\216\245\351\233\250\346\260\264.md" "b/Algorithm/16.\346\216\245\351\233\250\346\260\264.md"
new file mode 100644
index 00000000..0a86815c
--- /dev/null
+++ "b/Algorithm/16.\346\216\245\351\233\250\346\260\264.md"
@@ -0,0 +1,149 @@
+16.接雨水
+===
+
+
+### 题目
+
+给定n个非负整数表示每个宽度为1的柱子的高度图，计算按此排列的柱子，下雨之后能接多少雨水。
+
+示例 1:    
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/rainwatertrap_1.png?raw=true)
+
+- 输入：height = [0,1,0,2,1,0,1,3,2,1,2,1]
+- 输出：6
+- 解释：上面是由数组 [0,1,0,2,1,0,1,3,2,1,2,1] 表示的高度图，在这种情况下，可以接 6 个单位的雨水（蓝色部分表示雨水）。 
+
+示例 2:     
+
+- 输入：height = [4,2,0,3,2,5]
+- 输出：9
+
+
+### 思路
+
+##### 方法一：动态规划
+
+- 对于下标i，下雨后水能到达的***最大高度***等于下标i两边的最大高度的最小值，
+- 下标i处能接的雨水量等于下标i处的水能到达的***最大高度***减去height[i]。
+- 朴素的做法是对于数组height中的每个元素，分别向左和向右扫描并记录左边和右边的最大高度，然后计算每个下标位置能接的雨水量。
+
+
+上述做法的时间复杂度较高是因为需要对每个下标位置都向两边扫描。如果已经知道每个位置两边的最大高度，则可以在 O(n) 的时间内得到能接的雨水总量。使用动态规划的方法，可以在 O(n) 的时间内预处理得到每个位置两边的最大高度。
+
+- 创建两个长度为n的数组leftMax(存储每个位置左侧的最高柱子高度)和rightMax(存储每个位置右侧的最高柱子高度)。
+- 对于leftMax[i]表示下标i及其左边的位置中，柱子的最大高度
+- rightMax[i]表示下标i及其右边的位置中，柱子的最大高度。
+- 显然，leftMax[0]=height[0]，rightMax[n−1]=height[n−1]。
+- 两个数组的其余元素的计算如下:    
+    - 从左到右遍历，保障每次leftMax[i-1]是截止当前左边最大的。当1≤i≤n−1时，leftMax[i]=max(leftMax[i−1],height[i])；
+    - 从右到左遍历，保障每次rightMax[i+1]是截止当前右边最大的。当0≤i≤n−2时，rightMax[i]=max(rightMax[i+1],height[i])。
+
+- 在得到数组leftMax和rightMax的每个元素值之后，对于下标i处能接的雨水量等于`min(leftMax[i],rightMax[i])−height[i]`。遍历累加每个下标位置即可得到能接的雨水总量。
+
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/rainbow_2.png?raw=true)
+
+
+```java
+class Solution {
+    public int trap(int[] height) {
+        int n = height.length;
+        if (n == 0) {
+            return 0;
+        }
+
+        int[] leftMax = new int[n];
+        leftMax[0] = height[0];
+        for (int i = 1; i < n; i++) {
+            leftMax[i] = Math.max(leftMax[i - 1], height[i]);
+        }
+
+        int[] rightMax = new int[n];
+        rightMax[n - 1] = height[n - 1];
+        for (int i = n - 2; i >= 0; i--) {
+            rightMax[i] = Math.max(rightMax[i + 1], height[i]);
+        }
+
+        int ans = 0;
+        for (int i = 0; i < n; i++) {
+            // 左右最小边界决定能存水的高度
+            int minBound = Math.min(leftMax[i], rightMax[i]);
+            // 当前柱子能存的水高度 = 最小边界 - 当前高度
+            ans += minBound - height[i];
+        }
+        return ans;
+    }
+}
+```
+
+复杂度分析:    
+
+- 时间复杂度：O(n)，其中n是数组height的长度。计算数组leftMax和rightMax的元素值各需要遍历数组height一次，计算能接的雨水总量还需要遍历一次。
+- 空间复杂度：O(n)，其中n是数组height的长度。需要创建两个长度为n的数组leftMax和rightMax。
+
+
+
+##### 方法二
+
+动态规划的做法中，需要维护两个数组leftMax和rightMax，因此空间复杂度是O(n)。是否可以将空间复杂度降到O(1)？
+
+注意到下标i处能接的雨水量由leftMax[i]和rightMax[i]中的最小值决定。      
+
+- 由于数组leftMax是从左往右计算，数组rightMax是从右往左计算，因此可以使用双指针和两个变量代替两个数组。
+
+- 维护两个指针left和right，以及两个变量leftMax(左侧已扫描的最大高度)和rightMax(右侧已扫描的最大高度)，初始时left=0,right=n−1,leftMax=0,rightMax=0。
+- 指针left只会向右移动，指针right只会向左移动，在移动指针的过程中维护两个变量leftMax和rightMax的值。    
+
+当两个指针没有相遇时，进行如下操作：
+
+- 使用height[left]和height[right]的值更新leftMax和rightMax的值
+
+- 如果`height[left]<height[right]`，则必有`leftMax<rightMax`，下标`left`处能接的雨水量等于`leftMax−height[left]`，将下标`left`处能接的雨水量加到能接的雨水总量，然后将`left`加1（即向右移动一位）
+
+- 如果`height[left]≥height[right]`，则必有`leftMax≥rightMax`，下标`right`处能接的雨水量等于`rightMax−height[right]`，将下标right处能接的雨水量加到能接的雨水总量，然后将right减1（即向左移动一位）
+
+- 当两个指针相遇时，即可得到能接的雨水总量。
+
+
+```java
+class Solution {
+    public int trap(int[] height) {
+        int ans = 0;
+        int left = 0, right = height.length - 1;
+        int leftMax = 0, rightMax = 0;
+        while (left < right) {
+            leftMax = Math.max(leftMax, height[left]);
+            rightMax = Math.max(rightMax, height[right]);
+            // 选择较小的边界进行计算
+            // 如果height[left] < height[right]，说明右边存在一个较高的边界（至少是right指向的高度）能够保证左边有一个有效的边界（即leftMax）可以储水。
+            // 因为此时，左边的最大值leftMax是影响当前位置储水的关键，右边已经有一个不小于height[left]的边界（right指针指向的高度更高）。
+            if (height[left] < height[right]) {
+                // 左侧是短板，计算左侧储水量
+                ans += leftMax - height[left];
+                left++;
+            } else {
+                // 右侧是短板，计算右侧储水量
+                ans += rightMax - height[right];
+                right--;
+            }
+        }
+        return ans;
+    }
+}
+```
+
+复杂度分析:     
+
+- 时间复杂度:O(n)，其中n是数组height的长度。两个指针的移动总次数不超过n。
+
+- 空间复杂度：O(1)。只需要使用常数的额外空间。
+
+
+
+
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	
diff --git "a/Algorithm/17.\347\275\227\351\251\254\346\225\260\345\255\227\350\275\254\346\225\264\346\225\260.md" "b/Algorithm/17.\347\275\227\351\251\254\346\225\260\345\255\227\350\275\254\346\225\264\346\225\260.md"
new file mode 100644
index 00000000..f6765dd5
--- /dev/null
+++ "b/Algorithm/17.\347\275\227\351\251\254\346\225\260\345\255\227\350\275\254\346\225\264\346\225\260.md"
@@ -0,0 +1,116 @@
+17.罗马数字转整数
+===
+
+
+### 题目
+
+罗马数字包含以下七种字符: I， V， X， L，C，D 和 M。
+
+```
+字符          数值
+I             1
+V             5
+X             10
+L             50
+C             100
+D             500
+M             1000
+```
+例如， 罗马数字 2 写做 II ，即为两个并列的 1 。12 写做 XII ，即为 X + II 。 27 写做  XXVII, 即为 XX + V + II 。
+
+通常情况下，罗马数字中小的数字在大的数字的右边。但也存在特例，例如 4 不写做 IIII，而是 IV。数字 1 在数字 5 的左边，所表示的数等于大数 5 减小数 1 得到的数值 4 。同样地，数字 9 表示为 IX。这个特殊的规则只适用于以下六种情况：
+
+- I 可以放在 V (5) 和 X (10) 的左边，来表示 4 和 9。
+- X 可以放在 L (50) 和 C (100) 的左边，来表示 40 和 90。 
+- C 可以放在 D (500) 和 M (1000) 的左边，来表示 400 和 900。
+- 给定一个罗马数字，将其转换成整数。
+
+ 
+
+示例 1:     
+
+- 输入: s = "III"
+- 输出: 3
+
+示例 2:      
+
+- 输入: s = "IV"
+- 输出: 4
+
+示例 3:     
+
+- 输入: s = "IX"
+- 输出: 9
+
+示例 4:      
+
+- 输入: s = "LVIII"
+- 输出: 58
+- 解释: L = 50, V= 5, III = 3.
+
+示例 5:     
+
+- 输入: s = "MCMXCIV"
+- 输出: 1994
+- 解释: M = 1000, CM = 900, XC = 90, IV = 4.
+ 
+
+提示:     
+
+- 1 <= s.length <= 15
+- s 仅含字符 ('I', 'V', 'X', 'L', 'C', 'D', 'M')
+- 题目数据保证 s 是一个有效的罗马数字，且表示整数在范围 [1, 3999] 内
+- 题目所给测试用例皆符合罗马数字书写规则，不会出现跨位等情况。
+- IL 和 IM 这样的例子并不符合题目要求，49 应该写作 XLIX，999 应该写作 CMXCIX 。
+
+### 思路
+
+通常情况下，罗马数字中小的数字在大的数字的右边。若输入的字符串满足该情况，那么可以将每个字符视作一个单独的值，累加每个字符对应的数值即可。
+
+例如 XXVII 可视作 X+X+V+I+I=10+10+5+1+1=27。
+
+若存在小的数字在大的数字的左边的情况，根据规则需要减去小的数字。对于这种情况，我们也可以将每个字符视作一个单独的值，若一个数字右侧的数字比它大，则将该数字的符号取反。
+
+例如 XIV 可视作 X−I+V=10−1+5=14。
+
+所以我们可以从左遍历，如果一个字符右边的比当前的大，那这个就要减去该值，否则就加。
+
+```java
+class Solution {
+    Map<Character, Integer> symbolValues = new HashMap<Character, Integer>() {{
+        put('I', 1);
+        put('V', 5);
+        put('X', 10);
+        put('L', 50);
+        put('C', 100);
+        put('D', 500);
+        put('M', 1000);
+    }};
+
+    public int romanToInt(String s) {
+        int ans = 0;
+        int n = s.length();
+        for (int i = 0; i < n; ++i) {
+            int value = symbolValues.get(s.charAt(i));
+            if (i < n - 1 && value < symbolValues.get(s.charAt(i + 1))) {
+                ans -= value;
+            } else {
+                ans += value;
+            }
+        }
+        return ans;
+    }
+}
+```
+
+复杂度分析:   
+
+- 时间复杂度：O(n)，其中 n 是字符串 s 的长度。
+
+- 空间复杂度：O(1)。
+
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	
diff --git "a/Algorithm/18.\346\225\264\346\225\260\350\275\254\347\275\227\351\251\254\346\225\260\345\255\227.md" "b/Algorithm/18.\346\225\264\346\225\260\350\275\254\347\275\227\351\251\254\346\225\260\345\255\227.md"
new file mode 100644
index 00000000..cce5ae83
--- /dev/null
+++ "b/Algorithm/18.\346\225\264\346\225\260\350\275\254\347\275\227\351\251\254\346\225\260\345\255\227.md"
@@ -0,0 +1,114 @@
+18.整数转罗马数字
+===
+
+
+### 题目
+
+七个不同的符号代表罗马数字，其值如下：
+```
+符号	值
+I	1
+V	5
+X	10
+L	50
+C	100
+D	500
+M	1000
+```
+罗马数字是通过添加从最高到最低的小数位值的转换而形成的。将小数位值转换为罗马数字有以下规则：
+
+- 如果该值不是以 4 或 9 开头，请选择可以从输入中减去的最大值的符号，将该符号附加到结果，减去其值，然后将其余部分转换为罗马数字。
+- 如果该值以 4 或 9 开头，使用 减法形式，表示从以下符号中减去一个符号，例如 4 是 5 (V) 减 1 (I): IV ，9 是 10 (X) 减 1 (I)：IX。仅使用以下减法形式：4 (IV)，9 (IX)，40 (XL)，90 (XC)，400 (CD) 和 900 (CM)。
+- 只有 10 的次方（I, X, C, M）最多可以连续附加 3 次以代表 10 的倍数。你不能多次附加 5 (V)，50 (L) 或 500 (D)。如果需要将符号附加4次，请使用 减法形式。
+- 给定一个整数，将其转换为罗马数字。
+
+ 
+
+示例 1:   
+
+- 输入：num = 3749
+
+- 输出： "MMMDCCXLIX"
+
+- 解释:   
+
+    - 3000 = MMM 由于 1000 (M) + 1000 (M) + 1000 (M)
+    - 700 = DCC 由于 500 (D) + 100 (C) + 100 (C)
+    - 40 = XL 由于 50 (L) 减 10 (X)
+    - 9 = IX 由于 10 (X) 减 1 (I)
+注意：49 不是 50 (L) 减 1 (I) 因为转换是基于小数位
+
+示例 2:    
+
+- 输入：num = 58
+
+- 输出："LVIII"
+
+解释:   
+
+    - 50 = L
+    - 8 = VIII
+
+示例 3:    
+
+- 输入：num = 1994
+
+- 输出："MCMXCIV"
+
+- 解释:      
+
+    - 1000 = M
+    - 900 = CM
+    - 90 = XC
+    - 4 = IV
+ 
+
+提示:     
+
+- 1 <= num <= 3999
+
+### 思路
+
+题目中说了num <= 3999
+
+所以:    
+
+- 千位数只能由M表示，分别为 M，MM，MMM
+- 百位数只能由C、CC、CCC、CD、D、DC、DCC、DCCC、CM表示
+- 十位数只能由X、XX、XXX、XL、L、LX、LXX、LXXX、XC表示
+- 个位数只能由I、II、III、IV、V、VI、VII、VIII、IV表示
+
+
+所以可以利用模运算和除法运算，得到num每个位上的数字，然后去取对应的罗马数字就可以了。 
+
+```java
+
+class Solution {
+    String[] thousands = {"", "M", "MM", "MMM"};
+    String[] hundreds  = {"", "C", "CC", "CCC", "CD", "D", "DC", "DCC", "DCCC", "CM"};
+    String[] tens      = {"", "X", "XX", "XXX", "XL", "L", "LX", "LXX", "LXXX", "XC"};
+    String[] ones      = {"", "I", "II", "III", "IV", "V", "VI", "VII", "VIII", "IX"};
+
+    public String intToRoman(int num) {
+        StringBuffer roman = new StringBuffer();
+        roman.append(thousands[num / 1000]);
+        roman.append(hundreds[num % 1000 / 100]);
+        roman.append(tens[num % 100 / 10]);
+        roman.append(ones[num % 10]);
+        return roman.toString();
+    }
+}
+```
+
+复杂度分析:     
+
+- 时间复杂度：O(1)。计算量与输入数字的大小无关。
+
+- 空间复杂度：O(1)。
+
+
+---
+-  邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	
diff --git "a/Algorithm/19.\346\234\200\345\220\216\344\270\200\344\270\252\345\215\225\350\257\215\347\232\204\351\225\277\345\272\246.md" "b/Algorithm/19.\346\234\200\345\220\216\344\270\200\344\270\252\345\215\225\350\257\215\347\232\204\351\225\277\345\272\246.md"
new file mode 100644
index 00000000..95e2c32f
--- /dev/null
+++ "b/Algorithm/19.\346\234\200\345\220\216\344\270\200\344\270\252\345\215\225\350\257\215\347\232\204\351\225\277\345\272\246.md"
@@ -0,0 +1,78 @@
+19.最后一个单词的长度
+===
+
+
+### 题目
+
+给你一个字符串 s，由若干单词组成，单词前后用一些空格字符隔开。返回字符串中 最后一个 单词的长度。
+
+单词 是指仅由字母组成、不包含任何空格字符的最大子字符串。
+
+ 
+
+示例 1:    
+
+- 输入：s = "Hello World"
+- 输出：5
+- 解释：最后一个单词是“World”，长度为 5。
+
+示例 2:    
+
+- 输入：s = "   fly me   to   the moon  "
+- 输出：4
+- 解释：最后一个单词是“moon”，长度为 4。
+
+示例 3:     
+
+- 输入：s = "luffy is still joyboy"
+- 输出：6
+- 解释：最后一个单词是长度为 6 的“joyboy”。
+ 
+
+提示:    
+
+- 1 <= s.length <= 104
+- s 仅有英文字母和空格 ' ' 组成
+- s 中至少存在一个单词
+
+### 思路
+
+从最后一个字母开始往前遍历，并开始计数，找到第一个空格的时候停止。要注意没有空格的情况，例如"ab"，应该返回2。
+
+```java
+class Solution {
+    public int lengthOfLastWord(String s) {
+        int end = s.length() - 1;
+        while(end >= 0 && s.charAt(end) == ' ') end--;
+        if(end < 0) return 0;
+        int start = end;
+        while(start >= 0 && s.charAt(start) != ' ') start--;
+        return end - start;
+    }
+}
+```
+
+
+```python
+class Solution:
+    def lengthOfLastWord(self, s: str) -> int:
+        length = 0
+        for i in reversed(range(len(s.rstrip()))):
+            if s.rstrip()[i] == " ":
+                return length
+            else:
+                length += 1
+        return length    
+```
+
+复杂度分析:    
+
+- 时间复杂度：O(n)，其中 n 是字符串的长度。最多需要反向遍历字符串一次。
+
+- 空间复杂度：O(1)。
+
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	
diff --git "a/Algorithm/2.\347\247\273\351\231\244\345\205\203\347\264\240.md" "b/Algorithm/2.\347\247\273\351\231\244\345\205\203\347\264\240.md"
new file mode 100644
index 00000000..422431ad
--- /dev/null
+++ "b/Algorithm/2.\347\247\273\351\231\244\345\205\203\347\264\240.md"
@@ -0,0 +1,118 @@
+2.移除元素
+===
+
+
+### 题目
+
+给你一个数组`nums`和一个值`val`，你需要`原地`移除所有数值等于`val`的元素。元素的顺序可能发生改变。然后返回`nums`中与`val`不同的元素的数量。
+
+假设`nums`中不等于`val`的元素数量为`k`，要通过此题，您需要执行以下操作:    
+
+更改`nums`数组，使`nums`的前`k`个元素包含不等于`val`的元素。`nums`的其余元素和`nums`的大小并不重要。
+返回`k`。
+
+
+示例 1：
+
+输入：nums = [3,2,2,3], val = 3
+输出：2, nums = [2,2,_,_]
+解释：你的函数函数应该返回 k = 2, 并且 nums 中的前两个元素均为 2。
+你在返回的 k 个元素之外留下了什么并不重要（因此它们并不计入评测）。
+示例 2：
+
+输入：nums = [0,1,2,2,3,0,4,2], val = 2
+输出：5, nums = [0,1,4,0,3,_,_,_]
+解释：你的函数应该返回 k = 5，并且 nums 中的前五个元素为 0,0,1,3,4。
+注意这五个元素可以任意顺序返回。
+你在返回的 k 个元素之外留下了什么并不重要（因此它们并不计入评测）。
+
+
+### 思路
+
+##### 双指针： 
+
+- 用一个变量k记录不等于val的元素数量，从0开始
+- 从头开始遍历nums中的元素，与val进行比较，如果不等于val，那就将nums[k]的值设置为nums中当前的元素，同时后移k
+
+```python
+class Solution:
+    def removeElement(self, nums: List[int], val: int) -> int:
+        k = 0
+        for num in nums:
+            if num != val:
+                nums[k] = num
+                k += 1
+        return k
+```
+
+
+```kotlin
+class Solution {
+    fun removeElement(nums: IntArray, `val`: Int): Int {
+        var k = 0
+        for (num in nums) {
+            if (num != `val`) {
+                nums[k] = num
+                k++
+            }
+        }
+        return k
+    }
+}
+```
+
+##### 双指针优化
+
+上面的方案存在一个问题，就是例如数组为[1, 2, 3, 4, 5]，而val为1时。我们需要把每一个元素都左移一位。   
+
+注意到题目上说：元素的顺序可以改变。    
+
+实际上我们只需要将最后一个元素5移动到序列开头，取代元素1，得到序列[5, 2, 3, 4]就可以。 
+
+
+思路： 
+- 还是用双指针，一个从前往后left，一个从后往前right
+- 从前往后的指针left的判断方式还是如同上面的思路
+- 如果left上的值等于val，那就把left位置的值换成right位置的值，同时移动right继续循环
+- 直到left > right相等，那就都遍历完了
+
+```python
+class Solution:
+    def removeElement(self, nums: List[int], val: int) -> int:
+        left = 0
+        right = len(nums) - 1
+        while left <= right:
+            if (nums[left] == val):
+                nums[left] = nums[right]
+                right -= 1
+            else:
+                left += 1
+        return left   
+```
+
+```Kotlin
+class Solution {
+    fun removeElement(nums: IntArray, `val`: Int): Int {
+        var left = 0
+        var right = nums.size - 1
+        while (left <= right) {
+            if (nums[left] == `val`) {
+                nums[left] = nums[right]
+                right --
+            } else {
+                left ++
+            }
+        }
+
+        return left
+    }
+}
+```
+
+
+
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	
diff --git "a/Algorithm/20.\346\234\200\351\225\277\345\205\254\345\205\261\345\211\215\347\274\200.md" "b/Algorithm/20.\346\234\200\351\225\277\345\205\254\345\205\261\345\211\215\347\274\200.md"
new file mode 100644
index 00000000..ce72e6a5
--- /dev/null
+++ "b/Algorithm/20.\346\234\200\351\225\277\345\205\254\345\205\261\345\211\215\347\274\200.md"
@@ -0,0 +1,68 @@
+20.最长公共前缀
+===
+
+
+### 题目
+
+编写一个函数来查找字符串数组中的最长公共前缀。
+
+如果不存在公共前缀，返回空字符串 ""。
+
+ 
+
+示例 1:    
+
+- 输入：strs = ["flower","flow","flight"]
+- 输出："fl"
+
+示例 2:     
+
+- 输入：strs = ["dog","racecar","car"]
+- 输出：""
+- 解释：输入不存在公共前缀。
+ 
+
+提示:    
+
+- 1 <= strs.length <= 200
+- 0 <= strs[i].length <= 200
+- strs[i] 如果非空，则仅由小写英文字母组成
+
+### 思路
+
+
+###### 遍历每次找重合的前缀部分
+
+横向扫描，依次遍历每个字符串，更新最长公共前缀
+
+```python
+class Solution:
+    def longestCommonPrefix(self, strs: List[str]) -> str:
+        ans = strs[0]
+        def compare(s1, s2) -> str:
+            result = ""
+            for i in range(min(len(s1), len(s2))):
+                if s1[i] == s2[i]:
+                    result += s1[i]
+                else:
+                    break
+            return result
+
+        for i in range(1, len(strs)):
+            ans = compare(ans, strs[i])
+        return ans
+```
+
+
+复杂度分析:     
+
+- 时间复杂度：O(mn)，其中 m 是字符串数组中的字符串的平均长度，n 是字符串的数量。最坏情况下，字符串数组中的每个字符串的每个字符都会被比较一次。
+
+- 空间复杂度：O(1)。使用的额外空间复杂度为常数。
+
+
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	
diff --git "a/Algorithm/21.\345\217\215\350\275\254\345\255\227\347\254\246\344\270\262\344\270\255\347\232\204\345\215\225\350\257\215.md" "b/Algorithm/21.\345\217\215\350\275\254\345\255\227\347\254\246\344\270\262\344\270\255\347\232\204\345\215\225\350\257\215.md"
new file mode 100644
index 00000000..1a5754c5
--- /dev/null
+++ "b/Algorithm/21.\345\217\215\350\275\254\345\255\227\347\254\246\344\270\262\344\270\255\347\232\204\345\215\225\350\257\215.md"
@@ -0,0 +1,84 @@
+21.反转字符串中的单词
+===
+
+
+### 题目
+
+
+给你一个字符串 s ，请你反转字符串中 单词 的顺序。
+
+单词 是由非空格字符组成的字符串。s 中使用至少一个空格将字符串中的 单词 分隔开。
+
+返回 单词 顺序颠倒且 单词 之间用单个空格连接的结果字符串。
+
+注意：输入字符串 s中可能会存在前导空格、尾随空格或者单词间的多个空格。返回的结果字符串中，单词间应当仅用单个空格分隔，且不包含任何额外的空格。
+
+ 
+
+示例 1:    
+
+- 输入：s = "the sky is blue"
+- 输出："blue is sky the"
+
+示例 2:    
+
+- 输入：s = "  hello world  "
+- 输出："world hello"
+- 解释：反转后的字符串中不能存在前导空格和尾随空格。
+
+示例 3:     
+
+- 输入：s = "a good   example"
+- 输出："example good a"
+- 解释：如果两个单词间有多余的空格，反转后的字符串需要将单词间的空格减少到仅有一个。
+ 
+
+提示:    
+
+- 1 <= s.length <= 104
+- s 包含英文大小写字母、数字和空格 ' '
+- s 中 至少存在一个 单词
+
+
+### 思路
+
+- 倒序遍历，记录每个单词的起始和结束长度
+- 结果中累加每个单词，注意在加下一个单词的时候需要提前加上空格
+- 遍历到最后一个空格或者第一个元素截止
+- 注意如果是第一个元素截止的时候需要考虑第一个元素是不是空格" "，例如: " asdasd df f"
+    - 如果是空格，需要从i + 1开始
+    - 如果不是空格，需要从0开始
+
+```python
+class Solution:
+    def reverseWords(self, s: str) -> str:
+        length = len(s)
+        result = ""
+        last = -1
+
+        for i in reversed(range(length)):
+            if last == -1 and s[i] != " ":
+                last = i
+            if last > -1 and (s[i] == " " or i == 0):
+                if result != "":
+                    result += " "
+                if i == 0 and s[i] != " ":
+                    result += s[0: last + 1]
+                else:
+                    result += s[i + 1: last + 1]
+                last = -1
+
+        return result
+```        
+
+
+复杂度分析:     
+
+- 时间复杂度 O(N) ： 其中 N 为字符串 s 的长度，线性遍历字符串。
+- 空间复杂度 O(N) ： 新建的 list(Python) 或 StringBuilder(Java) 中的字符串总长度 ≤N ，占用 O(N) 大小的额外空间。
+
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	
diff --git "a/Algorithm/22.Z\345\255\227\345\275\242\350\275\254\346\215\242.md" "b/Algorithm/22.Z\345\255\227\345\275\242\350\275\254\346\215\242.md"
new file mode 100644
index 00000000..d4f3e661
--- /dev/null
+++ "b/Algorithm/22.Z\345\255\227\345\275\242\350\275\254\346\215\242.md"
@@ -0,0 +1,106 @@
+22.Z字形转换
+===
+
+
+### 题目
+
+将一个给定字符串 s 根据给定的行数 numRows ，以从上往下、从左到右进行 Z 字形排列。
+
+比如输入字符串为 "PAYPALISHIRING" 行数为 3 时，排列如下:     
+```
+P   A   H   N
+A P L S I I G
+Y   I   R
+```
+之后，你的输出需要从左往右逐行读取，产生出一个新的字符串，比如："PAHNAPLSIIGYIR"。
+
+请你实现这个将字符串进行指定行数变换的函数：
+
+string convert(string s, int numRows);
+ 
+
+示例 1:     
+
+- 输入：s = "PAYPALISHIRING", numRows = 3
+- 输出："PAHNAPLSIIGYIR"
+
+示例 2:    
+- 输入：s = "PAYPALISHIRING", numRows = 4
+- 输出："PINALSIGYAHRPI"
+- 解释：
+```
+P     I    N
+A   L S  I G
+Y A   H R
+P     I
+```
+示例 3:    
+
+- 输入：s = "A", numRows = 1
+- 输出："A"
+ 
+
+提示:    
+
+- 1 <= s.length <= 1000
+- s 由英文字母（小写和大写）、',' 和 '.' 组成
+- 1 <= numRows <= 1000
+
+### 思路
+
+找规律，假设s = "PAYPALISHIRING", numRows = 3
+
+- 从前往后遍历s
+- s[0] : 第一行
+- s[1] : 第二行
+- s[2] : 第三行， 大于等于numRows了，行要开始递减了
+- s[3] : 第二行，
+- s[4] : 第一行， 到最小行了，行要开始递加了
+- s[5] : 第二行
+- ...
+
+
+```python
+
+class Solution:
+    def convert(self, s: str, numRows: int) -> str:
+        if len(s) < 3 or numRows < 2:
+            return s
+        row = 1
+        add = True
+        # 用一个数组记录每一行的字符内容
+        rowArray = [""] * numRows
+        for i in s:
+            rowArray[row - 1] += i
+
+            if add:
+                row += 1
+            else:
+                row -= 1
+            if row > numRows:
+                add = False
+                # 本来要减1因为上面刚加了1，所以这里要减2
+                row -= 2
+            elif row < 1:
+                add = True
+                row += 2
+
+        result = ""
+        for i in rowArray:
+            result += i
+        return result
+```
+
+
+
+
+复杂度分析:   
+
+- 时间复杂度 O(N) ：遍历一遍字符串 s；
+- 空间复杂度 O(N) ：各行字符串共占用 O(N) 额外空间。
+
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	
diff --git "a/Algorithm/23.\346\211\276\345\207\272\345\255\227\347\254\246\344\270\262\344\270\255\347\254\254\344\270\200\344\270\252\345\214\271\351\205\215\351\241\271\347\232\204\344\270\213\346\240\207.md" "b/Algorithm/23.\346\211\276\345\207\272\345\255\227\347\254\246\344\270\262\344\270\255\347\254\254\344\270\200\344\270\252\345\214\271\351\205\215\351\241\271\347\232\204\344\270\213\346\240\207.md"
new file mode 100644
index 00000000..b3f118f9
--- /dev/null
+++ "b/Algorithm/23.\346\211\276\345\207\272\345\255\227\347\254\246\344\270\262\344\270\255\347\254\254\344\270\200\344\270\252\345\214\271\351\205\215\351\241\271\347\232\204\344\270\213\346\240\207.md"
@@ -0,0 +1,324 @@
+23.找出字符串中第一个匹配项的下标
+===
+
+
+### 题目
+
+给你两个字符串 haystack 和 needle ，请你在 haystack 字符串中找出 needle 字符串的第一个匹配项的下标（下标从 0 开始）。如果 needle 不是 haystack 的一部分，则返回  -1 。
+
+ 
+
+示例 1:    
+
+- 输入：haystack = "sadbutsad", needle = "sad"
+- 输出：0
+- 解释："sad" 在下标 0 和 6 处匹配。
+- 第一个匹配项的下标是 0 ，所以返回 0 。
+
+示例 2:   
+
+- 输入：haystack = "leetcode", needle = "leeto"
+- 输出：-1
+- 解释："leeto" 没有在 "leetcode" 中出现，所以返回 -1 。
+ 
+
+提示:    
+
+- 1 <= haystack.length, needle.length <= 104
+- haystack 和 needle 仅由小写英文字符组成
+
+### 思路
+
+##### 方法一： 普通对比
+
+```python
+
+class Solution:
+    def strStr(self, haystack: str, needle: str) -> int:
+        length = len(needle)
+        for i in range(len(haystack)):
+            if haystack[i] == needle[0]:
+                if haystack[i: i+length] == needle:
+                    return i
+        return -1    
+```
+
+
+复杂度分析
+
+- 时间复杂度：O(n×m)，其中 n 是字符串 haystack 的长度，m 是字符串 needle 的长度。最坏情况下我们需要将字符串 needle 与字符串 haystack 的所有长度为 m 的子串均匹配一次。
+
+- 空间复杂度：O(1)。我们只需要常数的空间保存若干变量。
+
+
+##### 方法二： KMP
+
+
+
+上述的朴素解法，不考虑剪枝的话复杂度是 O(m∗n) 的，而 KMP 算法的复杂度为 O(m+n)。
+
+KMP算法是一种字符串匹配算法，可以在 O(n+m) 的时间复杂度内实现两个字符串的匹配。
+
+KMP 之所以能够在 O(m+n) 复杂度内完成查找，是因为其能在「非完全匹配」的过程中提取到有效信息进行复用，以减少「重复匹配」的消耗。
+
+
+KMP算法的核心，是一个被称为部分匹配表(Partial Match Table)的数组。
+
+###### 算法原理
+
+从主字符串的第一个字符开始：KMP算法从主字符串的第一个字符开始，将其与子字符串的第一个字符进行比较。 相等与不等的情况：如果字符相等，则继续比较后续字符；如果不等，则根据部分匹配表（即next数组）的值，将子字符串向右移动若干个字符，然后再次进行比较。
+
+
+###### 算法效率
+
+- 时间复杂度：KMP算法的时间复杂度为O(m+n)，其中m和n分别是模式串和主串的长度。相较于O(n^2)的暴力匹配算法，KMP算法具有较高的效率。
+
+
+
+###### KMP算法的本质
+
+理解计算next数组是核心。
+
+
+next数组是匹配串的一个查找表，它的定义可以用下面一句话来解释。就是kmp算法的本质：
+
+***next数组的每个元素表示匹配串中从起始到以当前字符结尾的子串中以当前字符结尾的连续重复最长串长度。***
+
+字符串abcdabe,len是每个子串以最后一个字符结尾的连续重复最长串长度:     
+
+- next[0] = 0 // 子串'a'中没有包含以'a'结尾的连续重复子串，len = 0
+- next[1] = 0 // 子串'ab'中没有包含以'b'结尾的连续重复子串，len = 0
+- next[2] = 0 // 子串'abc'中没有包含以'c'结尾的连续重复子串，len = 0
+- next[3] = 0 // 子串'abcd'中没有包含以'd'结尾的连续重复子串，len = 0
+- next[4] = 1 // 子串'abcda'中包含以'a'结尾的连续重复子串是'a'，len = 1
+- next[5] = 2 // 子串'abcdab'中包含以'b'结尾的连续重复子串'ab'，len = 2
+- next[6] = 0 // 子串'abcdabe'中没有包含以'e'结尾的连续重复子串，len = 0 
+
+匹配过程与计算next的思路相似，如果当前字符不匹配，就往回跳，跳多少呢，就是前面已比较串的以最后一个字符结尾的连续最长重复长度，最长也就一半，不用跳到开头，即next[j-1]的长度，不用再重头比较，
+
+
+
+
+
+所谓字符串匹配，是这样一种问题： 字符串P是否为字符串S的子串？如果是，它出现在S的哪个位置。
+
+- S称为主串。    
+- P称为模式串。  
+
+
+最简单的方法就是上面的方法一，不断的去遍历查找。
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/Brute-Force.png?raw=true)
+
+
+这就是Brute-Force 算法。现在，我们需要对它的时间复杂度做一点讨论，它的时间复杂度是O(n×m)。 
+
+我们很难降低字符串比较的复杂度（因为比较两个字符串，真的只能逐个比较字符）。        
+
+因此，我们考虑降低比较的趟数。如果比较的趟数能降到足够低，那么总的复杂度也将会下降很多。    
+
+
+要优化一个算法，首先要回答的问题是“我手上有什么信息？”　我们手上的信息是否足够、是否有效，决定了我们能把算法优化到何种程度。请记住：尽可能利用残余的信息，是KMP算法的思想所在。
+
+
+在Brute-Force中，如果从S[i]开始的那一趟比较失败了，算法会直接开始尝试从S[i+1]开始比较。
+
+这种行为，属于典型的“没有从之前的错误中学到东西”。     
+
+我们应当注意到，一次失败的匹配，会给我们提供宝贵的信息：    
+
+- 如果 S[i : i+len(P)] 与 P 的匹配是在第 r 个位置失败的，那么从 S[i] 开始的 (r-1) 个连续字符，一定与 P 的前 (r-1) 个字符一模一样！
+- 为什么呢？ 因为不然得话你在r之前就失败了。
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/Brute-Force_2.png?raw=true)
+
+
+需要实现的任务是“字符串匹配”，而每一次失败都会给我们换来一些信息——能告诉我们，主串的某一个子串等于模式串的某一个前缀。但是这又有什么用呢？
+
+有些趟字符串比较是有可能会成功的；有些则毫无可能。      
+
+我们刚刚提到过，优化 Brute-Force的路线是“尽量减少比较的趟数”，而如果我们跳过那些绝不可能成功的字符串比较，则可以希望复杂度降低到能接受的范围。　　       
+
+那么，哪些字符串比较是不可能成功的？来看一个例子。已知信息如下：
+
+- 模式串 P = "abcabd".
+- 和主串从S[0]开始匹配时，在 P[5] 处失配。
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/Brute-Force_3.png?raw=true)
+
+- 既然是在 P[5] 失配的，那么说明 S[0:5] 等于 P[0:5]，即"abcab".       
+
+- 现在我们来考虑：从 S[1]、S[2]、S[3] 开始的匹配尝试，有没有可能成功？　　    
+
+- 从 S[1] 开始肯定没办法成功，因为 S[1] = P[1] = 'b'，和 P[0] 并不相等。       
+
+- 从 S[2] 开始也是没戏的，因为 S[2] = P[2] = 'c'，并不等于P[0].       
+
+- 但是从 S[3] 开始是有可能成功的——至少按照已知的信息，我们推不出矛盾。
+
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/Brute-Force_4.png?raw=true)
+
+
+也就是说当主串的某个字符c发生不匹配时，如果主串回退，最终还是会重新匹配到字符c上。     
+那干脆不回退，岂不美哉！   
+也就是说主串一直遍历不回退。
+主串不回退，那模式串必须回退尽可能少，并且模式串回退位置的前面那段已经和主串匹配，这样主串才能不用回退。
+
+如何找到模式串回退的位置呢？
+
+在不匹配发生时，前面匹配的那一小段字符对于主串和模式串都是相同的(如果不相同，在这之前会就匹配失败了)。     
+那既然这一小段是主串和模式串相同的。那我就用这个串的头部去匹配这个串的尾部，最长的那段就是答案，也就是模式串改回退到的位置。   
+
+
+***带着“跳过不可能成功的尝试”的思想，我们来看next数组。***
+
+那就假设模式串在其所有位置上都发生了不匹配，模式串在和主串匹配前把其所有位置的最长匹配都算出来（算个长度就行），生成一张表，之后我俩发生不匹配时直接查这张表就行。这就是next数组。  
+
+###### next数组
+
+next数组是对于***模式串***而言的。
+
+P 的 next 数组定义为：next[i] 表示 P[0] ~ P[i] 这一个子串，使得***前k个字符恰等于后k个字符的最大的k***. 特别地，k不能取i+1（因为这个子串一共才 i+1 个字符，自己肯定与自己相等，就没有意义了）。
+
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/Brute-Force_5.png?raw=true)
+
+上图给出了一个例子。P="abcabd"时，next[4]=2，这是因为P[0] ~ P[4] 这个子串是"abcab"，前两个字符与后两个字符相等，因此next[4]取2. 
+
+而next[5]=0，是因为"abcabd"找不到前缀与后缀相同，因此只能取0.
+
+如果把模式串视为一把标尺，在主串上移动，那么 Brute-Force 就是每次失配之后只右移一位；改进算法则是每次失配之后，移很多位，跳过那些不可能匹配成功的位置。但是该如何确定要移多少位呢？
+
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/Brute-Force_6.png?raw=true)
+
+
+- 在 S[0] 尝试匹配，失配于 S[3] != P[3] 之后，我们直接把模式串往右移了两位，让 S[3] 对准 P[1].      
+
+- 接着继续匹配，失配于 S[8] != P[6], 接下来我们把 P 往右平移了三位，把 S[8] 对准 P[3].         
+
+- 此后继续匹配直到成功。　　
+
+
+我们应该如何移动这把标尺？很明显，如图中蓝色箭头所示，旧的后缀要与新的前缀一致（如果不一致，那就肯定没法匹配上了）！　　     
+
+
+---  
+回忆next数组的性质：P[0] 到 P[i] 这一段子串中，前next[i]个字符与后next[i]个字符一模一样。       
+
+既然如此，如果失配在`P[r]`, 那么`P[0]~P[r-1]`这一段里面，前`next[r-1]`个字符恰好和后`next[r-1]`个字符相等——也就是说，我们可以拿长度为`next[r-1]`的那一段前缀，来顶替当前后缀的位置，让匹配继续下去。          
+
+
+您可以验证一下上面的匹配例子：P[3]失配后，把P[next[3-1]]也就是P[1]对准了主串刚刚失配的那一位；P[6]失配后，把P[next[6-1]]也就是P[3]对准了主串刚刚失配的那一位。
+
+--- 
+
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/Brute-Force_7.png?raw=true)
+
+
+
+如上图所示，绿色部分是成功匹配，失配于红色部分。深绿色手绘线条标出了相等的前缀和后缀，其长度为next[右端]. 由于手绘线条部分的字符是一样的，所以直接把前面那条移到后面那条的位置。因此说，next数组为我们如何移动标尺提供了依据。接下来，我们实现这个优化的算法。
+
+了解了利用next数组加速字符串匹配的原理，我们接下来代码实现之。分为两个部分:     
+
+- 建立next数组
+
+- 利用next数组进行匹配。
+
+
+首先是建立next数组。我们暂且用最朴素的做法，以后再回来优化：
+
+```python
+
+def getNxt(x):
+	for i in range(x, 0, -1):
+		if p[0: 1] == p[x-i+1:x+1]:
+			return i
+	return 0
+
+nxt = [getNxt(x) for x in range(len(p))]			
+```
+
+如上图代码所示，直接根据next数组的定义来建立next数组。不难发现它的复杂度是  的。
+　　接下来，实现利用next数组加速字符串匹配。代码如下：
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/Brute-Force_8.png?raw=true)
+
+
+
+###### 快速求next数组
+
+
+终于来到了我们最后一个问题——如何快速构建next数组。　　   
+
+- 首先说一句：快速构建next数组，是KMP算法的精髓所在，核心思想是“P自己与自己做匹配”。　    
+
+为什么这样说呢？回顾next数组的完整定义:    
+
+- 定义 “k-前缀” 为一个字符串的前 k 个字符； “k-后缀” 为一个字符串的后 k 个字符。k 必须小于字符串长度。     
+
+- next[x]定义为:`P[0]~P[x]`这一段字符串，使得k-前缀恰等于k-后缀的最大的k.　　   
+
+这个定义中，不知不觉地就包含了一个匹配——前缀和后缀相等。      
+
+接下来，我们考虑采用递推的方式求出next数组。如果next[0], next[1], ... next[x-1]均已知，那么如何求出 next[x] 呢？　　     
+
+来分情况讨论。首先，已经知道了 next[x-1]（以下记为now），如果 P[x] 与 P[now] 一样，那最长相等前后缀的长度就可以扩展一位，很明显 next[x] = now + 1. 图示如下。
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/Brute-Force_9.png?raw=true)
+
+刚刚解决了 P[x] = P[now] 的情况。那如果 P[x] 与 P[now] 不一样，又该怎么办？
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/Brute-Force_10.png?raw=true)
+
+如图。
+
+长度为now的子串A和子串B是`P[0]~P[x-1]`中最长的公共前后缀。        
+
+可惜 A 右边的字符和 B 右边的那个字符不相等，next[x]不能改成now+1了。     
+
+因此，我们应该缩短这个now，把它改成小一点的值，再来试试 P[x] 是否等于 P[now].　　         
+
+now该缩小到多少呢？显然，我们不想让now缩小太多。因此我们决定，在保持`P[0]~P[x-1]`的now-前缀仍然等于now-后缀”的前提下，让这个新的now尽可能大一点。       
+
+
+`P[0]~P[x-1]`的公共前后缀，前缀一定落在串A里面、后缀一定落在串B里面。       
+
+换句话讲：接下来now应该改成：使得 A的k-前缀等于B的k-后缀 的最大的k.　　 
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/Brute-Force_14.png?raw=true)
+
+也就是说：假设这个时候最大的前缀和后缀是字符串X，那将这个前缀和后缀去掉一个字符（去掉c）后，得到的两个新的串也必然是相等的。   
+也就是只可能是现有最大串的子串。也就是a的前缀和b的后缀(而这个时候a和b是一样的，所以就变成找A中的前缀和后缀一样的子串)。   
+
+您应该已经注意到了一个非常强的性质——串A和串B是相同的！B的后缀等于A的后缀！因此，使得A的k-前缀等于B的k-后缀的最大的k，其实就是串A的最长公共前后缀的长度 —— next[now-1]！
+
+简单说就是： 次大匹配必定在最大匹配中
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/Brute-Force_11.png?raw=true)
+
+
+来看上面的例子。当P[now]与P[x]不相等的时候，我们需要缩小now——把now变成next[now-1]，直到P[now]=P[x]为止。P[now]=P[x]时，就可以直接向右扩展了。
+
+
+代码实现如下：
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/Brute-Force_12.png?raw=true)
+
+
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/Brute-Force_13.png?raw=true)
+
+
+
+https://www.zhihu.com/question/21923021/answer/281346746
+
+
+
+
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	
diff --git "a/Algorithm/24.\346\226\207\346\234\254\345\267\246\345\217\263\345\257\271\351\275\220.md" "b/Algorithm/24.\346\226\207\346\234\254\345\267\246\345\217\263\345\257\271\351\275\220.md"
new file mode 100644
index 00000000..ffde6522
--- /dev/null
+++ "b/Algorithm/24.\346\226\207\346\234\254\345\267\246\345\217\263\345\257\271\351\275\220.md"
@@ -0,0 +1,160 @@
+24.文本左右对齐
+===
+
+
+### 题目
+
+给定一个单词数组 words 和一个长度 maxWidth ，重新排版单词，使其成为每行恰好有 maxWidth 个字符，且左右两端对齐的文本。
+
+你应该使用 “贪心算法” 来放置给定的单词；也就是说，尽可能多地往每行中放置单词。必要时可用空格 ' ' 填充，使得每行恰好有 maxWidth 个字符。
+
+要求尽可能均匀分配单词间的空格数量。如果某一行单词间的空格不能均匀分配，则左侧放置的空格数要多于右侧的空格数。
+
+文本的最后一行应为左对齐，且单词之间不插入额外的空格。
+
+注意:     
+
+- 单词是指由非空格字符组成的字符序列。
+- 每个单词的长度大于 0，小于等于 maxWidth。
+- 输入单词数组 words 至少包含一个单词。
+ 
+
+示例 1:   
+
+- 输入: words = ["This", "is", "an", "example", "of", "text", "justification."], maxWidth = 16
+- 输出:
+```
+[
+   "This    is    an",
+   "example  of text",
+   "justification.  "
+]
+```
+示例 2:    
+
+- 输入:words = ["What","must","be","acknowledgment","shall","be"], maxWidth = 16
+- 输出:   
+```
+[
+  "What   must   be",
+  "acknowledgment  ",
+  "shall be        "
+]
+```
+- 解释:     
+    - 注意最后一行的格式应为 "shall be    " 而不是 "shall     be",
+    - 因为最后一行应为左对齐，而不是左右两端对齐。       
+    - 第二行同样为左对齐，这是因为这行只包含一个单词。
+
+示例 3:     
+
+- 输入:words = ["Science","is","what","we","understand","well","enough","to","explain","to","a","computer.","Art","is","everything","else","we","do"]，maxWidth = 20
+- 输出:      
+```
+[
+  "Science  is  what we",
+  "understand      well",
+  "enough to explain to",
+  "a  computer.  Art is",
+  "everything  else  we",
+  "do                  "
+]
+```
+
+提示:      
+
+- 1 <= words.length <= 300
+- 1 <= words[i].length <= 20
+- words[i] 由小写英文字母和符号组成
+- 1 <= maxWidth <= 100
+- words[i].length <= maxWidth
+
+### 思路
+
+字符串大模拟，分情况讨论即可：
+
+- 如果当前行只有一个单词，特殊处理为左对齐；
+- 如果当前行为最后一行，特殊处理为左对齐；
+- 其余为一般情况，分别计算「当前行单词总长度」、「当前行空格总长度」和「往下取整后的单位空格长度」，然后依次进行拼接。当空格无法均分时，每次往靠左的间隙多添加一个空格，直到剩余的空格能够被后面的间隙所均分。
+
+```java
+
+class Solution {
+    public List<String> fullJustify(String[] words, int maxWidth) {
+        List<String> ans = new ArrayList<>();
+        int n = words.length;
+        List<String> list = new ArrayList<>();
+        for (int i = 0; i < n; ) {
+            // list 装载当前行的所有 word
+            list.clear();
+            list.add(words[i]);
+            int cur = words[i++].length();
+            while (i < n && cur + 1 + words[i].length() <= maxWidth) {
+                cur += 1 + words[i].length();
+                list.add(words[i++]);
+            }
+
+            // 当前行为最后一行，特殊处理为左对齐
+            if (i == n) {
+                StringBuilder sb = new StringBuilder(list.get(0));
+                for (int k = 1; k < list.size(); k++) {
+                    sb.append(" ").append(list.get(k));
+                }
+                while (sb.length() < maxWidth) sb.append(" ");
+                ans.add(sb.toString());
+                break;
+            }
+
+            // 如果当前行只有一个 word，特殊处理为左对齐
+            int cnt = list.size();
+            if (cnt == 1) {
+                String str = list.get(0);
+                while (str.length() != maxWidth) str += " ";
+                ans.add(str);
+                continue;
+            }
+
+            /**
+            * 其余为一般情况
+            * wordWidth : 当前行单词总长度;
+            * spaceWidth : 当前行空格总长度;
+            * spaceItem : 往下取整后的单位空格长度
+            */
+            int wordWidth = cur - (cnt - 1);
+            int spaceWidth = maxWidth - wordWidth;
+            int spaceItemWidth = spaceWidth / (cnt - 1);
+            String spaceItem = "";
+            for (int k = 0; k < spaceItemWidth; k++) spaceItem += " ";
+            StringBuilder sb = new StringBuilder();
+            for (int k = 0, sum = 0; k < cnt; k++) {
+                String item = list.get(k);
+                sb.append(item);
+                if (k == cnt - 1) break;
+                sb.append(spaceItem);
+                sum += spaceItemWidth;
+                // 剩余的间隙数量（可填入空格的次数）
+                int remain = cnt - k - 1 - 1;
+                // 剩余间隙数量 * 最小单位空格长度 + 当前空格长度 < 单词总长度，则在当前间隙多补充一个空格
+                if (remain * spaceItemWidth + sum < spaceWidth) {
+                    sb.append(" ");
+                    sum++;
+                }
+            }
+            ans.add(sb.toString());
+        }
+        return ans;
+    }
+}
+```
+
+复杂度分析:     
+
+- 时间复杂度：会对 words 做线性扫描，最坏情况下每个 words[i] 独占一行，此时所有字符串的长度为 n∗maxWidth。复杂度为 O(n∗maxWidth)
+- 空间复杂度：最坏情况下每个 words[i] 独占一行，复杂度为 O(n∗maxWidth)
+
+
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	
diff --git "a/Algorithm/25.\351\252\214\350\257\201\345\233\236\346\226\207\344\270\262.md" "b/Algorithm/25.\351\252\214\350\257\201\345\233\236\346\226\207\344\270\262.md"
new file mode 100644
index 00000000..b8720d78
--- /dev/null
+++ "b/Algorithm/25.\351\252\214\350\257\201\345\233\236\346\226\207\344\270\262.md"
@@ -0,0 +1,104 @@
+25.验证回文串
+===
+
+
+### 题目
+
+如果在将所有大写字符转换为小写字符、并移除所有非字母数字字符之后，短语正着读和反着读都一样。则可以认为该短语是一个 回文串 。
+
+字母和数字都属于字母数字字符。
+
+给你一个字符串 s，如果它是 回文串 ，返回 true ；否则，返回 false 。
+
+ 
+
+示例 1:    
+
+- 输入: s = "A man, a plan, a canal: Panama"
+- 输出：true
+- 解释："amanaplanacanalpanama" 是回文串。
+
+示例 2:   
+
+- 输入：s = "race a car"
+- 输出：false
+- 解释："raceacar" 不是回文串。
+示例 3:    
+
+- 输入：s = " "
+- 输出：true
+- 解释：在移除非字母数字字符之后，s 是一个空字符串 "" 。
+- 由于空字符串正着反着读都一样，所以是回文串。
+ 
+
+提示:   
+
+- 1 <= s.length <= 2 * 105
+- s 仅由可打印的 ASCII 字符组成
+
+
+### 思路
+
+##### 方法一
+
+最简单的方法是对字符串 s 进行一次遍历，并将其中的字母和数字字符进行保留，放在另一个字符串 sgood 中。这样我们只需要判断 sgood 是否是一个普通的回文串即可。
+
+判断的方法有两种:     
+
+- 第一种是使用语言中的字符串翻转 API 得到 sgood 的逆序字符串 sgood_rev，只要这两个字符串相同，那么 sgood 就是回文串。
+- 第二种是使用双指针。初始时，左右指针分别指向 sgood 的两侧，随后我们不断地将这两个指针相向移动，每次移动一步，并判断这两个指针指向的字符是否相同。当这两个指针相遇时，就说明 sgood 时回文串。
+
+```java
+class Solution {
+    public boolean isPalindrome(String s) {
+        StringBuffer sgood = new StringBuffer();
+        int length = s.length();
+        for (int i = 0; i < length; i++) {
+            char ch = s.charAt(i);
+            if (Character.isLetterOrDigit(ch)) {
+                sgood.append(Character.toLowerCase(ch));
+            }
+        }
+        int n = sgood.length();
+        int left = 0, right = n - 1;
+        while (left < right) {
+            if (Character.toLowerCase(sgood.charAt(left)) != Character.toLowerCase(sgood.charAt(right))) {
+                return false;
+            }
+            ++left;
+            --right;
+        }
+        return true;
+    }
+}
+```
+
+复杂度分析:     
+
+- 时间复杂度：O(n)，其中n是字符串s的长度。
+
+- 空间复杂度：O(n)。由于我们需要将所有的字母和数字字符存放在另一个字符串中，在最坏情况下，新的字符串sgood与原字符串s完全相同，因此需要使用 O(n) 的空间。
+
+
+##### 方法二：在原字符串上直接判断
+
+我们可以对方法一中第二种判断回文串的方法进行优化，就可以得到只使用 O(1) 空间的算法。
+
+我们直接在原字符串 s 上使用双指针。在移动任意一个指针时，需要不断地向另一指针的方向移动，直到遇到一个字母或数字字符，或者两指针重合为止。
+
+也就是说，我们每次将指针移到下一个字母字符或数字字符，再判断这两个指针指向的字符是否相同。
+
+
+
+
+复杂度分析：   
+
+- 时间复杂度：O(n)，其中n是字符串s的长度。
+
+- 空间复杂度：O(1)。
+
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	
diff --git "a/Algorithm/26.\345\210\244\346\226\255\345\255\220\345\272\217\345\210\227.md" "b/Algorithm/26.\345\210\244\346\226\255\345\255\220\345\272\217\345\210\227.md"
new file mode 100644
index 00000000..77ea7063
--- /dev/null
+++ "b/Algorithm/26.\345\210\244\346\226\255\345\255\220\345\272\217\345\210\227.md"
@@ -0,0 +1,129 @@
+26.判断子序列
+===
+
+
+### 题目
+
+给定字符串 s 和 t ，判断 s 是否为 t 的子序列。
+
+字符串的一个子序列是原始字符串删除一些（也可以不删除）字符而不改变剩余字符相对位置形成的新字符串。（例如，"ace"是"abcde"的一个子序列，而"aec"不是）。
+
+进阶：
+
+如果有大量输入的 S，称作 S1, S2, ... , Sk 其中 k >= 10亿，你需要依次检查它们是否为 T 的子序列。在这种情况下，你会怎样改变代码？
+ 
+
+示例 1:   
+
+- 输入：s = "abc", t = "ahbgdc"
+- 输出：true
+
+示例 2:   
+
+- 输入：s = "axc", t = "ahbgdc"
+- 输出：false
+ 
+
+提示:    
+
+- 0 <= s.length <= 100
+- 0 <= t.length <= 10^4
+- 两个字符串都只由小写字符组成。
+
+### 思路
+
+
+首先，如果 s 是空串，直接返回 true，因为空串是任何字符串的子序列。  
+设置双指针 i , j 分别指向字符串 s , t 的首个字符，遍历字符串 t:    
+
+- 当 s[i] == t[j] 时，代表匹配成功，此时同时 i++ , j++ ；
+    - 进而，若 i 已走过 s 尾部，代表 s 是 t 的子序列，此时应提前返回 true ；
+- 当 s[i] != t[j] 时，代表匹配失败，此时仅 j++ ；
+
+若遍历完字符串 t 后，字符串 s 仍未遍历完，代表 s 不是 t 的子序列，此时返回 false 。
+
+```java
+
+class Solution {
+    public boolean isSubsequence(String s, String t) {
+        int i = 0, j = 0;
+        while (i < s.length() && j < t.length()) {
+            if (s.charAt(i) == t.charAt(j)) {
+                i++;
+            }
+            j++;
+        }
+        return i == s.length();
+    }
+}
+```
+
+复杂度分析:   
+
+- 时间复杂度 O(N) ： 其中 N 为字符串 t 的长度。最差情况下需完整遍历 t 。
+- 空间复杂度 O(1) ： i , j 变量使用常数大小空间。
+
+
+##### 进阶问题解法
+
+如果有大量输入的 S，称作 S1, S2, ... , Sk 其中 k >= 10亿，你需要依次检查它们是否为 T 的子序列。在这种情况下，你会怎样改变代码？
+
+
+这种类似对同一个长字符串做很多次匹配的 ，可以像 KMP 算法一样，先用一些时间将长字符串中的数据 提取出来，磨刀不误砍柴功。有了提取好的数据，就可以快速的进行匹配。
+
+因为S非常多，所以可以通过一次性对T进行简化处理，这样来减少后续每一次S匹配T的遍历时间:     
+
+- 这里需要的数据就是匹配到某一点时,待匹配的字符在长字符串中 下一次 出现的位置。
+
+- 所以我们前期多做一点工作，将长字符串研究透彻，假如长字符串的长度为 n，建立一个 n∗26 大小的矩阵，表示每个位置上26个字符下一次出现的位置。实现如下：
+
+- 对于要匹配的短字符串，遍历每一个字符，不断地寻找该字符在长字符串中的位置，然后将位置更新，寻找下一个字符，相当于在长字符串上“跳跃”。
+
+- 如果下一个位置为 -1，表示长字符串再没有该字符了，返回 false 即可。
+
+- 如果能正常遍历完毕，则表示可行，返回 true
+
+- 需要注意的一点
+
+    - 对于 "abc" 在 "ahbgdc" 上匹配的时候，由于长字符串第一个 a 的下一个出现 a 的位置为 -1（不出现），会导致一个 bug。
+
+    - 所以在生成数组时在长字符串前插入一个空字符即可。
+
+```java
+
+//进阶问题的解决 
+public boolean isSubsequence(String s, String t) {
+
+    //考虑到  对第一个字符的处理 ，在t 之前一个空字符
+    t=' '+t;
+
+    //对t长字符串 做预处理
+    int[][] dp = new int[t.length()][26];//存储每一个位置上  a--z的下一个字符出现的位置
+    for (char c = 'a'; c <= 'z'; c++) {//依次对每个字符作处理
+        int nextPos = -1;//表示接下来不会在出现该字符
+
+        for (int i = t.length() - 1; i >= 0; i--) {//从最后一位开始处理
+            dp[i][c - 'a'] = nextPos;//dp[i][c-'a']  加上外层循环  就是对每一个位置的a---z字符的处理了
+            if (t.charAt(i) == c) {//表示当前位置有该字符  那么指向下一个该字符出现的位置就要被更新  为i
+                nextPos = i;
+            }
+        }
+    }
+
+    //数据的利用 ，开始匹配
+    int index=0;
+    for (char c:s.toCharArray()){
+        index=dp[index][c-'a'];//因为加了' '，所以之后在处理第一个字符的时候  如果是在第一行，就会去第一行，不影响之后字符的判断
+        if(index==-1){
+            return false;
+        }
+    }
+    return true;
+}
+```
+
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	
diff --git "a/Algorithm/27.\344\270\244\346\225\260\344\271\213\345\222\214 II - \350\276\223\345\205\245\346\234\211\345\272\217\346\225\260\347\273\204.md" "b/Algorithm/27.\344\270\244\346\225\260\344\271\213\345\222\214 II - \350\276\223\345\205\245\346\234\211\345\272\217\346\225\260\347\273\204.md"
new file mode 100644
index 00000000..b879cd8b
--- /dev/null
+++ "b/Algorithm/27.\344\270\244\346\225\260\344\271\213\345\222\214 II - \350\276\223\345\205\245\346\234\211\345\272\217\346\225\260\347\273\204.md"	
@@ -0,0 +1,97 @@
+27.两数之和 II - 输入有序数组
+===
+
+
+### 题目
+
+给你一个下标从1开始的整数数组numbers，该数组已按非递减顺序排列，请你从数组中找出满足相加之和等于目标数target的两个数。     
+
+如果设这两个数分别是numbers[index1]和numbers[index2]，则`1 <= index1 < index2 <= numbers.length`。     
+
+以长度为`2`的整数数组`[index1, index2]`的形式返回这两个整数的下标`index1`和`index2`。      
+
+你可以假设每个输入只对应唯一的答案，而且你不可以重复使用相同的元素。     
+
+你所设计的解决方案必须只使用常量级的额外空间。     
+
+ 
+示例 1:    
+
+- 输入：numbers = [2,7,11,15], target = 9
+- 输出：[1,2]
+- 解释：2 与 7 之和等于目标数 9 。因此 index1 = 1, index2 = 2 。返回 [1, 2] 。
+
+示例 2:    
+
+- 输入：numbers = [2,3,4], target = 6
+- 输出：[1,3]
+- 解释：2 与 4 之和等于目标数 6 。因此 index1 = 1, index2 = 3 。返回 [1, 3] 。
+
+示例 3:   
+
+- 输入：numbers = [-1,0], target = -1
+- 输出：[1,2]
+- 解释：-1 与 0 之和等于目标数 -1 。因此 index1 = 1, index2 = 2 。返回 [1, 2] 。
+ 
+
+提示:    
+
+- 2 <= numbers.length <= 3 * 104
+- -1000 <= numbers[i] <= 1000
+- numbers 按 非递减顺序 排列
+- -1000 <= target <= 1000
+- 仅存在一个有效答案
+
+### 思路
+
+注意题目说仅存在一个有效答案
+
+
+初始时两个指针分别指向第一个元素位置和最后一个元素的位置。每次计算两个指针指向的两个元素之和，并和目标值比较。如果两个元素之和等于目标值，则发现了唯一解。如果两个元素之和小于目标值，则将左侧指针右移一位。如果两个元素之和大于目标值，则将右侧指针左移一位。移动指针之后，重复上述操作，直到找到答案。
+
+使用双指针的实质是缩小查找范围。那么会不会把可能的解过滤掉？答案是不会。
+
+假设`numbers[i]+numbers[j]=target`是唯一解，其中`0≤i<j≤numbers.length−1`。        
+
+初始时两个指针分别指向下标0和下标`numbers.length−1`，左指针指向的下标小于或等于i，右指针指向的下标大于或等于 j。        除非初始时左指针和右指针已经位于下标 i 和 j，否则一定是左指针先到达下标 i 的位置或者右指针先到达下标 j 的位置。
+
+- 如果左指针先到达下标 i 的位置，此时右指针还在下标 j 的右侧，`sum>target`，因此一定是右指针左移，左指针不可能移到 i 的右侧。
+
+- 如果右指针先到达下标 j 的位置，此时左指针还在下标 i 的左侧，`sum<target`，因此一定是左指针右移，右指针不可能移到 j 的左侧。
+
+由此可见，在整个移动过程中，左指针不可能移到 i 的右侧，右指针不可能移到 j 的左侧，因此不会把可能的解过滤掉。
+
+
+由于题目确保有唯一的答案，因此使用双指针一定可以找到答案。
+
+
+```python
+class Solution:
+    def twoSum(self, numbers: List[int], target: int) -> List[int]:
+        left = 0
+        right = len(numbers) - 1
+        result = [-1]*2
+        while left < right:
+            sum = numbers[left] + numbers[right]
+            if sum < target:
+                left += 1
+            elif sum > target:
+                right -= 1
+            else:
+                return [left+1, right+1]
+
+        return [-1, -1]
+```
+
+复杂度分析:    
+
+- 时间复杂度：O(n)，其中 n 是数组的长度。两个指针移动的总次数最多为 n 次。
+
+- 空间复杂度：O(1)。
+
+
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	
diff --git "a/Algorithm/28.\347\233\233\346\234\200\345\244\232\346\260\264\347\232\204\345\256\271\345\231\250.md" "b/Algorithm/28.\347\233\233\346\234\200\345\244\232\346\260\264\347\232\204\345\256\271\345\231\250.md"
new file mode 100644
index 00000000..d8f7ea6e
--- /dev/null
+++ "b/Algorithm/28.\347\233\233\346\234\200\345\244\232\346\260\264\347\232\204\345\256\271\345\231\250.md"
@@ -0,0 +1,73 @@
+28.盛最多水的容器
+===
+
+
+### 题目
+
+给定一个长度为 n 的整数数组 height 。有 n 条垂线，第 i 条线的两个端点是 (i, 0) 和 (i, height[i]) 。
+
+找出其中的两条线，使得它们与 x 轴共同构成的容器可以容纳最多的水。
+
+返回容器可以储存的最大水量。
+
+说明：你不能倾斜容器。
+
+
+
+示例 1:     
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/leetcode_28_1.png?raw=true)
+
+- 输入：[1,8,6,2,5,4,8,3,7]
+- 输出：49 
+- 解释：图中垂直线代表输入数组 [1,8,6,2,5,4,8,3,7]。在此情况下，容器能够容纳水（表示为蓝色部分）的最大值为 49。
+
+示例 2:    
+
+- 输入：height = [1,1]
+- 输出：1
+ 
+
+提示:    
+
+- n == height.length
+- 2 <= n <= 105
+- 0 <= height[i] <= 104
+
+### 思路
+
+- 求出两个index1和index2，其中index < index2，使得min(height[index1], height[index2]) * (index2 - index1)最大
+- 核心就是：优先移动短板指针，因为面积是由短板的高度决定。
+
+在每个状态下，无论长板或短板向中间收窄一格，都会导致水槽 底边宽度 −1​ 变短:    
+
+- 若向内 移动短板 ，水槽的短板 min(h[i],h[j]) 可能变大，因此下个水槽的面积 可能增大 。
+- 若向内 移动长板 ，水槽的短板 min(h[i],h[j])​ 不变或变小，因此下个水槽的面积 一定变小 。
+
+因此，初始化双指针分列水槽左右两端，循环每轮将短板向内移动一格，并更新面积最大值，直到两指针相遇时跳出；即可获得最大面积。
+
+
+```python
+class Solution:
+    def maxArea(self, height: List[int]) -> int:
+        i, j, res = 0, len(height) - 1, 0
+        while i < j:
+            if height[i] < height[j]:
+                res = max(res, height[i] * (j - i))
+                i += 1
+            else:
+                res = max(res, height[j] * (j - i))
+                j -= 1
+        return res
+```
+
+复杂度分析:    
+
+- 时间复杂度 O(N)​ ： 双指针遍历一次底边宽度 N​​ 。
+- 空间复杂度 O(1)​ ： 变量 i , j , res 使用常数额外空间。
+
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	
diff --git "a/Algorithm/29.\344\270\211\346\225\260\344\271\213\345\222\214.md" "b/Algorithm/29.\344\270\211\346\225\260\344\271\213\345\222\214.md"
new file mode 100644
index 00000000..fae1fd31
--- /dev/null
+++ "b/Algorithm/29.\344\270\211\346\225\260\344\271\213\345\222\214.md"
@@ -0,0 +1,109 @@
+29.三数之和
+===
+
+
+### 题目
+
+
+给你一个整数数组 nums ，判断是否存在三元组 [nums[i], nums[j], nums[k]] 满足 i != j、i != k 且 j != k ，同时还满足 nums[i] + nums[j] + nums[k] == 0 。请你返回所有和为 0 且不重复的三元组。
+
+注意：答案中不可以包含重复的三元组。
+
+ 
+
+ 
+
+示例 1:    
+
+- 输入：nums = [-1,0,1,2,-1,-4]
+- 输出：[[-1,-1,2],[-1,0,1]]
+- 解释:    
+    - nums[0] + nums[1] + nums[2] = (-1) + 0 + 1 = 0 。
+    - nums[1] + nums[2] + nums[4] = 0 + 1 + (-1) = 0 。
+    - nums[0] + nums[3] + nums[4] = (-1) + 2 + (-1) = 0 。
+- 不同的三元组是 [-1,0,1] 和 [-1,-1,2] 。
+注意，输出的顺序和三元组的顺序并不重要。
+
+示例 2:    
+
+- 输入：nums = [0,1,1]
+- 输出：[]
+- 解释：唯一可能的三元组和不为 0 。
+
+示例 3:   
+
+- 输入：nums = [0,0,0]
+- 输出：[[0,0,0]]
+- 解释：唯一可能的三元组和为 0 。
+ 
+
+提示:    
+
+- 3 <= nums.length <= 3000
+- -105 <= nums[i] <= 105
+
+
+### 思路
+
+
+- 特判，对于数组长度 n，如果数组为 null 或者数组长度小于 3，返回 []。
+- 对数组进行从小到大的排序。
+- 从0到nums.length - 2(因为一共三个数，后面还有有两个数)遍历排序后数组:   
+    - 若 nums[i]>0：因为已经排序好，所以后面不可能有三个数加和等于 0，直接返回结果。
+    - 对于重复元素：跳过，避免出现重复解
+    - 令左指针 L=i+1，右指针 R=n−1，当 L<R 时，执行循环:     
+        - 当 nums[i]+nums[L]+nums[R]==0，执行循环，判断左界和右界是否和下一位置重复，去除重复解。并同时将 L,R 移到下一位置，寻找新的解
+        - 若和大于 0，说明 nums[R] 太大，R 左移
+        - 若和小于 0，说明 nums[L] 太小，L 右移
+
+```python
+
+class Solution:
+    def threeSum(self, nums: List[int]) -> List[List[int]]:
+        res = []
+        if not nums or len(nums) < 3:
+            return res
+        nums = sorted(nums)
+        for i in range(len(nums) - 2):
+            if nums[i] > 0:
+                return res
+            if i > 0 and nums[i] == nums[i - 1]:
+                continue
+
+            left = i + 1
+            right = len(nums) - 1
+            while left < right:
+                result = nums[i] + nums[left] + nums[right]
+                if result > 0:
+                    # 需要right减小
+                    right -= 1
+                elif result < 0:
+                    left += 1
+                else:
+                    res.append([nums[i], nums[left], nums[right]])
+                    # 去重复，判断左边或右边的元素是否与当前的相同，相同就夸脱
+                    while left < right and nums[left] == nums[left + 1]:
+                        left += 1
+
+                    while left < right and nums[right] == nums[right - 1]:
+                        right -= 1
+                     # 移动指针
+                    left += 1
+                    right -= 1
+        return res
+
+```
+
+
+复杂度分析:    
+
+- 时间复杂度：O(n²)，数组排序 O(NlogN)，遍历数组 O(n)，双指针遍历 O(n)，总体 O(NlogN)+O(n)∗O(n)，O(n²)
+- 空间复杂度：O(1)
+
+
+
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	
diff --git "a/Algorithm/3.\345\210\240\351\231\244\346\234\211\345\272\217\346\225\260\347\273\204\344\270\255\347\232\204\351\207\215\345\244\215\351\241\271.md" "b/Algorithm/3.\345\210\240\351\231\244\346\234\211\345\272\217\346\225\260\347\273\204\344\270\255\347\232\204\351\207\215\345\244\215\351\241\271.md"
new file mode 100644
index 00000000..8465bf39
--- /dev/null
+++ "b/Algorithm/3.\345\210\240\351\231\244\346\234\211\345\272\217\346\225\260\347\273\204\344\270\255\347\232\204\351\207\215\345\244\215\351\241\271.md"
@@ -0,0 +1,78 @@
+3.删除有序数组中的重复项
+===
+
+
+### 题目
+
+给你一个 非严格递增排列 的数组 nums ，请你 原地 删除重复出现的元素，使每个元素 只出现一次 ，返回删除后数组的新长度。元素的 相对顺序 应该保持 一致 。然后返回 nums 中唯一元素的个数。
+
+考虑 nums 的唯一元素的数量为 k ，你需要做以下事情确保你的题解可以被通过：
+
+更改数组 nums ，使 nums 的前 k 个元素包含唯一元素，并按照它们最初在 nums 中出现的顺序排列。nums 的其余元素与 nums 的大小不重要。
+返回 k 。
+
+
+
+示例 1：
+
+输入：nums = [1,1,2]
+输出：2, nums = [1,2,_]
+解释：函数应该返回新的长度 2 ，并且原数组 nums 的前两个元素被修改为 1, 2 。不需要考虑数组中超出新长度后面的元素。
+示例 2：
+
+输入：nums = [0,0,1,1,1,2,2,3,3,4]
+输出：5, nums = [0,1,2,3,4]
+解释：函数应该返回新的长度 5 ， 并且原数组 nums 的前五个元素被修改为 0, 1, 2, 3, 4 。不需要考虑数组中超出新长度后面的元素。
+
+
+
+### 思路
+
+双指针      
+- 既然非严格递增队列，那么重复的元素一定会相邻，那我们可以从0开始遍历，将没有重复的数值替换放到数组的开头
+
+
+```python
+class Solution:
+    def removeDuplicates(self, nums: List[int]) -> int:
+    	# 第一个位置的不用判断
+        k = 1
+        for i in range(len(nums)):
+        	# 当前的数值与已放置的数值不同就重新放置
+            if nums[i] != nums[k - 1]:
+                nums[k] = nums[i]
+                k += 1
+        return k
+```
+
+
+```kotlin
+class Solution {
+    fun removeDuplicates(nums: IntArray): Int {
+        var k = 1
+        for(i in nums){
+            if (i != nums[k - 1]) {
+                nums[k] = i
+                k ++
+            }
+        }
+        return k
+    }
+}
+```
+
+优化： 
+
+假如数组是[0, 1, 2, 3, 4, 5]
+此时数组中没有重复元素，按照上面的方法，每次比较时nums[i]都不等于nums[k - 1]，因此就会将k指向的元素原地复制一遍，这个操作其实是不必要的。
+
+因此我们可以添加一个小判断，当 i  - k > 1 时，才进行复制。
+
+
+
+
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	
diff --git "a/Algorithm/30.\351\225\277\345\272\246\346\234\200\345\260\217\347\232\204\345\255\220\346\225\260\347\273\204.md" "b/Algorithm/30.\351\225\277\345\272\246\346\234\200\345\260\217\347\232\204\345\255\220\346\225\260\347\273\204.md"
new file mode 100644
index 00000000..c04f8f5d
--- /dev/null
+++ "b/Algorithm/30.\351\225\277\345\272\246\346\234\200\345\260\217\347\232\204\345\255\220\346\225\260\347\273\204.md"
@@ -0,0 +1,102 @@
+30.长度最小的子数组
+===
+
+
+### 题目
+
+给定一个含有 n 个正整数的数组和一个正整数 target 。
+
+找出该数组中满足其总和大于等于 target 的长度最小的 子数组 [numsl, numsl+1, ..., numsr-1, numsr] ，并返回其长度。如果不存在符合条件的子数组，返回 0 。
+
+ 
+
+示例 1:    
+
+- 输入：target = 7, nums = [2,3,1,2,4,3]
+- 输出：2
+- 解释：子数组 [4,3] 是该条件下的长度最小的子数组。
+
+示例 2:    
+
+- 输入：target = 4, nums = [1,4,4]
+- 输出：1
+
+示例 3:    
+
+- 输入：target = 11, nums = [1,1,1,1,1,1,1,1]
+- 输出：0
+ 
+
+提示:    
+
+- 1 <= target <= 109
+- 1 <= nums.length <= 105
+- 1 <= nums[i] <= 104
+ 
+
+进阶:     
+
+如果你已经实现 O(n) 时间复杂度的解法, 请尝试设计一个 O(n log(n)) 时间复杂度的解法。
+
+
+
+### 思路
+
+注意:  
+子数组 是数组中连续的 非空 元素序列。
+
+所以下面排序的方法是错误的。 因为不连续
+```python
+class Solution:
+    def minSubArrayLen(self, target, nums) -> int:
+        nums = sorted(nums, reverse=True)
+        result = 0
+        total = 0
+        for i in nums:
+            print(i)
+            total += i
+            result += 1
+            print(total)
+            if total >= target:
+                print(result)
+                return result
+        return result
+```
+
+
+2.使用队列相加（实际上我们也可以把它称作是滑动窗口，这里的队列其实就相当于一个窗口）
+
+我们把数组中的元素不停的入队，直到总和大于等于 s 为止，接着记录下队列中元素的个数，然后再不停的出队，直到队列中元素的和小于 s 为止（如果不小于 s，也要记录下队列中元素的个数，这个个数其实就是不小于 s 的连续子数组长度，我们要记录最小的即可）。接着再把数组中的元素添加到队列中……重复上面的操作，直到数组中的元素全部使用完为止。
+
+```java
+class Solution {
+    public int minSubArrayLen(int s, int[] nums) {
+        int leftIndex = 0;
+        int rightIndex = 0;
+        int sum = 0;
+        int min = Integer.MAX_VALUE;
+        while (rightIndex < nums.length) {
+            sum += nums[rightIndex++];
+            while (sum >= s) {
+                min = Math.min(min, rightIndex - leftIndex);
+                sum -= nums[leftIndex++];
+            }
+        }
+        return min == Integer.MAX_VALUE ? 0 : min;
+    }
+}
+```
+
+
+复杂度分析:    
+
+- 时间复杂度：O(n)，其中 n 是数组的长度。指针 start 和 end 最多各移动 n 次。
+
+- 空间复杂度：O(1)。
+
+
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	
diff --git "a/Algorithm/31.\346\227\240\351\207\215\345\244\215\345\255\227\347\254\246\347\232\204\346\234\200\351\225\277\345\255\220\344\270\262.md" "b/Algorithm/31.\346\227\240\351\207\215\345\244\215\345\255\227\347\254\246\347\232\204\346\234\200\351\225\277\345\255\220\344\270\262.md"
new file mode 100644
index 00000000..32e4a899
--- /dev/null
+++ "b/Algorithm/31.\346\227\240\351\207\215\345\244\215\345\255\227\347\254\246\347\232\204\346\234\200\351\225\277\345\255\220\344\270\262.md"
@@ -0,0 +1,107 @@
+31.无重复字符的最长子串
+===
+
+
+### 题目
+
+给定一个字符串 s ，请你找出其中不含有重复字符的 最长 子串 的长度。
+
+ 
+
+示例 1:     
+
+- 输入: s = "abcabcbb"
+- 输出: 3 
+- 解释: 因为无重复字符的最长子串是 "abc"，所以其长度为 3。
+
+示例 2:     
+
+- 输入: s = "bbbbb"
+- 输出: 1
+- 解释: 因为无重复字符的最长子串是 "b"，所以其长度为 1。
+
+示例 3:      
+
+- 输入: s = "pwwkew"
+- 输出: 3
+- 解释: 
+    - 因为无重复字符的最长子串是 "wke"，所以其长度为 3。
+    - 请注意，你的答案必须是 子串 的长度，"pwke" 是一个子序列，不是子串。
+ 
+
+提示:    
+
+- 0 <= s.length <= 5 * 104
+- s 由英文字母、数字、符号和空格组成
+
+
+### 思路
+
+这道题主要用到思路是：滑动窗口
+
+什么是滑动窗口？
+
+其实就是一个队列,比如例题中的 abcabcbb，进入这个队列（窗口）为 abc 满足题目要求，当再进入 a，队列变成了 abca，这时候不满足要求。所以，我们要移动这个队列！
+
+如何移动？
+
+我们只要把队列的左边的元素移出就行了，直到满足题目要求！
+
+一直维持这样的队列，找出队列出现最长的长度时候，求出解！
+
+
+
+```python
+class Solution:
+    def lengthOfLongestSubstring(self, s: str) -> int:
+        leftIndex = 0
+        rightIndex = 0
+
+        # pwwkew
+        # "abcabcbb"
+        result = 0
+        while rightIndex < len(s):
+            index = s[leftIndex: rightIndex].find(s[rightIndex])
+            if index >= 0:
+                leftIndex += index + 1
+            rightIndex += 1
+            result = max(result, rightIndex - leftIndex)
+        return result
+```
+
+这个实现的时间复杂度是O(n²)，显然不满足。    
+
+可以使用Set或者HashMap进行优化:   
+
+
+
+```python
+class Solution:
+    def lengthOfLongestSubstring(self, s: str) -> int:
+        leftIndex = 0
+        rightIndex = 0
+        result = 0
+        data = set()
+        while rightIndex < len(s):
+            while s[rightIndex] in data:
+                data.remove(s[leftIndex])
+                leftIndex += 1
+            data.add(s[rightIndex])
+            rightIndex += 1
+            result = max(result, rightIndex - leftIndex)
+        return result
+```
+
+
+
+- 时间复杂度：O(n)
+
+
+
+
+
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	
diff --git "a/Algorithm/32.\344\270\262\350\201\224\346\211\200\346\234\211\345\215\225\350\257\215\347\232\204\345\255\220\344\270\262.md" "b/Algorithm/32.\344\270\262\350\201\224\346\211\200\346\234\211\345\215\225\350\257\215\347\232\204\345\255\220\344\270\262.md"
new file mode 100644
index 00000000..73f0d47d
--- /dev/null
+++ "b/Algorithm/32.\344\270\262\350\201\224\346\211\200\346\234\211\345\215\225\350\257\215\347\232\204\345\255\220\344\270\262.md"
@@ -0,0 +1,218 @@
+32.串联所有单词的子串
+===
+
+
+### 题目
+
+给定一个字符串 s 和一个字符串数组 words。 words 中所有字符串 长度相同。
+
+s 中的 串联子串 是指一个包含  words 中所有字符串以任意顺序排列连接起来的子串。
+
+例如，如果 words = ["ab","cd","ef"]， 那么 "abcdef"， "abefcd"，"cdabef"， "cdefab"，"efabcd"， 和 "efcdab" 都是串联子串。 "acdbef" 不是串联子串，因为他不是任何 words 排列的连接。  
+
+返回所有串联子串在 s 中的开始索引。你可以以 任意顺序 返回答案。
+
+ 
+
+示例 1:    
+
+- 输入：s = "barfoothefoobarman", words = ["foo","bar"]
+- 输出：[0,9]
+- 解释：因为 words.length == 2 同时 words[i].length == 3，连接的子字符串的长度必须为 6。
+- 子串 "barfoo" 开始位置是 0。它是 words 中以 ["bar","foo"] 顺序排列的连接。
+- 子串 "foobar" 开始位置是 9。它是 words 中以 ["foo","bar"] 顺序排列的连接。
+- 输出顺序无关紧要。返回 [9,0] 也是可以的。
+
+示例 2:    
+
+- 输入：s = "wordgoodgoodgoodbestword", words = ["word","good","best","word"]
+- 输出：[]
+- 解释：因为 words.length == 4 并且 words[i].length == 4，所以串联子串的长度必须为 16。
+- s 中没有子串长度为 16 并且等于 words 的任何顺序排列的连接。
+- 所以我们返回一个空数组。
+
+示例 3:    
+
+- 输入：s = "barfoofoobarthefoobarman", words = ["bar","foo","the"]
+- 输出：[6,9,12]
+- 解释：因为 words.length == 3 并且 words[i].length == 3，所以串联子串的长度必须为 9。
+- 子串 "foobarthe" 开始位置是 6。它是 words 中以 ["foo","bar","the"] 顺序排列的连接。
+- 子串 "barthefoo" 开始位置是 9。它是 words 中以 ["bar","the","foo"] 顺序排列的连接。
+- 子串 "thefoobar" 开始位置是 12。它是 words 中以 ["the","foo","bar"] 顺序排列的连接。
+ 
+
+提示:     
+
+- 1 <= s.length <= 104
+- 1 <= words.length <= 5000
+- 1 <= words[i].length <= 30
+- words[i] 和 s 由小写英文字母组成
+
+### 思路
+
+##### 方法一，从头到尾遍历s
+
+- words中每个字符的长度是m、words整个数组的长度是n
+- 那我们每次可以从s中从头开始去遍历，每次是取 `m*n` 个字符(窗口)
+- 然后把这个`m*n`个字符按照words中每个字符的长度m进行分割，然后把分割后的单词与words中的单词进行比较
+- 如果和words中的都一样，那当前的索引就是。否则不是
+- 在与words中的单词进行比较的时候，这个时候是不用关心顺序的，所以我们可以用一个哈希表来表示单词以及频次
+    - 当窗口中出现一个单词时，我们就把该单词加到哈希表中，如果已经存在，那就在后面的值+1
+    - 然后用哈希表中的内容与words中的单词进行对比，如果words中出现一个单词且也在哈希表中，那就将哈希表中该单词的频次减1，如果是0了就一次该单词
+    - 等到最后都遍历完，如果哈希表的长度是0，那就说明完全与words重点额一样
+
+```python
+
+class Solution:
+
+    def findSubstring(self, s: str, words: List[str]) -> List[int]:
+        res = []
+        if len(s) == 0 or len(words) == 0 or len(words[0]) == 0:
+            return[]
+
+        wordsLength = len(words[0])
+        slideLength = wordsLength * len(words)
+        wordsCount = len(words)
+
+        wordsMap = dict()
+        for word in words:
+            wordsMap[word] = wordsMap.get(word, 0) + 1
+
+        tempMap = dict()
+        for index in range(len(s) - slideLength + 1):
+            currentString = s[index: index+slideLength]
+            print(currentString)
+            for currentStringIndex in range(wordsCount):
+                currentWord = currentString[currentStringIndex * wordsLength: (currentStringIndex + 1) * wordsLength]
+                tempMap[currentWord] = tempMap.get(currentWord, 0) + 1
+
+            print(tempMap)
+            print(wordsMap)
+            if tempMap == wordsMap:
+                res.append(index)
+            tempMap.clear()
+
+
+        return res
+```
+
+
+
+时间复杂度：O(n×m×k)，n为s的长度，m为每个words中单词的长度，也就是len(words[0])，k为words的长度，也就是len(words)
+
+
+空间复杂度：每次循环都新建一个字典tempMap，但循环结束就清除，所以空间为O(m)（m是words中不同单词的个数）？实际上每次循环都重新统计，所以空间上是O(m)，但要注意，我们每次循环都重新统计整个子串，所以没有利用滑动窗口的特性。
+
+
+而下面方法二的时间复杂度是： 
+- O(n×k): n为s的长度，k为words中单词的个数
+
+
+
+##### 方法二
+
+
+上面方法一种当仅使用一个从0开始的滑动窗口时，为了避免漏掉一些子串，在缩短窗口时，每次只能缩小一格，而且这还会导致窗口内所维护的单词计数无效。那么，希望有一个方法，可以保证:     
+- 不遗漏子串
+- 缩小窗口时，不会使窗口内的单词计数无效
+
+那么，在使用滑动窗口时，每次都移动 sz = len(words[0]) 个字符，那么我们就可以按照单词的纬度进行统计。
+但是，这样会导致某一些子串没有枚举到（即[1, sz-1]为起点的子串都被忽略了），所以为了保证不遗漏子串，可以枚举以[0, sz-1]为起点的所有滑动窗口，并且每一个滑窗都是互相独立的。
+
+--- 
+
+- 建立滑动窗口
+
+    - 如何建立：计算窗口长度为：words中所有串拼接后的长度len，第一个窗口为[0,len-1]。
+    - 如果窗口中的字符串和words中所有串拼接后相等，则说明满足要求。
+    - 如何判断:     
+        - 将words中的所有word放入hashmap。key为word，value为个数。
+        - 对窗口进行substr操作，每隔d，substr一次。d为words中word的长度。将substr的结果作为key放入另一个hashmap,个数为value。
+        - 当窗口中没有剩余字符时，对两个map进行判断，如果相等。说明满足要求。此时记录窗口的起点。
+
+- 建立多起点的滑动窗口。
+
+    - 何为多起点：
+        - 一般理解滑动窗口从0或者某个数值开始，向右滑动不断滑动一个步长。
+        - 此处需要建立多个滑动窗口，数量为d。起点分别为0,1,2...d；
+
+    - 为何需要多起点：
+        - 如果只建立一个滑动窗口，那么每次就只能滑动一格，因为需要找到所有的可能。但是这样的操作意味着之前建立的map需要重新构建
+        - 例如：foobarfoobar [foo][bar]。当foobar完成匹配后，向右滑动一格，oobarf。这时候需要重新构建map。插入oob ,arf。时间复杂度很高，而滑动窗口应该是线性时间复杂度，
+        - 理想状态是，滑动d格，删去左侧foo，加入右侧foo。这个时候不需要重新构建map，map中原本的foo的计数先-1再+1即可，然后判断即可。
+
+    那么如果按照上面的方法，每次都滑动d，又会漏检。例如afoobarfoobar [foo][bar]     
+    
+    因此，需要多起点，afoobar，foobar。。个数为d个。这样每个窗口每次都是滑动d格。map的效率最高
+
+    - 如何建立多起点
+
+    - 从0开始初始化d个滑动窗口。每个滑动窗口每次都是滑动d格。建立相应的map。
+
+    - 最后得到vector<map<string, int>>;
+
+- 滑动
+
+    - 由于已经建立了多起点的滑动窗口，所以不会存在漏检的情况。同时map的效率最高。
+
+
+
+
+
+
+```java
+
+class Solution {
+    public List<Integer> findSubstring(String s, String[] words) {
+    	// 记录所有满足的结果索引
+        List<Integer> res = new ArrayList<>();
+        if (s == null || s.length() == 0 || words == null || words.length == 0) {
+        	return res;
+        }
+        	
+        HashMap<String, Integer> map = new HashMap<>();
+        // 每个单词的长度是固定的
+        int one_word = words[0].length();
+        int word_num = words.length;
+        // 窗口长度
+        int all_len = one_word * word_num;
+        // 把words中的内容和次数都记录到HashMap中
+        for (String word : words) {
+            map.put(word, map.getOrDefault(word, 0) + 1);
+        }
+
+        for (int i = 0; i < one_word; i++) {
+            int left = i, right = i, count = 0;
+            HashMap<String, Integer> tmp_map = new HashMap<>();
+            while (right + one_word <= s.length()) {
+                String w = s.substring(right, right + one_word);
+                right += one_word;
+                if (!map.containsKey(w)) {
+                    count = 0;
+                    left = right;
+                    tmp_map.clear();
+                } else {
+                    tmp_map.put(w, tmp_map.getOrDefault(w, 0) + 1);
+                    count++;
+                    while (tmp_map.getOrDefault(w, 0) > map.getOrDefault(w, 0)) {
+                        String t_w = s.substring(left, left + one_word);
+                        count--;
+                        tmp_map.put(t_w, tmp_map.getOrDefault(t_w, 0) - 1);
+                        left += one_word;
+                    }
+                    if (count == word_num) res.add(left);
+                }
+            }
+        }
+        return res;
+    }
+}
+```
+
+
+
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	
diff --git "a/Algorithm/33.\346\234\200\345\260\217\350\246\206\347\233\226\345\255\220\344\270\262.md" "b/Algorithm/33.\346\234\200\345\260\217\350\246\206\347\233\226\345\255\220\344\270\262.md"
new file mode 100644
index 00000000..c4f31bed
--- /dev/null
+++ "b/Algorithm/33.\346\234\200\345\260\217\350\246\206\347\233\226\345\255\220\344\270\262.md"
@@ -0,0 +1,109 @@
+33.最小覆盖子串
+===
+
+
+### 题目
+
+给你一个字符串s、一个字符串t。返回s中涵盖t所有字符的最小子串。如果s中不存在涵盖t所有字符的子串，则返回空字符串 "" 。
+
+ 
+
+注意:    
+
+- 对于 t 中重复字符，我们寻找的子字符串中该字符数量必须不少于 t 中该字符数量。
+- 如果 s 中存在这样的子串，我们保证它是唯一的答案。
+ 
+
+示例 1:    
+
+- 输入：s = "ADOBECODEBANC", t = "ABC"
+- 输出："BANC"
+- 解释：最小覆盖子串 "BANC" 包含来自字符串 t 的 'A'、'B' 和 'C'。
+
+示例 2:    
+
+- 输入：s = "a", t = "a"
+- 输出："a"
+- 解释：整个字符串 s 是最小覆盖子串。
+
+示例 3:    
+
+- 输入: s = "a", t = "aa"
+- 输出: ""
+- 解释: t 中两个字符 'a' 均应包含在 s 的子串中，因此没有符合条件的子字符串，返回空字符串。
+ 
+
+提示:     
+
+- m == s.length
+- n == t.length
+- 1 <= m, n <= 105
+- s 和 t 由英文字母组成
+ 
+
+进阶：你能设计一个在 o(m+n) 时间内解决此问题的算法吗？
+
+### 思路
+
+题目中说如果 s 中存在这样的子串，我们保证它是唯一的答案。
+
+双指针
+
+- 初始化ansLeft=−1, ansRight=m，用来记录最短子串的左右端点，其中m是s的长度。
+- 用一个哈希表（或者数组）cntT 统计 t 中每个字母的出现次数。
+- 初始化 left=0，以及一个空哈希表（或者数组）cntS，用来统计 s 子串中每个字母的出现次数。
+- 遍历 s，设当前枚举的子串右端点为 right，把 s[right] 的出现次数加一。
+- 遍历 cntS 中的每个字母及其出现次数，如果出现次数都大于等于 cntT 中的字母出现次数：
+    - 如果`right−left<ansRight−ansLeft`，说明我们找到了更短的子串，更新 ansLeft=left, ansRight=right。
+    - 把 s[left] 的出现次数减一。
+    - 左端点右移，即 left 加一。
+    重复上述三步，直到 cntS 有字母的出现次数小于 cntT 中该字母的出现次数为止。
+
+最后，如果 ansLeft<0，说明没有找到符合要求的子串，返回空字符串，否则返回下标 ansLeft 到下标 ansRight 之间的子串。
+由于本题大写字母和小写字母都有，为了方便，代码实现时可以直接创建大小为 128 的数组，保证所有 ASCII 字符都可以统计。
+
+
+```java
+class Solution {
+    public String minWindow(String s, String t) {
+        Map<Character, Integer> cnt = new HashMap<>();
+        for (char c : t.toCharArray()) {
+            cnt.put(c, cnt.getOrDefault(c, 0) + 1);
+        }
+        int ans_l = -1;
+        int ans_r = s.length();
+        int l = 0;
+        int count = cnt.size();
+        for (int r = 0; r < s.length(); r++) {
+            char c = s.charAt(r);
+            if (cnt.containsKey(c)) {
+                cnt.put(c, cnt.get(c) - 1);
+                if (cnt.get(c) == 0) {
+                    count--;
+                }
+            }
+            while (count == 0) {
+                if (ans_r - ans_l > r - l) {
+                    ans_l = l;
+                    ans_r = r;
+                }
+                char ch = s.charAt(l);
+                if (cnt.containsKey(ch)) {
+                    if (cnt.get(ch) == 0) {
+                        count++;
+                    }
+                    cnt.put(ch, cnt.get(ch) + 1);
+                }
+                l++;
+            }
+        }
+        return ans_l == -1 ? "" : s.substring(ans_l, ans_r+1);
+    }
+}
+```
+
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	
diff --git "a/Algorithm/34.\346\234\211\346\225\210\347\232\204\346\225\260\347\213\254.md" "b/Algorithm/34.\346\234\211\346\225\210\347\232\204\346\225\260\347\213\254.md"
new file mode 100644
index 00000000..e1c6fefa
--- /dev/null
+++ "b/Algorithm/34.\346\234\211\346\225\210\347\232\204\346\225\260\347\213\254.md"
@@ -0,0 +1,142 @@
+34.有效的数独
+===
+
+
+### 题目
+
+请你判断一个 9 x 9 的数独是否有效。只需要 根据以下规则 ，验证已经填入的数字是否有效即可。
+
+数字 1-9 在每一行只能出现一次。
+数字 1-9 在每一列只能出现一次。
+数字 1-9 在每一个以粗实线分隔的 3x3 宫内只能出现一次。（请参考示例图）
+ 
+
+注意:     
+
+- 一个有效的数独（部分已被填充）不一定是可解的。
+- 只需要根据以上规则，验证已经填入的数字是否有效即可。
+- 空白格用 '.' 表示。
+
+
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/isValidSudoku.png?raw=true)
+
+
+```
+输入：board = 
+[["5","3",".",".","7",".",".",".","."]
+,["6",".",".","1","9","5",".",".","."]
+,[".","9","8",".",".",".",".","6","."]
+,["8",".",".",".","6",".",".",".","3"]
+,["4",".",".","8",".","3",".",".","1"]
+,["7",".",".",".","2",".",".",".","6"]
+,[".","6",".",".",".",".","2","8","."]
+,[".",".",".","4","1","9",".",".","5"]
+,[".",".",".",".","8",".",".","7","9"]]
+```
+输出：true
+
+```
+输入：board = 
+[["8","3",".",".","7",".",".",".","."]
+,["6",".",".","1","9","5",".",".","."]
+,[".","9","8",".",".",".",".","6","."]
+,["8",".",".",".","6",".",".",".","3"]
+,["4",".",".","8",".","3",".",".","1"]
+,["7",".",".",".","2",".",".",".","6"]
+,[".","6",".",".",".",".","2","8","."]
+,[".",".",".","4","1","9",".",".","5"]
+,[".",".",".",".","8",".",".","7","9"]]
+```
+输出：false
+解释：除了第一行的第一个数字从 5 改为 8 以外，空格内其他数字均与 示例1 相同。 但由于位于左上角的 3x3 宫内有两个 8 存在, 因此这个数独是无效的。
+
+
+提示:     
+
+- board.length == 9
+- board[i].length == 9
+- board[i][j] 是一位数字（1-9）或者 '.'
+
+
+### 思路
+
+有效的数独满足以下三个条件：    
+
+- 同一个数字在每一行只能出现一次；
+
+- 同一个数字在每一列只能出现一次；
+
+- 同一个数字在每一个小九宫格只能出现一次。
+
+--- 
+
+- i是行标      
+- j是列标
+- 数字从char直接转换成int，会变成对应的ASCII数字码，而不是原来的数值。解决方法就是当前char数字减'0'：用两个char数字的ASCII码相减，差值就是原来char数值直接对应的int数值。
+    - 为什么不是减'0'，而是减'1'？
+    - 若运行了大佬的代码你会发现，减'0'的话会出现`ArrayIndexOutOfBoundsException`的异常。因为后面的代码将这个`num`作为了数组的下标。本身数组设置的就是9个位置，下标范围是`[0~8]`，那么遇到数字9作为下标的时候，不就越位了吗，所以就要减1，char转换成int的同时还能解决后面越位的情况。
+- boolean数组的巧妙建立
+    - 第一个[]存放第？行/列/块
+    - 第二个[]存放 相应数字
+    - 结合起来解释就是：第？行/列/块 是否 出现过相应数字
+
+- 行标决定一组block的起始位置（因为block为3行，所以除3取整得到组号，又因为每组block为3个，所以需要乘3），列标再细分出是哪个block（因为block是3列，所以除3取整）
+
+```
+blockIndex = i / 3 * 3 + j / 3的原因:    
+[0, 0, 0, 1, 1, 1, 2, 2, 2]
+[0, 0, 0, 1, 1, 1, 2, 2, 2]
+[0, 0, 0, 1, 1, 1, 2, 2, 2]
+[3, 3, 3, 4, 4, 4, 5, 5, 5]
+[3, 3, 3, 4, 4, 4, 5, 5, 5]
+[3, 3, 3, 4, 4, 4, 5, 5, 5]
+[6, 6, 6, 7, 7, 7, 8, 8, 8]
+[6, 6, 6, 7, 7, 7, 8, 8, 8]
+[6, 6, 6, 7, 7, 7, 8, 8, 8]
+```
+
+- blockIndex的规律探寻
+    - 微观`9x9` -> 宏观`3x3`
+    - （1）`i/3`为行号，`j/3`为列号
+    - （2）二维数组思路：`行号*列数＋列号`，即位置
+
+
+
+
+```java
+
+class Solution {
+    public boolean isValidSudoku(char[][] board) {
+        // 记录某行，某位数字是否已经被摆放
+        boolean[][] row = new boolean[9][9];
+        // 记录某列，某位数字是否已经被摆放
+        boolean[][] col = new boolean[9][9];
+        // 记录某 3x3 宫格内，某位数字是否已经被摆放
+        boolean[][] block = new boolean[9][9];
+
+        for (int i = 0; i < 9; i++) {
+            for (int j = 0; j < 9; j++) {
+                if (board[i][j] != '.') { // 只处理数字格子
+                    int num = board[i][j] - '1';
+                    int blockIndex = i / 3 * 3 + j / 3;
+                    if (row[i][num] || col[j][num] || block[blockIndex][num]) {
+                        return false;
+                    } else {
+                        row[i][num] = true;
+                        col[j][num] = true;
+                        block[blockIndex][num] = true;
+                    }
+                }
+            }
+        }
+        return true;
+    }
+}
+```
+
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	
diff --git "a/Algorithm/35.\350\236\272\346\227\213\347\237\251\351\230\265.md" "b/Algorithm/35.\350\236\272\346\227\213\347\237\251\351\230\265.md"
new file mode 100644
index 00000000..cdde4f92
--- /dev/null
+++ "b/Algorithm/35.\350\236\272\346\227\213\347\237\251\351\230\265.md"
@@ -0,0 +1,99 @@
+35.螺旋矩阵
+===
+
+
+### 题目
+
+
+给你一个 m 行 n 列的矩阵 matrix ，请按照 顺时针螺旋顺序 ，返回矩阵中的所有元素。
+ 
+
+示例 1:    
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/spiralOrder_1.png?raw=true)
+
+- 输入：matrix = [[1,2,3],[4,5,6],[7,8,9]]
+- 输出：[1,2,3,6,9,8,7,4,5]
+
+示例 2:    
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/spiralOrder_2.png?raw=true)
+
+- 输入：matrix = [[1,2,3,4],[5,6,7,8],[9,10,11,12]]
+- 输出：[1,2,3,4,8,12,11,10,9,5,6,7]
+ 
+
+提示:    
+
+- m == matrix.length
+- n == matrix[i].length
+- 1 <= m, n <= 10
+- -100 <= matrix[i][j] <= 100
+
+
+### 思路
+
+- 对于这种螺旋遍历的方法，重要的是要确定上下左右四条边的位置
+- 初始化的时候，上边up就是0，下边down就是m-1，左边left是0，右边right是n-1。
+- 然后我们进行while循环
+    - 先遍历上边第一行up ，将所有元素加入结果res，然后上边下移一位，如果此时上边大于下边，说明此时已经遍历完成了，直接break。
+
+
+```java
+class Solution {
+    public List<Integer> spiralOrder(int[][] matrix) {
+        List<Integer> res=new ArrayList<Integer>();
+
+        if(matrix.length==0 || matrix[0].length==0) {
+            return res;
+        }
+
+        int m = matrix.length;
+        int n =matrix[0].length;
+
+        int up = 0;
+        int down = m-1;
+        int left = 0;
+        int right = n-1;
+
+        while(true) {
+            for(int i=left; i<=right; i++) {
+            	res.add(matrix[up][i]);
+            }
+
+            if (++up > down) {
+            	break;
+            }
+
+            for (int i = up; i <= down; i++) {
+            	res.add(matrix[i][right]);
+            }
+
+            if (--right < left) {
+            	break;
+            }
+
+            for (int i = right; i >= left; i--) {
+            	res.add(matrix[down][i]);
+            }
+
+            if (--down < up) {
+            	break;
+            }
+
+            for (int i = down; i >= up; i--) {
+            	res.add(matrix[i][left]);
+            }
+
+            if (++left > right) {
+            	break;
+            }
+        }
+        return res;
+    }
+}
+```
+
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	
diff --git "a/Algorithm/36.\346\227\213\350\275\254\345\233\276\345\203\217.md" "b/Algorithm/36.\346\227\213\350\275\254\345\233\276\345\203\217.md"
new file mode 100644
index 00000000..ddda4601
--- /dev/null
+++ "b/Algorithm/36.\346\227\213\350\275\254\345\233\276\345\203\217.md"
@@ -0,0 +1,252 @@
+36.旋转图像
+===
+
+
+### 题目
+
+
+给定一个 n × n 的二维矩阵 matrix 表示一个图像。请你将图像顺时针旋转 90 度。
+
+你必须在 原地 旋转图像，这意味着你需要直接修改输入的二维矩阵。请不要 使用另一个矩阵来旋转图像。
+
+示例1:   
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/leetcode_rotate_1.png?raw=true)
+
+- 输入：matrix = [[1,2,3],[4,5,6],[7,8,9]]
+- 输出：[[7,4,1],[8,5,2],[9,6,3]]
+
+示例2:   
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/leetcode_rotate_2.png?raw=true)
+
+- 输入：matrix = [[5,1,9,11],[2,4,8,10],[13,3,6,7],[15,14,12,16]]
+- 输出：[[15,13,2,5],[14,3,4,1],[12,6,8,9],[16,7,10,11]]
+
+
+提示:    
+
+- n == matrix.length == matrix[i].length
+- 1 <= n <= 20
+- -1000 <= matrix[i][j] <= 1000
+
+
+
+
+### 思路
+
+##### 方法一： 辅助矩阵
+
+如下图所示，矩阵顺时针旋转 90º 后，可找到以下规律:     
+
+- 「第 i 行」元素旋转到「第 n−1−i 列」元素；
+- 「第 j 列」元素旋转到「第 j 行」元素；
+
+因此，对于矩阵任意第 i 行、第 j 列元素 matrix[i][j] ，矩阵旋转 90º 后「元素位置旋转公式」为:      
+
+```
+matrix[i][j] → matrix[j][n−1−i]
+原索引位置 →旋转后索引位置 
+​```
+  
+
+
+根据以上「元素旋转公式」，考虑遍历矩阵，将各元素依次写入到旋转后的索引位置。但仍存在问题：在写入一个元素 matrix[i][j]→matrix[j][n−1−i] 后，原矩阵元素 matrix[j][n−1−i] 就会被覆盖（即丢失），而此丢失的元素就无法被写入到旋转后的索引位置了。
+
+为解决此问题，考虑借助一个「辅助矩阵」暂存原矩阵，通过遍历辅助矩阵所有元素，将各元素填入「原矩阵」旋转后的新索引位置即可。
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/leetcode_rotate_3.png?raw=true)
+
+```python3
+class Solution:
+    def rotate(self, matrix: List[List[int]]) -> None:
+        n = len(matrix)
+        # 深拷贝 matrix -> tmp
+        tmp = copy.deepcopy(matrix)
+        # 根据元素旋转公式，遍历修改原矩阵 matrix 的各元素
+        for i in range(n):
+            for j in range(n):
+                matrix[j][n - 1 - i] = tmp[i][j]
+```
+
+复杂度分析:   
+​
+- 遍历矩阵所有元素的时间复杂度为O(N²)
+- 由于借助了一个辅助矩阵，空间复杂度为O(N²)。
+
+
+##### 方法二：原地修改
+
+
+考虑不借助辅助矩阵，通过在原矩阵中直接「原地修改」，实现空间复杂度 O(1) 的解法。
+
+以位于矩阵四个角点的元素为例，设矩阵左上角元素A、右上角元素B、右下角元素C、左下角元素D。      
+
+矩阵旋转90º后，相当于依次先后执行D→A,C→D,B→C,A→B修改元素，即如下「首尾相接」的元素旋转操作:     
+```
+A←D←C←B←A
+```
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/leetcode_rotate_4.png?raw=true)
+
+
+如上图所示:    
+
+- 由于第1步D→A已经将A覆盖（导致A丢失），此丢失导致最后第4步A→B无法赋值。为解决此问题，考虑借助一个「辅助变量 tmp 」预先存储 A ，此时的旋转操作变为：
+
+```
+暂存 tmp=A
+A←D←C←B←tmp
+```
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/leetcode_rotate_5.png?raw=true)
+
+
+
+如上图所示，一轮可以完成矩阵 4 个元素的旋转。因而，只要分别以矩阵左上角 1/4 的各元素为起始点执行以上旋转操作，即可完整实现矩阵旋转。
+
+- 当矩阵大小 n 为偶数时，取前½ * n行、前 ½ * n 列的元素为起始点；
+
+- 当矩阵大小 n 为奇数时，取前 ½ * n 行、前  ½ * (n + 1)列的元素为起始点。
+
+令 matrix[i][j]=A ，根据文章开头的元素旋转公式，可推导得适用于任意起始点的元素旋转操作：
+
+```
+暂存tmp=matrix[i][j]
+matrix[i][j]←matrix[n−1−j][i]←matrix[n−1−i][n−1−j]←matrix[j][n−1−i]←tmp
+```
+
+
+
+```python3
+class Solution:
+    def rotate(self, matrix: List[List[int]]) -> None:
+        n = len(matrix)
+        for i in range(n // 2):
+            for j in range((n + 1) // 2):
+                tmp = matrix[i][j]
+                matrix[i][j] = matrix[n - 1 - j][i]
+                matrix[n - 1 - j][i] = matrix[n - 1 - i][n - 1 - j]
+                matrix[n - 1 - i][n - 1 - j] = matrix[j][n - 1 - i]
+                matrix[j][n - 1 - i] = tmp
+```
+
+
+```java
+class Solution {
+    public void rotate(int[][] matrix) {
+        // 设矩阵行列数为 n
+        int n = matrix.length;
+        // 起始点范围为 0 <= i < n / 2 , 0 <= j < (n + 1) / 2
+        // 其中 '/' 为整数除法
+        for (int i = 0; i < n / 2; i++) {
+            for (int j = 0; j < (n + 1) / 2; j++) {
+                // 暂存 A 至 tmp
+                int tmp = matrix[i][j];
+                // 元素旋转操作 A <- D <- C <- B <- tmp
+                matrix[i][j] = matrix[n - 1 - j][i];
+                matrix[n - 1 - j][i] = matrix[n - 1 - i][n - 1 - j];
+                matrix[n - 1 - i][n - 1 - j] = matrix[j][n - 1 - i];
+                matrix[j][n - 1 - i] = tmp;
+            }
+        }
+    }
+}
+```
+
+复杂度分析:    
+
+- 时间复杂度 O(N²): 其中 N 为输入矩阵的行（列）数。需要将矩阵中每个元素旋转到新的位置，即对矩阵所有元素操作一次，使用O(N²)时间。
+- 空间复杂度 O(1): 临时变量 tmp 使用常数大小的额外空间。值得注意，当循环中进入下轮迭代，上轮迭代初始化的 tmp 占用的内存就会被自动释放，因此无累计使用空间。
+
+
+##### 方法三: 先转置再左右翻转
+
+```
+很明显可以发现，对二位矩阵顺时针旋转90度，等价于先对二位矩阵进行转置操作，再对转置后的数组进行左右翻转。
+如：
+原矩阵：
+1   2   3
+4   5   6
+7   8   9
+
+转置后：
+1   4   7
+2   5   8   
+3   6   9
+
+左右翻转：
+7   4   1   
+8   5   2   
+9   6   3
+
+原矩阵：
+1   2   3
+4   5   6
+7   8   9
+
+顺时针旋转90度：
+7   4   1
+8   5   2   
+9   6   3
+
+可以发现，顺时针旋转90度后的矩阵，于先转置再左右翻转的矩阵相同
+```
+
+1、矩阵转置:
+
+矩阵的转置是将矩阵的行和列互换，即将元素 matrix[i][j] 和 matrix[j][i] 交换。
+性质:    
+- 转置操作不会改变主对角线上的元素（即 i=j 时的元素）。
+- 转置完成后，矩阵变为关于主对角线对称。
+
+本质：将矩阵对角线两边的元素互换
+
+
+2、逐行翻转:
+
+- 对转置后的矩阵，每一行进行翻转，即从左到右交换元素，得到最终旋转后的结果。
+
+性质：
+转置只是调整了行列的关系，但要实现顺时针旋转 90 度，还需要将转置后的行元素顺序反转。
+
+
+全部代码:    
+
+```python3
+class Solution:
+    def transpose(self, matrix:List[List[int]]) -> None:
+        length = len(matrix)
+        for i in range(0, length):
+            for j in range(0, i):
+                temp = matrix[i][j]
+                matrix[i][j] = matrix[j][i]
+                matrix[j][i] = temp
+
+    def overturn(self, matrix:List[List[int]]) -> None:
+        length = len(matrix)
+        for i in range(0, length//2):
+            for j in range(0, length):
+                temp = matrix[j][i]
+                matrix[j][i] = matrix[j][length - 1 - i]
+                matrix[j][length - 1 - i] = temp
+
+    def rotate(self, matrix: List[List[int]]) -> None:
+        """
+        Do not return anything, modify matrix in-place instead.
+        """
+        self.transpose(matrix)
+        self.overturn(matrix)
+```
+
+
+- 时间复杂度: O(N²)
+- 空间复杂度: O(1)
+
+
+
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	
diff --git "a/Algorithm/37.\347\237\251\351\230\265\347\275\256\351\233\266.md" "b/Algorithm/37.\347\237\251\351\230\265\347\275\256\351\233\266.md"
new file mode 100644
index 00000000..774d552c
--- /dev/null
+++ "b/Algorithm/37.\347\237\251\351\230\265\347\275\256\351\233\266.md"
@@ -0,0 +1,165 @@
+37.矩阵置零
+===
+
+
+
+### 题目
+
+给定一个 m x n 的矩阵，如果一个元素为 0 ，则将其所在行和列的所有元素都设为 0 。请使用 原地 算法。
+
+
+示例:    
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/leetcode_setzeros_1.png?raw=true)
+
+- 输入: matrix = [[0,1,2,0],[3,4,5,2],[1,3,1,5]]
+- 输出: [[0,0,0,0],[0,4,5,0],[0,3,1,0]]
+
+提示:    
+
+- m == matrix.length
+- n == matrix[0].length
+- 1 <= m, n <= 200
+- -231 <= matrix[i][j] <= 231 - 1
+ 
+
+进阶:     
+
+- 一个直观的解决方案是使用  O(mn) 的额外空间，但这并不是一个好的解决方案。
+- 一个简单的改进方案是使用 O(m + n) 的额外空间，但这仍然不是最好的解决方案。
+
+你能想出一个仅使用常量空间的解决方案吗？
+
+
+### 思路
+
+
+思路一:   用 O(m+n)额外空间
+ 
+- 两遍扫matrix,第一遍用集合记录哪些行,哪些列有0;第二遍置0
+
+```java
+class Solution {
+    public void setZeroes(int[][] matrix) {
+        Set<Integer> row_zero = new HashSet<>();
+        Set<Integer> col_zero = new HashSet<>();
+        int row = matrix.length;
+        int col = matrix[0].length;
+        for (int i = 0; i < row; i++) {
+            for (int j = 0; j < col; j++) {
+                if (matrix[i][j] == 0) {
+                    row_zero.add(i);
+                    col_zero.add(j);
+                }
+            }
+        }
+        for (int i = 0; i < row; i++) {
+            for (int j = 0; j < col; j++) {
+                if (row_zero.contains(i) || col_zero.contains(j)) matrix[i][j] = 0;
+            }
+        }  
+    }
+}
+```
+
+思路二: 用O(1)空间      
+
+关键思想: 用matrix第一行和第一列记录该行该列是否有0,作为标志位
+
+但是对于第一行,和第一列要设置一个标志位,为了防止自己这一行(一列)也有0的情况.注释写在代码里,直接看代码很好理解!
+
+思路：第一次循环
+1、0行数组的每个元素临时标识该元素所在列是否有0，0列数组的每个元素临时标识该元素所在行是否有0。
+2、判断每行的第0列是否为0，有则赋值额外的标识字段，该字段的作用是用于后续对称遍历的时候，赋值所有行的0列是否应该赋值0使用
+
+```
+比如原始数组为
+[
+	[2,1,2,3],
+	[2,1,2,3],
+	[3,0,5,2],
+	[1,3,0,5]
+]
+
+
+// 如果当前遍历位置为0，则该行0列设置标识，以便后续使用
+// 如果当前遍历位置为0，则0行该列设置标识，以便后续使用
+[
+    [2,0,0,3],
+    [2,1,2,3],
+    [0,0,5,2],
+    [0,3,0,5]
+]
+// 第二次循环-从右下角遍历处理：行从最后一行遍历（直到0行），列从最后一列遍历(直到第一列)
+// 使用0行数组、0列数组判断当前遍历位置是否应该置0
+// 注意需要额外使用标识字段判断该行0列是否应该置0
+// 处理完成之后
+[
+    [2,0,0,3],
+    [2,0,0,3],
+    [0,0,0,0],
+    [0,0,0,0]
+]
+
+```
+
+
+```java
+
+class Solution {
+    public void setZeroes(int[][] matrix) {
+        int row = matrix.length;
+        int col = matrix[0].length;
+        boolean row0_flag = false;
+        boolean col0_flag = false;
+        // 第一行是否有零
+        for (int j = 0; j < col; j++) {
+            if (matrix[0][j] == 0) {
+                row0_flag = true;
+                break;
+            }
+        }
+        // 第一列是否有零
+        for (int i = 0; i < row; i++) {
+            if (matrix[i][0] == 0) {
+                col0_flag = true;
+                break;
+            }
+        }
+        // 把第一行第一列作为标志位
+        for (int i = 1; i < row; i++) {
+            for (int j = 1; j < col; j++) {
+                if (matrix[i][j] == 0) {
+                    matrix[i][0] = matrix[0][j] = 0;
+                }
+            }
+        }
+        // 置0
+        for (int i = 1; i < row; i++) {
+            for (int j = 1; j < col; j++) {
+                if (matrix[i][0] == 0 || matrix[0][j] == 0) {
+                    matrix[i][j] = 0;
+                }
+            }
+        }
+        if (row0_flag) {
+            for (int j = 0; j < col; j++) {
+                matrix[0][j] = 0;
+            }
+        }
+        if (col0_flag) {
+            for (int i = 0; i < row; i++) {
+                matrix[i][0] = 0;
+            }
+        } 
+    }
+}
+```
+
+
+
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	
diff --git "a/Algorithm/38.\347\224\237\345\221\275\346\270\270\346\210\217.md" "b/Algorithm/38.\347\224\237\345\221\275\346\270\270\346\210\217.md"
new file mode 100644
index 00000000..f2e79bb5
--- /dev/null
+++ "b/Algorithm/38.\347\224\237\345\221\275\346\270\270\346\210\217.md"
@@ -0,0 +1,137 @@
+38.生命游戏
+===
+
+
+### 题目
+
+
+生命游戏，简称为 生命 ，是英国数学家约翰·何顿·康威在 1970 年发明的细胞自动机。    
+
+给定一个包含 m × n 个格子的面板，每一个格子都可以看成是一个细胞。每个细胞都具有一个初始状态： 1 即为 活细胞 （live），或 0 即为 死细胞 （dead）。每个细胞与其八个相邻位置（水平，垂直，对角线）的细胞都遵循以下四条生存定律:    
+
+- 如果活细胞周围八个位置的活细胞数少于两个，则该位置活细胞死亡；
+- 如果活细胞周围八个位置有两个或三个活细胞，则该位置活细胞仍然存活；
+- 如果活细胞周围八个位置有超过三个活细胞，则该位置活细胞死亡；
+- 如果死细胞周围正好有三个活细胞，则该位置死细胞复活；
+
+下一个状态是通过将上述规则同时应用于当前状态下的每个细胞所形成的，其中细胞的出生和死亡是 同时 发生的。给你 m x n 网格面板 board 的当前状态，返回下一个状态。
+
+给定当前 board 的状态，更新 board 到下一个状态。
+
+注意 你不需要返回任何东西。
+
+
+示例1:   
+
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/leetcode_gameOfLife_1.jpg?raw=true)
+
+- 输入：board = [[0,1,0],[0,0,1],[1,1,1],[0,0,0]]
+- 输出：[[0,0,0],[1,0,1],[0,1,1],[0,1,0]]
+
+
+示例2:   
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/leetcode_gameOfLife_1.jpg?raw=true)
+
+- 输入：board = [[1,1],[1,0]]
+- 输出：[[1,1],[1,1]]
+
+
+提示：
+
+- m == board.length
+- n == board[i].length
+- 1 <= m, n <= 25
+- board[i][j] 为 0 或 1
+
+
+进阶：
+
+你可以使用原地算法解决本题吗？请注意，面板上所有格子需要同时被更新：你不能先更新某些格子，然后使用它们的更新后的值再更新其他格子。
+本题中，我们使用二维数组来表示面板。原则上，面板是无限的，但当活细胞侵占了面板边界时会造成问题。你将如何解决这些问题？
+
+
+### 思路
+
+简化规则:     
+1. 原来是活的，周围有2-3个活的，成为活的
+2. 原来是死的，周围有3个活的，成为活的
+3. 其他都是死了
+
+这道题主要就是模拟，遍历每一个格子，然后统计其周围八个格子的活细胞个数，来看这个格子的状态是否改变。
+但难点在于：如果这个格子的状态改变，不能直接改变。这样会影响后面格子的统计。即题目中说的：你不能先更新某些格子，然后使用它们的更新后的值再更新其他格子。
+
+因此我们需要使用特殊值去标记发生改变的格子，从而根据特殊值可以知道这个格子原状态是什么，要更新的状态是什么。
+
+
+- 可以使用 2表示活细胞变成死细胞，3表示死细胞变成活细胞。【这样的好处是最终是死细胞的都是偶数，活细胞的都是奇数，模2即结果；】
+
+也可以用下面的方式:       
+
+- 由于每个位置的细胞的状态是取决于当前四周其他状态的，而且每个细胞的状态是同时变化的，所以不能一个一个地更新，只能在一个新的数组里创建新的状态。
+
+- 当然上面所说的也不是绝对的，因为这道题目的输入是int[][]，矩阵是 int 类型的，有 32 位，而状态只有 0,1 两种，只需一位且只有最低位用上了，我们用其他位存储下一个状态即可，相当于用原矩阵当一个复制的矩阵。   
+
+- 所以可以，原有的最低位存储的是当前状态，那倒数第二低位存储下一个状态就行了。
+
+
+```java
+class Solution {
+    public void gameOfLife(int[][] board) {
+        int m = board.length;       // 行数
+        int n = board[0].length;    // 列数
+        int count = 0;              // 统计每个格子周围八个位置的活细胞数
+        for(int i = 0; i < m; i++){
+            for(int j = 0; j < n; j++){
+                count = 0;      // 每个格子计数重置为0
+                for(int x = -1; x <= 1; x++){ // -1 0 1 分别代表当前位置左边的格子、当前格子、当前位置右边的格子
+                    for(int y = -1; y <= 1; y++){ // -1 0 1 分别代表当前位置下边的格子、当前格子、当前位置上边的格子
+                        // 枚举周围八个位置，其中去掉本身（x = y = 0）和越界(靠近边缘)的情况
+                        if((x == 0 && y == 0) || i + x < 0 || i + x >= m || j + y < 0 || j + y >= n)continue;
+                        // 如果周围格子是活细胞（1）或者是活细胞变死细胞（2）的，都算一个活细胞
+                        if(board[i + x][j + y] == 1 || board[i + x][j + y] == 2) {
+                        	count++; 
+                        }
+                    }
+                }
+
+                if(board[i][j] == 1 && (count < 2 || count > 3)) {
+                	board[i][j] = 2;    // 格子本身是活细胞，周围满足变成死细胞的条件，标记为2
+            	}
+
+                if(board[i][j] == 0 && count == 3) {
+                	board[i][j] = 3;      // 格子本身是死细胞，周围满足复活条件，标记为3
+                }
+            }
+        }
+
+        for(int i = 0; i < m; i++){
+            for(int j = 0; j < n; j++){
+                // 死细胞为0，活细胞变成死细胞为2，都为偶数，模2为0，刚好是死细胞
+                // 活细胞为1，死细胞变成活细胞为3，都为奇数，模2为1，刚好是活细胞
+                board[i][j] %= 2;
+            }
+        }
+    }
+}
+```
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	
diff --git "a/Algorithm/39.\350\265\216\351\207\221\344\277\241.md" "b/Algorithm/39.\350\265\216\351\207\221\344\277\241.md"
new file mode 100644
index 00000000..63cff051
--- /dev/null
+++ "b/Algorithm/39.\350\265\216\351\207\221\344\277\241.md"
@@ -0,0 +1,97 @@
+39.赎金信
+===
+
+
+### 题目
+
+
+给你两个字符串：ransomNote 和 magazine ，判断 ransomNote 能不能由 magazine 里面的字符构成。     
+
+如果可以，返回 true ；否则返回 false 。     
+
+magazine 中的每个字符只能在 ransomNote 中使用一次。   
+
+ 
+
+示例 1:   
+
+- 输入：ransomNote = "a", magazine = "b"
+- 输出：false
+
+示例 2:     
+
+- 输入：ransomNote = "aa", magazine = "ab"
+- 输出：false
+
+示例 3:    
+
+- 输入：ransomNote = "aa", magazine = "aab"
+- 输出：true
+ 
+
+提示:    
+
+- 1 <= ransomNote.length, magazine.length <= 105
+- ransomNote 和 magazine 由小写英文字母组成
+
+
+### 思路
+
+用hash表还是一个大小为26的数组，记录26个单词每一个出现的次数
+
+```java
+class Solution {
+    public boolean canConstruct(String ransomNote, String magazine) {
+        //记录杂志字符串出现的次数
+        int[] arr = new int[26];
+        int temp;
+        for (int i = 0; i < magazine.length(); i++) {
+            temp = magazine.charAt(i) - 'a';
+            arr[temp]++;
+        }
+        for (int i = 0; i < ransomNote.length(); i++) {
+            temp = ransomNote.charAt(i) - 'a';
+            //对于金信中的每一个字符都在数组中查找
+            //找到相应位减一，否则找不到返回false
+            if (arr[temp] > 0) {
+                arr[temp]--;
+            } else {
+                return false;
+            }
+        }
+        return true;
+    }
+}
+```
+
+
+```python
+class Solution:
+    def canConstruct(self, ransomNote: str, magazine: str) -> bool:
+        if len(ransomNote) > len(magazine):
+            return False
+
+        arr = [0] * 26
+        for i in magazine:
+            arr[ord(i) -ord('a')] += 1
+
+        for i in ransomNote:
+            index = ord(i) - ord('a')
+            arr[index] -= 1
+            if arr[index] < 0:
+                return False
+
+        return True
+```
+
+
+复杂度:   
+
+- 时间复杂度: O(N)
+- 空间复杂度: O(1)
+
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	
diff --git "a/Algorithm/4.\345\210\240\351\231\244\346\234\211\345\272\217\346\225\260\347\273\204\344\270\255\347\232\204\351\207\215\345\244\215\351\241\271II.md" "b/Algorithm/4.\345\210\240\351\231\244\346\234\211\345\272\217\346\225\260\347\273\204\344\270\255\347\232\204\351\207\215\345\244\215\351\241\271II.md"
new file mode 100644
index 00000000..549b9a20
--- /dev/null
+++ "b/Algorithm/4.\345\210\240\351\231\244\346\234\211\345\272\217\346\225\260\347\273\204\344\270\255\347\232\204\351\207\215\345\244\215\351\241\271II.md"
@@ -0,0 +1,80 @@
+4.删除有序数组中的重复项II
+===
+
+
+### 题目
+
+给你一个有序数组 nums ，请你 原地 删除重复出现的元素，使得出现次数超过两次的元素只出现两次 ，返回删除后数组的新长度。
+
+不要使用额外的数组空间，你必须在 原地 修改输入数组 并在使用 O(1) 额外空间的条件下完成。
+
+
+
+示例 1：
+
+输入：nums = [1,1,1,2,2,3]
+输出：5, nums = [1,1,2,2,3]
+解释：函数应返回新长度 length = 5, 并且原数组的前五个元素被修改为 1, 1, 2, 2, 3。 不需要考虑数组中超出新长度后面的元素。
+示例 2：
+
+输入：nums = [0,0,1,1,1,1,2,3,3]
+输出：7, nums = [0,0,1,1,2,3,3]
+解释：函数应返回新长度 length = 7, 并且原数组的前七个元素被修改为 0, 0, 1, 1, 2, 3, 3。不需要考虑数组中超出新长度后面的元素。
+ 
+
+
+### 思路
+
+双指针
+
+- 因为给定数组是有序的，所以相同元素必然连续。     
+- 我们可以使用双指针解决本题，遍历数组检查每一个元素是否应该被保留，如果应该被保留，就将其移动到指定位置。具体地，我们定义两个指针 slow 和 fast 分别为慢指针和快指针，其中慢指针表示处理出的数组的长度，快指针表示已经检查过的数组的长度，即 nums[fast] 表示待检查的第一个元素，nums[slow−1] 为上一个应该被保留的元素所移动到的指定位置。
+
+- 因为本题要求相同元素最多出现两次而非一次，所以我们需要检查上上个应该被保留的元素 nums[slow−2] 是否和当前待检查元素 nums[fast] 相同。
+
+- 当且仅当 nums[slow−2]=nums[fast] 时，当前待检查元素 nums[fast] 不应该被保留（因为此时必然有 nums[slow−2]=nums[slow−1]=nums[fast]）。最后，slow 即为处理好的数组的长度。
+
+特别地，数组的前两个数必然可以被保留，因此对于长度不超过 2 的数组，我们无需进行任何处理，对于长度超过 2 的数组，我们直接将双指针的初始值设为 2 即可。
+
+
+```python
+
+class Solution:
+    def removeDuplicates(self, nums: List[int]) -> int:
+        if len(nums) < 2:
+            return len(nums)
+        k = 2
+        for i in range(2, len(nums)):
+            if nums[i] == nums[k - 2] :
+                continue
+            else:            
+                nums[k] = nums[i]
+                k += 1
+        return k
+```
+
+
+```kotlin
+class Solution {
+    fun removeDuplicates(nums: IntArray): Int {
+        if (nums.size < 2) {
+            return nums.size
+        }
+        var k = 2
+        for (i in 2..nums.size - 1) {
+            if (nums[i] != nums[k - 2]) {
+                nums[k] = nums[i]
+                k ++
+            }
+        }
+        return k
+    }
+}
+```
+
+
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	
diff --git "a/Algorithm/40.\345\220\214\346\236\204\345\255\227\347\254\246\344\270\262.md" "b/Algorithm/40.\345\220\214\346\236\204\345\255\227\347\254\246\344\270\262.md"
new file mode 100644
index 00000000..aa801292
--- /dev/null
+++ "b/Algorithm/40.\345\220\214\346\236\204\345\255\227\347\254\246\344\270\262.md"
@@ -0,0 +1,98 @@
+40.同构字符串
+===
+
+
+### 题目
+
+给定两个字符串 s 和 t ，判断它们是否是同构的。
+
+如果 s 中的字符可以按某种映射关系替换得到 t ，那么这两个字符串是同构的。
+
+每个出现的字符都应当映射到另一个字符，同时不改变字符的顺序。不同字符不能映射到同一个字符上，相同字符只能映射到同一个字符上，字符可以映射到自己本身。
+
+ 
+
+示例 1:   
+
+- 输入：s = "egg", t = "add"
+- 输出：true
+
+示例 2:   
+
+- 输入：s = "foo", t = "bar"
+- 输出：false
+
+示例 3:   
+
+- 输入：s = "paper", t = "title"
+- 输出：true
+ 
+
+提示:    
+
+- 1 <= s.length <= 5 * 104
+- t.length == s.length
+- s 和 t 由任意有效的 ASCII 字符组成
+
+### 思路
+
+
+
+
+- “每个出现的字符都应当映射到另一个字符”。代表字符集合 s , t 之间是「满射」。
+- “相同字符只能映射到同一个字符上，不同字符不能映射到同一个字符上”。代表字符集合 s , t 之间是「单射」。
+- 因此， s 和 t 之间是「双射」，满足一一对应。考虑遍历字符串，使用哈希表 s2t , t2s 分别记录 s→t , t→s 的映射，当发现任意「一对多」的关系时返回 false 即可。
+
+
+```java
+
+class Solution {
+    public boolean isIsomorphic(String s, String t) {
+        Map<Character, Character> s2t = new HashMap<>(), t2s = new HashMap<>();
+        for (int i = 0; i < s.length(); i++) {
+            char a = s.charAt(i), b = t.charAt(i);
+            // 对于已有映射 a -> s2t[a]，若和当前字符映射 a -> b 不匹配，
+            // 说明有一对多的映射关系，则返回 false ；
+            // 对于映射 b -> a 也同理
+            if (s2t.containsKey(a) && s2t.get(a) != b || 
+                t2s.containsKey(b) && t2s.get(b) != a) {
+                return false;
+            }
+            s2t.put(a, b);
+            t2s.put(b, a);
+        }
+        return true;
+    }
+}
+```
+
+
+```python
+class Solution:
+    def isIsomorphic(self, s: str, t: str) -> bool:
+        s2t = {}
+        t2s = {}
+
+        for i in range(len(s)):
+            a = s[i]
+            b = t[i]
+
+            if (a in s2t and s2t.get(a) != b) or (b in t2s and t2s.get(b) != a):
+                return False
+            s2t[a] = b
+            t2s[b] = a
+
+        return True
+```
+
+复杂度分析:    
+
+- 时间复杂度 O(N) : 其中 N 为字符串 s , t 的长度。遍历字符串 s , t 使用线性时间，hashmap 查询操作使用 O(1) 时间。
+- 空间复杂度 O(1) : 题目说明 s 和 t 由任意有效的 ASCII 字符组成。由于 ASCII 字符共 128 个，因此 hashmap s2t , t2s 使用 O(128)=O(1) 空间。
+
+
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	
diff --git "a/Algorithm/41.\345\215\225\350\257\215\350\247\204\345\276\213.md" "b/Algorithm/41.\345\215\225\350\257\215\350\247\204\345\276\213.md"
new file mode 100644
index 00000000..33cae539
--- /dev/null
+++ "b/Algorithm/41.\345\215\225\350\257\215\350\247\204\345\276\213.md"
@@ -0,0 +1,114 @@
+41.单词规律
+===
+
+
+### 题目
+
+给定一种规律pattern和一个字符串s，判断s是否遵循相同的规律。
+
+这里的遵循指完全匹配，例如，pattern里的每个字母和字符串s中的每个非空单词之间存在着双向连接的对应规律。     
+
+ 
+
+示例1:    
+
+- 输入: pattern = "abba", s = "dog cat cat dog"
+- 输出: true
+
+示例 2:   
+
+- 输入:pattern = "abba", s = "dog cat cat fish"
+- 输出: false
+
+示例 3:     
+
+- 输入: pattern = "aaaa", s = "dog cat cat dog"
+- 输出: false
+ 
+
+提示:      
+
+- 1 <= pattern.length <= 300
+- pattern 只包含小写英文字母
+- 1 <= s.length <= 3000
+- s 只包含小写英文字母和 ' '
+- s 不包含 任何前导或尾随对空格
+- s 中每个单词都被 单个空格 分隔
+
+
+### 思路
+
+和上一题的思路完全一样，由字符之间的一一映射升级成了字符与字符串之间的一一映射。
+首先本质是一样的，要实现一一映射，就要用到两个哈希表分别记录字符到字符串的映射和字符串到字符的映射。
+其次，我们要对s中的单词进行提取，比较单词数量和pattern中的数量是否一致，如果数量上不一致，二者一定不匹配；
+
+
+
+```java
+
+class Solution {
+    public boolean wordPattern(String pattern, String s) {
+        Map<Character, String> p2s = new HashMap<>();   // pattern中的字符到s中的字符子串的映射表
+        Map<String, Character> s2p = new HashMap<>();   // s中的字符字串到pattern中的字符的映射表
+        String[] words = s.split(" ");                  // 根据空格，提取s中的单词
+        int n = pattern.length();
+        int m = words.length;
+        if(n != m){
+            return false;   // 字符数和单词数不一致，一定不匹配
+        }
+        char ch;
+        String word;
+        for(int i = 0; i < n; i++){
+            ch = pattern.charAt(i);
+            word = words[i];
+            if((p2s.containsKey(ch) && !p2s.get(ch).equals(word)) || (s2p.containsKey(word) && s2p.get(word) != ch)){
+                // 字符与单词没有一一映射：即字符记录的映射不是当前单词或单词记录的映射不是当前字符
+                return false;
+            }
+            // 更新映射，已存在的映射更新后仍然是不变的；不存在的映射将被加入
+            p2s.put(ch, word);
+            s2p.put(word, ch);
+        }
+        return true;
+    }
+}
+```
+
+
+```python
+
+class Solution:
+    def wordPattern(self, pattern: str, s: str) -> bool:
+        words = s.split(' ')
+        length = len(words)
+        if length != len(pattern):
+            return False
+
+        p2s = {}
+        s2p = {}
+
+        for i in range(length):
+            word = words[i]
+            p = pattern[i]
+
+            if (word in s2p and s2p[word] != p) or (p in p2s and p2s[p] != word):
+                return False
+
+            p2s[p] = word
+            s2p[word] = p
+
+        return True
+```
+
+复杂度分析:     
+
+- 时间复杂度：O(n+m)，其中 n 为 pattern 的长度，m 为 str 的长度。插入和查询哈希表的均摊时间复杂度均为 O(n+m)。每一个字符至多只被遍历一次。
+
+- 空间复杂度：O(n+m)，其中 n 为 pattern 的长度，m 为 str 的长度。最坏情况下，我们需要存储 pattern 中的每一个字符和 str 中的每一个字符串。
+
+
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	
diff --git "a/Algorithm/42.\346\234\211\346\225\210\347\232\204\345\255\227\346\257\215\345\274\202\344\275\215\350\257\215.md" "b/Algorithm/42.\346\234\211\346\225\210\347\232\204\345\255\227\346\257\215\345\274\202\344\275\215\350\257\215.md"
new file mode 100644
index 00000000..b72a4c92
--- /dev/null
+++ "b/Algorithm/42.\346\234\211\346\225\210\347\232\204\345\255\227\346\257\215\345\274\202\344\275\215\350\257\215.md"
@@ -0,0 +1,194 @@
+42.有效的字母异位词
+===
+
+
+### 题目
+
+给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的 字母异位词。
+
+ 
+
+示例 1:     
+
+- 输入: s = "anagram", t = "nagaram"
+- 输出: true
+
+示例 2:   
+
+- 输入: s = "rat", t = "car"
+- 输出: false
+ 
+
+提示:   
+
+- 1 <= s.length, t.length <= 5 * 104
+- s 和 t 仅包含小写字母
+ 
+
+进阶: 如果输入字符串包含 unicode 字符怎么办？你能否调整你的解法来应对这种情况？
+
+
+### 思路
+
+设两字符串 s 
+1
+​	
+  , s 
+2
+​	
+  ，则两者互为重排的「充要条件」为：两字符串 s 
+1
+​	
+  , s 
+2
+​	
+  包含的字符是一致的，即 s 
+1
+​	
+  , s 
+2
+​	
+  所有对应字符数量都相同，仅排列顺序不同。
+
+根据以上分析，可借助「哈希表」分别统计 s 
+1
+​	
+  , s 
+2
+​	
+  中各字符数量 key: 字符, value: 数量 ，分为以下情况：
+
+若 s 
+1
+​	
+  , s 
+2
+​	
+  字符串长度不相等，则「不互为重排」；
+若 s 
+1
+​	
+  , s 
+2
+​	
+  某对应字符数量不同，则「不互为重排」；
+否则，若 s 
+1
+​	
+  , s 
+2
+​	
+  所有对应字符数量都相同，则「互为重排」；
+具体上看，我们可以统计 s 
+1
+​	
+  各字符时执行 +1 ，统计 s 
+2
+​	
+  各字符时 −1 。若两字符串互为重排，则最终哈希表中所有字符统计数值都应为 0 。
+
+作者：Krahets
+链接：https://leetcode.cn/problems/valid-anagram/solutions/2362065/242-you-xiao-de-zi-mu-yi-wei-ci-ha-xi-bi-cch7/
+来源：力扣（LeetCode）
+著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
+
+```java
+class Solution {
+    public boolean isAnagram(String s, String t) {
+        int len1 = s.length(), len2 = t.length();
+        if (len1 != len2)
+            return false;
+        HashMap<Character, Integer> dic = new HashMap<>();
+        for (int i = 0; i < len1; i++) {
+            dic.put(s.charAt(i) , dic.getOrDefault(s.charAt(i), 0) + 1);
+        }
+        for (int i = 0; i < len2; i++) {
+            dic.put(t.charAt(i) , dic.getOrDefault(t.charAt(i), 0) - 1);
+        }
+        for (int val : dic.values()) {
+            if (val != 0)
+                return false;
+        }
+        return true;
+    }
+}
+```
+
+
+```python
+class Solution:
+    def isAnagram(self, s: str, t: str) -> bool:
+        if len(s) != len(t):
+            return False
+        dic = defaultdict(int)
+        for c in s:
+            dic[c] += 1
+        for c in t:
+            dic[c] -= 1
+        for val in dic.values():
+            if val != 0:
+                return False
+        return True
+```
+
+
+复杂度分析:    
+
+- 时间复杂度 O(M+N) ： 其 M , N 分别为字符串 s1, s2长度。当 s1, s2无相同字符时，三轮循环的总迭代次数最多为 2M+2N ，使用 O(M+N) 线性时间。
+
+- 空间复杂度 O(1) ： 由于字符种类是有限的（常量），一般 ASCII 码共包含 128 个字符，因此可假设使用 O(1) 大小的额外空间。
+
+
+对于进阶问题，Unicode 是为了解决传统字符编码的局限性而产生的方案，它为每个语言中的字符规定了一个唯一的二进制编码。而 Unicode 中可能存在一个字符对应多个字节的问题，为了让计算机知道多少字节表示一个字符，面向传输的编码方式的 UTF−8 和 UTF−16 也随之诞生逐渐广泛使用，具体相关的知识读者可以继续查阅相关资料拓展视野，这里不再展开。
+
+回到本题，进阶问题的核心点在于「字符是离散未知的」，因此我们用哈希表维护对应字符的频次即可。同时读者需要注意 Unicode 一个字符可能对应多个字节的问题，不同语言对于字符串读取处理的方式是不同的。
+
+
+
+```java
+
+class Solution {
+    public boolean isAnagram(String s, String t) {
+        if (s.length() != t.length()) {
+            return false;
+        }
+        Map<Character, Integer> table = new HashMap<Character, Integer>();
+        for (int i = 0; i < s.length(); i++) {
+            char ch = s.charAt(i);
+            table.put(ch, table.getOrDefault(ch, 0) + 1);
+        }
+        for (int i = 0; i < t.length(); i++) {
+            char ch = t.charAt(i);
+            table.put(ch, table.getOrDefault(ch, 0) - 1);
+            if (table.get(ch) < 0) {
+                return false;
+            }
+        }
+        return true;
+    }
+}
+
+作者：力扣官方题解
+链接：https://leetcode.cn/problems/valid-anagram/solutions/493231/you-xiao-de-zi-mu-yi-wei-ci-by-leetcode-solution/
+来源：力扣（LeetCode）
+著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
+```
+
+复杂度分析
+
+时间复杂度：O(n)，其中 n 为 s 的长度。
+
+空间复杂度：O(S)，其中 S 为字符集大小，此处 S=26。
+
+
+
+class Solution:
+    def isAnagram(self, s: str, t: str) -> bool:
+        return Counter(s) == Counter(t)
+
+
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	
diff --git "a/Algorithm/43.\345\255\227\346\257\215\345\274\202\344\275\215\350\257\215\345\210\206\347\273\204.md" "b/Algorithm/43.\345\255\227\346\257\215\345\274\202\344\275\215\350\257\215\345\210\206\347\273\204.md"
new file mode 100644
index 00000000..69eee016
--- /dev/null
+++ "b/Algorithm/43.\345\255\227\346\257\215\345\274\202\344\275\215\350\257\215\345\210\206\347\273\204.md"
@@ -0,0 +1,118 @@
+43.字母异位词分组
+===
+
+
+### 题目
+
+给你一个字符串数组，请你将 字母异位词(字母异位词是通过重新排列不同单词或短语的字母而形成的单词或短语，并使用所有原字母一次) 组合在一起。可以按任意顺序返回结果列表。
+
+ 
+
+示例 1:
+
+输入: strs = ["eat", "tea", "tan", "ate", "nat", "bat"]
+
+输出: [["bat"],["nat","tan"],["ate","eat","tea"]]
+
+解释:    
+
+- 在 strs 中没有字符串可以通过重新排列来形成 "bat"。
+- 字符串 "nat" 和 "tan" 是字母异位词，因为它们可以重新排列以形成彼此。
+- 字符串 "ate" ，"eat" 和 "tea" 是字母异位词，因为它们可以重新排列以形成彼此。
+
+示例 2:    
+
+- 输入: strs = [""]
+
+- 输出: [[""]]
+
+示例 3:    
+
+- 输入: strs = ["a"]
+
+- 输出: [["a"]]
+
+ 
+
+提示:    
+
+- 1 <= strs.length <= 104
+- 0 <= strs[i].length <= 100
+- strs[i] 仅包含小写字母
+
+### 思路
+
+##### 方法一: 排序
+
+由于互为字母异位词的两个字符串包含的字母相同，因此对两个字符串分别进行排序之后得到的字符串一定是相同的，故可以将排序之后的字符串作为哈希表的键。
+
+```java
+class Solution {
+    public List<List<String>> groupAnagrams(String[] strs) {
+        Map<String, List<String>> map = new HashMap<String, List<String>>();
+        for (String str : strs) {
+            char[] array = str.toCharArray();
+            Arrays.sort(array);
+            String key = new String(array);
+            List<String> list = map.getOrDefault(key, new ArrayList<String>());
+            list.add(str);
+            map.put(key, list);
+        }
+        return new ArrayList<List<String>>(map.values());
+    }
+}
+```
+
+复杂度分析
+
+- 时间复杂度：O(nklogk)，其中 n 是 strs 中的字符串的数量，k 是 strs 中的字符串的的最大长度。需要遍历 n 个字符串，对于每个字符串，需要 O(klogk) 的时间进行排序以及 O(1) 的时间更新哈希表，因此总时间复杂度是 O(nklogk)。
+
+- 空间复杂度：O(nk)，其中 n 是 strs 中的字符串的数量，k 是 strs 中的字符串的的最大长度。需要用哈希表存储全部字符串。
+
+##### 方法二: 计数
+
+- 由于互为字母异位词的两个字符串包含的字母相同，因此两个字符串中的相同字母出现的次数一定是相同的
+- 所以可以将每个字母出现的次数使用字符串表示，作为哈希表的键
+
+```java
+
+class Solution {
+    public List<List<String>> groupAnagrams(String[] strs) {
+        Map<String, List<String>> map = new HashMap<String, List<String>>();
+        for (String str : strs) {
+            int[] counts = new int[26];
+            int length = str.length();
+            for (int i = 0; i < length; i++) {
+                counts[str.charAt(i) - 'a']++;
+            }
+            // 将每个出现次数大于 0 的字母和出现次数按顺序拼接成字符串，作为哈希表的键
+            StringBuffer sb = new StringBuffer();
+            for (int i = 0; i < 26; i++) {
+                if (counts[i] != 0) {
+                    sb.append((char) ('a' + i));
+                    sb.append(counts[i]);
+                }
+            }
+            String key = sb.toString();
+            List<String> list = map.getOrDefault(key, new ArrayList<String>());
+            list.add(str);
+            map.put(key, list);
+        }
+        return new ArrayList<List<String>>(map.values());
+    }
+}
+```
+
+
+复杂度分析:    
+
+- 时间复杂度：O(nk))，其中 n 是 strs 中的字符串的数量，k 是 strs 中的字符串的的最大长度.
+
+- 空间复杂度：O(nk))，其中 n 是 strs 中的字符串的数量，k 是 strs 中的字符串的最大长度.
+
+
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	
diff --git "a/Algorithm/44.\344\270\244\346\225\260\344\271\213\345\222\214.md" "b/Algorithm/44.\344\270\244\346\225\260\344\271\213\345\222\214.md"
new file mode 100644
index 00000000..9e1fba5d
--- /dev/null
+++ "b/Algorithm/44.\344\270\244\346\225\260\344\271\213\345\222\214.md"
@@ -0,0 +1,121 @@
+44.两数之和
+===
+
+
+### 题目
+
+给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target  的那 两个 整数，并返回它们的数组下标。
+
+你可以假设每种输入只会对应一个答案，并且你不能使用两次相同的元素。
+
+你可以按任意顺序返回答案。
+
+ 
+
+示例 1:    
+
+- 输入：nums = [2,7,11,15], target = 9
+- 输出：[0,1]
+- 解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。
+
+示例 2:    
+
+- 输入：nums = [3,2,4], target = 6
+- 输出：[1,2]
+
+示例 3:   
+
+- 输入：nums = [3,3], target = 6
+- 输出：[0,1]
+ 
+
+提示:   
+
+- 2 <= nums.length <= 104
+- -109 <= nums[i] <= 109
+- -109 <= target <= 109
+- 只会存在一个有效答案
+ 
+
+进阶：你可以想出一个时间复杂度小于 O(n2) 的算法吗？
+
+
+
+### 思路
+
+这道题本身如果通过暴力遍历的话也是很容易解决的，时间复杂度在 O(n²)
+
+##### 方法一：暴力枚举
+
+
+最容易想到的方法是枚举数组中的每一个数 x，寻找数组中是否存在 target - x。
+
+```java
+class Solution {
+    public int[] twoSum(int[] nums, int target) {
+        int n = nums.length;
+        for (int i = 0; i < n; ++i) {
+            for (int j = i + 1; j < n; ++j) {
+                if (nums[i] + nums[j] == target) {
+                    return new int[]{i, j};
+                }
+            }
+        }
+        return new int[0];
+    }
+}
+```
+
+复杂度分析:    
+
+- 时间复杂度：O(N²)，其中 N 是数组中的元素数量。最坏情况下数组中任意两个数都要被匹配一次。
+
+- 空间复杂度：O(1)。
+
+
+##### 方法二: 哈希表
+
+
+- 注意到方法一的时间复杂度较高的原因是寻找 target - x 的时间复杂度过高。       
+- 因此，我们需要一种更优秀的方法，能够快速寻找数组中是否存在目标元素。如果存在，我们需要找出它的索引。
+- 使用哈希表，可以将寻找 target - x 的时间复杂度降低到从 O(N) 降低到 O(1)。
+- 这样我们创建一个哈希表，对于每一个 x，我们首先查询哈希表中是否存在 target - x，然后将 x 插入到哈希表中，即可保证不会让 x 和自己匹配。
+
+
+```java
+class Solution {
+    public int[] twoSum(int[] nums, int target) {
+        Map<Integer, Integer> map = new HashMap<>();
+        for(int i = 0; i< nums.length; i++) {
+            if(map.containsKey(target - nums[i])) {
+                return new int[] {map.get(target-nums[i]),i};
+            }
+            map.put(nums[i], i);
+        }
+        throw new IllegalArgumentException("No two sum solution");
+    }
+}
+```
+
+```python
+class Solution:
+    def twoSum(self, nums: List[int], target: int) -> List[int]:
+        hashTable = dict()
+        for i, num in enumerate(nums):
+            if target - num in hashTable:
+                return [hashTable[target-num], i]
+            hashTable[nums[i]] = i
+        return []
+```
+
+复杂度分析:    
+
+- 时间复杂度：O(N)，其中 N 是数组中的元素数量。对于每一个元素 x，我们可以 O(1) 地寻找 target - x。
+
+- 空间复杂度：O(N)，其中 N 是数组中的元素数量。主要为哈希表的开销。
+
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	
diff --git "a/Algorithm/45.\345\277\253\344\271\220\346\225\260.md" "b/Algorithm/45.\345\277\253\344\271\220\346\225\260.md"
new file mode 100644
index 00000000..bd557384
--- /dev/null
+++ "b/Algorithm/45.\345\277\253\344\271\220\346\225\260.md"
@@ -0,0 +1,198 @@
+45.快乐数
+===
+
+
+### 题目
+
+编写一个算法来判断一个数 n 是不是快乐数。
+
+「快乐数」 定义为:     
+
+- 对于一个正整数，每一次将该数替换为它每个位置上的数字的平方和。
+- 然后重复这个过程直到这个数变为 1，也可能是 无限循环 但始终变不到 1。
+- 如果这个过程 结果为 1，那么这个数就是快乐数。
+- 如果 n 是 快乐数 就返回 true ；不是，则返回 false 。
+
+ 
+
+示例 1:    
+
+- 输入：n = 19
+- 输出：true
+
+- 解释:     
+    - 1² + 9² = 82
+    - 8² + 2² = 68
+    - 6² + 8² = 100
+    - 1² + 0² + 0² = 1
+
+示例 2:    
+
+- 输入：n = 2
+- 输出：false
+ 
+
+提示:    
+
+- 1 <= n <= 231 - 1
+
+
+### 思路
+
+- 快乐数的定义是基于一个计算过程，即对一个正整数，不断将其替换为它各个位上数字的平方和，如果最终这个过程能够收敛到1，则这个数被称为快乐数。    
+
+- 相反，如果在这个过程中形成了一个不包含1的循环，则该数不是快乐数。    
+
+- 对于非快乐数，它们的平方和序列会进入一个固定的循环，例如4 → 16 → 37 → 58 → 89 → 145 → 42 → 20 → 4。
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/leetcode_happy_1.png?raw=true)
+
+根据我们的探索，我们猜测会有以下三种可能:    
+
+- 最终会得到 1。
+- 最终会进入循环。
+- 值会越来越大，最后接近无穷大(不会发生，因为假设9999999999999，那他每个位置的数值平方相加后的值是1053，再往后循环只会越来越小)。
+
+
+第三个情况比较难以检测和处理。我们怎么知道它会继续变大，而不是最终得到 1 呢？我们可以仔细想一想，每一位数的最大数字的下一位数是多少。
+
+| 位数   | 最大值        | Next |
+|--------|----------------|------|
+| 1      | 9              | 81   |
+| 2      | 99             | 162  |
+| 3      | 999            | 243  |
+| 4      | 9999           | 324  |
+| 13     | 9999999999999  | 1053 |
+
+
+- 对于 3 位数的数字，它不可能大于 243。这意味着它要么被困在 243 以下的循环内，要么跌到 1。
+
+- 4 位或 4 位以上的数字在每一步都会丢失一位，直到降到 3 位为止。
+
+- 所以我们知道，最坏的情况下，算法可能会在 243 以下的所有数字上循环，然后回到它已经到过的一个循环或者回到 1。但它不会无限期地进行下去，所以我们排除第三种选择。
+
+
+
+##### 方法一：哈希表检测
+
+所以这道题的解法主要是两部分:   
+
+- 按照题目的要求做数位分离，求平方和。
+
+- 使用哈希集合完成。每次生成链中的下一个数字时，我们都会检查它是否已经在哈希集合中。
+
+    - 如果它不在哈希集合中，我们应该添加它。     
+    - 如果它在哈希集合中，这意味着我们处于一个循环中，因此应该返回 false。
+
+
+
+```java
+class Solution {
+    private int getNext(int n) {
+        int totalSum = 0;
+        while (n > 0) {
+            int d = n % 10;
+            n = n / 10;
+            totalSum += d * d;
+        }
+        return totalSum;
+    }
+
+    public boolean isHappy(int n) {
+        Set<Integer> seen = new HashSet<>();
+        while (n != 1 && !seen.contains(n)) {
+            seen.add(n);
+            n = getNext(n);
+        }
+        return n == 1;
+    }
+}
+```
+
+
+- 时间复杂度: O(Logn)
+- 空间复杂度: O(Logn)
+
+##### 方法二：快慢指针法
+
+通过反复调用 getNext(n) 得到的链是一个隐式的链表。隐式意味着我们没有实际的链表节点和指针，但数据仍然形成链表结构。起始数字是链表的头 “节点”，链中的所有其他数字都是节点。next 指针是通过调用 getNext(n) 函数获得。
+
+意识到我们实际有个链表，那么这个问题就可以转换为检测一个链表是否有环。因此我们在这里可以使用弗洛伊德循环查找算法。这个算法是两个奔跑选手，一个跑的快，一个跑得慢。在龟兔赛跑的寓言中，跑的慢的称为 “乌龟”，跑得快的称为 “兔子”。
+
+不管乌龟和兔子在循环中从哪里开始，它们最终都会相遇。这是因为兔子每走一步就向乌龟靠近一个节点（在它们的移动方向上）。
+
+```java
+class Solution {
+
+     public int getNext(int n) {
+        int totalSum = 0;
+        while (n > 0) {
+            int d = n % 10;
+            n = n / 10;
+            totalSum += d * d;
+        }
+        return totalSum;
+    }
+
+    public boolean isHappy(int n) {
+        int slowRunner = n;
+        int fastRunner = getNext(n);
+        while (fastRunner != 1 && slowRunner != fastRunner) {
+            slowRunner = getNext(slowRunner);
+            fastRunner = getNext(getNext(fastRunner));
+        }
+        return fastRunner == 1;
+    }
+}
+
+```
+
+复杂度分析:     
+
+- 时间复杂度：O(logn)。该分析建立在对前一种方法的分析的基础上，但是这次我们需要跟踪两个指针而不是一个指针来分析，以及在它们相遇前需要绕着这个循环走多少次。
+如果没有循环，那么快跑者将先到达 1，慢跑者将到达链表中的一半。我们知道最坏的情况下，成本是 O(2⋅logn)=O(logn)。       
+一旦两个指针都在循环中，在每个循环中，快跑者将离慢跑者更近一步。一旦快跑者落后慢跑者一步，他们就会在下一步相遇。假设循环中有 k 个数字。如果他们的起点是相隔 k−1 的位置（这是他们可以开始的最远的距离），那么快跑者需要 k−1 步才能到达慢跑者，这对于我们的目的来说也是不变的。因此，主操作仍然在计算起始 n 的下一个值，即 O(logn)。
+- 空间复杂度：O(1)，对于这种方法，我们不需要哈希集来检测循环。指针需要常数的额外空间。     
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	
diff --git "a/Algorithm/46.\345\255\230\345\234\250\351\207\215\345\244\215\345\205\203\347\264\240 II.md" "b/Algorithm/46.\345\255\230\345\234\250\351\207\215\345\244\215\345\205\203\347\264\240 II.md"
new file mode 100644
index 00000000..2051ee00
--- /dev/null
+++ "b/Algorithm/46.\345\255\230\345\234\250\351\207\215\345\244\215\345\205\203\347\264\240 II.md"	
@@ -0,0 +1,112 @@
+46.存在重复元素 II
+===
+
+
+### 题目
+
+给你一个整数数组 nums 和一个整数 k ，判断数组中是否存在两个 不同的索引 i 和 j ，满足 nums[i] == nums[j] 且 abs(i - j) <= k 。如果存在，返回 true ；否则，返回 false 。
+
+ 
+
+示例 1:    
+
+- 输入：nums = [1,2,3,1], k = 3
+- 输出：true
+
+示例 2:    
+
+- 输入：nums = [1,0,1,1], k = 1
+- 输出：true
+
+示例 3:      
+
+- 输入：nums = [1,2,3,1,2,3], k = 2
+- 输出：false
+ 
+
+ 
+
+提示:    
+
+- 1 <= nums.length <= 105
+- -109 <= nums[i] <= 109
+- 0 <= k <= 105
+
+
+### 思路
+
+##### 方法一: 哈希表
+
+```python
+class Solution:
+    def containsNearbyDuplicate(self, nums: List[int], k: int) -> bool:
+        map = defaultdict()
+        for i, num in enumerate(nums):
+            if num in map:
+                m = map[num]
+                if i - m > k:
+                    return True
+            map[num] = i
+        return False
+```
+
+复杂度分析:    
+
+- 时间复杂度：O(n)
+- 空间复杂度：O(n)
+
+
+##### 方法二: 定长滑动窗口
+
+
+整理题意：是否存在长度不超过的 k+1 窗口，窗口内有相同元素。
+
+
+我们可以从前往后遍历 nums，同时使用 Set 记录遍历当前滑窗内出现过的元素。
+
+假设当前遍历的元素为 nums[i]：
+
+- 下标小于等于 k（起始滑窗长度还不足 k+1）：直接往滑窗加数，即将当前元素加入 Set 中；
+- 下标大于 k：将上一滑窗的左端点元素 nums[i−k−1] 移除，判断当前滑窗的右端点元素 nums[i] 是否存在 Set 中，若存在，返回 True，否则将当前元素 nums[i] 加入 Set 中。
+- 重复上述过程，若整个 nums 处理完后仍未找到，返回 False。
+
+```python
+class Solution:
+    def containsNearbyDuplicate(self, nums: List[int], k: int) -> bool:
+        n = len(nums)
+        s = set()
+        for i in range(n):
+            if i > k:
+                s.remove(nums[i - k - 1])
+            if nums[i] in s:
+                return True
+            s.add(nums[i])
+        return False
+```
+
+```java
+class Solution {
+    public boolean containsNearbyDuplicate(int[] nums, int k) {
+        int n = nums.length;
+        Set<Integer> set = new HashSet<>();
+        for (int i = 0; i < n; i++) {
+            if (i > k) set.remove(nums[i - k - 1]);
+            if (set.contains(nums[i])) return true;
+            set.add(nums[i]);
+        }
+        return false;
+    }
+}
+```
+
+复杂度分析:    
+
+- 时间复杂度：O(n)
+- 空间复杂度：O(k)
+
+
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	
diff --git "a/Algorithm/47.\346\234\200\351\225\277\350\277\236\347\273\255\345\272\217\345\210\227.md" "b/Algorithm/47.\346\234\200\351\225\277\350\277\236\347\273\255\345\272\217\345\210\227.md"
new file mode 100644
index 00000000..0dd4b5f5
--- /dev/null
+++ "b/Algorithm/47.\346\234\200\351\225\277\350\277\236\347\273\255\345\272\217\345\210\227.md"
@@ -0,0 +1,133 @@
+47.最长连续序列
+===
+
+
+### 题目
+
+给定一个未排序的整数数组 nums ，找出数字连续的最长序列（不要求序列元素在原数组中连续）的长度。
+
+请你设计并实现时间复杂度为 O(n) 的算法解决此问题。
+
+ 
+
+示例 1:    
+
+- 输入：nums = [100,4,200,1,3,2]
+- 输出：4
+- 解释：最长数字连续序列是 [1, 2, 3, 4]。它的长度为 4。
+
+示例 2:    
+
+- 输入：nums = [0,3,7,2,5,8,4,6,0,1]
+- 输出：9
+
+示例 3:    
+
+- 输入：nums = [1,0,1,2]
+- 输出：3
+ 
+
+提示:    
+
+- 0 <= nums.length <= 105
+- -109 <= nums[i] <= 109
+
+
+### 思路
+
+首先，本题是不能排序的，因为排序的时间复杂度是 O(nlogn)，不符合题目 O(n) 的要求。
+
+
+题解说的比较复杂，不太容易懂，简单来说就是每个数都判断一次这个数是不是连续序列的开头那个数。
+
+怎么判断呢，就是用哈希表查找这个数前面一个数是否存在，即num-1在序列中是否存在。
+
+为了做到 O(n) 的时间复杂度，需要两个关键优化:    
+
+- 把 nums 中的数都放入一个哈希集合中，这样可以 O(1) 判断数字是否在 nums 中。
+- 存在那这个数肯定不是开头，直接跳过。
+- 因此只需要对每个开头的数进行循环，直到这个序列不再连续，因此复杂度是O(n)。
+
+以题解中的序列举例:     
+[100，4，200，1，3，4，2]
+去重后的哈希序列为:      
+[100，4，200，1，3，2]
+
+按照上面逻辑进行判断:     
+
+- 元素100是开头,因为没有99，且以100开头的序列长度为1    
+- 元素4不是开头，因为有3存在，过
+- 元素200是开头，因为没有199，且以200开头的序列长度为1
+- 元素1是开头，因为没有0，且以1开头的序列长度为4，因为依次累加，2，3，4都存在。
+- 元素3不是开头，因为2存在，过，
+- 元素2不是开头，因为1存在，过。
+
+
+```java
+class Solution {
+    public int longestConsecutive(int[] nums) {
+        Set<Integer> num_set = new HashSet<Integer>();
+        for (int num : nums) {
+            num_set.add(num);
+        }
+
+        int longestStreak = 0;
+
+        for (int num : num_set) {
+            if (!num_set.contains(num - 1)) {
+                int currentNum = num;
+                int currentStreak = 1;
+
+                while (num_set.contains(currentNum + 1)) {
+                    currentNum += 1;
+                    currentStreak += 1;
+                }
+
+                longestStreak = Math.max(longestStreak, currentStreak);
+            }
+        }
+
+        return longestStreak;
+    }
+}
+```
+
+```python
+class Solution:
+    def longestConsecutive(self, nums: List[int]) -> int:
+        longest = 0
+        numSet = set(nums)
+
+        for num in numSet:
+            if num -1 not in numSet:
+                # 这就是开头，可以开始计数
+                currentNum = num
+                currentStreak = 1
+
+                while currentNum + 1 in numSet:
+                    currentNum += 1
+                    currentStreak += 1
+
+
+                longest = max(longest, currentStreak)
+
+        return longest
+```
+
+复杂度分析:    
+
+- 时间复杂度：O(n)，其中 n 为数组的长度。具体分析已在上面正文中给出。
+
+- 空间复杂度：O(n)。哈希表存储数组中所有的数需要 O(n) 的空间。
+
+
+
+
+
+
+
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	
diff --git "a/Algorithm/48.\346\261\207\346\200\273\345\214\272\351\227\264.md" "b/Algorithm/48.\346\261\207\346\200\273\345\214\272\351\227\264.md"
new file mode 100644
index 00000000..60983af9
--- /dev/null
+++ "b/Algorithm/48.\346\261\207\346\200\273\345\214\272\351\227\264.md"
@@ -0,0 +1,134 @@
+48.汇总区间
+===
+
+
+### 题目
+
+
+给定一个 无重复元素 的 有序 整数数组 nums 。     
+
+区间 [a,b] 是从 a 到 b（包含）的所有整数的集合。      
+
+返回 恰好覆盖数组中所有数字 的 最小有序 区间范围列表 。也就是说，nums 的每个元素都恰好被某个区间范围所覆盖，并且不存在属于某个区间但不属于 nums 的数字 x 。    
+
+列表中的每个区间范围 [a,b] 应该按如下格式输出:     
+
+- "a->b" ，如果 a != b
+- "a" ，如果 a == b
+ 
+
+示例 1:   
+
+- 输入：nums = [0,1,2,4,5,7]
+- 输出：["0->2","4->5","7"]
+
+解释：区间范围是:   
+- [0,2] --> "0->2"
+- [4,5] --> "4->5"
+- [7,7] --> "7"
+
+示例 2:    
+
+- 输入：nums = [0,2,3,4,6,8,9]
+- 输出：["0","2->4","6","8->9"]
+
+解释：区间范围是:     
+
+- [0,0] --> "0"
+- [2,4] --> "2->4"
+- [6,6] --> "6"
+- [8,9] --> "8->9"
+ 
+
+提示:    
+
+- 0 <= nums.length <= 20
+- -231 <= nums[i] <= 231 - 1
+- nums 中的所有值都 互不相同
+- nums 按升序排列
+
+
+### 思路
+
+
+- 我们从数组的位置 0 出发，向右遍历。     
+- 每次遇到相邻元素之间的差值大于 1 时，我们就找到了一个区间。遍历完数组之后，就能得到一系列的区间的列表。     
+- 在遍历过程中，维护下标low和high分别记录区间的起点和终点，对于任何区间都有`low≤high`。当得到一个区间时，根据`low`和`high`的值生成区间的字符串表示。     
+- 当`low<high`时，区间的字符串表示为`"low→high"`      
+- 当`low=high`时，区间的字符串表示为`"low"`     
+
+```java
+class Solution {
+    public List<String> summaryRanges(int[] nums) {
+        List<String> ret = new ArrayList<String>();
+        int i = 0;
+        int n = nums.length;
+        while (i < n) {
+            int low = i;
+            i++;
+            while (i < n && nums[i] == nums[i - 1] + 1) {
+                i++;
+            }
+            int high = i - 1;
+            StringBuffer temp = new StringBuffer(Integer.toString(nums[low]));
+            if (low < high) {
+                temp.append("->");
+                temp.append(Integer.toString(nums[high]));
+            }
+            ret.add(temp.toString());
+        }
+        return ret;
+    }
+}
+```
+
+
+```python
+class Solution:
+    def summaryRanges(self, nums: List[int]) -> List[str]:
+        def f(i: int, j: int) -> str:
+            return str(nums[i]) if i == j else f'{nums[i]}->{nums[j]}'
+
+        i = 0
+        n = len(nums)
+        ans = []
+        while i < n:
+            j = i
+            while j + 1 < n and nums[j + 1] == nums[j] + 1:
+                j += 1
+            ans.append(f(i, j))
+            i = j + 1
+        return ans
+```
+
+复杂度分析:     
+
+- 时间复杂度：O(n)，其中 n 为数组的长度。
+
+- 空间复杂度：O(1)。除了用于输出的空间外，额外使用的空间为常数。
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	
diff --git "a/Algorithm/49.\345\220\210\345\271\266\345\214\272\351\227\264.md" "b/Algorithm/49.\345\220\210\345\271\266\345\214\272\351\227\264.md"
new file mode 100644
index 00000000..8040592e
--- /dev/null
+++ "b/Algorithm/49.\345\220\210\345\271\266\345\214\272\351\227\264.md"
@@ -0,0 +1,82 @@
+49.合并区间
+===
+
+
+### 题目
+
+以数组 intervals 表示若干个区间的集合，其中单个区间为 intervals[i] = [starti, endi] 。请你合并所有重叠的区间，并返回 一个不重叠的区间数组，该数组需恰好覆盖输入中的所有区间 。
+
+ 
+
+示例 1:    
+
+- 输入：intervals = [[2,6],[1,3],[8,10],[15,18]]
+- 输出：[[1,6],[8,10],[15,18]]
+- 解释：区间 [1,3] 和 [2,6] 重叠, 将它们合并为 [1,6].
+
+示例 2:     
+
+- 输入：intervals = [[1,4],[4,5]]
+- 输出：[[1,5]]
+- 解释：区间 [1,4] 和 [4,5] 可被视为重叠区间。
+ 
+
+提示:     
+
+- 1 <= intervals.length <= 104
+- intervals[i].length == 2
+- 0 <= starti <= endi <= 104
+
+
+### 思路
+
+如果我们按照区间的左端点排序，那么在排完序的列表中，可以合并的区间一定是连续的。如下图所示，标记为蓝色、黄色和绿色的区间分别可以合并成一个大区间，它们在排完序的列表中是连续的:    
+
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/leetcode_merge_qujian_1.png?raw=true)
+
+- 我们用数组 merged 存储最终的答案。
+
+- 首先，我们将列表中的区间按照左端点升序排序。然后我们将第一个区间加入 merged 数组中，并按顺序依次考虑之后的每个区间：
+
+- 如果当前区间的左端点在数组 merged 中最后一个区间的右端点之后，那么它们不会重合，我们可以直接将这个区间加入数组 merged 的末尾；
+
+- 否则，它们重合，我们需要用当前区间的右端点更新数组 merged 中最后一个区间的右端点，将其置为二者的较大值。
+
+```java
+class Solution {
+    public int[][] merge(int[][] intervals) {
+        if (intervals.length == 0) {
+            return new int[0][2];
+        }
+        Arrays.sort(intervals, new Comparator<int[]>() {
+            public int compare(int[] interval1, int[] interval2) {
+                return interval1[0] - interval2[0];
+            }
+        });
+        List<int[]> merged = new ArrayList<int[]>();
+        for (int i = 0; i < intervals.length; ++i) {
+            int L = intervals[i][0], R = intervals[i][1];
+            if (merged.size() == 0 || merged.get(merged.size() - 1)[1] < L) {
+                merged.add(new int[]{L, R});
+            } else {
+                merged.get(merged.size() - 1)[1] = Math.max(merged.get(merged.size() - 1)[1], R);
+            }
+        }
+        return merged.toArray(new int[merged.size()][]);
+    }
+}
+```
+
+复杂度分析:     
+
+- 时间复杂度：O(nlogn)，其中 n 为区间的数量。除去排序的开销，我们只需要一次线性扫描，所以主要的时间开销是排序的 O(nlogn)。
+
+- 空间复杂度：O(logn)，其中 n 为区间的数量。这里计算的是存储答案之外，使用的额外空间。O(logn) 即为排序所需要的空间复杂度。
+
+
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	
diff --git "a/Algorithm/5.\345\244\232\346\225\260\345\205\203\347\264\240.md" "b/Algorithm/5.\345\244\232\346\225\260\345\205\203\347\264\240.md"
new file mode 100644
index 00000000..f99c600a
--- /dev/null
+++ "b/Algorithm/5.\345\244\232\346\225\260\345\205\203\347\264\240.md"
@@ -0,0 +1,87 @@
+5.多数元素
+===
+
+
+### 题目
+
+给定一个大小为 n 的数组 nums ，返回其中的多数元素。多数元素是指在数组中出现次数 大于 ⌊ n/2 ⌋ 的元素。
+
+你可以假设数组是非空的，并且给定的数组总是存在多数元素。
+
+
+数组中出现次数超过一半的数字被称为众数。
+
+示例 1:    
+
+- 输入：nums = [3,2,3]
+- 输出：3
+
+示例 2:    
+
+- 输入：nums = [2,2,1,1,1,2,2]
+- 输出：2
+
+
+
+### 思路
+
+##### 哈希表
+
+遍历数组nums，用HashMap统计各数字的数量，即可找出众数。
+此方法时间和空间复杂度均为O(N)。
+
+
+##### 排序法
+
+将数组nums排序，数组中心点的元素，一定是众数
+
+##### 摩尔投票法
+
+核心理念是票数正负抵消。此方法的时间和空间复杂度分别为O(N)和O(1)。     
+为本题最佳解法。 
+
+若记 众数 的票数为 +1 ，非众数 的票数为 −1 ，则一定有所有数字的 票数和 >0 。
+
+```python
+
+class Solution:
+    def majorityElement(self, nums: List[int]) -> int:
+        votes = 0
+        for num in nums:
+            if votes == 0:
+                x = num
+            if num == x:
+                votes += 1
+            else:
+                votes -= 1
+        return x
+```
+
+
+```kotlin
+class Solution {
+    fun majorityElement(nums: IntArray): Int {
+        var vote = 0
+        var k = 0
+        for (num in nums) {
+            if (vote == 0) {
+                k = num
+            }
+            if (num == k) {
+                vote ++
+            } else {
+                vote --
+            }
+        }
+        return k
+    }
+}
+```
+
+
+
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	
diff --git "a/Algorithm/50.\346\217\222\345\205\245\345\214\272\351\227\264.md" "b/Algorithm/50.\346\217\222\345\205\245\345\214\272\351\227\264.md"
new file mode 100644
index 00000000..6fbe536e
--- /dev/null
+++ "b/Algorithm/50.\346\217\222\345\205\245\345\214\272\351\227\264.md"
@@ -0,0 +1,102 @@
+50.插入区间
+===
+
+
+### 题目
+
+给你一个 无重叠的 ，按照区间起始端点排序的区间列表 intervals，其中 intervals[i] = [starti, endi] 表示第 i 个区间的开始和结束，并且 intervals 按照 starti 升序排列。同样给定一个区间 newInterval = [start, end] 表示另一个区间的开始和结束。   
+
+在 intervals 中插入区间 newInterval，使得 intervals 依然按照 starti 升序排列，且区间之间不重叠（如果有必要的话，可以合并区间）。
+
+返回插入之后的 intervals。       
+
+注意 你不需要原地修改 intervals。你可以创建一个新数组然后返回它。     
+
+ 
+
+示例 1:    
+
+- 输入：intervals = [[1,3],[6,9]], newInterval = [2,5]
+- 输出：[[1,5],[6,9]]
+
+示例 2:    
+
+- 输入：intervals = [[1,2],[3,5],[6,7],[8,10],[12,16]], newInterval = [4,8]
+- 输出：[[1,2],[3,10],[12,16]]
+- 解释：这是因为新的区间 [4,8] 与 [3,5],[6,7],[8,10] 重叠。
+ 
+
+提示:     
+
+- 0 <= intervals.length <= 104
+- intervals[i].length == 2
+- 0 <= starti <= endi <= 105
+- intervals 根据 starti 按 升序 排列
+- newInterval.length == 2
+- 0 <= start <= end <= 105
+
+### 思路
+
+- 题目说了是无重叠的按照区间起始端点排序的，所以不用排序了。  
+- 用指针去扫 intervals，最多可能有三个阶段:   
+
+    - 不重叠的绿区间，在蓝区间的左边
+    - 有重叠的绿区间
+    - 不重叠的绿区间，在蓝区间的右边
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/leetcode_insert_qujian_1.png?raw=true)
+
+- 逐个分析
+
+    - 不重叠，需满足：绿区间的右端，位于蓝区间的左端的左边，如 [1,2]。
+
+        - 则当前绿区间，推入 res 数组，指针 +1，考察下一个绿区间。
+        - 循环结束时，当前绿区间的屁股，就没落在蓝区间之前，有重叠了，如 [3,5]。
+    - 现在看重叠的。我们反过来想，没重叠，就要满足：绿区间的左端，落在蓝区间的屁股的后面，反之就有重叠：绿区间的左端 <= 蓝区间的右端，极端的例子就是 [8,10]。
+
+        - 和蓝有重叠的区间，会合并成一个区间：左端取蓝绿左端的较小者，右端取蓝绿右端的较大者，不断更新给蓝区间。
+        - 循环结束时，将蓝区间（它是合并后的新区间）推入 res 数组。
+    - 剩下的，都在蓝区间右边，不重叠。不用额外判断，依次推入 res 数组。
+
+
+
+
+```java
+class Solution {
+    public int[][] insert(int[][] intervals, int[] newInterval) {
+        ArrayList<int[]> res = new ArrayList<>();
+        int len = intervals.length;
+        int i = 0;
+        // 判断左边不重合
+        while (i < len && intervals[i][1] < newInterval[0]) {
+            res.add(intervals[i]);
+            i++;
+        }
+        // 判断重合
+        while (i < len && intervals[i][0] <= newInterval[1]) {
+            newInterval[0] = Math.min(intervals[i][0], newInterval[0]);
+            newInterval[1] = Math.max(intervals[i][1], newInterval[1]);
+            i++;
+        }
+        res.add(newInterval);
+        // 判断右边不重合
+        while (i < len && intervals[i][0] > newInterval[1]) {
+            res.add(intervals[i]);
+            i++;
+        }
+        return res.toArray(new int[0][]);
+    }
+}
+```
+
+复杂度分析:     
+
+- 时间复杂度：O(n)，其中 n 是数组 intervals 的长度，即给定的区间个数。
+
+- 空间复杂度：O(n)。
+
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	
diff --git "a/Algorithm/51.\347\224\250\346\234\200\345\260\221\346\225\260\351\207\217\347\232\204\347\256\255\345\274\225\347\210\206\346\260\224\347\220\203.md" "b/Algorithm/51.\347\224\250\346\234\200\345\260\221\346\225\260\351\207\217\347\232\204\347\256\255\345\274\225\347\210\206\346\260\224\347\220\203.md"
new file mode 100644
index 00000000..a6fcbec6
--- /dev/null
+++ "b/Algorithm/51.\347\224\250\346\234\200\345\260\221\346\225\260\351\207\217\347\232\204\347\256\255\345\274\225\347\210\206\346\260\224\347\220\203.md"
@@ -0,0 +1,110 @@
+51.用最少数量的箭引爆气球
+===
+
+
+### 题目
+
+有一些球形气球贴在一堵用 XY 平面表示的墙面上。墙面上的气球记录在整数数组 points ，其中points[i] = [xstart, xend] 表示水平直径在 xstart 和 xend之间的气球。你不知道气球的确切 y 坐标。      
+
+一支弓箭可以沿着 x 轴从不同点 完全垂直 地射出。在坐标 x 处射出一支箭，若有一个气球的直径的开始和结束坐标为 xstart，xend， 且满足  xstart ≤ x ≤ xend，则该气球会被 引爆 。可以射出的弓箭的数量 没有限制 。 弓箭一旦被射出之后，可以无限地前进。      
+
+给你一个数组 points ，返回引爆所有气球所必须射出的 最小 弓箭数 。     
+
+ 
+示例 1:     
+
+- 输入：points = [[10,16],[2,8],[1,6],[7,12]]
+- 输出：2
+- 解释：气球可以用2支箭来爆破:      
+    - 在x = 6处射出箭，击破气球[2,8]和[1,6]。
+    - 在x = 11处发射箭，击破气球[10,16]和[7,12]。
+
+示例 2:     
+
+- 输入：points = [[1,2],[3,4],[5,6],[7,8]]
+- 输出：4
+- 解释：每个气球需要射出一支箭，总共需要4支箭。
+
+示例 3:     
+
+- 输入：points = [[1,2],[2,3],[3,4],[4,5]]
+- 输出：2
+- 解释：气球可以用2支箭来爆破:      
+    - 在x = 2处发射箭，击破气球[1,2]和[2,3]。
+    - 在x = 4处射出箭，击破气球[3,4]和[4,5]。
+ 
+
+提示:     
+
+- 1 <= points.length <= 105
+- points[i].length == 2
+- -231 <= xstart < xend <= 231 - 1
+
+
+### 思路
+
+##### 方法一：区间合并
+
+```java
+//思路：区间重叠则合并，合并为交集
+//先排序
+class Solution {
+    public int findMinArrowShots(int[][] points) {
+        //防止相减式的比较造成溢出
+        Arrays.sort(points,(o1,o2)->Integer.compare(o1[0],o2[0]));
+        int n = points.length; // 合并一次，n-1
+        for(int i=1;i<points.length;i++){
+            if(points[i][0] <= points[i-1][1]){
+                //区间重叠，合并为交集
+                n--;
+                points[i][0] = Math.max(points[i][0],points[i-1][0]);
+                points[i][1] = Math.min(points[i][1],points[i-1][1]);
+            }
+        }
+        return n;
+    }
+}
+```
+
+##### 方法二：
+
+- 每个气球都是有宽度的，分别是左边界和右边界，这里只需要把所有的气球按照右边界的大小进行排序。
+- 然后把第一支箭尽可能的往第一个气球的右边靠，这样第一支箭引爆气球的数量就是最多的。
+- 同理，第二支箭要尽可能的往第二个气球（这里不是排序后的第二个气球，这里的第二个气球是和第一个气球坐标没有交集的那个气球）的右边靠……。
+
+下面来画个图看下，假如下面是已经按照右边界排序好的气球:      
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/leetcode_qiqiu_1.png?raw=true)
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/leetcode_qiqiu_2.png?raw=true)
+
+
+```java
+public int findMinArrowShots(int[][] points) {
+    //边界条件判断
+    if (points == null || points.length == 0) {
+        return 0;
+    }
+    //按照每个气球的右边界排序
+    Arrays.sort(points, (a, b) -> a[1] > b[1] ? 1 : -1);
+    //获取排序后第一个气球右边界的位置，我们可以认为是箭射入的位置
+    int last = points[0][1];
+    //统计箭的数量
+    int count = 1;
+    for (int i = 1; i < points.length; i++) {
+        //如果箭射入的位置小于下标为i这个气球的左边位置，说明这支箭不能
+        //击爆下标为i的这个气球，需要再拿出一支箭，并且要更新这支箭射入的
+        //位置
+        if (last < points[i][0]) {
+            last = points[i][1];
+            count++;
+        }
+    }
+    return count;
+}
+```
+
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	
diff --git "a/Algorithm/52.\346\234\211\346\225\210\347\232\204\346\213\254\345\217\267.md" "b/Algorithm/52.\346\234\211\346\225\210\347\232\204\346\213\254\345\217\267.md"
new file mode 100644
index 00000000..a9518cdc
--- /dev/null
+++ "b/Algorithm/52.\346\234\211\346\225\210\347\232\204\346\213\254\345\217\267.md"
@@ -0,0 +1,140 @@
+52.有效的括号
+===
+
+
+### 题目
+
+给定一个只包括 '('，')'，'{'，'}'，'['，']' 的字符串s，判断字符串是否有效。
+
+有效字符串需满足:      
+
+- 左括号必须用相同类型的右括号闭合。
+- 左括号必须以正确的顺序闭合。
+- 每个右括号都有一个对应的相同类型的左括号。
+ 
+
+示例 1:   
+
+- 输入：s = "()"
+
+- 输出：true
+
+示例 2:   
+
+- 输入：s = "()[]{}"
+
+- 输出：true
+
+示例 3:    
+
+- 输入：s = "(]"
+
+- 输出：false
+
+示例 4:    
+
+- 输入：s = "([])"
+
+- 输出：true
+
+ 
+
+提示:    
+
+- 1 <= s.length <= 104
+- s 仅由括号`()[]{}`组成
+
+
+### 思路
+
+要求是“以正确的顺序闭合”，所以`([)]`这种是错误的。     
+
+要判断一个仅包含括号字符`()[]{}`的字符串是否有效（即括号是否按正确顺序闭合），可通过 ​栈`Stack`这一数据结构高效解决。
+
+
+括号的闭合需满足 ​​“后进先出”​​ 的嵌套关系: 最后出现的左括号需优先匹配右括号，栈的`LIFO后进先出`特性完美契合此需求。   
+
+
+
+​- 遍历字符​: 逐个处理字符串中的字符。
+​- 左括号入栈​: 遇到`(, {, [`时压入栈。
+​- 右括号匹配​: 遇到`), }, ]`时:       
+    - 若栈为空 `→` 无效（右括号多余）。
+    - 若栈顶左括号与当前右括号不匹配 `→` 无效。
+    - 匹配则弹出栈顶元素。
+
+- 最终校验​: 遍历结束后栈必须为空（左括号全被匹配）。    
+
+使用`ArrayDeque`替代传统`Stack`类，因前者在`push/pop`操作上效率更高（无同步开销）。    
+
+
+​```java
+import java.util.ArrayDeque;
+import java.util.Deque;
+public class Solution {
+    public boolean isValid(String s) {
+        // 边界处理：空字符串有效，null 或奇数长度直接无效
+        if (s == null) {
+            return false;
+        }
+        if (s.isEmpty()) {
+            return true;
+        }
+        if (s.length() % 2 != 0) {
+            // 奇数长度不可能完全匹配
+            return false;
+        }
+
+        // 使用双端队列模拟栈（高效）
+        Deque<Character> stack = new ArrayDeque<>(); 
+        
+        for (char c : s.toCharArray()) {
+            // 左括号：入栈
+            if (c == '(' || c == '{' || c == '[') {
+                stack.push(c);
+            } 
+            // 右括号：检查匹配
+            else {
+                if (stack.isEmpty()) return false; // 栈空说明右括号多余
+                char top = stack.pop(); // 弹出栈顶左括号
+                // 检查括号类型是否匹配
+                if ((c == ')' && top != '(') || 
+                    (c == '}' && top != '{') || 
+                    (c == ']' && top != '[')) {
+                    return false;
+                }
+            }
+        }
+        return stack.isEmpty(); // 栈空说明所有左括号均被匹配
+    }
+}
+```
+
+
+
+
+```python
+# 映射表优化：用字典 bracket_map 存储括号对应关系，避免冗长的 if-else 分支
+def isValid(s: str) -> bool:
+    stack = []
+    bracket_map = {')': '(', ']': '[', '}': '{'}  # 右括号到左括号的映射
+    for char in s:
+        if char in bracket_map.values():  # 左括号入栈
+            stack.append(char)
+        elif char in bracket_map:  # 右括号匹配
+            if not stack or stack.pop() != bracket_map[char]:
+                return False
+    return not stack
+```
+
+复杂度分析:   
+
+- 时间复杂度: O(N)
+- 空间复杂度: O(N)
+
+
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	
diff --git "a/Algorithm/53.\347\256\200\345\214\226\350\267\257\345\276\204.md" "b/Algorithm/53.\347\256\200\345\214\226\350\267\257\345\276\204.md"
new file mode 100644
index 00000000..a9ace618
--- /dev/null
+++ "b/Algorithm/53.\347\256\200\345\214\226\350\267\257\345\276\204.md"
@@ -0,0 +1,127 @@
+53.简化路径
+===
+
+
+### 题目
+
+给你一个字符串path，表示指向某一文件或目录的 Unix 风格 绝对路径（以 '/' 开头），请你将其转化为 更加简洁的规范路径。    
+
+在Unix风格的文件系统中规则如下:    
+
+- 一个点 '.' 表示当前目录本身。
+- 此外，两个点 '..' 表示将目录切换到上一级（指向父目录）。
+- 任意多个连续的斜杠（即，'//' 或 '///'）都被视为单个斜杠 '/'。
+- 任何其他格式的点（例如，'...' 或 '....'）均被视为有效的文件/目录名称。
+
+返回的 简化路径 必须遵循下述格式:     
+
+- 始终以斜杠 '/' 开头。
+- 两个目录名之间必须只有一个斜杠 '/' 。
+- 最后一个目录名（如果存在）不能 以 '/' 结尾。
+- 此外，路径仅包含从根目录到目标文件或目录的路径上的目录（即，不含 '.' 或 '..'）。
+
+返回简化后得到的 规范路径 。
+
+ 
+
+示例 1:    
+
+- 输入：path = "/home/"
+
+- 输出："/home"
+
+解释:   
+
+- 应删除尾随斜杠。
+
+示例 2:    
+
+- 输入：path = "/home//foo/"
+
+- 输出："/home/foo"
+
+解释:    
+
+- 多个连续的斜杠被单个斜杠替换。
+
+示例 3:    
+
+- 输入：path = "/home/user/Documents/../Pictures"
+
+- 输出："/home/user/Pictures"
+
+解释:   
+
+- 两个点 ".." 表示上一级目录（父目录）。
+
+示例 4:   
+
+- 输入：path = "/../"
+
+- 输出："/"
+
+解释:    
+
+- 不可能从根目录上升一级目录。
+
+示例 5:    
+
+- 输入：path = "/.../a/../b/c/../d/./"
+
+- 输出："/.../b/d"
+
+解释:    
+
+- "..." 在这个问题中是一个合法的目录名。
+
+ 
+
+提示:    
+
+- 1 <= path.length <= 3000
+- path 由英文字母，数字，'.'，'/' 或 '_' 组成。
+- path 是一个有效的 Unix 风格绝对路径。
+
+### 思路
+
+
+根据题意，使用栈进行模拟即可。
+
+具体的，从前往后处理 path，每次以 item 为单位进行处理（有效的文件名），根据 item 为何值进行分情况讨论:     
+
+- item 为有效值 : 存入栈中
+- item 为 .. : 弹出栈顶元素（若存在）
+- item 为 . : 不作处理
+
+```java
+public String simplifyPath(String path) {
+    Deque<String> deque = new ArrayDeque<>();
+    int n = path.length();
+    for (int i = 1; i < n; i++) {
+        if (path.charAt(i) == '/') continue;   // 找到下一个不是"/"的位置
+        int j = i + 1;   // j指向下一个位置，双指针！
+        while (j < n && path.charAt(j) != '/') j++; // 直到j指向的位置是"/"
+        String temp = path.substring(i, j);   // 左闭右开，[i.j)
+        if (temp.equals("..")) {     //..的时候，栈内有元素才删
+            if (!deque.isEmpty()) {
+                deque.pollLast();
+            }
+        } else if (!(temp.equals("."))) { // .的时候就continue，这里省略了，不是.的时候就进栈
+            deque.addLast(temp);
+        }
+        i = j; //j是指向"/"的，令i=j开始下一轮循环
+    }
+    StringBuilder ans = new StringBuilder();
+    while (!deque.isEmpty()) {  // 还原栈内的路径
+        ans.append("/");
+        ans.append(deque.pollFirst());
+    }
+    return ans.length() == 0 ? "/" : ans.toString();  // 栈为空就直接返回"/",否则返回ans.toString()
+}
+```
+
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	
diff --git "a/Algorithm/54.\346\234\200\345\260\217\346\240\210.md" "b/Algorithm/54.\346\234\200\345\260\217\346\240\210.md"
new file mode 100644
index 00000000..11a8c8c2
--- /dev/null
+++ "b/Algorithm/54.\346\234\200\345\260\217\346\240\210.md"
@@ -0,0 +1,103 @@
+54.最小栈
+===
+
+
+### 题目
+
+设计一个支持 push ，pop ，top 操作，并能在常数时间内检索到最小元素的栈。
+
+实现 MinStack 类:     
+
+- MinStack() 初始化堆栈对象。
+- void push(int val) 将元素val推入堆栈。
+- void pop() 删除堆栈顶部的元素。
+- int top() 获取堆栈顶部的元素。
+- int getMin() 获取堆栈中的最小元素。
+ 
+
+示例 1:    
+
+- 输入:     
+```
+["MinStack","push","push","push","getMin","pop","top","getMin"]
+[[],[-2],[0],[-3],[],[],[],[]]
+```
+输出:    
+[null,null,null,null,-3,null,0,-2]
+
+解释:   
+```
+MinStack minStack = new MinStack();
+minStack.push(-2);
+minStack.push(0);
+minStack.push(-3);
+minStack.getMin();   --> 返回 -3.
+minStack.pop();
+minStack.top();      --> 返回 0.
+minStack.getMin();   --> 返回 -2.
+``` 
+
+提示:     
+
+- -231 <= val <= 231 - 1
+- pop、top 和 getMin 操作总是在 非空栈 上调用
+- push, pop, top, and getMin最多被调用 3 * 104 次
+
+### 思路
+
+
+解题思路:    
+
+借用一个辅助栈min_stack，用于存获取stack中最小值。    
+
+算法流程:    
+
+- push()方法: 每当push()新值进来时，如果小于等于min_stack栈顶值，则一起push()到min_stack，即更新了栈顶最小值         
+-  pop()方法: 判断将pop()出去的元素值是否是min_stack栈顶元素值（即最小值），如果是则将min_stack栈顶元素一起pop()，这样可以保证min_stack栈顶元素始终是stack中的最小值      
+- getMin()方法: 返回min_stack栈顶即可     
+
+min_stack作用分析:     
+
+min_stack等价于遍历stack所有元素，把升序的数字都删除掉，留下一个从栈底到栈顶降序的栈。      
+相当于给stack中的降序元素做了标记，每当pop()这些降序元素，min_stack会将相应的栈顶元素pop()出去，保证其栈顶元素始终是stack中的最小元素。      
+复杂度分析:    
+
+- 时间复杂度 O(1) : 压栈，出栈，获取最小值的时间复杂度都为 O(1) 。
+- 空间复杂度 O(N) : 包含 N 个元素辅助栈占用线性大小的额外空间。
+
+```java
+class MinStack {
+    private Stack<Integer> stack;
+    private Stack<Integer> min_stack;
+    public MinStack() {
+        stack = new Stack<>();
+        min_stack = new Stack<>();
+    }
+    public void push(int x) {
+        stack.push(x);
+        if(min_stack.isEmpty() || x <= min_stack.peek()) {
+            min_stack.push(x);
+        }
+    }
+    public void pop() {
+        if(stack.pop().equals(min_stack.peek())) {
+            min_stack.pop();
+        }
+    }
+
+    public int top() {
+        return stack.peek();
+    }
+    
+    public int getMin() {
+        return min_stack.peek();
+    }
+}
+```
+
+
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	
diff --git "a/Algorithm/55.\351\200\206\346\263\242\345\205\260\350\241\250\350\276\276\345\274\217\346\261\202\345\200\274.md" "b/Algorithm/55.\351\200\206\346\263\242\345\205\260\350\241\250\350\276\276\345\274\217\346\261\202\345\200\274.md"
new file mode 100644
index 00000000..11250060
--- /dev/null
+++ "b/Algorithm/55.\351\200\206\346\263\242\345\205\260\350\241\250\350\276\276\345\274\217\346\261\202\345\200\274.md"
@@ -0,0 +1,137 @@
+55.逆波兰表达式求值
+===
+
+
+### 题目
+
+给你一个字符串数组 tokens ，表示一个根据 逆波兰表示法 表示的算术表达式。
+
+请你计算该表达式。返回一个表示表达式值的整数。
+
+注意:     
+
+- 有效的算符为 '+'、'-'、'*' 和 '/' 。
+- 每个操作数（运算对象）都可以是一个整数或者另一个表达式。
+- 两个整数之间的除法总是 向零截断 。
+- 表达式中不含除零运算。
+- 输入是一个根据逆波兰表示法表示的算术表达式。
+- 答案及所有中间计算结果可以用 32 位 整数表示。
+ 
+
+示例 1:    
+
+- 输入：tokens = ["2","1","+","3","*"]
+- 输出：9
+- 解释：该算式转化为常见的中缀算术表达式为：((2 + 1) * 3) = 9
+
+示例 2:     
+
+- 输入：tokens = ["4","13","5","/","+"]
+- 输出：6
+- 解释：该算式转化为常见的中缀算术表达式为：(4 + (13 / 5)) = 6
+
+示例 3:    
+
+- 输入：tokens = ["10","6","9","3","+","-11","*","/","*","17","+","5","+"]
+- 输出：22
+- 解释：该算式转化为常见的中缀算术表达式为:    
+```
+  ((10 * (6 / ((9 + 3) * -11))) + 17) + 5
+= ((10 * (6 / (12 * -11))) + 17) + 5
+= ((10 * (6 / -132)) + 17) + 5
+= ((10 * 0) + 17) + 5
+= (0 + 17) + 5
+= 17 + 5
+= 22
+``` 
+
+提示:   
+
+- 1 <= tokens.length <= 104
+- tokens[i]是一个算符（`+`、`-`、`*`或`/`），或是在范围`[-200, 200]`内的一个整数    
+ 
+
+逆波兰表达式:     
+
+- 逆波兰表达式是一种后缀表达式，所谓后缀就是指算符写在后面。
+
+- 平常使用的算式则是一种中缀表达式，如 ( 1 + 2 ) * ( 3 + 4 ) 。
+- 该算式的逆波兰表达式写法为 ( ( 1 2 + ) ( 3 4 + ) * ) 。
+
+逆波兰表达式主要有以下两个优点:    
+
+- 去掉括号后表达式无歧义，上式即便写成 1 2 + 3 4 + * 也可以依据次序计算出正确结果。
+- 适合用栈操作运算：遇到数字则入栈；遇到算符则取出栈顶两个数字进行计算，并将结果压入栈中
+
+### 思路
+
+逆波兰表达式，也叫做后缀表达式。
+
+我们平时见到的运算表达式是中缀表达式，即 "操作数① 运算符② 操作数③" 的顺序，运算符在两个操作数中间。
+但是后缀表达式是 "操作数① 操作数③ 运算符②" 的顺序，运算符在两个操作数之后。
+
+
+逆波兰表达式严格遵循「从左到右」的运算。计算逆波兰表达式的值时，使用一个栈存储操作数，从左到右遍历逆波兰表达式，进行如下操作:     
+
+- 如果遇到操作数，则将操作数入栈；
+
+- 如果遇到运算符，则将两个操作数出栈，其中先出栈的是右操作数，后出栈的是左操作数，使用运算符对两个操作数进行运算，将运算得到的新操作数入栈。
+
+整个逆波兰表达式遍历完毕之后，栈内只有一个元素，该元素即为逆波兰表达式的值。
+
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/leetcode_evalRPN1.png?raw=true)
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/leetcode_evalRPN2.png?raw=true)
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/leetcode_evalRPN3.png?raw=true)
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/leetcode_evalRPN4.png?raw=true)
+
+```java
+class Solution {
+    public int evalRPN(String[] tokens) {
+        Deque<Integer> stack = new LinkedList<Integer>();
+        int n = tokens.length;
+        for (int i = 0; i < n; i++) {
+            String token = tokens[i];
+            if (isNumber(token)) {
+                stack.push(Integer.parseInt(token));
+            } else {
+                int num2 = stack.pop();
+                int num1 = stack.pop();
+                switch (token) {
+                    case "+":
+                        stack.push(num1 + num2);
+                        break;
+                    case "-":
+                        stack.push(num1 - num2);
+                        break;
+                    case "*":
+                        stack.push(num1 * num2);
+                        break;
+                    case "/":
+                        stack.push(num1 / num2);
+                        break;
+                    default:
+                }
+            }
+        }
+        return stack.pop();
+    }
+
+    public boolean isNumber(String token) {
+        return !("+".equals(token) || "-".equals(token) || "*".equals(token) || "/".equals(token));
+    }
+}
+```
+
+复杂度分析:      
+
+- 时间复杂度: O(n)，其中 n 是数组 tokens 的长度。需要遍历数组 tokens 一次，计算逆波兰表达式的值。
+
+- 空间复杂度: O(n)，其中 n 是数组 tokens 的长度。使用栈存储计算过程中的数，栈内元素个数不会超过逆波兰表达式的长度。
+
+
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	
diff --git "a/Algorithm/56.\345\237\272\346\234\254\350\256\241\347\256\227\345\231\250.md" "b/Algorithm/56.\345\237\272\346\234\254\350\256\241\347\256\227\345\231\250.md"
new file mode 100644
index 00000000..10656199
--- /dev/null
+++ "b/Algorithm/56.\345\237\272\346\234\254\350\256\241\347\256\227\345\231\250.md"
@@ -0,0 +1,163 @@
+56.基本计算器
+===
+
+
+### 题目
+
+给你一个字符串表达式 s ，请你实现一个基本计算器来计算并返回它的值。
+
+注意:不允许使用任何将字符串作为数学表达式计算的内置函数，比如 eval() 。
+
+ 
+
+示例 1:    
+
+- 输入：s = "1 + 1"
+- 输出：2
+
+示例 2:   
+
+- 输入：s = " 2-1 + 2 "
+- 输出：3
+
+示例 3:    
+
+- 输入：s = "(1+(4+5+2)-3)+(6+8)"
+- 输出：23
+ 
+
+提示:    
+
+- 1 <= s.length <= 3 * 105
+- s 由数字、'+'、'-'、'('、')'、和 ' ' 组成
+- s 表示一个有效的表达式
+- '+' 不能用作一元运算(例如， "+1" 和 "+(2 + 3)" 无效)
+- '-' 可以用作一元运算(即 "-1" 和 "-(2 + 3)" 是有效的)
+- 输入中不存在两个连续的操作符
+- 每个数字和运行的计算将适合于一个有符号的 32位 整数
+
+### 思路
+
+
+【进阶补充】双栈解决通用「表达式计算」问题
+
+
+宫水三叶
+76872
+2021.03.10
+发布于 上海市
+栈
+数学
+C++
+Java
+双栈解法
+
+我们可以使用两个栈 nums 和 ops 。
+
+nums ： 存放所有的数字
+ops ：存放所有的数字以外的操作，+/- 也看做是一种操作
+然后从前往后做，对遍历到的字符做分情况讨论：
+
+空格 : 跳过
+( : 直接加入 ops 中，等待与之匹配的 )
+) : 使用现有的 nums 和 ops 进行计算，直到遇到左边最近的一个左括号为止，计算结果放到 nums
+数字 : 从当前位置开始继续往后取，将整一个连续数字整体取出，加入 nums
++/- : 需要将操作放入 ops 中。在放入之前先把栈内可以算的都算掉，使用现有的 nums 和 ops 进行计算，直到没有操作或者遇到左括号，计算结果放到 nums
+一些细节：
+
+由于第一个数可能是负数，为了减少边界判断。一个小技巧是先往 nums 添加一个 0
+为防止 () 内出现的首个字符为运算符，将所有的空格去掉，并将 (- 替换为 (0-，(+ 替换为 (0+（当然也可以不进行这样的预处理，将这个处理逻辑放到循环里去做）
+
+
+
+class Solution {
+    public int calculate(String s) {
+        // 存放所有的数字
+        Deque<Integer> nums = new ArrayDeque<>();
+        // 为了防止第一个数为负数，先往 nums 加个 0
+        nums.addLast(0);
+        // 将所有的空格去掉
+        s = s.replaceAll(" ", "");
+        // 存放所有的操作，包括 +/-
+        Deque<Character> ops = new ArrayDeque<>();
+        int n = s.length();
+        char[] cs = s.toCharArray();
+        for (int i = 0; i < n; i++) {
+            char c = cs[i];
+            if (c == '(') {
+                ops.addLast(c);
+            } else if (c == ')') {
+                // 计算到最近一个左括号为止
+                while (!ops.isEmpty()) {
+                    char op = ops.peekLast();
+                    if (op != '(') {
+                        calc(nums, ops);
+                    } else {
+                        ops.pollLast();
+                        break;
+                    }
+                }
+            } else {
+                if (isNum(c)) {
+                    int u = 0;
+                    int j = i;
+                    // 将从 i 位置开始后面的连续数字整体取出，加入 nums
+                    while (j < n && isNum(cs[j])) u = u * 10 + (int)(cs[j++] - '0');
+                    nums.addLast(u);
+                    i = j - 1;
+                } else {
+                    if (i > 0 && (cs[i - 1] == '(' || cs[i - 1] == '+' || cs[i - 1] == '-')) {
+                        nums.addLast(0);
+                    }
+                    // 有一个新操作要入栈时，先把栈内可以算的都算了
+                    while (!ops.isEmpty() && ops.peekLast() != '(') calc(nums, ops);
+                    ops.addLast(c);
+                }
+            }
+        }
+        while (!ops.isEmpty()) calc(nums, ops);
+        return nums.peekLast();
+    }
+    void calc(Deque<Integer> nums, Deque<Character> ops) {
+        if (nums.isEmpty() || nums.size() < 2) return;
+        if (ops.isEmpty()) return;
+        int b = nums.pollLast(), a = nums.pollLast();
+        char op = ops.pollLast();
+        nums.addLast(op == '+' ? a + b : a - b);
+    }
+    boolean isNum(char c) {
+        return Character.isDigit(c);
+    }
+}
+
+作者：宫水三叶
+链接：https://leetcode.cn/problems/basic-calculator/solutions/646865/shuang-zhan-jie-jue-tong-yong-biao-da-sh-olym/
+来源：力扣（LeetCode）
+著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	
diff --git a/Algorithm/57..md b/Algorithm/57..md
new file mode 100644
index 00000000..0970b4ab
--- /dev/null
+++ b/Algorithm/57..md
@@ -0,0 +1,17 @@
+18.整数转罗马数字
+===
+
+
+### 题目
+
+
+
+### 思路
+
+
+
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	
diff --git a/Algorithm/58..md b/Algorithm/58..md
new file mode 100644
index 00000000..0970b4ab
--- /dev/null
+++ b/Algorithm/58..md
@@ -0,0 +1,17 @@
+18.整数转罗马数字
+===
+
+
+### 题目
+
+
+
+### 思路
+
+
+
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	
diff --git a/Algorithm/59..md b/Algorithm/59..md
new file mode 100644
index 00000000..0970b4ab
--- /dev/null
+++ b/Algorithm/59..md
@@ -0,0 +1,17 @@
+18.整数转罗马数字
+===
+
+
+### 题目
+
+
+
+### 思路
+
+
+
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	
diff --git "a/Algorithm/6.\350\275\256\350\275\254\346\225\260\347\273\204.md" "b/Algorithm/6.\350\275\256\350\275\254\346\225\260\347\273\204.md"
new file mode 100644
index 00000000..4f9e6d02
--- /dev/null
+++ "b/Algorithm/6.\350\275\256\350\275\254\346\225\260\347\273\204.md"
@@ -0,0 +1,88 @@
+6.轮转数组
+===
+
+
+### 题目
+
+给定一个整数数组 nums，将数组中的元素向右轮转 k 个位置，其中 k 是非负数。
+
+
+示例 1:     
+
+- 输入: nums = [1,2,3,4,5,6,7], k = 3
+- 输出: [5,6,7,1,2,3,4]
+
+解释:      
+- 向右轮转 1 步: [7,1,2,3,4,5,6]
+- 向右轮转 2 步: [6,7,1,2,3,4,5]
+- 向右轮转 3 步: [5,6,7,1,2,3,4]
+
+示例 2:     
+
+- 输入：nums = [-1,-100,3,99], k = 2
+- 输出：[3,99,-1,-100]
+
+解释:     
+
+- 向右轮转 1 步: [99,-1,-100,3]
+- 向右轮转 2 步: [3,99,-1,-100]
+
+
+
+### 思路
+
+
+##### 双层循环
+
+外层循环k此，不断把最后一位移到第一位，然后内层循环每个元素后移一位
+
+```kotlin
+class Solution {
+    fun rotate(nums: IntArray, k: Int): Unit {
+        for (i in 0..<k) {
+            val temp = nums[nums.size - 1]
+            for (j in nums.size - 1 downTo   1) {
+                nums[j] = nums[j - 1]
+            }
+            nums[0] = temp
+        }
+    }
+}
+```
+##### 反转法
+
+
+- k=3
+[1, 2, 3, 4, 5, 6, 7]
+- 反转整个数组
+[7, 6, 5, 4, 3, 2, 1]
+- 反转前k个元素
+[5, 6, 7, 4, 3, 2, 1]
+- 反转后n - k个
+[5, 6, 7, 1, 2, 3, 4]
+
+
+注意：这里k可能超过数组的长度，所以要用 k %= n保证超过一轮的问题
+```python
+# 注：请勿使用切片，会产生额外空间
+class Solution:
+    def rotate(self, nums: List[int], k: int) -> None:
+        def reverse(i: int, j: int) -> None:
+            while i < j:
+                nums[i], nums[j] = nums[j], nums[i]
+                i += 1
+                j -= 1
+
+        n = len(nums)
+        k %= n  # 轮转 k 次等于轮转 k % n 次
+        reverse(0, n - 1)
+        reverse(0, k - 1)
+        reverse(k, n - 1)
+```
+
+
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	
diff --git a/Algorithm/60..md b/Algorithm/60..md
new file mode 100644
index 00000000..0970b4ab
--- /dev/null
+++ b/Algorithm/60..md
@@ -0,0 +1,17 @@
+18.整数转罗马数字
+===
+
+
+### 题目
+
+
+
+### 思路
+
+
+
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	
diff --git a/Algorithm/61..md b/Algorithm/61..md
new file mode 100644
index 00000000..0970b4ab
--- /dev/null
+++ b/Algorithm/61..md
@@ -0,0 +1,17 @@
+18.整数转罗马数字
+===
+
+
+### 题目
+
+
+
+### 思路
+
+
+
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	
diff --git a/Algorithm/62..md b/Algorithm/62..md
new file mode 100644
index 00000000..0970b4ab
--- /dev/null
+++ b/Algorithm/62..md
@@ -0,0 +1,17 @@
+18.整数转罗马数字
+===
+
+
+### 题目
+
+
+
+### 思路
+
+
+
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	
diff --git "a/Algorithm/7.\344\271\260\345\215\226\350\202\241\347\245\250\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272.md" "b/Algorithm/7.\344\271\260\345\215\226\350\202\241\347\245\250\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272.md"
new file mode 100644
index 00000000..18fa2d74
--- /dev/null
+++ "b/Algorithm/7.\344\271\260\345\215\226\350\202\241\347\245\250\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272.md"
@@ -0,0 +1,76 @@
+7.买卖股票的最佳时机
+===
+
+
+### 题目
+
+给定一个数组prices，它的第i个元素prices[i]表示一支给定股票第i天的价格。      
+
+你只能选择`某一天`买入这只股票，并选择在`未来的某一个不同的日子`卖出该股票。设计一个算法来计算你所能获取的最大利润。     
+
+返回你可以从这笔交易中获取的最大利润。如果你不能获取任何利润，返回0。   
+
+ 
+
+示例 1:   
+
+- 输入：[7,1,5,3,6,4]
+- 输出：5
+- 解释：在第2天（股票价格 = 1）的时候买入，在第5天（股票价格=6）的时候卖出，最大利润= `6-1 = 5` 。
+     注意利润不能是 7-1 = 6, 因为卖出价格需要大于买入价格；同时，你不能在买入前卖出股票。
+示例 2:   
+
+- 输入：prices = [7,6,4,3,1]
+- 输出：0
+- 解释：在这种情况下, 没有交易完成, 所以最大利润为 0。
+
+
+### 思路
+
+
+##### 暴力遍历
+
+先考虑最简单的「暴力遍历」，即枚举出所有情况，并从中选择最大利润。设数组 prices 的长度为 n ，由于只能先买入后卖出，因此第 1 天买可在未来 n−1 天卖出，第 2 天买可在未来 n−2 天卖出……以此类推，要思考更优解法。
+
+然而，暴力法会产生许多冗余计算。例如，若第 1 天价格低于第 2 天价格，即第 1 天成本更低，那么我们一定不会选择在第 2 天买入。进一步的，若在前 i 天选择买入，若想达到最高利润，则一定选择价格最低的交易日买入。
+
+##### 贪心思想
+
+考虑根据此贪心思想，遍历价格列表 prices 并执行两步：
+
+
+- 更新前 i 天的最低价格，即最低买入成本 cost；
+- 更新前 i 天的最高利润 profit ，即选择「前 i−1 天最高利润 profit 」和「第 i 天卖出的最高利润 price - cost 」中的最大值 ；
+
+
+```python
+class Solution:
+    def maxProfit(self, prices: List[int]) -> int:
+        minPrice = prices[0]
+        cost = 0
+        for i in prices:
+            if i < minPrice:
+                minPrice = i
+            elif i - minPrice > cost:
+                 cost = i - minPrice
+        return cost
+```        
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	
diff --git "a/Algorithm/8.\344\271\260\345\215\226\350\202\241\347\245\250\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272II.md" "b/Algorithm/8.\344\271\260\345\215\226\350\202\241\347\245\250\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272II.md"
new file mode 100644
index 00000000..00e0fa54
--- /dev/null
+++ "b/Algorithm/8.\344\271\260\345\215\226\350\202\241\347\245\250\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272II.md"
@@ -0,0 +1,107 @@
+8.买卖股票的最佳时机II
+===
+
+
+### 题目
+
+给你一个整数数组prices，其中prices[i]表示某支股票第i天的价格。
+
+在每一天，你可以决定是否购买和/或出售股票。你在任何时候最多只能持有一股股票。你也可以先购买，然后在同一天出售。
+
+返回 你能获得的 最大 利润 。
+
+ 
+
+示例 1:     
+
+- 输入：prices = [7,1,5,3,6,4]
+- 输出：7
+- 解释：在第 2 天（股票价格 = 1）的时候买入，在第 3 天（股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5 - 1 = 4。
+- 随后，在第 4 天（股票价格 = 3）的时候买入，在第 5 天（股票价格 = 6）的时候卖出, 这笔交易所能获得利润 = 6 - 3 = 3。
+- 最大总利润为 4 + 3 = 7 。
+
+示例 2:    
+
+- 输入：prices = [1,2,3,4,5]
+- 输出：4
+- 解释：在第 1 天（股票价格 = 1）的时候买入，在第 5 天 （股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5 - 1 = 4。
+- 最大总利润为 4。
+
+示例 3:      
+
+- 输入：prices = [7,6,4,3,1]
+- 输出：0
+- 解释：在这种情况下, 交易无法获得正利润，所以不参与交易可以获得最大利润，最大利润为 0。
+
+
+### 思路
+
+这个的改动点时可以交易多次，怎么能保证利益最大？
+下面两种方式其实一样
+
+##### 方式一
+
+只要第二天价格比第一天价格高就卖
+
+```kotlin
+class Solution {
+    fun maxProfit(prices: IntArray): Int {
+        var buyPirce = prices[0]
+        var totalIncome = 0
+        for (i in prices) {
+            if (i > buyPirce) {
+                totalIncome += (i - buyPirce)
+                buyPirce = i
+            } else if (i < buyPrice) {
+                buyPirce = i
+            }
+        }
+        return totalIncome
+    }
+}
+```
+##### 方式二
+
+- 记录当前可卖的最大收入及买入的价格
+- 如果最新的价格低于买入的价格或者当前已经有收入了且当前的价格小于最大收入时的卖价(i - buyPrice < income)，这个时候需要卖了再买
+
+
+```python3
+class Solution:
+    def maxProfit(self, prices: List[int]) -> int:
+        buyPrice = prices[0]
+        income = 0
+        totalIncome = 0
+        for i in prices:
+
+            if i < buyPrice or i - buyPrice < income: # 有更低的价格，或者说现在的价格比目前收益最大时可卖出的价格更低
+                # 有更低的购买价格了，这个时候要判断当前有没有利润，有就卖，没有就使用该价格买
+                if (income > 0):
+                    totalIncome += income
+                    income = 0
+                buyPrice = i
+            elif (i - buyPrice > income):
+                income = i - buyPrice
+
+        totalIncome += income
+        return totalIncome
+```
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	
diff --git "a/Algorithm/9.\350\267\263\350\267\203\346\270\270\346\210\217.md" "b/Algorithm/9.\350\267\263\350\267\203\346\270\270\346\210\217.md"
new file mode 100644
index 00000000..3bb87d3a
--- /dev/null
+++ "b/Algorithm/9.\350\267\263\350\267\203\346\270\270\346\210\217.md"
@@ -0,0 +1,91 @@
+9.跳跃游戏
+===
+
+
+### 题目
+
+给你一个非负整数数组nums，你最初位于数组的第一个下标。数组中的每个元素代表你在该位置可以跳跃的最大长度。
+
+判断你是否能够到达最后一个下标，如果可以，返回true；否则，返回false。
+
+ 
+
+示例 1:    
+
+- 输入：nums = [2,3,1,1,4]
+- 输出：true
+- 解释：可以先跳 1 步，从下标 0 到达下标 1, 然后再从下标 1 跳 3 步到达最后一个下标。
+
+示例 2:   
+
+- 输入：nums = [3,2,1,0,4]
+- 输出：false
+- 解释：无论怎样，总会到达下标为 3 的位置。但该下标的最大跳跃长度是 0 ， 所以永远不可能到达最后一个下标。
+
+
+
+### 思路
+
+##### 方式一
+
+题目中说：数组中的每个元素代表你在该位置可以跳跃的最大长度。
+所以我们只要保证能够跳跃的最大长度超过了数组的长度就可以。
+
+
+- 每走一步就记录最远可以到哪里
+- 最远可达位置够不够你继续往前走
+
+
+```python
+class Solution:
+    def canJump(self, nums: List[int]) -> bool:
+        rightmost = 0
+        for i in range(len(nums)):
+        	# 在可走的最大步数范围内走
+            if i <= rightmost:
+            	# 每走一步更新一下可继续走的最大步
+                rightmost = max(rightmost, i + nums[i])
+                if rightmost >= len(nums) - 1:
+                    return True
+        return False
+```
+
+
+
+
+##### 方式二
+
+
+- 假设在一个格子上，每个格子有对应的能量值。
+- 每前进一步需要消耗一个能量；
+- 而到达一个格子后， 如果当前格子储存的能量值较大，则更新为较大的能量值；
+- 如果当前格子能量值小于现有的能量值，则无需更新；
+- 如果出现能量值正好消耗完，那就没能量继续走了，最远的步数就是这里了
+- 判断最远的步数与数组的长度一样不一样
+
+```python
+class Solution:
+    def canJump(self, nums: List[int]) -> bool:
+        cur = nums[0]
+        if len(nums) == 1:
+            return True
+
+        for i in range(len(nums)):
+            cur -= 1
+            if cur < nums[i]:
+                cur = nums[i]
+            if cur <= 0:
+                break
+        return i == (len(nums) - 1)
+```
+
+
+
+
+
+
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	
diff --git "a/Architect/1.\346\236\266\346\236\204\347\256\200\344\273\213.md" "b/Architect/1.\346\236\266\346\236\204\347\256\200\344\273\213.md"
index 6fa7327a..a37e6d07 100644
--- "a/Architect/1.\346\236\266\346\236\204\347\256\200\344\273\213.md"
+++ "b/Architect/1.\346\236\266\346\236\204\347\256\200\344\273\213.md"
@@ -4,7 +4,7 @@
 #### 什么是系统架构
 
 关于系统架构，维基百科给出了一个非常好的定义。
-A system architecture is the conceptual model that defines the structure, behavior, and more views of a system.[
+A system architecture is the conceptual model that defines the structure, behavior, and more views of a system.
 (系统架构是概念模型，定义了系统的结构、行为和更多的视图)
 
 * 系统架构是一个概念模型。
@@ -12,7 +12,7 @@ A system architecture is the conceptual model that defines the structure, behavi
 关于这个定义，这里给出了另外一种解读，供大家参考。
 * 静。首先，从静止的角度，描述系统如何组成，以及系统的功能在这些组成部分之间是如何划分的。这就是系统的“结构”。一般要描述的是：系统包含哪些子系统，每个子系统有什么功能。在做这些描述时，应感觉自己是一名导游，带着游客在系统的子系统间参观。
 * 动。然后，从动态的角度，描述各子系统之间是如何联动的，它们是如何相互配合完成系统预定的任务或流程的。这就是系统的“行为”。在做这个描述时，应感觉自己是一名电影导演，将系统的各种运行情况通过一个个短片展现出来。
-* 细。最后，在以上两种描述的基础上，从不通的角度，更详细的刻画出系统的细节和全貌。这就是“更多的视图”。
+* 细。最后，在以上两种描述的基础上，从不同的角度，更详细的刻画出系统的细节和全貌。这就是“更多的视图”。
 
 
 
diff --git "a/Architect/2.UML\347\256\200\344\273\213.md" "b/Architect/2.UML\347\256\200\344\273\213.md"
index 2bcf58de..6427329e 100644
--- "a/Architect/2.UML\347\256\200\344\273\213.md"
+++ "b/Architect/2.UML\347\256\200\344\273\213.md"
@@ -9,12 +9,12 @@
 
 类图分三层，第一层显示类的名称，如果是抽象类，则就用斜体显示。第二层是类的特性，通常就是字段和属性。第三层是类的操作，通常是方法或行为。注意前面的符号，‘+’表示public，‘-’表示private，‘#’表示protected。”
 
-继承关系用空心三角形+实线来表示。
-接口用空心三角形+虚线来表示。
-关联关系用实线箭头来表示。
-聚合表示一种弱的‘拥有’关系，体现的是A对象可以包含B对象，但B对象不是A对象的一部分。聚合关系用空心的菱形+实线箭头来表示。
-合成（Composition，也有翻译成‘组合’的）是一种强的‘拥有’关系，体现了严格的部分和整体的关系，部分和整体的生命周期一样.合成关系用实心的菱形+实线箭头来表示
-依赖关系（Dependency），用虚线箭头来表示。
+- 继承关系用空心三角形+实线来表示。
+- 接口用空心三角形+虚线来表示。
+- 关联关系用实线箭头来表示。
+- 聚合表示一种弱的‘拥有’关系，体现的是A对象可以包含B对象，但B对象不是A对象的一部分。聚合关系用空心的菱形+实线箭头来表示。
+- 合成（Composition，也有翻译成‘组合’的）是一种强的‘拥有’关系，体现了严格的部分和整体的关系，部分和整体的生命周期一样.合成关系用实心的菱形+实线箭头来表示
+- 依赖关系（Dependency），用虚线箭头来表示。
 
 
 
diff --git "a/BasicKnowledge/Android\345\205\245\351\227\250\344\273\213\347\273\215.md" "b/BasicKnowledge/Android\345\205\245\351\227\250\344\273\213\347\273\215.md"
index ab179d5d..9749c05c 100644
--- "a/BasicKnowledge/Android\345\205\245\351\227\250\344\273\213\347\273\215.md"
+++ "b/BasicKnowledge/Android\345\205\245\351\227\250\344\273\213\347\273\215.md"
@@ -43,7 +43,7 @@ Android入门介绍
         - JVM基于栈的架构(栈内存)
         - Dalvik基于寄存器的架构(CPU)，执行效率比JVM要高
     3. Dalvik专门针对移动平台进行优化     
-        JVM的jar包中会有很多class文件，每个class文件中都含有头信息、常量池、字段、方法等，而apk中只有一个dex，它里面包括了所有头信息、常量池、方法等。这样读取一个文件要比读取多个文件去找块。  
+        JVM的jar包中会有很多class文件，每个class文件中都含有头信息、常量池、字段、方法等，而apk中只有一个dex，它里面包括了所有头信息、常量池、方法等。这样读取一个文件要比读取多个文件去找更快。  
 
 5. CPU处理器架构
     1. x86
diff --git "a/BasicKnowledge/Android\345\212\250\347\224\273.md" "b/BasicKnowledge/Android\345\212\250\347\224\273.md"
index 2705a05e..cd7ed266 100644
--- "a/BasicKnowledge/Android\345\212\250\347\224\273.md"
+++ "b/BasicKnowledge/Android\345\212\250\347\224\273.md"
@@ -180,7 +180,7 @@ animatorSet.start();
 ### `TypeEvalutors`
 
 
-根据属性的开始、结束值与`TimeInterpolation`计算出的比例值来计算当前时间对应的属性值，`Android`提供了一下几种`evalutor`:    
+根据属性的开始、结束值与`TimeInterpolation`计算出的比例值来计算当前时间对应的属性值，`Android`提供了以下几种`evalutor`:    
 
 - `IntEvalutor`:`int`类型的属性值
 - `FloatEvaluator`:
diff --git "a/BasicKnowledge/Fragment\344\270\223\351\242\230.md" "b/BasicKnowledge/Fragment\344\270\223\351\242\230.md"
index 81ceb228..6ac94a9b 100644
--- "a/BasicKnowledge/Fragment\344\270\223\351\242\230.md"
+++ "b/BasicKnowledge/Fragment\344\270\223\351\242\230.md"
@@ -21,10 +21,17 @@ If the no-argument constructor is not available, a runtime exception will occur
 
 ## 生命周期
 
-`onAttach()`(`Fragment`被绑定到`Activity`时调用) ---> `onCreate()`(`Fragment`创建) --> 
-`onCreateView()`(创建和`Fragment`关联的`View Hierarchy`时调用) --> `onActivityCreated()`(`Activity`的`onCreate()`方法返回时调用) 
---> `onStart()` --> `onResume()` --> `onPause()` --> `onStop()` --> `onDestroyView()`当和`Fragment`关联的`view hierarchy`正在被移除时调用. 
---> `onDestroy()`(`Activity`的`onDestroy`执行后的回调), --> `onDetach()`(当`Fragment`从`Activity`解除关联时被调用)        
+- `onAttach()`(`Fragment`被绑定到`Activity`时调用) ---> 
+- `onCreate()`(`Fragment`创建) --> 
+- `onCreateView()`(创建和`Fragment`关联的`View Hierarchy`时调用) --> 
+- `onActivityCreated()`(`Activity`的`onCreate()`方法返回时调用) --> 
+- `onStart()` --> 
+- `onResume()` --> 
+- `onPause()` --> 
+- `onStop()` --> 
+- `onDestroyView()`当和`Fragment`关联的`view hierarchy`正在被移除时调用. --> 
+- `onDestroy()`(`Activity`的`onDestroy`执行后的回调), --> 
+- `onDetach()`(当`Fragment`从`Activity`解除关联时被调用)        
 	
 ![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/complete_android_fragment_lifecycle.png)    
 
diff --git "a/BasicKnowledge/JNI\345\237\272\347\241\200.md" "b/BasicKnowledge/JNI\345\237\272\347\241\200.md"
index 700f59a8..0bd00767 100644
--- "a/BasicKnowledge/JNI\345\237\272\347\241\200.md"
+++ "b/BasicKnowledge/JNI\345\237\272\347\241\200.md"
@@ -407,4 +407,4 @@ JNI基础
 ---
 
 - 邮箱 ：charon.chui@gmail.com  
-- Good Luck!
\ No newline at end of file
+- Good Luck!
diff --git "a/BasicKnowledge/Parcelable\345\217\212Serializable.md" "b/BasicKnowledge/Parcelable\345\217\212Serializable.md"
index 73a927a1..de220416 100644
--- "a/BasicKnowledge/Parcelable\345\217\212Serializable.md"
+++ "b/BasicKnowledge/Parcelable\345\217\212Serializable.md"
@@ -1,6 +1,15 @@
 Parcelable及Serializable
 ===
 
+
+
+### Serializable
+
+在Java中Serializable接口是一个允许将对象转换为字节流(序列化)然后重新构造回对象(反序列化)的标记接口。   
+
+它会使用反射，并且会创建许多临时对象，导致内存使用率升高，并可能产生性能问题。  
+
+
 `Serializable`的作用是为了保存对象的属性到本地文件、数据库、网络流、`rmi`以方便数据传输，
 当然这种传输可以是程序内的也可以是两个程序间的。而`Parcelable`的设计初衷是因为`Serializable`效率过慢，
 为了在程序内不同组件间以及不同`Android`程序间(`AIDL`)高效的传输数据而设计，这些数据仅在内存中存在，`Parcelable`是通过`IBinder`通信的消息的载体。
@@ -11,6 +20,58 @@ Parcelable及Serializable
 
 Parcelable不同于将对象进行序列化，Parcelable方式的实现原理是将一个完整的对象进行分解，而分解后的每一部分都是Intent所支持的数据类型，这样也就实现传递对象的功能了。
 
+
+### Parcelable实现
+
+```kotlin
+data class Developer(val name: String, val age: Int) : Parcelable {
+
+    constructor(parcel: Parcel) : this(
+        parcel.readString(),
+        parcel.readInt()
+    )
+
+    override fun writeToParcel(parcel: Parcel, flags: Int) {
+        parcel.writeString(name)
+        parcel.writeInt(age)
+    }
+
+    // code removed for brevity
+
+    companion object CREATOR : Parcelable.Creator<Developer> {
+        override fun createFromParcel(parcel: Parcel): Developer {
+            return Developer(parcel)
+        }
+
+        override fun newArray(size: Int): Array<Developer?> {
+            return arrayOfNulls(size)
+        }
+    }
+}
+
+```
+上面是实现Parcelable的代码，可以看到有很多重复的代码。      
+为了避免写这些重复的代码，可以使用kotlin-parcelize插件，并在类上使用@Parcelize注解。
+
+```kotlin
+@Parcelize
+data class Developer(val name: String, val age: Int) : Parcelable
+```
+
+当在一个类上声明`@Parcelize`注解后，就会自动生成对应的代码。     
+
+
+
+
+
+Parcelable不会使用反射，并且在序列化过程中会产生更少的临时对象，这样就会减少垃圾回收的压力:    
+
+- Parcelable不会使用反射
+- Parcelable是Android平台特定的接口
+
+所以Parcelable比Serializable更快。    
+
+
 区别:    
 - Parcelable is faster than serializable interface
 - Parcelable interface takes more time for implemetation compared to serializable interface
@@ -20,4 +81,4 @@ Parcelable不同于将对象进行序列化，Parcelable方式的实现原理是
 
 ----
 - 邮箱 ：charon.chui@gmail.com  
-- Good Luck! 
\ No newline at end of file
+- Good Luck! 
diff --git "a/BasicKnowledge/adb logcat\344\275\277\347\224\250\347\256\200\344\273\213.md" "b/BasicKnowledge/adb logcat\344\275\277\347\224\250\347\256\200\344\273\213.md"
index 1222f1ce..273c43ab 100644
--- "a/BasicKnowledge/adb logcat\344\275\277\347\224\250\347\256\200\344\273\213.md"	
+++ "b/BasicKnowledge/adb logcat\344\275\277\347\224\250\347\256\200\344\273\213.md"	
@@ -28,11 +28,12 @@ brief process tag thread raw time threadtime long 设置日志的输出格式, 
 - `-c`              `clear (flush) the entire log and exit     清空所有的日志缓存信息`
 - `-d`              `dump the log and then exit (don't block)   将缓存的日志输出到屏幕上, 并且不会阻塞;`
 - `-t <count>`      `print only the most recent <count> lines (implies -d)  输出最近的几行日志, 输出完退出, 不阻塞;`
-  `-g`              `get the size of the log's ring buffer and exit   查看日志缓冲区信息`
-  `-b <buffer>`     `Request alternate ring buffer, 'main', 'system', 'radio' 
+
+- `-g`              `get the size of the log's ring buffer and exit   查看日志缓冲区信息`
+- `-b <buffer>`     `Request alternate ring buffer, 'main', 'system', 'radio' 
                   or 'events'. Multiple -b parameters are allowed and the
                   results are interleaved. The default is -b main -b system.加载一个日志缓冲区, 默认是 main`      
-  `-B`              `output the log in binary 以二进制形式输出日志`
+- `-B`              `output the log in binary 以二进制形式输出日志`
 
 
 `filterspecs are a series of `
diff --git "a/Gradle&Maven/Gradle\344\270\223\351\242\230.md" "b/Gradle&Maven/Gradle\344\270\223\351\242\230.md"
index 5968cbbe..253a8c33 100644
--- "a/Gradle&Maven/Gradle\344\270\223\351\242\230.md"
+++ "b/Gradle&Maven/Gradle\344\270\223\351\242\230.md"
@@ -4,12 +4,23 @@ Gradle专题
 作用
 ---
 
-[Gradle](https://docs.gradle.org/7.3.3/userguide/what_is_gradle.html)是一个开源的自动化构建工具。现在Android项目构建编译都是通过Gradle进行的，Gradle的版本在`gradle/wrapper/gradle-wrapper.properties`下:   
+[Gradle](https://docs.gradle.org/7.3.3/userguide/what_is_gradle.html)是一个开源的自动化构建工具。现在Android项目构建编译都是通过Gradle进行的。
+
+Gradle的版本在`gradle/wrapper/gradle-wrapper.properties`下:   
 ![image](https://github.com/CharonChui/Pictures/blob/master/gradle_version.png?raw=true)
 
 当前Gradle版本为6.7.1。当我们执行assembleDebug/assembleRelease编译命令的时候，Gradle就会开始进行编译构建流程。
 
 
+gradle-wrapper是对Gradle的一层包装，便于在团队开发过程中统一Gradle构建的版本号，这样大家都可以使用统一的Gradle版本进行构建。 
+里面的distributionUrl属性是用于配置Gradle发行版压缩包的下载地址。    
+
+Gradle 是一个 运行在 JVM 的通用构建工具,其核心模型是一个由 Task 组成的有向无环图(Directed Acyclic Graphs).
+
+
+![image](https://github.com/CharonChui/Pictures/blob/master/gradle_task_1.png?raw=true)
+
+
 简介
 ---
 
@@ -30,6 +41,27 @@ Java程序员可以无缝切换到使用Groovy开发程序。Groovy说白了就
 
 ![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/android_build_process.png?raw=true)
 
+
+说起来我们一直在使用Gradle，但仔细想想我们在项目中其实没有用gradle命令，而一般是使用gradlew命令，同时如下图所示，找遍整个项目，与gradle有关的就这两个文件夹，却只发现gradle-wrapper.jar。
+
+
+那么问题来了，gradlew是什么，gradle-wrapper.jar又是什么?
+
+wrapper的意思：包装。
+
+那么可想而已，这是gradle的包装。其实是这样的，因为gradle处于快速迭代阶段，经常发布新版本，如果我们的项目直接去引用，那么更改版本等会变得无比麻烦。而且每个项目又有可能用不一样的gradle版本，这样去手动配置每一个项目对应的gradle版本就会变得麻烦，gradle的引入本来就是想让大家构建项目变得轻松，如果这样的话，岂不是又增加了新的麻烦？
+
+所以android想到了包装，引入gradle-wrapper，通过读取配置文件中gradle的版本，为每个项目自动的下载和配置gradle，就是这么简单。我们便不用关心如何去下载gradle,如何配置到项目中。
+
+至于gradlew也是一样的道理，它共有两个文件，gradlew是在linux,mac下使用的，gradlew.bat是在window下使用的，提供在命令行下执行gradle命令的功能
+
+至于为什么不直接执行Gradle，而是执行Gradlew命令呢?
+
+因为就像wrapper本身的意义，gradle命令行也是善变的，所以wrapper对命令行也进行了一层封装，使用同一的gradlew命令，wrapper会自动去执行具体版本对应的gradle命令。
+
+同时如果我们配置了全局的gradle命令，在项目中如果也用gradle容易造成混淆，而gradlew明确就是项目中指定的gradle版本，更加清晰与明确
+
+
 ### Gradle的生命周期
 
 1. Initialization：初始化阶段     
@@ -1744,6 +1776,343 @@ pizzaPrices.pepperoni
 
 
 
+
+
+
+1.Groovy概述
+Groovy是Apache 旗下的一种基于JVM的面向对象编程语言，既可以用于面向对象编程，也可以用作纯粹的脚本语言。在语言的设计上它吸纳了Python、Ruby 和 Smalltalk 语言的优秀特性，比如动态类型转换、闭包和元编程支持。
+Groovy与 Java可以很好的互相调用并结合编程 ，比如在写 Groovy 的时候忘记了语法可以直接按Java的语法继续写，也可以在 Java 中调用 Groovy 脚本。比起Java，Groovy语法更加的灵活和简洁，可以用更少的代码来实现Java实现的同样功能。
+
+2.Groovy编写和调试
+Groovy的代码可以在Android Studio和IntelliJ IDEA等IDE中进行编写和调试，缺点是需要配置环境，这里推荐在文本中编写代码并结合命令行进行调试（文本推荐使用Sublime Text）。关于命令行请查看Gradle入门前奏这篇文章。
+具体的操作步骤就是：在一个目录中新建build.gradle文件，在build.gradle中新建一个task，在task中编写Groovy代码，用命令行进入这个build.gradle文件所在的目录，运行gradle task名称 等命令行对代码进行调试，本文中的例子都是这样编写和调试的。
+
+3.变量
+Groovy中用def关键字来定义变量，可以不指定变量的类型，默认访问修饰符是public。
+
+def a = 1;
+def int b = 1;
+def c = "hello world";
+4.方法
+方法使用返回类型或def关键字定义，方法可以接收任意数量的参数，这些参数可以不申明类型，如果不提供可见性修饰符，则该方法为public。
+用def关键字定义方法。
+
+task method <<{
+    add (1,2)
+    minus 1,2 //1
+}
+def add(int a,int b) { 
+ println a+b //3
+}  
+def minus(a,b) {//2 
+ println a-b
+}   
+如果指定了方法返回类型，可以不需要def关键字来定义方法。
+
+task method <<{
+    def number=minus 1,2
+    println number
+}
+int minus(a,b) { 
+  return a-b 
+}  
+如果不使用return ，方法的返回值为最后一行代码的执行结果。
+
+int minus(a,b) { 
+  a-b //4
+}  
+从上面两段代码中可以发现Groovy中有很多省略的地方：
+
+语句后面的分号可以省略。
+
+方法的括号可以省略，比如注释1和注释3处。
+
+参数类型可以省略，比如注释2处。
+
+return可以省略掉，比如注释4处。
+
+5.类
+Groovy类非常类似于Java类。
+
+task method <<{
+    def p = new Person()
+    p.increaseAge 5
+    println p.age
+}
+class Person {                       
+    String name                      
+    Integer age =10
+    def increaseAge(Integer years) { 
+        this.age += years
+    }
+}
+运行 gradle method打印结果为：
+15
+
+Groovy类与Java类有以下的区别：
+
+默认类的修饰符为public。
+
+没有可见性修饰符的字段会自动生成对应的setter和getter方法。
+
+类不需要与它的源文件有相同的名称，但还是建议采用相同的名称。
+
+6.语句
+6.1 断言
+Groovy断言和Java断言不同，它一直处于开启状态，是进行单元测试的首选方式。
+
+task method <<{
+  assert 1+2 == 6
+}
+输出结果为：
+
+Execution failed for task ':method'.
+> assert 1+2 == 6
+          |  |
+          3  false
+当断言的条件为false时，程序会抛出异常，不再执行下面的代码，从输出可以很清晰的看到发生错误的地方。
+
+6.2 for循环
+Groovy支持Java的for(int i=0;i<N;i++)和for(int i :array)形式的循环语句，另外还支持for in loop形式，支持遍历范围、列表、Map、数组和字符串等多种类型。
+
+//遍历范围
+def x = 0
+for ( i in 0..3 ) {
+    x += i
+}
+assert x == 6
+//遍历列表
+def x = 0
+for ( i in [0, 1, 2, 3] ) {
+    x += i
+}
+assert x == 6
+//遍历Map中的值
+def map = ['a':1, 'b':2, 'c':3]
+x = 0
+for ( v in map.values() ) {
+    x += v
+}
+assert x == 6
+6.3 switch语句
+Groovy中的Switch语句不仅兼容Java代码，还可以处理更多类型的case表达式。
+
+task method <<{
+def x = 16
+def result = ""
+
+switch ( x ) {
+    case "ok":
+        result = "found ok"
+    case [1, 2, 4, 'list']:
+        result = "list"
+        break
+    case 10..19:
+        result = "range"
+        break
+    case Integer:
+        result = "integer"
+        break
+    default:
+        result = "default"
+}
+assert result == "range"
+}
+case表达式可以是字符串、列表、范围、Integer等等，因为篇幅原因，这里只列出了一小部分。
+
+7. 数据类型
+Groovy中的数据类型主要有以下几种：
+
+Java中的基本数据类型
+
+Groovy中的容器类
+
+闭包
+
+7.1 字符串
+Groovy中的基本数据类型和Java大同小异，这里主要介绍下字符串类型。在Groovy种有两种字符串类型，普通字符串String（java.lang.String）和插值字符串GString（groovy.lang.GString）。
+
+单引号字符串
+在Groovy中单引号字符串和双引号字符串都可以定义一个字符串常量，只不过单引号字符串不支持插值。
+
+'Android进阶解密'
+双引号字符串
+要想插值可以使用双引号字符串，插值指的是替换字符串中的占位符，占位符表达式为${}或者以$为前缀。
+
+def name = 'Android进阶之光'
+println "hello ${name}"
+println "hello $name"
+三引号字符串
+三引号字符串可以保留文本的换行和缩进格式，不支持插值。
+
+task method <<{
+def name = '''Android进阶之光
+       Android进阶解密
+Android进阶？'''
+println name 
+}
+打印结果为：
+
+Android进阶之光
+       Android进阶解密
+Android进阶？
+GString
+String是不可变的，GString却是可变的，GString和String即使有相同的字面量，它们的hashCodes的值也可能不同，因此应该避免使用使用GString作为Map的key。
+
+assert "one: ${1}".hashCode() != "one: 1".hashCode()
+当双引号字符串中包含插值表达式时，字符串类型为GString，因此上面的断言为true。
+
+7.2  List
+Groovy没有定义自己的集合类，它在Java集合类的基础上进行了增强和简化。Groovy的List对应Java中的List接口，默认的实现类为Java中的ArrayList。
+
+def number = [1, 2, 3]         
+assert number instanceof List  
+def linkedList = [1, 2, 3] as LinkedList    
+assert linkedList instanceof java.util.LinkedList
+可以使用as操作符来显式指定List的实现类为java.util.LinkedList。
+获取元素同样要比Java要简洁些，使用[]来获取List中具有正索引或负索引的元素。
+
+task method <<{
+def number  = [1, 2, 3, 4]   
+assert number [1] == 2
+assert number [-1] == 4 //1  
+
+number << 5     //2             
+assert number [4] == 5
+assert number [-1] == 5
+}
+注释1处的索引-1是列表末尾的第一个元素。注释2处使用<<运算符在列表末尾追加一个元素。
+
+7.3  Map
+创建Map同样使用[]，需要同时指定键和值，默认的实现类为java.util.LinkedHashMap。
+
+def name = [one: '魏无羡', two: '杨影枫', three: '张无忌']   
+assert name['one']  == '魏无羡' 
+assert name.two  == '杨影枫'
+Map还有一个键关联的问题：
+
+def key = 'name'
+def person = [key: '魏无羡'] //1
+assert person.containsKey('key') 
+person = [(key): '魏无羡'] //2       
+assert person.containsKey('name') 
+注释1处魏无羡的键值是key这个字符串，而不是key变量的值 name。如果想要以key变量的值为键值，需要像注释2处一样使用(key)，用来告诉解析器我们传递的是一个变量，而不是定义一个字符串键值。
+
+7.4  闭包（Closure）
+Groovy中的闭包是一个开放的、匿名的、可以接受参数和返回值的代码块。
+定义闭包
+闭包的定义遵循以下语法：
+
+{ [closureParameters -> ] statements }
+闭包分为两个部分，分别是参数列表部分[closureParameters -> ]和语句部分 statements 。
+参数列表部分是可选的，如果闭包只有一个参数，参数名是可选的，Groovy会隐式指定it作为参数名，如下所示。
+
+{ println it }     //使用隐式参数it的闭包                                 
+当需要指定参数列表时，需要->将参数列表和闭包体相分离。
+
+{ it -> println it }   //it是一个显示参数 
+{ String a, String b ->                                
+    println "${a} is a ${b}"
+}   
+闭包是groovy.lang.Cloush类的一个实例，这使得闭包可以赋值给变量或字段，如下所示。
+
+//将闭包赋值给一个变量
+def println ={ it -> println it }     
+assert println instanceof Closure
+//将闭包赋值给Closure类型变量
+Closure do= { println 'do!' }                      
+调用闭包
+闭包既可以当做方法来调用，也可以显示调用call方法。
+
+def code = { 123 }
+assert code() == 123 //闭包当做方法调用
+assert code.call() == 123 //显示调用call方法
+def isOddNumber = { int i -> i%2 != 0 }                           
+assert isOddNumber(3) == true  //调用带参数的闭包
+8. I/O 操作
+Groovy的 I/O 操作要比Java的更为的简洁。
+
+8.1 文件读取
+我们可以在PC上新建一个name.txt，在里面输入一些内容，然后用Groovy来读取该文件的内容：
+
+def filePath = "D:/Android/name.txt"
+def file = new File(filePath) ;
+file.eachLine {
+    println it
+}
+可以看出Groovy的文件读取是很简洁的，还可以更简洁些：
+
+def filePath = "D:/Android/name.txt"
+def file = new File(filePath) ;
+println file.text
+8.2 文件写入
+文件写入同样十分简洁：
+
+def filePath = "D:/Android/name.txt"
+def file = new File(filePath);
+
+file.withPrintWriter {
+    it.println("三井寿")
+    it.println("仙道彰")
+}
+9. 其他
+9.1 asType
+asType可以用于数据类型转换：
+
+String a = '23'
+int b = a as int
+def c = a.asType(Integer)
+assert c instanceof java.lang.Integer
+9.2 判断是否为真
+if (name != null && name.length > 0) {}
+可以替换为
+
+if (name) {}
+9.3 安全取值
+在Java中，要安全获取某个对象的值可能需要大量的if语句来判空：
+
+if (school != null) {
+    if (school.getStudent() != null) {
+        if (school.getStudent().getName() != null) {
+            System.out.println(school.getStudent().getName());
+        }
+    }
+}
+Groovy中可以使用？.来安全的取值：
+
+println school?.student?.name
+9.4 with操作符
+对同一个对象的属性进行赋值时，可以这么做：
+
+task method <<{
+Person p = new Person()
+p.name = "杨影枫"
+p.age = 19
+p.sex = "男"
+println p.name
+}
+class Person {                       
+    String name                      
+    Integer age
+    String sex
+}
+使用with来进行简化：
+
+Person p = new Person()
+p.with {
+   name = "杨影枫"
+   age= 19
+   sex= "男"
+ }   
+println p.name
+
+
+
+
+
+
+
+
 [1]: https://github.com/CharonChui/AndroidNote/blob/master/AndroidStudioCourse/AndroidStudio%E4%BD%BF%E7%94%A8%E6%95%99%E7%A8%8B(%E7%AC%AC%E4%B8%83%E5%BC%B9).md       "AndroidStudio使用教程(第七弹)"
 
 
diff --git a/Gradle&Maven/kts.md b/Gradle&Maven/kts.md
new file mode 100644
index 00000000..c6a2e26c
--- /dev/null
+++ b/Gradle&Maven/kts.md
@@ -0,0 +1,136 @@
+Gradle 支持使用 Groovy DSL 或 Kotlin DSL 来编写脚本。所以在学习具体怎么写脚本时，我们肯定会考虑到底是使用 Kotlin 来写还是 Groovy 来写。
+
+不一定说你是 Kotlin Android 开发者就一定要用 Kotlin 来写 Gradle，我们得判断哪种写法更适合项目、更适合开发团队人群（学习成本）。
+
+所以下面来学习一下这两种语言的差异。
+
+1. Groovy 和 Kotlin 的差异     
+
+1.1 语言差异
+
+Groovy是一种基于 JVM 的面向对象的编程语言，它可以作为常规编程语言，但主要是作为脚本的语言（为了解决 Java 在写脚本时过于死板）。      
+
+它是一个动态语言，可以不指定变量类型。它的特性是支持闭包，闭包的本质很简单，简单的说就是定义一个匿名作用域，这个作用域内部可以封装函数和变量，外部不可以访问这个作用域内部的东西，但是可以通过调用这个作用域来完成一些任务。
+     
+Kotlin则是Java的优化版，在解决Kotlin很多痛点的情况下，不引入过多的新概念。它具有强大的类型推断系统，使得语言有良好的动态性，其次是其语言招牌 —— 语法糖，Kotlin 的代码可以写的非常简洁。这使得 Kotlin 不仅做为常规编程语言能大放异彩，作为脚本语言也深受很多开发者喜爱。
+
+它们共同特点就是基于JVM，可以和 Java 互操作。Gradle 能提供的东西， Kotlin 也能通过提供（闭包）。在功能上，两者能做的事情都是一样的。此外一些简单的差异有：
+
+groovy 字符串可以使用单引号，而 kotlin 则必须为双引号。    
+groovy 在方法调用时可以省略扩号，而 kotlin 不可省略。    
+groovy 分配属性时可以省略 = 赋值运算符，而 kotlin 不可省略。   
+groovy 是动态语言，不用导包，而 kotlin 则需要。
+
+
+
+为什么要用Kotlin DSL写gradle脚本?     
+
+撇开其他方面，就单从提高程序员生产效率方面就有很多优点：
+
+- 脚本代码自动补全
+- 跳转查看源码
+- 动态显示注释
+- 支持重构(Refactoring)
+…
+怎么样，要是你经历过groovy那令人蛋疼的体验，kotlin会让你爽的起飞，接下来让我们开始吧。
+
+从Groovy到Kotlin
+
+让我们使用Android Studio 新建一个Android项目，AS默认会为我们生成3个gradle脚本文件。
+
+- settings.gradle (属于 project)
+- build.gradle (属于 project)
+- build.gradle (属于 module)
+
+我们的目的就是转换这3个文件
+
+- 第一步: 修改groovy语法到严格格式
+
+groovy既支持双引号""也支持单引号''，而kotlin只支持双引号，所以首先将所有的单引号改为双引号。
+
+例如 include ':app' -> include ":app"
+
+groovy方法调用可以不使用() 但是kotlin方法调用必须使用(),所以将所有方法调用改为()方式。
+
+例如:     
+
+```java
+implementation "androidx.appcompat:appcompat:1.0.2"
+改为
+
+ implementation ("androidx.appcompat:appcompat:1.0.2")
+groovy 属性赋值可以不使用=，但是kotlin属性赋值需要使用=，所以将所有属性赋值添加=。
+```
+
+例如:     
+```
+applicationId "com.ss007.gradlewithkotlin"
+改为
+
+applicationId = "com.ss007.gradlewithkotlin"
+```
+
+完成以上几步，准备工作就完成了。
+
+
+
+
+1.2 文件差异
+两者编写 Gradle 的文件是有差异的：
+
+用 Groovy 写的 Gradle 文件是 .gradle 后缀
+用 Kotlin 写的 Gradle 文件是 .gradle.kts 为后缀
+两者的主要区别是：
+
+代码提示和编译检查
+.kts 内所有都是基于kotlin代码规范的，所以强类型语言的好处就是编译没通过的情况下根本无法运行。此外，IDE 集成后可以提供自动补全代码的能力
+.gradle 则不会有代码提示和编译检查
+源代码、文档查看
+.gradle 被编译后是 JVM 字节码，有时候无法查看其源码
+.kts 的 DSL 是通过扩展函数实现的（可以看这篇：Kotlin DSL 学习），IDE 支持下可以导航到源代码、文档或重构部分
+对于写脚本的人来说，两者的差异不大，因为 Gradle 的 DSL 是 Groovy 提供的，后来的 Kotlin 并没有另起炉灶，而是写了一套 Kotlin 版的。所以两者在代码上也就只有所用语言的差异了，概念啥的都是一样的。
+
+作为一名 Kotlin Android 开发者，我之后基本上是使用 Kotlin DSL 来学习写 Gradle 脚本，但是就跟我上面说的一样，了解其中一个后，要搞懂另外一个成本是很低的。
+
+
+2. 基本命令
+2.1 Project 、 Task 和 Action 介绍
+Gradle 主要是围绕着 Project（项目）、Task（任务）、Action（行为）这几个概念进行的。它们的作用分别是：
+
+project：每次 build 可以由一个或多个 project 组成。Gradle 为每个 build.gradle 创建一个相应的 project 领域对象，在编写Gradle脚本时，我们实际上是在操作诸如 project 这样的 Gradle 领域对象。
+若要创建多 project 的项目，我们需要在 根工程（root目录）下面新建 settings.gradle 文件，将所有的子 project 都写进去（include）。在 Android 中，每个 Module 都是一个子 project。
+task：每个 project 可以由一个或多个 task 组成。它代表更加细化的构建任务，例如：签名、编译一些java文件等。
+action：每个 task 可以由一个或多个 action 组成，它有 doFirst{} 和 doLast{} 两种类型
+————————————————
+
+                            
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git "a/ImageLoaderLibrary/Glide\347\256\200\344\273\213(\344\270\213).md" "b/ImageLoaderLibrary/Glide\347\256\200\344\273\213(\344\270\213).md"
index 5456759f..7c246365 100644
--- "a/ImageLoaderLibrary/Glide\347\256\200\344\273\213(\344\270\213).md"
+++ "b/ImageLoaderLibrary/Glide\347\256\200\344\273\213(\344\270\213).md"
@@ -420,6 +420,33 @@ builder.setDiskCache(
 - `Disk cache needs to implement: DiskCache`
 
 
+
+
+Let's take Glide as an example. To optimize memory usage and use less memory, Glide does downsampling.
+
+Downsampling means scaling the bitmap(image) to a smaller size which is actually required by the view.
+
+Assume that we have an image of size 2000*2000, but the view size is 400*400. So why load an image of 2000*2000, Glide down-samples the bitmap to 400*400, and then show it into the view.
+
+We use Glide like this:
+```
+Glide.with(fragment)
+    .load(url)
+    .into(imageView);
+```
+As we are passing the imageView as a parameter to the Glide, it knows the dimension of the imageView.
+
+Glide down-samples the image without loading the whole image into the memory.
+
+This way, the bitmap takes less memory, and the out-of-memory error is solved. Similarly, other Image Loading libraries like Fresco also do it.
+
+This was all about how the Android Image Loading library optimizes memory usage.
+
+
+
+
+
+
 参考
 ===
 
diff --git a/JavaKnowledge/.DS_Store b/JavaKnowledge/.DS_Store
deleted file mode 100644
index 1e695797..00000000
Binary files a/JavaKnowledge/.DS_Store and /dev/null differ
diff --git "a/JavaKnowledge/HashMap\345\256\236\347\216\260\345\216\237\347\220\206\345\210\206\346\236\220.md" "b/JavaKnowledge/HashMap\345\256\236\347\216\260\345\216\237\347\220\206\345\210\206\346\236\220.md"
index a5192325..02f9c51c 100644
--- "a/JavaKnowledge/HashMap\345\256\236\347\216\260\345\216\237\347\220\206\345\210\206\346\236\220.md"
+++ "b/JavaKnowledge/HashMap\345\256\236\347\216\260\345\216\237\347\220\206\345\210\206\346\236\220.md"
@@ -49,10 +49,20 @@ HashMap是无序的，因为HashMap无法保证内部存储的键值对的有序
 获取对象时，我们将K传给get()方法，它调用hashCode()计算hash从而得到bucket位置，并进一步调用equals()方法确定键值对。
 
 扩容前后，哈希桶的长度一定会是2的次方。这样在根据key的hash值寻找对应的哈希桶时，可以用位运算替代取余操作，更加高效。
+
 而key的hash值，并不仅仅只是key对象的hashCode()方法的返回值，还会经过扰动函数的扰动，以使hash值更加均衡。
-因为hashCode()是int类型，取值范围是40多亿，只要哈希函数映射的比较均匀松散，碰撞几率是很小的。 但就算原本的hashCode()取的很好，每个key的hashCode()不同，但是由于HashMap的哈希桶的长度远比hash取值范围小，默认是16，所以当对hash值以桶的长度取余，以找到存放该key的桶的下标时，由于取余是通过与操作完成的，会忽略hash值的高位。因此只有hashCode()的低位参加运算，
-发生不同的hash值，但是得到的index相同的情况的几率会大大增加，这种情况称之为hash碰撞。即碰撞率会增大。
-扰动函数就是为了解决hash碰撞的。它会综合hash值高位和低位的特征，并存放在低位，因此在与运算时，相当于高低位一起参与了运算，以减少hash碰撞的概率。（在JDK8之前，扰动函数会扰动四次，JDK8简化了这个操作）扩容操作时，会new一个新的Node数组作为哈希桶，然后将原哈希表中的所有数据(Node节点)移动到新的哈希桶中，相当于对原哈希表中所有的数据重新做了一个put操作。所以性能消耗很大，可想而知，在哈希表的容量越大时，性能消耗越明显。扩容时，如果发生过哈希碰撞，节点数小于8个。则要根据链表上每个节点的哈希值，依次放入新哈希桶对应下标位置。因为扩容是容量翻倍，所以原链表上的每个节点，现在可能存放在原来的下标，即low位， 或者扩容后的下标，即high位。 high位= low位+原哈希桶容量如果追加节点后，链表数量 >=8，且只有数组长度大于64才处理，则转化为红黑树由迭代器的实现可以看出，遍历HashMap时，
+
+因为hashCode()是int类型，取值范围是40多亿，只要哈希函数映射的比较均匀松散，碰撞几率是很小的。      
+
+但就算原本的hashCode()取的很好，每个key的hashCode()不同，但是由于HashMap的哈希桶的长度远比hash取值范围小，默认是16，所以当对hash值以桶的长度取余，以找到存放该key的桶的下标时，由于取余是通过与操作完成的，会忽略hash值的高位。      
+
+因此只有hashCode()的低位参加运算，发生不同的hash值，但是得到的index相同的情况的几率会大大增加，这种情况称之为hash碰撞。即碰撞率会增大。
+
+扰动函数就是为了解决hash碰撞的。它会综合hash值高位和低位的特征，并存放在低位，因此在与运算时，相当于高低位一起参与了运算，以减少hash碰撞的概率。（在JDK8之前，扰动函数会扰动四次，JDK8简化了这个操作）扩容操作时，会new一个新的Node数组作为哈希桶，然后将原哈希表中的所有数据(Node节点)移动到新的哈希桶中，相当于对原哈希表中所有的数据重新做了一个put操作。所以性能消耗很大，可想而知，在哈希表的容量越大时，性能消耗越明显。       
+
+扩容时，如果发生过哈希碰撞，节点数小于8个。则要根据链表上每个节点的哈希值，依次放入新哈希桶对应下标位置。因为扩容是容量翻倍，所以原链表上的每个节点，现在可能存放在原来的下标，即low位， 或者扩容后的下标，即high位。     
+
+high位= low位+原哈希桶容量,如果追加节点后，链表数量>=8，且只有数组长度大于64才处理，则转化为红黑树由迭代器的实现可以看出，遍历HashMap时，
 顺序是按照哈希桶从低到高，链表从前往后，依次遍历的。
 
 数组的特点：查询效率高，插入删除效率低。
@@ -70,7 +80,7 @@ HashMap在JDK1.8中发生了改变，下面的部分是基于JDK1.7的分析。H
 ```java
 transient Entry[] table;
 ```
-可以看到Map是通过数组的方式来储存Entry那Entry是神马呢？就是HashMap存储数据所用的类，它拥有的属性如下:   
+可以看到Map是通过数组的方式来储存Entry,那Entry是神马呢？就是HashMap存储数据所用的类，它拥有的属性如下:   
 ```java
 static class Entry implements Map.Entry {
     final K key;
@@ -177,12 +187,11 @@ public V get(Object key) {
 
 ## JDK1.8
 
-在Jdk1.8中HashMap的实现方式做了一些改变，但是基本思想还是没有变的，只是在一些地方做了优化，下面来看一下这些改变的地方,
-数据结构的存储由数组+链表的方式，变化为数组+链表+红黑树的存储方式，当链表长度超过阈值（8）时,且只有数组长度大于64才处理，将链表转换为红黑树。
-利用红黑树快速增删改查的特点来提高HashMap的性能，其中会用到红黑树的插入、删除、查找等算法。HashMap中，
-如果key经过hash算法得出的数组索引位置全部不相同，即Hash算法非常好，那样的话，getKey方法的时间复杂度就是O(1)，
-如果Hash算法技术的结果碰撞非常多，假如Hash算法极其差，所有的Hash算法结果得出的索引位置一样，那样所有的键值对都集中到一个桶中，
-或者在一个链表中，或者在一个红黑树中，时间复杂度分别为O(n)和O(lgn)。
+在Jdk1.8中HashMap的实现方式做了一些改变，但是基本思想还是没有变的，只是在一些地方做了优化，下面来看一下这些改变的地方,数据结构的存储由数组+链表的方式，变化为数组+链表+红黑树的存储方式，当链表长度超过阈值（8）时,且只有数组长度大于64才处理，将链表转换为红黑树。     
+
+利用红黑树快速增删改查的特点来提高HashMap的性能，其中会用到红黑树的插入、删除、查找等算法。     
+
+HashMap中，如果key经过hash算法得出的数组索引位置全部不相同，即Hash算法非常好，那样的话，getKey方法的时间复杂度就是O(1)，如果Hash算法技术的结果碰撞非常多，假如Hash算法极其差，所有的Hash算法结果得出的索引位置一样，那样所有的键值对都集中到一个桶中，或者在一个链表中，或者在一个红黑树中，时间复杂度分别为O(n)和O(lgn)。
 
 ![](https://raw.githubusercontent.com/CharonChui/Pictures/master/hashmap_data_structure.jpg)
 
diff --git "a/JavaKnowledge/JVM\345\236\203\345\234\276\345\233\236\346\224\266\346\234\272\345\210\266.md" "b/JavaKnowledge/JVM\345\236\203\345\234\276\345\233\236\346\224\266\346\234\272\345\210\266.md"
index 7c964b63..6e1a10a4 100644
--- "a/JavaKnowledge/JVM\345\236\203\345\234\276\345\233\236\346\224\266\346\234\272\345\210\266.md"
+++ "b/JavaKnowledge/JVM\345\236\203\345\234\276\345\233\236\346\224\266\346\234\272\345\210\266.md"
@@ -1,5 +1,41 @@
 # JVM垃圾回收机制
 
+
+当前主流的商用程序语言(Java、C#)的内存管理子系统都是通过可达性分析(Reachability Analysis)算法来判定对象是否存活的。      
+
+这个算法的基本思路就是通过一系列被称为"GC Roots"的根对象作为起始节点集，从这些节点开始，根据引用关系向下搜索，搜索过程所做过的路径称为"引用链"(Reference Chain)，
+如果某个对象到GC Roots间没有任何引用链相连，或者用图论的话来说就是从GC Roots到这个对象不可达时，则证明此对象是不可能再被使用的。  
+
+
+如下图:  对象object5、object6、object7虽然互有关联，但是它们到GC Roots是不可达的，因此它们将会被判定为可回收的对象。   
+
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/reachability_analysis.png)
+
+
+在Java技术体系里面，固定可作为GC Roots的对象包括以下几种:    
+
+- 在虚拟机栈(栈帧中的本地变量表)中引用的对象，譬如各个线程被调用的方法堆栈中使用到的参数、局部变量、临时变量等。   
+
+- 在方法区中类静态属性引用的对象，譬如Java类的引用类型静态变量。    
+
+- 在方法区中常量引用的对象，譬如字符串常量池(String Table)中的引用。   
+
+- 在本地方法栈中JNI(即通常所说的Native方法)引用的对象。    
+
+- Java虚拟机内部的引用，如基本数据类型对应的Class对象，一些常驻的异常对象(比如NullPointException、OutOfMemoryError)等，还有系统类加载器。   
+
+- 所有被同步锁(synchronized关键字)持有的对象。   
+
+- 反应Java虚拟机内部情况的JMXBean、JVMTI中注册的回调、本地代码缓存等。    
+
+
+除了这些固定的GC Roots集合以外，根据用户所选用的垃圾收集器以及当前回收的内存区域不同，还可以有其他对象“临时性”地加入，共同构成完整GC Roots集合。譬如后文将会提到的分代收集和局部回收(Partial GC)，如果只针对Java堆中某一块区域发起垃圾收集时（如最典型的只针对新生代的垃圾收集）​，必须考虑到内存区域是虚拟机自己的实现细节（在用户视角里任何内存区域都是不可见的）​，更不是孤立封闭的，所以某个区域里的对象完全有可能被位于堆中其他区域的对象所引用，这时候就需要将这些关联区域的对象也一并加入GC Roots集合中去，才能保证可达性分析的正确性。
+
+
+
+
+
 [Java内存模型](https://github.com/CharonChui/AndroidNote/blob/master/JavaKnowledge/Java%E5%86%85%E5%AD%98%E6%A8%A1%E5%9E%8B.md)如下图所示，**堆和方法区是所有线程共有的**，而虚拟机栈，本地方法栈和程序计数器则是线程私有的。
 
 ![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/jvm.png)
@@ -460,4 +496,4 @@ NUMA 是一种多核服务器的架构，简单来讲，一个多核服务器（
 ---
 
 - 邮箱 ：charon.chui@gmail.com  
-- Good Luck! 
\ No newline at end of file
+- Good Luck! 
diff --git "a/JavaKnowledge/Vim\344\275\277\347\224\250\346\225\231\347\250\213.md" "b/JavaKnowledge/Vim\344\275\277\347\224\250\346\225\231\347\250\213.md"
index 3c2cffc6..f749c763 100644
--- "a/JavaKnowledge/Vim\344\275\277\347\224\250\346\225\231\347\250\213.md"
+++ "b/JavaKnowledge/Vim\344\275\277\347\224\250\346\225\231\347\250\213.md"
@@ -3,27 +3,30 @@ Vim使用教程
 
 `Better, Stronger, Faster`
 
-首先`Vim`有两种模式: 
+首先`Vim`有三种模式: 
 
 - `Normal`            
     该模式下不能写入，修改要在该模式进行。在`Insert`模式中可以使用`ESC`键来返回到`Normal`模式。
 - `Insert`      
     该模式下可以进行写入。在`Normal`模式下使用按`i`键进行`Insert`模式。
+- `Visual`    
+    该模式是可视模式，可以选中， v进入字符可视模式。 V进入行可视模式。 `Ctrl+v`进入块可视模式。  
+
+    `Ctrl+v`进入后使用j/k选中多行同一列，按`I`输入内容，再按`ESC`键等一秒后会在所有选中行都插入该内容，是批量增加注释的神器。    
 	
-下面说一下`Normal`状态下的一些命令，所有的命令都要在`Normal`状态下执行：
+    下面说一下`Normal`状态下的一些命令，所有的命令都要在`Normal`状态下执行：
 
 进入`Insert`模式
 ---
 
+i进a追o开行,小写动作在光标，大写动作到行尾    
+
 - `i` 进入`insert`模式
 - `a(append)` 在光标后进行插入，直接进入`insert`模式
-- `o(open a line below)` 在当前行后插入一个新行，直接进入`insert`模式
-- `O` 大写的O是在光标所在的行下面插入一个新航，直接进入编译模式
-- `I` 从该行的最前面开始编辑
-- `A` 从该行的最后面开始编辑
-- `s` 删除光标后的字符，从光标当前位置插入
-- `S` 删除光标所在当前行，从行首插入
-- `cw` 替换从光标位置开始到该单词结束位置的所有字符，直接进入`Insert`模式
+- `o` 在下一行插入新行 
+- `O` 在上一行插入新行
+- `I` 在行首插入 
+- `A` 在行尾插入
 
 在VIM中，有相当一部分命令可以扩展为3部分：
 
@@ -42,27 +45,39 @@ Vim使用教程
 移动光标
 ---
 
-- `h` 左移
-- `j` 移到下一行
+
+
+
+- `h` 左移: 在键盘的最左边
+- `j` 移到下一行 : 像向下的钩子
 - `k` 移到上一行
-- `l` 右移
-- `gg` 移动到文章的开头
-- `G` 移动到当前文章的最后。
+- `l` 右移: 在键盘的最右边
 
-- `$` $光标移动当前行尾
-- `0` 数字0光标移动当前行首
+----
 
-- `e` 向右移动一个单词
-- `w` 向右移动一个单词，与e的区别是w是把光标放到下一个单词的开头，而e是把光标放到这一个单词的结尾。
-- `b` 移动到单词开始位置
+- `gg` 跳到文件开头
+- `G` 跳到文件结尾
+
+- `$` 行尾
+- `0` 行首
+- `^` 行首第一个非空字符
+
+- `e` 向右移动一个单词  (end)
+- `w` 向右移动一个单词，与e的区别是w是把光标放到下一个单词的开头，而e是把光标放到这一个单词的结尾。 (word)
+- `b` 移动到上一个单词开头  (back)
 - `:59` 移动到59行
 - `#l` 移动光标到该行第#个字的位置，如`5l`
+- `f字符` 跳到行内下一个指定字符，如fa 跳到下一个a
+
+
 - `ctrl+g` 列出当前光标所在行的行号等信息
-- `: #` 如输入: 15会跳到文章的第15行
-- `ctrl+b`:向上滚动一屏
-- `ctrl+f`:向下滚动一屏
-- `ctrl+u`:向上滚动半屏
-- `ctrl+d`:向下滚动半屏
+
+----- 
+
+- `ctrl+b`:向上滚动一屏  backward
+- `ctrl+f`:向下滚动一屏  forward
+- `ctrl+u`:向上滚动半屏   up 	
+- `ctrl+d`:向下滚动半屏   down 
 
 删除文字
 ---
@@ -72,9 +87,24 @@ Vim使用教程
 - `X` 大写的X为删除光标所在位置前的一个字符
 - `#X` 删除光标所在位置前的#个字符
 - `dd` 删除当前行，并把删除的行存到剪贴板中
+- `d$` 删除到行尾
+- `d0` 删除到行首
+- `dw` 删除一个单词
+- `di"` 删除双引号中的内容  delete inside 
+- `da"` 删除双引号中的内容以及双引号 delete all 
+- `di(` 删除括号中的内容
 - `#dd` 从光标所在行开始删除#行。如`5dd`就是删除5行
 - `v/ctrl+v`: 使用h、j、k、l移动选择内容，然后按d删除。其中v是非列模式，ctrl+v是列模式
 
+修改
+---   
+
+- `cc` 修改整行(清空并进入插入模式)
+- `cw` 修改一个单词
+- `c$` 修改到行尾
+
+
+
 复制粘贴
 ---
 
@@ -100,6 +130,10 @@ Vim使用教程
 - `:s/old/new/g` 光标所在行的所有old替换为new
 - `:s/old/new/` 光标所在行的第一个old替换为new
 
+记忆技巧: 
+百分号(%)斯(s)老(old)虎(new)狗(g)， s是substitute替换的意思, g是global全局的意思, c是confirm确认的意思。     
+
+
 撤销
 ---
 
@@ -109,10 +143,11 @@ Vim使用教程
 搜索
 ---
 
-- `/关键字` 先按`/`键，再输入您想寻找的字符，如果第一次找的关键字不是您想要的，可以一直按`n`会往后寻找到您要的关键字为止。
+- `/关键字` 先按`/`键，再输入您想寻找的字符，如果第一次找的关键字不是您想要的，可以一直按`n`会往后寻找到您要的关键字为止。N是上一个匹配。    
 
 - `?关键字` 同上，只不过`?`是往上查找
 
+
 缩进缩出
 ---
 
@@ -131,6 +166,42 @@ Vim使用教程
 - ZZ: 命令模式使用大写ZZ直接保存并退出
 
 
+单词记忆技巧
+---
+
+动词:   
+- d : 删除delte
+- y : 复制 yank
+- c : 修改 change
+- v : 选中 visual
+- p : 粘贴 paste
+
+名词:   
+
+- w : 单词 word
+- s : 句子 sentence
+- p : 段落 paragraph
+- i : 内部 inside
+- a : 整个 around
+
+
+
+
+----
+
+寄存器，Vim提供了很多寄存器，如果我们想要把vim中复制的内容放到系统的粘贴板中，
+就需要指定寄存器:   
+
+- `"+`: Linux/Windows/Mac通用
+
+例如:    
+
+- `"+yy`: 复制当前行内容到系统粘贴板
+- v选中内容后使用`"+y`复制选中内容到粘贴板
+
+
+
+
 
 
 
diff --git "a/JavaKnowledge/python3\345\205\245\351\227\250.md" "b/JavaKnowledge/python3\345\205\245\351\227\250.md"
new file mode 100644
index 00000000..35233217
--- /dev/null
+++ "b/JavaKnowledge/python3\345\205\245\351\227\250.md"
@@ -0,0 +1,1246 @@
+# python3入门
+
+## 变量
+
+```python
+message = "Hello World"
+print(message)
+```
+
+常量: python中一版约定名字全为大写的就是常量。   
+
+## bool
+
+
+bool类型只有True和False，用于真假判断。   
+
+python3中,bool是int的子类，True和False可以和数字相加。  
+
+True == 1、False == 0 会返回True
+
+is运算符用于比较两个对象的身份(即它们是否是同一个对象，是否在内存中占据相同的问题)，而不是比较它们的值。  
+
+```python3
+print(True == 1) # True
+print(False == 0) # True
+
+print(True is 1) # False
+print(False is 0) # False
+
+```
+
+
+在python中，能够解释为假的值不只有False，还有:   
+
+- None
+- 0
+- 0.0
+- False
+- 所有的空容器(空列表、空元组、空字典、空集合、空字符串)     
+
+## 字符串
+
+字符串就是一系列字符。在Python中，用引号括起来的都是字符串，其中的引号可以是单引号，也可以是双引号。例如:     
+```python
+message = 'Hello World'
+print(message)
+message = "Hello World"
+print(message)
+```
+
+### 大小写
+
+修改单词中的大小写:     
+
+- title()方法是以首字母大写的方式显示每个单词，即将每个单词的首字母都改为大写。   
+- upper()方法将字符串改为全部大写。
+- lower()方法将字符串改为全部小写。   
+
+```python
+message = 'hello world'
+print(message.title())
+# 输出结果为Hello World
+```
+
+注意上面方法lower、upper、title等不会修改存储在变量message中的值。
+
+### 拼接
+
+合并: Python使用加号(+)来合并字符串。这种合并字符串的方法称为拼接。   
+```python
+first_name = "ada"
+last_name = "lovelace"
+full_name = first_name + " " + last_name
+print(full_name)
+# 输出： ada lovelace
+```
+
+### 空格
+
+rstrip(): 去除字符串末尾空白。注意去除只是暂时的，等你再次访问该变量时，你会发现这个字符串仍然包含末尾空白。      
+要永久删除这个字符串中的空白，必须将删除的结果存回到变量中:   
+
+
+first_name = "ada  "
+print(first_name)
+first_name = first_name.rstrip()
+print(first_name)
+
+- lstrip(): 去除字符串开头空白       
+- strip(): 同时去除字符串两端的空白      
+
+
+## 整数
+
+
+可对整数执行加(+)、减(-)、乘(`*`)、除(/)运算。     
+
+Python使用两个乘号表示乘方运算。
+
+
+## 浮点数
+
+在Python中将带小数点的数字都称为浮点数。          
+但是要注意的是，结果包含小数位数可能是不确定的，例如:     
+```python
+>>> 0.2 + 0.1
+0.30000000000000004
+```
+
+命令行执行python后执行exit()或quit()可退出。     
+
+## 类型转换
+
+```python
+age = 23
+message = "Happy" + age + "Birthday"
+print(message)
+```
+
+执行时会报错：  
+```python
+message = "Happy" + age + "Birthday"
+              ~~~~~~~~^~~~~
+TypeError: can only concatenate str (not "int") to str
+```
+
+类型错误，这个时候需要显式的指定希望Python将这个整数用作字符串。      
+为此，可调用函数str()，它让Python将非字符串值表示为字符串： 
+
+```python
+age = 23
+message = "Happy" + str(age) + "Birthday"
+print(message)
+```
+
+### 自动类型转换(隐式转换)
+
+对两种不同类型的数据进行运算，较小的数据类型(整数)就会转换为较大的数据类型(浮点数)以免数据丢失，计算结果为浮点型:  
+
+```python3
+num1 = 2
+num2 = 3.0
+
+print(num1 + num2) # 5.0
+
+
+
+num1 = 9
+num2 = 1
+print(num1 / num2) #9.0
+```
+注意: 特别的，两个整形进行除法运算时结果也是浮点型。  
+
+
+
+
+
+
+
+
+
+
+
+## 注释
+
+使用井号(#)标识注释
+
+
+## 列表
+
+在Python中，用方括号[]来表示列表，并用逗号来分割其中的元素。   
+```python
+bicycles = ['trek', 'cannondale', 'redline', 'specialized']
+print(bicycles)
+print(bicycles[0])
+print(bicycles[-1])
+# 设置最后一个元素
+bicycles[-1] = 'honda'
+# 在列表最后添加元素
+bicycles.append('ducati')
+# 在某个位置添加元素
+bicycles.insert(0, 'a')
+print(bicycles)
+# 删除某个位置的元素
+del bicycles[0]
+# 删除最后一个元素，并返回删除的值
+popValue = bicycles.pop()
+print(popValue)
+# 通过值删除元素，如果列表中有多个重复的元素，那该方法只会删除第一个指定的值
+bicycles.remove('trek')
+# 排序
+bicycles.sort()
+# 反序排序
+bicycles.sort(reverse=True)
+```
+Python为访问最后一个列表元素提供了一种特殊的语法，通过将索引指定为-1，可让Python返回最后一个列表元素。      
+这是为了方便在不知道列表长度的情况下访问最后的元素。     
+这种约定也适用于其他负数索引，例如，索引-2返回倒数第二个列表元素，索引-3返回倒数第三个列表元素，以此类推。   
+
+### 临时排序
+
+要保留列表元素原来的排列顺序，同时以特定的顺序呈现它们，可使用函数sorted()。       
+函数sorted()让你能够按特定顺序显示列表元素，同时不影响它们在列表中的原始排列顺序。   
+
+```python
+bicycles = ['trek', 'cannondale', 'redline', 'specialized']
+bicycles.sort(reverse=True)
+# ['trek', 'specialized', 'redline', 'cannondale']
+print(bicycles)
+# ['cannondale', 'redline', 'specialized', 'trek']
+print(sorted(bicycles))
+# ['trek', 'specialized', 'redline', 'cannondale']
+print(bicycles)
+```
+
+
+### 反转列表
+
+```python
+bicycles = ['trek', 'cannondale', 'redline', 'specialized']
+bicycles.reverse()
+print(bicycles)
+# 列表长度
+size = len(bicycles)
+print(size)
+```
+
+### 遍历
+
+**Python根据缩进来判断代码行与前一个代码行的关系，在较长的Python程序中，你将看到缩进程度各不相同的代码块，这让你对程序的组织结构有大致的认识**
+
+
+注意:    
+
+- for in 后有个冒号`:`，for语句末尾的冒号告诉Python，下一行是循环的第一行。    
+- 前面缩进的代码才是for循环中的部分
+- 没有缩进的是for循环之外的
+
+
+```python
+bicycles = ['trek', 'cannondale', 'redline', 'specialized']
+for bcy in bicycles:
+    print(bcy)
+    print(bcy.title())
+print('end')
+```
+
+#### 使用enumerate()可以同时获取列表的下标和元素。
+
+```python
+lst = [1, 2, 3]
+
+for i, value in enumerate(lst):
+    print(i, value)
+```
+
+
+### 切片
+
+你还可以处理列表的部分元素——Python称之为切片。
+要创建切片，可指定要使用的第一个元素和最后一个元素的索引。
+你可以生成列表的任何子集，例如，如果你要提取列表的第2～4个元素，可将起始索引指定为1，并将终止索引指定为4：
+
+```python
+players = ['charles','martina','michael','florence','eli']
+print(players[1:4])
+```
+
+例如，如果要提取从第3个元素到列表末尾的所有元素，可将起始索引指定为2，并省略终止索引
+
+
+### range函数
+
+range()函数能够生成一系列的数字，例如range(1, 5)会生成1  2  3  4。     
+要创建数字列表，可使用函数list()将range()的结果直接转换为列表:    
+```ptyhon
+numbers = list(range(1, 5))
+print(numbers)
+
+# 
+print(min(numbers))
+print(max(numbers))
+print(sum(numbers))
+
+```
+
+
+## 元组(不可变的列表)
+
+有时候你需要创建一系列不可修改的元素，元组可以满足这种需求。Python将不能修改的值称为不可变的，而不可变的列表被称为元组。
+元组看起来犹如列表，但使用圆括号而不是方括号来标识。定义元组后，就可以使用索引来访问其元素，就像访问列表元素一样。
+元组中的元素不能修改，访问和遍历都和列表一样。
+
+
+相对于列表，元组是更简单的数据结构。       
+如果需要存储的一组值在程序的整个生命周期内都不变，可使用元组。    
+
+
+
+## if语句
+
+```python
+cars = ['audi', 'bmd', 'toyota']
+for car in cars:
+    if car == 'toyota':
+        print(car.upper())
+    else:
+        print(car.title())
+```
+每条if语句的核心都是一个值为True或False的表达式，这种表达式被称为条件测试。 
+
+
+```python
+age = 12
+if age < 4:
+    print("cost $0")
+elif age < 18:
+    print("cost $5")
+else:
+    print("cost $10")
+```
+
+### match case语句
+
+```python3
+match x:
+    case a:
+        xxxx
+    case b:
+        xxxx
+    case _:
+        xxx
+```
+在python3.10版本新增了match case的条件判断方式，match后的对象会依次与case后的内容匹配，匹配成功则执行相应的语句，否则跳过，其中_可以匹配一切。  
+
+
+### 相等判断
+```python
+car = 'Audi'
+# False
+car == 'audi'
+```
+
+Python中使用两个等号(==)检测值是否相等，在Python中检测是否相等时区分大小写。   
+
+判断两个值不相等，可结合使用惊叹号和等号(!=)来判断。   
+
+条件语句中可包含各种数学比较，如小于<、小于等于<=、大于>、大于等于>=。   
+
+### 多条件检测
+
+有时候需要判断两个条件都为True或只要求一个条件为True时就执行相应的操作。     
+
+在这些情况下，可以使用关键字and和or。    
+
+### 值是否包含在列表中
+
+要判断特定的值是否已包含在列表中，可使用关键字in。       
+```python
+cars = ['audi', 'bmd', 'toyota']
+# True
+print('audi' in cars)
+
+# False
+print('audi' not in cars)
+```
+
+
+## 字典(Key-Value)
+
+在Python中，字典是一系列键-值对。字典用放在花括号{}中的一些列键-值对表示。           
+每个键都与一个值相关联，你可以使用键来访问与之相关联的值。      
+与键相关联的值可以是数字、字符串、列表乃至字典。事实上，可将任何Python对象用作字典中的值。     
+
+```python
+alien = {'color': 'blue', 'points': 5}
+# 取值
+print(alien['color'])
+print(alien['points'])
+# 添加值
+alien['xPos'] = 10
+alien['yPos'] = 20
+print(alien['xPos'])
+del alien['points']
+```
+
+字典的其他写法:   
+
+```python3
+dict4 = dict(name="Bob", age=20, gender="female")
+dict5 = dict([("name", "Tom"), ("age", 22), ("gender", "male")])
+```
+
+
+### 遍历字典
+
+- keys()方法返回所有的键列表。
+- items()方法返回一个键-值对列表。    
+- values()方法返回一个值列表。  
+
+```ptyhon
+alien = {'color': 'blue', 'points': 5}
+
+for key,value in alien.items(): 
+    print("key: " + key)
+    print("value: " + str(value))
+
+
+for key in alien.keys(): 
+    print("key: " + key)    
+```
+字典总是明确地记录键和值之间的关联关系，但获取字典的元素时，获取顺序是不可预测的。      
+
+这不是问题，因为通常你想要的只是获取与键相关联的正确的值。     
+
+要以特定的顺序返回元素，一种方法是在for循环中对返回的键进行排序。。    
+
+为此，可使用函数sorted()来获得特定顺序排列的键列表的副本:     
+```python
+favorite_languages = {
+    'jen':'python',
+    'sarah':'c',
+    'edward':'ruby',
+    'phil':'python',
+    }
+for name in sorted(favorite_languages.keys()):
+    print(name.title()+",thank you for taking the poll.")
+```
+
+```python
+favorite_languages = {
+    'jen':'python',
+    'sarah':'c',
+    'edward':'ruby',
+    'phil':'python',
+    }
+print("The following languages have been mentioned:")
+for language in favorite_languages.values():
+    print(language.title())
+```
+
+这种做法提取字典中所有的值，而没有考虑是否重复。涉及的值很少时，这也许不是问题，但如果被调查者很多，最终的列表可能包含大量的重复项。为剔除重复项，可使用集合(set)。集合类似于列表，但每个元素都必须是独一无二的：
+```python
+favorite_languages = {
+    'jen':'python',
+    'sarah':'c',
+    'edward':'ruby',
+    'phil':'python',
+    }
+print("The following languages have been mentioned:")
+for language in set(favorite_languages.values()):❶
+    print(language.title())
+```
+通过对包含重复元素的列表调用set()，可让Python找出列表中独一无二的元素，并使用这些元素来创建一个集合。
+
+## 用户输入
+
+函数input()让程序暂停运行，等待用户输入一些文本。     
+
+获取用户输入后，Python将其存在一个变量中，以方便你使用。   
+```python3
+age = input("How old are you?")
+print(age)
+```
+用户输入的是数字21，但我们请求Python提供age的值时，它返回的是`'21'`(用户输入的数值的字符串表示)。    
+
+为了解决这个问题，可以使用函数int()：将数字的字符串表示转换为数值表示，如:  
+```python
+age = input("Please Input")
+print(age)
+# print(age >= 18)  报错
+age = int(age)
+print(age >= 18)
+```
+
+## while
+
+```python
+current_number = 1
+while current_number <= 5:
+    print(current_number)
+    current_number+= 1
+```
+
+同样while中也可以结合使用break、continue等，和Java基本一样。  
+
+## 缩进
+
+在python3中，代码块的结束不像其他一些编程语言(如c、java等)使用大括号{}来明确界定，而是通过缩进来表示。PEP8建议每级缩进都使用四个空格。
+
+
+## 函数
+
+使用关键字def来定义一个函数，定义以冒号结尾。      
+跟在def xxx:后面的所有缩进行构成了函数体。   
+
+```python
+def greet_user(username): 
+    """函数功能的注释"""
+    # 返回值
+    return 'Hello ' + username 
+
+# 调用函数    
+print(greet_user('jack')) 
+print(greet_user(username='lili'))
+```
+同样，在Python中函数也支持参数的默认值。   
+
+上面三个引号的部分是文档字符串格式，用于简要的阐述其功能的注释。     
+
+### 函数的参数传递
+
+- 不可变类型     
+    类似c++的值传递，如整数、字符串、元祖。如fun(a)，传递的只是a的值，没有影响a对象本身，比如在fun(a)内部修改a的值，只是修改了另一个复制的对象，不会影响a本身。 
+- 可变类型    
+    类似c++的引用传递，如列表、字典。如fun(la)，则是将la真正的传过去，修改后fun外部的la也会受影响  
+
+
+python中一切都是对象，严格意义上我们不能说值传递还是引用传递，我们应该说传可变对象和不可变对象。   
+
+
+
+### 函数列表参数副本
+
+将列表传递给函数后，函数就可对其进行修改。在函数中对这个列表所做的任何修改都是永久性的，这让你能够高效地处理大量的数据。
+
+但是有些时候我们并不想让函数修改原始的列表。  
+
+为解决这个问题，可向函数传递列表的副本而不是原件；这样函数所做的任何修改都只影响副本，而丝毫不影响原件。
+
+要将列表的副本传递给函数，可以像下面这样做：
+```
+function_name(list_name[:])
+```
+
+切片表示法[:]创建列表的副本。
+
+### 函数不定参数
+
+有时候，你预先不知道函数需要接受多少个实参，Python允许函数从调用语句中收集任意数量的实参。  
+```python
+def make_pizza(*toppings):
+    """打印顾客点的所有配料"""
+    print(toppings)
+make_pizza('pepperoni')
+make_pizza('mushrooms','green peppers','extra cheese')
+```
+形参名`*toppings`中的星号让Python创建一个名为toppings的空元组，并将收到的所有值都封装到这个元组中。
+
+现在，我们可以将这条print语句替换为一个循环，对配料列表进行遍历，并对顾客点的比萨进行描述：
+
+```python
+def make_pizza(*toppings):
+    """概述要制作的比萨"""
+    print("\nMaking a pizza with the following toppings:")
+    for topping in toppings:
+        print("- "+topping)
+make_pizza('pepperoni')
+make_pizza('mushrooms','green peppers','extra cheese')
+```
+
+
+简单来说，Python中所有的函数参数传递，统统都是基于传递对象的引用进行的。这是因为，在Python中，一切皆对象。而传对象，实质上传的是对象的内存地址，而地址即引用。
+
+
+看起来，Python的参数传递方式是整齐划一的，但具体情况还得具体分析。在Python中，对象大致分为两类，即可变对象和不可变对象。可变对象包括字典、列表及集合等。不可变对象包括数值、字符串、不变集合等。如果参数传递的是可变对象，传递的就是地址，形参的地址就是实参的地址，如同“两套班子，一套人马”一样，修改了函数中的形参，就等同于修改了实参。如果参数传递的是不可变对象，为了维护它的“不可变”属性，函数内部不得不“重构”一个实参的副本。此时，实参的副本（即形参）和主调用函数提供的实参在内存中分处于不同的位置，因此对函数形参的修改，并不会对实参造成任何影响，在结果上看起来和传值一样。
+
+
+### 解包传参
+
+若函数的形参是定长参数，可以通过`*`和`**`对列表、元组、字典等解包传参。  
+
+```python3
+def func(a, b, c):
+    return a + b + c
+
+tuple1 = (1, 2, 3)
+
+print(func(*tuple))
+dict1 = {"a":1, "b":2, "c":3}
+
+print(func(**dict1))
+``` 
+
+
+
+### 将函数存储在模块中
+
+函数的优点之一是，使用它们可将代码块与主程序分离。通过给函数指定描述性名称，可让主程序容易理解得多。你还可以更进一步，将函数存储在被称为模块的独立文件中，再将模块导入到主程序中。import语句允许在当前运行的程序文件中使用模块中的代码。
+
+
+要让函数是可导入的，得先创建模块。模块是扩展名为.py的文件，包含要导入到程序中的代码。下面来创建一个包含函数make_pizza()的模块。为此，我们将文件pizza.py中除函数make_pizza()之外的其他代码都删除：
+
+```python
+# pizza.py
+
+def make_pizza(size,*toppings):
+    """概述要制作的比萨"""
+    print("\nMaking a "+str(size)+
+          "-inch pizza with the following toppings:")
+    for topping in toppings:
+        print("- "+topping)
+```
+
+接下来，我们在pizza.py所在的目录中创建另一个名为making_pizzas.py的文件，这个文件导入刚创建的模块，再调用make_pizza()两次：
+
+```python
+# making_pizzas.py
+import pizza
+pizza.make_pizza(16,'pepperoni') ❶
+pizza.make_pizza(12,'mushrooms','green peppers','extra cheese')
+
+```
+Python读取这个文件时，代码行import pizza让Python打开文件pizza.py，并将其中的所有函数都复制到这个程序中。你看不到复制的代码，因为这个程序运行时，Python在幕后复制这些代码。你只需知道，在making_pizzas.py中，可以使用pizza.py中定义的所有函数。
+
+你还可以导入模块中的特定函数，这种导入方法的语法如下：
+`from modulname import funcxx`
+
+```python
+from pizza import make_pizza
+make_pizza(16,'pepperoni')
+make_pizza(12,'mushrooms','green peppers','extra cheese')
+```
+若使用这种语法，调用函数时就无需使用句点。由于我们在import语句中显式地导入了函数make_pizza()，因此调用它时只需指定其名称。
+
+还可以使用星号(`*`)导入模块中的所有函数:     
+
+```python
+from pizza import *
+make_pizza(16,'pepperoni')
+make_pizza(12,'mushrooms','green peppers','extra cheese')
+```
+`import *`会将模块pizza中的每个函数都复制到这个程序文件中。      
+由于导入了每个函数，可通过名称来调用每个函数，而无需使用句点表示法。      
+然而，使用并非自己编写的大型模块时，最好不要采用这种导入方法： 如果模块中有函数的名称与你的项目中使用的名称相同，可能导致意想不到的结果，因为Python可能遇到多个名称相同的函数或变量，进而覆盖函数，而不是分别导入所有的函数。   
+
+
+### 别名
+
+如果要导入的函数的名称与现有的名称冲突，或者函数的名称太长，可以通过别名的方式进行指定。
+
+```python
+from pizza import make_pizza as mp
+mp(16,'pepperoni')
+mp(12,'mushrooms','green peppers','extra cheese')
+```
+
+同样也可以通过as给模块指定别名:   
+
+```python
+import pizza as p
+
+p.make_pizza(16,'pepperoni')
+p.make_pizza(12,'mushrooms','green peppers','extra cheese')
+```
+
+### __name__
+
+在python中，__name__是一个特殊的内置变量:    
+
+- 当一个python文件被直接运行时，该文件的__name__属性为"__main__"
+- 当一个python文件作为模块被导入时，__name__属性会被设置为该模块的名称(即文件名，不包括.py后缀)
+
+例如有时我们在模块中写一些测试代码，当模块被其他文件导入时这些测试代码会被执行。
+例如我们在main.py中导入my_add.py中，会发现my_add中的测试代码被执行了。这个时候使用__name__ == "__main__"判断就能避免测试代码被执行。  
+
+
+
+
+
+
+### 全局变量和局部变量
+
+
+定义在函数内部的变量拥有一个局部作用域，定义在函数外的变量拥有全局作用域，局部变量只能在其被声明的函数内部访问，而全局变量可以在整个程序范围内访问。   
+
+#### global关键字
+
+使用global关键字修改全局变量
+```python
+def function_a():
+    global var1
+    var1 = 200
+    print("var1:", var1)
+
+var1 = 100
+
+```
+当全局变量为可变类型时，函数内部使用global声明，也可以对其进行修改。  
+```python
+def function_a():
+    list1[0] = 1000
+
+list1 = [1, 2, 3]
+```
+在函数中不使用global声明全局变量时不能修改全局变量的本质是不能修改全局变量的指向，即不能将全局变量指向新的数据。    
+
+- 不可变类型的全局变量其指向的数据不能修改，所以部使用global无法修改全局变量。
+- 可变类型的全局变量其指向的数据可以修改，所以不使用global也可修改全局变量。 
+
+#### nonlocal关键字
+
+nonlocal也用作内部作用域修改外部作用域的变量的场景，不过此时外部作用域不是全局作用域，而是嵌套作用域
+
+```python
+def function_outer():
+    var = 1
+    print(var)
+
+    def function_inner():
+        nonlocal var
+        var = 200
+    function_inner()
+    print(var)
+
+
+function_outer()
+```
+
+
+
+## 类 
+
+在Python中，首字母大写的名称指的是类。  
+根据类来创建对象叫实例化。   
+
+dog.py
+```python
+class Dog:
+    home = "xx"    # 类属性
+
+    def __init__(self, name, age):
+        self.name = name  # 实例属性
+        self.age = age
+
+    def sit(self):
+        print(self.name + " Sitting")
+
+    def roll(self):
+        print(self.name + " Rolling")
+```
+
+__init__()是一个特殊的方法(构造方法)，每当你根据Dog类创建新实例时，Python都会自动运行它(__init__()方法的调用时机在实例(通过__new__()被创建之后，返回调用者之前调用，一般用于初始化一些数据))。在这个方法中形参self必不可少，还必须位于其他形参的前面。        
+
+为什么必须在方法定义中包含形参self呢？因为Python调用这个__init__()方法来创建Dog实例时，将自动传入实参self。    
+
+每个与类相关联的方法调用都自动传入实参self，它是一个指向实例本身的引用，让实例能够访问类中的属性和方法。         
+
+
+
+```python
+import dog
+
+dog = dog.Dog("xiaohei", 1)
+# 属性
+print(dog.name)
+# 方法
+dog.sit()
+```
+
+类属性可以直接通过类名.类属性调用也可以通过实例对象.类属性调用，如`Dog.home或dog.home`
+
+```python
+class Person:
+    home = "class home"
+
+    def __init__(self, name) -> None:
+        self.name = name
+
+
+person = Person("name")
+print(person.name)
+print(person.home)
+person.home = "object home"
+print(person.home)
+print(Person.home)
+Person.home = "new class home"
+print(Person.home)
+
+# 结果
+name
+class home
+object home
+class home
+new class home
+
+```
+可以看到所有类的实力都会共享同一个类属性，如果通过对象实例.类属性调用则会直接创建一个实例属性(并不是修改了类属性的值)
+
+#### 动态添加属性和方法
+
+```python
+class Person:
+    def __init__(self, name: str) -> None:
+        self.name = name
+
+p = Person("John")
+p.age = 20
+print(p.name)
+print(p.age)
+
+```
+
+
+
+### 方法
+
+Python的类中有三种方法: 实例方法、静态方法、类方法。   
+
+- 实例方法在类中定义，第一个参数是self,代表实例本身
+- 实例方法只能被实例对象调用
+- 可以访问实例属性、类属性、类方法
+
+#### 类方法
+
+- 类方法通过@classmethod标注，方法的第一个参数是cls
+- 类方法可以通过类来调用也可以通过实例来调用
+- 可以访问类属性
+- 类方法可以在不创建实例的情况下调用，通过类名直接调用，非常方便，适合一些和类整体相关的操作
+
+
+```python
+class Dog:
+
+    @classmethod
+    def wangwang(cls):
+        print"wangwang"
+
+
+```
+
+#### 静态方法
+
+- 静态方法通过@staticmethod定义
+- 不访问实例属性或类属性，只依赖传入的参数
+- 可以通过类名或实例调用，但它不会访问类或实例的内部信息，更像一个工具函数
+
+
+#### 特殊方法
+
+
+方法名中有两个前缀下划线和两个后缀下划线的方法为特殊方法，也叫魔法方法。   
+上面的__init__()就是一个特殊方法，这些方法会在进行特定的操作时自动被调用。   
+
+几个常见的特殊方法:    
+
+- __new__(): 对象实例化时第一个调用的方法
+- __init__(): 类的初始化方法
+- __del__(): 对象的销毁器，定义了当对象被垃圾回收时的行为，使用del xxx时不会主动调用__del__()，除非此时引用计数=0
+- __str__(): 定义了对类的实例调用str()时的行为
+- __repr__(): 定义了对类的实例调用repr()时的行为，str()和repr()最主要的差别在于目标用户。repr()的作用是产生机器可读的输出，而str()则产生人类可读的输出。 
+- __getattribute__():属性访问拦截器，定义了属性被访问前的操作。  
+
+
+
+
+
+
+### 继承
+
+一个类继承另一个类时，它将自动获得另一个类的所有属性和方法。       
+
+创建子类实例时，Python首先需要完成的任务是给父类的所有属性赋值。因此，子类的__init__()方法需要调用父类的方法。   
+
+```python
+class Car:
+    def __init__(self, make, model, year):
+        self.make = make
+        self.model = model
+        self.year = year
+
+    def get_des(self):
+        name = str(self.year) + str(self.make) + str(self.model)
+        return name.title()
+
+
+class ElectricCar(Car):
+    def __init__(self, make, model, year, battery):
+        super().__init__(make, model, year)
+        self.battery = battery
+
+    # 重写父类方法
+    def get_des(self):
+        name = str(self.year) + str(self.make) + str(self.model) + str(self.battery)
+        return name.title()
+    def get_battery(self):
+        print("battery : " + str(self.battery))
+
+
+tesla = ElectricCar('Tesla', 'Model S', 2021, 80)
+print(tesla.get_des())
+tesla.get_battery()
+```
+
+- 创建子类时，父类必须包含在当前文件中，且位于子类前面。        
+- 定义子类时，必须在括号内指定父类的名称
+- 方法__init__()接受创建子类实例所需的信息
+
+super()是一个特殊函数，帮助Python将父类和子类关联起来。这行代码让子类包含父类的所有属性。 
+
+
+多继承: 调用方法时先在子类中查找，若不存在则从左到右依次查找父类中是否包含方法。    
+
+#### 私有属性和方法
+
+有时为了限制属性和方法只能在类内访问，外部无法访问。或父类中某些属性和方法不希望被子类继承，可以将其私有化:    
+
+- 单下划线: 非公开API
+
+    大多数python代码都遵循这样一个约定，有一个前缀下划线的变量或方法应被视为非公开的API，例如_var1。但这种约定不具有强制力。    
+
+- 双下划线: 名称改写
+    有两个前缀下划线，并至多一个后缀下划线的标识符，例如__x，会被改写为_类名__x，只有在类内部可以通过__x访问，其他地方无法访问或只能通过_类名__x访问。    
+
+
+#### property装饰器
+
+可通过@property装饰器将一个方法转换为属性来调用。转换后可直接使用.方法名来使用，而无需使用.方法名()。  
+
+注意: @property修饰的方法不要和变量重名，否则可能导致无限递归
+#### 只读属性
+
+```python
+class Person:
+    def __init__(self, name: str) -> None:
+        self.__name = name
+
+    @property
+    def name(self):
+        return self.__name
+
+p = Person("zhangsan")
+print(p.name)
+
+.name = "lisi" # 报错
+```
+
+#### 读写属性
+
+使用属性名.setter装饰
+
+```python
+class Person:
+    def __init__(self, name: str) -> None:
+        self.__name = name
+
+    @property
+    def name(self):
+        return self.__name
+
+    @name.setter
+    def name(self, name: str) -> None:
+        self.__name = name
+        
+p = Person("zhangsan")
+print(p.name)
+
+p.name = "lisi"
+print(p.name)
+```
+
+
+
+
+## 标准库
+
+Python标准库是一组模块，安装的Python都包含它。
+类名应采用驼峰命名法，即将类名中的每个单词的首字母都大写，而不使用下划线。实例名和模块名都采用小写格式，并在单词之间加上下划线。
+每个模块也都应包含一个文档字符串，对其中的类可用于做什么进行描述。
+
+
+### 读取文件
+
+一次性读取整个文件:          
+```python
+with open('test.txt') as file_object:
+    contents = file_object.read()
+    print(contents)
+```
+
+要以每次一行的方式检查文件，可对文件对象使用for循环:     
+
+```python
+filename = 'test.txt'
+with open(filename) as file_object:
+    for line in file_object:
+        print(line)
+```    
+这里使用了关键字with，让Python负责妥善地打开和关闭文件。       
+使用关键字with时，open()返回的文件对象只在with代码块内可用。
+
+
+要将文本写入文件，你在调用open()时需要提供另一个实参，告诉Python你要写入打开的文件。
+
+```python
+filename = 'test.txt'
+
+with open(filename, 'w') as fo:
+    fo.write("Hello World")
+```    
+调用open()时提供了两个实参:       
+
+- 第一个实参是要打开的文件的名称
+- 第二个实参('w')告诉Python，我们要以写入模式打开这个文件。
+
+打开文件时，可指定读取模式('r')、写入模式('w')、附加模式('a')或让你能够读取和写入文件的模式('r+')。如果你省略了模式实参，Python将以默认的只读模式打开文件。      
+如果你要写入的文件不存在，函数open()将自动创建它。然而，以写入('w')模式打开文件时千万要小心，因为如果指定的文件已经存在，Python将在返回文件对象前清空该文件。    
+注意　Python只能将字符串写入文本文件。要将数值数据存储到文本文件中，必须先使用函数str()将其转换为字符串格式。
+
+如果你要给文件添加内容，而不是覆盖原有的内容，可以附加模式打开文件。你以附加模式打开文件时，Python不会在返回文件对象前清空文件，而你写入到文件的行都将添加到文件末尾。如果指定的文件不存在，Python将为你创建一个空文件。   
+
+
+### 异常
+
+异常是使用try-except代码块处理的。try-except代码块让Python执行指定的操作，同时告诉Python发生异常时怎么办。使用了try-except代码块时，即便出现异常，程序也将继续运行：显示你编写的友好的错误消息，而不是令用户迷惑的traceback。
+
+```python
+try:
+    可能发生异常的代码
+except 异常类型1 as 变量名1:
+    异常1处理代码
+except 异常类型2 as 变量名2: 
+    异常2处理代码
+else: 
+    没有异常时执行的代码
+finally:
+    无论是否发生异常都会执行的代码 
+```
+
+#### 抛出异常
+
+当想在代码中明确表示发生了错误或异常时，可以使用raise来抛出异常。
+```python
+def int_add(a, b):
+    if isinstance(a, int) and isinstance(b, int):
+        return a + b
+    else:
+        raise TypeError("参数类型错误")
+```
+
+### with关键字
+
+
+python中的with语句用于异常处理，封装了try except finally编码范式，提供了一种简洁的方式来确保资源的正确获取和释放，同时处理可能发生的异常，提高了易用性，使代码更清晰、更具可读性，简化了文件流等公共资源的管理   
+
+```python
+with expression as variable:     
+    # 代码块
+```
+
+- expression: 通常是一个对象或函数调用，该对象需要一个上下文管理器，即实现了__enter__和__exit__方法
+
+- variable: 是可选的，用于存储expression的__enter__方法的返回值。     
+
+工作原理:   
+
+- 使用with关键字系统会自动调用f.close()方法，with的作用等效于try finally语句。 - 当执行with语句时，会调用expression对象的__enter__方法
+- __enter__方法的返回值可以被存储在variable中(如果有)，以供with代码块中使用  
+- 然后执行with语句内部的代码块
+- 无论在代码块中是否发生异常，都会调用expression对象的__exit__方法，以确保资源的释放或清理工作，这类似于try - except -finally中的finally语句。   
+
+
+
+
+
+### 分割字符串
+
+方法split()以空格为分隔符将字符串分拆成多个部分，并将这些部分都存储到一个列表中。
+
+```python
+title = "Alice in Wonderland"
+title.split()
+```
+
+['Alice','in','Wonderland']
+
+
+### pass
+
+Python有一个pass语句，可在代码块中使用它来让Python什么都不要做。    
+
+```python
+def donothing():    
+    pass    #空语句
+
+```
+
+
+pass语句如果啥事都不做，那要它有何用呢？实际上，pass可以作为一个占位符来用——视为未成熟代码的“预留地”。比如说，如果我们还没想好函数的内部实现，就可以先放一个pass，让代码先跑起来。
+
+### json
+
+函数json.dump()接受两个实参：要存储的数据以及可用于存储数据的文件对象。下面演示了如何使用json.dump()来存储数字列表：
+
+```python
+import json
+numbers = [2,3,5,7,11,13]
+filename = 'numbers.json'
+with open(filename,'w') as f_obj:
+    json.dump(numbers,f_obj) 
+```
+
+使用json.load()将这个列表读取到内存中：
+```python
+import json
+filename = 'numbers.json'
+with open(filename) as f_obj:
+    numbers = json.load(f_obj) 
+print(numbers)
+```
+
+### 网络请求
+
+Web API是网站的一部分，用于与使用非常具体的URL请求特定信息的程序交互。这种请求称为API调用。请求的数据将以易于处理的格式（如JSON或CSV）返回。依赖于外部数据源的大多数应用程序都依赖于API调用，如集成社交媒体网站的应用程序。
+
+
+
+requests包让Python程序能够轻松地向网站请求信息以及检查返回的响应。要安装requests，请执行类似于下面的命令：
+
+$pip install --user requests
+或者直接在ide中点击修复安装就可以:  
+
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/python_install_requests.png)
+
+```python
+import requests
+# 执行API调用并存储响应
+url = 'https://api.github.com/search/repositories?q=language:python&sort=stars'
+r = requests.get(url)
+print("Status code:",r.status_code)
+# 将API响应存储在一个变量中
+response_dict = r.json()
+# 处理结果
+print(response_dict.keys())
+```
+
+执行结果为:    
+```
+Status code: 200
+dict_keys(['total_count', 'incomplete_results', 'items'])
+```
+
+这个API返回JSON格式的信息，因此我们使用方法json()将这些信息转换为一个Python字典。我们将转换得到的字典存储在response_dict中。
+最后，我们打印response_dict中的键。
+
+
+
+
+在Python中，还可以定义可变参数。可变参数也称不定长参数，即传入函数中的实际参数可以是零个、一个、两个到任意个。
+
+Python中的可变参数的表现形式为，在形参前添加一个星号（*），意为函数传递过来的实参个数不定，可能为0个、1个，也可能为n个（n≥2）。需要注意的是，不管可变参数有多少个，在函数内部，它们都被“收集”起来并统一存放在以形参名为某个特定标识符的元组之中。因此，可变参数也被称为“收集参数”。
+
+
+除了用单个星号（*）表示可变参数，其实还有另一种标定可变参数的形式，即用两个星号（**）来标定。通过前文的介绍，我们知道，一个星号（*）将多个参数打包为一个元组，而两个星号（**）的作用是什么呢？它的作用就是把可变参数打包成字典模样。
+
+这时调用函数则需要采用如“arg1=value1,arg2=value2”这样的形式。等号左边的参数好比字典中的键（key）[插图]，等号右边的数值好比字典中的值（value）​，
+
+```python
+def varFun(**x): 
+    if len(x) == 0:
+        print("None")
+    else:
+        print(x)
+
+
+varFun(a = 1, b = 3)
+
+
+```
+
+定义可变参数时，主要有两种形式，一种是*parameter，另一种是**parameter。下面分别进行介绍。
+1．*parameter
+这种形式表示接收任意多个实际参数并将其放到一个元组中。
+2．**parameter
+这种形式表示接收任意多个类似关键字参数一样显式赋值的实际参数，并将其放到一个字典中。
+
+
+除了用等号给可变关键字参数赋值，事实上，我们还可以直接用字典给可变关键字参数赋值:     
+
+```python
+def some_kwargs(name, age, sex):
+    print(f"name: ${name}")
+
+kdic = {'name' : 'Alice', 'age' : 11, 'sex' : 'nv'}
+some_kwargs(**kdic)
+
+```
+
+
+在Python中，可以通过@property（装饰器）将一个方法转换为属性，从而实现用于计算的属性。将方法转换为属性后，可以直接通过方法名来访问方法，而不需要再添加一对小括号“()”，这样可以让代码更加简洁。
+
+
+#### lambda
+
+Python使用lambda来定义匿名函数，所谓匿名，指其不用def的标准形式定义函数。 
+
+
+Lambda 表达式的基本语法是：`lambda 参数列表: 表达式`。
+关键字与参数：以 lambda关键字开头，后跟参数列表（如 x或 x, y），参数之间用逗号分隔。这些参数是函数的输入。
+表达式与返回值：冒号后面是一个单一的表达式。这个表达式会被求值，其结果就是 lambda 函数的返回值。注意，lambda 函数体内只能有一个表达式，不能包含复杂的语句或多行代码块。
+Lambda 函数是匿名的，也就是说，它们没有像用 def定义的函数那样的名称。它们的优势在于简洁，特别适合定义那些逻辑简单、可能只使用一次的短小函数。
+
+
+### var1 *= 2与var1 = var1 * 2的区别
+
+
+- var1 *= 2使用原地址
+- var1 = var1 * 2开辟了新的空间
+- 同样的对于类似，var1 += 2和var1 = var1 + 2也是同理
+
+```python
+def test(var1): 
+    print("函数内var1 id:", id(var1))
+    var1 *= 2
+    print("var1 *= 2后函数内var1 id:", id(var1))
+    var1 = var1 * 2
+    print("var1 = var1 *  2后函数内var1 id:", id(var1))
+    
+函数内var1 id: 2302584035712
+var1 *= 2后，函数内var1 id: 2302584035712
+var1 = var1 * 2后，函数内var1 id: 2302584033664    
+```    
+    
+    
+    
+    
+
+----
+
+
+
+
+
+
+计算机高级运行方式:   
+
+- 编译型: c、c++
+- 解释型： python、JavaScript
+- 先编译再解释： java
+
+
+其实python也是先编译再解释，但是python的编译时机和java的不一样。 
+- java是在代码解释执行前，先进行预编译，编译后生成字节码文件存在硬盘中。
+- python是在对代码进行逐行解释执行的时候进行的编译操作，默认生成的字节码文件存在内存中。  
+
+
diff --git a/JavaKnowledge/shell.md b/JavaKnowledge/shell.md
new file mode 100644
index 00000000..1c2fb339
--- /dev/null
+++ b/JavaKnowledge/shell.md
@@ -0,0 +1,101 @@
+shell
+---
+
+
+
+
+### ls: 
+
+ls x* y*: 过滤文件中x和y开头的文件
+ls -F: 区分文件还是目录
+ls -l: 显示详细信息
+
+### touch: 创建或修改文件时间
+
+
+### cp: 复制文件
+
+cp sourceFile destinationFile，但是如果源文件存在会直接被覆盖，也不会提醒，
+如果想要提醒需要加上-i, 例如cp -i 1.txt 2.txt
+
+
+### mv移动重新命名
+
+用法和cp一致
+
+
+### rm删除
+
+rm -i xxx: -i会询问是否真的要删除
+rm -f xxx: 强制删除，不会询问
+
+注意　对于rm命令，-r选项和-R选项的效果是一样的，都可以递归地删除目录中的文件。shell命令很少会对相同的功能使用大小写不同的选项。
+一口气删除目录树的最终解决方案是使用rm -rf命令。该命令不声不响，能够直接删除指定目录及其所有内容。当然，这肯定是一个非常危险的命令，所以务必谨慎使用，并再三检查你要进行的操作是否符合预期。
+
+
+### mkdir 创建目录
+
+mkdir命令的-p选项可以根据需要创建缺失的父目录。父目录是包含目录树中下一级目录的目录。
+
+### rmdir 删除空目录
+
+### file
+
+file命令是一个方便的小工具，能够探测文件的内部并判断文件类型：
+$ file .bashrc
+.bashrc: ASCII text
+
+
+### cat 显示文本文件
+
+cat fileName
+
+-n 加上行号
+
+### more 
+cat的缺点是其开始运行后无法控制后续的操作，为了解决这个问题，有了more命令。    
+
+more命令会显示文件内容，但会在显示每页数据之后暂停下来。
+
+### ps 显示当前用户进程
+
+ps -ef显示系统中运行的所有进程    
+
+### top 实时监测进程
+
+ps命令虽然在收集系统中运行进程的信息时非常有用，但也存在不足之处：只能显示某个特定时间点的信息。如果想观察那些被频繁换入和换出内存的进程，ps命令就不太方便了。这正是top命令的用武之地。与ps命令相似，top命令也可以显示进程信息，但采用的是实时方式。
+
+
+
+### kill pid， 通过pid发送信号
+
+### pkill pname: pkill命令可以使用程序名代替PID来终止进程。除此之外，pkill命令也允许使用通配符。   
+
+
+### grep数据搜索
+
+经常需要在大文件中搜索
+
+### gzip压缩
+
+gzip: 压缩
+gzcat: 查看压缩过的文本文件内容
+gunzip:解压
+
+### tar归档
+
+ar命令最开始是用于将文件写入磁带设备以作归档，但它也可以将输出写入文件，这种用法成了在Linux中归档数据的普遍做法。tar命令的格式如下
+
+// 该命令创建了一个名为test.tar的归档文件，包含目录test和test2的内容。
+tar -cvf test.tar test/ test2/
+
+
+### 切换到root用户
+
+
+`sudo su -`
+
+ - sudo : super user doing
+ - su : switch user
+ - `-` : root用户
+
diff --git "a/JavaKnowledge/volatile\345\222\214Synchronized\345\214\272\345\210\253.md" "b/JavaKnowledge/volatile\345\222\214Synchronized\345\214\272\345\210\253.md"
index 82801018..8894decc 100644
--- "a/JavaKnowledge/volatile\345\222\214Synchronized\345\214\272\345\210\253.md"
+++ "b/JavaKnowledge/volatile\345\222\214Synchronized\345\214\272\345\210\253.md"
@@ -183,6 +183,12 @@ ctorInstance(memory);  //2.初始化对象
 
 指令重排序后，在多线程情况下，可能会发生A线程正在new对象，执行了3，但还没有执行2。此时B线程进入方法获取单例对象，执行同步代码块外的非空判断，发现变量非空，但此时对象还未初始化，B线程获取到的是一个未被初始化的对象。使用volatile修饰后，禁止指令重排序。即，先初始化对象后，再设置instance指向刚分配的内存地址。这样就就不存在获取到未被初始化的对象。
 
+
+
+那为何说它禁止指令重排序呢？从硬件架构上讲，指令重排序是指处理器采用了允许将多条指令不按程序规定的顺序分开发送给各个相应的电路单元进行处理。但并不是说指令任意重排，处理器必须能正确处理指令依赖情况保障程序能得出正确的执行结果。譬如指令1把地址A中的值加10，指令2把地址A中的值乘以2，指令3把地址B中的值减去3，这时指令1和指令2是有依赖的，它们之间的顺序不能重排——(A+10)*2与A*2+10显然不相等，但指令3可以重排到指令1、2之前或者中间，只要保证处理器执行后面依赖到A、B值的操作时能获取正确的A和B值即可。所以在同一个处理器中，重排序过的代码看起来依然是有序的。因此，lock addl$0x0，(%esp)指令把修改同步到内存时，意味着所有之前的操作都已经执行完成，这样便形成了“指令重排序无法越过内存屏障”的效果。
+
+
+
 ## synchronized
 
 **synchronized实现同步的基础是：Java中的每个对象都可作为锁。所以synchronized锁的都对象，只不过不同形式下锁的对象不一样。**
diff --git "a/JavaKnowledge/\345\274\272\345\274\225\347\224\250\343\200\201\350\275\257\345\274\225\347\224\250\343\200\201\345\274\261\345\274\225\347\224\250\343\200\201\350\231\232\345\274\225\347\224\250.md" "b/JavaKnowledge/\345\274\272\345\274\225\347\224\250\343\200\201\350\275\257\345\274\225\347\224\250\343\200\201\345\274\261\345\274\225\347\224\250\343\200\201\350\231\232\345\274\225\347\224\250.md"
index 48d014de..c656ea7f 100644
--- "a/JavaKnowledge/\345\274\272\345\274\225\347\224\250\343\200\201\350\275\257\345\274\225\347\224\250\343\200\201\345\274\261\345\274\225\347\224\250\343\200\201\350\231\232\345\274\225\347\224\250.md"
+++ "b/JavaKnowledge/\345\274\272\345\274\225\347\224\250\343\200\201\350\275\257\345\274\225\347\224\250\343\200\201\345\274\261\345\274\225\347\224\250\343\200\201\350\231\232\345\274\225\347\224\250.md"
@@ -66,6 +66,21 @@
 
 ![](https://raw.githubusercontent.com/CharonChui/Pictures/master/reference_compare.jpg)
 
+
+无论是通过引用计数算法判断对象的引用数量，还是通过可达性分析算法判断对象是否引用链可达，判定对象是否存活都和“引用”离不开关系。在JDK 1.2版之前，Java里面的引用是很传统的定义：如果reference类型的数据中存储的数值代表的是另外一块内存的起始地址，就称该reference数据是代表某块内存、某个对象的引用。
+
+
+在JDK 1.2版之后，Java对引用的概念进行了扩充，将引用分为强引用(Strongly Re-ference)、软引用(Soft Reference)、弱引用(Weak Reference)和虚引用(Phantom Reference)4种，这4种引用强度依次逐渐减弱。
+
+
+- 强引用是最传统的“引用”的定义，是指在程序代码之中普遍存在的引用赋值，即类似“Object obj=new Object()”这种引用关系。无论任何情况下，只要强引用关系还存在，垃圾收集器就永远不会回收掉被引用的对象。
+
+- 软引用是用来描述一些还有用，但非必须的对象。只被软引用关联着的对象，在系统将要发生内存溢出异常前，会把这些对象列进回收范围之中进行第二次回收，如果这次回收还没有足够的内存，才会抛出内存溢出异常。在JDK 1.2版之后提供了SoftReference类来实现软引用。
+
+- 弱引用也是用来描述那些非必须对象，但是它的强度比软引用更弱一些，被弱引用关联的对象只能生存到下一次垃圾收集发生为止。当垃圾收集器开始工作，无论当前内存是否足够，都会回收掉只被弱引用关联的对象。在JDK 1.2版之后提供了WeakReference类来实现弱引用。
+
+- 虚引用也称为“幽灵引用”或者“幻影引用”，它是最弱的一种引用关系。一个对象是否有虚引用的存在，完全不会对其生存时间构成影响，也无法通过虚引用来取得一个对象实例。为一个对象设置虚引用关联的唯一目的只是为了能在这个对象被收集器回收时收到一个系统通知。在JDK 1.2版之后提供了PhantomReference类来实现虚引用。
+
 ---
 
 - 邮箱 ：charon.chui@gmail.com  
diff --git "a/JavaKnowledge/\346\225\260\346\215\256\347\273\223\346\236\204\345\222\214\347\256\227\346\263\225/1. LeetCode_\344\270\244\346\225\260\344\271\213\345\222\214.md" "b/JavaKnowledge/\346\225\260\346\215\256\347\273\223\346\236\204\345\222\214\347\256\227\346\263\225/1. LeetCode_\344\270\244\346\225\260\344\271\213\345\222\214.md"
new file mode 100644
index 00000000..b5d71dba
--- /dev/null
+++ "b/JavaKnowledge/\346\225\260\346\215\256\347\273\223\346\236\204\345\222\214\347\256\227\346\263\225/1. LeetCode_\344\270\244\346\225\260\344\271\213\345\222\214.md"	
@@ -0,0 +1,172 @@
+1. LeetCode_两数之和
+===
+
+给定一个整数数组nums和一个整数目标值target，请你在该数组中找出和为目标值target的那两个整数，并返回它们的数组下标。
+
+你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。
+
+你可以按任意顺序返回答案。
+
+ 
+---
+
+示例 1           
+
+输入：nums = [2,7,11,15], target = 9
+输出：[0,1]
+解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。
+
+
+示例 2：
+
+输入：nums = [3,2,4], target = 6
+输出：[1,2]
+
+示例 3：        
+
+输入：nums = [3,3], target = 6
+输出：[0,1]
+
+
+
+提示：
+
+只会存在一个有效答案
+ 
+
+进阶：你可以想出一个时间复杂度小于 O(n2) 的算法吗？
+
+
+### 方法一：暴力枚举
+
+
+最简单的方法就是对数组中的每一个数x，都去遍历找后面是否存在target - x的值是否存在。
+
+```java
+class Solution {
+    public int[] twoSum(int[] nums, int target) {
+        int size = nums.length;
+
+        for (int i = 0; i < size; i++) {
+            for (int j = i + 1; j < size; j++) {
+                if (nums[i] + nums[j] == target) {
+                    return new int[]{i, j};
+                }
+            }
+        }
+        return new int[0];
+    }
+}
+```
+
+```c++
+#include <vector>
+using namespace std;
+
+
+class Solution {
+public:
+    vector<int> twoSum(vector<int> &nums, int target) {
+        int size = nums.size();
+
+        for (int i = 0; i < size; i++) {
+            for (int j = i + 1; j < size; j++) {
+                if (nums[i] + nums[j] == target) {
+                    return {i, j};
+                }
+            }
+        }
+        return {};
+    }
+};
+```
+
+复杂度分析:    
+
+- 时间复杂度：O(N²)，其中N是数组中的元素数量。最坏情况下数组中任意两个数都要被匹配一次。
+
+- 空间复杂度：O(1)。
+
+
+### 方法二： 哈希表
+
+注意到方法一的时间复杂度较高的原因是寻找target - x的时间复杂度过高。
+
+因此，我们需要一种更优秀的方法，能够快速寻找数组中是否存在目标元素。如果存在，我们需要找出它的索引。
+
+使用哈希表，可以将寻找target - x的时间复杂度降低到从O(N)降低到O(1)。
+
+
+---
+
+如果想要快速确定某个元素是否在nums数组中，并且可以快速的获取所在下表index。
+我们的第一反应就是将数组维护成一个Map结构:     
+
+- key: 存储数组里的值
+- value: 存储数组的下标index
+
+这样我们只需要通过target - nums[i]的值去Map中查找即可。      
+但是这样存在一个问题，就是你需要先把数组中的值都放到Map中，需要多一步循环。       
+
+
+--- 
+
+其实我们可以先创建一个Map，在Map的初始化过程中什么元素都不放。     
+
+对于每一个x，我们首先查询哈希表中是否存在target-x，如果已存在就返回，如果不存在那再将x插入到哈希表中，即可保证不会让x和自己匹配。
+
+这样只需要一次循环就可以了，而且Map数组不用提前初始化，在性能和内存占用率都比较低。  
+
+
+```java
+class Solution {
+    public int[] twoSum(int[] nums, int target) {
+        Map<Integer, Integer> hashtable = new HashMap<Integer, Integer>();
+        for (int i = 0; i < nums.length; ++i) {
+            if (hashtable.containsKey(target - nums[i])) {
+                return new int[]{hashtable.get(target - nums[i]), i};
+            }
+            hashtable.put(nums[i], i);
+        }
+        return new int[0];
+    }
+}
+
+```
+
+```c++ 
+#include <unordered_map>
+#include <vector>
+
+using namespace std;
+
+class Solution {
+public:
+    vector<int> twoSum(vector<int> &nums, int target) {
+        unordered_map<int, int> map;
+        for (int i = 0; i < nums.size(); i ++) {
+            auto it = map.find(target - nums[i]);
+            if (it != map.end()) {
+                return {i, it->second};
+            }
+
+            map[nums[i]] = i;
+        }
+        return {};
+    }
+};
+```
+
+
+复杂度分析:    
+
+- 时间复杂度：O(N)，其中 N 是数组中的元素数量。对于每一个元素 x，我们可以 O(1) 地寻找 target - x。
+
+- 空间复杂度：O(N)，其中 N 是数组中的元素数量。主要为哈希表的开销。
+
+
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	
diff --git "a/JavaKnowledge/\346\225\260\346\215\256\347\273\223\346\236\204\345\222\214\347\256\227\346\263\225/2. LeetCode_\344\270\244\346\225\260\347\233\270\345\212\240.md" "b/JavaKnowledge/\346\225\260\346\215\256\347\273\223\346\236\204\345\222\214\347\256\227\346\263\225/2. LeetCode_\344\270\244\346\225\260\347\233\270\345\212\240.md"
new file mode 100644
index 00000000..03581f19
--- /dev/null
+++ "b/JavaKnowledge/\346\225\260\346\215\256\347\273\223\346\236\204\345\222\214\347\256\227\346\263\225/2. LeetCode_\344\270\244\346\225\260\347\233\270\345\212\240.md"	
@@ -0,0 +1,210 @@
+2. LeetCode_两数相加       
+===
+
+给你两个非空的链表，表示两个非负的整数。它们每位数字都是按照逆序的方式存储的，并且每个节点只能存储一位数字。
+
+请你将两个数相加，并以相同形式返回一个表示和的链表。
+
+你可以假设除了数字0之外，这两个数都不会以0开头。
+
+
+输入：l1 = [2,4,3], l2 = [5,6,4]
+输出：[7,0,8]
+解释：342 + 465 = 807.
+
+
+
+输入：l1 = [9,9,9,9,9,9,9], l2 = [9,9,9,9]
+输出：[8,9,9,9,0,0,0,1]
+
+
+提示:      
+
+- 每个链表中的节点数在范围[1, 100]内
+- 0 <= Node.val <= 9
+- 题目数据保证列表表示的数字不含前导零
+
+
+
+想法:       
+
+我的想法是先把两个链表转成两个整数相加，然后把这个整数转成字符串再次生成链表。      
+
+这种方案是不可行的，因为链表的长度可能会很长，整数是操作不了的，例如:  
+
+
+方法:      
+
+- 由于输入的两个链表都是逆序存储数字的位数的，因此两个链表中同一位置的数字可以直接相加。      
+
+- 我们同时遍历两个链表，逐位计算它们的和，并与当前位置的进位值相加。具体而言，如果当前两个链表处相应位置的数字为 n1,n2，进位值为 carry，则它们的和为 n1+n2+carry；      
+其中，答案链表处相应位置的数字为 (n1+n2+carry)mod10，而新的进位值为 [(n1+n2+carry) / 10]
+
+- 如果两个链表的长度不同，则可以认为长度短的链表的后面有若干个 0 。
+
+- 此外，如果链表遍历结束后，有carry>0，还需要在答案链表的后面附加一个节点，节点的值为 carry。
+
+
+
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/leetcode_2_twoaddsum.png?raw=true)    
+
+
+- 将链表反过来看，头结点在右侧          
+- 横线上的数字为进位         
+- 2 + 5 + 0(第一个进位默认为0) = 7       
+
+    - 7 % 10得到新节点中的元素为7      
+    - 7 / 10得到下一个进位为0      
+
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/leetcode_2_twoaddsum_2.png?raw=true)    
+    
+
+```java
+class ListNode {
+    int val;
+    ListNode next;
+    
+    ListNode() {
+        this.val = 0;
+        this.next = null;
+    }
+
+    ListNode(int val) {
+        this.val = val;
+        this.next = null;
+    }
+
+    ListNode(int val, ListNode next) {
+        this.val = val;
+        this.next = next;
+    }
+}
+
+class Solution {
+    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
+         ListNode head = null;
+         ListNode tail = null;
+
+         int carry = 0;
+
+         while(l1 != null || l2 != null) {
+            int n1 = l1 != null ? l1.val : 0;
+            int n2 = l2 != null ? l2.val : 0;
+
+            int sum = n1 + n2 + carry;
+
+            if (head == null) {
+                head = tail = new ListNode(sum % 10);
+            } else {
+                tail.next = new ListNode(sum % 10);
+                tail = tail.next;
+            }
+
+            carry = sum / 10;
+
+            if (l1 != null) {
+                l1 = l1.next;
+            }
+
+            if (l2 != null) {
+                l2 = l2.next;
+            }
+         }
+
+         if (carry > 0) {
+            tail.next = new ListNode(carry);
+         }
+         return head;
+     }
+}
+```
+
+
+
+复杂度分析:         
+
+- 时间复杂度: O(max(m,n))，其中m和n分别为两个链表的长度。我们要遍历两个链表的全部位置，而处理每个位置只需要O(1)的时间。
+
+- 空间复杂度: O(1)。注意返回值不计入空间复杂度。
+
+
+### 改进： 递归
+
+```java
+class Solution {
+    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
+        return add(l1, l2, 0);
+    }
+}
+
+public ListNode add(ListNode l1, ListNode l2, int carry) {
+        if (l1 == null && l2 == null && carry == 0) {
+            return null;
+        }
+        int val = carry;
+        if (l1 != null) {
+            val += l1.val;
+            l1 = l1.next;
+        }
+        if (l2 != null) {
+            val += l2.val;
+            l2 = l2.next;
+        }
+        ListNode node = new ListNode(val % 10);
+        node.next = add(l1, l2, val / 10);
+        return node;
+    }
+}
+```
+
+使用C++实现:   
+
+```c++
+struct ListNode {
+    int val;
+    ListNode *next;
+
+    ListNode() : val(0), next(nullptr) {
+    }
+
+    ListNode(int x) : val(x), next(nullptr) {
+    }
+
+    ListNode(int x, ListNode *next) : val(x), next(next) {
+    }
+};
+
+class Solution {
+public:
+    ListNode *addTwoNumbers(ListNode *l1, ListNode *l2) {
+        int carry = 0;
+
+        ListNode *answer = new ListNode();
+        ListNode *head = answer;
+
+        while (l1 || l2) {
+            int number = (l1 ? l1->val : 0) + (l2 ? l2->val : 0) + carry;
+            carry = number / 10;
+            number %= 10;
+            head->next = new ListNode(number);
+            head = head->next;
+
+            l1 ? l1 = l1->next : 0;
+            l2 ? l2 = l2->next : 0;
+        }
+        if (carry) {
+            head->next = new ListNode(carry);
+        }
+        return answer->next;
+    }
+};
+```
+
+
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	
diff --git "a/JavaKnowledge/\346\225\260\346\215\256\347\273\223\346\236\204\345\222\214\347\256\227\346\263\225/3. LeetCode_\346\227\240\351\207\215\345\244\215\345\255\227\347\254\246\347\232\204\346\234\200\351\225\277\345\255\220\344\270\262.md" "b/JavaKnowledge/\346\225\260\346\215\256\347\273\223\346\236\204\345\222\214\347\256\227\346\263\225/3. LeetCode_\346\227\240\351\207\215\345\244\215\345\255\227\347\254\246\347\232\204\346\234\200\351\225\277\345\255\220\344\270\262.md"
new file mode 100644
index 00000000..748e420e
--- /dev/null
+++ "b/JavaKnowledge/\346\225\260\346\215\256\347\273\223\346\236\204\345\222\214\347\256\227\346\263\225/3. LeetCode_\346\227\240\351\207\215\345\244\215\345\255\227\347\254\246\347\232\204\346\234\200\351\225\277\345\255\220\344\270\262.md"	
@@ -0,0 +1,190 @@
+3. LeetCode_无重复字符的最长子串
+===
+
+给定一个字符串s，请你找出其中不含有重复字符的 最长子串 的长度。
+
+
+示例 1:
+
+输入: s = "abcabcbb"
+输出: 3 
+解释: 因为无重复字符的最长子串是 "abc"，所以其长度为 3。
+示例 2:
+
+输入: s = "bbbbb"
+输出: 1
+解释: 因为无重复字符的最长子串是 "b"，所以其长度为 1。
+示例 3:
+
+输入: s = "pwwkew"
+输出: 3
+解释: 因为无重复字符的最长子串是 "wke"，所以其长度为 3。
+     请注意，你的答案必须是 子串 的长度，"pwke" 是一个子序列，不是子串。
+ 
+
+提示：
+
+0 <= s.length <= 5 * 104
+s 由英文字母、数字、符号和空格组成
+
+
+
+方式一:    
+
+暴力破解，通过多个循环以穷举的方式 找出答案。简单且易想到的方案，包括之前我们刷的两道算法题也可以使用暴力破解来解决，缺点就是虽然简单，但是效率非常低，并非是最优方案。
+
+
+具体思路:   
+
+- 将字符串中每个字符作为一个循环，和子串的组合进行比较，从而获取最长字串长度。
+
+如字符串abc，则第一轮比较为: 字符a和子串a、ab、abc比较，第二轮则为字符b和子串b、bc比较，以此类推，最后获取不重复的子串长度。
+
+```java
+public class Solution {
+    public static int lengthOfLongestSubstring(String s) {
+        int maxLength = 0;
+
+        for (int i = 0; i < s.length(); i++) {
+            for (int j = i + 1; j < s.length(); j++) {
+                if (!judgeCharacterExist(i, j, s)) {
+                    maxLength = Math.max(maxLength, j - i);
+                }
+            }
+        }
+        return maxLength;
+    }
+
+
+    public static boolean judgeCharacterExist(int start, int end, String param) {
+        HashSet<Character> hashSet = new HashSet<>();
+        for (int i = start; i < end; i++) {
+            if (hashSet.contains(param.charAt(i))) {
+                return true;
+            }
+            hashSet.add(param.charAt(i));
+        }
+
+        return false;
+    }
+}
+```
+
+该方法效率低，时间福再度为O(n³)。
+
+
+方法二： 滑动窗口法
+
+滑动窗口： 是数组和字符串中一个抽象的概念，可分为滑动和窗口两个概念理解。   
+
+窗口：即表示一个范围，通常是字符串和数组从开始到结束两个索引范围中间包含的一系列元素集合。如字符串abcd，如果开始索引和结束索引分别为0、2的话，这个窗口包含的字符则为： abc。
+
+滑动：它表示窗口的开始和结束索引是可以往某个方向移动的。        
+如上面的例子开始索引和结束索引分别为0、2的话，当开始索引和结束索引都往右移动一位时，它们的索引值分别为1、3，这个窗口包含的字符为：bcd。
+
+示例：  
+
+- abcdef
+- 字符串开始索引： 0
+- 字符串结束索引： 5
+- 开始和结束索引范围包含的字符(abcdef)就可以看作是一个窗口
+
+思路：   
+
+- 使用一个HashSet来实现滑动窗口，用来检查重复字符
+- 维护开始和结束两个索引，默认都是从0开始
+- 随着循环 向右移动结束索引 
+
+    - 遇到不是重复的字符则放入窗口里
+    - 遇到重复字符则向右移动开始索引
+
+最终得到结果。      
+
+```java
+public class Solution {
+    public static Integer lengthOfLongestSubstring(String s) {
+        int maxLength = 0;
+        int leftPoint = 0;
+        int rightPoint = 0;
+        
+        Set<Character> set = new HashSet<>();
+        
+        while(leftPoint < s.length() && rightPoint < s.length()) {
+            if (!set.contains(s.charAt(rightPoint))) {
+                set.add(s.charAt(rightPoint++));
+                maxLength = Math.max(maxLength, rightPoint - leftPoint);
+            } else {
+                set.remove(s.charAt(leftPoint++));
+            }
+        }
+        return maxLength;
+    }
+}
+```
+
+滑动窗口算法的时间复杂度为O(n)，相比于暴力破解，它的效率大大提高了。
+
+方式三:     
+
+虽然方式使用了滑动窗口时间复杂度只有O(n)，但是如果存在重复字符还需要移动开始索引，因此我们可以考虑借助之前其他算法谈到的“空间换时间”的想法，通过借助HashMap建立字符和索引映射，避免手动移动索引。
+
+
+```java
+public class Solution {
+    public static Integer lengthOfLongestSubstring(String s) {
+        char[] charArry = s.toCharArray();
+
+        HashMap<Character, Integer> keyMap = new HashMap<>();
+        int maxLength = 0;
+
+        int leftPoint = 0;
+        for (int i = 0; i < charArry.length; i++) {
+            if (keyMap.containsKey(charArry[i])) {
+                // 存在重复数据则获取索引值最大的
+                leftPoint = Math.max(leftPoint, keyMap.get(charArry[i]));
+            }
+            // 值重复就覆盖，不重复就添加
+            keyMap.put(charArry[i], i + 1);
+            maxLength = Math.max(maxLength, i + 1 - leftPoint);
+        }
+        return maxLength;
+    }
+}
+```
+
+时间复杂度为O(n)，虽然和上一种方案的时间复杂度是一样的，但是效率还是有一定的提高(思考问题时要思考是否还有其他有优质的方案，培养发散思维)。
+
+
+方式四: 
+
+
+上面题目分析的时候就提到了要注意题目中提到的：【字符串英文字母、数字、符号和空格组成】，这些字符是可以使用ASCII表示(如字符a的ASCII值为97，想具体了解的可以百度下)，那么我们就可以建立字符与ASCII的映射关系，从而实现重复字符的排除。
+
+
+
+```java
+public class Solution {
+    public static Integer lengthOfLongestSubstring(String s) {
+        int[] index = new int[128];
+        int maxLength = 0;
+        int length = s.length();
+        int i = 0;
+        for (int j = 0; j < length; j++) {
+            i = Math.max(index[s.charAt(j)], i);
+            index[s.charAt(j)] = j + 1;
+            maxLength = Math.max(maxLength, j + 1 - i);
+        }
+        return maxLength;
+    }
+}
+```
+
+
+
+
+
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	
diff --git "a/JavaKnowledge/\346\225\260\346\215\256\347\273\223\346\236\204\345\222\214\347\256\227\346\263\225/\346\225\260\346\215\256\347\273\223\346\236\204.md" "b/JavaKnowledge/\346\225\260\346\215\256\347\273\223\346\236\204\345\222\214\347\256\227\346\263\225/\346\225\260\346\215\256\347\273\223\346\236\204.md"
index f8e8413f..14166129 100644
--- "a/JavaKnowledge/\346\225\260\346\215\256\347\273\223\346\236\204\345\222\214\347\256\227\346\263\225/\346\225\260\346\215\256\347\273\223\346\236\204.md"
+++ "b/JavaKnowledge/\346\225\260\346\215\256\347\273\223\346\236\204\345\222\214\347\256\227\346\263\225/\346\225\260\346\215\256\347\273\223\346\236\204.md"
@@ -10,8 +10,24 @@
 
 按照视点的不同，我们把数据结构分为逻辑结构和物理结构。
 
+数据结构（data structure）是组织和存储数据的方式，涵盖数据内容、数据之间关系和数据操作方法，它具有以下设计目标。
+
+- 空间占用尽量少，以节省计算机内存。
+- 数据操作尽可能快速，涵盖数据访问、添加、删除、更新等。
+- 提供简洁的数据表示和逻辑信息，以便算法高效运行。
+- 数据结构设计是一个充满权衡的过程。如果想在某方面取得提升，往往需要在另一方面作出妥协。
+
+下面举两个例子:   
+
+- 链表相较于数组，在数据添加和删除操作上更加便捷，但牺牲了数据访问速度。
+- 图相较于链表，提供了更丰富的逻辑信息，但需要占用更大的内存空间。
+
+
+
 #### 逻辑结构
+
 逻辑结构：是指数据对象中数据元素之间的相互关系。其实这也是我们今后最需要关注的问题。逻辑结构分为以下四种：
+
 - 集合结构
     集合结构：集合结构中的数据元素除了同属于一个集合外，它们之间没有其他关系。各个数据元素是“平等”的，它们的共同属性是"同属于一个集合"。
     数据结构中的集合关系就类似于数学中的集合
@@ -23,7 +39,9 @@
     图形结构：图形结构的数据元素是多对多的关系            
 
 #### 物理结构
+
 物理结构(也称为存储结构)：是指数据的逻辑结构在计算机中的存储形式。
+
 - 顺序存储结构
     顺序存储结构：是把数据元素存放在地址连续的存储单元里，其数据间的逻辑关系和物理关系是一致的
     这种存储结构其实很简单，说白了，就是排队占位。大家都按顺序排好，每个人占一小段空间，大家谁也别插谁的队。数组就是这
@@ -55,12 +73,16 @@
 - 有限
     元素的个数是有限的。
 
-线性表的顺序存储结构，在存、读数据时，不管是哪个位置，时间复杂度都是O(1)；
-而插入或删除时，时间复杂度都是O(n)。
 这就说明，它比较适合元素个数不太变化，而更多是存取数据的应用。当然，它的优缺点还不止这些。
 
-由于线性表的顺序存储结构在插入和删除的时候需要移动大量元素，为了解决这个问题，有了线性表的链式存储结构。
-又分为单链表和多链表。
+线性表是一个抽象的数据逻辑模型，不指定具体存储方式。主要强调的是元素的顺序性和有限性。    
+
+线性表常见的实现有:    
+
+- 数组(顺序存储)
+- 链表(链式存储)
+- 栈、队列(有限的线性表)
+
 
 ### 数组`(Array)`
 
@@ -110,14 +132,15 @@ int[] arr = new int[10];
 
 所谓的链表就好像火车车厢一样，从火车头开始，每一节车厢之后都连着后一节车厢。
 
-单链表插入和删除算法，它们其实都是由两部分组成：
-第一部分就是遍历查找第i个元素；
-第二部分就是插入和删除元素。
-从整个算法来说，我们很容易推导出：它们的时间复杂度都是O(n)。
-如果在我们不知道第i个元素的指针位置，单链表数据结构在插入和删除操作上，与线性表的顺序存储结构是没有太大优势的。
-但如果，我们希望从第i个位置，插入10个元素，对于顺序存储结构意味着，每一次插入都需要移动n－i个元素，每次都是O(n)。
-而单链表，我们只需要在第一次时，找到第i个位置的指针，此时为O(n)，接下来只是简单地通过赋值移动指针而已，时间复杂度都是O(1)。
-显然，对于插入或删除数据越频繁的操作，单链表的效率优势就越是明显。
+单链表插入和删除算法，它们其实都是由两部分组成:      
+- 第一部分就是遍历查找第i个元素；
+- 第二部分就是插入和删除元素。
+从整个算法来说，我们很容易推导出：它们的时间复杂度都是O(n)。     
+
+如果在我们不知道第i个元素的指针位置，单链表数据结构在插入和删除操作上，与线性表的顺序存储结构是没有太大优势的。     
+但如果，我们希望从第i个位置，插入10个元素，对于顺序存储结构意味着，每一次插入都需要移动n－i个元素，每次都是O(n)。      
+而单链表，我们只需要在第一次时，找到第i个位置的指针，此时为O(n)，接下来只是简单地通过赋值移动指针而已，时间复杂度都是O(1)。      
+显然，对于插入或删除数据越频繁的操作，单链表的效率优势就越是明显。   
 
 
 优点:   
@@ -168,8 +191,21 @@ int[] arr = new int[10];
 #### 栈的应用-递归
 
 把一个直接调用自己或通过一系列的调用语句间接地调用自己的函数，称做递归函数。
+
 当然，写递归程序最怕的就是陷入永不结束的无穷递归中，所以，每个递归定义必须至少有一个条件，满足时递归不再进行，即不再引用自身而是返回值退出。
 
+递归（recursion）是一种算法策略，通过函数调用自身来解决问题。它主要包含两个阶段：  
+
+- 递：程序不断深入地调用自身，通常传入更小或更简化的参数，直到达到“终止条件”。
+- 归：触发“终止条件”后，程序从最深层的递归函数开始逐层返回，汇聚每一层的结果。
+
+而从实现的角度看，递归代码主要包含三个要素：   
+
+- 终止条件：用于决定什么时候由“递”转“归”。
+- 递归调用：对应“递”，函数调用自身，通常输入更小或更简化的参数。
+- 返回结果：对应“归”，将当前递归层级的结果返回至上一层。
+
+
 那么我们讲了这么多递归的内容，和栈有什么关系呢？这得从计算机系统的内部说起。前面我们已经看到递归是如何执行它的前行和退回阶段的。
 递归过程退回的顺序是它前行顺序的逆序。在退回过程中，可能要执行某些动作，包括恢复在前行过程中存储起来的某些数据。这种存储某些数据，
 并在后面又以存储的逆序恢复这些数据，以提供之后使用的需求，显然很符合栈这样的数据结构，因此，编译器使用栈实现递归就没什么好惊讶的了。
diff --git "a/JavaKnowledge/\346\225\260\346\215\256\347\273\223\346\236\204\345\222\214\347\256\227\346\263\225/\347\256\227\346\263\225.md" "b/JavaKnowledge/\346\225\260\346\215\256\347\273\223\346\236\204\345\222\214\347\256\227\346\263\225/\347\256\227\346\263\225.md"
index 7c8a9a26..b33352bd 100644
--- "a/JavaKnowledge/\346\225\260\346\215\256\347\273\223\346\236\204\345\222\214\347\256\227\346\263\225/\347\256\227\346\263\225.md"
+++ "b/JavaKnowledge/\346\225\260\346\215\256\347\273\223\346\236\204\345\222\214\347\256\227\346\263\225/\347\256\227\346\263\225.md"
@@ -1,7 +1,12 @@
 算法
 ===
 
-算法(Algorithm)是解决特定问题求解步骤的描述，在计算机中表现为指令的有限序列，并且每条指令表示一个或多个操作。
+
+算法（algorithm）是在有限时间内解决特定问题的一组指令或操作步骤，它具有以下特性:   
+
+- 问题是明确的，包含清晰的输入和输出定义。
+- 具有可行性，能够在有限步骤、时间和内存空间下完成。
+- 各步骤都有确定的含义，在相同的输入和运行条件下，输出始终相同。
 
 
 算法具有五个基本特性：
@@ -17,6 +22,21 @@
     算法的每一步都必须是可行的，也就是说，每一步都能够通过执行有限次数完成
 
 
+在算法设计中，我们先后追求以下两个层面的目标。
+
+- 找到问题解法：算法需要在规定的输入范围内可靠地求得问题的正确解。
+- 寻求最优解法：同一个问题可能存在多种解法，我们希望找到尽可能高效的算法。
+
+也就是说，在能够解决问题的前提下，算法效率已成为衡量算法优劣的主要评价指标，它包括以下两个维度:    
+
+- 时间效率：算法运行时间的长短。
+- 空间效率：算法占用内存空间的大小。
+
+简而言之，我们的目标是设计“既快又省”的数据结构与算法。而有效地评估算法效率至关重要，因为只有这样，我们才能将各种算法进行对比，进而指导算法设计与优化过程。
+
+
+
+
 
 ### 算法时间复杂度
 
@@ -29,7 +49,9 @@
 显然，由此算法时间复杂度的定义可知，我们的三个求和算法的时间复杂度分别为O(n)，O(1)，O(n²)。
 我们分别给它们取了非官方的名称，O(1)叫常数阶、O(n)叫线性阶、O(n²)叫平方阶。
 
-
+- O(1) : 操作所需的时间是常数(n个元素所需的时间与一个元素所需的时间相同)
+- O(n) : n个元素的时间是一个元素时间乘以n
+- O(n²): n个元素的时间是一个元素时间乘以n²
 
 #### 推导大O阶方法
 
@@ -289,7 +311,19 @@ public static int[] merge(int[] a, int[] b) {
     }
     return result;
 }
-````
+```
+
+
+数据结构与算法高度相关、紧密结合，具体表现在以下三个方面:     
+
+- 数据结构是算法的基石。数据结构为算法提供了结构化存储的数据，以及操作数据的方法。
+- 算法是数据结构发挥作用的舞台。数据结构本身仅存储数据信息，结合算法才能解决特定问题。
+- 算法通常可以基于不同的数据结构实现，但执行效率可能相差很大，选择合适的数据结构是关键。
+
+
+
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/algorithm_datasturcture.jpg?raw=true)
+
 
 
 ---
diff --git "a/Jetpack/architecture/12.Navigation\347\256\200\344\273\213.md" "b/Jetpack/architecture/12.Navigation\347\256\200\344\273\213.md"
index dac4d75d..38c42a53 100644
--- "a/Jetpack/architecture/12.Navigation\347\256\200\344\273\213.md"
+++ "b/Jetpack/architecture/12.Navigation\347\256\200\344\273\213.md"
@@ -4,6 +4,11 @@
 
 为此，Jetpack提供了一个名为Navigation的组件，旨在方便我们管理页面和App bar。
 
+
+Navigation 是一个框架，用于在 Android 应用中的“目的地”之间导航，该框架提供一致的 API，无论目的地是作为 fragment、activity 还是其他组件实现。
+
+
+
 它具有以下优势: 
 
 - 可视化的页面导航图，类似于Apple Xcode中的StoryBoard，便于我们理清页面间的关系。
@@ -15,6 +20,16 @@
 
 Navigation 组件旨在用于具有一个主 Activity 和多个 Fragment 目的地的应用。主 Activity 与导航图相关联，且包含一个负责根据需要交换目的地的 `NavHostFragment`。在具有多个 Activity 目的地的应用中，每个 Activity 均拥有其自己的导航图。
 
+
+在使用过程中，我们感受到如下的优点。
+
+- 页面跳转性能更好，在单 Activity 的架构下，都是 fragment 的切换，每次 fragment 被压栈之后，View 被销毁，相比之前 Activity 跳转，更加轻量，需要的内存更少。
+- 通过 Viewmodel 进行数据共享更便捷，不需要页面之间来回传数据。
+- 统一的 Navigation API 来更精细的控制跳转逻辑。
+
+
+
+
 ## 依赖
 
 如果想要使用Navigation，需要现在build.gradle文件中添加以下依赖: 
@@ -51,17 +66,20 @@ dependencies {
 
 导航组件由以下三个关键部分组成：
 
-1. Navigation Graph
+1. Navigation Graph ： 图表
 
+    一种数据结果，用于定义应用中的所有导航目的地以及它们如何连接在一起。
     在一个集中位置包含所有导航相关信息的 XML 资源。这包括应用内所有单个内容区域（称为*目标*）以及用户可以通过应用获取的可能路径。
 
-2. NavHost
+
+2. NavHost ： 主机
 
     显示导航图中目标的空白容器。导航组件包含一个默认NavHost实现 (NavHostFragment)，可显示Fragment目标。
 
-3. NavController
+3. NavController ： 控制器
 
-    在NavHost中管理应用导航的对象。当用户在整个应用中移动时，NavController会安排NavHost中目标内容的交换。
+    在NavHost中管理应用导航的对象。当用户在整个应用中移动时，NavController会安排NavHost中目标内容的交换。     
+    该控制器提供了一些方法，可用于在目的地之间导航、处理深层链接、管理返回堆栈等。   
 
 在应用中导航时，您告诉NavController，您想沿导航图中的特定路径导航至特定目标，或直接导航至特定目标。NavController便会在NavHost中显示相应目标。
 
@@ -476,7 +494,9 @@ override fun onCreate(savedInstanceState: Bundle?) {
 
 ```
 
+### 参考
 
+https://mp.weixin.qq.com/s?src=11&timestamp=1712714064&ver=5191&signature=JTMgHGLtMGW*NoSWSrLNVuGzs-KEEDznO-ja7*X*KumZMFAuIRl7WbPYT1gG7AX810nUx6Ftb6nm6Ao92M*GzojPfqBUo1wOFc0gMs1mseTLkUWZ9Q*BIW69MM7ULPDV&new=1
 
 
 - [上一篇:11.Hilt简介](https://github.com/CharonChui/AndroidNote/blob/master/Jetpack/architecture/11.Hilt%E7%AE%80%E4%BB%8B.md)         
diff --git "a/Jetpack/architecture/4.ViewModel\347\256\200\344\273\213.md" "b/Jetpack/architecture/4.ViewModel\347\256\200\344\273\213.md"
index 7c8a3198..5ec5a6bf 100644
--- "a/Jetpack/architecture/4.ViewModel\347\256\200\344\273\213.md"
+++ "b/Jetpack/architecture/4.ViewModel\347\256\200\344\273\213.md"
@@ -11,6 +11,11 @@
 
 `ViewModel`是专门用于存放应用程序页面所需的数据。ViewModel将页面所需的数据从页面中剥离出来，页面只需要处理用户交互和展示数据。
 
+
+ViewModel类是一种业务逻辑或屏幕级状态容器。     
+它用于将状态公开给界面，以及封装相关的业务逻辑。    
+它的主要优点是，它可以缓存状态，并可在配置更改后持久保留相应状态。这意味着在activity之间导航时或进行配置更改后(例如旋转屏幕时)，界面将无需重新提取数据。   
+
 Viewmodel解决两个问题: 
 
 1. 数据的变更与view隔离，也就是解耦
diff --git a/Jetpack/ui/Jetpack Compose_Modifier.md b/Jetpack/ui/Jetpack Compose_Modifier.md
new file mode 100644
index 00000000..fefee653
--- /dev/null
+++ b/Jetpack/ui/Jetpack Compose_Modifier.md	
@@ -0,0 +1,180 @@
+# Jetpack Compose_Modifier
+
+在传统开发中，使用XML文件来描述组件的样式，而Jetpack Compose设计了一个精妙的东西，它叫作Modifier。Modifier允许我们通过链式调用的写法来为组件应用一系列的样式设置，如边距、字体、位移等。在Compose中，每个基础的Composable组件都有一个modifier参数，通过传入自定义的Modifier来修改组件的样式。
+
+
+
+- Modifier.size
+
+设置被修饰组件的大小。
+
+- Modifier.background
+
+添加背景色，支持使用color设置纯色背景，也可以使用brush设置渐变色背景。     
+
+传统视图中View的background属性可以用来设置图片格式的背景，Compose的background修饰符只能设置颜色背景，图片背景需要使用Box布局配合Image组件实现。   
+
+- Modifier.fillMaxSize
+
+组件在高度或宽度上填满父空间，此时可以使用fillMaxXXX系列方法：  
+
+Box(Modifier.fillMaxSize().background(Color.Red))
+Box(Modifier.fillMaxWidth().height(60.dp))
+Box(Modifier.fillMaxHeight().width(60.dp))
+
+
+```kotlin
+setContent {
+    Image(
+        painter = painterResource(id = R.drawable.ic_launcher_background),
+        contentDescription = null,
+        modifier = Modifier
+            .size(width = 60.dp, height = 50.dp)
+            .background(
+                brush = Brush.verticalGradient(
+                    colors = listOf(
+                        Color.Red,
+                        Color.Yellow,
+                        Color.White
+                    )
+                )
+            )
+    )
+}
+```
+
+
+- Modifier.border & Modifier.padding
+
+border用来为组件添加边框。   
+边框可以指定颜色、粗细以及通过Shape指定形状，比如圆角矩形等。    
+
+padding用来为被修饰组件增加间隙，可以在border前后各插入一个padding用来为为组件增加对外和对内的间距，例如:   
+
+```kotlin
+@Preview
+@Composable
+fun BoxTest() {
+    Box(
+        modifier = Modifier
+            .padding(10.dp)
+            .border(2.dp, Color.Red, shape = RoundedCornerShape(2.dp))
+            .padding(20.dp)
+    ) {
+        Spacer(
+            modifier = Modifier
+                .size(10.dp, 10.dp)
+                .background(Color.Green)
+        )
+    }
+}
+```
+
+相对于传统布局有Margin和Padding之分，Compose中只有padding这一种修饰符，根据在调用链中的位置不同发挥不同的作用。     
+
+Modifier调用顺序会影响最终UI的呈现效果。    
+这是因为Modifier会由于调用顺序不同而产生不同的Modifier链，Compose会按照Modifier链来顺序完成页面测量布局和渲染。      
+
+
+## 作用域限定
+
+Compose充分发挥了Kotlin的语法特性，让某些Modifier修饰符只能在特定作用域中使用，有利于类型安全的调用它们。      
+
+所谓的作用域，在Kotlin中就是一个带有Receiver的代码块。     
+
+例如Box组件参数中的content就是一个Receiver类型为BoxScope的代码块，因此其子组件都处于BoxScope作用域中。    
+
+```kotlin
+inline fun Box(
+    modifier: Modifier = Modifier, 
+    contentAlignment: Alignment = Alignment.TopStart,
+    propagateMinConstraints: Boolean = false,
+    content: @Composable BoxScope.() -> Unit
+)    
+
+Box {
+    // 该代码块Receiver类型即为BoxScope
+}
+```
+
+
+- matchParentSize
+
+matchParentSize是只能在BoxScope中使用的作用域限定修饰符。     
+当使用matchParentSize设置尺寸时，可以保证当前组件的尺寸与父组件相同。     
+而父组件默认的是wrapContent，会根据子组件的尺寸确定自身的尺寸。   
+
+而如果使用fillMaxSize取代matchParentSize，那么该组件的尺寸会被设置为父组件所允许的最大尺寸，这样会导致铺满整个屏幕。 
+```kotlin
+@Composable 
+// 只把UserInfo区域设置背景
+fun MatchParentModifierDemo() {
+    Box {
+        Box(modifier = Modifier
+            .matchParentSize()
+            .background(Color.RED)
+        )
+        UserInfo()
+    }
+}
+
+
+// 使用fillMaxSize取代matchParentSize，那么该组件的尺寸会被设置为父组件所允许的最大尺寸，这样会导致整个背景铺满整个屏幕
+@Composable
+fun MatchParentModifierDemo() {
+    Box {
+        Box(modifier = Modifier
+            .fillMaxSize()
+            .background(Color.READ)
+        )
+        UserInfo()
+    }
+}
+```
+
+
+- weight
+
+在RowScope和ColumnScope中，可以使用专属的weight修饰符来设置尺寸。      
+
+与size修饰符不同的是，weight修饰符允许组件通过百分比设置尺寸，也就是允许组件可以自适应适配各种屏幕尺寸。    
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git "a/Jetpack/ui/Jetpack Compose\347\256\200\344\273\213.md" "b/Jetpack/ui/Jetpack Compose\347\256\200\344\273\213.md"
index 150ccb9e..ada5182a 100644
--- "a/Jetpack/ui/Jetpack Compose\347\256\200\344\273\213.md"	
+++ "b/Jetpack/ui/Jetpack Compose\347\256\200\344\273\213.md"	
@@ -15,8 +15,104 @@ GogleAndroid团队的Anna-Chiara表示，他们对已经实现的一些API感到
 这就是为什么Jetpack Compose 让我们看到了曙光。
 
 
+### 精简代码
 
-作者：依然范特稀西
-链接：https://www.jianshu.com/p/19c4e10370ba
-来源：简书
-著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
\ No newline at end of file
+编写更少的代码会影响到所有开发阶段:作为代码撰写者，需要测试和调试的代码会更少，出现bug的可能性也更小。
+
+与使用Android View系统(按钮、列表或动画)相比，Compose可让您使用更少的代码实现更多的功能。      
+而且编写代码只需要采用Kotlin，而不必拆分成Kotlin和XML部分。
+
+### 直观易读
+
+Compose使用声明性API，这意味着您只需描述界面，Compose会负责完成其余工作。    
+
+
+### 加速开发
+
+Compose与您所有的现有代码兼容：您可以从View调用Compose代码，也可以从Compose调用View。    
+
+
+### 旧项目支持Compose
+
+以Android平台而言，Compose实际上都承载在ComposeView上，如果想要在旧项目中使用Compose开发，就需要在使用处添加一个ComposeView。   
+
+可以在XML中静态声明或在程序中动态构造出一个ComposeView实例，例如在activity_main.xml中添加ComposeView，如下所示:      
+
+```xml
+<?xml version="1.0" encoding="utf-8"?>
+<androidx.compose.ui.platform.ComposeView xmlns:android="http://schemas.android.com/apk/res/android"
+    android:id="@+id/root"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent">
+
+</androidx.compose.ui.platform.ComposeView>
+```
+
+```kotlin
+class MainActivity2 : AppCompatActivity() {
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        setContentView(R.layout.activity_main2)
+        findViewById<ComposeView>(R.id.root).setContent {
+            Text("Hello World")
+        }
+    }
+}
+```
+
+
+### 简单的可组合函数
+
+使用Compose，您可以通过定义一组接受数据而发出界面元素的可组合函数来构建界面。     
+下面是一个简单的示例，接受一个字符串并现实一个问号信息:    
+
+```kotlin
+@Composable
+fun Greeting(name: String) {
+    Text("Hello $name)
+}
+```
+
+- 此函数带有@Composable注释。所有可组合函数都必须带有此注释。此注释可告知Compose编译器:此函数旨在将数据转换为界面。     
+- 此函数可以在界面中显示文本。为此，它会调用Text()可组合函数，该函数实际上会创建文本界面元素。可组合函数通过调用其他可组合函数来发出界面层次结构。 
+
+
+
+### 在Composet中使用View组件
+
+不少功能性的传统视图控件在Compose中没有对应的Composable实现，例如SurfaceView、
+WebView、MapView等。     
+
+因此在Compose中可能会有使用传统View控件的需求。     
+Compose提供了名为AndroidView的Composable组件，允许在Composable中插入任意基于继承自View的传统试图控件。   
+
+```kotlin
+class MainActivity2 : AppCompatActivity() {
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        setContent {
+            AndroidView(factory = {context ->
+                WebView(context).apply {
+                    settings.javaScriptEnabled = true
+                    webViewClient = WebViewClient()
+                    loadUrl("https://www.baidu.com")
+                }
+            }, modifier = Modifier.fillMaxSize())
+        }
+    }
+}
+```
+AndroidView中传入一个工厂的实现，工厂方法中可以获取Composable所在的Context，并基于其构建View视图控件。  
+
+### Modifier
+
+Modifier是一个装饰或者添加行为的有序的，不变的集合。     
+例如background、padding、宽高、焦点点击事件等。   
+例如给Text设置单行、给Button设置个中点击状态等行为。    
+其实就是所有控件的通用属性都在Modifier中。  
+
+
+在Compose中，每个组件都是一个带有@Composable注解的函数，被称为Composable。   
+Compose中已经预置了很多基础的Composable组件，他们都是基于Material Design规范设计，例如Button、TextField、TopAppBar等。   
+
+在布局方面，Compose提供了Column、Row、Box三种布局组件，类似于传统视图开发中的LinearLayout(Vertical)、LinearLayout(Horizontal)、RelativeLayout。   
diff --git "a/Jetpack/ui/Jetpack Compose\347\273\204\344\273\266.md" "b/Jetpack/ui/Jetpack Compose\347\273\204\344\273\266.md"
new file mode 100644
index 00000000..3ffcb46e
--- /dev/null
+++ "b/Jetpack/ui/Jetpack Compose\347\273\204\344\273\266.md"	
@@ -0,0 +1,106 @@
+# Jetpack Compose组件
+
+### Text组件
+
+```kotlin
+Text(text = "Hello World")
+Text(
+    text = stringResource(id = R.string.next),
+    style = TextStyle(
+        fontSize = 25.sp,
+        fontWeight = FontWeight.Bold,
+        lineHeight = 35.sp,
+        color = Color.Red,
+        textDecoration = TextDecoration.LineThrough,
+        fontStyle = FontStyle.Italic
+    )
+)
+```
+
+#### AnnotatedString多样式文字
+
+在很多应用场景中，我们需要在一段文字中对局部内容应用特别格式以示突出，比如一个超链接或者一个电话号码等，此时需要用到AnnotatedString。AnnotatedString是一个数据类，除了文本值，它还包含了一个SpanStyle和ParagraphStyle的Range列表。SpanStyle用于描述在文本中子串的文字样式，ParagraphStyle则用于描述文本中子串的段落样式，Range确定子串的范围。
+
+```kotlin
+val annotedText = buildAnnotatedString {
+    withStyle(style = SpanStyle(fontSize = 23.sp)) {
+        pushStringAnnotation(tag = "url", annotation = "https://www.baidu.com")
+        append("haha")
+    }
+
+    withStyle(SpanStyle(fontSize = 30.sp)) {
+        append("A")
+    }
+}
+
+ClickableText(
+    text = annotedText,
+    onClick = { offset ->
+        annotedText.getStringAnnotations(tag = "url", start = offset, end = offset)
+            .firstOrNull()?.let {
+            Log.e("@@@", it.item)
+        }
+    }
+)
+```
+
+Compose提供了一种可点击文本组件ClickedText，可以响应我们对文字的点击，并返回点击位置。可以让AnnotatdString子串在相应的ClickedText中点击后，做出不同的动作。
+
+
+
+
+
+### SelectionContainer
+
+选中文字Text自身默认是不能被长按选择的，否则在Button中使用时，又会出现那种“可粘贴的Button”的例子。       
+Compose提供了专门的SelectionContainer组件，对包裹的Text进行选中。可见Compose在组件设计上，将关注点分离的原则发挥到了极致。
+
+
+```kotlin
+SelectionContainer {
+    Text("hahah")
+}
+```
+
+
+
+### TextField输入框
+
+
+TextField有两种风格，一种是默认的，也就是filled，另一种是OutlinedTextField。      
+```kotlin
+var text by remember { mutableStateOf("") }
+
+TextField(value = text, onValueChange = {
+    text = it
+}, label = { Text("请输入用户名") })
+```
+
+这个text是一个可以变化的文本，用来显示TextField输入框中当前输入的文本内容。           在onValueChange回调中可以获取来自软键盘的最新输入，我们利用这个信息来更新可变状态text，驱动界面刷新显示最新的输入文本。
+
+
+***来自软键盘的输入内容不会直接更新TextField, TextField需要通过观察额外的状态更新自身，这也体现了声明式UI中“状态驱动UI”的基本理念。***
+
+
+
+
+
+### Column组件
+
+很多产品中都有展示一组数据的需求场景，如果数据数量是可以枚举的，则仅需通过Column组件来枚举列出。 
+
+
+然而很多时候，列表中的项目会非常多，例如通讯录、短信、音乐列表等，我们需要滑动列表来查看所有的内容，可以通过Column的Modifier添加verticalScroll()方法来让列表实现滑动。     
+
+
+#### LazyComposables
+
+给Column的Modifier添加verticalScroll()方法可以让列表实现滑动。    
+
+但是如果列表过长，众多的内容会占用大量的内存。然而更多的内容对于用户其实都是不可见的，没必要记载到内存。     
+
+所以Compose提供了专门用于处理长列表的组件，这些组件指挥在我们能看到的列表部分进行重组和布局，它们分别是LazyColumn和LazyRow。其作用类似于传统视图中的ListView或者RecyclerView。   
+
+
+
+
diff --git "a/Jetpack/ui/\345\257\271\346\257\224.md" "b/Jetpack/ui/\345\257\271\346\257\224.md"
new file mode 100644
index 00000000..644118ec
--- /dev/null
+++ "b/Jetpack/ui/\345\257\271\346\257\224.md"
@@ -0,0 +1,68 @@
+# 对比
+
+
+当前，Android开发正经历着从\"代码工人\"到\"智能场景架构师\"的转型。传统的XML布局开发模式正被声明式UI取代，云端AI计算快速向设备端迁移，跨平台技术也从\"能用\"向\"好用\"演进。
+
+
+1. 界面开发革命：Compose主导的声明式转型
+Jetpack Compose已不再是\"未来技术\"，而是现在的必备技能。数据显示，使用Compose后，页面开发周期可缩短70% 。更有性能测试表明，在折叠屏设备上，传统的RecyclerView滑动帧率下降至45fps，而Compose的LazyColumn能稳定在60fps 。
+
+
+
+2. 设备端AI：从云端到终端的算力迁移
+设备端AI正成为移动开发的新战场。2025年三大杀手级应用已落地：实时视频抠图、离线语音合成、智能代码补全。
+成本对比数据令人震惊：对于月活100万的应用，使用设备端AI进行图片风格迁移的成本几乎为零，而云端方案成本约为2000美元/月 。这种成本优势，加上设备端AI在延迟和隐私保护上的优势，使得端侧智能成为必然趋势。
+
+
+
+传统的 Android UI 开发采用的是 View 视图体系，它是一种命令式的编程模型。开发者需要通过编写大量的代码来描述 View 的外观和行为，包括布局、样式、交互等。这种方式需要开发者花费大量的时间和精力，而且代码量也非常庞大，维护和扩展也比较困难。
+
+与之相比，Jetpack Compose 是一种声明式的编程模型，采用的是函数式编程的思想。开发者只需要描述 UI 的样式和行为，然后 Jetpack Compose 会自动处理 View 的布局和绘制。这种方式不仅减少了代码量，还可以提高开发效率，同时也使得代码更加易于维护和扩展。
+
+那 Data Binding 呢？用过的人自然能明白其中的痛苦，在 xml 文件中编写代码。并且还需要先解析 xml 文件，效率自然会有影响。而 Jetpack Compose 代码完全基于 Kotlin DSL 实现，相较于 Data Binding 需要有 xml 的依赖，Compose 只依赖单一语言，避免了因为语言间交互而带来的性能开销及安全问题。
+
+
+传统的 View 视图是基于继承的结构体系，也已经随着 Android 发展了十多年。View.java 本身也变得十分臃肿，目前已经超过三万行。臃肿的父类控件，也会造成子类视图的功能不合理。以 Button 为例，为了能让 Button 具备显示文字的功能，Button 被设计成了继承自 TextView 的子类。这样有很多不适用于按钮的功能也被继承下来了，TextView 的剪贴板功能，对 Button 来说显得不合理。而且随着 TextView 自身功能的迭代，Button 可能引入更多不必要的功能。
+另一方面，想 Button 这类基础控件，只能跟随系统升级而更新，及使发现了问题，也得不到及时的修复。这也是为什么如今很多新的视图都以 Jetpack 扩展库的形式单独发布的原因。
+而 Jetpack Compose 则是作为函数，相互之间没有继承关系。让开发这更多的是以组合的思想去思考问题。
+
+
+
+3.1 声明式 UI 的编程范式发展的趋势
+从编程范式的维度来说，声明式 UI 相对传统的命令式 UI，更加先进， React， iOS 的 SwiftUI， flutter， Jetpack Compose， 声明式 UI 开发思想已经席卷了整个前端开发领域。如果你还在使用传统 View 视图体系开发 Android 原生界面，那你应该尝试声明式 UI。
+
+
+如同 Kotlin 取代 Java 成为 Google 推荐的 Android 官方推荐的编程语言一样，Jetpack Compose 也是 Google 推荐的 Android 官方 UI 框架。并且，新版的 Android Studio 中集成了大量的特性来支持 Jetpack Compose 更高效的开发。这表明 Jetpack Compose 在未来的 Android 开发中将扮演重要的角色。目前来看，Jetpack Compose 并不会完全取代传统的 View 视图体系，而是会和传统 View 视图体系共存， 但是 Jetpack Compose 在未来会能成为 Android 开发的主流。从 Android 14 Framework 中我们能看到 Compose 的影子了。在 2018 年，SystemUI 模块中，我们能看到 Kotlin 改写的部分模块，在 Android 14 中，我们再 Settings 中再次看到了 Kotlin 的代码了。并且 Google 新建了一个 spa 包，这个包里面尝试把 “应用管理”、“应用管理通知”、“使用情况” 页面用 Jetpack Compose 重写了。
+
+
+
+四、Jetpack Compose 与 View 视图体系对比
+Compose 重新定义了 Android UI 开发方式，大幅提升了开发效率，主要体现在：
+
+声明式 UI， 不需要手动刷新数据
+取消 XML, 完全解除了混合写法的(XML + java、Kotlin) 的局限性，以及性能开销
+超强兼容性，大多数 jetpack 库(如 Navigation、ViewModel) 以及 Kotlin 协程都适用于 Compose, Compose 能够与现有 View 体系并存，你可以为一个既有项目引入 Compose。
+加速开发，更简单的动画和触摸事件Api, Compose 为我们提供了很多开箱即用的 Material 组件，如果的APP是使用的material设计的话，那么使用Jetpack Compose 能让你节省不少精力。
+精简代码数量，减少 bug 的出现
+强大的预览功能， Compose 预览机制可以实时预览动画，交互式预览，真正所见即所得。
+
+
+
+4.1.1 APK 尺寸缩减
+
+
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/tvi_compose_apk_size.png?raw=true)
+
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/tvi_compose_method_count.png?raw=true)
+
+在将迁移后的应用与接入 Compose 前的应用做比较后，我们发现 APK 大小缩减了 41%，方法数减少了 17%。
+
+
+4.1.3 构建速度
+
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/tvi_compose_build_time.png?raw=true)
+
+
+        
+
+
diff --git "a/KotlinCourse/1.Kotlin_\347\256\200\344\273\213&\345\217\230\351\207\217&\347\261\273&\346\216\245\345\217\243.md" "b/KotlinCourse/1.Kotlin_\347\256\200\344\273\213&\345\217\230\351\207\217&\347\261\273&\346\216\245\345\217\243.md"
index 6128245e..6bd6e2fe 100644
--- "a/KotlinCourse/1.Kotlin_\347\256\200\344\273\213&\345\217\230\351\207\217&\347\261\273&\346\216\245\345\217\243.md"
+++ "b/KotlinCourse/1.Kotlin_\347\256\200\344\273\213&\345\217\230\351\207\217&\347\261\273&\346\216\245\345\217\243.md"
@@ -324,10 +324,42 @@ var myProperty: String
     }
 ```
 
+自定义set和get的重点在field，field指代当前参数，类似于java的this关键字。   
+
 这意味着无论何时当你使用点操作符来获取或设置属性值时，实际上你总是调用了属性的getter或是setter。那么，为什么编译器要这么做呢？
 为属性添加getter和setter意味着有访问该属性的标准方法。getter处理获取值的所有请求，而setter处理所有属性值设置的请求。
 因此，如果你想要改变处理这些请求的方式，你可以在不破坏任何人代码的前提下进行。通过将其包装在getter和setter中来输出对属性的直接访问称为数据隐藏。
 
+
+在某些情况下，无参的函数与只读属性可互换通用。虽然语义相似，但在以下情况中，更多的是选择使用属性而不是方法。 
+
+- 不会抛出任何异常。
+- 具有O(1)的复杂度。
+- 容易计算(或者运行一次之后缓存结果)。
+- 每次调用返回同样的结果。 
+
+
+
+## 后端属性(Blocking Property)
+
+它实际上是一个隐含的对属性值的初始化声明。能有效避免空指针问题的产生。 
+
+```kotlin
+var size: Int = 2;
+private var _table: Map<toString, Int>? = null
+
+val table: Map<String, Int> 
+    get() {
+        if (_table == null) {
+            _table = HashMap()
+        }
+        return _table ?: throw AssertionError("Set to null by another thread")
+    }
+```
+
+在Java中，访问private成员变量需要通过getter和setter来实现，此处通过table来获取_table变量，优化了Java中函数调用带来的开销。  
+
+
 ## 延迟初始化
 
 在类内声明的属性必须初始化，如果设置非`null`的属性，应该将此属性在构造器内进行初始化。
@@ -461,6 +493,61 @@ private var lazyValue: Fragment? = null
 
 当您稍后需要在代码中初始化var时，请选择lateinit，它将被重新分配。当您想要初始化一个val值一次时，特别是当初始化的计算量很大时，请选择by lazy。
 
+```kotlin
+val name: String by lazy {getName()}
+```
+这样，当第一次使用name引用时，getName()函数只会被调用一次。此外，还可以使用函数引用代替lambda表达式:   
+```kotlin
+val name: String by lazy(::getName)
+
+fun getName() : String {
+    println("computing name")
+    return "Mockey"
+}
+```
+
+
+## @操作符
+
+在Kotlin中，@操作符主要有两个作用:  
+
+- 限定this的对象类型
+```kotlin
+class User {
+    inner class State {
+        fun getUser(): User {
+            return this@User   // 返回User
+        }
+
+        fun getState(): State {
+            return this@State // 返回State
+        }
+
+    }
+}
+```
+- 作为标签使用
+当把@操作符作为标签使用时，可以跳出双层for循环和forEach函数。
+例如:   
+```kotlin
+val listA = listOf(1, 2, 3, 4, 5, 6)
+val listB = listOf(2, 3, 4, 5, 6, 7 )
+
+loop@ for(itemA in listA) {
+    var i: Int = 0
+    for (itemB in listB) {
+        i++
+        if (item > 2) {
+            break @loop  // 当itemB > 2时，跳出循环
+        }
+        println("itemB: $itemB")
+    }
+}
+```
+
+
+
+
 
 ## 类的定义:使用`class`关键字
 
@@ -586,8 +673,8 @@ class Person{
 }
 ```
 
-如果类有一个主构造函数，每个次构造函数都需要委托给主构造函数(不然会报错)， 可以直接委托或者通过别的次构造函数间接委托。
-委托到同一个类的另一个构造函数用`this`关键字即可:    
+**如果类有一个主构造函数，每个次构造函数都需要委托给主构造函数(不然会报错)， 可以直接委托或者通过别的次构造函数间接委托。
+委托到同一个类的另一个构造函数用`this`关键字即可:**    
 ```kotlin
 class Person constructor(name: String) {
     constructor(name: String, surName: String) : this(name) {
@@ -616,6 +703,25 @@ class Person private constructor(name: String) {
 }
 ```
 
+
+
+```kotlin
+open class Base(p: Int)
+class Example(p: Int) : Base(p)
+```
+
+如果该类有一个主构造函数，那么其基类型可以用主构造函数的参数进行初始化。   
+**如果该类没有主构造函数，那么每个次构造函数必须使用super关键字初始化其类型，或者委托给另一个构造函数初始化**。如：   
+```kotlin
+class Example : View {
+    constructor(ctx: Context) : super(ctx)
+
+    constructor(ctx: Context, attrs: AttributeSet) : super(ctx, attrs)
+}
+```
+
+
+
 #### 构造方法默认参数
 
 ```kotlin
@@ -827,6 +933,48 @@ var age = f1.component2()
 对于有些不需要toString()、equals()、hashCode()方法的类如果使用数据类就会导致多生成这些代码，所以在使用数据类的时候不要去为了简单而乱用，
 也要去想想是否需要这些方法？是否需要设计成数据类。
 
+
+#### 获取类中成员函数的对象
+
+```kotlin
+fun main(args: Array<String>) {
+    var user = User::special
+    // 调用invoke函数执行
+    user.invoke(User("Jack", 30))
+
+    // 利用反射机制获取指定方法的内容
+    var method = User::class.java.getMethod("special")
+    method.invoke(User("Tom", 20))
+}
+
+class User(val name: String, val age: Int) {
+    fun special() {
+        println("name:${name") age:${age}");
+    }
+}
+```
+
+**在上面的实例中，User类还有一个special函数，使用User::special可以获取成员函数的对象，然后使用invoke函数调用special函数，以获取该函数的内容。**   
+
+
+### 构造函数引用
+
+**构造函数的引用和属性、方法类似，构造函数可以作用于任何函数类型的对象，该函数的对象与构造函数的参数相同，可以使用::操作符加类名的方式来引用构造函数。** 
+
+```kotlin
+class Foo
+
+fun function(factory: () -> Foo) {
+    val x: Foo = factory()
+}
+
+// 使用::Foo方式调用类Foo的无参数构造函数
+fun main() {
+    function(::Foo)
+}
+```
+
+
 ## 继承
 
 在`Kotlin`中所有类都有一个共同的超类`Any`，这对于没有超类型声明的类是默认超类:   
@@ -882,14 +1030,17 @@ class SuperPerson(num: Int) : Person(num)
 请记住，即使你没有在父类中显式地添加构造函数，编译器也会在编译代码的时候自动创建一个空构造函数。
 假如我们不想为Person类添加构造函数，因此编译器在编译代码的时候创建了一个空构造函数。该构造函数通过使用Person()被调用。
 
-注意： 上面在说到继承的时候`class SuperPerson(num: Int) : Person(num)`在父类后面必须加上括号，这是为了能够调用到父类的主构造函数。
-Kotlin中规定，当一个类既有主构造函数又有次构造函数时，所有的次构造函数都必须调用主构造函数(包括间接调用)。
-但是如果类没有主构造函数，那么每个次构造函数必须使用`super`关键字初始化其基类型，或委托给另一个构造函数做到这一点。 这里很特殊，在Kotlin
-中是允许类中只有次构造函数，没有主构造函数的。当一个类没有显式的定义主构造函数且定义了次构造函数时，它就是没有主构造函数的。
 
-如果该类有一个主构造函数，其基类必须用基类型的主构造函数参数就地初始化。
+***注意： 上面在说到继承的时候`class SuperPerson(num: Int) : Person(num)`在父类后面必须加上括号，这是为了能够调用到父类的主构造函数。
+Kotlin中规定，当一个类既有主构造函数又有次构造函数时，所有的次构造函数都必须调用主构造函数(包括间接调用)。***
+***但是如果类没有主构造函数，那么每个次构造函数必须使用`super`关键字初始化其基类型，或委托给另一个构造函数做到这一点。 这里很特殊，在Kotlin
+中是允许类中只有次构造函数，没有主构造函数的。当一个类没有显式的定义主构造函数且定义了次构造函数时，它就是没有主构造函数的。***
+
+***如果该类有一个主构造函数，其基类必须用基类型的主构造函数参数就地初始化。***
+
+***如果类没有主构造函数，那么每个次构造函数必须使用`super`关键字初始化其基类型，或委托给另一个构造函数做到这一点。***
+
 
-如果类没有主构造函数，那么每个次构造函数必须使用`super`关键字初始化其基类型，或委托给另一个构造函数做到这一点。
 注意，在这种情况下，不同的次构造函数可以调用基类型的不同的构造函数:   
 
 ```kotlin
@@ -898,11 +1049,15 @@ class MyView : View {
     constructor(ctx: Context, attrs: AttributeSet) : super(ctx, attrs)
 }
 ```
-也就是MyView类的后面没有显式的定义主构造函数，同时又定义了次构造函数。所以现在MyView类是没有主构造函数的。那么既然没有主构造函数，继承View类
-的时候也就不需要再在View类后加上括号了。其实原因就是这么简单，只是很多人在刚开始学习Kotlin的时候没能理解这对括号的意义和规则，因此总感觉继承的
+
+也就是MyView类的后面没有显式的定义主构造函数，同时又定义了次构造函数。所以现在MyView类是没有主构造函数的。     
+
+***那么既然没有主构造函数，继承View类的时候也就不需要再在View类后加上括号了。***
+
+其实原因就是这么简单，只是很多人在刚开始学习Kotlin的时候没能理解这对括号的意义和规则，因此总感觉继承的
 写法有时候要加上括号，有时候又不要加，搞得晕头转向的，而在你真正理解了规则之后，就会发现其实还是很好懂的。
 
-另外，由于没有主构造函数，次构造函数只能直接调用父类的构造函数，上述代码也是将this关键字换成了super关键字，这部分就很好理解了。
+***另外，由于没有主构造函数，次构造函数只能直接调用父类的构造函数，上述代码也是将this关键字换成了super关键字，这部分就很好理解了。***
 
 
 ### Any
@@ -1135,14 +1290,15 @@ Unit与Int一样，都是一种类型，然而它不代表任何信息，用面
 
 ### 表达式函数体
 
-如果返回的结果可以使用一个表达式计算出来，你可以不使用括号而是使用等号:         
+***如果一个函数的返回的结果可以使用一个表达式计算出来，你可以不使用括号而是使用等号***:         
 
 ```kotlin
 fun add(x: Int,y: Int) : Int = x + y // 省略了{}
 ```
 
-Kotlin支持这种单行表达式与等号的语法来定义函数，叫做表达式函数体，作为区分，普通的函数声明则可以叫做代码块函数体。如你所见，在使用表达式函数体
-的情况下我们可以不声明返回值类型，这进一步简化了语法。
+***Kotlin支持这种单行表达式与等号的语法来定义函数，叫做表达式函数体，作为区分，普通的函数声明则可以叫做代码块函数体。***    
+
+如你所见，在使用表达式函数体的情况下我们可以不声明返回值类型，这进一步简化了语法。
 
 我们可以给参数指定一个默认值使的它们变的可选，这是非常有帮助的。这里有一个例子，在`Activity`中创建了一个函数用来`Toast`一段信息:    
 
@@ -1200,6 +1356,11 @@ val mList2 = vars(0, *myArray, 6, 7)
 ```
 
 
+在Kotlin中，方法调用也被定义为二元操作运算符，而这些方法往往可以转化为invoke函数。
+例如 a(i)方法的对应转换方法为 a.invoke(i)
+
+
+
 ## 命名风格
 
 如果拿不准的时候，默认使用`Java`的编码规范，比如:   
@@ -1214,7 +1375,7 @@ val mList2 = vars(0, *myArray, 6, 7)
 
 ### 类布局
 
-通常，一个类的内容按以下顺序排列：
+通常，一个类的内容按以下顺序排列:      
 
 - 属性声明与初始化块
 - 次构造函数
diff --git "a/KotlinCourse/2.Kotlin_\351\253\230\351\230\266\345\207\275\346\225\260&Lambda&\345\206\205\350\201\224\345\207\275\346\225\260.md" "b/KotlinCourse/2.Kotlin_\351\253\230\351\230\266\345\207\275\346\225\260&Lambda&\345\206\205\350\201\224\345\207\275\346\225\260.md"
index 42440cd9..a3f2b9c9 100644
--- "a/KotlinCourse/2.Kotlin_\351\253\230\351\230\266\345\207\275\346\225\260&Lambda&\345\206\205\350\201\224\345\207\275\346\225\260.md"
+++ "b/KotlinCourse/2.Kotlin_\351\253\230\351\230\266\345\207\275\346\225\260&Lambda&\345\206\205\350\201\224\345\207\275\346\225\260.md"
@@ -1,8 +1,64 @@
 2.Kotlin_高阶函数&Lambda&内联函数
 ===
 
+## 函数还是属性
+
+在某些情况下，不带参数的函数可与只读属性互换。 虽然语义相似，但是在某种程度上有一些风格上的约定。
+
+底层算法优先使用属性而不是函数：
+
+- 不会抛异常
+- 计算开销小（或者在首次运行时缓存）
+- 如果对象状态没有改变，那么多次调用都会返回相同结果
+
+
 ## 高阶函数
 
+
+高阶函数(Higher Order Function)是一种特殊的函数，它接收函数作为参数，或者返回一个函数。     
+函数的基本格式如下:   
+
+```kotlin
+fun 高阶函数名(参数函数名: 参数函数类型): 高阶函数返回类型 {
+    // 高阶函数体
+}
+```
+
+高阶函数的一个很好的例子就是lock函数，它的参数是一个Lock类型对象和一个函数。 
+
+该函数执行时获取锁，运行函数参数，运行结束后再释放锁。  
+```kotlin
+fun <T> lock(lock: Lock, body: () -> T): T {
+    lock.lock()
+    try {
+        return body()
+    } finally {
+        lock.unlock()
+    }
+}
+```
+在这个例子中，body为函数的类型对象，该函数是一个无参函数，而且返回值类型是T。 
+
+调用lock函数时，可以传入另一个函数作为参数。  
+
+***和许多编程语言类似，如果函数的最后一个参数也是函数，则该函数参数还可以定义在括号外面***，如:   
+```kotlin
+val result = lock(lock, { sharedResource.operation()})
+// 等同于
+lock(lock) {
+    sharedResource.operation()
+}
+```
+
+
+高阶函数类似C语言的函数指针，它的另一个使用场景是map函数。
+
+***如果函数只有一个参数，则可以忽略声明的函数参数，用it来代替。***   
+
+```kotlin
+val doubled = mMap.map {it -> it * 2}
+```
+
 Kotlin天然支持了部分函数式特性。函数式语言一个典型的特征就在于函数是头等公民——我们不仅可以像类一样在底层直接定义一个函数，也可以在一个函数内部定义一个局部函数。 
 
 ```kotlin
@@ -138,7 +194,8 @@ class CountryTest {
 
 - 需要把isBigEuropeanCountry的方法引用当做参数传递给filterCountries
 
-    Kotlin存在一种特殊的语法，通过两个冒号来实现对于某个类的方法进行引用(方法引用表达式)。以上面的代码为例，假如我们有一个CountryTest类的对象实例countryTest，如果要引用它的isBigEuropeanCountry方法，就可以这样写:   
+    **Kotlin存在一种特殊的语法，通过两个冒号来实现对于某个类的方法进行引用(方法引用表达式)。**
+    以上面的代码为例，假如我们有一个CountryTest类的对象实例countryTest，如果要引用它的isBigEuropeanCountry方法，就可以这样写:   
 
     ```kotlin
     countryTest::isBigEuropeanCountry
@@ -225,7 +282,9 @@ countryApp.filterCountries(countries, {
 })
 ```
 
-这就是Lambda表达式，它与匿名函数一样，是一种函数字面量。
+这就是Lambda表达式。
+
+Lambda表达式本质上是一个匿名函数，它是一种函数字面值，即一个没有声明的函数，可以把该函数当做普通表达式进行参数传递，它可以访问自己的闭包函数。   
 
 首先来看一下Lambda的定义，如果用最直白的语言来阐述的话，Lambda就是一小段可以作为参数传递的代码。从定义上看，这个功能就很厉害了，因为正常情况下，我们向某个函数传参时只能传入变量，而借助Lambda却允许传入一小段代码。这里两次使用了“一小段代码”这种描述，那么到底多少代码才算一小段代码呢？Kotlin对此并没有进行限制，但是通常不建议在Lambda表达式中编写太长的代码，否则可能会影响代码的可读性。
 
@@ -260,26 +319,27 @@ val foo = { x: Int ->
 ```java
 // 没有使用Lambda的老方法:   
 button.addActionListener(new ActionListener(){
-	public void actionPerformed(ActionEvent ae){
-		System.out.println("Actiondetected");
-	}
+    public void actionPerformed(ActionEvent ae){
+        System.out.println("Actiondetected");
+    }
 });
 // 使用Lambda:  
-button.addActionListener(()->{ 
-	System.out.println("Actiondetected");
+button.addActionListener(() -> { 
+    System.out.println("Actiondetected");
 });
 
 
 // 不采用Lambda的老方法: 
-Runnable runnable1=new Runnable(){
-	@Override
-	public void run(){
-		System.out.println("RunningwithoutLambda");
-	}
+Runnable runnable1 = new Runnable() {
+    @Override
+    public void run() {
+        System.out.println("RunningwithoutLambda");
+    }
 };
+
 // 使用Lambda:   
-Runnable runnable2=()->{
-	System.out.println("RunningfromLambda");
+Runnable runnable2 = () -> {
+    System.out.println("RunningfromLambda");
 };
 ```
 
@@ -310,10 +370,10 @@ max(strings, compare)
 ```
 就是找出`strings`里面最长的那个。但是我个人觉得`compare`还是很碍眼的，因为我并不想在后面引用他，那我怎么办呢，就是用“匿名函数”方式。
 ```kotlin
-max(strings, (a,b)->{a.length < b.length})
+max(strings, (a,b) -> {a.length < b.length})
 ```
 
-`(a,b)->{a.length < b.length}`就是一个没有名字的函数，直接作为参数赋给`max`方法的第二个参数。但这个方法有很多东西都没有写明，如:   
+`(a,b) -> {a.length < b.length}`就是一个没有名字的函数，直接作为参数赋给`max`方法的第二个参数。但这个方法有很多东西都没有写明，如:   
 
 - 参数的类型
 - 返回值的类型
@@ -362,7 +422,7 @@ val msg = { x: Int -> "xxx" }
 (Int) -> String
 ```
 
-如果将lambda赋值给一个变量，编译器会根据该lambda来推测变量的类型，如上例所示。然而，就像任何其他类型的对象一样，你可以显式地定义该变量的类型。例如，以下代码定义了一个变量add，该变量可以保存对具有两个Int参数并返回Int类型的lambda的引用：
+如果将lambda赋值给一个变量，编译器会根据该lambda来推测变量的类型，如上例所示。然而，就像任何其他类型的对象一样，你可以显式地定义该变量的类型。例如，以下代码定义了一个变量add，该变量可以保存对具有两个Int参数并返回Int类型的lambda的引用:      
 
 ```kotlin
 val add: (Int, Int) -> Int
@@ -373,7 +433,8 @@ add = { x: Int, y: Int -> x + y }
 Lambda类型也被认为是函数类型。
 
 
-当Lambda表达式的参数列表中只有一个参数时，也不必声明参数名，而是可以使用it关键字来代替.
+**当Lambda表达式的参数列表中只有一个参数时，那么可以不声明唯一的参数名，而是可以使用it关键字来代替，因为Kotlin会隐含的声明一个名为it的参数.这叫做单个参数的隐式名称，代表了这个Lambda所接收的单个参数**    
+
 ```kotlin
 val list = listOf("Apple", "Bnana", "Orange", "Pear")
 val maxLengthFruit = list.maxBy {it.length}
@@ -388,13 +449,13 @@ fun foo(int: Int) = {
 listOf(1, 2, 3).forEach { foo(it) } // 对一个整数列表的元素遍历调用foo
 ```
 
-这里，你可定会纳闷it是啥？其实它也是Kotlin简化Lambda表达的一种语法糖，叫做单个参数的隐式名称，代表了这个Lambda所接收的单个参数。这里的调用等价于:  
+这里的调用等价于:  
 
 ```kotlin
 listOf(1, 2, 3).forEach { item -> foo(item) }
 ```
 
-如果lambda具有一个单独的参数，而且编译器能够推断其类型，你可以省略该参数，并在lambda的主体中使用关键字it指代它。要了解它是如何工作的，如前所述，假设使用以下代码将lambda赋值给变量：
+假设使用以下代码将lambda赋值给变量：
 
 ```kotlin
 val addFive: (Int) -> Int = { x -> x + 5 }
@@ -406,7 +467,11 @@ val addFive: (Int) -> Int = { x -> x + 5 }
 val addFive: (Int) -> Int = { it + 5 }
 ```
 
-在上述代码中，{it+5}等价于{x->x+5}，但更加简洁。请注意，你只能在编译器能够推断该参数类型的情况下使用it语法。例如，以下代码将无法编译，因为编译器不知道it应该是什么类型：
+在上述代码中，{it+5}等价于{x->x+5}，但更加简洁。      
+
+请注意，你只能在编译器能够推断该参数类型的情况下使用it语法。       
+
+例如，以下代码将无法编译，因为编译器不知道it应该是什么类型：
 
 ```kotlin
 val addFive = { it + 5 } // 该代码无法编译，因为编译器不能推断其类型
@@ -416,7 +481,7 @@ val addFive = { it + 5 } // 该代码无法编译，因为编译器不能推断
 
 
 
-我们看一下foo函数用IDE转换后的Java代码:  
+我们看一下foo函数用IDE转换后的Java代码:      
 
 ```java
 @JvmStatic
@@ -472,20 +537,27 @@ listOf(1, 2, 3).forEach{ foo(it)() }
 
 ## 闭包
 
-在Kotlin中，你会发现匿名函数体、Lambda在语法上都存在“{}"，由这对花括号包裹的代码如果访问了外部环境变量则被称为一个闭包。一个闭包可以被当做参数传递或直接使用，它可以简单的看成”访问外部环境变量的函数“。Lambda是Kotlin中最常见的闭包形式。
+
+**闭包就是能够读取其他函数内部变量的函数。**   
+
+它是函数内部和函数外部信息交换的桥梁。   
+
+在Kotlin中，Lambda表达式或匿名函数(局部函数、对象表达式等)都可以访问它的闭包。 
+
+在Kotlin中，你会发现匿名函数体、Lambda在语法上都存在“{}"，由这对花括号包裹的代码如果访问了外部环境变量则被称为一个闭包。      
+一个闭包可以被当做参数传递或直接使用，它可以简单的看成”访问外部环境变量的函数“。Lambda是Kotlin中最常见的闭包形式。
 
 与Java不一样的地方在于，Kotlin中的闭包不仅可以访问外部变量，还能够对其进行修改(我有点疑惑，Java为啥不能修改？下面说)，如下： 
 
 ```kotlin
 var sum = 0
 listOf(1, 2, 3).filter { it > 0 }.forEach {
+    // 外部的变量，且可以修改
     sum += it
 }
 println(sum)  // 6
 ```
 
-看到这里我是懵逼的？ 到底什么是闭包？ 闭包有什么作用？ 
-
 闭包就是能够读取其他函数内部变量的函数。例如在javascript中，只有函数内部的子函数才能读取局部变量，所以闭包可以理解成“定义在一个函数内部的函数“。在本质上，闭包是将函数内部和函数外部连接起来的桥梁。--百度百科
 第一句总结的很简洁了：闭包就是能够读取其他函数内部变量的函数。
 
@@ -568,7 +640,7 @@ What java docs says about “Local Inner class cannot access the non-final local
 
 
 
-JVM create create a synthetic field inside the inner class in java -
+JVM create a synthetic field inside the inner class in java -
 
 As final variable will not change after initialization, when a inner class access final local variables **compiler create a synthetic field inside the inner class and also copy that variable into the heap.** So, these synthetic fields can be accessed inside local inner class even when execution of method is over in java.
 
@@ -625,7 +697,9 @@ fun main() {
 
 是不是发现了新世界的大门，内部函数很轻松地调用了外部变量a。
 
-这只是一个最简单的闭包实现。按照这种思想，其他的实现例如：函数、条件语句、Lambda表达式等等都可以理解为闭包，这里不再赘述。不过万变不离其宗，只要记得一句话：**闭包就是能够读取其他函数内部变量的函数**。就是一个函数A可以访问另一个函数B的局部变量，即便另一个函数B执行完成了也没关系。目前把满足这样条件的函数A叫做闭包。
+这只是一个最简单的闭包实现。按照这种思想，其他的实现例如：函数、条件语句、Lambda表达式等等都可以理解为闭包，这里不再赘述。    
+
+不过万变不离其宗，只要记得一句话：**闭包就是能够读取其他函数内部变量的函数**。就是一个函数A可以访问另一个函数B的局部变量，即便另一个函数B执行完成了也没关系。目前把满足这样条件的函数A叫做闭包。
 
 
 
@@ -633,13 +707,21 @@ fun main() {
 
 ## 内联函数
 
-刚被闭包搞蒙，这里又没搞明白内联函数到底是干什么？ 有什么作用？Kotlin中的内联函数其实显得有点尴尬，因为它之所以被设计出来，主要是为了优化Kotlin支持Lambda表达式之后所带来的开销。然而，在Java中我们似乎并不需要特别关注这个问题，因为在Java 7之后，JVM引入了一种叫做invokedynamic的技术，它会自动帮助我们做Lambda优化。但是为什么Kotlin要引入内联函数这种手动的语法呢？ 这主要还是因为Kotlin要兼容Java 6。
+刚被闭包搞蒙，这里又没搞明白内联函数到底是干什么？ 有什么作用？Kotlin中的内联函数其实显得有点尴尬，因为它之所以被设计出来，主要是为了优化Kotlin支持Lambda表达式之后所带来的开销。     
+
+然而，在Java中我们似乎并不需要特别关注这个问题，因为在Java 7之后，JVM引入了一种叫做invokedynamic的技术，它会自动帮助我们做Lambda优化。但是为什么Kotlin要引入内联函数这种手动的语法呢？ 这主要还是因为Kotlin要兼容Java 6。
 
 
 
 ## 优化Lambda开销
 
-在Kotlin中每声明一个Lambda表达式，就会在字节码中产生一个匿名类(也就是说我们一直使用的Lambda表达式在底层被转换成了匿名类的实现方式)。该匿名类包含了一个invoke方法，作为Lambda的调用方法，每次调用的时候，还会创建一个新的匿名类对象。可想而知，Lambda语法虽然简洁，但是额外增加的开销也不少。并且，如果Lambda捕捉了某个变量，那么每次调用的时候都会创建一个新的对象，这样导致效率较低。尤其对Kotlin这门语言来说，它当今优先要实现的目标，就是在Android这个平台上提供良好的语言特性支持。Kotlin要在Android中引入Lambda语法，必须采用某种方法来优化Lambda带来的额外开销，也就是内联函数。 
+在Kotlin中每声明一个Lambda表达式，就会在字节码中产生一个匿名类(也就是说我们一直使用的Lambda表达式在底层被转换成了匿名类的实现方式)。      
+
+该匿名类包含了一个invoke方法，作为Lambda的调用方法，每次调用的时候，还会创建一个新的匿名类对象。      
+
+可想而知，Lambda语法虽然简洁，但是额外增加的开销也不少。并且，如果Lambda捕捉了某个变量，那么每次调用的时候都会创建一个新的对象，这样导致效率较低。     
+
+尤其对Kotlin这门语言来说，它当今优先要实现的目标，就是在Android这个平台上提供良好的语言特性支持。Kotlin要在Android中引入Lambda语法，必须采用某种方法来优化Lambda带来的额外开销，也就是内联函数。 
 
 #### 1. invokedynamic
 
@@ -655,7 +737,9 @@ fun main() {
 
 invokedynamic固然不错，但Kotlin不支持它的理由似乎也很充分，我们有足够的理由相信，其最大的原因是Kotlin在一开始就需要兼容Android最主流的Java版本SE 6，这导致它无法通过invovkedynamic来解决Android平台的Lambda开销问题。 
 
-因此，作为另一种主流的解决方案，Kotlin拥抱了内联函数，在C++、C#等语言中也支持这种特性。简单的来说，我们可以用inline关键字来修饰函数，这些函数就称为了内联函数。他们的函数体在编译期被嵌入每一个被调用的地方，以减少额外生成的匿名类数，以及函数执行的时间开销。
+因此，作为另一种主流的解决方案，Kotlin拥抱了内联函数，在C++、C#等语言中也支持这种特性。     
+
+简单的来说，我们可以用inline关键字来修饰函数，这些函数就称为了内联函数。他们的函数体在编译期被嵌入每一个被调用的地方，以减少额外生成的匿名类数，以及函数执行的时间开销。
 所以内联函数的工作原理并不复杂，就是Kotlin编译器会将内敛函数中的代码在编译的时候自动替换到调用它的地方，这样也就不存在运行时的开销了。 
 
 所以如果你想在用Kotlin开发时获得尽可能良好的性能支持，以及控制匿名类的生成数量，就有必要来学习下内联函数的相关语法。 
@@ -920,7 +1004,9 @@ fun main() {
     println("main end")
 }
 ```
-这里定义了一个叫作printString()的高阶函数，用于在Lambda表达式中打印传入的字符串参数。但是如果字符串参数为空，那么就不进行打印。注意，Lambda表达式中是不允许直接使用return关键字的，这里使用了return@printString的写法，表示进行局部返回，并且不再执行Lambda表达式的剩余部分代码。现在我们就刚好传入一个空的字符串参数，运行程序，打印结果如下： 
+这里定义了一个叫作printString()的高阶函数，用于在Lambda表达式中打印传入的字符串参数。但是如果字符串参数为空，那么就不进行打印。      
+
+注意，Lambda表达式中是不允许直接使用return关键字的，这里使用了return@printString的写法，表示进行局部返回，并且不再执行Lambda表达式的剩余部分代码。现在我们就刚好传入一个空的字符串参数，运行程序，打印结果如下： 
 ```
 main start
 printString begin
@@ -969,7 +1055,9 @@ inline fun runRunnable(block: () -> Unit) {
 
 ![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/inline_noline_error.png?raw=true)        
 
-这个错误出现的原因解释起来可能会稍微有点复杂。首先，在runRunnable()函数中，我们创建了一个Runnable对象，并在Runnable的Lambda表达式中调用了传入的函数类型参数。而Lambda表达式在编译的时候会被转换成匿名类的实现方式，也就是说，上述代码实际上是在匿名类中调用了传入的函数类型参数。
+这个错误出现的原因解释起来可能会稍微有点复杂。首先，在runRunnable()函数中，我们创建了一个Runnable对象，并在Runnable的Lambda表达式中调用了传入的函数类型参数。      
+
+而Lambda表达式在编译的时候会被转换成匿名类的实现方式，也就是说，上述代码实际上是在匿名类中调用了传入的函数类型参数。
 
 
 而内联函数所引用的Lambda表达式允许使用return关键字进行函数返回，但是由于我们是在匿名类中调用的函数类型参数，此时是不可能进行外层调用函数返回的，最多只能对匿名类中的函数调用进行返回，因此这里就提示了上述错误。
@@ -1009,7 +1097,11 @@ Error: (2, 11) Kotlin: 'return' is not allowed here
 
 #### 具体化参数类型
 
-除了非局部返回之外，内联函数还可以帮助Kotlin实现具体化参数类型。Kotlin与Java一样，由于运行时的类型擦除，我们并不能直接获取一个参数的类型。然而，由于内联函数会直接在字节码中生成相应的函数体实现，这种情况下我们反而可以获得参数的具体类型。我们可以用reified修饰符来实现这一效果。
+除了非局部返回之外，内联函数还可以帮助Kotlin实现具体化参数类型。
+
+**Kotlin与Java一样，由于运行时的类型擦除，我们并不能直接获取一个参数的类型。**  
+
+**然而，由于内联函数会直接在字节码中生成相应的函数体实现，这种情况下我们反而可以获得参数的具体类型。我们可以用reified修饰符来实现这一效果。**
 
 ```kotlin
 fun main(args: Array<String>) {
diff --git "a/KotlinCourse/3.Kotlin_\346\225\260\345\255\227&\345\255\227\347\254\246\344\270\262&\346\225\260\347\273\204&\351\233\206\345\220\210.md" "b/KotlinCourse/3.Kotlin_\346\225\260\345\255\227&\345\255\227\347\254\246\344\270\262&\346\225\260\347\273\204&\351\233\206\345\220\210.md"
index 213e4c91..f4d67cad 100644
--- "a/KotlinCourse/3.Kotlin_\346\225\260\345\255\227&\345\255\227\347\254\246\344\270\262&\346\225\260\347\273\204&\351\233\206\345\220\210.md"
+++ "b/KotlinCourse/3.Kotlin_\346\225\260\345\255\227&\345\255\227\347\254\246\344\270\262&\346\225\260\347\273\204&\351\233\206\345\220\210.md"
@@ -193,11 +193,10 @@ val str = "$s.length is ${s.length}" // 求值结果为 "abc.length is 3"
 
 ### 字符串判等
 
-Kotlin中的判等性主要有两种类型： 
+Kotlin中的判等性主要有两种类型:       
 
-- 结构相等。通过操作符==来判断两个对象的内容是否相等。
-- 引用相等。通
-引用相等由`===`以及其否定形式`!===`操作判断。`a === b`当且仅当`a`和`b`指向同一个对象时求值为`true`。如果比较的是运行时的原始类型，比如Int，那么===判断的效果也等价于==。
+- 结构相等: 通过操作符==来判断两个对象的内容是否相等。
+- 引用相等: 引用相等由`===`以及其否定形式`!===`操作判断。`a === b`当且仅当`a`和`b`指向同一个对象时求值为`true`。如果比较的是运行时的原始类型，比如Int，那么===判断的效果也等价于==。
 
 ```kotlin
 var a = "Java"
@@ -367,7 +366,7 @@ val newList = list.map{it * 2} // 对集合遍历，在遍历过程中，给每
 
 val mStudents = students.filter{it.sex == "m"} // 筛选出性别为男的学生
 
-val scoreTotal = students.sumBy{it.score} // 拥挤和中的sumby实现求和
+val scoreTotal = students.sumBy{it.score} // 用集合中的sumby实现求和
 ```
 
 #### 通过序列提高效率
@@ -391,7 +390,7 @@ list.asSequence().filter {it > 2}.map {it * 2}.toList()
 toList方法将序列转为列表。将list转换为序列，在很大程度上就提高了上面操作集合的效率。
 因为在使用序列的时候filter方法和map方法的操作都没有创建额外的集合，这样当集合中的元素数量巨大的时候，
 就减少了大部分开销。在Kotlin中，序列中元素的求值是惰性的，这就意味着在利用序列进行链式求值的时候，
-不需要像操作普通集合那样，每进行一次求值操作，就产生一个新的集合保存中间数据。那么什么惰性又是什么意思呢？
+不需要像操作普通集合那样，每进行一次求值操作，就产生一个新的集合保存中间数据。那么惰性又是什么意思呢？
 
 #### 惰性求值
 在编程语言理论中，惰性求值(Lazy Evaluation)表示一种在需要时才进行求值的计算方式。
@@ -406,10 +405,10 @@ toList方法将序列转为列表。将list转换为序列，在很大程度上
 list.asSequence().filter {it > 2}.map {it * 2}.toList()
 ```
 
-在这个例子中，我们序列总共执行了两类操作分别是: 
+在这个例子中，我们序列总共执行了两类操作分别是:     
 
-- `filter{it > 2}.map{it * 2}`:filter和map的操作返回的都是序列，我们将这类操作称为中间操作。
-- `toList()`:这一类操作将序列转换为List，我们将这类操作称为末端操作。
+- `filter{it > 2}.map{it * 2}`: filter和map的操作返回的都是序列，我们将这类操作称为中间操作。
+- `toList()`: 这一类操作将序列转换为List，我们将这类操作称为末端操作。
 
 其实，Kotlin中序列的操作就分为两类： 
 
@@ -432,10 +431,10 @@ list.asSequence().filter {it > 2}.map {it * 2}.toList()
 - 末端操作
 
     在对集合进行操作的时候，大部分情况下，我们在意的只是结果，而不是中间过程。
-  末端操作就是一个返回结果的操作，它的返回值不能是序列，必须是一个明确的结果，
-  比如列表、数字、对象等表意明确的结果。末端操作一般都放在链式操作的末尾，
-  在执行末端操作的时候，会去触发中间操作的延迟计算，也就是将”被需要“这个状态打开了，
-  我们给上面的例子加上末端操作: 
+    末端操作就是一个返回结果的操作，它的返回值不能是序列，必须是一个明确的结果，
+    比如列表、数字、对象等表意明确的结果。末端操作一般都放在链式操作的末尾，
+    在执行末端操作的时候，会去触发中间操作的延迟计算，也就是将”被需要“这个状态打开了，
+    我们给上面的例子加上末端操作: 
 
     ```kotlin
     list.asSequence().filter {
@@ -458,10 +457,10 @@ list.asSequence().filter {it > 2}.map {it * 2}.toList()
     ```
 
     可以看到，所有的中间操作都被执行了。从上面执行打印的结果我们发现，它的执行顺序与我们预想的不一样。
-  普通集合在进行链式操作的时候会先在list上调用filter，然后产生一个结果列表，接下来map就在这个结果列表上进行操作。
-  而序列则不一样，序列在执行链式操作的时候，会将所有的操作都应用在一个元素上，也就是说，第一个元素执行完所有的操作之后，
-  第二个元素再去执行所有的操作，以此类推。放到我们这个例子上面，就是第一个元素执行了filter之后再去执行map，
-  然后第二个元素也是这样。
+    普通集合在进行链式操作的时候会先在list上调用filter，然后产生一个结果列表，接下来map就在这个结果列表上进行操作。
+    而序列则不一样，序列在执行链式操作的时候，会将所有的操作都应用在一个元素上，也就是说，第一个元素执行完所有的操作之后，
+    第二个元素再去执行所有的操作，以此类推。放到我们这个例子上面，就是第一个元素执行了filter之后再去执行map，
+    然后第二个元素也是这样。
 
 #### 序列可以是无限的
 
@@ -525,7 +524,7 @@ if(str == null) {
 }
 ```
 
-那么如果我们需要的就是一个`Int`的结果(事实上大部分情况都是如此)，那又该怎么办呢？在`kotlin`中除了`?`表示可为空以外，还有一个新的符号:双感叹号`!!`，表示一定不能为空。所以上面的例子，如果要对`result`进行操作，可以这么写:  
+那么如果我们需要的就是一个`Int`的结果(事实上大部分情况都是如此)，那又该怎么办呢？在`kotlin`中除了`?`表示可为空以外，还有一个新的双感叹号`!!`符号，表示一定不能为空。所以上面的例子，如果要对`result`进行操作，可以这么写:  
 
 ```kotlin
 var str : String? = null
diff --git "a/KotlinCourse/4.Kotlin_\350\241\250\350\276\276\345\274\217&\345\205\263\351\224\256\345\255\227.md" "b/KotlinCourse/4.Kotlin_\350\241\250\350\276\276\345\274\217&\345\205\263\351\224\256\345\255\227.md"
index f922d625..159e419a 100644
--- "a/KotlinCourse/4.Kotlin_\350\241\250\350\276\276\345\274\217&\345\205\263\351\224\256\345\255\227.md"
+++ "b/KotlinCourse/4.Kotlin_\350\241\250\350\276\276\345\274\217&\345\205\263\351\224\256\345\255\227.md"
@@ -218,6 +218,42 @@ for(num in nums) {
 
 
 
+### infix关键字   
+
+Kotlin中infix的中缀表示法允许在不使用点和括号的情况下调用函数。
+
+
+例如:   
+
+```kotlin
+infix fun Int.add(value: Int): Int = this + value
+
+val sum = 5 add 10
+```
+
+平时在使用map的时候经常会这样用:     
+
+```kotlin
+val map = mapOf(
+    1 to "A",
+    2 to "B",
+    3 to "C"
+)
+```
+而mapOf需要一个Pair<K, V>的列表。这里可以使用to关键字来实现就是因为infix。     
+
+我们可以检查一下Kotlin中的Pair的源码，就会发现:     
+```kotlin
+infix fun <A, B> A.to(that: B): Pair<A, B> = Pair(this, that)
+```
+
+使用infix的时候有个点需要注意:    
+
+- 它必须是一个函数
+- 必须只有一个参数
+- 参数不能是可变参数
+- 参数不能有默认值
+
 
 - [上一篇:3.Kotlin_数字&字符串&数组&集合](https://github.com/CharonChui/AndroidNote/blob/master/KotlinCourse/3.Kotlin_%E6%95%B0%E5%AD%97%26%E5%AD%97%E7%AC%A6%E4%B8%B2%26%E6%95%B0%E7%BB%84%26%E9%9B%86%E5%90%88.md)       
 - [下一篇:5.Kotlin_内部类&密封类&枚举&委托](https://github.com/CharonChui/AndroidNote/blob/master/KotlinCourse/5.Kotlin_%E5%86%85%E9%83%A8%E7%B1%BB%26%E5%AF%86%E5%B0%81%E7%B1%BB%26%E6%9E%9A%E4%B8%BE%26%E5%A7%94%E6%89%98.md)    
diff --git "a/KotlinCourse/5.Kotlin_\345\206\205\351\203\250\347\261\273&\345\257\206\345\260\201\347\261\273&\346\236\232\344\270\276&\345\247\224\346\211\230.md" "b/KotlinCourse/5.Kotlin_\345\206\205\351\203\250\347\261\273&\345\257\206\345\260\201\347\261\273&\346\236\232\344\270\276&\345\247\224\346\211\230.md"
index 9c91998e..fbf36eea 100644
--- "a/KotlinCourse/5.Kotlin_\345\206\205\351\203\250\347\261\273&\345\257\206\345\260\201\347\261\273&\346\236\232\344\270\276&\345\247\224\346\211\230.md"
+++ "b/KotlinCourse/5.Kotlin_\345\206\205\351\203\250\347\261\273&\345\257\206\345\260\201\347\261\273&\346\236\232\344\270\276&\345\247\224\346\211\230.md"
@@ -43,7 +43,7 @@ inline fun <reified T> startActivity(context: Context) {
     context.startActivity(intent)
 }
 ```
-这里我们定义了一个startActivity()函数，该函数接收一个Context参数，并同时使用inline和reified关键字让泛型T成为了一个被实化的泛型。接下来就是神奇的地方了，Intent接收的第二个参数本来应该是一个具体Activity的Class类型，但由于现在T已经是一个被实化的泛型了，因此这里我们可以直接传入T::class.java。最后调用Context的startActivity()方法来完成Activity的启动。现在，如果我们想要启动TestActivity，只需要这样写就可以了：[插图]Kotlin将能够识别出指定泛型的实际类型，并启动相应的Activity。
+这里我们定义了一个startActivity()函数，该函数接收一个Context参数，并同时使用inline和reified关键字让泛型T成为了一个被实化的泛型。接下来就是神奇的地方了，Intent接收的第二个参数本来应该是一个具体Activity的Class类型，但由于现在T已经是一个被实化的泛型了，因此这里我们可以直接传入T::class.java。最后调用Context的startActivity()方法来完成Activity的启动。现在，如果我们想要启动TestActivity，只需要像下面这样写就可以了，Kotlin将能够识别出指定泛型的实际类型，并启动相应的Activity:       
 ```kotlin
 startActivity<TestActivity>(context)
 ```
@@ -55,7 +55,7 @@ intent.putExtra("param1", "data")
 intent.putExtra("param2", 123)
 context.startActivity(intent)
 ```
-而经过刚才的封装之后，我们就无法进行传参了。这个问题也不难解决，只需要借助之前在第6章学习的高阶函数就可以轻松搞定。回到reified.kt文件当中，这里添加一个新的startActivity()函数重载，如下所示：
+而经过刚才的封装之后，我们就无法进行传参了。这个问题也不难解决，只需要借助之前学习的高阶函数就可以轻松搞定。回到reified.kt文件当中，这里添加一个新的startActivity()函数重载，如下所示：
 ```kotlin
 inline fun <reified T> startActivity(context: Context, block: Intent.() -> Unit) {
     val intent = Intent(context, T::class.java)
@@ -132,6 +132,8 @@ class Outter{
 val outter = Outter()
 outter.Inner().execute()
 
+var v = this@Outer.testVal // 引用外部类的成员
+
 // 输出
 Inner -> execute : can read testVal=test
 ```
@@ -142,18 +144,28 @@ val outter = Outter()
 outter.Inner().execute()
 ```
 
+引用外部类中对象的方式为: var 变量名 = this@外部类名
+
+在类成员中，this指代该类的当前对象。而在扩展函数或者带接受者的函数中，this表示在点左侧传递的接收者参数。   
+
+
 #### 内部类vs嵌套类
 
 在Java中，我们通过在内部类的语法上增加一个static关键词，把它变成一个嵌套类。然而，Kotlin则是相反的思路，默认是一个嵌套类，
 必须加上inner关键字才是一个内部类，也就是说可以把静态的内部类看成嵌套类。
 
 内部类和嵌套类有明显的差别，具体体现在：
+
+- 嵌套类相当于Java中的静态内部类，不能使用外部类的this。
+- 内部类必须以inner class定义，相当于Java中的私有非静态内部类，可以访问外部类的this。
 - 内部类包含着对其外部类实例的引用，在内部类中我们可以使用外部类中的属性。而在嵌套类中不包含对其外部类实例的引用，所以它无法调用其外部类的属性。
 
 
 
 #### 匿名内部类
 
+没有名字的内部类被称为匿名内部类，使用匿名内部类必须继承一个父类或实现一个接口，匿名内部类可以简化代码编写。
+
 ```kotlin
 // 通过对象表达式来创建匿名内部类的对象，可以避免重写抽象类的子类和接口的实现类，这和Java中匿名内部类的是接口和抽象类的延伸一致。
 text.setOnClickListener(object : View.OnClickListener{
@@ -175,10 +187,18 @@ mViewPager.addOnPageChangeListener(object : ViewPager.OnPageChangeListener {
     override fun onPageSelected(position: Int) {
         TODO("not implemented") //To change body of created functions use File | Settings | File Templates.
     }
-
 })
 ```
 
+如果对象实例是一个函数接口，还可以使用Lambda表达式来实现。 
+```kotlin
+val listener = ActionListener {
+    println("clicked")
+}
+```
+
+
+
 ### 枚举
 
 与Java中的enum语法大体类似，无非多了一个class关键字，表示它是一个枚举类。
@@ -231,7 +251,7 @@ enum class MessageType(var msg: String) {
 }
 ```
 
-但是使用这种方法存在两个问题： 
+但是使用这种方法存在两个问题:        
 
 - 每个值都是一个常量，并且仅作为单个实例存在。
 
@@ -245,7 +265,11 @@ enum class MessageType(var msg: String) {
 
 ### 密封类
 
-Kotlin除了可以利用final来限制类的继承之外，还可以通过密封类的语法来限制一个类的继承。密封类就像枚举类的加强版本。它允许你将类层次结构限制为一组特定的子类型，每个子类型都可以定义自己的属性和函数。与枚举类不同，你可以创建每种类型的多个实例。 你可以通过使用sealed前缀类名来创建密封类。例如，以下代码创建一个名为MessageType的密封类，其中包含名为MessageSuccess和MessageFailure的子类型。每个子类型都有一个名为msg的String属性，并且MessageFailure子类型中有一个额外的名为e的Exception属性：
+Kotlin除了可以利用final来限制类的继承之外，还可以通过密封类的语法来限制一个类的继承。密封类就像枚举类的加强版本。        
+
+它允许你将类层次结构限制为一组特定的子类型，每个子类型都可以定义自己的属性和函数。与枚举类不同，你可以创建每种类型的多个实例。         
+
+你可以通过使用sealed前缀类名来创建密封类。例如，以下代码创建一个名为MessageType的密封类，其中包含名为MessageSuccess和MessageFailure的子类型。每个子类型都有一个名为msg的String属性，并且MessageFailure子类型中有一个额外的名为e的Exception属性:     
 
 ```kotlin
 sealed class MessageType
@@ -254,7 +278,7 @@ class MessageSuccess(var msg: String) : MessageType()
 class MessageFailure(var msg: String, var e: Exception) : MessageType()
 ```
 
-由于MessageType是一个有限子类的密封类。你可以使用when来检查每个子类型，这样可以避免使用额外的else子句，如以下代码所示:  
+由于MessageType是一个有限子类的密封类。你可以使用when来检查每个子类型，这样可以避免使用额外的else子句，如以下代码所示:      
 
 ```kotlin
 fun main(args: Array<String>) {
@@ -306,7 +330,8 @@ public abstract class Bird {
 ```
 
 
-密封类用来表示受限的类继承结构:当一个值为有限几种的类型、而不能有任何其他类型时。在某种意义上，他们是枚举类的扩展:枚举类型的值集合也是受限的，但每个枚举常量只存在一个实例，而密封类的一个子类可以有可包含状态的多个实例。
+密封类用来表示受限的类继承结构: 当一个值为有限几种的类型、而不能有任何其他类型时。       
+在某种意义上，他们是枚举类的扩展:枚举类型的值集合也是受限的，但每个枚举常量只存在一个实例，而密封类的一个子类可以有可包含状态的多个实例。
 
 虽然密封类也可以有子类，但是所有子类都必须在与密封类自身相同的文件中声明。(在`Kotlin 1.1`之前，该规则更加严格:子类必须嵌套在密封类声明的内部)。
 
@@ -337,7 +362,7 @@ fun eval(expr: Expr): Double = when(expr) {
 
 ### 异常    
 
-在`Kotlin`中，所有的`Exception`都是实现了`Throwable`，含有一个`message`且未经检查。这表示我们不会强迫我们在任何地方使用`try/catch`。
+在`Kotlin`中，所有的`Exception`都是实现了`Throwable`，含有一个`message`且未经检查。这表示我们不会强迫我们在任何地方使用`try/catch`。       
 这与`Java`中不太一样，比如在抛出`IOException`的方法，我们需要使用`try-catch`包围代码块。但是通过检查`exception`来处理显示并不是一个
 好的方法。
 
@@ -350,11 +375,9 @@ throw MyException("Exception message")
 ```kotlin
 try{
     // 一些代码
-}
-catch (e: SomeException) {
+} catch (e: SomeException) {
     // 处理
-}
-finally {
+} finally {
     // 可选的finally块
 }
 ```
@@ -379,7 +402,8 @@ val s = try { x as String } catch(e: ClassCastException) { null }
 在Kotlin中，你将告别static这种语法，因为它引入了全新的关键字object，可以完美的代替使用static的所有场景。
 当然除了代替static的场景之外，它还能实现更多的功能，比如单例对象及简化匿名表达式等。 
 
-声明对象就如同声明一个类，你只需要用保留字`object`替代`class`，其他都相同。只需要考虑到对象不能有构造函数，因为我们不调用任何构造函数来访问它们。事实上，对象就是具有单一实现的数据类型。object声明的内容可以看成没有构造方法的类，它会在系统或者类加载时进行初始化。
+声明对象就如同声明一个类，你只需要用保留字`object`替代`class`，其他都相同。只需要考虑到对象不能有构造函数，因为我们不调用任何构造函数来访问它们。      
+事实上，对象就是具有单一实现的数据类型。object声明的内容可以看成没有构造方法的类，它会在系统或者类加载时进行初始化。
 
 ```kotlin
 object Resource {
@@ -387,6 +411,27 @@ object Resource {
 }
 ```
 
+
+Kotlin中除了object之外还有一个companion object，也可以替代Java中的static关键字，那他俩有什么区别呢？  
+
+
+#### Companion object
+
+- 必须在一个类中定义      
+- companion object会在类第一次加载的时候就创建好，这就意味着我们可能还没使用的时候就初始化好了
+- 它等同于Java中的static     
+- 如果我们不手动指定名字的话会有一个默认的Companion的名字      
+- 在调用方法或变量的时候可以省略名字
+
+#### object
+
+- 可以被定义到任何地方      
+- 在我们第一次使用它时才会创建。      
+- 主要被用作提供单例行为       
+- 必须提供一个命名          
+- 如果在一个类中定义object，那在调用方法或者变量的时候不能省略名字  
+
+
 ### 对象表达式
 
 对象也能用于创建匿名类实现。
@@ -405,7 +450,8 @@ recycler.adapter = object : RecyclerView.Adapter() {
 ```
 例如，每次想要创建一个接口的内联实现，或者扩展另一个类时，你将使用上面的符号。
 
-object表达式和匿名内部类很像，那对象表达式与Lambda表达式哪个更适合代替匿名内部类呢？  当你的匿名内部类使用的类接口只需要实现一个方法时，使用Lambda表达式更适合。当匿名内部类内有多个方法实现的时候，使用object表达式更适合。
+object表达式和匿名内部类很像，那对象表达式与Lambda表达式哪个更适合代替匿名内部类呢?        
+当你的匿名内部类使用的类接口只需要实现一个方法时，使用Lambda表达式更适合。当匿名内部类内有多个方法实现的时候，使用object表达式更适合。
 
 #### 伴生对象
 
@@ -447,6 +493,8 @@ public class Prize {
 伴生对象：“伴生”是相较于一个类而言的，意为伴随某个类的对象，它属于这个类所有，因此伴生对象跟Java中static修饰效果性质一样，
 全局只有一个单例。它需要声明在类的内部，在类被装载时会被初始化。 
 
+准确的说是Kotlin使用伴生对象来实现Java静态的效果，但不能说伴生就是静态。   
+
 现在将上面的例子改写成伴生对象的版本:   
 
 ```kotlin
@@ -493,7 +541,7 @@ class Prize private constructor(val name: String, val count: Int, val type: Int)
     fun main(args: Array<String>) {
         val redpackPrize = Prize.newRedpackPrize("hongbao", 10)
         val couponPrize = Prize.newCouponPrize("shiyuan", 10)
-        vval commonPrize = Prize.defaultCommonPrize()
+        val commonPrize = Prize.defaultCommonPrize()
     }
 }
 ```
@@ -519,9 +567,12 @@ class App : Application() {
 `lateinit`表示这个属性开始是没有值的，但是，在使用前将被赋值（否则，就会抛出异常）。     
 
 
-不过，上面companion object中的isRedpack()方法其实也并不是静态方法，companionobject这个关键字实际上会在类的内部创建一个伴生类，而isRedpack方法就是定义在这个伴生类里面的实例方法。只是Kotlin会保证类始终只会存在一个伴生类对象，因此调用Prize.isRedpack()方法实际上就是调用了Prize类中伴生对象的isRedpack()方法。由此可以看出，Kotlin确实没有直接定义静态方法的关键字，但是提供了一些语法特性来支持类似于静态方法调用的写法，这些语法特性基本可以满足我们平时的开发需求了。然而如果你确确实实需要定义真正的静态方法， Kotlin仍然提供了两种实现方式：注解和顶层方法。
+不过，上面companion object中的isRedpack()方法其实也并不是静态方法，companion object这个关键字实际上会在类的内部创建一个伴生类，而isRedpack方法就是定义在这个伴生类里面的实例方法。      
+
+只是Kotlin会保证类始终只会存在一个伴生类对象，因此调用Prize.isRedpack()方法实际上就是调用了Prize类中伴生对象的isRedpack()方法。     
+由此可以看出，Kotlin确实没有直接定义静态方法的关键字，但是提供了一些语法特性来支持类似于静态方法调用的写法，这些语法特性基本可以满足我们平时的开发需求了。然而如果你确确实实需要定义真正的静态方法， Kotlin仍然提供了两种实现方式：注解和顶层方法。
 
-先来看注解，前面使用的单例类和companion object都只是在语法的形式上模仿了静态方法的调用方式，实际上它们都不是真正的静态方法。因此如果你在Java代码中以静态方法的形式去调用的话，你会发现这些方法并不存在。而如果我们给单例类或companion object中的方法加上@JvmStatic注解，那么Kotlin编译器就会将这些方法编译成真正的静态方法
+先来看注解，前面使用的单例类和companion object都只是在语法的形式上模仿了静态方法的调用方式，实际上它们都不是真正的静态方法。因此如果你在Java代码中以静态方法的形式去调用的话，你会发现这些方法并不存在。而如果我们给单例类或companion object中的方法加上@JvmStatic注解，那么Kotlin编译器就会将这些方法编译成真正的静态方法。
 
 注意，@JvmStatic注解只能加在单例类或companion object中的方法上，如果你尝试加在一个普通方法上，会直接提示语法错误。那么现在不管是在Kotlin中还是在Java中，都可以使用Prize.isRedpack()的写法来调用了。
 
@@ -612,12 +663,16 @@ public static Instance getInstance() {
 
     具体的业务逻辑执行者
 
+
+
 ##### 类委托
 
 在委托模式中，有两个对象参与处理同一个请求，接受请求的对象将请求委托给另一个对象来处理。
 `kotlin`中的委托可以算是对委托模式的官方支持。    
 `Kotlin`直接支持委托模式，更加优雅，简洁。`Kotlin`通过关键字`by`实现委托。
 
+委托模式已被证明是类继承模式的一种很好的替代方案。
+
 我们经常会打游戏进行升级，但是有时候因为我们的水平不行，没法升到很高的级别，这就出现了很多的游戏代练，他们帮我们代打，这就是一个委托模式： 
 
 1. 定义约束类，定义具体需要委托的业务，这里的业务: 
@@ -660,6 +715,10 @@ public static Instance getInstance() {
 
 ##### 属性委托
 
+在软件的开发中，属性的getter和setter方法的代码有很多相同或相似的地方，虽然为每个类编写相同的代码是可行的，但这样会造成大量的代码冗余，而委托属性正是为解决这一问题而提出的。  
+
+属性委托是指一个类的某个属性值不是在类中直接定义，而是将其委托给一个代理类，从而实现对该类属性的统一管理。  
+
 在Kotlin中，有一些常见的属性类型，虽然我们可以在每次需要的时候手动实现他们，但是很麻烦，为了解决这些问题，Kotlin标准提供了委托属性。
 
 语法是`val/var <属性名>: <类型> by <表达式>`。在`by`后面的表达式是该委托，因为属性对应的`get()`和`set()`会被委托给它的`getValue()`
@@ -667,12 +726,15 @@ public static Instance getInstance() {
 
 ```kotlin
 class Example {
+    // 语法中，关键词by之后的表达式就是委托的类，而且属性的get()以及set()方法将被委托给这个对象的getValue()和setValue()方法。
+    // 属性委托不必实现相关接口，但必须提供getValue()方法，如果是var类型的属性，还需要提供setValue()方法。  
     var property : String by DelegateProperty()
 }
 
 class DelegateProperty {
     var temp = "old"
     // getValue和setValue方法的参数是固定的
+    // getValue和setValue方法必须用关键字operator标记 
     operator fun getValue(ref: Any?, p: KProperty<*>): String {
         return "DelegateProperty --> ${p.name} --> $temp"
     }
@@ -798,8 +860,10 @@ fun main() {
 
 
 
+### 标准委托 
+
 
-`Kotlin`通过属性委托的方式，为我们实现了一些常用的功能，包括:   
+`Kotlin`通过属性委托的方式在Kotlin标准库中内置了很多工厂方法来实现属性委托，包括:   
 
 - 延迟属性`lazy properties`
 - 可观察属性`observable properties`
@@ -810,6 +874,9 @@ fun main() {
 延迟属性我们应该不陌生，也就是通常说的懒汉，在定义的时候不进行初始化，把初始化的工作延迟到第一次调用的时候。`kotlin`中实现延迟属性很简单，
 来看一下。
 
+lazy()是一个接收Lambda表达式作为参数并返回一个Lazy<T>实例的函数，返回的实例可以作为实现延迟属性的委托。   
+也就是说，延迟属性第一次调用get()时，将会执行传递给lazy()函数的Lambda表达式并记录执行结果，后续所有对get()的调用只会返回记录的结果。   
+
 ```kotlin
 val lazyValue: String by lazy {
     Log.d(JTAG, "Just run when first being used")
@@ -857,7 +924,7 @@ void test(){
 ```kotlin
 val p by lazy { ... }
 ```
-现在再来看这段代码，是不是觉得更有头绪了呢？实际上，bylazy并不是连在一起的关键字，只有by才是Kotlin中的关键字，
+现在再来看这段代码，是不是觉得更有头绪了呢？实际上，by lazy并不是连在一起的关键字，只有by才是Kotlin中的关键字，
 lazy在这里只是一个高阶函数而已。在lazy函数中会创建并返回一个Delegate对象，当我们调用p属性的时候，
 其实调用的是Delegate对象的getValue()方法，然后getValue()方法中又会调用lazy函数传入的Lambda表达式，
 这样表达式中的代码就可以得到执行了，并且调用p属性后得到的值就是Lambda表达式中最后一行代码的返回值。
@@ -892,7 +959,24 @@ fun <T> later(block: () -> T) = Later(block)
 
 ##### 可观察属性
 
-如果你要观察一个属性的变化过程，那么可以将属性委托给`Delegates.observable`, `observable`函数原型如下：
+
+所谓可观察属性(observable)，就是当属性发生变化时能自动拦截其变化，实现观察属性值变化的委托函数是Delegates.observable()。  
+
+该函数接受两个参数:   
+
+- 初始值
+- 属性值变化时间的响应器(handler)
+
+每当给属性值赋值时都会调用该响应器，该响应器主要有3个参数:   
+
+- 被赋值的属性
+- 赋值前的旧属性值
+- 赋值后的新属性值    
+
+
+如果你要观察一个属性的变化过程，那么可以将属性委托给`Delegates.observable`。
+
+ `observable`函数原型如下：
 
 ```kotlin
 public inline fun <T> observable(initialValue: T, crossinline onChange: (property: KProperty<*>, oldValue: T, newValue: T) -> Unit):
@@ -947,9 +1031,10 @@ fun test(){
 
 
 
-##### map映射
+##### map委托
+
+Map委托常常用来将Map中的key-value映射到对象的属性中，这经常出现在解析JSON或者其他动态事情的应用中。 
 
-一个常见的用例是在一个映射`map`里存储属性的值。这经常出现在像解析`JSON`或者做其他“动态”事情的应用中。在这种情况下，你可以使用映射实例自身作为委托来实现委托属性。
 
 ```kotlin
 class User(val map: Map<String, Any?>) {
@@ -975,6 +1060,18 @@ class MutableUser(val map: MutableMap<String, Any?>) {
 
 
 
+委托模式是一种被广泛使用的设计模式，Kotlin的委托主要用来实现代码的重用，Kotlin默认支持委托模式，且不需任何模版方法。   
+
+
+
+###### 委托 vs 继承 vs 组合     
+
+- 继承：is-a关系，破坏封装，不灵活
+- 组合：has-a关系，灵活但样板代码多
+- 委托：has-a关系 + 自动转发，兼顾灵活性和简洁性
+
+也就是简单来说委托是为了简化组合中样板代码多及重复代码多的问题，可以优雅的实现装饰器模式。   
+
 
 - [上一篇:4.Kotlin_表达式&关键字](https://github.com/CharonChui/AndroidNote/blob/master/KotlinCourse/4.Kotlin_%E8%A1%A8%E8%BE%BE%E5%BC%8F%26%E5%85%B3%E9%94%AE%E5%AD%97.md)       
 - [下一篇:6.Kotlin_多继承问题](https://github.com/CharonChui/AndroidNote/blob/master/KotlinCourse/6.Kotlin_%E5%A4%9A%E7%BB%A7%E6%89%BF%E9%97%AE%E9%A2%98.md)
diff --git "a/KotlinCourse/7.Kotlin_\346\263\250\350\247\243&\345\217\215\345\260\204&\346\211\251\345\261\225.md" "b/KotlinCourse/7.Kotlin_\346\263\250\350\247\243&\345\217\215\345\260\204&\346\211\251\345\261\225.md"
index 50ff4d0a..ac59cae9 100644
--- "a/KotlinCourse/7.Kotlin_\346\263\250\350\247\243&\345\217\215\345\260\204&\346\211\251\345\261\225.md"
+++ "b/KotlinCourse/7.Kotlin_\346\263\250\350\247\243&\345\217\215\345\260\204&\346\211\251\345\261\225.md"
@@ -156,6 +156,13 @@ public final class ExtenndsKt {
 被该类的所有实例共享。此外，被public修饰的静态方法本质上也就是全局方法。所以扩展函数不会带来额外的性能消耗。
 
 
+
+- 扩展函数是静态分配的，使用的是声明类型对应的扩展函数，不是多态    
+- 如果成员函数和扩展函数重名，那么成员函数会优先于扩展函数
+- 扩展函数实际上是静态函数，所以扩展函数不能访问private/protected成员
+
+
+
 ##### 扩展函数的作用域
 
 在平时写扩展时，我们通常会把扩展方法放到一个文件中，例如ViewExtends.kt: 
@@ -327,6 +334,8 @@ text.panddingH = 100
 
 扩展属性与扩展函数一样，其本质也是对应Java中的静态方法。由于扩展没有实际的将成员插入类中，因此对扩展属性来说幕后字段是无效的。
 
+扩展属性允许定义在类或者Kotlin文件中，但不允许定义在函数中。 因为扩展属性不能有初始化器，所以只能由显式提供的getter/setter定义，而且扩展属性只能被声明为val。
+
 
 ##### 静态扩展
 
@@ -1205,6 +1214,12 @@ class Group<T>(val name: String) {
 `KDoc`不支持`@deprecated`这个标签。作为替代，请使用`@Deprecated`注解。
 
 
+### 泛型
+
+通配符类型参数 `? extends E`表示该方法接收E类型或者E类型的一些子类型，而不仅仅是E类型本身。
+Kotlin抛弃了通配符类型这一概念，转而引入了生产者和消费者的概念，其中，生产者表示那些只能读取数据的对象，使用表达式`out T`标记。    
+消费者表示那些只能写入数据的对象，使用表达式`in T`标记。      
+为了便于理解，可以简单的将`out T`理解为`? exnteds T`，将`in T`理解为`? super T`。 
 
 
 
diff --git "a/KotlinCourse/8.Kotlin_\345\215\217\347\250\213.md" "b/KotlinCourse/8.Kotlin_\345\215\217\347\250\213.md"
index b1e79261..0fdbd597 100644
--- "a/KotlinCourse/8.Kotlin_\345\215\217\347\250\213.md"
+++ "b/KotlinCourse/8.Kotlin_\345\215\217\347\250\213.md"
@@ -5,24 +5,38 @@
 
 Kotlin引入了协程（Coroutine）来支持更好的异步操作，利用它我们可以避免在异步编程中使用大量的回调，同时相比传统多线程技术，它更容易提升系统的高并发处理能力。 
 
-## 起源
 
-协程是一个无优先级的子程序调用组件，允许子程序在特定的地方挂起恢复。线程包含于进程，协程包含于线程。只要内存足够，
-一个线程中可以有任意多个协程，但某一时刻只能有一个协程在运行，多个协程分享该线程分配到的计算机资源。
+协程(coroutine)，又称微线程，是一种无优先级的子程序调度组件，由协程构建器(coroutine builder)启动。 
+
+协程本质上是一种用户态的轻量级线程
+
+## 起源
 
 线程是由操作系统来进行调度的，当操作系统切换线程的时候，会产生一定的消耗。而协程不一样，协程是包含于线程的，也就是说协程
 是工作在线程之上的，协程的切换可以由程序自己来控制，不需要操作系统进行调度。这样的话就大大降低了开销。
 
 
 
-协程就像一个轻量级的线程在幕后，启动协程就像启动一个单独的执行线程。线程在其他语言中很常见，例如Java，协程和线程可以并行运行，并互相通信。然而，不同点在于使用协程比使用线程更加高效。在性能方面，启动一个线程并使其保持运行是非常昂贵的。处理器通常只能同时运行有限数量的线程，并且运行尽可能少的线程会更高效。而另一方面，协程默认运行在共享的线程池中，同一个线程可以运行多个协程。由于使用的线程较少，当你想要运行异步任务时，使用协程会更加高效。
+协程就像一个轻量级的线程在幕后，启动协程就像启动一个单独的执行线程。线程在其他语言中很常见，例如Java，协程和线程可以并行运行，并互相通信。然而，不同点在于使用协程比使用线程更加高效。在性能方面，启动一个线程并使其保持运行是非常昂贵的。    
+
+处理器通常只能同时运行有限数量的线程，并且运行尽可能少的线程会更高效。     
+
+而另一方面，协程默认运行在共享的线程池中，同一个线程可以运行多个协程。由于使用的线程较少，当你想要运行异步任务时，使用协程会更加高效。
+
+**也就是说本质上Kotlin协程就是创建了一个可以复用的线程池，并且协程的delay是一个特殊的挂起函数，它不会造成线程堵塞，但是会挂起协程，并且只能在协程中使用。**    
+
+协程是语言层面的东西，线程是系统层面的东西。    
+协程就是一段代码块，既然是代码那就离不开CPU的执行，而CPU调度的基本单位是线程。    
+
+可以说，只要内存足够，一个线程中可以包含任意多个协程，但某一时刻却只能有一个协程在运行，多个协程分享该线程资源。   
 
 ## 进程、线程、协程
-进程：一段程序的执行过程，资源分配和调度的基本单位，有其独立地址空间，互相之间不发生干扰
-线程：轻量级进程，资源调度的最小单位，共享父进程地址空间和资源，其调度和进程一样要切换到内核态
-并行：同时发生，在多核CPU中，多个任务可同时在不同CPU上面同一时间执行
-并发：宏观并行，微观串行，操作系统根据相关算法，分配时间片来调度，从而达到一种宏观上并行的方式
-上下文：程序执行的状态，通常用调用栈记录程序执行的当前状态以及其相关的环境信息
+
+- 进程：一段程序的执行过程，资源分配和调度的基本单位，有其独立地址空间，互相之间不发生干扰      
+- 线程：轻量级进程，资源调度的最小单位，共享父进程地址空间和资源，其调度和进程一样要切换到内核态     
+- 并行：同时发生，在多核CPU中，多个任务可同时在不同CPU上面同一时间执行     
+- 并发：宏观并行，微观串行，操作系统根据相关算法，分配时间片来调度，从而达到一种宏观上并行的方式     
+- 上下文：程序执行的状态，通常用调用栈记录程序执行的当前状态以及其相关的环境信息      
 
 早期，CPU是单核，无法真正并行，为了产生共享CPU的假象，提出了时间片概念，将时间分割成连续的时间片段，多个程序交替获得CPU使用权限。 而管理时间片分配调度的调度器则成为操作系统的核心组件。
 
@@ -33,7 +47,15 @@ CPU增加内存管理单元，进行虚拟地址和物理地址的转换
 
 进程是一个实体，包括程序代码以及其相关资源(内存，I/O，文件等)，可被操作系统调度。但想一边操作I/O进行输入输出，一边想进行加减计算，就得两个进程，这样写代码，内存就爆表了。于是又想着能否有一轻量级进程呢，只执行程序，不需要独立的内存，I/O等资源，而是共享已有资源，于是产生了线程。
 
-一个进程可以跑很多个线程处理并发，但是线程进行切换的时候，操作系统会产生中断，线程会切换到相应的内核态，并进行上下文的保存，这个过程不受上层控制，是操作系统进行管理。然而内核态线程会产生性能消耗，因此线程过多，并不一定提升程序执行的效率。正是由于1.线程的调度不能精确控制；2.线程的切换会产生性能消耗。协程出现了。
+一个进程可以跑很多个线程处理并发，但是线程进行切换的时候，操作系统会产生中断，线程会切换到相应的内核态，并进行上下文的保存，这个过程不受上层控制，是操作系统进行管理。    
+然而内核态线程会产生性能消耗，因此线程过多，并不一定提升程序执行的效率。    
+
+正是由于:      
+
+1. 线程的调度不能精确控制；
+2. 线程的切换会产生性能消耗。     
+
+协程出现了。
 
 协程: 
 
@@ -43,17 +65,52 @@ CPU增加内存管理单元，进行虚拟地址和物理地址的转换
 4. 协程是非抢占式调度，当前协程切换到其他协程是由自己控制；线程则是时间片用完抢占时间片调度
 
 优点:   
+
 1. 用户态，语言级别
 2. 无切换性能消耗
 3. 非抢占式
 4. 同步代码思维
 5. 减少同步锁
+
 缺点:  
+
 1. 注意全局变量
 2. 阻塞操作会导致整个线程被阻塞
 
 
-用一句话概括Kotlin Couroutine的特点即是"以同步之名，行异步之实".
+
+简单地讲，Kotlin 的协程就是一个封装在线程上面的线程框架。
+
+它有两个非常关键的亮点：
+
+- 耗时函数自动后台，从而提高性能；
+- 线程的「自动切回」
+
+所以，Kotlin 的协程在 Android 开发上的核心好处就是：消除回调地域。
+例如，用普通的方式，连续请求三个接口，需要三层嵌套。 
+但是使用协程就会看起来像同步代码一样的实现，但实际是异步的:    
+
+```kotlin
+suspend fun loadUserData(suerId: String) {
+    val user = apiService.getUser(userId)        // 挂起，不堵塞线程
+    val posts = apiService.getUserPosts(user.id) // 挂起，不堵塞线程
+    val comments = apiService.getPostComents(posts[0].id) // 挂起，不堵塞线程
+    updateUI(user, posts, comments)  // 回到主线程更新UI
+}
+```
+
+
+线程操作需要VM或OS的支持，通过CPU调度来执行生效。   
+而协程主要通过编译技术来实现，通过参入代码来生效，不需要VM或OS的额外支持。   
+
+简单来说，协程是编译器级的，而线程是操作系统级的。   
+
+协程运行在同一个线程上，没有上下文切换。 
+和线程不同，协程有多个入口点，可以在指定的位置挂起和恢复执行，而线程通常只有一个入口点，且只能返回一次。       
+其次，协程不需要多线程的锁机制，因为协程只有一个线程，也不存在同时写变量冲突，在协程中控制共享资源不需要加锁，只需要判断状态即可，因此执行效率比多线程高很多。   
+另外，使用协程后，不再需要像异步编程时那样写很多回调函数，代码结构不再支离破碎，整个代码逻辑看上去和同步代码没有什么区别，代码结构更加优雅简洁。   
+
+
 ## 使用
 
 如需在 Android 项目中使用协程，请将以下依赖项添加到应用的build.gradle文件中：
@@ -246,6 +303,15 @@ Hello,
 World!
 ```
 
+#### suspend关键字    
+
+- suspend关键字用来标记函数可以被挂起和恢复。    
+
+- 挂起函数只能在协程或另一个挂起函数中调用。   
+
+
+
+
 ### 取消协程的执行
 
 在一个长时间运行的应用程序中，你也许需要对你的后台协程进行细粒度的控制。 比如说，一个用户也许关闭了一个启动了协程的界面，
@@ -400,7 +466,6 @@ main: Now I can quit.
 对于回调式的写法，如果并发场景再复杂一些，代码的嵌套可能会更多，这样的话维护起来就非常麻烦。但如果你使用了 Kotlin 协程，多层网络请求只需要这么写：
 
 ```
-🏝️
 coroutineScope.launch(Dispatchers.Main) {       // 开始协程：主线程
     val token = api.getToken()                  // 网络请求：IO 线程
     val user = api.getUser(token)               // 网络请求：IO 线程
@@ -413,8 +478,6 @@ coroutineScope.launch(Dispatchers.Main) {       // 开始协程：主线程
 协程最简单的使用方法，其实在前面章节就已经看到了。我们可以通过一个 `launch` 函数实现线程切换的功能：
 
 ```
-🏝️
-//               👇
 coroutineScope.launch(Dispatchers.IO) {
     ...
 }
@@ -426,24 +489,20 @@ coroutineScope.launch(Dispatchers.IO) {
 所以，什么时候用协程？当你需要切线程或者指定线程的时候。你要在后台执行任务？切！
 
 ```
-🏝️
 launch(Dispatchers.IO) {
     val image = getImage(imageId)
 }
-复制代码
 ```
 
 然后需要在前台更新界面？再切！
 
 ```
-🏝️
 coroutineScope.launch(Dispatchers.IO) {
     val image = getImage(imageId)
     launch(Dispatch.Main) {
         avatarIv.setImageBitmap(image)
     }
 }
-复制代码
 ```
 
 好像有点不对劲？这不还是有嵌套嘛。
@@ -451,20 +510,17 @@ coroutineScope.launch(Dispatchers.IO) {
 如果只是使用 `launch` 函数，协程并不能比线程做更多的事。不过协程中却有一个很实用的函数：`withContext` 。这个函数可以切换到指定的线程，并在闭包内的逻辑执行结束之后，自动把线程切回去继续执行。那么可以将上面的代码写成这样：
 
 ```
-🏝️
 coroutineScope.launch(Dispatchers.Main) {      // 👈 在 UI 线程开始
     val image = withContext(Dispatchers.IO) {  // 👈 切换到 IO 线程，并在执行完成后切回 UI 线程
         getImage(imageId)                      // 👈 将会运行在 IO 线程
     }
     avatarIv.setImageBitmap(image)             // 👈 回到 UI 线程更新 UI
 } 
-复制代码
 ```
 
 这种写法看上去好像和刚才那种区别不大，但如果你需要频繁地进行线程切换，这种写法的优势就会体现出来。可以参考下面的对比：
 
 ```
-🏝️
 // 第一种写法
 coroutineScope.launch(Dispachers.IO) {
     ...
@@ -491,13 +547,11 @@ coroutineScope.launch(Dispachers.Main) {
     }
     ...
 }
-复制代码
 ```
 
 由于可以"自动切回来"，消除了并发代码在协作时的嵌套。由于消除了嵌套关系，我们甚至可以把 `withContext` 放进一个单独的函数里面：
 
 ```
-🏝️
 launch(Dispachers.Main) {              // 👈 在 UI 线程开始
     val image = getImage(imageId)
     avatarIv.setImageBitmap(image)     // 👈 执行结束后，自动切换回 UI 线程
@@ -506,7 +560,6 @@ launch(Dispachers.Main) {              // 👈 在 UI 线程开始
 fun getImage(imageId: Int) = withContext(Dispatchers.IO) {
     ...
 }
-复制代码
 ```
 
 这就是之前说的「用同步的方式写异步的代码」了。
@@ -514,22 +567,14 @@ fun getImage(imageId: Int) = withContext(Dispatchers.IO) {
 不过如果只是这样写，编译器是会报错的：
 
 ```
-🏝️
 fun getImage(imageId: Int) = withContext(Dispatchers.IO) {
     // IDE 报错 Suspend function'withContext' should be called only from a coroutine or another suspend funcion
 }
-复制代码
 ```
 
 意思是说，`withContext` 是一个 `suspend` 函数，它需要在协程或者是另一个 `suspend` 函数中调用。
 
 
-
-
-
-
-
-
 #### 挂起函数
 
 当我们调用标记有特殊修饰符`suspend`的函数时，会发生挂起:    
@@ -539,9 +584,13 @@ suspend fun doSomething(foo: Foo): Bar {
     ……
 }
 ```
-这样的函数称为挂起函数，因为调用它们可能挂起协程(如果相关调用的结果已经可用，库可以决定继续进行而不挂起)。挂起函数能够以与普通函数相同的方式
-获取参数和返回值，但它们只能从协程和其他挂起函数中调用。事实上，要启动协程，
-必须至少有一个挂起函数，它通常是匿名的(即它是一个挂起`lambda`表达式)。让我们来看一个例子，一个简化的`async()`函数
+这样的函数称为挂起函数，因为调用它们可能挂起协程(如果相关调用的结果已经可用，库可以决定继续进行而不挂起)。
+
+挂起函数能够以与普通函数相同的方式获取参数和返回值，但它们只能从协程和其他挂起函数中调用。
+
+事实上，要启动协程，必须至少有一个挂起函数，它通常是匿名的(即它是一个挂起`lambda`表达式)。
+
+让我们来看一个例子，一个简化的`async()`函数
 (源自`kotlinx.coroutines`库):    
 
 ```kotlin
@@ -558,7 +607,8 @@ async {
 }
 ```
 
-`await()`可以是一个挂起函数(因此也可以在一个`async {}`块中调用)，该函数挂起一个协程，直到一些计算完成并返回其结果:   
+`await()`可以是一个挂起函数(因此也可以在一个`async {}`块中调用)，该函数挂起一个协程，直到一些计算完成并返回其结果:  
+ 
 ```kotlin
 async {
     ……
@@ -569,13 +619,15 @@ async {
 ```
 
 
-请注意，挂起函数`await()`和`doSomething()`不能在像`main()`这样的普通函数中调用:    
+请注意，挂起函数`await()`和`doSomething()`不能在像`main()`这样的普通函数中调用:   
+ 
 ```kotlin
 fun main(args: Array<String>) {
     doSomething() // 错误：挂起函数从非协程上下文调用
 }
 ```
 还要注意的是，挂起函数可以是虚拟的，当覆盖它们时，必须指定`suspend`修饰符:    
+
 ```kotlin
 interface Base {
     suspend fun foo()
diff --git a/MobileAIModel/AIGC.md b/MobileAIModel/AIGC.md
new file mode 100644
index 00000000..e37d7149
--- /dev/null
+++ b/MobileAIModel/AIGC.md
@@ -0,0 +1,49 @@
+AIGC
+---
+
+
+### AIGC概念
+
+AIGC全称为AI-Generated Content，人工智能内容生成。   
+
+
+### 技术划分
+
+AIGC从技术上的应用可以划分为:     
+
+- 内容孪生: 是数字内容映射到另一个模态的技术，包括智能增强与智能转译，应用场景包括图像超分、语音转字幕、文字转语音等。   
+- 内容编辑: 通过理解内容及属性控制实现修改，应用场景: 场景剪辑、虚拟试衣、人声分离等。    
+- 内容生成: 通过学习海量数据中的抽象概念，并生成全新的内容，应用广泛，包括图像生成(AI绘画)、文本生成(AI写作)，视频生成、多模态生成等。 
+
+
+### 从生成内容划分    
+
+- 文本生成
+- 图像生成
+- 音频生成
+- 视频生成
+- 多模态生成
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/MobileAIModel/Agent Skill.md b/MobileAIModel/Agent Skill.md
new file mode 100644
index 00000000..4b590629
--- /dev/null
+++ b/MobileAIModel/Agent Skill.md	
@@ -0,0 +1,16 @@
+## Agent Skill
+
+Agent Skill是大模型的说明文档
+
+
+
+### MCP vs Skill 
+
+MCP给大模型提供数据，而Skill教大模型如何处理数据   
+
+MCP本质是是一个运行程序，而Skill本质是一个说明文档
+
+- MCP connects Claude to data
+- Skills teach Claude what to do with that data
+
+
diff --git a/MobileAIModel/Agent.md b/MobileAIModel/Agent.md
new file mode 100644
index 00000000..30a8a525
--- /dev/null
+++ b/MobileAIModel/Agent.md
@@ -0,0 +1,31 @@
+## Agent
+
+大模型是无法感知或改变外接环境的   
+
+那怎么来解决这个问题呢？    
+
+就是通过让大模型调用对应的工具Tool，就可以，例如:    
+
+- 读写文件内容
+- 查看文件列表
+- 运行终端命令
+
+
+### Agent运行模式  
+
+
+
+##### ReAct模式
+
+思考与行动:  Reasoning and Acting
+
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/react_1.png?raw=true)               
+
+
+
+##### Plan And Execute 
+
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/plan_and_execute_1.png?raw=true)               
+
+
+
diff --git a/MobileAIModel/RAG.md b/MobileAIModel/RAG.md
new file mode 100644
index 00000000..c50f2dfc
--- /dev/null
+++ b/MobileAIModel/RAG.md
@@ -0,0 +1,75 @@
+RAG
+---
+
+
+### RAG概念
+
+
+RAG(Retrieval Augmented Generation)：检索增强生成。     
+
+顾名思义，就是通过检索外部数据，增强大模型的生成效果。   
+
+RAG为LLM提供了从某些数据源检索到的信息，并基于此修正生成的答案。      
+
+RAG基本上是Search + LLM提示，可以通过大模型回答查询，并将搜索算法所找到的信息作为大模型的上下文。查询和检索到的上下文都会被注入发送到LLM的提示语中。    
+
+
+
+
+将大模型应用于实际业务场景时会发现，通用的基础大模型基本无法满足我们的实际业务需求，主要有以下几个方面的原因:      
+
+- LLM的知识不是实时的，不具备知识更新
+- LLM可能不知道你私有的领域/业务知识
+- LLM有时会在回答中生成看似合理但实际上是错误的信息  
+
+
+为什么会用RAG
+
+- 提高准确性: 通过检索相关的信息，RAG可以提高生成文本的准确性
+- 减少训练成本: 与需要大量数据来训练的大型生成模型相比，RAG可以通过检索机制来减少所需的训练数据量，从而降低训练成本。
+- 适应性强: RAG模型可以适应新的或不断变化的数据，由于它们能够检索最新的消息，因此在新数据和事件出现时，它们能够快速适应并生成相关的文本。   
+
+
+RAG系统兼具检索与生成的双重能力，可视为传统生成系统的升级版：既有效减少了幻觉现象，又显著提升了回答的事实准确性。该技术还支持“与数据对话”(chat with my data)的应用场景，使企业和个人能够将LLM与内部数据或特定数据源（如书籍内容）对接。
+
+RAG技术是一种结合信息检索与生成模型的新型架构，其核心思想是利用外部知识库或文档集合为大模型提供实时、准确的背景信息，从而弥补大模型的局限性。   
+
+
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/rag.png?raw=true)        
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/MobileAIModel/TensorFlow Lite.md b/MobileAIModel/TensorFlow Lite.md
new file mode 100644
index 00000000..0f9a7adf
--- /dev/null
+++ b/MobileAIModel/TensorFlow Lite.md	
@@ -0,0 +1,43 @@
+TensorFlow Lite
+---
+
+
+
+[TensorFlow Lite](https://tensorflow.google.cn/lite?hl=zh-cn) 是一个移动端库，可用于在移动设备、微控制器和其他边缘设备上部署模型。
+
+
+[TensorFlow Lite](https://tensorflow.google.cn/lite?hl=zh-cn) 是一组工具，可帮助开发者在移动设备、嵌入式设备和 loT 设备上运行模型，以便实现设备端机器学习。
+
+
+TensorFlow模型通常不是为移动场景而设计的，在这些场景中，必须考虑大小、电池消耗以及可能影响移动用户体验的所有其他因素。为此，TensorFlow Lite的创建有两个主要目标。第一，它可用于将现有的TensorFlow模型转换为更小、更紧凑的格式，着眼于针对移动设备进行优化。第二则是为可用于模型推理的各种移动平台提供高效的运行环境。
+
+
+TensorFlow Lite是TensorFlow在手机和嵌入设备上的一个轻量级框架。      
+
+主要特性:  
+
+- 通过解决以下 5 项约束条件，针对设备端机器学习进行了优化：延时（数据无需往返服务器）、隐私（没有任何个人数据离开设备）、连接性（无需连接互联网）、大小（缩减了模型和二进制文件的大小）和功耗（高效推断，且无需网络连接）。
+- 支持多种平台，涵盖 Android 和 iOS 设备、嵌入式 Linux 和微控制器。
+- 支持多种语言，包括 Java、Swift、Objective-C、C++ 和 Python。
+高性能，支持硬件加速和模型优化。
+- 提供多种平台上的常见机器学习任务的端到端示例，例如图像分类、对象检测、姿势估计、问题回答、文本分类等。
+
+
+1. 创建 TensorFlow Lite 模型
+TensorFlow Lite 模型以名为 FlatBuffer 的专用高效可移植格式（由“.tflite”文件扩展名标识）表示。      
+
+与 TensorFlow 的协议缓冲区模型格式相比，这种格式具有多种优势，例如可缩减大小（代码占用的空间较小）以及提高推断速度（可直接访问数据，无需执行额外的解析/解压缩步骤），这样一来，TensorFlow Lite 即可在计算和内存资源有限的设备上高效地运行。
+
+TensorFlow Lite 模型可以选择包含元数据，并在元数据中添加人类可读的模型说明和机器可读的数据，以便在设备推断过程中自动生成处理前和处理后流水线。如需了解详情，请参阅添加元数据。
+
+您可以通过以下方式生成 TensorFlow Lite 模型：
+
+使用现有的 TensorFlow Lite 模型：若要选择现有模型，请参阅 TensorFlow Lite 示例。模型可能包含元数据，也可能不含元数据。
+
+创建 TensorFlow Lite 模型：使用 TensorFlow Lite Model Maker，利用您自己的自定义数据集创建模型。默认情况下，所有模型都包含元数据。
+
+将 TensorFlow 模型转换为 TensorFlow Lite 模型：使用 TensorFlow Lite Converter 将 TensorFlow 模型转换为 TensorFlow Lite 模型。在转换过程中，您可以应用量化等优化措施，以缩减模型大小和缩短延时，并最大限度降低或完全避免准确率损失。默认情况下，所有模型都不含元数据。
+
+
+
+
diff --git "a/MobileAIModel/\345\244\247\346\250\241\345\236\213.md" "b/MobileAIModel/\345\244\247\346\250\241\345\236\213.md"
new file mode 100644
index 00000000..0dfdf6ae
--- /dev/null
+++ "b/MobileAIModel/\345\244\247\346\250\241\345\236\213.md"
@@ -0,0 +1,404 @@
+大模型简介
+---
+
+### 人工智能
+
+人工智能(AI, Artificial Inteligence)通常用于描述致力于执行接近人类智能任务(如语音识别、语音翻译和视觉感知)的计算机系统。它是指软件产生的智能，而不是人类的智能。   
+
+目标是研究、设计和构建具备智能、学习、推理和行动能力的计算机和机器。    
+
+例如: 2016年Alphago击败李世石围棋。     
+
+### 生成式人工智能
+
+GAI (Generative Aritificial Interligence)
+
+目标是让机器能够产生复杂有结构的物件。 例如chatGPT、deepseek。
+
+### 机器学习
+
+ML(Machine Learning)
+
+提到机器学习，追根溯源，我们需要先知道什么是“学习”。著名学者、1975年图灵奖获得者、1978年诺贝尔经济学奖获得者，赫伯特·西蒙（Herbert Simon）教授曾对“学习”下过一个定义:     
+
+如果一个系统，能够通过执行某个过程，就此改进它的性能，那么这个过程就是学习。    
+
+在西蒙看来，学习的核心目的就是改善性能。      
+
+其实对于人而言，这个定义也是适用的。如果我们仅仅进行低层次的重复性学习，而没有达到认知升级的目的，那么即使表面看起来非常勤奋，其实也仅仅是一个“伪学习者”，因为我们的性能并没有得到改善。       
+西蒙认为，对于计算机系统而言，通过运用数据及某种特定的方法（比如统计方法或推理方法）来提升机器系统的性能，就是机器学习（Machine Learning，简称ML）。        
+
+所谓机器学习，在形式上可近似等同于，在数据对象中通过统计或推理的方法，寻找一个有关特定输入和预期输出的功能函数f
+
+
+所有的监督学习（Supervised Learning），基本上都是分类（Classification）的代名词。它从有标签的训练数据中学习模型，然后对某个给定的新数据利用模型预测它的标签。        
+比如，小时候父母告诉我们某个动物是猫、狗或猪，然后在我们的大脑里就会形成或猫或狗或猪的印象（相当于模型构建），当面前来了一只“新”小狗时，如果你能叫出“这是一只小狗”，那么恭喜你，标签分类成功！         
+但如果你回答说“这是一头小猪”，这时你的父母就会纠正你的偏差：“乖，不对，这是一只小狗。”这样一来二去地进行训练，不断更新你大脑的认知体系，当下次再遇到这类新的猫、狗、猪时，你就会在很大概率上做出正确的“预测”分类。    
+监督学习，就是先利用有标签的训练数据学习得到一个模型，然后使用这个模型对新样本进行预测。在本质上，监督学习的目标在于，构建一个由输入到输出的映射，该映射用模型来表示。      
+
+### 深度学习
+
+DL(Deep Learning): 深度学习算法试图模拟人类大脑的工作方式，其灵感来源于神经生物学，它通过对大量数据的学习，自动提取出数据的高层次特征和模式，从而实现图像识别、语音识别、自然
+语言处理等任务。 
+
+按照架构的不同，神经网络可以分为:   
+
+- 卷积神经网络(CNNS)
+- 循环神经网络(RNNS)
+- Transformer网络等
+
+同样是区分不同水果，这次你带孩子去了超市，那里有各种不同的水果，你没有解释每种水果的特点，只是给孩子指出了哪些是苹果、哪些是香蕉，他通过观察和比较，慢慢学会了辨认各种水果。 
+
+在这个过程中，孩子的大脑(在这里比喻为深度学习模型)自动从复杂的视觉、嗅觉等信号中提取层次化的特征。比如圆形、条纹、颜色深浅、气味等，从而达到识别水果的目的。  
+
+
+### LoRA
+
+低秩自适应(Low-Rank Adaptation，LoRA)是一种针对大型预训练语言模型（如GPT-3）的微调技术。     
+LoRA的核心思想是通过对模型权重进行低秩更新，以实现有效的参数适应，而无须重新训练模型的全部参数。这种技术在保留预训练模型的泛化能力的同时，允许模型快速适应特定任务。
+
+
+
+
+### 多模态
+
+提及LLM时，我们通常不会第一时间联想到多模态。毕竟，LLM本质上是语言模型。但我们很快会发现，若能处理文本之外的数据类型，其应用价值将大幅提升。例如，当语言模型可“看到”图像并回答相关问题时，其效用将显著增强。这种能够处理文本与图像（每种数据类型称为一种模态）的模型，即被称为多模态(multimodal)模型
+
+能处理多种数据模态（如图像、音频、视频或传感器数据）的模型称为多模态模型。模型接收某种模态作为输入，但不一定能生成对应模态的输出
+
+### 什么是大模型
+
+大语言模型(large language model，LLM)，简称大模型。
+是一种基于深度学习技术训练出来的人工智能系统，主要用于处理和生成人类语言。    
+基本市面上所有的大模型都是基于Transformer架构训练出来的。   
+ 
+
+大模型已经对世界产生了深远的影响。通过使机器更好地理解和生成人类语言，LLM在人工智能(artificial inteligence，AI)领域开创了新的可能性，并影响了众多行业。
+
+
+
+模型规模: 通常包含数十亿到数千亿个参数，这些参数就像是模型的"大脑神经元"。     
+训练数据: 使用海量文本数据进行训练，包括书籍、文章、网页等各种形式的文字内容。
+
+在深度学习和像GPT这样的大语言模型中，“参数”指的是模型的可训练权重。这些权重本质上是模型的内部变量，在训练过程中通过调整和优化来最小化特定的损失函数。
+
+
+### 模型蒸馏
+
+大模型的运行需要极高的硬件资源，通常都是服务器集群并挂载数量众多的GPU(显卡)。
+为了满足低性能设备的运行，可以对大模型进行蒸馏。   
+
+例如deepseek r1的 7b模型、70b模型。 
+
+模型蒸馏: 对模型进行简化，在尽量保证模型性能的前提下，尽可能减少对硬件资源的需求。  
+
+简单理解就是假设你有一个超强的老师(大模型)，他能讲解很复杂的知识。
+你想把这些知识传授给一群学生(小模型)。为了让学生能在不需要过多时间和资源的情况下，快速掌握老师的知识。你可以通过“蒸馏的方式”，让学生只学习精华、最重要的部分。
+这样，学生虽然没有老师那么强大，单依然能做出优秀表现。   
+
+
+
+### 大模型训练
+
+大模型整体的训练主要分为三个阶段:    
+
+- 预训练: 注入领域知识     
+- SFT(监督微调):      
+- RLHF(基于人类反馈的强化学习)     
+
+
+
+### 模型部署
+
+
+#### ollama
+
+[ollama](https://ollama.com/)是一款旨在简化大型语言模型本地部署和运行过程的开源软件。   
+
+
+- 本地部署(ollama)
+    - 后端和模型部署(例如ollama本地部署千问模型)
+    - 前端部署(交互界面，例如chatbox ai、Stremlit)
+    - 用户使用
+
+#### LangChain
+
+
+[LangChain](https://www.langchain.com/)是一个用于构建和管理基于语言模型(Language Models，LM)的应用程序框架。      
+
+
+它提供了一系列工具和组件，帮助开发者更高效的构建、训练、部署和管理语言模型应用。      
+
+LangChain的设计目标是简化语言模型的使用过程，使其更加容易被集成到各种应用场景中。      
+它本质上是一个Python框架
+
+LangChain的名称源自其核心方法之一——链(chain)。虽然我们可以独立运行LLM，但链的真正威力在与其他组件协同工作，甚至在多条链相互配合时才能充分展现。这种架构不仅能拓展LLM的能力，还能实现链与链之间的无缝衔接。
+
+
+
+LangChain主要组件:   
+
+- Prompts: 提示，包括提示管理、提示优化和提示序列化
+- Models: 模型，各种类型的模型和模型集成，比如gpt-4、deepseek
+- Memory: 记忆，用来保存和模型交互时的上下文状态
+- Indexes: 索引，用来结构化文档，以便和模型交互
+- Chains: 链，一系列对各种组件的调用
+- Agents: 代理，决定模型采取哪些行动，执行并且观察流程，直到完成为止
+
+
+
+- 云端部署(LangChain)
+    - 后端部署(例如阿里云百炼平台部署千问模型)
+    - 前端部署(例如Stremlit)
+    - 用户使用
+
+
+
+模型部署总结:   
+
+Ollama是本地模型运行的入门工具。     
+LangChain是覆盖入门 + 进阶的全功能框架。    
+
+除了Ollama的功能外，LangChain额外多出了:   
+
+- 记忆能力: 基于ConversationBufferMemory等组件完成多轮对话历史记录    
+- 文档对接能力: 可实现PDF/Word等本地文档对打，构建私有知识库
+- 工具调用与智能体能力: 通过Tool、Agent组件让模型自动调用工具
+- 流程编排能力: SequentialChain、LCEL等实现任务自动化与并行模型
+
+以及，针对云平台的API调用支持(如阿里云的通义千问百炼平台、腾讯云的混元等)    
+
+
+
+## 端模型
+
+不是所有模型都奔着“更大更强”去才有价值。    
+
+相反，像Qwen3-0.6b这种小模型才是真正能在实际场景中跑起来、用得起的模型。   
+
+Qwen3-0.6b的表现:   
+
+- 推理速度快、延迟低：典型场景延迟在几十毫秒，适合边缘设备部署。  
+- 资源占用小: 内存带宽压力低，功耗控制出色，支持长时间稳定运行。 
+- 兼容性强: 广泛适用于query改写、文本匹配、语义检索等任务。   
+
+ 
+很多人认为Qwen3-0.6b不如7b、13b强大，因此没用。但现实是，在高并发、低延迟、受限资源的实际业务场景中，大模型往往根本上不了场。   
+
+总结: 轻、小、稳，才是能落地的关键。   
+
+举个例子:   
+
+普通小货车的运载能力相比较那些拉上十几吨、几十吨的大货车相差太多，难道它就没用用处吗？      
+
+当然不是，因为它的定位就是面对相对狭小的场景、相对少的货物做出更敏捷的选择。    
+
+Qwen3-0.6b的定位，从来也不是生成长文本或复杂推理，而是在多模态系统中提供“一点点启发性的信号”，用于放大系统整体效能。      
+
+这“一点点信号”在推荐、搜索、识别系统重，往往正是决定点击、转化、留存的关键。   
+
+
+我们选择部署Qwen3-0.6b，不是"凑合"，而是精准选择--它足够快、足够轻、足够稳，也足够使用。     
+
+在生产环境中，能跑、能稳、能提效的模型，才是真正有价值的模型。   
+
+
+
+### 大模型的工作流程
+
+
+大多数人与语言模型交互的方式是通过网页平台，它提供用户与语言模型之间的聊天界面。你可能会注意到，模型并不是一次性生成所有输出，而是一次生成一个词元。
+词元不仅是模型的输出单位，也是模型查看输入的方式。发送给模型的提示词首先被分解成词元。
+
+
+
+对计算机来说，语言是一个复杂的概念。   
+
+
+文本本质上是非结构化的，当用0和1(单个字符)表示时就会失去其含义。因此，在语言人工智能的发展历史中，人们一直非常关注如何以结构化的方式标识语言，使计算机能够更容易的使用。    
+
+语言人工智能历史始于一种名为词袋(bag of words)的技术，这是一种表示非结构化文本的方法。  
+
+词袋模式的工作原理如下: 假设我们有两个句子需要创建数值表示。
+
+词袋模型的第一步是分词(tokenization)，即将句子拆分为单个词或子词(词元(token))。   
+
+
+Token是大模型处理文本的最基本单元.
+
+Token和词并不是一一对应的，Token是模型自己学会的一套文本切分规则，切出来的每一块就是它一次能够处理的最小单位，一般来说一个token对应1.5 ~ 2个汉字或0.75个英文单词。    
+)
+
+用户和大模型的沟通过程:   
+
+1. 用户输入内容后，需要经过编码环节
+
+    - 切分
+    - 映射
+
+2. 将编码之后的token id传输给大模型
+3. 大模型基础计算预测后输出tokenid
+4. tokenid再经过解码环节，解码环节会将tokenid映射成对应的字
+5. 将字显示给用户
+6. 然后一直循环处理吐token直到结束
+
+
+最常见的分词方法是通过空格分割来把句子分割成词。      
+
+然而，这种方法也有其缺点，因为某些语言(如汉语)的词之间没有空格。
+在分词之后，我们将每个句子中所有不同的词组合起来，创建一个可用于表示句子的词表(vocabulary)。
+使用词表，我们只需计算每个句子中词出现的次数，就创建了一个词袋。       
+因此，词袋模型旨在以数字形式创建文本的表示(representation)，也称为向量或向量的标识。我们将这类模型称为表示模型(representation model)    
+
+
+
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/respresentation_1.png?raw=true)        
+
+通过计算单个词出现的次数创建词袋，这些值被称为向量表示。
+
+
+词袋虽然是一种优雅的方法，但存在一个明显的缺陷。它仅仅把语言视为一个几乎字面意义上的"词袋"，而忽略了文本的语音特性和含义。
+这是因为词袋模型就像把一段话拆成一堆词，装进袋子里，只数数量，不看顺序，不懂意思，不管谁和谁有关系。这让它在理解句子真正含义时，显的很呆。     
+比如狗追猫和猫追狗。 词袋模型看不出来到底谁追谁。    
+
+
+word2vec(词向量)于2013年发布，是首批成功利用嵌入(embeding)这个概念来捕捉文本含义的技术之一。     
+
+嵌入是数据的向量表示，试图捕捉数据的含义。为此word2vec通过在大量文本数据(如整个维基百科)上训练来学习词的语义表示。   
+
+为了生成这些语义表示，word2vec利用了神经网络(neural network)技术。    
+
+神经网络由处理信息的多层互连节点组成。神经网络可以有多个分层，每个连接有一定的权重，这些权重通常被称为模型的参数。    
+
+
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/neural_network_1.png?raw=true)        
+
+在训练过程中，word2vec会学习词与词之间的关系，并将这些信息提炼到词嵌入中。如果两个词各自的相邻词集合有更大的交集，它们的词嵌入向量就会更接近，反之亦然。    
+
+词嵌入可以用多种属性来表示一个词的含义。由于嵌入向量的大小是固定的，这些属性需要经过精心选择，以构建用来代表词的“心智表征”的抽象标识。 
+
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/word2vec_2.png?raw=true)        
+
+在实践中，这些属性通常相当抽象，很少与单一实体或人类可识别的概念相关。然而，这些属性组合在一起对计算机来说是有意义的，是将人类语言转换为计算机语言行之有效的方式。     
+
+词嵌入非常有用，因为它使我们能够衡量两个词的语义相似度。   
+
+上面word2vec的训练过程会创建静态的、可下载的词标识。例如，bank这个词无论在什么上下文中使用，都会有相同的词嵌入。   
+
+然而，bank既可以指银行，也可以指河岸。它的含义应该根据上下文而变化，因此它的嵌入也应该根据上下文而变化。   
+使用RNN(Recurrent Neural Network，循环神经网络)，可以实现文本编码的一个步骤。这些神经网络的变体可以将序列作为补充输入进行建模。    
+为此，这些RNN被用于两个任务:    
+- 编码: 也就是表示输入句子
+- 解码: 也就是输出句子
+
+该架构中的每个步骤都是自回归(auto - regressvie)的，在生成下一个词时，该架构需要使用所有先前生成的词作为输入。    
+然而，这种上下文嵌入方式存在局限性，因为它仅用一个嵌入向量来表示整个输入，使得处理较长的句子变得困难。    
+
+在2014年，研究人员提出了注意力(attention)解决方案，大大改善了原始架构。    
+注意力云讯模型关注输入序列中彼此相关(相互注意)的部分，并放大它们的信号，注意力机制通过选择性地聚焦于句子中最关键的词，来突出其重要性。   
+
+### Transformer
+
+在2017年著名论文"Attention is All You Need"首次探讨了注意力机制的真正威力，并提出了一种被称为Transformer的网络架构。    
+
+Transformer完全基于注意力机制，摒弃了此前提到的RNN。与RNN相比，Transformer支持并行训练，这大大加快了训练速度。    
+在Transformer中，编码和解码组件相互堆叠。这种架构仍然是自回归的，每个新生成的词都被模型用于生成下一个词。   
+
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/transformer_1.png?raw=true)        
+
+Transformer由堆叠的编码器和解码器块组合而成，输入依次轮流经每个编码器和解码器. 
+
+要理解Transformer LLM的行为，最常见的方式是将其视为一个接收文本输入并生成响应文本的软件系统。 
+
+通过分词后大模型会生成一个个的新词元的概率列表，然后从生成的词元列表中选择某一个词元的过程就叫做解码策略。 
+
+每次都选择概率分数最高的词元的策略被称为贪心解码。这就是在LLM中将温度(temperature)参数设为零时会发生的情况。
+
+
+
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/transformer_2.png?raw=true)        
+
+· Transformer LLM 每次生成一个词元。     
+· 生成的词元会被追加到提示词中，然后，这个更新后的提示词会再次被输入模型进行下一次前向传播，以生成下一个词元。    
+· Transformer LLM的三个主要组件是分词器、一系列Transformer块和语言建模头。    
+· 分词器包含模型的词元词表。模型中包含与这些词元相关联的词元嵌入。将文本分解成词元，然后使用这些词元的嵌入向量，是词元生成过程的第一步。    
+· 前向传播会依次经过所有阶段。    
+· 在处理接近尾声时，语言建模头会对下一个可能的词元进行概率评分。解码策略决定了在这一生成步骤中选择哪个实际词元作为输出（有时是概率最高的下一个词元，但并非总是如此）。    
+· Transformer表现出色的原因之一是它能够并行处理词元。每个输入词元都流入其独立的计算流（也称为处理路径）。这些流的数量就是模型的“上下文长度”，代表模型可以处理的最大词元数量。    
+· 由于Transformer LLM通过循环来一次生成一个词元的文本，因此缓存每个步骤的处理结果是一种很好的策略，这样可以避免重复处理工作（这些结果以各种矩阵的形式存储在层中）。    
+· 大部分处理发生在Transformer块中。这些块由两个组件组成，其中一个是前馈神经网络，它能够存储信息，并根据训练数据进行预测和插值。    
+· Transformer块的另一个主要组件是自注意力。自注意力整合了上下文信息，使模型能够更好地捕捉语言的细微差别。    
+· 注意力过程分为两个主要步骤：相关性评分；信息组合。    
+· Transformer的自注意力层并行执行多个注意力操作，每个操作都发生在注意力头内，它们的输出被聚合成自注意力层的输出。    
+· 通过在所有注意力头或一组注意力头（分组查询注意力）之间共享键矩阵和值矩阵，可以加速注意力计算。    
+· Flash Attention等方法通过优化在GPU不同显存系统上的操作方式来加速注意力计算。    
+
+
+
+
+
+
+
+##### 1. 分词化与词表映射
+
+分词化(Tokenization)是自然语言处理(NLP)中的重要概念，它是将段落和句子分割成更小的分词(Token)的过程。    
+
+举一个实际的例子，以下是一个英文句子:    
+
+I want to study LLM.   
+
+为了让机器理解这个句子，对字符串执行分词化，将其分解为独立的单元。使用分词化，我们会得到这样的结果:     
+
+`["I", "want", "to", "study", "LLM", "."]`
+
+将一个句子分解成更小的、独立的部分可以帮助计算机理解句子的各个部分，以及它们在上下文中的作用，这对于进行大量上下文的分析尤其重要。   
+
+每一个分词(token)都会通过预先设置好的词表，映射为一个tokenid，这是token的身份证，这样一句话最终会被表示为一个元素为tokenid的列表，供给计算机进行下一步处理。
+
+
+
+##### 2. 文本生成过程
+
+
+大模型的工作概括来说是根据给定的文本预测下一个token。 
+
+对于我们来说，看似像在对大模型提问，但实际上是给了大模型一串提示文本，让它可以对后续的文本进行推理。   
+
+大模型的推理过程不是一步到位的，当大模型进行推理时，它会基于现有的token，根据概率最大原则预测出下一个最有可能的token，然后将该预测的token加入到输入序列中，并将更新
+后的输入序列继续输入大模型预测下一个token。
+这个概率则是我们用很多的文本，分词为token以后训练大模型得来的。   
+
+
+
+### LLM
+
+
+LLM大模型训练流程:    
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/llm_training_process.png?raw=true)        
+
+
+
+
+
+### 提示工程
+
+提示工程(Prompt Engineering)是一项通过优化提示词(Prompt)和生成策略，从而获得更好的模型返回结果的工程技术。    
+
+提示词(Prompt)  --> 大语言模型(LLM) -->  返回结果(Completion)
+
+- 好的Prompt需要不断优化
+- 说清楚自己到底想要什么，要具体
+- 不要让机器去猜测太多，为了不让机器去猜测，我们就需要告诉细节
+- 提示工程有一些技巧，灵活掌握，事半功倍。   
+
+
+一个包含多个组件的复杂提示词示例:     
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/prompt_engie_1.png?raw=true)        
+
+
+
+### GPU
+
+计算资源通常是指系统中可用的GPU（graphics processing unit，图形处理单元，通常称显卡）资源。      
+
+强大的GPU可以加速LLM的训练和使用。在选择GPU时，一个重要的因素是可用的VRAM（video random access memory，视频随机存储器，通常称显存）容量，即GPU上可用的内存量。实践中，显存越大越好。原因是如果没有足够的显存，某些模型根本无法使用。
diff --git "a/MobileAIModel/\351\242\204\350\256\255\347\273\203.md" "b/MobileAIModel/\351\242\204\350\256\255\347\273\203.md"
new file mode 100644
index 00000000..87bf60d2
--- /dev/null
+++ "b/MobileAIModel/\351\242\204\350\256\255\347\273\203.md"
@@ -0,0 +1,11 @@
+预训练
+---
+
+
+
+### 文本分类
+
+
+文本分类是NLP中的一项常见任务。    
+
+该任务的目标是训练一个模型，为输入的文本分配标签或类别。从情感分析和意图识别，到实体提取和语言检测，文本分类在全球范围内被广泛应用
diff --git "a/OperatingSystem/1.\346\223\215\344\275\234\347\263\273\347\273\237\347\256\200\344\273\213.md" "b/OperatingSystem/1.\346\223\215\344\275\234\347\263\273\347\273\237\347\256\200\344\273\213.md"
index ddfe2b25..9971d3a0 100644
--- "a/OperatingSystem/1.\346\223\215\344\275\234\347\263\273\347\273\237\347\256\200\344\273\213.md"
+++ "b/OperatingSystem/1.\346\223\215\344\275\234\347\263\273\347\273\237\347\256\200\344\273\213.md"
@@ -103,7 +103,7 @@
 
 ## 操作系统的基本特征
 
-并发和共享是操作系统的两个最基本的特征，它们又互为存在条件。一方面，资源共享是以程序（进程）的并发执行为条件的，若系统部允许程序并发执行，自然不存在资源共享问题。另一方面，若系统部能对资源共享实施有效管理，也必将影响程序的并发执行，甚至根本无法并发执行。
+并发和共享是操作系统的两个最基本的特征，它们又互为存在条件。一方面，资源共享是以程序（进程）的并发执行为条件的，若系统不允许程序并发执行，自然不存在资源共享问题。另一方面，若系统部能对资源共享实施有效管理，也必将影响程序的并发执行，甚至根本无法并发执行。
 
 ## 计算机的组成
 
@@ -172,9 +172,36 @@
     U-Boot分为SPL和正常的U-Boot程序两个部分，如果想要编译为SPL，需要开启配置宏CONFIG_SPL_BUILD。SPL是“Secondary Program Loader”的简称，即第二阶段程序加载器，第二阶段是相对于处理器里面的只读存储器中的固化程序来说的，处理器启动时最先执行的是只读存储器中的固化程序。固化程序通过检测启动方式来加载第二阶段程序加载器。为什么需要第二阶段程序加载器？原因是：一些处理器内部集成的静态随机访问存储器比较小，无法装载一个完整的U-Boot镜像，此时需要第二阶段程序加载器，它主要负责初始化内存和存储设备驱动，然后把正常的U-Boot镜像从存储设备读到内存中执行。
 
 
-- 操作系统内核初始化 执行内核程序，这一步所说的内核程序在上一步中指的就是”用户程序“。因为从CPU的角度来看，除了Bootloader之外的所有程序都是用户程序，只是从软件的角度来看，用户程序被分为”内核程序“和”应用程序“，而本步执行的是内核程序。 内核程序初始化时执行的操作包括，初始化各种硬件，包括内存、网络接口、显示器、输入设备、然后建立各种内部数据结构，这些数据结构将用于多线程调度及内存的管理等。当内核初始化完毕后就开始运行具体的应用程序了。在一般情况下，习惯于将第一个应用程序称为”Home程序“。 - 执行第一个应用程序 运行Home程序，比如Windows系统的桌面。之所以称为Home程序，是因为通过该程序可以方便的启动其他应用程序。而传统的Linux系统启动后第一个运行的程序一般是一个Terminal。 ### Android系统启动过程 目前的Android系统大多运行在ARM处理器之上。ARM本身是一个公司的名称，从技术的角度来看，它又是一种微处理器内核的架构。 对于ARM处理器，当复位完毕后，处理器首先执行芯片上ROM中的一小块程序。这块ROM的大小一般只有几KB，该段程序就是Bootloader程序，这段程序执行时会根据处理器上一些特定引脚的高低电平状态，选择从何种物理接口上装载用户程序，比如USB口、SD卡、并口Flash等。
+- 操作系统内核初始化     
 
-多数基于ARM的实际硬件系统，会从并口NAND Flash芯片上的0x00000000地址处装载程序。对于一些小型嵌入式系统而言，该地址中的程序就是最终要执行的用户程序；而对于Android而言，该地址中的程序还不是Android程序，而是一个叫做uboot或者fastboot的程序，其作用是初始化硬件设备，比如网口、SDRAM、RS232等，并提供一些调试功能，比如向NAND Flash中写入新的数据，这可用于开发过程中的内核烧写、升级等。
+    执行内核程序，这一步所说的内核程序在上一步中指的就是”用户程序“。    
+
+因为从CPU的角度来看，除了Bootloader之外的所有程序都是用户程序，只是从软件的角度来看，用户程序被分为”内核程序“和”应用程序“，而本步执行的是内核程序。     
+
+内核程序初始化时执行的操作包括，初始化各种硬件，包括内存、网络接口、显示器、输入设备、然后建立各种内部数据结构，这些数据结构将用于多线程调度及内存的管理等。     
+当内核初始化完毕后就开始运行具体的应用程序了。     
+在一般情况下，习惯于将第一个应用程序称为”Home程序“。    
+
+- 执行第一个应用程序     
+
+运行Home程序，比如Windows系统的桌面。    
+之所以称为Home程序，是因为通过该程序可以方便的启动其他应用程序。而传统的Linux系统启动后第一个运行的程序一般是一个Terminal。 
+
+### Android系统启动过程      
+
+目前的Android系统大多运行在ARM处理器之上。     
+
+ARM本身是一个公司的名称，从技术的角度来看，它又是一种微处理器内核的架构。    
+
+对于ARM处理器，当复位完毕后，处理器首先执行芯片上ROM中的一小块程序。    
+
+这块ROM的大小一般只有几KB，该段程序就是Bootloader程序，这段程序执行时会根据处理器上一些特定引脚的高低电平状态，选择从何种物理接口上装载用户程序，比如USB口、SD卡、并口Flash等。
+
+多数基于ARM的实际硬件系统，会从并口(并行接口)NAND Flash芯片上的0x00000000地址处装载程序。     
+
+对于一些小型嵌入式系统而言，该地址中的程序就是最终要执行的用户程序；     
+
+而对于Android而言，该地址中的程序还不是Android程序，而是一个叫做uboot或者fastboot的程序，其作用是初始化硬件设备，比如网口、SDRAM、RS232等，并提供一些调试功能，比如向NAND Flash中写入新的数据，这可用于开发过程中的内核烧写、升级等。
 
 当uboot（fastboot）被装载后便开始运行，它一般会先检测用户是否按下了某些特别的按键，这些特别按键是uboot在编译时预先预定好的，用于进入调试模式。如果用户没有按这些特殊的按键，则uboot会从NAND Flash中装载Linux内核，装载的地址是在编译uboot时预先约定好的。
 
@@ -228,19 +255,35 @@ Android平台的基础是Linux内核，比如ART虚拟机最终调用底层Linux
 
 ![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/app_process.jpg?raw=true)        
 
-简单的来说一个正在运行的程序会做一件非常简单的事情：执行指令。处理器从内存中获取（fetch）一条指令，对其进行解码（decode）（弄清楚这是哪条指令），然后执行（execute）它（做它应该做的事情，如两个数相加、访问内存、检查条件、跳转到函数等）。完成这条指令后，处理器继续执行下一条指令，依此类推，直到程序最终完成。
+简单的来说一个正在运行的程序会做一件非常简单的事情：执行指令。     
+
+处理器从内存中获取（fetch）一条指令，对其进行解码（decode）（弄清楚这是哪条指令），然后执行（execute）它（做它应该做的事情，如两个数相加、访问内存、检查条件、跳转到函数等）。     
+
+完成这条指令后，处理器继续执行下一条指令，依此类推，直到程序最终完成。
 
 这样，我们就描述了冯·诺依曼（Von Neumann）计算模型的基本概念。听起来很简单，对吧？但是在一个程序运行的同时，还有很多其他疯狂的事情也在同步进行——主要是为了让系统易于使用。
 
 实际上，有一类软件负责让程序运行变得容易（甚至允许你同时运行多个程序），允许程序共享内存，让程序能够与设备交互，以及其他类似的有趣的工作。这些软件称为操作系统（Operating System，OS），因为它们负责确保系统既易于使用又正确高效地运行。
 
-要做到这一点，操作系统主要利用一种通用的技术，我们称之为虚拟化（virtualization）。也就是说，操作系统将物理（physical）资源（如处理器、内存或磁盘）转换为更通用、更强大且更易于使用的虚拟形式。因此，我们有时将操作系统称为虚拟机（virtual machine）。
+要做到这一点，操作系统主要利用一种通用的技术，我们称之为虚拟化（virtualization）。     
+
+也就是说，操作系统将物理（physical）资源（如处理器、内存或磁盘）转换为更通用、更强大且更易于使用的虚拟形式。     
+
+因此，我们有时将操作系统称为虚拟机（virtual machine）。
 
 
 
 ### 什么是虚拟化？
 
-假设我们有一个桃子，我们称之为物理（physical）的桃子。但有很多想吃这个桃子的人，我们希望向每个想吃的人提供一个属于他的桃子，这样才能皆大欢喜。我们把给每个人的桃子称为虚拟（virtual）桃子。我们通过某种方式，从这个物理桃子创造出许多虚拟桃子。重要的是，在这种假象中，每个人看起来都有一个物理桃子，但实际上不是。每个人都不知道他在和别人一起分享这个桃子，但是如果我和别人分享同一个桃子我一定会发现这个问题。但是只有吃的人多才有这样的问题。多数时间他们都在打盹或者做其他事情，所以，你可以在他们打盹的时候把他手中的桃子拿过来分给其他人，这样我们就创造了有许多虚拟桃子的假象，每个人有一个桃子。
+假设我们有一个桃子，我们称之为物理（physical）的桃子。      
+
+但有很多想吃这个桃子的人，我们希望向每个想吃的人提供一个属于他的桃子，这样才能皆大欢喜。     
+
+我们把给每个人的桃子称为虚拟（virtual）桃子。我们通过某种方式，从这个物理桃子创造出许多虚拟桃子。    
+重要的是，在这种假象中，每个人看起来都有一个物理桃子，但实际上不是。    
+
+每个人都不知道他在和别人一起分享这个桃子，但是如果我和别人分享同一个桃子我一定会发现这个问题。但是只有吃的人多才有这样的问题。    
+多数时间他们都在打盹或者做其他事情，所以，你可以在他们打盹的时候把他手中的桃子拿过来分给其他人，这样我们就创造了有许多虚拟桃子的假象，每个人有一个桃子。
 
 以最基本的计算机资源CPU为例，假设一个计算机只有一个CPU(尽管现在计算机一般拥有2个、4个或更多CPU)，虚拟化要做的就是将这个CPU虚拟成多个虚拟CPU并分给每一个进程使用，因此，每个应用都以为自己在独占CPU，但实际上只有一个CPU。这样操作系统就创造了美丽的假象--它虚拟化了CPU。
 
@@ -250,7 +293,11 @@ Android平台的基础是Linux内核，比如ART虚拟机最终调用底层Linux
 
 ## CPU(Central Processing Unit)
 
-CPU(中央处理器)是计算机的大脑，它主要和内存进行交互，从内存中提取指令并执行它。它是一块超大规模的集成电路(Integrated Circuit)，是信息处理、程序运行的最终执行单元。其功能主要是解释计算机指令以及处理计算机软件中的数据。由于访问内存获取执行或数据要比执行指令花费的时间长，因此所有的 CPU 内部都会包含一些寄存器来保存关键变量和临时结果。    
+CPU(中央处理器)是计算机的大脑，它主要和内存进行交互，从内存中提取指令并执行它。
+
+它是一块超大规模的集成电路(Integrated Circuit)，是信息处理、程序运行的最终执行单元。    
+其功能主要是解释计算机指令以及处理计算机软件中的数据。    
+由于访问内存获取执行或数据要比执行指令花费的时间长，因此所有的 CPU 内部都会包含一些寄存器来保存关键变量和临时结果。    
 因此，在指令集中通常会有一些指令用于把关键字从内存中加载到寄存器中，以及把关键字从寄存器存入到内存中。
     
 从功能方面来看，CPU的内部主要由寄存器，控制器，运算器构成，各部分之间由电流信号相互连通。其中运算器负责算术运算和逻辑运算，控制器负责计算指令的解析，产生各种控制指令，寄存器组用来临时存放参加运算的数据和计算的中间结果。    
diff --git "a/OperatingSystem/2.\350\277\233\347\250\213\344\270\216\347\272\277\347\250\213.md" "b/OperatingSystem/2.\350\277\233\347\250\213\344\270\216\347\272\277\347\250\213.md"
index 906d5fd8..c488cb4c 100644
--- "a/OperatingSystem/2.\350\277\233\347\250\213\344\270\216\347\272\277\347\250\213.md"
+++ "b/OperatingSystem/2.\350\277\233\347\250\213\344\270\216\347\272\277\347\250\213.md"
@@ -327,15 +327,15 @@ A给B发送信号，B收到信号之前执行自己的代码，收到信号后
 int kill(pid_t pid, int sig);
 ```
 
-    两个或多个进程可以通过简单的信号进行合作，可以强迫一个进程在某个位置停止，直到它接收到一个特定的信号。信号量是一个特殊的变量。用于进程间传递信息的一个整数值。
+两个或多个进程可以通过简单的信号进行合作，可以强迫一个进程在某个位置停止，直到它接收到一个特定的信号。信号量是一个特殊的变量。用于进程间传递信息的一个整数值。
 
-    信号是 UNIX 系统最先开始使用的进程间通信机制，因为 Linux 是继承于 UNIX 的，所以 Linux 也支持信号机制，通过向一个或多个进程发送`异步事件信号`来实现，信号可以从键盘或者访问不存在的位置等地方产生；信号通过 shell 将任务发送给子进程。
+信号是 UNIX 系统最先开始使用的进程间通信机制，因为 Linux 是继承于 UNIX 的，所以 Linux 也支持信号机制，通过向一个或多个进程发送`异步事件信号`来实现，信号可以从键盘或者访问不存在的位置等地方产生；信号通过 shell 将任务发送给子进程。
 
-    你可以在 Linux 系统上输入 `kill -l` 来列出系统使用的信号。
+你可以在 Linux 系统上输入 `kill -l` 来列出系统使用的信号。
 
-    进程可以选择忽略发送过来的信号，但是有两个是不能忽略的：`SIGSTOP` 和 `SIGKILL` 信号。SIGSTOP 信号会通知当前正在运行的进程执行关闭操作，SIGKILL 信号会通知当前进程应该被杀死。除此之外，进程可以选择它想要处理的信号，进程也可以选择阻止信号，如果不阻止，可以选择自行处理，也可以选择进行内核处理。如果选择交给内核进行处理，那么就执行默认处理。
+进程可以选择忽略发送过来的信号，但是有两个是不能忽略的：`SIGSTOP` 和 `SIGKILL` 信号。SIGSTOP 信号会通知当前正在运行的进程执行关闭操作，SIGKILL 信号会通知当前进程应该被杀死。除此之外，进程可以选择它想要处理的信号，进程也可以选择阻止信号，如果不阻止，可以选择自行处理，也可以选择进行内核处理。如果选择交给内核进行处理，那么就执行默认处理。
 
-    操作系统会中断目标程序的进程来向其发送信号、在任何非原子指令中，执行都可以中断，如果进程已经注册了新号处理程序，那么就执行进程，如果没有注册，将采用默认处理的方式。
+操作系统会中断目标程序的进程来向其发送信号、在任何非原子指令中，执行都可以中断，如果进程已经注册了新号处理程序，那么就执行进程，如果没有注册，将采用默认处理的方式。
 
    信号效率非常高，但是可携带的数据有限，只能写到一个标志位，无法携带其他数据。
 
@@ -356,12 +356,14 @@ int kill(pid_t pid, int sig);
 
     管道、套接字、信号、信号量，虽然满足了多种通信需要，但还是有一种需要未能满足。这就是两个进程需要共享大量数据。这就像两个人，他们互相喜欢，并想要一起生活时（共享大量数据量），打电话、握手、对白等就显得不够了，这个时候需要的是拥抱，只有将其紧紧拥抱于怀，感觉才最到位，也才能尽可能地共享。进程的拥抱就是共享内存。    
     共享内存就是两个进程共同拥有同一片内存。对于这片内存中的任何内容，二者均可以访问。要使用共享内存进行通信，一个进程首先需要在内核中创建一片内存空间专门作为通信用，然后该进程与这片内存空间进行关联，而其他进程则将该片内存映射到自己的（虚拟）地址空间。    
-    这样，读写自己地址空间中对应共享内存的区域时，就是在和其他进程进行通信。乍一看，共享内存有点像管道，有些管道不也是一片共享内存吗？这是形似而神不似：- 首先，使用共享内存机制通信的两个进程必须在同一台物理机器上；
+    这样，读写自己地址空间中对应共享内存的区域时，就是在和其他进程进行通信。乍一看，共享内存有点像管道，有些管道不也是一片共享内存吗？这是形似而神不似：
+
+- 首先，使用共享内存机制通信的两个进程必须在同一台物理机器上；    
 - 其次，共享内存的访问方式是随机的，而不是只能从一端写，另一端读，因此其灵活性比管道和套接字大很多，能够传递的信息也复杂得多。
 
 共享内存的缺点是管理复杂，且两个进程必须在同一台物理机器上才能使用这种通信方式。共享内存的另外一个缺点是安全性脆弱。因为两个进程存在一片共享的内存，如果一个进程染有病毒，很容易就会传给另外一个进程。就像两个紧密接触的人，一个人的病毒是很容易传染另外一个人的。这里需要注意的是，使用全局变量在同一个进程的进程间实现通信不称为共享内存。
 
-    共享内存是进程通信中最快的一种方法，因为数据不需要在进程间复制，而可以直接映射到各个进程的地址空间中。在共享内存中要注意的一个问题是：当多个进程对共享内存区域进行访问时，要注意这些进程之间的同步问题。    
+共享内存是进程通信中最快的一种方法，因为数据不需要在进程间复制，而可以直接映射到各个进程的地址空间中。在共享内存中要注意的一个问题是：当多个进程对共享内存区域进行访问时，要注意这些进程之间的同步问题。    
 例如，如果server正在向共享内存区域中写数据，那么client进程就不能访问这些数据，直到server全部写完之后，client才可以访问。    
 为了实现进程间的同步问题，通常使用前面介绍过的信号量来实现这一目标。一个共享内存段可以由一个进程创建，然后由任意共享这一内存段的进程对它进行读写。    
 当进程间需要通信时，一个进程可以创建一个共享内存段，然后需要通信的各个进程就可以在信号量的控制下保持同步，在这里交换数据，完成通信。
@@ -383,7 +385,7 @@ FIFO常被称为命名管道，以区分管道(pipe)。管道(pipe)只能用于
        FIFO是Linux基础文件类型中的一种。但，FIFO文件在磁盘上没有数据块，仅仅用来标识内核中一条通道。各进程可以打开这个文件进行read/write，实际上是在读写内核通道，这样就实现了进程间通信。
 创建方式：
 1. 命令：mkfifo 管道名
-       2. 库函数：int mkfifo(const char *pathname,  mode_t mode);  成功：0； 失败：-1
+2. 库函数：int mkfifo(const char *pathname,  mode_t mode);  成功：0； 失败：-1
        一旦使用mkfifo创建了一个FIFO，就可以使用open打开它，常见的文件I/O函数都可用于fifo。如：close、read、write、unlink等。
 
 
diff --git a/OperatingSystem/5.I:O.md b/OperatingSystem/5.IO.md
similarity index 99%
rename from OperatingSystem/5.I:O.md
rename to OperatingSystem/5.IO.md
index 4ed8964e..dba31d71 100644
--- a/OperatingSystem/5.I:O.md
+++ b/OperatingSystem/5.IO.md
@@ -36,13 +36,12 @@ I/O进程是专门处理系统中的I/O请求和I/O中断工作的。是系统
     
     当一个 I/O 设备完成它的工作后，它就会产生一个中断（默认操作系统已经开启中断），它通过在总线上声明已分配的信号来实现此目的。主板上的中断控制器芯片会检测到这个信号，然后执行中断操作。
 
-​    
 
 ### 磁盘高速缓存
 
 
 
-高速缓冲存储器（cache memory）通常指比内存小且比内存块的存储器，它位于内存和处理器之间。这种高速缓冲存储器利用局部性原理来减少平均存储器的存取时间。同样的原理也适用于磁盘存储器。磁盘高速缓存是内存中为磁盘扇区设置的一个缓冲区，它包含有磁盘中某些扇区的副本。出现对某一特定扇区的I/O请求时，首先会进行检测，以确定该扇区是否在磁盘的高速缓存中。若在则该请求可通过这个高速缓存来满足。若不在，则把被请求的扇区从磁盘读到磁盘高速缓存中。
+高速缓冲存储器（cache memory）通常指比内存小且比内存快的存储器，它位于内存和处理器之间。这种高速缓冲存储器利用局部性原理来减少平均存储器的存取时间。同样的原理也适用于磁盘存储器。磁盘高速缓存是内存中为磁盘扇区设置的一个缓冲区，它包含有磁盘中某些扇区的副本。出现对某一特定扇区的I/O请求时，首先会进行检测，以确定该扇区是否在磁盘的高速缓存中。若在则该请求可通过这个高速缓存来满足。若不在，则把被请求的扇区从磁盘读到磁盘高速缓存中。
 
 
 
diff --git "a/OperatingSystem/AndroidKernal/1.Android\350\277\233\347\250\213\351\227\264\351\200\232\344\277\241.md" "b/OperatingSystem/AndroidKernal/1.Android\350\277\233\347\250\213\351\227\264\351\200\232\344\277\241.md"
index a6c6a9e3..69160731 100644
--- "a/OperatingSystem/AndroidKernal/1.Android\350\277\233\347\250\213\351\227\264\351\200\232\344\277\241.md"
+++ "b/OperatingSystem/AndroidKernal/1.Android\350\277\233\347\250\213\351\227\264\351\200\232\344\277\241.md"
@@ -4,13 +4,23 @@
 
 ## Binder简介
 
-Binder，英文的意思是别针、回形针。我们经常用别针把两张纸”别“在一起，而在Android中，Binder用于完成进程间通信（IPC），即把多个进程”别“在一起。比如，普通应用程序可以调用音乐播放服务提供的播放、暂停、停止等功能。Binder工作在Linux层面，属于一个驱动，只是这个驱动不需要硬件，或者说其操作的硬件是基于一小段内存。从线程的角度来讲，Binder驱动代码运行在内核态，客户端程序调用Binder是通过系统调用完成的。
+Binder，英文的意思是别针、回形针。     
+
+我们经常用别针把两张纸”别“在一起，而在Android中，Binder用于完成进程间通信（IPC），即把多个进程”别“在一起。    
+
+比如，普通应用程序可以调用音乐播放服务提供的播放、暂停、停止等功能。    
+
+Binder工作在Linux层面，属于一个驱动，只是这个驱动不需要硬件，或者说其操作的硬件是基于一小段内存。    
+
+从线程的角度来讲，Binder驱动代码运行在内核态，客户端程序调用Binder是通过系统调用完成的。
 
 
 
 ## 进程间通信
 
-无论是Android系统，还是各种Linux衍生系统，各个组件、模块往往运行在各种不同的进程和线程内，这里就必然涉及进程/线程之间的通信。对于IPC(Inter-Process Communication,  进程间通信)，Linux目前有一下这些IPC机制: 
+无论是Android系统，还是各种Linux衍生系统，各个组件、模块往往运行在各种不同的进程和线程内，这里就必然涉及进程/线程之间的通信。    
+
+对于IPC(Inter-Process Communication,  进程间通信)，Linux目前有一下这些IPC机制: 
 
 - 管道(Pipe)
 
@@ -41,7 +51,9 @@ Binder，英文的意思是别针、回形针。我们经常用别针把两张
 
     套接字的创建和使用与管道是有区别的，套接字明确的将客户端与服务器区分开来，可以实现多个客户端连到同一个服务器。
 
-Android额外还有Binder  IPC机制，Android OS中的Zygote进程的IPC采用的是Socket机制，在上层system server、media  server以及上层App之间更多的是采用Binder。 IPC方式来完成跨进程间的通信。对于Android上层架构中，很多时候是在同一个进程的线程之间需要相互通信，例如同一个进程的主线程与工作线程之间的通信，往往采用的Handler消息机制。所以对于Android最上层架构而言，最常用的通信方式是: 
+Android额外还有Binder IPC机制，Android OS中的Zygote进程的IPC采用的是Socket机制，在上层system server、media  server以及上层App之间更多的是采用Binder IPC方式来完成跨进程间的通信。     
+
+对于Android上层架构中，很多时候是在同一个进程的线程之间需要相互通信，例如同一个进程的主线程与工作线程之间的通信，往往采用的Handler消息机制。所以对于Android最上层架构而言，最常用的通信方式是: 
 
 - Binder
 
@@ -68,7 +80,8 @@ Android额外还有Binder  IPC机制，Android OS中的Zygote进程的IPC采用
 
 ### 进程隔离
 
-进程隔离是操作系统为了保护进程之间不相互干扰而设计的，避免进程A写入进程B的情况发生，其实现就是使用虚拟地址空间，两个进程虚拟地址不同，这样就可以防止A进程写入数据到B进程。也就是说，操作系统的不同进程之间，数据不共享，在每个进程看来，自己都独享了整个系统空间，完全不知道其他进程的存在，因此一个进程想要与另一个进程通信，需要某种系统机制才能完成。
+进程隔离是操作系统为了保护进程之间不相互干扰而设计的，避免进程A写入进程B的情况发生，其实现就是使用虚拟地址空间，两个进程虚拟地址不同，这样就可以防止A进程写入数据到B进程。    
+也就是说，操作系统的不同进程之间，数据不共享，在每个进程看来，自己都独享了整个系统空间，完全不知道其他进程的存在，因此一个进程想要与另一个进程通信，需要某种系统机制才能完成。
 
 
 
@@ -76,7 +89,7 @@ Android额外还有Binder  IPC机制，Android OS中的Zygote进程的IPC采用
 
 Linux Kernel是操作系统的核心，独立于普通的应用程序，可以访问受保护的内存空间，也有访问底层硬件设备的所有权限。
 
-对于Kernel这中高安全级别的功能，显然是不允许其它应用程序随便调用或访问的，所以需要对Kernel提供一定的保护机制，这个保护机制用来告诉那些应用程序，你只可以访问某些许可的资源，不许可的资源是不能访问的，于是操作系统就把kernel和上层的应用程序抽象的隔离开，分别称之为kenel space和user space，即内核空间和用户空间。
+对于Kernel这种高安全级别的功能，显然是不允许其它应用程序随便调用或访问的，所以需要对Kernel提供一定的保护机制，这个保护机制用来告诉那些应用程序，你只可以访问某些许可的资源，不许可的资源是不能访问的，于是操作系统就把kernel和上层的应用程序抽象的隔离开，分别称之为kenel space和user space，即内核空间和用户空间。
 
 
 
@@ -98,11 +111,15 @@ Linux 使用两级保护机制：0 级供系统内核使用，3 级供用户程
 
 通过系统调用，用户空间可以访问内核空间，那么如果一个用户空间想与另外一个用户空间进行通信该怎么处理？
 
-那就是让操作系统内核添加支持，传统的linux通信机制，比如socket、管道等都是内核的一部分，因此通过内核支持来实现进程间通信自然是没有问题的，但是binder并不是linux系统内核的一部分，那它是怎么做到访问内核空间的呢？这就得益于 Linux 的**动态内核可加载模块**（Loadable Kernel  Module，LKM）的机制；模块是具有独立功能的程序，它可以被单独编译，但是不能独立运行。它在运行时被链接到内核作为内核的一部分运行。这样，Android 系统就可以通过动态添加一个内核模块运行在内核空间，用户进程之间通过这个内核模块作为桥梁来实现通信。
+那就是让操作系统内核添加支持，传统的linux通信机制，比如socket、管道等都是内核的一部分，因此通过内核支持来实现进程间通信自然是没有问题的，但是binder并不是linux系统内核的一部分，那它是怎么做到访问内核空间的呢？     
+
+这就得益于 Linux 的**动态内核可加载模块**（Loadable Kernel  Module，LKM）的机制；模块是具有独立功能的程序，它可以被单独编译，但是不能独立运行。它在运行时被链接到内核作为内核的一部分运行。这样，Android 系统就可以通过动态添加一个内核模块运行在内核空间，用户进程之间通过这个内核模块作为桥梁来实现通信。
 
 >  在 Android 系统中，这个运行在内核空间，负责各个用户进程通过 Binder 实现通信的内核模块就叫  **Binder 驱动**（Binder Dirver）（尽管名叫‘驱动’，实际上和硬件设备没有任何关系，只是实现方式和设备驱动程序是一样的）。
 >
->  从进程角度来看IPC机制，每个Android的进程，只能运行在自己进程所拥有的虚拟地址空间。对应一个4GB的虚拟地址空间，其中3GB是用户空间，1GB是内核空间，当然内核空间的大小是可以通过参数配置调整的。对于用户空间，不同进程之间彼此是不能共享的，而内核空间却是可共享的。Client进程向Server进程通信，恰恰是利用进程间可共享的内核内存空间来完成底层通信工作的，Client端与Server端进程往往采用ioctl等方法跟内核空间的驱动进行交互。
+>  从进程角度来看IPC机制，每个Android的进程，只能运行在自己进程所拥有的虚拟地址空间。对应一个4GB的虚拟地址空间，其中3GB是用户空间，1GB是内核空间，当然内核空间的大小是可以通过参数配置调整的。    
+
+对于用户空间，不同进程之间彼此是不能共享的，而内核空间却是可共享的。Client进程向Server进程通信，恰恰是利用进程间可共享的内核内存空间来完成底层通信工作的，Client端与Server端进程往往采用ioctl等方法跟内核空间的驱动进行交互。
 
 
 
@@ -135,7 +152,9 @@ Binder作为Android系统提供的一种IPC机制。首先一个问题就是为
 
     那Binder是怎么操作的呢？这就需要知道 Linux 下的另一个概念：**内存映射**。
 
-    Binder IPC 机制中涉及到的内存映射通过 mmap() 来实现，mmap()  是操作系统中一种内存映射的方法。内存映射简单的讲就是将用户空间的一块内存区域映射到内核空间。映射关系建立后，用户对这块内存区域的修改可以直接反应到内核空间；反之内核空间对这段区域的修改也能直接反应到用户空间。
+    Binder IPC 机制中涉及到的内存映射通过 mmap() 来实现，mmap()  是操作系统中一种内存映射的方法。     
+
+    内存映射简单的讲就是将用户空间的一块内存区域映射到内核空间。映射关系建立后，用户对这块内存区域的修改可以直接反应到内核空间；反之内核空间对这段区域的修改也能直接反应到用户空间。
 
     内存映射能减少数据拷贝次数，实现用户空间和内核空间的高效互动。两个空间各自的修改能直接反映在映射的内存区域，从而被对方空间及时感知。也正因为如此，内存映射能够提供对进程间通信的支持。
 
@@ -161,6 +180,32 @@ Binder作为Android系统提供的一种IPC机制。首先一个问题就是为
 
     Android中权限控制策略有SELinux等多方面手段。传统IPC只能由用户在数据包里填入UID/PID；另外，可靠的身份标记只有由IPC机制本身在内核中添加。其次传统IPC访问接入点是开放的，无法建立私有通道。从安全角度，Binder的安全性更高。
 
+    这里可能很多人会有一个疑问就是共享内存也可以通过增加逻辑来判断pid啊？这里有个问题就是共享内存的pid判断会有更笨的缺陷，因为共享内存的接口设计是完全自由的，等于没有规范，你获取了pid，但是你怎么保证这个pid是谁写的？ 攻击者完全可以伪造写入某一个进程的pid。但是binder中这个pid是在binder驱动层填写完成的，用户态是无法伪造的。 
+
+    还有就是Binder支持对象引用的跨进程传递，而这是共享内存做不到的。 
+    ```java
+    // Binder 可以传递「跨进程对象引用」
+    // 进程 A 把一个 Callback 对象传给进程 B
+    // 进程 B 可以直接回调进程 A 的方法！
+    
+    // 这在 Android 中无处不在：
+    service.registerCallback(new ICallback.Stub() {
+        @Override
+        public void onResult(Data data) {
+            // 这个方法在进程 B 触发，但运行在进程 A
+        }
+    });
+    
+    // 共享内存如何实现双向回调？
+    // → 需要两段共享内存 + 两组锁 + 轮询或额外信号机制
+    // → 复杂度爆炸
+    ```
+
+而且这里还要补充一句，在大数据传输时Binder本身也会降级用共享内存，例如Android在大数据传输(如图片、视频帧)本身就用Ashmem共享内存。只不过Binder传递的是共享内存的"句柄"，所以Binder和共享内存并不是对立关系。 
+ 
+
+
+
 - **从语言层面的角度**
     大家多知道Linux是基于C语言(面向过程的语言)，而Android是基于Java语言(面向对象的语句)，而对于Binder恰恰也符合面向对象的思想，将进程间通信转化为通过对某个Binder对象的引用调用该对象的方法，而其独特之处在于Binder对象是一个可以跨进程引用的对象，它的实体位于一个进程中，而它的引用却遍布于系统的各个进程之中。可以从一个进程传给其它进程，让大家都能访问同一Server，就像将一个对象或引用赋值给另一个引用一样。Binder模糊了进程边界，淡化了进程间通信过程，整个系统仿佛运行于同一个面向对象的程序之中。从语言层面，Binder更适合基于面向对象语言的Android系统，对于Linux系统可能会有点“水土不服”。
 
@@ -239,7 +284,7 @@ TCP/IP中一个典型的服务连接过程（比如客户端通过浏览器方
 
 - Client在得到Google.com的IP地址后，就可以据此来向Google服务器发起连接了。
 
-在这一些列流程中，我们并没有特别提及Router的作用。因为它所担负的责任是将数据包投递到用户设定的目标IP中，即Router是整个通信结构中的基础。
+在这一系列流程中，我们并没有特别提及Router的作用。因为它所担负的责任是将数据包投递到用户设定的目标IP中，即Router是整个通信结构中的基础。
 
 从这个典型的TCP/IP通信中，我们还能得到什么提示呢？
 
@@ -266,6 +311,26 @@ Binder的本质目标用一句话来描述，就是进程1（客户端）希望
     ##### Binder线程池
 
     每个Server进程在启动时会创建一个binder线程池，并向其中注册一个Binder线程；之后Server进程也可以向binder线程池注册新的线程，或者Binder驱动在探测到没有空闲binder线程时会主动向Server进程注册新的的binder线程。对于一个Server进程有一个最大Binder线程数限制，默认为16个binder线程，例如Android的system_server进程就存在16个线程。对于所有Client端进程的binder请求都是交由Server端进程的binder线程来处理的。
+   
+    为什么需要线程池?  
+    ```java
+    现实场景：system_server 提供 AMS/WMS/PMS 等服务
+    同时有几十个 App 进程向它发起 Binder 调用
+    
+    Binder 调用是同步阻塞模型，Server 端若用单线程，面对多个并发请求时会串行排队，导致性能低下甚至死锁。线程池让 Server 可以并发处理多个 Client 的请求，同时将 Binder 请求处理与主线程隔离，保证 UI 流畅，是高并发 IPC 场景下的必然选择。
+    
+    
+    没有线程池：
+    App1: startActivity()  ──► 等待...
+    App2: getPackageInfo() ──► 等待 App1 完成...
+    App3: bindService()    ──► 等待 App1+App2 完成...
+    
+    有线程池：
+    App1 ──► Binder线程1 → 立即处理
+    App2 ──► Binder线程2 → 立即处理  
+    App3 ──► Binder线程3 → 立即处理
+    ```
+
 
 - Binder驱动
 
diff --git "a/OperatingSystem/AndroidKernal/2.Android\347\272\277\347\250\213\351\227\264\351\200\232\344\277\241\344\271\213Handler\346\266\210\346\201\257\346\234\272\345\210\266.md" "b/OperatingSystem/AndroidKernal/2.Android\347\272\277\347\250\213\351\227\264\351\200\232\344\277\241\344\271\213Handler\346\266\210\346\201\257\346\234\272\345\210\266.md"
index 424a31dd..cf2a4cea 100644
--- "a/OperatingSystem/AndroidKernal/2.Android\347\272\277\347\250\213\351\227\264\351\200\232\344\277\241\344\271\213Handler\346\266\210\346\201\257\346\234\272\345\210\266.md"
+++ "b/OperatingSystem/AndroidKernal/2.Android\347\272\277\347\250\213\351\227\264\351\200\232\344\277\241\344\271\213Handler\346\266\210\346\201\257\346\234\272\345\210\266.md"
@@ -1,19 +1,25 @@
 # 2.Android线程间通信之Handler消息机制
 
 
-Binder/Socket用于进程间通信，而Handler消息机制用于同进程的线程间通信，Handler消息机制是由一组MessageQueue、Message、Looper、Handler共同组成的，为了方便且称之为Handler消息机制。
+Binder/Socket用于进程间通信，而Handler消息机制用于同进程的线程间通信，Handler消息机制是由一组MessageQueue、Message、Looper、Handler共同组成的，为了方便称之为Handler消息机制。
 
-有人可能会疑惑，为何Binder/Socket用于进程间通信，能否用于线程间通信呢？答案是肯定，对于两个具有独立地址空间的进程通信都可以，当然也能用于共享内存空间的两个线程间通信，这就好比杀鸡用牛刀。接着可能还有人会疑惑，那handler消息机制能否用于进程间通信？答案是不能，Handler只能用于共享内存地址空间的两个线程间通信，即同进程的两个线程间通信。很多时候，Handler是工作线程向UI主线程发送消息，即App应用中只有主线程能更新UI，其他工作线程往往是完成相应工作后，通过Handler告知主线程需要做出相应地UI更新操作，Handler分发相应的消息给UI主线程去完成，如下图：
+有人可能会疑惑，为何Binder/Socket用于进程间通信，能否用于线程间通信呢？答案是肯定可以，对于两个具有独立地址空间的进程通信都可以，当然也能用于共享内存空间的两个线程间通信，这就好比杀鸡用牛刀。    
+
+接着可能还有人会疑惑，那handler消息机制能否用于进程间通信？答案是不能，Handler只能用于共享内存地址空间的两个线程间通信，即同进程的两个线程间通信。很多时候，Handler是工作线程向UI主线程发送消息，即App应用中只有主线程能更新UI，其他工作线程往往是完成相应工作后，通过Handler告知主线程需要做出相应地UI更新操作，Handler分发相应的消息给UI主线程去完成，如下图：
 
 ![img](https://raw.githubusercontent.com/CharonChui/Pictures/master/handler_thread_commun.jpg)
 
-**由于工作线程与主线程共享地址空间，即Handler实例对象mHandler位于线程间共享的内存堆上，工作线程与主线程都能直接使用该对象**，只需要注意多线程的同步问题。工作线程通过mHandler向其成员变量MessageQueue中添加新Message，主线程一直处于loop()方法内，当收到新的Message时按照一定规则分发给相应的handleMessage()方法来处理。所以说，**Handler消息机制用于同进程的线程间通信，其核心是线程间共享内存空间，而不同进程拥有不同的地址空间，也就不能用handler来实现进程间通信**。
+**由于工作线程与主线程共享地址空间，即Handler实例对象mHandler位于线程间共享的内存堆上，工作线程与主线程都能直接使用该对象**，只需要注意多线程的同步问题。    
+
+工作线程通过mHandler向其成员变量MessageQueue中添加新Message，主线程一直处于loop()方法内，当收到新的Message时按照一定规则分发给相应的handleMessage()方法来处理。
+
+所以说，**Handler消息机制用于同进程的线程间通信，其核心是线程间共享内存空间，而不同进程拥有不同的地址空间，也就不能用handler来实现进程间通信**。
 
 
 
 消息机制主要包含: 
 
-- Message：消息分为硬件产生的消息(如按钮、触摸)和软件生成的消息；Message中有一个用于处理消息的Handler；
+- Message：消息分为硬件产生的消息(如按钮、触摸)和软件生成的消息；Message中有一个用于处理消息的Handler；Message维护一个静态对象池(private static Message sPool)，最多50个，可以使用Message.obtain()从池中获取，msg.recycle()重新归还到池中，这样能够避免频繁GC。  
 - MessageQueue：消息队列的主要功能向消息池投递消息(MessageQueue.enqueueMessage)和取走消息池的消息(MessageQueue.next)；MessageQueue有一组待处理的Message；
 - Handler：消息辅助类，主要功能向消息池发送各种消息事件(Handler.sendMessage)和处理相应消息事件(Handler.handleMessage)；Handler中有Looper和MessageQueue的成员变量。
 - Looper：不断循环执行(Looper.loop)，按分发机制将消息分发给目标处理者。Looper有一个MessageQueue消息队列；
@@ -544,6 +550,11 @@ public final void removeCallbacksAndMessages(@Nullable Object token) {
 
 
 
+##### postAtFrontOfQueue():将消息插入到队列头部
+
+通过调用sendMessageAtFrontOfQueue计入一个when为0的message到队列，即插入到队列的头部。可以尽量保证快速执行。
+
+
 ## MessageQueue类的常用方法
 
 MessageQueue非常重要，因为quit、next等都最终调用的是MessageQueue类: 
diff --git "a/OperatingSystem/AndroidKernal/3.Android Framework\346\241\206\346\236\266.md" "b/OperatingSystem/AndroidKernal/3.Android Framework\346\241\206\346\236\266.md"
index d653e130..bcf041f8 100644
--- "a/OperatingSystem/AndroidKernal/3.Android Framework\346\241\206\346\236\266.md"	
+++ "b/OperatingSystem/AndroidKernal/3.Android Framework\346\241\206\346\236\266.md"	
@@ -64,6 +64,8 @@ Linux驱动和Framework相关的主要包含两部分：
 
 
 
+<img src="https://github.com/CharonChui/Pictures/blob/master/android_architecture.jpg?raw=true" width="70%" height="70%" />
+
 ## APK程序的运行过程
 
 1. 首先，ActivityThread从main()函数开始执行，调用prepareMainLooper()为UI线程创建一个消息队列(MessageQueue)。
diff --git a/README.md b/README.md
index 5f20491c..e7e3e4f7 100644
--- a/README.md
+++ b/README.md
@@ -58,6 +58,7 @@ Android学习笔记
         - [1.音视频基础知识][328]
         - [2.系统播放器MediaPlayer][329]
         - [11.播放器组件封装][330]
+        - [MediaMetadataRetriever][344]
     - [DNS及HTTPDNS][23]
     - [流媒体协议][224]
         - [流媒体协议][246]
@@ -108,6 +109,8 @@ Android学习笔记
         - [10.GLSurfaceView+MediaPlayer播放视频][241]
         - [11.OpenGL ES滤镜][242]
         - [12.FBO][332]
+        - [13.LUT滤镜][346]
+        - [14.实例化][347]
     - [弹幕][243]
         - [Android弹幕实现][244]
     - [FFmpeg][322]    
@@ -296,6 +299,7 @@ Android学习笔记
     - [Top-K问题][196]
     - [Java内存模型][285]
     - [JVM架构][286]
+    - [python3入门][345]
 - [基础部分][54] 
     - [安全退出应用程序][110]
     - [病毒][111]
@@ -721,6 +725,10 @@ Android学习笔记
 [341]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/%E8%A7%86%E9%A2%91%E5%B0%81%E8%A3%85%E6%A0%BC%E5%BC%8F/AVI.md "AVI"
 [342]: https://github.com/CharonChui/AndroidNote/tree/master/VideoDevelopment/OpenCV "OpenCV"
 [343]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenCV/1.OpenCV%E7%AE%80%E4%BB%8B.md "1.OpenCV简介"
+[344]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/Android%E9%9F%B3%E8%A7%86%E9%A2%91%E5%BC%80%E5%8F%91/MediaMetadataRetriever.md    "MediaMetadataRetriever"
+[345]: https://github.com/CharonChui/AndroidNote/blob/master/JavaKnowledge/python3%E5%85%A5%E9%97%A8.md    "python3入门"
+[346]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/13.LUT%E6%BB%A4%E9%95%9C.md  "13.LUT滤镜"
+[347]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/14.%E5%AE%9E%E4%BE%8B%E5%8C%96.md  "14.实例化"
 
 
 Developed By
diff --git "a/RxJavaPart/1.RxJava\350\257\246\350\247\243(\344\270\200).md" "b/RxJavaPart/1.RxJava\350\257\246\350\247\243(\344\270\200).md"
index 81b665b6..9e6e2c14 100644
--- "a/RxJavaPart/1.RxJava\350\257\246\350\247\243(\344\270\200).md"
+++ "b/RxJavaPart/1.RxJava\350\257\246\350\247\243(\344\270\200).md"
@@ -1,8 +1,6 @@
 RxJava详解(一)
 ===
 
-年初的时候就想学习下`RxJava`然后写一些`RxJava`的教程，无奈发现已经年底了，然而我还么有写。今天有点时间，特别是发布了`RxJava 2.0`后，我决定动笔开始。
-
 现在`RxJava`变的越来越流行了，很多项目中都使用了它。特别是大神`JakeWharton`等的加入，以及`RxBinding、Retrofit、RxLifecycle`等众多项目的，然开发越来越方便，但是上手比较难，不过一旦你入门后你就会发现真是太棒了。
 
 
@@ -85,6 +83,15 @@ public void rxFetchUserDetails() {
 
 从根本上讲，函数响应式编程是在观察者模式的基础上，增加对`Observables`发送的数据流进行操纵和变换的功能。
 
+
+
+特殊注意：
+
+（1） 若Observable.subscribeOn（）多次指定被观察者 生产事件的线程，则只有第一次指定有效，其余的指定线程无效。
+（2） 若Observable.observeOn（）多次指定观察者 接收 & 响应事件的线程，则每次指定均有效，即每指定一次，就会进行一次线程的切换。
+
+
+
 `RxJava`简介
 ---
 
@@ -92,7 +99,9 @@ public void rxFetchUserDetails() {
 
 ![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/rx_logo.png?raw=true)
 
-`Rx`基于观察者模式，它是一种编程模型，目标是提供一致的编程接口，帮助开发者更方便的处理异步数据流。`ReactiveX.io`给的定义是，`Rx`是一个使用可观察数据流进行异步编程的编程接口，`ReactiveX`结合了观察者模式、迭代器模式和函数式编程的精华。`Rx`已经渗透到了各个语言中，有了`Rx`所以才有了`RxJava`、`Rx.NET`、`RxJS`、`RxSwift`、`Rx.rb`、`RxPHP`等等，
+`Rx`基于观察者模式，它是一种编程模型，目标是提供一致的编程接口，帮助开发者更方便的处理异步数据流。
+
+`ReactiveX.io`给的定义是，`Rx`是一个使用可观察数据流进行异步编程的编程接口，`ReactiveX`结合了观察者模式、迭代器模式和函数式编程的精华。`Rx`已经渗透到了各个语言中，有了`Rx`所以才有了`RxJava`、`Rx.NET`、`RxJS`、`RxSwift`、`Rx.rb`、`RxPHP`等等，
 
 这里先列举一下相关的官网:  
 
@@ -107,7 +116,9 @@ public void rxFetchUserDetails() {
 
 这里可能会有人想不就是个异步吗，至于辣么矫情么?用`AsyncTask`、`Handler`甚至自定义一个`BigAsyncTask`分分钟搞定。
 
-但是`RxJava`的好处是简洁。异步操作很关键的一点是程序的简洁性，因为在调度过程比较复杂的情况下，异步代码经常会既难写也难被读懂。 `Android`创造的`AsyncTask`和`Handler`其实都是为了让异步代码更加简洁。虽然`RxJava`的优势也是简洁，但它的简洁的与众不同之处在于，随着程序逻辑变得越来越复杂，它依然能够保持简洁。
+但是`RxJava`的好处是简洁。异步操作很关键的一点是程序的简洁性，因为在调度过程比较复杂的情况下，异步代码经常会既难写也难被读懂。     
+
+`Android`创造的`AsyncTask`和`Handler`其实都是为了让异步代码更加简洁。虽然`RxJava`的优势也是简洁，但它的简洁的与众不同之处在于，随着程序逻辑变得越来越复杂，它依然能够保持简洁。
 
 
 #### 扩展的观察者模式
@@ -115,13 +126,23 @@ public void rxFetchUserDetails() {
 
 `RxJava`的异步实现，是通过一种扩展的观察者模式来实现的。
 
-观察者模式面向的需求是：`A`对象（观察者）对`B`对象（被观察者）的某种变化高度敏感，需要在`B`变化的一瞬间做出反应。举个例子，新闻里喜闻乐见的警察抓小偷，警察需要在小偷伸手作案的时候实施抓捕。在这个例子里，警察是观察者，小偷是被观察者，警察需要时刻盯着小偷的一举一动，才能保证不会漏过任何瞬间。程序的观察者模式和这种真正的『观察』略有不同，观察者不需要时刻盯着被观察者（例如`A`不需要每过`2ms`就检查一次`B`的状态），而是采用注册(`Register`)或者称为订阅(`Subscribe`)的方式，告诉被观察者：我需要你的某某状态，你要在它变化的时候通知我。 `Android`开发中一个比较典型的例子是点击监听器`OnClickListener`。对设置`OnClickListener`来说，`View`是被观察者，`OnClickListener`是观察者，二者通过 `setOnClickListener()`方法达成订阅关系。订阅之后用户点击按钮的瞬间，`Android Framework`就会将点击事件发送给已经注册的`OnClickListener`。采取这样被动的观察方式，既省去了反复检索状态的资源消耗，也能够得到最高的反馈速度。当然，这也得益于我们可以随意定制自己程序中的观察者和被观察者，而警察叔叔明显无法要求小偷『你在作案的时候务必通知我』。
+观察者模式面向的需求是：`A`对象（观察者）对`B`对象（被观察者）的某种变化高度敏感，需要在`B`变化的一瞬间做出反应。    
+
+举个例子，新闻里喜闻乐见的警察抓小偷，警察需要在小偷伸手作案的时候实施抓捕。在这个例子里，警察是观察者，小偷是被观察者，警察需要时刻盯着小偷的一举一动，才能保证不会漏过任何瞬间。     
+
+程序的观察者模式和这种真正的『观察』略有不同，观察者不需要时刻盯着被观察者（例如`A`不需要每过`2ms`就检查一次`B`的状态），而是采用注册(`Register`)或者称为订阅(`Subscribe`)的方式，告诉被观察者：我需要你的某某状态，你要在它变化的时候通知我。       
+
+`Android`开发中一个比较典型的例子是点击监听器`OnClickListener`。对设置`OnClickListener`来说，`View`是被观察者，`OnClickListener`是观察者，二者通过 `setOnClickListener()`方法达成订阅关系。    
+
+订阅之后用户点击按钮的瞬间，`Android Framework`就会将点击事件发送给已经注册的`OnClickListener`。      采取这样被动的观察方式，既省去了反复检索状态的资源消耗，也能够得到最高的反馈速度。当然，这也得益于我们可以随意定制自己程序中的观察者和被观察者，而警察叔叔明显无法要求小偷『你在作案的时候务必通知我』。   
 
 `OnClickListener`的模式大致如下图：
 
 ![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/btn_onclick.jpg?raw=true)
 
-如图所示，通过`setOnClickListener()`方法，`Button`持有`OnClickListener`的引用（这一过程没有在图上画出）；当用户点击时，`Button`自动调用`OnClickListener`的`onClick()` 方法。另外，如果把这张图中的概念抽象出来（`Button` -> 被观察者、`OnClickListener` -> 观察者、`setOnClickListener()` -> 订阅，`onClick()` -> 事件），就由专用的观察者模式（例如只用于监听控件点击）转变成了通用的观察者模式。如下图：
+如图所示，通过`setOnClickListener()`方法，`Button`持有`OnClickListener`的引用（这一过程没有在图上画出）；当用户点击时，`Button`自动调用`OnClickListener`的`onClick()` 方法。     
+
+另外，如果把这张图中的概念抽象出来（`Button` -> 被观察者、`OnClickListener` -> 观察者、`setOnClickListener()` -> 订阅，`onClick()` -> 事件），就由专用的观察者模式（例如只用于监听控件点击）转变成了通用的观察者模式。如下图：
 
 ![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/btn_rxjava_observable.jpg?raw=true)
 
@@ -134,7 +155,7 @@ public void rxFetchUserDetails() {
 `RxJava`的基本概念：
 
 - `Observable`(可观察者，即被观察者):产生事件，例如去饭店吃饭的顾客。
-- `Observer`(观察者):接收事件，并给出响应动作，例如去饭店吃饭的厨房，会接受事件，并给出相应。
+- `Observer`(观察者):接收事件，并给出响应动作，例如去饭店吃饭的厨房，会接受事件，并给出响应。
 - `subscribe()`(订阅):连接被观察者与观察者，例如去饭店吃饭的服务员。
     `Observable`和`Observer`通过`subscribe()` 方法实现订阅关系，从而`Observable`可以在需要的时候发出事件来通知`Observer`。
 - `Event`(事件):被观察者与观察者沟通的载体，例如顾客点的菜。
@@ -155,6 +176,18 @@ public void rxFetchUserDetails() {
 ![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/rxjava_observer_1.jpg?raw=true)
 
 
+RxJava在响应式编程中的基本流程如下：
+
+这个流程，可以简单的理解为：Observable -> Operator1 -> Operator2 -> Operator3 -> Subscriber
+
+- Observable发出一系列事件，他是事件的产生者；
+- Subscriber负责处理事件，他是事件的消费者；
+- Operator是对Observable发出的事件进行修改和变换；
+- 若事件从产生到消费不需要其他处理，则可以省略掉中间的Operator，从而流程变为Obsevable -> Subscriber；
+- Subscriber通常在主线程执行，所以原则上不要去处理太多的事务，而这些复杂的处理则交给Operator；
+
+
+
 #### 基本实现
 
 
@@ -219,13 +252,14 @@ public void rxFetchUserDetails() {
     observable.subscribe(subscriber);
     ```
 
-    > 有人可能会注意到，`subscribe()`这个方法有点怪：它看起来是`observalbe`订阅了`observer/subscriber`而不是`observer/subscriber`订阅了`observalbe`，这看起来就像『杂志订阅了读者』一样颠倒了对象关系。这让人读起来有点别扭，不过如果把`API`设计成`observer.subscribe(observable)/subscriber.subscribe(observable)` ，虽然更加符合思维逻辑，但对流式`API`的设计就造成影响了，比较起来明显是得不偿失的。
+    > 有人可能会注意到，`subscribe()`这个方法有点怪：它看起来是`observalbe`订阅了`observer/subscriber`而不是`observer/subscriber`订阅了`observalbe`，这看起来就像『杂志订阅了读者』一样颠倒了对象关系。       
+    > 这让人读起来有点别扭，不过如果把`API`设计成`observer.subscribe(observable)/subscriber.subscribe(observable)` ，虽然更加符合思维逻辑，但对流式`API`的设计就造成影响了，比较起来明显是得不偿失的。
 
   
 `RxJava`入门示例
 ---
 
-一个`Observable`可以发出零个或者多个事件，知道结束或者出错。每发出一个事件，就会调用它的`Subscriber`的`onNext`方法，最后调用`Subscriber.onComplete()`或者`Subscriber.onError()`结束。
+一个`Observable`可以发出零个或者多个事件，直到结束或者出错。每发出一个事件，就会调用它的`Subscriber`的`onNext`方法，最后调用`Subscriber.onComplete()`或者`Subscriber.onError()`结束。
 
 #### `Hello World`
 
@@ -285,7 +319,7 @@ public Subscription subscribe(Subscriber subscriber) {
 }
 ```
 
-可以看到`subscriber()`做了3件事：
+可以看到`subscriber()`做了3件事:        
 
 - 调用`Subscriber.onStart()`。这个方法在前面已经介绍过，是一个可选的准备方法。
 - 调用`Observable`中的`onSubscribe.call(Subscriber)`。在这里，事件发送的逻辑开始运行。从这也可以看出，在`RxJava`中，`Observable` 并不是在创建的时候就立即开始发送事件，而是在它被订阅的时候，即当`subscribe()`方法执行的时候。
@@ -296,8 +330,6 @@ public Subscription subscribe(Subscriber subscriber) {
 ![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/rxjava_observable_list.gif?raw=true)
 
 
-讲到这里很多人肯定会骂傻`X`,这TM简洁你妹啊...，这里只是个入门`Hello World`，真正的简洁等你看完全部介绍后就明白了。
-
 `RxJava`内置了很多简化创建`Observable`对象的函数，比如`Observable.just()`就是用来创建只发出一个事件就结束的`Observable`对象，上面创建`Observable`对象的代码可以简化为一行
 
 ```java
@@ -330,7 +362,7 @@ Observable.just("Hello ", "World !").subscribe(new Action1<String>() {
 });
 ```
 
-这里顺便多提一些`subscribe()`的多个`Action`参数：   
+这里顺便多提一下`subscribe()`的多个`Action`参数：   
 ```java
 Action1<String> onNextAction = new Action1<String>() {
     // onNext()
@@ -357,12 +389,27 @@ Action0 onCompletedAction = new Action0() {
 observable.subscribe(onNextAction, onErrorAction, onCompletedAction);
 ```
 
-简单解释一下这段代码中出现的`Action1`和`Action0`。`Action0`是`RxJava`的一个接口，它只有一个方法`call()`，这个方法是无参无返回值的；由于`onCompleted()` 方法也是无参无返回值的，因此`Action0`可以被当成一个包装对象，将`onCompleted()`的内容打包起来将自己作为一个参数传入`subscribe()`以实现不完整定义的回调。这样其实也可以看做将 `onCompleted()`方法作为参数传进了`subscribe()`，相当于其他某些语言中的『闭包』。`Action1`也是一个接口，它同样只有一个方法`call(T param)`，这个方法也无返回值，但有一个参数；与`Action0`同理，由于`onNext(T obj)`和`onError(Throwable error)`也是单参数无返回值的，因此`Action1`可以将`onNext(obj)`和`onError(error)`打包起来传入`subscribe()`以实现不完整定义的回调。事实上，虽然`Action0`和`Action1`在`API`中使用最广泛，但`RxJava`是提供了多个`ActionX`形式的接口(例如`Action2`, `Action3`)的，它们可以被用以包装不同的无返回值的方法。
+简单解释一下这段代码中出现的`Action1`和`Action0`。      
+
+`Action0`是`RxJava`的一个接口，它只有一个方法`call()`，这个方法是无参无返回值的；     
+
+由于`onCompleted()` 方法也是无参无返回值的，因此`Action0`可以被当成一个包装对象，将`onCompleted()`的内容打包起来将自己作为一个参数传入`subscribe()`以实现不完整定义的回调。      
+
+
+这样其实也可以看做将 `onCompleted()`方法作为参数传进了`subscribe()`，相当于其他某些语言中的『闭包』。       
+
+`Action1`也是一个接口，它同样只有一个方法`call(T param)`，这个方法也无返回值，但有一个参数；       
+
+与`Action0`同理，由于`onNext(T obj)`和`onError(Throwable error)`也是单参数无返回值的，因此`Action1`可以将`onNext(obj)`和`onError(error)`打包起来传入`subscribe()`以实现不完整定义的回调。      
+
+事实上，虽然`Action0`和`Action1`在`API`中使用最广泛，但`RxJava`是提供了多个`ActionX`形式的接口(例如`Action2`, `Action3`)的，它们可以被用以包装不同的无返回值的方法。
 
 
 假设我们的`Observable`是第三方提供的，它提供了大量的用户数据给我们，而我们需要从用户数据中筛选部分有用的信息，那我们该怎么办呢？    
 从`Observable`中去修改肯定是不现实的？那从`Subscriber`中进行修改呢？ 这样好像是可以完成的。但是这种方式并不好，因为我们希望`Subscriber`越轻量越好，因为很有可能我们需要
-在主线程中去执行`Subscriber`。另外，根据响应式函数编程的概念，`Subscribers`更应该做的事情是`响应`，响应`Observable`发出的事件，而不是去修改。
+在主线程中去执行`Subscriber`。
+
+另外，根据响应式函数编程的概念，`Subscribers`更应该做的事情是`响应`，响应`Observable`发出的事件，而不是去修改。
 那该怎么办呢？ 这就要用到下面的部分要讲的操作符。  
 
 
@@ -381,7 +428,7 @@ observable.subscribe(onNextAction, onErrorAction, onCompletedAction);
 
 > 背压是指在异步场景中，被观察者发送事件速度远快于观察者的处理速度的情况下，一种告诉上游的被观察者降低发送速度的策略。
 
-简而言之，背压是流速控制的一种策略。
+简而言之，背压是流速控制的一种策略。      
 其实`RxJava 2.x`最大的改动就是对于`backpressure`的处理，为此将原来的`Observable`拆分成了新的`Observable`和`Flowable`，同时其他相关部分也同时进行了拆分。
 
 ![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/rxjava1vs2.png?raw=true)
@@ -394,7 +441,7 @@ observable.subscribe(onNextAction, onErrorAction, onCompletedAction);
 
 `RxJava`提供了对事件序列进行变换的支持，这是它的核心功能之一.所谓变换，就是将事件序列中的对象或整个序列进行加工处理，转换成不同的事件或事件序列。       
 操作符就是为了解决对`Observable`对象的变换的问题，操作符用于在`Observable`和最终的`Subscriber`之间修改`Observable`发出的事件。`RxJava`提供了很多很有用的操作符。
-比如`map`操作符，就是用来把把一个事件转换为另一个事件的。
+比如`map`操作符，就是用来把一个事件转换为另一个事件的。
 
 #### `map`
 
@@ -456,10 +503,10 @@ map.subscribe(new Action1<Integer>() {
 
 通过上面的部分我们可以得知:   
 
-- `Observable`和`Subscriber`可以做任何事情
+- `Observable`和`Subscriber`可以做任何事情    
     `Observable`可以是一个数据库查询，`Subscriber`用来显示查询结果；`Observable`可以是屏幕上的点击事件，`Subscriber`用来响应点击事件；`Observable`可以是一个网络请求，`Subscriber`用来显示请求结果。
 
-- `Observable`和`Subscriber`是独立于中间的变换过程的。
+- `Observable`和`Subscriber`是独立于中间的变换过程的      
     在`Observable`和`Subscriber`中间 可以增减任何数量的`map`。整个系统是高度可组合的，操作数据是一个很简单的过程。
 
 
@@ -532,7 +579,9 @@ Observable.from(students)
     .subscribe(subscriber);
 ```
 
-`map`与`flatmap`在功能上是一致的,它也是把传入的参数转化之后返回另一个对象。区别在于`flatmap`是通过中间`Observable`来进行，而`map`是直接执行.`flatMap()`中返回的是个 `Observable`对象，并且这个`Observable`对象并不是被直接发送到了`Subscriber`的回调方法中。 
+`map`与`flatmap`在功能上是一致的,它也是把传入的参数转化之后返回另一个对象。区别在于`flatmap`是通过中间`Observable`来进行，而`map`是直接执行.       
+
+`flatMap()`中返回的是个 `Observable`对象，并且这个`Observable`对象并不是被直接发送到了`Subscriber`的回调方法中。 
 
 `flatMap()`的原理是这样的:  
 
@@ -585,18 +634,18 @@ Observable.from(s).subscribe(new Action1<String>() {
 
 ```java
 Observable.from(new Integer[]{1, 2, 3, 4, 5, 6, 7, 8, 9})
-                .filter(new Func1<Integer, Boolean>() {
-                    @Override
-                    public Boolean call(Integer integer) {
-                        return integer < 5;
-                    }
-                })
-                .subscribe(new Action1<Integer>() {
-                    @Override
-                    public void call(Integer integer) {
-                        Log.i("@@@", "integer=" + integer); //1,2,3,4
-                    }
-                });
+    .filter(new Func1<Integer, Boolean>() {
+        @Override
+        public Boolean call(Integer integer) {
+            return integer < 5;
+        }
+    })
+    .subscribe(new Action1<Integer>() {
+        @Override
+        public void call(Integer integer) {
+            Log.i("@@@", "integer=" + integer); //1,2,3,4
+        }
+    });
 ```
 
 #### `timer`
@@ -606,12 +655,12 @@ Observable.from(new Integer[]{1, 2, 3, 4, 5, 6, 7, 8, 9})
 
 ```java
 Observable.timer(3, TimeUnit.SECONDS).observeOn(AndroidSchedulers.mainThread())
-                .subscribe(new Action1<Long>() {
-                    @Override
-                    public void call(Long aLong) {
-                        Log.i("@@@", "aLong=" + aLong); // 延时3s
-                    }
-                });
+    .subscribe(new Action1<Long>() {
+        @Override
+        public void call(Long aLong) {
+            Log.i("@@@", "aLong=" + aLong); // 延时3s
+        }
+    });
 ```
 
 #### `interval`
@@ -622,12 +671,12 @@ Observable.timer(3, TimeUnit.SECONDS).observeOn(AndroidSchedulers.mainThread())
 
 ```java
 Observable.interval(1, TimeUnit.SECONDS, AndroidSchedulers.mainThread())
-        .subscribe(new Action1<Long>() {
-            @Override
-            public void call(Long aLong) {
-                Log.i("@@@", "aLong=" + aLong); //从0递增，间隔1s 0,1,2,3....
-            }
-        });
+    .subscribe(new Action1<Long>() {
+        @Override
+        public void call(Long aLong) {
+            Log.i("@@@", "aLong=" + aLong); //从0递增，间隔1s 0,1,2,3....
+        }
+    });
 ```
 
 #### `Repeat`
diff --git "a/RxJavaPart/2.RxJava\350\257\246\350\247\243(\344\272\214).md" "b/RxJavaPart/2.RxJava\350\257\246\350\247\243(\344\272\214).md"
index a689be18..55be3ce4 100644
--- "a/RxJavaPart/2.RxJava\350\257\246\350\247\243(\344\272\214).md"
+++ "b/RxJavaPart/2.RxJava\350\257\246\350\247\243(\344\272\214).md"
@@ -85,7 +85,7 @@ try{
 这样，我们就可以处理这三个函数中所抛出的任何异常了。如果没有`try catch`语句，我们也可以把异常继续传递下去。
 
 
-向异步粗发
+向异步出发
 ---
 
 但是，现实世界中我们往往没法等待。有些时候你没法只使用阻塞调用。在`Android`中你需要处理各种异步操作。
@@ -225,7 +225,6 @@ public class CatsHelper {
 
 
 #### 奔向更好的世界     
-#### 通用的回调
 
 
 如果我们仔细的观察下回调接口，我们会发现它们的共性:   
@@ -318,7 +317,6 @@ public class CatsHelper{
 下面来试试看看这种方式能否有效。
 如果我们返回一个临时的对象作为异步操作的回调接口处理方式，我们需要先定义这个对象。由于对象遵守通用的行为(有一个回调接口参数)，我们定义一个能用于所有操作的对象。我们称之为`AsyncJob`。
 
-> 注意： 我非常想把这个名字称之为`AsyncTask`。但是由于`Android`系统已经有个`AsyncTask`类了， 为了避免混淆，所以就用`AsyncJob`了。
 
 该对象如下:   
 ```java
@@ -384,28 +382,28 @@ public class CatsHelper {
             @Override
             public void start(Callback<Uri> cutestCatCallback) {
                 apiWrapper.queryCats(query)
-                        .start(new Callback<List<Cat>>() {
-                            @Override
-                            public void onResult(List<Cat> cats) {
-                                Cat cutest = findCutest(cats);
-                                apiWrapper.store(cutest)
-                                        .start(new Callback<Uri>() {
-                                            @Override
-                                            public void onResult(Uri result) {
-                                                cutestCatCallback.onResult(result);
-                                            }
- 
-                                            @Override
-                                            public void onError(Exception e) {
-                                                cutestCatCallback.onError(e);
-                                            }
-                                        });
-                            }
- 
-                            @Override
-                            public void onError(Exception e) {
-                                cutestCatCallback.onError(e);
-                            }
+                    .start(new Callback<List<Cat>>() {
+                        @Override
+                        public void onResult(List<Cat> cats) {
+                            Cat cutest = findCutest(cats);
+                            apiWrapper.store(cutest)
+                                .start(new Callback<Uri>() {
+                                    @Override
+                                    public void onResult(Uri result) {
+                                        cutestCatCallback.onResult(result);
+                                    }
+
+                                    @Override
+                                    public void onError(Exception e) {
+                                        cutestCatCallback.onError(e);
+                                    }
+                                });
+                        }
+
+                        @Override
+                        public void onError(Exception e) {
+                            cutestCatCallback.onError(e);
+                        }
                         });
             }
         };
@@ -466,17 +464,17 @@ public class CatsHelper {
                     @Override
                     public void onResult(Cat cutest) {
                         apiWrapper.store(cutest)
-                                .start(new Callback<Uri>() {
-                                    @Override
-                                    public void onResult(Uri result) {
-                                        cutestCatCallback.onResult(result);
-                                    }
- 
-                                    @Override
-                                    public void onError(Exception e) {
-                                        cutestCatCallback.onError(e);
-                                    }
-                                });
+                            .start(new Callback<Uri>() {
+                                @Override
+                                public void onResult(Uri result) {
+                                    cutestCatCallback.onResult(result);
+                                }
+
+                                @Override
+                                public void onError(Exception e) {
+                                    cutestCatCallback.onError(e);
+                                }
+                            });
                     }
  
                     @Override
@@ -505,21 +503,21 @@ public class CatsHelper {
 
 ```java
 AsyncJob<Cat> cutestCatAsyncJob = new AsyncJob<Cat>() {
+    @Override
+    public void start(Callback<Cat> callback) {
+        catsListAsyncJob.start(new Callback<List<Cat>>() {
             @Override
-            public void start(Callback<Cat> callback) {
-                catsListAsyncJob.start(new Callback<List<Cat>>() {
-                    @Override
-                    public void onResult(List<Cat> result) {
-                        callback.onResult(findCutest(result));
-                    }
- 
-                    @Override
-                    public void onError(Exception e) {
-                        callback.onError(e);
-                    }
-                });
+            public void onResult(List<Cat> result) {
+                callback.onResult(findCutest(result));
             }
-        };
+
+            @Override
+            public void onError(Exception e) {
+                callback.onError(e);
+            }
+        });
+    }
+};
 ```
 
 这 16 行代码中，只有一行代码是我们的业务逻辑代码：
@@ -661,7 +659,7 @@ public class CatsHelper {
     }
 }
 ```
-哎。。。 看起来没这么简单啊， 下面修复返回的类型再试一次：
+哎。。。 看起来没这么简单啊，下面修复返回的类型再试一次:    
 
 ```java
 public class CatsHelper {
@@ -911,7 +909,7 @@ public class CatsHelper {
 }
 ```
 
-把 Observable 替换为 AsyncJob 后 他们的代码是一样的。
+把Observable替换为AsyncJob后他们的代码是一样的。
 
 #### 结论
 
@@ -926,7 +924,7 @@ public class CatsHelper {
 
 如果嫌上面的代码麻烦，可以通过下面的例子看:   
 
-假设有这样一个需求：界面上有一个自定义的视图`imageCollectorView`，它的作用是显示多张图片，并能使用`addImage(Bitmap)` 方法来任意增加显示的图片。现在需要程序将一个给出的目录数组`File[] folders`中每个目录下的`png`图片都加载出来并显示在`imageCollectorView`中。需要注意的是，由于读取图片的这一过程较为耗时，需要放在后台执行，而图片的显示则必须在`UI`线程执行。常用的实现方式有多种，我这里贴出其中一种：
+假设有这样一个需求：界面上有一个自定义的视图`imageCollectorView`，它的作用是显示多张图片，并能使用`addImage(Bitmap)` 方法来任意增加显示的图片。现在需要程序将一个给出的目录数组`File[] folders`中每个目录下的`png`图片都加载出来并显示在`imageCollectorView`中。需要注意的是，由于读取图片的这一过程较为耗时，需要放在后台执行，而图片的显示则必须在`UI`线程执行。常用的实现方式有多种，我这里贴出其中一种:        
 
 
 ```java
@@ -984,7 +982,7 @@ Observable.from(folders)
     });
 ```
 
-那位说话了：『你这代码明明变多了啊！简洁个毛啊！』大兄弟你消消气，我说的是逻辑的简洁，不是单纯的代码量少（逻辑简洁才是提升读写代码速度的必杀技对不？）。观察一下你会发现， `RxJava`的这个实现，是一条从上到下的链式调用，没有任何嵌套，这在逻辑的简洁性上是具有优势的。当需求变得复杂时，这种优势将更加明显（试想如果还要求只选取前`10`张图片，常规方式要怎么办？如果有更多这样那样的要求呢？再试想，在这一大堆需求实现完两个月之后需要改功能，当你翻回这里看到自己当初写下的那一片迷之缩进，你能保证自己将迅速看懂，而不是对着代码重新捋一遍思路？）。
+观察一下你会发现， `RxJava`的这个实现，是一条从上到下的链式调用，没有任何嵌套，这在逻辑的简洁性上是具有优势的。当需求变得复杂时，这种优势将更加明显（试想如果还要求只选取前`10`张图片，常规方式要怎么办？如果有更多这样那样的要求呢？再试想，在这一大堆需求实现完两个月之后需要改功能，当你翻回这里看到自己当初写下的那一片迷之缩进，你能保证自己将迅速看懂，而不是对着代码重新捋一遍思路？）。
 
 更多内容请看下一篇文章[RxJava详解(三)][1]
 
diff --git "a/RxJavaPart/3.RxJava\350\257\246\350\247\243(\344\270\211).md" "b/RxJavaPart/3.RxJava\350\257\246\350\247\243(\344\270\211).md"
index e1f39a75..4d0ac650 100644
--- "a/RxJavaPart/3.RxJava\350\257\246\350\247\243(\344\270\211).md"
+++ "b/RxJavaPart/3.RxJava\350\257\246\350\247\243(\344\270\211).md"
@@ -22,9 +22,11 @@ public <R> Observable<R> lift(Operator<? extends R, ? super T> operator) {
 }
 ```
 
-这段代码很有意思：它生成了一个新的`Observable`并返回，而且创建新`Observable`所用的参数`OnSubscribe的回调方法`call()`中的实现竟然看起来和前面讲过的`Observable.subscribe()`一样！然而它们并不一样哟~不一样的地方关键就在于第二行`onSubscribe.call(subscriber)`中的`onSubscribe` 所指代的对象不同          
+这段代码很有意思：它生成了一个新的`Observable`并返回，而且创建新`Observable`所用的参数`OnSubscribe的回调方法`call()`中的实现竟然看起来和前面讲过的`Observable.subscribe()`一样！      
+然而它们并不一样哟~不一样的地方关键就在于第二行`onSubscribe.call(subscriber)`中的`onSubscribe` 所指代的对象不同:            
 - `subscribe()`中这句话的`onSubscribe`指的是`Observable`中的`onSubscribe`对象，这个没有问题，但是`lift()`之后的情况就复杂了点。
-- 当含有`lift()`时： 
+- 当含有`lift()`时:     
+
     - `lift()`创建了一个`Observable`后，加上之前的原始`Observable`，已经有两个`Observable`了； 
     - 而同样地，新`Observable`里的新`OnSubscribe`加上之前的原始`Observable`中的原始`OnSubscribe`，也就有了两个`OnSubscribe`； 
     - 当用户调用经过`lift()`后的`Observable`的`subscribe()`的时候，使用的是`lift()`所返回的新的`Observable`，于是它所触发的`onSubscribe.call(subscriber)`，也是用的新`Observable`中的新`OnSubscribe`，即在`lift()`中生成的那个`OnSubscribe`； 
@@ -69,7 +71,7 @@ observable.lift(new Observable.Operator<String, Integer>() {
 线程控制`Scheduler`
 ---
 
-在不指定线程的情况下，`RxJava`遵循的是线程不变的原则，即在哪个线程调用`subscribe()`方法就在哪个线程生产事件；在哪个线程生产事件，就在哪个线程消费事件。也就是说事件的发出和消费都是在同一个线程的。观察者模式本身的目的就是『后台处理，前台回调』的异步机制，因此异步对于`RxJava`是至关重要的。而要实现异步，则需要用到`RxJava`的另一个概念：`Scheduler`。   
+在不指定线程的情况下，`RxJava`遵循的是线程不变的原则，即在哪个线程调用`subscribe()`方法就在哪个线程生产事件；       在哪个线程生产事件，就在哪个线程消费事件。也就是说事件的发出和消费都是在同一个线程的。观察者模式本身的目的就是『后台处理，前台回调』的异步机制，因此异步对于`RxJava`是至关重要的。而要实现异步，则需要用到`RxJava`的另一个概念：`Scheduler`。   
 
 
 #### `Scheduler`简介
@@ -98,16 +100,23 @@ Observable.just("Hello ", "World !")
         });
 ```
 
-上面这段代码中，`subscribeOn(Schedulers.io())`的指定会让创建的事件的内容`Hello `、`World !`将会在`IO`线程发出；而由于`observeOn(AndroidScheculers.mainThread())` 的指定，因此`subscriber()`方法设置后的回调中内容的打印将发生在主线程中。事实上，这种在`subscribe()`之前写上两句`subscribeOn(Scheduler.io())`和`observeOn(AndroidSchedulers.mainThread())`的使用方式非常常见，它适用于多数的***后台线程取数据，主线程显示***的程序策略。
+上面这段代码中，`subscribeOn(Schedulers.io())`的指定会让创建的事件的内容`Hello `、`World !`将会在`IO`线程发出；      
+
+而由于`observeOn(AndroidScheculers.mainThread())` 的指定，因此`subscriber()`方法设置后的回调中内容的打印将发生在主线程中。     
+事实上，这种在`subscribe()`之前写上两句`subscribeOn(Scheduler.io())`和`observeOn(AndroidSchedulers.mainThread())`的使用方式非常常见，它适用于多数的***后台线程取数据，主线程显示***的程序策略。
 
 #### `Scheduler`的原理
 
-`RxJava`的`Scheduler API`很方便，也很神奇（加了一句话就把线程切换了，怎么做到的？而且 subscribe() 不是最外层直接调用的方法吗，它竟然也能被指定线程？）。然而 Scheduler 的原理需要放在后面讲，因为它的原理是以下一节《变换》的原理作为基础的。
+`RxJava`的`Scheduler API`很方便，也很神奇（加了一句话就把线程切换了，怎么做到的？而且subscribe()不是最外层直接调用的方法吗，它竟然也能被指定线程？）。然而Scheduler的原理需要放在后面讲，因为它的原理是以下一节《变换》的原理作为基础的。
 
 好吧这一节其实我屁也没说，只是为了让你安心，让你知道我不是忘了讲原理，而是把它放在了更合适的地方。
 
 
-能不能多切换几次线程？答案是：能。因为`observeOn()`指定的是`Subscriber`的线程，而这个`Subscriber`并不是（严格说应该为『不一定是』，但这里不妨理解为『不是』）`subscribe()` 参数中的`Subscriber`，而是`observeOn()`执行时的当前`Observable`所对应的`Subscriber`，即它的直接下级`Subscriber`。换句话说`observeOn()` 指定的是它之后的操作所在的线程。因此如果有多次切换线程的需求，只要在每个想要切换线程的位置调用一次`observeOn()`即可。
+能不能多切换几次线程？答案是：能。      
+
+因为`observeOn()`指定的是`Subscriber`的线程，而这个`Subscriber`并不是（严格说应该为『不一定是』，但这里不妨理解为『不是』）`subscribe()` 参数中的`Subscriber`，而是`observeOn()`执行时的当前`Observable`所对应的`Subscriber`，即它的直接下级`Subscriber`。      
+
+换句话说`observeOn()` 指定的是它之后的操作所在的线程。因此如果有多次切换线程的需求，只要在每个想要切换线程的位置调用一次`observeOn()`即可。
 
 上代码：
 
@@ -140,13 +149,19 @@ Observable.just(1, 2, 3, 4) // IO 线程，由 subscribeOn() 指定
 
 ![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/rxjava_observable_list.jpg?raw=true)
 
-图中共有5处含有对事件的操作。由图中可以看出，①和②两处受第一个`subscribeOn()`影响，运行在红色线程；③和④处受第一个`observeOn()`的影响，运行在绿色线程；⑤处受第二个 `onserveOn()`影响，运行在紫色线程；而第二个`subscribeOn()`，由于在通知过程中线程就被第一个`subscribeOn()` 截断，因此对整个流程并没有任何影响。这里也就回答了前面的问题：当使用了多个`subscribeOn()`的时候，只有第一个`subscribeOn()`起作用。
+图中共有5处含有对事件的操作。由图中可以看出，①和②两处受第一个`subscribeOn()`影响，运行在红色线程；     
+③和④处受第一个`observeOn()`的影响，运行在绿色线程；      
+⑤处受第二个 `onserveOn()`影响，运行在紫色线程；而第二个`subscribeOn()`，由于在通知过程中线程就被第一个`subscribeOn()` 截断，因此对整个流程并没有任何影响。     
+
+这里也就回答了前面的问题：当使用了多个`subscribeOn()`的时候，只有第一个`subscribeOn()`起作用。
 
 在前面讲`Subscriber`的时候，提到过`Subscriber`的`onStart()`可以用作流程开始前的初始化。然而`onStart()`由于在`subscribe()`发生时就被调用了，因此不能指定线程，而是只能执行在`subscribe()`被调用时的线程。这就导致如果`onStart()`中含有对线程有要求的代码（例如在界面上显示一个`ProgressBar`，这必须在主线程执行），将会有线程非法的风险，因为有时你无法预测`subscribe()`将会在什么线程执行。
 
-而与`Subscriber.onStart()`相对应的，有一个方法`Observable.doOnSubscribe()`。它和`Subscriber.onStart()`同样是在`subscribe()`调用后而且在事件发送前执行，但区别在于它可以指定线程。默认情况下,`doOnSubscribe()`执行在`subscribe()`发生的线程；而如果在`doOnSubscribe()`之后有`subscribeOn()`的话，它将执行在离它最近的`subscribeOn()`所指定的线程。
+而与`Subscriber.onStart()`相对应的，有一个方法`Observable.doOnSubscribe()`。      
+它和`Subscriber.onStart()`同样是在`subscribe()`调用后而且在事件发送前执行，但区别在于它可以指定线程。       
+默认情况下,`doOnSubscribe()`执行在`subscribe()`发生的线程；而如果在`doOnSubscribe()`之后有`subscribeOn()`的话，它将执行在离它最近的`subscribeOn()`所指定的线程。
 
-示例代码：
+示例代码:       
 
 ```java
 Observable.create(onSubscribe)
diff --git "a/RxJavaPart/4.RxJava\350\257\246\350\247\243\344\271\213\346\211\247\350\241\214\345\216\237\347\220\206(\345\233\233).md" "b/RxJavaPart/4.RxJava\350\257\246\350\247\243\344\271\213\346\211\247\350\241\214\345\216\237\347\220\206(\345\233\233).md"
index 52de63e3..913f85d2 100644
--- "a/RxJavaPart/4.RxJava\350\257\246\350\247\243\344\271\213\346\211\247\350\241\214\345\216\237\347\220\206(\345\233\233).md"
+++ "b/RxJavaPart/4.RxJava\350\257\246\350\247\243\344\271\213\346\211\247\350\241\214\345\216\237\347\220\206(\345\233\233).md"
@@ -300,7 +300,7 @@ public interface Subscription {
 observable.subscribe(subscriber)源码分析
 ---
 
-好了，关系部分出现了，我们继续看`Observable`类中的`subscribe()`方法，上面在将`Observable`源码的时候我们简单带过这部分，没有细说，这里仔细说一下:     
+好了，关键部分出现了，我们继续看`Observable`类中的`subscribe()`方法，上面在将`Observable`源码的时候我们简单带过这部分，没有细说，这里仔细说一下:     
 ```java
 public class Observable<T> {
     final OnSubscribe<T> onSubscribe;
@@ -486,6 +486,7 @@ observable.subscribe(subscriber);
 ```
 
 总结一下:
+
 - 首先我们调用`Observable.create(OnSubscribe f)`创建一个观察者，同时创建一个`OnSubscribe`接口的实现类作为`create()`方法的参数，并重写该接口的`call()`方法，在`call()`方法中我们调用`subscriber`的`onNext()`、`onComplete()`及`onError()`方法。而这个`call()`方法中的`subscriber`对象就是我们后面调用`observable.subscribe(subscriber);`所传递的`subscribe`对象。    
 - 然后调用`new Subscriber()`创建一个`Subscriber`类的实例。 
 - 最后通过`observable.subscribe(subscriber);`将`Observable`和`Subscriber`对象进行绑定。来订阅我们自己创建的观察者`Subscriber`对象。
diff --git "a/SourceAnalysis/ARouter\350\247\243\346\236\220.md" "b/SourceAnalysis/ARouter\350\247\243\346\236\220.md"
new file mode 100644
index 00000000..3468f729
--- /dev/null
+++ "b/SourceAnalysis/ARouter\350\247\243\346\236\220.md"
@@ -0,0 +1,55 @@
+# ARouter解析
+
+[ARouter](https://github.com/alibaba/ARouter)
+
+> 一个用于帮助 Android App 进行组件化改造的框架 —— 支持模块间的路由、通信、解耦
+
+简单的说: 它是一个路由系统 ——— 给无依赖的组件提供通信和路由的能力。
+
+举个例子： 
+你过节了你想写一个明信片递给远方的朋友，那你就需要通过邮局(ARoter)来把明信片派送给你的朋友(你和你的朋友相当于两个组件)。
+
+使用ARouter在进行Activity跳转非常简单:    
+
+- 初始化ARouter  `ARouter.init(mApplication); // 尽可能早，推荐在Application中初始化`
+- 添加注解@Route  
+	```java
+	// 在支持路由的页面上添加注解(必选)
+	// 这里的路径需要注意的是至少需要有两级，/xx/xx
+	@Route(path = "/test/activity")
+	public class YourActivity extend Activity {
+	    ...
+	}
+	```
+- 发起路由  `ARouter.getInstance().build("/test/activity").navigation();`
+
+
+
+ARouter框架能将多个服务提供者隔离，减少相互之间的依赖。其实现的流程和我们平常的快递物流管理很类似，每一个具体的快递包裹就是一个独立的服务提供者（IProvider），每一个快递信息单就是一个RouteMeta对象，客户端就是快递的接收方，而使用@Route注解中的path就是快递单号。在初始化流程中，主要完成的工作就是将所有注册的快递信息表都在物流中心（LogisticsCenter）注册，并将数据存储到数据仓库中（Warehouse）。
+
+作者：魔焰之
+链接：https://www.jianshu.com/p/11006054f156
+来源：简书
+著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
diff --git "a/SourceAnalysis/RecyclerView\345\244\215\347\224\250\345\216\237\347\220\206.md" "b/SourceAnalysis/RecyclerView\345\244\215\347\224\250\345\216\237\347\220\206.md"
new file mode 100644
index 00000000..bf99eba6
--- /dev/null
+++ "b/SourceAnalysis/RecyclerView\345\244\215\347\224\250\345\216\237\347\220\206.md"
@@ -0,0 +1,15 @@
+RecyclerView复用原理
+===
+
+但是很多时候我们的使用方式并不是最完美的，将Adapter和数据进行了强绑定。尽管在很多实际项目中，将数据存储在 Adapter 内部，甚至将数据作为了Adapter的成员变量是一种常见的做法:
+
+这种实现方式就是把数据给Adapter，然后Adapter进过处理，完成数据的展示，不过，从严格的单一职责原则角度出发， Adapter 只应该负责“映射”而不是“管理”数据。也就是说，数据的维护（如数据的获取、更新和业务逻辑）可以交给 Activity、Fragment 或 ViewModel，而 Adapter 仅仅负责根据外部传入的数据来创建和绑定视图
+
+
+
+
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
diff --git "a/VideoDevelopment/Android\351\237\263\350\247\206\351\242\221\345\274\200\345\217\221/CameraX\347\273\223\345\220\210OpenGL.md" "b/VideoDevelopment/Android\351\237\263\350\247\206\351\242\221\345\274\200\345\217\221/CameraX\347\273\223\345\220\210OpenGL.md"
new file mode 100644
index 00000000..276f664d
--- /dev/null
+++ "b/VideoDevelopment/Android\351\237\263\350\247\206\351\242\221\345\274\200\345\217\221/CameraX\347\273\223\345\220\210OpenGL.md"
@@ -0,0 +1,84 @@
+CameraX结合OpenGL
+===
+
+
+CameraX 是一个 Jetpack 库，旨在帮助您更轻松地开发相机应用。如果您要开发新应用，我们建议您从 CameraX 开始。它提供了一个一致且易于使用的 API，该 API 适用于绝大多数 Android 设备，并向后兼容 Android 5.0（API 级别 21）。
+
+
+CameraX 着重于用例，使您可以专注于需要完成的任务，而无需花时间处理不同设备之间的细微差别。CameraX 支持大多数常见的相机用例：
+
+预览：在屏幕上查看图片。接受用于显示预览的 Surface，例如 PreviewView。
+图片分析：无缝访问缓冲区中的图片以便在算法中使用，例如将其传递到机器学习套件。为分析（例如机器学习）提供 CPU 可访问的缓冲区。
+图片拍摄：保存图片。拍摄并保存照片。
+视频拍摄：保存视频和音频。通过 VideoCapture 拍摄视频和音频
+
+
+
+版本 1.4.0
+2024 年 10 月 30 日
+
+发布了 androidx.camera:camera-*:1.4.0。版本 1.4.0 包含这些提交内容。
+
+自 1.3.0 以来的重要变更
+
+CameraX 1.4.0 包含众多精彩更新！下面是摘要：
+
+主打功能：10 位 HDR：
+
+轻松拍摄出令人惊艳的 HDR 照片和视频。
+支持 HLG 和 10 位 HEVC 编码。
+享受 10 位 HDR 预览，并查询设备功能。
+可在越来越多的设备上与 UltraHDR 图片和 HDR 视频搭配使用。
+其他酷炫功能：
+
+Kotlin 扩展：添加了 takePicture 和 awaitInstance 挂起函数。
+实时特效：应用水印和对象突出显示等特效。
+CameraController API：新增了视频拍摄配置控件。
+预览防抖：查询设备功能并启用防抖。
+增强了 VideoCapture 功能：可更精细地控制画质，并支持更高分辨率。
+CameraX 扩展程序集成：与 VideoCapture 和新的 ImageCapture 功能无缝集成。
+Shutter Sound API：轻松查看各个地区的快门提示音要求。
+屏幕闪光灯：改进了前置摄像头在弱光环境下的拍照效果。
+Camera Extensions Metadata API：支持在 ExtensionMode#AUTO 中调整扩展程序强度和获取当前扩展程序模式通知的 API。如需了解更多 bug 修复，请参阅我们的Beta 版和RC 版公告。
+
+
+
+
+同时选择多个摄像头
+从 CameraX 1.3 开始，您还可以同时选择多个摄像头。 例如，您可以对前置和后置摄像头进行绑定，以便从两个视角同时拍摄照片或录制视频。
+
+使用并发摄像头功能时，设备可以同时运行两个不同镜头方向的摄像头，或同时运行两个后置摄像头。以下代码块展示了如何在调用 bindToLifecycle 时设置两个摄像头，以及如何从返回的 ConcurrentCamera 对象中获取两个 Camera 对象。
+
+Kotlin
+Java
+
+// Build ConcurrentCameraConfig
+val primary = ConcurrentCamera.SingleCameraConfig(
+    primaryCameraSelector,
+    useCaseGroup,
+    lifecycleOwner
+)
+
+val secondary = ConcurrentCamera.SingleCameraConfig(
+    secondaryCameraSelector,
+    useCaseGroup,
+    lifecycleOwner
+)
+
+val concurrentCamera = cameraProvider.bindToLifecycle(
+    listOf(primary, secondary)
+)
+
+val primaryCamera = concurrentCamera.cameras[0]
+val secondaryCamera = concurrentCamera.cameras[1]
+
+
+
+
+
+
+​    
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
\ No newline at end of file
diff --git "a/VideoDevelopment/Android\351\237\263\350\247\206\351\242\221\345\274\200\345\217\221/MediaExtractor\343\200\201MediaCodec\343\200\201MediaMuxer.md" "b/VideoDevelopment/Android\351\237\263\350\247\206\351\242\221\345\274\200\345\217\221/MediaExtractor\343\200\201MediaCodec\343\200\201MediaMuxer.md"
index e69de29b..204676f3 100644
--- "a/VideoDevelopment/Android\351\237\263\350\247\206\351\242\221\345\274\200\345\217\221/MediaExtractor\343\200\201MediaCodec\343\200\201MediaMuxer.md"
+++ "b/VideoDevelopment/Android\351\237\263\350\247\206\351\242\221\345\274\200\345\217\221/MediaExtractor\343\200\201MediaCodec\343\200\201MediaMuxer.md"
@@ -0,0 +1,37 @@
+# MediaExtractor、MediaCodec、MediaMuxer
+
+
+## MediaExtractor
+
+MediaExtractor是一个Android系统用于从多媒体文件中提取音频和视频数据的类。   
+
+它可以从本地文件或网络流中读取音频和视频数据，并将其解码为原始的音频和视频帧。它的主要功能就是解封装，也就是从媒体文件中提取出原始的音频和视频数据流。这些数据流可以被送入解码器进行解码，然后进行播放或者其他处理。      
+
+MediaExtractor可以用于开发音视频播放器、视频编辑器、音频处理器等应用程序。
+
+
+## MediaMuxter
+
+MediaMuxter是Android系统提供的一个用于混合音频和视频数据的API。    
+
+它可以将音频和视频的原始数据流混合封装成媒体文件，例如MP4、WebM等。    
+
+MediaMuxter通常与MediaExtractor一起使用，MediaExtractor用于从媒体文件中提取音频和视频数据，MediaMuxter用于将这些数据混合成新的媒体文件。   
+
+简单说就是: MediaExtractor提供了解封装的能力，而MediaMuxer提供了视频封装的能力。   
+
+
+## MediaCodec
+
+MediaCodec是Android提供的用于对音视频进行编码的类，是Android Media基础框架的一部分，一般和MediaExtractor、MediaMuxer、Surface和AudioTrack一起使用。 
+
+
+MediaCodec可以处理原始的音视频数据，包括编码(将原始数据转换为压缩格式)和解码(将压缩格式转换为原始数据)。    
+
+
+
+MediaExtractor仅仅是解封装数据，不会对数据进行解码。要对媒体数据进行解码，需要使用MediaCodec类。    
+
+而且MediaExtractor只能解封装媒体文件中的音视频等媒体轨道，而不能解析整个媒体文件的结构。如果需要解析整个媒体文件的结构，需要使用其他库或框架。   
+
+ 
diff --git "a/VideoDevelopment/Android\351\237\263\350\247\206\351\242\221\345\274\200\345\217\221/MediaMetadataRetriever.md" "b/VideoDevelopment/Android\351\237\263\350\247\206\351\242\221\345\274\200\345\217\221/MediaMetadataRetriever.md"
new file mode 100644
index 00000000..a57255ab
--- /dev/null
+++ "b/VideoDevelopment/Android\351\237\263\350\247\206\351\242\221\345\274\200\345\217\221/MediaMetadataRetriever.md"
@@ -0,0 +1,33 @@
+# MediaMetadataRetriever
+
+MediaMetadataRetriever是Android中用于从媒体文件中提取元数据的类，可以获取音频、视频和图片文件的各种信息，例如时长、标题、封面等。
+
+```java
+MediaMetadataRetriever mRetriever = new MediaMetadataRetriever();
+
+mRetriever.setDataSource(mContext, mVideoUri);
+```
+
+## 获取元数据
+
+// 获取歌曲标题
+`mRetriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_TITLE);`
+
+根据key的不同还可以是时长、帧率、分辨率等。
+
+## 获取缩略图
+
+`public Bitmap getFrameAtTime(long timeUs, int option)`
+用于获取音视频文件中的一帧画面，可以用于实现缩略图、视频预览等功能。 
+
+- timeUs:是获取画面对应的时间戳，单位为微妙
+- option:可以设置是获取离指定时间戳最近的一帧画面或者事最近的关键帧画面等。
+
+## 获取专辑封面图
+
+```java
+byte[] bytes = mRetriever.getEmbeddedPicture();
+Bitmap bitmap = BitmapFactory.decodeByteArray(bytes, 0, bytes.length); 
+```
+需要注意的是，MediaMetadataRetriever只能用于读取已经完成的音视频文件，无法用于实时处理音视频数据流。
+
diff --git "a/VideoDevelopment/Android\351\237\263\350\247\206\351\242\221\345\274\200\345\217\221/SurfaceView\344\270\216TextureView.md" "b/VideoDevelopment/Android\351\237\263\350\247\206\351\242\221\345\274\200\345\217\221/SurfaceView\344\270\216TextureView.md"
index de765b86..23739606 100644
--- "a/VideoDevelopment/Android\351\237\263\350\247\206\351\242\221\345\274\200\345\217\221/SurfaceView\344\270\216TextureView.md"
+++ "b/VideoDevelopment/Android\351\237\263\350\247\206\351\242\221\345\274\200\345\217\221/SurfaceView\344\270\216TextureView.md"
@@ -2,13 +2,21 @@ SurfaceView与TextureView
 ===
 
 
-## SurfaceView
+Android系统中图形系统是相当复杂的，包括WindowManager、SurfaceFlinger、OpenGL等。     
+
+其中SurfaceFlinger(表面合成器或表面渲染器)作为负责绘制应用UI的核心。
+
+但是不论使用什么渲染API，所有的东西最终都渲染到Surface上，Android平台所创建的Window都由Surface所支持，所有可见的Surface渲染到显示设备都是通过SurfaceFlinger来完成。    
+
+
+
 
-在说SurfaceView之前，需要先说一下几个相关的部分。
 
 ### `Surface`简介
 
-- `Surface`就是“表面”的意思，可以简单理解为内存中的一段绘图缓冲区。在`SDK`的文档中，对`Surface`的描述是这样的：“`Handle onto a raw buffer that is being managed by the screen compositor`”，
+- `Surface`就是“表面”的意思，可以简单理解为内存中的一段绘图缓冲区。
+
+    在`SDK`的文档中，对`Surface`的描述是这样的：“`Handle onto a raw buffer that is being managed by the screen compositor`”，
     翻译成中文就是“由屏幕显示内容合成器`(screen compositor)`所管理的原生缓冲器的句柄”，   这句话包括下面两个意思:     
 
     - 通过`Surface`（因为`Surface`是句柄）就可以获得原生缓冲器以及其中的内容。就像在`C`语言中，可以通过一个文件的句柄，就可以获得文件的内容一样；
@@ -19,6 +27,9 @@ SurfaceView与TextureView
 - `Surface`是一个用来画图形的地方，但是我们知道画图都是在一个`Canvas`对象上面进行的，*`Surface`中的`Canvas`成员，是专门用于提供画图的地方，就像黑板一样，其中的原始缓冲区是用来保存数据的地方，
     `Surface`本身的作用类似一个句柄，得到了这个句柄就可以得到其中的`Canvas`、原始缓冲区以及其他方面的内容，所以简单的说`Surface`是用来管理数据的(句柄)*。
     
+
+Surface是一个绘制目标，可以被系统的SurfaceFlinger直接合成显示在屏幕上。    
+
 ### `SurfaceView`简介      
 
 - 简单的说`SurfaceView`就是一个有`Surface`的`View`里面内嵌了一个专门用于绘制的`Surface`,`SurfaceView`控制这个`Surface`的格式和尺寸以及绘制位置。
@@ -84,16 +95,40 @@ TextureView是一个可以把内容流作为外部纹理输出在上面的View,
 
 ### SurfaceTexture
 
-SurfaceTexture是Surface和OpenGL ES(GLES)纹理的组合。SurfaceTexture用于提供输出到GLES 纹理的Surface。SurfaceTexture是从Android 3.0开始加入，与SurfaceView不同的是，它对图像流的处理并不直接显示，而是转为GL外部纹理，因此用于图像流数据的二次处理。比如Camera的预览数据，变成纹理后可以交给GLSurfaceView直接显示，也可以通过SurfaceTexture交给TextureView作为View heirachy中的一个硬件加速层来显示。首先，SurfaceTexture从图像流(来自Camera预览、视频解码、GL绘制场景等)中获得帧数据，当调用updateTexImage()时，根据内容流中最近的图像更新SurfaceTexture对应的GL纹理对象。
+SurfaceTexture 是一种 纹理对象，可以作为 OpenGL ES 纹理（OES 纹理）进行处理。它不会直接显示在屏幕上，而是可以将内容传递给 OpenGL 进行进一步处理或绘制。
+
+SurfaceTexture用于提供输出到GLES 纹理的Surface。SurfaceTexture是从Android 3.0开始加入，与SurfaceView不同的是，它对图像流的处理并不直接显示，而是转为GL外部纹理，因此用于图像流数据的二次处理。比如Camera的预览数据，变成纹理后可以交给GLSurfaceView直接显示，也可以通过SurfaceTexture交给TextureView作为View heirachy中的一个硬件加速层来显示。
+
+在Android系统重，SurfaceTexture是一个特殊的类，它将来自硬件纹理缓冲区(如相机预览流或视频解码输出)的图像数据转换为OpenGL ES可以直接使用的纹理。     
+
+updateTexImage()方法是SurfaceTexture类的核心方法之一，此方法的主要作用是从SurfaceTexture内部特有的图像缓冲区中取出最新一帧，
+并将其内容复制到与SurfaceTexture关联的OpenGL纹理上。    
+
+这对于实时图形渲染、视频播放以及从相机捕获并实时处理图像等场景至关重要。 
 
 
 
 SurfaceTexture 包含一个应用是其使用方的BufferQueue。当生产方将新的缓冲区排入队列时，onFrameAvailable() 回调会通知应用。然后，应用调用updateTexImage()，这会释放先前占有的缓冲区，从队列中获取新缓冲区并执行EGL调用，从而使GLES可将此缓冲区作为外部纹理使用。
 
+
+##### Surface与SurfaceTexture的关系
+
+- SurfaceTexture是一个OpenGL纹理对象，用于GPU处理视频流或相机数据，它不会直接显示在屏幕上，需要OpenGL渲染后才能看到。    
+- Surface是一个绘制目标，可以直接用于屏幕渲染，它可以基于SurfaceTexture创建，这样Surface就可以间接获取SurfaceTexture的数据。  
+
+例如相机使用OpenGL的渲染过程:   
+
+- 在相机预览时，Camera可以将相机数据输出到SurfaceTexture上，然后
+- SurfaceTexture采集相机数据，并将其存储到OpenGL纹理中(OES纹理)
+- SurfaceTexture触发onFrameAvailable()回调，通知OpenGL纹理更新。 
+- OpenGL使用该纹理进行渲染，最终显示在GLSurfaceView或TextureView上。    
+
+
 ## SurfaceView vs TextureView
 
 
 
+
 简单地说，SurfaceView是一个有自己Surface的View。它的渲染可以放在单独线程而不是主线程中。其缺点是不能做变形和动画。SurfaceTexture可以用作非直接输出的内容流，这样就提供二次处理的机会。与SurfaceView直接输出相比，这样会有若干帧的延迟。同时，由于它本身管理BufferQueue，因此内存消耗也会稍微大一些。TextureView是一个可以把内容流作为外部纹理输出在上面的View。它本身需要是一个硬件加速层。事实上TextureView本身也包含了SurfaceTexture。它与SurfaceView+SurfaceTexture组合相比可以完成类似的功能（即把内容流上的图像转成纹理，然后输出）。区别在于TextureView是在View hierachy中做绘制，因此一般它是在主线程上做的（在Android 5.0引入渲染线程后，它是在渲染线程中做的）。而SurfaceView+SurfaceTexture在单独的Surface上做绘制，可以是用户提供的线程，而不是系统的主线程或是渲染线程。
 
 
@@ -123,4 +158,5 @@ SurfaceTexture 包含一个应用是其使用方的BufferQueue。当生产方将
 ---
 
 - 邮箱 ：charon.chui@gmail.com  
-- Good Luck! 
\ No newline at end of file
+- Good Luck! 
+
diff --git "a/VideoDevelopment/CDN\345\217\212PCDN.md" "b/VideoDevelopment/CDN\345\217\212PCDN.md"
index bc9d8c36..c10a989c 100644
--- "a/VideoDevelopment/CDN\345\217\212PCDN.md"
+++ "b/VideoDevelopment/CDN\345\217\212PCDN.md"
@@ -281,7 +281,27 @@ P2P用户将根据这些规则来完成P2P共享。P2P在边缘层的引入大
 一方面，P2P+CDN结合的方式，使得有限的服务能力可以为更多的用户提供流媒体服务。超级种子的存在保证了
 服务质量。另一方面，P2P技术的应用也能够更有效地防止因网络的抖动而产生对服务质量的影响。
 
-​    
+
+### CDN回源 
+
+缓存没有命中时，去回到源站请求原始数据来源的过程。
+
+
+用户访问 img.example.com/photo.jpg
+
+CDN 边缘节点没有这张图
+   → 回源到 源站 origin.example.com
+   → 拿到图片，缓存在 CDN 节点
+   → 返回给用户
+
+下次同区域用户访问同一张图
+   → CDN 直接命中，不再回源
+
+
+回源率 = 回源请求数 / 总请求数
+回源率高 → 缓存命中率低 → 源站压力大 → 需要优化缓存策略
+
+
 
 [Content Delivery Acceleration and Cost Reduction with P2P CDN (PCDN)](https://dzone.com/articles/content-delivery-acceleration-and-cost-reduction-w)
 
diff --git a/VideoDevelopment/JPEG 2.md b/VideoDevelopment/JPEG 2.md
new file mode 100644
index 00000000..fa200838
--- /dev/null
+++ b/VideoDevelopment/JPEG 2.md	
@@ -0,0 +1,102 @@
+# JPEG
+
+JPEG（Joint Photographic Experts Group)，全称为联合图像专家小组，是国际标准化组织（ISO）制定的静态图像压缩标准，文件扩展名为.jpg或.jpeg，适用于连续色调静止图像处理。
+
+
+JPEG只描述一副图像如何转换成一组数据流，而不论这些字节存储在何种介质上。由独立JPEG组创立的另一个进阶标准，JFIF（JPEGFileInterchangeFormat，JPEG文件交换格式）则描述JPEG数据流如何生成适于电脑存储或传送的图像。在一般应用中，我们从数码相机等来源获得的“JPEG文件”，指的就是JFIF文件，有时是ExifJPEG文件。
+
+
+该格式采用有损压缩算法，通过牺牲部分画质换取较小文件体积，压缩过程包含色彩空间转换（RGB转YCbCr）、离散余弦变换（DCT）、量化和熵编码等步骤。
+
+支持标准JPEG、渐进式JPEG和JPEG2000三种格式，其中渐进式格式可实现图像由模糊到清晰的渐进加载.  
+
+JPEG压缩技术通过分离高频与低频信息并对高频部分进行压缩，压缩比可通过量化表参数调节，典型压缩率为原始大小的10%.   
+
+
+### 说明
+1. jpeg是一种压缩标准，大幅度缩小数据流，jpeg以FF D8开头，FF D9结束。
+2. jpeg文件中有一些形如0xFF**这样的数据，它们被称为标志(Markeer),它表示jpeg信息数据段。例如0xFFD8代表SOI(Startof image)。OxFFD9代表EOI(End of image)。
+4. jpeg图像由多个maker组成，多个maker+compressed组成了jpeg。
+5. jiff是一种在万维网上进行jpeg传输的格式，可以理解是对jpeg图片的封装，符合jpeg标准，jiff的maker是app0，记录了图像的基本信息，也可能有缩略图。jiff格式比较老，老式的数码相机使用此格式。
+6. exif新比较新的jpeg封装格式，exif的maker是app1，记录了更多的东西，如ISP信息、GPS信息、相机信息，图像旋转等等
+7. jiff和exif可以共存，很多jpeg图像都有app0的jiff段和app1的exif段
+
+
+
+## 压缩流程
+
+1. 原始图像
+2. 8x8分块
+3. DCT(Discrete Cosine Transform,离散余弦变换)变换: 把数据从时域转化到频域的数学方法，把图像数据转换到频域之后，可以从中分离出各种频率的信息。   
+4. 量化
+5. Z字形扫描
+6. 对系数编码
+7. 熵编码
+8. 压缩数据
+
+
+ 
+
+ 
+JPEG文件除了图像数据之外，还保存了与图片相关的各种信息，这些信息通过不同类型的TAG存储在文件中。 
+
+
+## TAG
+
+JPEG通过TAG编辑压缩数据之外的信息。    
+
+所有的TAG都包含一个TAG类型，TAG类型的大小为两个字节，位于一个TAG的最前面。TAG类型的第一个字节一定为0xFF
+
+一般情况下，是按照这个顺序排列的:     
+
+
+| TAG 类型          | 数值(十六进制标识符)     | 全称                       | 其他备注                          |
+|-------------------|----------|----------------------------|-----------------------------------|
+| SOI               | 0xFFD8   | Start of Image             | 必带                              |
+| APP0              | 0xFFE0   | application0               | 必带                              |
+| APPn              | 0xFFEn   | applicationn               | 可选带(APP1一般为Exif信息)        |
+| DQT               | 0xFFDB   | Define Quantization Table  | 必带                              |
+| SOF               | 0xFFC0   | Start of Frame             | 必带                              |
+| DHT               | 0xFFC4   | Define Huffman Table       | 必带                              |
+| SOS               | 0xFFDA   | Start of Scan              | 必带                              |
+| compress data     | ...      | ...                        | 必带                              |
+| EOI               | 0xFFD9   | End of Image               | 必带                              |
+
+标志OxFFE0~OxFFEF被称为"Application Marker"，它们不是解码JPEG文件必须得，可以被用来存储配置信息等。    
+EXIF也是利用这个标志段来插入信息的。具体来说，是APP1(0xFFE1)Marker，所有的EXIF信息都存储在该数据段。    
+​EXIF（Exchangeable Image File Format）​​ 是嵌入在 JPEG 文件中的 ​元数据标准，记录拍摄设备、参数和场景信息，相当于照片的“数字身份证”。
+
+
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/jpeg_1.png?raw=true)             
+
+
+#### 典型JPEG文件结构    
+
+[SOI] -> [APP0] -> [APP1(EXIF)] -> [DQT] -> [SOF] -> [DHT] -> [SOS] -> [压缩数据] -> [EOI]
+
+
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/jpeg_2.png?raw=true)             
+
+##### 怎么判断是不是JPEG图片？ 
+
+jpeg是一种压缩标准，大幅度缩小数据流，jpeg以FF D8开头，FF D9结束。
+
+
+其实很简单，就是判断前面3个字节是什么，如果发现是FF D8 FF开始，那就认为它是JEPG图片。(注意android不是根据后缀名来判断是什么文件的，当然你必须是图片的后缀名文件管理器才可以打开
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/VideoDevelopment/JPEG.md b/VideoDevelopment/JPEG.md
new file mode 100644
index 00000000..fa200838
--- /dev/null
+++ b/VideoDevelopment/JPEG.md
@@ -0,0 +1,102 @@
+# JPEG
+
+JPEG（Joint Photographic Experts Group)，全称为联合图像专家小组，是国际标准化组织（ISO）制定的静态图像压缩标准，文件扩展名为.jpg或.jpeg，适用于连续色调静止图像处理。
+
+
+JPEG只描述一副图像如何转换成一组数据流，而不论这些字节存储在何种介质上。由独立JPEG组创立的另一个进阶标准，JFIF（JPEGFileInterchangeFormat，JPEG文件交换格式）则描述JPEG数据流如何生成适于电脑存储或传送的图像。在一般应用中，我们从数码相机等来源获得的“JPEG文件”，指的就是JFIF文件，有时是ExifJPEG文件。
+
+
+该格式采用有损压缩算法，通过牺牲部分画质换取较小文件体积，压缩过程包含色彩空间转换（RGB转YCbCr）、离散余弦变换（DCT）、量化和熵编码等步骤。
+
+支持标准JPEG、渐进式JPEG和JPEG2000三种格式，其中渐进式格式可实现图像由模糊到清晰的渐进加载.  
+
+JPEG压缩技术通过分离高频与低频信息并对高频部分进行压缩，压缩比可通过量化表参数调节，典型压缩率为原始大小的10%.   
+
+
+### 说明
+1. jpeg是一种压缩标准，大幅度缩小数据流，jpeg以FF D8开头，FF D9结束。
+2. jpeg文件中有一些形如0xFF**这样的数据，它们被称为标志(Markeer),它表示jpeg信息数据段。例如0xFFD8代表SOI(Startof image)。OxFFD9代表EOI(End of image)。
+4. jpeg图像由多个maker组成，多个maker+compressed组成了jpeg。
+5. jiff是一种在万维网上进行jpeg传输的格式，可以理解是对jpeg图片的封装，符合jpeg标准，jiff的maker是app0，记录了图像的基本信息，也可能有缩略图。jiff格式比较老，老式的数码相机使用此格式。
+6. exif新比较新的jpeg封装格式，exif的maker是app1，记录了更多的东西，如ISP信息、GPS信息、相机信息，图像旋转等等
+7. jiff和exif可以共存，很多jpeg图像都有app0的jiff段和app1的exif段
+
+
+
+## 压缩流程
+
+1. 原始图像
+2. 8x8分块
+3. DCT(Discrete Cosine Transform,离散余弦变换)变换: 把数据从时域转化到频域的数学方法，把图像数据转换到频域之后，可以从中分离出各种频率的信息。   
+4. 量化
+5. Z字形扫描
+6. 对系数编码
+7. 熵编码
+8. 压缩数据
+
+
+ 
+
+ 
+JPEG文件除了图像数据之外，还保存了与图片相关的各种信息，这些信息通过不同类型的TAG存储在文件中。 
+
+
+## TAG
+
+JPEG通过TAG编辑压缩数据之外的信息。    
+
+所有的TAG都包含一个TAG类型，TAG类型的大小为两个字节，位于一个TAG的最前面。TAG类型的第一个字节一定为0xFF
+
+一般情况下，是按照这个顺序排列的:     
+
+
+| TAG 类型          | 数值(十六进制标识符)     | 全称                       | 其他备注                          |
+|-------------------|----------|----------------------------|-----------------------------------|
+| SOI               | 0xFFD8   | Start of Image             | 必带                              |
+| APP0              | 0xFFE0   | application0               | 必带                              |
+| APPn              | 0xFFEn   | applicationn               | 可选带(APP1一般为Exif信息)        |
+| DQT               | 0xFFDB   | Define Quantization Table  | 必带                              |
+| SOF               | 0xFFC0   | Start of Frame             | 必带                              |
+| DHT               | 0xFFC4   | Define Huffman Table       | 必带                              |
+| SOS               | 0xFFDA   | Start of Scan              | 必带                              |
+| compress data     | ...      | ...                        | 必带                              |
+| EOI               | 0xFFD9   | End of Image               | 必带                              |
+
+标志OxFFE0~OxFFEF被称为"Application Marker"，它们不是解码JPEG文件必须得，可以被用来存储配置信息等。    
+EXIF也是利用这个标志段来插入信息的。具体来说，是APP1(0xFFE1)Marker，所有的EXIF信息都存储在该数据段。    
+​EXIF（Exchangeable Image File Format）​​ 是嵌入在 JPEG 文件中的 ​元数据标准，记录拍摄设备、参数和场景信息，相当于照片的“数字身份证”。
+
+
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/jpeg_1.png?raw=true)             
+
+
+#### 典型JPEG文件结构    
+
+[SOI] -> [APP0] -> [APP1(EXIF)] -> [DQT] -> [SOF] -> [DHT] -> [SOS] -> [压缩数据] -> [EOI]
+
+
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/jpeg_2.png?raw=true)             
+
+##### 怎么判断是不是JPEG图片？ 
+
+jpeg是一种压缩标准，大幅度缩小数据流，jpeg以FF D8开头，FF D9结束。
+
+
+其实很简单，就是判断前面3个字节是什么，如果发现是FF D8 FF开始，那就认为它是JEPG图片。(注意android不是根据后缀名来判断是什么文件的，当然你必须是图片的后缀名文件管理器才可以打开
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git "a/VideoDevelopment/OpenCV/1.OpenCV\347\256\200\344\273\213.md" "b/VideoDevelopment/OpenCV/1.OpenCV\347\256\200\344\273\213.md"
index d9b77c6e..f9dd0282 100644
--- "a/VideoDevelopment/OpenCV/1.OpenCV\347\256\200\344\273\213.md"
+++ "b/VideoDevelopment/OpenCV/1.OpenCV\347\256\200\344\273\213.md"
@@ -51,8 +51,8 @@ API：
 	默认的BGR 彩色图像加载方式，此外支持灰度图像和任意格式。注意：在OpenCV中颜色值写法是BGR，而不是RGB。
     imread() 函数默认加载图像文件，加载进来的是3 通道彩色图像，色彩空间是RGB 色彩空间。
     通道顺序是：BGR （蓝色、绿色、红色）。
-    通道分离函数：split（）
-    通道合并函数：merge（）
+    通道分离函数：split()
+    通道合并函数：merge()
 - imshow("namexx", ...url...)：显示图像
 - getStructuringElement(...)：获取腐蚀的内核矩阵
 - erode(...)：腐蚀(源图像、目的图像、内核矩阵）
@@ -127,7 +127,7 @@ copyTo()。
 在早期的OpenCV1.x 版本中，图像的处理是通过IplImage（该名称源于Intel 的另一个
 开源库Intel Image Processing Library ，缩写成IplImage）结构来实现的。
 
-早期的OpenCV 是用C 语言编写，因此提供的借口也是C 语言接口，其源代码完全是C
+早期的OpenCV 是用C 语言编写，因此提供的接口也是C 语言接口，其源代码完全是C
 的编程风格。IplImage 结构是OpenCV 矩阵运算的基本数据结构。
 
 到OpenCV2.x 版本，OpenCV 开源库引入了面向对象编程思想，大量源代码用C++重写。
diff --git "a/VideoDevelopment/OpenGL/1.OpenGL\347\256\200\344\273\213.md" "b/VideoDevelopment/OpenGL/1.OpenGL\347\256\200\344\273\213.md"
index 7578a7eb..ec827301 100644
--- "a/VideoDevelopment/OpenGL/1.OpenGL\347\256\200\344\273\213.md"
+++ "b/VideoDevelopment/OpenGL/1.OpenGL\347\256\200\344\273\213.md"
@@ -9,9 +9,6 @@ OpenGL(Open Graphics Library开放图形库)是用于渲染2D、3D矢量图形
 
 [OpenGL官网](https://www.opengl.org/)
 
-
-OpenGL的前身是硅谷图形功能(SGI)公司为其图形工作站开发的IRIS GL,后来因为IRIS GL的移植性不好，所以在其基础上，开发出了OpenGL。
-
 OpenGL一般用于在图形工作站，PC端使用，由于性能各方面原因，在移动端使用OpenGL基本带不动。       
 为此，Khronos公司就为OpenGL提供了一个子集，OpenGL ES(OpenGL for Embedded System)。
 
@@ -35,9 +32,22 @@ OpenGL ES由OpenGL裁剪而来，因此有必要了解一下两者版本的对
 
 ### OpenGL的作用
 
-在手机或电脑上有两大元件，一个是CPU,一个是GPU。      
+在手机或电脑上有两大元件，一个是CPU,一个是GPU。
+
 显示图形界面也有两种方式，一个是使用CPU渲染，一个是使用GPU渲染。        
-但是目前为止最高效的方法就是有效的使用图形处理单元(GPU)，图像的处理和渲染就是在将要渲染到窗口上的像素上做很多的浮点运算，而GPU可以并行的做浮点运算，所以用GPU来分担CPU的部分，可以提高效率，可以说GPU渲染其实是一种硬件加速。
+
+CPU和GPU因为涉及之初需求就不一样，所以它们的组成不同，在计算机中的分工也不同。    
+GPU有更多的ALU(算术逻辑单元，能实现多组算术运算和逻辑运算的组合逻辑电路)，而CPU有Control单元和Cache单元，普通的业务代码因为逻辑复杂，数据类型复杂、跳转复杂、依赖性高等，就更适合CPU来做。    
+
+而GPU不擅长处理这些复杂的逻辑，它更擅长处理单一的运算，大量的算术逻辑单元可以保证做到真正的高并发，所以大量的计算任务是适合它的工作，就比如GLSL代码。    
+
+简单说就是CPU更像管理者，负责调度和控制，也进行小量的计算，而GPU则是单纯的打工人，负责大量的计算工作。      
+
+
+
+
+目前为止最高效的方法就是有效的使用图形处理单元(GPU)，图像的处理和渲染就是在将要渲染到窗口上的像素上做很多的浮点运算，而GPU可以并行的做浮点运算，所以用GPU来分担CPU的部分，可以提高效率，可以说GPU渲染其实是一种硬件加速。
+
 
 - 图片处理:比如图片色调转换、美颜等。
 - 摄像头预览效果处理。比如美颜相机、恶搞相机等。
@@ -46,6 +56,10 @@ OpenGL ES由OpenGL裁剪而来，因此有必要了解一下两者版本的对
 
 
 
+图像数据无非是一个个的像素点，对图像数据的处理无非是对每个像素点进行计算后重新赋值，一般来说对每个像素点的计算都比较独立，计算也相对简单。CPU虽然计算能力强大，但是并行处理能力有限，对一张720P的图片，一共包含720*1280=921600个像素，要进行这么多次运算，CPU也要望洋兴叹了。GPU与CPU相比最大的优势就是并行处理能力，一般移动端的GPU也要包含数千个处理单元，这些处理单元虽然计算能力比不上CPU，但是却可以同时处理几千个像素点。像素点数据的计算相对简单，而且可以同时处理几千个像素点，图像数据用GPU来做计算就非常适合了。而怎么使用GPU呢？这就要介绍到目前使用最广泛的2D、3D矢量图形沉浸API：OpenGL了。
+
+
+
 ### Android中的OpenGL ES
 
 Android中OpenGL ES的版本支持如下:  
@@ -56,14 +70,24 @@ Android中OpenGL ES的版本支持如下:
 - OpenGL ES 3.1 - 此 API 规范受 Android 5.0（API 级别 21）及更高版本的支持。
 
 
+OpenGL ES是一套绘制3D图形的API，OpenGL ES是和平台无关的一套API，主要是为了rendering 2D和3D图形等。    
+OpenGL就是一组函数名，并不能直接用，需要底层硬件GPU的支持。     
+
+OpenGL ES的实现有2中方式：    
+
+- 第一种：是软件实现，用cpu去实现算法模拟GPU渲染、合成工作，就是agl(libGLES_android.so)，路径是frameworks/native/opengl/libagl，即the software OpenGL ES library。  
+
+- 第二种：是硬件厂商根据自己GPU提供的实现，一般都不开放源代码，就是/vendor/lib/egl或/system/lib/egl目录下的库。   
+
+
 
 ### OpenGL状态机(State Machine)
 >>> As long as you keep in mind that OpenGL is basically one large state machine,most of its functionality will make more sense. 
 
 - OpenGL自身是一个巨大的状态机: 描述该如何操作的所有变量的大集合
 - OpenGL的状态通常被称为上下文(Context)
-- 状态设置函数(State-changing Function)
-- 状态应用的函数(State-using Function)
+- 状态设置函数(State-changing Function): 该类函数将会改变上下文	
+- 状态应用的函数(State-using Function): 该类函数会根据当前OpenGL的状态执行一些操作。    
 
 ![image](https://github.com/CharonChui/Pictures/blob/master/opengl_state_machine.png?raw=true)
 
@@ -82,8 +106,9 @@ OpenGL是个状态机，有很多状态变量，是个标准的过程式操作
 OpenGL采用Client-Server模型来解释OpenGL程序，即Server存储OpenGL Context，Client提出渲染请求，Server给予响应。之后的渲染工作就要依赖这些渲染状态信息来完成，当一个上下文被销毁时，它所对应的OpenGL渲染工作也将结束。
 
 
-OpenGL ES API没有提及如何创建渲染上下文，或者渲染上下文如何连接到原生窗口系统。EGL是Khronos渲染API(如OpenGL ES)和原生窗口系统之间的接口。
+OpenGL ES API没有提及如何创建渲染上下文，或者渲染上下文如何连接到原生窗口系统。    
 
+EGL是Khronos渲染API(如OpenGL ES)和原生窗口系统之间的接口。
 ### 对象
 OpenGL在开发的时候引入了一些抽象层，对象(Object)就是其中的一个。 
 
@@ -95,12 +120,26 @@ OpenGL在开发的时候引入了一些抽象层，对象(Object)就是其中的
 ```	C
 struct object_Window_Target {
     float set_window_size;    // 这里调用的是OpenGL提供的设置窗口大小的某个方法
-    float set_window_color;   // 这里调用的事OpenGL提供的设置窗口颜色位数的某个方法
-        ....
+    float set_window_color;   // 这里调用的是OpenGL提供的设置窗口颜色位数的某个方法
+    ....
 }
 ```
 
-通常把OpenGL上下文比作一个大的结构体，包含很多子集。  
+
+但是，这样也有问题:        
+
+- 当前状态只有一份，如果每次显示不同的效果，都重新配置会很麻烦。 
+- 这时候我们就需要一些小助理(对象)，来帮忙记录某些状态信息，以便复用。  
+
+如果我们有10种子集，那就需要10个小助理(对象)，而当前状态(Context，只有一份)可以通过装配这些对象来完成。 
+
+![image](https://github.com/CharonChui/Pictures/blob/master/opengl_zhuli.jpg?raw=true)
+
+
+通常把OpenGL上下文比作一个大的结构体，包含很多子集。
+
+在OpenGL中一个对象是指一些选项的集合，它代表OpenGL状态的一个子集。     
+比如，我们可以用一个对象来代表绘制窗口的设置，之后我们就可以设置它的大小等。      
 
 ```C
 // OpenGL的状态
@@ -111,20 +150,48 @@ struct OpenGL_Context {
 }
 ```
 
-但是，这样也有问题:        
 
-- 当前状态只有一份，如果每次显示不同的效果，都重新配置会很麻烦。 
-- 这时候我们就需要一些小助理(对象)，来帮忙记录某些状态信息，以便复用。  
 
-如果我们有10中子集，那就需要10个小助理(对象)，而当前状态(Context，只有一份)，可以通过装配这些对象来完成。 
+```c++
+// 创建对象    
+unsigned int objectId = 0;
+glGenObject(1, &objectId);
 
-![image](https://github.com/CharonChui/Pictures/blob/master/opengl_zhuli.jpg?raw=true)
+// 绑定对象至上下文
+glBindObject(GL_WINDOW_TARGET, objectId);
+// 设置当前绑定到GL_WINDOW_TARGET的对象的一些选项
+glSetObjectOption(GL_WINDOW_TARGET, GL_OPTION_WINDOW_WIDTH, 800);
+glSetObjectOption(GL_WINDOW_TARGET, GL_OPTION_WINDOW_HEIGHT, 600);
+// 将上下文对象设回默认
+glBindObject(GL_WINDOW_TARGET, 0);
+```
+上面这一小段代码展示了以后使用OpenGL时常见的工作流。    
+
+- 我们首先创建一个对象，然后用一个id保存它的引用(实际数据被存储在后台)。     
+- 然后我们将对象绑定至上下文的目标位置(例子中窗口对象目标的位置被定义成GL_WINDOW_TARGET)     
+- 接下来我们设置窗口的选项。     
+- 最后我们将目标位置的对象id设回0，解绑这个对象。   
+
+**设置的选项将被保存在objectId所引用的对象中，一旦我们重新绑定这个对象到GL_WINDOW_TARGET位置，这些选项就会重新生效。**      
+
+使用对象的一个好处是在程序中，我们不止可以定义一个对象，并设置它们的选项，每个对象都可以是不同的设置。     
 
+在我们执行一个使用OpenGL状态的操作的时候，只需要绑定含有需要的设置的对象即可。       
 
 
 
 ###  渲染管线
 
+
+渲染管线有时也称为渲染流水线，一般由显示芯片(GPU)内部处理图形信号的并行处理单元组成。      
+这些并行处理单元两两之间是相互独立的，在不同型号的硬件上独立处理单元的数量也有很大的差异。一般越高端型号的硬件，其中独立处理单元的数量也就越多。   
+
+
+与普通应用程序通过CPU串行执行不同的是，渲染工作是通过渲染管线由多个相互独立的处理单元进行并行处理的，这种模式极大的提升了渲染效率。  
+
+从另一个角度看，OpenGLES中的渲染管线实际上指的是一系列绘制过程。   
+这些过程输入的是待渲染3D物体的相关描述信息数据，经过渲染管线，输出的是一帧想要的图像。      
+
 在OpenGL中，任何事物都在3D空间中，而屏幕和窗口却是2D像素数组，这导致OpenGL的大部分工作都是关于把3D坐标转变为适应你屏幕的2D像素。        
 
 3D坐标转为2D坐标的处理过程是由OpenGL的图形渲染管线（Graphics Pipeline，大多译为管线，实际上指的是一堆原始图形数据途经一个输送管道，期间经过各种变化处理最终出现在屏幕的过程）管理的。        
@@ -168,7 +235,10 @@ OpenGL ES 3.0实现了具有可编程着色功能的图形管线，有两个规
 而顶点数据是用顶点属性(Vertex Attribute)表示的，它可以包含任何我们想用的数据，但是简单起见，我们还是假定每个顶点只由一个3D位置和一些颜色值组成的吧。
 
 
-### 立即渲染模式(Immediate mode) && 核心模式(Core-profile)
+
+
+### 立即渲染模式(Immediate mode) && 核心模式(Core-profile)       
+
 早期的OpenGL使用立即渲染模式（Immediate mode，也就是固定渲染管线），这个模式下绘制图形很方便。OpenGL的大多数功能都被库隐藏起来，开发者很少有控制OpenGL如何进行计算的自由。而开发者迫切希望能有更多的灵活性。随着时间推移，规范越来越灵活，开发者对绘图细节有了更多的掌控。立即渲染模式确实容易使用和理解，但是效率太低。因此从OpenGL3.2开始，规范文档开始废弃立即渲染模式，并鼓励开发者在OpenGL的核心模式(Core-profile)下进行开发，这个分支的规范完全移除了旧的特性。
 
 当使用OpenGL的核心模式时，OpenGL迫使我们使用现代的函数。当我们试图使用一个已废弃的函数时，OpenGL会抛出一个错误并终止绘图。现代函数的优势是更高的灵活性和效率，然而也更难于学习。立即渲染模式从OpenGL实际运作中抽象掉了很多细节，因此它在易于学习的同时，也很难让人去把握OpenGL具体是如何运作的。现代函数要求使用者真正理解OpenGL和图形编程，它有一些难度，然而提供了更多的灵活性，更高的效率，更重要的是可以更深入的理解图形编程。
@@ -181,9 +251,15 @@ OpenGL ES 3.0实现了具有可编程着色功能的图形管线，有两个规
 
 ### 依赖库
 
+OpenGL实际上并不是把图像直接绘制到计算机屏幕上，而是将之渲染到一个帧缓冲区。    
+然后由计算机来负责把帧缓冲区中的内容绘制到屏幕上的一个窗口中。有不少库都可以支持这一部分工作:     
+
+- 使用操作系统提供的窗口管理功能，比如Microsoft Windows API。但这通常不实用，因为需要很多底层的编码工作。   
+- FreeGLUT、GLOW、GLFW等库
+
+
 简要来说，GLAD、GLEW都是一个图形库，可以理解为是在显卡驱动上给渲染用户一个统一的API；   
 而GLUT、FreeGLUT、GLFW这三个是用于图形开发的辅助工具库，主要用于创建和管理OpenGL环境、操作窗口等。
-
 OpenGL只是一个标准/规范，具体的实现是由驱动开发商针对特定显卡实现的。但是在你真正能够在程序中使用OpenGL之前，你需要对他进行初始化，但是由于OpenGL是跨平台的，所以也没有一个标准的方式进行初始化。OpenGL初始化分为两个阶段：
 
 - 第一个阶段，你需要创建一个OpenGL上下文环境，这个上下文环境存储了所有与OpenGL相关的状态（OpenGL是一个状态机），上下文位于操作系统中某个进程中，一个进程可以创建多个上下文，每一个上下文都可以描绘一个不同的可视界面，就像应用程序中的窗口；简单来理解就是为了创建一个窗口；而GLUT、FreeGLUT、GLFW库就是用于干这件事的。
@@ -228,6 +304,8 @@ GLFW是一个专门针对OpenGL的C语言库，它提供了一些渲染物体所
 它把一个单独的顶点作为输入。顶点着色器主要的目的是把3D坐标转为另一种3D坐标（后面会解释）从而生成每个顶点的最终位置，同时顶点着色器允许我们对顶点属性进行一些基本处理。
 
 
+所有顶点着色器的主要目标都是将顶点发送给管线(正如之前所说的它会对每个顶点进行处理)。
+
 顶点着色器可以操作的属性有: 位置、颜色、纹理坐标，但是不能创建新的顶点。最终产生纹理坐标、颜色、点位置等信息送往后续阶段。
 
 顶点着色器会在GPU上创建内存用于存储我们的顶点数据，还要配置OpenGL如何解释这些内存，并且指定其如何发送给显卡。顶点着色器接着会处理我们在内存中指定数量的顶点。
@@ -286,9 +364,22 @@ Java使用:
 ```java
 GLES30.glBindBuffer(GLES30.GL_ARRAY_BUFFER, vbo.get(0));
 ```
-从这一刻起，我们使用的任何(在GL_ARRAY_BUFFER目标上的)缓冲调用都会用来配置当前绑定的缓冲(VBO)。      
+从调用glBindBuffer()这一刻起，我们使用的任何(在GL_ARRAY_BUFFER目标上的)缓冲调用都会用来配置当前绑定的缓冲(VBO)。      
 然后我们可以调用glBufferData()函数，它会把之前定义的顶点数据复制到缓冲的内存中(小助理把对应的数据单独记录下来了)。   
-      
+     
+
+
+绑定对象的过程有点类似设置铁路的道岔开关。     
+一旦设置了开关，从这条线路通过的所有列车都会驶向对应的轨道。    
+如果我们将开关设置到另一个状态，那么所有之后经过的列车都会驶向另一条轨道。OpenGL的对象也是如此。     
+
+总体上来说，在两种情况下我们需要绑定一个对象:   
+- 创建对象并初始化它所对应的数据是。   
+- 每次我们准备使用这个对象，而它并不是当前绑定的对象时。   
+
+
+
+ 
 ```C
 // glBufferData creates a new data store for the buffer object currently bound to target. 
 // glBufferData为当前绑定到的目标缓冲区对象创建一个新的数据存储
@@ -340,8 +431,15 @@ glBufferData是一个专门用来把用户定义的数据复制到当前绑定
     - OpenGL允许我们同时绑定多个缓冲，只要它们是不同的缓冲类型(每一个缓冲类型类似于前面说的子集，每个VBO是一个小助理)。
 
 - 配置OpenGL如何解释这些内存            
-    通过顶点数组对象(Vertex Array Objects, VAO）来管理，数组中的每一个项都对应一个属性的解析。        
-    **注意: VAO并不保存实际数据，而是放顶点结构的定义**
+
+
+通过顶点数组对象(Vertex Array Objects, VAO）来管理，数组中的每一个项都对应一个属性的解析。       
+
+VAO（Vertex Array Object）是指顶点数组对象，主要用于管理 VBO 或 EBO ，减少 glBindBuffer 、glEnableVertexAttribArray、 glVertexAttribPointer 这些调用操作，高效地实现在顶点数组配置之间切换。
+
+ **注意: VAO并不保存实际数据，而是放顶点结构的定义** 
+
+
 
 ![image](https://github.com/CharonChui/Pictures/blob/master/vao_vbo.jpg?raw=true)
 
@@ -355,7 +453,7 @@ OpenGLES3.0 VBO和EBO的出现就是为了解决这个问题。VBO和EBO的作
 
 把数据发送给OpenGL管线还要更加复杂一点，有两种方式:    
 
-- 通过顶点属性的缓冲区；
+- 通过顶点属性的缓冲区。
 - 直接发送给统一变量。
 
 理解这两种方式的机制非常重要，因为这样我们才能为每个要发送的项目选取合适的方式。  
@@ -421,13 +519,29 @@ OpenGL中最基础且唯一的多边形就是三角形，所有更复杂的图
 
 ### 片段着色器或片元着色器(Fragment Shader)
 
+
+显示设备屏幕都是离散化的(由一个一个的像素组成)，因此还需要将投影的结果离散化。    
+将其分解为一个个离散化的小单元，这些小单元一版称为片元。    
+
+其实每个片元都对应于帧缓冲中的一个像素，之所以不直接称为像素是因为3D空间中的物体是可以相互遮挡的。而一个3D场景最终显示到屏幕上虽然是一个整体，但每个3D物体的每个图元是独立处理的。这就可能出现这样的情况，系统先处理的是位于离观察点较远的图元，其光栅化成为了一组图元，暂时送入帧缓冲的对应位置。    
+
+但后面继续处理离观察点较近的图元时也光栅化出了一组片元，两组片元中有对应到帧缓冲中同一个位置的，这时距离近的片元将覆盖距离远的片元(如何覆盖的检测是在深度检测阶段完成的)。      
+
+因此，某片元就不一定能成为最终屏幕上的像素，称为像素就不准确了，可以将其理解为候选像素。    
+
 使用颜色或纹理(texture)渲染图形表面的OpenGLES代码。
 
-主要目的是计算一个像素的最终颜色。         
 
-光栅化操作构造了像素点，这个阶段就是处理这些像素点，根据自己的业务，例如高亮、饱和度调节、高斯模糊等来变化这个片元的颜色。      
+我们3D世界中的点、三角形、颜色等全都需要展现在一个2D显示器上。      
+这个2D屏幕由栅格(即矩形像素阵列)组成。当3D物体栅格化后，OpenGL会将物体中的图元(通常是三角形)转化为片段。    
+片段拥有关于像素的信息。栅格化过程确定了为了显示由3个顶点确定的三角形需要绘制的所有像素的位置。片段着色器用于为栅格化的像素指定颜色。    
+
+主要目的是计算一个像素的最终颜色。      
+所有片段着色器的目的都是给为要展示的像素赋予颜色。              
+
+光栅化操作构造了像素点(图元(点或三角形)转换成了像素的集合)，这个阶段就是处理这些像素点，根据自己的业务，例如高亮、饱和度调节、高斯模糊等来变化这个片元的颜色。      
 为组成点、直线和三角形的每个片元生成最终颜色/纹理，针对每个片元都会执行一次，一个片元是一个小的、单一颜色的长方形区域，类似于计算机屏幕上的一个像素。        
-一旦最终颜色生成，OpenGL就会把它们写到一块成为帧缓冲区的内存块中，然后Android就会把这个帧缓冲区显示到屏幕上。
+一旦最终颜色生成，OpenGL就会把它们写到一块称为帧缓冲区的内存块中，然后Android就会把这个帧缓冲区显示到屏幕上。
 
 通常在这里对片段进行处理(纹理采样、颜色汇总等)，将每个片段的颜色等属性计算出来并送给后续阶段。
 
@@ -435,6 +549,11 @@ OpenGL中最基础且唯一的多边形就是三角形，所有更复杂的图
 
 **在现代OpenGL中，我们必须定义至少一个顶点着色器和一个片段着色器（因为GPU中没有默认的顶点/片段着色器）。**  
 
+
+光栅化后产生了多少个片元，就会插值计算出多少套in变量。同时，渲染管线就会调用多少次片元着色器。可以看出，一般情况下对一个3D物体的渲染中，片元着色器执行的次数会大大超过顶点着色器。
+
+因此，GPU硬件中配置的片元着色器硬件数量往往多于顶点着色器硬件数量，通过这些硬件单元的并行执行，提高渲染速度。
+
 整个处理过程又分为以下几个部分:     
 
 - 逐片段操作
@@ -467,6 +586,9 @@ OpenGL中最基础且唯一的多边形就是三角形，所有更复杂的图
 
 ### 帧缓冲区
 
+像素(pixel)是显示器上最小的可见单元。计算机系统将所有的像素保存到帧缓存(framebuffer)当中，后者是由图形硬件设备管理的一块独立内存区域，可以直接映射到最终的显示设备上。     
+
+
 OpenGL实际上并不是把图像直接绘制到计算机屏幕上，而是将之渲染到一个帧缓冲区，然后由计算机来负责把帧缓冲区中的内容绘制到屏幕上的一个窗口中。            
 
 OpenGL管线的最终渲染目的地被称为帧缓存(framebuffer也被记做FBO)
@@ -480,6 +602,8 @@ GLSL(OpenGL Shading Language)是OpenGL着色语言。
   - 顶点着色器(Vertex Shader)
   - 片段着色器(Fragment Shader)
 
+通常在CPU上编译、链接成二进制数据，然后将它拷贝到GPU上运行，在GPU上运行起来的就是渲染、合成的命令。它的编译是通过OpenGL API操作的。     
+
 ### 坐标系
 
 OpenGL ES是一个3D的世界，由x、y、z坐标组成顶点坐标。采用虚拟的右手坐标。
@@ -503,6 +627,8 @@ OpenGL采用的是右手坐标，选取屏幕中心为原点，从原点到屏
 
 如果想要绘制图像，需要至少一个顶点着色器来定义一个图形顶点，以及一个片元着色器为该图形上色。这些着色器必须被编译然后再添加到一个OpenGL Program中，并利用这个Program来绘制形状。
 
+glUseProgram()用于将含有两个已编译着色器的程序载入OpenGL管线阶段(在GPU上)。   
+注意，glUseProgram()并没有运行着色器，它只是将着色器加载进硬件。   
 
 ### EGL
 
@@ -519,7 +645,7 @@ EGL是OpenGL和本地窗口系统（Native Window System）之间的通信接口
 - 创建绘图表面；
 - 在OpenGL ES 和其他图形渲染API之间同步渲染；
 - 管理纹理贴图等渲染资源。
-OpenGL ES 的平台无关性正是借助 EGL 实现的，EGL 屏蔽了不同平台的差异（Apple 提供了自己的 EGL API 的 iOS 实现，自称 EAGL）。
+OpenGL ES 的平台无关性正是借助 EGL 实现的，EGL 屏蔽了不同平台的差异。
 
 ![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/egl_interface_1.png?raw=true)
 
@@ -566,11 +692,21 @@ EGL为双缓冲工作模式(Double Buffer)，既有一个Back Frame Buffer和一
 
 6. 设置OpenGL的渲染环境
 
-   eglMakeCurrent(EGLDisplay display, EGLSurface draw, EGLSurface read, EGLContext context);该方法的参数意义很明确，该方法在异步线程中被调用，该线程也会被成为GL线程，一旦设定后，所有OpenGL渲染相关的操作都必须放在该线程中执行。
+   eglMakeCurrent(EGLDisplay display, EGLSurface draw, EGLSurface read, EGLContext context);该方法的参数意义很明确，该方法在异步线程中被调用，该线程也会被称为GL线程，一旦设定后，所有OpenGL渲染相关的操作都必须放在该线程中执行并且指定OpenGL绘制的结果最后输出到这个EGLSurface上。    
 
 通过上述操作，就完成了EGL的初始化设置，便可以进行OpenGL的渲染操作。所有EGL命令都是以egl前缀开始，对组成命令名的每个单词使用首字母大写(如eglCreateWindowSurface)。
 
+
+简单总结:    
+
+- EGLDisplay: 代表物理屏幕，可能支持多种配置(EGLConfig)
+- EGLContext: 线程相关上下文环境，存储数据如图片、顶点、着色器等，使用的时候只需要拿他们的id取用。  
+- EGLSurface: 绘制的模板Surface，用于指定在哪个view上显示OpenGL的绘制结果  
+
+
+
 #### 创建屏幕外渲染区域: EGL Pbuffer
+
 除了可以用OpenGL在屏幕上的窗口渲染之外，还可以渲染称作pbuffer(像素缓冲区Pixel buffer的缩写)的不可见屏幕外表面。          
 和窗口一样，Pbuffer可以利用OpenGL ES3.0中的任何硬件加速。      
 Pbuffer最常用于生成纹理贴图。如果你想要做的是渲染到一个纹理，那么我们建议使用帧缓冲区对象代替Pbuffer，因为帧缓冲区更高效。不过，在某些帧缓冲区对象无法使用的情况下，Pbuffer仍然有用，例如用OpenGL ES在屏幕外表面上渲染，然后将其作为其他API(如OpenVG)中的纹理。     
@@ -583,9 +719,20 @@ Pbuffer最常用于生成纹理贴图。如果你想要做的是渲染到一个
 纹理(Texture)是一个2D图片(也有1D和3D纹理)，他可以用来添加物体的细节，你可以想象纹理是一张绘有砖块的纸，无缝折叠贴合到你的3D房子上，这样你的房子看起来就有砖墙的外表了。
 
 
-Android 通过其框架 API 和原生开发套件 (NDK) 来支持 OpenGL。
+#### 视频数据流
 
-Android 框架中有如下两个基本类，用于通过 OpenGL ES API 来创建和操控图形：`GLSurfaceView` 和 `GLSurfaceView.Renderer`。
+视频从视频文件到屏幕显示出来，Surface起到了非常重要的作用，在视频解码时，需要一个Surface作为已解码数据的载体，保存播放器解码后的数据。       
+
+在显示时，需要另一个Surface作为已渲染数据的载体，保存OpenGL渲染后的数据，最后通过EGL显示在屏幕上。   
+
+数据流如下图所示:   
+
+![image](https://github.com/CharonChui/Pictures/blob/master/video_display_process.webp?raw=true)
+
+- 解码器(MediaCodec或FFmpeg等)将视频文件中的视频编码数据解码成图像流放到Surface中。
+- SurfaceTexture把Surface生成的图像流，转换为纹理
+- OpenGL ES渲染纹理生成图形数据，放到GLSurfaceView中的Surface中
+- EGL从Surface中取出图形数据，显示到屏幕上
 
 
 ### 参考
@@ -598,9 +745,9 @@ Android 框架中有如下两个基本类，用于通过 OpenGL ES API 来创建
 
 
 
+--- 
 
-
-[下一篇: 2.GLSurfaceView简介](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/2.GLSurfaceView%E7%AE%80%E4%BB%8B.md)
+- [下一篇: 2.GLSurfaceView简介](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/2.GLSurfaceView%E7%AE%80%E4%BB%8B.md)
 
 ---
 
diff --git "a/VideoDevelopment/OpenGL/10.GLSurfaceView+MediaPlayer\346\222\255\346\224\276\350\247\206\351\242\221.md" "b/VideoDevelopment/OpenGL/10.GLSurfaceView+MediaPlayer\346\222\255\346\224\276\350\247\206\351\242\221.md"
index c1c347da..0eb4f1b9 100644
--- "a/VideoDevelopment/OpenGL/10.GLSurfaceView+MediaPlayer\346\222\255\346\224\276\350\247\206\351\242\221.md"
+++ "b/VideoDevelopment/OpenGL/10.GLSurfaceView+MediaPlayer\346\222\255\346\224\276\350\247\206\351\242\221.md"
@@ -325,9 +325,10 @@ public class VideoPlayerRender extends BaseGLSurfaceViewRenderer {
 
 
 
+---
+- [上一篇: 9.OpenGL ES纹理](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/9.OpenGL%20ES%E7%BA%B9%E7%90%86.md)  
 
-[上一篇: 9.OpenGL ES纹理](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/9.OpenGL%20ES%E7%BA%B9%E7%90%86.md)  
-[下一篇: 11.OpenGL ES滤镜](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/11.OpenGL%20ES%E6%BB%A4%E9%95%9C.md)
+- [下一篇: 11.OpenGL ES滤镜](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/11.OpenGL%20ES%E6%BB%A4%E9%95%9C.md)
 
 ---
 
diff --git "a/VideoDevelopment/OpenGL/11.OpenGL ES\346\273\244\351\225\234.md" "b/VideoDevelopment/OpenGL/11.OpenGL ES\346\273\244\351\225\234.md"
index e76e826e..ac2ff34d 100644
--- "a/VideoDevelopment/OpenGL/11.OpenGL ES\346\273\244\351\225\234.md"	
+++ "b/VideoDevelopment/OpenGL/11.OpenGL ES\346\273\244\351\225\234.md"	
@@ -401,7 +401,10 @@ public class BaseFilter {
 
 
 
-[上一篇: 10.GLSurfaceView+MediaPlayer播放视频](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/10.GLSurfaceView%2BMediaPlayer%E6%92%AD%E6%94%BE%E8%A7%86%E9%A2%91.md)
+---
+- [上一篇: 10.GLSurfaceView+MediaPlayer播放视频](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/10.GLSurfaceView%2BMediaPlayer%E6%92%AD%E6%94%BE%E8%A7%86%E9%A2%91.md)
+
+- [下一篇: 12.FBO](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/12.FBO.md)
 
 ---
 
diff --git a/VideoDevelopment/OpenGL/12.FBO.md b/VideoDevelopment/OpenGL/12.FBO.md
index 4a9632fb..569ff910 100644
--- a/VideoDevelopment/OpenGL/12.FBO.md
+++ b/VideoDevelopment/OpenGL/12.FBO.md
@@ -1,14 +1,119 @@
 ## 12.FBO
 
+
+### 什么是 EGL
+
+EGL 是 OpenGL ES 和本地窗口系统（Native Window System）之间的通信接口，它的主要作用:      
+
+- 与设备的原生窗口系统通信；
+
+- 查询绘图表面的可用类型和配置；
+
+- 创建绘图表面；
+
+- 在OpenGL ES 和其他图形渲染API之间同步渲染；
+
+- 管理纹理贴图等渲染资源。
+
+OpenGL ES 的平台无关性正是借助 EGL 实现的，EGL 屏蔽了不同平台的差异（Apple 提供了自己的 EGL API 的 iOS 实现，自称 EAGL）。
+
+本地窗口相关的 API 提供了访问本地窗口系统的接口，而 EGL 可以创建渲染表面 EGLSurface ，同时提供了图形渲染上下文 EGLContext，用来进行状态管理
+
+
+当前屏幕渲染(onscreen rendering)和离屏渲染(offscreen rendering) 默认的测试其实就是onscreen rendering，顾名思义，渲染的场景是需要呈现在屏幕上眼睛可见的，而offscreen则是不需要呈现的。 当前屏幕渲染绘制流程是:    
+
+``` 
+eglCreateXXXSurface 
+eglCreateContext 
+Draw 
+eglSwapbuffers 
+``` 
+
+离屏渲染流程则是:     
+
+``` 
+glGenFramebuffers 
+glBindFramebuffer
+glFramebufferTexture2D/glFramebufferRenderbuffer
+Draw
+glFlush (or internal flush)
+```
+
+
+我们知道eglSwapbuffer是为了把EGL当前渲染的surface给呈现到屏幕上，glFlush是为了把GLES当前渲染的结果绘制到和FBO绑定的Texture或者Render Buffer里面。所以简单的说，onscreen rendering是EGL surface的渲染，而offscreen rendering是GLES FBO的渲染。
+
+
+
+当然并不是所有的EGL surface都是onscreen的，一个例外就是EGL pbuffer surface，这是EGL为了offscreen rendering专门定制的。
+
+
+
+### Onscreen和Offscreen的关系
+
+
+
+那么问题来了，这两者到底有什么关系呢？
+
+下图是一个benchmark某一帧的流程图，
+
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/onscreen_offscreen.webp?raw=true)
+
+
+
+图中的FBO0是最终的屏幕渲染输出，而其他用于离屏渲染的FBO都是为了叠加最后的Blur效果和提供背景模版。通常对于复杂的场景，最终的onscreen rendering是由众多的offscreen rendering的结果组合而成的。
+
+Offscreen有什么好处吗
+
+
+
+Onscreen rendering的一个限制因素是当前屏幕的分辨率，比如显示器最多只支持1080p，那么EGL surface大小最大只能是1080p。而offscreen rendering则宽松多了，它只受GPU硬件本身的限制，通常可以支持4K分辨率。所以如果需要不同于当前屏幕分辨率的渲染，反锯齿或者添加新的renderpass，通常会先渲染到offscreen来获取更好的渲染效果。
+
+
+
+因为offscreen是不可见的，GPU可能会有一定的优化。举个例子，原点(0, 0)对于DirectX来讲，通常在左上角，而对于OpenGLES则在左下角。如果GPU是为DirectX设计的，GPU默认的(0, 0)当然是左上角，那么对于OpenGLES的onscreen rendering，就需要做一个Y坐标的翻转，让原点从左下角映射到左上角。然而对于offscreen rendering，GPU就可以默认其原点在左上角，从而避免坐标转换的损耗。
+
+
+
+
+
 FBO（Frame Buffer Object）即帧缓冲区对象，实际上是一个可添加缓冲区的容器，可以为其添加纹理或渲染缓冲区对象（RBO）。
 
+
+顾名思义，它就是能缓存一帧的这么个东西，它有什么用呢？     
+
+大家回想我们之前的教程，我们都是通过一次渲染把内容渲染到屏幕(严格来说是渲染到GLSurfaceview上)。      
+如果我们的渲染由多个步骤组成，而每个步骤的渲染结果会给到下一个步骤作为输入，那么就要用到frame buffer。      
+
+比如一个效果：先把图片的蓝色通道全都设置为0.5，得到的结果再去做一个水平方向的模糊，这时渲染过程就由2步组成，第一步的操作不应该显示到屏幕上，应该有个地方存着它的结果，作为第二步的输入，然后第二步的渲染结果才直接显示到屏幕上。实际上这两步可以合成一步，大家可以思考一下如何用一步实现，这里分成两步主要是为了展示如果使用frame buffer。
+
+
+FBO从名字上看，往往很容易让人误解这是一个缓存空间，但实际上，FBO很重要的在后面的Object上。    
+
+这是一个缓存对象，包含了多个缓冲索引，分别是颜色缓冲(Color buffers)、深度缓冲(Depth buffer)、模板缓冲(Stencil buffer)。之所以说是缓冲索引，是因为FBO并不包含这些缓冲数据，仅仅保存了缓冲数据的索引地址。    
+
+FBO和这些缓冲区则通过附着点进行连接。     
+
+frame buffer本身其实并不会存储数据，都是通过attachment去绑定别的东西来存储相应的数据，我们今天要讲的就是color attachment，我们会将frame buffer中的一个attachment绑定到一个texture上，然后先将第一步的效果渲染到这个frame buffer上作为中间结果，然后将这个texture作为第二步的输入。
+
+
 FBO本身不能用于渲染，只有添加了纹理或者渲染缓冲区之后才能作为渲染目标，它仅且提供了3种附着（Attachment），分别是颜色附着、深度附着和模板附着。
 
+只有color buffer用于最后的像素显示，其他的都是用来辅助fragment的处理。
+
+
 RBO（Render Buffer Object）即渲染缓冲区对象，是一个由应用程序分配的2D图像缓冲区。渲染缓冲区可以用于分配和存储颜色、深度或者模板值，可以用作FBO中的颜色、深度或者模板附着。
 
 使用FBO作为渲染目标时，首先需要为FBO的附着添加连接对象，如颜色附着需要连接纹理或者渲染缓冲区对象的颜色缓冲区。
 
 
+FBO可以绑定到纹理对象或者RenderBuffer对象，RenderBuffer是以内部格式存储的经过渲染优化的对象，它的渲染速度更快，缺点是无法对渲染进果进行重采样。如果不需要对FBO的输出再做下一步采样处理，就可以用RenderBuffer。在我们的例子中，因为我们要暂存相机流处理着色器的渲染结果，并作为灰度黑着色器程序的输入，即要对此输出结果进行采样，所以我们必须要用FBO绑定纹理对象的方式。
+
+
+GLSurfaceView的onDrawFrame回调中，默认是绑定了window系统生成的FBO的，这个FBO对应屏幕显示，即0号FBO。只要我们中间不切换FBO，所有的glDrawArray或glDrawElements指令调用都是将目标渲染到这个0号FBO的。
+
+
+
+
 #### 为什么用 FBO
 
 默认情况下，OpenGL ES通过绘制到窗口系统提供的帧缓冲区，然后将帧缓冲区的对应区域复制到纹理来实现渲染到纹理，但是此方法只有在纹理尺寸小于或等于帧缓冲区尺寸才有效。       
@@ -20,9 +125,83 @@ Android OpenGL ES开发中，一般使用GLSurfaceView将绘制结果显示到
 使用FBO可以让渲染操作不用再渲染到屏幕上，而是渲染到离屏Buffer中，然后可以使用glReadPixels或者HardwareBuffer将渲染后的图像数据读出来，从而实现在后台利用GPU完成对图像的处理。
 
 
+在OpenGL ES中，调用: 
+```java
+GLES20.glBindFramebuffer(GLES20.GL_FRAMEBUFFER, 0);
+```
+表示将当前的帧缓冲绑定切换回默认帧缓冲，即屏幕帧缓冲。这意味着后续的绘图操作将直接渲染到屏幕，而不是一个自定义的 FrameBuffer Object (FBO)。
+
+1. 默认帧缓冲
+	•	默认帧缓冲由 OpenGL 创建，并与窗口系统关联。
+	•	默认帧缓冲的内容直接显示在屏幕上。
+	•	调用 glBindFramebuffer 将目标设置为 0 时：
+	•	GL_FRAMEBUFFER 绑定到默认的屏幕渲染目标。
+
+2. 切换渲染目标
+
+在 OpenGL 中，你可以使用自定义的帧缓冲对象（FBO）来进行离屏渲染，例如将渲染结果存储到纹理或处理后的数据中。当你完成对自定义 FBO 的渲染任务后，通常需要将绑定切换回默认帧缓冲，这样后续的渲染操作会直接绘制到屏幕。
+
+3. 操作流程
+
+通常操作流程如下：
+	1.	创建并绑定 FBO，进行离屏渲染。
+	2.	渲染完成后，解绑 FBO，将绘图切换回屏幕。
+	3.	渲染其他内容或将离屏渲染的结果作为纹理在屏幕上显示。
+
+示例代码：
+
+```java
+// 绑定自定义 FBO，进行离屏渲染
+GLES20.glBindFramebuffer(GLES20.GL_FRAMEBUFFER, customFbo);
+renderToTexture();
+
+// 解绑 FBO，切换回屏幕渲染
+GLES20.glBindFramebuffer(GLES20.GL_FRAMEBUFFER, 0);
+renderToScreen();
+```
+
+ 解除FBO绑定，将窗口大小、纹理坐标、矩阵都恢复回原来的配置。
+将渲染重新切换到原来的系统窗口上，画面将重新显示到系统窗口上。
+
 
+作用场景
+
+1. 屏幕显示
+
+完成离屏渲染后，使用默认帧缓冲可以将最终结果显示到屏幕上。
+
+2. 渲染链切换
+
+当使用多个渲染目标（如多个 FBO）时，通过解绑 FBO，可以轻松地切换回屏幕渲染或默认的绘图目标。
+
+3. 调试和测试
+
+解绑 FBO 也方便直接在屏幕上观察渲染结果，便于调试。
+
+
+
+
+首先，Fbo 的概念性的东西，大家可以上网查查，这里就直接说说Fbo的作用
+
+Oes纹理转换2D纹理
+
+预览相机、播放视频等这些通过SurfaceTexture方式渲染的，一般都是使用Oes纹理，而当需要在相机预览或者播放视频中添加水印/贴纸，则需要先将Oes纹理转化成2D纹理，因为Oes纹理和2D纹理是不能同时使用
+
+保留帧
+
+让当前渲染的纹理保留在一个帧缓存里，而不显示在屏幕上
+
+
+
+
+
+
+
+
+---
+- [上一篇: 11.OpenGL ES滤镜](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/11.OpenGL%20ES%E6%BB%A4%E9%95%9C.md)
 
-[上一篇: 10.GLSurfaceView+MediaPlayer播放视频](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/10.GLSurfaceView%2BMediaPlayer%E6%92%AD%E6%94%BE%E8%A7%86%E9%A2%91.md)
+- [下一篇: 13.LUT滤镜](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/13.LUT%E6%BB%A4%E9%95%9C.md)
 
 ---
 
diff --git "a/VideoDevelopment/OpenGL/13.LUT\346\273\244\351\225\234.md" "b/VideoDevelopment/OpenGL/13.LUT\346\273\244\351\225\234.md"
new file mode 100644
index 00000000..d02b6e97
--- /dev/null
+++ "b/VideoDevelopment/OpenGL/13.LUT\346\273\244\351\225\234.md"
@@ -0,0 +1,261 @@
+# 13.LUT滤镜
+
+
+LUT全称Look Up Table，也称为颜色查找表。       
+
+它代表的是一种映射关系，通过LUT可以将输入的像素数组通过映射关系转换输出成另外的像素数组。     
+
+比如一个像素的颜色值分别是R1 G1 B1，经过一次LUT操作后变为R2 G2 B2。    
+
+
+LUT从查找方式上可以分为1D LUT和3D LUT:     
+
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/lut_1dvs3d.webp)
+
+- 1D LUT
+
+对于一张RGB图像，每个通道都可以作为一个输入，用公式可以描述如下:     
+
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/lut_1d.jpg)
+
+由于颜色值的范围是（0～255），我们可以用`256*3` 的表来表示一个1D LUT，在实际操作中，我们通常以一张`256*3*1`的图片来存储这个映射表，如下，这是一张1D LUT在Mac访达中文件信息图:    
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/lut_1d_map.jpg)
+
+由于1D LUT各个通道都是相互独立的，无法对其他通道产生影响，因此1D LUT只能用来调节亮度/伽马/饱和度/色彩平衡等，如果我们希望对其他通道产生影响，就需要了解另一种滤镜查找方式--3D LUT。    
+
+
+- 3D LUT
+
+3D LUT在滤镜中的影响比1D LUT更为深刻，假设上图3D中的红色平面发生移动，其中对应的绿色和蓝色分量也会发生改变，也就是说，一个颜色通道改变可以影响其他的颜色通道。      
+
+理论上3D LUT可以在立体色彩空间中描述所有颜色调整行为，所以它可以处理任何显示的非线性属性，从简单的gamma值、颜色范围和追踪错误，到修正高级的非线性属性、颜色串扰（去耦）、色相、饱和度、亮度等，3D LUT都可以胜任。
+
+
+常见的3D LUT滤镜文件与.cube或者.3dl都是把3D坐标二维化后的数据表现，如下图
+
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/3d_lut.jpg)
+
+
+我们看到的这些方格子里面的蓝色是固定的，然后每个格子横坐标是红色，纵坐标是绿色，最左上角的格子因为蓝色全无，所以红色和绿色就很明显，而最右下角的那个格子，蓝色色值达到最大，因此整体看上去就非常的蓝(从左上角的格子到右下角的格子，一共是8行8列，正好是64个格子)。
+
+
+### 为什么是64x64
+
+对于RGB颜色，每种颜色可以有256(0 ~ 255)种取值，而每个颜色占用3个字节，因此一个3D LUT如果全量表示的话，大小为`256*256*256*3`个字节，即48M内存空间。      
+
+如果我们有一个大小为`256*256*256*3`的3D LUT文件，那么颜色映射将非常简单，只要根据RGB的像素值按照用蓝色找到对应的格子，然后用红色和绿色找到对应格子的横列就可以找到映射的颜色值。
+
+但是通常情况下，我们不会这么干，因为一张图48M存储空间实在是太大了。
+
+如果要完全记录这种映射关系，设备需要耗费大量的内存，并且可能在计算时因为计算量大而产生性能问题， 为了简化计算量，降低内存占用，可以将相近的n种颜色采用一条映射记录并存储，(采样步长，n通常为4)，这样只需要`64 * 64 * 64 * 3`个字节就可以表示原来`256 * 256 * 256 * 3`的颜色数量，我们也将4称为采样步长。
+
+对于忽略的颜色值可以进行插值获得其相似结果。    
+
+在专业领域一般认为`16 * 16 * 16`的3D LUT足够适用于预览和监看。     
+`64 * 64 * 64`或者更大的3D LUT更适合渲染和调色。     
+
+
+### 3D LUT映射
+
+要想熟练使用LUT滤镜，我们首先要了解它是怎么建立颜色映射关系的， 我们看下以下这张图，这张图展示了在LUT中RBG颜色是如何实现映射关系的:  
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/3d_lut_convert_1.png)     
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/lut.jpg)
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/lut_rg.jpg)
+
+
+- LUT图在横竖方向上被分成了8 X 8一共64个小方格，每一个小方格内的B（Blue）分量为一个定值，64 个小方格一共表示了B分量的64种取值。
+
+- 对于每一个小方格，横竖方向又各自分为64个小格:以左上角为原点，横向小格的 R（Red）分量依次增加，纵向小格的 G（Green）分量依次增加
+
+
+**在使用上面这张LUT表的时候首选需要找对B分量对应的小格子，然后在找到的小格子上再计算出R分量和G分量的映射结果即可得到完整的RGB映射结果。**
+
+
+
+下面我们就以一个`64*64*64`的3D LUT为例，来说明一下3D LUT如何查找和使用的（用glsl来实现）:     
+
+- 整张图从左到右和从上到下为蓝色的渐变，每个小格子从左到右为红色渐变，从上到下为绿色渐变
+- 肉眼可见的有8*8个方格，假设整个图的范围我们定义为0.0~1.0 ，也就是说每个格子所表示的范围是1./8. = 0.125
+- 我们首先通过蓝色来查找我们在哪个方格，由于涉及到插值，因此通过蓝色进行查找的时候，可能不会那么幸运一定映射到整数的格子上面，因此我们需要通过向下取整和向上进位两种方式来获取蓝色所对应的方格，然后通过蓝色的颜色值来mix这两种的颜色值，从而获取最终的颜色值。   
+
+
+### 映射示例
+
+
+#### 1.1 寻找B值的两个格子
+
+B值对应的是0 ~ 63，共64个格子，在计算时，并不一定会是一个整数，对应到某一个格子，大概率会是一个小数，为了能够更精确的进行映射，需要使用两个格子，然后根据小数(因子)进行插值计算，从而能够更精确。    
+
+##### 蓝色值用来定位两个相邻的小格子
+
+- 首先是对原图进行像素采样
+
+```glsl
+vec4 textureColor = texture(s_texture, v_texCoord);
+```
+
+textureColor.b是一个0 - 1之间的浮点数，乘以63用来确定B分量所在的格子.       
+因为会出现浮点误差，所以才需要取两个B分量，也就是下一步的取与B分量值最接近的2个小方格的坐标，最后根据小数点进行插值运算。
+
+
+- 第一个小格子:         
+
+```python
+vec4 color = texture(s_texture, v_texCoord);
+float blueColor = color.b * 63.0;
+
+vec2 quad1;
+// blueColor = 25.4, 第3行的第1个小格子
+// floor:向下取整
+quad1.y = floor(floor(blueColor) / 8.0);
+quad1.x = floor(blueColor) - (quad1.y * 8.0);
+```
+
+- 第二个小格子:     
+
+```python
+vec2 quad2;
+// blueColor = 25.4，第3行的第2个小格子
+// ceil：向上取整
+quad2.y = floor(ceil(blueColor) / 8.0);
+quad2.x = ceil(blueColor) - (quad2.y * 8.0);
+```
+
+##### 确定每个格子内具体点对应的色值
+
+通过R和G分量的值确定小方格内目标映射的RGB组合的坐标，然后归一化，转化为纹理坐标。
+
+每个B格子代表的纹理坐标长度是 1/8 = 0.125
+63 * textureColor.r是将当前实际像素的r值映射到0 ~ 63，再除以512是转化为纹理坐标中实际的点，LUT图的分辨率为`512*512`
+
+红色值和绿色值用来确定相对于整个LUT的纹理坐标:   
+
+```glsl
+
+vec2 texPos1;
+texPos1.x = (quad1.x * 0.125) + 0.5/512.0 + ((0.125 - 1.0/512.0) * color.r);
+texPos1.y = (quad1.y * 0.125) + 0.5/512.0 + ((0.125 - 1.0/512.0) * color.g);
+
+vec2 texPos2;
+texPos2.x = (quad2.x * 0.125) + 0.5/512.0 + ((0.125 - 1.0/512.0) * color.r);
+texPos2.y = (quad2.y * 0.125) + 0.5/512.0 + ((0.125 - 1.0/512.0) * color.g);
+```
+
+- 上面texPos1.x，texPos1.y代表的是在0-1的纹理坐标中该点(texPos1)的具体坐标。  
+- `(quad1.x * 0.125)`指的是在纹理坐标中的左上角的归一化坐标
+    - quad1.x代表当前格子在`8*8`的格子中横坐标的第几个，这个`8*8`的格子构成了0-1的纹理空间，所以一个格子代表的纹理坐标长度就是 1/8 = 0.125
+    - 所以第几个格子就代表了具有几个0.125这样的纹理长度
+    - 所以`(quad1.x * 0.125)`指的就是当前格子的**左上角**在纹理坐标系中的横坐标的具体坐标点。
+
+    ![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/3dlut_zuoshangjiao.jpg)
+
+- `((0.125 - 1.0/512.0) * textureColor.r)`
+
+这段代码可能是最看不懂的一段了，其实是这里是一个计算步骤的省略如下:      
+`((0.125 - 1.0/512.0) * textureColor.r) = （（64-1）* textureColor.r）/512`这样就可以理解了，
+`（64-1）* textureColor.r`意思是首先将当前实际像素的r值映射到0-63的范围内。       
+除以512是转化为纹理坐标中实际的点。（`纹理的分辨率为512*512`）
+
+这个步骤结束就在这一个小方格中根据R分量和G分量又确定了更小的一个方格的左上角的坐标点。如下图
+
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/3dlut_2.jpg)    
+
+- 0.5/512.0
+
+这个就很好理解了，因为上面算出来的结果都是小方格的左上角坐标，加上小方格横纵的一半坐标就是将该点移动到了小方格中心。   
+
+
+
+
+    
+
+##### 通过纹理坐标获取两个新的颜色   
+
+```glsl
+vec4 newColor1 = texture(textureLUT, texPos1);
+vec4 newColor2 = texture(textureLUT, texPos2);
+```
+
+##### 然后根据蓝色值小数部分作为权重做线性混合，获取最终的颜色输出
+
+
+```glsl
+// mix(x, y, a) -> x * (1 - a) + y * a
+// 使用mix方法对2个边界像素值进行插值混合
+// 根据浮点数到整点的距离来计算其对应的颜色值，fract函数是指小数部分。
+vec4 newColor = mix(newColor1, newColor2, fract(blueColor));
+// 将原图与映射后的图进行插值混合
+// 这次的插值混合是实现我们常见的滤镜调节功能，adjust调节的范围是(0-1)，取0时完全使用原图，取1时完全使用映射后的滤镜图
+gl_FragColor = mix(textureColor, vec4(newColor.rgb, textureColor.w), adjust);
+```
+
+片元着色器代码:     
+
+```glsl
+#version 300 es
+precision mediump float;
+
+in vec2 v_texCoord;
+out vec4 outColor;
+uniform sampler2D s_texture;
+uniform sampler2D textureLUT;
+
+//查找表滤镜
+vec4 lookupTable(vec4 color){
+    float blueColor = color.b * 63.0;
+
+    vec2 quad1;
+    quad1.y = floor(floor(blueColor) / 8.0);
+    quad1.x = floor(blueColor) - (quad1.y * 8.0);
+    vec2 quad2;
+    quad2.y = floor(ceil(blueColor) / 8.0);
+    quad2.x = ceil(blueColor) - (quad2.y * 8.0);
+
+    vec2 texPos1;
+    texPos1.x = (quad1.x * 0.125) + 0.5/512.0 + ((0.125 - 1.0/512.0) * color.r);
+    texPos1.y = (quad1.y * 0.125) + 0.5/512.0 + ((0.125 - 1.0/512.0) * color.g);
+    vec2 texPos2;
+    texPos2.x = (quad2.x * 0.125) + 0.5/512.0 + ((0.125 - 1.0/512.0) * color.r);
+    texPos2.y = (quad2.y * 0.125) + 0.5/512.0 + ((0.125 - 1.0/512.0) * color.g);
+    vec4 newColor1 = texture(textureLUT, texPos1);
+    vec4 newColor2 = texture(textureLUT, texPos2);
+    vec4 newColor = mix(newColor1, newColor2, fract(blueColor));
+    return vec4(newColor.rgb, color.w);
+}
+
+void main(){
+    vec4 tmpColor = texture(s_texture, v_texCoord);
+    outColor = lookupTable(tmpColor);
+}
+
+```
+
+---
+
+- [12.FBO](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/12.FBO.md)    
+- [14.实例化](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/14.%E5%AE%9E%E4%BE%8B%E5%8C%96.md)
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git "a/VideoDevelopment/OpenGL/14.\345\256\236\344\276\213\345\214\226.md" "b/VideoDevelopment/OpenGL/14.\345\256\236\344\276\213\345\214\226.md"
new file mode 100644
index 00000000..e04ca224
--- /dev/null
+++ "b/VideoDevelopment/OpenGL/14.\345\256\236\344\276\213\345\214\226.md"
@@ -0,0 +1,75 @@
+## 13.实例化
+
+
+OpenGL ES实例化(Instancing)是一种只调用一次渲染函数就能绘制出很多物体的技术，可以实现将数据一次性发送给GPU，告诉OpenGL ES使用一个绘制函数，将这些数据绘制成多个物体。   
+
+
+实例化(Instancing)避免了CPU多次向GPU下达渲染命令(避免多次调用glDrawArrays或glDrawElements等绘制函数)，节省了绘制多个物体时CPU和GPU之间的通信时间，提升了渲染性能。   
+
+
+
+
+
+实例化(instancing)提供了一种机制，可以只用一个C++/OpenGL调用就告诉显卡渲染一个对象的多个副本。这可以带来显著的性能优势，特别是在绘制有数千甚至数百万个对象时，例如渲染在场地中的许多花朵。
+
+### 粒子  
+
+实例化最常见的应用就是做一些粒子效果，例如一些烟花的效果。。
+
+实例化的目标并不是实现同一个物体绘制多次，而是能基于某一物体绘制出位置、大小、形状或颜色不同的多个物体。   
+
+OpenGL ES着色器中有一个与实例化绘制相关的内建变量gl_InstanceID，表示当前正在绘制实例的ID，每个实例对应一个唯一的ID，通过这个ID可以轻易实现基于一个物体而绘制出位置、大小、形状或颜色不同的多个物体(实例)。     
+
+
+在渲染多个对象时，OpenGL使用Z-buffer算法来进行隐藏面消除。通常情况下，通过选择最接近相机的相应片段的颜色作为像素的颜色，这种方法可决定哪些物体的曲面可见并呈现到屏幕，而位于其他物体后面的曲面不应该被渲染。
+然而，有时候场景中的两个物体表面重叠并位于重合的平面中，这使得深度缓冲区算法难以确定应该渲染两个表面中的哪一个（因为两者都不“最接近”相机）。发生这种情况时，浮点舍入误差可能会导致渲染表面的某些部分使用其中一个对象的颜色，而其他部分则使用另一个对象的颜色。这种不自然的伪影称为Z冲突(Z-fighting)或深度冲突(depth-fighting)，是渲染的片段在深度缓冲区中相互对应的像素条目上“斗争”的结果。
+
+
+![image](https://github.com/CharonChui/Pictures/blob/master/opengl_z_fighting.png?raw=true)
+
+
+
+提高渲染效率的另一种方法是利用OpenGL的背面剔除能力。当3D模型完全“闭合”时，意味着内部永远不可见（例如对于立方体和四棱锥），那么外表面的那些与观察者背离且呈一定角度的部分将始终被同一模型的其他部分遮挡。也就是说，那些背离观察者的三角形不可能被看到（无论如何它们都会在隐藏面消除的过程中被覆盖），因此没有理由栅格化或渲染它们。
+我们可以使用命令glEnable(GL_CULL_FACE)要求OpenGL识别并“剔除”（不渲染）背向的三角形。我们还可以使用glDisable(GL_CULL_FACE)禁用背面剔除。默认情况下，背面剔除是关闭的，因此如果你希望OpenGL剔除背向三角形，必须手动启用它。
+
+
+
+
+--- 
+[上一篇: 13.LUT滤镜](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/13.LUT%E6%BB%A4%E9%95%9C.md)
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git "a/VideoDevelopment/OpenGL/15.\347\276\216\351\242\234\346\273\244\351\225\234.md" "b/VideoDevelopment/OpenGL/15.\347\276\216\351\242\234\346\273\244\351\225\234.md"
new file mode 100644
index 00000000..043db19f
--- /dev/null
+++ "b/VideoDevelopment/OpenGL/15.\347\276\216\351\242\234\346\273\244\351\225\234.md"
@@ -0,0 +1,43 @@
+美颜滤镜
+---
+
+美颜的基本原理就是深度学习加计算机图形学。    
+
+- 深度学习用来人脸检测和人脸关键点检测。    
+- 计算机图形学用来磨皮、瘦脸和化妆容。   
+- 一般在Android上使用OpenGL ES，iOS使用Metal。   
+
+## 美颜算法的原理
+
+
+美颜算法主要是基于图像处理技术，包括人脸检测、皮肤平滑、肤色调整、瘦脸大眼瞪。     
+其中，人脸检测是美颜的第一步，通过算法识别出照片中的人脸区域，然后针对该区域进行后续的美化处理。   
+
+### 关键技术点
+
+- 人脸检测：利用OpenCV(强大的计算机视觉库，支持人脸检测等)、Dlib等库实现。 
+- 皮肤平滑：通过高斯模糊、双边滤波等技术减少皮肤瑕疵。    
+- 肤色调整：调整肤色饱和度、亮度等，使肤色更加自然。
+- 瘦脸大眼：基于人脸关键点定位，通过变形算法实现。   
+
+
+
+### 人脸检测
+
+- 人脸检测指的是对图片或者视频流中的人脸进行检测，并定位到图片中的人脸。   
+- 人脸关键点检测是对人脸中五官和脸的轮廓进行关键点定位，一般情况下它紧接在人脸检测后。    
+
+
+- 加载OpenCV库，在项目中集成OpenCV库，并加载本地人脸检测模型。 
+- 实时处理：在相机预览的回调中，对每一帧图像进行人脸检测，并应用美颜算法。  
+
+
+
+
+
+https://zhuanlan.zhihu.com/p/163604590
+
+
+
+
+
diff --git "a/VideoDevelopment/OpenGL/16.\350\211\262\346\270\251\343\200\201\350\211\262\350\260\203\343\200\201\351\245\261\345\222\214\345\272\246.md" "b/VideoDevelopment/OpenGL/16.\350\211\262\346\270\251\343\200\201\350\211\262\350\260\203\343\200\201\351\245\261\345\222\214\345\272\246.md"
new file mode 100644
index 00000000..8dff2153
--- /dev/null
+++ "b/VideoDevelopment/OpenGL/16.\350\211\262\346\270\251\343\200\201\350\211\262\350\260\203\343\200\201\351\245\261\345\222\214\345\272\246.md"
@@ -0,0 +1,74 @@
+
+- 色温: 图片的色温指的是图片中呈现出来的整体颜色偏暖或偏冷的程度。    
+
+色温可以影响图像的分为和情感表达。简单理解就是色彩的温度，越低越冷如蓝色，越高越暖如红色。 
+
+- 色调: 色调是指图片色彩的整体质感，包括主要色调的选择和组合。    
+
+通过调整色调，可以改变图像的整体色彩效果，营造特定的视觉风格或情绪。简单理解就是色彩倾向，倾向于红橙还是黄绿。    
+
+- 亮度: 亮度描述了图片中各个部分的明暗程度。增加亮度将使整体图像看起来更明亮，减小亮度则会使图片变得更暗。     
+
+亮度的调整可以影响图像的整体视觉效果和光线感。   
+增加就是给图片所有色彩增加白色，减少黑色。注意是只加黑白两种颜色，不然容易跟纯度弄混。   
+
+- 对比度: 对比度是描述图像中不同区域之间亮度差异的程度。    
+
+提高对比度会使图像中的明暗部分更加突出，增强图像的清晰度和视觉冲击力。   
+适当的对比度可以让图像更具有立体感和层次感。    
+增加就是让白的更白，黑的更黑。减少就是白的不那么白，黑的不那么黑。   
+
+- 饱和度: 饱和度表示图片中颜色的纯度和鲜艳程度。    
+
+增加饱和度会使颜色更加丰富饱满，减少饱和度会使颜色变得更加灰暗。     
+调整饱和度可以改变图像的整体色彩和视觉吸引力。     
+
+简单理解就是增加图片各种颜色的纯度。
+比如蓝色，增加纯度就是在蓝色上加蓝色，降低纯度就是键入蓝色的对比色，让它变灰色或黑色。  
+
+- 高光: 高光是指图片中最亮的部分，通常实在光线照射下产生的明亮区域。    
+
+调整高光可以改变图像中亮部的强度和反射效果，从而影响图像的细节和光影效果。   
+增加就是给图片白色的部分再加点白色，减少就是减少点白色。  
+
+
+
+
+
+### RGB颜色模型
+
+RGB颜色模型是一种用于创建各种颜色的方法，它基于红色、绿色、蓝色三种颜色的组合。    
+
+通过调节这三种颜色的强度和比例，可以生成多种不同的颜色。 
+
+### HSV颜色模型
+
+HSV代表色相(Hue)、饱和度(Saturation)、明度(Value)，或色相(Hue)、饱和度(Saturation)、亮度(Brightness)。   
+
+在HSV模型中，色相同样表示颜色本身，饱和度表示颜色的纯度或浓淡程度，而明度或亮度则表示颜色的亮度程度。     
+
+HSV模型有时也被称为HSB(色相、饱和度、亮度)模型。  
+
+
+HSV（HSB）颜色模型根据下图对应说明可以得知：
+
+- H(Hue)：色调,用角度度量,取值范围为0°～360° ,从红色开始按逆时针方向计算
+- S(Saturation)：饱和度,表示颜色接近光谱色的程度.一种颜色,可以看成是某种光谱色不白色混合的结果.通常取值范围为0%～100%,值越大,颜色越饱和.光谱色的白光成分为0,饱和度达到最高.
+- V(Value或Brightness)：明度,表示颜色明亮的程度.
+
+
+
+### HSL颜色模型
+
+HSL代表色相(Hue)、饱和度(Stauration)、亮度(Lightness)。   
+
+在HSL模型中，色相表示颜色本身，饱和度表示颜色纯度或浓淡程度，亮度则表示颜色的明暗程度。   
+
+- H: 色相，使用不水平轴之间的角度来表示，范围是从(0 ~ 360)度。从蓝色开始。   
+- S: 饱和度，说明颜色的相对浓度。     
+- L: 亮度，在L=0处为黑色，在L=1处为白色。灰色沿着L轴分布。   
+
+
+
+
+
diff --git "a/VideoDevelopment/OpenGL/17.EGL\345\222\214GL\347\272\277\347\250\213.md" "b/VideoDevelopment/OpenGL/17.EGL\345\222\214GL\347\272\277\347\250\213.md"
new file mode 100644
index 00000000..fd4db0e9
--- /dev/null
+++ "b/VideoDevelopment/OpenGL/17.EGL\345\222\214GL\347\272\277\347\250\213.md"
@@ -0,0 +1,306 @@
+EGL和GL线程
+---
+
+
+EGL是连接OpenGL ES与本地窗口系统的桥梁。   
+
+OpenGL是跨平台的，但是不同平台上的窗口系统是不一样的，它就需要一个东西帮助OpenGL与本地窗口系统进行对接、管理及执行GL命令等。    
+
+OpenGL ES的平台无关性正是借助EGL实现的，EGL屏蔽了不同平台的差异(Apple提供了自己的EGL API的iOS实现，自称EAGL)。
+
+EGL可以创建渲染表面EGLSurface，同时提供了图形渲染上下文EGLContext，用来进行状态管理，接下来OpenGL ES就可以在这个渲染表面上绘制。   
+
+
+GL线程是一个与EGL环境绑定了的线程，绑定后可以在这个线程中执行GL操作。 
+
+
+比如将原视频进行OpenGL ES特效渲染然后编码保存，或者是解码原视频然后进行OpenGL ES特效渲染再显示出来。
+
+编码时需要将要编码的帧渲染到MediaCodec给你的一块surface上，而这些操作需要有EGL才能做，而解码时是解码到一块你自己指定的surface上，此时你也没有一个现成的EGL环境，如果你想解码出来先用OpenGL ES做些特效处理再显示出来，那么这时也需要EGL环境。
+
+
+### GLContext
+
+
+在我们的程序运行时，每一个方法的调用都是在CPU上的。
+OpenGL也不例外，与普通调用的区别在于这些调用会被转换为GPU驱动指令在GPU上执行，而CPU和GPU作为两个不同的处理单元，它们之间的指令是并行执行的。     
+
+OpenGL的设计模式是Client/Server，这里Client是指CPU、Server是指GPU。     
+
+在执行gl命令时会有一个队列用于暂存还未发送到GPU的命令，实际上我们调用的绝大多数OpenGL方法，只是在往命令队列中插入命令，在CPU中并不一定会等待命令执行完。    
+
+
+![image](https://github.com/CharonChui/Pictures/blob/master/opengl_cpu_gpu.png?raw=true)
+
+但并不是所有的线程都对应同一个命令队列，命令队列是和EGL Context对应的，而一个线程又只能同时绑定到一个EGL Context。      
+因此可以理解为命令队列是和绑定的EGL Context的线程对应的。     
+
+CommandQueue：在CPU和GPU分别有各自的CommanQueue，当一个OpenGL命令在CPU执行时，会先添加到CPU的CommanQueue，在CPU切换到burst mode后，CPU 
+CommanQueue中的命令被依次发送到GPU CommanQueue，GPU会在合适的时机执行CommanQueue里的命令。     
+
+GLContext: OpenGL的状态机，保存有渲染管线用到的状态和资源，OpenGL命令的宿主环境。    
+
+GLContext是和线程强相关的，这是因为绝大部分驱动的设计中，都是一个线程一个CommanQueue，而这个线程中的当前GLContext中发生的命令才会被添加到CommanQueue。      
+
+绝大多数OpenGL命令在CPU上是异步执行的，在CPU上是同步执行的。    
+
+这一切得益于CommanQueue的存在，让CPU可以更高效地完成命令发送，毕竟总线的资源是珍贵的，尤其在移动端的总线带宽是非常小的(内存64/128bit，显存128/256bit)。      
+但这样的代价是在渲染有问题时，在CPU无法定位到真正的现场。     
+
+
+
+
+
+为了让大家直接感觉一下EGL所起的作用，我们来试试几段代码，一段是我们很熟悉的GLSurfaceView的Renderer的代码，我们可以在回调中做GL操作，比如这里我们创建一个texture：
+
+```kotlin	
+glSurfaceView.setRenderer(object : GLSurfaceView.Renderer {
+            
+    override fun onDrawFrame(gl: GL10?) {
+    }
+
+    override fun onSurfaceChanged(gl: GL10?, width: Int, height: Int) {
+    }
+
+    override fun onSurfaceCreated(gl: GL10?, config: EGLConfig?) {
+        
+        val textures = IntArray(1)
+        GLES30.glGenTextures(textures.size, textures, 0)
+        val imageTexture = textures[0]
+        
+    }
+
+})
+
+```
+如果你查看这个texture的值，会发现它大于0，也就是创建成功了，另外也可以通过OpenGL ES的方法GLES30.glIsTexture(imageTexture)来判断一个texture是不是合法的texture。
+
+如果我们把上述创建texture的操作放到主线程中会怎样？
+
+```kotlin
+class MainActivity : AppCompatActivity() {
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+
+        val textures = IntArray(1)
+        GLES30.glGenTextures(textures.size, textures, 0)
+        val imageTexture = textures[0]
+    }
+}
+```
+
+我们会发现，这时创建出来的texture是0，也就是创建失败了，其实不只是创建texture失败，其它GL操作一律会失败。
+
+如果放到一个子线程中呢？
+
+效果是一样的，也会失败，为什么？
+
+**原因就是在一个没有EGL环境的线程中调用了OpenGL ES API。**   
+
+ 那如何让一个线程拥有EGL环境？创建EGL环境，步骤还不少，一共有以下几个步骤：
+
+
+- 获取显示设备
+```
+eglDisplay = EGL14.eglGetDisplay(EGL14.EGL_DEFAULT_DISPLAY)
+```
+
+这里获取的是default的显示设备，大多数情况下我们都是获取default，因为大多数情况下设备只有一个屏幕，本文也只讨论这种情况。
+
+- 初始化显示设备
+
+```
+val version = IntArray(2)
+EGL14.eglInitialize(eglDisplay, version, 0, version, 1)
+```
+这里初始化完成后，会返回给我们支持的EGL的最大和最小版本号。
+
+
+这里初始化完成后，会返回给我们支持的EGL的最大和最小版本号。
+
+- 选择config
+
+```
+val attribList = intArrayOf(
+    EGL14.EGL_RED_SIZE, 
+    8, 
+    EGL14.EGL_GREEN_SIZE, 
+    8, 
+    EGL14.EGL_BLUE_SIZE, 
+    8, 
+    EGL14.EGL_ALPHA_SIZE, 
+    8,
+    EGL14.EGL_RENDERABLE_TYPE, 
+    EGL14.EGL_OPENGL_ES2_BIT or EGLExt.EGL_OPENGL_ES3_BIT_KHR, 
+    EGL14.EGL_NONE
+)
+val eglConfig = arrayOfNulls<EGLConfig>(1)
+val numConfigs = IntArray(1)
+EGL14.eglChooseConfig(
+    eglDisplay, 
+    attribList, 
+    0, 
+    eglConfig, 
+    0, 
+    eglConfig.size,
+    numConfigs, 
+    0
+)
+```
+
+这步操作告诉系统我们期望的EGL配置，然后系统返回给我们一个列表，按配置的匹配程度排序，因为系统不一定有我们期望的配置，因此要通过查询让系统返回尽可能接近的配置。
+
+attribList是我们期望的配置，我们这里的配置是将RGBA颜色深度设置为8位，并将OpenGL ES版本设置为2和3，表示同时支持OpenGL 2和OpenGL 3，最后以一个EGL14.EGL_NONE作为结束符。
+
+eglConfig是返回的尽可能接近我们期望的配置的列表，通常我们取第0个来使用，即最符合我们期望配置。
+
+- 创建EGL Context
+
+```
+eglContext = EGL14.eglCreateContext(
+    eglDisplay, 
+    eglConfig[0], 
+    EGL14.EGL_NO_CONTEXT,
+    intArrayOf(EGL14.EGL_CONTEXT_CLIENT_VERSION, 3, EGL14.EGL_NONE), 
+    0
+)
+```
+
+eglDisplay即是之前创建的显示设备，注意第三个参数，它是指定一个共享的EGL Context，共享后，2个EGL Context可以相互使用对方创建的texture等资源，默认情况下是不共享的，但不是所有资源都能共享，例如program就是不共享的。
+
+
+- 创建EGL Surface
+
+```
+val surfaceAttribs = intArrayOf(EGL14.EGL_NONE)
+eglSurface = EGL14.eglCreatePbufferSurface(
+    eglDisplay, 
+    eglConfig[0], 
+    surfaceAttribs, 
+    0
+)
+```
+
+EGL Surface是什么东西？可以理解成是一个用于承载显示内容的东西，这里有2种EGL Surface可以选择，一种是window surface，一种是pbuffer surface。
+
+如果我们创建这个EGL环境是为了跟一块Surface绑定，例如希望给Surface View创建一个EGL环境，使用OpenGL ES渲染到Surface View上，那么就要选择window surface，对应的创建方法为：
+```
+EGL14.eglCreateWindowSurface(
+    eglDisplay, 
+    eglConfig[0], 
+    surface, 
+    surfaceAttribs, 
+    0
+)
+```
+其中surface就是这个Surface View对应的surface。如果我们不需要渲染出来看，那么就可以创建一个pbuffer surface，它不和surface绑定，不需要传surface给它，这也称为离屏渲染，本文中将创建pbuffer surface。
+
+这里提一个细节，现在的surface所对应的buffer一般都是双buffer，以便于一个buffer正在显示的时候，有另一个buffer可用于渲染， 正在显示的buffer称为front buffer，正在渲染的buffer称为back buffer。
+
+如果要渲染到surface上，必须在渲染后调EGL14.eglSwapBuffers(eglDisplay, eglSurface) 将显示buffer和渲染buffer进行交换才会生效，否则会一直渲染到back buffer上，这个buffer无法变成front buffer显示到surface上。
+
+
+
+- 绑定EGL
+前面的几个步骤，我们把一些需要创建的东西都创建好了，下面就要将EGL绑定到线程上让它具体有EGL环境：
+```
+EGL14.eglMakeCurrent(
+    eglDisplay, 
+    eglSurface, 
+    eglSurface, 
+    eglContext
+)
+```
+
+注意，一个线程只能绑定一个EGL环境，如果之前绑过其它的，后面又绑了一个，那就会是最后绑的那个。至此，就能让一个线程拥有EGL环境了，此后就可以顺利地做GL操作了。
+
+好，我们看一下我们的例子代码：
+```
+Thread {
+
+    val egl = EGL()
+    egl.init()
+
+    egl.bind()
+
+    val textures = IntArray(1)
+    GLES30.glGenTextures(textures.size, textures, 0)
+    val imageTexture = textures[0]
+    assert(GLES30.glIsTexture(imageTexture))
+
+    egl.release()
+
+}.start()
+```
+代码很简单，只是为了验证是否有了EGL环境，就不写复杂的操作了，EGL就是对前文所述的操作的一个封装类，init()方法对应了获取显示设备、初始化显示设备、选择config、创建EGL Context和创建EGL Surface，bind()方法对应了eglMakeCurrent()。
+
+
+
+
+### 共享上下文
+
+![image](https://github.com/CharonChui/Pictures/blob/master/opengl_share_context.png?raw=true)
+
+共享上下文时，可以跨线程共享哪些资源?    
+
+可共享的资源:    
+
+- 纹理
+- shader
+- program着色器程序
+- buffer类对象，如VBO、EBO、RBO等
+
+不可以共享的资源:    
+
+- FBO帧缓冲区对象(不属于buffer类)
+- VAO顶点数组对象(不属于buffer类)
+
+
+在不可以共享的资源中，FBO和VAO属于资源管理型对象，FBO负责管理几种缓冲区，本身不占用资源，VAO负责管理VBO或EBO，本身也不占用资源。    
+
+
+注意：每个线程同时只能绑定(eglMakeCurrent)一个Context，但可以按顺序切换不同Context。
+
+
+### glFinish()、glFlush()、glFence()
+
+但是在跨线程的共享中也会带来一些同步问题，比如两个线程对同一个纹理进行操作，thread0在纹理上绘制，thread1使用thread0提供的纹理，这时候如果thread0的线程没有渲染完，而thread1就开始使用，就会造成黑屏或者花屏的问题。    
+
+要解决这个问题有一个简单的方案就是使用glFinish()，glFinish()是一个同步方法，运行时会等待该线程中所有的GL命令(包括所有改变GL状态的命令，所有改变连接状态的命令和所有改变Frame buffer内容的命令)都执行完，从而保证绘制的完整性。    
+
+
+与glFinish()比较相近的还有一个glFlush()方法，它的作用是将命令队列中的命令全部刷到GPU，但并不等它执行完成。    
+
+在实际使用中，各个厂家的GPU实现差异很大，但都要求符合OpenGL标准，glFlush可以异步实现，也可以同步实现，但glFinish必须同步实现，所以调用glFlush并返回时，只能说是渲染命令都下发了，但不能保证一定完成，而glFinish返回时是保证了命令已经执行完成的。    
+
+glFinish虽然能保证命令的完整执行，但是会对性能有一定的影响，因为它会使得GPU和CPU之间的并行性丧失。    
+
+一般，我们提交给驱动的任务被分组，然后被送到硬件上(再缓冲区交换的时候)，如果调用glFinish，就强制驱动将命令送到GPU。然后CPU等待直到被传送的命令全部执行完成。这样在GPU工作的整个期间内，CPU没有工作(至少在这个线程上)。而在CPU工作时(通常是在对命令分组)，GPU没有工作，因此造成性能上的下降。   
+
+有些厂商在实现中已经做了一些保证操作完整性的处理(比如高通部分Soc)，并不需要使用到glFinish，过度的使用glFinish反而降低了渲染的效率，相比于glFinish在OpenGL 3.0中有了更好的方案glFence。  
+
+
+
+GLFence 的原理是在同步过程中创建一个 Fence 同步对象并将 Fence 命令插入 GL 命令队列中，当 Fence 命令满足同步对象的指定条件时，GL 发出解除信号，解除由glWaitSync 或 glClientWaitSync命令造成的阻塞。
+
+
+
+同时，glFenceSync 或相关 Fence 命令的执行不会影响其他 GL 状态。
+
+
+glFence 中包含两个 Sync 命令 glWaitSync 和 glClientWaitSync，glWaitSync 是在 GPU 上等待，而 glClientWaitSync 是在 CPU 上等待，实际使用中只有 glClientWaitSync 起到了阻止闪屏的作用。
+
+
+
+
+
+
+
+如果说OpenGL ES是画笔，那Android的Surface就是画布。我们是可以使用OpenGL ES将图像画到 Surface中去的。但是OpenGL并不能直接在Android的Surface中画画，需要借助 EGLSurface 来将 Android的Surface关联起来。  
+
+
+
+
+
+
diff --git "a/VideoDevelopment/OpenGL/18.\345\205\266\344\273\226.md" "b/VideoDevelopment/OpenGL/18.\345\205\266\344\273\226.md"
new file mode 100644
index 00000000..723b4dae
--- /dev/null
+++ "b/VideoDevelopment/OpenGL/18.\345\205\266\344\273\226.md"
@@ -0,0 +1,74 @@
+18.其他
+---
+
+
+视觉暂留： 人眼在观察景物时，光信号传入大脑神经，需经过一段短暂的时间，光的作用结束后，视觉形象并不立即消失，这种残留的视觉称“后像”，视觉的这一现象则被称为“视觉暂留”。   
+
+物体在快速运动时，当人眼所看到的影像消失后，人眼仍能继续保留其影像0.1 ~ 0.4秒左右的图像，所以当图像的刷新帧率高于每秒16帧时，在人眼看来就是不间断的显示。     
+
+
+#### 光栅扫描
+
+
+光栅扫描显示是目前的主流。     
+
+在光栅扫描显示中，电子束横向扫描屏幕，一次一行，从顶到底依次进行。      
+
+电子束在屏幕上逐点移动时，从被称为帧缓存的存储区取出每个像素点的强度值控制其显示状态。       
+这种实现原理决定了光栅扫描显示的刷新频率和图像复杂度无关，刷新频率可以是恒定的。    
+
+
+光栅扫描显示对屏幕上的每个点都有存储强度信息的能力(除颜色信息外，其他的像素信息也存在帧缓存中)，从而使得适用于包含阴影和彩色模式的逼真场景。    
+
+
+GPU的渲染流程:   
+
+GPU进行渲染时，会把数据先存储在帧缓冲区里，然后视频控制器读取帧缓冲区里的数据，完成数模转化，逐行扫描显示画面。   
+
+理论上，完美情况时，每扫描一张图，就显示一张，然后下一张也扫描完成等待刷新。   
+
+一次反复，屏幕就会保持流畅，那为什么有时候屏幕还会出现不流畅的现象？   
+
+
+- 撕裂:  
+
+当视频控制器读取完一帧画面显示后，会去帧缓存读取下一帧，如果帧缓存仍然保持着上一帧的数据没有被刷新，视频控制器照常工作读取帧缓存中的数据。     
+
+当寄存器工作到某一行时，帧缓存的数据被更新为下一帧，视频控制器就读取到新的数据，而此时已经显示的画面是上一帧的数据，后续将要显示的是下一帧的数据，撕裂也就产生了。    
+
+所以，撕裂的产生是因为帧缓存的刷新频率没有跟上屏幕的刷新频率，根本原因就是CPU或GPU工作超时。
+
+
+为了解决撕裂的问题，会使用垂直同步Vsync + 双缓冲的机制。  
+
+
+
+在VSync信号到来后，会在CPU中计算显示内容，比如视图的创建、布局计算、图片解码、文本绘制等。
+
+然后CPU会将计算好的数据提交到GPU，由GPU进行变换、合成、渲染。然后GPU会把渲染结果提交到帧缓存，等待下一次VSync信号到来时显示到屏幕上。
+
+由于垂直同步的机制，如果在一个VSync时间内，CPU或者GPU没有完成内容提交，则那一帧就会被丢弃，等待下一次机会再显示，而这时屏幕会刷新显示上一帧的内容。
+
+
+
+通过这种机制，就解决了撕裂的问题，但同时引入了新的问题 -- 掉帧。
+
+
+
+当CPU或GPU渲染流⽔线耗时过⻓，前后显示同一帧时，也就出现了掉帧现象(所以掉帧不是不渲染数据，而是重复渲染同一帧数据)。
+
+
+
+至于掉帧无法被完全解决，因为CPU或GPU的工作是不可预估的。只能尽量合理的使用CPU或GPU减少掉帧次数。
+
+
+
+
+### 混合
+
+OpenGL ES混合本质上是将2个片元颜色进行调和产生一个新的颜色。    
+
+OpenGL ES混合发生在片元通过各项测试之后，准备进入帧缓冲区的片元和原有的片元按照特定比例加权计算出最终片元的颜色值
+
+
+ 
diff --git "a/VideoDevelopment/OpenGL/19.\347\233\270\346\234\272\351\242\204\350\247\210.md" "b/VideoDevelopment/OpenGL/19.\347\233\270\346\234\272\351\242\204\350\247\210.md"
new file mode 100644
index 00000000..fec81043
--- /dev/null
+++ "b/VideoDevelopment/OpenGL/19.\347\233\270\346\234\272\351\242\204\350\247\210.md"
@@ -0,0 +1,43 @@
+# 19.相机预览
+
+相机预览可以使用OpenGL方便的实现相机美颜、滤镜、塑性以及一些特效。   
+
+
+相机的预览实现一般有2种方式:    
+
+- 一种是基于Android原生SurfaceTexture的纯GPU实现方式    
+- 一种是通过相机的预览回调接口获取帧的YUV数据，利用CPU算法处理完成之后，传入显存，再利用GPU实现YUV转RGBA进行渲染，即CPU + GPU的实现方式   
+
+基于Android原生SurfaceTexture的纯GPU实现方式，相机可以使用SurfaceTexture作为预览载体。     
+SurfaceTexture可以来自于GLSurfaceView、TextureView或SurfaceView这些独立拥有Surface的封装类，也可以自定义实现。    
+
+
+作为预览载体的SurfaceTexture绑定的纹理需要是OES纹理。    
+
+使用OES纹理后，我们不需要在片段着色器中自己做YUV to RGBA的转换，因为OES纹理可以直接接收YUV数据或者直接输出YUV数据。  
+
+
+### YUV
+
+YUV和RGBA是两种不同的颜色编码格式，主要区别于在数据组织和应用场景。
+
+- YUV主要用于视频压缩、传输(例如H264/HEVC)，优势为亮度和色度分离适合压缩(人眼对亮度更敏感，色度可降采样)。
+YUV为视频压缩设计，牺牲直接显示兼容性换取高压缩率。   
+
+- RGBA主要用于图像显示、图形渲染(如屏幕绘制)，每个像素的RGBA值连续存储，可直接兼容显示设备。    
+RGBA为显示优化，直接支持像素渲染和透明通道。   
+
+
+### OES与YUV的关系
+
+OES纹理(GL_TEXTURE_EXTERNAL_OES)是OpenGL ES的一种扩展纹理类型，主要用于直接操作外部设备(如摄像头、视频解码器)的纹理数据。它与YUV的关系如下:   
+
+- 视频解码后的YUV数据: 移动端视频解码器(如Android的MediaCodec)输出的YUV帧数据，通常通过OES纹理直接传递给GPU，避免CPU到GPU的数据拷贝。     
+
+
+
+使用OES纹理需要修改片段着色器，在着色器脚本的头部增加扩展纹理的声明:   
+
+`#extension GL_OES_EGL_image_external : require`
+
+并且纹理采样器不再使用sample2D，需要换成samplerExternalOES作为纹理采样器。    
diff --git "a/VideoDevelopment/OpenGL/2.GLSurfaceView\347\256\200\344\273\213.md" "b/VideoDevelopment/OpenGL/2.GLSurfaceView\347\256\200\344\273\213.md"
index fa6b2098..0647b7ea 100644
--- "a/VideoDevelopment/OpenGL/2.GLSurfaceView\347\256\200\344\273\213.md"
+++ "b/VideoDevelopment/OpenGL/2.GLSurfaceView\347\256\200\344\273\213.md"
@@ -1,12 +1,26 @@
 ## 2.GLSurfaceView简介
 
+
+### 生产者(Surface)与消费者(SurfaceFlinger)
+
+在Android系统中，无论开发者调用什么渲染API，一切内容都会渲染到Surface上。       
+
+Surface表示缓冲区队列中的生产者，而缓冲区队列会被消费者SurfaceFlinger消耗掉。     
+
+在Android平台上创建的每个窗口都由Surface提供支持。
+用户通过在Surface这张画布上绘制生成图形数据，这些数据会被BufferQueue传输给SurfaceFlinger，所有被渲染的可见Surface都被SurfaceFlinger合成到屏幕。    
+
+
+
+
+
 Android 通过其框架 API 和原生开发套件 (NDK) 来支持 OpenGL。
 
 Android 框架中有如下两个基本类，用于通过 OpenGL ES API 来创建和操控图形：`GLSurfaceView` 和 `GLSurfaceView.Renderer`。也就是说我们想在Android中使用OpenGL ES的最简单的方法就是将我们要显示的图像渲染到GLSurfaceView上，但它只是一个展示类，至于怎么渲染到上面我们就要自己去实现GLSurfaceView.Renderer来生成我们自己的渲染器从而完成渲染操作，这里是不是感觉Android框架提供的类太少了，怎么没有GLTextureView，后面在分析完GLSurfaceView的源码后，可以直接拷贝自己去实现GLTextureView，[有关SurfaceView与TextureView的区别可以看这篇文章](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/SurfaceView%E4%B8%8ETextureView.md)。    
 
 ### GLSurfaceView(使用OpenGL绘制的图形的视图容器)
 
-SurfaceView在View的基础上创建了独立的Surface，拥有SurfaceHolder来管理它的Surface，渲染的工作可以不再主线程中做。可以通过SurfaceHolder得到Canvas，在单独的线程中，利用Canvas绘制需要显示的内容，然后更新到Surface上。
+SurfaceView在View的基础上创建了独立的Surface，拥有SurfaceHolder来管理它的Surface，渲染的工作可以不在主线程中做。可以通过SurfaceHolder得到Canvas，在单独的线程中，利用Canvas绘制需要显示的内容，然后更新到Surface上。
 
 GLSurfaceView继承自SurfaceView，它主要是在SurfaceView的基础上加入了EGL的管理，并自带了一个GLThread的绘制线程，绘制的工作直接通过OpenGL在绘制线程进行，不会堵塞主线程，绘制的结果输出到SurfaceView所提供的Surface上，这使得GLSurfaceView也拥有了OpenGLES所提供的图形处理能力，通过它定义的Render接口，使更改具体的Render的行为非常灵活，只需要将实现了渲染函数的Renderer的实现类设置给GLSurfaceView既可。也就是说它是对SurfaceView的再次封装，为了方便我们在安卓中使用OpenGL。
 
@@ -26,7 +40,12 @@ GLSurfaceView继承自SurfaceView，它主要是在SurfaceView的基础上加入
 
 GLSurfaceView.Renderer接口要求您实现以下方法:     
 - onSurfaceCreated():系统会在创建GLSurface时调用一次此方法。使用此方法可执行仅需发生一次的操作，例如设置OpenGL环境参数或初始化OpenGL图形对象。          
-- onDrawFrame():完成绘制工作，每一帧图像的渲染都要在这里完成，系统会在每次重新绘制GLSurfaceView时调用此方法。请将此方法作为绘制（和重新绘制）图形对象的主要执行点。
+在GLSurfaceView attach到父View后，此方法会被调用。    
+
+- onDrawFrame(): 完成绘制工作，每一帧图像的渲染都要在这里完成，系统会在每次重新绘制GLSurfaceView时调用此方法。请将此方法作为绘制（和重新绘制）图形对象的主要执行点。
+
+在任意时间调用GLSurfaceView的requestRender()方法后，GLSurfaceView会优先执行已保存在GL线程队列中的Runnable,然后调用此onDrawFrame()方法渲染图像。GL线程队列中的所有Runnable和onDrawFrame()方法的调用都执行在GL线程中。   
+
 - onSurfaceChanged():系统会在GLSurfaceView几何图形发生变化（包括GLSurfaceView大小发生变化或设备屏幕方向发生变化）时调用此方法。例如，系统会在设备屏幕方向由纵向变为横向时调用此方法。使用此方法可响应GLSurfaceView容器中的更改。          
 
 使用GLSurfaceView和GLSurfaceView.Renderer为OpenGL ES建立容器视图后，您便可以开始使用以下类调用 OpenGL API：
@@ -55,7 +74,7 @@ GLSurfaceView的特性:
 - 管理一个surface，这个surface就是一块特殊的内存，能直接排版到android的视图view上。
 - 管理一个EGL Display，它能让OpenGL把内容渲染到surface上
 - 用户自定义渲染器render
-- 让渲染器在独立的变成里运作(与UI线程分离)
+- 让渲染器在独立的线程里运作(与UI线程分离)
 - 支持按需渲染(on-demand)和连续渲染(continuous)
 - 可以封装、跟踪并且排查渲染器的问题
 
@@ -114,7 +133,8 @@ class MyGLRenderer implements GLSurfaceView.Renderer {
 ```
 
 效果图就不贴了，就是一个纯绿色的Activity。
-上面glClearColor函数是一个状态设置函数，而glClear函数则是一个状态使用的函数，它使用了当前的状态来获取应该清除为的颜色
+上面glClearColor函数是一个状态设置函数，而glClear函数则是一个状态使用的函数，它使用了当前的状态来获取应该清除为的颜色    
+
 Render接口重写的三个方法中调用了GLES31的API方法:   
 
 - glClearColor()：设置清空屏幕用的颜色，参数为RGBA。
@@ -176,16 +196,29 @@ GLSurfaceView默认采用的是RENDERMODE_CONTINUOUSLY连续渲染的方式，
 
 说到GLSurfaceView就一定要提一下SurfaceTexture。
 
-和SurfaceView功能类似，区别是，SurfaceTexure可以不显示在界面中。使用OpenGl对图片流进行美化，添加水印，滤镜这些操作的时候我们都是通过SurfaceTexre去处理，处理完之后再通过GlSurfaceView显示。缺点，可能会导致个别帧的延迟。本身管理着BufferQueue,所以内存消耗会多一点。
-SurfaceTexture从图像流（来自Camera预览，视频解码，GL绘制场景等）中获得帧数据，当调用updateTexImage()时，根据内容流中最近的图像更新SurfaceTexture对应的GL纹理对象，接下来，就可以像操作普通GL纹理一样操作它了。  SurfaceTexture 可以将 Surface 中最近的图像数据更新到 GL Texture 中。通过 GL Texture 我们就可以拿到视频帧，然后直接渲染到 GLSurfaceView 中。
+和SurfaceView功能类似，区别是，SurfaceTexure可以不显示在界面中。使用OpenGL对图片流进行美化，添加水印，滤镜这些操作的时候我们都是通过SurfaceTexre去处理，处理完之后再通过GLSurfaceView显示。
+
+缺点，可能会导致个别帧的延迟。本身管理着BufferQueue,所以内存消耗会多一点。  
+
+
+SurfaceTexture从图像流（来自Camera预览，视频解码，GL绘制场景等）中获得帧数据，当调用updateTexImage()时，根据内容流中最近的图像更新SurfaceTexture对应的GL纹理对象，接下来，就可以像操作普通GL纹理一样操作它了。
+
+SurfaceTexture可以将Surface中最近的图像数据更新到GL Texture中。通过GL Texture我们就可以拿到视频帧，然后直接渲染到GLSurfaceView中。       
+
+通过 **setOnFrameAvailableListener(listener)** 可以向 SurfaceTexture 注册监听事件，当Surface有新的图像可用时，调用SurfaceTexture的**updateTexImage()**方法将图像内容更新到GL Texture中，然后做绘制操作。
+
+SurfaceTexture中的attachToGLContext()和detachToGLContext()可以让多个GL context共享同一个内容源。      
+
+SurfaceTexture对象可以在任何线程上创建。      
+
+updateTexImage()只能在包含纹理对象的OpenGL ES上下文的线程上调用。 在任意线程上调用frame-available回调函数，不与updateTexImage()在同一线程上出现。
 
-通过 **setOnFrameAvailableListener(listener)** 可以向 SurfaceTexture 注册监听事件，当 Surface 有新的图像可用时，调用 SurfaceTexture 的 **updateTexImage()** 方法将图像内容更新到 GL Texture 中，然后做绘制操作。SurfaceTexture中的attachToGLContext()和detachToGLContext()可以让多个GL context共享同一个内容源。
-SurfaceTexture对象可以在任何线程上创建。 updateTexImage()只能在包含纹理对象的OpenGL ES上下文的线程上调用。 在任意线程上调用frame-available回调函数，不与updateTexImage()在同一线程上出现。
 
+--- 
 
+- [上一篇: 1.OpenGL简介](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/1.OpenGL%E7%AE%80%E4%BB%8B.md)        
 
-[上一篇: 1.OpenGL简介](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/1.OpenGL%E7%AE%80%E4%BB%8B.md)        
-[下一篇: 3.GLSurfaceView源码解析](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/3.GLSurfaceView%E6%BA%90%E7%A0%81%E8%A7%A3%E6%9E%90.md)
+- [下一篇: 3.GLSurfaceView源码解析](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/3.GLSurfaceView%E6%BA%90%E7%A0%81%E8%A7%A3%E6%9E%90.md)
 
 ---
 
diff --git "a/VideoDevelopment/OpenGL/20.\351\200\232\350\277\207OpenGL\351\242\204\350\247\210\345\271\266\345\275\225\345\210\266\350\247\206\351\242\221.md" "b/VideoDevelopment/OpenGL/20.\351\200\232\350\277\207OpenGL\351\242\204\350\247\210\345\271\266\345\275\225\345\210\266\350\247\206\351\242\221.md"
new file mode 100644
index 00000000..64e06971
--- /dev/null
+++ "b/VideoDevelopment/OpenGL/20.\351\200\232\350\277\207OpenGL\351\242\204\350\247\210\345\271\266\345\275\225\345\210\266\350\247\206\351\242\221.md"
@@ -0,0 +1,50 @@
+## 通过OpenGL预览并录制视频
+
+
+Camera将预览的画面通过SurfaceTexture输出给屏幕的GLSurfaceView以及视频编码的MediaCodec的Surface上。   
+
+
+将渲染的结果输出到不同的目标，我们需要使用一种称为离屏渲染的技术。    
+
+离屏渲染：就是让OpenGL不将渲染的结果直接输出到屏幕上，而是输出到一个中间缓冲区(一块GPU空间)，然后再将中间缓冲区的内容输出到屏幕或编码器等目标上，这就称为离屏渲染。    
+
+
+在Android系统下可以使用三种方法实现同时将OpenGL ES的内容输出给多个目标(屏幕和编码器):     
+
+- 二次渲染法
+收到数据后调用Shader程序进行渲染；将渲染结果输出到SurfaceView中显示到屏幕；然后我们需要切换当前渲染的EGLSurface，通过调用EGL的eglMakeCurrent方法，将默认SurfaceView的EGLSurface切换到MediaCodec的EGLSurface上，然后再次调用Shader程序进行渲染，并将渲染结果输出给MediaCodec的Surface进行编码。     
+
+因为调用了两次Shader程序进行渲染，每次渲染后的结果输送给不同的Surface，因此称为二次渲染法。    
+- FBO
+二次渲染会调用两次滤镜程序的draw方法，将同一个纹理绘制到不同的Surface上，但是如果要对图像进行一些美颜、高斯模糊等变换操作，那么我们就要对同一个纹理进行两次计算，这无疑是对GPU的浪费，且效率低下。    
+
+那如何只计算一次，把结果输出给不同的Surface呢？    
+OpenGL提供了一种高效的方法，即FBO(FrameBufferObject)。 
+
+FBO法中我们操作步骤如下：
+
+- 将渲染结果绘制到FBO中
+- 将FBO数据输送到屏幕中
+- 将FBO数据输送到编码器
+
+FBO法中，我们不直接将OpenGL ES的渲染结果输送给不同的Surface，而是将结果输出到FBO中，FBO可以理解为一块显存区域，用于存放OpenGL ES的渲染结果。
+我们知道CameraFilter着色器程序是将SurfaceTexture纹理渲染到EGLSurface中的，如何将纹理渲染到FBO帧缓冲区中呢，我们需要一个渲染到FBO中的着色器程序。
+渲染结果输出到FBO后，我们可以将FBO结果分别输出给不同的目标，FBO->屏幕，FBO->MediaCodec。而FBO输出到不同的目标也需要一个新的着色器去绘制。
+
+FBO高效的原理在于，纹理渲染到FBO中的前置操作。如果需要对纹理进行美颜、高斯模糊等复杂的计算，FBO确实能提高效率。如果没有复杂的计算，那么FBO和二次渲染法效率差不多。
+
+
+- glBlitFramebuffer: copy a block of pixels from the read framebuffer to the draw framebuffer
+
+
+该方式不再使用FBO做缓存，而是像二次渲染法一样，先将渲染的内容输出到当前Surface中，但并不展示到屏幕上。我们来看下这种方式的流程：
+
+- 先将渲染结果输送给SurfaceView的Surface
+- 切换Surface为MediaCodec的Surface，此时当前Surface为MediaCodec的
+- 利用OpenGL3.0提供的API glBlitFramebuffer从原来的Surface拷贝数据到当前Surface中，再调用EGL的eglSwapBuffers将Surface中的内容送编码器编码
+- 最后将当前Surface切回原来的Surface，也就是SurfaceView的Surface，同样调用EGL的eglSwapBuffers方法，将其内容显示到屏幕上
+
+该方式的效率是最高的，一次渲染输出给多个目标，但是只有OpenGL3.0才有该方法
+
+
+
diff --git "a/VideoDevelopment/OpenGL/3.GLSurfaceView\346\272\220\347\240\201\350\247\243\346\236\220.md" "b/VideoDevelopment/OpenGL/3.GLSurfaceView\346\272\220\347\240\201\350\247\243\346\236\220.md"
index d5c9e8ab..4453dcc7 100644
--- "a/VideoDevelopment/OpenGL/3.GLSurfaceView\346\272\220\347\240\201\350\247\243\346\236\220.md"
+++ "b/VideoDevelopment/OpenGL/3.GLSurfaceView\346\272\220\347\240\201\350\247\243\346\236\220.md"
@@ -689,9 +689,11 @@ public void setRenderer(Renderer renderer) {
 
 
 
+---
+
+- [上一篇: 2.GLSurfaceView简介](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/2.GLSurfaceView%E7%AE%80%E4%BB%8B.md)       
 
-[上一篇: 2.GLSurfaceView简介](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/2.GLSurfaceView%E7%AE%80%E4%BB%8B.md)       
-[下一篇: 4.GLTextureView实现](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/4.GLTextureView%E5%AE%9E%E7%8E%B0.md)
+- [下一篇: 4.GLTextureView实现](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/4.GLTextureView%E5%AE%9E%E7%8E%B0.md)
 
 ---
 
diff --git "a/VideoDevelopment/OpenGL/4.GLTextureView\345\256\236\347\216\260.md" "b/VideoDevelopment/OpenGL/4.GLTextureView\345\256\236\347\216\260.md"
index 86affc03..63981545 100644
--- "a/VideoDevelopment/OpenGL/4.GLTextureView\345\256\236\347\216\260.md"
+++ "b/VideoDevelopment/OpenGL/4.GLTextureView\345\256\236\347\216\260.md"
@@ -1,4 +1,4 @@
-### 4.GLTextureView实现
+## 4.GLTextureView实现
 
 系统提供了GLSurfaceView，确没有提供GLTextureView，但是我们目前的项目灰常复杂庞大，我不想去封一层接口，然后动态去选择使用GLSurfaceView(实现一些纹理效果)或者TextureView(无OpenGL效果)来播放视频。我只想在目前的基础上去扩展，我想去实现一个GLTextureView。上面分析完GLSurfaceView的源码后我们也可以自己去实现GLTextureView的功能了。具体的实现就是和GLSurfaceView的源码一模一样。
 
@@ -1977,9 +1977,10 @@ public class GLTextureView extends TextureView implements TextureView.SurfaceTex
 
 
 
+---
+- [上一篇: 3.GLSurfaceView源码解析](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/3.GLSurfaceView%E6%BA%90%E7%A0%81%E8%A7%A3%E6%9E%90.md)     
 
-[上一篇: 3.GLSurfaceView源码解析](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/3.GLSurfaceView%E6%BA%90%E7%A0%81%E8%A7%A3%E6%9E%90.md)     
-[下一篇: 5.OpenGL ES绘制三角形](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/5.OpenGL%20ES%E7%BB%98%E5%88%B6%E4%B8%89%E8%A7%92%E5%BD%A2.md)
+- [下一篇: 5.OpenGL ES绘制三角形](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/5.OpenGL%20ES%E7%BB%98%E5%88%B6%E4%B8%89%E8%A7%92%E5%BD%A2.md)
 
 ---
 
diff --git "a/VideoDevelopment/OpenGL/5.OpenGL ES\347\273\230\345\210\266\344\270\211\350\247\222\345\275\242.md" "b/VideoDevelopment/OpenGL/5.OpenGL ES\347\273\230\345\210\266\344\270\211\350\247\222\345\275\242.md"
index 18119b7d..be6c7acb 100644
--- "a/VideoDevelopment/OpenGL/5.OpenGL ES\347\273\230\345\210\266\344\270\211\350\247\222\345\275\242.md"	
+++ "b/VideoDevelopment/OpenGL/5.OpenGL ES\347\273\230\345\210\266\344\270\211\350\247\222\345\275\242.md"	
@@ -1,5 +1,6 @@
 ## 5.OpenGL ES绘制三角形
 
+
 OpenGL ES的绘制需要有以下步骤:   
 
 ### 1. 顶点输入
@@ -18,7 +19,24 @@ float vertices[] = {
      0.0f,  0.5f, 0.0f
 };
 ```
-定义这样的顶点数据以后，我们会把它作为输入发送给图形渲染管线的第一个处理阶段：顶点着色器。    
+定义这样的顶点数据以后，我们会把它作为输入发送给图形渲染管线的第一个处理阶段：顶点着色器。   
+
+
+
+在OpenGL ES2.0编程中，用于绘制的顶点数组数据首先保存在CPU内存，在调用glDrawArrays或glDrawElements等进行绘制时，需要将顶点数组数据从CPU内存拷贝到显存。     
+
+但是很多时候我们没必要每次绘制的时候都去进行内存拷贝，如果可以在显存中缓存这些数据，就可以在很大程度上降低内存拷贝带来的开销。   
+
+OpenGL ES3.0编程中，VBO和EBO的出现就是为了解决这个问题。    
+
+VBO和EBO的作用是在显存中提前开辟好一块内存，用于缓存顶点数据或者图元索引数据，从而避免每次绘制时的CPU和GPU之间的内存拷贝，可以改进渲染性能，降低内存带宽和功耗。  
+OpenGL ES3.0支持两类缓冲区对象: 顶点数组缓冲区对象、图元索引缓冲区对象。  
+
+GL_ARRAY_BUFFER标志指定的缓冲区对象用于保存顶点数组。   
+
+GL_EMELEMNT_ARRAY_BUFFER标志指定的缓存区对象用于保存图元索引。   
+
+ 
 **这里会在GPU上创建内存用于储存我们的顶点数据，还要配置OpenGL如何解释这些内存，并且指定其如何发送给显卡。**      
 
 顶点着色器接着会处理我们在内存中指定数量的顶点。
@@ -54,6 +72,8 @@ float vertices[] = {
     你后面会看到为什么我们会需要这个位置值。
     
 
+layout限定符是从OpenGL ES 3.0开始出现的，其主要用于设置变量的存储索引（即引用）值.    
+
 ##### 向量(Vector)
 
 在图形编程中我们经常会使用向量这个数学概念，因为它简明地表达了任意空间中的位置和方向，并且它有非常有用的数学属性。      
@@ -146,6 +166,10 @@ GLES30.glVertexAttribPointer(0, 3, GLES30.GL_FLOAT, false, 3 * 4, vertexBuffer);
 GLES30.glEnableVertexAttribArray(0);
 ```
 
+
+glEnableVertexAttribArray调用后允许顶点着色器读取句柄对应的GPU数据。默认情况下，出于性能考虑，所有顶点着色器的attribute变量都是关闭的，意味着数据在着色器端是不可见的，哪怕数据已经上传到GPU.由glEnableVertexAttribArray启用指定属性，才可在顶点着色器中访问逐顶点的attribute数据。glVertexAttribPointer或VBO只是建立CPU和GPU之间的逻辑连接，从而实现了CPU数据上传至GPU。但是，数据在GPU端是否可见，即着色器能否读取到数据，由是否启用了对应的属性决定，这就是glEnableVertexAttribArray的功能，允许顶点着色器读取GPU数据。
+
+
   glVertexAttribPointer函数的参数非常多，所以我会逐一介绍它们：
 
   - 第一个参数指定我们要配置的顶点属性。还记得我们在顶点着色器中使用`layout(location = 0)`定义了position顶点属性的位置值(Location)吗？它可以把顶点属性的位置值设置为`0`。因为我们希望把数据传递到这一个顶点属性中，所以这里我们传入`0`。
@@ -190,6 +214,7 @@ someOpenGLFunctionThatDrawsOurTriangle();
 绑定正确的缓冲对象，为每个物体配置所有顶点属性很快就变成一件麻烦事。有没有一些方法可以使我们把所有这些状态配置储存在一个对象中，并且可以通过绑定这个对象来恢复状态呢？
 
 顶点数组对象(Vertex Array Object, VAO)可以像顶点缓冲对象那样被绑定，任何随后的顶点属性调用都会储存在这个VAO中。    
+
 这样的好处就是，当配置顶点属性指针时，你只需要将那些调用执行一次，之后再绘制物体的时候只需要绑定相应的VAO就行了。    
 这使在不同顶点数据和属性配置之间切换变得非常简单，只需要绑定不同的VAO就行了。刚刚设置的所有状态都将存储在VAO中。
 
@@ -207,7 +232,7 @@ someOpenGLFunctionThatDrawsOurTriangle();
 IntBuffer arrays = IntBuffer.allocate(1);
 GLES30.glGenVertexArrays(1, arrays);
 ```
-要想使用VAO，要做的只是使用glBindVertexArray绑定VAO。从绑定之后起，我们应该绑定和配置对应的VBO和属性指针，之后解绑VAO供之后使用。    
+要想使用VAO，要做的只是使用glBindVertexArray绑定VAO(glBindVertexArrays()命令的目的是将指定的VAO标记为活跃，这样生成的缓冲区就会和这个VAO相关联)。从绑定之后起，我们应该绑定和配置对应的VBO和属性指针，之后解绑VAO供之后使用。    
 当我们打算绘制一个物体的时候，我们只要在绘制物体前简单地把VAO绑定到希望使用的设定上就行了。这段代码应该看起来像这样：
 
 VAO小助理偷偷帮我们记录一切：   
@@ -271,6 +296,12 @@ Preferences -> Plugins -> 搜GLSL Support安装就可以了。
 
 - 顶点着色器(triangle_vertex_shader.glsl)
 
+关键字in意思是输入(input)，表示这个顶点属性将会从缓冲区(C++或Java代码中的VBO、VAO等)中接收数值。
+顶点属性还可以改为被声明为out，这意味着它们会将值发送到管线中的下一个阶段。    
+
+layout(location=0)称为layout修饰符。也就是我们把顶点属性和特定缓冲区关联起来的方法，这意味着这个顶点属性的识别号是0.
+
+
 ```glsl 
 // 声明着色器的版本 
 #version 300 es 
@@ -444,11 +475,12 @@ public class TriangleRender implements GLSurfaceView.Renderer {
         //把颜色缓冲区设置为我们预设的颜色，绘图设计到多种缓冲区类型:颜色、深度和模板。这里只是向颜色缓冲区中绘制图形
         GLES30.glClear(GLES30.GL_COLOR_BUFFER_BIT);
         // glVertexAttribPointer是把顶点位置属性赋值给着色器程序
-        //0是上面着色器中写的vPosition的变量位置(location = 0)。意思就是绑定vertex坐标数据，然后将在vertextBuffer中的顶点数据传给vPosition变量。
+        // 0是上面着色器中写的vPosition的变量位置(location = 0)。意思就是绑定vertex坐标数据，然后将在vertextBuffer中的顶点数据传给vPosition变量。
         // 你肯定会想，如果我在着色器中不写呢？int vposition = glGetAttribLocation(program, "vPosition");就可以获得他的属性位置了
         // 第二个size是3，是因为上面我们triangleCoords声明的属性就是3位，xyz
         GLES30.glVertexAttribPointer(0, 3, GLES30.GL_FLOAT, false, 3 * Float.BYTES, vertexBuffer);
         //启用顶点变量，这个0也是vPosition在着色器变量中的位置，和上面一样，在着色器文件中的location=0声明的
+        // 也就是说由于vPosition在着色器中的位置被指定为0，因此可以简单的通过glVertexAttribPointer()函数调用中的第一个参数和在glEnableVertexAttribArray()函数调用中使用0来引用此变量
         GLES30.glEnableVertexAttribArray(0);
 
         //准备颜色数据
@@ -628,6 +660,11 @@ public class TriangleRender implements GLSurfaceView.Renderer {
 - 如何将这个矩阵传递给GLSL中。(与获取顶点索引类似，可以在GLSL中声明一个mat4类型的矩阵变量，获取其索引，再传递值给它)
 
 
+## 数学概念
+
+
+
+
 
 ### 向量（Vector)
 
@@ -635,6 +672,18 @@ public class TriangleRender implements GLSurfaceView.Renderer {
 在GLSL中一个向量有最多4个分量，每个分量值都代表空间中的一个坐标，它们可以通过vec.x、vec.y、vec.z和vec.w来获取。         
 vec.w分量不是用作表达空间中的位置(因为我们处理的是3D不是4D)，而是用在所谓透视划分上。
 
+
+3D空间中的点可以通过使用形如(2, 8, −3)的符号列出x、y、z的值来表示。       
+
+不过，如果用齐次坐标—— 一种在19世纪初首次描述的表示法来表示点会更有用。      
+
+在每个点的齐次坐标有4个值，前3个值表示x、y和z，第四个值w总是非零值，通常为1。因此，我们会将之前的点表示为(2, 8, −3, 1)。
+
+用来存储齐次3D坐标的GLSL数据类型是vec4（“vec”代表向量，同时也可以用来表示点）。    
+
+
+
+
 ### 矩阵
 
 由m*n个数按照一定顺序排列成m行n列的矩形数表称为矩阵，而向量则是由n个有序数组成的数组。       
@@ -645,6 +694,44 @@ vec.w分量不是用作表达空间中的位置(因为我们处理的是3D不是
 OpenGL中使用的是列向量，如[xyzx]T，所以与矩阵相乘时，矩阵在前，向量在后，最终通过变换矩阵得到想要的向量。
 
 
+矩阵是矩形的值的阵列，它的元素通常使用下标访问。第一个下标表示行号，第二个下标表示列号，下标从0开始。我们在3D图形计算中要用到的矩阵尺寸常为4×4。    
+
+![image](https://github.com/CharonChui/Pictures/blob/master/opengl_matrix.png?raw=true)
+
+GLSL中的mat4数据类型用来存储4×4矩阵。
+
+单位矩阵中一条对角线的值为1，其余值全为0。任何点或矩阵乘单位矩阵都不会改变。在GLM中，调用构造函数glm::mat4 m(1.0f)可以在变量m中生成单位矩阵。
+
+
+
+**在图形学中，矩阵通常用来进行物体的变换。例如矩阵可以用来将点从一处移动到另一处。**
+
+
+矩阵变换:     
+
+- 平移矩阵
+- 缩放矩阵
+缩放矩阵除了放大缩小之外，还可以用来切换坐标系。       
+例如，我们可以用缩放来在给定右手坐标系的情况下确定左手坐标系中的坐标。 通过反转Z坐标就可以在右手坐标系和左手坐标系中切换。
+
+- 旋转矩阵
+
+数学家欧拉表明，围绕任何轴的旋转都可以表示为绕x轴、y轴、z轴旋转的组合。围绕这3个轴的旋转角度被称为欧拉角。       
+这个被称为欧拉定理的发现对我们很有用，因为对于每个坐标轴的旋转可以用矩阵变换来表示。    
+
+实践中，当在3D空间中旋转轴不穿过原点时，物体使用欧拉角进行旋转需要几个额外的步骤，一般有：    
+
+1. 平移旋转轴以使它经过原点
+2. 绕x轴、y轴、z轴旋转适当的欧拉角
+3. 服用步骤1中的平移
+
+
+- 投影矩阵
+- LookAt矩阵
+
+变换矩阵的重要特性之一就是它们都是4x4的矩阵。这是因为我们决定使用齐次坐标系。 否则，各变换矩阵可能会有不同的纬度并且无法想乘。    
+
+
 
 ### 相机
 
@@ -1108,10 +1195,10 @@ public class IsoTriangleRender implements GLTextureView.Renderer {
 
 
 
+---
 
-
-[上一篇: 4.GLTextureView实现](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/4.GLTextureView%E5%AE%9E%E7%8E%B0.md)  
-[下一篇: 6.OpenGL ES绘制矩形及圆形](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/6.OpenGL%20ES%E7%BB%98%E5%88%B6%E7%9F%A9%E5%BD%A2%E5%8F%8A%E5%9C%86%E5%BD%A2.md)
+- [上一篇: 4.GLTextureView实现](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/4.GLTextureView%E5%AE%9E%E7%8E%B0.md)  
+- [下一篇: 6.OpenGL ES绘制矩形及圆形](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/6.OpenGL%20ES%E7%BB%98%E5%88%B6%E7%9F%A9%E5%BD%A2%E5%8F%8A%E5%9C%86%E5%BD%A2.md)
 
 ---
 
diff --git "a/VideoDevelopment/OpenGL/6.OpenGL ES\347\273\230\345\210\266\347\237\251\345\275\242\345\217\212\345\234\206\345\275\242.md" "b/VideoDevelopment/OpenGL/6.OpenGL ES\347\273\230\345\210\266\347\237\251\345\275\242\345\217\212\345\234\206\345\275\242.md"
index f9319879..ff975060 100644
--- "a/VideoDevelopment/OpenGL/6.OpenGL ES\347\273\230\345\210\266\347\237\251\345\275\242\345\217\212\345\234\206\345\275\242.md"	
+++ "b/VideoDevelopment/OpenGL/6.OpenGL ES\347\273\230\345\210\266\347\237\251\345\275\242\345\217\212\345\234\206\345\275\242.md"	
@@ -143,6 +143,8 @@ public abstract class BaseGLSurfaceViewRenderer implements GLSurfaceView.Rendere
 ![](https://raw.githubusercontent.com/CharonChui/Pictures/master/opengl_es_gl_triangle.jpg)
 
 
+OpenGL ES中仅允许采用三角形来搭建物体。其实这从构造能力上来说并没有区别，因为任何多边形都可以拆分为多个三角形。OpenGL ES中之所以仅支持三角形而不支持任意多边形是出于性能的考虑，就目前移动嵌入式设备的硬件性能情况来看，这是必然的选择了。
+
 
 ### 顶点法和索引法
 
@@ -514,8 +516,18 @@ public class CircleRender extends BaseGLSurfaceViewRenderer {
 }
 ```
 
-[上一篇: 5.OpenGL ES绘制三角形](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/5.OpenGL%20ES%E7%BB%98%E5%88%B6%E4%B8%89%E8%A7%92%E5%BD%A2.md)       
-[下一篇: 7.OpenGL ES着色器语言GLSL](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/7.OpenGL%20ES%E7%9D%80%E8%89%B2%E5%99%A8%E8%AF%AD%E8%A8%80GLSL.md)
+
+### OpenGL支持的图元
+
+
+![image](https://github.com/CharonChui/Pictures/blob/master/opengl_tuyuan.png?raw=true)
+
+
+
+--- 
+
+- [上一篇: 5.OpenGL ES绘制三角形](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/5.OpenGL%20ES%E7%BB%98%E5%88%B6%E4%B8%89%E8%A7%92%E5%BD%A2.md)       
+- [下一篇: 7.OpenGL ES着色器语言GLSL](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/7.OpenGL%20ES%E7%9D%80%E8%89%B2%E5%99%A8%E8%AF%AD%E8%A8%80GLSL.md)
 
 ---
 
diff --git "a/VideoDevelopment/OpenGL/7.OpenGL ES\347\235\200\350\211\262\345\231\250\350\257\255\350\250\200GLSL.md" "b/VideoDevelopment/OpenGL/7.OpenGL ES\347\235\200\350\211\262\345\231\250\350\257\255\350\250\200GLSL.md"
index 6e1414d8..12bb9706 100644
--- "a/VideoDevelopment/OpenGL/7.OpenGL ES\347\235\200\350\211\262\345\231\250\350\257\255\350\250\200GLSL.md"	
+++ "b/VideoDevelopment/OpenGL/7.OpenGL ES\347\235\200\350\211\262\345\231\250\350\257\255\350\250\200GLSL.md"	
@@ -1,5 +1,16 @@
 ## 7.OpenGL ES着色器语言GLSL
 
+### 齐次坐标(Homogeneous coordinates)
+
+三维顶点视为三元组(x,y,z)。现在引入一个新的分量w，得到向量(x,y,z,w)。请先记住以下两点：
+
+若w==1，则向量(x, y, z, 1)为空间中的点。
+若w==0，则向量(x, y, z, 0)为方向。
+
+齐次坐标使得我们可以用同一个公式对点和方向作运算。
+
+
+
 着色器是使用一种叫GLSL的类C语言写成的。GLSL是为图形计算量身定制的，它包含一些针对向量和矩阵操作的有用特性。
 
 着色器的开头总是要声明版本，接着是输入和输出变量、uniform和main函数。       
@@ -53,9 +64,23 @@ OpenGL ES版本有自己的着色器语言，其中OpenGL ES的版本与GLSL的
 
 - OpenGL ES 3.0的shader中没有texture2D()和texture3D等了，全部使用texture()方法替换。
 
-- 300版本中布局限定符可以声明顶点着色器输入和片段着色器输出的问题，例如layout(location = 2) in vec3 values[4];
+- 可直接使用layout制定属性值。 300版本中布局限定符可以声明顶点着色器输入和片段着色器输出的问题，例如layout(location = 2) in vec3 values[4];，如果不限定该属性的位置为2，需要通过glGetAttribuLocation()查询
 
-- 舍弃了gl_FragColor和gl_FragData内置属性，变成我们需要自己使用out关键字定义的属性，例如out vec4 fragColor，这就是为什么你从网还是哪个找到的代码换成GLSL ES 300版本后报错的原因。
+片元着色器中，layout限定符通过location值将输出变量和指定编号的绘制缓冲绑定起来。每一个输出变量的索引(引用)值都会对应到一个相应编号的绘制缓冲，而这个输出变量的值将写入相应缓冲。    
+
+layout限定符的location值是有范围的，其范围为[0, MAX_DRAW_BUFFERS-1]。不同手持设备的范围有可能不同，最基本的范围是[0, 3]。  
+
+```glsl
+// 此输出变量写入到0号绘制缓冲
+layout(location = 0) out vec4 fragColor;
+// 此输出变量写入到1号绘制缓冲
+layout(location = 1) out vec4 colors[2];
+
+```
+顶点着色器不允许有layout输出限定符。 如果在片元着色器中只有一个输出变量，则不需要用layout修饰符说明其对应绘制缓冲，在这种情况下，默认值为0。     
+如果片元着色器中有多个输出变量，则不允许重复使用相同的location值。   
+
+- 舍弃了gl_FragColor和gl_FragData内置属性，变成我们需要自己使用out关键字定义的属性，例如out vec4 fragColor，这就是为什么你从网还是哪个找到的代码换成GLSL ES 300版本后报错的原因。不过保留了gl_Position
 
 - GL_OES_EGL_image_external被废弃
 
@@ -118,6 +143,14 @@ void main()
 由于我们在顶点着色器中将颜色设置为深红色，最终的片段也是深红色的。
 
 
+
+
+顶点着色器中用in限定符修饰的变量其值实质是由宿主程序（本书中为Java、C++）批量传入渲染管线的，管线进行基本处理后再传递给顶点着色器。       数据中有多少个顶点，管线就调用多少次顶点着色器，每次将一个顶点的各种属性数据传递给顶点着色器中对应的in变量。因此，顶点着色器每次执行将完成对一个顶点各项属性数据的处理。
+
+
+顶点着色器每顶点执行一次，而片元着色器每片元执行一次，片元着色器的执行次数明显大于顶点着色器的执行次数。因此在开发中，应尽量减少片元着色器的运算量，可以将一些复杂运算尽量放在顶点着色器中执行。
+
+
 ####  精度限定符
 
 精度限定符使着色器创作者可以指定着色器变量的计算精度。变量可以声明为低、中或者高精度。这些限定符用于提示编译器允许在较低的范围和精度上执行变量计算。在较低的精度上，有些OpenGL ES实现在运行着色器时可能更快，或者电源效率更高。
@@ -140,7 +173,25 @@ precision mediump int;
 
 
 #### Uniform
-Uniform是一种从CPU中的应用向GPU中的着色器发送数据的方式，但uniform和顶点属性有些不同。     
+
+Uniform是一种从CPU中的应用向GPU中的着色器发送数据的方式，但uniform和顶点属性有些不同： 
+
+- uniform是全局的(Global)。全局意味着uniform变量必须在每个着色器程序对象中都是独一无二的，而且它可以被着色器程序的任意着色器在任意阶段访问。   
+
+- 无论你把uniform值设置成什么，uniform会一直保存它们的数据，直到它们被重置或更新。    
+
+
+CPU在处理并行线程的时候，每个线程负责给完整图像的一部分配置颜色。    
+尽管每个线程和其他线程之间不能有数据交换，但我们能从CPU给每个线程输入数据。    
+因为显卡的架构，所有线程的输入值必须统一(uniform)，而且必须设为只读。      
+
+也就是说，每条线程接收相同的数据，并且是不可改变的数据。这些输入值叫做uniform(统一值). 
+
+按业界传统应该在uniform值的名字前加u_，这样一看便知是uniform。    
+
+Uniform是一种从CPU中的应用向GPU中的着色器发送数据的方式，但uniform和顶点属性有些不同。 
+
+你可以把uniform想象成连通CPU和GPU的许多的小桥梁。        
 
 首先，uniform是全局的(Global)。         
 全局意味着uniform变量必须在每个着色器程序对象中都是独一无二的，而且它可以被着色器程序的任意着色器在任意阶段访问。       
@@ -202,6 +253,14 @@ glUniform4f(vertexColorLocation, 0.0f, greenValue, 0.0f, 1.0f);
 现在你知道如何设置uniform变量的值了，我们可以使用它们来渲染了。如果我们打算让颜色慢慢变化，我们就要在游戏循环的每一次迭代中（所以他会逐帧改变）更新这个uniform，否则三角形就不会改变颜色。        
 
 
+顶点着色器中的乘法将矩阵变换应用于顶点，将其转换为相机空间（请注意从右到左的计算顺序）。这些值被放入内置的OpenGL输出变量gl_Position中，然后继续通过管线，并由光栅着色器进行插值。
+插值后的像素位置（称为片段）被发送到片段着色器(fragment shader)。回想一下，片段着色器的主要目的是设置输出像素的颜色。与顶点着色器的方式类似，片段着色器逐个处理像素，并对每个像素单独调用。
+
+
+![image](https://github.com/CharonChui/Pictures/blob/master/opengl_progress_11.png?raw=true)
+
+
+
 
 ### GLSL的特点
 
@@ -256,6 +315,24 @@ vec2 vect = vec2(0.5, 0.7);
 vec4 result = vec4(vect, 0.0, 0.0);
 ```
 
+#### vec4表示矩形
+
+通常，一个矩形可以用其左上角位置（x, y），宽度（width），高度（height）来定义。我们可以将这些值存储在一个 vec4 中，如下：
+
+```glsl
+vec4 rect = vec4(x, y, width, height);
+```
+
+这里的 rect 向量表示:    
+
+- rect.x 是矩形的左上角的 x 坐标。
+- rect.y 是矩形的左上角的 y 坐标。
+- rect.z 是矩形的宽度。
+- rect.w 是矩形的高度。
+
+
+
+
 - 矩阵
 
 在GLSL中矩阵拥有2 * 2、3 * 3、4 * 4三种类型的矩阵，分别用mat2、mat3、mat4表示。         
@@ -265,9 +342,53 @@ vec4 result = vec4(vect, 0.0, 0.0);
 
 矩阵可以通过(i, j)进行索引，i是行，j是列，这就是上面的矩阵叫做2×3矩阵的原因（3列2行，也叫做矩阵的维度(Dimension)）。这与你在索引2D图像时的(x, y)相反，获取4的索引是(2, 1)（第二行，第一列）（译注：如果是图像索引应该是(1, 2)，先算列，再算行）
 
+矩阵的构造方法则更加灵活，有以下规则:      
+
+- 如果对矩阵构造器只提供了一个标量参数，该值会作为矩阵的对角线上的值。例如 mat4(1.0) 可以构造一个 4 × 4 的单位矩阵
+- 矩阵可以通过多个向量作为参数来构造，例如一个 mat2 可以通过两个 vec2 来构造
+- 矩阵可以通过多个标量作为参数来构造，矩阵中每个值对应一个标量，按照从左到右的顺序
+
+```glsl
+mat3 myMat3 = mat3(1.0, 0.0, 0.0,  // 第一列
+                   0.0, 1.0, 0.0,  // 第二列
+                   0.0, 1.0, 1.0); // 第三列
+```
+
+
+三维图形学中我们只用到4x4矩阵，它能对顶点(x,y,z,w)作变换。这一变换是用矩阵左乘顶点来实现的：
+
+矩阵x顶点（记住顺序！！矩阵左乘顶点，顶点用列向量表示）= 变换后的顶点
+
+![image](https://github.com/CharonChui/Pictures/blob/master/MatrixXVect.gif?raw=true)
+
+这看上去复杂，实则不然。左手指着a，右手指着x，得到ax。 左手移向右边一个数b，右手移向下一个数y，得到by。依次类推，得到cz、dw。最后求和ax + by + cz + dw，就得到了新的x！每一行都这么算下去，就得到了新的(x, y, z, w)向量。
+
+
+这种重复无聊的计算就让计算机代劳吧。
+
+用C++，GLM表示：
+```c++
+glm::mat4 myMatrix;
+glm::vec4 myVector;
+// fill myMatrix and myVector somehow
+glm::vec4 transformedVector = myMatrix * myVector; // Again, in this order ! this is important.
+```
+
+用GLSL表示:      
+
+```glsl
+mat4 myMatrix;
+vec4 myVector;
+// fill myMatrix and myVector somehow
+vec4 transformedVector = myMatrix * myVector; // Yeah, it's pretty much the same than GLM
+```
+
+
+
+
 - 采样器
 
-  采样器是专门用来对纹理进行采样工作的，在GLSL中一般来说，一个采样器变量表示一副或者一套纹理贴图。所谓的纹理贴图可以理解为我们看到的物体上的皮肤。
+  采样器是着色语言中不同于C语言的一种特殊的基本数据类型，采样器是专门用来对纹理进行采样工作的，在GLSL中一般来说，一个采样器变量表示一副或者一套纹理贴图。所谓的纹理贴图可以理解为我们看到的物体上的皮肤。
 
 - 结构体
 
@@ -338,7 +459,7 @@ GLSL的类型转换与C不同。在GLSL中类型不可以自动提升，比如fl
 片段着色器的内建变量
 
 - 输入变量
-  - gl_FragCoord:当前片元在framebuffer画面的相对位置
+  - gl_FragCoord:当前片元在framebuffer画面的相对位置(输入片段的坐标)
   - gl_FragFacing:bool型，表示是否为属于光栅化生成此片元的对应图元的正面。
   - gl_PointCoord:经过插值计算后的纹理坐标，点的范围是0.0到1.0
 - 输出变量
@@ -457,9 +578,47 @@ glVertexAttribPointer函数的前几个参数比较明了。这次我们配置
 同样，这次我们必须指定一个偏移量。对于每个顶点来说，位置顶点属性在前，所以它的偏移量是0。颜色属性紧随位置数据之后，所以偏移量就是Float.BYTES，用字节来计算就是12字节。    
 
 
+### 着色器示例
+
+```
+顶点着色器如下：
+#version 430
+
+layout (location=0) in vec3 position;
+uniform mat4 mv_matrix;
+uniform mat4 proj_matrix;
+
+out vec4 varyingColor;
+
+void main(void)
+{  gl_Position = proj_matrix * mv_matrix * vec4(position,1.0);
+    varyingColor = vec4(position,1.0) * 0.5 + vec4(0.5, 0.5, 0.5, 0.5);
+}
+
+
+着色器如下：
+#version 430
+
+in vec4 varyingColor;
+
+out vec4 color;
+uniform mat4 mv_matrix;
+uniform mat4 proj_matrix;
+
+void main(void)
+{  color = varyingColor;
+}
+请注意，因为颜色是从顶点着色器的顶点属性varyingColor中发出的，所以它们也由光栅着色器进行插值！
+```
+
+请注意，代码中将位置坐标乘1/2，然后加1/2，以将取值区间从[−1, +1]转换为[0, 1]。此外，由程序员定义的插值顶点属性变量名称中通常包含单词“varying”，这是一种约定俗成的做法。修改的具体位置已突出显示。
+
+
+
+---
 
-[上一篇: 6.OpenGL ES绘制矩形及圆形](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/6.OpenGL%20ES%E7%BB%98%E5%88%B6%E7%9F%A9%E5%BD%A2%E5%8F%8A%E5%9C%86%E5%BD%A2.md)  
-[下一篇: 8.GLES类及Matrix类](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/8.GLES%E7%B1%BB%E5%8F%8AMatrix%E7%B1%BB.md)
+- [上一篇: 6.OpenGL ES绘制矩形及圆形](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/6.OpenGL%20ES%E7%BB%98%E5%88%B6%E7%9F%A9%E5%BD%A2%E5%8F%8A%E5%9C%86%E5%BD%A2.md)  
+- [下一篇: 8.GLES类及Matrix类](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/8.GLES%E7%B1%BB%E5%8F%8AMatrix%E7%B1%BB.md)
 
 ---
 
diff --git "a/VideoDevelopment/OpenGL/8.GLES\347\261\273\345\217\212Matrix\347\261\273.md" "b/VideoDevelopment/OpenGL/8.GLES\347\261\273\345\217\212Matrix\347\261\273.md"
index 01eb63e1..4bc0353a 100644
--- "a/VideoDevelopment/OpenGL/8.GLES\347\261\273\345\217\212Matrix\347\261\273.md"
+++ "b/VideoDevelopment/OpenGL/8.GLES\347\261\273\345\217\212Matrix\347\261\273.md"
@@ -138,6 +138,70 @@ GLES30.glVertexAttribPointer(1, 4, GLES30.GL_FLOAT, false, 0, colorBuffer);
 
 如果启用，那么当GLES30.glDrawArrays或者GLES30.glDrawElements被调用时，顶点属性数组会被使用。
 
+
+
+
+尽管现在已经知道了如何创建一个物体、着色、加入纹理，给它们一些细节的表现，但因为它们都还是静态的物体，仍不够有趣。      
+
+我们可以尝试着在每一帧改变物体的顶点并且重配置缓冲区从而使它移动，但这太繁琐了，而且会消耗很多的处理时间。     
+我们现在有一个更好的解决方案，使用(多个)矩阵(Matrix)对象可以更好的变换(Transform)一个物体。     
+
+为了更好的了解矩阵，需要先了解向量.   
+
+## 向量
+
+向量有一个方向(Direction)和大小(Magnitude，也叫强度或长度)。      
+
+你可以把向量想象成一个藏宝图上的指示: 向左走10步，向北走3步，然后向右走5步。    
+
+这里面左就是方向，10步就是向量的长度。       
+
+向量可以在任何维度(Dimension)上，但是我们通常只使用2至4维。    
+如果一个向量有2个维度，它表示一个平面的方向(想象一下2D的图像)。    
+当它有3个维度的时候它可以表达一个3D世界的方向。      
+
+
+
+![image](https://github.com/CharonChui/Pictures/blob/master/glsl_vector_0.png?raw=true)
+
+上图中有3个向量，每个向量在2D图像中都用一个箭头(x, y)表示。    
+***由于向量表示的是方向，起始于何处并不会改变它的值。***
+例如上面的向量v和w是相等的，尽管他们的起始点不同。         
+
+
+由于向量是一个方向，所以有些时候会很难形象的将它们用位置(Position)表示出来。     
+为了让其更为直观，我们通常设定这个方向的原点为(0, 0, 0),然后指定一个方向，对应一个点，使其变为位置向量(Position Vector)。     
+你也可以把起点设置为其他的点，然后说这个向量从这个点起始指向另一个点。     
+
+比如说位置向量(3, 5)在图像中的起点会是(0, 0)，并会指向(3, 5)。我们可以使用向量在2D或3D空间中表示方向与位置。      
+
+
+### 向量相乘
+
+两个向量相乘是一种很奇怪的情况。     
+普通的乘法在向量上是没有定义的，因为它在视觉上是没有意义的。     
+
+但是在相乘的时候我们有两种特定情况可以选择:     
+
+- 一个是点乘(Dot Product)
+- 一个是叉乘(Cross Product)
+
+
+##### 点乘
+
+两个向量的点乘等于它们的数乘结果乘以两个向量之间夹角的余弦值。    
+
+##### 叉乘 
+
+叉乘只在3D空间中有定义，它需要两个不平行向量作为输入，生成一个正交于两个输入向量的第三个向量。    
+如果输入的两个向量也是正交的，那么叉乘之后将会产生3个相互正交的向量。   
+下面的图就是3D控件中叉乘的样子:     
+
+![image](https://github.com/CharonChui/Pictures/blob/master/opengl_chacheng.png?raw=true)
+
+
+
+
 ## Matrix
 
 Matrix就是专门设计出来帮助我们简化矩阵和向量运算操作的，里面所有的实现原理都是线性代数中的运算。
@@ -146,6 +210,11 @@ Matrix就是专门设计出来帮助我们简化矩阵和向量运算操作的
 利用这点，我们构建一个的矩阵，与图形所有的顶点坐标坐标相乘，得到新的顶点坐标集合，当这个矩阵构造恰当的话，新得到的顶点坐标集合形成的图形相对原图形就会出现平移、旋转、缩放或拉伸、抑或扭曲的效果。    
 Matrix是专门为处理4*4矩阵和4元素向量设计的，其中的方法都是static的，不需要初始化Matrix实例。
 
+
+
+OpenGL ES中使用的是列向量。列向量和矩阵相乘实现变换时，只能在列向量前面乘以矩阵。    
+而行向量则反之，否则乘法没有意义。   
+
 - multiplyMM
 
   两个4x4矩阵相乘，并将结果存储到第三个4x4矩阵中。
@@ -170,6 +239,46 @@ Matrix是专门为处理4*4矩阵和4元素向量设计的，其中的方法都
   获取逆矩阵
 
 
+
+平移、旋转、缩放等基本变换都是通过将表示点坐标的向量与特定的变换矩阵相乘完成的，进行基于矩阵的变换时，三维空间中点的位置需要表示成齐次坐标形式。   
+
+所谓齐次坐标形式也就是在x、y、z 3个坐标值后面增加第四个量w，未变换时w值一般为1。
+
+所谓齐次坐标表示就是用N+1维坐标表示N维坐标。     
+
+齐次坐标是为了兼容点的平移操作，使得我们可以用同一个公式对点和方向做运算。  y
+采用齐次坐标是由于很多在N维空间中难以解决的问题在N+1维空间中会变得比较简单。
+
+
+
+
+
+##### 旋转变换
+
+OpenGL ES中，旋转角度的正负可以用右手螺旋定则来确定。  
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/gl_rotate_youshou.png?raw=true)
+
+所谓右手螺旋定则是指:    
+
+右手握住旋转轴，使大拇指指向旋转轴的正方向，4指环绕的方向即为旋转的正方向，也就是旋转角度为正值。       
+
+
+
+### 基本变换的实质    
+
+上面说到的3中基本变换的实现方法，给人的感觉是通过矩阵直接实现了对物体的变换。    
+
+但在OpenGL ES中这并不完全准确，若仅仅这样来理解在非常简单的情况下可能没有问题，但在多个物体的组合变换中可能就会产生问题了。    
+
+这是因为变换实际上并不是直接针对物体的，而是针对坐标系进行的。    
+
+OpenGL ES中变换的实现机制可以理解为首先通过矩阵对坐标系进行变换，然后根据传入渲染管线的原始顶点坐标在最终变换结果坐标系中的位置来绘制。   
+
+
+
+
+
 ### 相机
 
 顶点着色器可赋予程序员一次操作一个顶点（“按顶点”处理）的能力，片段着色器（稍后会看到）可赋予程序员一次操作一个像素（“按片段”处理）的能力，几何着色器可赋予程序员一次操作一个图元（“按图元”处理）的能力。
@@ -179,6 +288,8 @@ Matrix是专门为处理4*4矩阵和4元素向量设计的，其中的方法都
 为了达成这个目标，我们需要找到一个有利点。       
 正如我们在现实世界通过眼睛从一点观察一样，我们也必须找到一点并确立观察方向作为我们观察虚拟世界的窗口。这个点叫作视图或视觉空间，或“合成相机”（简称相机）。
 
+
+
 观察3D世界需要:    
 
 - 将相机放入世界的某个位置；
@@ -195,6 +306,28 @@ OpenGL有一个固定在原点(0,0,0)并朝向z轴负方向的相机，如下图
 给定世界空间中的点PW，我们需要通过变换将它转换成相应相机空间中的点，从而让它看起来好像是从我们期望的相机位置CW看到的样子。    
 
 
+从日常生活的经验中可以很容易的了解到，随着摄像机位置、姿态的不同，就算是对同一个场景进行拍摄，得到的画面也是迥然不同的。    
+
+因此摄像机的位置、姿态在OpenGL应用程序的开发中就显得非常重要。
+
+摄像机的设置需要给出3个方面的信息，包括摄像机的位置、观察的方向以及up方向，
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/gl_shexiangji_1.png?raw=true)
+
+- 摄像机的位置很容易理解，用其在3D空间中的坐标来表示。   
+- 摄像机观察的方向可以理解为摄像机镜头的指向，用一个观察目标点来表示(通过摄像机位置与观察目标点可以确定一个向量，此向量即代表了摄像机观察的方向)。
+- 摄像机的up方向可以理解为摄像机顶端的指向，用一个向量来表示。   
+
+通过摄像机拍摄场景与人眼观察现实世界很类似，因此，通过人眼对现实世界观察的切身感受可以理解摄像机的哥哥参数:    
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/gl_renyan_1.png?raw=true)
+
+从上图可以看出，摄像机的位置、朝向、up方向可以有很多不同的组合。   
+例如: 同样的位置可以有不同的朝向，不同的up方向。   
+
+
+
+
 当我们设置好相机之后，就可以学习投影矩阵了。我们需要学习的两个重要的投影矩阵：透视投影矩阵和正射投影矩阵。    
 透视投影通过使用透视概念模仿我们看真实世界的方式，尝试让2D图像看起来像是3D的。物体近大远小，3D空间中有的平行线用透视法画出来就不再平行。我们可以通过使用变换矩阵将平行线变为恰当的不平行线来实现这个效果，这个矩阵叫作透视矩阵或者透视变换。           
 
@@ -209,9 +342,109 @@ OpenGL有一个固定在原点(0,0,0)并朝向z轴负方向的相机，如下图
 
   计算正交投影和透视投影
 
+
+
+### 正交投影
+
 - orthoM
 
-  计算正交投影矩阵
+  计算正交投影矩阵    
+
+OpenGL ES 3.0中，根据应用程序中提供的投影矩阵，管线会确定一个可视空间区域，称为视景体。视景体是由6个平面确定的，这6个平面分别为：上平面（up）、下平面（down）、左平面（left）、右平面（right）、远平面（far）、近平面（near）。场景中处于视景体内的物体会被投影到近平面上（视景体外面的物体将被裁剪掉），然后再将近平面上投影出的内容映射到屏幕上的视口中。
+
+
+OpenGL ES 3.0中，根据应用程序中提供的投影矩阵，管线会确定一个可视空间区域，称为视景体。视景体是由6个平面确定的，这6个平面分别为：上平面（up）、下平面（down）、左平面（left）、右平面（right）、远平面（far）、近平面（near）。场景中处于视景体内的物体会被投影到近平面上（视景体外面的物体将被裁剪掉），然后再将近平面上投影出的内容映射到屏幕上的视口中。
+
+
+对于正交投影而言，视景体及近平面的情况如下图所示:    
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/gl_zhengjiao_1.png?raw=true)
+
+视点为摄像机的位置；离视点较近（距离为near）​，垂直于观察方向向量的平面为近平面，离视点较远（距离为far）​，垂直于观察方向向量的平面为远平面。与观察向量平行，从上下左右4个方向约束视景体范围的4个平面分别为上平面、下平面、左平面、右平面，这4个平面与视景体中心轴线的距离分别为top、bottom、left、right。
+
+由于正交投影是平行投影的一种，其投影线（物体的顶点与近平面上投影点的连线）是平行的。故其视景体为长方体，投影到近平面上的图形不会产生真实世界中“近大远小”的效果:      
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/gl_zhengjiao_2.png?raw=true)
+
+通过Matrix类的orthoM方法完成对正交投影的设置，其基本代码如下:   
+
+```glsl
+Matrix.orthoM (
+    mProjMatrix,         // 生成矩阵元素的float[]类型数据
+    0,                   // 起始偏移量
+    left, right,         // near面的left right
+    bottom, top,         // near面的bottom, top
+    near, far,           // near面、far面与视点的距离
+)
+```
+
+
+orthoM方法的功能为根据接收的6个正交投影相关参数产生正交投影矩阵，并将矩阵的元素填充到指定的数组中。    
+
+参数left, right为近平面左右侧边对应的x坐标，top、bottom为近平面上下侧边对应的y坐标，分别用来确定左平面、右平面、上平面、下平面的位置。    
+
+参数near、far粉笔嗯为视景体近平面与远平面距视点的距离。    
+
+
+场景中的物体投影到近平面后，最终会映射到显示屏上的视口中。     
+
+视口也就是显示屏上指定的矩形区域，通过如下代码进行设置:    
+
+```glsl
+GLES30.glViewport(x, y, width, height);   
+```
+
+从近平面到视口的映射是由渲染管线自动完成的。
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/gl_zhengjiao_sample.png?raw=true)
+
+上图是由一组距离观察点原来越远的相同尺寸的六角星构成。由于采用的投影方式为正交投影，因此，最终显示在屏幕上的每个六角星尺寸都相同。     
+
+
+### 透视投影
+
+现实世界中人眼观察物体时会有“近大远小”的效果。     
+
+因此，想要开发出更加真实的场景，仅使用正交投影是远远不够的，这时可以采用透视投影。    
+
+透视投影的投影线是不平行的，他们相交于视点。    
+
+通过透视投影，可以产生现实世界中“近大远小”的效果，大部分3D游戏采用的都是透视投影。    
+
+透视投影中，视景体位锥台形区域，如下图:    
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/gl_toushi_1.png?raw=true)
+
+视点为摄像机的位置；离视点较近（距离为near），垂直于观察方向向量的平面为近平面；离视点较远（距离为far），垂直于观察方向向量的平面为远平面。近平面左侧距中心的距离为left，右侧为right，上侧为top，下侧为bottom。由观察点与近平面左上、左下、右上、右下4个的点连线与远平面的交点可以确定上、下、左、右4个斜面，这4个斜面及远近平面确定了视景体的范围。
+
+
+
+透视投影的投影线互不平行，都相交于视点。因此，同样尺寸的物体，近处的投影出来大，远处的投影出来小，从而产生了现实世界中“近大远小”的效果
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/gl_toushi_2.png?raw=true)
+
+通过Matrix类的frustumM方法完成对透视投影的设置:   
+
+```glsl
+Matrix.frustumM (
+    mProjMatrix,          // 要填充矩阵元素的float[]类型数组
+    0,                    // 填充起始偏移量
+    left, right,          // near面的left、right
+    bottom, top,          // near面的bottom、top
+    near, far             // near面、far面与视点的距离
+)
+```
+
+从上述代码中可以看出，frustumM方法的功能是，根据接收的6个透视投影相关参数产生透视投影矩阵，并将矩阵的元素依次填充到指定的数组中。
+
+
+透视投影:    
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/gl_toushi_sample.png?raw=true)
+
+
+上图由一组距离观察点越来越远的相同尺寸的六角星构成。由于采用的投影方式为透视投影，因此，最终显示在屏幕上的多个六角星近大远小。
+
+
 
 - frustumM
 
@@ -246,15 +479,37 @@ OpenGL有一个固定在原点(0,0,0)并朝向z轴负方向的相机，如下图
     用来进行旋转变换的。第一个参数是需要变换的矩阵；第二参数是偏移量；第三个参数是旋转角度，这边是以角度制，也就是说是0-360这个范围；第四、五、六个参数分别代表旋转轴向量的x，y，z值。如果x=0，y=0,z = 1 就相当于以z轴为旋转轴进行旋转，其他类似。
 
 - setLookAtm
+    
+```glsl
+Matrix.setLookAtm(
+    mVMatrix,      // 存储生成矩阵元素的float[]类型数组
+    0,             // 填充起始偏移量
+    cx, cy, cz,    // 摄像机位置的x、y、z坐标
+    tx, ty, tz,    // 观察目标点的x、y、z坐标
+    upx, upy, upz, // up向量在x、y、z轴上的分量
+)
+```
+    
+ 定义相机视图: 从上面代码中可以看出，setLookAtM方法的功能为根据接收的9个摄像机相关参数产生摄像机的观察矩阵，并将矩阵的元素填充到指定的数组中。   
 
-  定义相机视图
+之所以产生矩阵是因为OpenGL ES渲染管线的需要。   
 
   
 
 
 
-[上一篇: 7.OpenGL ES着色器语言GLSL](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/7.OpenGL%20ES%E7%9D%80%E8%89%B2%E5%99%A8%E8%AF%AD%E8%A8%80GLSL.md)  
-[下一篇: 9.OpenGL ES纹理](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/9.OpenGL%20ES%E7%BA%B9%E7%90%86.md)
+### 旋转
+
+OpenGL ES中，旋转角度的正负可以用右手螺旋定则来确定。
+所谓右手螺旋定则是指：右手握住旋转轴，使大姆指指向旋转轴的正方向，4指环绕的方向即为旋转的正方向，也就是旋转角度为正值。
+
+![](https://raw.githubusercontent.com/CharonChui/Pictures/master/opengl_rotate_angle.png)
+
+
+---
+
+- [上一篇: 7.OpenGL ES着色器语言GLSL](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/7.OpenGL%20ES%E7%9D%80%E8%89%B2%E5%99%A8%E8%AF%AD%E8%A8%80GLSL.md)  
+- [下一篇: 9.OpenGL ES纹理](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/9.OpenGL%20ES%E7%BA%B9%E7%90%86.md)
 
 ---
 
diff --git "a/VideoDevelopment/OpenGL/9.OpenGL ES\347\272\271\347\220\206.md" "b/VideoDevelopment/OpenGL/9.OpenGL ES\347\272\271\347\220\206.md"
index 3f3fb88b..e6a24893 100644
--- "a/VideoDevelopment/OpenGL/9.OpenGL ES\347\272\271\347\220\206.md"	
+++ "b/VideoDevelopment/OpenGL/9.OpenGL ES\347\272\271\347\220\206.md"	
@@ -4,6 +4,50 @@
 
 ### 纹理
 
+
+现实生活中，纹理（Texture）最通常的作用是装饰 3D 物体，它就像贴纸一样贴在物体表面，丰富了物体的表面和细节。
+ 
+在 OpenGLES 开发中，纹理除了用于装饰物体表面，还可以用来作为存储数据的容器。
+
+那么在 OpenGLES 中，***纹理实际上是一个可以被采样的复杂数据集合，是 GPU 的图像数据结构，纹理分为 2D 纹理、 立方图纹理和 3D 纹理。***
+
+***2D 纹理是 OpenGLES 中最常用和最常见的纹理形式，是一个图像数据的二维数组。纹理中的一个单独数据元素称为纹素或纹理像素。***
+
+立方图纹理是一个由 6 个单独的 2D 纹理面组成的纹理。立方图纹理像素的读取通过使用一个三维坐标（s,t,r）作为纹理坐标。
+
+3D 纹理可以看作 2D 纹理作为切面的一个数组，类似于立方图纹理，使用三维坐标对其进行访问。
+
+
+
+使用纹理坐标来获取纹理颜色就称为采样(sampling)。
+
+
+### 基本原理
+
+启用纹理映射功能后，如果想把一副纹理应用到相应的几何图元，就必须告知渲染系统如何进行纹理的映射。     
+
+告知的方式就是为图元中的顶点指定恰当的纹理坐标，纹理坐标用浮点数来表示，范围一般从0.0到1.0。    
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/gl_texture_0.png?raw=true)
+
+
+- 左侧是一幅纹理图，其位于纹理坐标系中。纹理坐标系原点在左上侧，向右为S轴，向下为T轴，两个轴的取值范围都是0.0～1.0。也就是说不论实际纹理图的尺寸如何，其横向、纵向坐标最大值都是1。若实际图为512像素×256像素，则横边第512个像素对应纹理坐标为1，竖边第256个像素对应纹理坐标为1，其他情况依此类推。
+
+- 右侧是一个三角形图元，其3个顶点A、B、C都指定了纹理坐标，3组纹理坐标正好在右侧的纹理图中确定了需要映射的三角形纹理区域。
+
+从上述两点可以看出，纹理映射的基本思想就是，首先为图元中的每个顶点指定恰当的纹理坐标，然后通过纹理坐标在纹理图中可以确定选中的纹理区域，最后将选中纹理区域中的内容根据纹理坐标映射到指定的图元上。
+
+从上述两点可以看出，纹理映射的基本思想就是，首先为图元中的每个顶点指定恰当的纹理坐标，然后通过纹理坐标在纹理图中可以确定选中的纹理区域，最后将选中纹理区域中的内容根据纹理坐标映射到指定的图元上。
+
+进行纹理映射的过程实际上就是为右侧三角形图元中的每个片元着色，用于着色的颜色需要从左侧的纹理图中提取，具体过程如下:     
+- 首先图元中的每个顶点都需要在顶点着色器中通过out变量将纹理坐标传入片元着色器。
+
+- 经过顶点着色器后渲染管线的固定功能部分会根据情况进行插值计算，产生对应到每个片元的用于记录纹理坐标的out变量值。
+
+- 最后每个片元在片元着色器中根据其接收到的记录纹理坐标的in变量值到纹理图中提取出对应位置的颜色即可，提取颜色的过程一般称为纹理采样。
+
+
+
 在OpenGL中简单理解就是一张图片，在学习之前需要明白这几个概念，不然很容易迷糊，不知道为什么要这样去调用api，到底是什么意思.
 
 - 纹理Id:句柄，纹理的直接引用
@@ -17,6 +61,17 @@ OpenGL要操作一个纹理，那么是将纹理ID装进纹理单元这个容器
 
   
 
+纹理贴图是在栅格化的模型表面上覆盖图像的技术。它是为渲染场景添加真实感的最基本和最重要的方法之一。
+纹理贴图非常重要，因此硬件也为它提供了支持，使得它具备实现实时的照片级真实感的超高性能。纹理单元是专为纹理设计的硬件组件，现代显卡通常带有数个纹理单元。
+为了在OpenGL/GLSL中有效地完成纹理贴图，需要协调好以下几个不同的数据集和机制：
+·用于保存纹理图像的纹理对象（在本章中我们仅考虑2D图像）；
+·特殊的统一采样器变量，以便顶点着色器访问纹理；
+·用于保存纹理坐标的缓冲区；
+·用于将纹理坐标传递给管线的顶点属性；
+·显卡上的纹理单元。
+
+
+
 ### 纹理与渐变色的区别
 
 渐变色:光栅化过程中计算出颜色值，然后在使用片段着色器的时候可以直接赋值。
@@ -63,6 +118,12 @@ V0（-1，0.5），V1（-1， -0.5），V2（1，-0.5），V3（1，0.5）
 
 
 
+纹理坐标是对纹理图像（通常是2D图像）中的像素的引用。纹理图像中的像素被称为纹元(texel)，以便将它们与在屏幕上呈现的像素区分开。纹理坐标用于将3D模型上的点映射到纹理中的位置。除了将它定位在3D空间中的坐标(x,y,z)之外，模型表面上的每个点还具有纹理坐标(s,t)，用来指定纹理图像中的哪个纹元为它提供颜色。这样，物体的表面被按照纹理图像“涂画”。纹理在对象表面上的朝向由分配给对象顶点的纹理坐标确定。
+要使用纹理贴图，必须为要添加纹理的对象中的每个顶点提供纹理坐标。OpenGL将使用这些纹理坐标，查找存储在纹理图像中的引用的纹元的颜色，来确定模型中每个栅格化像素的颜色。为了确保渲染模型中的每个像素都使用纹理图像中的适当纹元进行绘制，纹理坐标也需要被放入顶点属性中，以便由光栅着色器进行插值。
+
+
+
+
 
 ### 文件读取
 
@@ -71,9 +132,29 @@ OpenGL不能直接加载jpg或者png这类被编码的压缩格式，需要加
 
 ### 纹理过滤
 
+纹理坐标不依赖于分辨率，它可以是任意浮点值，所以OpenGL需要知道怎样将纹理像素映射到纹理坐标。      
+
+当你有一个很大的物体但是纹理的分辨率很低的时候这就变得很重要了。
+
+
 当我们通过光栅化将图形处理成一个个小片段的时候，再将纹理采样，渲染到指定位置上时，通常会遇到纹理元素和小片段并非一一对应。      
 这时候，会出现纹理的压缩或者放大。那么在这两种情况下，就会有不同的处理方案，这就是纹理过滤了。
 
+
+纹理过滤有很多选项，这里只说最重要的两项: GL_NEAREST和GL_LINEAR。   
+
+- GL_NEAREST: 临近过滤，是OpenGL默认的纹理过滤方式，会选择中心点最接近纹理坐标的那个像素。      
+
+- GL_LINEAR: 线性过滤，会基于纹理坐标附近的纹理像素，计算出一个插值，近似出这些纹理像素之间的颜色。一个纹理像素的中心距离纹理坐标越近，那么这个纹理像素的颜色对最终的样本颜色的贡献越大。     
+
+
+
+如果在一个很大的物体上应用一张低分辨率的纹理会发生什么呢(纹理被放大了，每个纹理像素都能看到)？
+
+GL_NEAREST产生了颗粒状的图案，我们能够清晰看到组成纹理的像素。    
+而GL_LINEAR能够产生更平滑的图案，很难看出单个的纹理像素。GL_LINEAR可以产生更真实的输出。      
+
+
 ### 纹理对象和纹理的加载
 
 纹理应用的第一步是创建一个纹理对象。纹理对象是一个容器对象，保存渲染所需的纹理数据，例如图像数据、过滤模式和包装模式。         
@@ -277,6 +358,14 @@ void main() {
 }
 ```
 
+
+为了最大限度地提高性能，我们希望在硬件中执行纹理处理。这意味着片段着色器需要一种访问我们在C++/OpenGL应用程序中创建的纹理对象的方法。它的实现机制是通过一个叫作统一采样器变量的特殊GLSL工具。这是一个变量，用于指示显卡上的纹理单元，从加载的纹理对象中提取或“采样”纹元。
+要实际执行纹理处理，我们需要修改片段着色器输出颜色的方式。以前，我们的片段着色器要么输出一个固定的颜色常量，要么从顶点属性获取颜色，而这次我们需要使用从顶点着色器（通过光栅着色器）接收的插值纹理坐标来对纹理对象进行采样。调用texture()函数如下：
+```
+in vec2 tc;            // 纹理坐标
+...
+color = texture(samp, tc);
+```
   
 
 - render实现类
@@ -286,7 +375,7 @@ void main() {
 纹理的绘制:  
 
 ```java
-//激活纹理，设置当前活动的纹理单元为单元0
+//激活纹理单元，设置当前活动的纹理单元为单元0
 GLES30.glActiveTexture(GLES30.GL_TEXTURE0);
 //绑定纹理，将纹理id绑定到当前活动的纹理单元上
 GLES30.glBindTexture(GLES30.GL_TEXTURE_2D, textureId);
@@ -294,11 +383,53 @@ GLES30.glBindTexture(GLES30.GL_TEXTURE_2D, textureId);
 GLES20.glUniform1i(aTextureLocation, 0);
 ```
 
+
+
+#### 为什么要激活纹理单元0？(glActiveTexture(GL_TEXTURE_0))
+
+
+- 纹理单元系统: OpenGL通过纹理单元(Texture Unit)管理多个纹理。    
+
+每个纹理单元都是一个独立的“插槽”，可以绑定不同类型的纹理(GL_TEXTURE_2D, GL_TEXTURE_CUBE_MAP等)
+
+- 多纹理支持: 现代GPU支持同时使用多个纹理(例如同时使用漫反射贴纸+法线贴图+高光贴图)。通过激活不同纹理单元(GL_TEXTURE0、GL_TEXTURE1...)来实现这一点。     
+
+- 状态机特性: OpenGL是状态机，glActiveTexture选择当前操作的纹理单元，后续的glBindTexture和glTexParameter等操作都作用于这个单元。    
+
+#### 为什么要绑定纹理? (glBindTexture(GL_TEXTURE_2D, m_TextureId))  
+
+- 关联操作目标: 将具体的纹理对象(textureId)与当前激活的纹理单元(GL_TEXTURE0)关联。    
+
+- 多类型支持: 同一个纹理单元可以绑定不同类型的纹理(例如GL_TEXTURE_2D和GL_TEXTURE_CUBE_MAP互不影响)。
+
+- 渲染时使用: 绘制时，着色器通过纹理单元索引(这里是0)访问绑定的纹理数据。     
+
+#### 为什么要设置采样器为0? glUniform1i(m_SamplerLoc, 0) 
+
+- 着色器(uniform sampler2D texture1)与纹理单元的桥梁: 在着色器中sampler2D类型的uniform变量需要知道从哪个纹理单元读取数据。 0表示使用纹理单元GL_TEXTURE0(1对应GL_TEXTURE1,以此类推)。也就是告诉OpenGL每个着色器采样器从哪个纹理单元采样数据。     
+
+那这里为什么参数是0，而不是GL_TEXTURE0? 这是因为glUniform1i传递的是索引值，而不是OpenGL枚举常量。   
+
 这里有没有很奇怪，sampler2D的变量是uniform的，但是我们并不是用glUniform()方法给他赋值，而是使用glUniform1i()。         
 这是因为可以给纹理采样器分配一个位置值，这样我们就能够在一个片段着色器中设置多个纹理单元。一个纹理的话，纹理单元是默认为0，它是默认激活的，纹理单元的主要目的就是给着色器多一个使用的纹理。         
 通过纹理单元赋值给采样器，我们可以一次绑定多个纹理，只要我们在使用的时候激活纹理。
 
 
+OpenGL至少保证有16个纹理单元供你使用，也就是说你可以激活从GL_TEXTURE0到GL_TEXTURE15。         
+它们都是按顺序定义的，所以我们也可以通过GL_TEXUTURE0 + 8的方式获得GL_TEXTURE8，这在需要循环一些纹理单元的时候会很有用。    
+
+
+#### 完整的流程
+
+1. 激活单元: 选择操作目标(GL_TEXTURE0)。 类比: 选择电视机第0号HDMI输入口。   
+2. 绑定纹理: 将具体纹理放入该单元。 类比: 给第0号HDMI口连接一个播放器。    
+3. 设置采样器: 告诉着色器从哪个“HDMI口”读取数据。 类比: 告诉观众观看第0 HDMI口的画面。     
+
+
+
+
+
+
 ```java
   public class TextureRender extends BaseGLSurfaceViewRenderer {
       private final FloatBuffer vertextBuffer;
@@ -524,8 +655,58 @@ void main() {
 - 纹理，texture：存储描述信息
 - 画布，surface：内存中的一块地址，存储像素数据
 
-[上一篇: 8.GLES类及Matrix类](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/8.GLES%E7%B1%BB%E5%8F%8AMatrix%E7%B1%BB.md)  
-[下一篇: 10.GLSurfaceView+MediaPlayer播放视频](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/10.GLSurfaceView%2BMediaPlayer%E6%92%AD%E6%94%BE%E8%A7%86%E9%A2%91.md)
+
+
+- 几何着色器
+
+几何着色器阶段位于曲面细分着色器和栅格化之间，位于用于图元处理的管线内。
+顶点着色器允许一次操作一个顶点，而片段着色器一次可以操作一个片段（实际上是一个像素），但几何着色器却可以一次操作一个图元。
+
+
+
+
+#### 纹理色彩通道灵活组合
+
+纹理色彩通道的灵活组合。通过其可以对输入的RGBA纹理颜色分量如何映射到着色器中对应的颜色分量进行细节控制。实现纹理色彩通道的灵活组合主要是通过glTexParameterf方法进行设置。
+
+实际设置时，glTexParameterf方法的第一个参数一般为“GLES30.GL_TEXTURE_2D”，表示对2D纹理进行设置。第二个参数有4种选择，具体含义如下所列:       
+- GL_TEXTURE_SWIZZLE_R表示映射到着色器中对应采样器的红色通道。
+- GL_TEXTURE_SWIZZLE_G表示映射到着色器中对应采样器的绿色通道。
+- GL_TEXTURE_SWIZZLE_B表示映射到着色器中对应采样器的蓝色通道。
+- GL_TEXTURE_SWIZZLE_A表示映射到着色器中对应采样器的透明度通道。
+
+第三个参数则有6种选择，具体含义如下所列:     
+- GL_RED表示是映射纹理图中的红色通道。
+- GL_GREEN表示是映射纹理图中的绿色通道。
+- GL_BLUE表示是映射纹理图中的蓝色通道。
+- GL_ALPHA表示是映射纹理图中的透明度通道。
+- GL_ONE表示采用1值进行映射。
+- GL_ZERO表示采用0值进行映射。
+
+
+
+#### 2D纹理数组
+
+从OpenGL ES 3.0开始支持的纹理类型——2D纹理数组。通过使用2D纹理数组，在同一个着色器中需要使用多个2D纹理的情况下可以简化开发。可以想象出，如果没有2D纹理数组技术，当一个着色器中需要使用多个2D纹理时就需要声明多个采样器变量。     
+
+而使用2D纹理数组实现，同样功能时只需声明一个sampler2DArray类型的变量即可，方便高效。对于2D纹理数组进行采样时，需要提供的纹理坐标有3个分量，前两个与普通2D纹理坐标含义相同，为S、T分量，第三个分量则为2D纹理数组中的索引。
+
+需要注意的是，使用2D纹理数组时，一般会使数组中的纹理保持相同的尺寸。
+
+
+需要注意的是，glBindTexture方法和glTexParameterf方法的第一个参数由原来的GLES30.GL_TEXTURE_2D变为GLES30.GL_TEXTURE_2D_ARRAY。
+
+
+
+
+
+
+
+
+---
+- [上一篇: 8.GLES类及Matrix类](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/8.GLES%E7%B1%BB%E5%8F%8AMatrix%E7%B1%BB.md)  
+
+- [下一篇: 10.GLSurfaceView+MediaPlayer播放视频](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/10.GLSurfaceView%2BMediaPlayer%E6%92%AD%E6%94%BE%E8%A7%86%E9%A2%91.md)
 
 ---
 
diff --git "a/VideoDevelopment/\345\205\263\351\224\256\345\270\247.md" "b/VideoDevelopment/\345\205\263\351\224\256\345\270\247.md"
index 878ca9db..848acaf3 100644
--- "a/VideoDevelopment/\345\205\263\351\224\256\345\270\247.md"
+++ "b/VideoDevelopment/\345\205\263\351\224\256\345\270\247.md"
@@ -9,7 +9,7 @@
 
 - I帧(Intra coded picture):帧内编码图像帧简称关键帧，这一帧画面的完整保留，解码时只需要本帧数据就可以完成.I帧通常是每个GOP(MPEG所使用的一种视频压缩技术)的第一个，GOP就是指两个I帧之间的距离。
 
-    我们在做直播的时候，想要能达到秒开的效果，因为I帧是能不依赖其他帧独立完成解码的，这就意味着当播放器接收到I帧就能立马渲染出来，而接收到P、B帧则需要等待依赖的帧而不能立马完成解码和渲染，这个期间就会黑屏，所以可以在服务端通过缓存GOP，保证播放端在接入直播时能先获取到I帧马上渲染出画面，从而提高起播速度。在直播服务器中，支持设置一个cache，用于存放GOP，直播服务器缓存了当前的GOP序列，当播放端请求数据的时候，CDN会从I帧返回给客户端，从而保证客户端可以快速进行播放。当然由于缓存的是之前的视频信息，当音频数据到达播放端后，为了音视频同步播放器会进行视频的快进处理。
+我们在做直播的时候，想要能达到秒开的效果，因为I帧是能不依赖其他帧独立完成解码的，这就意味着当播放器接收到I帧就能立马渲染出来，而接收到P、B帧则需要等待依赖的帧而不能立马完成解码和渲染，这个期间就会黑屏，所以可以在服务端通过缓存GOP，保证播放端在接入直播时能先获取到I帧马上渲染出画面，从而提高起播速度。在直播服务器中，支持设置一个cache，用于存放GOP，直播服务器缓存了当前的GOP序列，当播放端请求数据的时候，CDN会从I帧返回给客户端，从而保证客户端可以快速进行播放。当然由于缓存的是之前的视频信息，当音频数据到达播放端后，为了音视频同步播放器会进行视频的快进处理。
 
 - P帧(Predictive coded picture):预测编码图像帧简称差别帧，这一帧跟之前的一个关键帧或P帧的差别，解码时需要用之前缓存的画面叠加上本帧定义的差别，生成最终的画面。也就是说P帧没有完整的画面数据，只有与前一帧的画面差别的数据。 
 
@@ -41,14 +41,35 @@ IDR（Instantaneous Decoding Refresh）是H.264视频编码中的一种特殊的
 
 一个序列(GOP)的第一个图像叫做IDR图像(立即刷新图像)，IDR图像都是I帧图像。H.264引入IDR图像是为了解码的重新同步，当解码器解码到IDR图像时，立即将参考帧队列清空，将已解码的数据全部输出或抛弃，重新查找下一个参考集，开始解码一个新的序列。这样，如果前一个序列出现重大错误，在这里可以获得重新同步的机会。IDR图像之后的图像永远不会使用IDR之前的图像数据来解码。一个序列就是一段内容差异不太大的图像编码后生成的一串数据流。当运动变化比较少时，一个序列可以很长，因为运动变化少就代表图像画面的内容变动很小，所以就可以是一个I帧，然后一直是P帧、B帧。当运动变化多时，一个序列可能会比较短，比如只包含一个I帧和几个P帧、B帧。
 
-     那么IDR帧与I帧的区别是什么呢?因为H264采用了多帧预测，所以I帧之后的P帧有可能会参考I 帧之前的帧，这就使得在随机访问的时候不能以找到I帧作为参考条件，因为即使找到I帧，I帧之后的帧还是有可能解析不出来，而IDR帧 就是一种特殊的I帧，即这一帧之后的所有参考帧只会参考到这个IDR 帧，而不会再参考前面的帧。在解码器中，一旦收到一个IDR帧，就会 立即清理参考帧缓冲区，并将IDR帧作为被参考的帧。
-     I和IDR帧都是使用帧内预测的。它们都是同一个东西而已,在编码和解码中为了方便，要首个I帧和其他I帧区别开，所以才把第一个首个I帧叫IDR，这样就方便控制编码和解码流程。 IDR帧的作用是立刻刷新,使错误不致传播,从IDR帧开始,重新算一个新的序列开始编码。而I帧不具有随机访问的能力，这个功能是由IDR承担。  IDR会导致DPB（DecodedPictureBuffer  参考帧列表——这是关键所在）清空，而I不会。IDR图像一定是I图像，但I图像不一定是IDR图像。一个序列中可以有很多的I图像，I图像之后的图像可以引用I图像之间的图像做运动参考。一个序列中可以有很多的I图像，I图像之后的图象可以引用I图像之间的图像做运动参考。
-     对于IDR帧来说，在IDR帧之后的所有帧都不能引用任何IDR帧之前的帧的内容，与此相反，对于普通的I-帧来说，位于其之后的B-和P-帧可以引用位于普通I-帧之前的I-帧。从随机存取的视频流中，播放器永远可以从一个IDR帧播放，因为在它之后没有任何帧引用之前的帧。但是，不能在一个没有IDR帧的视频中从任意点开始播放，因为后面的帧总是会引用前面的帧 。
-     收到 IDR 帧时，解码器另外需要做的工作就是：把所有的 PPS 和 SPS 参数进行更新。
-     对IDR帧的处理(与I帧的处理相同)：(1) 进行帧内预测，决定所采用的帧内预测模式。(2) 像素值减去预测值，得到残差。(3) 对残差进行变换和量化。(4) 变长编码和算术编码。(5) 重构图像并滤波，得到的图像作为其它帧的参考帧。
-     多参考帧情况下， 举个例子 ：有如下帧序列： IPPPP I P PPP ……。按照 3 个参考帧编码。
-     因为“按照 3 个参考帧编码”，所以参考帧队列长度为 3 。
-     遇到第二个 I 时，并不清空参考帧队列，把这个 I 帧加入参考帧队列（当然 I 编码时不用参考帧。）。再检测到其后面的 P 帧时，用到之前的 PPI 三帧做参考了。
+那么IDR帧与I帧的区别是什么呢?      
+
+因为H264采用了多帧预测，所以I帧之后的P帧有可能会参考I 帧之前的帧，这就使得在随机访问的时候不能以找到I帧作为参考条件，因为即使找到I帧，I帧之后的帧还是有可能解析不出来，而IDR帧 就是一种特殊的I帧，即这一帧之后的所有参考帧只会参考到这个IDR 帧，而不会再参考前面的帧。在解码器中，一旦收到一个IDR帧，就会 立即清理参考帧缓冲区，并将IDR帧作为被参考的帧。
+
+I和IDR帧都是使用帧内预测的。它们都是同一个东西而已,在编码和解码中为了方便，要首个I帧和其他I帧区别开，所以才把第一个首个I帧叫IDR，这样就方便控制编码和解码流程。 IDR帧的作用是立刻刷新,使错误不致传播,从IDR帧开始,重新算一个新的序列开始编码。    
+而I帧不具有随机访问的能力，这个功能是由IDR承担。   
+
+IDR会导致DPB（DecodedPictureBuffer  参考帧列表——这是关键所在）清空，而I不会。IDR图像一定是I图像，但I图像不一定是IDR图像。
+
+一个序列中可以有很多的I图像，I图像之后的图像可以引用I图像之间的图像做运动参考。一个序列中可以有很多的I图像，I图像之后的图象可以引用I图像之间的图像做运动参考。
+
+对于IDR帧来说，在IDR帧之后的所有帧都不能引用任何IDR帧之前的帧的内容，与此相反，对于普通的I-帧来说，位于其之后的B-和P-帧可以引用位于普通I-帧之前的I-帧。
+
+从随机存取的视频流中，播放器永远可以从一个IDR帧播放，因为在它之后没有任何帧引用之前的帧。但是，不能在一个没有IDR帧的视频中从任意点开始播放，因为后面的帧总是会引用前面的帧 。
+
+收到 IDR 帧时，解码器另外需要做的工作就是：把所有的 PPS 和 SPS 参数进行更新。
+
+对IDR帧的处理(与I帧的处理相同):     
+
+1. 进行帧内预测，决定所采用的帧内预测模式。
+2. 像素值减去预测值，得到残差。
+3. 对残差进行变换和量化。
+4. 变长编码和算术编码。
+5. 重构图像并滤波，得到的图像作为其它帧的参考帧。
+
+多参考帧情况下， 举个例子 ：有如下帧序列： IPPPP I P PPP ……。按照 3 个参考帧编码。
+因为“按照 3 个参考帧编码”，所以参考帧队列长度为 3 。
+
+遇到第二个 I 时，并不清空参考帧队列，把这个 I 帧加入参考帧队列（当然 I 编码时不用参考帧。）。再检测到其后面的 P 帧时，用到之前的 PPI 三帧做参考了。
 
 ![](https://raw.githubusercontent.com/CharonChui/Pictures/master/video_frame_ipb.jpg)
 
@@ -71,6 +92,7 @@ P帧和B帧极大的节省了数据量，节省出来的空间可以用来多保
 先来了解一下PTS和DTS的基本概念：
 
 DTS（Decoding Time Stamp）：即**解码时间戳**，这个时间戳的意义在于告诉播放器该在什么时候解码这一帧的数据。
+
 PTS（Presentation Time Stamp）：即**显示时间戳**，这个时间戳用来告诉播放器该在什么时候显示这一帧的数据。
 
 虽然 DTS、PTS 是用于指导播放端的行为，但它们是在编码的时候由编码器生成的。
diff --git "a/VideoDevelopment/\345\233\276\347\211\207\346\240\274\345\274\217/GIF.md" "b/VideoDevelopment/\345\233\276\347\211\207\346\240\274\345\274\217/GIF.md"
new file mode 100644
index 00000000..1024aa43
--- /dev/null
+++ "b/VideoDevelopment/\345\233\276\347\211\207\346\240\274\345\274\217/GIF.md"
@@ -0,0 +1,106 @@
+# GIF
+
+GIF(Graphics Interchange Format，图像文件存储格式)是CompuServe公司开发的。     
+
+它的核心特点是支持动画和透明度，但牺牲了色彩深度。
+
+1987年开发的GIF文件格式版本号是GIF87a，1989年进行了扩充，扩充后的版本号定义为GIF89a。    
+
+ 
+GIF图像文件以数据块(block)为单位来存储图像的相关信息。      
+
+
+一个GIF文件由表示图形/图像的数据块、数据子块以及显示图形/图像的控制信息块组成，称为GIF数据流(Data Stream)。      
+
+
+数据流中的所有控制信息块和数据块都必须在文件头(Header)和文件结束块(Trailer)之间 。
+ 
+GIF文件格式采用了LZW(Lempel-Ziv Walch)压缩算法来存储图像数据，定义了允许用户为图像设置背景的透明(transparency)属性。     
+
+此外，GIF文件格式可在一个文件中存放多幅彩色图形/图像。如果在GIF文件中存放有多幅图，它们可以像演幻灯片那样显示或者像动画那样演示。     
+
+
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/gif_1.png?raw=true)             
+ 
+
+## GIF文件结构
+
+GIF格式的文件结构整体上分为三部分：文件头、GIF数据流、文件结尾。其中，GIF数据流分为全局配置和图像块。
+
+
+GIF 文件由一系列数据块（Blocks）和扩展块（Extension Blocks）顺序组成。理解这个结构是解析元数据的关键。
+- 文件头 (Header)​​：GIF87a或 GIF89a，标识文件版本： GIF署名（Signature）和版本号（Version）:GIF的前6个字节内容是GIF的署名和版本号。我们可以通过前3个字节判断文件是否为GIF格式，后3个字节判断GIF格式的版本。
+- 逻辑屏幕描述符 (Logical Screen Descriptor)​​：定义画布大小和全局调色板信息。
+- 全局调色板 (Global Color Table)​​：可选，定义所有帧共用的颜色表。
+- 数据块​:      
+    - 图像描述符 (Image Descriptor)​​：定义帧的图像区域和局部调色板信息。
+    - 基于调色板的图像数据​：使用 LZW 压缩后的像素数据。
+- 扩展块 (Extension Blocks)​​:       
+    - 图形控制扩展 (Graphic Control Extension)​​：​最重要的扩展，包含帧的延迟时间（动画速度）、透明色索引和处置方法。
+    - 注释扩展 (Comment Extension)​​：​这是存储纯文本元数据的主要位置！​​
+    - 应用扩展 (Application Extension)​​：用于存储应用程序的特定信息（如 Netscape 的循环次数）。
+    - 明文扩展、等。
+- 文件终结器 (Trailer)​​：一个分号 ;，标识文件结束。
+
+
+
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/gif_2.png?raw=true)             
+
+
+
+数据块可分成3类：控制块(Control Block)，图形描绘块(Graphic-RenderingBlock)和专用块(Special Purpose Block)。
+
+
+- 控制块: 控制块包含有用来控制数据流(Data Stream)或者设置硬件参数的信息，其成员包括:     
+    - GIF文件头(Header)
+    - 逻辑屏幕描述块(LogicalScreen Descriptor)
+    - 图形控制扩展块(GraphicControl Extension)
+    - 文件结束块(Trailer)
+
+- 图形描绘块：包含有用来描绘在显示设备上显示图形的信息和数据，其成员包括:      
+    - 图像描述块(ImageDescriptor)
+    - 无格式文本扩展块(PlainText Extension)
+    - 全局调色板、局部调色板、图像压缩数据和图像说明扩充块。
+
+ - 特殊用途数据块；包含有与图像处理无关的信息，其成员包括:    
+    - 注释扩展块(CommentExtension)
+    - 应用扩展块(ApplicationExtension)
+    - 除了在控制块中的逻辑屏幕描述块(Logical Screen Descriptor)和全局彩色表(GlobalColor Table)的作用范围是整个数据流(Data Stream)之外, 所有其他控制块仅跟在它们后面的图形描绘块。
+
+
+
+第二部分：元数据与 XMP 在 GIF 中的存储位置   
+这是一个非常关键的点，也是 GIF 与 JPEG、PNG 等格式最大的不同。    
+1. 元数据存储在哪里？​​
+
+GIF 格式没有为 EXIF、IPTC 或 XMP 这类现代、结构化的元数据设计标准的存储位置。它的元数据能力非常有限。
+主要位置：注释扩展块 (Comment Extension)​​
+块标识符​：0x21 0xFE
+内容​：可以包含任意纯文本信息。这是存储版权信息、作者、描述等简单元数据的传统位置。
+限制​：​只能是纯文本，没有键值对或结构化的标准。不同软件写入的格式完全不同。
+次要位置：应用扩展块 (Application Extension)​​
+块标识符​：0x21 0xFF
+内容​：通常被特定应用程序用于存储私有数据。例如，NETSCAPE2.0应用扩展用于指定动画循环次数。
+理论上，某个软件可以自定义一个应用扩展来存储 XMP 数据，但这绝非标准，其他软件很可能无法识别。
+
+
+2. XMP 存储在哪里？​​
+标准的、符合 Adobe XMP 规范的元数据通常不存在于 GIF 文件中。​​
+原因​：GIF 格式诞生时，XMP 规范还不存在。GIF 的结构没有为容纳一大段 XML 数据而设计。
+变通方案​：极少数专业软件（如 Adobe 的部分产品）​可能会将 XMP 数据作为一串很长的 XML 文本字符串写入到注释扩展 (Comment Extension)​​ 中。
+现实情况​：​99.9% 的 GIF 文件不包含 XMP 数据。​​ 如果您的目标是读取 XMP，遇到 GIF 格式的概率极低。
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git "a/VideoDevelopment/\345\233\276\347\211\207\346\240\274\345\274\217/HEIC.md" "b/VideoDevelopment/\345\233\276\347\211\207\346\240\274\345\274\217/HEIC.md"
new file mode 100644
index 00000000..f2630848
--- /dev/null
+++ "b/VideoDevelopment/\345\233\276\347\211\207\346\240\274\345\274\217/HEIC.md"
@@ -0,0 +1,42 @@
+# HEIC
+
+
+HEIC（High Efficiency Image Container​ 高效图像容器）是苹果公司基于HEIF（高效图像文件格式）和HEVC（高效视频编码）技术开发的一种图像存储格式。自2017年iOS 11系统更新起，该格式被设定为iPhone 7及后续机型的默认照片存储格式，在相同画质下可将文件体积较JPEG减少约50%。
+
+
+High Efficiency Image File Format (HEIF, 发音为：heef)，由 Moving Picture Experts Group ( MPEG，即动态图像专家组) 于2013年开发，它基于ISOBMFF标准。HEIF是一个容器的图片格式，它可以包含图片和图片序列（一个文件可以包含不止一个图片）。当前的编码格式有：HEVC 和H.264/MPEG-4 AVC 两种，并且未来可能有新的编码格式加入。
+
+
+
+### HEIF和HEIC的关系
+
+- HEIF是规则、HEIC是实例。 
+- HEIF定义了如何存储图像、图像序列(动画、连拍)、音频和元数据。  
+- 而HEIC文件是遵循HEIF规则，并使用HEVC(H.265)编码来压缩图像数据的具体文件。   
+- .HEIC只是一个HEIF文件格式的一种扩展名，言外之意是：HEIF不仅有.HEIC这种扩展名，还有其它的，比如说: .HEIF和.avci，它们都是属于HEIF文件格式。当然，常见的只有.heif和.heic这两种，而.avci 很少见。
+
+
+
+HEIF 的强大源于其现代的设计理念，它本质上是一个基于 ISO 基础媒体文件格式（ISOBMFF）的容器，该格式也是 MP4 视频的基础。
+
+
+​1. 核心结构：'box' (盒子) 体系​
+
+HEIF/HEIC 文件由一系列嵌套的 ​​'box'​​（或称 'atom'） 组成。每个 'box' 都有一个头部（声明类型和大小）和负载（数据）。
+​- ftyp​：文件类型盒，标识这是一个 HEIC 文件。
+​- meta​：元数据盒，是最重要的盒子，包含了描述图像数据的各种信息。
+​- mdat​：媒体数据盒，存储实际的、经过压缩的图像比特流。
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git "a/VideoDevelopment/\345\233\276\347\211\207\346\240\274\345\274\217/JPEG.md" "b/VideoDevelopment/\345\233\276\347\211\207\346\240\274\345\274\217/JPEG.md"
new file mode 100644
index 00000000..ba93a123
--- /dev/null
+++ "b/VideoDevelopment/\345\233\276\347\211\207\346\240\274\345\274\217/JPEG.md"
@@ -0,0 +1,119 @@
+# JPEG
+
+[JPEG](https://www.w3.org/Graphics/JPEG/itu-t81.pdf)
+JPEG（Joint Photographic Experts Group)，全称为联合图像专家小组，是国际标准化组织（ISO）制定的静态图像压缩标准，文件扩展名为.jpg或.jpeg，适用于连续色调静止图像处理。
+
+
+
+JPEG只描述一副图像如何转换成一组数据流，而不论这些字节存储在何种介质上。     
+
+由独立JPEG组创立的另一个进阶标准，JFIF（JPEG File Interchange Format，JPEG文件交换格式）则描述JPEG数据流如何生成适于电脑存储或传送的图像。在一般应用中，我们从数码相机等来源获得的“JPEG文件”，指的就是JFIF文件，有时是ExifJPEG文件。
+
+
+该格式采用有损压缩算法，通过牺牲部分画质换取较小文件体积，压缩过程包含色彩空间转换（RGB转YCbCr）、离散余弦变换（DCT）、量化和熵编码等步骤。
+
+支持标准JPEG、渐进式JPEG和JPEG2000三种格式，其中渐进式格式可实现图像由模糊到清晰的渐进加载.  
+
+JPEG压缩技术通过分离高频与低频信息并对高频部分进行压缩，压缩比可通过量化表参数调节，典型压缩率为原始大小的10%.   
+
+
+### 说明
+1. jpeg是一种压缩标准，大幅度缩小数据流，jpeg以FF D8开头，FF D9结束。
+2. jpeg文件中有一些形如0xFF**这样的数据，它们被称为标志(Markeer),它表示jpeg信息数据段。例如0xFFD8代表SOI(Startof image)。OxFFD9代表EOI(End of image)。
+4. jpeg图像由多个maker组成，多个maker+compressed组成了jpeg。
+5. jiff是一种在万维网上进行jpeg传输的格式，可以理解是对jpeg图片的封装，符合jpeg标准，jiff的maker是app0，记录了图像的基本信息，也可能有缩略图。jiff格式比较老，老式的数码相机使用此格式。
+6. exif新比较新的jpeg封装格式，exif的maker是app1，记录了更多的东西，如ISP信息、GPS信息、相机信息，图像旋转等等
+7. jiff和exif可以共存，很多jpeg图像都有app0的jiff段和app1的exif段
+
+
+
+## 压缩流程
+
+1. 原始图像
+2. 8x8分块
+3. DCT(Discrete Cosine Transform,离散余弦变换)变换: 把数据从时域转化到频域的数学方法，把图像数据转换到频域之后，可以从中分离出各种频率的信息。   
+4. 量化
+5. Z字形扫描
+6. 对系数编码
+7. 熵编码
+8. 压缩数据
+
+
+ 
+
+ 
+JPEG文件除了图像数据之外，还保存了与图片相关的各种信息，这些信息通过不同类型的TAG存储在文件中。 
+
+
+## TAG
+
+JPEG通过TAG编辑压缩数据之外的信息。    
+
+所有的TAG都包含一个TAG类型，TAG类型的大小为两个字节，位于一个TAG的最前面。TAG类型的第一个字节一定为0xFF
+
+一般情况下，是按照这个顺序排列的:     
+
+
+| TAG 类型          | 数值(十六进制标识符)     | 全称                       | 其他备注                          |
+|-------------------|----------|----------------------------|-----------------------------------|
+| SOI               | 0xFFD8   | Start of Image             | 必带                              |
+| APP0              | 0xFFE0   | application0               | 必带                              |
+| APPn              | 0xFFEn   | applicationn               | 可选带(APP1一般为Exif信息)        |
+| DQT               | 0xFFDB   | Define Quantization Table  | 必带                              |
+| SOF               | 0xFFC0   | Start of Frame             | 必带                              |
+| DHT               | 0xFFC4   | Define Huffman Table       | 必带                              |
+| SOS               | 0xFFDA   | Start of Scan              | 必带                              |
+| compress data     | ...      | ...                        | 必带                              |
+| EOI               | 0xFFD9   | End of Image               | 必带                              |
+
+标志OxFFE0~OxFFEF被称为"Application Marker"，它们不是解码JPEG文件必须得，可以被用来存储配置信息等。    
+EXIF也是利用这个标志段来插入信息的。具体来说，是APP1(0xFFE1)Marker，所有的EXIF信息都存储在该数据段。    
+​EXIF（Exchangeable Image File Format）​​ 是嵌入在 JPEG 文件中的 ​元数据标准，记录拍摄设备、参数和场景信息，相当于照片的“数字身份证”。
+
+
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/jpeg_1.png?raw=true)             
+
+
+#### 典型JPEG文件结构    
+
+[SOI] -> [APP0] -> [APP1(EXIF)] -> [DQT] -> [SOF] -> [DHT] -> [SOS] -> [压缩数据] -> [EOI]
+
+
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/jpeg_2.png?raw=true)             
+
+##### 怎么判断是不是JPEG图片？ 
+
+jpeg是一种压缩标准，大幅度缩小数据流，jpeg以FF D8开头，FF D9结束。
+
+
+其实很简单，就是判断前面3个字节是什么，如果发现是FF D8 FF开始，那就认为它是JEPG图片。(注意android不是根据后缀名来判断是什么文件的，当然你必须是图片的后缀名文件管理器才可以打开
+
+
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/jpeg_3.png?raw=true)             
+
+
+
+
+### Exif是什么
+
+
+Exif(Exchangeable Image File可交换图像文件)就是用来记录拍摄图像时的各种信息: 
+- 图像信息(厂商、分辨率等)
+- 相机拍摄记录(ISO、白平衡、饱和度、锐度等)
+- 缩略图(缩略图宽度、高度等)
+- gps(拍摄时的经度、纬度、高度等)
+
+将这些信息按照JPEG文件标准放在图像文件头部。   
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git "a/VideoDevelopment/\345\233\276\347\211\207\346\240\274\345\274\217/PNG.md" "b/VideoDevelopment/\345\233\276\347\211\207\346\240\274\345\274\217/PNG.md"
new file mode 100644
index 00000000..3732f554
--- /dev/null
+++ "b/VideoDevelopment/\345\233\276\347\211\207\346\240\274\345\274\217/PNG.md"
@@ -0,0 +1,243 @@
+# PNG
+
+[PNG](https://www.w3.org/TR/png/#4Concepts.Format): 便携式网络图形（Portable Network Graphics）是一种无损压缩的位图图形格式,被设计为取代古老的 GIF 格式，其核心目标是无损压缩、支持真彩色和完全透明。      
+
+
+### 文件结构
+
+PNG图像格式文件（或者称为数据流）由一个8字节的PNG文件署名（PNG file signature）域和按照特定结构组织的3个以上的数据块（chunk）组成。   
+
+
+
+1. 文件署名域（Magic Number）​
+
+
+8字节的PNG文件署名域用来识别该文件是不是PNG文件。该域的值是:     
+
+- 十进制数137 80 78 71 13 10 26 10
+- 十六进制数 89 50 4e 47 0d 0a 1a 0a
+
+
+
+​固定8字节：89 50 4E 47 0D 0A 1A 0A:        
+- 89：高位设置，防止被误判为文本文件。
+- 50 4E 47：ASCII "PNG"。
+- 0D 0A：DOS 风格的换行符，用于换行符转换检测。
+- 1A：DOS 的 EOF（文件结束）字符。
+- 0A：Unix 风格的换行符。
+
+​任何PNG解析器首先都必须检查这8个字节。​​
+
+
+PNG定义了两种类型的数据块:    
+
+- 一种是称为关键数据块（critical chunk），这是必需的数据块
+- 另一种叫做辅助数据块（ancillary chunks），这是可选的数据块。
+
+2. 数据块（Chunk）结构​
+
+每个数据块都有统一的格式，如下所示：
+
+```
+// 数据块结构
++-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+| Length (4 bytes)                              |  // 数据字段长度
++-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+| Chunk Type (4 bytes ASCII)                    |  // 块类型，如 IHDR
++-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+| Chunk Data (Length bytes)                     |  // 数据内容
++-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+| CRC32 (4 bytes)                               |  // 对整个块类型+数据的校验
++-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+```
+
+
+
+
+​- Length​：Data字段的字节数（32 位无符号整数，​大端序）。
+​- Chunk Type​：4 个 ASCII 字符，定义了块的用途。​大小写敏感​:      
+​    - 大写首字母​：关键块（解析器必须识别）
+    - 小写首字母​：辅助块（可忽略）
+    例如：IHDR是关键块，tEXt是辅助块。
+​- CRC​：循环冗余校验码，用于检测数据在传输过程中是否出错。
+
+
+3. 关键数据块（Critical Chunks）​​
+
+解析必须按顺序处理这些块：
+
+| 块类型 | 必须 | 说明 | 结构（Data 字段内容） |
+
+| ：--- | :--- | :--- | :--- |
+
+| ​IHDR​ | 是 | 文件头，包含图像基本信息 | Width(4B), Height(4B), BitDepth(1B), ColorType(1B), Compression(1B), Filter(1B), Interlace(1B) |
+
+| ​PLTE​ | 可选 | 调色板，定义索引颜色 | 一系列 RGB 三元组（R, G, B） |
+
+| ​IDAT​ | 是 | 图像数据，可存在多个 | 由 DEFLATE 压缩过的、经过过滤的像素数据流 |
+
+| ​IEND​ | 是 | 图像结束标记 | 无数据 |
+
+
+- IHDR：文件头数据块IHDR(header chunk):     
+
+它包含有PNG文件中存储的图像数据的基本信息，并要作为第一个数据块出现在PNG数据流中，而且一个PNG数据流中只能有一个文件头数据块。     
+文件头数据块由13字节组成，包含图像宽度(4字节)、图像高度(4字节)、图像深度(1字节)、颜色类型(1字节)、压缩方法(1字节)、滤波器方法(1字节)、隔行扫描方法(1字节)
+
+- PLTE: 调色板数据块PLTE(palette chunk)包含有与索引彩色图像(indexed-color image)相关的彩色变换数据，它仅与索引彩色图像有关，而且要放在图像数据块(image data chunk)之前。PLTE数据块是定义图像的调色板信息，PLTE可以包含1~256个调色板信息，每一个调色板信息由3个字节组成。    
+- IDAT: 图像数据块IDAT(image data chunk)：它存储实际的数据，在数据流中可包含多个连续顺序的图像数据块。IDAT存放着图像真正的数据信息，因此，如果能够了解IDAT的结构，我们就可以很方便的生成PNG图像。
+- IEND: 图像结束数据IEND(image trailer chunk)：它用来标记PNG文件或者数据流已经结束，并且必须要放在文件的尾部。如果我们仔细观察PNG文件，我们会发现，文件的结尾12个字符看起来总应该是这样的：
+0000000049454E44AE426082，不难明白，由于数据块结构的定义，IEND数据块的长度总是0（00 00 00 00，除非人为加入信息），数据标识总是IEND（49 45 4E 44），因此，CRC码也总是AE 42 60 82。 
+
+除了表示数据块开始的IHDR必须放在最前面， 表示PNG文件结束的IEND数据块放在最后面之外，其他数据块的存放顺序没有限制。
+
+
+4. 辅助数据块（Ancillary Chunks）​​
+
+常见的有:      
+
+| 块类型 | 说明 |
+
+| ：--- | :--- |
+
+| ​tEXt​| 文本信息数据块(textual data)，可存储任何文本信息（关键字+值），如软件、作者、版权。​你之前操作的 aigc:{}就可以写在这里。​​ |
+
+| ​zTXt​ | 压缩的文本数据块(comporessed textual data)。 |
+
+| ​iTXt​ | 国际化的 UTF-8 文本，可包含语言标签。例如中文、日文要写入该区域 |
+
+| ​tRNS​ | 透明度信息数据块(transparency)。对于索引色，它是调色板索引的 Alpha 数组；对于灰度/真彩色，它指定单一颜色为透明色。 |
+
+| ​gAMA​ | 图像y数据块(image gamma)指定图像伽马值，用于跨平台显示校正。 |
+
+| ​pHYs​ | 物理像素尺寸数据块(physical pixel dimensions)指定像素的物理尺寸（像素比/DPI）。 |
+
+| ​tIME​ | 图像最后修改时间数据块tIME(image last-modification time) |
+
+
+4.8.2 Chunk types
+Chunk types are four-byte sequences chosen so that they correspond to readable labels when interpreted in the ISO 646.IRV:1991 [ISO646] character set. The first four are termed critical chunks, which shall be understood and correctly interpreted according to the provisions of this specification. These are:
+
+- IHDR: image header, which is the first chunk in a PNG datastream.
+- PLTE: palette table associated with indexed PNG images.
+- IDAT: image data chunks.
+- IEND: image trailer, which is the last chunk in a PNG datastream.
+
+The remaining chunk types are termed ancillary chunk types, which encoders may generate and decoders may interpret.
+
+- Transparency information: tRNS (see 11.3.1 Transparency information).
+- Color space information: cHRM, gAMA, iCCP, sBIT, sRGB, cICP, mDCV (see 11.3.2 Color space information).
+- Textual information: iTXt, tEXt, zTXt (see 11.3.3 Textual information).
+- Miscellaneous information: bKGD, hIST, pHYs, sPLT, eXIf (see 11.3.4 Miscellaneous information).
+- Time information: tIME (see 11.3.5 Time stamp information).
+- Animation information: acTL, fcTL, fdAT (see 11.3.6 Animation information).
+
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/png_1.png?raw=true)             
+
+
+#### Textual information
+
+PNG provides the tEXt, iTXt, and zTXt chunks for storing text strings associated with the image, such as an image description or copyright notice. Keywords are used to indicate what each text string represents. Any number of such text chunks may appear, and more than one with the same keyword is permitted.
+
+11.3.3.1 Keywords and text strings
+The following keywords are predefined and should be used where appropriate.
+
+Table 21 Predefined keywords
+Keyword value	Description
+Title	Short (one line) title or caption for image
+Author	Name of image's creator
+Description	Description of image (possibly long)
+Copyright	Copyright notice
+Creation Time	Time of original image creation
+Software	Software used to create the image
+Disclaimer	Legal disclaimer
+Warning	Warning of nature of content
+Source	Device used to create the image
+Comment	Miscellaneous comment
+XML:com.adobe.xmp	Extensible Metadata Platform (XMP) information, formatted as required by the XMP specification [XMP]. The use of iTXt, with Compression Flag set to 0, and both Language Tag and Translated Keyword set to the null string, are recommended for XMP compliance.
+Collection	Name of a collection to which the image belongs. An image may belong to one or more collections, each named by a separate text chunk.
+Other keywords MAY be defined by any application for private or general interest.
+
+Keywords SHOULD be .
+
+- reasonably self-explanatory, since the aim is to let other human users understand what the chunk contains; and
+- chosen to minimize the chance that the same keyword is used for incompatible purposes by different applications.
+
+## 所有块
+
+The constraints on the positioning of the individual chunks are listed in Table 7 and illustrated diagrammatically for static images in Figure 11 and Figure 12, for animated images where the static image forms the first frame in Figure 13 and Figure 14, and for animated images where the static image is not part of the animation in Figure 15 and Figure 16. These lattice diagrams represent the constraints on positioning imposed by this specification. The lines in the diagrams define partial ordering relationships. Chunks higher up shall appear before chunks lower down. Chunks which are horizontally aligned and appear between two other chunk types (higher and lower than the horizontally aligned chunks) may appear in any order between the two higher and lower chunk types to which they are connected. The superscript associated with the chunk type is defined in Table 8. It indicates whether the chunk is mandatory, optional, or may appear more than once. A vertical bar between two chunk types indicates alternatives.
+
+Table 7 Chunk ordering rules
+Critical chunks
+(shall appear in this order, except PLTE is optional)
+Chunk name	Multiple allowed	Ordering constraints
+IHDR	No	Shall be first
+PLTE	No	Before first IDAT
+IDAT	Yes	Multiple IDAT chunks shall be consecutive
+IEND	No	Shall be last
+Ancillary chunks
+(need not appear in this order)
+Chunk name	Multiple allowed	Ordering constraints
+acTL	No	Before IDAT
+cHRM	No	Before PLTE and IDAT
+cICP	No	Before PLTE and IDAT
+gAMA	No	Before PLTE and IDAT
+iCCP	No	Before PLTE and IDAT. If the iCCP chunk is present, the sRGB chunk should not be present.
+mDCV	No	Before PLTE and IDAT.
+cLLI	No	Before PLTE and IDAT.
+sBIT	No	Before PLTE and IDAT
+sRGB	No	Before PLTE and IDAT. If the sRGB chunk is present, the iCCP chunk should not be present.
+bKGD	No	After PLTE; before IDAT
+hIST	No	After PLTE; before IDAT
+tRNS	No	After PLTE; before IDAT
+eXIf	No	Before IDAT
+fcTL	Yes	One may occur before IDAT; all others shall be after IDAT
+pHYs	No	Before IDAT
+sPLT	Yes	Before IDAT
+fdAT	Yes	After IDAT
+tIME	No	None
+iTXt	Yes	None
+tEXt	Yes	None
+zTXt	Yes	None
+
+
+我们发现上面也有eXif块:   
+#### eXif(Exchangeable Image File)  
+
+The data segment of the eXIf chunk contains an Exif profile in the format specified in "4.7.2 Interoperability Structure of APP1 in Compressed Data" of [CIPA-DC-008] except that the JPEG APP1 marker, length, and the "Exif ID code" described in 4.7.2(C), i.e., "Exif", NULL, and padding byte, are not included.
+
+The eXIf chunk size is constrained only by the maximum of 231-1 bytes imposed by the PNG specification. Only one eXIf chunk is allowed in a PNG datastream.
+
+The eXIf chunk contains metadata concerning the original image data. If the image has been edited subsequent to creation of the Exif profile, this data might no longer apply to the PNG image data. It is recommended that unless a decoder has independent knowledge of the validity of the Exif data, the data should be considered to be of historical value only. It is beyond the scope of this specification to resolve potential conflicts between data in the eXIf chunk and in other PNG chunks.
+
+
+
+PNG格式中的eXIf块​和​zTXt块​虽然都是用于存储元数据，但其设计目的、内部结构和适用场景有本质区别。
+
+
+PNG 格式中的eXIf块​和zTXt块​ 虽然都是用于存储元数据，但其设计目的、内部结构和适用场景有本质区别。
+
+为了更直观地理解它们的区别，我们可以通过以下流程图来快速判断哪种块更适合你的需求：
+​eXIf 块 (Chunk Type: 65 58 49 66 -> ASCII "eXIf")​​
+
+​1. 作用​
+唯一目的​：用于在 PNG 图像中嵌入 ​Exif（Exchangeable Image File Format）数据。
+​内容​：Exif 数据是一套高度标准化的元数据规范，主要用于记录数码照片的拍摄参数和设备信息。例如:     
+​- 相机参数​：光圈、快门速度、ISO、焦距、镜头型号
+​- 设备信息​：相机制造商、型号
+​- 时间信息​：照片原始拍摄时间（DateTimeOriginal）
+​- 位置信息​：GPS 坐标（经度、纬度、高度）
+​- 版权信息​：作者、版权说明
+​- 缩略图​：嵌入式的小尺寸预览图
+
+
+
+### 应该选择哪一个？​​
+
+​要保存相机的拍摄信息（光圈、快门、GPS等）？​​
+-> 使用 ​eXIf 块。（例如：用 exiftool -tagsFromFile source.jpg -all:all拷贝）
+
+​要写入自己定义的文字、配置或标识（如 aigc:{"model":"GPT-4"}）？​​
+-> 使用 ​zTXt 块。（例如：用 exiftool -zTXt:YourKey="Your Value"写入）
+
+​简单总结：eXIf 用于“相机说什么”，zTXt 用于“你想说什么”。​
diff --git "a/VideoDevelopment/\345\233\276\347\211\207\346\240\274\345\274\217/WebP.md" "b/VideoDevelopment/\345\233\276\347\211\207\346\240\274\345\274\217/WebP.md"
new file mode 100644
index 00000000..fa55a758
--- /dev/null
+++ "b/VideoDevelopment/\345\233\276\347\211\207\346\240\274\345\274\217/WebP.md"
@@ -0,0 +1,87 @@
+# WebP
+
+WebP是一种图片格式，它使用VP8关键帧编码，以有损方式压缩图像数据或WebP无损编码。    
+
+除了 WebP 的基本用例（即包含编码为 VP8 关键帧的单个图片的文件）之外，WebP 容器（即 WebP 的 RIFF 容器）还支持其他功能。WebP 容器提供 对以下各项的支持:    
+
+- 无损压缩：可以使用 WebP 无损格式对图片进行无损压缩。
+
+- 元数据：图片中可能有存储于可交换图片文件中的元数据 格式 (Exif) 或可扩展元数据平台 (XMP) 格式。
+
+- 透明度：图片可以具有透明度，即 alpha 通道。
+
+- 颜色配置文件：图片可能具有如国际色彩联盟所述的嵌入式 ICC 配置文件。
+
+- 动画：同一张图片可能包含多个帧，帧之间会暂停播放； 使其成为动画
+
+
+在图片（和多媒体）文件格式中，​RIFF​ 是一个容器格式，或者说是一种文件结构规范，而不是一种图片编码格式本身。
+
+您可以把它理解为一个盒子或文件夹，里面可以装各种不同的东西（图片数据、音频数据、元数据等）。
+
+### RIFF
+
+RIFF​ 的全称是 ​Resource Interchange File Format​（资源交换文件格式），由微软公司在1991年提出。    
+
+它的核心思想是：​所有数据都存储在称为“块（Chunks）”的结构中。
+
+#### RIFF 文件的结构
+
+一个典型的 RIFF 文件由以下几个部分组成:     
+
+​- RIFF 头（Header）​​:      
+    - RIFF（4字节）：固定标识，表明这是一个RIFF格式的文件。
+    - 文件大小（4字节）：从下一个字节开始到文件结尾的总大小。
+    - 格式类型（4字节）：用四个字符代码（FOURCC）定义文件的具体类型，例如 AVI或 WAVE。
+​- 块（Chunks）​​:     
+
+在文件头之后，就是一系列的数据块。
+每个块都有自己的头和信息:     
+- 块ID（4字节）：用四个字符代码标识这个块是什么（例如 fmt是格式块，data是数据块）。
+- 块大小（4字节）：该块数据部分的大小。
+- 块数据（可变长度）：实际的数据内容。
+
+​- 列表块（LIST Chunks）​​:     
+
+这是一种特殊的块，它本身内部又可以包含其他多个子块，用于更复杂的数据组织。
+
+​用个比喻来说:    
+
+一个 RIFF 文件就像一个行李箱（RIFF Container）​，上面贴着一个标签写着“摄影器材”（格式类型= PHOT）。箱子里面有几个收纳盒（Chunks）​，每个收纳盒上又贴着“镜头”、“机身”、“电池”等标签（块ID）。这样就可以井井有条地存放所有东西。
+
+
+#### 与图片格式的关系
+
+RIFF 作为一种容器，被用于多种图片格式。最著名的例子就是WebP:     
+
+一个典型的 WebP 文件结构如下:    
+```
+RIFF Header (标识这是一个RIFF文件，格式类型为 'WEBP')
+|
++-- VP8 (或 VP8L, VP8X) Chunk (存储实际的图片编码数据)
+|
++-- ANIM Chunk (可选，如果存在则表示是动画WebP)
+|
++-- ANMF Chunk (可选，动画帧数据)
+|
++-- EXIF Chunk (可选，存储EXIF元数据)
+|
++-- XMP  Chunk (可选，存储XMP元数据)
+|
++-- ... (其他可选块)
+```
+
+
+WebP的强大之处在于它利用了RIFF容器的可扩展性，可以轻松的在一个文件中包含静态图、动画、Alpha透明度、元数据等多种信息。   
+
+
+
+简单来说:   
+
+- RIFF: 是一种文件结构或容器规范，可以比喻成行李箱
+- JPEG、PNG: 是一种图片编码格式，可以比喻成一种折叠衣服的方法。注意PNG拥有自己独特的、与RIFF无关的容器结构。   
+- WebP: 使用RIFF容器来包装VP8编码数据的图片格式，可以比喻成用行李箱装了特定方法折叠好的衣服
+
+
+
+
diff --git "a/VideoDevelopment/\345\233\276\347\211\207\346\240\274\345\274\217/\345\233\276\347\211\207\345\205\203\346\225\260\346\215\256.md" "b/VideoDevelopment/\345\233\276\347\211\207\346\240\274\345\274\217/\345\233\276\347\211\207\345\205\203\346\225\260\346\215\256.md"
new file mode 100644
index 00000000..1748eb73
--- /dev/null
+++ "b/VideoDevelopment/\345\233\276\347\211\207\346\240\274\345\274\217/\345\233\276\347\211\207\345\205\203\346\225\260\346\215\256.md"
@@ -0,0 +1,118 @@
+# 图片元数据
+
+简单来说，元数据就是有关数据的数据。      
+
+
+实际上，元数据是关于文件的一组标准化信息，如作者姓名、分辨率、色彩空间、版权以及应用于文件的关键字。例如，多数摄像机会在视频文件中附加一些基本信息，如日期、持续时间和文件类型。
+
+
+
+
+## 元数据分类
+
+对于数码图像，目前常见的元数据有EXIF、IPTC、XMP三种:   
+
+- EXIF: 通常被数码相机在拍摄照片时自动添加，比如相机型号、镜头、曝光、图片尺寸等信息
+- IPTC: 比如图片标题、关键字、说明、作者、版权等信息。主要是由人工在后期通过软件写入的数据。
+- XMP: XMP实际上是一种元数据存储和管理的标准，可以将Exif，IPTC或其他的数据都按XMP统一的格式存放在图像文件中。
+- ICC: 色彩管理、色彩空间
+
+### 1.EXIF/标准元数据
+
+EXIF（Exchangeable Image File Format，可交换图像文件格式）
+
+这是最常见的元数据类型，主要记录拍摄参数、设备信息、时间、位置等数据。以下是常见 EXIF 信息分类：
+
+- 拍摄参数类:  
+    - 曝光时间
+    - 焦距
+    - ISO感光度等
+
+- 时间与位置
+    - 拍摄时间
+    - 文件创建时间
+    - GPS经纬度
+    - 海拔
+
+- 设备信息
+    - Make: 相机/手机制造商(例如Apple)
+    - Model: 设备型号(如iPhone14)
+    - LensModel: 镜头型号
+
+- 图片属性
+    - 图片宽高
+    - Orientation: 拍摄方向
+    - 压缩方式
+    - 缩略图数据(如有)    
+
+### 2. ICC/色彩管理的核心
+ICC（International Color Consortium，国际色彩联盟）元数据是嵌入在图像文件中的色彩管理数据，用于确保不同设备（相机、显示器、打印机）呈现的色彩一致性。
+
+### 3. XMP/图像的可扩展元数据
+
+[XMP](https://helpx.adobe.com/cn/after-effects/using/xmp-metadata.html)Extensible Metadata Platform，可扩展元数据平台）是 Adobe 开发的一种标准化元数据格式，用于嵌入到图片、视频、PDF 等文件中。它比 EXIF 更灵活，支持自定义字段和结构化数据，具有高度可扩展性。   
+
+核心特点​:   
+
+- 基于RDF/XML格式
+    - XML: 语法规则，提供了语法(如何写)
+    - RDF: 数据模型，提供了语义(什么意思)，确保不同系统、不同厂商、不同标准的元数据都能够共存且被正确理解
+    - 总结: RDF在XML提供的语法基础上，增加了语义层，使得数据不仅仅是结构化的，更是有意义且可互联的。    
+- 支持自定义命名空间和属性
+- 可以嵌入到多种文件格式中
+- 支持复杂数据结构（数组、嵌套对象）
+
+
+例如: 在元数据中增加一个信息，如果没有 RDF，只是自定义 XML：:  
+```
+<metadata>
+    <TC260:AIGC>{"Label":"value1"}</TC260:AIGC>
+</metadata>
+```
+问题​：其他系统看不懂 TC260:AIGC是什么意思，无法理解和重用这个数据。
+
+使用 RDF (XMP 的实际做法):
+
+```
+<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+         xmlns:tc260="http://www.tc260.org.cn/ns/AIGC/1.0/">
+    <rdf:Description rdf:about="">
+        <tc260:AIGC>{"Label":"value1"}</tc260:AIGC>
+    </rdf:Description>
+</rdf:RDF>
+```
+优势​:   
+​
+- 明确语义​：通过 xmlns:tc260="http://www.tc260.org.cn/ns/AIGC/1.0/"明确指出了 tc260:AIGC的含义是由该命名空间定义的。任何人都可以访问这个 URI 来了解 AIGC属性的正式定义。
+​- 可扩展性​：可以轻松混合来自不同来源的元数据。例如，可以同时包含 Dublin Core 的标题和您自定义的 TC260 标签，而不会产生冲突。
+​- 机器可读​：计算机程序可以自动解析和理解这些关系，实现数据的互联和智能处理。
+
+
+
+### 4. IPTC
+
+IPTC(International Press Telecommunications Council)，
+最初为新闻行业设计，主要用于描述图片内容和版权信息。   
+
+
+
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/metadata_1.png?raw=true)             
+
+
+EXIF里面保存的是二进制数据，而且基本都是固定的字段，主要应用于相机参数、时间等。    
+
+XMP中则是XML文本而且支持扩展性，可用于编辑元数据、版权等。   
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git "a/VideoDevelopment/\351\237\263\351\242\221\347\274\226\347\240\201/\351\237\263\351\242\221\347\274\226\347\240\201\346\240\274\345\274\217.md" "b/VideoDevelopment/\351\237\263\351\242\221\347\274\226\347\240\201/\351\237\263\351\242\221\347\274\226\347\240\201\346\240\274\345\274\217.md"
index 84d9fe63..a0d2f54b 100644
--- "a/VideoDevelopment/\351\237\263\351\242\221\347\274\226\347\240\201/\351\237\263\351\242\221\347\274\226\347\240\201\346\240\274\345\274\217.md"
+++ "b/VideoDevelopment/\351\237\263\351\242\221\347\274\226\347\240\201/\351\237\263\351\242\221\347\274\226\347\240\201\346\240\274\345\274\217.md"
@@ -1,5 +1,10 @@
 ## 音频编码格式
 
+多媒体要想发声，就得加个喇叭，但是喇叭是靠模拟信号驱动的，所以在喇叭之前需要增加一个数字信号转模拟信号的“解码器”，
+将数字信号转换为模拟信号。      
+
+其次还需要增加一个信号放大器，将微弱的电流放大成足以驱动喇叭磁铁产生足够磁力从而震动纸盆的足够强的电流。
+
 原始的PCM音频数据也是非常大的数据量，因此也需要对其进行压缩编码。
 和视频编码一样，音频也有许多的编码格式，如：WAV、MP3、WMA、APE、FLAC等等，音乐发烧友应该对这些格式非常熟悉，特别是后两种无损压缩格式。
 
diff --git a/test.md b/test.md
new file mode 100644
index 00000000..e69de29b