当前位置：首页 > news >正文

String类型

news 2025/12/23 17:03:46

String类

在Java中，String 类是一个非常核心且常用的类，它用于表示文本值，即字符序列或者说字符串。

1.1 类的声明

public final class Stringimplements java.io.Serializable, Comparable<String>, CharSequence

解释：

final：String 类前面的 final 关键字表明这个类不能被继承。这意味着任何试图扩展 String 类的行为都是非法的。这主要是因为字符串在 Java 中是不可变的（immutable），如果允许继承，则子类可能会破坏这种不变性。
Serializable：String 类实现了 Serializable 接口，这表示 String 对象可以被序列化。序列化是指将对象的状态保存到一个字节流中，以便可以在网络上传输或者以后使用（例如存储到磁盘上）。任何实现了 Serializable 接口的对象都可以被 Java 的内置序列化机制处理。
Comparable：String 类实现了 Comparable 接口，这意味着 String 对象可以相互比较它们的大小。具体来说，可以通过 compareTo() 方法来比较两个字符串的字典顺序（即按照字母表顺序），从而确定它们之间的关系（相等、小于或大于）。
CharSequence：String 类也实现了 CharSequence 接口，这是一个定义了字符序列的基本操作的接口。CharSequence 接口中定义的方法包括获取某个位置的字符、获取序列长度等基本功能。String 类自然地支持这些方法，因为字符串本身就是一种字符序列。

1.2 内部属性

在 JDK 8 中，String 类内部使用 char 数组来存储字符串数据。
从 JDK 9 开始，String 类内部使用 byte 数组来存储数据，并引入 coder 字段来指示编码方式。

// JDK 8 及以前
private final char value[];// JDK 9 及以后
private final byte value[];
private final int coder; // 编码信息

1.3 String实例化的两种方式

第1种方式：String s1 = "hello";
第2种方式：String s2 = new String("hello");

第二种方式: 被IntrinsicCandidate 注解标注了。这个注解是Java16引入的。

@IntrinsicCandidatepublic String(String original) {this.value = original.value;this.coder = original.coder;this.hash = original.hash;this.hashIsZero = original.hashIsZero;}

String s2 = new String("hello");

底层会有两个对象，一个是"hello"在字符串常量池中。一个是在堆内存中。浪费内存。

1.5 字符串的拼接

当在Java中使用+运算符连接字符串，尤其是在有变量参与的情况下，Java会在后台创建一个StringBuilder对象来进行字符串的拼接，并在最后通过调用toString()方法将StringBuilder转换为String对象。这样做可以提高字符串拼接的效率。

一::字符串常量池的特性

字符串常量池用于存放字符串常量，这些常量在编译期就可以确定。它的主要目的是避免重复创建相同的字符串对象，以节省内存空间。

例如，当你直接定义String s = "abc"时，"abc" 这个字符串常量会被放入字符串常量池，如果后续又有一个String s2 = "abc"，那么s2会直接指向常量池中已有的 "abc" 对象，而不会再创建一个新的对象。

二、s1 + s2的拼接过程

当执行String s1 = "abc"和String s2 = "def"时，"abc" 和 "def" 这两个字符串常量被放入字符串常量池，s1和s2分别指向常量池中的这两个对象。
对于s3 = s1 + s2，由于涉及到对字符串变量的操作，Java 会在后台创建一个StringBuilder对象来进行拼接。它会先将s1指向的 "abc" 添加到StringBuilder中，然后再将s2指向的 "def" 添加进去。
最后，通过调用StringBuilder的toString()方法创建一个新的String对象，这个新对象并不是在字符串常量池中创建的，而是在堆内存中。

三. intern() 方法：

如果将 s3 指向的字符串放入字符串常量池，可以显式地调用 intern() 方法：

String s3 = (s1 + s2).intern();


String m = "m";
String f = m + "e";
String str = f.intern(); // 将"me"放入字符串常量池中，并且将"me"对象的地址返回。

1.6 关于String类的构造方法

1.6.1 String(char[] value) String(char[] value, int index, int count)

 若:有一个byte[]数组，可以将byte[]数组或者其中一部分转换成字符串,这是一个解码的过程。（采用的是平台默认的字符编码方式进行的解码。）

// 有一个char[]数组，可以将char[]数组转换成字符串
char[] chars = new char[]{'你','好','优','秀'};
// 转换成字符串
String s1 = new String(chars);
System.out.println(s1);
// 将char[]数组的一部分转换成字符串
String s2 = new String(chars, 0, 2);
System.out.println(s2);

1.6.2 编码与解码

使用指定字符集

// 将字符串转换成byte[]数组（这个过程是一个编码的过程）
byte[] bs = "你好".getBytes(StandardCharsets.UTF_8);
// 将以上的byte[]数组转换成字符串（这个过程是一个解码的过程）
//String s5 = new String(bs, "UTF-8");
String s5 = new String(bs, StandardCharsets.UTF_8);
System.out.println(s5);String s6 = new String( bs, Charset.defaultCharset() );  在不知道字符编码方式的时候，可以
动态获取平台的编码方式。
（使用平台默认的字符集进行编码）

1.4 字符串常量的存储位置

> 字符串常量都存储在字符串常量池(StringTable)中

> 字符串常量池不允许存放两个相同的字符串常量。

> 字符串常量池，在不同的jdk版本中，存放位置不同。

jdk8及之后：字符串常量池存放在堆空间。

Jdk8 之前永久代

字符串常量池的工作原理可以总结如下：

编译阶段确定：在编译Java源代码时，所有的字符串字面量都会被确定下来。
JVM启动时初始化：当JVM启动时，会初始化字符串常量池，将所有字符串字面量放入其中。
运行时直接使用：在程序运行时，如果需要使用某个字符串字面量，可以直接从字符串常量池中获取，而不需要每次都创建新的字符串对象。
提高效率：由于避免了重复创建相同的字符串对象，字符串常量池可以节省内存空间并提高程序的执行效率。
缓存技术：字符串常量池本质上是一种缓存技术，它预先创建了字符串对象，以便在需要时快速访问。

/*** 在java程序当中，凡是带有双引号的字符串，在编译阶段就已经完全确定了：这些字符串字面量将来会放在字符串常量池中。* 在JVM启动的时候，会进行一系列的初始化，其中就包括字符串常量池的初始化，在初始化字符串常量池的时候，会将所有的* 字符串字面量全部提前创建好，放到字符串常量池中。在执行java程序的过程中，如果需要这个字符串字面量对象，直接从*           字符串常量池中获取。提高执行效率。** Java8之后：字符串常量池在堆内存当中。** 字符串常量池是一种缓存技术。提前创建好对象放进去，用的时候直接拿。（字符串字面量在JVM启动的时候就会创建好。）*/

1.7 String 类常用方法

length

equals 与 equalsIgnoreCase

        String s3 = "Java";String s4 = "java";System.out.println(s3.equals(s4)); // falseSystem.out.println(s3.equalsIgnoreCase(s4)); // true

startswith 与 endswith

    @Testpublic void testStartsWithAndEndsWith() {System.out.println("http://www.baidu.com".startsWith("http://")); // trueSystem.out.println("http://www.baidu.com".endsWith(".com")); // trueSystem.out.println("http://www.baidu.com".startsWith("https://")); //falseSystem.out.println("http://www.baidu.com".endsWith(".cn")); // false}

`regionMatches` 是 Java 中 `String` 类的一个方法，它用于比较两个字符串在指定区域内的子串是否相等。这个方法有两个重载版本：

1. `public boolean regionMatches(int toffset, String other, int ooffset, int len)`

这个版本的 `regionMatches` 方法会区分大小写。参数解释如下：
- `toffset`：当前字符串中开始比较的位置。
- `other`：另一个要进行比较的字符串。
- `ooffset`：`other` 字符串中开始比较的位置。
- `len`：要比较的字符数。

`public boolean regionMatches(boolean ignoreCase, int toffset, String other, int ooffset, int len)`

这个版本允许你指定是否忽略大小写来进行比较。额外的参数是：
- `ignoreCase`：如果为 `true`，则比较时忽略大小写；如果为 `false`，则区分大小写。

当你调用 `regionMatches` 时，它会返回一个布尔值，表示两个指定区域的子串是否相等。例如，如果你想要比较 `"HelloWorld"` 从索引 0 开始的 5 个字符与 `"helloJava"` 从索引 0 开始的 5 个字符，并且不区分大小写，你可以这样写代码：

```java
String s1 = "HelloWorld";
String s2 = "helloJava";
boolean result = s1.regionMatches(true, 0, s2, 0, 5);
// 结果应该是 true，因为 "Hello" 和 "hello" 在忽略大小写的情况下是相同的。
```

compareTo

用于按字典顺序比较两个字符串。这个方法是基于 Unicode 值来比较字符串中的字符的。

- 返回值：一个整数，表示调用该方法的字符串（即当前字符串）与参数字符串之间的相对顺序。

- 如果返回值为负数，说明当前字符串在字典顺序上位于参数字符串之前。

- 如果返回值为正数，说明当前字符串在字典顺序上位于参数字符串之后。

- 如果返回值为 0，说明两个字符串相等。

    @Testpublic void testCompareTo() {System.out.println("a".compareTo("b")); // -1System.out.println("a".compareTo("c")); // -2System.out.println("b".compareTo("a")); // 1System.out.println("a".compareTo("a")); // 0System.out.println("A".compareTo("a")); // -32System.out.println("A".compareToIgnoreCase("a")); // 0}

- 注意事项：

- `compareTo` 是区分大小写的，这意味着大写字母和小写字母会被视为不同的字符。

- 如果你需要进行忽略大小写的比较，可以使用 `compareToIgnoreCase` 方法。

contains

    @Testpublic void testContains() {System.out.println("HelloWorld.java".contains(".java")); // trueSystem.out.println("HelloWorld.java".contains(".txt")); // false}

substring

// 截取子字符串

截取字符串中介于两个指定下标之间的字符

str.substring(beginIndex, endIndex)

 注意：不包括endIndex

拼接字符串

concat 与 "+"

String s = "ab";
System.out.println(s + 1);
// concat方法
System.out.println(s.concat(String.valueOf(2)));

+ 运算符可以连接任意数量的字符串，

而 concat 方法只能连接两个字符串

使用 + 运算符时，非字符串类型的操作数会被自动转换为字符串；

而使用 concat 方法时，如果传入非字符串类型的参数，会抛出异常。

即:

不能连接 null，会抛出 NullPointerException。
不能连接多个字符串，必须链式调用

String s1 = "test";
String s2 = null;
String s3 = s1 + s2;
System.out.println(s3); // "testnull"/*String s1 = "test";
String s2 = null;
String s3 = s1.concat(s2); // 空指针异常*/

`String.join()` 方法（Java 8+）

String.join() 方法

用于连接多个字符串，并在每个字符串之间插入指定的分隔符。

有两个重载版本

String.join(CharSequence delimiter, CharSequence... elements)
这个方法接受两个参数：delimiter：这是一个CharSequence类型的参数，它表示用作分隔符的字符序列。这个分隔符会被插入到连接的字符串元素之间。
elements：这是一个变长参数，接受CharSequence类型的数组。这些是将要被连接的字符串元素。

String.join(CharSequence delimiter, Iterable<? extends CharSequence> elements)
这个方法接受两个参数：delimiter：与第一个版本相同，这是一个CharSequence类型的参数，表示分隔符。
elements：这是一个Iterable类型的参数，其元素必须是CharSequence的子类型。这个方法会遍历这个可迭代对象中的所有元素，并将它们连接起来。

eg:

 // 创建一个集合对象List list = new ArrayList();list.add("abc");list.add("def");list.add("xyz");System.out.println(String.join("-", list));  abc-def-xyz

去除空格

trim()

trim() 方法是最常用的方法之一，它用于删除字符串两端的空白字符。这里的空白字符包括空格、制表符、换行符等

                 ASCII码的空白 , （无法去除全角空白）

`strip()`

从 Java 11 开始，引入了 strip() 方法，它与 trim() 功能相似，但 strip() 去除的是根据 Unicode 标准来标识的所有空格字符，而不仅仅局限于 ASCII 中的空格字符

`stripLeading()` 和 `stripTrailing()`

从 Java 11 引入的，分别用于只删除字符串开头或结尾的空白字符

非字符串 ->字符串

`String.valueOf()`

Object obj = 42;
String str = String.valueOf(obj);         "42"

+ 号拼接

String的正则表达式相关的方法：

①String replace(CharSequence target, CharSequence replacement);

将当前字符串中所有的target替换成replacement，返回一个新的字符串。

②String replaceAll(String regex, String replacement);

将当前字符串中所有符合正则表达式的regex替换成replacement。

public void testReplace(){// 这个也是替换所有，只不过没有使用正则表达式String str1 = "oraclejavac++mysqlphppythonjavamysql".replace("java", "golang");System.out.println(str1);// 替换所有数字，使用正则表达式String str2 = "a1b2c3d54e43f".replaceAll("\\d", "");System.out.println(str2);}

③String[] split(String regex);

将当前字符串以某个正则表达式表示的子字符串进行分割，返回一个字符串数组。

④boolean matches(String regex);

判断当前字符串是否符合正则表达式regex。