lucene第三步，分词

最新推荐文章于 2025-08-08 22:01:10 发布
最新推荐文章于 2025-08-08 22:01:10 发布 · 126 阅读 · 0
文章标签：

#java #设计模式

本文详细介绍了Java分词器在英文和中文分词下的比较，展示了不同分词器的特性与效果。同时，文章探讨了如何扩展自定义分词器，包括停用词分词器、同义词分词器等，提供了实现步骤与实例。最后，文章还介绍了如何打印语汇单元的详细信息和同义词过滤器的扩展。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

出自：http://blog.youkuaiyun.com/wxwzy738/article/details/8799656 的整理

1

、

2、语汇单元的结构解释


3、同义词的设计思路


4、分词器的比较和测试

[java] view plain copy
  1. packageorg.lucene.test;
  3. importjava.io.File;
  4. importjava.io.IOException;
  5. importorg.apache.lucene.analysis.Analyzer;
  6. importorg.apache.lucene.analysis.SimpleAnalyzer;
  7. importorg.apache.lucene.analysis.StopAnalyzer;
  8. importorg.apache.lucene.analysis.WhitespaceAnalyzer;
  9. importorg.apache.lucene.analysis.standard.StandardAnalyzer;
  10. importorg.apache.lucene.document.Document;
  11. importorg.apache.lucene.document.Field;
  12. importorg.apache.lucene.index.CorruptIndexException;
  13. importorg.apache.lucene.index.IndexReader;
  14. importorg.apache.lucene.index.IndexWriter;
  15. importorg.apache.lucene.index.IndexWriterConfig;
  16. importorg.apache.lucene.index.Term;
  17. importorg.apache.lucene.search.IndexSearcher;
  18. importorg.apache.lucene.search.ScoreDoc;
  19. importorg.apache.lucene.search.TermQuery;
  20. importorg.apache.lucene.search.TopDocs;
  21. importorg.apache.lucene.store.Directory;
  22. importorg.apache.lucene.store.RAMDirectory;
  23. importorg.apache.lucene.util.Version;
  24. importorg.junit.Test;
  25. importorg.lucene.util.AnalyzerUtils;
  26. importorg.lucene.util.MySameAnalyzer;
  27. importorg.lucene.util.MyStopAnalyzer;
  29. importcom.chenlb.mmseg4j.analysis.MMSegAnalyzer;
  31. publicclassTestAnalyzer{
  32. /**
  33. *几种分词器在英文分词下面的比较
  34. */
  35. @Test
  36. publicvoidtest01(){
  37. //标准分词器
  38. Analyzera1=newStandardAnalyzer(Version.LUCENE_35);
  39. //停用词分词器
  40. Analyzera2=newStopAnalyzer(Version.LUCENE_35);
  41. //简单分词器
  42. Analyzera3=newSimpleAnalyzer(Version.LUCENE_35);
  43. //空格分词器
  44. Analyzera4=newWhitespaceAnalyzer(Version.LUCENE_35);
  46. Stringtxt="thisismyhouse,Iamcomefromyunnangzhaotong,"+
  47. "Myemailisynkonghao@gmail.com,MyQQis707807876";
  49. AnalyzerUtils.displayToken(txt,a1);
  50. //[my][house][i][am][come][from][yunnang][zhaotong][my][email][ynkonghao][gmail.com][my][qq][707807876]
  51. AnalyzerUtils.displayToken(txt,a2);
  52. //[my][house][i][am][come][from][yunnang][zhaotong][my][email][ynkonghao][gmail][com][my][qq]
  53. AnalyzerUtils.displayToken(txt,a3);
  54. //[this][is][my][house][i][am][come][from][yunnang][zhaotong][my][email][is][ynkonghao][gmail][com][my][qq][is]
  55. AnalyzerUtils.displayToken(txt,a4);
  56. //[this][is][my][house,I][am][come][from][yunnang][zhaotong,My][email][is][ynkonghao@gmail.com,My][QQ][is][707807876]
  57. }
  58. /**
  59. *几种分词器在中文分词下面的比较
  60. */
  61. @Test
  62. publicvoidtest02(){
  63. //标准分词器
  64. Analyzera1=newStandardAnalyzer(Version.LUCENE_35);
  65. //停用词分词器
  66. Analyzera2=newStopAnalyzer(Version.LUCENE_35);
  67. //简单分词器
  68. Analyzera3=newSimpleAnalyzer(Version.LUCENE_35);
  69. //空格分词器
  70. Analyzera4=newWhitespaceAnalyzer(Version.LUCENE_35);
  72. Stringtxt="我来自云南昭通昭阳区师专";
  74. AnalyzerUtils.displayToken(txt,a1);
  75. //[我][来][自][云][南][昭][通][昭][阳][区][师][专]
  76. AnalyzerUtils.displayToken(txt,a2);
  77. //[我来自云南昭通昭阳区师专]
  78. AnalyzerUtils.displayToken(txt,a3);
  79. //[我来自云南昭通昭阳区师专]
  80. AnalyzerUtils.displayToken(txt,a4);
  81. //[我来自云南昭通昭阳区师专]
  82. }
  83. /**
  84. *打印分词的详细信息
  85. */
  86. @Test
  87. publicvoidtest03(){
  88. //标准分词器
  89. Analyzera1=newStandardAnalyzer(Version.LUCENE_35);
  90. //停用词分词器
  91. Analyzera2=newStopAnalyzer(Version.LUCENE_35);
  92. //简单分词器
  93. Analyzera3=newSimpleAnalyzer(Version.LUCENE_35);
  94. //空格分词器
  95. Analyzera4=newWhitespaceAnalyzer(Version.LUCENE_35);
  97. Stringtxt="howareyouthankyou";
  99. AnalyzerUtils.displayAllToken(txt,a1);
  100. AnalyzerUtils.displayAllToken(txt,a2);
  101. AnalyzerUtils.displayAllToken(txt,a3);
  102. AnalyzerUtils.displayAllToken(txt,a4);
  103. }
  104. /**
  105. *停用词的测试
  106. */
  107. @Test
  108. publicvoidtest04(){
  109. Analyzera1=newMyStopAnalyzer(newString[]{"I","you","hate"});
  110. Analyzera2=newStopAnalyzer(Version.LUCENE_35);
  111. Stringtxt="howareYouthAnk'syouIhateyou";
  112. AnalyzerUtils.displayToken(txt,a1);
  113. AnalyzerUtils.displayToken(txt,a2);
  114. }
  115. /**
  116. *中文分词测试
  117. *使用词库分词，自己可扩展词库
  118. */
  119. @Test
  120. publicvoidtest05(){
  121. //Analyzera1=newMMSegAnalyzer();//未加入该分词器自带的词库
  122. //[我][来][自][云][南][昭][通][昭][阳][区][师][专]
  123. //导入分词的词典便有词库
  124. Analyzera1=newMMSegAnalyzer(newFile("D:\\Workspaces\\03_lucene_analyzer\\mmseg4j-1.8.4\\data"));
  125. //[我][来自][云南][昭][通][昭][阳][区][师专]
  126. //可以在data文件下面的words-my.dic扩展自己的词典，比如加了昭通，分词结果为：
  127. //[我][来自][云南][昭通][昭][阳][区][师专]
  129. Stringtxt="我来自云南昭通昭阳区师专";
  130. AnalyzerUtils.displayToken(txt,a1);
  131. }
  133. /**
  134. *同义词测试
  135. *@throwsIOException
  136. *@throwsCorruptIndexException
  137. */
  138. @Test
  139. publicvoidtest06()throwsCorruptIndexException,IOException{
  140. Analyzera1=newMySameAnalyzer();
  141. Stringtxt="我来自中国云南昭通昭阳区师专";
  142. AnalyzerUtils.displayAllToken(txt,a1);
  144. Stringkeyword="俺";
  145. Directorydire=newRAMDirectory();
  146. IndexWriterindexWriter=newIndexWriter(dire,newIndexWriterConfig(Version.LUCENE_35,a1));
  147. Documentdoc=newDocument();
  148. doc.add(newField("content",txt,Field.Store.YES,Field.Index.ANALYZED));
  149. indexWriter.addDocument(doc);
  150. indexWriter.close();
  152. IndexSearchersearch=newIndexSearcher(IndexReader.open(dire));
  153. TopDocstopDoc=search.search(newTermQuery(newTerm("content",keyword)),10);
  154. ScoreDoc[]scoreDoc=topDoc.scoreDocs;
  155. for(ScoreDocscore:scoreDoc){
  156. Documentdoc1=search.doc(score.doc);
  157. System.out.println(doc1.get("content"));
  158. }
  160. }
  161. }

5、扩展自己的停用词分词器
[java] view plain copy
  1. packageorg.lucene.util;
  3. importjava.io.IOException;
  4. importjava.io.Reader;
  5. importjava.util.Set;
  6. importorg.apache.lucene.analysis.Analyzer;
  7. importorg.apache.lucene.analysis.LetterTokenizer;
  8. importorg.apache.lucene.analysis.LowerCaseFilter;
  9. importorg.apache.lucene.analysis.StopAnalyzer;
  10. importorg.apache.lucene.analysis.StopFilter;
  11. importorg.apache.lucene.analysis.TokenStream;
  12. importorg.apache.lucene.analysis.Tokenizer;
  13. importorg.apache.lucene.analysis.tokenattributes.CharTermAttribute;
  14. importorg.apache.lucene.util.Version;
  16. /**
  17. *扩展自己的停用词分词器
  18. *@authoruser
  19. *
  20. */
  21. publicclassMyStopAnalyzerextendsAnalyzer{
  23. privateSetstops;
  24. publicMyStopAnalyzer(String[]sws){
  25. //会自动将字符串数组转化为Set
  26. stops=StopFilter.makeStopSet(Version.LUCENE_35,sws,true);
  27. //把原来的停用词给加进来
  28. stops.addAll(StopAnalyzer.ENGLISH_STOP_WORDS_SET);
  29. }
  30. publicMyStopAnalyzer(){
  31. //获取原有的停用词
  32. stops.addAll(StopAnalyzer.ENGLISH_STOP_WORDS_SET);
  33. }
  35. @Override
  36. publicTokenStreamtokenStream(StringfieldName,Readerreader){
  37. System.out.println("//------------------------------------");
  38. Tokenizertokenizer=newLetterTokenizer(Version.LUCENE_35,reader);
  39. //Tokenizertokenizer=newStandardTokenizer(Version.LUCENE_35,reader);
  40. CharTermAttributecta=tokenizer.addAttribute(CharTermAttribute.class);
  41. try{
  42. while(tokenizer.incrementToken()){
  43. System.out.println(cta);
  44. }
  45. }catch(IOExceptione){
  46. e.printStackTrace();
  47. }
  48. System.out.println("------------------------------------\\");
  49. //为这个分词器设定过滤链和Tokenizer
  50. returnnewStopFilter(Version.LUCENE_35,
  51. newLowerCaseFilter(Version.LUCENE_35,
  52. newLetterTokenizer(Version.LUCENE_35,reader)),
  53. stops);
  54. }
  56. }
6、分词器的扩展，同义词分词器
[java] view plain copy
  1. packageorg.lucene.util;
  3. importjava.io.Reader;
  4. importorg.apache.lucene.analysis.Analyzer;
  5. importorg.apache.lucene.analysis.TokenStream;
  6. importcom.chenlb.mmseg4j.Dictionary;
  7. importcom.chenlb.mmseg4j.MaxWordSeg;
  8. importcom.chenlb.mmseg4j.analysis.MMSegTokenizer;
  10. /**
  11. *分词器的扩展，同义词分词器
  12. *@authoruser
  13. *
  14. */
  15. publicclassMySameAnalyzerextendsAnalyzer{
  17. @Override
  18. publicTokenStreamtokenStream(StringfieldName,Readerreader){
  19. Dictionarydic=Dictionary.getInstance("D:\\Workspaces\\03_lucene_analyzer\\mmseg4j-1.8.4\\data");
  21. returnnewMySameTokenFilter(newMMSegTokenizer(newMaxWordSeg(dic),reader));
  22. }
  24. }

7、同义词过滤器的扩展
[java] view plain copy
  1. packageorg.lucene.util;
  3. importjava.io.IOException;
  4. importjava.util.HashMap;
  5. importjava.util.Map;
  6. importjava.util.Stack;
  7. importorg.apache.lucene.analysis.TokenFilter;
  8. importorg.apache.lucene.analysis.TokenStream;
  9. importorg.apache.lucene.analysis.tokenattributes.CharTermAttribute;
  10. importorg.apache.lucene.analysis.tokenattributes.PositionIncrementAttribute;
  11. importorg.apache.lucene.util.AttributeSource;
  13. /**
  14. *同义词过滤器的扩展
  15. *@authoruser
  16. *
  17. */
  18. publicclassMySameTokenFilterextendsTokenFilter{
  20. privateCharTermAttributecta=null;
  21. privatePositionIncrementAttributepia=null;
  22. privateAttributeSource.Statecurrent=null;
  23. privateStack<String>sames=null;
  25. protectedMySameTokenFilter(TokenStreaminput){
  26. super(input);
  27. cta=this.addAttribute(CharTermAttribute.class);
  28. pia=this.addAttribute(PositionIncrementAttribute.class);
  29. sames=newStack<String>();
  30. }
  32. /**
  33. *思想如下：
  34. *其实每个同义词都要放在CharTermAttribute里面，但是如果直接cta.append("大陆");的话
  35. *那会直接把原来的词和同义词连接在同一个语汇单元里面[中国大陆]，这样是不行的
  36. *要的是这样的效果[中国][大陆]
  37. *那么就要在遇到同义词的时候把当前的状态保存一份，并把同义词的数组放入栈中，
  38. *这样在下一个语汇单元的时候判断同义词数组是否为空，不为空的话把之前的保存的一份状态
  39. *还原，然后在修改之前状态的值cta.setEmpty(),然后在把同义词的值加入cta.append("大陆")
  40. *再把位置增量设为0，pia.setPositionIncrement(0)，这样的话就表示是同义词，
  41. *接着把该同义词的语汇单元返回
  42. */
  43. @Override
  44. publicbooleanincrementToken()throwsIOException{
  45. while(sames.size()>0){
  46. //将元素出栈，并获取这个同义词
  47. Stringstr=sames.pop();
  48. //还原状态
  49. restoreState(current);
  50. cta.setEmpty();
  51. cta.append(str);
  52. //设置位置
  53. pia.setPositionIncrement(0);
  54. returntrue;
  55. }
  56. if(!input.incrementToken())returnfalse;
  57. if(getSameWords(cta.toString())){
  58. //如果有同义词将当前状态先保存
  59. current=captureState();
  60. }
  61. returntrue;
  62. }
  63. /*
  64. *使用这种方式是不行的，这种会把的结果是[中国]替换成了[大陆]
  65. *而不是变成了[中国][大陆]
  66. @Override
  67. publicbooleanincrementToken()throwsIOException{
  68. if(!input.incrementToken())returnfalse;
  69. if(cta.toString().equals("中国")){
  70. cta.setEmpty();
  71. cta.append("大陆");
  72. }
  73. returntrue;
  74. }
  75. */
  76. privatebooleangetSameWords(Stringname){
  77. Map<String,String[]>maps=newHashMap<String,String[]>();
  78. maps.put("中国",newString[]{"大陆","天朝"});
  79. maps.put("我",newString[]{"咱","俺"});
  80. String[]sws=maps.get(name);
  81. if(sws!=null){
  82. for(Strings:sws){
  83. sames.push(s);
  84. }
  85. returntrue;
  86. }
  87. returnfalse;
  88. }
  89. }

8、打印语汇单元的信息
[java] view plain copy
  1. packageorg.lucene.util;
  2. importjava.io.IOException;
  3. importjava.io.StringReader;
  4. importorg.apache.lucene.analysis.Analyzer;
  5. importorg.apache.lucene.analysis.TokenStream;
  6. importorg.apache.lucene.analysis.tokenattributes.CharTermAttribute;
  7. importorg.apache.lucene.analysis.tokenattributes.OffsetAttribute;
  8. importorg.apache.lucene.analysis.tokenattributes.PositionIncrementAttribute;
  9. importorg.apache.lucene.analysis.tokenattributes.TypeAttribute;
  11. /**
  12. *打印语汇单元的信息
  13. *@authoruser
  14. *
  15. */
  16. publicclassAnalyzerUtils{
  17. publicstaticvoiddisplayToken(Stringstr,Analyzera){
  18. TokenStreamstream=a.tokenStream("content",newStringReader(str));
  19. /*
  20. *TokenStream相当于一条流
  21. *CharTermAttribute相当于一个碗
  22. *然后把碗丢进流里面，当碗得到一个元素后，碗又会自动流到了下
  23. *一个元素进行取值
  24. *这是一种设计模式：创建一个属性，这个属性会添加流中，
  25. *随着这个TokenStream增加
  26. */
  27. CharTermAttributecta=stream.addAttribute(CharTermAttribute.class);
  28. try{
  29. while(stream.incrementToken()){
  30. System.out.print("["+cta+"]");
  31. //System.out.println(stream);
  32. //如果直接打印Stream的话,toString打印如下：
  33. //(来,startOffset=1,endOffset=2,positionIncrement=1,type=<IDEOGRAPHIC>)
  34. }
  35. System.out.println();
  36. }catch(IOExceptione){
  37. e.printStackTrace();
  38. }
  39. }
  40. /**
  41. *打印详细信息的语汇单元
  42. *@paramstr
  43. *@parama
  44. */
  45. publicstaticvoiddisplayAllToken(Stringstr,Analyzera){
  46. TokenStreamstream=a.tokenStream("content",newStringReader(str));
  47. //位置增量
  48. PositionIncrementAttributepia=stream.addAttribute(PositionIncrementAttribute.class);
  49. //偏移量
  50. OffsetAttributeoa=stream.addAttribute(OffsetAttribute.class);
  51. //词元
  52. CharTermAttributecta=stream.addAttribute(CharTermAttribute.class);
  53. //分词的类型
  54. TypeAttributeta=stream.addAttribute(TypeAttribute.class);
  55. try{
  56. while(stream.incrementToken()){
  57. System.out.print(pia.getPositionIncrement()+":");
  58. System.out.print(cta+"["+oa.startOffset()+"-"+
  59. oa.endOffset()+"-"+ta.type());
  60. System.out.println();
  61. }
  62. System.out.println();
  63. }catch(IOExceptione){
  64. e.printStackTrace();
  65. }
  66. }
  67. }

工程下载路径： http://download.youkuaiyun.com/detail/wxwzy738/5284705
bingdongguke1
关注
Lucene（6）：分词器
u013938578的博客
05-23 887
比如语气助词、副词、介词、连接词等，通常自身并无明确的意义，只有将其放入一个完整的句子中才有一定作用，如常见的“的”、“在”、“是”、“啊”等。输入关键字进行搜索，当需要让该关键字与文档域内容所包含的词进行匹配时需要对文档域内容进行分析，需要经过Analyzer分析器处理生成语汇单元（Token）。对搜索关键字进行分析和索引分析一样，使用Analyzer对搜索关键字进行分析、分词处理，使用分析后每个词语进行搜索。在对Document中的内容进行索引之前，需要使用分词器进行分词 ，分词的目的是为了搜索。
Lucene的学习第八篇——Lucene开发的Ik分词器使用
码上学习
01-04 1961
Lucene开发的Ik分词器使用 至此，我们搞明白了，文档，域，term，索引，他们的关系，以及能使用lukeall查看索引。那么恭喜你，lucene开发已经入门。但是离工作使用还是远远不够，下面继续介绍，继续使用需求场景一进行推动： 我们还是面临一个问题： 如何通过“全文” 搜到我们想要的“全文检索.txt”文档？ 我们通过lukeall查看索引，找到了原因。那就是没有正确的分词，是因为我
SpringBoot+Lucene第三篇——分词
K One
02-19 1713
Lucene的学习第三篇——分词 Lucene创建索引—分词 分词主要介绍这几个问题  分词是什么？  分词干嘛？  分词怎么分？ 疑问： 看完这篇，带着疑问看下一篇 下一篇的代码中，能找到aaabbb.txt文档，但是我们不能找到aaabbb文档，好像说明fileName只能进行了精确匹配。但是不能找到“汪浩斌.txt”文档， 说明不是精确匹配，而是在索引库中“全文检索.txt”或者“...
Lucene.Net+盘古分词器(详细介绍)
我是菜鸟
10-11 911
Lucene.net是Lucene的.net移植版本，是一个开源的全文检索引擎开发包，即它不是一个完整的全文检索引擎，而是一个全文检索引擎的架构，提供了完整的查询引擎和索引引擎。开发人员可以基于Lucene.net实现全文检索的功能。
lucene分词器比较
无
06-23 382
摘要：本文介绍了14种文本分析器（Analyzer）的功能特点，主要包括：StopAnalyzer（停用词过滤及大小写转换）、StandardAnalyzer（多语言支持）、SimpleAnalyzer（西文基础处理）等Lucene内置分析器，以及CJKAnalyzer、IKAnalyzer等中文分词器。重点说明了中文处理方案如ICTCLAS4J（基于中科院算法）、PaodingAnalysis（高效分词）和MMSeg4J（最大匹配算法）等第三方工具的特性。
Lucene搜索引擎-分词器
supermao1013的专栏
10-27 3958
文章目录Lucene初识适用场景特性Lucene初识分词器正向索引反向索引Lucene自带分词器项目集成IKAnalyzer分词器IKAnalyze扩展 官方网站：https://lucene.apache.org/ Lucene初识 Apache顶级开源项目，Lucene-core是一个开放源代码的全文检索引擎工具包，但它不是一个完整的全文检索引擎，而是一个全文检索引擎的框架，提供了完整的查询引...
Lucene——IK分词器测试
weixin_42789698的博客
08-10 208
文章目录IK分词器测试一、导入相关依赖二、使用Lucene自带的分词器代码三、lucene6.0使用IK分词器需要修改IKAnalyzer和IKTokenizer四、在resource下创建一个ext.dic(分词文件)，stopword(停止分词文件)五、测试 IK分词器测试 一、导入相关依赖 <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId>
Lucene支持中文分词代码实现
学亮编程手记
08-18 1068
支持中文分词 分析器（Analyzer）的执行过程 如下图是语汇单元的生成过程： 从一个Reader字符流开始，创建一个基于Reader的Tokenizer分词器，经过三个TokenFilter生成语汇单元Token。 要看分析器的分析效果，只需要看Tokenstream中的内容就可以了。每个分析器都有一个方法tokenStream，返回一个tokenStream对象。 分析器的分...
Lucene使用IKAnalyzer分词实例 及 IKAnalyzer扩展词库
hong2511的博客
01-08 811
本文转载自：https://www.cnblogs.com/dennisit/archive/2013/04/07/3005847.html 作者：dennisit 转载请注明该声明。方案一:基于配置的词典扩充 项目结构图如下:IK分词器还支持通过配置IKAnalyzer.cfg.xml文件来扩充您的专有词典。谷歌拼音词库下载:http://ishare.iask.sina.com.cn/...
lucene.NET 中文分词
05-26
在Lucene.NET中，为了支持中文分词，通常需要结合第三方分词器，如IK Analyzer、HanLP、jieba.NET等。这些分词器具备丰富的词汇库和优秀的分词算法，能有效地对中文文本进行拆分。 - **IK Analyzer**：是一个开源的...
lucene第一步---5.中文分词IKAnalyzer和高亮highlighter的使用
03-17
标题中的“lucene第一步---5.中文分词IKAnalyzer和高亮highlighter的使用”指出，这个主题将探讨如何在Lucene中应用IKAnalyzer进行中文分词，以及如何使用高亮器(highlighter)来突出搜索结果中的关键词。Lucene是...
需求EAV模型的优化与思考
HAN_789的博客
08-06 577
针对EAV（Entity-Attribute-Value）存储模型及Elasticsearch集成需求，以下是详细方案设计和实现建议。
Java集合中的链表
最新发布
Y409001的博客
08-08 445
本文详细介绍了Java中LinkedList的实现原理及其应用。首先分析了ArrayList在插入删除操作上的效率问题，引出链表结构的必要性。文章详细讲解了单向链表的基本概念、8种链表结构分类，以及不带头单向链表的具体实现，包括节点定义、接口设计和基本操作方法（增删改查）。重点说明了头插法、尾插法和任意位置插入的实现细节与注意事项。最后提供了9个链表相关的经典面试题及其解决方案，包括链表反转、中间节点查找、回文判断、环检测等。
Flash循环存储的地址回绕处理：跨边界写入的三种实现方案
u010360138的博客
08-05 1209
本文介绍了三种实现Flash循环存储地址计算的方法：1）条件判断法通过显式判断是否溢出实现地址回绕，逻辑清晰通用性强；2）模运算法利用取模运算自动处理地址回绕，代码简洁；3）位掩码法在存储区大小为2的幂时使用位与运算替代模运算，性能最优。三种方法功能等效但各有特点，选择时应考虑存储区特性、性能需求和代码可读性。关键注意事项包括写入延迟、地址有效性检查和边界条件处理。
Java中的RabbitMQ完全指南
H1658554092的博客
07-31 1115
Java中的RabbitMQ完全指南
SpringMvc的原理深度剖析及源码解读
gonghua0502的专栏
08-07 694
文章主要讲解了SpringServletContainerInitializer类初始化的过程。拦截器与过滤器区别及应用场景。DispatcherServlet处理流程。控制器初始化涉及文件解析器、本地化解析器等组件配置。适配器模式支持多种handler类型，包括Controller继承、HTTP请求和注解方式。异步实现可通过@Async注解或Callable类，需在配置类中开启异步支持。
LangChain4j终极指南：Spring Boot构建企业级Agent框架
夜雨的博客
08-08 642
LangChain4j终极指南：Spring Boot构建企业级Agent框架。实时流量看板：QPS、错误率、响应时间；资源利用率：CPU/内存/GPU使用率；LLM性能分析：Token消耗、推理延迟分布；工具热力图：调用频率、执行时长排行
如何实现分布式锁
m0_63486540的博客
08-06 700
文章摘要：本文系统探讨了锁机制的核心特性与实现。首先阐述了锁的互斥性本质，分析Redis中setnx命令的原子性优势。针对锁使用中的关键问题，提出了过期时间、看门狗机制和守护线程等解决方案。深入讲解了可重入锁的实现原理，对比了synchronized和ReentrantLock的不同机制。在分布式锁方面，详细介绍了Redission的哈希结构实现、阻塞锁设计及主从架构下的联锁机制。最后讨论了红锁(Redlock)的优缺点，指出其时间敏感性和运维复杂性等实际应用中的挑战。全文提供了从基础到进阶的完整锁机制知识
使用Lucene.Net与盘古分词构建搜索引擎
- **社区支持**: 此版本发布已久，拥有庞大的社区支持和丰富的第三方插件。 #### vs2012开发环境适配 - **项目兼容**: Lucene.Net框架与vs2012兼容性良好，能够顺利集成到vs2012项目中。 - **工具支持**: vs2012...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值