java字符串比較

應該場景：
有一批酒店的產品名字，名字不規則，有中文有英文也會有特殊符號，現需要按這個產品的名稱將其對應到相應的房型上。這時就需要按字符進行比較。去匹配相似度最高的房型名稱之上。經過對數據的分析，最後有中文的名稱採用分詞的方法進行相似對比，英文的文本之間的相似度計算用的是餘弦距離，先哈希過。下面是計算兩個List的餘弦距離。

英文字符進行相似度比較

package com.e100.hotelcore.stringUtils;
import java.util.ArrayList;  
import java.util.HashMap;  
import java.util.Iterator;  
import java.util.Map;  
  
  
public class EnStringCompare {  
  
    public static double getSimilarity(ArrayList<String> doc1, ArrayList<String> doc2) {  
        if (doc1 != null && doc1.size() > 0 && doc2 != null && doc2.size() > 0) {  
  
            Map<Long, int[]> AlgorithmMap = new HashMap<Long, int[]>();  
  
            for (int i = 0; i < doc1.size(); i++) {  
                String d1 = doc1.get(i);  
                long sIndex = hashId(d1);  
                int[] fq = AlgorithmMap.get(sIndex);  
                if (fq != null) {  
                    fq[0]++;  
                } else {  
                    fq = new int[2];  
                    fq[0] = 1;  
                    fq[1] = 0;  
                    AlgorithmMap.put(sIndex, fq);  
                }  
            }  
  
            for (int i = 0; i < doc2.size(); i++) {  
                String d2 = doc2.get(i);  
                long sIndex = hashId(d2);  
                int[] fq = AlgorithmMap.get(sIndex);  
                if (fq != null) {  
                    fq[1]++;  
                } else {  
                    fq = new int[2];  
                    fq[0] = 0;  
                    fq[1] = 1;  
                    AlgorithmMap.put(sIndex, fq);  
                }  
  
            }  
  
            Iterator<Long> iterator = AlgorithmMap.keySet().iterator();  
            double sqdoc1 = 0;  
            double sqdoc2 = 0;  
            double denominator = 0;  
            while (iterator.hasNext()) {  
                int[] c = AlgorithmMap.get(iterator.next());  
                denominator += c[0] * c[1];  
                sqdoc1 += c[0] * c[0];  
                sqdoc2 += c[1] * c[1];  
            }  
  
            return denominator / Math.sqrt(sqdoc1 * sqdoc2);  
        } else {  
            return 0;  
        }  
    }  
  
    public static long hashId(String s) {  
        long seed = 131; // 31 131 1313 13131 131313 etc.. BKDRHash   
        long hash = 0;  
        for (int i = 0; i < s.length(); i++) {  
            hash = (hash * seed) + s.charAt(i);  
        }  
        return hash;  
    }  
  
    public static void main(String[] args) {  
        ArrayList<String> t1 = new ArrayList<String>();  
        ArrayList<String> t2 = new ArrayList<String>(); 
        ArrayList<String> t3 = new ArrayList<String>(); 
        t1.add("double");  
        t1.add("or");
        t1.add("twin");
        t1.add("superior");
       
  
        t2.add("superior"); 
        t2.add("twin"); 
        t2.add("double"); 
         
        t3.add("superior");
        t3.add("suite");
        t3.add("standard");
        t3.add("zone");
        System.out.println(getSimilarity(t1, t2));
        System.out.println(getSimilarity(t1, t3));
    }  
}

餘弦相似度計算字符串相似率

比較中文比較準確，英文區分大少寫，按空格分詞，空格的多少也會影響到相似度，所以上面的方法比較英文比較準確。

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 static void main(String[] args) {

    	String content1 = "run of the house";

    	String content2 = "1 bed presidential suite space zone";
    	String content3 = "Premier";
    	String content4 = "Superior";
    	
		double score = CosineSimilarity.getSimilarity(content1, content2);
		System.out.println("相似度：" + score);

		score = CosineSimilarity.getSimilarity(content1, content3);
		System.out.println("相似度：" + score);
		score = CosineSimilarity.getSimilarity(content1, content4);
		System.out.println("相似度：" + score);
	}

3、Tokenizer（分詞工具類）

	package com.e100.hotelcore.stringUtils;

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（封裝分詞結果）

package com.e100.hotelcore.stringUtils;
import lombok.Data;

import java.util.Objects;

/**
 * 封裝分詞結果*/
@Data
public class Word implements Comparable {
	
	 // 詞名
    private String name;
    public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = 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);
    }

	public Float getWeight() {
		return weight;
	}

	public void setWeight(Float weight) {
		this.weight = weight;
	}
	
}

5、CosineSimilarity

package com.e100.hotelcore.stringUtils;

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;
    }
}

6、AtomicFloat原子類

package com.e100.hotelcore.stringUtils;
import java.util.concurrent.atomic.AtomicInteger;

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());
    }
}

7、總結

把大致思路再捋一下：

（1）先分詞：分詞當然要按一定規則，不然隨便分那也沒有意義，那這裏通過採用HanLP中文自然語言處理中標準分詞進行分詞。

（2）統計詞頻：就統計上面詞出現的次數。

（3）通過每一個詞出現的次數，變成一個向量，通過向量公式計算相似率。

java字符串比較

英文字符進行相似度比較

餘弦相似度計算字符串相似率

1、pom.xml

2、main方法

3、Tokenizer（分詞工具類）

4、Word（封裝分詞結果）

5、CosineSimilarity

6、AtomicFloat原子類

7、總結

mybatis----標籤

mybatis----標籤，標籤

JAXB（Java API for XML Binding）java轉發爲xml對象

HttpURLConnection getContentLength值爲-1

JAX-WS 構建簡單webservice部署到tomcat上

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結