Buscar último índice de por Regex en Java

Question

tengo una cadena %/O^/O%/O. Quiero encontrar el último/para dividir la cadena. El primer intento fue: \/[POL]$ pero eso lo incluye el "O" que es obvio. ¿Alguien tiene un consejo?

Answer 1

¿Es necesario utilizar expresiones regulares ¿para esto? Lo haría con String. lastIndexOf("/") funcionan para encontrar el índice, y luego usan String.substring(int start, int end) con el resultado? ¿O son sus datos reales diferentes y más complicados, que requieren expresiones regulares? Con lo que ya ha proporcionado a dividir la cadena en la última /, aquí está el código:

int lastSlash = mystring.lastIndexOf("/"); 
String start = mystring.substring(0, lastSlash); 
String end = mystring.substring(lastSlash + 1, mystring.length); 

Answer 2

/(?=[^/]*$) 

coincidirá con un / que no vaya seguida de las más / s. Para dividir en él, utilizar

String[] splitArray = subjectString.split("/(?=[^/]*$)"); 

Answer 3

Si lo que quieres es encontrar la última instancia de una expresión regular personaje es una exageración, sólo debe usar lastIndexOf de cadena

int pos = myString.lastIndexOf('/'); 

Answer 4

La pregunta central es buena, aunque el ejemplo que diste no se lo necesitan. El índice de Java no toma expresiones regulares. Respondiendo parte solo objeto de la cuestión, esto es lo que se necesita:

/** 
* Version of indexOf that uses regular expressions for the search 
* by Julian Cochran. 
*/ 
public static int indexOfRegex(String message, String toFind) { 
    // Need to add an extra character to message because to ensure 
    // split works if toFind is right at the end of the message. 
    message = message + " "; 
    String separated[] = message.split(toFind); 
    if (separated == null || 
     separated.length == 0 || 
     separated.length == 1) { 
    return -1; 
    } 
    return separated[0].length(); 
} 

Si necesita el último índice:

/** 
* Version of lastIndexOf that uses regular expressions for 
* the search by Julian Cochran. 
*/ 
public static int lastIndexOfRegex(String message, String toFind) { 
    // Need to add an extra character to message because to ensure 
    // split works if toFind is right at the end of the message. 
    message = message + " "; 
    String separated[] = message.split(toFind); 
    if (separated == null || 
     separated.length == 0 || 
     separated.length == 1) { 
    return -1; 
    } 
    return separated[separated.length - 1].length(); 
} 

Answer 5

Estoy de acuerdo que el uso de método de la norma String.lastIndexOf() es su mejor curso de acción, pero recientemente he tenido uso para la parte Regex (es decir, quería encontrar el último carácter no alfanumérico en una cadena).

terminé escribiendo yo mismo, y pensado para compartir, con la esperanza de que sirva para ayudar a otros:

/** 
* Indicates that a String search operation yielded no results. 
*/ 
public static final int NOT_FOUND = -1; 

/** 
* Version of lastIndexOf that uses regular expressions for searching. 
* By Tomer Godinger. 
* 
* @param str String in which to search for the pattern. 
* @param toFind Pattern to locate. 
* @return The index of the requested pattern, if found; NOT_FOUND (-1) otherwise. 
*/ 
public static int lastIndexOfRegex(String str, String toFind) 
{ 
    Pattern pattern = Pattern.compile(toFind); 
    Matcher matcher = pattern.matcher(str); 

    // Default to the NOT_FOUND constant 
    int lastIndex = NOT_FOUND; 

    // Search for the given pattern 
    while (matcher.find()) 
    { 
     lastIndex = matcher.start(); 
    } 

    return lastIndex; 
} 

/** 
* Finds the last index of the given regular expression pattern in the given string, 
* starting from the given index (and conceptually going backwards). 
* By Tomer Godinger. 
* 
* @param str String in which to search for the pattern. 
* @param toFind Pattern to locate. 
* @param fromIndex Maximum allowed index. 
* @return The index of the requested pattern, if found; NOT_FOUND (-1) otherwise. 
*/ 
public static int lastIndexOfRegex(String str, String toFind, int fromIndex) 
{ 
    // Limit the search by searching on a suitable substring 
    return lastIndexOfRegex(str.substring(0, fromIndex), toFind); 
} 

Además, puede ser posible para que este método más rápido invirtiendo primero la cadena de entrada , luego tomando el índice final del primer grupo (en lugar de pasar por todos los grupos).

Pero para hacer eso tendrías que invertir el patrón también; eso puede ser simple en algunos casos (como mi caso de buscar un solo personaje), pero puede ser problemático en otros.

Answer 6

 String name ="rami is good boy, and he is working for andorid,is completed"; 
    int lastSlash = name.lastIndexOf("is"); 
    String start = name.substring(0, lastSlash); 
    String end = name.substring(lastSlash + 1, name.length()); 
    StringBuffer sb = new StringBuffer(name); 
    sb.replace(start.length(), name.lastIndexOf(end)+1, ""); 

    System.out.println(sb.toString()); 

Answer 7

ref: https://github.com/apache/commons-lang/pull/273/files

public static int lastIndexOfAnyChar(final CharSequence str,final String searchChars) { 
    return searchChars == null ? INDEX_NOT_FOUND : lastIndexOfAnyChar(str,searchChars.toCharArray()); 
} 

/** 
* <p>Search a CharSequence to find the last index of any 
* character in the given set of characters.</p> 
* 
* <p>A {@code null} String will return {@code -1}. 
* A {@code null} or zero length search array will return {@code -1}.</p> 
* 
* <pre> 
* StringUtils.lastIndexOfAnyChar(null, *)    = -1 
* StringUtils.lastIndexOfAnyChar("", *)     = -1 
* StringUtils.lastIndexOfAnyChar(*, null)    = -1 
* StringUtils.lastIndexOfAnyChar(*, [])     = -1 
* StringUtils.lastIndexOfAnyChar("zzabyycdxx",['z','a']) = 2 
* StringUtils.lastIndexOfAnyChar("zzabyycdxx",['b','y']) = 5 
* StringUtils.lastIndexOfAnyChar("aba", ['z'])   = -1 
* </pre> 
* 
* @param cs the CharSequence to check, may be null 
* @param searchChars the chars to search for, may be null 
* @return the last index of any of the chars, -1 if no match or null input 
*/ 
public static int lastIndexOfAnyChar(final CharSequence str,final char... searchChars) { 
    if (isEmpty(str) || ArrayUtils.isEmpty(searchChars)) { 
     return INDEX_NOT_FOUND; 
    } 
    int csLen = str.length(); 
    int csLast = csLen - 1; 
    int searchLen = searchChars.length; 
    int searchLast = searchLen - 1; 
    for (int i = csLast ; i >= 0 ; i--) { 
     char ch = str.charAt(i); 
     for (int j = 0; j < searchLen; j++) { 
      if (searchChars[j] == ch) { 
       if (i < csLast && j < searchLast && Character.isHighSurrogate(ch)) { 
        // ch is a supplementary character 
        if (searchChars[j + 1] == str.charAt(i + 1)) { 
         return i; 
        } 
       } else { 
        return i; 
       } 
      } 
     } 
    } 
    return INDEX_NOT_FOUND; 
}