46 | This is a paragraph 47 |
48 | ``` 49 | 50 | -------------------------------------------------------------------------------- /books/图解Http/第7章-确保Web安全的HTTPS.md: -------------------------------------------------------------------------------- 1 | # 第7章-确保Web安全的HTTPS 2 | 3 | 4 | 5 | SSL 采用 公开密钥加密的加密处理方式。 6 | 7 | #### 共享密钥加密 8 | 9 | 加密和解密同用一个密钥的方式称为共享密钥加密，也被称为 对称密钥加密。 10 | 11 | 加密时必须把密钥发送给对方，那么如何保证安全就是个问题 12 | 13 | #### 公开密钥加密 14 | 15 | 公开密钥加密使用一对『非对称的密钥』。一把叫做私有密钥，另一把叫做公开密钥。 16 | 17 | 发送时，发送公钥加密，解密使用私钥，安全。 18 | 19 | 相对于 共享密钥加密，公开密钥加密更加复杂，所以效率更低。 20 | 21 | 破解：对离散对数进行求值，有希望，但是目前不太现实。 22 | 23 | #### 混合加密 24 | HTTPS 采用混合加密 即 共享密钥加密 和 公开密钥加密 并用。 25 | 26 | 利用两个加密方式各自的有点，使用安全性更高的公开密钥加密来传输共享密钥所使用的密钥，然后使用效率更高的共享密钥加密来进行后续通讯，又安全又快。 27 | 28 | 29 | #### 证书 30 | 31 | 公开密钥加密方式的缺点是：无法证明公开密钥本身就是货真价实的公开密钥。 32 | 33 | 注：本质上来说密钥依然是数据，在传输的过程中，还是可能会遭恶意篡改。 34 | 35 | EV SSL 36 | 37 | 38 | -------------------------------------------------------------------------------- /leetcode/344-反转字符串.md: -------------------------------------------------------------------------------- 1 | # 344.反转字符串 2 | 3 | 4 | 5 | 编写一个函数，其作用是将输入的字符串反转过来。输入字符串以字符数组 `char[]` 的形式给出。 6 | 7 | 不要给另外的数组分配额外的空间，你必须**原地修改输入数组**、使用 O(1) 的额外空间解决这一问题。 8 | 9 | 你可以假设数组中的所有字符都是 [ASCII](https://baike.baidu.com/item/ASCII) 码表中的可打印字符。 10 | 11 | 12 | 13 | ```java 14 | class Solution { 15 | public void reverseString(char[] s) { 16 | for(int i = 0;i<(s.length+1)/2;i++){ 17 | char tmp = s[i]; 18 | s[i]=s[s.length-1-i]; 19 | s[s.length-1-i]=tmp; 20 | } 21 | } 22 | } 23 | ``` 24 | 25 | 26 | 27 | 执行用时 : 4 ms, 在Reverse String的Java提交中击败了93.67% 的用户 28 | 29 | 内存消耗 : 52 MB, 在Reverse String的Java提交中击败了76.89% 的用户 -------------------------------------------------------------------------------- /books/HeadFirstDesignPatterns/Iterator.md: -------------------------------------------------------------------------------- 1 | # 迭代器模式 2 | 3 | 迭代器模式(Iterator)： **提供一种方法顺序访问一个聚合对象中的各个元素，而又不暴露其内部的表示**。 4 | 5 | 迭代器模式服务『集合』，为了更好地管理集合。 6 | 7 | 所谓集合(Collection)就是是，**一群对象**，可以放在数组、堆栈、列表、散列表等。 8 | 集合有时候也被称为『聚合』(aggregate)。 9 | 10 | 11 | ## 迭代器的意义与优势 12 | 13 | 1. 我们不需要知道一个集合到底是数组还是列表还是什么其他的结构。 14 | 2. 把游走的任务放在迭代器上，而不是聚合上。这样简化了聚合的接口和实现，也让责任各得其所。 15 | 16 | 17 | 18 | ## 要点 19 | 20 | 1. 迭代器允许访问聚合的元素，而不需要暴露它的内部结构。 21 | 2. 迭代器将遍历聚合的工作封装进一个对象中。 22 | 3. 当使用迭代器的时候，我们依赖聚合提供遍历。 23 | 4. 迭代器提供了一个通用的接口，让我们遍历聚合的项，当我们编码使用聚合的项时，就可以使用多台机制。 24 | 25 | 26 | ## 小结 27 | 28 | Java中已经存在有 `Iterator` 了，大部分情况下，我们不需要自己在写。 29 | 如果要加新的功能，当然还是可以扩展的，比如 `ListIterator`新增了`previous`等方法。 30 | -------------------------------------------------------------------------------- /gradle/gradle-params.md: -------------------------------------------------------------------------------- 1 | # Gradle 传递 参数 2 | 3 | 4 | 5 | 6 | 7 | - `-P` 8 | - `-D` 9 | 10 | 11 | 12 | 通过命令行传递 String 类型的参数时，需要转义符号： 13 | 14 | ```shell 15 | ./gradlew assembleDebug -Dcv="\"字符串需要转义符号\"" 16 | ``` 17 | 18 | 19 | 20 | 在 build.gradle 里可以这样接受参数： 21 | 22 | ```groovy 23 | String customValue = System.properties.getProperty("cv") 24 | ``` 25 | 26 | 27 | 28 | 29 | 30 | ### BuildConfig 参数配置 31 | 32 | 33 | 34 | ```groovy 35 | android { 36 | defaultConfig { 37 | buildConfigField("String", "Author", "\"程序亦非猿\"") 38 | } 39 | } 40 | ``` 41 | 42 | 在 BuildConfig 类中会生成一个属性： 43 | 44 | ```java 45 | public static final String Author = "程序亦非猿"; 46 | ``` 47 | 48 | -------------------------------------------------------------------------------- /ds-algorithm-proj/src/me/yifeiyuan/dsalgorithm/learn/LearnArrayList.java: -------------------------------------------------------------------------------- 1 | package me.yifeiyuan.dsalgorithm.learn; 2 | 3 | import java.util.ArrayList; 4 | 5 | /** 6 | * Created by 程序亦非猿 on 2020/4/15. 7 | */ 8 | public class LearnArrayList { 9 | 10 | 11 | public static void main(String[] args) { 12 | 13 | ArrayList
9 |
10 |
11 | ### 针对 Web 的攻击技术
12 |
13 | - HTTP不具备必要的安全功能
14 | - 在客户端即可篡改请求
15 |
16 | ### 因输出值转义不完全引发的安全漏洞
17 |
18 | - 跨站脚本攻击 XSS
19 |
20 | - SQL注入攻击
21 |
22 | - OS命令注入攻击
23 |
24 | - HTTP首部注入攻击
25 | - 首部注入
26 | - 响应截断
27 |
28 | - 邮件首部注入攻击
29 |
30 | - 目录遍历攻击
31 |
32 | - 远程文件包含漏洞
33 |
34 | ### 因设置或设计上的缺陷引发的安全漏洞
35 |
36 | - 强制浏览
37 | - 不正确的错误消息处理
38 | - 开放重定向
39 |
40 | ### 因会话管理疏忽引发的安全漏洞
41 |
42 | - 会话劫持
43 | - 会话固定攻击
44 | - 跨站点请求伪造
45 |
46 | ### 其他安全漏洞
47 |
48 | - 密码破解
49 | - 点击劫持
50 | - Dos 攻击
51 | - 后门程序
--------------------------------------------------------------------------------
/books/HeadFirstDesignPatterns/State.md:
--------------------------------------------------------------------------------
1 | # 状态模式
2 |
3 | 状态模式： **允许对象在内部状态改变时改变它的行为，对象看起来好像修改它的类。**
4 |
5 |
6 | 状态模式把每个状态都独立成类，并将动作委托到代表当前状态的对象。
7 |
8 |
9 | 
10 |
11 |
12 | Context需要持有 **所有状态的一个实例**（弹性的代价），通过不同状态来切换状态对象，把行为委托给当前状态的对象，客户端不知道Context内部的状态，跟策略模式不同，策略模式需要客户端去指定策略，而且一般来讲策略模式就只有一个最佳策略，不会存在多个。
13 |
14 |
15 | ## 要点
16 |
17 | 1. 状态模式允许一个对象基于内部状态而拥有不同的行为。
18 | 2. 和程序状态机（PSM）不同，状态模式用类代表状态。
19 | 3. Context会将行为委托给当前状态对象。
20 | 4. 通过将每个状态封装进一个类，我们把以后需要做的任何状态局部化了。
21 | 5. 状态模式和策略模式有相同的类图，但是它们的意图不同。
22 | 6. 策略模式通常会用行为或算法来配置Context类。
23 | 7. 状态模式允许Context随着状态的改变而改变行为。
24 | 8. 状态转换可以由State类或Context类控制。
25 | 9. 使用状态模式通常会导致设计中类的数目大量增加。
26 | 10. 状态类可以被多个Context实例共享。
27 |
--------------------------------------------------------------------------------
/android/asm.md:
--------------------------------------------------------------------------------
1 | # ASM
2 |
3 | > 迁移语雀 2021-2-22
4 |
5 |
6 | ASM是一个通用的 **Java 字节码操作和分析框架**。 它可以**直接以二进制形式用于修改现有类或动态生成类**。 ASM提供了一些常见的字节码转换和分析算法，可以从中构建定制的复杂转换和代码分析工具。 ASM提供与其他Java字节码框架类似的功能，但**侧重于性能**。 因为它的设计和实现是尽可能的小和尽可能快，所以它非常适合在动态系统中使用（但当然也可以以静态方式使用，例如在编译器中）。(官网介绍)
7 |
8 |
9 |
10 | ASM 操作 class 文件，而在 Android 中其实是 dex 文件，不能直接操作 class 文件，所以如果要在 Android 中使用，得配合 gradle 插件以及 gradle 的 transform api 。
11 |
12 |
13 |
14 |
15 |
16 |
17 |
18 |
19 |
20 | ## 资料
21 |
22 | 1. [ASM](https://asm.ow2.io/index.html)
23 | 2. [AOP 的利器：ASM 3.0 介绍](https://www.ibm.com/developerworks/cn/java/j-lo-asm30/index.html)
24 | 3. [【Android】函数插桩（Gradle + ASM）](https://cloud.tencent.com/developer/article/1399805)
25 | 4. [Android全埋点解决方案之ASM](https://www.sensorsdata.cn/blog/20181206-9/)
--------------------------------------------------------------------------------
/books/JavaScriptDom编程艺术/第1章-JavaScript简史.md:
--------------------------------------------------------------------------------
1 | # 第1章-JavaScript简史
2 |
3 | > Write once,run anywhere.
4 |
5 | JavaScript是一门脚本语言，是解释型语言，需要 Web浏览器进行解释和执行。
6 |
7 | JavaScript 是 Netscapte 公司与 Sun 公司合作开发的。
8 |
9 | JavaScript 与 Java 毫无关系。
10 |
11 |
12 | HTML(超文本标记语言)，CSS(层叠样式表)。
13 |
14 | ## DOM
15 |
16 | 什么是 DOM（文档对象模型，Document Object Model）？
17 |
18 | DOM 是一套对文档的内容进行抽象和概念化的方法；所有与 Web 标准相兼容的 Web浏览器都支持它。
19 |
20 | DHTML是 Dynamic HTML(动态 HTML)，是描述 HTML CSS 和 JavaScript 技术组合的术语。
21 |
22 | DHTML 背后的含义：
23 |
24 | 1. 利用 HTML 把网页标记为各种元素；
25 | 2. 利用 CSS 设置元素样式和它们的显示位置；
26 | 3. 利用 JavaScript 实时地操控页面和改变样式。
27 |
28 | 利用 DHTML 可以非常容易实现复杂的动画效果。
29 |
30 |
31 | ## 制定标准
32 |
33 | W3C对 DOM 的定义是：“一个与系统平台和编程语言无关的接口，程序和脚本可以通过这个接口动态地访问和修改文档的内容、结构和样式”。
34 |
35 |
36 |
37 |
38 |
39 |
--------------------------------------------------------------------------------
/leetcode/434-字符串中的单词数.md:
--------------------------------------------------------------------------------
1 | # 434.字符串中的单词数
2 |
3 |
4 |
5 | 统计字符串中的单词个数，这里的单词指的是连续的不是空格的字符。
6 |
7 | 请注意，你可以假定字符串里不包括任何不可打印的字符。
8 |
9 | **示例:**
10 |
11 | ```
12 | 输入: "Hello, my name is John"
13 | 输出: 5
14 | ```
15 |
16 | ```java
17 | class Solution {
18 | public int countSegments(String s) {
19 | int count = 0;
20 | boolean lastIsBlank = true;
21 | for (int i = 0; i < s.length(); i++) {
22 | if (s.charAt(i) == ' ') {
23 | lastIsBlank = true;
24 | } else {
25 | if (lastIsBlank) {
26 | count++;
27 | }
28 | lastIsBlank = false;
29 | }
30 | }
31 | return count;
32 | }
33 | }
34 | ```
35 |
36 |
37 |
38 | 思路：查看之前的字符是否是空格，如果是，则判断已经存在一个字母。
--------------------------------------------------------------------------------
/books/图解Http/第10章-构建Web内容的技术.md:
--------------------------------------------------------------------------------
1 | # 第10章-构建Web内容的技术
2 |
3 | Web使用各种各样的技术，来呈现丰富多彩的内容。
4 |
5 | 
6 |
7 | ### Html
8 |
9 | #### CSS
10 |
11 | 层叠样式表；可以指定如何展现HTML 内的各种元素，属于样式表标准之一。
12 |
13 | - 让文档的结构和设计分离，达到解耦的目的。
14 |
15 | ### 动态 Html
16 |
17 | #### JavaScript
18 |
19 | #### DOM
20 |
21 | ### Web应用
22 |
23 | #### CGI
24 |
25 | CGI，通用网关接口，是指 Web 服务器在接收到客户端发送过来的请求后转发给程序的一组机制。
26 |
27 | - Perl
28 | - PHP
29 | - Ruby
30 | - C
31 |
32 | #### Servlet
33 |
34 | JavaEE 的产物，现在应该被淘汰了吧？不太清楚了。
35 |
36 | ### 数据发布的格式及语言
37 |
38 | #### XML
39 |
40 | 可扩展标记语言。
41 |
42 | #### RSS/Atom
43 |
44 | RSS（简易信息聚合，也叫聚合内容）和 Atom 都是发布新闻或博客日志等更新信息文档的格式的总称。
45 |
46 | RSS 还是有在用的。
47 |
48 | #### JSON
49 |
50 | 一种以 JavaScript 的对象表示法为基础的轻量级数据标记语言。
51 |
--------------------------------------------------------------------------------
/fed/js/var-let-const.md:
--------------------------------------------------------------------------------
1 | # Var Let Const
2 |
3 |
4 |
5 |
6 |
7 | 用 var let const 尝试定义同一个变量两遍得到的结果：
8 |
9 | **用 var**：
10 |
11 | ```js
12 | var a = 555
13 | var a = 666
14 | console.log(a)
15 | //输出 666
16 | ```
17 |
18 | **用 let:**
19 |
20 | ```js
21 | let b = 1
22 | let b = 2;
23 | console.log(b)
24 | ```
25 |
26 | 报错：
27 |
28 | ```
29 | Uncaught SyntaxError: Identifier 'b' has already been declared
30 | ```
31 |
32 |
33 |
34 | **用 const：**
35 |
36 | ```js
37 | const c = 1
38 | const c = 2
39 | console.log(c)
40 | ```
41 |
42 | 报错：
43 |
44 | ```js
45 | Uncaught SyntaxError: Identifier 'c' has already been declared
46 | ```
47 |
48 |
49 |
50 | ### 总结
51 |
52 | 1. var 可以声明定义一个变量多次，而 let、const 则不行；
53 | 2.
54 |
55 |
56 |
57 |
58 |
59 | 定义变量，**优先使用 const，let 次之，尽量避免使用 var**。
60 |
61 |
62 |
63 |
64 |
65 |
66 |
67 |
--------------------------------------------------------------------------------
/ds/queue.md:
--------------------------------------------------------------------------------
1 | # 队列 Queue
2 |
3 | [TOC]
4 |
5 |
6 |
7 | ### 什么是队列？
8 |
9 |
10 |
11 | 队列是`先进先出`（FIFO，First-In-First-Out）的`线性表`。队列只允许在后端(rear)进行插入操作，在前端(front)进行删除操作。通常用`数组`或`链表`来实现。
12 |
13 |
14 |
15 | **注：**队列跟生活中的排队是一个道理，先排队的先出去，只能从队尾排队（插入），从队头出队（删除）。
16 |
17 |
18 |
19 |
20 |
21 |
22 |
23 | ### 队列的分类
24 |
25 |
26 |
27 | 队列可以分为几个：
28 |
29 | 1. `单链队列`，使用链表实现的队列对内存要求比较低（因为内存不连续），`不存在内存伪溢出的问题`，队列长度也没有限制。但插入和读取的时间代价较高。
30 | 2. `循环队列`，循环队列可以更简单防止伪溢出的发生，但队列大小是固定的。
31 | 3. `阵列队列`
32 |
33 |
34 |
35 |
36 |
37 | ### 复杂度
38 |
39 |
40 |
41 | | 算法 | 平均 | 最差 |
42 | | ---- | ------ | ------ |
43 | | 空间 | O(*n*) | O(*n*) |
44 | | 搜索 | O(*n*) | O(*n*) |
45 | | 插入 | O(1) | O(1) |
46 | | 删除 | O(1) | O(1) |
47 |
48 |
49 |
50 |
51 |
52 | ### 资料
53 |
54 | [https://zh.wikipedia.org/wiki/%E9%98%9F%E5%88%97](https://zh.wikipedia.org/wiki/队列)
--------------------------------------------------------------------------------
/ds-algorithm-proj/src/me/yifeiyuan/dsalgorithm/learn/LearnLinkedList.java:
--------------------------------------------------------------------------------
1 | package me.yifeiyuan.dsalgorithm.learn;
2 |
3 | /**
4 | * Created by 程序亦非猿 on 2019/12/30.
5 | */
6 | public class LearnLinkedList {
7 |
8 |
9 | public static void main(String[] args) {
10 |
11 | Node node1 = new Node(1);
12 | Node node2 = new Node(2);
13 | Node node3 = new Node(3);
14 |
15 | }
16 |
17 |
18 | class LinkedList {
19 |
20 |
21 | Node header;
22 |
23 | Node tail;
24 |
25 | public void add(int value) {
26 |
27 | }
28 |
29 | }
30 |
31 | public static class Node {
32 |
33 | Node next;
34 | int value;
35 |
36 | public Node(int value) {
37 | this.value = value;
38 | }
39 |
40 | Node next() {
41 | return next;
42 | }
43 | }
44 | }
45 |
--------------------------------------------------------------------------------
/books/HeadFirstDesignPatterns/Observer.md:
--------------------------------------------------------------------------------
1 | # 观察者模式
2 |
3 | 观察者模式：
4 | **定义了对象之间的一对多依赖，这样依赖，当一个对象改变状态时，它的所有依赖者都会受到通知，并自动更新。**
5 |
6 |
7 | 
8 |
9 | 出版者（Subject） + 订阅者（Observer） = 观察者模式
10 |
11 | 观察者依赖于主题。
12 |
13 |
14 | 
15 |
16 | **观察者模式提供了一种对象设计，让主题和观察者之间松耦合。**
17 |
18 | 1. 观察者与主题之间依赖于接口，主题不需要知道观察者的具体实现
19 | 2. 可以动态添加删除观察者，对主题没有任何影响
20 | 3. 新增新类型的观察者对主题没有影响，主题的代码不需要修改，而且旧的观察者也不受影响
21 | 4. 观察者与主题都可以独立复用，因为是松耦合
22 | 5. 只要约定的接口不改变，修改主题或观察者任何一方，都不会影响另一方
23 |
24 |
25 |
26 | 比如 EventBus 就是观察者模式。
27 | 注意： **观察者模式会造成内存泄漏，一定要记得取消订阅**
28 |
29 |
30 |
31 | ## See also
32 | [Observer pattern](https://en.wikipedia.org/wiki/Observer_pattern)
33 | [Observer Design Pattern Example](http://javadesign-patterns.blogspot.com/p/page22.html)
34 |
--------------------------------------------------------------------------------
/java/linkedblockingdeque.md:
--------------------------------------------------------------------------------
1 | # LinkedBlockingDeque
2 |
3 |
4 |
5 |
6 |
7 | ```java
8 | public static void main(String[] args) {
9 | BlockingQueue
18 |
19 |
20 |
21 | 堆栈常用`一维数组`或`链表`来实现。
22 |
23 |
24 |
25 | ### 堆栈的操作
26 |
27 |
28 |
29 | - `入栈`，push，将数据放入栈的顶部；
30 | - `出栈`，pop，将栈顶数据移除；
31 |
32 |
33 |
34 | ### 堆栈的特性
35 |
36 |
37 |
38 | 1. 先进后出，后进先出；
39 | 2. 除了头尾节点之外，每个元素都有一个前驱，一个后继；
40 |
41 |
42 |
43 | ### Java 中的堆栈
44 |
45 |
46 |
47 | Java 中有 Stack 以及 ArrayDeque 可以实现栈的功能，推荐使用 ArrayDeque。
48 |
49 |
50 |
51 | ### 栈的应用
52 |
53 | todo
54 |
55 | - [回溯](https://zh.wikipedia.org/wiki/回溯法)
56 | - [递归](https://zh.wikipedia.org/wiki/递归)
57 | - [深度优先搜索](https://zh.wikipedia.org/wiki/深度优先搜索)
58 |
59 |
60 |
61 | ### 资料
62 |
63 | https://zh.wikipedia.org/wiki/%E5%A0%86%E6%A0%88
--------------------------------------------------------------------------------
/android/activity-1.md:
--------------------------------------------------------------------------------
1 | # Activity
2 |
3 | > 迁移语雀 2021-2-22
4 |
5 |
6 | ### 启动模式
7 |
8 |
9 |
10 |
11 |
12 | #### Flags
13 |
14 | ##### FLAG_ACTIVITY_REORDER_TO_FRONT
15 |
16 | ```java
17 | Intent intent = new Intent(this, Foo.class);
18 | intent.addFlags(Intent.FLAG_ACTIVITY_REORDER_TO_FRONT);
19 | startActivity(intent);
20 | ```
21 |
22 | 如果 Activity 已经存在，则会被移动到栈顶，不会新启动一个 Activity。（onNewIntent 会被调用）
23 |
24 | 例如有 A、B、C 三个 Activity，再次启动 B 要变成：A C B 而不是 A B C B 的话，就可以使用它。
25 |
26 | 坑：透明的 Activity 不起作用， 得加上启动模式 singleTask or singleTask。
27 |
28 |
29 | ##### FLAG_ACTIVITY_CLEAR_TOP
30 |
31 | ```java
32 | intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
33 | ```
34 |
35 | 如果目标 Activity 存在，则会清除它顶部的所有 Activity，并将 Intent 传递给它，调用 onNewIntent() 。
36 |
37 | A B C D ，启动 B ==> A B ， CD 都因为在 B 顶部所以被移除。
38 |
39 | 但是默认情况下这个 B 会被重启，如果不想，则需要加`FLAG_ACTIVITY_SINGLE_TOP` 到 Intent 上。
40 |
41 | https://developer.android.com/reference/android/content/Intent.html#FLAG_ACTIVITY_CLEAR_TOP
--------------------------------------------------------------------------------
/books/HeadFirstDesignPatterns/Decorator.md:
--------------------------------------------------------------------------------
1 | # 装饰者模式
2 |
3 | 装饰者模式：
4 |
5 | **动态地将责任附加到对象上，若要扩展功能，装饰者提供了比继承更有弹性的替代方案。**
6 |
7 | 装饰者模式可以给类 **动态地添加功能，而不需要修改已经存在的类**，类似一个`Wrapper`。
8 |
9 | 装饰者有弹性，非常符合 `开闭原则`
10 |
11 | ## 特点
12 |
13 | 1. 装饰者和被装饰者对象**拥有相同的超类型**
14 | 2. 你可以用一个或多个装饰者包装一个对象
15 | 3. 既然装饰者和被装饰者对象拥有相同的超类型，所以在任何需要原始对象（被包装的）的场合，可以用装饰过的对象替代它
16 | 4. **装饰者可以在所委托被装饰者的行为之前或之后加上自己的行为，以达到特定的目的**
17 | 5. 对象可以在任何时候被装饰，所以可以在运行时动态地不限量地用你喜欢的装饰者来装饰对象
18 |
19 |
20 | ## 装饰者模式的缺点
21 |
22 | **可能会引入大量的类**，导致理解起来并不容易，也可能会使使用者懵逼。
23 |
24 | 可能会出现以下情况：
25 | ```
26 | D a = new A(new B(new C(new D)));
27 | ```
28 |
29 | 比较复杂，难以理解。
30 |
31 | ## 具体使用
32 |
33 | Java源码中的`I/O`就是装饰者模式，各种 `XXXStream`、`Reader` 和 `Writer`。
34 |
35 | 比如：
36 |
37 | ```
38 | BufferedReader reader = new BufferedReader(new FileReader(new File("C:\\testing.txt")));
39 | ```
40 |
41 | ## See also
42 | [Decorator Design Pattern Example](http://javadesign-patterns.blogspot.com/p/decorator.html)
43 |
--------------------------------------------------------------------------------
/fed/js/README.md:
--------------------------------------------------------------------------------
1 | # JavaScript
2 |
3 |
4 |
5 |
6 |
7 |
8 |
9 |
10 |
11 |
12 |
13 |
14 |
15 | JS 的问题：
16 |
17 | 1. 语法太灵活导致开发大型 Web 项目困难；解法：TypeScript
18 | 2. 性能不能满足一些场景的需要；解法：Google 的 V8
19 |
20 |
21 |
22 |
23 |
24 | ### TypeScript
25 |
26 |
27 |
28 | 
29 |
30 |
31 |
32 | ### Google : V8
33 |
34 | V8 是 Google 推出的 JS 引擎，使用 JIT 技术提升JS 的执行速度。并且成功地使性能提升了数十倍。
35 |
36 |
37 |
38 |
39 |
40 | ### WebAssembly
41 |
42 | WebAssembly 是一份`字节码标准`，以字节码的形式依赖虚拟机在浏览器中运行。
43 |
44 | 注意：`它并不是汇编`，只是看起来像汇编而已。
45 |
46 |
47 |
48 | 可以依赖 Emscripten 等编译器将 C++/Golang/Rust/Kotlin 等`强类型`语言编译成 WebAssembly 字节码（`.wasm` 文件）。
49 |
50 | （JS 不能直接编译成.wasm，因为它是弱类型）
51 |
52 |
53 |
54 |
55 |
56 |
57 |
58 | ### 优质资料
59 |
60 | 腾讯：
61 |
62 | [WebAssembly 不完全指北](https://juejin.im/post/5d367656f265da1b904c2126)
63 |
64 | https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/A_re-introduction_to_JavaScript
--------------------------------------------------------------------------------
/android/annotation-processor.md:
--------------------------------------------------------------------------------
1 | # Android Processor
2 |
3 | > 迁移语雀 2021-2-22
4 |
5 |
6 |
7 | ### 经验
8 |
9 | ### 配置参数
10 |
11 | 我们可以通过配置 options 来给 processor 传递参数，达到配置 Processor 的目的。
12 |
13 | 在引用了 processor 的项目里配置 javaCompileOptions DSL。
14 |
15 | 例如：
16 | ```grovvy
17 | android {
18 | compileSdkVersion 28
19 | defaultConfig {
20 | ...
21 | javaCompileOptions{
22 | annotationProcessorOptions{
23 | //填写键值对，多个用逗号隔开
24 | arguments = [autoRegister:'true']
25 | }
26 | }
27 | }
28 | buildTypes {
29 | release {
30 | minifyEnabled false
31 | proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
32 | }
33 | }
34 | }
35 | ```
36 |
37 | 在 init 方法里接受参数：
38 | ```java
39 | Map
6 | * todo
7 | */
8 | public class MyLinkedStack {
9 |
10 | private Node top;
11 |
12 | public boolean push(String value) {
13 | Node item = new Node(value);
14 |
15 | if (top == null) {
16 | top = item;
17 | }else{
18 | item.next=top;
19 | top = item;
20 | }
21 |
22 | return true;
23 | }
24 |
25 | public String pop() {
26 |
27 | if (top == null) {
28 | return null;
29 | }
30 |
31 | String value = top.value;
32 |
33 | if (top.next != null) {
34 | top = top.next;
35 | }else{
36 | top = null;
37 | }
38 |
39 | return value;
40 | }
41 |
42 |
43 | public static void main(String[] args) {
44 |
45 | MyLinkedStack myArrayStack = new MyLinkedStack();
46 |
47 | for (int i = 0; i < 6; i++) {
48 | System.out.println(myArrayStack.push("" + i));
49 | }
50 |
51 | for (int i = 0; i < 7; i++) {
52 | System.out.println(myArrayStack.pop());
53 | }
54 | }
55 | }
56 |
--------------------------------------------------------------------------------
/java/countdownlatch.md:
--------------------------------------------------------------------------------
1 | # CountDownLatch
2 |
3 |
4 |
5 | ### 示例
6 |
7 | ```java
8 | private static void countdownLatchTest() {
9 |
10 | final CountDownLatch latch = new CountDownLatch(2);
11 |
12 | Thread a = new Thread(new Runnable() {
13 | @Override
14 | public void run() {
15 |
16 | try {
17 | Thread.sleep(1000);
18 | } catch (InterruptedException e) {
19 | e.printStackTrace();
20 | }
21 | System.out.println("thread a done");
22 | latch.countDown();
23 | }
24 | });
25 |
26 | Thread b = new Thread(new Runnable() {
27 | @Override
28 | public void run() {
29 | System.out.println("thread a done");
30 | latch.countDown();
31 | }
32 | });
33 |
34 | a.start();
35 | b.start();
36 |
37 | try {
38 | latch.await();
39 | } catch (InterruptedException e) {
40 | e.printStackTrace();
41 | }
42 |
43 | System.out.println("All threads are done~");
44 | }
45 | ```
46 | 输出：
47 | ```
48 | thread a done
49 | thread b done
50 | All threads are done~
51 | ```
52 |
53 |
--------------------------------------------------------------------------------
/flutter/README.md:
--------------------------------------------------------------------------------
1 | # Flutter
2 |
3 |
4 |
5 | State*less* widgets 是不可变的，这意味着它们的属性不能改变 —— 所有的值都是 final。
6 |
7 | State*ful* widgets 持有的状态可能在 widget 生命周期中发生变化，实现一个 stateful widget 至少需要两个类： 1）一个 StatefulWidget 类；2）一个 State 类，StatefulWidget 类本身是不变的，但是 State 类在 widget 生命周期中始终存在。
8 |
9 |
10 |
11 | 语法跟 Java 也类似，有泛型，继承用 extends
12 |
13 |
14 |
15 | ```dart
16 | class FooWidget extends StatefulWidget {
17 | @override
18 | FooWidgetState createState() => FooWidgetState();
19 | }
20 |
21 | class FooWidgetState extends State
6 | * 用数组实现栈
7 | */
8 | public class MyArrayStack {
9 |
10 | private String[] items;
11 | private int n;//栈的大小
12 | private int count;//栈内元素的个数
13 |
14 | public MyArrayStack(int n) {
15 | this.items = new String[n];
16 | this.n = n;
17 | }
18 |
19 | public boolean push(String value) {
20 | //栈满了
21 | if (count == n) {
22 | return false;
23 | }
24 |
25 | items[count] = value;
26 | count++;
27 | return true;
28 | }
29 |
30 | public String pop() {
31 | //栈空了
32 | if (count == 0) {
33 | return null;
34 | }
35 |
36 | String value = items[count - 1];
37 | count--;
38 | return value;
39 | }
40 |
41 | @Override
42 | public String toString() {
43 | StringBuilder sb = new StringBuilder();
44 | for (int i = 0; i < count; i++) {
45 | sb.append("," + i);
46 | }
47 | return sb.length() > 0 ? sb.substring(1) : "";
48 | }
49 |
50 | public static void main(String[] args) {
51 |
52 | MyArrayStack myArrayStack = new MyArrayStack(5);
53 |
54 | for (int i = 0; i < 6; i++) {
55 | System.out.println(myArrayStack.push("" + i));
56 | }
57 |
58 | System.out.println(myArrayStack);
59 |
60 | for (int i = 0; i < 7; i++) {
61 | System.out.println(myArrayStack.pop());
62 | }
63 | System.out.println(myArrayStack);
64 | }
65 | }
66 |
--------------------------------------------------------------------------------
/books/HeadFirstDesignPatterns/Proxy.md:
--------------------------------------------------------------------------------
1 | # 代理模式
2 |
3 | > 这一章节的内容较多，笔记比较乱，还是看书好些。
4 |
5 | 代理模式： **为另一个对象提供一个替身或占位符以控制对这个对象的访问。**
6 |
7 | 所谓代理（proxy），就是代表某个真实的对象。
8 |
9 | 代理要做的就是：**控制和管理访问(控制对象访问)**
10 |
11 | why? 是因为Client不知道如何和远程对象沟通。从某方面来看，远程代理控制访问，可以帮忙处理一些细节（比如网络，IPC）。
12 |
13 | 
14 | （Subject可以是接口）
15 |
16 |
17 | 代理最主要的方法：
18 |
19 | **远程代理**（remote proxy），好比『远程对象的本地代表』;远程代理是 **一种对象，活在不同的Java虚拟机(JVM)堆中**（更一般的说法为，在不同 **地址空间运行的远程对象**）
20 |
21 | PS：在Android中的代理，如 Binder，处理不同进程间IPC，就是在不同的地址。
22 |
23 | 变体代理方法：
24 |
25 | 1. 远程代理 控制访问远程对象。
26 | 2. 虚拟代理控制访问创建开销大的资源（在必要的时候才创建对象，对象创建完了才委托给对象）
27 | 3. 保护代理基于权限控制对资源的访问。
28 |
29 | 本地代表，是一种可以由本地方法调用的对象，其行为会转发到远程对象中。
30 |
31 | 工作原理示意图：
32 |
33 | 
34 |
35 | 书中提到了 `RMI` 技术，它将 客户辅助对象称为`stub`（桩）,服务器辅助对象称为`skeleton`（g骨架）。
36 |
37 | BONUS：
38 |
39 | - 原语类型（primitive-原来常说的基本类型），传输过程允许的对象类型要注意，自己定义的类的对象需要实现Serializable（Java）
40 | - 当不需要传输的时候，用`transient`来修饰变量。
41 |
42 | 例子让我想起来Android中的 `AIDL`和`Binder`，忽然间懂了好多。
43 |
44 | ## 保护代理
45 |
46 | 可以在运行时动态地创建一个代理类，实现一个或多个接口，并将方法的调用转发到你所指定的类。因为实际的代理类是在运行时创建的，我们称这个Java技术为：**动态代理**。大名鼎鼎的 `retrofit` 用的就是动态代理。
47 |
48 |
49 | 动态代理的UML：
50 |
51 |
52 | 
53 |
54 | ## 要点
55 |
56 | 1. 代理模式为另一个对象提供代表，以便控制客户对对象的访问，管理访问的方式有许多种。
57 | 2. 远程代理管理客户和远程对象之间的交互。
58 | 3. 虚拟代理控制访问实例化对对象方法的访问。
59 | 4. 代理模式有许多变体，例如：缓存代理、同步代理、防火墙代理和写入时复制代理。
60 | 5. 代理在结构上类似装饰者，但是目的不同。
61 | 6. 装饰者模式为对象加上行为，而代理则是控制访问。
62 | 7. Java内置的代理支持，可以根据需要建立动态代理，并将所有调用分配到所选的处理器。
63 | 8. 就和其他的包装者（wrapper)一样，代理会造成你的设计中类的数目增加。
64 |
--------------------------------------------------------------------------------
/ds-algorithm-proj/src/me/yifeiyuan/dsalgorithm/self/MyLinkedQueue.java:
--------------------------------------------------------------------------------
1 | package me.yifeiyuan.dsalgorithm.self;
2 |
3 | /**
4 | * Created by 程序亦非猿 on 2020/4/16.
5 | *
6 | * todo
7 | */
8 | public class MyLinkedQueue {
9 |
10 |
11 | private Node head;
12 | private Node tail;
13 |
14 | private int size;
15 |
16 | public MyLinkedQueue() {
17 | }
18 |
19 | //入队
20 | public boolean enqueue(String value) {
21 |
22 | Node item = new Node(value);
23 |
24 | //空
25 | if (size == 0) {
26 | head = item;
27 | } else {
28 | tail.next = item;
29 | }
30 | tail = item;
31 | size++;
32 |
33 | return true;
34 | }
35 |
36 | //出队
37 | public String dequeue() {
38 |
39 | //空队列
40 | if (size == 0) {
41 | return null;
42 | }
43 |
44 | String value = head.value;
45 | //head 指向 next
46 | head = head.next;
47 |
48 | size--;
49 |
50 | return value;
51 | }
52 |
53 | public static void main(String[] args) {
54 |
55 | MyLinkedQueue queue = new MyLinkedQueue();
56 |
57 | System.out.println(queue.dequeue());//null
58 |
59 | for (int i = 0; i < 6; i++) {
60 | System.out.println(queue.enqueue("" + i)); //6 true
61 | }
62 |
63 | for (int i = 0; i < 6; i++) {
64 | System.out.println(queue.dequeue());//0,1,2,3,5
65 | }
66 |
67 |
68 | for (int i = 0; i < 6; i++) {
69 | System.out.println(queue.enqueue("" + i)); //6 true
70 | }
71 |
72 | for (int i = 0; i < 6; i++) {
73 | System.out.println(queue.dequeue());//0,1,2,3,4,5
74 | }
75 |
76 | }
77 | }
78 |
--------------------------------------------------------------------------------
/books/图解Http/第2章-简单的HTTP协议.md:
--------------------------------------------------------------------------------
1 | # 第2章-简单的HTTP协议
2 |
3 | 对 HTTP 协议结构进行讲解。
4 |
5 |
6 | *
7 | * 目前的实现会让费一个位置。
8 | */
9 | public class MyArrayCircularQueue {
10 |
11 |
12 | private String[] items;
13 |
14 | private int size;
15 |
16 | private int head;
17 | private int tail;
18 |
19 | public MyArrayCircularQueue(int capacity) {
20 | this.size = capacity;
21 | items = new String[capacity];
22 | }
23 |
24 | public boolean enqueue(String value) {
25 |
26 | //队列满了
27 | if ((tail + 1) % size == head) {
28 | return false;
29 | }
30 |
31 | items[tail] = value;
32 |
33 | tail = (tail + 1) % size;
34 |
35 | return true;
36 | }
37 |
38 | public String dequeue() {
39 |
40 | if (tail==head){
41 | return null;
42 | }
43 |
44 | String value = items[head];
45 | head = (head+1)%size;
46 | return value;
47 | }
48 |
49 |
50 | public static void main(String[] args) {
51 |
52 | MyArrayCircularQueue queue = new MyArrayCircularQueue(5);
53 |
54 | System.out.println(queue.dequeue());//null
55 |
56 | for (int i = 0; i < 6; i++) {
57 | System.out.println(queue.enqueue("" + i)); //4 true 2 false
58 | }
59 |
60 | for (int i = 0; i < 6; i++) {
61 | System.out.println(queue.dequeue());//0,1,2,3,null,null
62 | }
63 |
64 |
65 | for (int i = 0; i < 6; i++) {
66 | System.out.println(queue.enqueue("" + i)); //4 true 2 false
67 | }
68 |
69 | for (int i = 0; i < 6; i++) {
70 | System.out.println(queue.dequeue());//0,1,2,3,null,null
71 | }
72 | }
73 | }
74 |
75 |
--------------------------------------------------------------------------------
/android/fragment.md:
--------------------------------------------------------------------------------
1 | # Fragment
2 |
3 | > 迁移语雀 2021-2-22
4 |
5 |
6 | ### 概述
7 |
8 |
9 |
10 | Android 在 Android 3.0（API 级别 11）中引入了 Fragment，主要是为了给大屏幕（如平板电脑）上更加动态和灵活的 UI 设计提供支持。由于平板电脑的屏幕比手机屏幕大得多，因此可用于组合和交换 UI 组件的空间更大。利用片段实现此类设计时，您无需管理对视图层次结构的复杂更改。 通过将 Activity 布局分成片段，您可以在运行时修改 Activity 的外观，并在由 Activity 管理的返回栈中保留这些更改。
11 |
12 |
13 |
14 | #### 静态添加
15 |
16 |
17 |
18 | 静态添加：在 layout 文件中添加 fragment ，在运行中不能修改。
19 |
20 |
21 |
22 | 例子：
23 |
24 | ```xml
25 | `,` 这里是文本 `,返回一个对象数组
83 | - getElementByClassName 通过 class 属性来获取，返回一个对象数组；可以指定多个类名
84 |
85 | ## 获取和设置属性
86 |
87 | getAttribute setAttribute
88 |
89 | setAttribute 做出的修改不会反映在文档本身的源代码里。
90 |
91 | DOM的工作模式：先加载文档的静态内容，再动态刷新，动态刷新不影响文档的静态内容。这正是 DOM 的真正威力：对页面内容进行刷新却不需要在浏览器里刷新页面。
92 |
93 | ## 小结
94 |
95 | JS 与 Android 相同，同为一门前端语言，其实有很多类似的设计，可以类比来学习理解。
96 |
97 | 感觉可以把 html中的 body 部分理解为 Android 中的 XML，用来描述网页的布局，标签元素可以理解为 Android 中的 View，CSS 可以理解为 style，这样更容易去理解，虽然可能不是很准确。
98 |
99 |
100 |
101 |
102 |
103 |
104 |
105 |
106 |
--------------------------------------------------------------------------------
/android/progressbar.md:
--------------------------------------------------------------------------------
1 | # ProgressBar
2 |
3 | > 迁移语雀 2021-2-22
4 |
5 |
6 |
7 |
8 | ### 常用属性
9 |
10 |
11 |
12 | - `style="@style/Widget.MaterialProgressBar.ProgressBar.Horizontal"`，设置水平还是转圈等；
13 | - `android:progressDrawable="@drawable/xxx"`，设置进度条的样式；
14 | - `android:progress="20"`，设置进度；
15 | - `android:secondaryProgress=""`，设置次级进度；
16 |
17 |
18 |
19 | ### 自定义 ProgressBar 展示的样式
20 |
21 |
22 |
23 | 1. 新建 `layer-list` 类型的 drawable；
24 | 2. 按需添加 `item`：
25 | 1. `android:id="@android:id/background"` , 背景
26 | 2. `android:id="@android:id/secondaryProgress"`，
27 | 3. `android:id="@android:id/progress"`
28 | 3. 给 progressbar 设置`android:progressDrawable`属性，如 `"@drawable/custom_progress"`;
29 |
30 |
31 |
32 | ```xml
33 |
34 | Most {@code ArrayDeque} operations run in amortized constant time.
14 | * Exceptions include {@link #remove(Object) remove}, {@link
15 | * #removeFirstOccurrence removeFirstOccurrence}, {@link #removeLastOccurrence
16 | * removeLastOccurrence}, {@link #contains contains}, {@link #iterator
17 | * iterator.remove()}, and the bulk operations, all of which run in linear
18 | * time.
19 | *
20 | * The iterators returned by this class's {@code iterator} method are
21 | * fail-fast: If the deque is modified at any time after the iterator
22 | * is created, in any way except through the iterator's own {@code remove}
23 | * method, the iterator will generally throw a {@link
24 | * ConcurrentModificationException}. Thus, in the face of concurrent
25 | * modification, the iterator fails quickly and cleanly, rather than risking
26 | * arbitrary, non-deterministic behavior at an undetermined time in the
27 | * future.
28 | *
29 | * Note that the fail-fast behavior of an iterator cannot be guaranteed
30 | * as it is, generally speaking, impossible to make any hard guarantees in the
31 | * presence of unsynchronized concurrent modification. Fail-fast iterators
32 | * throw {@code ConcurrentModificationException} on a best-effort basis.
33 | * Therefore, it would be wrong to write a program that depended on this
34 | * exception for its correctness: the fail-fast behavior of iterators
35 | * should be used only to detect bugs.
36 | *
37 | * This class and its iterator implement all of the
38 | * optional methods of the {@link Collection} and {@link
39 | * Iterator} interfaces.
40 | *
41 | * This class is a member of the
42 | *
43 | * Java Collections Framework.
44 | *
45 | * @author Josh Bloch and Doug Lea
46 | * @since 1.6
47 | * @param 
6 |
7 |
8 | ## 客户端和服务端的通信
9 |
10 | 请求访问文本或图像等资源的一端称为**客户端**，而提供资源响应的一端称为**服务端**。
11 |
12 | **请求报文**由 请求方法、请求 URI、协议版本、可选的请求首部字段(headers)和内容实体(body)构成的。
13 |
14 | 图：
15 |
16 | 
17 |
18 |
19 | **响应报文**基本上由 协议版本、状态吗、用以解释状态码的原因短语、可选的响应首部字段以及实体主体构成。
20 |
21 | 图：
22 |
23 | 
24 |
25 |
26 | ## HTTP 是不保存状态的协议
27 |
28 | 无状态 ，不保存之前发送过的请求或响应的功能。
29 |
30 | 更快处理大量事务，确保协议的可伸缩性，简单。
31 |
32 | 可以减少服务器的 CPU以及内存消耗。
33 |
34 |
35 | ## 告知服务器意图的 HTTP方法
36 |
37 | | 方法名 | 作用 |
38 | | :-----: | :---------: |
39 | | GET | 获取资源 |
40 | | POST | 传输实体主体 |
41 | | PUT | 传输文件 |
42 | | HEAD | 获得报文首部 |
43 | | DELETE | 删除文件 |
44 | | OPTIONS | 询问支持的方法 |
45 | | TRACE | 追踪路径 |
46 | | CONNECT | 要求用隧道协议连接代理(SSL+TLS) |
47 |
48 | POST 与 GET(也能传输实体的主体) 相似，但POST 的主要目的并不是获取响应的主体内容。
49 |
50 | 很多方法都不怎么用了，PUT DELETE 由于安全原因也不常用了，TRACE 由于容易引发 XST 攻击，就更不会用到了。
51 |
52 | 现在常用的，还是 GET与POST。
53 |
54 | ## 持久连接节省通信
55 |
56 | 由于 HTTP 最开始每次通信都需要重新链接/断开TCP，效率低，通信开销大，速度低。
57 |
58 | #### 持久连接 keep-alive
59 |
60 | 持久链接的特点是：只要任意一端没有明确提出断开连接，则保持 TCP 连接状态。
61 |
62 | 好处：减少了 TCP 连接/断开的开销，减轻服务器负载，提升速度。
63 |
64 |
65 | #### 管线化 pipelining
66 |
67 | 以前发送请求后需要等待并收到响应，才能发送下一个请求。
68 |
69 | 管线化技术可以使得**不需等待就能发送下一个请求**，这样就能做到**并发发送多个请求**了。
70 |
71 | NOTE:**管线化比持久连接还要快**！
72 |
73 |
74 | ## 使用 Cookie 的状态管理
75 |
76 | HTTP 本身是无状态的，但是遇到一些功能，比如登录，那么保存登录状态就不需要每次都重新登录，就显得格外重要。
77 |
78 | 所以引入了 Cookie 技术。
79 |
80 | 服务端发送响应，带`Set-Cookie`的首部字段信息，客户端再次发送请求的时候在首部字段`Cookie`写入，传递给服务端。
--------------------------------------------------------------------------------
/ds/adt.md:
--------------------------------------------------------------------------------
1 | # 抽象数据类型 ADT
2 |
3 | [TOC]
4 |
5 | ### 什么是抽象数据类型？
6 |
7 |
8 |
9 | 抽象数据类型（Abstract Data Type，ADT）是计算机科学中`具有类似行为的特定类别的数据结构的数据模型`；或者具有类似语义的一种或多种程序设计语言的数据类型。抽象数据类型是间接定义的，通过其上的`可执行的操作`以及`这些操作的效果`的数学约束（与可能的代价）。
10 |
11 |
12 |
13 | 例如，抽象的[堆栈](https://zh.wikipedia.org/wiki/堆疊)（stack）由3个操作定义：推入`push`，弹出`pop`（接受约束：每次弹出返回的是最新被推入且没有被弹出的数据，也就是后进先出），查看堆栈顶端数据`peek`。当分析使用堆栈算法的效率，所有这3个操作用时相同，无论堆栈中包含多少项数据；并且对每项数据栈使用了常量大小的存储。
14 |
15 |
16 |
17 | 抽象数据类型（ADT）是`纯粹理论实体`，`用于简化描述抽象算法`，`分类与评价数据结构`，`形式描述程序设计语言`的`类型系统`。
18 |
19 |
20 |
21 | 一个 ADT 可以用特定数据类型或数据结构实现，在许多程序设计语言中有许多种实现方式；或者用形式规范语言描述。ADT常实现为模块（module）：模块的接口声明了对应于ADT操作的例程（procedure），有时用注释描述了约束。
22 |
23 |
24 |
25 | ### 常见的抽象数据类型
26 |
27 |
28 |
29 | - 关联数组
30 | - 复数
31 | - 容器
32 | - 双端队列
33 | - 列表
34 | - Multimap
35 | - 优先队列
36 | - 队列
37 | - 集合
38 | - 堆栈
39 | - 字符串
40 | - 树
41 |
42 |
43 |
44 | ### 接口和实现的分离
45 |
46 |
47 |
48 | 实现于程序时，`抽象数据类型只显现出其接口`，并`将实现加以隐藏`。用户只需关心它的接口，而不是如何实现。未来更可以改变实现的方式。
49 |
50 |
51 |
52 | **抽象数据类型的强处在于对用户隐藏了实现细节，仅公开其接口。这表示抽象数据类型可以用各种方法来实现，只要遵循其接口，就不会影响到用户**。
53 |
54 |
55 |
56 | 在抽象数据类型和数据结构之间，有一个实现上的`微妙差别`。例如，列表的抽象数据类型可以数组为基础、或者使用链表来实现。列表即是一种具良好运算（加入元素、移除元素等等）定义的抽象数据类型。链表是以指针为基础的数据结构，且可用来创建一个列表。链表常用于列表的抽象数据类型。
57 |
58 |
59 |
60 | 同样地，二叉树搜索法的抽象数据结构可以几个方式实现：二叉树、AVL树、红黑树、数组等等。且无须关心其实现，二叉树搜索法总是有相同的运算（插入、移除、查找等等）。
61 |
62 |
63 |
64 | 在面向对象的用语中，抽象数据类型相当于类别；抽象数据类型的实体就相当于对象。某些语言包含了用于宣告抽象数据类型的构造函数。例如，C++ 和 Java 为此提供了类的构造函数。
65 |
66 |
67 |
68 | ### 总结
69 |
70 |
71 |
72 | ADT 不是 数据结构，它们是有差异的。ADT 是更加抽象的一层，一种模型的定义，而各种数据结构基于它来实现。按 Java 是思路来理解，ADT 就是各种定义了操作的接口类，被各种数据结构具体类实现，从而只暴露了公开的接口，隐藏了实现细节。例如，一个具体的数据结构它可以是用数组来实现，也可以用链表来实现，但是它们的抽象数据类型是一样的。
73 |
74 | List(l列表) -> LinkedList （基于链表）, ArrayList（基于数组）
75 |
76 | ### 资料
77 |
78 | https://zh.wikipedia.org/wiki/%E6%8A%BD%E8%B1%A1%E8%B3%87%E6%96%99%E5%9E%8B%E5%88%A5
79 |
80 |
--------------------------------------------------------------------------------
/android/popupmenu.md:
--------------------------------------------------------------------------------
1 | # PopupMenu
2 |
3 | > 迁移语雀 2021-2-22
4 |
5 | > A PopupMenu displays a `Menu` in a modal popup window anchored to a `View`. The popup will appear below the anchor view if there is room, or above it if there is not. If the IME is visible the popup will not overlap it until it is touched. Touching outside of the popup will dismiss it.
6 |
7 |
8 |
9 | PopupMenu 可以以某个 View 为锚点，展示一个菜单栏。
10 |
11 |
12 |
13 | 会根据锚点、Gravity 以及空间展示，并且点击外部会消失。
14 |
15 |
16 |
17 | ### 基础使用教程
18 |
19 |
20 |
21 | 使用步骤：
22 |
23 | 1. `res`目录下 新建 menu 目录
24 | 2. `menu`目录下新建 foo.xml
25 | 3. 构建 PopupMenu，加载菜单
26 | 4. 设置监听
27 | 5. show() 展示
28 |
29 |
30 |
31 | ```xml
32 |
33 | java.util.concurrent package such as {@link Executor},
15 | > {@link ThreadPoolExecutor} and {@link FutureTask}.
16 |
17 |
18 |
19 | AsyncTask ，抽象类， 被设计用于那些 **短时间（几秒）的异步操作拿到结果后需要反馈给UI 线程**的场景。
20 |
21 |
22 |
23 | 如果需要长时间的跑线程的话就不合适。
24 |
25 |
26 |
27 | ### AsyncTask 的常用方法
28 |
29 |
30 |
31 | - `doInBackground(Params)`，异步执行任务时调用，并且接受参数，与Thread的run方法类似，**与其他方法不同的是, 这个方法必须要重写**（抽象方法）；
32 | - `onPreExecute` ，在任务开始之前调用,通常可以用来做初始化参数,或者判断网络是否连接；
33 | - `onProgressUpdate`， 在doInBackground中调用publishProgress()触发；
34 | - `onPostExecute` ，doInBackground方法执行完成之后会调用，并接受Result；
35 | - `onCancelled(Result)` ，任务被取消时候调用
36 | - `onCancelled()`， 同上
37 |
38 |
39 |
40 | 一般情况下 AsyncTask 方法的执行顺序是：
41 |
42 | onPreExecute —> doInBackground —> onProgressUpdate —> onPostExecute
43 |
44 | 它们也被称为是 **四大步骤**。
45 |
46 |
47 |
48 | ### 知识点汇总
49 |
50 |
51 |
52 | 1. AsyncTask 只能在主线程创建，因为它内部需要一个运行在主线程的 Handler，这需要主线程的 Looper;
53 | 2. AsyncTask 只能在主线程执行，并且不能被执行两次；
54 | 3. AsyncTask 中只有 `doingBackground`方法是在异步线程执行，其他的都是在主线程；
55 | 4. `AsyncTask.cancel(mayInterruptIfRunning)` 方法调用后并不能直接立即取消，而只是设置了个标记位而已，需要自己配合`isCancelled()`方法使用；
56 | 5. 取消后的 AsyncTask 会回调 `onCancelled(Object)`而不是 `onPostExecute(Object)`；
57 | 6. `推荐配合线程池使用`，因为*某些版本的 AsyncTask 任务是串行的*，一个一个按排序执行，并不支持并发；
58 | 7. AsyncTask 需要是静态内部类型，因为有内存泄露的风险，不要保存 context；
--------------------------------------------------------------------------------
/android/google-io-2019.md:
--------------------------------------------------------------------------------
1 | # Google IO 2019
2 |
3 | > 迁移语雀 2021-2-22
4 |
5 | [TOC]
6 |
7 | ### ViewBinding
8 |
9 | 
10 |
11 |
12 |
13 | AS 3.6 会上。
14 |
15 |
16 |
17 | ### Lifecycles
18 |
19 | A way to observe lifecycle events of Fragments and Activities.
20 |
21 | ViewModel- state retained across config changes.
22 |
23 | LiveData - lifecycle-aware observable
24 |
25 |
26 |
27 |
28 |
29 | #### **ViewModel & Saved State**
30 |
31 |
32 |
33 | **Saved State**
34 |
35 | 
36 |
37 |
38 |
39 | **ViewModel**
40 |
41 | 
42 |
43 |
44 |
45 | 两者对比
46 |
47 | 
48 |
49 |
50 |
51 |
52 |
53 | ViewModel 跟 SavedState 并不是对立的，两者作用不一样。
54 |
55 |
56 |
57 |
58 |
59 | ### WorkManager
60 |
61 | WorkManager is a background processing library for work that is specifically deferrable,meaning that it doesn't have to be executed right away.
62 |
63 |
64 |
65 | - deferrable
66 | - persistent
67 | - constraint-based
68 | - Backwards compatible
69 |
70 |
71 |
72 | ### Room
73 |
74 | Room is SQLite object mapping library.
75 |
76 |
77 |
78 | 协程支持
79 |
80 |
81 |
82 | ### Paging
83 |
84 |
85 |
86 | Paging is a library to load large lists into RecyclerView lazily.
87 |
88 |
89 |
90 | Error handling...
91 |
92 |
93 |
94 | ### Navigation
95 |
96 | A library to manager in app UI flows.
97 |
98 |
99 |
100 |
101 |
102 | Arch Components
103 |
104 | ### Ref
105 |
106 | [What's New in Architecture Components (Google I/O'19)](https://www.youtube.com/watch?v=Qxj2eBmXLHg&feature=youtu.be)
107 |
108 |
109 |
110 |
--------------------------------------------------------------------------------
/books/HeadFirstDesignPatterns/FactoryMethod.md:
--------------------------------------------------------------------------------
1 | # 工厂模式
2 |
3 | 工厂模式分两种模式：
4 |
5 | 1. 工厂方法
6 | 2. 抽象工厂
7 |
8 |
9 | ## 简单工厂
10 |
11 | 使用`new Xxx()`创建对象非常脆弱，缺乏弹性，耦合度高。
12 |
13 | 
14 |
15 | 当具体类需要新增或删除的时候，就必须修改这段代码，非常容易出错，难以维护和更新。
16 |
17 | 所以需要把创建对象的方法封装起来，用“工厂”来负责创建对象。
18 |
19 | 定义Factory：
20 | 
21 |
22 | 使用：
23 |
24 | 
25 |
26 |
27 | 看起来可能只是把代码挪到了另外一个地方，但是其实有不少好处。
28 |
29 | ### 好处
30 | 1. 避免代码重复，可复用，也可服务多个对象
31 | 2. 降低耦合度，增加弹性
32 | 3. 便于维护
33 |
34 | NOTE：它跟静态方法的差别是，静态方法不需要实例化，并且它不能通过继承来改变创建方法的行为。
35 |
36 | oh，另外，其实简单工厂并不是设计模式。
37 |
38 | ## 工厂方法
39 |
40 | 工厂方法模式(FactoryMethod)定义了**一个创建对象的接口，但由子类决定要实例化的类是哪一个。工厂方法让类把实例化推迟到子类。**
41 |
42 | 工厂方法通过**让子类决定该创建的对象是什么，来达到将对象创建的过程封装的目的
43 | **，所以工厂方法是 **继承，覆盖方法来实现**
44 |
45 | 通常工厂方法模板是这样的：
46 |
47 | ```
48 | // 返回对象和入参根据实际情况定
49 | abstract Product factoryMethod（String type）;
50 | ```
51 |
52 |
53 | 
54 |
55 | `createPizza`应该是受保护权限
56 |
57 | 在父类`PizzaStore`中定义`createPizza`抽象方法，让子类去实现。
58 |
59 | NOTE：也可以不是抽象方法，提供默认的实现。
60 |
61 | ### 好处
62 | 1. 将‘实例化’从‘使用’中解耦
63 | 2. 易扩展 易维护
64 | 3. 更具弹性
65 |
66 |
67 |
68 | ## 抽象工厂
69 |
70 | 抽象工厂模式：**提供一个接口，用于创建相关或依赖对象的家族，而不需要明确指定具体类。**
71 |
72 |
73 | 抽象工厂允许**客户使用抽象的接口来创建一组相关的产品，而不需要知道（或关心）实际产出的具体产品是什么**。这样一来客户就从具体的产品中被解耦。
74 |
75 | 抽象工厂跟工厂方法非常相似，但抽象工厂强调的是**一组产品**，是对组的抽象，需要一个大的接口；工厂方法使用的是类与继承而抽象工厂使用的是**组合**；
76 |
77 | ## 要点
78 |
79 | 1. 所有的工厂都是用来封装对象的创建。
80 | 2. 工厂方法使用继承：把对象的创建委托给子类，将实例化延迟到子类。
81 | 3. 抽象工厂使用对象组合：对象的创建被实现在工厂接口所暴露出来的方法中。
82 | 4. 所有工厂模式都通过减少应用程序和具体类之间的依赖促进松耦合。
83 | 5. 抽象工厂创建相关的对象家族，而不需要依赖它们的具体类。
84 |
85 | ## See also
86 |
87 | [Factory method pattern
88 | ](https://en.wikipedia.org/wiki/Factory_method_pattern)
89 |
90 | [Factory Design Pattern Example
91 | ](http://javadesign-patterns.blogspot.com/p/factory-desig.html)
92 |
--------------------------------------------------------------------------------
/books/JavaScriptDom编程艺术/第3章-DOM.md:
--------------------------------------------------------------------------------
1 | # 第3章-DOM
2 |
3 |
4 | ## 文档：DOM 中的 D
5 | D 文档 document ，当创建了一个网页并把它加载到 Web 浏览器中时，DOM 就在幕后生成，它把你编写的网页文档转换为一个文档对象。（加载到内存？）
6 |
7 | ## 对象：DOM 中的 O
8 |
9 | - 用户定义对象
10 | - 内建对象
11 | - 宿主对象
12 |
13 | 最基础的宿主对象： window对象，对应浏览器窗口本身。（类似 Android 的 PhoneWindow？）
14 |
15 | window 对象的属性和方法通常称为 BOM（浏览器对象模型）。
16 |
17 | BOM 提供了如 window.open window.blur 等方法。
18 |
19 | 更重要的是 document 对象。
20 |
21 |
22 | ## 模型：DOM 中的 M
23 |
24 | 模型：某种事物的表现形式。 比如模型火车就代表一列真正的火车。
25 |
26 | DOM 把一份文档表示为一棵树（数学意义上的树，类似二叉树）
27 |
28 | 家谱书模型 非常适合用来表示一份用(X)HTML 语言编写出来的文档。（parent child sibling）
29 |
30 | 节点树。
31 |
32 | ## 节点node
33 |
34 | 节点相当于现实世界组成万物的『原子』。
35 |
36 | 文档是『由节点构成的集合』。
37 |
38 | 节点的类型：元素节点、文本节点和属性节点。
39 |
40 | #### 元素节点（element node）
41 |
42 | 元素节点，DOM 的原子是元素节点。 如 `
68 |
69 |
70 |
71 | 
72 |
73 |
74 |
75 |
76 |
77 | Feature modularization brings you encapsulation and possibility of on-demand delivery.
78 |
79 | Modularization by layer brings you isolation,allows you to isolate your third-party dependencies or the layers in your app,and also brings structure to our app.
80 |
81 |
82 |
83 | 按层分的模块化更加简单，适合小的 App，按功能划分的更加复杂，很适合庞大的 App。
84 |
85 | 其实两者也可以结合，当 App 还小，layer modularization 可以用用，App 大了，再换成 feature modularization 更加合适。
86 |
87 |
88 |
89 |
90 |
91 | 
92 |
93 |
94 |
95 |
96 |
97 | you should always compare your short-term costs with your long-term benefits and make a proper decision.
98 |
99 |
100 |
101 | ### 资料
102 |
103 | [Build a Modular Android App Architecture (Google I/O'19)](https://www.youtube.com/watch?v=PZBg5DIzNww&feature=youtu.be)
104 |
105 |
106 |
107 | #
--------------------------------------------------------------------------------
/books/图解Http/第4章-返回结果的HTTP状态码.md:
--------------------------------------------------------------------------------
1 | # 第4章-返回结果的HTTP状态码
2 |
3 | HTTP状态码负责表示客户端 HTTP 请求的返回结果，标记服务端的处理是否正常、通知出现的错误等工作。
4 |
5 | 
6 |
7 |
8 | 状态码以**3为数字和原因短语组成**，如 `200 OK`。
9 |
10 | 状态码的类别：
11 |
12 | | | 类别 | 原因短语 |
13 | | ---- | ---------------------- | ------------- |
14 | | 1XX | Informational(信息性状态码) | 接收的请求正在处理 |
15 | | 2XX | Success(成功状态码) | 请求正常处理完毕 |
16 | | 3XX | Redirection(重定向状态码) | 需要进行附加操作以完成请求 |
17 | | 4XX | Client Error(客户端错误状态码) | 服务器无法处理请求 |
18 | | 5XX | Server Error(服务器错误状态码) | 服务器处理请求出错 |
19 |
20 |
21 | 状态码数量达60余种，但是常用的大概就14种。
22 |
23 | 做客户端的，还是要稍微了解一下的，有个印象。在做一些需求，比如第三方授权时遇到 401等错误也不至于无从下手；遇到500错误也不会傻乎乎的在找自己的代码哪里写错了。
24 |
25 | 这里简单列举了一下(3XX 的太绕，就不多写了)：
26 |
27 | | | 状态码 | 含义 |
28 | | :--------: | :------------------------ | ---------------------------------------- |
29 | | 2XX 成功 | | 请求被正常处理了 |
30 | | | 200 OK | 从客户端发来的请求在服务端被**正常处理**了 |
31 | | | 204 No Content | 服务器接收的请求已处理成功，但在返回的响应报文中**不含实体的主体部分** |
32 | | | 206 Partial Content | 客户端进行了范围请求，服务器成功执行了这部分的 GET 请求(Content-Range) |
33 | | 3XX 重定向 | | |
34 | | | 301 Moved Permanently | 永久性重定向 |
35 | | | 302 Found | 临时性重定向 |
36 | | | 303 See Other | |
37 | | | 304 Not Modified | |
38 | | | 307 Temporary Redirect | 与302的差别是，不会从 POST 变成 GET |
39 | | 4XX 客户端错误 | | 客户端是发生错误的原因所在 |
40 | | | 400 Bad Request | 请求报文中存在语法错误 |
41 | | | 401 Unauthorized | 需要有通过 HTTP 认证的认证信息 |
42 | | | 404 Not Found | 服务器上找不到资源 |
43 | | 5XX 服务器错误 | | 服务器本身发生错误 |
44 | | | 500 Internal Server Error | 服务端在执行请求时发生了错误 |
45 | | | 503 Service Unavailable | 服务端暂时处于超负载或正在进行停机维护，现在无法处理请求。 |
46 |
47 |
--------------------------------------------------------------------------------
/books/HeadFirstDesignPatterns/README.md:
--------------------------------------------------------------------------------
1 | # HeadFirstDesignPatterns
2 |
3 | 深入浅出设计模式，非常优秀的设计模式书籍，入门最佳选择。
4 |
5 | NOTE：不过 **该书并没有讲述所有的设计模式** ，还缺少以下设计模式的仔细讲解(相对其他模式，篇幅小很多)：
6 |
7 | - 桥接模式
8 | - 生成器模式
9 | - 责任链模式
10 | - 蝇量模式
11 | - 解释器模式
12 | - 中介者模式
13 | - 备忘录模式
14 | - 原型模式
15 | - 访问者模式
16 |
17 | 所以如果要完整学习所有的设计模式，那么还需要阅读其他书籍(该书推荐四人帮的书)，不过，尽管如此它依然是一本好书。
18 |
19 |
20 | 设计模式分类（多了就要分类啊）：
21 |
22 | 
23 |
24 | 模式：**是在某情境（context）下，针对某问题的某种解决方案。**
25 |
26 | - 情境：就是应用某个模式的情况。这应该是会不断出现的情况。
27 | - 问题：就是你想在某情境下达到的目标，但也可以是某情境下的约束。
28 | - 解决方案：就是你所追求的：一个通用的设计，用来解决约束，达到目标。
29 |
30 |
31 | 与设计模式对立的叫反模式：
32 |
33 | 反模式告诉你如何采用一个不好的解决方案解决一个问题。
34 |
35 | - 开发反模式
36 | - OO反模式
37 | - 组织反模式
38 | - 领域特定
39 |
40 | 建议：
41 |
42 | 1. 不需要严格遵照设计模式，可以适当调整以符合需求
43 | 2. 保持简单
44 | 3. 设计、重构的时候考虑设计模式
45 | 4. 现在不需要，就别做
46 | 5. 可能一直都不需要设计模式
47 | 6. 过度使用设计模式可能导致代码被过度工程化。应该总是用最简单的解决方案完成工作，并在真正需要模式的地方才使用它。
48 |
49 |
50 | ## 感悟
51 |
52 | 设计模式的强大需要在实践中去体会
53 |
54 |
55 | ## 设计模式推荐资料
56 | [HeadFirst设计模式](https://www.amazon.cn/Head-First%E8%AE%BE%E8%AE%A1%E6%A8%A1%E5%BC%8F-%E5%BC%97%E9%87%8C%E6%9B%BC/dp/B0011FBU34/ref=sr_1_1?ie=UTF8&qid=1469026679&sr=8-1&keywords=%E6%B7%B1%E5%85%A5%E6%B5%85%E5%87%BA%E8%AE%BE%E8%AE%A1%E6%A8%A1%E5%BC%8F)
57 | [设计模式：可复用面向对象软件的基础](https://www.amazon.cn/%E8%AE%A1%E7%AE%97%E6%9C%BA%E7%A7%91%E5%AD%A6%E4%B8%9B%E4%B9%A6-%E8%AE%BE%E8%AE%A1%E6%A8%A1%E5%BC%8F-%E5%8F%AF%E5%A4%8D%E7%94%A8%E9%9D%A2%E5%90%91%E5%AF%B9%E8%B1%A1%E8%BD%AF%E4%BB%B6%E7%9A%84%E5%9F%BA%E7%A1%80-Erich-Gamma/dp/B001130JN8/ref=sr_1_1?ie=UTF8&qid=1469026646&sr=8-1&keywords=%E8%AE%BE%E8%AE%A1%E6%A8%A1%E5%BC%8F+%E5%8F%AF%E5%A4%8D%E7%94%A8%E9%9D%A2%E5%90%91%E5%AF%B9%E8%B1%A1%E8%BD%AF%E4%BB%B6%E7%9A%84%E5%9F%BA%E7%A1%80)
58 | [wiki:Design Patterns](https://en.wikipedia.org/wiki/Design_Patterns)
59 | [Android源码设计模式解析与实战](https://www.amazon.cn/Android%E6%BA%90%E7%A0%81%E8%AE%BE%E8%AE%A1%E6%A8%A1%E5%BC%8F%E8%A7%A3%E6%9E%90%E4%B8%8E%E5%AE%9E%E6%88%98-%E4%BD%95%E7%BA%A2%E8%BE%89/dp/B0176QDPUW/ref=sr_1_1?s=books&ie=UTF8&qid=1469026788&sr=1-1&keywords=android+%E6%BA%90%E7%A0%81%E8%AE%BE%E8%AE%A1%E6%A8%A1%E5%BC%8F%E8%A7%A3%E6%9E%90%E4%B8%8E%E5%AE%9E%E6%88%98)
60 | [EffectiveJava](https://www.amazon.cn/Sun-%E5%85%AC%E5%8F%B8%E6%A0%B8%E5%BF%83%E6%8A%80%E6%9C%AF%E4%B8%9B%E4%B9%A6-Effective-Java%E4%B8%AD%E6%96%87%E7%89%88-Joshua-Bloch/dp/B001PTGR52/ref=pd_sim_14_3?ie=UTF8&dpID=51bFt0sSAKL&dpSrc=sims&preST=_AC_UL160_SR121%2C160_&psc=1&refRID=2ZABEPEFGX2M1YM5HVZN)
61 |
62 |
63 |
64 |
--------------------------------------------------------------------------------
/java/cyclicbarrier.md:
--------------------------------------------------------------------------------
1 | # CyclicBarrier
2 |
3 |
4 | CyclicBarrier 类实现了一个集结点(rendezvous) 称为障栅(barrier)。考虑大量线程运行 在一次计算的不同部分的情形。 当所有部分都准备好时， 需要把结果组合在一起。当一个线 程完成了它的那部分任务后， 我们让它运行到障栅处。一旦所有的线程都到达了这个障栅， 障栅就撤销， 线程就可以继续运行。
5 |
6 | 障栅被称为是循环的(cyclic), 因为可以在所有等待线程被释放后被重用。在这一点上，
7 | 有别于 CountDownLatch, CountDownLatch 只能被使用一次。
8 |
9 | 当线程做完了一部分事情后，调用 barrier.await() 方法进行等待，等到所有的线程都准备完，都调用了 await 后，就可以认为所有的线程都准备好了 ，此时，barrier action 会执行，然后所有的线程也可以开始执行。
10 |
11 |
12 | 设置屏障，当调用 barrier.await() 方法的线程数量到达限制，就会执行 barrier action。然后线程
13 |
14 |
15 | 例如：
16 | ```java
17 | private static void cyclicBarrier() {
18 | //设定屏障为两个线程
19 | CyclicBarrier barrier = new CyclicBarrier(2, new Runnable() {
20 | @Override
21 | public void run() {
22 | System.out.println("CyclicBarrier run");
23 | }
24 | });
25 |
26 | Thread a = new Thread(new Runnable() {
27 | @Override
28 | public void run() {
29 |
30 | System.out.println("A is done.");
31 | //做完了 调用 barrier.await 等待其他线程
32 | try {
33 | barrier.await();
34 | } catch (InterruptedException e) {
35 | e.printStackTrace();
36 | } catch (BrokenBarrierException e) {
37 | e.printStackTrace();
38 | }
39 | //等 B 好了就可以执行了
40 | System.out.println("A after barrier");
41 |
42 | }
43 | });
44 |
45 | a.start();
46 |
47 | Thread b = new Thread(new Runnable() {
48 | @Override
49 | public void run() {
50 |
51 | System.out.println("B is done.");
52 | try {
53 | barrier.await();
54 | } catch (InterruptedException e) {
55 | e.printStackTrace();
56 | } catch (BrokenBarrierException e) {
57 | e.printStackTrace();
58 | }
59 | System.out.println("B after barrier");
60 |
61 | }
62 | });
63 |
64 | b.start();
65 |
66 | try {
67 | a.join();
68 | b.join();
69 | } catch (InterruptedException e) {
70 | e.printStackTrace();
71 | }
72 |
73 | System.out.println("All threads are done.");
74 | }
75 | ```
76 |
77 | 输出：
78 | ```
79 | A is done.
80 | B is done.
81 | CyclicBarrier run
82 | B after barrier
83 | A after barrier
84 | All threads are done.
85 | ```
86 |
87 |
88 |
--------------------------------------------------------------------------------
/books/图解Http/第1章-了解Web及网络基础.md:
--------------------------------------------------------------------------------
1 | # 第1章 了解Web及网络基础
2 |
3 | 讲了TCP/IP协议族,分层,如何传输,TCP三次握手,URI&URL等网络基础。
4 |
5 | 
6 |
7 |
8 | ## TCP/IP 分层管理
9 |
10 | TCP/IP协议族按层次分别分为以下4层:
11 |
12 | **应用层==>传输层==>网络层==>数据链路层**
13 |
14 | 分层的优势在于，当某块需要改变时，只需要修改一层即可。
15 |
16 | ### 应用层
17 |
18 | 应用层：**决定了向用户提供应用服务时通信的活动**.
19 |
20 | TCP/IP协议族内预存了各类通用的应用服务,如:`FTP` `DNS` `HTTP`
21 |
22 | ### 传输层
23 |
24 | 传输层：**对上层应用层,提供处于网络连接中的两台计算机之间的数据传输**.
25 |
26 | 传输层有两个性质不同的协议:`TCP`和`UDP`
27 |
28 | PS: TCP 可靠 ,UDP 不可靠 后面会讲
29 |
30 | ### 网络层(又名网络互联层)
31 |
32 | 网络层：用来**处理在网络上流动的数据包**. 数据包是网络传输的最小单位。
33 |
34 | 该层规定了通过怎么样的路径（所谓的传输路线）到达对方计算机，并把数据包传送给对方。
35 |
36 | 网络层所起的作用就是在众多的选项内选择一条传输路线。
37 |
38 | PS：IP协议在网络层
39 |
40 | ### 链路层(又名数据链路层,网络接口层)
41 |
42 | 用来处理链接网络的硬件部分。
43 |
44 | 包括控制操作系统、硬件的设备驱动、NIC(网卡)、光纤等。硬件上的范畴都在链路层的作用范围内。
45 |
46 |
47 | ##### 其他知识点
48 |
49 | 发送端从应用层往下走，接收端则往应用层往上走。
50 |
51 | 发送时，数据经过每一层，都会被加上该层的首部信息，接受时，经过每一层，都会被校区该层信息。
52 |
53 |
54 | ## 负责传输的 IP协议
55 |
56 | IP 协议的作用是**把各种数据包传送给对方**。
57 |
58 | 保证确实送到对方的重要条件：
59 |
60 | 1. IP 地址（节点被分配到的地址，可变）
61 | 2. MAC 地址（网卡所属的固定地址，一般不会变）
62 |
63 | IP之间的通信依赖 Mac 地址，IP 地址可以和 MAC 地址配对。
64 |
65 |
66 | 在多台网络设备间中转的时候，采用 ARP 协议（地址解析协议），根据通信方的 IP 地址，反查出对应的 MAC 地址。
67 |
68 |
69 | ## 确保可靠性的 TCP协议
70 |
71 | TCP 位于传输层,提供**可靠的字节流服务**（Byte Stream Service）
72 |
73 | 字节流服务是指 **为了方便传输,将大块数据分割成以`报文段(segment)`为单位的数据包进行管理** 这样能更容易传送大数据。
74 |
75 | ### 可靠性(三次握手)
76 |
77 | TCP的可靠性是因为它采用了**三次握手策略(three-way handshaking)**
78 |
79 | 握手过程中使用了TCP的标志:
80 | - SYN(synchronize)
81 | - ACK(acknowledgement 确认)
82 |
83 | 三次握手的过程:
84 |
85 | 1. 客户端先发送带有 SYN 标志的数据包给对方。（我要给你发数据了）
86 | 2. 接收端收到消息后，回传带有 SYN/ACK 标志的数据包，以示确认。（告诉你，我收到了）
87 | 3. 最后发送端再回传一个带有 ACK 标志的数据包，代表“握手”结束。（我知道你收到了，结束）
88 |
89 |
90 | ## 负责域名解析的 DNS 服务
91 |
92 | DNS 服务是和 HTTP 协议一样位于应用层的协议。**它提供域名到 IP 地址之间的解析服务**（通过域名查找 IP地址，反之亦可）
93 |
94 | ### 分层小结
95 |
96 | | 协议名称 | 所属层 |
97 | | :--: | :--: |
98 | | HTTP | 应用层 |
99 | | DNS | 应用层 |
100 | | IP | 网络层 |
101 | | TCP | 传输层 |
102 |
103 | ## URI和 URL
104 |
105 | URI 统一资源标识符，URL 统一资源定位符。
106 |
107 | URI**就是某个协议方案表示的资源定位的标识符**，协议方案是指**访问资源所使用的协议类型名称**。
108 |
109 | 比如采用 HTTP 协议时，协议方案就是 http。
110 |
111 | URI 协议方案有30种左右：
112 |
113 | - ftp
114 | - http
115 | - ldap
116 | - mailto
117 | - tel
118 | - ...
119 |
120 | URI格式如下：
121 |
122 | 
123 |
124 |
125 |
126 |
127 |
128 |
129 |
130 |
131 |
132 |
--------------------------------------------------------------------------------
/java/arraydeque.md:
--------------------------------------------------------------------------------
1 | # ArrayQueue
2 |
3 | ```java
4 | /**
5 | * Resizable-array implementation of the {@link Deque} interface. Array
6 | * deques have no capacity restrictions; they grow as necessary to support
7 | * usage. They are not thread-safe; in the absence of external
8 | * synchronization, they do not support concurrent access by multiple threads.
9 | * Null elements are prohibited. This class is likely to be faster than
10 | * {@link Stack} when used as a stack, and faster than {@link LinkedList}
11 | * when used as a queue.
12 | *
13 | *