Java中的字符串String

落日映苍穹つ 2024-02-18 12:53 66阅读 0赞

**目录**

一、常用方法

1、字符串构造

2、String对象的比较

（1）、equals方法

（2）、compareTo方法

（3）、compareToIgnoreCase方法（忽略大小写进行比较）

3、字符串查找

4、转化

（1）数值和字符串转化

编辑

（2）大小写转换

（3）字符串转数组

（4）格式化

5、字符串替换

6、字符串拆分

7、字符串截取

8、其他操作方法

二、String的不可变性

三、StringBuffer和StingBuilder

1、方法：

2、String、StringBuffer、StringBuilder的区别

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

## 一、常用方法 ##

### 1、字符串构造 ###

三种构造方法

**（1）、直接赋值**

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

**（2）、创建出新的对象**

String s2 = new String("hello");
    System.out.println(s2);

**（3）、使用字符数组进行构造**

char[] ch = {'h','e','l','l','o'};
    String s3 = new String(ch);
    System.out.println(s3);

**三个输出效果如下：**

> ![425f4bc42b5147e3bbbbffdadd59c385.png][]

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

对于基本变量，可以直接用 “==， <， >， <=， >= ”来进行比较，但对于引用类型变量，不可以直接使用上面的表达式来比较，如图：

> 代码：
> 
>     String s1 = new String("hello");
>     String s2 = new String("hello");
>     System.out.println(s1 == s2);
> 
> ![bd92a0f522a9426898c6af91da7227a0.png][]
> 
> s1和s2的内容都是一样的，为啥下面输出false呢？
> 
> 原因是s1和s2是引用类型，使用上述表达式进行比较，比较的是两个对象的地址，两个对象是不同的，地址自然也是不同的。

那么怎么可以比较引用对象的内容呢？有以下方法：

#### （1）、equals方法 ####

> 按照字典序比较，字典序：字符大小。
> 
> Object的equals默认是按 “==” 进行比较的，如图：
> 
> ![944d1e3fab4646e8b45b854612957881.png][]
> 
> 所以类都默认继承Object类，String继承Object类，重写了equals方法，如图：
> 
> ![5bf21ba616424d15910e5ced87e803da.png][]
> 
> **方法的使用：**
> 
> 代码：
> 
>     String s1 = new String("hello");
>             String s2 = new String("hello");
>             System.out.println(s1.equals(s2));
>     
>             String s3 = new String("Hello");
>             System.out.println(s1.equals(s3));
> 
> 执行效果：
> 
> ![16c6b7bb0fb745b2bdb51350d3bc1c6d.png][]

#### （2）、compareTo方法 ####

> 按照字典序比较，和equals方法不同的是：equals返回的是boolean类型，而compareTo返回的是int类型，具体比较方式：
> 
> 1、先按照字典序大小比较，如果出现不相等的字符，直接返回这两个字符的大小差值。
> 
> 2、如果前k个字符相同，返回两个字符串长度差值。
> 
> **方法内部：**
> 
>     public int compareTo(String anotherString) {
>             int len1 = value.length;
>             int len2 = anotherString.value.length;
>             int lim = Math.min(len1, len2);
>             char v1[] = value;
>             char v2[] = anotherString.value;
>     
>             int k = 0;
>             while (k < lim) {
>                 char c1 = v1[k];
>                 char c2 = v2[k];
>                 if (c1 != c2) {
>                     return c1 - c2;
>                 }
>                 k++;
>             }
>             return len1 - len2;
>         }
> 
> **方法使用：**
> 
> 代码：
> 
>     String s1 = new String("ab");
>             String s2 = new String("ac");
>             String s3 = new String("ab");
>             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
> 
> 执行效果：
> 
> ![fb36beff2e6546239e38840e9531793f.png][]

#### （3）、compareToIgnoreCase方法（忽略大小写进行比较） ####

与compareTo方法一样，不过忽略大小写

> **方法内部：**
> 
> ![0627075a9fad4a4e85aed1082727264e.png][]
> 
>     public static final Comparator<String> CASE_INSENSITIVE_ORDER
>                                              = new CaseInsensitiveComparator();
>         private static class CaseInsensitiveComparator
>                 implements Comparator<String>, java.io.Serializable {
>             // use serialVersionUID from JDK 1.2.2 for interoperability
>             private static final long serialVersionUID = 8575799808933029326L;
>     
>             public int compare(String s1, String s2) {
>                 int n1 = s1.length();
>                 int n2 = s2.length();
>                 int min = Math.min(n1, n2);
>                 for (int i = 0; i < min; i++) {
>                     char c1 = s1.charAt(i);
>                     char c2 = s2.charAt(i);
>                     if (c1 != c2) {
>                         c1 = Character.toUpperCase(c1);
>                         c2 = Character.toUpperCase(c2);
>                         if (c1 != c2) {
>                             c1 = Character.toLowerCase(c1);
>                             c2 = Character.toLowerCase(c2);
>                             if (c1 != c2) {
>                                 // No overflow because of numeric promotion
>                                 return c1 - c2;
>                             }
>                         }
>                     }
>                 }
>                 return n1 - n2;
>             }
> 
> **方法的使用：**
> 
> 代码：
> 
>     String s1 = new String("hello");
>             String s2 = new String("Hello");
>             System.out.println(s1.compareToIgnoreCase(s2));
> 
> 执行效果：
> 
> ![10c428ad52c747199d073b2d97482261.png][]

### 3、字符串查找 ###

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

### 4、转化 ###

#### （1）数值和字符串转化 ####

> **数值转字符串：**
> 
>     String s1 = String.valueOf(1234);
>             String s2 = String.valueOf(12.34);
>             System.out.println(s1);
>             System.out.println(s2);
>     
>             System.out.println("==============");
>     
>             String s3 = String.valueOf(true);
>             String s4 = String.valueOf(new Student("Hanmeimei", 18));
>             System.out.println(s3);
>             System.out.println(s4);
> 
> #### ![ac7c2c0ae1e84fe2a3171d3d5b7ddb32.png][] ####
> 
> 整型转换为字符串型的内部代码：
> 
>     public static String valueOf(int i) {
>             return Integer.toString(i);
>         }
> 
> double类型转换为字符串型代码：
> 
>     public static String valueOf(double d) {
>             return Double.toString(d);
>         }
> 
> boolean转换为字符串的内部代码：
> 
>     public static String valueOf(boolean b) {
>             return b ? "true" : "false";
>         }
> 
> 引用类型转换为字符串型的内部代码：
> 
>     public static String valueOf(Object obj) {
>             return (obj == null) ? "null" : obj.toString();
>         }

> **字符串转换为整型 / double类型：**
> 
> **代码：**
> 
>     int data1 = Integer.parseInt("1234");
>     Double data2 = Double.parseDouble("12.34");
> 
> 如图，执行效果：
> 
> ![1bdd896bf589455a93031cefd06679fb.png][]

####    （2）大小写转换 ####

> **代码:**
> 
>     String s1 = "hello";
>             String s2 = "HELLO";
>             //小写转大写
>             System.out.println(s1.toUpperCase());
>             //大写转小写
>             System.out.println(s2.toLowerCase());
> 
> **执行效果：**
> 
> ![7949a11ec3754f40923c54b5582953a0.png][]

#### （3）字符串转数组 ####

> **代码：**
> 
>     //字符串转数组
>     char[] ch = s1.toCharArray();
>     //数组转字符串
>     String s2 = new String(ch);
> 
> **执行效果**
> 
> ![98d87983f7084fad9796d8b5fe8e0241.png][]

#### （4）格式化 ####

> **代码：**
> 
>     String s = String.format("%d-%d-%d", 2023, 11, 21);
> 
> **执行效果：**
> 
> ![3051ed0829244df2957ab2562ee8316a.png][]

### 5、字符串替换 ###

使用一个新的字符串替换旧的字符串，方法如下：

<table> 
 <tbody> 
  <tr> 
   <td>方法</td> 
   <td>功能</td> 
  </tr> 
  <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>

> **代码：**
> 
>     String str = "hello world";
>     System.out.println(str.replaceAll("l", "-"));
>     System.out.println(str.replaceFirst("l", "-"));
> 
> **执行效果：**
> 
> ![6948bda298064c1483948e205268f62a.png][]

### 6、字符串拆分 ###

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

<table> 
 <tbody> 
  <tr> 
   <td>方法</td> 
   <td>功能</td> 
  </tr> 
  <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>

> **代码：**
> 
>     String s1 = "hello world hello bit";
>             String[] result = s1.split(" ");
>             for(String x : result) {
>                 System.out.println(x);
>             }
> 
> **执行效果：**  
> ![3601452d89bd4683a3c80f15cbab809b.png][]
> 
> **字符串的部分拆分代码：**  
> 
> 
>     String s1 = "hello world hello bit";
>             String[] result = s1.split(" ", 2);
>             for(String x : result) {
>                 System.out.println(x);
>             }
> 
> ![379c54ff55b442cfb2df0a8564b76f2d.png][]
> 
> **拆分IP地址：**  
> 
> 
>     String s1 = "192.168.1.1";
>             String[] result = s1.split("\\.");
>             for(String x : result) {
>                 System.out.println(x);
>             }
> 
> **执行效果：**
> 
> ![c6abc06c3753406fa575a1dfaef4e7e8.png][]
> 
> **注意：**要写划分ip地址，在字符串里写进转义字符，在字符串里，两个 “ \\\\ ” 代表一个 “ \\ ” 
> 
> 1. 字符"|","\*","+"都得加上转义字符，前面加上 "\\\\" .  
> 2. 而如果是 "\\" ，那么就得写成 "\\\\\\\\" .  
> 3. 如果一个字符串中有多个分隔符，可以用"|"作为连字符.
> 
> 如下：
> 
>     String s1 = "192.16-8.1.1";
>             String[] result = s1.split("\\.|-");
>             for(String x : result) {
>                 System.out.println(x);
>             }
> 
> ![96b307a48bd242ab81e3afa120e83026.png][]
> 
> 代码示例: 多次拆分  
> 
> 
>     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]);
>     }

### 7、字符串截取 ###

从一个完整的字符串截取出部分内容，方法如下：

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

> 代码：
> 
>     String s = "helloworld";
>             System.out.println(s.substring(5));
>             System.out.println(s.substring(0, 5));
> 
> 执行效果：
> 
> ![04e6531ebbe048bcb6f2497f33be22ab.png][]
> 
> **注意：**区间是是前闭后开的规则，上面的第二个substring语句，是 \[0,5）。所以不包含5下标。

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

<table> 
 <tbody> 
  <tr> 
   <td>方法</td> 
   <td>功能</td> 
  </tr> 
  <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 会去掉字符串开头和结尾的空白字符(空格, 换行, 制表符等).  
后面两个函数只转换字母

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

## 二、String的不可变性 ##

String是一种不可变对象. 字符串中的内容是不可改变。字符串不可被修改，是因为：  
**1. String类在设计时就是不可改变的，String类实现描述中已经说明了**  
![e23603c3a9f54a5c9662d36593fd979f.png][]

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

**2. 所有涉及到可能修改字符串内容的操作都是创建一个新对象，改变的是新对象**  
比如 replace 方法：  
![02a8ab6b10e74cc782112f40498516e8.png][]

原因不是final，

> **final修饰类表明该类不想被继承，final修饰引用类型表明该引用变量不能引用其他对象，但是其引用对象中的内容是可以修改的**  
> 代码验证如下：
> 
>     final int array[] = {1,2,3,4,5};
>     array[0] = 100;
>     System.out.println(Arrays.toString(array));
>     //array = new int[]{4,5,6}; //java: 无法为最终变量array分配值
> 
> 执行效果：
> 
> ![f1b113ab831942038c9811549900f74a.png][]
> 
> ![692f797c42d94ce894aecec6881c71bf.png][]

**注意：**尽量避免直接对String类型对象进行修改，因为String类是不能修改的，所有的修改都会创建新对象，效率非常低下，尽量避免对String的直接修改，如果要修改建议尽量使用StringBuffer或者StringBuilder。

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

## 三、StringBuffer和StingBuilder ##

### 1、方法： ###

<table> 
 <tbody> 
  <tr> 
   <td>方法</td> 
   <td>说明</td> 
  </tr> 
  <tr> 
   <td>StringBuff append(String<br> str)</td> 
   <td>在尾部追加，相当于String的+=，可以追加：boolean、char、char[]、<br> double、float、int、long、Object、String、StringBuff的变量</td> 
  </tr> 
  <tr> 
   <td>char charAt(int index)</td> 
   <td>获取index位置的字符</td> 
  </tr> 
  <tr> 
   <td>int length()</td> 
   <td>获取字符串的长度</td> 
  </tr> 
  <tr> 
   <td>int capacity()</td> 
   <td>获取底层保存字符串空间总的大小</td> 
  </tr> 
  <tr> 
   <td>void ensureCapacity(int<br> mininmumCapacity)</td> 
   <td>扩容</td> 
  </tr> 
  <tr> 
   <td>void setCharAt(int index,<br> char ch)</td> 
   <td>将index位置的字符设置为ch</td> 
  </tr> 
  <tr> 
   <td>int indexOf(String str)</td> 
   <td>返回str第一次出现的位置</td> 
  </tr> 
  <tr> 
   <td>int indexOf(String str, int<br> fromIndex)</td> 
   <td>从fromIndex位置开始查找str第一次出现的位置</td> 
  </tr> 
  <tr> 
   <td>int lastIndexOf(String str)</td> 
   <td>返回最后一次出现str的位置</td> 
  </tr> 
  <tr> 
   <td>int lastIndexOf(String str,<br> int fromIndex)</td> 
   <td>从fromIndex位置开始找str最后一次出现的位置</td> 
  </tr> 
  <tr> 
   <td>StringBuff insert(int<br> offset, String str)</td> 
   <td>在offset位置插入：八种基类类型 &amp; String类型 &amp; Object类型数据</td> 
  </tr> 
  <tr> 
   <td>StringBuffer<br> deleteCharAt(int index)</td> 
   <td>删除index位置字符</td> 
  </tr> 
  <tr> 
   <td>StringBuffer delete(int<br> start, int end)</td> 
   <td>删除[start, end)区间内的字符</td> 
  </tr> 
  <tr> 
   <td>StringBuffer replace(int<br> start, int end, String str)</td> 
   <td>将[start, end)位置的字符替换为str</td> 
  </tr> 
  <tr> 
   <td>String substring(int start)</td> 
   <td>从start开始一直到末尾的字符以String的方式返回</td> 
  </tr> 
  <tr> 
   <td>String substring(int<br> start，int end)</td> 
   <td>将[start, end)范围内的字符以String的方式返回</td> 
  </tr> 
  <tr> 
   <td>StringBuffer reverse()</td> 
   <td>反转字符串</td> 
  </tr> 
  <tr> 
   <td>String toString()</td> 
   <td>将所有字符按照String的方式返回</td> 
  </tr> 
 </tbody> 
</table>

String和StringBuilder最大的区别在于String的内容无法修改，而StringBuilder的内容可以修改。

和StringBuffer的区别也是。频繁修改字符串的情况考虑使用StringBuilder / StringBuffer。

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

（1）String的内容不可修改，StringBuffer和StringBuilder的内容可修改。

（2）StringBuffer和StringBuilder的大部分功能一样。

（3）StringBuffer采用同步处理，属于线程安全操作，StringBuilder未采用同步处理，不属于线程安全操作。

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

## 都看到这了，点个赞再走吧，谢谢谢谢谢！！ ##

[425f4bc42b5147e3bbbbffdadd59c385.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/18/235fb7f90c7e4730b1f3d0c688a2b6d3.png
[bd92a0f522a9426898c6af91da7227a0.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/18/c3f9e714184e48aa9a7d30b222ec3238.png
[944d1e3fab4646e8b45b854612957881.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/18/1a9536f26f4e4fec8d46e194f56d9123.png
[5bf21ba616424d15910e5ced87e803da.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/18/b9cfb04412ce4a1e93585a05e98fa247.png
[16c6b7bb0fb745b2bdb51350d3bc1c6d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/18/fb5ab9706a2c4ee09ac639a675270696.png
[fb36beff2e6546239e38840e9531793f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/18/021f038a910149c892766ec895aafcff.png
[0627075a9fad4a4e85aed1082727264e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/18/9a8596b42c4e40bbbc01ff2bd6c927e5.png
[10c428ad52c747199d073b2d97482261.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/18/823894f68e2c4fb2bf1428cee4140ce7.png
[ac7c2c0ae1e84fe2a3171d3d5b7ddb32.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/18/c9e2866db06145c88f79295393682941.png
[1bdd896bf589455a93031cefd06679fb.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/18/e79de64168cb48f6919c76ea8eebfb8a.png
[7949a11ec3754f40923c54b5582953a0.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/18/0032af6d7e9340f7b19970ade1deaef3.png
[98d87983f7084fad9796d8b5fe8e0241.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/18/d068574856ee404a8ff483c51fda954b.png
[3051ed0829244df2957ab2562ee8316a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/18/fb240afbae4c4c1e9dc1716fed5ceaeb.png
[6948bda298064c1483948e205268f62a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/18/2857d19ecc984197bae9da631cae1fe6.png
[3601452d89bd4683a3c80f15cbab809b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/18/4a3ee60e49fd4665a427259554f0cb8d.png
[379c54ff55b442cfb2df0a8564b76f2d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/18/21625e4c5c7e4225be127cadc446c93c.png
[c6abc06c3753406fa575a1dfaef4e7e8.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/18/b35b0419b59647a5bfa350f00d5f8468.png
[96b307a48bd242ab81e3afa120e83026.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/18/641a73508d6e4e94b9fe82520f88abfe.png
[04e6531ebbe048bcb6f2497f33be22ab.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/18/d5e4db432ac1416f918ebdcda6e79de8.png
[e23603c3a9f54a5c9662d36593fd979f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/18/c31edf76767e4fb5a5dbf2f2d2da097f.png
[02a8ab6b10e74cc782112f40498516e8.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/18/26b0891be1a343ab9e86acdf197f4360.png
[f1b113ab831942038c9811549900f74a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/18/71df889c55f0475eadeb27baa3295151.png
[692f797c42d94ce894aecec6881c71bf.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/18/6e893850fd2c4318b06478c49a469f85.png