16、字符串_u202f

1、String

String 是不可变的，String 类中每一个看起来会修改 String 值的方法，实际上都是创建了一个全新的 String 对象，以包含修改后的字符串内容。而最初的 String 对象则丝毫未动。

对于一个方法而言，参数是为该方法提供信息的，而不是想让该方法改变自己的。

1.1、StringBuilder 与 + 重载的对比

使用StringBuilder的相关操作会更好，+内部也会使用StringBuilder

1.2 、对象的内存地址

如果你真的想要打印对象的内存地址，应该调用 Object.toString() 方法，这才是负责此任务的方法。所以，不要使用 this，而是应该调用 super.toString() 方法。this 会调用该类的toString()，造成循环调用。

1.3 String的操作

1.4 格式化输出

2、正则表达式

字符

字符类

预定义字符类

逻辑操作符

边界匹配符

量词(quantifiers)

• 贪婪型（greedy）:量词总是贪婪的，除非有其他的选项被设置。贪婪表达式会为所有可能的模式发现尽可能多的匹配。导致此问题的一个典型理由就是假定我们的模式仅能匹配第一个可能的字符组，如果它是贪婪的，那么它就会继续往下匹配。
• 勉强型（reluctant）: 用问号来指定，这个量词匹配满足模式所需的最少字符数。因此也被称作懒惰的、最少匹配的、非贪婪的或不贪婪的。
• 占有型（progressive）:目前，这种类型的量词只有在 Java 语言中才可用（在其他语言中不可用），并且也更高级，因此我们大概不会立刻用到它。当正则表达式被应用于 String 时，它会产生相当多的状态，以便在匹配失败时可以回溯。而“占有型”量词并不保存这些中间状态，因此它们可以防止回溯。它们常常用于防止正则表达式失控，因此可以使正则表达式执行起来更高效。

表达式 X 通常必须要用圆括号括起来，以便它能够按照我们期望的效果去执行。

Pattern 和 Matcher

Pattern pattern = Pattern.compile("regex"，[flag]);
Matcher matcher = pattern.matcher(pattern);
1
2

Matcher

组是用括号划分的正则表达式，可以根据组的编号来引用某个组。组号为 0 表示整个表达式，组号 1 表示被第一对括号括起来的组，以此类推。

Pattern 标记

split

split()方法将输入 String 断开成 String 对象数组，断开边界由正则表达式确定

String[] split(CharSequence input) 
String[] split(CharSequence input, int limit)
1
2

• 如果limit为正，那么匹配limit-1次
• 如果limit为0，那么会尽可能匹配所有结果，但是末尾的空字符串会被丢弃
• 如果limit为负，那么会尽可能匹配所有结果，包括末尾的空格字符

替换操作

使用正则表达式替换文本非常方便。

• replaceFirst(String replacement) 以参数字符串 replacement 替换掉第一个匹配成功的部分。
• replaceAll(String replacement) 以参数字符串 replacement 替换所有匹配成功的部分。
• appendReplacement(StringBuffer sbuf, String replacement) 执行渐进式的替换，而不是像 replaceFirst() 和 replaceAll() 那样只替换第一个匹配或全部匹配。允许调用其他的方法来处理生成的replacement(replaceFirst() 和 replaceAll() 则只能使用一个固定的字符串)，这样可以使你能够以编程的方式将目标分割成组，从而具备更强大的替换功能。
• appendTrail():执行一次或多次appendReplacement() 之后，调用此方法可以将输入字符串余下的部分复制到 sbuf 中。

import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.*;
import java.nio.file.*;
/*! Here's a block of text to use as input to 
    the regular expression matcher. Note that we 
    first extract the block of text by looking for 
    the special delimiters, then process the     
    extracted block. !*/
public class TheReplacements {
    public static void main(String[] args) throws Exception {
        String s = Files.lines(Paths.get("TheReplacements.java")).collect(Collectors.joining("\n"));
        //匹配上面的注释,需要打开dotall模式
        Matcher mInput = Pattern.compile("/\\*!(.*)!\\*/",Pattern.DOTALL).matcher(s);
        if (mInput.find()) {
            //返回第一个捕获组，及时上面表达式中(.*)匹配到的内容
            s = mInput.group(1);
        }
        //将两个或两个以上的空格替换为一个空格
        s = s.replaceAll(" {2,}", " ");
        //把每一行开头的空格去掉，需要打开多行模式
        s = s.replaceAll("(?m)^ +", "");
        System.out.println(s);

        s = s.replaceFirst("[aeiou]", "(VOWEL1)");
        StringBuffer sbuf = new StringBuffer();     
        Pattern p = Pattern.compile("[aeiou]");
        Matcher m = p.matcher(s);
        //把元音字母大写
        while (m.find()) {
            m.appendReplacement(sbuf, m.group().toUpperCase());
        }
        m.appendTail(sbuf);
        System.out.println(sbuf);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

输出结果：

Here’s a block of text to use as input to
the regular expression matcher. Note that we
first extract the block of text by looking for
the special delimiters, then process the
extracted block.
H(VOWEL1)rE’s A blOck Of tExt tO UsE As InpUt tO
thE rEgUlAr ExprEssIOn mAtchEr. NOtE thAt wE
fIrst ExtrAct thE blOck Of tExt by lOOkIng fOr
thE spEcIAl dElImItErs, thEn prOcEss thE
ExtrActEd blOck.

reset

通过 reset() 方法，可以将现有的 Matcher 对象应用于一个新的字符序列