String类型

String类

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

1.1 类的声明

public final class String
    implements 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引入的。

@IntrinsicCandidate
    public 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的拼接过程

1. 当执行String s1 = "abc"和String s2 = "def"时，"abc" 和 "def" 这两个字符串常量被放入字符串常量池，s1和s2分别指向常量池中的这两个对象。
2. 对于s3 = s1 + s2，由于涉及到对字符串变量的操作，Java 会在后台创建一个StringBuilder对象来进行拼接。它会先将s1指向的 "abc" 添加到StringBuilder中，然后再将s2指向的 "def" 添加进去。
3. 最后，通过调用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 之前 永久代

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

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

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

1.7  String 类常用方法

length

equals 与 equalsIgnoreCase

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

startswith  与 endswith

    @Test
    public void testStartsWithAndEndsWith() {
        System.out.println("http://www.baidu.com".startsWith("http://")); // true
        System.out.println("http://www.baidu.com".endsWith(".com")); // true

        System.out.println("http://www.baidu.com".startsWith("https://")); //false
        System.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`：要比较的字符数。

2.

 `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，说明两个字符串相等。

    @Test
    public void testCompareTo() {
        System.out.println("a".compareTo("b")); // -1
        System.out.println("a".compareTo("c")); // -2
        System.out.println("b".compareTo("a")); // 1
        System.out.println("a".compareTo("a")); // 0

        System.out.println("A".compareTo("a")); // -32

        System.out.println("A".compareToIgnoreCase("a")); // 0
    }

- 注意事项：

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

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

contains

    @Test
    public void testContains() {
        System.out.println("HelloWorld.java".contains(".java")); // true
        System.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。

原文地址：https://blog.csdn.net/2301_80090573/article/details/143778439

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！