字符串中所有出现的字符的索引

101

以下代码将打印2

String word = "bannanas";
String guess = "n";
int index;
System.out.println( 
    index = word.indexOf(guess)
);

我想知道如何在字符串“ bannanas”中获取“ n”（“ guess”）的所有索引

预期结果将是： [2,3,5]

java  loops  indexing  character 
— 特鲁法
source

Answers:

162

这应该打印位置的列表中没有-1结尾的那段彼得Lawrey的解决方案 已经过。

int index = word.indexOf(guess);
while (index >= 0) {
    System.out.println(index);
    index = word.indexOf(guess, index + 1);
}

也可以for循环执行：

for (int index = word.indexOf(guess);
     index >= 0;
     index = word.indexOf(guess, index + 1))
{
    System.out.println(index);
}

[注意：如果guess可以长于单个字符，则通过分析guess字符串，可以word比上述循环更快地循环。这种方法的基准是Boyer-Moore算法。但是，似乎不存在使用这种方法的条件。]

— 泰德·霍普
source
28

请尝试以下操作（现在末尾不会打印-1！）

int index = word.indexOf(guess);
while(index >= 0) {
   System.out.println(index);
   index = word.indexOf(guess, index+1);
}
— 彼得·劳瑞
source
1
您总是在末尾打印-1
— lukastymo 2011年
@Peter非常感谢您的回答，这似乎是正确的，但这实际上是我使用Java的第一天，所以我对最终结果有些困惑，这似乎最后输出-1，我不知道。不太明白为什么！谢谢！！
— Trufa
@Trufa：总是在末尾打印-1，因为indexOf找不到字符时返回-1。
— ColinD
@Trufa-它最后打印的原因-1是do循环执行了主体，然后index == -1在终止处发现了主体while。
— 泰德·霍普
@ColinD我得到的那部分，我不明白的是该功能发生了什么，它通过单词“循环”寻找字符的出现，直到找不到正确的为止？并显示未找到的最后一个索引（-1），这是什么情况？（我不知道是否正确）
— Trufa
7 
String string = "bannanas";
ArrayList<Integer> list = new ArrayList<Integer>();
char character = 'n';
for(int i = 0; i < string.length(); i++){
    if(string.charAt(i) == character){
       list.add(i);
    }
}

结果将像这样使用：

    for(Integer i : list){
        System.out.println(i);
    }

或作为数组：

list.toArray();
— POSIX_ME_HARDER
source
3 
int index = -1;
while((index = text.indexOf("on", index + 1)) >= 0) {
   LOG.d("index=" + index);
}
— 我们
source
1 
String word = "bannanas";

String guess = "n";

String temp = word;

while(temp.indexOf(guess) != -1) {
     int index = temp.indexOf(guess);
     System.out.println(index);
     temp = temp.substring(index + 1);
}
— 装备
source
总体思路是正确的，但word.substring(word)不会编译。：P
— Peter Lawrey 2011年
1
还有一个问题：它连续打印2
— POSIX_ME_HARDER
天哪，我需要使用我在这里发布的所有内容进行javac操作。
— asgs 2011年
1

可以使用正则表达式在Java 9中以功能方式完成此操作：

Pattern.compile(Pattern.quote(guess)) // sanitize input and create pattern
            .matcher(word) // create matcher
            .results()     // get the MatchResults, Java 9 method
            .map(MatchResult::start) // get the first index
            .collect(Collectors.toList()) // collect found indices into a list
    );

这是Kotlin解决方案，CharSequence使用扩展方法将此逻辑作为新的新方法添加到API中：

 // Extension method
fun CharSequence.indicesOf(input: String): List<Int> =
    Regex(Pattern.quote(input)) // build regex
        .findAll(this)          // get the matches
        .map { it.range.first } // get the index
        .toCollection(mutableListOf()) // collect the result as list

// call the methods as
"Banana".indicesOf("a") // [1, 3, 5]
— Pavneet_Singh
source
0 
    String input = "GATATATGCG";
    String substring = "G";
    String temp = input;
    String indexOF ="";
    int tempIntex=1;

    while(temp.indexOf(substring) != -1)
    {
        int index = temp.indexOf(substring);
        indexOF +=(index+tempIntex)+" ";
        tempIntex+=(index+1);
        temp = temp.substring(index + 1);
    }
    Log.e("indexOf ","" + indexOF);
— 伊德里斯·耶尔德兹
source
0

另外，如果您想在字符串中查找字符串的所有索引。

int index = word.indexOf(guess);
while (index >= 0) {
    System.out.println(index);
    index = word.indexOf(guess, index + guess.length());
}
— 精英贵宾
source
这很有趣，因为它在“所有事件”的含义上引起了歧义。如果guess was "aba"和wordwas "ababa"，则不清楚是guess发生一次还是两次word。（我的意思是，很明显，一个人可以guess在两个不同的位置开始查找，但是由于出现的重叠是未知的，因此不清楚是否应该将它们都计算在内。）此答案认为，重叠的出现不被视为不同的。当然，由于OP的措辞强烈暗示该guess长度将始终为1，因此不会出现歧义。
— Ted Hopp
0

在提出这种方法之前，我也遇到了这个问题。

public static int[] indexesOf(String s, String flag) {
    int flagLen = flag.length();
    String current = s;
    int[] res = new int[s.length()];
    int count = 0;
    int base = 0;
    while(current.contains(flag)) {
        int index = current.indexOf(flag);
        res[count] = index + base;
        base += index + flagLen;
        current = current.substring(current.indexOf(flag) + flagLen, current.length());
        ++ count;
    }
    return Arrays.copyOf(res, count);
}

此方法可用于查找字符串中任何长度的任何标志的索引，例如：

public class Main {

    public static void main(String[] args) {
        int[] indexes = indexesOf("Hello, yellow jello", "ll");

        // Prints [2, 9, 16]
        System.out.println(Arrays.toString(indexes));
    }

    public static int[] indexesOf(String s, String flag) {
        int flagLen = flag.length();
        String current = s;
        int[] res = new int[s.length()];
        int count = 0;
        int base = 0;
        while(current.contains(flag)) {
            int index = current.indexOf(flag);
            res[count] = index + base;
            base += index + flagLen;
            current = current.substring(current.indexOf(flag) + flagLen, current.length());
            ++ count;
        }
        return Arrays.copyOf(res, count);
    }
}
— 伊恩·S。
source
0

我想出的用于拆分字符串的类。最后提供了简短测试。

SplitStringUtils.smartSplitToShorterStrings(String str, int maxLen, int maxParts) 如果可能的话，将按空格分割而不会中断单词，如果可能的话，将根据maxLen按索引分割。

提供了控制其拆分方式的其他方法：bruteSplitLimit(String str, int maxLen, int maxParts)，spaceSplit(String str, int maxLen, int maxParts)。

public class SplitStringUtils {

  public static String[] smartSplitToShorterStrings(String str, int maxLen, int maxParts) {
    if (str.length() <= maxLen) {
      return new String[] {str};
    }
    if (str.length() > maxLen*maxParts) {
      return bruteSplitLimit(str, maxLen, maxParts);
    }

    String[] res = spaceSplit(str, maxLen, maxParts);
    if (res != null) {
      return res;
    }

    return bruteSplitLimit(str, maxLen, maxParts);
  }

  public static String[] bruteSplitLimit(String str, int maxLen, int maxParts) {
    String[] bruteArr = bruteSplit(str, maxLen);
    String[] ret = Arrays.stream(bruteArr)
          .limit(maxParts)
          .collect(Collectors.toList())
          .toArray(new String[maxParts]);
    return ret;
  }

  public static String[] bruteSplit(String name, int maxLen) {
    List<String> res = new ArrayList<>();
    int start =0;
    int end = maxLen;
    while (end <= name.length()) {
      String substr = name.substring(start, end);
      res.add(substr);
      start = end;
      end +=maxLen;
    }
    String substr = name.substring(start, name.length());
    res.add(substr);
    return res.toArray(new String[res.size()]);
  }

  public static String[] spaceSplit(String str, int maxLen, int maxParts) {
    List<Integer> spaceIndexes = findSplitPoints(str, ' ');
    List<Integer> goodSplitIndexes = new ArrayList<>();
    int goodIndex = -1; 
    int curPartMax = maxLen;
    for (int i=0; i< spaceIndexes.size(); i++) {
      int idx = spaceIndexes.get(i);
      if (idx < curPartMax) {
        goodIndex = idx;
      } else {
        goodSplitIndexes.add(goodIndex+1);
        curPartMax = goodIndex+1+maxLen;
      }
    }
    if (goodSplitIndexes.get(goodSplitIndexes.size()-1) != str.length()) {
      goodSplitIndexes.add(str.length());
    }
    if (goodSplitIndexes.size()<=maxParts) {
      List<String> res = new ArrayList<>();
      int start = 0;
      for (int i=0; i<goodSplitIndexes.size(); i++) {
        int end = goodSplitIndexes.get(i);
        if (end-start > maxLen) {
          return null;
        }
        res.add(str.substring(start, end));
        start = end;
      }
      return res.toArray(new String[res.size()]);
    }
    return null;
  }


  private static List<Integer> findSplitPoints(String str, char c) {
    List<Integer> list = new ArrayList<Integer>();
    for (int i = 0; i < str.length(); i++) {
      if (str.charAt(i) == c) {
        list.add(i);
      }
    }
    list.add(str.length());
    return list;
  }
}

简单的测试代码：

  public static void main(String[] args) {
    String [] testStrings = {
        "123",
        "123 123 123 1123 123 123 123 123 123 123",
        "123 54123 5123 513 54w567 3567 e56 73w45 63 567356 735687 4678 4678 u4678 u4678 56rt64w5 6546345",
        "1345678934576235784620957029356723578946",
        "12764444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444",
        "3463356 35673567567 3567 35 3567 35 675 653 673567 777777777777777777777777777777777777777777777777777777777777777777"
    };

    int max = 35;
    int maxparts = 2;


    for (String str : testStrings) {
      System.out.println("TEST\n    |"+str+"|");
      printSplitDetails(max, maxparts);
      String[] res = smartSplitToShorterStrings(str, max, maxparts);
      for (int i=0; i< res.length;i++) {
        System.out.println("  "+i+": "+res[i]);
      }
      System.out.println("===========================================================================================================================================================");
    }

  }

  static void printSplitDetails(int max, int maxparts) {
    System.out.print("  X: ");
    for (int i=0; i<max*maxparts; i++) {
      if (i%max == 0) {
        System.out.print("|");
      } else {
        System.out.print("-");
      }
    }
    System.out.println();
  }
— 大流士
source
0

这是一个Java 8解决方案。

public int[] solution (String s, String subString){
        int initialIndex = s.indexOf(subString);
        List<Integer> indexList = new ArrayList<>();
        while (initialIndex >=0){
            indexList.add(initialIndex);
            initialIndex = s.indexOf(subString, initialIndex+1);
        }
        int [] intA = indexList.stream().mapToInt(i->i).toArray();
        return intA;
    }
— 阿米贝（Bamidele Alegbe）
source
-1

这可以通过迭代myString和移动以下fromIndex参数来完成indexOf()：

  int currentIndex = 0;

  while (
    myString.indexOf(
      mySubstring,
      currentIndex) >= 0) {

    System.out.println(currentIndex);

    currentIndex++;
  }
— 宗恩
source
您甚至尝试运行此代码吗？它将打印出每个位置（0，1，2，...），直到最后一次出现的索引mySubstring，无论是否mySubstring可以在每个位置找到它。根本不是OP想..
— 泰德·霍普
-4

试试这个

String str = "helloslkhellodjladfjhello";
String findStr = "hello";

System.out.println(StringUtils.countMatches(str, findStr));
— Vikas Kumbhar
source
这对于计算较大字符串中子字符串的实例非常有用，但不会返回匹配项的索引。
— Fiveclubs 2015年
尽管此代码可以回答问题，但提供有关如何和/或为什么解决问题的其他上下文将提高​​答案的长期价值。
— Nic3500
这不能回答问题。这个问题需要所有指数的列表
— sheu
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.