Indices de toutes les occurrences d'un caractère dans une chaîne de caractères

Question

Le code suivant imprimera 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" ("devine") dans la chaîne "bannanas".

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

Answer 1

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

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

Il peut également être fait en tant que for boucle :

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

[Note : si guess peut être plus long qu'un seul caractère, alors il est possible, en analysant le fichier guess pour parcourir en boucle la chaîne word plus rapidement que les boucles ci-dessus. Le point de référence pour une telle approche est le Algorithme de Boyer-Moore . Cependant, les conditions qui favoriseraient le recours à une telle approche ne semblent pas réunies].

Answer 2

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

Answer 3

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

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

Ou comme un tableau :

list.toArray();

Answer 4

Cela peut être fait de manière fonctionnelle avec Java 9 en utilisant une expression régulière :

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

Voici la solution Kotlin pour ajouter cette logique en tant que nouvelle méthode dans le fichier CharSequence API en utilisant la méthode d'extension :

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

Answer 5

Avec Java9, on peut utiliser la fonction 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);