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

//String

char

object类的toString方法。
1 toString

public String toString()

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

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

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

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

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

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

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

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

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

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

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。

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
另请参见：

toLowerCase

public String toLowerCase(Locale locale)

Locale

String

Character

String

String

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

locale

String

toLowerCase()

toUpperCase()

toUpperCase(Locale)

toUpperCase

public String toUpperCase(Locale locale)

Locale

String

Character

String

String

locale

String

toUpperCase()

toLowerCase()

toLowerCase(Locale)

toUpperCase

public String toUpperCase()

String

toUpperCase(Locale.getDefault())

"title".toUpperCase()

"T?TLE"

toUpperCase(Locale.ENGLISH)

String

toUpperCase(Locale)

append

public StringBuffer append(CharSequence s)

CharSequence

CharSequence

s

s

null

"null"

Appendable

append

s

CharSequence

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';
}

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

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)

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

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值。在此情况下，我们还是无法得知字节组合的样式，但可以确定的是所参照的相同的对象。

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

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

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 的值。