精华内容
下载资源
问答
  • paoding

    2007-05-31 03:03:01
    该软件能切分许多文件,便于发送
  • paoding 分词

    2013-03-13 12:24:50
    paoding 中文分词 环境搭建 欢迎交流学习
  • paoding分词

    2017-05-22 21:15:00
    Paoding详细介绍 庖丁中文分词库是一个使用Java开发的,可结合到Lucene应用中的,为互联网、企业内部网使用的中文搜索引擎分词组件。Paoding填补了国内中文分词方面开源组件的空白,致力于此并希翼成为互联网网站...
    Paoding 详细介绍

    庖丁中文分词库是一个使用Java开发的,可结合到Lucene应用中的,为互联网、企业内部网使用的中文搜索引擎分词组件。Paoding填补了国内中文分词方面开源组件的空白,致力于此并希翼成为互联网网站首选的中文分词开源组件。 Paoding中文分词追求分词的高效率和用户良好体验。

    Paoding's Knives 中文分词具有极 高效率 和 高扩展性 。引入隐喻,采用完全的面向对象设计,构思先进。

    高效率:在PIII 1G内存个人机器上,1秒 可准确分词 100万 汉字。

    采用基于 不限制个数 的词典文件对文章进行有效切分,使能够将对词汇分类定义。

    能够对未知的词汇进行合理解析

    示例代码:

    //生成analyzer实例 
    Analyzer analyzer = new PaodingAnalyzer(properties); 
    //取得Token流 
    TokenStream stream = analyzer.tokenStream("", reader); 
    
    //重置到流的开始位置 
    stream.reset(); 
    
    //添加工具类 
    TermAttribute termAtt = (TermAttribute) stream.addAttribute(TermAttribute.class); 
    OffsetAttribute offAtt = (OffsetAttribute) stream.addAttribute(OffsetAttribute.class); 
    
    //循环打印所有分词及其位置 
    while (stream.incrementToken()) {
        System.out.println(termAtt.term() + " " + offAtt.startOffset() + " " + offAtt.endOffset()); 
    }







    参考自:开源中国 https://www.oschina.net/p/paoding



    转载于:https://www.cnblogs.com/qiaoyanlin/p/6891426.html

    展开全文
  • paoding-rose

    2017-12-06 11:00:11
    paoding-rose-jade 是一个基于Annotation的数据库访问框架,它支持以接口 + Annotation + SQL 语句的形式,依据开发者的DAO接口在运行时通过java proxy技术创建DAO实例,不需要编写DAO实际实现代码。
  • paoding rose Demo

    2014-11-20 15:34:30
    paoding rose做的一个完整的Demo 附带数据库文件
  • paoding-analysis

    2013-04-19 11:26:36
    Paoding分词器for Lucene4.2.1-Solr4.2.1,下载后自行修改src下的paoding-dic-home.properties文件,将paoding.dic.home设成词典路径
  • paoding-rose, paoding-rose 提供最好用的Java Web应用整体性框架。
  • paoding-analysis.jar

    2017-09-29 13:52:54
    paoding-analysis 庖丁分词 paoding-analysis.jar java开源中文分词jar包
  • paoding-analysis-6.2.1.jar

    2018-08-02 11:34:57
    paoding-analysis-6.2.1.jar;paoding-analysis-6.2.1.jar;
  • paoding 中文分词

    2012-02-22 10:45:08
    paoding 中文分词 项目包 可通过文本读取内容分词 运行 src/AnalyzerTest 即可
  • paoding-rose-2.0.jar

    2018-09-11 20:21:38
    paoding-rose-2.0
  • Paoding-analysis

    2009-05-25 15:05:17
    Paoding中文分词参考手册.htm paoding-analysis.jar
  • paoding-rose-demo-源码

    2021-05-31 05:57:07
    paoding-rose-demo paoding-rose 环境构建 准备工作 jdk 安装完成 gradle 安装完成 网络ok 构建项目结构工具 构建项目 生成一枚空的web项目结构如下 | |____src | | |____main | | | |____java | | | | |____org | |...
  • paoding-rose-jade DAO层使用手册 jdk 需要 1.8以上版本 功能 1. 支持jade 原生的语法 具体用法请参考 1.0 语法支持 2. 支持 条件语句封装 具体用法参考 2.0 ,[想象MyBatis 的xml一样,自动的添加 关键字] 3. 支持...
  • Paoding Analyzer

    2014-05-31 20:38:21
    je分词用lucene.中文分词庖丁解牛 一般使用 使用评估 ... 在命令行模式下执行analyzer.bat(windows)或analyzer.sh(linux)即可0 ...E:\Paoding-Analysis>analyzer.bat ? u 分词对话 多次输入或粘贴不同的文字内

    je分词用lucene.中文分词庖丁解牛


    一般使用
    使用评估
    参考资料
    下载
    开始使用
    分词策略

    效果体验
     在命令行模式下执行analyzer.bat(windows)或analyzer.sh(linux)即可0
    u       显示帮助
    E:\Paoding-Analysis>analyzer.bat ?
    u       分词对话
    多次输入或粘贴不同的文字内容,查看分词效果,如:
    E:\Paoding-Analysis>analyzer.bat
    paoding> |
     此时使用者可以在光标所在所在位置(|)输入或粘贴待分词的内容(以分号结束),按下Enter键换行,analyzer.bat便可以输出分词结果。
    paoding> 中文分词;
    1:      中文/分词/
            分词器net.paoding.analysis.analyzer.PaodingAnalyzer
            内容长度 4字符, 分 2个词
            分词耗时 0ms
    --------------------------------------------------
    分词完毕后,又会进入以上对话模式。
    键入:e或:q退出会话 (包括:符号) 。
    键入:?显示帮助(包括:符号) 。

    u       对文件进行分词
    analyzer.bat允许对指定的文件进行分词体验。文件以路径名给出可以使绝对地址、相对当前目录的地址,或以classpath:为前缀的类路径地址。示例如下:
    paoding> :-f E:/content.txt
    paoding> :-f E:/content.txt -c gbk
    paoding> :-f E:/content.txt -c gbk -m max

    开始使用
     第一步:安装词典
    将程序存储在某个目录下,这个目录称为安装目录!
     将程序拷贝到安装目录称为安装程序!
     增加、删除、修改程序称为自定制程序!

     第二步:配置词典系统环境变量
     庖丁中文分词需要一套词典,使用者安装辞典后,应该设置系统环境变量PAODING_DIC_HOME指向词典安装目录。
    在windows下,通过“我的电脑”属性之“高级”选项卡,然后在进入“环境变量”编辑区,新建环境变量,设置“变量名”为PAODING_DIC_HOME;“变量值”为E:/data/paoding/dic
    工程中使用分词,dic文件包copy到 web-info/classes 下面!


     第三步:将庖丁JAR类库导入工程
     将paoding-analysis.jar添加到工程。
     至此,便可以在应用代码中使用庖丁提供的中文分析器了。
     
     提醒:以下示例代码中的IDNEX_PATH表示索引库地址,读者运行以下代码前,应该赋与一个不重要的地址,比如/data/paoding/test_index 或E:/paoding_test_index,以免一时疏忽将重要数据丢失。

     

    Java代码  收藏代码
    1. package net.paoding.analysis;  
    2.   
    3. import net.paoding.analysis.analyzer.PaodingAnalyzer;  
    4.   
    5. import org.apache.lucene.analysis.Analyzer;  
    6. import org.apache.lucene.analysis.TokenStream;  
    7. import org.apache.lucene.document.Document;  
    8. import org.apache.lucene.document.Field;  
    9. import org.apache.lucene.index.IndexReader;  
    10. import org.apache.lucene.index.IndexWriter;  
    11. import org.apache.lucene.index.TermPositionVector;  
    12. import org.apache.lucene.queryParser.QueryParser;  
    13. import org.apache.lucene.search.Hits;  
    14. import org.apache.lucene.search.IndexSearcher;  
    15. import org.apache.lucene.search.Query;  
    16. import org.apache.lucene.search.Searcher;  
    17. import org.apache.lucene.search.highlight.Formatter;  
    18. import org.apache.lucene.search.highlight.Highlighter;  
    19. import org.apache.lucene.search.highlight.QueryScorer;  
    20. import org.apache.lucene.search.highlight.TokenGroup;  
    21. import org.apache.lucene.search.highlight.TokenSources;  
    22.   
    23. /** 
    24.  * 创建索引库 
    25.  * @author Administrator 
    26.  * 
    27.  */  
    28. public class CreateIndexLibTest {  
    29.     public static void main(String[] args) throws Exception {  
    30.           
    31.         /** 创建分词 */  
    32.         // 词典目录  
    33.         String path = "D:\\Java\\paoding_analyzer\\dic";  
    34.         // 庖丁解牛中文分词器  
    35.         Analyzer analyzer = new PaodingAnalyzer();  
    36.         // 索引书写器  
    37.         IndexWriter writer = new IndexWriter(path, analyzer, true);  
    38.         // 文档  
    39.         Document doc = new Document();  
    40.         // 字段  
    41.         Field field = new Field(  
    42.                 "content",                                  // name  
    43.                 "你好,世界!",                               // value  
    44.                 Field.Store.YES,                            // store  
    45.                 Field.Index.TOKENIZED,                      // index  
    46.                 Field.TermVector.WITH_POSITIONS_OFFSETS);   // termVector  
    47.         doc.add(field);             // 文档添加字段  
    48.         writer.addDocument(doc);    // 索引书写器添加文档  
    49.         writer.close();  
    50.         System.out.println("Indexed success!");  
    51.            
    52.         /** 搜索关键词 */  
    53.         // 索引读取器  
    54.         IndexReader reader = IndexReader.open(path);  
    55.         // 查询解析器  
    56.         QueryParser parser = new QueryParser("content", analyzer);  
    57.         Query query = parser.parse("你好");   // 解析  
    58.         // 搜索器  
    59.         Searcher searcher = new IndexSearcher(reader);  
    60.         // 命中  
    61.         Hits hits = searcher.search(query);  
    62.         if (hits.length() == 0) {  
    63.             System.out.println("hits.length=0");  
    64.         }  
    65.           
    66.         /** 高亮显示搜索的关键词 */     
    67.         Document doc2 = hits.doc(0);  
    68.         //高亮处理  
    69.         String text = doc2.get("content");  
    70.         // 条件位置载体  
    71.         TermPositionVector tpv = (TermPositionVector) reader.getTermFreqVector(// 获得条件次数载体  
    72.                         0"content");  
    73.         // 记号流  
    74.         TokenStream ts = TokenSources.getTokenStream(tpv);  
    75.         // 格式化器  
    76.         Formatter formatter = new Formatter() {  
    77.             // 高亮条件  
    78.             public String highlightTerm(String srcText, TokenGroup g) {  
    79.                 if (g.getTotalScore() <= 0) {  
    80.                     return srcText;  
    81.                 }  
    82.                 return "<b>" + srcText + "</b>";  
    83.             }  
    84.         };  
    85.         // 高亮器  
    86.         Highlighter highlighter = new Highlighter(  
    87.                 formatter,   
    88.                 new QueryScorer(query));    // 查询记录员  
    89.         // 获得最好的片段  
    90.         String result = highlighter.getBestFragments(ts, text, 5"…");  
    91.         System.out.println("result:\n\t" + result);  
    92.         reader.close();  
    93.   
    94.     }  
    95. }  

     

     

     

    Java代码  收藏代码
    1. package net.paoding.analysis;  
    2.   
    3. import java.io.StringReader;  
    4.   
    5. import junit.framework.TestCase;  
    6. import net.paoding.analysis.analyzer.PaodingAnalyzer;  
    7.   
    8. import org.apache.lucene.analysis.Token;  
    9. import org.apache.lucene.analysis.TokenStream;  
    10. /** 
    11.  * 解析器单元测试(JUnit) 
    12.  * @author Administrator 
    13.  * 
    14.  */  
    15. public class AnalyzerTest extends TestCase {  
    16.   
    17.     protected PaodingAnalyzer analyzer = new PaodingAnalyzer();  
    18.   
    19.     protected StringBuilder sb = new StringBuilder();  
    20.   
    21.     /** 
    22.      * 解剖分词 
    23.      * @param input 
    24.      * @return 
    25.      */  
    26.     protected String dissect(String input) {  
    27.         try {  
    28.             TokenStream ts = analyzer.tokenStream(""new StringReader(input));  
    29.             Token token;  
    30.             sb.setLength(0);  
    31.             while ((token = ts.next()) != null) {  
    32.                 sb.append(token.termText()).append('/');  
    33.             }  
    34.             if (sb.length() > 0) {  
    35.                 sb.setLength(sb.length() - 1);  
    36.             }  
    37.             System.out.println(sb.toString());  
    38.             return sb.toString();  
    39.         } catch (Exception e) {  
    40.             e.printStackTrace();  
    41.             return "error";  
    42.         }  
    43.     }  
    44.   
    45.     /** 
    46.      * 断言值: 预测的分词 
    47.      * 结果值:词典中的分词 
    48.      * 解剖关键字 "a",返回"",表示在词典分词策略中字母(a)不是一个分词 
    49.      * 断言结果为Green bar 表示,返回的结果与断言中的结果相同。 
    50.      */  
    51.     public void test000() {  
    52.         String result = dissect("a");  
    53.         assertEquals("", result);       // (断言值,结果值)  
    54.     }  
    55.   
    56.     /** 
    57.      * 
    58.      */  
    59.     public void test001() {  
    60.         String result = dissect("空格 a 空格");  
    61.         assertEquals("空格/空格", result);  
    62.     }  
    63.   
    64.     /** 
    65.      * 
    66.      */  
    67.     public void test002() {  
    68.         String result = dissect("A座");  
    69.         assertEquals("a座", result);  
    70.     }  
    71.       
    72.     /** 
    73.      * 
    74.      */  
    75.     public void test003() {  
    76.         String result = dissect("u盘");  
    77.         assertEquals("u盘", result);  
    78.     }  
    79.   
    80.     public void test004() {  
    81.         String result = dissect("刚买的u盘的容量");  
    82.         assertEquals("刚/买的/u盘/容量", result); // 中文分词效果  
    83.     }  
    84.       
    85.     public void test005() {  
    86.         String result = dissect("K歌之王很好听");  
    87.         assertEquals("k歌之王/很好/好听", result);  
    88.     }  
    89.     // --------------------------------------------------------------  
    90.     // 仅包含词语的句子分词策略  
    91.     // --------------------------------------------------------------  
    92.   
    93.     /** 
    94.      * 句子全由词典词语组成,但词语之间没有包含、交叉关系 
    95.      */  
    96.     public void test100() {  
    97.         String result = dissect("台北中文国际");  
    98.         assertEquals("台北/中文/国际", result);  
    99.     }  
    100.   
    101.     /** 
    102.      * 句子全由词典词语组成,但词语之间有包含关系 
    103.      */  
    104.     public void test101() {  
    105.         String result = dissect("北京首都机场");  
    106.         assertEquals("北京/首都/机场", result);  
    107.     }  
    108.   
    109.     /** 
    110.      * 句子全由词典词语组成,但词语之间有交叉关系 
    111.      */  
    112.     public void test102() {  
    113.         String result = dissect("东西已经拍卖了");  
    114.         assertEquals("东西/已经/拍卖/卖了", result);  
    115.     }  
    116.   
    117.     /** 
    118.      * 句子全由词典词语组成,但词语之间有包含、交叉等复杂关系 
    119.      */  
    120.     public void test103() {  
    121.         String result = dissect("羽毛球拍");  
    122.         assertEquals("羽毛/羽毛球/球拍", result);  
    123.     }  
    124.   
    125.     // --------------------------------------------------------------  
    126.     // noise(噪音)词汇和单字的分词策略  
    127.     // --------------------------------------------------------------  
    128.   
    129.     /** 
    130.      * 词语之间有一个noise字(的) 
    131.      */  
    132.     public void test200() {  
    133.         String result = dissect("足球的魅力");  
    134.         assertEquals("足球/魅力", result);  
    135.     }  
    136.   
    137.     /** 
    138.      * 词语之间有一个noise词语(因之) 
    139.      */  
    140.     public void test201() {  
    141.         String result = dissect("主人因之生气");  
    142.         assertEquals("主人/生气", result);  
    143.     }  
    144.   
    145.     /** 
    146.      * 词语前后分别有单字和双字的noise词语(与,有关) 
    147.      */  
    148.     public void test202() {  
    149.         String result = dissect("与谋杀有关");  
    150.         assertEquals("谋杀", result);  
    151.     }  
    152.   
    153.     /** 
    154.      * 前有noise词语(哪怕),后面跟随了连续的noise单字(了,你) 
    155.      */  
    156.     public void test203() {  
    157.         String result = dissect("哪怕朋友背叛了你");  
    158.         assertEquals("朋友/背叛", result);  
    159.     }  
    160.   
    161.     /** 
    162.      * 前后连续的noise词汇(虽然,某些),词语中有noise单字(很) 
    163.      */  
    164.     public void test204() {  
    165.         String result = dissect("虽然某些动物很凶恶");  
    166.         assertEquals("动物/凶恶", result);  
    167.     }  
    168.   
    169.     // --------------------------------------------------------------  
    170.     // 词典没有收录的字符串的分词策略  
    171.     // --------------------------------------------------------------  
    172.   
    173.       
    174.     /** 
    175.      * 仅1个字的非词汇串(东,西,南,北) 
    176.      */  
    177.     public void test300() {  
    178.         String result = dissect("东&&西&&南&&北");  
    179.         assertEquals("东/西/南/北", result);  
    180.     }  
    181.   
    182.       
    183.     /** 
    184.      * 仅两个字的非词汇串(古哥,谷歌,收狗,搜狗) 
    185.      */  
    186.     public void test302() {  
    187.         String result = dissect("古哥&&谷歌&&收狗&&搜狗");  
    188.         assertEquals("古哥/谷歌/收狗/搜狗", result);  
    189.     }  
    190.       
    191.     /** 
    192.      * 多个字的非词汇串 
    193.      */  
    194.     public void test303() {  
    195.         String result = dissect("这是鸟语:玉鱼遇欲雨");  
    196.         assertEquals("这是/鸟语/玉鱼/鱼遇/遇欲/欲雨", result);  
    197.     }  
    198.       
    199.     /** 
    200.      * 两个词语之间有一个非词汇的字(真) 
    201.      */  
    202.     public void test304() {  
    203.         String result = dissect("朋友真背叛了你了!");  
    204.         assertEquals("朋友/真/背叛", result);  
    205.     }  
    206.       
    207.     /** 
    208.      * 两个词语之间有一个非词汇的字符串(盒蟹) 
    209.      */  
    210.     public void test305() {  
    211.         String result = dissect("建设盒蟹社会");  
    212.         assertEquals("建设/盒蟹/社会", result);  
    213.     }  
    214.       
    215.     /** 
    216.      * 两个词语之间有多个非词汇的字符串(盒少蟹) 
    217.      */  
    218.     public void test306() {  
    219.         String result = dissect("建设盒少蟹社会");  
    220.         assertEquals("建设/盒少/少蟹/社会", result);  
    221.     }  
    222.   
    223.     // --------------------------------------------------------------  
    224.     // 不包含小数点的汉字数字  
    225.     // --------------------------------------------------------------  
    226.   
    227.   
    228.     /** 
    229.      * 单个汉字数字 
    230.      */  
    231.     public void test400() {  
    232.         String result = dissect("二");  
    233.         assertEquals("2", result);  
    234.     }  
    235.   
    236.     /** 
    237.      * 两个汉字数字 
    238.      */  
    239.     public void test61() {  
    240.         String result = dissect("五六");  
    241.         assertEquals("56", result);  
    242.     }  
    243.   
    244.     /** 
    245.      * 多个汉字数字 
    246.      */  
    247.     public void test62() {  
    248.         String result = dissect("三四五六");  
    249.         assertEquals("3456", result);  
    250.     }  
    251.   
    252.     /** 
    253.      * 十三 
    254.      */  
    255.     public void test63() {  
    256.         String result = dissect("十三");  
    257.         assertEquals("13", result);  
    258.     }  
    259.   
    260.     /** 
    261.      * 二千 
    262.      */  
    263.     public void test65() {  
    264.         String result = dissect("二千");  
    265.         assertEquals("2000", result);  
    266.     }  
    267.   
    268.     /** 
    269.      * 两千 
    270.      */  
    271.     public void test651() {  
    272.         String result = dissect("两千");  
    273.         assertEquals("2000", result);  
    274.     }  
    275.     /** 
    276.      * 两千 
    277.      */  
    278.     public void test6511() {  
    279.         String result = dissect("两千个");  
    280.         assertEquals("2000/个", result);  
    281.     }  
    282.   
    283.     /** 
    284.      * 2千 
    285.      */  
    286.     public void test652() {  
    287.         String result = dissect("2千");  
    288.         assertEquals("2000", result);  
    289.     }  
    290.       
    291.     /** 
    292.      *  
    293.      */  
    294.     public void test653() {  
    295.         String result = dissect("3千万");  
    296.         assertEquals("30000000", result);  
    297.     }  
    298.       
    299.     /** 
    300.      *  
    301.      */  
    302.     public void test654() {  
    303.         String result = dissect("3千万个案例");  
    304.         assertEquals("30000000/个/案例", result);  
    305.     }  
    306.   
    307.   
    308.     /** 
    309.      *  
    310.      */  
    311.     public void test64() {  
    312.         String result = dissect("千万");  
    313.         assertEquals("千万", result);  
    314.     }  
    315.   
    316.     public void test66() {  
    317.         String result = dissect("两两");  
    318.         assertEquals("两两", result);  
    319.     }  
    320.   
    321.     public void test67() {  
    322.         String result = dissect("二二");  
    323.         assertEquals("22", result);  
    324.     }  
    325.   
    326.     public void test68() {  
    327.         String result = dissect("2.2两");  
    328.         assertEquals("2.2/两", result);  
    329.     }  
    330.   
    331.     public void test69() {  
    332.         String result = dissect("二两");  
    333.         assertEquals("2/两", result);  
    334.     }  
    335.   
    336.   
    337.     public void test690() {  
    338.         String result = dissect("2两");  
    339.         assertEquals("2/两", result);  
    340.     }  
    341.   
    342.     public void test691() {  
    343.         String result = dissect("2千克");  
    344.         assertEquals("2000/克", result);  
    345.     }  
    346.   
    347.     public void test692() {  
    348.         String result = dissect("2公斤");  
    349.         assertEquals("2/公斤", result);  
    350.     }  
    351.   
    352.     public void test693() {  
    353.         String result = dissect("2世纪");  
    354.         assertEquals("2/世纪", result);  
    355.     }  
    356.   
    357.     public void test7() {  
    358.         String result = dissect("哪怕二");  
    359.         assertEquals("2", result);  
    360.     }  
    361.   
    362. }  

     

    展开全文
  • paoding rose 框架实例

    2015-08-27 15:01:34
    环境配置为maven3.1.1,tomcat6.0.41,jdk1.7,myeclipse10,mysql数据库。使用paoding rose框架,spring3,mybatis3;在dao层简单进行BaseDao设计;用VM实现页面显示。 在controller层实现了单条user数据的显示。
  • paoding-analysis-4.3.0.jar

    2018-01-03 15:49:40
    paoding-analysis-4.3.0.jar
  • Paoding Analysis摘要 Paoding's Knives 中文分词具有极 高效率 和 高扩展性 。引入隐喻,采用完全的面向对象设计,构思先进。 高效率:在PIII 1G内存个人机器上,1秒 可准确分词 100万 汉字。 ...

     

    Paoding Analysis摘要

    Paoding's Knives 中文分词具有极 高效率高扩展性 。引入隐喻,采用完全的面向对象设计,构思先进。

    高效率:在PIII 1G内存个人机器上,1秒 可准确分词 100万 汉字。

    采用基于 不限制个数 的词典文件对文章进行有效切分,使能够将对词汇分类定义。

    能够对未知的词汇进行合理解析

     

    2010-01-20 庖丁 Lucene 3.0 升级说明

    (代码已提交svn,下载包稍后稍推迟下)

    这次升级的主要目的是支持Lucene 3.0,具体改动如下:

    (1)支持Lucene 3.0,对Lucene 3.0以下的版本,请使用 http://paoding.googlecode.com/svn/branches/paoding-for-lucene-2.4/ 中的代码编译。

    (2)使用Java 5.0编译,不再支持Java 1.4,以后的新功能将会在Java 5上开发。

    (3)PaodingAnalyzer的调用接口没有改动,但在使用上需要适应Lucene 3.0的API,分词示例如下:

    //生成analyzer实例 Analyzer analyzer = new PaodingAnalyzer(properties);
    //取得Token流 TokenStream stream = analyzer.tokenStream("", reader);
    //重置到流的开始位置 stream.reset();
    //添加工具类 TermAttribute termAtt = (TermAttribute) stream.addAttribute(TermAttribute.class); OffsetAttribute offAtt = (OffsetAttribute) stream.addAttribute(OffsetAttribute.class);
    //循环打印所有分词及其位置 while (stream.incrementToken()) {
    System.out.println(termAtt.term() + " " + offAtt.startOffset() + " " + offAtt.endOffset());
    }

    具体使用方法可以参见net.paoding.analysis.analyzer.estimate以及net.paoding.analysis.examples包下面的示例代码。

     

     

    /*
         *param   分词
         */
        public List getname(String param) throws IOException{
            //分词(庖丁解牛分词法)
            Analyzer ika = new PaodingAnalyzer();
            List<String> keys = new ArrayList<String>();
                TokenStream ts = null;
               
                try{
                    Reader r = new StringReader(param);
                    ts = ika.tokenStream("TestField", r);
                    TermAttribute termAtt = (TermAttribute) ts.getAttribute(TermAttribute.class);
                    TypeAttribute typeAtt = (TypeAttribute) ts.getAttribute(TypeAttribute.class);
                    String key = null;
                    while (ts.incrementToken()) {
                        if ("word".equals(typeAtt.type())) {
                            key = termAtt.term();
                            if (key.length() >= 2) {
                                keys.add(key);
                            }
                        }
                    }
                }catch(IOException e){
                    e.printStackTrace();
                } finally {
                    if (ts != null) {
                        ts.close();
                    }
                }
               
                Map<String, Integer> keyMap = new HashMap<String, Integer>();
                Integer $ = null;
                //计算每个词出现的次数
                for (String key : keys) {
                    keyMap.put(key, ($ = keyMap.get(key)) == null ? 1 : $ + 1);
                }
                List<Map.Entry<String, Integer>> keyList = new ArrayList<Map.Entry<String, Integer>>(keyMap.entrySet());
                //进行排序
                Collections.sort(keyList, new Comparator<Map.Entry<String, Integer>>() {
                    public int compare(Map.Entry<String, Integer> o1, Map.Entry<String, Integer> o2) {
                        return (o2.getValue() - o1.getValue());
                    }
                });
                //取出关键词
                String id = null;
                String str = "";
                List list = new ArrayList();
                if(keyList.size() >0){
                    for (int i = 0;i < keyList.size(); i++) {
                         id = keyList.get(i).toString();
                         String[] strs = id.split("\\=");
                         str = strs[0];
                         list.add(strs[0]);
                         System.out.println("id:"+id);
                    }
                }
                return list;
        }

    展开全文
  • paoding-rose 了解

    2019-10-01 23:28:03
    paoding-rose 是人人开源的基于 spring 开发的 javaEE 框架。wiki 地址: https://code.google.com/archive/p/paoding-rose/ rose 的特点:后续补充 转载于:...

    paoding-rose 是人人开源的基于 spring 开发的 javaEE 框架。wiki 地址:

    https://code.google.com/archive/p/paoding-rose/

    rose 的特点:后续补充

    转载于:https://www.cnblogs.com/sonofelice/p/5386463.html

    展开全文
  • paoding-analysis6.2.1.jar

    2016-10-09 11:28:58
    修改了paoding-analysis6的部分源码,使之支持lucene6.2.1
  • paoding-analysis3.0

    2012-01-13 16:18:22
    solr3 配置 paoding 需要的人可以下载
  • paoding-rose手册

    千次阅读 2019-06-12 14:51:58
    Paoding Rose使用手册 2015年05月28日 11:07:04 winwill2012 阅读数:4374 ...
  • spring-boot-paoding-rose.zip

    2020-02-28 12:05:28
    spring boot 整合 paoding-rose的demo,需要修改 数据库相关的连接信息,
  • paoding Automatically exported from code.google.com/p/paodingPaoding Analysis摘要 Paoding's Knives 中文分词具有极 高效率 和 高扩展性 。引入隐喻,采用完全的面向对象设计,构思先进。 高效率:在PIII 1G...
  • paoding中文分词

    2008-07-08 15:23:06
    paoding是一个不错的中文分词程序,中文分词是很多NLP需要用到的,希望能对大家有点用
  • Paoding Rose使用手册

    千次阅读 2015-05-28 11:07:04
    rose项目源代码地址:http://code.google.com/p/paoding-rose/ 目标:光大rose在国内java行业的使用,降低java入门。 人人网、糯米网释出的、开源的高效Java web开发框架。在小米米聊服务端再次被验证和使用。一个从...
  • paoding-analysis3.0.jar

    热门讨论 2012-05-08 15:23:43
    从http://paoding.googlecode.com/svn/trunk/paoding-analysis下载源码并编译的paoding-analysis3.0.jar 目前(2012年5月7日)是最新源码

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 679
精华内容 271
关键字:

Paoding