String、StringBuilder和StringBuffer类

*/

.hljs {
display: block;
overflow-x: auto;
padding: 0.5em;
color: #333;
background: #f8f8f8;
}

.hljs-comment,
.hljs-template_comment,
.diff .hljs-header,
.hljs-javadoc {
color: #998;
font-style: italic;
}

.hljs-keyword,
.css .rule .hljs-keyword,
.hljs-winutils,
.javascript .hljs-title,
.nginx .hljs-title,
.hljs-subst,
.hljs-request,
.hljs-status {
color: #333;
font-weight: bold;
}

.hljs-number,
.hljs-hexcolor,
.ruby .hljs-constant {
color: #099;
}

.hljs-string,
.hljs-tag .hljs-value,
.hljs-phpdoc,
.tex .hljs-formula {
color: #d14;
}

.hljs-title,
.hljs-id,
.coffeescript .hljs-params,
.scss .hljs-preprocessor {
color: #900;
font-weight: bold;
}

.javascript .hljs-title,
.lisp .hljs-title,
.clojure .hljs-title,
.hljs-subst {
font-weight: normal;
}

.hljs-class .hljs-title,
.haskell .hljs-type,
.vhdl .hljs-literal,
.tex .hljs-command {
color: #458;
font-weight: bold;
}

.hljs-tag,
.hljs-tag .hljs-title,
.hljs-rules .hljs-property,
.django .hljs-tag .hljs-keyword {
color: #000080;
font-weight: normal;
}

.hljs-attribute,
.hljs-variable,
.lisp .hljs-body {
color: #008080;
}

.hljs-regexp {
color: #009926;
}

.hljs-symbol,
.ruby .hljs-symbol .hljs-string,
.lisp .hljs-keyword,
.tex .hljs-special,
.hljs-prompt {
color: #990073;
}

.hljs-built_in,
.lisp .hljs-title,
.clojure .hljs-built_in {
color: #0086b3;
}

.hljs-preprocessor,
.hljs-pragma,
.hljs-pi,
.hljs-doctype,
.hljs-shebang,
.hljs-cdata {
color: #999;
font-weight: bold;
}

.hljs-deletion {
background: #fdd;
}

.hljs-addition {
background: #dfd;
}

.diff .hljs-change {
background: #0086b3;
}

.hljs-chunk {
color: #aaa;
}

#container {
padding: 15px;
}
pre {
border: 1px solid #ccc;
border-radius: 4px;
display: block;
background-color: #f8f8f8;
}
pre code {
white-space: pre-wrap;
}
.hljs,
code {
font-family: Monaco, Menlo, Consolas, 'Courier New', monospace;
}
:not(pre) > code {
padding: 2px 4px;
font-size: 90%;
color: #c7254e;
background-color: #f9f2f4;
white-space: nowrap;
border-radius: 4px;
}
-->

简介

String/StringBuilder/StringBuffer这3个类都能创建字符串对象，它们都继承自Object类。

其中String对象一经创建，空间固定不变，无法再向其中增、删数据。即使提供了replace()方法，但也是一个字符对应一个字符的替换。总之它的空间大小不变。

而后两者都是字符串的容器类，属于可变空间的String对象，，因此它们都提供了append()方法、insert()方法以及delete()等修改空间数据的功能。StringBuilder类是StringBuffer类的简版，但效率更高，且它们提供的功能是完全一致的。因此在StringBuilder能满足要求时，建议使用StringBuilder类而非StringBuffer类。

StringBuilder类和StringBuffer类

它们的使用方法完全一致。因此以StringBuilder类为例。

该类用于创建String类，并提供向String数据中插入、删除数据的功能。它最主要的两个方法是append()和insert()。

构建String对象：

StringBuilder sb1 = new StringBuilder();  //对象中包含空字符串
StringBuilder sb2 = new StringBuilder("ac");  //对象中包含字符串ac
System.out.println(sb1);
System.out.println(sb2);

append()方法用于向已有String对象的尾部追加字符串数据，如果数据不是字符串类型，则会使用toString()方法转换为String类型。

StringBuilder sb = new StringBuilder("ac");
sb.append("xx");
sb.append(3);
sb.append(3.12);
System.out.println(sb);  //return value: acxx33.12

insert()方法用于向指定位置处插入数据。

StringBuilder sb = new StringBuilder("ac");
sb.append("xx");     //acxx
sb.append(3);        //acxx3
sb.append(3.12);     //acxx33.12
sb.insert(3,"x");    //acxxx33.12
sb.insert(3,2.12);   //acx2.12xx33.12

还有以下一些String相关的通用方法，其中如果包含start、end位置的方法，一般都不会计算end边界。

• charAt(int n)：返回对象中指定字符位置的字符，位置从0开始计算。
• delete(int start,int end)：删除从位置start到end位置处的子串并返回。不包含end边界。
• deleteCharAt(int n)：删除指定位置处的字符并返回。
• indexOf(String str)：取得从左算起str第一次出现的位置。
• lastIndexOf(String str)：取得从右算起str第一次出现的位置。
• lenght()：返回字符串长度。
• replace(int start,int end,String str)：从start到end位置处(不包含end边界)替换为str。
• reverse()：反转字符串。
• substring(int n)：截取从位置n开始到结尾的子串。
• substring(int start,int end)：截取从位置start到end处(不包含end边界)的子串。
• toString()：重写Object类的toString()方法。将StringBuilder对象转换为String对象。

StringBuilder和StringBuffer的区别

Buffer(为了方便，简写)是同步的，保证多线程安全。线程1 append()后，必须先同步才释放锁，线程2和线程3等才能继续操作(如delete)这段缓冲区中的数据。但也因为要确保数据已经同步，所以效率稍稍差一点。

Builder不保证多线程安全，线程1 append()数据后，线程2可以直接操作(如delete)这段缓存区中的数据。但因为无需确认数据是否同步，因此效率比Buffer要高一些。

它们的关键点在于是否多线程安全，对于单线程来说，它们总是安全的，此时应该采用Builder来提高效率。

String类

几个重要的方法：

• equals(Object obj)和equalsIgnoreCase(Object obj)
  比较两个对象是否相等。String类的equals()方法重写后的比较行为是：仅当两对象的内容相等时，equals()才返回true。

  String a = String.valueOf(123);
  String b = new String("123");
  System.out.println(a.equals(b));  //true
  

• compareTo(String str)和compareToIgnoreCase(String str)
  继承自接口Comparable，重写后的方法按照字典顺序将String对象和str比较，当String对象比str小时返回负数，大时返回正数，相等时返回0。只有当equals()返回true时compareTo()才返回0。

• split(String regexp)：将String按照指定的regexp划分为String[]数组。

  String b = new String("123 xyz 456");
  String[] c = b.split(" ");      //c={"123","xyz","456"}
  

• valueOf(type value)：将给定type类型的数据value转换为String类型并封装到String对象中。

  String a = String.valueOf(123);   //int --> String
  String a = String.valueOf(12.3);  //double --> String
  

还有些其他方法：

• charAt(int n)：返回对象中指定字符位置的字符，位置从0开始计算。
• concat(String str)：将指定字符串str连接到该字符串的尾部。
• contains(String str)：String对象中是否包含str子串，如果为真则返回true，否则返回false。
• contentEquals(String str)：如果该String对象的内容为str，则返回true，否则返回false。
• contentEquals(StringBuffer s)：如果该String对象和StringBuffer对象s的内容相同，则返回true，否则返回false。同样适用于StringBuilder类对象。
• startsWith(String str)：测试String对象是否以str子串为前缀。返回boolean类型。
• endsWith(String str)：测试String对象是否以str子串为结尾的后缀。返回boolean类型。
• indexOf(String str)：取得从左算起str第一次出现的位置。
• lastIndexOf(String str)：取得从右算起str第一次出现的位置。
• lenght()：返回字符串长度。
• isEmpty()：该String对象中是否含有数据。即length返回0时为真。
• matchs(String regexp)：String对象是否能被正则表达式regexp匹配上。
• replace(char o,char n)：将String中的o字符替换为新的n字符。
• substring(int n)：截取从位置n开始到结尾的子串。
• substring(int start,int end)：截取从位置start到end处(不包含end边界)的子串。
• toLowerCase()：返回小写字母。
• toUpperCase()：返回小写字母。
• trim()：返回该String忽略前导和后导空格后的副本。
• toString()：重写Object类的toString()方法。将String对象转换为String对象。其实它自身就是String类型。
• toCharArray()：将String返回为一个char数组。
• getChars(s,e,char[] c,c_s)：将String对象中从s位置开始到e结束(不包含e边界位置)的字符复制到char数组c中的c_s位置处。

  String s = new String("acde");
  char[] sb1 =  s.toCharArray();  //sb1 = {a,c,d,e}
  char[] sb2 = new char[3];
  s.getChars(0,3,sb,0);           //sb2 = {a,c,d}
  

int[]数组转String[]数组

例如，有一个int[]数组，想将该数组转换为String[]。这相当于重写一个"String[] toString(int[] arr)"方法。

import java.util.*;
    //int[]-->String[]
    public static String[] toString(int[] arr) {
        String[] sarr = new String[arr.length];
        for (int i=0;i<arr.length;i++) {
            sarr[i] = Integer.valueOf(arr[i]).toString();
        }
        return sarr;
    }

public class TestToString {
    public static void main(String[] args) {
        int[] arr = {12,3,4,5,66};
        String[] sarr = toString(arr);
        System.out.println(Arrays.toString(sarr));
    }
}

int[]数组转String字符串

例如int[]数组{1,2,3,4}转成字符串，结果为"1 2 3 4"。即将数组中的值变为字符串并使用空格分隔。

public class IntToString {

    // int[] --> String
    public static String toString(int[] arr) {
        StringBuilder sarr = new StringBuilder();
        for (int i=0;i<arr.length;i++) {
            if (i != arr.length - 1) {
                sarr.append(arr[i] + " ");
            } else {
                sarr.append(arr[i]);
            }
        }
        return sarr.toString();
    }

    public static void main(String[] args) {
        int[] arr = {12,3,4,5,66};
        String sarr = toString(arr);
        System.out.println(sarr);
    }
}