目录
[1. 基础实现](#1. 基础实现)
[2. 文本相似度应用](#2. 文本相似度应用)
[3. 推荐系统应用示例](#3. 推荐系统应用示例)
[4. 测试示例](#4. 测试示例)
[5. 性能优化版本（处理大数据）](#5. 性能优化版本（处理大数据）)
Jaccard相似度系数是一种简单而有效的集合相似度度量方法，其核心优势在于：
-
直观易懂：基于集合的基本运算
-
计算高效：时间复杂度线性
-
适用范围广：可用于各种集合数据
一、算法原理
Jaccard相似度系数（Jaccard Similarity Coefficient） 用于衡量两个集合的相似度，定义为两个集合交集大小与并集大小的比值：
J(A,B) = |A ∩ B| / |A ∪ B|取值范围：0到1之间
-
0表示两个集合没有共同元素
-
1表示两个集合完全相同
Jaccard距离：用于衡量不相似度
J_distance(A,B) = 1 - J(A,B)二、应用场景
-
文本相似度计算：词袋模型
-
推荐系统：用户兴趣相似度
-
数据挖掘：集合比较
-
生物信息学：基因序列比较
-
网络安全：恶意软件检测
Java实现示例
1. 基础实现
import java.util.HashSet;
import java.util.Set;
public class JaccardSimilarity {
/**
* 计算两个集合的Jaccard相似度
*/
public static double calculateJaccardSimilarity(Set<?> setA, Set<?> setB) {
if (setA == null || setB == null || setA.isEmpty() || setB.isEmpty()) {
return 0.0;
}
// 计算交集
Set<Object> intersection = new HashSet<>(setA);
intersection.retainAll(setB);
// 计算并集
Set<Object> union = new HashSet<>(setA);
union.addAll(setB);
// 防止除零错误
if (union.isEmpty()) {
return 0.0;
}
return (double) intersection.size() / union.size();
}
/**
* 计算Jaccard距离
*/
public static double calculateJaccardDistance(Set<?> setA, Set<?> setB) {
return 1 - calculateJaccardSimilarity(setA, setB);
}
}2. 文本相似度应用
import java.util.Arrays;
import java.util.HashSet;
import java.util.Set;
public class TextJaccardSimilarity {
/**
* 将文本转换为词集合（简单分词）
*/
public static Set<String> textToWordSet(String text) {
if (text == null || text.trim().isEmpty()) {
return new HashSet<>();
}
// 转换为小写，按空格和标点分割
String[] words = text.toLowerCase()
.replaceAll("[^a-zA-Z0-9\\s]", " ")
.split("\\s+");
return new HashSet<>(Arrays.asList(words));
}
/**
* 计算两个文本的Jaccard相似度
*/
public static double calculateTextSimilarity(String text1, String text2) {
Set<String> set1 = textToWordSet(text1);
Set<String> set2 = textToWordSet(text2);
return JaccardSimilarity.calculateJaccardSimilarity(set1, set2);
}
/**
* 带n-gram的文本相似度计算
*/
public static Set<String> getNGrams(String text, int n) {
Set<String> ngrams = new HashSet<>();
if (text == null || text.length() < n) {
return ngrams;
}
for (int i = 0; i <= text.length() - n; i++) {
ngrams.add(text.substring(i, i + n));
}
return ngrams;
}
/**
* 使用n-gram计算文本相似度
*/
public static double calculateNGramSimilarity(String text1, String text2, int n) {
Set<String> ngrams1 = getNGrams(text1, n);
Set<String> ngrams2 = getNGrams(text2, n);
return JaccardSimilarity.calculateJaccardSimilarity(ngrams1, ngrams2);
}
}3. 推荐系统应用示例
import java.util.*;
public class UserSimilarityRecommendation {
static class User {
String userId;
Set<String> itemSet; // 用户购买/喜欢的物品集合
public User(String userId, Set<String> itemSet) {
this.userId = userId;
this.itemSet = itemSet;
}
}
/**
* 计算用户相似度矩阵
*/
public static Map<String, Map<String, Double>> calculateUserSimilarityMatrix(
List<User> users) {
Map<String, Map<String, Double>> similarityMatrix = new HashMap<>();
for (int i = 0; i < users.size(); i++) {
User user1 = users.get(i);
Map<String, Double> similarities = new HashMap<>();
for (int j = 0; j < users.size(); j++) {
if (i != j) {
User user2 = users.get(j);
double similarity = JaccardSimilarity.calculateJaccardSimilarity(
user1.itemSet, user2.itemSet);
similarities.put(user2.userId, similarity);
}
}
similarityMatrix.put(user1.userId, similarities);
}
return similarityMatrix;
}
/**
* 基于用户的协同过滤推荐
*/
public static Set<String> recommendItems(User targetUser,
List<User> allUsers,
int topK) {
// 存储用户相似度
Map<String, Double> userSimilarities = new HashMap<>();
for (User user : allUsers) {
if (!user.userId.equals(targetUser.userId)) {
double similarity = JaccardSimilarity.calculateJaccardSimilarity(
targetUser.itemSet, user.itemSet);
userSimilarities.put(user.userId, similarity);
}
}
// 获取最相似的K个用户
List<String> topSimilarUsers = userSimilarities.entrySet().stream()
.sorted((e1, e2) -> Double.compare(e2.getValue(), e1.getValue()))
.limit(topK)
.map(Map.Entry::getKey)
.toList();
// 收集推荐物品
Set<String> recommendedItems = new HashSet<>();
for (String userId : topSimilarUsers) {
User similarUser = allUsers.stream()
.filter(u -> u.userId.equals(userId))
.findFirst()
.orElse(null);
if (similarUser != null) {
// 推荐目标用户没有的物品
Set<String> newItems = new HashSet<>(similarUser.itemSet);
newItems.removeAll(targetUser.itemSet);
recommendedItems.addAll(newItems);
}
}
return recommendedItems;
}
}4. 测试示例
public class JaccardExample {
public static void main(String[] args) {
// 示例1：基础集合相似度
Set<Integer> set1 = new HashSet<>(Arrays.asList(1, 2, 3, 4, 5));
Set<Integer> set2 = new HashSet<>(Arrays.asList(3, 4, 5, 6, 7));
double similarity = JaccardSimilarity.calculateJaccardSimilarity(set1, set2);
System.out.println("集合相似度: " + similarity);
System.out.println("集合距离: " + JaccardSimilarity.calculateJaccardDistance(set1, set2));
// 示例2：文本相似度
String text1 = "Java is a programming language";
String text2 = "Python is also a programming language";
double textSimilarity = TextJaccardSimilarity.calculateTextSimilarity(text1, text2);
System.out.println("\n文本相似度: " + textSimilarity);
// 示例3：n-gram相似度
double ngramSimilarity = TextJaccardSimilarity.calculateNGramSimilarity("hello", "hallo", 2);
System.out.println("2-gram相似度: " + ngramSimilarity);
// 示例4：推荐系统
User user1 = new User("U1", new HashSet<>(Arrays.asList("item1", "item2", "item3")));
User user2 = new User("U2", new HashSet<>(Arrays.asList("item2", "item3", "item4")));
User user3 = new User("U3", new HashSet<>(Arrays.asList("item1", "item3", "item5")));
List<User> users = Arrays.asList(user1, user2, user3);
Set<String> recommendations = UserSimilarityRecommendation.recommendItems(user1, users, 2);
System.out.println("\n为用户" + user1.userId + "推荐: " + recommendations);
}
}5. 性能优化版本（处理大数据）
import java.util.*;
import java.util.stream.Collectors;
public class OptimizedJaccard {
/**
* 使用MinHash近似计算Jaccard相似度（适用于大数据集）
*/
public static class MinHashJaccard {
private final int numHashes;
private final int[] hashCoefficientsA;
private final int[] hashCoefficientsB;
private final int largePrime = 2147483647; // 大素数
public MinHashJaccard(int numHashes) {
this.numHashes = numHashes;
this.hashCoefficientsA = new int[numHashes];
this.hashCoefficientsB = new int[numHashes];
Random rand = new Random(42); // 固定种子保证可重复性
for (int i = 0; i < numHashes; i++) {
hashCoefficientsA[i] = rand.nextInt(largePrime - 1) + 1;
hashCoefficientsB[i] = rand.nextInt(largePrime);
}
}
/**
* 计算MinHash签名
*/
public int[] computeMinHashSignature(Set<String> set) {
int[] minHash = new int[numHashes];
Arrays.fill(minHash, Integer.MAX_VALUE);
for (String element : set) {
int hash = element.hashCode();
for (int i = 0; i < numHashes; i++) {
int hashValue = (hashCoefficientsA[i] * hash + hashCoefficientsB[i]) % largePrime;
minHash[i] = Math.min(minHash[i], hashValue);
}
}
return minHash;
}
/**
* 通过MinHash估计Jaccard相似度
*/
public double estimateJaccardSimilarity(Set<String> setA, Set<String> setB) {
int[] signatureA = computeMinHashSignature(setA);
int[] signatureB = computeMinHashSignature(setB);
int equalCount = 0;
for (int i = 0; i < numHashes; i++) {
if (signatureA[i] == signatureB[i]) {
equalCount++;
}
}
return (double) equalCount / numHashes;
}
}
/**
* 使用位图表示集合（适用于元素有限的情况）
*/
public static class BitmapJaccard {
private final Map<String, Integer> elementIndex;
private final BitSet bitSet;
public BitmapJaccard(Set<String> allElements) {
elementIndex = new HashMap<>();
int index = 0;
for (String element : allElements) {
elementIndex.put(element, index++);
}
bitSet = new BitSet(elementIndex.size());
}
public BitSet toBitSet(Set<String> elements) {
BitSet bs = new BitSet(elementIndex.size());
for (String element : elements) {
Integer idx = elementIndex.get(element);
if (idx != null) {
bs.set(idx);
}
}
return bs;
}
public double calculateSimilarity(BitSet bs1, BitSet bs2) {
BitSet intersection = (BitSet) bs1.clone();
intersection.and(bs2);
BitSet union = (BitSet) bs1.clone();
union.or(bs2);
return (double) intersection.cardinality() / union.cardinality();
}
}
}优缺点分析
优点：
-
简单直观：原理简单，易于理解
-
计算高效：对于中等规模集合计算速度快
-
不受顺序影响：适用于无序集合
-
适用于稀疏数据：特别适合高维稀疏数据
缺点：
-
忽略元素频率：只考虑是否出现，不考虑出现次数
-
对集合大小敏感：小集合的相似度可能被夸大
-
不考虑元素权重：所有元素权重相同
-
不适用于有序数据：顺序信息丢失