List<String> keywordList = extractKeyword(str, str.length());

public static String getHash(String str) {
    try {
        // 这里使用了SHA-256获得hash值
        MessageDigest messageDigest = MessageDigest.getInstance("SHA-256");
        return new BigInteger(1, messageDigest.digest(str.getBytes(StandardCharsets.UTF_8))).toString(2);
    } catch (Exception e) {
        e.printStackTrace();
        return str;
    }
}

public static int[] getSimHash(String str){
        // 文本长度太短时HanLp无法取得关键字
        Assert.isFalse(str.length() < 200,"text length is too short!");

        // 用数组表示特征向量,取256位,从 0 1 2 位开始表示从高位到低位
        int[] vector = new int[256];

        // 分词 基于外部依赖hankcs包
        // 取出所有关键词
        List<String> keywordList = extractKeyword(str, str.length());

        // hash
        int size = keywordList.size();
        AtomicInteger times = new AtomicInteger();
        keywordList.forEach(
                keyword->{
                    // 获取hash值
                    String keywordHash = getHash(keyword);
                    char[] Words = keywordHash.toCharArray();
                    // hash值可能少于256位，在低位以0补齐
                    if(keywordHash.length()<256){
                        char[] newWord=new char[256];
                        Arrays.fill(newWord,'0');
                        System.arraycopy(Words,0,newWord,0,Words.length);
                        Words=newWord;
                    }
                    // 加权与合并
                    for (int j = 0; j < Words.length; j++) {
                        if(Words[j]=='1'){
                            vector[j]+=(10 - (times.get() / (size / 10)));
                        }else {
                            vector[j] -= (10 - (times.get() / (size / 10)));
                        }
                    }
                    times.getAndIncrement();
                });
        for (int j = 0; j < vector.length; j++) {
            if(vector[j]<=0){
                vector[j]=0;
            }else vector[j]=1;
        }
        return vector;
    }

public static int getHammingDistance(int[] simHash1, int[] simHash2) {

    if (simHash1.length != simHash2.length) {
        // 出错，返回-1
        return -1;
    } else {
        int distance = 0;
        for (int i = 0; i < simHash1.length; i++) {
            // 每一位进行比较
            if (simHash1[i] != simHash2[i]) {
                distance++;
            }
        }
        return distance;
    }
}

public static double getSimilarity(int[] simHash1, int[] simHash2) {
    // 通过 simHash1 和 simHash2 获得它们的海明距离
    // 通过海明距离计算出相似度，并返回
    return 0.01 * (100 - (double) (getHammingDistance(simHash1, simHash2) * 100) / 128);
}

public class MainActivity {
    public static void main(String[] args) {
        run(args);
    }
    public static void run(String[] args){
        //断言匹配
        Assert.isTrue((args!=null) && (args.length==3),"need three parameters!");
        //分别输入所用及保存文件地址
        // 从输入的路径名读取对应的文件，将文件的内容转化为对应的字符串
        // 由字符串得出对应的 simHash值
        // 由 simHash值求出相似度
        double similarity = getSimilarity(getSimHash(read(args[0])), getSimHash(read(args[1])));
        System.out.println(similarity*100+"%");
        append(args[2],String.format("%.2f",similarity));
    }
}

public class IOUtils {
    public static String read(String filePath){
        return new FileReader(filePath).readString();
    }
    public static void write(String filePath,String content){
        new FileWriter(filePath).write(content);
    }
    public static void append(String filePath,String content){
        new FileWriter(filePath).append(content+"\n");
    }
}

//断言匹配确保输入的有三个路径
Assert.isTrue((args!=null) && (args.length==3),"need three parameters!");

// 文本长度太短时HanLp无法取得关键字
Assert.isFalse(str.length() < 200,"text length is too short!");

public class HammingTest {
    String file1="D:\\code\\java\\duplicate_checking_czh\\src\\main\\resources\\orig.txt";
    String file2="D:\\code\\java\\duplicate_checking_czh\\src\\main\\resources\\orig_0.8_add.txt";
    @Test
    public void getHammingDistanceTest(){
        int hammingDistance = Hamming.getHammingDistance(getSimHash(read(file1)), getSimHash(read(file2)));
        System.out.println(hammingDistance);
    }
    @Test
    public void getSimilarityTest(){
        double hammingDistance = Hamming.getSimilarity(getSimHash(read(file1)), getSimHash(read(file2)));
        System.out.println(hammingDistance);
    }
}

public class SimHashTest {
    private String filePath="D:\\code\\java\\duplicate_checking_czh\\src\\main\\resources\\orig.txt";
    @Test
    public void getHashTest(){
        String c=SimHash.getHash(IOUtils.read(filePath));
        System.out.println(c);
        System.out.println(c.length());
    }
    @Test
    public void getSimHashTest(){
        int[] simHash = SimHash.getSimHash(IOUtils.read(filePath));
    }
}