java开源分词

‘壹’ java语言中文分词程序怎么编写

现可以提供两种思路:
1.String或是StringBuffer(建议用) 中的indexOf("中华")方法，查找给定的的字符串中是否有给定词表中的词。
2.借鉴编译原理中的状态装换的思想。
先编写一个状态机，用于测试给定字符串中的词是否满足词表中的内容。

写在最后：1)建议使用第一种方法，因为在java 内部实现的查找操作其实 和你想得思路是相同的，不过他的效率会高些。
2)如果个人的编程能力比较强或是不考虑效率只是想实现专有的分词算法。可以使用第二种方法。
3)以上的两种方法都可以使用多线程来提高程序的效率。

‘贰’ java如何分词

如果你的分词规则是在一个字符串的开头和结尾加上"_"，然后两个字符一分的话，代码可以这样写：
import java.util.ArrayList;
import java.util.List;

public class Participle
{
private static final String HEAD_END_STR = "_";

private static final int PARTICIPLE_LENGTH = 2;

public static void main(String[] args)
{
String exampleWord = "计算机";

exampleWord = "_" + exampleWord + "_";

int length = exampleWord.length();
List<String> result = new ArrayList<String>();

for (int i = 0; i < length - 1; i++)
{
String str = exampleWord.substring(i, i + PARTICIPLE_LENGTH);
result.add(str);
}

System.out.println(result);
}
}
输出结果：_计, 计算, 算机, 机_

‘叁’ 怎么使用java中文分词组件word

参考如下
1、快速体验
运行项目根目录下的脚本demo-word.bat可以快速体验分词效果
用法: command [text] [input] [output]
命令command的可选值为：demo、text、file
demo
text 杨尚川是APDPlat应用级产品开发平台的作者
file d:/text.txt d:/word.txt
exit

2、对文本进行分词
移除停用词：List<Word> words = WordSegmenter.seg("杨尚川是APDPlat应用级产品开发平台的作者");
保留停用词：List<Word> words = WordSegmenter.segWithStopWords("杨尚川是APDPlat应用级产品开发平台的作者");
System.out.println(words);

输出：
移除停用词：[杨尚川, apdplat, 应用级, 产品, 开发平台, 作者]
保留停用词：[杨尚川, 是, apdplat, 应用级, 产品, 开发平台, 的, 作者]

3、对文件进行分词
String input = "d:/text.txt";
String output = "d:/word.txt";
移除停用词：WordSegmenter.seg(new File(input), new File(output));
保留停用词：WordSegmenter.segWithStopWords(new File(input), new File(output));

4、自定义配置文件
默认配置文件为类路径下的word.conf，打包在word-x.x.jar中
自定义配置文件为类路径下的word.local.conf，需要用户自己提供
如果自定义配置和默认配置相同，自定义配置会覆盖默认配置
配置文件编码为UTF-8

5、自定义用户词库
自定义用户词库为一个或多个文件夹或文件，可以使用绝对路径或相对路径
用户词库由多个词典文件组成，文件编码为UTF-8
词典文件的格式为文本文件，一行代表一个词
可以通过系统属性或配置文件的方式来指定路径，多个路径之间用逗号分隔开
类路径下的词典文件，需要在相对路径前加入前缀classpath:

指定方式有三种：
指定方式一，编程指定（高优先级）：
WordConfTools.set("dic.path", "classpath:dic.txt，d:/custom_dic");
DictionaryFactory.reload();//更改词典路径之后，重新加载词典
指定方式二，Java虚拟机启动参数（中优先级）：
java -Ddic.path=classpath:dic.txt，d:/custom_dic
指定方式三，配置文件指定（低优先级）：
使用类路径下的文件word.local.conf来指定配置信息
dic.path=classpath:dic.txt，d:/custom_dic

如未指定，则默认使用类路径下的dic.txt词典文件

6、自定义停用词词库
使用方式和自定义用户词库类似，配置项为：
stopwords.path=classpath:stopwords.txt，d:/custom_stopwords_dic

7、自动检测词库变化
可以自动检测自定义用户词库和自定义停用词词库的变化
包含类路径下的文件和文件夹、非类路径下的绝对路径和相对路径
如：
classpath:dic.txt，classpath:custom_dic_dir,
d:/dic_more.txt，d:/DIC_DIR，D:/DIC2_DIR，my_dic_dir，my_dic_file.txt

classpath:stopwords.txt，classpath:custom_stopwords_dic_dir，
d:/stopwords_more.txt，d:/STOPWORDS_DIR，d:/STOPWORDS2_DIR，stopwords_dir，remove.txt

8、显式指定分词算法
对文本进行分词时，可显式指定特定的分词算法，如：
WordSegmenter.seg("APDPlat应用级产品开发平台", SegmentationAlgorithm.BidirectionalMaximumMatching);

SegmentationAlgorithm的可选类型为：
正向最大匹配算法：MaximumMatching
逆向最大匹配算法：ReverseMaximumMatching
正向最小匹配算法：MinimumMatching
逆向最小匹配算法：ReverseMinimumMatching
双向最大匹配算法：BidirectionalMaximumMatching
双向最小匹配算法：BidirectionalMinimumMatching
双向最大最小匹配算法：
全切分算法：FullSegmentation
最少分词算法：MinimalWordCount
最大Ngram分值算法：MaxNgramScore

9、分词效果评估
运行项目根目录下的脚本evaluation.bat可以对分词效果进行评估
评估采用的测试文本有253 3709行，共2837 4490个字符
评估结果位于target/evaluation目录下：
corpus-text.txt为分好词的人工标注文本，词之间以空格分隔
test-text.txt为测试文本，是把corpus-text.txt以标点符号分隔为多行的结果
standard-text.txt为测试文本对应的人工标注文本，作为分词是否正确的标准
result-text-***.txt，***为各种分词算法名称，这是word分词结果
perfect-result-***.txt，***为各种分词算法名称，这是分词结果和人工标注标准完全一致的文本
wrong-result-***.txt，***为各种分词算法名称，这是分词结果和人工标注标准不一致的文本

‘肆’ 中文分词的常见项目

功能性能 功能描述：1.新词自动识别
对词典中不存在的词，可以自动识别，对词典的依赖较小；
2.词性输出
分词结果中带有丰富的词性；
3.动态词性输出
分词结果中的词性并非固定，会根据不同的语境，赋予不同的词性；
4.特殊词识别
比如化学、药品等行业词汇，地名、品牌、媒体名等；
5.智能歧义解决
根据内部规则，智能解决常见分词歧义问题；
6.多种编码识别
自动识别各种单一编码，并支持混合编码；
7.数词量词优化
自动识别数量词； 性能介绍：处理器：AMD Athlon II x2 250 3GHZ
单线程大于833KB/s，多线程安全。 一个php函数实现中文分词。使分词更容易，使用如下图:
Paoding（庖丁解牛分词）基于Java的开源中文分词组件，提供lucene和solr 接口，具有极 高效率和 高扩展性。引入隐喻，采用完全的面向对象设计，构思先进。
高效率：在PIII 1G内存个人机器上，1秒可准确分词 100万汉字。
采用基于 不限制个数的词典文件对文章进行有效切分，使能够将对词汇分类定义。
能够对未知的词汇进行合理解析。
仅支持Java语言。 MMSEG4J基于Java的开源中文分词组件，提供lucene和solr 接口：
1．mmseg4j 用 Chih-Hao Tsai 的 MMSeg 算法实现的中文分词器，并实现 lucene 的 analyzer 和 solr 的TokenizerFactory 以方便在Lucene和Solr中使用。
2．MMSeg 算法有两种分词方法：Simple和Complex，都是基于正向最大匹配。Complex 加了四个规则过虑。官方说：词语的正确识别率达到了 98.41%。mmseg4j 已经实现了这两种分词算法。 盘古分词是一个基于.net 平台的开源中文分词组件，提供lucene(.net 版本) 和HubbleDotNet的接口
高效：Core Duo 1.8 GHz 下单线程 分词速度为 390K 字符每秒
准确：盘古分词采用字典和统计结合的分词算法，分词准确率较高。
功能：盘古分词提供中文人名识别，简繁混合分词，多元分词，英文词根化，强制一元分词，词频优先分词，停用词过滤，英文专名提取等一系列功能。 jcseg是使用Java开发的一个中文分词器，使用流行的mmseg算法实现。
1。mmseg四种过滤算法，分词准确率达到了98.4%以上。
2。支持自定义词库。在lexicon文件夹下，可以随便添加/删除/更改词库和词库内容，并且对词库进行了分类，词库整合了《现代汉语词典》和cc-cedict辞典。
3。词条拼音和同义词支持，jcseg为所有词条标注了拼音，并且词条可以添加同义词集合，jcseg会自动将拼音和同义词加入到分词结果中。
4。中文数字和分数识别，例如："四五十个人都来了，三十分之一。"中的"四五十"和"三十分之一"，并且jcseg会自动将其转换为对应的阿拉伯数字。
5。支持中英混合词的识别。例如：B超，x射线。
6。支持基本单字单位的识别，例如2012年。
7。良好的英文支持，自动识别电子邮件，网址，分数，小数，百分数……。
8。智能圆角半角转换处理。
9。特殊字母识别：例如：Ⅰ，Ⅱ
10。特殊数字识别：例如：①，⑩
11。配对标点内容提取：例如：最好的Java书《java编程思想》，‘畅想杯黑客技术大赛’，被《,‘,“,‘标点标记的内容。
12。智能中文人名识别。中文人名识别正确率达94%以上。
jcseg佩带了jcseg.properties配置文档，使用文本编辑器就可以自主的编辑其选项，配置适合不同应用场合的分词应用。例如：最大匹配分词数，是否开启中文人名识别，是否载入词条拼音，是否载入词条同义词……。 friso是使用c语言开发的一个中文分词器，使用流行的mmseg算法实现。完全基于模块化设计和实现，可以很方便的植入到其他程序中，例如：MySQL，PHP等。并且提供了一个php中文分词扩展robbe。
1。只支持UTF-8编码。【源码无需修改就能在各种平台下编译使用，加载完20万的词条，内存占用稳定为14M。】。
2。mmseg四种过滤算法，分词准确率达到了98.41%。
3。支持自定义词库。在dict文件夹下，可以随便添加/删除/更改词库和词库词条，并且对词库进行了分类。
4。词库使用了friso的Java版本jcseg的简化词库。
5。支持中英混合词的识别。例如：c语言，IC卡。
7。很好的英文支持，电子邮件，网址，小数，分数，百分数。
8。支持阿拉伯数字基本单字单位的识别，例如2012年，5吨，120斤。
9。自动英文圆角/半角，大写/小写转换。
并且具有很高的分词速度：简单模式：3.7M/秒，复杂模式：1.8M/秒。

‘伍’ java编个中文分词的程序

importjava.io.Reader;
importjava.io.StringReader;
importorg.apache.lucene.analysis.*;
importorg.apache.lucene.analysis.cjk.CJKAnalyzer;
importorg.apache.lucene.analysis.cn.ChineseAnalyzer;
importorg.apache.lucene.analysis.standard.StandardAnalyzer;
importorg.mira.lucene.analysis.MIK_CAnalyzer;

publicclassJeAnalyzer{

publicstaticvoidtestStandard(StringtestString){
try{
Analyzeranalyzer=newStandardAnalyzer();
Readerr=newStringReader(testString);
StopFiltersf=(StopFilter)analyzer.tokenStream("",r);
System.err.println("=====standardanalyzer====");
Tokent;
while((t=sf.next())!=null){
System.out.println(t.termText());
}
}catch(Exceptione){
e.printStackTrace();
}
}

publicstaticvoidtestCJK(StringtestString){
try{
Analyzeranalyzer=newCJKAnalyzer();
Readerr=newStringReader(testString);
StopFiltersf=(StopFilter)analyzer.tokenStream("",r);
System.err.println("=====cjkanalyzer====");
Tokent;
while((t=sf.next())!=null){
System.out.println(t.termText());
}
}catch(Exceptione){
e.printStackTrace();
}
}

publicstaticvoidtestChiniese(StringtestString){
try{
Analyzeranalyzer=newChineseAnalyzer();
Readerr=newStringReader(testString);
TokenFiltertf=(TokenFilter)analyzer.tokenStream("",r);
System.err.println("=====chineseanalyzer====");
Tokent;
while((t=tf.next())!=null){
System.out.println(t.termText());
}
}catch(Exceptione){
e.printStackTrace();
}
}

publicstaticStringtransJe(StringtestString,Stringc1,Stringc2){
Stringresult="";
try{
Analyzeranalyzer=newMIK_CAnalyzer();
Readerr=newStringReader(testString);
TokenStreamts=(TokenStream)analyzer.tokenStream("",r);
Tokent;
while((t=ts.next())!=null){
result+=t.termText()+",";
}
}catch(Exceptione){
e.printStackTrace();
}
returnresult;
}

publicstaticvoidmain(String[]args){
try{
StringtestString="中文分词的方法其实不局限于中文应用，也被应用到英文处理，如手写识别，单词之间的空格就很清楚，中文分词方法可以帮助判别英文单词的边界";
System.out.println("测试的语句"+testString);
StringsResult[]=transJe(testString,"gb2312","utf-8").split(",");
for(inti=0;i<sResult.length;i++){
System.out.println(sResult[i]);
}
}catch(Exceptione){
e.printStackTrace();
}
}
}

jar包
lucene-analyzers-2.4.1.jar
lucene-core-2.4.1.jar
IKAnalyzer2.0.2OBF.jar

‘陆’ 求高手给我用java编写一个英文单词分词器

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Danci {
public static void main(String[] args){

String str = new String();
System.out.print("请输入一个英文句子：");
try{
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));//获取键盘输入
str = br.readLine();
}catch(IOException e){
e.printStackTrace();
}
String []s = str.split(" ");//转换成数组
System.out.println("你输入的句子共有单词 "+s.length+" 个");//s.length获取数组长度
}

}
//此程序只能获取一句话的单词个数.

‘柒’ Java中文分词算法

这两天正好在玩lucene,没用庖丁分词,主要是嫌它要配置环境,麻烦
下面是demo,记得要加lucene-core-2.3.2.jar和lucene-Analyzer.jar以及IKAnalyzer.jar这几个包,有问题call我

import java.io.Reader;
import java.io.StringReader;

import org.apache.lucene.analysis.Analyzer;
import org.apache.lucene.analysis.StopFilter;
import org.apache.lucene.analysis.Token;
import org.apache.lucene.analysis.TokenFilter;
import org.apache.lucene.analysis.TokenStream;
import org.apache.lucene.analysis.cjk.CJKAnalyzer;
import org.apache.lucene.analysis.cn.ChineseAnalyzer;
import org.apache.lucene.analysis.standard.StandardAnalyzer;
import org.mira.lucene.analysis.IK_CAnalyzer;

public class TestJeAnalyzer {
private static String testString1 = "冗长的代码常常是复杂性的标志，会导致代码难以测试和维护.";
public static void testStandard(String testString) throws Exception{
Analyzer analyzer = new StandardAnalyzer();
Reader r = new StringReader(testString);
StopFilter sf = (StopFilter) analyzer.tokenStream("", r);
System.err.println("=====standard analyzer====");
System.err.println("分析方法：默认没有词只有字");
Token t;
while ((t = sf.next()) != null) {
System.out.println(t.termText());
}
}
public static void testCJK(String testString) throws Exception{
Analyzer analyzer = new CJKAnalyzer();
Reader r = new StringReader(testString);
StopFilter sf = (StopFilter) analyzer.tokenStream("", r);
System.err.println("=====cjk analyzer====");
System.err.println("分析方法:交叉双字分割");
Token t;
while ((t = sf.next()) != null) {
System.out.println(t.termText());
}
}
public static void testChiniese(String testString) throws Exception{
Analyzer analyzer = new ChineseAnalyzer();
Reader r = new StringReader(testString);
TokenFilter tf = (TokenFilter) analyzer.tokenStream("", r);
System.err.println("=====chinese analyzer====");
System.err.println("分析方法:基本等同StandardAnalyzer");
Token t;
while ((t = tf.next()) != null) {
System.out.println(t.termText());
}
}

public static void testJe(String testString) throws Exception{
// Analyzer analyzer = new MIK_CAnalyzer();
Analyzer analyzer = new IK_CAnalyzer();
Reader r = new StringReader(testString);
TokenStream ts = (TokenStream)analyzer.tokenStream("", r);
System.err.println("=====je analyzer====");
System.err.println("分析方法:字典分词,正反双向搜索，具体不明");
Token t;
while ((t = ts.next()) != null) {
System.out.println(t.termText());
}
}
public static void main(String[] args) throws Exception{
// String testString = testString1;
String testString = testString1;
System.out.println(testString);

testStandard(testString);
testCJK(testString);
// testPaoding(testString);

testChiniese(testString);
testJe(testString);
}

}

‘捌’ java 怎么用lucenes进行分词

import java.io.IOException;

import org.apache.lucene.analysis.Analyzer;
import org.apache.lucene.document.Document;
import org.apache.lucene.document.Field;
import org.apache.lucene.document.StringField;
import org.apache.lucene.document.TextField;
import org.apache.lucene.index.CorruptIndexException;
import org.apache.lucene.index.DirectoryReader;
import org.apache.lucene.index.IndexReader;
import org.apache.lucene.index.IndexWriter;
import org.apache.lucene.index.IndexWriterConfig;
import org.apache.lucene.index.IndexWriterConfig.OpenMode;
import org.apache.lucene.queryparser.classic.ParseException;
import org.apache.lucene.queryparser.classic.QueryParser;
import org.apache.lucene.search.IndexSearcher;
import org.apache.lucene.search.Query;
import org.apache.lucene.search.ScoreDoc;
import org.apache.lucene.search.TopDocs;
import org.apache.lucene.store.Directory;
import org.apache.lucene.store.LockObtainFailedException;
import org.apache.lucene.store.RAMDirectory;
import org.apache.lucene.util.Version;
import org.wltea.analyzer.lucene.IKAnalyzer;

/**
* 使用IKAnalyzer进行Lucene索引和查询的演示
* 2012-3-2
*
* 以下是结合Lucene4.0 API的写法
*
*/
public class LuceneIndexAndSearchDemo {

/**
* 模拟：
* 创建一个单条记录的索引，并对其进行搜索
* @param args
*/
public static void main(String[] args){
//Lucene Document的域名
String fieldName = "text";
//检索内容
String text = "IK Analyzer是一个结合词典分词和文法分词的中文分词开源工具包。它使用了全新的正向迭代最细粒度切分算法。";

//实例化IKAnalyzer分词器
Analyzer analyzer = new IKAnalyzer(true);

Directory directory = null;
IndexWriter iwriter = null;
IndexReader ireader = null;
IndexSearcher isearcher = null;
try {
//建立内存索引对象
directory = new RAMDirectory();

//配置IndexWriterConfig
IndexWriterConfig iwConfig = new IndexWriterConfig(Version.LUCENE_40 , analyzer);
iwConfig.setOpenMode(OpenMode.CREATE_OR_APPEND);
iwriter = new IndexWriter(directory , iwConfig);
//写入索引
Document doc = new Document();
doc.add(new StringField("ID", "10000", Field.Store.YES));
doc.add(new TextField(fieldName, text, Field.Store.YES));
iwriter.addDocument(doc);
iwriter.close();

//搜索过程**********************************
//实例化搜索器
ireader = DirectoryReader.open(directory);
isearcher = new IndexSearcher(ireader);

String keyword = "中文分词工具包";
//使用QueryParser查询分析器构造Query对象
QueryParser qp = new QueryParser(Version.LUCENE_40, fieldName, analyzer);
qp.setDefaultOperator(QueryParser.AND_OPERATOR);
Query query = qp.parse(keyword);
System.out.println("Query = " + query);

//搜索相似度最高的5条记录
TopDocs topDocs = isearcher.search(query , 5);
System.out.println("命中：" + topDocs.totalHits);
//输出结果
ScoreDoc[] scoreDocs = topDocs.scoreDocs;
for (int i = 0; i < topDocs.totalHits; i++){
Document targetDoc = isearcher.doc(scoreDocs[i].doc);
System.out.println("内容：" + targetDoc.toString());
}

} catch (CorruptIndexException e) {
e.printStackTrace();
} catch (LockObtainFailedException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} catch (ParseException e) {
e.printStackTrace();
} finally{
if(ireader != null){
try {
ireader.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if(directory != null){
try {
directory.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}