【javaSE】万字带你了解String类

比眉伴天荒 2023-10-14 14:16 161阅读 0赞

#### 目录 ####

*  String类的重要性
 *  常用方法
 *   *  字符串构造
     *   *  使用常量串构造
         *  直接newString对象
         *  使用字符数组进行构造
     *  String对象的比较
     *   *  ==比较是否引用同一个对象
         *  boolean equals(Object anObject) 方法
         *  int compareTo(String s) 方法
         *  int compareToIgnoreCase(String str) 方法
     *  字符串查找
     *   *  char charAt(int index)
         *  int indexOf(int ch)
         *  int indexOf(int ch, int fromIndex)
         *  int indexOf(String str)
         *  int indexOf(String str, int fromIndex)
         *  int lastIndexOf(int ch)
         *  int lastIndexOf(int ch, int fromIndex)
         *  int lastIndexOf(String str)
         *  int lastIndexOf(String str, int fromIndex)
     *  字符串转化
     *   *  数值和字符串转化
         *   *  数字转字符串
             *  字符串转数字
         *  大小写转换
         *   *  小写转大写
             *  大写转小写
         *  字符串和数组转化
         *   *  字符串转数组
             *  数组转字符串
         *  格式化
     *  字符串替换
     *   *  String replaceAll(String regex, String replacement)方法
         *  String replaceFirst(String regex, String replacement)方法
     *  字符串拆分
     *   *  String\[\] split(String regex)方法
         *  String\[\] split(String regex, int limit)方法
     *  字符串截取
     *   *  String substring(int beginIndex)方法
         *  String substring(int beginIndex, int endIndex)方法
     *  其他操作方法
     *   *  String trim() 方法
         *  String toUpperCase() 方法
         *  String toLowerCase() 方法
     *  字符串的不可变性
     *   *  String类在设计时就是不可改变的
         *  修改字符串内容的操作是创建一个新对象
         *  String 要设计成不可变的原因
     *  字符串修改
 *  StringBuilder和StringBuffer
 *   *  StringBuilder的介绍
 *  String、StringBuffer、StringBuilder的区别
 *  实战练习
 *  总结

## String类的重要性 ##

在C语言中已经涉及到字符串了，但是在C语言中要表示字符串只能使用字符数组或者字符指针，可以使用标准库提供的字符串系列函数完成大部分操作，但是这种将数据和操作数据方法分离开的方式不符合面相对象的思想，而字符串应用又非常广泛，因此Java语言专门提供了String类

在开发和校招笔试中，字符串也是常客，而且在面试中也频繁被问到，比如：String、StringBuff和StringBulider之间的区别等

## 常用方法 ##

### 字符串构造 ###

String类提供的构造方式非常多，常用的就以下三种

#### 使用常量串构造 ####

String s1 = "hello world";
    System.out.println(s1);

#### 直接newString对象 ####

// 直接newString对象
    String s2 = new String("hello world");
    System.out.println(s2);

#### 使用字符数组进行构造 ####

char[] array = {
        'h','e','l','l','o','w','o','r','l','d'};
    String s3 = new String(array);
    System.out.println(s1);

注意

1.  String是引用类型，内部并不存储字符串本身，在String类的实现源码中，String类实例变量如下：  
    ![在这里插入图片描述][fff25e9c4af541c19cdf466e5ba7af8f.png]  
    再比如有以下代码

String s1 = new String("hello");
    String s2 = new String("world");
    String s3 = s1;
    System.out.println(s1.length()); // 获取字符串长度---输出5
    System.out.println(s1.isEmpty()); // 如果字符串长度为0，返回true，否则返回false

此时这里s1和s2引用的是不同对象 s1和s3引用的是同一对象，图解如下  
![代码图解][46ef4719240c407d803a99fd3e848bc6.png]  
2. 在Java中" "引起来的也是String类型对象。比如

// 打印"hello"字符串(String对象)的长度
    System.out.println("hello".length());

### String对象的比较 ###

字符串的比较是常见操作之一，比如：字符串排序。Java中总共提供了4中方式：

#### ==比较是否引用同一个对象 ####

注意：对于内置类型，= = 比较的是变量中的值；对于引用类型 = =比较的是引用中的地址。

**内置类型**

int a = 10;
    int b = 20;
    int c = 10;
    // 对于基本类型变量，==比较两个变量中存储的值是否相同
    System.out.println(a == b); // false
    System.out.println(a == c); // true

**引用类型**

// 对于引用类型变量，==比较两个引用变量引用的是否为同一个对象
    String s1 = new String("hello");
    String s2 = new String("hello");
    String s3 = new String("world");
    String s4 = s1;
    System.out.println(s1 == s2); // false
    System.out.println(s2 == s3); // false
    System.out.println(s1 == s4); // true

#### boolean equals(Object anObject) 方法 ####

用于比较两个字符串是否相等

String类重写了父类Object中equals方法，Object中equals默认按照==比较，String重写equals方法后，按照如下规则进行比较

public boolean equals(Object anObject) {
        
            // 1. 先检测this 和 anObject 是否为同一个对象比较，如果是返回true
            if (this == anObject) {
        
                return true;
            } 
            // 2. 检测anObject是否为String类型的对象，如果是继续比较，否则返回false
            if (anObject instanceof String) {
        
            // 将anObject向下转型为String类型对象
                String anotherString = (String)anObject;
                int n = value.length;
            // 3. this和anObject两个字符串的长度是否相同，是继续比较，否则返回false
                if (n == anotherString.value.length) {
        
                    char v1[] = value;
                    char v2[] = anotherString.value;
                    int i = 0;
            // 4. 按照字符顺序，从前往后逐个字符进行比较
                    while (n-- != 0) {
        
                        if (v1[i] != v2[i])
                            return false;
                        i++;
                    } 
                    return true;
                }
            } 
            return false;

使用如下，比如我们有以下代码

String s1 = new String("hello");
    String s2 = new String("hello");
    String s3 = new String("Hello");

当我们使用==进行比较时

System.out.println(s1 == s2); // false
    System.out.println(s1 == s3); // false

s1、s2、s3引用的是三个不同对象，因此==比较结果全部为false  
equals比较

System.out.println(s1.equals(s2)); // true
    System.out.println(s1.equals(s3)); // false
    }

equals比较：String对象中的逐个字符  
虽然s1与s2引用的不是同一个对象，但是两个对象中放置的内容相同，因此输出true； s1与s3引用的不是同一个对象，而且两个对象中内容也不同，因此输出false

#### int compareTo(String s) 方法 ####

用于比较两个字符串的大小

与equals不同的是，equals返回的是boolean类型，而compareTo返回的是int类型具体比较方式：

1.  先按照字符串次序大小比较，如果出现不等的字符，直接返回这两个字符的大小差值
2.  如果前k个字符相等(k为两个字符长度最小值)，返回值两个字符串长度差值

使用如下

String s1 = new String("abc");
    String s2 = new String("ac");
    String s3 = new String("abc");
    String s4 = new String("abcdef");
    //大于返回大于0的值，小于返回小于0的值，等于则返回0
    System.out.println(s2.compareTo(s1)); // 不同输出字符差值1
    System.out.println(s1.compareTo(s2)); // 不同输出字符差值-1
    System.out.println(s1.compareTo(s3)); // 相同输出 0
    System.out.println(s1.compareTo(s4)); // 前k个字符完全相同，输出长度差值 -3

#### int compareToIgnoreCase(String str) 方法 ####

与compareTo方式相同，但是忽略大小写比较  
使用如下

String s1 = new String("abc");
    String s2 = new String("ac");
    String s3 = new String("ABc");
    String s4 = new String("abcdef");
    System.out.println(s1.compareToIgnoreCase(s2)); // 不同输出字符差值-1
    System.out.println(s1.compareToIgnoreCase(s3)); // 相同输出 0
    System.out.println(s1.compareToIgnoreCase(s4)); // 前k个字符完全相同，输出长度差值 -3

同理；我们的equals方法后面加上IgnoreCase也可以忽视大小写，使用如下

String s1 = new String("hello");
    String s3 = new String("Hello");
    System.out.println(s1.equalsIgnoreCase(s3)); // true

### 字符串查找 ###

字符串查找也是字符串中非常常见的操作，String类提供的常用查找的方法：

#### char charAt(int index) ####

返回index位置上字符，如果index为负数或者越界，抛出IndexOutOfBoundsException异常

String s = "aaabbbcccaaabbbccc";
    System.out.println(s.charAt(3)); // 'b'

#### int indexOf(int ch) ####

返回ch第一次出现的位置，没有返回-1

String s = "aaabbbcccaaabbbccc";
    System.out.println(s.indexOf('c')); // 6

#### int indexOf(int ch, int fromIndex) ####

从fromIndex位置开始找ch第一次出现的位置，没有返回-1

String s = "aaabbbcccaaabbbccc";
    System.out.println(s.indexOf('c', 10)); // 15

#### int indexOf(String str) ####

返回str第一次出现的位置，没有返回-1

String s = "aaabbbcccaaabbbccc";
    System.out.println(s.indexOf("bbb")); // 3

#### int indexOf(String str, int fromIndex) ####

从fromIndex位置开始找str第一次出现的位置，没有返回-1

String s = "aaabbbcccaaabbbccc";
    System.out.println(s.indexOf("bbb", 10)); // 12

#### int lastIndexOf(int ch) ####

从后往前找，返回ch第一次出现的位置，没有返回-1

String s = "aaabbbcccaaabbbccc";
    System.out.println(s.lastIndexOf('c')); // 17

#### int lastIndexOf(int ch, int fromIndex) ####

从fromIndex位置开始找，从后往前找ch第一次出现的位置，没有返回-1

String s = "aaabbbcccaaabbbccc";
    System.out.println(s.lastIndexOf('c', 10)); // 8

#### int lastIndexOf(String str) ####

从后往前找，返回str第一次出现的位置，没有返回-1

String s = "aaabbbcccaaabbbccc";
    System.out.println(s.lastIndexOf("bbb", 10)); // 3

#### int lastIndexOf(String str, int fromIndex) ####

从fromIndex位置开始找，从后往前找str第一次出现的位置，没有返回-1

String s = "aaabbbcccaaabbbccc";
    System.out.println(s.lastIndexOf("bbb", 10)); // 3

*注意：上述方法都是实例方法。*

### 字符串转化 ###

#### 数值和字符串转化 ####

##### 数字转字符串 #####

String s1 = String.valueOf(1234);
    String s2 = String.valueOf(12.34);

##### 字符串转数字 #####

int data1 = Integer.parseInt("1234");
    double data2 = Double.parseDouble("12.34");

#### 大小写转换 ####

##### 小写转大写 #####

String s1 = "hello";
    String s2 = "HELLO";
    // 小写转大写
    System.out.println(s1.toUpperCase());

##### 大写转小写 #####

String s1 = "hello";
    String s2 = "HELLO";
    // 大写转小写
    System.out.println(s2.toLowerCase());

#### 字符串和数组转化 ####

##### 字符串转数组 #####

String s = "hello";
    char[] ch = s.toCharArray();
    for (int i = 0; i < ch.length; i++) {
        
    	System.out.print(ch[i]);
    }

##### 数组转字符串 #####

char[] = {
        'a','b','c'};
    System.out.println(s2);

#### 格式化 ####

String s = String.format("%d-%d-%d", 2023, 8,5);
    System.out.println(s);

### 字符串替换 ###

使用一个指定的新的字符串替换掉已有的字符串数据，可用的方法如下：

#### String replaceAll(String regex, String replacement)方法 ####

替换所有的指定内容

System.out.println(str.replaceAll("l", "_")); //he__owor_d

#### String replaceFirst(String regex, String replacement)方法 ####

替换首个内容

System.out.println(str.replaceFirst("l", "_")); //he_loworld

*注意事项: 由于字符串是不可变对象, 替换不修改当前字符串, 而是产生一个新的字符串*

### 字符串拆分 ###

可以将一个完整的字符串按照指定的分隔符划分为若干个子字符串

#### String\[\] split(String regex)方法 ####

将字符串全部拆分

String str = "hello world hello bit" ;
     String[] result = str.split(" ") ; // 按照空格拆分
     for(String s: result) {
        
         System.out.println(s);
      }
      //运行结果
            //hello
            // world
            // hello
            // bit

#### String\[\] split(String regex, int limit)方法 ####

将字符串以指定的格式，拆分为limit组

String str = "hello world hello bit" ;
    String[] result = str.split(" ",2) ;
    for(String s: result) {
        
    	System.out.println(s);
    }
    
    //结果如下
    //hello
    //world

拆分是特别常用的操作. 一定要重点掌握. 另外有些特殊字符作为分割符可能无法正确切分, 需要加上转义

**代码示例:** 拆分IP地址

String str = "192.168.1.1" ;
    String[] result = str.split("\\.") ;
    for(String s: result) {
        
    	System.out.println(s);
    }

***注意事项***

1.  字符"|“,”\*“,”+"都得加上转义字符，前面加上 “\\” .
2.  而如果是 “” ，那么就得写成 “\\\\” .
3.  如果一个字符串中有多个分隔符，可以用"|"作为连字符.

### 字符串截取 ###

从一个完整的字符串之中截取出部分内容

#### String substring(int beginIndex)方法 ####

从指定索引截取到结尾

String str = "helloworld" ;
    System.out.println(str.substring(5));//world

#### String substring(int beginIndex, int endIndex)方法 ####

截取部分内容

String str = "helloworld" ;
    System.out.println(str.substring(0, 5));//hello

***注意事项:***

1.  索引从0开始
2.  注意前闭后开区间的写法, substring(0, 5) 表示包含 0 号下标的字符, 不包含 5 号下标

### 其他操作方法 ###

#### String trim() 方法 ####

去掉字符串中的左右空格,保留中间空格

String str = " hello world " ;
    System.out.println("["+str+"]");//[ hello world ]
    System.out.println("["+str.trim()+"]");//[hello world]

*trim 会去掉字符串开头和结尾的空白字符(空格, 换行, 制表符等)*

#### String toUpperCase() 方法 ####

字符串转大写

String str = "AaBbCc遇事问春风乄" ;
    System.out.println(str.toUpperCase());//AABBCC遇事问春风乄

#### String toLowerCase() 方法 ####

字符串转小写

String str = "AaBbCc遇事问春风乄" ;
    System.out.println(str.toLowerCase());//aabbcc遇事问春风乄

*这两个函数只转换字母*

### 字符串的不可变性 ###

String是一种不可变对象. 字符串中的内容是不可改变。字符串不可被修改，是因为：

#### String类在设计时就是不可改变的 ####

String类实现描述中已经说明了，以下来自JDK1.8中String类的部分实现  
![在这里插入图片描述][1cafe34ccf4040ab8f35c2260e1886b9.png]  
![在这里插入图片描述][c46806faa8254674afc793194d2e7669.png]  
String类中的字符实际保存在内部维护的value字符数组中，该图还可以看出：

1.  String类被final修饰，表明该类不能被继承
2.  value被修饰被final修饰，表明value自身的值不能改变，即不能引用其它字符数组，但是其引用空间中的内容可以修改。

#### 修改字符串内容的操作是创建一个新对象 ####

**改变的是新对象**，比如 replace 方法：  
![在这里插入图片描述][e3488bbf59dc426f896e33458b5a90fa.png]  
*注意*  
final修饰类表明该类不想被继承，final修饰引用类型表明该引用变量不能引用其他对象，但是其引用对象中的内容是可以修改的

#### String 要设计成不可变的原因 ####

1.  方便实现字符串对象池. 如果 String 可变, 那么对象池就需要考虑写时拷贝的问题了.
2.  不可变对象是线程安全的.
3.  不可变对象更方便缓存 hash code, 作为 key 时可以更高效的保存到 HashMap 中

那如果想要修改字符串中内容，该如何操作呢？

### 字符串修改 ###

*注意：尽量避免直接对String类型对象进行修改，因为String类是不能修改的，所有的修改都会创建新对象，效率非常低下*  
例如

public static void main(String[] args) {
        
    	String s = "hello";
    	s += " world";
    	System.out.println(s); // 输出：hello world
    }

但是这种方式不推荐使用，因为其效率非常低，中间创建了好多临时对象  
![在这里插入图片描述][97cbdc61fb08481e963e7ca4a02528a8.png]  
对String类进行修改时，效率是非常慢的，因此：尽量避免对String的直接需要，如果要修改建议尽量使用StringBuffer或者StringBuilder。

## StringBuilder和StringBuffer ##

### StringBuilder的介绍 ###

由于String的不可更改特性，为了方便字符串的修改，Java中又提供StringBuilder和StringBuffer类。这两个类大部分功能是相同的，这里介绍 StringBuilder常用的一些方法  
[ StringBuilder详情描述][StringBuilder]  
![在这里插入图片描述][ba1ee005ae2c413b9f1120ebed1f53d6.png]  
String和StringBuilder最大的区别在于String的内容无法修改，而StringBuilder的内容可  
以修改。频繁修改字符串的情况考虑使用StringBuilder  
注意：*String和StringBuilder类不能直接转换。如果要想互相转换，可以采用如下原则*:

1.  String变为StringBuilder: 利用StringBuilder的构造方法或append()方法
2.  StringBuilder变为String: 调用toString()方法

## String、StringBuffer、StringBuilder的区别 ##

1.  String的内容不可修改，StringBuffer与StringBuilder的内容可以修改.
2.  StringBuffer与StringBuilder大部分功能是相似的
3.  StringBuffer采用同步处理，属于线程安全操作；而StringBuilder未采用同步处理，属于线程不安全操作

## 实战练习 ##

[ 第一个只出现一次的字符][Link 1]  
[最后一个单词的长度][Link 2]  
[ 检测字符串是否为回文][Link 3]

## 总结 ##

关于《 万字带你了解String类》就讲解到这儿，欢迎各位留言交流以及批评指正，如果文章对您有帮助或者觉得作者写的还不错可以点一下关注，点赞，收藏支持一下。

[fff25e9c4af541c19cdf466e5ba7af8f.png]: https://img-blog.csdnimg.cn/fff25e9c4af541c19cdf466e5ba7af8f.png
[46ef4719240c407d803a99fd3e848bc6.png]: https://img-blog.csdnimg.cn/46ef4719240c407d803a99fd3e848bc6.png
[1cafe34ccf4040ab8f35c2260e1886b9.png]: https://img-blog.csdnimg.cn/1cafe34ccf4040ab8f35c2260e1886b9.png
[c46806faa8254674afc793194d2e7669.png]: https://img-blog.csdnimg.cn/c46806faa8254674afc793194d2e7669.png
[e3488bbf59dc426f896e33458b5a90fa.png]: https://img-blog.csdnimg.cn/e3488bbf59dc426f896e33458b5a90fa.png
[97cbdc61fb08481e963e7ca4a02528a8.png]: https://img-blog.csdnimg.cn/97cbdc61fb08481e963e7ca4a02528a8.png
[StringBuilder]: https://docs.oracle.com/javase/8/docs/api/
[ba1ee005ae2c413b9f1120ebed1f53d6.png]: https://img-blog.csdnimg.cn/ba1ee005ae2c413b9f1120ebed1f53d6.png
[Link 1]: https://leetcode.cn/problems/first-unique-character-in-a-string/
[Link 2]: https://www.nowcoder.com/practice/8c949ea5f36f422594b306a2300315da?tpId=37&&tqId=21224&rp=5&ru=/activity/oj&qru=/ta/huawei/question-ranking
[Link 3]: https://leetcode.cn/problems/valid-palindrome/