使用regexJava获取重叠模式

Question

此代码用于从数据集中提取顺序字母

import java.util.regex.*;
public class IFS {
    public static void main(String[] args) {
        String a;
        a = "ABC1abc";
        regexchecker ("\D+", a);
    }
    public static void regexchecker(String theRegex, String stuffToCheck) {
        // compiling the regex pattern
        Pattern checkRegex = Pattern.compile(theRegex);
        // the regex matcher being joined to the pattern
        Matcher regexmatcher = checkRegex.matcher(stuffToCheck);
        int end = stuffToCheck.length();
        for (int i = 0; i < end; i = i + 1) {
            for (int j = i + 1; j <= end; ++j) {
                regexmatcher.region(i, j);
                while (regexmatcher.find()) {
                    if (regexmatcher.group().length() != 0) {         
                        System.out.println(regexmatcher.group());
                    }
                }    
            }
        }
    }
}

好的，所以我知道我的代码每次都会从j迭代到结束，但我需要它跳过一个给出相同输出的迭代。

我的输出是

1. A
2. AB
3. ABC
4. ABC
5. ABCa
6. ABC ab
7. ABC ABC

等等，当我想要像这样的输出时

1. A
2. B
3. C
4. a
5. b
6. c
7. AB
8. BC
9. ab
10. bc
11. ABC
12. abc

非常感谢您的帮助。我的原始数据集比这个大得多，但为了简单起见，我使用了7个字符集

Answer 1

由于您正在设置要在区域中检查的确切边界，因此您希望排除仅与部分区域匹配的匹配，因为它们将在不同的迭代中找到。由于默认情况下，Matcher在设置区域时将锚点边界应用于区域，因此在正则表达式中使用锚点可以消除重复结果：

    regexchecker ("^\D+$", a);

Answer 2

我对您的代码进行了以下更改：

1. Defined an ArrayList to filter those duplicate matches. 
2. Small changes on start/end index to the matcher's region 
import java.util.regex.*;
import java.util.ArrayList;
public static void main(String[] args) {
    String a;
    a = "ABC1abc";
    regexchecker ("\D+", a);
}
public static void regexchecker(String theRegex, String stuffToCheck) {
    // compiling the regex pattern
    Pattern checkRegex = Pattern.compile(theRegex);
    // the regex matcher being joined to the pattern
    Matcher regexmatcher = checkRegex.matcher(stuffToCheck);
    // define an ArrayList
    ArrayList<String> result = new ArrayList<>();
    int end = stuffToCheck.length();
    for (int i = 1; i <= end; i++) {
        for (int j = 0; j <= end-i; j++) {
            regexmatcher.region(j, j + i);
            while (regexmatcher.find()) {
                if (result.indexOf(regexmatcher.group()) == -1) {         
                    System.out.println(regexmatcher.group());
                    //result.add(regexmatcher.group());
                }
            }    
        }
    }
}

输出：

A
B
C
a
b
c
AB
BC
ab
bc
ABC
abc

Answer 3

我发现最简单的方法是先抓住最长的比赛，然后在同一起始位置连续进行较短的比赛。外循环中的find()定位下一个匹配，然后内循环将区域设置到其边界并稳步缩小。我在内循环中使用lookingAt()，因为它会自动将匹配固定到区域的开头；可能没有必要，但不管怎样，它就在那里D

public static void regexchecker(String regex, String source)
{
  Pattern p = Pattern.compile(regex);
  Matcher m = p.matcher(source);
  int len = source.length();
  int start = 0;
  int end = len;
  while (start < len && m.region(start, len).find())
  {
    start = m.start();
    end = m.end();
    while (start < end && m.region(start, end).lookingAt())
    {
      System.out.println(m.group());
      end = m.end() - 1;
    }
    start++;
  }
}

输出：

ABC
AB
A
BC
B
C
abc
ab
a
bc
b
c