java字符串处理_Java字符串处理

[TOC]

# 一. 字符串原理

- 概要说明

在`Java`中，`String`是一个引用类型，它本身也是一个`class`，实际上字符串在`String`内部是通过一个`char[]`数组表示的，因此，按下面的写法也是可以的`String s2 = new String(new char[] {'H', 'e', 'l', 'l', 'o', '!'});` 因为`String`太常用了，所以`Java`提供了`"..."`这种字符串字面量表示方法。`Java`字符串的一个重要特点就是字符串不可变。这种不可变性是通过内部的`private final char[]`字段，以及没有任何修改`char[]`的方法实现的。

- 早期`JDK`版本的`String`。

总是以`char[]`存储，它的定义如下：

```

public final class String {

private final char[] value;

private final int offset;

private final int count;

}

```

- 较新的`JDK`版本的`String`。

较新的`JDK`版本的`String`则以`byte[]`存储：如果`String`仅包含`ASCII`字符，则每个`byte`存储一个字符，否则，每两个`byte`存储一个字符，这样做的目的是为了节省内存，因为大量的长度较短的`String`通常仅包含`ASCII字`符：

```

public final class String {

private final byte[] value;

private final byte coder; // 0 = LATIN1, 1 = UTF16

}

```

# 二. 字符串常用方法

```

# 字符串比较

String s1 = "hello";

String s2 = "hello";

System.out.println(s1.equals(s2));

# 字符串忽略大小写比较

String s1 = "Hello";

String s2 = "hello";

System.out.println(s1.equalsIgnoreCase(s2));

"Hello".contains("ll"); // true

"Hello".indexOf("l"); // 2

"Hello".lastIndexOf("l"); // 3

"Hello".startsWith("He"); // true

"Hello".endsWith("lo"); // true

"Hello".substring(2); // "llo"

"Hello".substring(2, 4); // "ll"

# trim()移除字符串首尾空白字符，包括空格，\t，\r，\n。

" \tHello\r\n ".trim(); // "Hello"

# strip()移除字符串首尾空白字符，包括空格，\t，\r，\n。strip()还能移除类似中文的空格字符\u3000。

"\u3000Hello\u3000".strip(); // "Hello"

" Hello ".stripLeading(); // "Hello "

" Hello ".stripTrailing(); // " Hello"

"".isEmpty(); // true，因为字符串长度为0

" ".isEmpty(); // false，因为字符串长度不为0

" \n".isBlank(); // true，因为只包含空白字符

" Hello ".isBlank(); // false，因为包含非空白字符

# 替换子串方法一：replace 字符或字符串

String s = "hello";

s.replace('l', 'w'); // "hewwo"，所有字符'l'被替换为'w'

s.replace("ll", "~~"); // "he~~o"，所有子串"ll"被替换为"~~"

# 替换子串方法二：replaceAll 正则

String s = "A,,B;C ,D";

s.replaceAll("[\\,\\;\\s]+", ","); // "A,B,C,D"

# 分割字符串：传入参数可以是正则，也可以是字符串

String s = "A,,,B, C,D";

String[] ss = s.split("[,\\s]+"); // {"A", "B", "C", "D"}

# 拼接字符串

String[] arr = {"A", "B", "C"};

String s = String.join("***", arr); // "A***B***C"

# 字符串格式化

String s1 = "Hi %s!".formatted("Alice");

String s2 = String.format("Hi %s!", "Alice");

# 其他类型转换为 => 字符串

String.valueOf(123); // "123"

String.valueOf(45.67); // "45.67"

String.valueOf(true); // "true"

# 字符串类型转换为 => 其他类型

int n1 = Integer.parseInt("123"); // 123

boolean b1 = Boolean.parseBoolean("true"); // true

boolean b2 = Boolean.parseBoolean("fALSE"); // false

# String 和 char[] 类型可以互相转换

char[] cs = "Hello".toCharArray(); // String -> char[]

String s = new String(cs); // char[] -> String

```

# 三. 字符串编码转换

在`Java`中，`char`类型实际上就是两个字节的`Unicode`编码。如果我们要手动把字符串转换成其他编码，可以如下这样做。注意：转换编码后，就不再是`char`类型，而是`byte`类型表示的数组。

```

byte[] b1 = "Hello".getBytes(); // 按ISO8859-1编码转换，不推荐

byte[] b2 = "Hello".getBytes("UTF-8"); // 按UTF-8编码转换

byte[] b2 = "Hello".getBytes("GBK"); // 按GBK编码转换

byte[] b3 = "Hello".getBytes(StandardCharsets.UTF_8); // 按UTF-8编码转换

```

如果要把已知编码的`byte[]`转换为`String`，可以这样做。始终牢记：`Java`的`String`和`char`在内存中总是以`Unicode`编码表示。

```

byte[] b = ...

String s1 = new String(b, "GBK"); // 按GBK转换

String s2 = new String(b, StandardCharsets.UTF_8); // 按UTF-8转换

```

# 四. 字符串拼接

- 方法1：`StringBuilder`(推荐)

```

var sb = new StringBuilder(1024);

sb.append("Mr ")

.append("Bob!")

.insert(0, "Hello, ");

String s1 = sb.toString();

```

- 方法二：`StringBuffer`(不推荐)

```

var sb = new StringBuffer(1024);

sb.append("Mr ")

.append("Bob!")

.insert(0, "Hello, ");

String s1 = sb.toString();

```

- 方法三：`StringJoiner`(推荐)

```

String[] names = {"Bob", "Alice", "Grace"};

var sj = new StringJoiner(", ", "Hello ", "!"); // 指定拼接字符串的 开头 和 结尾

// var sj = new StringJoiner(", "); // 不指定拼接字符串的 开头 和 结尾

for (String name : names) {

sj.add(name);

}

String s1 = sj.toString();

```

- 方法四：`String.join`

`String`还提供了一个静态方法`join()`，这个方法在内部使用了`StringJoiner`来拼接字符串，在不需要指定“开头”和“结尾”的时候，用`String.join()`更方便：

```

String[] names = {"Bob", "Alice", "Grace"};

var s = String.join(", ", names);

```