Indizes aller Vorkommen von Zeichen in einer Zeichenfolge

Der folgende Code wird gedruckt 2

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

Ich würde gerne wissen, wie man alle Indizes von “n” (“rate”) in die Zeichenfolge “bannanas” bringt

Das erwartete Ergebnis wäre: [2,3,5]

   

Dies sollte die Liste der Positionen ohne die -1 am Ende drucken , die Peter Lawreys Lösung hatte.

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

Es kann auch als for Schleife gemacht werden:

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

[Hinweis: Wenn die guess länger als ein einzelnes Zeichen sein kann, ist es möglich, das word schneller zu durchlaufen, als dies bei den obigen Schleifen der Fall ist. Der Maßstab für einen solchen Ansatz ist der Boyer-Moore-Algorithmus . Die Voraussetzungen für einen solchen Ansatz scheinen jedoch nicht gegeben zu sein.]

Probiere folgendes aus (Was am Ende nicht -1 ausdruckt!)

 int index = word.indexOf(guess); while(index >= 0) { System.out.println(index); index = word.indexOf(guess, index+1); } 
 String string = "bannanas"; ArrayList list = new ArrayList(); char character = 'n'; for(int i = 0; i < string.length(); i++){ if(string.charAt(i) == character){ list.add(i); } } 

Das Ergebnis würde folgendermaßen aussehen:

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

Oder als ein Array:

 list.toArray(); 
 int index = -1; while((index = text.indexOf("on", index + 1)) >= 0) { LOG.d("index=" + index); } 

Mit Java9 kann man die iterate(int seed, IntPredicate hasNext,IntUnaryOperator next) wie folgt verwenden:

 List indexes = IntStream .iterate(word.indexOf(c), index -> index >= 0, index -> word.indexOf(c, index + 1)) .boxed() .collect(Collectors.toList()); System.out.printlnt(indexes); 
 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); } 
  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); 

Wenn Sie alle Indizes eines Strings in einem String finden möchten.

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

Ich hatte auch dieses Problem, bis ich mit dieser Methode kam.

 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); } 

Diese Methode kann verwendet werden, um Indizes eines beliebigen Flags beliebiger Länge in einem String zu finden, zum Beispiel:

 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); } } 

Eine class zum Spalten von Strings, die mir einfiel. Am Ende steht ein kurzer Test.

SplitStringUtils.smartSplitToShorterStrings(String str, int maxLen, int maxParts) wird nach Leerzeichen aufgeteilt, ohne Wörter zu unterbrechen, und wenn nicht, werden sie nach MaxLen aufgeteilt.

Andere Methoden zur Steuerung der Aufteilung: 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 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 spaceIndexes = findSplitPoints(str, ' '); List 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 res = new ArrayList<>(); int start = 0; for (int i=0; i maxLen) { return null; } res.add(str.substring(start, end)); start = end; } return res.toArray(new String[res.size()]); } return null; } private static List findSplitPoints(String str, char c) { List list = new ArrayList(); for (int i = 0; i < str.length(); i++) { if (str.charAt(i) == c) { list.add(i); } } list.add(str.length()); return list; } } 

Einfacher Testcode:

  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 

Dies kann durch Iteration von myString und Verschieben fromIndex Parameter in indexOf() :

  int currentIndex = 0; while ( myString.indexOf( mySubstring, currentIndex) >= 0) { System.out.println(currentIndex); currentIndex++; } 

Versuche dies

 String str = "helloslkhellodjladfjhello"; String findStr = "hello"; System.out.println(StringUtils.countMatches(str, findStr));