String类

String 类是 Java 中最常用的类之一，用于表示和操作字符串。字符串在 Java 中是不可变的（immutable），这意味着一旦创建了一个 String 对象，它的值就不能被改变。

字符串的拼接

String a = "HH" + "abc"

这种拼接方式会在编译时被优化为一个字符串常量。编译器会将 "HH" + "abc" 直接合并为 "HHabc"，并将其放入字符串常量池中
String a = b + "abc"或者String a = b + c

这种拼接方式会在运行时通过 StringBuilder 或 StringBuffer 完成。编译器会将 b + "abc" 转换为以下代码
```
StringBuilder sb = new StringBuilder();
sb.append(b);
sb.append("abc");
String a = sb.toString();//会new String字符串
```

字符串相关方法

创建字符串

使用字符串字面量创建字符串

String str1 = "Hello, World!";
person.name = "Hello, World!";
//这种方式创建的字符串会被存储在字符串常量池中，如果常量池中已经存在相同内容的字符串，则直接引用该字符串

使用 new 关键字

String str2 = new String("Hello, World!");
//这种方式会在堆内存中创建一个新的 String 对象，即使字符串常量池中已经存在相同内容的字符串

字符串的不可变性
- String 类的不可变性意味着一旦字符串被创建，它的值就不能被改变。任何对字符串的修改操作（如拼接、替换等）都会创建一个新的 String 对象
```
String str = "Hello";
str = str + ", World!";  // 创建一个新的字符串对象
```
String类中的常用方法
1. 构造方法
  - String()：创建一个空字符串对象
  - String(String original)：根据指定的字符串创建一个新的字符串对象
  - String(char[] value)：根据字符数组创建一个新的字符串对象
  - String(char[] value, int offset, int count)：根据字符数组的一部分创建一个新的字符串对象
  - String(byte[] bytes)根据字节数组（使用默认字符编码）创建一个新的字符串对象
  - String(byte[] bytes, String charsetName)根据字节数组和指定的字符编码创建一个新的字符串对象
```
String str = new String(); // str = ""
String str = new String("Hello"); // str = "Hello"

char[] charArray = {'H', 'e', 'l', 'l', 'o'};
String str = new String(charArray); // str = "Hello"

char[] charArray = {'H', 'e', 'l', 'l', 'o'};
String str = new String(charArray, 1, 3); // str = "ell"

byte[] byteArray = {72, 101, 108, 108, 111};
String str = new String(byteArray); // str = "Hello"

byte[] byteArray = {72, 101, 108, 108, 111};
String str = new String(byteArray, "UTF-8"); // str = "Hello"
```
2. 静态方法，通过 String 类直接调用的方法
  - String.format(String format, Object... args)根据指定的格式字符串和参数生成格式化字符串
```
String formattedStr = String.format("Name: %s, Age: %d", "Alice", 25); // formattedStr = "Name: Alice, Age: 25"
```
  - String.join(CharSequence delimiter, CharSequence... elements)使用指定的分隔符将多个字符序列连接成一个字符串
```
String joinedStr = String.join(", ", "Java", "Python", "C++"); // joinedStr = "Java, Python, C++"
```
  - String.valueOf(Object obj)将对象转换为字符串
3. 成员方法，是通过 String 对象调用的方法
  - intern() 方法intern() 方法可以将字符串对象添加到字符串常量池中，并返回常量池中的引用
```
String str1 = new String("Hello").intern();
String str2 = new String("Hello").intern();
System.out.println(str1 == str2); // true，str1 和 str2 引用常量池中的同一个对象
```
  - length()返回字符串的长度
```
int len = "Hello".length(); // len = 5
```
  - charAt(int index)返回指定索引处的字符
```
char ch = "Hello".charAt(1); // ch = 'e'
```
  - substring(int beginIndex)返回从 beginIndex 开始到字符串末尾的子字符串
```
String sub1 = "Hello, World!".substring(7); // sub1 = "World!"
```
  - substring(int beginIndex, int endIndex)返回从 beginIndex 开始到 endIndex - 1 的子字符串
```
String sub2 = "Hello, World!".substring(0, 5); // sub2 = "Hello"
```
  - concat(String str)将指定字符串拼接到当前字符串的末尾
```
String newStr = "Hello".concat(", World!"); // newStr = "Hello, World!"
```
  - 字符串比较
    1. equals(Object anObject)比较字符串的内容是否相等（区分大小写）
```
boolean isEqual = "Hello".equals("hello"); // isEqual = false
```
    2. equalsIgnoreCase(String anotherString)比较字符串的内容是否相等（不区分大小写）
```
boolean isEqualIgnoreCase = "Hello".equalsIgnoreCase("hello"); // isEqualIgnoreCase = true
```
    3. compareTo(String anotherString)按字典顺序比较两个字符串
      
      实现了Comparable接口
```
int result = "Hello".compareTo("World"); // result < 0
```
  - indexOf(String str)返回指定子字符串第一次出现的索引
```
int index = "Hello, World!".indexOf("World"); // index = 7
```
  - lastIndexOf(String str)返回指定子字符串最后一次出现的索引
```
int lastIndex = "Hello, World!".lastIndexOf("o"); // lastIndex = 8
```
  - replace(char oldChar, char newChar)替换字符串中所有 oldChar 为 newChar
```
String replacedStr = "Hello".replace('o', 'O'); // replacedStr = "HellO"

String newStr = "Hello, World!".replace("World", "Java"); // newStr = "Hello, Java!"
```
  - toLowerCase()、toUpperCase()将字符串转换为大、小写
```
String lowerStr = "Hello".toLowerCase(); // lowerStr = "hello"

String upperStr = "Hello".toUpperCase(); // upperStr = "HELLO"
```
  - trim()去除字符串开头和结尾的空白字符
```
String trimmedStr = "  Hello  ".trim(); // trimmedStr = "Hello"
```
  - split(String regex)根据正则表达式将字符串拆分为字符串数组
```
String[] parts = "Java,Python,C++".split(","); // parts = ["Java", "Python", "C++"]
```
  - startsWith(String prefix)、endsWith(String suffix)检查字符串是否以指定的前缀开头或指定的后缀结尾
```
boolean startsWith = "Hello".startsWith("He"); // startsWith = true

boolean endsWith = "Hello".endsWith("lo"); // endsWith = true
```
  - isEmpty()检查字符串是否为空（长度为 0）
```
boolean isEmpty = "".isEmpty(); // isEmpty = true
```

String编码方式

内部编码机制
- Java的字符串（String类）在内存中始终以Unicode形式存储，这是JVM规范强制要求的。无论源文件或外部数据采用何种编码（如GBK、UTF-8），编译后的class文件会将所有字符统一转换为Unicode编码
- 例如：String s = "汉字"在JVM中存储为Unicode码点，与源文件编码无关

String内容的存储

在 Java 8 及更早版本中，String 类的内部实现使用 char[] 来存储字符数据。每个 char 占用 2 个字节（16 位），无论字符的实际编码是什么
```
String str = "Hello";
```
在内存中，str 的 char[] 数组如下，每个字符占用 2 个字节，因此 "Hello" 占用 5 * 2 = 10 字节
```
char[] value = {'H', 'e', 'l', 'l', 'o'};
```
在 Java 9 中，String 类的内部实现改为使用 byte[]，并引入了一个 coder 字段来标识字符编码。coder 的值可以是

0：表示字符串使用 Latin-1 编码（ISO-8859-1）

1：表示字符串使用 UTF-16 编码
```
String str = "Hello";
```
在内存中，str 的 byte[] 数组如下，每个字符占用 1 个字节，因此 "Hello" 占用 5 * 1 = 5 字节
```
byte[] value = {72, 101, 108, 108, 111}; // Latin-1 编码
byte coder = 0; // 表示 Latin-1 编码
```

String中的一些知识点
String是final类，不能被其他的类继承
String中存在private final char value[];用于存放字符串内容
value[] 是 String 类的核心属性，用于存储字符串的字符数据。String 类的几乎所有方法（如 length()、charAt()、substring() 等）都是基于 value[] 实现的
在 Java 9 及更高版本中，String 类的实现从 char[] 改为 byte[]，并引入了一个 coder 字段来标识字符编码（Latin-1 或 UTF-16）。这种优化可以减少内存占用

posted @ 2025-03-03 21:55 QAQ001 阅读(14) 评论(0) 收藏举报

刷新页面返回顶部

Learn-Review-blog

String类

String类

String编码方式

String内容的存储

公告