使用 Java 和 RegEx 转换字符串中的大小写

Use Java and RegEx to convert casing in a string

提问by Andreas

Problem: Turn

问题：转弯

"My Testtext TARGETSTRING My Testtext" 

into

进入

"My Testtext targetstring My Testtext"

Perl supports the "\L"-operation which can be used in the replacement-string.

Perl 支持可以在替换字符串中使用的“\L”操作。

The Pattern-Class does not support this operation:

Pattern-Class 不支持此操作：

Perl constructs not supported by this class: [...] The preprocessing operations \l \u, \L, and \U. https://docs.oracle.com/javase/10/docs/api/java/util/regex/Pattern.html

此类不支持 Perl 构造：[...] 预处理操作 \l \u、\L 和 \U。 https://docs.oracle.com/javase/10/docs/api/java/util/regex/Pattern.html

采纳答案by polygenelubricants

You can't do this in Java regex. You'd have to manually post-process using String.toUpperCase()and toLowerCase()instead.

您不能在 Java 正则表达式中执行此操作。您必须使用String.toUpperCase()and手动进行后期处理toLowerCase()。

Here's an example of how you use regex to find and capitalize words of length at least 3 in a sentence

下面是一个示例，说明如何使用正则表达式查找句子中长度至少为 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"

---

---

Note on appendReplacementand appendTail

注意appendReplacement和appendTail

Note that the above solution uses substringand manages a tailindex, etc. In fact, you can go without these if you use Matcher.appendReplacementand appendTail.

请注意，上述解决方案使用substring和管理tail索引等。实际上，如果使用Matcher.appendReplacementand ，则可以不使用这些appendTail。

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

Note how sbis now a StringBufferinstead of StringBuilder. Until Matcherprovides StringBuilderoverloads, you're stuck with the slower StringBufferif you want to use these methods.

注意sb现在是一个StringBuffer而不是StringBuilder. 在Matcher提供StringBuilder重载之前，StringBuffer如果你想使用这些方法，你会被困在较慢的地方。

It's up to you whether the trade-off in less efficiency for higher readability is worth it or not.

以较低的效率换取较高的可读性是否值得，这取决于您。

See also

也可以看看

• StringBuilderand StringBufferin Java

• StringBuilder而StringBuffer在Java中

回答by VonC

You could use the regexp capturing group(if you really need to use regex, that is, meaning if "TARGETSTRING" is complex enough and "regular" enough to justify being detected by a regex).
You would then apply toLowerCase()to the group #1.

您可以使用正则表达式捕获组（如果您确实需要使用正则表达式，也就是说，如果“ 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);
  }
}

回答by Andriy Kryvtsun

To do this on regexp level you have to use \Uto switch on uppercase mode and \Eto switch it off. Here is an example how to use this feature in IntelliJ IDEA find-and-replacedialog which transforms set of class fields to JUnit assertions (at IDE tooltip is a result of find-and-replacetransformation):

要在正则表达式级别执行此操作，您必须使用\U打开大写模式并将\E其关闭。以下是如何在 IntelliJ IDEAfind-and-replace对话框中使用此功能的示例，该对话框将类字段集转换为 JUnit 断言（IDE 工具提示是find-and-replace转换的结果）：

回答by YCF_L

Java9+

Java9+

From Java 9+ you can use String::replaceAllwhere you can use a Function<MatchResult, String>for example we use the example of polygenelubricants:

从 Java 9+ 开始，您可以使用String::replaceAll，您可以在其中使用Function<MatchResult, String>例如我们使用polygenelubricants的示例：

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

Or Just :

要不就 ：

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

Output

输出

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

回答by Kannan Ramamoorthy

How about this transformation function in "Java 8"

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