El siguiente código imprimirá 2

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

Me gustaría saber cómo obtener todos los índices de «n» («adivinar») en la cadena «bannanas»

El resultado esperado sería: [2,3,5]

InformationsquelleAutor Trufa | 2011-02-17

12 Comentarios

  1. 137

    Este debe imprimir la lista de posiciones sin la -1 en el extremo que Pedro Lawrey la solución ha había.

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

    También se puede hacer como un for bucle:

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

    [Nota: si guess puede ser más que un solo personaje, entonces es posible, mediante el análisis de la guess cadena, un bucle a través de word más rápido que el anterior bucles de hacer. El punto de referencia para este tipo de enfoque es el Boyer-Moore algoritmo. Sin embargo, las condiciones que favorecen el uso de este enfoque no parece estar presente.]

  2. 21

    Tratar el siguiente (Que no de la impresión -1 al final ahora!)

    int index = word.indexOf(guess);
    while(index >= 0) {
       System.out.println(index);
       index = word.indexOf(guess, index+1);
    }
    • mejor uso de indexOf!
    • siempre de impresión -1 al final
    • Muchas gracias por contestar, parece ser justo, pero esto es la verdad mi primer día con Java, así que estoy un poco confundido con el resultado final, esto parece salida de -1 al final una no acabo de entender por qué! gracias!!
    • Siempre imprime -1 al final, porque indexOf devuelve -1 cuando el personaje no se encuentra.
    • la razón por la que imprime -1 al final, es que el do bucle se ejecuta el cuerpo y luego descubre que index == -1 en la terminación de while.
    • esa parte me pongo, lo que no entiendo es lo que sucede con la función para que esto suceda, es «loops» a través de la palabra en busca de la aparición de los caracteres y hasta que se puede encontrar no más a la derecha? e imprime este último índice de que no es el de encontrar (-1), es que lo que está sucediendo? (No sé si que salió a la derecha)
    • Sí, siempre se imprime el índice antes de comprobar si es -1.

  3. 6
    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);
        }
    }

    Resultado sería utilizado como esta :

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

    O como una matriz :

    list.toArray();
  4. 2
    int index = -1;
    while((index = text.indexOf("on", index + 1)) >= 0) {
       LOG.d("index=" + index);
    }
  5. 1
    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);
    }
    • La idea general es correcto, pero word.substring(word) no se compilará. 😛
    • gracias por la corrección.
    • Todavía tiene un problema : se imprime continuamente 2.
    • Caramba, tengo que javac todo lo que he puesto aquí.
  6. 0
        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);
    • … se que código busca de ADN sequnces?¿?¿ XD
  7. 0

    También, si u quiere encontrar todos los índices de una Cadena de caracteres en una Cadena.

    int index = word.indexOf(guess);
    while (index >= 0) {
        System.out.println(index);
        index = word.indexOf(guess, index + guess.length());
    }
    • Esto es muy interesante, en el que se plantea una ambigüedad en el significado de «todos los sucesos». Si guess fue "aba" y word fue "ababa", no está claro si el guess se produce una o dos veces en word. (Me refiero, es claro que uno puede encontrar guess partida en dos posiciones distintas, pero desde las apariciones de superposición no está claro si ambos deben ser contados.) Esta respuesta es de la opinión de que la superposición de las apariciones no son consideradas como distintas. Por supuesto, desde el OP de la redacción sugiere que guess siempre tiene longitud 1, la ambigüedad no surgir.
  8. 0

    He tenido este problema, hasta que me encontré con este método.

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

    Este método puede ser usado para encontrar los índices de cualquier marca de cualquier longitud de una cadena, por ejemplo:

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

    Una clase de división de las cadenas que se me ocurrió. Una prueba corta al final.

    SplitStringUtils.smartSplitToShorterStrings(String str, int maxLen, int maxParts) dividirá por espacios sin romper las palabras, si es posible, y si no, se dividirá por índices de acuerdo a maxLen.

    Otros métodos para controlar la forma en que está dividido: 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;
    }
    }

    Simple código de prueba:

      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();
    }
  10. -1

    Esto se puede hacer por iteración myString y el cambio de fromIndex parámetro en indexOf():

      int currentIndex = 0;
    while (
    myString.indexOf(
    mySubstring,
    currentIndex) >= 0) {
    System.out.println(currentIndex);
    currentIndex++;
    }
    • ¿Tratas de ejecutar este código? Se imprimirá en cada posición (0, 1, 2, …) hasta que el índice de la última ocurrencia de mySubstring, independientemente de si mySubstring se puede encontrar en cada posición. No, en absoluto lo OP quería..
  11. -2

    Probar este

    String str = "helloslkhellodjladfjhello";
    String findStr = "hello";
    System.out.println(StringUtils.countMatches(str, findStr));
    • Esto es bueno para el recuento de los casos de una subcadena en una gran cadena, pero no devuelve los índices de los partidos.
    • Mientras que este código puede responder a la pregunta, proporcionar contexto adicional sobre cómo y/o por qué se resuelve el problema podría mejorar la respuesta del valor a largo plazo.

Dejar respuesta

Please enter your comment!
Please enter your name here