java 余弦相似度

Java中的余弦相似度是一种常用的相似度度量方法，用于比较两个向量之间的相似程度。在文本挖掘、推荐系统等领域广泛应用。

余弦相似度的计算公式如下：
cosine_similarity = (A·B) / (||A|| * ||B||)

其中，A和B是两个向量，(A·B)表示A和B的内积，||A||和||B||分别表示A和B的模长。

在Java中，可以使用Apache Commons Math库来计算余弦相似度。具体步骤如下：

1. 导入Apache Commons Math库：

   import org.apache.commons.math3.linear.ArrayRealVector;
   import org.apache.commons.math3.linear.RealVector;

2. 创建两个向量A和B：

   double[] arrayA = {1, 2, 3};
   double[] arrayB = {4, 5, 6};
   RealVector vectorA = new ArrayRealVector(arrayA);
   RealVector vectorB = new ArrayRealVector(arrayB);

3. 计算余弦相似度：

   double cosineSimilarity = vectorA.cosine(vectorB);

以上就是在Java中计算余弦相似度的基本步骤。

相关问题

java 余弦相似度算法

余弦相似度是一种常用的相似度计算方法，可以用于文本分类、信息检索等领域。在Java中，可以通过以下步骤实现余弦相似度算法：

1. 首先将文本转换为向量表示，可以使用词袋模型或TF-IDF模型等方法。
2. 计算两个向量的点积，即将两个向量对应位置的元素相乘并求和。
3. 计算两个向量的模长，即将向量中每个元素的平方相加并开方。
4. 将步骤2和步骤3的结果相除，即可得到两个向量的余弦相似度。

下面是Java代码示例：

import java.util.HashMap;
import java.util.Map;

public class CosineSimilarity {
    public static double cosineSimilarity(Map<String, Integer> vector1, Map<String, Integer> vector2) {
        double dotProduct = 0.0;
        double norm1 = 0.0;
        double norm2 = 0.0;
        for (String key : vector1.keySet()) {
            if (vector2.containsKey(key)) {
                dotProduct += vector1.get(key) * vector2.get(key);
            }
            norm1 += Math.pow(vector1.get(key), 2);
        }
        for (String key : vector2.keySet()) {
            norm2 += Math.pow(vector2.get(key), 2);
        }
        return dotProduct / (Math.sqrt(norm1) * Math.sqrt(norm2));
    }

    public static void main(String[] args) {
        Map<String, Integer> vector1 = new HashMap<>();
        vector1.put("apple", 1);
        vector1.put("banana", 2);
        vector1.put("orange", 3);

        Map<String, Integer> vector2 = new HashMap<>();
        vector2.put("apple", 2);
        vector2.put("banana", 1);        vector2.put("peach", 3);

        double similarity = cosineSimilarity(vector1, vector2);
        System.out.println("Cosine similarity: " + similarity);
    }
}

Java余弦相似度算法怎么写

要实现 Java 中的余弦相似度算法，需要对向量进行计算。以下是一个简单的代码实现：

import java.util.List;
import java.util.ArrayList;

public class CosineSimilarity {

    public static double cosineSimilarity(List<Double> vectorA, List<Double> vectorB) {
        double dotProduct = 0.0;
        double normA = 0.0;
        double normB = 0.0;
        for (int i = 0; i < vectorA.size(); i++) {
            dotProduct += vectorA.get(i) * vectorB.get(i);
            normA += Math.pow(vectorA.get(i), 2);
            normB += Math.pow(vectorB.get(i), 2);
        }
        return dotProduct / (Math.sqrt(normA) * Math.sqrt(normB));
    }

    public static void main(String[] args) {
        List<Double> vectorA = new ArrayList<Double>();
        List<Double> vectorB = new ArrayList<Double>();

        vectorA.add(1.0);
        vectorA.add(2.0);
        vectorA.add(3.0);

        vectorB.add(2.0);
        vectorB.add(3.0);
        vectorB.add(4.0);

        System.out.println("Cosine similarity: " + cosineSimilarity(vectorA, vectorB));
    }
}

在上面的代码中，`cosineSimilarity` 函数计算了两个向量的余弦相似度，并返回其值。