java12-字符串操作类String、StringBuffer、StringBuilder

╰+攻爆jí腚メ 2022-01-07 20:35 287阅读 0赞

# 1.概述 #

刚看了一下，我截图的文档字太小了好像有点看不清，请放大浏览器页面观看（Ctrl + 鼠标滚轮）或者到  [官方API文档查看][API]

无论是哪种编程语言，对字符串的操作都是必不可少的。JAVA中为我们提供了三个操作字符串的类，分别是String、StringBuffer、StringBuilder，下面我们将会详细进行介绍。

String、StringBuffer、StringBuilder类都是在java.lang包中定义的。所有的应用程序都可以使用他们。所有的这些类都被声明为final，这就意味着这些类不能有子类。这使得对于通用的字符串操作

可以采用特定的优化用来提高性能，并且这三个类都实现了CharSequeue接口。

提示：所谓的String类型对象中的字符串不可改变是指创建了String实例后不能修改实例的值。但是在任何时候都可以修改String引用变量，使其指向其他String对象。

# 2. String类 #

## 　　2.1 构造函数： ##

String类有众多的构造函数。一般我们使用一个传入一个字符串的构造函数。当然，如果我们想创建一个空字符串，可以使用默认的构造函数。

其它构造函数列表如下：

![1676271-20190520184517553-1144027454.png][]

## 　　2.2 其他方法 ##

这里也不再赘述，要学会查询文档！ 这里给出常用函数列表：

![1676271-20190520184653711-964212051.png][]

![1676271-20190520184720897-239095578.png][]

![1676271-20190520184754787-1959177630.png][]

![1676271-20190520184823766-1778274389.png][]

## 　　2.3 注意事项 ##

1. String 字符串是支持+号连接的，并且在编译时，String会将+号去掉，用来简化拼接方式。

2. 当字符串与数字进行连接的时候，若字符串在数字之前，则将数字转换成字符串，然后进行连接；若数字在前，则先对数字进行计算，将计算的结果与字符串进行拼接。（仅限+号）

1 public class TestString {
     2 
     3     public static void main(String[] args) {
     4         String s1 = "abc"+ 5+2;  //直接拼接
     5         String s2 = 5+2+"abc"; //先计算后拼接
     6         String s3 = "abc"+5*2;//对于出去+号之外的都要先计算再拼接
     7         System.out.println(s1); //abc52
     8         System.out.println(s2); //7abc
     9         System.out.println(s3); //abc10
    10     }
    11 
    12 }

3.equals 与 == 的区别：equals 是用来比较两个字符串的值是否相等（只要值相等即可，并不要求引用相同），而==是比较两个字符串的引用地址是否是同一个地址（尽管值相等，但是引用地址不一定相等）

public class TestString {
    
        public static void main(String[] args) {
            String s1 = new String("xiaobai");
            String s2 = new String("xiaobai");
            System.out.println(s1.equals(s2)); //true  值相等
            System.out.println(s1==s2); //false //不是相同的引用    
        }
    
    }

4.字符串的单一性（常量保存）：字符串是不可变对象，而且是存储在常量区的，意思就是说，如果常量区中有某一个字符串，当我们再次声明它时，jvm并不会为我们再创建一个新的字符串，而是将已经存在的字符串的引用返回。

public class TestString {
        public static void main(String[] args) {
            String s1 = "xiaobai";
            String s2 = "xiaobai";
            System.out.println(s1.equals(s2)); //true  值相等
            System.out.println(s1==s2); //true 常量单一    
        }
    }

# 3.StringBuffer类 #

## 　　3.1 概述 ##

我们知道，String类对象一旦确定就不能再修改，因为String类中的字符存储数组是final的。java为我们提供了一个可以更改的字符串操作类：StringBuffer。

## 　　3.2 构造函数 ##

同理，这里直接给出构造函数：

![1676271-20190520191122823-609160083.png][]

## 　　3.3 其他方法 ##

![1676271-20190520191248712-1901816709.png][]

![1676271-20190520191310974-1265438885.png][]

![1676271-20190520191332740-912084682.png][]

## 　　3.4 注意事项 ##

1.StringBuffer 不支持直接字面量赋值（也就是说不能直接把String对象引用赋值给StringBuffer），必须使用new 的形式。

public class TestString {
        public static void main(String[] args) {
            StringBuffer s1 = "xiaobai"; //不合法 
            StringBuffer sb = new StringBuffer("ssss"); //正确
            
        }
    }

2. StringBuffer 中的append方法可以进行链式调用，并且返回结果是最后一次链式调用的结果

public class TestString {
        public static void main(String[] args) {
            StringBuffer sb = new StringBuffer("xiao")
                    .append("bai").append("ni").append("hao");
            System.out.println(sb); //xiaobainihao
        }
    }

3.StringBuffer是线程不安全的。

# 4.StringBuilder类 #

## 　　4.1 概述 ##

我们上面有提到，StringBuffer不是同步的，也就是说是线程不安全的。StringBuffer的优势是在于得到更高的性能。若我们同时有多个线程修改这个字符串怎么保证线程安全？

当然，我们可以选择加锁同步。不过java已经为我们提供了一个类——StringBuilder  该类与StringBuffer基本相同，只不过他是线程安全的。

## 　　4.2 构造方法 ##

![1676271-20190520192253170-82122664.png][]

## 　　4.3 其它常用方法 ##

与StringBuffer 基本相同，这里不再进行展示。

## 　　4.4 注意事项 ##

这里也没什么可说的，等想到了再回来补充。

# 5.String、StringBuffer、StringBuilder 比较 #

这三个类的比较无非是效率（运行速度/内存占用）和线程安全上，

## 　　首先我们来看一下速度： ##

下面这段代码分别是创建和拼接一万个次的执行时间： 可以看出 执行时间效率 StringBuilder > StringBuffer > String

造成这种情况的原因也很简单，因为String 是单一实例（final）每次都要创建新对象并修改引用，所以最慢。

而StringBuffer和StringBuilder的时间要比String短得多，原因也很简单，他只是在原有的字符串数组做添加操作，并不需要生成新对象和修改引用。

StringBuilder比StringBuffer快的原因是StringBuffer实现了线程安全（synchronized），每次操作要获得锁，导致费时较长（但是要比String快的多）。

1 public class TestString {
     2     public static void main(String[] args) {
     3         System.gc();
     4         long stringStart = System.currentTimeMillis();
     5         String s1 = new String();
     6         for(int i=0;i<100000;i++) {
     7             s1 =s1 + i;
     8         }
     9         long stringEnd = System.currentTimeMillis();
    10         System.out.println("10w String instance coast: "+(stringEnd-stringStart)+" ms");
    11     
    12         long stringBufferStart = System.currentTimeMillis();
    13         StringBuffer s2 = new StringBuffer();
    14         for(int i=0;i<100000;i++) {
    15             s2 = s2.append(i);
    16         }
    17         long stringBufferEnd = System.currentTimeMillis();
    18         System.out.println("10w StringBuffer instance coast: "+(stringBufferEnd-stringBufferStart)+" ms");
    19     
    20         long stringBuilderStart = System.currentTimeMillis();
    21         StringBuilder s3 = new StringBuilder();
    22         for(int i=0;i<100000;i++) {
    23             s3 = s3.append(i);
    24         }
    25         long stringBuilderEnd = System.currentTimeMillis();
    26         System.out.println("10w StringBuilder instance coast: "+(stringBuilderEnd-stringBuilderStart)+" ms");
    27         System.gc();
    28     }
    29 }

![1676271-20190520194810686-1272428112.png][]

##  　　然后再来看一下线程安全： ##

由于String不支持修改，所以也就没有线程是否安全的说法（如果非要说有，那就是创建新对象时修改原来的引用地址为新地址，那一定是线程不安全的）。

我们通过多线程程序测试：

我分别在StringBuffer 和 StringBuilder 中循环了1000 次 ，每次拼接一个字母A ，同时开启三条线程进行这个操作。

可以知道，如果线程安全 我们将会得到一个  3 \* 1000 = 3000 长度的结果（一条线程拼接1000个 三条刚好3000个），通过结果我们可以看出，StringBuffer 是线程安全的，而SrtingBuilder的结果不足3000 说明发生了线程

不安全的操作。（最直接的办法还是去jdk源码看一下，StringBuffer基本上每一个方法都有synchronized修饰）。

1 public class TestString {
     2     public static void main(String[] args) throws InterruptedException {
     3         /**
     4          * @author xiaobai
     5          * 测试StringBuffer与StringBuilder的线程安全性 
     6          * 实现两个自己的线程类
     7          * 分别创建三条线程 并发执行
     8          * 等待线程全部执行完，统计结果 比较  
     9          * 
    10          * 若线程安全  应该是  3 * 1000 = 3000 
    11          */
    12         Thread t1 =  new Thread(new MyStringBufferTest());
    13         Thread t2 =  new Thread(new MyStringBufferTest());
    14         Thread t3 =  new Thread(new MyStringBufferTest());
    15         
    16         Thread t4 =  new Thread(new MyStringBuilderTest());
    17         Thread t5 =  new Thread(new MyStringBuilderTest());
    18         Thread t6 =  new Thread(new MyStringBuilderTest());
    19         
    20         t1.start(); t2.start(); t3.start(); t4.start(); t5.start(); t6.start();
    21         
    22         while(Thread.activeCount()>1); //等待线程执行完
    23         
    24         System.out.println("StringBuilder : "+MyStringBuilderTest.sbd.length());  //不一定是多少
    25         System.out.println("StringBuffer : "+MyStringBufferTest.sbf.length()); // 一定是 3000 
    26         
    27     }
    28 }
    29 
    30 class MyStringBufferTest implements Runnable{
    31     static StringBuffer sbf = new StringBuffer();
    32     /**
    33      * 进行1000 次拼接字符操作  
    34      * 中途sleep 10ms 使效果更好
    35      */
    36     @Override
    37     public void run() {
    38         for(int i=0;i<1000;i++) {
    39             sbf.append("A");
    40             try {
    41                 Thread.sleep(10);
    42             } catch (InterruptedException e) {
    43                 // TODO Auto-generated catch block
    44                 e.printStackTrace();
    45             }
    46         }
    47     }
    48 }
    49 
    50 class MyStringBuilderTest implements Runnable{
    51     static StringBuilder sbd = new StringBuilder();
    52     /**
    53      * 进行1000 次拼接字符操作  
    54      * 中途sleep 10ms 使效果更好
    55      */
    56     @Override
    57     public void run() {
    58         for(int i=0;i<1000;i++) {
    59             sbd.append("A");
    60             try {
    61                 Thread.sleep(10);
    62             } catch (InterruptedException e) {
    63                 // TODO Auto-generated catch block
    64                 e.printStackTrace();
    65             }
    66         }
    67     }
    68 }

结果：![1676271-20190520202617382-540035981.png][]

##  　　比较结论： ##

效率上  ： 由快到慢  StringBuilder > StringBuffer > String

线程安全性： String  不安全   StringBuilder 不安全  StringBuffer 安全

转载于:https://www.cnblogs.com/xiaobai1202/p/10896325.html

[API]: https://docs.oracle.com/javase/8/docs/api/
[1676271-20190520184517553-1144027454.png]: /images/20211220/8019290207794ac09dc01f59d5faf111.png
[1676271-20190520184653711-964212051.png]: /images/20211220/b5f00552a0bd4f20af4c1dc801d0aef4.png
[1676271-20190520184720897-239095578.png]: /images/20211220/2933a785c20045918451953b164ad509.png
[1676271-20190520184754787-1959177630.png]: /images/20211220/ba3c07250ead47eb805b6ea75c592dba.png
[1676271-20190520184823766-1778274389.png]: /images/20211220/ee667a43c52349baba360126dc426ac1.png
[1676271-20190520191122823-609160083.png]: /images/20211220/53d48e9b3213429a88b1dc45c5e077d3.png
[1676271-20190520191248712-1901816709.png]: /images/20211220/a516c117d52443fa95a99d478ee85220.png
[1676271-20190520191310974-1265438885.png]: /images/20211220/2f2ff1097095491682a37bff7f215c68.png
[1676271-20190520191332740-912084682.png]: /images/20211220/985a219b34a84ec683a0bf5b68469d34.png
[1676271-20190520192253170-82122664.png]: /images/20211220/7538e8e94b254007a0a497c21f0aee9a.png
[1676271-20190520194810686-1272428112.png]: /images/20211220/6f11a3c51fc04a1897a2735c7df36807.png
[1676271-20190520202617382-540035981.png]: /images/20211220/72c506298dda42ada1ff7e6a57485d6e.png