【JAVA】String 类

约定不等于承诺〃 2024-04-23 20:28 0阅读 0赞

> ⭐ 作者：小胡\_不糊涂  
> 🌱 作者主页：[小胡\_不糊涂的个人主页][Link 1]  
> 📀 收录专栏：[浅谈Java][Java]  
> 💖 持续更文，关注博主少走弯路，谢谢大家支持 💖

#### String ####

*  1. 字符串构造
 *  2. String对象的比较
 *  3. 字符串查找
 *  4. 转化
 *  5. 字符串替换
 *  6. 字符串拆分
 *  7. 字符串截取
 *  8. 其他操作方法
 *  9. 字符串的不可改变性

![在这里插入图片描述][8fe194fd1eb14a65aba21b56e88b890b.gif_pic_center]

## 1. 字符串构造 ##

String类常用的构造方法：

public class Main {
        
        public static void main(String[] args) {
        
    		// 使用常量串构造
            String s1 = "hello bit";
            System.out.println(s1);
            
       		// 直接newString对象
            String s2 = new String("hello bit");
            System.out.println(s1);
            
    		// 使用字符数组进行构造
            char[] array = {
        'h','e','l','l','o','b','i','t'};
            String s3 = new String(array);
            System.out.println(s1);
        }
    }

注：

1.  **String是引用类型，内部并不存储字符串本身。**

**例如：**

public static void main(String[] args) {
        
    	// s1和s2引用的是不同对象 s1和s3引用的是同一对象
    	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、s3在虚拟机栈中三者的存储位置都不同，但在堆区中s1和s2所指向的是同一个空间，也就是"hello"的存储空间。

1.  **在Java中 “” 引起来的也是String类型对象。**

**例如：**

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

## 2. String对象的比较 ##

> 字符串的比较是常见操作之一，比如：字符串排序。

Java中总共提供了4中方式：

1.  **==比较是否引用同一个对象**  
    对于内置类型，== 比较的是变量中的值；对于引用类型 == 比较的是引用中的地址。

**例如：**

public static void main(String[] args) {
        
            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
        }

🍤 *运行结果：*

![在这里插入图片描述][07a856fab7b84a3da8c0ef2f987a9dee.png]

1.  **`boolean equals(Object anObject)` 方法：按照字典序比较**

> 字典序：字符大小的顺序

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

public static void main(String[] args) {
        
            String s1 = new String("hello");
            String s2 = new String("hello");
            String s3 = new String("Hello");
            
    		// s1、s2、s3引用的是三个不同对象，因此==比较结果全部为false
            System.out.println(s1 == s2); // false
            System.out.println(s1 == s3); // false
            
    		// equals比较：String对象中的逐个字符
    		// 虽然s1与s2引用的不是同一个对象，但是两个对象中放置的内容相同，因此输出true
    		// s1与s3引用的不是同一个对象，而且两个对象中内容也不同，因此输出false
            System.out.println(s1.equals(s2)); // true
          System.out.println(s1.equals(s3)); // false
        }

equal的比较方式：

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;
        }

1.  **`int compareTo(String s)` 方法: 按照字典序进行比较**

> equals返回的是**boolean类型**，而compareTo返回的是**int类型**。

具体比较方式：

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

**例如：**

public static void main(String[] args) {
        
            String s1 = new String("abc");
            String s2 = new String("ac");
            String s3 = new String("abc");
            String s4 = new String("abcdef");
            System.out.println(s1.compareTo(s2)); // 不同输出字符差值-1
            System.out.println(s1.compareTo(s3)); // 相同输出 0
            System.out.println(s1.compareTo(s4)); // 前k个字符完全相同，输出长度差值 -3
        }

1.  **`int compareToIgnoreCase(String str)` 方法**

与compareTo方式相同，但是忽略大小写比较，**例如：**

public static void main(String[] args) {
        
            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
        }

## 3. 字符串查找 ##

常用查找的方法：

<table> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th>功能</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>char charAt(int index)</td> 
   <td>返回index位置上字符，如果index为负数或者越界，抛出IndexOutOfBoundsException异常</td> 
  </tr> 
  <tr> 
   <td>int indexOf(int ch)</td> 
   <td>返回ch第一次出现的位置，没有返回-1</td> 
  </tr> 
  <tr> 
   <td>int indexOf(int ch, int fromIndex)</td> 
   <td>从fromIndex位置开始找ch第一次出现的位置，没有返回-1</td> 
  </tr> 
  <tr> 
   <td>int indexOf(String str)</td> 
   <td>返回str第一次出现的位置，没有返回-1</td> 
  </tr> 
  <tr> 
   <td>int indexOf(String str, int fromIndex)</td> 
   <td>从fromIndex位置开始找str第一次出现的位置，没有返回-1</td> 
  </tr> 
  <tr> 
   <td>int lastIndexOf(int ch)</td> 
   <td>从后往前找，返回ch第一次出现的位置，没有返回-1</td> 
  </tr> 
  <tr> 
   <td>int lastIndexOf(int ch, int fromlndex)</td> 
   <td>从fromIndex位置开始找，从后往前找ch第一次出现的位置，没有返回-1</td> 
  </tr> 
  <tr> 
   <td>int lastIndexOf(Stringstr)</td> 
   <td>从后往前找，返回str第一次出现的位置，没有返回-1</td> 
  </tr> 
  <tr> 
   <td>int lastIndexOf(String str, int fromlndex)</td> 
   <td>从fromIndex位置开始找，从后往前找str第一次出现的位置，没有返回-1</td> 
  </tr> 
 </tbody> 
</table>

**实例：**

public static void main(String[] args) {
        
            String s = "aaabbbcccaaabbbccc";
            System.out.println(s.charAt(3)); // 'b'
            System.out.println(s.indexOf('c')); // 6
            System.out.println(s.indexOf('c', 10)); // 15
            System.out.println(s.indexOf("bbb")); // 3
            System.out.println(s.indexOf("bbb", 10)); // 12
            System.out.println(s.lastIndexOf('c')); // 17
            System.out.println(s.lastIndexOf('c', 10)); // 8
            System.out.println(s.lastIndexOf("bbb")); // 12
            System.out.println(s.lastIndexOf("bbb", 10)); // 3
        }

## 4. 转化 ##

1.  **数值和字符串转化**

public static void main(String[] args) {
        
            // 数字转字符串
            String s1 = String.valueOf(1234);
            String s2 = String.valueOf(12.34);
            String s3 = String.valueOf(true);
            System.out.println(s1);//"1234"
            System.out.println(s2);//"12.34"
            System.out.println(s3);//"true"
            System.out.println("=================================");
            // 字符串转数字
            // Integer、Double等是Java中的包装类型
            int data1 = Integer.parseInt("1234");
            double data2 = Double.parseDouble("12.34");
            System.out.println(data1);//1234
            System.out.println(data2);//12.34
        }

1.  **大小写转换**

public static void main(String[] args) {
        
            String s1 = "heLlo";
            String s2 = "HELLO";
            // 小写转大写
            System.out.println(s1.toUpperCase());//HELLO
            // 大写转小写
            System.out.println(s2.toLowerCase());//hello
        }

1.  **字符串转数组**

public static void main(String[] args) {
        
            String s = "hello";
            // 字符串转数组
            char[] ch = s.toCharArray();
            for (int i = 0; i < ch.length; i++) {
        
                System.out.print(ch[i]);
            }
            System.out.println();
            // 数组转字符串
            String s2 = new String(ch);
            System.out.println(s2);
        }

1.  **格式化**

//格式化
        public static void main(String[] args) {
        
            String s = String.format("%d-%d-%d", 2019, 9,14);
            System.out.println(s);//2019-9-14
        }

## 5. 字符串替换 ##

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

<table> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th>功能</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>String replaceAll(String regex, String replacement)</td> 
   <td>替换所有的指定内容</td> 
  </tr> 
  <tr> 
   <td>String replaceFirst(String regex, String replacement)</td> 
   <td>替换首个内容</td> 
  </tr> 
 </tbody> 
</table>

**实例：**

public static void main(String[] args) {
        
            String str = "helloworld" ;
            System.out.println(str.replaceAll("l", "_"));//he__owor_d
            System.out.println(str.replaceFirst("l", "_"));//he_loworld
        }

`🍩字符串是不可变对象，替换-不修改当前字符串，而是产生一个新的字符串。`

## 6. 字符串拆分 ##

可以将一个完整的字符串按照指定的分隔符划分为若干个子字符串。可用方法如下：

<table> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th>功能</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>String[] split(String regex)</td> 
   <td>将字符串全部拆分</td> 
  </tr> 
  <tr> 
   <td>String[] split(String regex, int limit)</td> 
   <td>将字符串以指定的格式，拆分为limit组</td> 
  </tr> 
 </tbody> 
</table>

**实例：实现字符串的拆分处理**

public static void main(String[] args) {
        
            String str = "hello world" ;
            String[] result = str.split(" ") ; // 按照空格拆分
            for(String s: result) {
        
                System.out.println(s);
            }
        }

🍤 *运行结果：*

![在这里插入图片描述][3bcee4e096ca4ea49c12acedb75a9c10.png]

**实例：字符串的部分拆分**

public static void main(String[] args) {
        
            String str = "hello beautiful world " ;
            String[] result = str.split(" ",2) ;
            for(String s: result) {
        
                System.out.println(s);
            }
        }

🍤 *运行结果：*

![在这里插入图片描述][108e116e76f5494d9eee176de498ca4d.png]  
`🍩有些特殊字符作为分割符可能无法正确切分，需要加上转义。`

**实例：拆分IP地址**

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

🍤 *运行结果：*

![在这里插入图片描述][ceee9d04e99046afb495cb8aeac4c0aa.png]  
注：

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

**实例：多次拆分**

public static void main(String[] args) {
        
            String str = "name=zhangsan&age=18" ;
            String[] result = str.split("&") ;
            for (int i = 0; i < result.length; i++) {
        
                String[] temp = result[i].split("=") ;
                System.out.println(temp[0]+" = "+temp[1]);
            }
        }

🍤 *运行结果：*

![在这里插入图片描述][e79f7b2d10ad4fdfab48131a5760e07d.png]

## 7. 字符串截取 ##

从一个完整的字符串之中截取出部分内容。可用方法如下：

<table> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th>功能</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>String substring(int beginIndex)</td> 
   <td>从指定索引截取到结尾</td> 
  </tr> 
  <tr> 
   <td>String substring(int beginIndex, int endIndex)</td> 
   <td>截取部分内容</td> 
  </tr> 
 </tbody> 
</table>

**实例：**

public static void main(String[] args) {
        
            String str = "helloworld" ;
            System.out.println(str.substring(5));
            System.out.println(str.substring(0, 5));
        }

🍤 *运行结果：*  
![在这里插入图片描述][5c9fd20fb2704abe9a16113f0b36640a.png]

注：

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

## 8. 其他操作方法 ##

<table> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th>功能</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>String trim()</td> 
   <td>去掉字符串中的左右空格,保留中间空格</td> 
  </tr> 
  <tr> 
   <td>String toUpperCase()</td> 
   <td>字符串转大写</td> 
  </tr> 
  <tr> 
   <td>String toLowerCase()</td> 
   <td>字符串转小写</td> 
  </tr> 
 </tbody> 
</table>

**实例：trim()方法的使用**

public static void main(String[] args) {
        
            String str = " hello world " ;
            System.out.println("["+str+"]");
            System.out.println("["+str.trim()+"]");
        }

🍤 *运行结果：*

![在这里插入图片描述][19a8261590c04b71b667b815048a4562.png]  
`🍩trim 会去掉字符串开头和结尾的空白字符（空格、换行、制表符等)。`

**实例：大小写转换**

public static void main(String[] args) {
        
            String str = " hello%$$%@#$%world 哈哈 " ;
            System.out.println(str.toUpperCase());
            System.out.println(str.toLowerCase());
        }

🍤 *运行结果：*

![在这里插入图片描述][bebe5ae3dfad4d9cae63e260eed86d67.png]

## 9. 字符串的不可改变性 ##

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

1.  **String类在设计时就是不可改变的，它的内容在创建好之后就不能被修改。**

> String类中的字符实际保存在内部维护的value字符数组中；  
> String类被final修饰，表明该类不能被继承；  
> value被修饰被final修饰，表明value自身的值不能改变，即不能引用其它字符数组，但是其引用空间中的内容可以修改。

1.  **所有涉及到可能修改字符串内容的操作都是创建一个新对象，改变的是新对象**

> final修饰类表明该类不想被继承，final修饰引用类型表明该引用变量不能引用其他对象，但是其引用对象中的内  
> 容是可以修改的。

为什么String要设计成不可变的？

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

--------------------

![在这里插入图片描述][c05fc0ad5b0e45adaaa8e478890d1ab7.png]

[Link 1]: https://blog.csdn.net/iLoyo_
[Java]: http://t.csdn.cn/P9HTz
[8fe194fd1eb14a65aba21b56e88b890b.gif_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/f1648c8b831b403abe046789b4d16cc7.gif
[07a856fab7b84a3da8c0ef2f987a9dee.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/b4f73ee7bc9e4024a1f05fd507f28156.png
[3bcee4e096ca4ea49c12acedb75a9c10.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/3d37bc1bca1b41ca89a1e8bee407e0d5.png
[108e116e76f5494d9eee176de498ca4d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/96dbf3e2020f45aeba782f939b758885.png
[ceee9d04e99046afb495cb8aeac4c0aa.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/6ee4f12084ab4e7daeb552045a12077e.png
[e79f7b2d10ad4fdfab48131a5760e07d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/e9647a2318da40c59e48871af06531dc.png
[5c9fd20fb2704abe9a16113f0b36640a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/1af31e86aa3c4999ad0b95b1efea1d41.png
[19a8261590c04b71b667b815048a4562.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/534dfa6a4e80414eb8b47c849b3eaaaf.png
[bebe5ae3dfad4d9cae63e260eed86d67.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/19208b8a29a747099241d7d52bbee126.png
[c05fc0ad5b0e45adaaa8e478890d1ab7.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/2c62dcab0d6e4cbe87061a90ccac17cf.png