1.落笔缘由
字符串在程序中使用得太频繁了，而java.lang.String中包含着许多有用的方法，但是由于平时没详细去看过String的源码，所以有些逻辑String已经提供处理的方法了，而由于对String的生疏，于是又重复造轮子，做了许多无谓的功夫。
总的来说，String常用的方法大概有几类：
（1）将其他基本类型转换为String
（2）将String转换为char数组
（3）将字符串所以英文转为大写字母或小写字母
（4）获取指定的子字符串在字符串中出现的位置（返回的是首位置）
（5）返回该字符串指定位置的字符
（6）根据给定正则表达式的匹配拆分字符串
（7）替换字符
（8）连接字符
（9）比较字符串是否相等（compareTo和equal）
（10）去除字符串首位的空格（trim）
2.实践检验
import android.app.Activity;
import android.os.Bundle;
import android.util.Log;
public class Test1 extends Activity
{
private final static String TAG = "lgy";
private String beseStr = "lgy哈喽";
private int i = 111;
private float f = 222f;
private long l = 333333333;
private double d = 444F;
private short s = 555;
private byte b = 0010;
private char c = 'c';
private boolean bl = true;
@Override
protected void onCreate(Bundle savedInstanceState)
{
super.onCreate(savedInstanceState);
setContentView(R.layout.test1);
// typeToString();
// stringToType();
// stringConcat("_ok");
stringCompareTo("lgy哈喽","lgy哈喽", 0);
stringCompareTo("lgy哈喽","lgy哈", 0);//返回多出的字符个数 3
stringCompareTo("lgy哈","lgy哈喽", 0);//返回少了的字符个数 -3
stringCompareTo("lgd","lgy哈喽", 0);//d 100 y 121
stringCompareTo("lgy哈喽","LGY哈喽", 1);
// stringEndWith("l");
// stringEndWith("喽");
// stringStartWith("l");
// stringToCharArrays(beseStr);
// stringSplit("lgy_123_rtt", "_");
// stringIndexOf("lgy_123_ktv_456","k");
// stringCharAt("abcdefg",5);
}
/**
* Administrator
* 2017-1-16
*TODO 基本类型转String
*/
private void typeToString()
{
//Java中数值常量的默认类型都是int类型的，当进行赋值操作的时候，如果像这个一样，赋值给byte类型的数据，
//这是系统内部会先判断这个数据是否超过byte类型的最大范围（-128~127），如果没有超过则可以正常赋值，超过了会报错
//如果赋的值前面没有0,转String的值对应的是十进制的数值
//如果赋的值前面有0（如b = 0111），转String的值貌似是对不上的,因为这个0111被系统认为是8进制转为10进制就是73
//0100 转String 64
//0001 1
//0010 8
//0110 72
//0111 73
//反正把byte这个基本类型当作10进制，但是值限定在-127~127来使用即可
//总结：
//1.数值前面带0的表示的是这个数值是8进制的
//2.数值前面带0x的标识这个数值是16进制的
Log.i(TAG, "byte:"+String.valueOf(b));
Log.i(TAG, "short:"+String.valueOf(s));
Log.i(TAG, "int:"+String.valueOf(i));
Log.i(TAG, "long:"+String.valueOf(l));
Log.i(TAG, "float:"+String.valueOf(f));
Log.i(TAG, "double:"+String.valueOf(d));
Log.i(TAG, "char:"+String.valueOf(c));
Log.i(TAG, "boolean:"+String.valueOf(bl));
//结果：
// 01-16 11:46:30.427: I/lgy(23893): byte:8
// 01-16 11:46:30.427: I/lgy(23893): short:555
// 01-16 11:46:30.427: I/lgy(23893): int:111
// 01-16 11:46:30.427: I/lgy(23893): long:333333333
// 01-16 11:46:30.427: I/lgy(23893): float:222.0
// 01-16 11:46:30.427: I/lgy(23893): double:444.0
// 01-16 11:46:30.427: I/lgy(23893): char:c
// 01-16 11:46:30.427: I/lgy(23893): boolean:true
}
private void stringToType()
{
Log.i(TAG, "stringToType================================");
//1.string to int
//parseInt(String string, int radix)的radix参数是进制数，这个方法可以将数值字符串转为对应radix进制数的数值的10进制数
//例如Integer.parseInt("100",2)=4，它将字符串“100”当作2进制数，换算成10进制就是4
//Integer.parseInt("100",8)=64
//Integer.parseInt("100",16)=256
//Integer.parseInt("100",4)=16
//反正最后的返回值是10进制数
Log.i(TAG, "int:"+Integer.parseInt("g",17));
//不带radix参数的默认是把string当作10进制数来转换
Log.i(TAG, "int:"+Integer.parseInt("100"));
//除非radix>16,否则无法解析字母(不区分大小写)
//例如Integer.parseInt("a")或Integer.parseInt("a",10)都是会报错的
//因为16进制的10到15是用A到F表示的，所以Integer.parseInt("a",16)=10是能解析的
//但是如果Integer.parseInt("g",16)是会报错的，因为16进制中没有用到g
//然而如果你将radix设置为17，也就是17进制，即Integer.parseInt("g",17)，是能解析的Integer.parseInt("g",17)=16
Log.i(TAG, "int:"+Integer.parseInt("+100"));
//能识别‘-’和‘+’号
//看了源码radix必须大于等于2，小于等于36
//2.string to float
Log.i(TAG, "float:"+Float.parseFloat("100"));
//Float.parseFloat("100")==100.0
//Float无法设置进制，只有parseFloat(String string)这个解析方法
Log.i(TAG, "float:"+Float.parseFloat("100.01"));
//3.string to double
Log.i(TAG, "double:"+Double.parseDouble("100"));
//Double.parseDouble("100")==100.0
//Double无法设置进制，只有parseDouble(String string)这个解析方法
//4.string to char ---no char本来就表示字符，转为字符串有什么意义
//5.string to boolean
Log.i(TAG, "boolean:"+Boolean.parseBoolean("true"));
//Boolean.parseBoolean("true")=true
Log.i(TAG, "boolean:"+Boolean.parseBoolean("trues"));
//Boolean.parseBoolean("trues")=false
Log.i(TAG, "boolean:"+Boolean.parseBoolean("tru"));
//Boolean.parseBoolean("tru")=false
Log.i(TAG, "boolean:"+Boolean.parseBoolean("1"));
//Boolean.parseBoolean("1")=false
//感觉有点sb,我应该去看parseBoolean源码的，代码是return "true".equalsIgnoreCase(s)
//也就是只要字符串不是“true”或“TRUE”,就返回false
//6.string to byte
Log.i(TAG, "byte:"+Byte.parseByte("11"));
//看源码它调用了Integer.parseInt("11",10);它的用法和parseInt一样，只是它的数值限制在-127到127，超出这个范围就报异常
//7.string to short
Log.i(TAG, "short:"+Short.parseShort("11"));
//看源码它调用了Integer.parseInt("11",10);它的用法和parseInt一样，只是它的数值限制在-256到256，超出这个范围就报异常
//8.string to long
Log.i(TAG, "long:"+Long.parseLong("11"));
//它没调用Integer.parseInt，但是用法应该也一样，只是他的数值范围比较大
}
/**
* Administrator
* 2017-1-16
*TODO 连接两个字符串，将指定的str加到beseStr字符串的结尾
* @param str
*/
private void stringConcat(String str)
{
Log.i(TAG, beseStr.concat(str));
}
/**
* Administrator
* 2017-1-16
*TODO 这个函数的作用就是对两个字符串按字典排序的方式进行比较，返回两个字符串中第一个不同的字符的ascII码差值
* 如stringCompareTo("lgd","lgy哈喽", 0);//d 100 y 121 返回的是-21
* 但是stringCompareTo("lg","lgy哈喽", 0);这样子会返回-3，也就是返回少了的字符的个数
*compareTo:If the strings are the same length and every {@code char} is the same, the result is 0
*compareToIgnoreCase:不区分大小写，If the strings are the same length and every {@code char} is the same, the result is 0
* @param string
* @param m
*/
private void stringCompareTo(String str ,String string ,int m)
{
if (m==0)
{
Log.i(TAG, "return value:"+str.compareTo(string));
}else if (m==1)
{
Log.i(TAG, "return value:"+str.compareToIgnoreCase(string));
}
}
/**
* Administrator
* 2017-1-16
*TODO 此字符串是否以指定的后缀结束
*/
private void stringEndWith(String suffix)
{
Log.i(TAG, "return value:"+beseStr.endsWith(suffix));
}
/**
* Administrator
* 2017-1-16
*TODO 测试此字符串是否以指定的前缀开始
* @param prefix
*/
private void stringStartWith(String prefix)
{
Log.i(TAG, "return value:"+beseStr.startsWith(prefix));
}
/**
* Administrator
* 2017-1-16
*TODO 将此字符串转换为一个新的字符数组
* @param string
*/
private void stringToCharArrays(String string)
{
char[] cs = string.toCharArray();
for (int i = 0; i < cs.length; i++)
{
Log.i(TAG, "i:"+cs[i]);
}
}
/**
* Administrator
* 2017-1-16
*TODO 根据给定正则表达式的匹配拆分此字符串
* @param string
*/
private void stringSplit(String beSplitString,String regularExpression)
{
String str[] = beSplitString.split(regularExpression);
for (int i = 0; i < str.length; i++)
{
Log.i(TAG, "i:"+str[i]);
}
}
/**
* Administrator
* 2017-1-16
*TODO 返回指定子字符串在此字符串中第一次出现处的索引(首位置)
* @param beIndexString
* @param string
*/
private void stringIndexOf(String beIndexString,String string)
{
int index = beIndexString.indexOf(string);
Log.i(TAG, "index:"+index);
}
/**
* Administrator
* 2017-1-16
*TODO 返回指定索引处的字符,别忘了，索引从0开始
* @param string
* @param index
*/
private void stringCharAt(String string,int index)
{
Log.i(TAG, "char:"+string.charAt(index));
}
}
3. compareTo的用途
compareTo这个方法确实不常用，但是觉得他挺有意思的，想仔细了解它的用途。在上面例子中也说明了：
这个函数的作用就是对两个字符串按字典排序的方式进行比较，返回两个字符串中第一个不同的字符的ascII码差值
如stringCompareTo("lgd","lgy哈喽", 0);//d 100 y 121 返回的是-21
但是stringCompareTo("lg","lgy哈喽", 0);这样子会返回-3，也就是返回少了的字符的个数
stringCompareTo("lgy哈喽","lg", 0);这样子会返回3，也就是返回多出的字符个数
但是还是不是很清楚compareTo有很用，虽然知道它的作用，但是具体用途还是不清楚，要它何用？还是通过现实例子来展示它的作用：
//使用compareTo 进行姓名的排序
//需要进行排序的字符串
String[] array = new String[] { "lilei", "libai", "james", "poly",
"wobfei" };
//使用简单的循环排序
for (int i = 0; i < array.length - 1; i++) {
for (int j = i + 1; j < array.length; j++) {
if (array[i].compareTo(array[j]) > 0) {
String temp = array[i];
array[i] = array[j];
array[j] = temp;
}
}
}
//结果：
//james libai lilei poly wobfei
4.总结
这里只是列举一下比较常用的，如果想深入了解还是要看源码，可以比较深入的了解这些方法的实现过程和具体的使用限制。
5.源码地址
http://download.csdn.net/detail/lgywsdy/9741104
