Java 工具类总结(2): 再也不怕表单字符串处理 - String / StringBuilder / StringBuffer

String / StringBuilder / StringBuffer 是 Java 中字符串类;
本文从源码角度, 进行分析与总结:
1. String 常用的方法和注意点;
2. StringBuilder 和 StringBuffer 各自的特点;
3. 可变类和不可变类的实现原理

1. String 类简要总结

1.1 String 源码分析

/**
 * The String class represents character strings. All
 * string literals in Java programs, such as {@code "abc"}, are
 * implemented as instances of this class.
 * String 类用于表述字符串字面量, 如: "abc" 就是 String 类的一个实例;
 * 
 * Strings are constant; their values cannot be changed after they
 * are created. String buffers support mutable strings.
 * Because String objects are immutable they can be shared. For example:
 * <blockquote><pre>
 *     String str = "abc";
 * </pre></blockquote><p>
 * is equivalent to:
 * <blockquote><pre>
 *     char data[] = {'a', 'b', 'c'};
 *     String str = new String(data);
 * </pre></blockquote><p>
 * Here are some more examples of how strings can be used:
 * <blockquote><pre>
 *     System.out.println("abc");
 *     String cde = "cde";
 *     System.out.println("abc" + cde);
 *     String c = "abc".substring(2,3);
 *     String d = cde.substring(1, 2);
 * </pre></blockquote>
 * <p>
 * String 类是 Immutable 不可变的, String 实例能够被多个变量共享;(但是, 此处举的例子我没有看懂, 哪里能体现共享)
 * 我理解的共享: 
 * String str1 = "Hello";
 * String str2 = "Hello";
 * 此时的 str1, str2 是指向同一个字符串存储地址的, 即 str1 == str2 为 true;
 * 
 * The class {@code String} includes methods for examining
 * individual characters of the sequence, for comparing strings, for
 * searching strings, for extracting substrings, and for creating a
 * copy of a string with all characters translated to uppercase or to
 * lowercase. Case mapping is based on the Unicode Standard version
 * specified by the {@link java.lang.Character Character} class.
 * <p>
 * String 包含常用的方法: 比较 / 查找 / 提取子串 / 创建新字符串(全部大写/小写)
 * 
 * The Java language provides special support for the string
 * concatenation operator (+), and for conversion of
 * other objects to strings. String concatenation is implemented
 * through the {@code StringBuilder}(or {@code StringBuffer})
 * class and its {@code append} method.
 * String conversions are implemented through the method
 * {@code toString}, defined by {@code Object} and
 * inherited by all classes in Java. For additional information on
 * string concatenation and conversion, see Gosling, Joy, and Steele,
 * <i>The Java Language Specification</i>.
 * 
 * 
 * <p> Unless otherwise noted, passing a <tt>null</tt> argument to a constructor
 * or method in this class will cause a {@link NullPointerException} to be
 * thrown.
 * 不要试图访问 String str = null, 被赋予 null 值得字符串变量, 会 cause NullPointerException 错误
 * 
 * <p>A {@code String} represents a string in the UTF-16 format
 * in which <em>supplementary characters</em> are represented by <em>surrogate
 * pairs</em> (see the section <a href="Character.html#unicode">Unicode
 * Character Representations</a> in the {@code Character} class for
 * more information).
 * Index values refer to {@code char} code units, so a supplementary
 * character uses two positions in a {@code String}.
 * <p>The {@code String} class provides methods for dealing with
 * Unicode code points (i.e., characters), in addition to those for
 * dealing with Unicode code units (i.e., {@code char} values).
 *
 * @author  Lee Boynton
 * @author  Arthur van Hoff
 * @author  Martin Buchholz
 * @author  Ulf Zibis
 * @see     java.lang.Object#toString()
 * @see     java.lang.StringBuffer
 * @see     java.lang.StringBuilder
 * @see     java.nio.charset.Charset
 * @since   JDK1.0
 */

查看完整文档

---

1.2 String 演示

// 1. 字符串就是多个 Unicode 字符序列
String str = "Java\u2122";  
System.out.println(str);

// 2. used frequently methods
String str2 = str.substring(0, 1);  // s
String str3 = str.substring(str.length()-1, str.length()); // /u2122

// 3. String is immutable class
String str4 = str + "Hello";    
String str5 = "Java\u2122Hello";
System.out.println(str4 == str5);   // false
String str8 = "hel";
char[] chs = {'h', 'e', 'l'};
String str9 = new String(chs);
System.out.println(str8 == str9);   // false



//5. "" 和 null
String str6 = "";   //str6 是 String 对象, 长度为 0, 值为 空
String str7 = null; // str7 只是 null 对象, 表示还没有被初始化
                    // 请不要试图使用 str7 进行操作 !!!

1.3 常用方法

1.4 关于 Java 采用 UTF-16 编码的问题

留下问题: (关于 Java 采用 UTF-16 编码的问题)
Java 字符串是由 char 序列组成的, char 类型是一个采用 UTF-16 编码格式表示 Unicode 代码点的代码单元;

大多数字符使用一个代码点就可以表示, 而辅助字符需要两个代码点;
那么如何对具有两个代码点的字符串进行操作呢 ?

2. 从源码分析 StringBuilder / StringBuffer

总结: StringBuffer 和 StringBuilder 都是可变类;

StringBuilder 是 JDK 1.5 引入的类;

当业务主要涉及字符串存储于访问的时候, 使用 String 类;

当业务主要涉及字符串 insert / update / delete 时候, 使用 StringBuilder ( 单线程) / StringBuffer (多线程)

2.1 继承关系

2.2 分析 StringBuilder 源码

StringBuilder 和 StringBuffer 所有方法都相同, 只是在线程安全和效率上有所区别, 因此, 我只演示 StringBuilder 的部分源码

/**
 * A mutable sequence of characters.  This class provides an API compatible
 * with {@code StringBuffer}, but with no guarantee of synchronization.
 * This class is designed for use as a drop-in replacement for
 * {@code StringBuffer} in places where the string buffer was being
 * used by a single thread (as is generally the case).   Where possible,
 * it is recommended that this class be used in preference to
 * {@code StringBuffer} as it will be faster under most implementations.
 *
 * StringBuilder 是可变的字符序列, 它提供的类方法和 StringBuilder 完全相同, 但是它是非线程安全的 !!!
 * StringBuilder 类设计的初衷是, 希望在单线程(不要求线程安全)情境下, 替代 StringBuffer 类, 尽可能的
 * 提高系统的运行效率; 
 * 
 * <p>The principal operations on a {@code StringBuilder} are the
 * {@code append} and {@code insert} methods, which are
 * overloaded so as to accept data of any type. Each effectively 
 * converts a given datum to a string and then appends or inserts the
 * characters of that string to the string builder. 
 * StringBuilder 类中主要的方法包括: append() / insert() 方法;
 * 
 *  The {@code append} method always adds these characters at the end
 * of the builder; the {@code insert} method adds the characters at
 * a specified point.
 * <p>
 * append() 方法: 从末尾增加新字符串
 * insert() 方法: 在指定索引位置增加字符串
 * 
 * For example, if {@code z} refers to a string builder object
 * whose current contents are "{@code start}", then
 * the method call {@code z.append("le")} would cause the string
 * builder to contain "{@code startle}", whereas
 * {@code z.insert(4, "le")} would alter the string builder to
 * contain "{@code starlet}".
 * 
 * In general, if sb refers to an instance of a {@code StringBuilder},
 * then {@code sb.append(x)} has the same effect as
 * {@code sb.insert(sb.length(), x)}.
 * 
 * Every string builder has a capacity(容量, 这里指的是存储字符串的空间). As long as the length of the
 * character sequence contained in the string builder does not exceed
 * the capacity, it is not necessary to allocate a new internal
 * buffer. If the internal buffer overflows, it is automatically made larger.
 * 这里主要说明了 StringBuilder 类是动态调整存储空间的, 如果存储空间不足的话, 会自动增加存储空间;
 * 在父类 AbstractStringBuilder 中, ensureCapacityInternal() 方法就是用来确保存储空间问题;
 * (当然, StringBuffer 也具有相同的功能实现)
 * 
 * <p>Instances of {@code StringBuilder} are not safe for
 * use by multiple threads. If such synchronization is required then it is
 * recommended that {@link java.lang.StringBuffer} be used.
 *
 * <p>Unless otherwise noted, passing a {@code null} argument to a constructor
 * or method in this class will cause a {@link NullPointerException} to be
 * thrown.
 *
 * @author      Michael McCloskey
 * @see         java.lang.StringBuffer
 * @see         java.lang.String
 * @since       1.5
 */

public final class StringBuilder extends AbstractStringBuilder
    implements java.io.Serializable, CharSequence
{
    /**
     * Constructs a string builder with no characters in it and an
     * initial capacity of 16 characters.
     */
    public StringBuilder() {
        super(16);    // initial capacity: 16 个字符
    }

    /**
     * Constructs a string builder with no characters in it and an
     * initial capacity specified by the {@code capacity} argument.
     *
     * @param      capacity  the initial capacity.
     * @throws     NegativeArraySizeException  if the {@code capacity}
     *               argument is less than {@code 0}.
     */
    public StringBuilder(int capacity) {
        super(capacity);
    }

    /**
     * Constructs a string builder initialized to the contents of the
     * specified string. The initial capacity of the string builder is
     * {@code 16} plus the length of the string argument.
     *
     * @param   str   the initial contents of the buffer.
     */
    public StringBuilder(String str) {
        super(str.length() + 16);    // 如果有 String 实参, 此时的容量是 str.length() + 16 个字符大小
        append(str);
    }

    // append() 方法
    // delete() 方法
    // deleteCharAt() 方法
    // replace() 方法
    // insert() 方法
    // indexOf() 方法
    // reverse() 方法

}

2.3 解释可变类 和 不可变类的实现

那为什么, StringBuilder / StringBuffer 是可变的, 而 String 就不是可变的呢? 接下里, 就从源码上来分析:

// from AbstractStringBuilder.java
// AbstractStringBuilder 是 StringBuilder 和 StringBuffer 共同的父类

abstract class AbstractStringBuilder implements Appendable, CharSequence {
    /**
     * The value is used for character storage.
     */
    char[] value;    // 原来 StringBuffer 和 StringBuilder 都是通过 char[] value 进行存值嗒
                     // 最重要的是, 不是 final 修饰的哦, 当然可以改变

    /**
     * The count is the number of characters used.
     */
    int count;
}


// from String.java
public final class String
    implements java.io.Serializable, Comparable<String>, CharSequence {
    /** The value is used for character storage. */
    private final char value[];    // final 修饰, 这就是不可变的原因
}

3. 参考

• Core Java Volumn I , Chapter 3.6

• Think in Java,

• 尚学堂 Java 300 集,