Java基础—String、StringBuffer、StringBuilder

前言:本系列的主题是平时容易疏忽的知识点,只有基础扎实,在编码的时候才能更注重规范和性能,在出现bug的时候,才能处理更加从容。

String

==问题

        String s6=new String("jiajun");
        String s1="jiajun";
        String s2="jiajun";
        System.out.println(s1==s2);//true
        System.out.println(s1==s6);//false
  • 看常量池中是否已有此字符串,如果有,将指针指向这个字符串
  • 如果使用new来创建字符串对象,那么这个字符串是存放在堆中,无论堆中是否已有这个对象

String对象改变

public String substring(int beginIndex) {
        if (beginIndex < 0) {
            throw new StringIndexOutOfBoundsException(beginIndex);
        }
        int subLen = value.length - beginIndex;
        if (subLen < 0) {
            throw new StringIndexOutOfBoundsException(subLen);
        }
        return (beginIndex == 0) ? this : new String(value, beginIndex, subLen);
    }
    
    public String concat(String str) {
        int otherLen = str.length();
        if (otherLen == 0) {
            return this;
        }
        int len = value.length;
        char buf[] = Arrays.copyOf(value, len + otherLen);
        str.getChars(buf, len);
        return new String(buf, true);
    }
  • 从源码可以看出,任何操作都是创建一个新的对象,不影响原对象

StringBuffer和StringBuidler

初始容量

  • StringBuilder和StringBuffer的构造参数来初始化容量
public StringBuilder() {
        super(16);
    }
AbstractStringBuilder(int capacity) {
        value = new char[capacity];
    }
  • 默认情况下容量为16
public AbstractStringBuilder append(String str) {
        if (str == null)
            return appendNull();
        int len = str.length();
        ensureCapacityInternal(count + len);
        str.getChars(0, len, value, count);
        count += len;
        return this;
    }
    private void ensureCapacityInternal(int minimumCapacity) {
        // overflow-conscious code
        if (minimumCapacity - value.length > 0) {
            value = Arrays.copyOf(value,
                    newCapacity(minimumCapacity));
        }
    }
    public static char[] copyOf(char[] original, int newLength) {
        char[] copy = new char[newLength];
        System.arraycopy(original, 0, copy, 0,
                         Math.min(original.length, newLength));
        return copy;
    }
  • 从源码看出,在执行append方法的时候,会执行ensureCapacityInternal方法来保证容量,而如果超出容量的话,会重新创建一个char数组,并将旧的字符数组复制到新的字符数组

线程安全

public synchronized StringBuffer append(StringBuffer sb) {
        toStringCache = null;
        super.append(sb);
        return this;
    }
 public synchronized StringBuffer append(String str) {
        toStringCache = null;
        super.append(str);
        return this;
    }
    
 public StringBuilder append(StringBuffer sb) {
        super.append(sb);
        return this;
    }
    public StringBuilder append(String str) {
        super.append(str);
        return this;
    }
    public String toString() {
        // Create a copy, don't share the array
        return new String(value, 0, count);
    }
  • 可以看出,String的方法是加了synchronzied,也就加了锁,那么而在单线程的情况下或者不用考虑线程安全的情况下,那么StringBuilder的性能是更高的

toString方法

 public synchronized String toString() {
        if (toStringCache == null) {
            toStringCache = Arrays.copyOfRange(value, 0, count);
        }
        return new String(toStringCache, true);
    }
public String toString() {
        // Create a copy, don't share the array
        return new String(value, 0, count);
    }
  • 通过源码发现,toString方法会创建一个新的String对象

性能试验

间接相加和直接相加

public class d {
    public static void main(String[] args) {
        String s="I"+"love"+"jiajun";
        String s1="I";
        String s2="love";
        String s3="jiajun";
        String s4=s1+s2+s3;
    }
}
  • 通过反编译的结果可以看出,第一种方式字符串直接相加,在编译器就直接优化了”Ilovejiajun“
  • 而第二种方式间接相加,从结果可以看出,是先创建一个StringBuilder,然后再apend,最后再toString方法,可以发现性能比第一种低
public class d {
    public static void main(String[] args) {
        String s="I"+"love"+"jiajun";
        String s1="I";
        String s2=s1+"lovejiajun";
        System.out.println(s==s2);
    }
}
  • 同样从反编译的结果可以看出,第二种方式并没有被优化,也是通过StringBuilder来实现的,最后通过toString方法创建一个String对象,所以返回的false
  • 但是当s1是用final修饰的却是不一样的,虚拟机会对其进行优化,所以不会像之前一样创建一个StringBuilder,最后在堆中产生一个对象
public class d {
    public static void main(String[] args) {
        
        final String s1="I";
        
        String s2=s1+"lovejiajun";
        String s3="Ilovejiajun";
        //s1==s3
    }
}

用+和用append

public class Demo3 {
    public static void main(String[] args) {
        run1();
        run2();
    }
    
    public static void run1() {
        long start = System.currentTimeMillis();
        String result = "";
        for (int i = 0; i < 10000; i++) {
            result += i;
        }
        System.out.println(System.currentTimeMillis() - start);
    }

    public static void run2() {
         long start = System.currentTimeMillis();
        StringBuilder builder = new StringBuilder();
        for (int i = 0; i < 10000; i++) {
            builder.append(i);
        }
        System.out.println(System.currentTimeMillis() - start);
    }
    //输出:223 1
  • 从实验发现,用append效率更高,从实验一发现,当字符串相加的时候,实际上每次都会重新初始化StringBuilder然后执行相加,这样效率并不高

初始化容量

public class Demo3 {
    public static void main(String[] args) {
        test1();
        test2();
    }

    public static void test1() {
        StringBuilder sb = new StringBuilder(7000000);
        long start = System.currentTimeMillis();
        for (int i = 0; i < 1000000; i++) {
            sb.append("jiajun");
        }
        long end=System.currentTimeMillis()-start;
        System.out.println(end);
    }

    public static void test2() {

        StringBuilder sb = new StringBuilder();
        long start = System.currentTimeMillis();
        for (int i = 0; i < 1000000; i++) {
            sb.append("jiajun");
        }
        long end=System.currentTimeMillis()-start;
        System.out.println(end);
    }
    //输出:18 26
}
  • 通过实验可以看出,适当的初始化容量可以提高性能,因为当不初始化容量的时候,如果此时append超出容量,那么将会从新创建一个char数组,并且进行复制

总结

  • 用new创建对象的时候,会在堆中创建对象,而如果是直接用引号形式的话,会先看常量池是否有此字符串,有的话指向常量池的字符串
  • StringBuilder是非线程安全的,StringBuffer是线程安全的
  • 使用StringBuilder和StringBuffer的时候最好初始化一个合适的容量,因为如果默认容量不够的话,会重新创建一个char数组,再进行复制
  • 字符串相加的时候,直接相加的时候,编译器会进行优化,而如果是间接相加的时候,实际上会创建一个StringBuilder来进行append

我有一个微信公众号,经常会分享一些Java技术相关的干货。如果你喜欢我的分享,可以用微信搜索“Java团长”或者“javatuanzhang”关注。

原创声明,本文系作者授权云+社区发表,未经许可,不得转载。

如有侵权,请联系 yunjia_community@tencent.com 删除。

编辑于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏浪淘沙

关于数组的算法

3.给定一个数组和一个数num,把小于num的书放在数组左边,大于num的书放在数组右边

1066
来自专栏浪淘沙

java学习day10--异常 IO

2018.6.15 1.递归 递归输出99乘法表 public static void test3(int i) { if(i...

1106
来自专栏博岩Java大讲堂

Java集合--Set(基础)

3437
来自专栏Java 源码分析

HashSet 源码分析

HashSet 源码分析 1. 在阅读源码时做了大量的注释,并且做了一些测试分析源码内的执行流程,由于博客篇幅有限,并且代码阅读起来没有 IDE 方便,所以在...

2994
来自专栏博岩Java大讲堂

Java集合--TreeMap完全解析

6344
来自专栏老马说编程

(41) 剖析HashSet / 计算机程序的思维逻辑

查看历史文章,请点击上方链接关注公众号。 上节介绍了HashMap,提到了Set接口,Map接口的两个方法keySet和entrySet返回的都是Set,本节,...

1799
来自专栏nnngu

数据结构04 链表的面试题

这篇文章包含的链表面试题如下: 1、从尾到头打印单向链表 2、查找单向链表中的倒数第k个节点 3、反转一个单向链表【出现频率较高】 4、合并两个有序的单向链表,...

3696
来自专栏Java帮帮-微信公众号-技术文章全总结

第十九天 集合-Map接口容器工具类集合框架总结【悟空教程】

Map集合的特点,如是否可重复,是否有序仅作用在键上,如HashMap集合的键不得重复,值可以重复。

1213
来自专栏Java学习123

mysql分组查询

2669
来自专栏java一日一条

Java中的clone() 深拷贝 浅拷贝

上图展示了浅拷贝:对于非基本数据类型,clone过后,结果两个指针指向了同一块儿内存空间,所以仅仅是浅拷贝,这样的话如果对一个对象进行操作,另一个内容也会变,这...

562

扫码关注云+社区