java中字符串处理、串联和转换的几个常用方法，以及如果需要自己编程实现的具体实施步骤。

What?

如何分类?

如何使用？

//String 类提供处理 Unicode 代码点（即字符）(TT观点：指的莫非就是对象的意思。)和 Unicode 代码单元（即 char 值）的方法。（TT观点:看来处理这两种Unicode代码点和代码单元是不一样的，分开掌握。）

1、toString()

 object类的toString方法。
1 toString

 public String toString()

          返回该对象的字符串表示。通常，toString 方法会返回一个“以文本方式表示”此对象的字符串。结果应是一个简明但易于读懂的信息表达式。建议所有子类都重写此方法。

          Object 类的 toString 方法返回一个字符串，该字符串由类名（对象是该类的一个实例）、at 标记符“@”和此对象哈希码的无符号十六进制表示组成。换句话说，该方法返回一个字符串，它的值等于： 

          getClass().getName() + '@' + Integer.toHexString(hashCode())

          返回：
                  该对象的字符串表示形式。

Character类中的toString方法如下，

 toString
        public String toString()
        返回表示此 Character 值的 String 对象。
        结果是一个长度为 1 的字符串，其唯一组件是此 Character 对象表示的基本 char 值。 

       覆盖：
          类 Object 中的 toString
       返回：
               此对象的字符串表示形式。

Character类中的另外一个toString方法。

 toString
 public static String toString(char c)
         返回一个表示指定 char 值的 String 对象。结果是长度为 1 的字符串，仅由指定的 char 组成。 

 参数：
      c - 要转换的 char 值
 返回：
      指定 char 值的字符串表示形式
 从以下版本开始：
 1.4 

String类中的toString()

 toString
    public String toString()
             返回此对象本身（它已经是一个字符串！）。 

         指定者：
                 接口 CharSequence 中的 toString
         覆盖：
                  类 Object 中的 toString
         返回：
                  字符串本身。

2、subString()

子字符串。

String类的方法。

 substring
 public String substring(int beginIndex)
              返回一个新的字符串，它是此字符串的一个子字符串。该子字符串从指定索引处的字符开始，直到此字符串末尾。
               示例： 

                                  "unhappy".substring(2) returns "happy"
                                  "Harbison".substring(3) returns "bison"
                                  "emptiness".substring(9) returns "" (an empty string)

   参数：
 beginIndex - 起始索引（包括）。
    返回：
 指定的子字符串。
    抛出：
 IndexOutOfBoundsException - 如果 beginIndex 为负或大于此 String 对象的长度。

 substring
 public String substring(int beginIndex,
                         int endIndex)返回一个新字符串，它是此字符串的一个子字符串。该子字符串从指定的 beginIndex 处开始，直到索引 endIndex - 1 处的字符。因此，该子字符串的长度为 endIndex-beginIndex。
 示例： 

  "hamburger".substring(4, 8) returns "urge"
  "smiles".substring(1, 5) returns "mile"

 参数：
 beginIndex - 起始索引（包括）。
 endIndex - 结束索引（不包括）。
 返回：
 指定的子字符串。
 抛出：
 IndexOutOfBoundsException - 如果 beginIndex 为负，或 endIndex 大于此 String 对象的长度，或 beginIndex 大于 endIndex。

2、（2）split（）方法。

 split
 public String[] split(String regex,
                       int limit)根据匹配给定的正则表达式来拆分此字符串。
 此方法返回的数组包含此字符串的子字符串，每个子字符串都由另一个匹配给定表达式的子字符串终止，或者由此字符串末尾终止。数组中的子字符串按它们在此字符串中出现的顺序排列。如果表达式不匹配输入的任何部分，那么所得数组只具有一个元素，即此字符串。 

 limit 参数控制模式应用的次数，因此影响所得数组的长度。如果该限制 n 大于 0，则模式将被最多应用 n - 1 次，数组的长度将不会大于 n，而且数组的最后一项将包含所有超出最后匹配的定界符的输入。如果 n 为非正，那么模式将被应用尽可能多的次数，而且数组可以是任何长度。如果 n 为 0，那么模式将被应用尽可能多的次数，数组可以是任何长度，并且结尾空字符串将被丢弃。 

 例如，字符串 "boo:and:foo" 使用这些参数可生成以下结果： 

 Regex Limit 结果
 : 2 { "boo", "and:foo" }
 : 5 { "boo", "and", "foo" }
 : -2 { "boo", "and", "foo" }
 o 5 { "b", "", ":and:f", "", "" }
 o -2 { "b", "", ":and:f", "", "" }
 o 0 { "b", "", ":and:f" } 

 调用此方法的 str.split(regex, n) 形式与以下表达式产生的结果完全相同： 

 Pattern.compile(regex).split(str, n) 

 参数：
 regex - 定界正则表达式
 limit - 结果阈值，如上所述
 返回：
 字符串数组，它是根据给定正则表达式的匹配拆分此字符串确定的
 抛出：
 PatternSyntaxException - 如果正则表达式的语法无效
 从以下版本开始：
 1.4
 另请参见：
 Pattern

 split
 public String[] split(String regex)根据给定正则表达式的匹配拆分此字符串。
 该方法的作用就像是使用给定的表达式和限制参数 0 来调用两参数 split 方法。因此，所得数组中不包括结尾空字符串。 

 例如，字符串 "boo:and:foo" 使用这些表达式可生成以下结果： 

 Regex 结果
 : { "boo", "and", "foo" }
 o { "b", "", ":and:f" } 

 参数：
 regex - 定界正则表达式
 返回：
 字符串数组，它是根据给定正则表达式的匹配拆分此字符串确定的
 抛出：
 PatternSyntaxException - 如果正则表达式的语法无效
 从以下版本开始：
 1.4
 另请参见：

2、（3）toLowerCase()

toLowerCase

public String toLowerCase(Locale locale)

使用给定 Locale 的规则将此 String 中的所有字符都转换为小写。大小写映射关系基于 Character 类指定的 Unicode 标准版。由于大小写映射关系并不总是 1:1 的字符映射关系，因此所得 String 的长度可能不同于原 String。

下表中给出了几个小写映射关系的示例：

语言环境的代码	大写字母	小写字母	描述
tr (Turkish)	\u0130	\u0069	大写字母 I，上面有点 -> 小写字母 i
tr (Turkish)	\u0049	\u0131	大写字母 I -> 小写字母 i，无点
(all)	French Fries	french fries	将字符串中的所有字符都小写
(all)			将字符串中的所有字符都小写

参数：

locale - 使用此语言环境的大小写转换规则

返回：

要转换为小写的 String。

从以下版本开始：

1.1

另请参见：

toLowerCase(), toUpperCase(), toUpperCase(Locale)

---

toUpperCase

public String toUpperCase(Locale locale)

使用给定 Locale 的规则将此 String 中的所有字符都转换为大写。大小写映射关系基于 Character 类指定的 Unicode 标准版。由于大小写映射关系并不总是 1:1 的字符映射关系，因此所得 String 的长度可能不同于原 String。

下表中给出了几个与语言环境有关和 1:M 大小写映射关系的一些示例。

语言环境的代码	小写	大写	描述
tr (Turkish)	\u0069	\u0130	小写字母 i -> 大写字母 I，上面有点
tr (Turkish)	\u0131	\u0049	小写字母 i，无点 -> 大写字母 I
(all)	\u00df	\u0053 \u0053	小写字母 sharp s -> 两个字母：SS
(all)	Fahrvergnügen	FAHRVERGNÜN

参数：

locale - 使用此语言环境的大小写转换规则

返回：

要转换为大写的 String。

从以下版本开始：

1.1

另请参见：

toUpperCase(), toLowerCase(), toLowerCase(Locale)

---

toUpperCase

public String toUpperCase()

使用默认语言环境的规则将此 String 中的所有字符都转换为大写。此方法等效于 toUpperCase(Locale.getDefault())。

注： 此方法与语言环境有关，如果用于应独立于语言环境解释的字符串，则可能生成不可预料的结果。示例有编程语言标识符、协议键、HTML 标记。例如，"title".toUpperCase() 在 Turkish（土耳其语）语言环境中返回 "T?TLE"，其中“?”是 LATIN CAPITAL LETTER I WITH DOT ABOVE 字符。对于与语言环境有关的字符，要获得正确的结果，请使用 toUpperCase(Locale.ENGLISH)。

返回：

要转换为大写的 String。

另请参见：

toUpperCase(Locale)

3、append()

（1）append()方法如果对8Bit的byte类型变量进行操作，是从高位到低位一位一位添加的，还是相反的顺序添加的呢？

append

public StringBuffer append(CharSequence s)

将指定的 CharSequence 添加到该序列。

按顺序将 CharSequence 参数中的字符添加到该序列中，使该序列增加该参数的长度。

该方法的结果与调用 this.append(s, 0, s.length()) 完全相同；

该方法在 this（目标）对象上实现同步，但不在源上（s）实现同步。

如果 s 为 null，则添加 4 个 "null" 字符。

指定者：

接口 Appendable 中的 append

参数：

s - 要添加的 CharSequence。

返回：

此对象的一个引用。

从以下版本开始：

1.5 

4、charAt()

 charAt
 public char charAt(int index)返回指定索引处的 char 值。索引范围为从 0 到 length() - 1。序列的第一个 char 值位于索引 0 处，第二个位于索引 1 处，依此类推，这类似于数组索引。
 如果索引指定的 char 值是代理项，则返回代理项值。 

 指定者：
 接口 CharSequence 中的 charAt
 参数：
 index - char 值的索引。
 返回：
 此字符串指定索引处的 char 值。第一个 char 值位于索引 0 处。
 抛出：
 IndexOutOfBoundsException - 如果 index 参数为负或不小于此字符串的长度。

 e.g.1:
           //将数字放到整数数组，逆序，字符串尾部对齐。
         int[] arrStr1=new int[str1.length()-flagStr1];//如果是负数，则字符串的长度需要减去符号位的那一位。
         for(int i=0;i<arrStr1.length;i++){
             arrStr1[i]=str1.charAt(str1.length() - 1 - i) - '0';
         }
         int[] arrStr2=new int[str2.length()-flagStr2];//如果是负数，则字符串的长度需要减去符号位的那一位。
         for(int i=0;i<arrStr2.length;i++){
             arrStr2[i]=str1.charAt(str2.length() - 1 - i) - '0';
         }

5、charValue()

这是Character类的一个方法。不仅String是类，作为主数据类型的char，有对应的类Character。它的实例对象，是基本类型char的值。

Character 类在对象中包装一个基本类型 char 的值。Character 类型的对象包含类型为 char 的单个字段。

 charValue
 public char charValue()
          返回此 Character 对象的值。 

          返回：
          此对象表示的基本 char 值。

 英文版：
 char charValue()
 Converts this value to a CharValue and returns the result as a char. The value will be narrowed or widened as necessary, and magnitude or precision information may be lost (as if the primitive had been cast to a char, in the narrowing case).
 Returns:
 the value, converted to char

6、equals()比较的是什么呢？

Ans：记得比较的是字节组合。（对了一半，但是模棱两可。）

 equals
 public boolean equals(Object obj)
          指示其他某个对象是否与此对象“相等”。
          equals 方法在非空对象引用上实现相等关系： 

             （1）自反性：对于任何非空引用值 x，x.equals(x) 都应返回 true。
             （2）对称性：对于任何非空引用值 x 和 y，当且仅当 y.equals(x) 返回 true      时，x.equals(y) 才应返回 true。
             （3）传递性：对于任何非空引用值 x、y 和 z，如果 x.equals(y) 返回 true，并且 y.equals(z) 返回 true，那么 x.equals(z) 应返回 true。
             （4）一致性：对于任何非空引用值 x 和 y，多次调用 x.equals(y) 始终返回 true 或始终返回 false，前提是对象上 equals 比较中所用的信息没有被修改。
 对于任何非空引用值 x，x.equals(null) 都应返回 false。 

 Object 类的 equals 方法实现对象上差别可能性最大的相等关系；即，对于任何非空引用值 x 和 y，当且仅当 x 和 y 引用同一个对象时，此方法才返回 true（x == y 具有值 true）。 

 注意：当此方法被重写时，通常有必要重写 hashCode 方法，以维护 hashCode 方法的常规协定，该协定声明相等对象必须具有相等的哈希码。 

 参数：
 obj - 要与之比较的引用对象。
 返回：
 如果此对象与 obj 参数相同，则返回 true；否则返回 false。
 另请参见：
 hashCode(), Hashtable

 //String类中的equals:

 equals
 public boolean equals(Object anObject)将此字符串与指定的对象比较。当且仅当该参数不为 null，并且是与此对象表示相同字符序列的 String 对象时，结果才为 true。 
(TT观点：还是下面总结的，equals()比较的是判断两个对象是否在意义上相等。即，比较两个String对象是否带有相同的字节组合。也就是两个对象，相当于两个引用，是不是指向同一个对象。TT观：看来也是看是不是具有相同的字节组合。）)

 覆盖：
 类 Object 中的 equals
 参数：
 anObject - 与此 String 进行比较的对象。
 返回：
 如果给定对象表示的 String 与此 String 相等，则返回 true；否则返回 false。
 另请参见：
 compareTo(String), equalsIgnoreCase(String)

equals()和“==”的区别与联系：

“==”的两个用法：

（1）使用==来比较两个primitive 主数据类型，

（2）或者判断两个引用是否引用同一个对象，即是否指向同一个对象。

（3）==只能来比较两个变量的字节组合。

（4）使用equals()，这个方法是object类的，使用这个方法可以来判断两个对象是否在意义上相等。（像是两个String对象是否带有相同的字节组合。TT观：看来也是看是不是具有相同的字节组合。）

e.g.1:

 int a=3;
 byte b=3;
 if(a==b){//true}

虽然int类型和byte类型的变量空间大小是不一样的，但是，==只比较两个变量的字节组合，只要字节组合相等，就判断为真，不管int变量的长度那么长了。

e.g.2:

 Foo a=new Foo();

 Foo b=new Foo();

 Foo c=a;

 if(a==b)   {//false}
 if(a==c)   {//true}
 if(b==c)   {//false}

 //要记得，只是在比较字节组合的模样。此规则适用与primitive主数据类型。因此==运算符对参照相同对象的引用变量会返回true值。在此情况下，我们还是无法得知字节组合的样式，但可以确定的是所参照的相同的对象。

7、contentEquals()

 contentEquals
 public boolean contentEquals(StringBuffer sb)将此字符串与指定的 StringBuffer 比较。当且仅当此 String 与指定 StringBuffer 表示相同的字符序列时，结果才为 true。 也就是说String和StringBuffer指向同一个对象喽？？是这个意思吗？

 参数：
 sb - 要与此 String 比较的 StringBuffer。
 返回：
 如果此 String 与指定 StringBuffer 表示相同的字符序列，(就是字节组合。)则返回 true；否则返回 false。
 从以下版本开始：
 1.4 

8、compareTo

 compareTo
 public int compareTo(String anotherString)
   按字典顺序比较两个字符串。
   该比较基于字符串中各个字符的 Unicode 值。按字典顺序将此 String 对象表示的字符序列与参数字符串所表示的字符序列进行比较。如果按字典顺序此 String 对象位于参数字符串之前，则比较结果为一个负整数。如果按字典顺序此 String 对象位于参数字符串之后，则比较结果为一个正整数。如果这两个字符串相等，则结果为 0；compareTo 只在方法 equals(Object) 返回 true 时才返回 0。
 这是字典排序的定义。如果这两个字符串不同，那么它们要么在某个索引处的字符不同（该索引对二者均为有效索引），要么长度不同，或者同时具备这两种情况。如果它们在一个或多个索引位置上的字符不同，假设 k 是这类索引的最小值；则在位置 k 上具有较小值的那个字符串（使用 < 运算符确定），其字典顺序在其他字符串之前。在这种情况下，compareTo 返回这两个字符串在位置 k 处两个char 值的差，即值： 

  this.charAt(k)-anotherString.charAt(k)
  如果没有字符不同的索引位置，则较短字符串的字典顺序在较长字符串之前。在这种情况下，compareTo 返回这两个字符串长度的差，即值：
  this.length()-anotherString.length()

 指定者：
 接口 Comparable<String> 中的 compareTo
 参数：
 anotherString - 要比较的 String。
 返回：
 如果参数字符串等于此字符串，则返回值 0；如果此字符串按字典顺序小于字符串参数，则返回一个小于 0 的值；如果此字符串按字典顺序大于字符串参数，则返回一个大于 0 的值。