如何從特定索引開始向后搜索字串的子字串（backwordindexOf）

我想從特定索引開始搜索字串的子字串。

假設我有字串："PO DAD PO PE DA X PO ZA RA"

我想開始的索引是 character X，所以是 13。如果我想正常搜索“ZA”，我會做類似的事情： "DAD PO PE DA X PO ZA RA ZA".indexOf("ZA")我會得到 18。

接下來我想搜索第一個子字串'PO'，但從"X"索引向后搜索。所以，我會得到 4（因為它離X左側更近）而不是 15。

我怎么能這樣做？

uj5u.com熱心網友回復：

public static void main(String[] args) {
    String s = "PO DAD PO PE DA X PO ZA RA";
    System.out.println(usingSubstring(s));

    
    long start = System.currentTimeMillis();
    for (int i = 0; i < 10000; i  ) {
        usingSubstring(s);
    }
    long end = System.currentTimeMillis();
    System.out.println("`usingSubstring()` took "   (end - start)   "ms.");
}


/**
 * 1. Get the first index of `X`.
 * 2. Substring from 0 ... (1).
 * 3. Get the last index from (2) for `PO`.
 *
 * @param s input string
 * @return last index of `PO` backwards from `X`
 */
private static int usingSubstring(String s) {
    String toSearch = "PO";
    String searchUntil = "X";
    return s.substring(0, s.indexOf(searchUntil)).lastIndexOf(toSearch);
}

輸出：

7
`usingSubstring()` took 2ms.

在代碼注釋中解釋:)

uj5u.com熱心網友回復：

您可以Iterator在String. 這不僅可以讓您String向后迭代，還可以告訴您是否有進一步的匹配項（通過hasNext()）并使用該next()方法檢索所有匹配項。該類可以包含 3 個欄位：要搜索的字串、要查找的字串和內部游標。Iterator通過建構式，您可以設定兩個字串（顯然）和游標的起點。

這是一個可能的實作：

class StringBackwardSearcher implements Iterator<Integer> {
    private String str, match;
    private int index;

    public BackwardSearcher(String str, String match, int index) {
        this.str = Objects.requireNonNull(str);
        this.match = Objects.requireNonNull(match);
        this.index = Objects.checkIndex(index, str.length());
    }

    public void setIndex(int index) {
        this.index = Objects.checkIndex(index, str.length());
    }

    @Override
    public boolean hasNext() {
        return str.substring(0, index).contains(match);
    }

    @Override
    public Integer next() {
        for (; index >= 0; index--) {
            if (str.substring(index - match.length(), index).equals(match)) {
                Integer temp = index;
                index--;
                return temp - match.length();
            }
        }
        return -1;
    }
}

您的主要內容將包括

public static void main(String[] args) {
    String s = "PO DAD PO PE DA X PO ZA RA";
    StringBackwardSearcher bs = new StringBackwardSearcher(s, "PO", 16);
    while (bs.hasNext()) {
        System.out.println(bs.next());
    }
}

如果迭代器從 的索引開始X并且必須尋找PO，那么輸出將是：

uj5u.com熱心網友回復：

這應該有效：

public static int indexOfFromBackOf(String s,String match){
   for(int i = s.length()-1; i>0;i--) {
     int prevI = i;
     boolean found = true;
     for(int j=match.length()-1;j>0 && i>0;j--){
       if(s.charAt(i)!=match.charAt(j)) {found = false; break;}
       else i--;
     }
     if(found) return i;
     i = prevI;
   }
   return -1;
}

進而：

  String s = "DAD PO PE DA X PO ZA RA ZA";
  String match = "PO"; 
  System.out.println(indexOfFromBackOf(s.substring(0,s.indexOf("X")-1),match));

但它的混亂和復雜。為什么不使用斯科特的方法？在一行中：

    String s = "DAD PO PE DA X PO ZA RA ZA";
    String match = "PO";
    String cropped = s.substring(0,s.indexOf("X")-1;
    int index = cropped.length() - (new StringBuilder(cropped).reverse().indexOf(new StringBuilder(match).reverse().toString())   match.length()));

uj5u.com熱心網友回復：

要混合另一種解決方案，可以編譯具有以下邏輯的正則運算式：匹配以“PO”開頭，不跟隨“PO”，并以“X”結尾。

這樣，只有最近的（從左側）“PO”會匹配到“X”。

例如：

String subj = "AA PO DAD PO PE DA X PO ZA RA ZA";
        
final Pattern pattern = Pattern.compile("(PO)([^P]|P(?!O))*(X)");
final Matcher matcher = pattern.matcher(subj);
if (matcher.find()) {
   System.err.println("match at ["   matcher.start()   ","   matcher.end()   "): "   matcher.group());
}

標籤：爪哇

上一篇：我在這里正確使用java.time嗎？似乎舊的API會更容易

下一篇：使用Java流從嵌套串列和外部串列中收集資料