web-dev-qa-db-fra.com

Index de toutes les occurrences de caractère dans une chaîne

Le code suivant va imprimer 2

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

Je voudrais savoir comment obtenir tous les index de "n" ("suppose") dans la chaîne "bannanas"

Le résultat attendu serait: [2,3,5]

javaloopsindexingcharacter
84
Trufa

Cela devrait imprimer la liste des positions sans le -1 à la fin qui La solution de Peter Lawrey a eu.

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

Cela peut aussi être fait comme une boucle for:

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

[Remarque: si guess peut être plus long qu'un seul caractère, il est possible, en analysant la chaîne guess, de parcourir Word plus rapidement que les boucles ci-dessus. Le point de référence pour une telle approche est l’algorithme Boyer-Moore . Cependant, les conditions favorables à l’utilisation d’une telle approche ne semblent pas être présentes.]

130
Ted Hopp

Essayez ce qui suit (qui n’imprime pas -1 à la fin maintenant!)

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

Le résultat serait utilisé comme ceci:

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

Ou sous forme de tableau:

list.toArray();
6
POSIX_ME_HARDER

Avec Java9, on peut utiliser la iterate(int seed, IntPredicate hasNext,IntUnaryOperator next) comme suit: -

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

J'ai eu ce problème aussi, jusqu'à ce que je trouve cette méthode.

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

Cette méthode peut être utilisée pour trouver les index de n'importe quel drapeau de n'importe quelle longueur dans une chaîne, par exemple:

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.

En outre, si vous voulez trouver tous les index d'une chaîne dans une chaîne.

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

Une classe pour séparer des cordes que je suis venu avec. Un court test est fourni à la fin.

SplitStringUtils.smartSplitToShorterStrings(String str, int maxLen, int maxParts) sera scindé par des espaces sans casser les mots, si possible, et sinon, scindé par des index selon maxLen. 

Autres méthodes fournies pour contrôler la division: 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;
  }
}

Code de test simple:

  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