String、StringBuffer、StringBuilder

最新推荐文章于 2020-01-01 23:37:44 发布
最新推荐文章于 2020-01-01 23:37:44 发布
阅读量655 收藏
点赞数
分类专栏： Java基础 文章标签： string stringbuilder stringbuffer
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiaoguobaf/article/details/52104220
版权

1、String

String的部分源码（jdk1.8.0_65）如下： 

public final class String
    implements java.io.Serializable, Comparable<String>, CharSequence {
    /** The value is used for character storage. */
    private final char value[];

    /** Cache the hash code for the string */
    private int hash; // Default to 0

    /** use serialVersionUID from JDK 1.0.2 for interoperability */
    private static final long serialVersionUID = -6849794470754667710L;



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 replace(char oldChar, char newChar) {
    if (oldChar != newChar) {
        int len = value.length;
        int i = -1;
        char[] val = value; /* avoid getfield opcode */

        while (++i < len) {
            if (val[i] == oldChar) {
                break;
            }
        }
        if (i < len) {
            char buf[] = new char[len];
            for (int j = 0; j < i; j++) {
                buf[j] = val[j];
            }
            while (i < len) {
                char c = val[i];
                buf[i] = (c == oldChar) ? newChar : c;
                i++;
            }
            return new String(buf, true);
        }
    }
    return this;
}

从以上看出：

  1. String类是final类，所以方法默认都是final方法，且成员变量都被final修饰，所以String类不可更改（value不能指向其他字符数组）。final类意味着不可继承，在早期的JVM实现版本中，被final修饰的方法会被转为内嵌调用以提升执行效率，但是，此外还有常量优化、多线程安全
  2. String类是通过字符数组来实现的，一个String对象包含一个字符数组
  3. 例如substring、replace等对字符串的操作会返回一个新的String对象，并不是原String对象，原String对象未改变

1.1 常量优化

JVM为了提高性能和减少内存开销，在实例化字符串常量（字面量）的时候进行了一些优化。为了减少在JVM中创建的字符串的数量，字符串类维护了一个全局性的字符串常量池(String Pool，与类的Runtime Constant Pool有别，字符串常量池中里面存放的是引用)，当通过字面量来创建（发生在加载阶段，不是运行时）字符串时，JVM通过字符串常量池，看能否查找到具有该字面量的字符串对象，不能则创建对象（放在运行时常量池中）并将其引用放入字符串常量池中，能则返回字符串常量池中的引用。

常量优化的前提是String对象是不可改变的，这样确保多个引用指向同一个对象，不论对String对象怎么处理，都不会改变对象。这里只是说了下原理，具体底层的实现细节请移步R大的博文(113楼)

来看几个例子，注意==比较是引用，并不是对象本身。

package offer;
/**
* @author 小锅巴
*/
public class StringTest {

    public static void main(String[] args){
        String str1 = "hello world";
        String str2 = new String("hello world");
        String str3 = "hello world";
        String str4 = new String("hello world");         
        System.out.println(str1==str2);
        System.out.println(str1==str3);
        System.out.println(str2==str4);
        System.out.println();

        String str6 = "ab";
        String str7 = "b";
        final String str8 = "b"; 
        String str9 = "a"+"b";
        String str10 = "a" + str7; 
        String str11 = "a" + str8;
        System.out.println((str6 == str9)); 
        System.out.println((str6 == str10));
        System.out.println((str6 == str11));
        System.out.println();

        String str5="abab"; 
        System.out.println(("abab" == str5)); 
        }
}
/**
输出：
false
true
false

true
false
true

true
*/

“hello world”实例实际上只有一份，所以str1和str3指向了同一对象；而str2和str4是通过new运行时创建的，那么不论字符串常量池中有没有相同内容的字符串，都要在堆上创建对象，显然是不同的对象，尽管对象的内容相同，str1和str2也就显然是不同的了。

1.2 编译优化

还是上面的例子，str9和str6是同一个对象。编译器将”a”+”b”作为常量表达式，直接取结果为”ab”，后面就和常量优化一样了。

将这两条语句单独拿出来，通过javap反编译查看字节码，可以看出，str9直接指向了”ab”

package offer;
/**
* @author 小锅巴
*/
public class test {

    public static void main(String[] args) {
        String str6 = "ab";
        String str9 = "a"+"b";
        System.out.println((str6 == str9));
    }
}

然后再看str10和str11，区别在于表达式中的变量是否是final变量，这里因为str8是final变量（引用），因为一旦赋值之后就不允许修改，所以在编译时编译器就已经可以确定str8所指向对象的内容了，直接视为”b”，而str7则不能确定，它所指向的对象可能会改变。还是单独拿出来，反编译验证一下，看不懂字节码也没关系，通过给出的注释也能了解个大概

package offer;
/**
 * @author 小锅巴
 */
public class test {

    public static void main(String[] args) {
        String str6 = "ab";
        String str7 = "b";
        final String str8 = "b"; 
        String str10 = "a" + str7; 
        String str11 = "a" + str8;
        System.out.println((str6 == str10));
        System.out.println((str6 == str11));
    }
}

反编译后：

D:\Develop\Java\jdk1.8.0_65\bin>javap -c test
警告: 二进制文件test包含offer.test
Compiled from "test.java"
public class offer.test {
public offer.test();
    Code:
       0: aload_0
   1: invokespecial #8                  // Method java/lang/Object."<init>":
()V
       4: return

public static void main(java.lang.String[]);
    Code:
       0: ldc           #16                 // String ab
       2: astore_1
       3: ldc           #18                 // String b
       5: astore_2
       6: ldc           #18                 // String b
       8: astore_3
       9: new           #20                 // class java/lang/StringBuilder
      12: dup
      13: ldc           #22                 // String a
      15: invokespecial #24                 // Method java/lang/StringBuilder."<
init>":(Ljava/lang/String;)V
      18: aload_2
      19: invokevirtual #27                 // Method java/lang/StringBuilder.ap
pend:(Ljava/lang/String;)Ljava/lang/StringBuilder;
      22: invokevirtual #31                 // Method java/lang/StringBuilder.to
String:()Ljava/lang/String;
      25: astore        4
      27: ldc           #16                 // String ab这里就是执行"a" + str8
      29: astore        5
      31: getstatic     #35                 // Field java/lang/System.out:Ljava/
io/PrintStream;
      34: aload_1
      35: aload         4
      37: if_acmpne     44
      40: iconst_1
      41: goto          45
      44: iconst_0
      45: invokevirtual #41                 // Method java/io/PrintStream.printl
n:(Z)V
      48: getstatic     #35                 // Field java/lang/System.out:Ljava/
io/PrintStream;
      51: aload_1
      52: aload         5
      54: if_acmpne     61
      57: iconst_1
      58: goto          62
      61: iconst_0
      62: invokevirtual #41                 // Method java/io/PrintStream.printl
n:(Z)V
      65: return
}

D:\Develop\Java\jdk1.8.0_65\bin>

最后一个，初看可能觉得有点奇怪，一个是引用，一个是字面量，能比么？由于String是比较特殊的类，这里编译器会直接把引用的地方替换为对象的内容，还是单独拿出来，通过反编译来查看，为了便于查看字节码指令，稍微改了一下

package offer;
/**
 * @author 小锅巴
 */
public class test {

    public static void main(String[] args) {
        String str5="abab"; 
        boolean b = ("abab" == str5);
        System.out.println(b);
    }
}

除此之外，String的编译优化的常量表达式不仅限于字符串类型，基本数据类型都可以，比如：

package offer;
/**
 * @author 小锅巴
 */
public class test {

    public static void main(String[] args) {
        String a = "a1"; 
        String b = "a" + 1; 
        System.out.println((a == b));
    }
}

输出结果为true

对于String str2 = new String("hello world");“创建了”几个对象，这么说吧，涉及两个String对象，一个其引用在字符串常量池中，另一个是new创建出来的，前者是在类加载时创建的，后者是在运行时创建的。想了解更多请移步R大的博文

在查找Sring的资料时，发现java8（hotspot）中已经没有“永久代”了，取而代之的是“元空间”，可参考这里。而java8之前是用“永久代”实现方法区，运行时常量池是方法区的一部分。

2、StringBuffer StringBuilder

因为String对象是不可变的，每次操作都是创建一个新的String对象，浪费资源，也导致性能过低，StringBuilder不是线程安全的，StringBuffer是线程安全的。

2.1 重载+和StringBuilder

+是java里唯一的一个重载操作符，当String对象通过+和基本类型或字符串类型“相加时”，编译器会创建StringBuilder对象并调用StringBuilder的append方法来连接。比如：

package offer;
/**
* @author 小锅巴
*/
public class test {

    public static void main(String[] args) {
        String  str = "";
        str = str + "hello";
        System.out.println(str);
    }
}

AbstractStringBuilder

StringBuffer和StringBuilder都继承自AbstractStringBuilder类，这里只看下append方法的实现，以此为例来说明StringBuilder、StringBuffer的实现原理

AbstractStringBuilder部分源码：

abstract class AbstractStringBuilder implements Appendable, CharSequence    {
    char[] value;
    int count;

    AbstractStringBuilder(int capacity) {
        value = new char[capacity];
    }

    public void getChars(int srcBegin, int srcEnd, char[] dst, int  dstBegin)
    {
        if (srcBegin < 0)
            throw new StringIndexOutOfBoundsException(srcBegin);
        if ((srcEnd < 0) || (srcEnd > count))
            throw new StringIndexOutOfBoundsException(srcEnd);
        if (srcBegin > srcEnd)
            throw new StringIndexOutOfBoundsException("srcBegin > srcEnd");
        System.arraycopy(value, srcBegin, dst, dstBegin, srcEnd - srcBegin);
    }

    void expandCapacity(int minimumCapacity) {
        int newCapacity = value.length * 2 + 2;
        if (newCapacity - minimumCapacity < 0)
            newCapacity = minimumCapacity;
        if (newCapacity < 0) {
            if (minimumCapacity < 0) // overflow
                throw new OutOfMemoryError();
            newCapacity = Integer.MAX_VALUE;
        }
        value = Arrays.copyOf(value, newCapacity);
    }

    private void ensureCapacityInternal(int minimumCapacity) {
        if (minimumCapacity - value.length > 0)
            expandCapacity(minimumCapacity);
    }

    public AbstractStringBuilder append(StringBuffer sb) {
        if (sb == null)
            return appendNull();
        int len = sb.length();
        ensureCapacityInternal(count + len);
        sb.getChars(0, len, value, count);
        count += len;
        return this;
    }
}

这里用到了Arrays.copyOf()方法，关键源码如下，可以看出就是新建了一个字符数组：

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;
}

System.arraycopy()的源码：

public static native void arraycopy(Object src,  int  srcPos,
                                    Object dest, int destPos,
                                    int length);

StringBuilder部分源码：

public final class StringBuilder
    extends AbstractStringBuilder
    implements java.io.Serializable, CharSequence
{
    static final long serialVersionUID = 4383685877147921099L;

    public StringBuilder() {
        super(16);
    }

    public StringBuilder(int capacity) {
        super(capacity);
    }

    public StringBuilder(String str) {
        super(str.length() + 16);
        append(str);
    }

    @Override
    public StringBuilder append(StringBuffer sb) {
        super.append(sb);
        return this;
    }

    @Override
    public StringBuilder append(String str) {
        super.append(str);
        return this;
    }
}

StringBuffer和StringBuilder类似，区别在于方法都被Synchronized修饰，多个了被transient修饰的字段

append的实现最终还是要看AbstractStringBuilder，可以发现是使用可变长数组实现的（和用数组实现可扩容的栈思想类似），利用了System.arraycopy()实现数组的复制，该方法是个本地方法。

参考资料：

  1. http://www.cnblogs.com/dolphin0520/p/3778589.html
  2. http://rednaxelafx.iteye.com/blog/774673/
  3. http://droidyue.com/blog/2014/12/21/string-literal-pool-in-java/index.html
  4. http://www.cnblogs.com/fancydeepin/archive/2013/04/23/min-snail-speak_String-StringBuffer-StringBuilder.html
  5. http://www.cnblogs.com/fancydeepin/archive/2013/04/22/min-snail-speak_String.html
  6. http://sabaao.blogspot.my/2013/10/java-stringstringbufferstringbuilder.html
  7. http://www.infoq.com/cn/articles/Java-PERMGEN-Removed
xiaoguobaf
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
String StringBuffer和StringBuilder区别之源码解析
12-07
"String StringBuffer和StringBuilder区别之源码解析" 在Java中，字符串是我们经常使用的数据类型，而String、StringBuffer和StringBuilder是Java中三种常用的字符串类。在这篇文章中，我们将从源码角度对String、...
String，StringBuffer，StringBuilder区别
09-14
对于Java中的字符串操作，主要涉及到三个类：String、StringBuffer和StringBuilder。理解这三个类之间的区别，对于编写高质量、高效率的代码至关重要。 首先，String类是Java中最基础也是最常用的字符串处理类。...
JDK源码分析 – String、StringBuilder、StringBuffer
anglong7701的博客
05-20 88
String类的申明 public final class String implements java.io.Serializable, Comparable<String>, CharSequence {…} String类用了final修饰符，表示它不可以被继承，同时还实现了三个接口, 实现Serializable接口表示String类可被序列化；...
深入理解Java中的String
u013698807的博客
12-21 234
转载自 https://www.cnblogs.com/xiaoxi/p/6036701.html 一、String类 想要了解一个类，最好的办法就是看这个类的实现源代码，来看一下String类的源码： 复制代码 public final class String implements java.io.Serializable, Comparable, CharSequence { /** The...
浅谈String,StringBuilder,StringBuffer的使用与区别
weixin_44632716的博客
01-01 541
浅谈String,StringBuilder,StringBuffer的使用与区别Java中String类的使用1. 简介2. 常用方法3. "String对象为不可变对象"源码分析StringBuilder类的使用1. 简介2. 常用方法String,StringBuilder,StringBuffer之间的区别切记 Java中String类的使用 1. 简介 String 类代表字符串,是ja...
Java知识总结
十年饮冰，难凉热血
05-18 1万+
来源： 一、 java开发工具Editplus：Editplus与jdk的连接配置，如： javac（编译）、java（运行）、javap(查看字节码) a) 配置内容： i. javac（编译）：参数为 -d .  $(FileName)；初始目录 $(FileDir) ii. java（运行）：参数为 $(CurSel).$(FileNameNoExt)；初始 目录
java基础(8)--深入理解Java.String
上善若水，厚德载物
04-18 763
本文转载自：http://www.cnblogs.com/ITtangtang/p/3976820.html 尊重原创在讲解String之前，我们先了解一下Java的内存结构。一、Java内存模型按照官方的说法：Java 虚拟机具有一个堆，堆是运行时数据区域，所有类实例和数组的内存均从此处分配。JVM主要管理两种类型内存：堆和非堆，堆内存（Heap Memory）是在 Java 虚拟机启动时创建，非
String、StringBuffer和StringBuilder的区别
热门推荐
幸遇三杯酒好，况逢一朵花新
06-16 25万+
String、StringBuffer和StringBuilder的区别： 文章目录StringStringBufferStringBuilderStringBuffer是如何实现线程安全的呢？Java9的改进 String   String类是不可变类，即一旦一个String对象被创建以后，包含在这个对象中的字符序列是不可改变的，直至这个对象被销毁。   这个是String类的解释，之前小咸儿看...
String Stringbuffer StringBuilder的区别
spring_root的博客
08-20 822
String Stringbuffer StringBuilder的区别： 1、string是字符串常量，且长度是不可改变的，Stringbuffer、stringBuilder是字符串变量 2、Stringbuffer是线程安全的，StringBuilder是非线程安全，主要用在全局变量中。 3、String是改变赋值的地址，而不是改变String中的值： 如：String a = “...
String StringBuffer StringBuilder的简单介绍
qq_2790289459的博客
07-16 613
String是字符串类，字符串和数组一样只要声明后就不会再改变长度。若要改变字符串的值原内存中的内容不变，会产生一个新的字符串，即会声明一个新的内存空间，其中保存新的数据。 StringBuffer是带缓冲的字符串。 StringBuffer str=new StringBuffer(“字符串”);//初始化 对该字符串我们可以使用append()方法在原有字符串的基础上追加，而不会生成新的
String StringBuffer StringBuilder
weixin_41730409的博客
09-03 387
String StringBuffer StringBuilderStringStringBufferStringBuilderString StringBuilder StringBuffer的使用字符串常量池总结 String String是一个被final修饰的最终类，hash没有被final修饰，每次修改字符串都会创建对象 StringBuffer StringBuffer是为了解决...
浅谈java中String StringBuffer StringBuilder的区别
09-02
在Java编程语言中，String、StringBuffer和StringBuilder都是用来处理字符串的类，但它们之间存在显著的性能和功能差异。下面我们将深入探讨这三个类的区别。 首先，`String`类是Java中最基本的字符串类型，它表示...
Java构造函数到底有没有返回值？
xiaoguobaf的博客
03-11 1万+
Java构造函数到底有没有返回值？
Java中数据初始化
xiaoguobaf的博客
03-11 2950
总结一下Java的初始化，本文涉及的内容 自动初始化 成员指定初始化 静态初始化 实例初始化 数组的初始化 引用的初始化 1、自动初始化对于在类中定义成员变量（又称为成员属性、字段），基本数据类型会自动初始化，引用类型——对象变量，会被初始化为null。注意，必须是字段，对于局部变量，必须指定初始化为其赋值，局部变量不初始化是程序员的疏忽。自动初始化是Java为了所有变量在使用前都能得到初始化，它要
try catch finally中有return语句的执行情况及原因分析
xiaoguobaf的博客
08-03 1677
前言之前在学习Java异常时遇到了try cathc finally中有return的情况，但是到底return执不执行，以怎样的顺序执行，以及原因是什么，还没弄清楚。 1 执行顺序以及原因先来看一个简单的例子，为了便于阅读方法的字节码指令，没有采用static方法 package chapter6; /** * @author 小锅巴 */ public class Finally {
Java中的继承、封装、多态
xiaoguobaf的博客
03-21 1584
Java中的继承、封装、多态本博客包含以下内容，博主是菜鸟，正在努力学习中，如有错误或不足，欢迎交流讨论。 基本定义 初始化和类的加载 final关键字 类之间的关系 向上转型 多态的缺陷 构造器和多态 1、基本定义继承：在创建一个新类（子类、导出类）时，使用extends关键字表明它派生于一个已经存在的类（父类、基类、超类），导出类会获得基类的所有域和方法，但并不是一定能直接访问，和访问权限控制有
Java中的访问权限控制
xiaoguobaf的博客
03-16 986
成员、方法的访问权限控制 包访问权限 没有访问修饰符的默认权限，有时也表示称为friendly。当前包中的所有其他类对那个成员都有访问权限，当对于包之外的类，却是private的，没有访问权限。 public访问权限 被修饰的成员或方法可以被任何人访问。 private访问权限 只有包含该成员（方法）的类具有访问权限，其他任何类都无法访问。 protected访问权限 继承访问权限，对子类
Java中的内部类
xiaoguobaf的博客
03-29 757
Java中的内部类总结一下内部类，如有错误或者不错，欢迎交流讨论。 内部类的定义，作用 内部类的分类 和内部类相关的几个问题 1、什么是内部类，为什么需要内部类，它有什么用？在一个类的内部定义一个类，就是内部类。内部类提供了某种进入外围类的窗口；每个内部类都能独立继承子一个实现（接口或抽象类），无论其外围类是否实现，对内部类都没有影响；实现多继承，Java的中继承是单根继承，只能继承
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值