【知识点】General Base

知识点】General Base"/>

【知识点】General Base

1.命名规则
C# 命名规则是为了让整个程序代码统一以增强其可读性而设置的。每一个单位在开发一个软件之前都会编写一份编码规范的文档。

常用的命名方法有两种，一种是 Pascal 命名法（帕斯卡命名法），另一种是 Camel 命名法（驼峰命名法）。

Pascal 命名法是指每个单词的首字母大写；Camel 命名法是指第一个单词小写，从第二个单词开始每个单词的首字母大写。

1. 变量的命名规则
   变量的命名规则遵循 Camel 命名法，并尽量使用能描述变量作用的英文单词。例如存放学生姓名的变量可以定义成 name 或者 studentName 等。另外，变量名字也不建议过长， 最好是 1 个单词，最多不超过 3 个单词。
2. 常量的命名规则
   为了与变量有所区分，通常将定义常量的单词的所有字母大写。例如定义求圆面积的 n 的值，可以将其定义成一个常量以保证在整个程序中使用的值是统一的，直接定义成 PI 即可。
3. 类的命名规则
   类的命名规则遵循 Pascal 命名法，即每个单词的首字母大写。例如定义一个存放学生信息的类，可以定义成 Student。
4. 接口的命名规则
   接口的命名规则也遵循 Pascal 命名法，但通常都是以 I 开头，并将其后面的每个单词的首字母大写。例如定义一个存放值比较操作的接口，可以将其命名为 ICompare。
5. 方法的命名规则
   方法的命名遵循 Pascal 命名法，一般采用动词来命名。例如实现添加用户信息操作的方法，可以将其命名为 AddUser。

在 C# 语言中，除了上面涉及的内容外还有很多对象，但命名规则都是类似的，在涉及其他对象时还会对命名规则再次说明。
2.数据挖掘十大经典算法（包括各自优缺点 / 适用数据场景）

3.数据挖掘领域十大经典算法
1. C4.5算法
1. 计算类别信息熵
类别信息熵表示的是所有样本中各种类别出现的不确定性之和。根据熵的概念，熵越大，不确定性就越大，把事情搞清楚所需要的信息量就越多。
2. 计算每个属性的信息熵
每个属性的信息熵相当于一种条件熵。他表示的是在某种属性的条件下，各种类别出现的不确定性之和。属性的信息熵越大，表示这个属性中拥有的样本类别越不“纯”。
3. 计算信息增益
信息增益的 = 熵 - 条件熵，在这里就是 类别信息熵 - 属性信息熵，它表示的是信息不确定性减少的程度。如果一个属性的信息增益越大，就表示用这个属性进行样本划分可以更好的减少划分后样本的不确定性，当然，选择该属性就可以更快更好地完成我们的分类目标。
4.计算属性分裂信息度量
用分裂信息度量来考虑某种属性进行分裂时分支的数量信息和尺寸信息，我们把这些信息称为属性的内在信息（instrisic information）。信息增益率用信息增益 / 内在信息，会导致属性的重要性随着内在信息的增大而减小（也就是说，如果这个属性本身不确定性就很大，那我就越不倾向于选取它），这样算是对单纯用信息增益有所补偿。
5. 计算信息增益率
天气的信息增益率最高，选择天气为分裂属性。发现分裂了之后，天气是“阴”的条件下，类别是”纯“的，所以把它定义为叶子节点，选择不“纯”的结点继续分裂。
2. K-Means算法
kNN的思想很简单：在训练集中选取离输入的数据点最近的k个邻居，根据这个k个邻居中出现次数最多的类别（最大表决规则），作为该数据点的类别。kNN算法中，所选择的邻居都是已经正确分类的对象。
3. SVM算法
4. Apriori算法
5. EM算法
6. AdaBoost算法
7. PageRank算法
8. K-邻近算法/kNN
9. 朴素贝叶斯算法
(1)病人分类的例子
某个医院早上收了六个门诊病人，如下表：

症状　　职业　　　疾病
——————————————————
打喷嚏　护士　　　感冒
打喷嚏　农夫　　　过敏
头痛　　建筑工人　脑震荡
头痛　　建筑工人　感冒
打喷嚏　教师　　　感冒
头痛　　教师　　　脑震荡

现在又来了第七个病人，是一个打喷嚏的建筑工人。请问他患上感冒的概率有多大？
根据贝叶斯定理：

P(A|B) = P(B|A) P(A) / P(B)
1
可得

P(感冒|打喷嚏x建筑工人)
= P(打喷嚏x建筑工人|感冒) x P(感冒) / P(打喷嚏x建筑工人)
1
2
假定”打喷嚏”和”建筑工人”这两个特征是独立的，因此，上面的等式就变成了

P(感冒|打喷嚏x建筑工人)
= P(打喷嚏|感冒) x P(建筑工人|感冒) x P(感冒) / P(打喷嚏) x P(建筑工人)
1
2
这是可以计算的。

P(感冒|打喷嚏x建筑工人)
= 0.66 x 0.33 x 0.5 / 0.5 x 0.33
= 0.66
1
2
3
因此，这个打喷嚏的建筑工人，有66%的概率是得了感冒。同理，可以计算这个病人患上过敏或脑震荡的概率。比较这几个概率，就可以知道他最可能得什么病。

这就是贝叶斯分类器的基本方法：在统计资料的基础上，依据某些特征，计算各个类别的概率，从而实现分类。

(2)朴素贝叶斯分类器的公式
假设某个体有n项特征（Feature），分别为F1、F2、…、Fn。现有m个类别（Category），分别为C1、C2、…、Cm。贝叶斯分类器就是计算出概率最大的那个分类，也就是求下面这个算式的最大值：

P(C|F1F2…Fn) = P(F1F2…Fn|C)P© / P(F1F2…Fn)
1
由于 P(F1F2…Fn) 对于所有的类别都是相同的，可以省略，问题就变成了求

P(F1F2…Fn|C)P©
1
的最大值。
朴素贝叶斯分类器则是更进一步，假设所有特征都彼此独立，因此

P(F1F2…Fn|C)P© = P(F1|C)P(F2|C) … P(Fn|C)P©
1
上式等号右边的每一项，都可以从统计资料中得到，由此就可以计算出每个类别对应的概率，从而找出最大概率的那个类。
虽然”所有特征彼此独立”这个假设，在现实中不太可能成立，但是它可以大大简化计算，而且有研究表明对分类结果的准确性影响不大。

(3)拉普拉斯平滑（Laplace smoothing）
也就是参数为1时的贝叶斯估计，当某个分量在总样本某个分类中（观察样本库/训练集）从没出现过，会导致整个实例的计算结果为0。为了解决这个问题，使用拉普拉斯平滑/加1平滑进行处理。
它的思想非常简单，就是对先验概率的分子（划分的计数）加1，分母加上类别数；对条件概率分子加1，分母加上对应特征的可能取值数量。这样在解决零概率问题的同时，也保证了概率和依然为1。
10. CART算法
4.try catch throw

5.github使用
这是在github网站中，搜索到一个项目之后，经常会看到的几个按钮。
Watch,按钮中有三个选项：
Not watching （默认选中）：当参与或者被提及到的时候，通知。
Watching：所有的更改会话都通知。
Ignoring：忽略所有的会话。
Star：表示赞，给它一个星星奖励，^_
Fork： 克隆别人的代码库到自己的github项目中，可以作为子模块的形式使用，或二次开发 。
Pull requests (PR): Fork之后，如果希望将自己的修改贡献到原始代码中，可以使用pull requests推送请求到原来仓库中，然后，原始代码的作者，根据你提交的内容，考虑是否真的放入源码中。
6.列表和元组
列表和元组是python中常用的两种数据类型。列表的类名是list，元组类名是tuple。这两个都是用来‘装东西的’。例如你有一堆数，举个例子，你想求20个数的平均值，最大值，最小值，这个时候你需要一个容器把他们装起来。数组和元组就可以实现。例如：list_a=[1,2,3,4,5,6,7,8,9,11,12,13,14,15,15,15,16,17,18,19]tuple_a=(1,2,3,4,5,6,7,8,9,11,12,13,14,15,15,15,16,17,18,19)这样就定义了一个容器把这些数字都寄存在里面。然后供后面的计算调用。数组的标志是[]，元组的标志是,。数组和元组最大的区别是一个是可变的一个是不可变的。数组在定义之后可以改变任意一个数据，数组的长度也可以发生变化，可多可少。但是元组定义之后就是固定的。元素不能变，长度也不能变。访问列表最简单的就是访问元素的下表。我想取列表中的第三个元素，用下表2（下标从零开始）a_list=[1,2,3,4,5]print(a_list[2])#打印出来3同时可以改变特定位置的元素的值，例如a_list[4]=15 #让数组第5个元素等于15print(a_list[4])#打印出来15元组访问元素也是一样的。但是因为元组不可变，所以元组的元素不能改变。a_tuple=(1,2,3,4,5)print(a_tuple[2])#打出3数组还有一些常见的方法，例如，append，insert等
7.c#中//注释和///注释的区别
///会被编译，
//不会
所以使用///会减慢编译的速度（但不会影响执行速度）
///会在其它的人调用你的代码时提供智能感知

也是一种注释，但是这种注释主要有两种作用：
1.这些注释能够生成一个XML文件。这样呢,看起来会对程序的内容一目了然。
2.以这种方式对你的类，属性，方法等等加上注释之后，当你在其他地方使用以这种方式加上的类，属性，方法等等地时候，黄色的提示框里面会把你写的注释显示出来，是你更加明白你要使用的功能的作用。
///
///定义用户姓名属性，该属性为可读可写属性
///
C# Coding的时候，常常涉及代码注释，常见的注释包括两类：
1）单行注释。格式：// Comments
2）多行注释。格式：/* Comments… */
C#引入了新的XML注释，即我们在某个函数前新起一行，输入///，VS.Net会自动增加XML格式的注释，这里整理一下可用的XML注释。
XML注释分为一级注释（Primary Tags）和二级注释（Secondary Tags），前者可以单独存在，后者必须包含在一级注释内部。
I 一级注释

1. 对类型进行描述，功能类似，据说建议使用;
2. 对共有类型的类、方法、属性或字段进行注释；
3. 主要用于属性的注释，表示属性的制的含义，可以配合使用；
4. 用于对方法的参数进行说明，格式：value；
5. 用于定义方法的返回值，对于一个方法，输入///后，会自动添加、列表和；
6. 定义可能抛出的异常，格式：；
7. 用于给出如何使用某个方法、属性或者字段的使用方法；
8. 涉及方法的访问许可；
9. 用于参考某个其它的东东:)，也可以通过cref设置属性；
10. 用于指示外部的XML注释；
    II 二级注释
11. or 主要用于加入代码段；
12. 的作用类似HTML中的

    标记符，就是分段；

13. 用于引用某个参数；
14. 的作用类似，可以指示其它的方法；
15. 用于生成一个列表；
    另外，还可以自定义XML标签
    8.SELECT * 速度比 SELECT [字段1],[字段2]…
    这个要看具体的执行计划。首先我们要分析清楚select *和select a1,a2,a3的区别。

首先sql server是按照数据块来存取数据的，一个数据块是8K，当你需要的数据在某个数据块上时，sql server会将整个8K的数据从磁盘上加载到内存中，而不仅仅是读取你需要的a1、a2这几个字段，从这种意义上来说，select *和select a1,a2,a3这种写法速度是一样的。

但是有一个问题在于有索引，当有索引的时候就不一样了，比如a1, a2, a3都在索引字段里面（包括inclue），这个时候如果select a1, a2,a3的话只要扫描索引就好了，而select *却要扫描表，通常这种情况下select a1, a2, a3要快一些。但是如果只有a1, a2在索引中，而a3不在索引中，那么select a1, a2, a3的时候就需要先扫描索引得到a1, a2，再通过索引找到表中对应的数据块取出来a3（注意取a3的时候是8K数据块一起取得），这时你会发现select a1, a2, a3又没什么优势了。当取得数据特别多的时候，扫描索引再去查找表，反而不如直接扫描表来的快，所以有时可能select *反而快。
9.避免全局查找
一个函数能用局部变量就用局部，因为访问局部变量的时间会比全局变量的时间更短
10.减值迭代

这段代码变成减值迭代后，为什么时间复杂度从O（n）变成了O（1）
reason:1 ,增值迭代时， i<values.length-1 这个语句中，每次执行判断都会去求values.length，所以时间复杂度是
2.减值迭代时，因为var i=values.length-1 只执行了一次 所以复杂度低一些
和增值迭代时简化终止条件同样的原理，如：for（）中先把length存起来作为终止条件 而不是用var.length作为终止条件
11.简化循环体
循环体是相同代码执行最多的地方 做以在循环体里做优化会事半功倍
12.后测试循环

13.缩短否定检测

14.条件分支

15.使用常量

17.强弱类型
强类型、弱类型是指类型检查的严格程度的。无论哪种语言，对于变量而言，都存在“类型”和“值”两个概念。对于强类型语言，要求所有的变量必须先定义（定义时必须声明数据类型）后使用，并且指定类型的变量只能接受类型与之匹配的值。
弱类型的变量类型则是无需声明的，由解释器解释。
18.巧用位运算

19.巧用短路

20.if

21.全等于和等于

全不等于同理
22.依赖注入
把有依赖关系的类放到容器中，解析出这些类的实例，就是依赖注入。目的是实现类的解耦。

实例：Class A中用到了Class B的对象b，一般情况下，需要在A的代码中显式的new一个B的对象。采用依赖注入技术之后，A的代码只需要定义一个私有的B对象，不需要直接new来获得这个对象，而是通过相关的容器控制程序来将B对象在外部new出来并注入到A类里的引用中。这样做有什么好处呢？

解释：假如现在有N多个类，需要用到Class B,那就需要在类里面实例化N多次，这样对于后期的维护和管理都是不方便的，如果后期需求发生改变，那更改量有大很多。

依赖注入的具体实现：

依赖注入代码
上面代码中的就是依赖注入，现在又有一个问题，假如，现在类b中的b方法现在改名为c了，那a类里面的a方法中，就要将b类中调用的b方法改成c方法。那依旧涉及到那个问题，如果有N多个类要用到B类呢？那需要做的也是去N多个类中不断得去改，这样对后期得维护，需求更改都是要花费很大的成本。

因此，PHP中有一个接口类的说法，接口类：

PHP接口（interface）的特点

1、接口的方法必须是公开的。

2、接口的方法默认是抽象的，所以不在方法名前面加abstract。

3、接口可以定义常量，但不能定义成员属性，常量的定义和用法和类中常量一样。

4、类可以实现多个接口（相当于把多个功能集于一身，如手机实现了小灵通、MP3、MP4的功能）

5、接口也可以继承接口。

不多做解释，直接贴代码：

图中可以看到，b类是一个接口类，c,d继承了b类，接口类的具体规则，则可以自己百度一下，代码中，我们延续了，第一图的代码做为修改，把普通类，改为接口类来实现依赖注入，就能解决那个遗留的问题，当依赖注入的类中的方法，改变了，那我们需要做的就是，在原有的类中，创建一个子类，接着写上相同得方法，然后在方法中写上需要的内容和逻辑就行了，当需要得时候，直接实例化，然后注入到需要的类中就行，哪怕是那些类中原有存在的方法都不需要更改。
*23.soap
SOAP的是什么的简写
soap是(Simple Object Access Protocal)的简写，即简单对象访问协议,它描述了一种在分散或分布式的环境中如何交换信息的轻量级协议。

soap用来干什么的
SOAP在http协议的基础上，是基于XML的简易协议，可使应用程序在HTTP之上进行信息交换，也就是用于访问网络服务的协议。SOAP的优点是可以传递结构化的数据，客户生成的SOAP请求会被嵌入在一个HTTP POST请求中，发送到Web服务器。Web服务器再把这些请求转发给Web service请求处理器，它解析收到的SOAP请求，调用Web service，处理后再生成相应的SOAP应答。Web服务器得到SOAP应答后，会再通过HTTP应答的方式把它送回到客户端。从HTTP协议的角度看，最基本的四种操作是GET（查），POST（改），PUT（增），DELETE（删），我们用的比较多的是POST和GET方式。而SOAP可视为POST的一个专用版本，遵循一种特殊的XML消息格式。

soap的组成部分
包括四个部分

SOAP封装：它定义了一个整体框架用来表示消息中包含什么内容，谁来处理，以及这些内容是可选的或是必需的。
SOAP编码规则：定义了用以交换应用程序定义的数据类型的实例的一系列机制。
SOAP RPC：表示定义了一个用来表示远程调用和应答的协议。
SOAP绑定：定义了一种使用底层传输协议来完成在节点间交换SOAP封装的约定。
soap协议的语法规则
构建模块
　　一条SOAP消息就是一个普通的XML文档，包含下列元素:
　　　　　　1）必需的Envelope元素，可把此XML文档表示为一条SOAP消息。
　　　　　　2）可选的Header元素，包含头部信息。
　　　　　　3）必需的Body元素，包含所有的调用和响应消息；
　　　　　　4）可选的Fault元素，提供有关在处理此消息发生错误的信息
语法规则
　　　　　　1）SOAP消息必须用XML来编码；
　　　　　　2）SOAP消息必须使用SOAP Envelope命名空间
　　　　　　3）SOAP消息必须使用SOAP Encoding命名空间
　　　　　　4）SOAP消息不能包含DTD引用
（文档类型定义（DTD，Document Type Definition）是一种特殊文档，它规定、约束符合标准通用标示语言（SGML）或SGML子集可扩展标示语言（XML）规则的定义和陈述。）
　　　　　　5）不能包含XML处理指令

SOAP基本的消息结构
　　<?xml 　version="1.0"?>
　　　　<soap:Envelope 　xmlns:soap=“”
soap:encodingStyle=“”>
　　　　soap:Header
　　　　
　　　　</soap:Header>
　　　　soap:Body
　　　　
　　　　soap:Fault
　　　　
　　　　</soap:Fault>
　　　　</soap:Body>
　　　　</soap:Envelope>
soap协议的优点
可扩展的
SOAP无需中断已有的应用程序, SOAP客户端、 服务器和协议自身都能发展。而且SOAP能极好地支持中间介质和层次化的体系结构。
简单的
客户端发送一个请求,调用相应的对象, 然后服务器返回结果。这些消息是XML格式的,并且封装成符合HTTP协议的消息。因此,它符合任何路由器、 防火墙或代理服务器的要求。
完全和厂商无关
SOAP可以相对于平台、 操作系统、 目标模型和编程语言独立实现。另外,传输和语言绑定以及数据编码的参数选择都是由具体的实现决定的。
与编程语言无关
SOAP可以使用任何语言来完成，只要客户端发送正确SOAP请求( 也就是说, 传递一个合适的参数给一个实际的远端服务器)。SOAP没有对象模型,应用程序可以捆绑在任何对象模型中。
与平台无关
SOAP可以在任何操作系统中无需改动正常运行。
总结
SOAP与XML的关系：所有的SOAP消息都使用XML形式编码
SOAP简单的理解就是这样的一个开放协议SOAP=RPC+HTTP+XML：
采用HTTP作为底层通讯协议；RPC作为一致性的调用途径，XML作为数据传送的格式，允许服务提供者和服务客户经过防火墙在INTERNET进行通讯交互。
一个SOAP方法可以简单地看作遵循SOAP编码规则的HTTP请求和响应, 一个 SOAP终端则可以看作一个基于HTTP的URL, 它用来识别方法调用的目标。像CORBA/IIOP一样, SOAP不需要具体的对象绑定到一个给定的终端, 而是由具体实现程序来决定怎样把对象终端标识符映像到服务器端的对象。
23.自动变量&局部变量
自动变量”窗口显示当前断点周围使用的变量。 “局部变量”窗口显示在局部范围内定义的变量，通常是当前函数或方法。
24.目录
1、./是当前目录
2、…/是父级目录
3、/是根目录
25.innerHTML和outerHTML区别
1.innerHTML

你好

就是喜欢你

输出结果：

就是喜欢你

2.outerHTML

你好

就是喜欢你

输出结果：

就是喜欢你

注意：

1.innerHTML 设置或获取位于对象起始和结束标签内的HTML

2.outerHTML设置或获取对象及其内容的HTML形式
向上转型和向下转型
子类对象转化为父类，向上转型（安全的）
父类转化为子类，向下转型（危险的）
VS清理项目和清理解决方案
选择清理解决方案将删除所有中间文件和输出文件，只留下项目文件和组件文件之后可以从这些文件生成中间文件和输出文件的新实例
清理项目，会清理项目生成的ilk、pdb、exe等文件。
迭代 遍历 循环 递归 的区别
　　1，循环（loop），指的是在满足条件的情况下，重复执行同一段代码。比如，while语句。 循环则技能对应集合，列表，数组等，也能对执行代码进行操作。

2，迭代（iterate），指的是按照某种顺序逐个访问列表中的每一项。比如，for语句。 　　迭代只能对应集合，列表，数组等。不能对执行代码进行迭代。

3，遍历（traversal），指的是按照一定的规则访问树形结构中的每个节点，而且每个节点都只访问一次。 遍历同迭代一样，也不能对执行代码进行遍历。

4，递归（recursion），指的是一个函数不断调用自身的行为。比如，以编程方式输出著名的斐波纳契数列
xml和yml(yaml)
yml比json、xml更适合做配置
与xml对比，简洁(xml配置中有大量的资源被浪费在开闭资源上)
控制反转（IOC），依赖注入(DI)，反射
控制反转（Inversion of Control，缩写为IoC），是面向对象编程中的一种设计原则，可以用来减低计算机代码之间的耦合度。其中最常见的方式叫做依赖注入（Dependency Injection，简称DI），还有一种方式叫“依赖查找”（Dependency Lookup）。通过控制反转，对象在被创建的时候，由一个调控系统内所有对象的外界实体将其所依赖的对象的引用传递给它。也可以说，依赖被注入到对象中。
如果一个类A 的功能实现需要借助于类B，那么就称类B是类A的依赖，如果在类A的内部去实例化类B，那么两者之间会出现较高的耦合，一旦类B出现了问题，类A也需要进行改造，如果这样的情况较多，每个类之间都有很多依赖，那么就会出现牵一发而动全身的情况，程序会极难维护，并且很容易出现问题。要解决这个问题，就要把A类对B类的控制权抽离出来，交给一个第三方去做，把控制权反转给第三方，就称作控制反转（IOC Inversion Of Control）。控制反转是一种思想，是能够解决问题的一种可能的结果，而依赖注入（Dependency Injection）就是其最典型的实现方法。由第三方（我们称作IOC容器）来控制依赖，把他通过构造函数、属性或者工厂模式等方法，注入到类A内，这样就极大程度的对类A和类B进行了解耦。
什么是依赖：
如果在 Class A 中，有 Class B 的实例，则称 Class A 对 Class B 有一个依赖。例如下面类 Human 中用到一个 Father 对象，我们就说类 Human 对类 Father 有一个依赖。

public class Human {...Father father;...public Human() {father = new Father();}
}

仔细看这段代码我们会发现存在一些问题：

如果现在要改变 father 生成方式，如需要用new Father(String name)初始化 father，需要修改 Human 代码；
如果想测试不同 Father 对象对 Human 的影响很困难，因为 father 的初始化被写死在了 Human 的构造函数中；
如果new Father()过程非常缓慢，单测时我们希望用已经初始化好的 father 对象 Mock 掉这个过程也很困难。
依赖注入：
上面将依赖在构造函数中直接初始化是一种 Hard init 方式，弊端在于两个类不够独立，不方便测试。我们还有另外一种 Init 方式，如下：

public class Human {...Father father;...public Human(Father father) {this.father = father;}
}

上面代码中，我们将 father 对象作为构造函数的一个参数传入。在调用 Human 的构造方法之前外部就已经初始化好了 Father 对象。像这种非自己主动初始化依赖，而通过外部来传入依赖的方式，我们就称为依赖注入。
现在我们发现上面 1 中存在的两个问题都很好解决了，简单的说依赖注入主要有两个好处：
1·解耦，将依赖之间解耦。
2·因为已经解耦，所以方便做单元测试，尤其是 Mock 测试。

变量的声明与定义
一般情况，把建立存储空间的声明称为定义，而把不需要建立存储空间的声明称为声明！
日志存.txt还是数据库
需要分析、统计存数据库会便利很多,只需要保存日志就存.txt
灰度发布
灰度发布（又名金丝雀发布）是指在升级版本过程中，通过分区控制，白名单控制等方式对一部分用户先升级产品特性，而其余用户则保持不变，当一段时间后升级产品特性的用户没有反馈问题，就逐步扩大范围，最终向所有用户开放新版本特性，灰度发布可以保证整体系统的稳定，在初始灰度的时候就可以发现、修改问题，以保证其影响度。
稀疏列
稀疏列是对 Null 值采用优化的存储方式的普通列。 稀疏列减少了 Null 值的空间需求，但代价是检索非 Null 值的开销增加。 当至少能够节省 20% 到 40% 的空间时，才应考虑使用稀疏列。