Domanda java replaceLast () [duplicato]


Questa domanda ha già una risposta qui:

È lì replaceLast() in Java? Ho visto che c'è replaceFirst().

EDIT: Se non c'è nell'SDK, quale sarebbe una buona implementazione?


44
2018-02-17 17:05


origine


risposte:


Potrebbe (ovviamente) essere fatto con regex:

public class Test {

    public static String replaceLast(String text, String regex, String replacement) {
        return text.replaceFirst("(?s)"+regex+"(?!.*?"+regex+")", replacement);
    }

    public static void main(String[] args) {
        System.out.println(replaceLast("foo AB bar AB done", "AB", "--"));
    }
}

anche se un po ' cpu-ciclo-fame con lo sguardo in avanti, ma questo sarà solo un problema quando si lavora con stringhe molto grandi (e molte occorrenze della regex in cerca).

Una breve spiegazione (nel caso dell'essere regex AB):

(?s)     # enable dot-all option
A        # match the character 'A'
B        # match the character 'B'
(?!      # start negative look ahead
  .*?    #   match any character and repeat it zero or more times, reluctantly
  A      #   match the character 'A'
  B      #   match the character 'B'
)        # end negative look ahead

MODIFICARE

Mi dispiace per svegliare un vecchio post. Ma questo è solo per istanze non sovrapposte.   Per esempio .replaceLast("aaabbb", "bb", "xx"); ritorna "aaaxxb"no "aaabxx"

È vero, questo potrebbe essere risolto come segue:

public class Test {

    public static String replaceLast(String text, String regex, String replacement) {
        return text.replaceFirst("(?s)(.*)" + regex, "$1" + replacement);
    }

    public static void main(String[] args) {
        System.out.println(replaceLast("aaabbb", "bb", "xx"));
    }
}

44
2018-02-17 17:38



Se non hai bisogno di regex, ecco un'alternativa di sottostringa.

public static String replaceLast(String string, String toReplace, String replacement) {
    int pos = string.lastIndexOf(toReplace);
    if (pos > -1) {
        return string.substring(0, pos)
             + replacement
             + string.substring(pos + toReplace.length(), string.length());
    } else {
        return string;
    }
}

TestCase:

public static void main(String[] args) throws Exception {
    System.out.println(replaceLast("foobarfoobar", "foo", "bar")); // foobarbarbar
    System.out.println(replaceLast("foobarbarbar", "foo", "bar")); // barbarbarbar
    System.out.println(replaceLast("foobarfoobar", "faa", "bar")); // foobarfoobar
}

29
2018-02-17 17:36



usa replaceAll e aggiungi un segno di dollaro subito dopo il tuo pattern:

replaceAll("pattern$", replacement);

14
2018-03-26 15:23



Puoi combinare StringUtils.reverse() con String.replaceFirst() 


7
2018-02-17 17:11



Vedi di persona: String

Oppure la tua domanda in realtà "Come posso implementare a replaceLast()?"

Lasciatemi tentare un'implementazione (questo dovrebbe comportarsi in modo molto simile replaceFirst(), quindi dovrebbe supportare regex e backreferences nella stringa di sostituzione):

public static String replaceLast(String input, String regex, String replacement) {
    Pattern pattern = Pattern.compile(regex);
    Matcher matcher = pattern.matcher(input);
    if (!matcher.find()) {
       return input;
    }
    int lastMatchStart=0;
    do {
      lastMatchStart=matcher.start();
    } while (matcher.find());
    matcher.find(lastMatchStart);
    StringBuffer sb = new StringBuffer(input.length());
    matcher.appendReplacement(sb, replacement);
    matcher.appendTail(sb);
    return sb.toString();
}

6
2018-02-17 17:09



Usa StringUtils da apache:

org.apache.commons.lang.StringUtils.chomp(value, ignoreChar);

3
2017-08-08 09:10



No.

Potresti farlo reverse / replaceFirst / reverse, ma è un po 'costoso.


2
2018-02-17 17:09



Se la stringa esaminata è così

myString.endsWith(substringToReplace) == true

anche tu puoi farlo

myString=myString.replaceFirst("(.*)"+myEnd+"$","$1"+replacement) 

1
2018-05-25 13:32



è lento, ma funziona: 3

    import org.apache.commons.lang.StringUtils;

public static String replaceLast(String str, String oldValue, String newValue) {
    str = StringUtils.reverse(str);
    str = str.replaceFirst(StringUtils.reverse(oldValue), StringUtils.reverse(newValue));
    str = StringUtils.reverse(str);
    return str;
}

0
2017-09-18 14:59



dividi il pagliaio con l'ago usando un'espressione regolare lookahead e sostituisci l'ultimo elemento dell'array, quindi uniscili insieme: D

String haystack = "haystack haystack haystack";
String lookFor = "hay";
String replaceWith = "wood";

String[] matches = haystack.split("(?=" + lookFor + ")");
matches[matches.length - 1] = matches[matches.length - 1].replace(lookFor, replaceWith);
String brandNew = StringUtils.join(matches);

0
2017-07-23 16:57