免费视频淫片aa毛片_日韩高清在线亚洲专区vr_日韩大片免费观看视频播放_亚洲欧美国产精品完整版

       <!--結(jié)合操作工具包-->        <dependency>            <groupId>org.apache.commons</groupId>            <artifactId>commons-lang3</artifactId>            <version>3.5</version>        </dependency>       <!--bean實(shí)體注解工具包-->           <dependency>            <groupId>org.projectlombok</groupId>            <artifactId>lombok</artifactId>        </dependency>      <!--漢語(yǔ)言包，主要用于分詞-->        <dependency>            <groupId>com.hankcs</groupId>            <artifactId>hanlp</artifactId>            <version>portable-1.6.5</version>        </dependency>

/** * 計(jì)算兩個(gè)字符串的相識(shí)度 */public class Similarity {    public static final  String content1="今天小小和爸爸一起去摘草莓，小小說今天的草莓特別的酸，而且特別的小，關(guān)鍵價(jià)格還貴";    public static final  String content2="今天小小和媽媽一起去草原里采草莓，今天的草莓味道特別好，而且價(jià)格還挺實(shí)惠的";    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);    }    }

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中文自然語(yǔ)言處理中標(biāo)準(zhǔn)分詞進(jìn)行分詞        List<Term> termList = HanLP.segment(sentence);
        //上面控制臺(tái)打印信息就是這里輸出的        System.out.println(termList.toString());        //2、重新封裝到Word對(duì)象中（term.word代表分詞后的詞語(yǔ)，term.nature代表改詞的詞性）        return termList.stream().map(term -> new Word(term.word, term.nature.toString())).collect(Collectors.toList());    }}

import lombok.Data;import java.util.Objects;/** * 封裝分詞結(jié)果*/@Datapublic class Word implements Comparable {    // 詞名    private String name;    // 詞性    private String pos;
    // 權(quán)重，用于詞向量分析    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);    }}

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;/** * 判定方式：余弦相似度，通過計(jì)算兩個(gè)向量的夾角余弦值來評(píng)估他們的相似度 余弦夾角原理： 向量a=(x1,y1),向量b=(x2,y2) similarity=a.b/|a|*|b| a.b=x1x2+y1y2 * |a|=根號(hào)[(x1)^2+(y1)^2],|b|=根號(hào)[(x2)^2+(y2)^2]*/public class CosineSimilarity {    protected static final Logger LOGGER = LoggerFactory.getLogger(CosineSimilarity.class);    /**     * 1、計(jì)算兩個(gè)字符串的相似度     */    public static double getSimilarity(String text1, String text2) {        //如果wei空，或者字符長(zhǎng)度為0，則代表完全相同        if (StringUtils.isBlank(text1) && StringUtils.isBlank(text2)) {            return 1.0;        }        //如果一個(gè)為0或者空，一個(gè)不為，那說明完全不相似        if (StringUtils.isBlank(text1) || StringUtils.isBlank(text2)) {            return 0.0;        }        //這個(gè)代表如果兩個(gè)字符串相等那當(dāng)然返回1了（這個(gè)我為了讓它也分詞計(jì)算一下，所以注釋掉了）//        if (text1.equalsIgnoreCase(text2)) {//            return 1.0;//        }        //第一步：進(jìn)行分詞        List<Word> words1 = Tokenizer.segment(text1);        List<Word> words2 = Tokenizer.segment(text2);        return getSimilarity(words1, words2);    }    /**     * 2、對(duì)于計(jì)算出的相似度保留小數(shù)點(diǎn)后六位     */    public static double getSimilarity(List<Word> words1, List<Word> words2) {        double score = getSimilarityImpl(words1, words2);        //(int) (score * 1000000 + 0.5)其實(shí)代表保留小數(shù)點(diǎn)后六位 ,因?yàn)?034234.213強(qiáng)制轉(zhuǎn)換不就是1034234。對(duì)于強(qiáng)制轉(zhuǎn)換添加0.5就等于四舍五入        score = (int) (score * 1000000 + 0.5) / (double) 1000000;        return score;    }    /**     * 文本相似度計(jì)算 判定方式：余弦相似度，通過計(jì)算兩個(gè)向量的夾角余弦值來評(píng)估他們的相似度 余弦夾角原理： 向量a=(x1,y1),向量b=(x2,y2) similarity=a.b/|a|*|b| a.b=x1x2+y1y2     * |a|=根號(hào)[(x1)^2+(y1)^2],|b|=根號(hào)[(x2)^2+(y2)^2]     */    public static double getSimilarityImpl(List<Word> words1, List<Word> words2) {        // 向每一個(gè)Word對(duì)象的屬性都注入weight（權(quán)重）屬性值        taggingWeightByFrequency(words1, words2);        //第二步：計(jì)算詞頻        //通過上一步讓每個(gè)Word對(duì)象都有權(quán)重值，那么在封裝到map中（key是詞，value是該詞出現(xiàn)的次數(shù)（即權(quán)重））        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|的平方        // 第三步：寫出詞頻向量，后進(jìn)行計(jì)算        words.parallelStream().forEach(word -> {            //看同一詞在a、b兩個(gè)集合出現(xiàn)的此次            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| 對(duì)aa開方        double aaa = Math.sqrt(aa.doubleValue());        //|b| 對(duì)bb開方        double bbb = Math.sqrt(bb.doubleValue());        //使用BigDecimal保證精確計(jì)算浮點(diǎn)數(shù)        //double aabb = aaa * bbb;        BigDecimal aabb = BigDecimal.valueOf(aaa).multiply(BigDecimal.valueOf(bbb));        //similarity=a.b/|a|*|b|        //divide參數(shù)說明：aabb被除數(shù),9表示小數(shù)點(diǎn)后保留9位，最后一個(gè)表示用標(biāo)準(zhǔn)的四舍五入法        double cos = BigDecimal.valueOf(ab.get()).divide(aabb, 9, BigDecimal.ROUND_HALF_UP).doubleValue();        return cos;    }    /**     * 向每一個(gè)Word對(duì)象的屬性都注入weight（權(quán)重）屬性值     */    protected static void taggingWeightByFrequency(List<Word> words1, List<Word> words2) {        if (words1.get(0).getWeight() != null && words2.get(0).getWeight() != null) {            return;        }        //詞頻統(tǒng)計(jì)（key是詞，value是該詞在這段句子中出現(xiàn)的次數(shù)）        Map<String, AtomicInteger> frequency1 = getFrequency(words1);        Map<String, AtomicInteger> frequency2 = getFrequency(words2);        //如果是DEBUG模式輸出詞頻統(tǒng)計(jì)信息//        if (LOGGER.isDebugEnabled()) {//            LOGGER.debug("詞頻統(tǒng)計(jì)1：\n{}", getWordsFrequencyString(frequency1));//            LOGGER.debug("詞頻統(tǒng)計(jì)2：\n{}", getWordsFrequencyString(frequency2));//        }        // 標(biāo)注權(quán)重（該詞出現(xiàn)的次數(shù)）        words1.parallelStream().forEach(word -> word.setWeight(frequency1.get(word.getName()).floatValue()));        words2.parallelStream().forEach(word -> word.setWeight(frequency2.get(word.getName()).floatValue()));    }    /**     * 統(tǒng)計(jì)詞頻     * @return 詞頻統(tǒng)計(jì)圖     */    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;    }    /**     * 輸出：詞頻統(tǒng)計(jì)信息     */    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();    }    /**     * 構(gòu)造權(quán)重快速搜索容器     */    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;    }}

import java.util.concurrent.atomic.AtomicInteger;/** * jdk沒有AtomicFloat，寫一個(gè) */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());    }}