Find Last Index Of by Regex in Java

Question

i have a string %/O^/O%/O. I want to find the last / to split the string. First attemp was: \/[POL]$ but that gets it inclusive the "O" which is obvious. Has somebody a tip?

Answer 1

I agree that using the standard String.lastIndexOf() method is your best course of action, but I have recently had use for the Regex part (namely, I wanted to find the last non-alphanumeric character in a string).

I ended up writing it myself, and thought to share, in hopes that it would serve to help others:

/**
 * 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.
 * 
 * @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).
 * 
 * @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);
}

Also, it may be possible to make this method faster by first reversing the input string, then taking the ending index of the first group (rather than going over all the groups).

But to do that you would have to reverse the pattern as well; that can be simple in some cases (like my case of searching for a single character), but may prove problematic in others.

Answer 2

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

Answer 3

        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 4

The core question is good although the example you gave doesn't need it. Java's indexOf doesn't take regular expressions. Answering just subject part of the question, here's what you would need:

/**
* 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();
}

If you need the last index:

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

Do you need to use regular expressions for this? Would String.lastIndexOf("/") work to find the index, and then use String.substring(int start, int end) with the result? Or is your actual data different and more complicated, requiring regular expressions? With what you provided to split the string on the last /, here's code:

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

Answer 6

If all you want is to find the last instance of a character regex is overkill, you should just use String's lastIndexOf

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

Answer 7

/(?=[^/]*$)

will match a / that isn't followed by any more /s. To split on it, use

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