it-swarm.com.de

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 der Zeichenfolge "bannanas" erhält.

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

84
Trufa

Dies sollte die Liste der Positionen ohne den -1 am Ende der Peter Lawreys Lösung hat hätten.

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

Es kann auch als for-Schleife ausgeführt werden:

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

[Hinweis: Wenn guess länger als ein einzelnes Zeichen sein kann, ist es durch Analyse der guess-Zeichenfolge möglich, Word schneller als die oben genannten Schleifen zu durchlaufen. Der Maßstab für einen solchen Ansatz ist der Boyer-Moore-Algorithmus . Die Bedingungen, die einen solchen Ansatz begünstigen würden, scheinen jedoch nicht gegeben zu sein.]

130
Ted Hopp

Versuchen Sie folgendes (welches jetzt nicht -1 am Ende druckt!)

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

Ergebnis würde folgendermaßen verwendet werden:

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

Oder als Array:

list.toArray();
6
POSIX_ME_HARDER

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

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
nullpointer
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

Ich hatte auch dieses Problem, bis ich mir diese Methode ausgedacht hatte.

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

Mit dieser Methode können Sie Indizes eines beliebigen Flags beliebiger Länge in einer Zeichenfolge suchen. 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);
    }
}
0
Ian S.

Auch wenn Sie alle Indizes eines Strings in einem String suchen möchten.

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

Eine Klasse zum Teilen von Saiten, die ich mir ausgedacht habe. Am Ende steht ein kurzer Test zur Verfügung.

SplitStringUtils.smartSplitToShorterStrings(String str, int maxLen, int maxParts) wird, wenn möglich, durch Leerzeichen ohne Unterbrechen von Wörtern aufgeteilt, und falls dies nicht der Fall ist, wird der Index 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<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;
  }
}

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<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