String,String Buffer,String Build

﹏ヽ暗。殇╰゛Y 2022-03-08 21:28 246阅读 0赞

**可变性**

简单的来说：String 类中使用 final 关键字字符数组保存字符串，`private　final　char　value[]`，所以 String 对象是不可变的。而StringBuilder 与 StringBuffer 都继承自 AbstractStringBuilder 类，在 AbstractStringBuilder 中也是使用字符数组保存字符串`char[]value` 但是没有用 final 关键字修饰，所以这两种对象都是可变的。

StringBuilder 与 StringBuffer 的构造方法都是调用父类构造方法也就是 AbstractStringBuilder 实现的，大家可以自行查阅源码。

AbstractStringBuilder.java

abstract class AbstractStringBuilder implements Appendable, CharSequence {
        char[] value;
        int count;
        AbstractStringBuilder() {
        }
        AbstractStringBuilder(int capacity) {
            value = new char[capacity];
        }

**线程安全性**

String 中的对象是不可变的，也就可以理解为常量，线程安全。AbstractStringBuilder 是 StringBuilder 与 StringBuffer 的公共父类，定义了一些字符串的基本操作，如 expandCapacity、append、insert、indexOf 等公共方法。StringBuffer 对方法加了同步锁或者对调用的方法加了同步锁，所以是线程安全的。StringBuilder 并没有对方法进行加同步锁，所以是非线程安全的。

**性能**

每次对 String 类型进行改变的时候，都会生成一个新的 String 对象，然后将指针指向新的 String 对象。StringBuffer 每次都会对 StringBuffer 对象本身进行操作，而不是生成新的对象并改变对象引用。相同情况下使用 StringBuilder 相比使用 StringBuffer 仅能获得 10%~15% 左右的性能提升，但却要冒多线程不安全的风险。

**对于三者使用的总结：**

1.  操作少量的数据 = String
2.  单线程操作字符串缓冲区下操作大量数据 = StringBuilder
3.  多线程操作字符串缓冲区下操作大量数据 = StringBuffer

===========================================================

**String、StringBuffer和StringBuilder的区别**

**String** 类分别用于实现 [IComparable][]、[ICloneable][]、[IConvertible][]、[IEnumerable][] 和 [IComparable][IComparable 1] 接口。使用 [Convert][] 类进行转换，而不是使用此类型的 **IConvertible** 显式接口成员实现。

**String** 类提供的成员执行以下操作：比较 **String** 对象；返回 **String** 对象内字符或字符串的索引；复制 **String** 对象的值；分隔字符串或组合字符串；修改字符串的值；将数字、日期和时间或枚举值的格式设置为字符串；对字符串进行规范化。

*  使用 [Compare][]、[CompareOrdinal][]、[CompareTo][]、[Equals][]、[EndsWith][] 和 [StartsWith][] 方法进    行比较。 
 *  使用 [IndexOf][]、[IndexOfAny][]、[LastIndexOf][] 和 [LastIndexOfAny][] 方法可获取字符串中子字符串或 Unicode 字符的索引。 
 *  使用 [Copy][] 和 [CopyTo][] 可将字符串或子字符串复制到另一个字符串或 **Char** 类型的数组。
 *  使用 [Substring][] 和 [Split][] 方法可通过原始字符串的组成部分创建一个或多个新字符串；使用 [Concat][] 和 [Join][] 方法可通过一个或多个子字符串创建新字符串。 
 *  使用 [Insert][]、[Replace][]、[Remove][]、[PadLeft][]、[PadRight][]、[Trim][]、[TrimEnd][] 和 [TrimStart][] 可修改字符串的全部或部分。
 *  使用 [ToLower][]、[ToLowerInvariant][]、[ToUpper][] 和 [ToUpperInvariant][] 方法可更改字符串中 Unicode 字符的大小写。 
 *  使用 [Format][]， 可将字符串中的一个或多个格式项占位符替换为一个或多个数字、日期和时间或枚举值的文本表示形式。 
 *  使用 [Length][] 属性可获取字符串中 **Char** 对象的数量；使用 [Chars][] 属性可访问字符串中实际的 **Char** 对象。
 *  使用 [IsNormalized][] 方法可测试某个字符串是否已规范化为特定的范式。使用 [Normalize][] 方法可创建规范化为特定范式的字符串。

**StringBuilder** 类此类表示值为可变字符序列的类似字符串的对象。之所以说值是可变的，是因为在通过追加、移除、替换或插入字符而创建它后可以对它进行修改。

**String****和****StringBuilder****、StringBuffer的区别：**

1.  **String 对象是不可改变的**。每次使用 System.String 类中的方法之一时，都要在内存中创建一个新的字符串对象，这就需要为该新对象分配新的空间。在需要对字符串执行重复修改的情况下，创建新的 String 对象相关的系统开销可能会非常昂贵。
2.  如果要**修改字符串而不创建新**的对象，则可以使用 System.Text.StringBuilder 类。例如，当在一个循环中将许多字符串连接在一起时，使用 StringBuilder 类可以提升性能。

3. 字符串是 Unicode 字符的连续集合，通常用于表示文本，而 String 是表示字符串的 System.Char 对象的连续集合。String 的值构成该连续集合的内容，并且该值是恒定的。由于 String 的值一旦创建就不能再修改，所以称它是恒定的。看似能修改 String 的方法实际上只是返回一个包含修改内容的新 String。

4. **StringBuffer**可改变的Unicode字符序列，允许并发操作，是线程安全的

例：对于字符串连接String str = "A" + "B" + "C" + "D";

产生："AB"、"ABC"、"ABCD"

在串池中产生的"AB"、"ABC"明显是多余对象，浪费空间。

解决方案：

String s = null;

StringBuffer sb = new StringBuffer("A");

sb.append("B");

sb.append("C");

sb.append("D");

s = sb.toString();

5.  **StringBuilder：**可改变的Unicode字符序列操作同StringBuffer，只是不支持并发操作，非线程安全的

6. 不考虑线程安全前提下,StringBuild性能最高,StringBuffer次之,String比较差.

为什么StringBuffer的性能比String高？主要原因在于String类是不可变类，任何对String引用指向的字符串作出的修改都会导致生成新的字符串（对象），而对StringBuffer的修改则不会导致新对象的产生。大家都知道，生成新对象是十分耗时的事情，自然导致对String对象的修改性能下降不少。

那么为什么StringBuilder的性能比StringBuffer的高呢？这则与线程安全有关。就是支持线程同步保证线程安全而导致性能下降的问题。StringBuffer和StringBuilder类的区别也在于此，新引入的StringBuilder类不是线程安全的，但其在单线程中的性能比StringBuffer高。

String str="You are nice.";  
str+="I love you so much.";  
  
如果用StringBuffer类的话，代码如下：  
  
StringBuffer str= new StringBuffer("You are nice.");  
str.append("I love you so much.");  
  
从表面看来String类只用一个加号（+）便完成了字符串的拼接，而StringBuffer类却要调用一个append()方法，是否实现起来更简洁，更单纯呢？其实不然，让我们了解一下程序运行内部发生了哪些事情：  
 可见，在这一个简单的一次拼接过程中，我们让程序创建了四个对象：两个待拼接的String，一个临时StringBuffer，和最后将StringBuffer转型成为的String－－它当然不是最初的str了，这个引用的名称没变，但它指向了新的String对象。  
   而如果直接使用StringBuffer类，程序将只产生两个对象：最初的StringBuffer和拼接时的String（"I love you so much."），也不再需要创建临时的StringBuffer类对象而后还得将其转换回String对象。  
  可以想象，当我们的字符串要被循环拼接若干段时，用String类直接操作会带来多少额外的系统开销，生成多少无用的临时StringBuffer对象，并处理多少次无谓的强制类型转换哪。

[IComparable]: http://msdn.microsoft.com/zh-cn/library/system.icomparable%28v=VS.80%29.aspx
[ICloneable]: http://msdn.microsoft.com/zh-cn/library/system.icloneable%28v=VS.80%29.aspx
[IConvertible]: http://msdn.microsoft.com/zh-cn/library/system.iconvertible%28v=VS.80%29.aspx
[IEnumerable]: http://msdn.microsoft.com/zh-cn/library/system.collections.ienumerable%28v=VS.80%29.aspx
[IComparable 1]: http://msdn.microsoft.com/zh-cn/library/4d7sx9hd%28v=VS.80%29.aspx
[Convert]: http://msdn.microsoft.com/zh-cn/library/system.convert%28v=VS.80%29.aspx
[Compare]: http://msdn.microsoft.com/zh-cn/library/system.string.compare%28v=VS.80%29.aspx
[CompareOrdinal]: http://msdn.microsoft.com/zh-cn/library/system.string.compareordinal%28v=VS.80%29.aspx
[CompareTo]: http://msdn.microsoft.com/zh-cn/library/system.string.compareto%28v=VS.80%29.aspx
[Equals]: http://msdn.microsoft.com/zh-cn/library/system.string.equals%28v=VS.80%29.aspx
[EndsWith]: http://msdn.microsoft.com/zh-cn/library/system.string.endswith%28v=VS.80%29.aspx
[StartsWith]: http://msdn.microsoft.com/zh-cn/library/system.string.startswith%28v=VS.80%29.aspx
[IndexOf]: http://msdn.microsoft.com/zh-cn/library/system.string.indexof%28v=VS.80%29.aspx
[IndexOfAny]: http://msdn.microsoft.com/zh-cn/library/system.string.indexofany%28v=VS.80%29.aspx
[LastIndexOf]: http://msdn.microsoft.com/zh-cn/library/system.string.lastindexof%28v=VS.80%29.aspx
[LastIndexOfAny]: http://msdn.microsoft.com/zh-cn/library/system.string.lastindexofany%28v=VS.80%29.aspx
[Copy]: http://msdn.microsoft.com/zh-cn/library/system.string.copy%28v=VS.80%29.aspx
[CopyTo]: http://msdn.microsoft.com/zh-cn/library/system.string.copyto%28v=VS.80%29.aspx
[Substring]: http://msdn.microsoft.com/zh-cn/library/system.string.substring%28v=VS.80%29.aspx
[Split]: http://msdn.microsoft.com/zh-cn/library/system.string.split%28v=VS.80%29.aspx
[Concat]: http://msdn.microsoft.com/zh-cn/library/system.string.concat%28v=VS.80%29.aspx
[Join]: http://msdn.microsoft.com/zh-cn/library/system.string.join%28v=VS.80%29.aspx
[Insert]: http://msdn.microsoft.com/zh-cn/library/system.string.insert%28v=VS.80%29.aspx
[Replace]: http://msdn.microsoft.com/zh-cn/library/system.string.replace%28v=VS.80%29.aspx
[Remove]: http://msdn.microsoft.com/zh-cn/library/system.string.remove%28v=VS.80%29.aspx
[PadLeft]: http://msdn.microsoft.com/zh-cn/library/system.string.padleft%28v=VS.80%29.aspx
[PadRight]: http://msdn.microsoft.com/zh-cn/library/system.string.padright%28v=VS.80%29.aspx
[Trim]: http://msdn.microsoft.com/zh-cn/library/system.string.trim%28v=VS.80%29.aspx
[TrimEnd]: http://msdn.microsoft.com/zh-cn/library/system.string.trimend%28v=VS.80%29.aspx
[TrimStart]: http://msdn.microsoft.com/zh-cn/library/system.string.trimstart%28v=VS.80%29.aspx
[ToLower]: http://msdn.microsoft.com/zh-cn/library/system.string.tolower%28v=VS.80%29.aspx
[ToLowerInvariant]: http://msdn.microsoft.com/zh-cn/library/system.string.tolowerinvariant%28v=VS.80%29.aspx
[ToUpper]: http://msdn.microsoft.com/zh-cn/library/system.string.toupper%28v=VS.80%29.aspx
[ToUpperInvariant]: http://msdn.microsoft.com/zh-cn/library/system.string.toupperinvariant%28v=VS.80%29.aspx
[Format]: http://msdn.microsoft.com/zh-cn/library/system.string.format%28v=VS.80%29.aspx
[Length]: http://msdn.microsoft.com/zh-cn/library/system.string.length%28v=VS.80%29.aspx
[Chars]: http://msdn.microsoft.com/zh-cn/library/system.string.chars%28v=VS.80%29.aspx
[IsNormalized]: http://msdn.microsoft.com/zh-cn/library/system.string.isnormalized%28v=VS.80%29.aspx
[Normalize]: http://msdn.microsoft.com/zh-cn/library/system.string.normalize%28v=VS.80%29.aspx