当JVM空闲时，自动回收每块可能被回收的内存，GC是完全自动的，不能被强制执行。程序员最多只能用System.gc()来建议执行垃圾回收器回收内存，但是具体的回收时间，是不可知的。

1. 标记-清除算法

这是 垃圾收集算法中 最最基础的算法。

1.1 算法思想

算法分为两个阶段：

标记阶段：标记出所有需要回收的对象；
清除阶段：统一清除（回收）所有被标记的对象。
下面主要讲解标记阶段。标记阶段主要分为：（先进行可达性分析）

第一次标记 & 筛选 执行finalize
第二次标记 & 筛选 放入F队列，F队列中的对象是否重新连接

1.2 优点

算法简单、实现简单

1.3 缺点

效率问题：即标记和清除两个过程效率不高
空间问题：标记 - 清除后，会产生大量不连续的内存碎片。

这导致 以后程序 需要分配较大空间对象时无法找到足够大的连续内存而被迫触发另外一次垃圾收集行为，这导致非常浪费资源。

1.4 应用场景

对象存活率较低 & 垃圾回收行为频率低 的场景

如老年代区域，因为老年代区域回收频次少、回收数量少，所以对于效率问题 & 空间问题不会很明显。

2、复制算法

该算法的出现是为了解决 标记-清除算法中 效率 & 空间问题的。

2.1 算法思想

• 将内存分为大小相等的两块，每次使用其中一块；
• 当使用的这块内存用完，就将 这块内存上还存活的对象 复制到另一块还没试用过的内存上
• 最终将使用的那块内存一次清理掉

2.2 优点

1. 解决了标记-清除算法中 清除效率低的问题：每次仅回收内存的一半区域
2. 解决了标记-清除算法中 空间产生不连续内存碎片的问题：将已使用内存上的存活对象 移动到栈顶的指针，按顺序分配内存即可。

2.3 缺点

• 每次使用的内存缩小为原来的一半。
• 当对象存活率较高的情况下需要做很多复制操作，即效率会变低

2.4 应用场景

对象存活率较低 & 需要频繁进行垃圾回收 的区域

如新生代区域

2.5 特别注意

a. 背景

新生代区域在进行垃圾回收时，98%对象都必须得回收

b. 问题

复制算法中 每次使用的内存缩小为原来的一半 利用率低 & 代价太高

c. 解决方案

不 按 1：1的比例 划分内存，而是 按8：1：1比例 将内存划分为一块较大的 Eden 和两块较小的 Survivor 区域（From Survivor、To Survivor）

• 每次使用Eden、From Survivor区域；
• 用完后就 将上述两块区域存活的对象 复制到To Survivor区域上
• 最终一次清理掉Eden、From Survivor区域使用逻辑 同 改进前

很多同学会问，假如 Eden、From Survivor区域上存活对象所需内存大小 > To Survivor区域怎么办？

解决方案：依赖老年代内存区域 做 内存分配担。

即To Survivor区域 存不下来的对象 会通过 内存分配担保机制 暂时保存在老年代

3、标记-整理算法

3.1 算法思路

算法分为三个阶段：

1. 标记阶段：标记出所有需要回收的对象；
2. 整理阶段：让所有存活的对象都向一端移动
3. 清除阶段：统一清除（回收）端以外的对象。

3.2 优点

• 解决了标记-清除算法中 清除效率低的问题：一次清楚端外区域
• 解决了标记-清除算法中 空间产生不连续内存碎片的问题：将已使用内存上的存活对象 移动到栈顶的指针，按顺序分配内存即可。

3.3 应用场景

对象存活率较低 & 垃圾回收行为频率低的场景

如老年代区域，因为老年代区域回收频次少、回收数量少，所以对于效率问题 & 空间问题不会很明显。

4. 分代收集算法

主流的虚拟机基本都采用该算法，下面会着重讲解。

4.1 算法思路

逐一标记和压缩 Java 虚拟机里的所有对象非常低效：分配的对象越多，垃圾回收需时就越久。不过，根据统计，大部分的对象，其实用没多久就不用了。根据之前的规律，就可以用来提升 JVM 的效率了。方法是，把堆分成几个部分（就是所谓的分代），分别是新生代、老年代，以及永生代.

根据 对象存活周期的不同 将 Java堆内存 分为：新生代 & 老年代 。分配比例如下：

老年代存活率高使用标记整理或者标记清除，年轻代少量存活使用复制算法

特别注意

有时候survivor被称为From Survivor和To Survivor，他们之间会经常互换角色：每次发生GC时，把Eden区和 From Survivor区中 存活且没超过年龄阈值的对象 复制到To Survivor区中（此时To Survivor变成了From Survivor），然后From Survivor清空（此时From Survivor变成了To Survivor）

两块区域特点 选择 对应的垃圾收集算法（即上面介绍的算法），具体细节请看下图

4.2 具体存储过程

新对象会被分配在新生代内存。一旦新生代内存满了，就会开始对死掉的对象，进行所谓的小型垃圾回收过程。一片新生代内存里，死掉的越多，回收过程就越快；至于那些还活着的对象，此时就会老化，并最终老到进入老年代内存。

Stop the World 事件 —— 小型垃圾回收属于一种叫 “Stop the World” 的事件。在这种事件发生时，所有的程序线程都要暂停，直到事件完成（比如这里就是完成了所有回收工作）为止（停止也不是随意停止，当到达安全点的时候暂停，OopMap才会记录信息）。停顿的时候不是全部遍历，这样太麻烦了。而是枚举根节点时，递归遍历每个栈帧的 OopMap（数据结构） ，通过栈中记录的被引用对象的内存地址，即可找到这些对象（ GC Roots ）。这是执行的线程，如果线程不执行，那么在安全区域内开始GC是安全的。

老年代用来保存长时间存活的对象。通常，设置一个阈值，当达到该年龄时，年轻代对象会被移动到老年代。最终老年代也会被回收。这个事件成为 Major GC。

Major GC 也会触发STW（Stop the World）。通常，Major GC会慢很多，因为它涉及到所有存活对象。所以，对于响应性的应用程序，应该尽量避免Major GC。还要注意，Major GC的STW的时长受年老代垃圾回收器类型的影响。

永久代包含JVM用于描述应用程序中类和方法的元数据。永久代是由JVM在运行时根据应用程序使用的类来填充的。此外，Java SE类库和方法也存储在这里。

如果JVM发现某些类不再需要，并且其他类可能需要空间，则这些类可能会被回收。

介绍

1. 新建的对象 一般会被优先分配到新生代的Eden区、From Survivor区
2. 大对象（如很长的字符串以及数组）会直接分配到老年代，这是为了避免在 Eden 区 和 Survivor区之间发生大量的内存复制（因为新生代会采用复制算法进行垃圾收集）
3. 这些对象经过第一次 Minor GC后，若仍然存活，将会被移到To Survivor区
4. 一次清理掉Eden、From Survivor区域
5. 在 To Survivor 区每经过一轮 Minor GC ，该对象的年龄就+1
6. 当对象年龄达到一定时(阈值默认=15)，就会被移动到老年代。

• 即新生代的对象在存活一定时间后，会被移动存储到老年代区域。
• 还有一种 新生代对象被移懂到老年代区域 的情况是：动态对象年龄判定。即如果在Survivor区中 所有相同年龄对象的大小总和 大于Survivor区内存大小一半时，所有大于或等于该年龄的对象都会直接进入老年代。

世代垃圾收集过程

首先，将任何新对象分配给 eden 空间。 两个 survivor 空间都是空的。

当 eden 空间填满时，会触发轻微的垃圾收集。

引用的对象被移动到第一个 survivor 空间。 清除 eden 空间时，将删除未引用的对象。

在下一次Minor GC中，Eden区也会做同样的操作。删除未被引用的对象，并将被引用的对象移动到Survivor区。然而，这里，他们被移动到了第二个Survivor区（S1）。

此外，第一个Survivor区（S0）中，在上一次Minor GC幸存的对象，会增加年龄，并被移动到S1中。待所有幸存对象都被移动到S1后，S0和Eden区都会被清空。注意，Survivor区中有了不同年龄的对象。

在下一次Minor GC中，会重复同样的操作。不过，这一次Survivor区会交换。被引用的对象移动到S0,。幸存的对象增加年龄。Eden区和S1被清空。

在较小的GC之后，当老化的物体达到一定的年龄阈值（在该示例中为8）时，它们从年轻一代晋升到老一代。

随着较小的GC持续发生，物体将继续被推广到老一代空间。

所以这几乎涵盖了年轻一代的整个过程。最终，将主要对老一代进行GC，清理并最终压缩该空间。

4.3 优点

效率高、空间利用率高

根据不同区域特点选择不同的垃圾收集算法

4.4 应用场景

现在主流的虚拟机基本都采用 分代收集算法 ，即根据不同区域特点选择不同垃圾收集算法。

新生代 区域：采用 复制算法

老年代 区域：采用 标记-清除 算法、标记 - 整理 算法

4.5 GC 触发条件

Minor GC触发条件：

当Eden区满时，触发Minor GC。

Full GC触发条件：

1. 调用System.gc时，系统建议执行Full GC，但是不必然执行
2. 老年代空间不足
3. 方法去空间不足
4. 通过Minor GC后进入老年代的平均大小大于老年代的可用内存
5. 由Eden区、From Space区向To Space区复制时，对象大小大于To Space可用内存，则把该对象转存到老年代，且老年代的可用内存小于该对象大小

5、HotSpot算法实现

根据垃圾回收算法和判定对象存活的原理来实现HotSpot。

1、枚举根节点 我们知道，对象可达性分析中GC Roots根节点主要包括栈和方法区所引用的对象。那么实际设计中如何逐个检查这些引用呢？

为了保证准确性，显然我们在枚举根节点的时候，应该停止所有的Java用户线程。
（Stop-The-World，使整个分析过程，系统好像冻结到某个时间点），为了让这个时间尽量短（否则用户线程阻塞太久），主流的虚拟机都是采用准确式GC，并不需要挨个扫描方法栈，就可以得知哪些位置上存放着对象引用。这个又是如何实现的呢？

在HotSpot的实现中，是使用一组称为OopMap的数据结构来达到这个目的的，在类加载完成的时候，HotSpot就把对象内什么偏移量上是什么类型的数据计算出来，在JIT编译过程中，也会在特定的位置记录下栈和寄存器中哪些位置是引用。这样，GC在扫描时就可以直接得知这些信息了。

OopMap 记录了栈上本地变量到堆上对象的引用关系。

其作用是：垃圾收集时，收集线程会对栈上的内存进行扫描，看看哪些位置存储了 Reference 类型。如果发现某个位置确实存的是 Reference 类型，就意味着它所引用的对象这一次不能被回收。但问题是，栈上的本地变量表里面只有一部分数据是 Reference 类型的（它们是我们所需要的），那些非 Reference 类型的数据对我们而言毫无用处，但我们还是不得不对整个栈全部扫描一遍，这是对时间和资源的一种浪费。 它的另外一个更根本的作用是，可以帮助 HotSpot 实现准确式 GC。

2、安全点

一个线程意味着一个栈，一个栈由多个栈帧组成，一个栈帧对应着一个方法，一个方法里面可能有多个安全点。

gc 发生时，程序首先运行到最近的一个安全点停下来，然后更新自己的 OopMap ，记下栈上哪些位置代表着引用。

枚举根节点时，递归遍历每个栈帧的OopMap，通过栈中记录的被引用对象的内存地址，即可找到这些对象（ GC Roots ）。

前面我们知道了OopMap的概念，然而为每一条指令的位置都生成对应的OopMap显然不显示。前面提到的“特定位置”即安全点：程序执行并非所有地方都可以停下来GC，只有到达安全点才可以。

关于安全点的选择？ 既不能让GC等待太久，也不能太过频繁增加负荷。 普通指令执行很快，一般遇到“长时间执行”的指令才会产生安全点，包括：方法调用、循环跳转等。

GC时如何让所有线程跑到安全点再停下来？抢先式中断和主动式中断。

抢先式中断：一般不采用。GC时暂停所有线程，如果发现有线程没在安全点，则让它跑到安全点。

主动式中断：GC中断线程不直接对线程操作，而是设置一个中断标志位。线程在每一个安全点检查这个标志位即可。

3、安全区域

考虑一下，程序不执行的时候（没有分配到cpu时间片）如何跑到安全点呢？ 于是，提出了扩展的安全点——安全区域的概念。

安全区域：一段代码中，对象引用没有发生变化，任何地方开始GC都是安全的。
当线程执行到安全区域时，首先标识自己已经进入安全区域，这中间如果发生GC，就不用管标识为安全区域的线程了。 线程离开安全区域之前，需要确定自己已经完成了根节点枚举的过程，否则必须等待完成。

861. 翻转矩阵后的得分

有一个二维矩阵 A 其中每个元素的值为 0 或 1。

移动是指选择任一行或列，并转换该行或列中的每一个值：将所有 0 都更改为 1，将所有 1 都更改为 0。

在做出任意次数的移动后，将该矩阵的每一行都按照二进制数来解释，矩阵的得分就是这些数字的总和。

返回尽可能高的分数。

示例：

输入：[[0,0,1,1],[1,0,1,0],[1,1,0,0]]

输出：39

解释：

转换为 [[1,1,1,1],[1,0,0,1],[1,1,1,1]]

0b1111 + 0b1001 + 0b1111 = 15 + 9 + 15 = 39

提示：

1 <= A.length <= 20

1 <= A[0].length <= 20

A[i][j] 是 0 或 1

思路：我的思路是把数组的行先转置，每一行如果转置后的结果比原先的一行结果大，则转置成功，之后，再按照列转置，转置列的时候要注意，因为同一列的时候，是同一阶的数（按照行求二进制），所以我要保证同一列的时候，1是最多的即可。

提交记录：https://leetcode-cn.com/submissions/detail/22283165/

ARTS打卡第四周

A

861. 翻转矩阵后的得分

提交记录：https://leetcode-cn.com/submissions/detail/22283165/

R

介绍了民主的种类，以及产生过滤泡的一些现象特征，未完

Breaking the filter bubble democracy and design

T

关于hexo博客的搭建，现在好像还没有被浏览器收录，这样貌似搜索引擎搜索不到我，暂时就总结一下，并没有尝试过，关于访客记录和文字记录还没有做

关于Hexo的浏览器收录

S

如果可以通过算法来判断女朋友有没有生气

有理有据，笑死我了

1051. 高度检查器

学校在拍年度纪念照时，一般要求学生按照 非递减 的高度顺序排列。

请你返回至少有多少个学生没有站在正确位置数量。该人数指的是：能让所有学生以 非递减 高度排列的必要移动人数。

示例：

输入：[1,1,4,2,1,3]

输出：3

解释：

高度为 4、3 和最后一个 1 的学生，没有站在正确的位置。

提示：

1 <= heights.length <= 100

1 <= heights[i] <= 100

思路：普通人的思路应该是把原数组排序一遍，然后再比较位置，但是排序的复杂度是On2，能不能On就把题目解出来呢，我的考虑是，因为只要找出站错学生，并记录数量就好了，假设有个“哨兵”从左向右移动，哨兵会每次移动到比之前大的那个位置，遇到比之前小的数那就是站错的同学

然而我发现这个思路是错的，这样只能找出一部分站错的位置，最后我还是老老实实的排序再比较！

提交记录：https://leetcode-cn.com/submissions/detail/21704153/

1021. 删除最外层的括号

有效括号字符串为空 (“”)、”(“ + A + “)” 或 A + B，其中 A 和 B 都是有效的括号字符串，+代表字符串的连接。例如，””，”()”，”(())()” 和 “(()(()))” 都是有效的括号字符串。

如果有效字符串 S 非空，且不存在将其拆分为 S = A+B 的方法，我们称其为原语（primitive），其中 A 和 B 都是非空有效括号字符串。

给出一个非空有效字符串 S，考虑将其进行原语化分解，使得：S = P_1 + P_2 + … + P_k，其中 P_i 是有效括号字符串原语。

对 S 进行原语化分解，删除分解中每个原语字符串的最外层括号，返回 S 。

示例 1：

输入：”(()())(())”

输出：”()()()”

解释：

输入字符串为 “(()())(())”，原语化分解得到 “(()())” + “(())”，删除每个部分中的最外层括号后得到 “()()” + “()” = “()()()”。

示例 2：

输入：”(()())(())(()(()))”

输出：”()()()()(())”

解释：

输入字符串为 “(()())(())(()(()))”，原语化分解得到 “(()())” + “(())”+”(()(()))”，删除每隔部分中的最外层括号后得到 “()()” + “()” + “()(())” = “()()()()(())”。

示例 3：

输入：”()()”

输出：””

解释：

输入字符串为 “()()”，原语化分解得到”()”+”()”，删除每个部分中的最外层括号后得到 “” + “” = “”。

提示：

S.length <= 10000

S[i] 为 “(“ 或 “)”

S 是一个有效括号字符串

思路：考虑把“(”看做-1，“)”,如果它们是一组的话，如”(())”最后得到的值就是0，如果相加等于0的话，那么就能找出“)”。从右往左就能找出“)”,想法是对的，但是还是比较麻烦。看了下别人的，发现自己就是个傻子。

优化思路：考虑一个初始数如count=0，遇到”(“就执行count++，否则就是“)”执行–count，一旦count>0或者count<0则是里面的括号，注意是count++和–count

提交记录：https://leetcode-cn.com/submissions/detail/20565238/

977. 有序数组的平方

给定一个按非递减顺序排序的整数数组A，返回每个数字的平方组成的新数组，要求也按非递减顺序排序。

示例 1：

输入：[-4,-1,0,3,10]

输出：[0,1,9,16,100]

示例 2：

输入：[-7,-3,2,3,11]

输出：[4,9,9,49,121]

提示：

1 <= A.length <= 10000

-10000 <= A[i] <= 10000

A 已按非递减顺序排序。

思路：其实只要做乘方之后的排序就能做出来，但是复杂度是在n^2，考虑能不能在O(n)中解出来，我的想法是，找到了数组中中间两个数的位置，也就是第一个正数和第一个负数的位置，然后通过位置的比较，来改变索引，其实我的思路是对的，用两个索引去表示位置，但是好像考虑情况比较多，数组全是正数，或者全是负数，或者正多负少，或者正少负多，最初来运行也不是很快，需要改善

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
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
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69

public class Solution_977 {
    public int[] sortedSquares(int[] A) {
        //找到两个大于等于0的第一个位置和小于等于0的位置
        int pindex = 0;
        int nindex = 0;
        int[] result = new int[A.length];
        for(int i=0;i<A.length;i++){
            if(A[i]>=0){//找到临界位置
                pindex = i;
                nindex = i-1;
                break;
            }
        }

        if(nindex==-1){
            for(int i=0;i<A.length;i++){
                result[i] = A[i] * A[i];
            }
        }else if(pindex==nindex){
            int count = 0;
            for(int i=A.length-1;i>=0;i--){
                result[count] = A[i] * A[i];
                count++;
            }
        }else {
            int count=0;
            while (true){
                //循环终止两个条件，要么pindex到末尾，要么nindex到0位
                if(nindex<0){
                    while(pindex<=A.length-1){
                        System.out.println(pindex);
                        result[count] = A[pindex]*A[pindex];
                        count++;
                        pindex++;
                    }
                    break;
                }
                if(pindex>A.length-1){
                    while(nindex>=0){
                        System.out.println(nindex);
                        result[count] = A[nindex]*A[nindex];
                        count++;
                        nindex--;
                    }
                    break;
                }

                if(-A[nindex]<A[pindex]){
                    System.out.println(nindex);
                    result[count] = A[nindex]*A[nindex];
                    count++;
                    nindex--;
                }else{
                    System.out.println(pindex);
                    result[count] = A[pindex]*A[pindex];
                    count++;
                    pindex++;
                }


            }
        }

//        for(int i=0;i<result.length;i++){
//            System.out.print(result[i]+" ");
//        }

        return result;
    }

别的思路，我看了下，其实索引位置可以定在开头和结尾，那么判断条件就是当他们两个相等时就可以终止循环了（为什么我没有想到！！！别问，问就是我菜！）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

class Solution {
    public int[] sortedSquares(int[] A) {
        int res[]=new int[A.length];
        int count=A.length-1;
        int right=A.length-1;
        int left=0;
        while(left<=right){
            if(A[left]*A[left]<=A[right]*A[right]){
                res[count]=A[right]*A[right];
                right--;
                count--;
            }else{
                res[count]=A[left]*A[left];
                left++;
                count--;
            }
        }
        return res;
    }
}

提交记录：https://leetcode-cn.com/submissions/detail/20921091/

292. Nim 游戏

你和你的朋友，两个人一起玩Nim游戏：桌子上有一堆石头，每次你们轮流拿掉1 - 3块石头。拿掉最后一块石头的人就是获胜者。你作为先手。

你们是聪明人，每一步都是最优解。编写一个函数，来判断你是否可以在给定石头数量的情况下赢得游戏。

示例:

输入: 4

输出: false

解释: 如果堆中有4块石头，那么你永远不会赢得比赛；因为无论你拿走1块、2块还是3块石头，最后一块石头总是会被你的朋友拿走。

思路：其实只要是当谁轮到4或者是4的倍数的时候，谁就输了，也就是说我先手的话，我只要拿掉的石头看是否是4的倍数即可，很简单的一道题，可以了解下巴什博弈。

提交记录：https://leetcode-cn.com/submissions/detail/21578477/

ARTS打卡第二周

A

977. 有序数组的平方

R

本来是想找这本书看的，但是好像这本书内容比较多，且正好找到关于这一篇书的review，主要是关于过滤泡的介绍，大部分人对过滤泡的概念可能不太理解，用个人比较直白的言语介绍就是，在网络中存在了许多的推荐算法，这些推荐算法的本意是帮用户找到自己感兴趣的观点，但是长此以往用户只能接收自己感兴趣的东西，但是不能接收与自己意见相反的观点，在文中表达式陷入循环当中

The Filter Bubble:
What the Internet is Hiding From You

过滤泡沫:互联网对你隐瞒了什么

在《过滤气泡》中，Eli Pariser透过现代搜索技术和通信技术的面纱，揭示了塑造我们对世界认知的算法。这些出色的过滤器对人们学习、探索和发现周围环境的方式有着深远的影响。在他的书中，Pariser将他的论点分为七个部分，其中他解释了当前的技术前景，确定了主要的参与者，并提出了消费者、公司和政府在新技术时代成为知情的、积极的和受保护的参与者的方法。

Pariser首先描述了他所谓的“相关性竞赛”(Pariser 2011, 21)，在这场竞赛中，各家公司都在叫嚣着要开发最新的、最个性化的过滤器，这种过滤器远远超出了过滤到搜索结果顶部的赞助商搜索结果。他解释说，每点击一次鼠标，就会向公司发送一个点击信号，这个信号就是个人感兴趣的东西。Pariser提供了一个搜索术语“sox”可以返回“Sarbanes Oxley”来搜索华尔街类型，并返回另一个类型的棒球结果的例子(Pariser 2011, 35)公司能够跟踪个人偏好，甚至知道用户在第一次点击后需要等待多长时间才能继续浏览。目前，这些高度专业化的主页实施起来很昂贵，但与所有技术创新一样，一旦有足够的需求，价格就会下降。

Pariser解释说，在个人层面上收集大量和多种信息的能力导致了一个全新的领域，称为数据市场(Pariser 2011,42)。他介绍了Acxiom和TARGUSinfo等公司的情况，这些公司的业务是出售人们的个人数据，帮助公司创建有针对性的广告，并提高利润。Acxiom了解96%的美国家庭，收集了超过1500个不同的数据点，比如家庭成员的名字、地址、处方，甚至一个人是左撇子还是右撇子。然而，一家对个人信息如此了解的公司还远未被广泛知晓。
在第二章中，Pariser探讨了不断变化的媒体格局，并引用了去中介化的兴起和中间商的消失(Pariser 2011,59)。他提出的观点是，随着互联网的显著发展，人们不再需要依靠《华盛顿邮报》(Washington Post)来解读新闻发布会，而是可以阅读文字记录，自己做出决定。他解释说，由于新闻主页是由点击信号的受众反应来驱动的，这可能是一件好事，也可能导致重要的标题被娱乐性的标题淹没。
Pariser在第三章中关于技术时代的机缘巧合的丧失的论述，也许是最雄辩和最及时的论述。他认为，个性化过滤器的存在与人们的自然认知过程不一致，因为它限制了人们接触相反思想的程度，并从我们的环境中移除一些促使我们想要学习的关键提示(Pariser 2011, 84)。

Pariser警告说，这个世界的危险在于，它过于适应个人利益，并对社会狭隘经验中意外收获的丧失感到遗憾。他解释说，从创新的进化观点来看，这种随机的机会不是偶然的，而是必要的。创新需要机缘巧合(Pariser 2011,96)。对于那些在政策领域工作的人来说，这不仅仅是让可复制的文献综述几乎不可能的问题。研究人员不再面临与他们现有观点相悖的想法。为了实现真正的创新和学习，全球社会需要面对挑战现有思想的相反的和新的信息。
认知失调的概念是指人们倾向于确认自己信念的想法，而不是反驳它们(Festinger 1957)。一旦一个人点击了一个链接，他们以后更有可能看到类似的链接，从而加强了他们自己的兴趣。在第四章中，Pariser写道，你的身份塑造了你的媒体，然后你的媒体塑造了你的信仰和你所关心的。你点击一个链接，这表明你对某件事很感兴趣，这意味着你将来更有可能看到关于这个话题的文章，这反过来又为你准备了这个话题。你被困在一个你自己的循环中，如果你的身份被误导，奇怪的模式开始出现，就像混响从放大器(Pariser 2011, 125)。
在一个认知失调被抑制，甚至完全避免的世界里，没有多少改变、影响或发现的空间。过滤器无法区分一个人的冲动和一般利益。过滤器无法区分一个人的冲动和一般利益。突然，一个人的状态更新、推特和个性化新闻的世界变成了现实，屏幕顶部没有免责声明警告说，在你的循环之外还有一个广阔的世界。

第五章和第六章是书中技术性最强的，但是以一种相当容易理解的方式呈现给读者。对大多数人来说，技术是他们使用的东西，而不是他们能够控制的东西，更不用说影响了。一般人不会流利地使用复杂的编程语言。Pariser解释说，人们依赖程序员来设计能够在日常生活中帮助他们的技术，并希望了解与之相关的潜在危险或风险(Pariser 2011)。此外，他还通过马克·扎克伯格(Mark Zuckerberg)和他的导师彼得·泰尔(Peter Theil)的个人简介，将Facebook生动地人格化，从而让这个行业的巨头们变得有关联，并让人们更容易理解他们是如何落入这个价值500亿美元的沙堡(Pariser 2011, 180)的。

Pariser在第七章中讨论了技术的未来，描述了化身、机器人和智能尘埃的兴起。这一章也许是全书最令人不安的一章。这一章预言了一个未来，人工智能和真实智能之间的界限是如此模糊，以至于代码可能学会问人们无法思考的问题。隐私损失的程度将是惊人的，并逃避目前大多数人的理解。这些例子从良性的，服装店知道一个人最喜欢的颜色，并利用它的优势，到不那么美味的，一个婴儿监视器使用132书评:过滤气泡作为黑客设备。虽然个性化技术的许多方面旨在使人们的生活更容易，但这种信息超载导致有限理性，最终导致有限信息的经济问题(True et al. 1999)。Pariser认为，人们必须记住，他们生活在自己的欲望和市场承受能力之间的平衡之中(Pariser 2011,215)。

当读者认为对未来隐私、自由意志和创造力的所有希望都破灭时，Pariser的第八章也是最后一章指出，适应新技术和通信环境的关键是接受并承认意见形成算法和目标信息的存在。Pariser在最后一章中承认，留给“you loop”一代的最大问题将是隐私问题。此外，在能够熟练地解释信息之前，社会将不得不成为信息的消费者。
Pariser最后为公司、政府和个人提供了一些建议，以帮助他们采取措施减轻和/或消除这些过滤器和算法的影响。他还建议，工程师可以设计过滤系统，让人们接触到气泡之外的话题。然而，他解释说，责任不能完全落在企业的肩上。从来没有人说过互联网的工作就是向世界展示相互矛盾的观点。思想的市场是复杂的，不可能也不应该被简化成像搜索引擎那样令人懊悔的东西。如果社会把学习和发现的工作留给计算机程序，他们就放弃了我们自己推理和发现新事物的能力和责任。
Pariser是一位深刻而睿智的作家，他的理论和论点都得到了清晰而公正的表达。在这样一本书中，一个简单的立场是攻击这家渴求数据的公司，称其试图抓住天真的消费者。Pariser对争论双方的风险和利益进行了深入的讨论，最终确定了分担责任的必要性。他把读者的注意力吸引到一个极其重要的话题上，让读者感到有权力做出自己的选择，保护自己的个人信息。他的写作风格使技术官僚主义的主题易于理解;它不需要先进或详细的计算机科学知识来理解内容。

过滤气泡有时是可怕的。用通俗易懂的非技术术语准确地了解屏幕后面发生了什么，让人大开眼界，偶尔也会感到不安。一个聪明的、精通电脑的消费者可能仍然会感到不安，因为他们对公司在多大程度上挖掘个人信息、只提供高度个性化的内容知之甚少。这本书推荐给任何使用技术在一天内做出、指导或影响一个或多个决定的人。有了这本书提供的信息，读者可能会觉得有必要改变他们的网上行为。至少，读者在阅读过程中会对日常交流中普遍使用的技术有一个全面的了解，并意识到它的影响。

T

对于Hexo网站的搭建记录，这里主要是介绍Hexo+Github的搭建，以及一些坑

对于主流的搭建，网上以及比较多了，我这这里稍微写一下

1、准备与搭建

安装node.js、Git、Hexo

2、本地初始化Hexo静态博客

hexo s 启动服务器指令，查看是否成功

3、将博客与Github关联

ssh key添加到Github账户中，仓库门一定是xxx.github.io

之后要修改_config.yml文件配置中的deploy，之后hexo d -g上传至GitHub上就可以访问了

关于这个主要的问题是，如何异步管理，自己的本地电脑可以每次在本机上发布文章，上传到GitHub上，可以浏览。但是，如果用户出差在外地又如何维护，主要的思路是，你本地的代码，并不全都上传到GitHub上的，而上传的那一部分也就是供用户浏览的静态页面（master分支），如果想要多台设备共同维护，只要把代码部分上传至GitHub即可，可以在仓库里再建一个新分支，大致是这么一个思路，但是好像里面文件的关系，我是没有成功，要清楚哪些文件需要上传，我觉得再建一个仓库也是可行的，这个可以尝试一下。

S

看到这一篇耗子叔翻译的很有意思的文章，看了下标题应该就能理解，这是一篇反面关于程序员写代码的翻译例子，如果这么写代码的话，可以体验下医院的wifi到底能用多块吧，哈哈

原文：http://mindprod.com/jgloss/unmain.html
译者：陈皓 （@左耳朵耗子）
译文：http://coolshell.cn/articles/4758.html

对，你没看错，本文就是教你怎么写出让同事无法维护的代码。

一、程序命名

容易输入的变量名。比如：Fred，asdf
单字母的变量名。比如：a,b,c, x,y,z（如果不够用，可以考虑a1,a2,a3,a4,….）
有创意地拼写错误。比如：SetPintleOpening， SetPintalClosing。这样可以让人很难搜索代码。
抽象。比如：ProcessData, DoIt, GetData… 抽象到就跟什么都没说一样。
缩写。比如：WTF，RTFSC …… （使用拼音缩写也同样给力，比如： BT，TMD，TJJTDS）
随机大写字母。比如：gEtnuMbER..
重用命名。在内嵌的语句块中使用相同的变量名有奇效。
使用重音字母。比如：int ínt（第二个 ínt不是int）
使用下划线。比如：, _, ___。
使用不同的语言。比如混用英语，德语，或是中文拼音。
使用字符命名。比如：slash, asterix, comma…
使用无关的单词。比如：god, superman, iloveu….
混淆l和1。字母l和数字1有时候是看不出来的。

二、伪装欺诈

把注释和代码交织在一起。
for(j=0; j<array_len; j+ =8){ total += array[j+0 ]; total += array[j+1 ]; total += array[j+2 ]; /* Main body of total += array[j+3]; * loop is unrolled total += array[j+4]; * for greater speed. total += array[j+5]; */ total += array[j+6 ]; total += array[j+7 ];}
代码和显示不一致。比如，你的界面显示叫postal code，但是代码里确叫 zipcode.
隐藏全局变量。把使用全局变量以函数参数的方式传递给函数，这样可以让人觉得那个变量不是全局变量。
使用相似的变量名。如：单词相似，swimmer 和 swimner，字母相似：ilI1| 或 oO08。parselnt 和 parseInt， D0Calc 和 DOCalc。还有这一组：xy_Z, xy__z, _xy_z, _xyz, XY_Z, xY_z, Xy_z。
重载函数。使用相同的函数名，但是其功能和具体实现完全没有关系。
操作符重载。重载操作符可以让你的代码变得诡异，感谢CCTV，感谢C++。这个东西是可以把混乱代码提高到一种艺术的形式。比如：重载一个类的 ! 操作符，但实际功能并不是取反，让其返回一个整数。于是，如果你使用 ! ! 操作符，那么，有意思的事就发生了—— 先是调用类的重载 ! 操作符，然后把其返回的整数给 ! 成了 布尔变量，如果是 !!! 呢？呵呵。

三、文档和注释

在注释中撒谎。你不用真的去撒谎，只需在改代码的时候不要更新注释就可以了。
注释里面写废话。比如：/* add 1 to i */
只注释是什么，而不是为什么。
不要注释秘密。如果你开发一个航班系统，请你一定要保证每有一个新的航班被加入，就得要修改25个以上的位置的程序。千万别把这个事写在文档中。
注重细节。当你设计一个很复杂的算法的时候，你一定要把所有的详细细设计都写下来，没有100页不能罢休，段落要有5级以上，段落编号要有500个以上，例如：1.2.4.6.3.13 – Display all impacts for activity where selected mitigations can apply (short pseudocode omitted). 这样，当你写代码的时候，你就可以让你的代码和文档一致，如：Act1_2_4_6_3_13()千万不要注释度衡单位。比如时间用的是秒还是毫秒，尺寸用的是像素还是英寸，大小是MB还是KB。等等。另外，在你的代码里，你可以混用不同的度衡单位，但也不要注释。
Gotchas。陷阱，千万不要注释代码中的陷阱。
在注释和文档中发泄不满。

四、程序设计

Java Casts。Java的类型转型是天赐之物。每一次当你从Collection里取到一个object的时候，你都需要把其转回原来的类型。因些，这些转型操作会出现在N多的地方。如果你改变了类型，那么你不一定能改变所有的地方。而编译器可能能检查到，也可能检查不到。
利用Java的冗余。比如：Bubblegum b = new Bubblegom(); 和 swimmer = swimner + 1; 注意变量间的细微差别。
从不验证。从不验证输入的数据，从不验证函数的返回值。这样做可以向大家展示你是多么的信任公司的设备和其它程序员
不要封装。调用者需要知道被调用的所有的细节。
克隆和拷贝。为了效率，你要学会使用copy + paste。你几乎都不用理解别人的代码，你就可以高效地编程了。
巨大的listener。写一个listener，然后让你的所有的button类都使用这个listener，这样你可以在这个listener中整出一大堆if…else…语句，相当的刺激。
使用三维数组。如果你觉得三维还不足够，你可以试试四维。
混用。同时使用类的get/set方法和直接访问那个public变量。这样做的好处是可以极大的挫败维护人员。
包装，包装，包装。把你所有的API都包装上6到8遍，包装深度多达4层以上。然后包装出相似的功能。
没有秘密。把所有的成员都声明成public的。这样，你以后就很难限制其被人使用，而且这样可以和别的代码造成更多的耦合度，可以让你的代码存活得更久。
排列和阻碍。把drawRectangle(height, width) 改成 drawRectangle(width, height)，等release了几个版本后，再把其改回去。这样维护程序的程序员们很快就不明白哪一个是对的。
把变量改在名字上。例如，把setAlignment(int alignment)改成，setLeftAlignment, setRightAlignment, setCenterAlignment。
保留你所有的没有使用的和陈旧的变量，方法和代码。
Final你所有的子结点的类，这样，当你做完这个项目后，没有人可以通过继承来扩展你的类。java.lang.String不也是这样吗？
避免使用layout。这样就使得我们只能使用绝对坐标。如果你的老大强制你使用layout，你可以考虑使用GridBagLayout，然后把grid坐标hard code.
环境变量。如果你的代码需要使用环境变量。那么，你应该把你的类的成员的初始化使用环境变量，而不是构造函数。
使用全局变量。1）把全局变量的初始化放在不同的函数中，就算这个函数和这个变量没有任何关系，这样能够让我们的维护人员就像做侦探工作一样。2）使用全局变量可以让你的函数的参数变得少一些。
配置文件。配置文件主要用于一些参数的初始化。在编程中，我们可以让配置文件中的参数名和实际程序中的名字不一样。
膨胀你的类。让你的类尽可能地拥有各种臃肿和晦涩的方法。比如，你的类只实现一种可能性，但是你要提供所有可能性的方法。不要定义其它的类，把所有的功能都放在一个类中。
使用子类。面向对象是写出无法维护代码的天赐之物。如果你有一个类有十个成为（变量和方法）你可以考虑写10个层次的继承，然后把这十个属性分别放在这十个层次中。如果可能的话，把这十个类分别放在十个不同的文件中。
混乱你的代码。使用XML。XML的强大是无人能及的。使用XML你可以把本来只要10行的代码变成100行。而且，还要逼着别人也有XML。（参看，信XML得永生，信XML得自信）
分解条件表达式。如：把 a==100分解成，a>99 && a<101
学会利用分号。如：if ( a );else;{ int d; d = c;}
间接转型。如：把double转string，写成new Double(d).toString() 而不是 Double.toString(d)
大量使用嵌套。一个NB的程序员可以在一行代码上使用超过10层的小括号（），或是在一个函数里使用超过20层的语句嵌套{}，把嵌套的if else 转成 [? :] 也是一件很NB的事。
长代码行。一行的代码越长越好。这样别人阅读时就需要来来回回的
不要过早的return。不要使用break，这样，你就需要至少5层以上的if-else来处理错误。
不要使用{}。不要在if else使用{}，尤其是在你重量地使用if-else嵌套时，你甚至可以在其中乱缩进代码，这样一来，就算是最有经验的程序员也会踩上陷阱。
琐碎的封装。比较封装一个bool类，类里面什么都做，就是一个bool.
循环。千万不可用for(int i=0; i<n; i++)使用while代替for，交换n和i，把<改成<=，使用 i–调整步伐 。

五、测试

从不测试。千万不要测试任何的出错处理，从来也不检测系统调用的返回值。
永远不做性能测试。如果不够快就告诉用户换一个更快的机器。如果你一做测试，那么就可能会要改你的算法，甚至重设计，重新架构。
不要写测试案例。不要做什么代码覆盖率测试，自动化测试。
测试是懦夫行为。一个勇敢的程序员是根本不需要这一步的。太多的程序太害怕他们的老板，害怕失去工作，害怕用户抱怨，甚至被起诉。这种担心害怕直接影响了生产力。如果你对你的代码有强大的信心，那还要什么测试呢？真正的程序员是不需要测试自己的代码的。

六、其他

你的老板什么都知道。无论你的老板有多SB，你都要严格地遵照他的旨意办事，这样一来，你会学到更多的知识以及如何写出更加无法维护的代码。
颠覆Help Desk。你要确保你那满是bug的程序永远不要被维护团队知道。当用户打电话和写邮件给你的时候，你就不要理会，就算要理会，让用户重做系统或是告诉用户其帐号有问题，是标准的回答。
闭嘴。对于一些像y2k这样的大bug，你要学会守口如瓶，不要告诉任何人，包括你的亲人好友以及公司的同事和管理层，这样当到那一天的时候，你就可以用这个bug挣钱了。
忽悠。你会学会忽悠，就算你的代码写得很烂，你也要为其挂上GoF设计模式的标签，就算你的项目做得再烂，你也要为其挂上敏捷的标签，让整个团队和公司，甚至整个业界都开始躁动，这样才能真正为难维护的代码铺平道路。
总之，我们的口号是—— Write Everywhere, Read Nowhere

ARTS打卡第三周

A

292. Nim游戏

提交记录：https://leetcode-cn.com/submissions/detail/21578477/

1051. 高度检查器

提交记录：https://leetcode-cn.com/submissions/detail/21704153/

R

《Exposure to ideologically diverse news and opinion on Facebook》

T

积累了两个技巧
1、JSONObject和JSONArray的区别和基本用法

2、json文件批量导入Mongodb及其字段类型转换

S

本周看了深入理解Java虚拟机这本书，做了学习笔记

ARTS打卡第一周

A

1021.删除最外层的括号

R

Anatomy of news consumption on Facebook

摘要
社交媒体和微博平台的出现从根本上改变了我们消费信息和形成观点的方式。本文通过对全球范围内3.76亿用户在6年(2010年1月至2015年12月)的新闻消费模式进行表征，探索Facebook信息空间的解剖。我们发现，用户倾向于关注有限的页面集，从而在新闻媒体之间形成一个清晰的社区结构。我们还发现用户和新闻提供者的偏好不同。通过跟踪Facebook页面之间的相似程度，并检查它们的地理位置，我们发现新闻提供商比用户更受地理位置的限制。我们设计了一个简单的选择性曝光模型，重现了观察到的连接模式。

T

看了极客时间的数据结构与算法之美，对数据结构数组和链表又重温了一遍

主要是数组和链表，数组随机访问快，增删慢，关于增加删除如果是在中间位置部分，算法复杂度是O(n)，而链表则相反。这个应该大多数人都知道，关于数组还有在java的ArrayList有动态扩容1.5杯，默认容量为10，也就是超出容量后，自动扩展内存容量1.5倍。

链表了解了基本概念，需要实践几遍

S

参考论答系统，设计开发一个系统。
当前的想法是要面向教师群体，当前面临的问题，以及实施步骤

1. 需要从网上抓取基本的题库，然后整理并标签化
2. 参考论文找出合适的核心算法
3. 参考论答系统设计出系统

关于利用Github+Hexo网站的搭建学习
https://www.cnblogs.com/fengxiongZz/p/7707219.html