布隆过滤器原理
开发一个电商项目，因为数据量一直在增加(已达亿级)，所以需要重构之前开发好的秒杀功能，为了更好的支持高并发，在验证用户是否重复购买的环节，就考虑用布隆过滤器。
也顺便更加深入的去了解下布隆过滤器的原理，感觉还是蛮有意思的，这一连串的公式不静下心来思考，很容易被绕晕。
一、概述
1、什么是布隆过滤器
本质上布隆过滤器是一种数据结构，比较巧妙的概率型数据结构，特点是高效地插入和查询。根据查询结果可以用来告诉你 某样东西一定不存在或者可能存在 这句话是该算法的核心。
相比于传统的 List、Set、Map 等数据结构，它更高效、占用空间更少，但是缺点是其返回的结果是概率性的，而不是确切的，同时布隆过滤器还有一个缺陷就是
数据只能插入不能删除。
2、数据如何存入布隆过滤器
布隆过滤器是由一个很长的bit数组和一系列哈希函数组成的。
数组的每个元素都只占1bit空间，并且每个元素只能为0或1。
布隆过滤器还拥有k个哈希函数，当一个元素加入布隆过滤器时，会使用k个哈希函数对其进行k次计算,得到k个哈希值，并且根据得到的哈希值，在维数组中把对应下标的值置位1。
判断某个数是否在布隆过滤器中，就对该元素进行k次哈希计算，得到的值在位数组中判断每个元素是否都为1，如果每个元素都为1，就说明这个值在布隆过滤器中。
3、布隆过滤器为什么会有误判
当插入的元素越来越多时，当一个不在布隆过滤器中的元素，经过同样规则的哈希计算之后，得到的值在位数组中查询，有可能这些位置因为其他的元素先被置1了。
所以布隆过滤器存在误判的情况，但是如果布隆过滤器判断某个元素不在布隆过滤器中，那么这个值就一定不在。
如果对布隆过滤器的概念还不是很理解的话，推荐一篇博客，图文并茂好理解很多。详解布隆过滤器的原理、使用场景和注意事项
4、使用场景
- 网页爬虫对URL的去重，避免爬去相同的URL地址。
- 垃圾邮件过滤，从数十亿个垃圾邮件列表中判断某邮箱是否是杀垃圾邮箱。
- 解决数据库缓存击穿，黑客攻击服务器时，会构建大量不存在于缓存中的key向服务器发起请求，在数据量足够大的时候，频繁的数据库查询会导致挂机。
- 秒杀系统，查看用户是否重复购买。
二、实际应用场景
背景 现在有个100亿个黑名单网页数据，每个网页的URL占用64字节。现在想要实现一种网页过滤系统，可以根据网页的URL判断该网站是否在黑名单上，请设计该系统。
需求可以允许有0.01%以下的判断失误率，并且使用的总空间不要超过200G。
这里一共有4个常量：
100亿条黑名单数据，每条数据占64个字节,万分之一的失误率，总空间不要超过200G。
如果不考虑不拢过滤器，那么这里存储100亿条数据就需要 100亿 * 64字节 = 596G 显然超过300G
解题 在满足有 100亿条数据 并且允许 万分之一的失误率 的布隆过滤器需要多大的bit数组呢？
- 设bit数组大小为m，样本数量为n，失误率为p。
- 由题可知 n = 100亿，p = 0.01%
布隆过滤器的大小m公式
求得 m = 19.19n，向上取整为 20n。所以2000亿bit，约为186G。
算完m，我们顺便来算下m，n已知，这时满足最小误差的k是几个。
哈希函数的个数k公式
求得 k = 14，即需要14个哈希函数。
通过通过 m = 20n， k = 14我们再来算下真实的失误率。
布隆过滤器真实失误率p公式
求得 p = 0.006%，即布隆过滤器的真实失误率为0.006%。
通过布隆过滤器公式也可以看出：
单个数据的大小不影响布隆过滤器大小，因为样本会通过哈希函数得到输出值。
就好比上面的 每个网页的URL占用64字节 这个数据大小 跟布隆过滤器大小没啥关系。
这三个公式就是有关布隆过滤器已经推倒出的公式，下面我们来推下这个公式是如何推导出来的。
三、公式推导
讲公式，应该先知道几个关键的常量。
误判率p、布隆过滤器长度m、元素个数n、哈希函数个数k
我们再来一步一步由简单到难推导公式。
1、误差率公式推导
前提条件：就是假设每个元素哈希得到的值分布到m数组上的每一个数组节点的概率是相等的。
1) 假设布隆过滤器长度为m,元素个数n为1,哈希函数个数k也为1。那么在插入时某一数组节点没有被置为1的概率。
这个应该很好理解。
2）如果上面其它不变，而哈希函数个数变成k个，那么在插入时某一数组节点没有被置为1的概率。
好理解！
3）如果元素个数变成n个，而哈希函数个数变成k个，那么在插入时某一数组节点没有被置为1的概率。
4）从上面推导出的是: 当布隆过滤器长度为m，元素个数变成n个，哈希函数个数变成k个的时候，某一节点被置为1的概率为
到这里应该也好理解，第三步是该位置从未被置为1，那么1去减去它就是至少有一次被置为1,那么只要存在一次被置1，那么该位置的bit标示就是1，因为布隆过滤器是不能删除的。
5）这个还需要考虑到，一个元素通过hash会生成多个k，放入m数组中,所以需要这k个值都为1才会认为该该元素已经存在。所以是这样的。
上面这个公式推导在转换下就成了
思考 为什么上面这个公式的值就是最终的误差率?
因为当一个布隆过滤器中不存在的元素进来的是的时候，首先通过hash算法产生k个哈希值，分布在m数组上都为1的的概率不就是上面推导出的这个公式吗，那不就是误差吗?
因为明明是不存在的值，却有这个概率表明已经存在。
思考 给定的m和n,思考k值为多少误差会最小。
为什么k值的大小不合理会影响误差呢？
我们来思考下，一个元素最终生成k个hash值，那么会在数组m上的k个位置标记为1。
假设k为1，那么每次进来只在m上的某一个位置标记为1，这样的话如果一个新元素进来刚好hash值也在这里，而不用其它位置来判断是否为1，这个误差就会比较大。
假设k为m，那么第一个元素进来，在m上所有位置上都表为1了 ，以后只要进来一个元素就会标记为已存在。这个误差也太大了。
上面只是举了两个极端的例子，但也说明k值太大、太小都不好，它的最优值一定跟m、n存在某种关系。
至于完整公式的推导，我这里就不在写了，后面会贴一个人家怎么推导的博客。
它们之间的关系只要记住下面这个公式就可以了。
这篇博客就到这里了，后面有整理通过谷歌的guava工具 和 redis 实现布隆过滤器的示例。通过Lua脚本批量插入数据到Redis布隆过滤器
那这篇博客主要分为三部分：
1、几种方式判断当前key是否存在的性能进行比较。
2、Redis实现布隆过滤器并批量插入数据,并判断当前key值是否存在。
3、针对以上做一个总结。
一、性能对比
主要对以下方法进行性能测试比较：
1、List的 contains 方法
2、Map的 containsKey 方法
3、Google布隆过滤器 mightContain 方法
前提准备
在SpringBoot项目启动的时候，向 List集合、Map集合、Google布隆过滤器 分布存储500万条，长度为32位的String字符串。
1、演示代码
@Slf4j
@RestController
public class PerformanceController {
/**
* 存储500万条数据
*/
public static final int SIZE = 5000000;
/**
* list集合存储数据
*/
public static List<String> list = Lists.newArrayListWithCapacity(SIZE);
/**
* map集合存储数据
*/
public static Map<String, Integer> map = Maps.newHashMapWithExpectedSize(SIZE);
/**
* guava 布隆过滤器
*/
BloomFilter<String> bloomFilter = BloomFilter.create(Funnels.unencodedCharsFunnel(), SIZE);
/**
* 用来校验的集合
*/
public static List<String> exist = Lists.newArrayList();
/**
* 计时工具类
*/
public static Stopwatch stopwatch = Stopwatch.createUnstarted();
/**
* 初始化数据
*/
@PostConstruct
public void insertData() {
for (int i = 0; i < SIZE; i++) {
String data = UUID.randomUUID().toString();
data = data.replace("-", "");
//1、存入list
list.add(data);
//2、存入map
map.put(data, 0);
//3、存入本地布隆过滤器
bloomFilter.put(data);
//校验数据 相当于从这500万条数据,存储5条到这个集合中
if (i % 1000000 == 0) {
exist.add(data);
}
}
}
/**
* 1、list 查看value是否存在 执行时间
*/
@RequestMapping("/list")
public void existsList() {
//计时开始
stopwatch.start();
for (String s : exist) {
if (list.contains(s)) {
log.info("list集合存在该数据=============数据{}", s);
}
}
//计时结束
stopwatch.stop();
log.info("list集合测试，判断该元素集合中是否存在用时:{}", stopwatch.elapsed(MILLISECONDS));
stopwatch.reset();
}
/**
* 2、查看map 判断k值是否存在 执行时间
*/
@RequestMapping("/map")
public void existsMap() {
//计时开始
stopwatch.start();
for (String s : exist) {
if (map.containsKey(s)) {
log.info("map集合存在该数据=============数据{}", s);
}
}
//计时结束
stopwatch.stop();
//获取时间差
log.info("map集合测试，判断该元素集合中是否存在用时:{}", stopwatch.elapsed(MILLISECONDS));
stopwatch.reset();
}
/**
* 3、查看guava布隆过滤器 判断value值是否存在 执行时间
*/
@RequestMapping("/bloom")
public void existsBloom() {
//计时开始
stopwatch.start();
for (String s : exist) {
if (bloomFilter.mightContain(s)) {
log.info("guava布隆过滤器存在该数据=============数据{}", s);
}
}
//计时结束
stopwatch.stop();
//获取时间差
log.info("bloom集合测试，判断该元素集合中是否存在用时:{}", stopwatch.elapsed(MILLISECONDS));
stopwatch.reset();
}
}
2、测试输出结果
测试结果
这里其实对每一个校验是否存在的方法都执行了5次，如果算单次的话那么，那么在500万条数据，且每条数据长度为32位的String类型情况下，可以大概得出。
1、List的contains方法执行所需时间，大概80毫秒左右。
2、Map的containsKey方法执行所需时间，不超过1毫秒。
3、Google布隆过滤器 mightContain 方法，不超过1毫秒。
总结
Map比List效率高的原因这里就不用多说，没有想到的是它们速度都这么快。我还测了100万条数据通过list遍历key时间竟然也不超过1毫秒。这说明在实际开发过程中，如果数据
量不大的话，用哪里其实都差不多。
3、占用内存分析
从上面的执行效率来看，Google布隆过滤器 其实没什么优势可言，确实如果数据量小，完全通过上面就可以解决，不需要考虑布隆过滤器，但如果数据量巨大，千万甚至亿级
别那种，用集合肯定不行，不是说执行效率不能接受，而是占内存不能接受。
我们来算下key值为32字节的500万条条数据，存放在List集合需要占多少内存。
500万 * 32 = 16000000字节 ≈ 152MB
一个集合就占这么大内存，这点显然无法接受的。
那我们来算算布隆过滤器所需要占内存
-
设bit数组大小为m，样本数量为n，失误率为p。
-
由题可知 n = 500万，p = 3%（Google布隆过滤器默认为3%，我们也可以修改）
通过公式求得：
m ≈ 16.7MB
是不是可以接收多了。
那么Google布隆过滤器也有很大缺点
1、每次项目启动都要重新将数据存入Google布隆过滤器，消费额外的资源。
2、分布式集群部署架构中，需要在每个集群节点都要存储一份相同数据到布隆过滤器中。
3、随着数据量的加大，布隆过滤器也会占比较大的JVM内存，显然也不够合理。
那么有个更好的解决办法，就是用redis作为分布式集群的布隆过滤器。
二、Redis布隆过滤器
1、Redis服务器搭建
如果你不是用docker,那么你需要先在服务器上部署redis，然后单独安装支持redis布隆过滤器的插件rebloom。
如果你用过docker那么部署就非常简单了，只需以下命令：
docker pull redislabs/rebloom # 拉取镜像
docker run -p 6379:6379 redislabs/rebloom # 运行容器
这样就安装成功了。
2、Lua批量插入脚本
SpringBoot完整代码我这里就不粘贴出来了，文章最后我会把整个项目的github地址附上，这里就只讲下脚本的含义：
bloomFilter-inster.lua
local values = KEYS
local bloomName = ARGV[1]
local result_1
for k,v in ipairs(values) do
result_1 = redis.call('BF.ADD',bloomName,v)
end
return result_1
1）参数说明
这里的 KEYS 和 ARGV[1]都是需要我们在java代码中传入，redisTemplate有个方法
execute(RedisScript<T> script, List<K> keys, Object... args)
- script实体中中封装批量插入的lua脚本。
- keys 对于脚本的 KEYS。
- ARGV[1]对于可变参数第一个，如果输入多个可变参数，可以可以通过ARGV[2].....去获取。
2）遍历
Lua遍历脚本有两种方式一个是ipairs,另一个是pairs它们还是有差别的。这里也不做展开，下面有篇博客可以参考。
注意Lua的遍历和java中遍历还有有点区别的，我们java中是从0开始，而对于Lua脚本 k是从1开始的。
3）插入命令
BF.ADD 是往布隆过滤器中插入数据的命令，插入成功返回 true。
3、判断布隆过滤器元素是否存在Lua脚本
bloomFilter-exist.lua
local bloomName = KEYS[1]
local value = KEYS[2]
-- bloomFilter
local result_1 = redis.call('BF.EXISTS', bloomName, value)
return result_1
从这里我们可以很明显看到， KEYS[1]对于的是keys集合的get(0)位置,所以说Lua遍历是从1开始的。
BF.EXISTS 是判断布隆过滤器中是否存在该数据命令，存在返回true。
4、测试
我们来测下是否成功。
@Slf4j
@RestController
public class RedisBloomFilterController {
@Autowired
private RedisService redisService;
public static final String FILTER_NAME = "isMember";
/**
* 保存 数据到redis布隆过滤器
*/
@RequestMapping("/save-redis-bloom")
public Object saveReidsBloom() {
//数据插入布隆过滤器
List<String> exist = Lists.newArrayList("11111", "22222");
Object object = redisService.addsLuaBloomFilter(FILTER_NAME, exist);
log.info("保存是否成功====object:{}",object);
return object;
}
/**
* 查询 当前数据redis布隆过滤器是否存在
*/
@RequestMapping("/exists-redis-bloom")
public void existsReidsBloom() {
//不存在输出
if (!redisService.existsLuabloomFilter(FILTER_NAME, "00000")) {
log.info("redis布隆过滤器不存在该数据=============数据{}", "00000");
}
//存在输出
if (redisService.existsLuabloomFilter(FILTER_NAME, "11111")) {
log.info("redis布隆过滤器存在该数据=============数据{}", "11111");
}
}
}
这里先调插入接口，插入两条数据，如果返回true则说明成功，如果是同一个数据第一次插入返回成功，第二次插入就会返回false，说明重复插入相同值会失败。
然后调查询接口，这里应该两条日志都会输出，因为上面"00000"是取反的，多了个！号。
我们来看最终结果。
符合我们的预期，说明，redis布隆过滤器从部署到整合SpringBoot都是成功的。
三、总结
下面个人对整个做一个总结吧。主要是思考下，在什么环境下可以考虑用以上哪种方式来判断该元素是否存在。
1、数据量不大，且不能有误差。
那么用List或者Map都可以，虽然说List判断该元素是否存在采用的是遍历集合的方式，在性能在会比Map差，但就像上面测试一样，100万的数据，
List遍历和Map都不超过1毫秒，选谁不都一样，何必在乎那0.几毫秒的差异。
2、数据量不大，且允许有误差。
这就可以考虑用Google布隆过滤器了，尽管查询数据效率都差不多，但关键是它可以减少内存的开销，这就很关键。
3、数据量大，且不能有误差。
如果说数量大，为了提升查询元素是否存在的效率，而选用Map的话，我觉得也不对，因为如果数据量大，所占内存也会更大，所以我更推荐用
Redis的map数据结构来存储数据，这样可以大大减少JVM内存开销，而且不需要每次重启都要往集合中存储数据。
4、数据量大，且允许有误差。
如果是单体应用，数据量内存也可以接收，那么可以考虑Google布隆过滤器，因为它的查询速度会比redis要快。毕竟它不需要网络IO开销。
如果是分布式集群架构，或者数据量非常大，那么还是考虑用redis布隆过滤器吧，毕竟它不需要往每一节点都存储数据，而且不占用JVM虚拟机内存。
余弦相似度计算字符串相似率
功能需求：最近在做通过爬虫技术去爬取各大相关网站的新闻，储存到公司数据中。这里面就有一个技术点，就是如何保证你已爬取的新闻，再有相似的新闻
或者一样的新闻，那就不存储到数据库中。（因为有网站会去引用其它网站新闻，或者把其它网站新闻拿过来稍微改下内容就发布到自己网站中）。
解析方案：最终就是采用余弦相似度算法，来计算两个新闻正文的相似度。现在自己写一篇博客总结下。
一、理论知识
先推荐一篇博客，对于余弦相似度算法的理论讲的比较清晰，我们也是按照这个方式来计算相似度的。网址：相似度算法之余弦相似度。
1、说重点
我这边先把计算两个字符串的相似度理论知识再梳理一遍。
（1）首先是要明白通过向量来计算相识度公式。
（2）明白：余弦值越接近1，也就是两个向量越相似，这就叫"余弦相似性"，
余弦值越接近0，也就是两个向量越不相似，也就是这两个字符串越不相似。
2、案例理论知识
举一个例子来说明，用上述理论计算文本的相似性。为了简单起见，先从句子着手。
句子A：这只皮靴号码大了。那只号码合适。
句子B：这只皮靴号码不小，那只更合适。
怎样计算上面两句话的相似程度？
基本思路是：如果这两句话的用词越相似，它们的内容就应该越相似。因此，可以从词频入手，计算它们的相似程度。
第一步，分词。
句子A：这只/皮靴/号码/大了。那只/号码/合适。
句子B：这只/皮靴/号码/不/小，那只/更/合适。
第二步，计算词频。（也就是每个词语出现的频率）
句子A：这只1，皮靴1，号码2，大了1。那只1，合适1，不0，小0，更0
句子B：这只1，皮靴1，号码1，大了0。那只1，合适1，不1，小1，更1
第三步，写出词频向量。
句子A：(1，1，2，1，1，1，0，0，0)
句子B：(1，1，1，0，1，1，1，1，1)
第四步：运用上面的公式：计算如下：
计算结果中夹角的余弦值为0.81非常接近于1，所以，上面的句子A和句子B是基本相似的
二、实际开发案例
我把我们实际开发过程中字符串相似率计算代码分享出来。
1、pom.xml
展示一些主要jar包
<!--结合操作工具包-->
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-lang3</artifactId>
<version>3.5</version>
</dependency>
<!--bean实体注解工具包-->
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
</dependency>
<!--汉语言包，主要用于分词-->
<dependency>
<groupId>com.hankcs</groupId>
<artifactId>hanlp</artifactId>
<version>portable-1.6.5</version>
</dependency>
2、main方法
/**
* 计算两个字符串的相识度
*/
public class Similarity {
public static final String content1="今天小小和爸爸一起去摘草莓，小小说今天的草莓特别的酸，而且特别的小，关键价格还贵";
public static final String content2="今天小小和妈妈一起去草原里采草莓，今天的草莓味道特别好，而且价格还挺实惠的";
public static void main(String[] args) {
double score=CosineSimilarity.getSimilarity(content1,content2);
System.out.println("相似度："+score);
score=CosineSimilarity.getSimilarity(content1,content1);
System.out.println("相似度："+score);
}
}
先看运行结果：
通过运行结果得出：
（1）第一次比较相似率为：0.772853 （说明这两条句子还是挺相似的），第二次比较相似率为：1.0 （说明一模一样）。
（2）我们可以看到这个句子的分词效果，后面是词性。
3、Tokenizer（分词工具类）
import com.hankcs.hanlp.HanLP;
import com.hankcs.hanlp.seg.common.Term;
import java.util.List;
import java.util.stream.Collectors;
/**
* 中文分词工具类*/
public class Tokenizer {
/**
* 分词*/
public static List<Word> segment(String sentence) {
//1、 采用HanLP中文自然语言处理中标准分词进行分词
List<Term> termList = HanLP.segment(sentence);
//上面控制台打印信息就是这里输出的
System.out.println(termList.toString());
//2、重新封装到Word对象中（term.word代表分词后的词语，term.nature代表改词的词性）
return termList.stream().map(term -> new Word(term.word, term.nature.toString())).collect(Collectors.toList());
}
}
4、Word（封装分词结果）
这里面真正用到的其实就词名和权重。
import lombok.Data;
import java.util.Objects;
/**
* 封装分词结果*/
@Data
public class Word implements Comparable {
// 词名
private String name;
// 词性
private String pos;
// 权重，用于词向量分析
private Float weight;
public Word(String name, String pos) {
this.name = name;
this.pos = pos;
}
@Override
public int hashCode() {
return Objects.hashCode(this.name);
}
@Override
public boolean equals(Object obj) {
if (obj == null) {
return false;
}
if (getClass() != obj.getClass()) {
return false;
}
final Word other = (Word) obj;
return Objects.equals(this.name, other.name);
}
@Override
public String toString() {
StringBuilder str = new StringBuilder();
if (name != null) {
str.append(name);
}
if (pos != null) {
str.append("/").append(pos);
}
return str.toString();
}
@Override
public int compareTo(Object o) {
if (this == o) {
return 0;
}
if (this.name == null) {
return -1;
}
if (o == null) {
return 1;
}
if (!(o instanceof Word)) {
return 1;
}
String t = ((Word) o).getName();
if (t == null) {
return 1;
}
return this.name.compareTo(t);
}
}
5、CosineSimilarity（相似率具体实现工具类）
import com.jincou.algorithm.tokenizer.Tokenizer; import com.jincou.algorithm.tokenizer.Word;
import org.apache.commons.lang3.StringUtils; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springframework.util.CollectionUtils; import java.math.BigDecimal; import java.util.*; import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.atomic.AtomicInteger; /** * 判定方式：余弦相似度，通过计算两个向量的夹角余弦值来评估他们的相似度 余弦夹角原理： 向量a=(x1,y1),向量b=(x2,y2) similarity=a.b/|a|*|b| a.b=x1x2+y1y2 * |a|=根号[(x1)^2+(y1)^2],|b|=根号[(x2)^2+(y2)^2]*/ public class CosineSimilarity { protected static final Logger LOGGER = LoggerFactory.getLogger(CosineSimilarity.class); /** * 1、计算两个字符串的相似度 */ public static double getSimilarity(String text1, String text2) { //如果wei空，或者字符长度为0，则代表完全相同 if (StringUtils.isBlank(text1) && StringUtils.isBlank(text2)) { return 1.0; } //如果一个为0或者空，一个不为，那说明完全不相似 if (StringUtils.isBlank(text1) || StringUtils.isBlank(text2)) { return 0.0; } //这个代表如果两个字符串相等那当然返回1了（这个我为了让它也分词计算一下，所以注释掉了） // if (text1.equalsIgnoreCase(text2)) { // return 1.0; // } //第一步：进行分词 List<Word> words1 = Tokenizer.segment(text1); List<Word> words2 = Tokenizer.segment(text2); return getSimilarity(words1, words2); } /** * 2、对于计算出的相似度保留小数点后六位 */ public static double getSimilarity(List<Word> words1, List<Word> words2) { double score = getSimilarityImpl(words1, words2); //(int) (score * 1000000 + 0.5)其实代表保留小数点后六位 ,因为1034234.213强制转换不就是1034234。对于强制转换添加0.5就等于四舍五入 score = (int) (score * 1000000 + 0.5) / (double) 1000000; return score; } /** * 文本相似度计算 判定方式：余弦相似度，通过计算两个向量的夹角余弦值来评估他们的相似度 余弦夹角原理： 向量a=(x1,y1),向量b=(x2,y2) similarity=a.b/|a|*|b| a.b=x1x2+y1y2 * |a|=根号[(x1)^2+(y1)^2],|b|=根号[(x2)^2+(y2)^2] */ public static double getSimilarityImpl(List<Word> words1, List<Word> words2) { // 向每一个Word对象的属性都注入weight（权重）属性值 taggingWeightByFrequency(words1, words2); //第二步：计算词频 //通过上一步让每个Word对象都有权重值，那么在封装到map中（key是词，value是该词出现的次数（即权重）） Map<String, Float> weightMap1 = getFastSearchMap(words1); Map<String, Float> weightMap2 = getFastSearchMap(words2); //将所有词都装入set容器中 Set<Word> words = new HashSet<>(); words.addAll(words1); words.addAll(words2); AtomicFloat ab = new AtomicFloat();// a.b AtomicFloat aa = new AtomicFloat();// |a|的平方 AtomicFloat bb = new AtomicFloat();// |b|的平方 // 第三步：写出词频向量，后进行计算 words.parallelStream().forEach(word -> { //看同一词在a、b两个集合出现的此次 Float x1 = weightMap1.get(word.getName()); Float x2 = weightMap2.get(word.getName()); if (x1 != null && x2 != null) { //x1x2 float oneOfTheDimension = x1 * x2; //+ ab.addAndGet(oneOfTheDimension); } if (x1 != null) { //(x1)^2 float oneOfTheDimension = x1 * x1; //+ aa.addAndGet(oneOfTheDimension); } if (x2 != null) { //(x2)^2 float oneOfTheDimension = x2 * x2; //+ bb.addAndGet(oneOfTheDimension); } }); //|a| 对aa开方 double aaa = Math.sqrt(aa.doubleValue()); //|b| 对bb开方 double bbb = Math.sqrt(bb.doubleValue()); //使用BigDecimal保证精确计算浮点数 //double aabb = aaa * bbb; BigDecimal aabb = BigDecimal.valueOf(aaa).multiply(BigDecimal.valueOf(bbb)); //similarity=a.b/|a|*|b| //divide参数说明：aabb被除数,9表示小数点后保留9位，最后一个表示用标准的四舍五入法 double cos = BigDecimal.valueOf(ab.get()).divide(aabb, 9, BigDecimal.ROUND_HALF_UP).doubleValue(); return cos; } /** * 向每一个Word对象的属性都注入weight（权重）属性值 */ protected static void taggingWeightByFrequency(List<Word> words1, List<Word> words2) { if (words1.get(0).getWeight() != null && words2.get(0).getWeight() != null) { return; } //词频统计（key是词，value是该词在这段句子中出现的次数） Map<String, AtomicInteger> frequency1 = getFrequency(words1); Map<String, AtomicInteger> frequency2 = getFrequency(words2); //如果是DEBUG模式输出词频统计信息 // if (LOGGER.isDebugEnabled()) { // LOGGER.debug("词频统计1：\n{}", getWordsFrequencyString(frequency1)); // LOGGER.debug("词频统计2：\n{}", getWordsFrequencyString(frequency2)); // } // 标注权重（该词出现的次数） words1.parallelStream().forEach(word -> word.setWeight(frequency1.get(word.getName()).floatValue())); words2.parallelStream().forEach(word -> word.setWeight(frequency2.get(word.getName()).floatValue())); } /** * 统计词频 * @return 词频统计图 */ private static Map<String, AtomicInteger> getFrequency(List<Word> words) { Map<String, AtomicInteger> freq = new HashMap<>(); //这步很帅哦 words.forEach(i -> freq.computeIfAbsent(i.getName(), k -> new AtomicInteger()).incrementAndGet()); return freq; } /** * 输出：词频统计信息 */ private static String getWordsFrequencyString(Map<String, AtomicInteger> frequency) { StringBuilder str = new StringBuilder(); if (frequency != null && !frequency.isEmpty()) { AtomicInteger integer = new AtomicInteger(); frequency.entrySet().stream().sorted((a, b) -> b.getValue().get() - a.getValue().get()).forEach( i -> str.append("\t").append(integer.incrementAndGet()).append("、").append(i.getKey()).append("=") .append(i.getValue()).append("\n")); } str.setLength(str.length() - 1); return str.toString(); } /** * 构造权重快速搜索容器 */ protected static Map<String, Float> getFastSearchMap(List<Word> words) { if (CollectionUtils.isEmpty(words)) { return Collections.emptyMap(); } Map<String, Float> weightMap = new ConcurrentHashMap<>(words.size()); words.parallelStream().forEach(i -> { if (i.getWeight() != null) { weightMap.put(i.getName(), i.getWeight()); } else { LOGGER.error("no word weight info:" + i.getName()); } }); return weightMap; } }
这个具体实现代码因为思维很紧密所以有些地方写的比较绕，同时还手写了AtomicFloat原子类。
6、AtomicFloat原子类
import java.util.concurrent.atomic.AtomicInteger;
/**
* jdk没有AtomicFloat，写一个
*/
public class AtomicFloat extends Number {
private AtomicInteger bits;
public AtomicFloat() {
this(0f);
}
public AtomicFloat(float initialValue) {
bits = new AtomicInteger(Float.floatToIntBits(initialValue));
}
//叠加
public final float addAndGet(float delta) {
float expect;
float update;
do {
expect = get();
update = expect + delta;
} while (!this.compareAndSet(expect, update));
return update;
}
public final float getAndAdd(float delta) {
float expect;
float update;
do {
expect = get();
update = expect + delta;
} while (!this.compareAndSet(expect, update));
return expect;
}
public final float getAndDecrement() {
return getAndAdd(-1);
}
public final float decrementAndGet() {
return addAndGet(-1);
}
public final float getAndIncrement() {
return getAndAdd(1);
}
public final float incrementAndGet() {
return addAndGet(1);
}
public final float getAndSet(float newValue) {
float expect;
do {
expect = get();
} while (!this.compareAndSet(expect, newValue));
return expect;
}
public final boolean compareAndSet(float expect, float update) {
return bits.compareAndSet(Float.floatToIntBits(expect), Float.floatToIntBits(update));
}
public final void set(float newValue) {
bits.set(Float.floatToIntBits(newValue));
}
public final float get() {
return Float.intBitsToFloat(bits.get());
}
@Override
public float floatValue() {
return get();
}
@Override
public double doubleValue() {
return (double) floatValue();
}
@Override
public int intValue() {
return (int) get();
}
@Override
public long longValue() {
return (long) get();
}
@Override
public String toString() {
return Float.toString(get());
}
}
