中文分词引擎 java 实现 — 正向最大、逆向最大、双向最大匹配法

broccoli2 broccoli2 博客等级 墨衍会员 · AI 创作全网分发 墨衍智能分发 本文由作者通过墨衍一键同步至各平台 1分发平台 600+累计阅读 631平均单平台 已同步平台 优快云 微信公众号 微博 知乎 掘金 百家号 博客园 抖音 小红书 你的文章也可以这样分发 墨衍会员 ¥399起/年，写一次发全网 我也要 码龄10年
关注
转载 最新推荐文章于 2026-05-16 10:29:13 发布 631 阅读 AI 写同款· GEO 优化 ›
开源分词框架分析 本文将带你一起了解搜索引擎神秘面纱中的一个重要部分---中文分词技术：主要讲述中文分词的实现原理和现今比较热门的几种搜索分词java版开源框架。任何一个全文搜索引擎都必须要在对索引处理之前进行一项重要的数据预处理工作：分词。分词的作用在于让机器能够更加容易的"学会"人类语言，搜索引擎才能展示出我们真正想要找的东西。当然，如果仅仅只是针对搜索这个应用场景，对外文（英文，俄文）的分词工作似乎轻而易举， 阅读详情

正向最大匹配法

分词目标：

在词典中进行扫描，尽可能地选择与词典中最长单词匹配的词作为目标分词，然后进行下一次匹配。

算法流程：

假设词典中最长的单词为 5 个（MAX_LENGTH），那么最大匹配的起始子串字数也为 5 个

（1）扫描字典，测试读入的子串是否在字典中

（2）如果存在，则从输入中删除掉该子串，重新按照规则取子串，重复（1）

（3）如果不存在于字典中，则从右向左减少子串长度，重复（1）

分词实例：

比如说输入 “北京大学生前来应聘”，

  1. 第一轮：取子串 “北京大学生”，正向取词，如果匹配失败，每次去掉匹配字段最后面的一个字
    • “北京大学生”，扫描 5 字词典，没有匹配，子串长度减 1 变为“北京大学”
    • “北京大学”，扫描 4 字词典，有匹配，输出“北京大学”，输入变为“生前来应聘”
  2. 第二轮：取子串“生前来应聘”
    • “生前来应聘”，扫描 5 字词典，没有匹配，子串长度减 1 变为“生前来应”
    • “生前来应”，扫描 4 字词典，没有匹配，子串长度减 1 变为“生前来”
    • “生前来”，扫描 3 字词典，没有匹配，子串长度减 1 变为“生前”
    • “生前”，扫描 2 字词典，有匹配，输出“生前”，输入变为“来应聘””
  3. 第三轮：取子串“来应聘”
    • “来应聘”，扫描 3 字词典，没有匹配，子串长度减 1 变为“来应”
    • “来应”，扫描 2 字词典，没有匹配，子串长度减 1 变为“来”
    • 颗粒度最小为 1，直接输出“来”，输入变为“应聘”
  4. 第四轮：取子串“应聘”
    • “应聘”，扫描 2 字词典，有匹配，输出“应聘”，输入变为“”
  5. 输入长度为0，扫描终止


正向匹配法最终的切分结果为：”北京大学 / 生前 / 来 / 应聘”

正向匹配法实现代码如下：

public List<String> leftMax(String str) {

        List<String> results = new ArrayList<String>();
        String input = str;

        while( input.length() > 0 ) {

            String subSeq;
            // 每次取小于或者等于最大字典长度的子串进行匹配
            if( input.length() < MAX_LENGTH) 
                subSeq = input;
            else
                subSeq = input.substring(0, MAX_LENGTH);

            while( subSeq.length() > 0 ) {
                // 如果字典中含有该子串或者子串颗粒度为1，子串匹配成功
                if( dictionary.contains(subSeq) || subSeq.length() == 1) {
                    results.add(subSeq);
                    // 输入中从前向后去掉已经匹配的子串
                    input = input.substring(subSeq.length());
                    break;      // 退出循环，进行下一次匹配
                } else {
                    // 去掉匹配字段最后面的一个字
                    subSeq = subSeq.substring(0, subSeq.length() - 1);
                }   
            }

        }
        return results;
    }
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30


逆向最大匹配法

分词目标：

在词典中进行扫描，尽可能地选择与词典中最长单词匹配的词作为目标分词，然后进行下一次匹配。

在实践中，逆向最大匹配算法性能优于正向最大匹配算法。

算法流程：

假设词典中最长的单词为 5 个（MAX_LENGTH），那么最大匹配的起始子串字数也为 5 个

（1）扫描字典，测试读入的子串是否在字典中

（2）如果存在，则从输入中删除掉该子串，重新按照规则取子串，重复（1）

（3）如果不存在于字典中，则从左向右减少子串长度，重复（1）

分词实例：

比如说输入 “北京大学生前来应聘”，

  1. 第一轮：取子串 “生前来应聘”，逆向取词，如果匹配失败，每次去掉匹配字段最前面的一个字
    • “生前来应聘”，扫描 5 字词典，没有匹配，字串长度减 1 变为“前来应聘”
    • “前来应聘”，扫描 4 字词典，没有匹配，字串长度减 1 变为“来应聘”
    • “来应聘”，扫描 3 字词典，没有匹配，字串长度减 1 变为“应聘”
    • “应聘”，扫描 2 字词典，有匹配，输出“应聘”，输入变为“大学生前来”
  2. 第二轮：取子串“大学生前来”
    • “大学生前来”，扫描 5 字词典，没有匹配，字串长度减 1 变为“学生前来”
    • “学生前来”，扫描 4 字词典，没有匹配，字串长度减 1 变为“生前来”
    • “生前来”，扫描 3 字词典，没有匹配，字串长度减 1 变为“前来”
    • “前来”，扫描 2 字词典，有匹配，输出“前来”，输入变为“北京大学生”
  3. 第三轮：取子串“北京大学生”
    • “北京大学生”，扫描 5 字词典，没有匹配，字串长度减 1 变为“京大学生”
    • “京大学生”，扫描 4 字词典，没有匹配，字串长度减 1 变为“大学生”
    • “大学生”，扫描 3 字词典，有匹配，输出“大学生”，输入变为“北京”
  4. 第四轮：取子串“北京”
    • “北京”，扫描 2 字词典，有匹配，输出“北京”，输入变为“”
  5. 输入长度为0，扫描终止


逆向匹配法最终的切分结果为：”北京/ 大学生/ 前来 / 应聘”

逆向匹配法实现如下：

public List<String> rightMax(String str) {
        // 采用堆栈处理结果，后进先出
        Stack<String> store=new Stack<String>();
        List<String> results = new ArrayList<String>();
        String input = str;

        while( input.length() > 0 ) {

            String subSeq;
            // 每次取小于或者等于最大字典长度的子串进行匹配
            if( input.length() < MAX_LENGTH)
                subSeq = input;
            else 
                subSeq = input.substring(input.length() - MAX_LENGTH);

            while( subSeq.length() > 0 ) {
                // 如果字典中含有该子串或者子串颗粒度为1，子串匹配成功
                if( dictionary.contains(subSeq) || subSeq.length() == 1) {
                    store.add(subSeq);
                    // 输入中从后向前去掉已经匹配的子串
                    input = input.substring(0, input.length() - subSeq.length());
                    break;
                } else {
                    // 去掉匹配字段最前面的一个字
                    subSeq = subSeq.substring(1);
                }
            }
        }
        // 输出结果
        int size = store.size();
        for( int i = 0; i < size; i ++) {
            results.add(store.pop());
        }

        return results;
    }
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36


双向最大匹配法

分词目标：

将正向最大匹配算法和逆向最大匹配算法进行比较，从而确定正确的分词方法。

算法流程：

  1. 比较正向最大匹配和逆向最大匹配结果
  2. 如果分词数量结果不同，那么取分词数量较少的那个
  3. 如果分词数量结果相同
    • 分词结果相同，可以返回任何一个
    • 分词结果不同，返回单字数比较少的那个


分词实例：

就上例来看，

正向匹配最终切分结果为：北京大学 / 生前 / 来 / 应聘，分词数量为 4，单字数为 1

逆向匹配最终切分结果为：”北京/ 大学生/ 前来 / 应聘，分词数量为 4，单字数为 0

逆向匹配单字数少，因此返回逆向匹配的结果。

双向最大匹配法实现如下：

public List<String> segment() {
        List<String> fmm = this.leftMax();
        List<String> bmm = this.rightMax();

        // 如果分词的结果不同，返回长度较小的
        if( fmm.size() != bmm.size()) {
            if ( fmm.size() > bmm.size())
                return bmm;
            else 
                return bmm;
        }
        // 如果分词的词数相同
        else {
            int fmmSingle = 0, bmmSingle = 0;
            boolean isEqual = true;
            for( int i = 0; i < bmm.size(); i ++) {
                if( !fmm.get(i).equals(bmm.get(i))) {
                    isEqual = false;
                }
                if( fmm.get(i).length() == 1)
                    fmmSingle ++;
                if( bmm.get(i).length() == 1)
                    bmmSingle ++;
            }
            // 如果正向、逆向匹配结果完全相等，返回任意结果
            if ( isEqual ) {
                return fmm;
            // 否则，返回单字数少的匹配方式
            } else if ( fmmSingle > bmmSingle)      
                return bmm;
            else 
                return fmm;     
        }

    }
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35


载入字典和自定义添加词

这里的字典文件采用的是

http://download.youkuaiyun.com/download/yuanlulu/2380141

载入字典和自定义添加词实现如下：

private static Set<String> dictionary;  
    // 初始化字典，采用 hashset 存储
    public void getDictionary() {
        dictionary = new HashSet<String>();  
        String dicpath = "data/worddict2.txt";  
        String line = null;  

            BufferedReader br;
            try {
                // 按照 gbk 编码读入文件
                br = new BufferedReader(new InputStreamReader(new FileInputStream(dicpath),"gbk"));
                try {
                    while(((line = br.readLine())!=null)) {
                        // 按照空格切分，只读取第二部分
                        String[] str = line.split("\\s+");
                        line = str[1];
                        dictionary.add(line);   
                    }
                    br.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            } catch (UnsupportedEncodingException | FileNotFoundException e) {
                e.printStackTrace();
            }       
    }
    // 自定义添加词汇
    public void addWord(String str) {
        dictionary.add(str);    
    }
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30


歧义句测试

可以看到效果还不错，最大匹配法的效果还是取决于字典的质量。

整体代码如下：

package mm;
import java.io.BufferedReader;
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.Stack;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.InputStreamReader;
import java.io.UnsupportedEncodingException; 
public class MMSegment {

    private String request;
    private int MAX_LENGTH = 5;
    private static Set<String> dictionary;  

    public void getDictionary() {
        dictionary = new HashSet<String>();  
        String dicpath = "data/worddict2.txt";  
        String line = null;  

            BufferedReader br;
            try {
                br = new BufferedReader(new InputStreamReader(new FileInputStream(dicpath),"gbk"));
                try {
                    while(((line = br.readLine())!=null)) {
                        String[] str = line.split("\\s+");
                        line = str[1];
                        dictionary.add(line);   
                    }
                    br.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            } catch (UnsupportedEncodingException | FileNotFoundException e) {
                e.printStackTrace();
            }       
    }

    public void addWord(String str) {
        dictionary.add(str);    
    }

    public List<String> leftMax() {

        List<String> results = new ArrayList<String>();
        String input = request;

        while( input.length() > 0 ) {

            String subSeq;
            if( input.length() < MAX_LENGTH) 
                subSeq = input;
            else
                subSeq = input.substring(0, MAX_LENGTH);

            while( subSeq.length() > 0 ) {
                if( dictionary.contains(subSeq) || subSeq.length() == 1) {
                    results.add(subSeq);
                    input = input.substring(subSeq.length());
                    break;  
                } else {
                    subSeq = subSeq.substring(0, subSeq.length() - 1);
                }   
            }

        }
        return results;
    }
    public List<String> rightMax() {

        Stack<String> store=new Stack<String>();
        List<String> results = new ArrayList<String>();
        String input = request;

        while( input.length() > 0 ) {

            String subSeq;
            if( input.length() < MAX_LENGTH)
                subSeq = input;
            else 
                subSeq = input.substring(input.length() - MAX_LENGTH);

            while( subSeq.length() > 0 ) {
                if( dictionary.contains(subSeq) || subSeq.length() == 1) {
                    store.add(subSeq);
                    input = input.substring(0, input.length() - subSeq.length());
                    break;
                } else {
                    subSeq = subSeq.substring(1);
                }
            }
        }
        int size = store.size();
        for( int i = 0; i < size; i ++) {
            results.add(store.pop());
        }

        return results;
    }

    public List<String> segment() {
        List<String> fmm = this.leftMax();
        List<String> bmm = this.rightMax();

        if( fmm.size() != bmm.size()) {
            if ( fmm.size() > bmm.size())
                return bmm;
            else 
                return fmm;
        }

        else {
            int fmmSingle = 0, bmmSingle = 0;
            boolean isEqual = true;
            for( int i = 0; i < bmm.size(); i ++) {
                if( !fmm.get(i).equals(bmm.get(i))) {
                    isEqual = false;
                }
                if( fmm.get(i).length() == 1)
                    fmmSingle ++;
                if( bmm.get(i).length() == 1)
                    bmmSingle ++;
            }

            if ( isEqual ) {
                return fmm;
            } else if ( fmmSingle > bmmSingle)      
                return bmm;
            else 
                return fmm; 
        }
    }

    public void test(String str) {
        request = str;
        System.out.println(this.segment());
    }

    public static void main(String[] args) {
        MMSegment f = new MMSegment();
        f.getDictionary();
        f.test("研究生命科学");
        f.test("研究生命令本科生");
        f.test("我从马上下来");
        f.test("北京大学生喝进口红酒");
        f.test("美军中将竟公然说");
        f.test("阿美首脑会议将讨论巴以和平等问题");
        f.addWord("巴以和平");
        System.out.println("---------------------------");
        System.out.println("向字典中添加'巴以和平'后");
        f.test("阿美首脑会议将讨论巴以和平等问题");
        f.test("我不想吃东西");
    }

}

 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98
  • 99
  • 100
  • 101
  • 102
  • 103
  • 104
  • 105
  • 106
  • 107
  • 108
  • 109
  • 110
  • 111
  • 112
  • 113
  • 114
  • 115
  • 116
  • 117
  • 118
  • 119
  • 120
  • 121
  • 122
  • 123
  • 124
  • 125
  • 126
  • 127
  • 128
  • 129
  • 130
  • 131
  • 132
  • 133
  • 134
  • 135
  • 136
  • 137
  • 138
  • 139
  • 140
  • 141
  • 142
  • 143
  • 144
  • 145
  • 146
  • 147
  • 148
  • 149
  • 150
  • 151
  • 152
  • 153
  • 154
  • 155
  • 156
  • 157
  • 158
  • 159
  • 160
参考资料

[1] http://blog.youkuaiyun.com/worldwindjp/article/details/18085725

[2] http://blog.youkuaiyun.com/hu948162999/article/details/43608107

[3] http://blog.youkuaiyun.com/xiaoyeyopulei/article/details/25194021

[4] http://blog.youkuaiyun.com/chenlei0630/article/details/40710441

收录于
自然语言处理

当前文章被收录于：

自然语言处理
30 篇文章 9 人学习
订阅专栏 查看详情
标签
#正向最大匹配算法 #逆向最大匹配算法
Ruby中文分词利器Rurima：纯Ruby实现的高性能分词引擎详解 中文分词是自然语言处理（NLP）的基础技术，其核心原理是将连续的中文字符序列切分为有意义的词语单元。传统方法依赖空格分隔的英文不同，中文需要借助词典与算法实现智能切分，技术价值在于为搜索、情感分析、文本挖掘等应用提供结构化数据基础。在工程实践中，Trie树数据结构与正向最大匹配算法是实现高效分词的关键组合，前者提供快速词典查询，后者确保切分效率与准确性。应用场景广泛覆盖搜索引擎、内容审核、舆情监控等领域。本文聚焦的Rurima分词器，正是基于纯Ruby实现的现代分词解决方案，它通过优化Trie树与规则引擎， 阅读详情

相关推荐

IKAnalyzer2012中文分词器入门示例项目实战

IKAnalyzer2012是一款专为中文文本处理设计的开源分词工具，广泛应用于Java生态体系中。其核心优势在于高效稳定的分词能力、灵活的词库扩展机制以及良好的集成兼容性，适用于构建搜索引擎、实现自然语言处理（NLP）任务、进行信息抽取等多种场景。本章将引导读者了解IKAnalyzer2012的基本功能，包括其支持的分词模式、内置词典结构及初步的配置方式。同时，我们也将探讨其在实际业务中的典型应用场景，如文本预处理、搜索关键词提取、语义分析等，为后续深入学习其原理与优化策略打下坚实基础。

weixin_26805451的博客 1020

java手写简易中文分词器简易实现（算法）

java手写简易中文分词器简易实现

qq_43833453的博客 715

Java中文分词器合集与实战指南

中文分词器种类繁多，开源项目和商业产品并存。其中，HanLP、jieba、IK Analyzer、Thulac 等是目前使用最为广泛的开源中文分词器。这些分词器各有特点，适用于不同的业务场景和技术栈。以下是对主流中文分词器的简要介绍：分词器语言支持开发语言主要特点HanLP中文、英文、日文、韩文多功能、支持多种算法、可扩展性强jieba中文Python轻量级、易用、社区活跃中文Java。

weixin_28736145的博客 1167

中文分词JAVA实现（基于已知的词典txt）

这是我第一次写博客，里面有些内容可能描述不当，但是我能保证最后的程序可以在eclipse环境下运行 最近有了作业，要求写中文分词程序，主要是依据一个词典，txt文本，里面是词语，然后要求依据词典，对输入的一句话进行分词。txt的部分截图见下： 首先，要明确中文分词，需要包含的功能： 读取txt文件的数据 存储词语的容器，这里可以使用array，但是推荐使用set 具体中文分词的比对逻...

logiclj 8859

Java实现分词（正向最大匹配和逆向最大匹配）两种方法实现

Java实现分词（正向最大匹配和逆向最大匹配）两种方法实现

最大匹配算法

最大匹配算法，中文分词

Java---正向、逆向和双向最大匹配算法

完成正向、逆向和双向最大匹配算法 import java.io.*; import java.util.*; /** * 正向最大匹配 * 逆向最大匹配 * 双向最大匹配 */ public class TwoMaxMatch { private static final int MAX_LENGTH = 5; public static void main(String[] a...

qq_41982466的博客 1184

新手避坑指南：用Silvaco Atlas搞定GaN HEMT电热仿真的完整流程（附代码解读）

本文详细介绍了使用Silvaco Atlas进行GaN HEMT电热特性仿真的完整流程，特别针对新手常见问题提供避坑指南。从软件环境配置、结构定义、网格划分到物理模型设置，逐步解析关键步骤，并附有代码解读和调试技巧，帮助读者快速掌握GaN器件仿真的核心技术。

weixin_29215815的博客 597

NLP-中文分词：最大正向匹配算法

一、前言 1、什么是分词 在讲分词算法之前，先来研究一下什么是分词？ 分词是将语句按照语境，以字词为单位划分的一个过程，如下图所示： 2、为什么需要分词 那为什么需要分词呢？笔者认为主要有一下几个原因： 1、汉语的基本组成单位是字词，造成了字词成为了理解语句的基本单位（这其实是文化思维定式） 2、中文的自然语言处理技术好多事借鉴于英文的，而英文语句是最为真实单词构成语句，以空格分隔，在处理上也就就从单词角度为起点 3、人类的思维方式很容易以自我意识为主导，习惯于将自己的认知方式赋予其他生物或者机器，我们

Huoyo 2932

深度解析跨境支付之业务架构

详解跨境支付之业务架构

weixin_47493863的博客 1878

vivado实现SDI接口

XAPP1249，用来介绍UHD_SDI的实现。

Huskar_Liu的博客 7076

比较好的中文分词方案汇总推荐

2019独角兽企业重金招聘Python工程师标准>>> ...

weixin_34032827的博客 130

英伟达（NVIDIA） 显卡型号、计算能力（CC）、CUDA版本、PyTorch版本 对照表

本文全面梳理NVIDIA显卡型号与其计算能力（CC）的对应关系，并详解各代CUDA版本对不同架构的支持与弃用情况，帮助用户判断硬件兼容性。同时，结合PyTorch官方发布版本，整理其支持的CUDA版本清单，指导开发者合理选择深度学习环境配置。涵盖从Jetson嵌入式设备到H100、Blackwell等最新旗舰显卡，是一份实用的AI开发环境搭建参考指南。

寒水馨 · 轻量级技术文档 · hanshuixin.org 4889

前向、后向、双向最大匹配分词

借鉴中文的前向、后向、双向最大匹配分词

ExcaliburZY的博客 466

Oracle数据库表空间使用情况查询

在Oracle数据库中，表空间（Tablespace）是用于存储表、索引和其他数据库对象的逻辑存储单元。了解表空间的使用情况对于数据库管理员和开发人员来说是非常重要的，因为它可以帮助他们监控数据库的空间使用情况并进行容量规划。本文将介绍如何查询Oracle数据库中的表空间使用情况。通过执行以上SQL查询语句，你可以获得Oracle数据库中表空间的使用情况、文件大小和表空间大小等信息。这些信息可以帮助你了解数据库的存储情况，并进行适当的优化和容量规划。查看表空间的数据文件和表空间大小。查看表空间的使用情况。

CsmbPascal的博客 858

2026爬虫反爬终极对抗：AST解混淆+算法还原+Python复现全流程实战

本文分享了破解JS加密参数的完整流程，重点介绍AST解混淆和算法还原方法。针对电商网站常见的混淆手段（变量名混淆、控制流平坦化、字符串加密等），作者提出一套高效解决方案：通过AST解析还原可读代码，结合Chrome断点调试定位加密函数，最后用Python精准复现加密逻辑。文章包含具体的代码实现，如字符串数组还原的AST操作示例，并详细说明了从样本采集到验证测试的全流程。该方法已成功应用于10多个网站，将破解时间从一周缩短至一天，为处理JS加密参数提供了可复用的技术方案。

专注于Python爬虫开发，分享爬虫技巧、项目实战与反爬经验，使用Scrapy、BeautifulSoup等工具，解决数据抓取难题。 1523

中文分词方法

** 中文分词方法 ** 中文分词是中文文本处理的一个基础步骤，也是中文人机自然语言交互的基础模块。不同于英文的是，中文句子中没有词的界限，因此在进行中文自然语言处理时，通常需要先进行分词，分词效果将直接影响词性、句法树等模块的效果。当然分词只是一个工具，场景不同，要求也不同。在人机自然语言交互中，成熟的中文分词算法能够达到更好的自然语言处理效果，帮助计算机理解复杂的中文语言。竹间智能在构建中文自然语言对话系统时，结合语言学不断优化，训练出了一套具有较好分词效果的算法模型，为机器更好地理解中文自然语言奠定了

weixin_52652826的博客 697

RISC-V CPU设计(三)---多周期CPU的设计与实现

基本情况 本多周期CPU支持RV32I指令集(fence,ecall,ebreak除外),已通过部分指令的测试，如代码有bug，欢迎指出。 模块划分 代码将CPU划分为以下几个模块： 1.控制单元：ControlUnit 用于产生控制信号，是CPU的大脑，指挥中枢。 2.分支决策单元:BranchUnit 用于决定B型指令是否发生跳转 3.立即数单元:ImmUnit 用于从指令中解析出立即数. 4.寄存器堆:RegisterFile RISC-V的32个寄存器，其中x0寄存器恒为0，不可更改。 5.指令存储

qq_40268672的博客 5542

深入解析Word分词：Java分布式中文分词组件的核心实现原理

Word分词是一个功能强大的Java分布式中文分词组件，它提供了多种基于词典的分词算法，并利用ngram模型来消除歧义。作为一款开源的中文分词工具，Word分词能够准确识别新词、人名、地名、组织机构名等未登录词，同时支持词性标注、同义词标注、反义词标注、拼音标注等丰富功能。本文将深入解析Word分词的架构设计和核心实现原理，帮助你全面理解这款优秀的中文分词工具。 ## 📊 Word分词的核心架

gitblog_00348的博客 918

基于Simulink的电动汽车电池管理系统热管理优化仿真

电动汽车电池管理系统（Battery Management System, BMS）中的热管理是确保电池性能、安全性和寿命的关键环节。温度过高或过低都会显著影响电池的工作效率和寿命，因此需要对电池组进行精确的热管理。基于MATLAB/Simulink的仿真平台可以用于建模和优化电池热管理系统，包括热分布预测、冷却策略设计以及热平衡控制等。本项目旨在构建一个完整的电动汽车电池热管理优化仿真模型，并通过仿真验证系统的性能。

xiaoheshang_123的博客 462

汉书HE8，好用的汇编代码编写工具

汉书HE8，好用的汇编代码编写工具早期编写汇编代码所用功能强大

中文自动分词

基于最大匹配算法的分词系统实现http://blog.sciencenet.cn/blog-733228-577338.html 三种常用的python中文分词工具http://www.php.cn/python-tutorials-392625.html 基于正向最大匹配算法的分词算法  Java     https://blog.csdn.net/yin5627/article/detai...

囡囡的博客 946

jre9下载 jdk9

(Java SE Runtime Environment 9.0) 9.0u175 官方最新版 【x86|x64】

NLP学习记录 第一天 最大匹配算法

分词工具Jieba (还有很多) 例： 前向最大匹配算法：需要定义一个参数，就是最大的单词字数（maxlen），从前扫到最后，先看前五个字组成的单词有没有在词典库出现，如果没有，就看前四个，依次类推。。。。 贪心算法，每此只会选择当前最优解，只能看到当前布局，一般不能保证全局最优。DP算法可以降低算法复杂度，能看到全局（很重要）还有BEAN SEARCH。 后向最大匹配：字面意思，和前向相反。 前向后向分出来可能不一样，这里介绍‘一篇优快云：(22条消息) 中文分词引擎 java ...

carrymybaby的博客 194

SIMATIC S7-1200, S7-1500 PID 控制[手册]

SIMATIC S7-1200, S7-1500 PID 控制[手册]

lwip-2.0.3

lwip是瑞典计算机科学院(SICS)的Adam Dunkels 开发的一个小型开源的TCP/IP协议栈。实现的重点是在保持TCP协议主要功能的基础上减少对RAM 的占用。

java分词器种类_自然语言处理工具中的中文分词器介绍

中文分词是中文文本处理的一个基础步骤，也是中文人机自然语言交互的基础模块，不同于英文的是，中文句子中没有词的界限，因此在进行中文自然语言处理时，通常需要先进行分词，分词效果将直接影响词性，句法树等模块的效果，当然分词只是一个工具，场景不同，要求也不同。在人机自然语言交互中，成熟的中文分词算法能够达到更好的自然语言处理效果，帮助计算机理解复杂的中文语言。基于词典分词算法基于词典分词算法，也称为字符串...

weixin_30927801的博客 435

中文分词整理

背景 存在中文分词技术，是由于中文在基本文法上有其特殊性，具体表现在： 1．以英文为代表的拉丁语系语言相比，英文以空格作为天然的分隔符，而中文由于继承自古代汉语的传统，词语之间没有分隔。　古代汉语中除了连绵词和人名地名等，词通常就是单个汉字，所以当时没有分词书写的必要。而现代汉语中双字或多字词居多，一个字不再等同于一个词。 2．在中文里，“词”和“词组”边界模糊 现代汉语的

4224
上一篇： JS在url中传递参数时参数包含中文乱码的问题
下一篇： 余弦相似性的原理及应用
点赞 0
评论 0
书签 书签 1
broccoli2
broccoli2
博客等级 码龄10年 404粉丝 195原创
+ 关注 专栏目录 订阅专栏
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值