Ответ 1

Вы не можете сделать это в регулярном выражении Java. Вам нужно будет выполнить постобработку вручную, используя вместо этого String.toUpperCase() и toLowerCase().

Вот пример того, как вы используете регулярное выражение, чтобы найти и использовать слова длиной не менее 3 в предложении

    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"

Примечание к appendReplacement и appendTail

Обратите внимание, что вышеупомянутое решение использует substring и управляет индексом tail и т.д. Фактически, вы можете обойтись без них, если используете Matcher.appendReplacement и appendTail.

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

Обратите внимание, что sb теперь является StringBuffer вместо StringBuilder. Пока Matcher не обеспечит перегрузки StringBuilder, если вы захотите использовать эти методы, вы застрянете с более медленным StringBuffer.

Вам решать, стоит ли компромисс в меньшей эффективности для большей читабельности или нет.

Смотрите также

• StringBuilder и StringBuffer на Java

Ответ 2

Вы можете использовать группу захвата регулярного выражения (если вам действительно нужно использовать регулярное выражение, то есть, если "TARGETSTRING" достаточно сложный и "регулярный" достаточно, чтобы оправдать обнаружение регулярным выражением).
Затем вы примените toLowerCase() к группе № 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);
  }
}

Ответ 3

Чтобы сделать это на уровне регулярных выражений, вы должны использовать \U для включения режима прописных букв и \E для его отключения. Вот пример того, как использовать эту функцию в диалоговом окне IntelliJ IDEA find-and-replace, которое преобразует набор полей класса в утверждения JUnit (подсказка в IDE является результатом преобразования find-and-replace):

Ответ 4

Java9+

Из Java 9+ вы можете использовать String :: replaceAll, где вы можете использовать Function<MatchResult, String>, например, мы используем пример полигеномасляных смазок :

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

или просто:

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

Выход

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

Ответ 5

Как насчет этой функции преобразования в "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();
}