Java negative indexOf (contando desde el final [longitud()])

Question

¿Hay alguna forma en Java para encontrar el índice de un carácter que comience desde el final y teniendo length() como referencia como lo hacen otros idiomas?

new String("abcd").reverseIndexOf("d"(,[4 or -0])) 
or new String("abcd").indexOf("d",-0) // Should return a (-)1 

... en lugar de lo obvio

new String("abcd").indexOf("d") - newString("abcd").length()  

Gracias!

Answer 1

lastIndexOf(int ch) comenzará desde el final y buscar hacia atrás, volviendo el índice absoluto de la última ocurrencia. Luego, puedes restar ese número de la longitud del String y negarlo, si eso es lo que realmente quieres.

También puede usar lastIndexOf(int ch, int fromIndex) si desea buscar hacia atrás desde un índice en particular.

Para responder a su pregunta sobre qué sucede cuando pasa un número negativo, puede profundizar en el código fuente de la clase String. Como resultado, la implementación indexOf que finalmente se llamó restablece un negativo fromIndex valor a cero:

static int indexOf(char[] source, int sourceOffset, int sourceCount, 
        char[] target, int targetOffset, int targetCount, 
        int fromIndex) { 
if (fromIndex >= sourceCount) { 
     return (targetCount == 0 ? sourceCount : -1); 
} 
    if (fromIndex < 0) { 
     fromIndex = 0; 
    } 
    ... 

Volviendo a su segundo ejemplo:

"abcd".indexOf("d",-0) 

... la implementación de un indexOf genérico que acepta un índice negativo y devuelve el índice negativo apropiado (si hay uno) es más complicado porque Java no distingue entre int0 y int-0 (ambos se representarán como 0), y porque String.indexOf ni mally devuelve -1 si no se encuentra la cadena de búsqueda. Sin embargo, puedes acercarte a lo que quieres. Tenga en cuenta que hay algunas advertencias:

1. String.indexOf normalmente regrese -1 si no se encuentra la cadena de búsqueda. Pero debido a que -1 es un índice válido en nuestra nueva implementación, necesitamos definir un nuevo contrato. Integer.MIN_VALUE ahora se devuelve si no se encuentra la cadena de búsqueda.
2. Porque no podemos probar para int-0, no podemos referirnos al índice del último carácter como -0. Por esa razón, usamos -1 para referirnos al índice del último carácter, y continuamos contando hacia atrás desde allí.
3. Para mantener la coherencia con el elemento 2, los valores de retorno negativos también comienzan la cuenta atrás comenzando con -1 como el índice del último carácter.

El código podría simplificarse, pero intencionalmente lo he hecho prolijo para que pueda pasarlo fácilmente en un depurador.

package com.example.string; 

public class StringExample { 

    public static int indexOf(String str, String search, int fromIndex) { 
     if (fromIndex < 0) { 
      fromIndex = str.length() + fromIndex; // convert the negative index to a positive index, treating the negative index -1 as the index of the last character 
      int index = str.lastIndexOf(search, fromIndex); 
      if (index == -1) { 
       index = Integer.MIN_VALUE; // String.indexOf normally returns -1 if the character is not found, but we need to define a new contract since -1 is a valid index for our new implementation 
      } 
      else { 
       index = -(str.length() - index); // convert the result to a negative index--again, -1 is the index of the last character 
      } 
      return index; 
     } 
     else { 
      return str.indexOf(str, fromIndex); 
     } 
    } 

    public static void main(String[] args) { 
     System.out.println(indexOf("abcd", "d", -1)); // returns -1 
     System.out.println(indexOf("adbcd", "d", -2)); // returns -4 
    } 
} 

Answer 2

sólo tiene que utilizar String.lastIndexOf() método:

String s = "abcd"; 
int rindex = s.lastIndexof('d'); 
System.out.println(rindex); // print 0 

Answer 3

Desde aquí se puede revertir la cadena por cierto:

String s="abcd"; 
StringBuilder reverseS = new StringBuilder(s).reverse(); 
System.out.println(reverseS.indexOf("d")); //print 0 
System.out.println(reverseS.indexOf("a")); //print 3 
System.out.println(reverseS.indexOf("d",1)); //print -1