String/StringBuilder/ToString()底层代码解析（ JAVA / C# ）

置顶 已于 2022-09-29 15:10:38 修改
阅读量6.8k 收藏 27
点赞数 15
分类专栏： Java_学习笔记 C#/.net 文章标签： java 学习 后端 c# 开发语言
于 2022-05-24 18:25:08 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46484674/article/details/124951029
版权

C# /JAVA: 字符串构建利器StringBuilder区别

前言

本章笔记直接记录的string、StringBuilder内存存储原理，并没有大幅度、重点的去介绍堆、栈、常量池的相关底层实现原理。
所以，为了帮助大家更好的去理解，可以在阅读本文章前去了解堆、栈、常量池之间的基础关系，对以下的阅读有很大的帮助。

名词解释

栈：存放变量（值类型）

堆：存放对象（引用类型）

常量池：它是一个Hash表。
为了提升性能和减少内存开销，避免字符串的重复创建，所以开辟出来一个单独的内存空间，就是字符串池。
字符串常量池是由String类私有的维护。

八大基本类型： byte、short、int、long、boolean、float、double、char
四大引用类型：数组、class、interface、字符串（string

一、String

1.1 示例

案例一： 不同变量赋值（ = ）

String  str1 = "Hello" ;
String  str2 = "Hello" ;
System.out.println(str1 );  //结果： Hello
System.out.println(str1 );  //结果： Hello
  • 情况1：不存在
    1. 变量 str1 会存放在栈中，
    2. 首先在常量池中进行查找“Hello”是否存在。
    3. 不存在时，会在常量池中以键值对格式创建<key，value>，value则指向堆中的“Hello”对象指针。
    4. 从而，str1的引用地址就是堆中0x0001对应的“Hello”指针。
  • 情况2：存在
    1. 变量 str2 会存放在栈中，
    2. 首先在常量池中进行查找“Hello”是否存在。
    3. 存在时，会继续使用常量池中已存在的key,不会再新建。也就是 str2使用常量池中hello指向堆中的0x0001对应的“Hello”指针。
    4. 与str1的引用地址是一个。

在这里插入图片描述

案例二：相同变量赋值（ = ）

我们都知道String属于类，它是不可变的。即一旦一个String对象被创建以后便不能被更改、变长、修改；直至这个对象被销毁。

不可变 : 文章下方会有专门的讲解

下面写了一个小例子，如下方所示：

String  str1 = "Hello" ;
str1 = "Word" ;
//打印出来的str1为： Word
System.out.println(str1);

看到这里，可能就会有疑问：不是不能被修改吗？怎么会对他进行了修改？
针对这个问题，我画了一张底层实现原理图，希望能够帮助到大家。如图所示：
在这里插入图片描述
前面我们说到了第一次str1赋值“Hello”，在常量池中创建后，其value指向对象指针；

从图中可以看出，再次给str1赋值“Word”时，并不是对原来堆中的实例对象进行重新赋值，而是生成一个新的实例对象，并且str1的引用地址变指向了这个新的“Word”这个字符串。

之前的实例对象“Hello”依然存在，只是不再被引用了而已；如果没有被再次引用，则会被垃圾回收。
但是吧，在这里暂时不回被回收（垃圾回收不能释放被Hash表中引用的字符串，因为Hash表中正在容纳对他们的引用。除非进程终止）

案例三：变量追加赋值（ += ）

前面提到了String属于类，它是不可变的。即一旦一个String对象被创建以后便不能被更改、变长、修改；直至这个对象被销毁。

小案例：

String  str1 = "Hello" ;
str1 + = " Word" ;
//打印出来的str1为：Hello  Word
System.out.println(str1)

看到这里，可能就会有疑问：不是长度不可以变吗？为什么变量str1的长度会增加？会被修改？
针对这个问题，我又画了一张底层实现原理图，希望能够帮助到大家。如图所示：
在这里插入图片描述
公式变化：
str1在追加赋值+=“Word”时，（图中为了好看，堆地址0x0003对应的字符串对象我添加了空格，不要被误导了哈~）实际上是str1+“Word”（str1指向Hello） → Hello+Word → " HelloWord "。

底层变化：

  1. str1 中的“Hello”、“Word” 在常量池中没有，所以需要在常量池中创建对应key，其value（0x0001、0x0002）指向堆中的对象指针（Hello、Word）。
  2. 前面也提到了，实际上str1 = str1+“Word”，而这一步操作是隐式操作，不走字符串常量池的。
  3. 也就是说：Hello+Word 是在堆中相加的，生成了新的对象。
  4. 其新生成堆地址0x0003（对象在堆中地址）会赋给str1。
  5. str1 根据这个地址去找到对象 “ HelloWord ”。（之前的实例对象“Hello”“Word”依然存在，只是不再被引用了而已）。



1.2 常量池扩展（IsInterned、ReferenceEquals）

有关常量池动态机制在此处查看： string常量池/驻留池——动态机制
这两个都是在C#中提供的方法，java的我还没有使用过。之后的java练习中找到了平替将会及时补充本文哈。

Object.ReferenceEquals() 确定实例是否为同一实例

ReferenceEquals 方法是 Object类的静态方法 ，不能被改写。该方法可以比较两个引用类型的引用是否指向用一个实例。

案例一：
> string aa = "Hello";
> string bb = "Hello";  
> aa == bb     
//判断变量是否相等。返回结果为：true
 true
 
案例二： 
> object.ReferenceEquals(aa,bb)
 //判断两个变量引用地址是否相同
 true

在这里我们可以使用object.ReferenceEquals(aa,bb) 来判断aa与bb是否是使用的一个常量池中的字符串，是否指向同一个对象指针。

由于ReferenceEquals()是判断两个对象的引用是否相等

  • 对于值类型，因为每次判断前都必须进行装箱操作，也就是每次都生成了一个临时的object，因而永远返回false。
  • 对于2个引⽤类型，ReferenceEquals则会⽐较它们是否指向同⼀地址。（特殊情况是两个都是null的话，会返回true）

String.IsInterned（） 判断字符串是否存在内部池中

String.IsInterned（验证是否在常量池中），用来判断一个字符串是都已在常量池中。如果存在，返回该字符串；反之则返回null。

案例一：
> string aa = "Hello";
> string.IsInterned(aa)
 "Hello"  //正确输出“Hello”，说明常量池中存在“Hello”
  
案例二：
> string.IsInterned(aa.ToUpper())
 null  //因为常量池中不存在“HELLO”，故返回：null
 
 //因为常量池中不存在“HELLO”，所以其对象、引用地址都为false
> aa == aa.ToUpper()
 false  
> object.ReferenceEquals(aa,aa.ToUpper())
 false

二、StringBuilder 底层实现（C#/JAVA）

StringBuilder来源：
前面提到了String是不可变的对象。这就相当于每次对字符串进行 + 或 += 操作的时候会产生一个新的String实例。
对于大量进行拼接的场景非常不友好。因此，StringBuilder诞生~~~~ 撒花撒花~~~

2.1 stringBuilder是什么？

StringBuilder是一个可变的字符序列。此类提供一个与StringBuilder兼容的API，但不保证同步。
该类被设计用作StringBuilder的一个简易替换，用在字符串缓冲区被单个线程使用的时候。

StringBuffer就是为了解决大量拼接字符串时产生很多中间对象问题而提供的一个类，提供 append 和 add 方法，可以将字符串添加到已有序列的末尾或指定位置。
它的本质是一个线程安全的可修改的字符序列，把所有修改数据的方法都加上synchronized。但是保证了线程安全是需要性能的代价的。

StringBuilder，它和StringBuffer本质上没什么区别，就是去掉了保证线程安全的那部分，减少了开销。

其中StringBuffer是线程安全的。有个小地方需要慎重，就是toString()方法。

全文例子(下方讲解全都按照这个走，不再重复写)

//方式1 通过构造函数初始化数据
 StringBuilder stringBuilder = new StringBuilder("我爱你中国心爱的母亲");
 System.out.println(stringBuilder);
//方式2 使用Append追加
 StringBuilder builder = new StringBuilder(16);
 builder.append("我爱你中国");
 builder.append("心爱的母亲");
 builder.append("，");
 builder.append("我为你流泪");
 builder.append("也为你自豪。");
 builder.append("我爱你中国");
 builder.append("心爱的母亲");
 System.out.println(builder);
//方式3 将StringBuilder转换成字符串
 String str = builder.toString();
 System.out.println(str);
//结果输出
> 我爱你中国心爱的母亲
> 我爱你中国心爱的母亲，我为你流泪也为你自豪。我爱你中国心爱的母亲
> 我爱你中国心爱的母亲，我为你流泪也为你自豪。我爱你中国心爱的母亲

上面例子中简单操作了一个StringBuilder 的简单使用方式，主要操作是使用 Append() 方法和 ToString() 方法。这也是最常用的拼接方式。

2.2 StringBuilder — C#

2.2.1 单项链表

单链表是一种特殊的数据结构，能够动态的存储一种结构类型数据。
链表是通过指针将一组零散的内存块儿串联在一起使用。为了将所有的结点（内存块儿）串联起来。

每个链表除了存储数据data之外，还需要记录链上的下一个结点的地址。如图所示，我们把这个记录下一个结点（后继指针）我们把这个记录下个结点地址的指针叫作后继指针next。

如图所示，由四个扩容产生的对象 组合在一起，形成了链表。

其中是第一个结点和最后一个结点是比较特殊的。我们习惯性地把第一个结点叫作头结点，把最后一个结点叫作尾结点。其中，头结点用来记录链表的基地址。有了它，我们就可以遍历得到整条链表。而尾结点特殊的地方是： 指针不是指向下一个结点，而是指向一个空地址NULL，表示这是链表上的最后一个结点。

下面进入到了对象扩容之间的了（存储数据data + 后继指针next）：

该结构可以看成由两个部分组成。分别包含两个部分数据：

  • 第一部分data ：结点本身的数据
  • 第二部分next ：指向下一个结点的指针（整个stringBuilder对象的地址）

下图是画了一张StringBuilder的大体数据流转情况，希望能够帮助理解。

在这里插入图片描述
如图所示：

  1. stringBuilderB 是stringBuilderA扩容出来的char[ ]（后面会讲到扩容相关）
  2. 声明变量 builder 通过堆地址0x0002（也就是整个stringBuilder对象的地址）找到stringBuilderB。
  3. stringBuilderB 后继指针next存放了stringBuilderA 的引用地址0x0001，也就是结点的指针。（这里就用到了单链表）
  4. 底层实现是循环遍历查找：
    • 通过循环，使得stringBuilderB 找到 stringBuilderA 。（会开辟一个新的空间，stringBuilderB放在新数组后方，接着通过stringBuilderB 后继指针next存放引用地址0x0001找到stringBuilderA放到新数组前面，一次类推）
    • ToString()方法将char[ ] 拼接在一起（会开辟一个总的长的，然后把数组挨个放进去），最后输出得到结果。

2.2.2 扩容机制

想了解StringBuilder的扩容机制，还需要从它的Append方法入手。
只有Append的时候才有机会去判断原有的 char[ ] 长度是否满足存储Append进来的字符串。
在这里插入图片描述

如图所示，从扩容方面讲解：
  1. 我刚开始初始化了一个char[16]，
  2. 首次Append《我爱你中国 》存放在stringBuilderA 。并未达到16，未达到扩容条件。
  3. 二次Append《心爱的母亲》继续存放在stringBuilderA（因为tringBuilderA 还有11位空闲着，遂继续追加）占用下标5~9 。
  4. …一直这样一个个的追加，直到stringBuilderA 住满了，到达扩容条件。则会重新生成一个新char[ ] stringBuilderB，将剩余元素接着存放在其中。后继指针next指向下一个结点的指针，也就是stringBuilderA对象的地址。
  5. 其本质就是将Append进来的字符串复制到stringBuilderA数组中去。其字符串字符长度也代表了stringBuilderA已经使用的长度； 那么下一次的Append进来的元素，将会接着在上一个Append的后面继续追加。

如果当前存储块满足存储，则直接使用。

如果当前存储位置不满足存储，那么存储空间也不会浪费，按照当前存储块的可用存储长度去截取需要Append的字符串的长度，放入到这个存储块的剩余位置，剩下的存储不下的字符则存储到扩容的新的存储块stringBuilderB中去，这个做法就是为了不浪费存储空间。

即时要扩容，那么我当前结点的存储块也一定要填充满，不浪费空间，保证了存储空间最大的利用。

如图所示，从底层实现原理方面讲解：
  1. 声明变量 builder 存放在栈中
  2. 首次Append（“我爱你中国”） ,将会在字符串常量池中搜索是否存在？
  3. 不存在：将在常量池新建<key，value>，并在堆中创建string对象。string对象中存放着“我爱你中国”，之后同时会进行两步操作：
    • 将指针，也就是引用地址0x123返回给字符串常量池进行value绑定。
    • 同时返回给Append（也就是stringBuilderA）。
  4. stringBuilderA会根据引用地址0x123去找到str1，将里面的char[ ]拷贝一份至stringBuilderA中的char[ ]。
  5. 以此类推，等到占满了就会进行扩容机制，扩容出stringBuilderB。（详情看上方，不再重复作业）
  6. 输出结果：实例对象的 . ToString（）干了什么事？
    • 会开辟一个新的空间 char[ ] ，目的是将stringBuilderA+stringBuilderB拼接起来
    • 栈中的builder会找到指针（引用地址）0x0002
    • 变量builder引用地址指向0x0002；接着继续循环查找出0x0001（通过stringBuilderB 后继指针next存放引用地址0x0001），根据线索找到stringBuilderA。
    • 会开辟一个新的空间，循环倒序遍历出来一个char[ ]，就挨个放进去，以此类推，直到循环结束。

2.3 StringBuilder — JAVA

Java的实现方式与C#那些常量池什么的几乎一样，只是存储格式（数据结构）+扩容机制有些区别，其他都一样。
区别咱们继续往下看：

2.3.1 char数组（与C#扩展区别）

数据结构
C# 的 StringBuilder 整体结构来说是一个单向链表。
JAVA的StringBuilder整体结构来说是一个char[ ]字符数组。

扩展长度
C# 的 StringBuilder 容量和上一个stringBuilder长度有关，每次扩容不固定：max(当前追加字符的剩余长度,min(当前StringBuilder长度,8000))。

JAVA的StringBuilder容量则是生成一个新的数组，在原来char[ ]数组长度*2+2。（可理解为克隆）

底层实现
C# 扩容是单向链表，该结构有结点组成：后继指针next存放 指向下一个结点的指针 ；尾结点存放本身的数据。最后ToString()时，根据后继指针next的指针找到之前的元素，倒序遍历单项列表，拼接起来。

JAVA 扩容整体都是char[ ]数组：当达到扩容条件，会生成新的数组（一般是原来的char[ ]长度*2+2），新数组会把旧数组的元素克隆一份给自己。原来旧的数组没人引用了，就等待着垃圾回收。
在这里插入图片描述

在这里插入图片描述

2.3.2 扩容机制

刚才大体说了一下JAVA的底层实现机制是在旧数组的基础上，新生成一个新数组。并且克隆旧数组元素给自己。
旧数组没人引用就会等待着垃圾回收。

扩容机制也并不全都是旧char[]数组长度*2+2。他也会根据追加的长度进行判断，从而减少空间浪费。
对于这个问题，我们可以先进入java内部方法实现中去看(我用的是jdk1.8)：

情景回顾：

声明char[16]，数组中的16个字符已经被占满了，我现在二次.Append（“…50个字符…”），展开以下扩展路径

> 方法一，Append方法：
public AbstractStringBuilder append (String str)
{
    if (str == null) return appendNull();   

    int len = str.length();                   /.****** Append的50个字符长度 ******/  
    ensureCapacityInternal(count + len);      /.****** 16+50=66  原数组长度+现在新Append长度******/
    str.getChars(0, len, value, count);
    count += len;
    return this;
}

> 方法二，扩容条件：
private void ensureCapacityInternal(int minimumCapacity)
{
   if (minimumCapacity - value.length > 0)     /.****** 66-16>0，也就是66>16，条件成立，进入下一个方法******/  
   {
            value = Arrays.copyOf(value,
             newCapacity(minimumCapacity));
    }
 }
 
 > 方法三，获取扩容之后的数组长度：   
private int newCapacity(int minCapacity)
{
    int newCapacity = (value.length << 1) + 2;  	/.****** 16*2+2=34 新扩容长度 ******/  
  
  //新扩容的长度 小于 .Append()的长度
    if (newCapacity - minCapacity < 0)				/.****** 34-66<0,也就是34<66 条件成立 ******/ 
    {
    //申请的扩容空间 就等于 你.Append()的长度
        newCapacity = minCapacity;					/.****** 新扩容长度=66， 取两个最大值 ******/ 
    }
    
    //下方代码判断是否溢出
    //      66<=0   ||  int最大值-8<66 
    return (newCapacity <= 0 || MAX_ARRAY_SIZE - newCapacity < 0) 	 
            ? hugeCapacity(minCapacity)  //rue 进入溢出代码
            : newCapacity;				 //false 返回刚申请的长度
} 


> 方法四，溢出相关：
private int hugeCapacity(int minCapacity) 
{
    if (Integer.MAX_VALUE - minCapacity < 0)   /.******int最大值<大于最大数组长度或者小于等于0******/ 
    {
        throw new OutOfMemoryError();// overflow
    }
    
    /.******
    *如果大于int最大值-8，正好小于int最大值，返回它自己
    *反之， 返回int最大值-8，作为该扩展容器长度。（可能也有负数 我也是服了这个老6了）
    ******/
    
    return (minCapacity > MAX_ARRAY_SIZE) ? minCapacity : MAX_ARRAY_SIZE;  
}

三、ToSting()方法

具体的ToString底层实现代码讲解，请移到下方链接进行查看：
链接: stringBuilder.ToString()方法浅谈

结语

要说两种哪一个好，emmmmm不太好说，各有各的好。

C# 的StringBuilder 是单向链表，扩容的时候挺好，充分利用空间，保证了存储空间的最大利用。但是最后ToString（）需要循环倒序遍历，最终把结果组装成一个字符串返回。

JAVA 的StringBuilder 是 char[ ] 类型的，扩容的时候，会生成一个新的数组并且克隆旧数组中的元素到自己里面。之前的旧数组没人引用就会等待垃圾回收。
所以，类似数组扩容再copy的逻辑没有链表的方式高效。
最后输出结果的时候因为本身存储在char[ ]中，所以随后输出 Java的StringBuilder优势是非常明显的。


推荐内容





c#中的string和StringBuilder的区别
opencv220的博客
07-04 3528
string和StringBuilder的区别 解析c#中的string和StringBuilder的区别，只有非常了解后我们才能更好的编程和灵活使用。 区别 1、类 String 表示字符串， 比如“ abc ”。 类 StringBuilder 表示可改变大小的字符序列（ sequence of characters ），多个字符组成字符序列，字符序列和字符串是同一个意思。二者的区别在于， String 类型的字符串是常量，字符串创建出来后不允许修改。而 StringBuilder 类型的字符串是可修改
StringBuilder字符串生成器(含源码VS2010)
07-23
StringBuilder 字符串生成器 举例说明: SELECT * FROM dbo.Pub_User WHERE ID = 1001 以上这段Sql语句,利用此工具,一键生成以下StringBuilder字符串变量,支持翻转生成,内含VS2010源码,是.Net程序员必备工具 sb.AppendLine("SELECT *"); sb.AppendLine("FROM dbo.Pub_User"); sb.AppendLine("WHERE ID = 1001");
浅谈stringBuilder.ToString()方法底层原理代码解析（C#/JAVA）
weixin_46484674的博客
05-30 7574
ToString方法浅谈一、什么是单向链表？二、ToString（）底层区别（C#/Java）C#Java两者区别二、走进底层代码 — 场景回顾小结 一、什么是单向链表？ 首先我们要知道，三个StringBuilder的关系是单向链表，那么什么是单向链表呢？ 链表是一种特殊的数据结构，能够动态的存储一种结构类型数据。 该结构由节点组成。每个节点包含两个部分数据： 第一部分（尾节点）：节点本身的数据 第二部分（头节点）：指向下一个节点的指针（整个stringBuilder对象的地址 单向链表就是C# 的
StringBuilder类—append()和toString()方法
weixin_44057803的博客
06-09 1848
java.lang .StringBuilder是个字符串Q的缓冲区，即它是一个容器.它的内部拥有一个数组用来存放字符串内容，进行字符串拼接时，直接在数组中加入新内容。 stringBuilder 会自动维护数组Q，进行扩容。(默认16字符空间，超过自动扩充)StringBuilder类构造方法 public stringBuilder():构造一个空的StringBuilder 容器。 public stringBuilder(String str):构造一个StringBuilder容器，并将字符串添加
StringBuilder的toString方法
lch2685904364的博客
08-31 4710
StringBuilder和String可以相互转换： String->StringBuilder：可以使用StringBuilder的构造方法。 StringBuilder(String str) 构造一个字符串生成器，并初始化为指定的字符串内容。 StringBuilder->String:可以使用StringBuilder中的toString方法。 public String toString();将当前StringBuilder对象转换为String对象。 ...
StringBuilder类-toString()方法
lsc0211的博客
03-05 574
StringBuilder类-toString()方法 StringBuilder->String：可用StringBuilder中的toString方法 //String -> StringBuilder String str = "hello"; StringBuilder bu = new StringBuilder(str); //往StringBuilder中添加数据 bu...
C#使用String和StringBuilder运行速度测试及各自常用方法简介
08-26
C#使用String和StringBuilder运行速度测试及各自常用方法简介 在C#语言中，String和StringBuilder都是用于处理字符串的类，但是它们在性能和使用场景方面有很大的区别。本文将对String和StringBuilder进行运行速度...
C#中String和StringBuilder的简介与区别
01-01
String的缺点是每次字符串变量的内容发生了改变时，都必须重新分配内存。你想想，如果创建一个迭代100000次的循环，每次迭代都将一个字符连接到字符串，这样内存中就会有100000个字符串，每个字符串仅仅与前一个字符...
C#中的char、string和StringBuilder的使用详解
08-18
在C#编程中，字符串处理是一个非常重要的环节，涉及到字符（char）、字符串（string）和StringBuilder等多个类型。下面将详细介绍这几种类型在C#中的使用方法和相关知识点。 首先，我们来探讨char类型。在C#中，...
C#中String StringBuilder StringBuffer类的用法
08-30
C#中String StringBuilder StringBuffer类的用法 C#中String、StringBuilder和StringBuffer三个类是字符串操作中经常使用的类，本文将对这三个类的用法进行详细介绍。 String类 String类是C#中最基本的字符串类型...
C#文章加空格源码 StringBuilder类
05-27
有选中部分给选中部分加空格 没有选中部分给整篇文章加空格
String Builder 源码分析
公众号：Java后端
08-14 302
StringBuilder 与 StringBuffer 区别StringBuilder 可变字符串，线程不太安全，但效率高，推荐使用。StringBuffer 可变字符...
源码浅谈(一)：java中的 toString()方法
defukwanmcth26174的博客
05-12 615
前言： toString()方法 相信大家都用到过，一般用于以字符串的形式返回对象的相关数据。 　　 　　最近项目中需要对一个ArrayList<ArrayList<Integer>> datas 形式的集合处理。 　　处理要求把集合数据转换成字符串形式，格式为 ：子集合1数据+"#"+子集合2数据+"#"+....+子集合n数据。 　　举...
String,StringBuilder,StringBuffer源码分析
顶峰
01-16 679
String 长度大小不可变StringBuffer 和 StringBuilder 长度可变StringBuffer 线程安全 StringBuilder 线程不安全因此：String：适用于少量的字符串操作的情况StringBuilder：适用于单线程下在字符缓冲区进行大量操作的情况StringBuffer：适用多线程下在字符缓冲区进行大量操作的情况。
Stringbuilder的底层原理
最新发布
acasfdwrffafasfd的博客
07-07 209
如果大于当前数组的长度就会进行长度扩容扩容的方式是把数组长度左移1位再加2（*2+2）如果新扩容的数组长度任然小于要添加的字符数则直接将要添加的字符串长度作为数组的新长度，如果该长度小于0或者大于最大限制的长度，会报错否则返回新的长度然后通过Arrays.copyof方法创建一个新的具有新数组长度的数组并将原数组的内容复制给新数组完成扩容。他的底层是一个char类型的数组来存储字符数据可以对数组进行初始化也可以在元素添加时进行扩容。如果小于当前数组长度则直接把字符串添加到数组中。类型的数组value。
Java在手，世界我有！！！Java基础之StringBuilder类——append()和toString()方法
醉挽~清风
08-24 812
StringBuilder类概述 java.lang.StringBuilder是个字符串的缓冲区，即它是一个容器.它的内部拥有一个数组用来存放字符串内容，进行字符串拼接时，直接在数组中加入新内容。 StringBuilder会自动维护数组，进行扩容。(默认16字符空间，超过自动扩充) StringBuilder类构造方法 public StringBuilder()：构造一个空的StringBuilder容器。 public StringBuilder(String str)：构造一个StringBuil
StringBuilder的底层源码探究
qq_43383307的博客
08-02 288
打开源码 可以看见StringBulder有四个构造器 空参构造器初始化了一个16大小的数组 如果一开是new的时候就输入一个字符串或数组，StringBuilder又会怎么做呢？ 很明显，底层选择字符串长度（数组长度）+16为总长度 接下来探究append方法的实现： 先将存入的对象变为String型，再存入 接下来，先判断是否为null，如果为null，他会把null拆分为四个字母“n ” “u” ”l“ ”l"存入 接着判断当前容量是否足够，如过不够，会新建一个数组，容量为原来的2倍+2
java tostring底层_String底层解析
weixin_39545329的博客
02-28 358
目录关于StringString类型的底层代码是Java所有底层代码中相对来说比较简单、好理解。同时，String底层的源码又是面试官经典的“面试第一题”。“良好的开端就是成功的一半”，因此这个问题回答的好坏会很大程度影响你接下来的面试。我会在这篇博客中梳理几个面试中频率较高的知识点。String内部结构String内部存储结构为char数组，有两个私有变量，一个是char[]，哈希值。具体结构：...
C# StringBuilder 转 stringlist
07-14
要将C#中的StringBuilder对象转换为一个字符串列表（string list），可以按照以下步骤进行操作： 1. 将StringBuilder对象转换为一个字符串：使用StringBuilder对象的ToString()方法将其转换为一个字符串。 ```csharp StringBuilder sb = new StringBuilder(); // 添加一些文本到StringBuilder对象 string str = sb.ToString(); // 将StringBuilder对象转换为字符串 ``` 2. 将字符串拆分为字符串数组：使用String类的Split()方法将字符串拆分为一个字符串数组。 ```csharp string[] strArray = str.Split('\n'); // 使用换行符拆分字符串为字符串数组 ``` 3. 创建一个字符串列表，并将字符串数组添加到列表中：使用List<string>类创建一个字符串列表，并将字符串数组的每个元素添加到列表中。 ```csharp List<string> stringList = new List<string>(); stringList.AddRange(strArray); // 将字符串数组的每个元素添加到列表中 ``` 现在，您可以使用stringList变量来访问转换后的字符串列表，每个元素都是StringBuilder对象中的一行文本。 请注意，转换后的字符串列表将根据您在StringBuilder对象中的文本上的换行符进行拆分。在上面的示例中，我们使用`\n`作为换行符进行拆分。如果您的StringBuilder对象中使用了其他换行符，例如`\r\n`，则需要相应地调整拆分方法。 希望这能帮助到您！
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

元气小羊.

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值