[JAVA][String常用方法]

0.397字数 443阅读 89

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

6.参考文章

http://wobfei.iteye.com/blog/743123

推荐阅读更多精彩内容