Problem: Abbiegen

"My Testtext TARGETSTRING My Testtext" 

hinein

"My Testtext targetstring My Testtext"

Perl unterstützt die “L”-Operation, die im Ersetzungs-String verwendet werden kann.

Die Pattern-Klasse unterstützt diese Operation nicht:

Perl-Konstrukte, die von dieser Klasse nicht unterstützt werden:
[…]
Die Vorverarbeitungsoperationen l u, L und U.
https://docs.oracle.com/javase/10/docs/api/java/util/regex/Pattern.html

Sie können dies in Java Regex nicht tun. Sie müssten manuell nachbearbeiten mit String.toUpperCase() und toLowerCase() stattdessen.

Hier ist ein Beispiel dafür, wie Sie mit Regex Wörter mit einer Länge von mindestens 3 in einem Satz finden und groß schreiben

    String text = "no way oh my god it cannot be";
    Matcher m = Pattern.compile("\b\w{3,}\b").matcher(text);

    StringBuilder sb = new StringBuilder();
    int last = 0;
    while (m.find()) {
        sb.append(text.substring(last, m.start()));
        sb.append(m.group(0).toUpperCase());
        last = m.end();
    }
    sb.append(text.substring(last));

    System.out.println(sb.toString());
    // prints "no WAY oh my GOD it CANNOT be"

Hinweis zu appendReplacement und appendTail

Beachten Sie, dass die obige Lösung verwendet substring und verwaltet ein tail index usw. Tatsächlich können Sie auf diese verzichten, wenn Sie verwenden Matcher.appendReplacement und appendTail.

    StringBuffer sb = new StringBuffer();
    while (m.find()) {
        m.appendReplacement(sb, m.group().toUpperCase());
    }
    m.appendTail(sb);

Beachten Sie, wie sb ist jetzt ein StringBuffer anstatt StringBuilder. Noch bis Matcher bietet StringBuilder Überlastungen, du bleibst beim Langsameren StringBuffer wenn Sie diese Methoden verwenden möchten.

Es liegt an Ihnen, ob sich der Kompromiss zwischen geringerer Effizienz für höhere Lesbarkeit lohnt oder nicht.

Siehe auch

• StringBuilder und StringBuffer auf Java

Um dies auf Regexp-Ebene zu tun, müssen Sie verwenden U um den Großbuchstabenmodus einzuschalten und E um es auszuschalten. Hier ist ein Beispiel für die Verwendung dieser Funktion in IntelliJ IDEA find-and-replace Dialog, der einen Satz von Klassenfeldern in JUnit-Assertionen umwandelt (im IDE-Tooltip ist das Ergebnis von find-and-replace Transformation):

Du könntest das benutzen Regexp-Erfassungsgruppe (wenn Sie wirklich Regex verwenden müssen, das heißt, wenn “TARGETSTRING” ist komplex genug und “regelmäßig” genug, um die Erkennung durch eine Regex zu rechtfertigen).
Sie würden sich dann bewerben toLowerCase() zur Gruppe 1.

import java.util.regex.*;

public class TargetToLowerCase {

  public static void main(String[] args) {
    StringBuilder sb= new StringBuilder(
            "my testtext TARGETSTRING my testtext");
    System.out.println(sb);
    String regex= "TARGETSTRING ";
    Pattern p = Pattern.compile(regex); // Create the pattern.
    Matcher matcher = p.matcher(sb); // Create the matcher.
    while (matcher.find()) {
      String buf= sb.substring(matcher.start(), matcher.end()).toLowerCase();
      sb.replace(matcher.start(), matcher.end(), buf);
    }
    System.out.println(sb);
  }
}

Java9+

Ab Java 9+ können Sie verwenden String::replaceAll wo du a . verwenden kannst Function<MatchResult, String> zum Beispiel verwenden wir das Beispiel der Polygenschmierstoffe:

String text = "this is just a test which upper all short words";
String regex = "\b\w{0,3}\b";
Pattern pattern = Pattern.compile(regex);
Matcher matcher = pattern.matcher(text);
String result = matcher.replaceAll(matche -> matche.group().toUpperCase());

System.out.println(result);

Oder nur :

String result = Pattern.compile(regex)
        .matcher(text)
        .replaceAll(matche -> matche.group().toUpperCase());

Ausgabe

this IS just A test which upper ALL short words
     ^^      ^                  ^^^

Wie wäre es mit dieser Transformationsfunktion in “Java 8“

/**
 * Searches the given pattern in the given src string and applies the txr to the
 * matches
 * 
 * @param src     The string to be converted
 * @param pattern the pattern for which the transformers to be applied.
 * @param txr     The transformers for the mathed patterns.
 * @return The result after applying the transformation.
 */
private static String fromTo(String src, String pattern, Function<String, String> txr) {
    Matcher m = Pattern.compile(pattern).matcher(src);

    StringBuilder sb = new StringBuilder();
    int last = 0;

    while (m.find()) {
        sb.append(src.substring(last, m.start()));
        sb.append(txr.apply(m.group(0)));
        last = m.end();
    }
    sb.append(src.substring(last));
    return sb.toString();
}