Java String, StringBuffer和StringBuilder实例

1- 分层继承
2- 可变和不可变的概念
3- String
3.1- 字符串是一个非常特殊的类
3.2- String 字面值 vs. String对象
3.3- String的方法
3.3.1- length()
3.3.2- concat(String)
3.3.3- indexOf(..)
3.3.4- substring(..)
3.3.5- replace
3.3.6- 其它实例
4- StringBuffer vs StringBuilder

1- 分层继承

当使用文本数据时，Java提供了三种类别，包括String, StringBuffer和StringBuilder。当使用大数据来工作时，你应该用StringBuffer或StringBuilder来优化效率。基本上这三个类有许多相似之处。

• String 是不可变的(这个概念的更多详细信息，在文档中)。它不允许子类的存在。
• StringBuffer, StringBuilder 是可变的。

StringBuilder和StringBuffer都是一样的，除了涉及到多线程的使用情况。

• 为了处理多线程使用文本，你应该为了防止线程之间冲突而使用StringBuffer。
• 要使用一个线程处理的文本，你应该使用StringBuilder。

至于处理的速度，StringBuilder是最好的，其次是StringBuffer，而最后是String。

2- 可变和不可变的概念

考虑下面的一个例子：

// This is a class with value field and name field.
// When you create this class, you cannot reset the value and all other fields from outside.
// This class does not have methods for the purpose of resetting fields from outside.
// It means this class is immutable
public class ImmutableClassExample  {
   private int value;
   private String name;

   public ImmutableClassExample(String name, int value)  {
          this.value = value;
          this.name= name;
   }

   public String getName()  {
          return name;
   }

   public int getValue()  {
         return value;
   }
}


// This is a class owning a value field.
// After creating the object, you can reset values of the value field by calling setNewValue(int) method.
// This is a mutable class.
public class MutableClassExample  {

     private int value;

     public MutableClassExample(int value)  {
           this.value= value;
     }

     public void setNewValue(int newValue)  {
          this.value = newValue;
     }

}

String是不可变的类。String包括各种字段如长度，但在这些字段中的值不能改变。

3- String

String 在Java中是最重要的一个类，Java编程开始使用字符串就使用著名的System.out.println()语句在控制台上打印东西。许多Java初学者不知道String是不可变的和最终的Java字符串结果，每次修改需要创建一个新的String对象。

3.1- String是一个非常特殊的类

字符串接受Java的特殊处理，因为它们在程序中经常使用。因此，效率(在计算和存储方面)是至关重要的。

Java的设计者决定这一个面向对象语言，以保留原始类型，而不是使所有的对象， 以便提高语言的性能。原始数据存储(在)调用栈，其需要较少的存储空间和更方便的操作。另一方面，对象被存储在程序堆，这需要复杂的存储器管理和更多的存储空间。出于性能的原因，Java字符串被设计为在一种原始和类之间类型。特殊功能的字符串包括：

1. “+”操作符，它执行的加入对原始类型(如int和double)，重载对String对象进行操作。'+'两个字符串操作数进行串联。 Java不考虑让开发者支持运算符重载。在支持运算符重载像C++语言，可以把一个“+”操作符来执行减法，引起不良代码。 “+”操作符是重载的内部支持字符串连接在Java中的唯一操作符。注意到，“+”不在两个任意对象上工作。
2. 一个字符串，可以通过构造：
   • 直接分配字符串到字符串引用 - 就像一个原始数据类型或通过“new”操作符和构造，类似于任何其他类。然而，这是不常用的，所以不推荐。
3. 字符串字面存储在一个公共池。这有利于对具有相同内容的字符串，以节省存储存储的共享。new操作符分配的String对象都存储在堆中，并没有对相同内容的共享存储。

例如：

// Implicit construction via string literal
String str1 = "Java is Hot";

// Explicit construction via new
String str2 = new String("I'm cool");
 

3.2- String文字和String对象

正如前面提到的，有两种方法来构造字符串：通过指定一个字符串字面量或显式创建通过 new 操作符，并构造一个String对象的隐式构建。 例如，

String s1 = "Hello";              // String literal
String s2 = "Hello";              // String literal
String s3 = s1;                   // same reference
String s4 = new String("Hello");  // String object
String s5 = new String("Hello");  // String object

我们使用以下图片说明来解释它：

Java已经提供了一个特殊的机制，来保存字符串文字 - 所谓的字符串公共池。如果两个字符串具有相同的内容，它们将共享公共池内同一存储器。这样的做法是采取以节省对经常使用的字符串存储。在另一方面，通过 new 操作符和构造器创建String对象都保存在堆中。 在堆中的每个String对象都有自己的存储就像任何其他对象。没有共享存储堆，即使两个String对象具有相同的内容。

可以使用String类的方法equals()方法比较两个字符串的内容。可以使用关系等于运算符'=='来比较两个对象的引用(或指针)。研究以下代码：

String s1 = "Hello";              // String literal
String s2 = "Hello";              // String literal
String s3 = s1;                   // same reference
String s4 = new String("Hello");  // String object
String s5 = new String("Hello");  // String object

s1 == s1;         // true, same pointer
s1 == s2;         // true, s1 and s2 share storage in common pool
s1 == s3;         // true, s3 is assigned same pointer as s1
s1 == s4;         // false, different pointers
s4 == s5;         // false, different pointers in heap

s1.equals(s3);    // true, same contents
s1.equals(s4);    // true, same contents
s4.equals(s5);    // true, same contents

事实上，你应该使用字符串，而是采用了“new”的操作符，这有助于加快程序运行速度。

3.3- 字符串的方法

下面是字符串列表的方法：

SN	方法	描述
1	char charAt(int index)	返回指定索引处的字符
2	int compareTo(Object o)	该字符串的另一个对象比较
3	int compareTo(String anotherString)	字典顺序比较两个字符串
4	int compareToIgnoreCase(String str)	按字典顺序比较两个字符串，忽略大小写差异
5	String concat(String str)	将指定字符串添加到该字符串的结尾处
6	boolean contentEquals(StringBuffer sb)	当且仅当此String表示字符与指定StringBuffer的顺序相同时返回true
7	static String copyValueOf(char[] data)	返回表示所指定的数组中的字符序列的字符串
8	static String copyValueOf(char[] data, int offset, int count)	返回表示所指定的数组中的字符序列的字符串
9	boolean endsWith(String suffix)	测试此字符串是否以指定的后缀结束
10	boolean equals(Object anObject)	比较此字符串指定的对象
11	boolean equalsIgnoreCase(String anotherString)	这个字符串与另一个字符串比较，不考虑大小写
12	byte getBytes()	将此String使用平台默认的字符集的字节序列解码，并将结果存储到一个新的字节数组
13	byte[] getBytes(String charsetName)	将此String使用指定字符集的字节序列解码，并将结果存储到一个新的字节数组
14	void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)	将这个字符串的字符复制到目标字符数组
15	int hashCode()	返回此字符串的哈希码
16	int indexOf(int ch)	返回此字符串指定字符第一次出现处的索引
17	int indexOf(int ch, int fromIndex)	返回此字符串指定字符，从指定索引的搜索中第一次出现处的索引
18	int indexOf(String str)	返回此字符串的指定子第一次出现处的索引
19	int indexOf(String str, int fromIndex)	返回此字符串的指定从指定索引处的子字符串第一次出现的索引
20	String intern()	返回字符串对象规范表示形式
21	int lastIndexOf(int ch)	返回此字符串指定字符最后一次出现处的索引
22	int lastIndexOf(int ch, int fromIndex)	返回此字符串指定字符最后一次出现处的索引，从指定索引处开始向后搜索
23	int lastIndexOf(String str)	返回此字符串指定子最右边出现处的索引
24	int lastIndexOf(String str, int fromIndex)	返回此字符串的指定子最后一次出现处的索引，指定索引处向后开始搜索
25	int length()	返回此字符串的长度
26	boolean matches(String regex)	判断此字符串是否与给定的正则表达式匹配。
27	boolean regionMatches(boolean ignoreCase, int toffset, String other, int ooffset, int len)	检测两个字符串区域是否是相等的
28	boolean regionMatches(int toffset, String other, int ooffset, int len)	检测两个字符串区域是否是相等的
29	String replace(char oldChar, char newChar)	返回从此字符串中使用newChar替换oldChar所有出现的字符串
30	String replaceAll(String regex, String replacement)	这个替换字符串使用给定的正则表达式匹配并替换每个子字符串
31	String replaceFirst(String regex, String replacement)	这个替换字符串使用给定的正则表达式匹配替换第一个字符串
32	String[] split(String regex)	围绕给定的正则表达式的匹配来拆分此字符串
33	String[] split(String regex, int limit)	围绕给定的正则表达式的匹配来拆分此字符串
34	boolean startsWith(String prefix)	测试此字符串是否以指定的前缀开始
35	boolean startsWith(String prefix, int toffset)	检测此字符串是否从指定索引开始以指定前缀开始
36	CharSequence subSequence(int beginIndex, int endIndex)	返回一个新的字符序列，它是此序列的子序列
37	String substring(int beginIndex)	返回一个新字符串，它是此字符串的子串
38	String substring(int beginIndex, int endIndex)	返回一个新字符串，它是此字符串的子串
39	char[] toCharArray()	这个字符串转换为一个新的字符数组
40	String toLowerCase()	将所有在这个字符串中的字符的使用默认语言环境的规则转为小写
41	String toLowerCase(Locale locale)	将所有在这个字符串中的字符使用给定Locale的规则转为小写
42	String toString()	这个对象(这已经是一个字符串！)本身返回。
43	String toUpperCase()	所有的字符在这个字符串使用默认语言环境的规则转换为大写。
44	String toUpperCase(Locale locale)	所有的字符在这个字符串使用给定的Locale规则转换为大写
45	String trim()	返回字符串的副本，开头和结尾的空白省略
46	static String valueOf(primitive data type x)	返回传递的数据类型参数的字符串表示

3.3.1- length()

• LengthDemo.java

package com.yiibai.tutorial.str;

public class LengthDemo {

    public static void main(String[] args) {
        String str = "This is text";
        int len = str.length();
        System.out.println("String Length is : " + len);
    }
}

运行示例的结果：

3.3.2- concat(String)

• ConcatDemo.java

package com.yiibai.tutorial.str;

public class ConcatDemo {

    public static void main(String[] args) {
        String s1 = "One";
        String s2 = "Two";
        String s3 = "Three";

        // s1.concat(s2) same as s1 + s2
        String s = s1.concat(s2);
        System.out.println("s1.concat(s2) = " + s);

        // s1.concat(s2).concat(s3) same as s1 + s2 + s3;
        s = s1.concat(s2).concat(s3);

        System.out.println("s1.concat(s2).concat(s3) = " + s);
    }
}

运行示例的结果：

s1.concat(s2) = OneTwo
s1.concat(s2).concat(s3) = OneTwoThree

3.3.3- indexOf(..)

• IndexOfDemo.java

package com.yiibai.tutorial.str;

public class IndexOfDemo {

    public static void main(String[] args) {
        String str = "This is text";
       
        // Find index within this string of the first occurrence 'i'.
        // ==> 2
        int idx = str.indexOf('i');
        System.out.println("- indexOf('i') = " + idx);

      
        // Find index within this string of the first occurrence 'i'
        // starting the search at index 4.  
        // ==> 5
        idx = str.indexOf('i', 4);
        System.out.println("- indexOf('i',4) = " + idx);
       
        // index within this string of the first occurrence of "te".
        // ==> 8
        idx = str.indexOf("te");
        System.out.println("- indexOf('te') = " + idx);
    }

}

运行示例的结果：

- indexOf('i') = 2
- indexOf('i',4) = 5
- indexOf('te') = 8

3.3.4- substring(..)

• SubstringDemo.java

package com.yiibai.tutorial.str;

public class SubstringDemo {

    public static void main(String[] args) {
        String str = "This is text";

        // Returns the substring from index 3 to the end of string.
        String substr = str.substring(3);

        System.out.println("- substring(3)=" + substr);

        // Returns the substring from index 2 to index 7.
        substr = str.substring(2, 7);

        System.out.println("- substring(2, 7) =" + substr);
    }
}

运行示例的结果：

- substring(3)=s is text
- substring(2, 7) =is is

3.3.5- replace

与更换的一些方法。

// Returns a new string resulting from replacing all occurrences of
// oldChar in this string with newChar.
public String replace(char oldChar, char newChar)

// Replaces each substring of this string that matches the given  
// 'regular expression' with the given replacement.
public String replaceAll(String regex, String replacement)

// Replaces the first substring of this string that matches
// the given <'regular expression' with the given replacement.
public String replaceFirst(String regex, String replacement)

• ReplaceDemo.java

package com.yiibai.tutorial.str;

public class ReplaceDemo {

    public static void main(String[] args) {
        String str = "This is text";

        // Replace the character 'i' by 'x'.
        String s2 = str.replace('i', 'x');

        System.out.println("- s2=" + s2);

        // Replace all the strings match "is" by "abc". (Regular Expression)
        String s3 = str.replaceAll("is", "abc");

        System.out.println("- s3=" + s3);

        // Replaces the first substring of this string that matches "is" by "abc".
        String s4 = str.replaceFirst("is", "abc");

        System.out.println("- s4=" + s4);
       
        // (See also document the regular expression)
        // Replace all substring matching expression:
        // "is|te": means "is" or "te" replaced by "+".
        String s5 = str.replaceAll("is|te", "+");
        System.out.println("- s5=" + s5);
    }

}

运行示例的结果：

- s2=Thxs xs text
- s3=Thabc abc text
- s4=Thabc is text
- s5=Th+ + +xt

3.3.6- 其它示例

• StringOtherDemo.java

package com.yiibai.tutorial.str;

public class StringOtherDemo {

    public static void main(String[] args) {
        String str = "This is text";

        System.out.println("- str=" + str);

        // Return lower case string.
        String s2 = str.toLowerCase();

        System.out.println("- s2=" + s2);

        // Return upper case string
        String s3 = str.toUpperCase();

        System.out.println("- s3=" + s3);

        // Check string started by "This" or not.
        boolean swith = str.startsWith("This");

        System.out.println("- 'str' startsWith This ? " + swith);
       
        // A string with whitespace in beginning and end.
        // Note: \t is tab character
        // \n is new line character
        str = " \t Java is hot!  \t \n ";

        System.out.println("- str=" + str);

        // Returns a copy of the string, with leading and trailing whitespace omitted.
        String s4 = str.trim();

        System.out.println("- s4=" + s4);
    }

}

运行示例的结果：

- str=This is text
- s2=this is text
- s3=THIS IS TEXT
- 'str' startsWith This ? true
- str= 	 Java is hot!  	 
 
- s4=Java is hot!

4- StringBuffer vs StringBuilder

StringBuffer是可变的。它可以在长度和内容方面发生变化。StringBuffer是线程安全的，这意味着它们已经同步方法来控制访问，以便只有一个线程可以在同一时间访问一个StringBuffer对象同步代码。因此，StringBuffer的对象通常在多线程环境中是安全的，使用多个线程可以试图同时访问相同StringBuffer对象。

StringBuilder类非常相似的StringBuffer，不同之处在于它的访问不同步的，因此，它不是线程安全的。由于不同步，StringBuilder的性能可以比StringBuffer更好。因此，如果在单线程环境中工作，使用StringBuilder，而不是StringBuffer可能会有更高的性能。这也类似其他情况，如StringBuilder的局部变量(即一个方法中的一个变量)，其中只有一个线程会访问一个StringBuilder对象。

StringBuffer的方法(StringBuilder相似)

// Constructors
StringBuffer()             // an initially-empty StringBuffer
StringBuffer(int size)     // with the specified initial size
StringBuffer(String s)     // with the specified initial content

// Length
int length()

// Methods for building up the content
// type could be primitives, char[], String, StringBuffer, etc
StringBuffer append(type arg)  // ==> note above!
StringBuffer insert(int offset, type arg) // ==> note above!

// Methods for manipulating the content
StringBuffer delete(int start, int end)
StringBuffer deleteCharAt(int index)
void setLength(int newSize)
void setCharAt(int index, char newChar)
StringBuffer replace(int start, int end, String s)
StringBuffer reverse()

// Methods for extracting whole/part of the content
char charAt(int index)
String substring(int start)
String substring(int start, int end)
String toString()

// Methods for searching
int indexOf(String searchKey)
int indexOf(String searchKey, int fromIndex)
int lastIndexOf(String searchKey)
int lastIndexOf(String searchKey, int fromIndex)

• StringBuilderDemo.java

package com.yiibai.tutorial.strbb;


public class StringBuilderDemo {

    public static void main(String[] args) {
       
        // Create StringBuilder object
        // with no characters in it and
        // an initial capacity specified by the capacity argument
        StringBuilder sb = new StringBuilder(10);
        
        // Append the string Hello ... on sb.
        sb.append("Hello...");
        System.out.println("- sb after appends a string: " + sb);

        // append a character
        char c = '!';
        sb.append(c);
        System.out.println("- sb after appending a char: " + sb);

        // Insert a string at index 5
        sb.insert(8, " Java");
        System.out.println("- sb after insert string: " + sb);
        
    
        // Delete substring at index 5 to 8
        sb.delete(5,8);

        System.out.println("- sb after delete: " + sb);
    }
}

运行示例的结果：

- sb after appends a string: Hello...
- sb after appending a char: Hello...!
- sb after insert string: Hello... Java!
- sb after delete: Hello Java!