模糊查找文本
    1、定义忽略字符，如“的吗了啊吧”及所有符号
    2、把原始文本中的忽略字符去掉并记下位置
    3、把目标文本中的忽略字符替换成正则.{0,3}
    4、用正则匹配处理后的原始文本，得到开始/结束位置
    5、开始/结束位置加上在此之间被删除的字符数
    6、如果目标文本最后是忽略字符，从后向前查找最后一个字符, 或标点符号

    容错性有点差，还得另想办法~~

    1. public class SearchSubtextTest {
    2.     public static void main(String[] args) {
    3.         String source = "持有人会议机制：本期债务融资工具募集说明书在【持有人会议机制】章节中设置了对投资者的实体权利影响较大的特别议案，按照本募集说明书约定，特别议案决议生效条件为持有本期债务融资工具表决权超过总表决权数额 90% 的持有人同意。因此，存在特别议案未经全体投资人同意而生效的情况下，个别投资人虽不同意但已受生效特别议案的约束，自身实体权益存在因服从绝大多数人利益可能受到不利影响的可能性，特别议案如下：";
    4.         // 差异:                                                 #             #                   +                                                   -                                                  ####                                                                                                  -                                                     #  
    5.         String target =               "本期债务融资工具募集说明书在“持有人会议机制”章节中设置了对投资者实体权利影响较大的特别议案，按照本募集说明书约定，特别议案的决议生效条件为持有本期债务融资工具表决权超过总表决权数额【___】的持有人同意。因此，存在特别议案未经全体投资人同意而生效的情况下，个别投资人虽不同意但已受生效特别议案的约束，______等自身实体权益存在因服从绝大多数人利益可能受到不利影响的可能性。";
    6.         String ignore = "【】[]{}“”,:!?，。：！？ \t\n的吗等了";
    7.         System.out.println(SearchSubtextTools.searchSubtext(source, target, ignore));
    8.     }
    9. }
    1. import java.util.Arrays;
    2. import java.util.HashMap;
    3. import java.util.Map;
    4. import java.util.regex.Matcher;
    5. import java.util.regex.Pattern;
    7. /**
    8.  * 模糊查找文本
    9.  *
    10.  * @author zhaohuihua
    11.  * @version 20210804
    12.  */
    13. public class SearchSubtextTools {
    15.     public static void main(String[] args) {
    16.         String source = "持有人会议机制：本期债务融资工具募集说明书在【持有人会议机制】章节中设置了对投资者的实体权利影响较大的特别议案，按照本募集说明书约定，特别议案决议生效条件为持有本期债务融资工具表决权超过总表决权数额 90% 的持有人同意。因此，存在特别议案未经全体投资人同意而生效的情况下，个别投资人虽不同意但已受生效特别议案的约束，自身实体权益存在因服从绝大多数人利益可能受到不利影响的可能性，特别议案如下：";
    17.         // 差异:                                                 #             #                   +                                                   -                                                  ####                                                                                                  -                                                     #  
    18.         String target =               "本期债务融资工具募集说明书在“持有人会议机制”章节中设置了对投资者实体权利影响较大的特别议案，按照本募集说明书约定，特别议案的决议生效条件为持有本期债务融资工具表决权超过总表决权数额【___】的持有人同意。因此，存在特别议案未经全体投资人同意而生效的情况下，个别投资人虽不同意但已受生效特别议案的约束，______等自身实体权益存在因服从绝大多数人利益可能受到不利影响的可能性。";
    19.         String ignore = "【】[]{}“”,:!?，。：！？ \t\n的吗等了";
    20.         System.out.println(searchSubtext(source, target, ignore));
    21.     }
    23.     /**
    24.      * 模糊查找文本<br>
    25.      * 1、定义忽略字符，如“的吗了啊吧”及所有符号<br>
    26.      * 2、把原始文本中的忽略字符去掉并记下位置<br>
    27.      * 3、把目标文本中的忽略字符替换成正则.{0,3}<br>
    28.      * 4、用正则匹配处理后的原始文本，得到开始/结束位置<br>
    29.      * 5、开始/结束位置加上在此之间被删除的字符数<br>
    30.      * 6、如果目标文本最后是忽略字符，从后向前查找最后一个字符, 或标点符号
    31.      * 
    32.      * @param text 原始文本
    33.      * @param target 目标文本
    34.      * @param ignoreChars 忽略字符
    35.      * @return 关键字及位置信息
    36.      */
    37.     public static SubtextInfo searchSubtext(String text, String target, String ignoreChars) {
    38.         if (text == null || text.length() == 0 || target == null || target.length() == 0) {
    39.             return null;
    40.         }
    41.         if (ignoreChars == null || text.length() == 0) {
    42.             // 没有忽略字符, 直接使用indexOf比对
    43.             int index = text.indexOf(target);
    44.             if (index < 0) {
    45.                 return null;
    46.             }
    47.             return new SubtextInfo(target, index, index + target.length());
    48.         }
    50.         // 删除原文中的忽略字符, 并记录下位置
    51.         Map<Integer, Character> removedChars = new HashMap<>();
    52.         StringBuffer source = new StringBuffer();
    53.         for (int i = 0, z = text.length(); i < z; i++) {
    54.             char c = text.charAt(i);
    55.             if (ignoreChars.indexOf(c) >= 0) {
    56.                 removedChars.put(source.length(), c);
    57.             } else {
    58.                 source.append(c);
    59.             }
    60.         }
    62.         // 将目标文本中的忽略字符替换为正则表达式.{0,n}
    63.         String regexpChars = "{}[]()^$.*?-+|";
    64.         StringBuilder buffer = new StringBuilder();
    65.         int ignoreLength = 0;
    66.         char lastChar = 0;
    67.         for (int i = 0, z = target.length(); i < z; i++) {
    68.             char c = target.charAt(i);
    69.             if (c == '_') {
    70.                 ignoreLength += 3;
    71.             } else if (ignoreChars.indexOf(c) >= 0) {
    72.                 ignoreLength += 3;
    73.             } else {
    74.                 if (ignoreLength > 0) {
    75.                     buffer.append(".{0,").append(Math.max(5, ignoreLength)).append("}");
    76.                     ignoreLength = 0;
    77.                 }
    78.                 if (regexpChars.indexOf(c) >= 0) {
    79.                     buffer.append("\\");
    80.                 }
    81.                 buffer.append(c);
    82.                 lastChar = c;
    83.             }
    84.         }
    85.         boolean endsWithIgnoreChars = false;
    86.         if (ignoreLength > 0) {
    87.             endsWithIgnoreChars = true;
    88.             buffer.append(".{0,").append(Math.max(5, ignoreLength)).append("}");
    89.         }
    90.         Pattern pattern = Pattern.compile(buffer.toString());
    91.         Matcher matcher = pattern.matcher(source);
    92.         if (!matcher.find()) {
    93.             return null;
    94.         }
    96.         int min = matcher.start();
    97.         int max = matcher.end();
    98.         int start = min;
    99.         int end = max;
    101.         // 在min和max之间被删除的字符, 加到start和end中
    102.         for (int index : removedChars.keySet()) {
    103.             if (index <= min) {
    104.                 start++;
    105.                 end++;
    106.             }
    107.             if (index < max) {
    108.                 end++;
    109.             }
    110.         }
    112.         if (endsWithIgnoreChars) {
    113.             String symbol = "；，。：！？:;!?";
    114.             // 从后向前查找最后一个字符, 或标点符号
    115.             for (; end > start && end > 1; end--) {
    116.                 char c = text.charAt(end - 1);
    117.                 if (c == lastChar) {
    118.                     break;
    119.                 } else if (symbol.indexOf(c) >= 0) {
    120.                     break;
    121.                 }
    122.             }
    123.         }
    124.         String substring = text.substring(start, end);
    126.         return new SubtextInfo(substring, start, end);
    127.     }
    129.     /** 子文本信息 **/
    130.     public static class SubtextInfo {
    132.        /** 子文本 **/
    133.        private final String subtext;
    134.        /** 子文本在原文本的开始位置 **/
    135.        private final Integer startIndex;
    136.        /** 子文本在原文本的结束位置 **/
    137.        private final Integer endIndex;
    139.        public SubtextInfo(String subtext, int start, int end) {
    140.            this.subtext = subtext;
    141.            this.startIndex = start;
    142.            this.endIndex = end;
    143.        }
    145.        /** 子文本 **/
    146.        public String getSubtext() {
    147.            return subtext;
    148.        }
    150.        /** 子文本在原文本的开始位置 **/
    151.        public Integer getStartIndex() {
    152.            return startIndex;
    153.        }
    155.        /** 子文本在原文本的结束位置 **/
    156.        public Integer getEndIndex() {
    157.            return endIndex;
    158.        }
    160.        @Override
    161.        public String toString() {
    162.            StringBuilder buffer = new StringBuilder();
    163.            buffer.append(pad(startIndex, 3));
    164.            buffer.append(':').append(pad(endIndex, 3));
    165.            buffer.append("    ").append(subtext);
    166.            return buffer.toString();
    167.        }
    169.        /** 左侧补零 **/
    170.        private static String pad(int number, int length) {
    171.            char c = '0';
    172.            String string = String.valueOf(number);
    173.            char[] array = new char[length - string.length()];
    174.            Arrays.fill(array, c);
    175.            return new String(array) + string;
    176.        }
    177.    }
    178. }