java12-字符串操作类StringStringBufferStringBuilder

Posted 2021-12-02 xiaobai1202

1.概述

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

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

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

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

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

2. String类

　　2.1 构造函数：

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

　　　　　　其它构造函数列表如下：

　　2.2 其他方法

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

　

　　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 构造函数

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

　　3.3 其他方法

　　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 构造方法

　　　　　　

　　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 }

 

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

　　　　　　由于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 }

 

 

结果：

 

 　　比较结论：

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

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