web-dev-qa-db-ja.com

文字列内のすべての文字のインデックス

次のコードは2を出力します

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

文字列「bannanas」の「n」（「guess」）のすべてのインデックスを取得する方法を知りたい

期待される結果は次のとおりです。[2,3,5]

javaloopsindexingcharacter
86
Trufa

これは、最後に-1なしで位置のリストを出力するはずです Peter 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が1文字より長くなる可能性がある場合、guess文字列を分析することにより、上記のループよりも速くWordをループすることができます。このようなアプローチのベンチマークは、 Boyer-Mooreアルゴリズム です。しかし、そのようなアプローチを使用することを支持する条件は存在しないようです。]

138
Ted Hopp

以下を試してください（最後に-1を出力しません！）

int index = Word.indexOf(guess);
while(index >= 0) {
   System.out.println(index);
   index = Word.indexOf(guess, index+1);
}
21
Peter Lawrey
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();
6
POSIX_ME_HARDER

Java9では、次のように iterate(int seed, IntPredicate hasNext,IntUnaryOperator next) を使用できます。

List<Integer> indexes = IntStream
          .iterate(Word.indexOf(c), index -> index >= 0, index -> Word.indexOf(c, index + 1))
          .boxed()
          .collect(Collectors.toList());
System.out.printlnt(indexes);
4
Naman
int index = -1;
while((index = text.indexOf("on", index + 1)) >= 0) {
   LOG.d("index=" + index);
}
2
urSus
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);
}
1
asgs

この方法を思い付くまでは、この問題もありました。

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);
    }
}
0
Ian S.

また、文字列内の文字列のすべてのインデックスを検索する場合。

int index = Word.indexOf(guess);
while (index >= 0) {
    System.out.println(index);
    index = Word.indexOf(guess, index + guess.length());
}
0
Elite Vip

私が思いついた文字列を分割するためのクラス。最後に短いテストが提供されます。

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();
  }
0
Dariusz
    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);
0
idris yıldız