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

时间:2024-01-24 09:25:06

1.概述

  无论是哪种编程语言,对字符串的操作都是必不可少的。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 安全