java.lang.String--String常用方法介绍

1、length方法获取字符串的长度

public int length() {
        return value.length;
    }

得到一个字符串的字符个数（中、英、空格、转义字符皆为字符，计入长度），具体例子如下所示

package string;

public class MethodTest {

	public static void main(String[] args) {
		String a="中移fwyxgs \t\n";
		lengThMethod(a);//11
		lengThMethod("中移");//2
		lengThMethod("fwyxgs");//6
		lengThMethod("中移fwyxgs ");//9
		lengThMethod("\t");//1
		lengThMethod("\3");//1

	}
	
	public static void lengThMethod(String s){
	        int l = s.length();
	        System.out.println(l);
		
	}

}

2、charAt方法从字符串中取出指定位置的字符 

 public char charAt(int index) {
        if ((index < 0) || (index >= value.length)) {
            throw new StringIndexOutOfBoundsException(index);
        }
        return value[index];
    }

An index ranges from 0 to length() - 1

index形参取值范围为0-（length() - 1），不在这个范围内会抛出StringIndexOutOfBoundsException异常

package string;

public class MethodTest {

	public static void main(String[] args) {
		String a="中移fwyxgs \t\n";
		charAt(a,0);//中
		charAt(a,1);//移
		charAt(a,8);//空格
		charAt(a,9);//缩进，控制台打印的是个缩进，不能明显看出来
		charAt(a,10);//
		charAt(a,11);//StringIndexOutOfBoundsException

	}
	public static void charAt(String s,int i){
        System.out.println(s.charAt(i));
	
}

}

3、toCharArray将字符串转成字符数组并返回

public char[] toCharArray() {
        // Cannot use Arrays.copyOf because of class initialization order issues
        char result[] = new char[value.length];
        System.arraycopy(value, 0, result, 0, value.length);
        return result;
    }

Converts this string to a new character array.

很明显返回的字符数组是一个新的数组对象。

package string;

public class MethodTest {

	public static void main(String[] args) {
		String a="中移fwyxgs \t\n";
		toCharArray(a);
	}
	
	public static void toCharArray(String s){
		char ca[]=s.toCharArray();
		for (int i = 0; i < ca.length; i++){
			System.out.println("输出:" + ca[i]);
		}
	
     }
}

输出内容如下所示： 

 4、indexOf方法

返回的是形参字符串的第一次出现的位置索引，如果不存在，则返回-1 。

从运行结果来看如果形参是字符串，如果完全匹配，返回的索引是形参字符串第一个字符的位置

public int indexOf(String str) {
        return indexOf(str, 0);
    }

package string;

public class MethodTest2 {

	public static void main(String[] args) {
		indexOf("fawyx");//2
		indexOf("f");//2
		indexOf("移");//1
		indexOf("fb");//-1
		lastIndexOf("f");//7
		lastIndexOf("fa");//7
		lastIndexOf("移");//1
		lastIndexOf("fb");//-1
		
	}
	
	public static void indexOf(String s){
		    String a="中移fawyxfags \t\n";
	        int l = a.indexOf(s);
	        System.out.println(l);
		
	}
	public static void lastIndexOf(String s){
	    String a="中移fawyxfags \t\n";
        int l = a.lastIndexOf(s);
        System.out.println(l);
	
}
}

5、lastIndexOf方法

返回的是形参字符串的最后一次出现的位置索引，如果不存在，则返回-1 。

6、toUpperCase方法--------字符串转大写；toLowerCase方法---------字符串转小写

 public String toLowerCase() {
        return toLowerCase(Locale.getDefault());
    }

7、split方法

根据给定的正则表达式的匹配来拆分此字符串。形成一个String数组，并返回。

public String[] split(String regex) {
        return split(regex, 0);
    } 

对于特殊字符的分隔|  ^   $  *   .    (    )   \   /等都是正则表达式的一部分，只能通过前面加上\\进行转义。注意\要用三个\\\，也就是split（“\\\\”）;

因为形参是正则表达式，故可以使用正则表达式来拆分字条串，比如[23]表示用2，3这两个字符分隔。

其他例子如下所示

按空格分开

public static void main(String[] args) {
        String a = "hello world wk";
        String[] a1 = a.split(" ");
        System.out.println("a1-->"+Arrays.toString(a1));
    }
结果是：a1-->[hello, world, wk]
按|分开

        String a1="北京|北京市|海淀区|科技大厦";
        String[] splitAddress=a1.split("\\|");
        System.out.println(Arrays.toString(splitAddress));
结果是：[北京, 北京市, 海淀区, 科技大厦]
按*分开

        String a1="北京*北京市*海淀区*科技大厦";
        String[] splitAddress=a1.split("\\*");
        System.out.println(Arrays.toString(splitAddress));
结果是：[北京, 北京市, 海淀区, 科技大厦]
按@隔开

        String a1="北京@北京市@海淀区@科技大厦";
        String[] splitAddress=a1.split("@");
        System.out.println(Arrays.toString(splitAddress));
结果是：[北京, 北京市, 海淀区, 科技大厦]
多个标记隔开

        String a1="北京^北京市@海淀区#科技大厦 wk";
        String[] splitAddress=a1.split("\\^|@|#| ");
        System.out.println(Arrays.toString(splitAddress));
结果是：[北京, 北京市, 海淀区, 科技大厦, wk]
限制返回数组长度隔开

        String a1="北京 北京市 海淀区 科技大厦 wk";
        String[] str=a1.split(" ",3);
        System.out.println(Arrays.toString(str));
结果是：[北京, 北京市, 海淀区 科技大厦 wk]

package string;

public class MethodTest2 {

	public static void main(String[] args) {
		splitTest("f");
		splitTest("\\|");
		splitTest("[as]");
		
	}
	
	public static void splitTest(String s){
	    String a="中移|fawyx|fags figxmi";
        String[] l = a.split(s);
        for(int i=0;i<l.length;i++){
        	System.out.println(l[i]);
        }
     }
}

输出结果为 

 8、equals方法

比较两个字符串是否相同，如果地址相同则返回true,如果内容相同，也返回 true,其他返回false，源码如下所示

public boolean equals(Object anObject) {
        if (this == anObject) {
            return true;
        }
        if (anObject instanceof String) {
            String anotherString = (String)anObject;
            int n = value.length;
            if (n == anotherString.value.length) {
                char v1[] = value;
                char v2[] = anotherString.value;
                int i = 0;
                while (n-- != 0) {
                    if (v1[i] != v2[i])
                        return false;
                    i++;
                }
                return true;
            }
        }
        return false;
    }

equalsIgnoreCase方法忽略大小写的比较两个字符串的内容是否一模一样。

9、trim方法

去掉字符串的左边和右边空格，中间的去不了，源码如下所示。

public String trim() {
        int len = value.length;
        int st = 0;
        char[] val = value;    /* avoid getfield opcode */

        while ((st < len) && (val[st] <= ' ')) {
            st++;
        }
        while ((st < len) && (val[len - 1] <= ' ')) {
            len--;
        }
        return ((st > 0) || (len < value.length)) ? substring(st, len) : this;
    }

10、contains方法

返回某字符串是否包含输入（形参中）的字符串的boolean结果，包含返回true，否则返回false

public boolean contains(CharSequence s) {
        return indexOf(s.toString()) > -1;
    }

11、startsWith方法

返回字符串是否以指定的前缀开始，是返回 true否则返回false

endsWith方法返回字符串是否以指定的后缀结尾，是返回 true否则返回false

public boolean endsWith(String suffix) {
        return startsWith(suffix, value.length - suffix.value.length);
    }

12、replace方法

replace方法替换所有的给出来的字符（target）为指定字符（replacement）

public String replace(CharSequence target, CharSequence replacement) {
        return Pattern.compile(target.toString(), Pattern.LITERAL).matcher(
                this).replaceAll(Matcher.quoteReplacement(replacement.toString()));
    }

replaceFirst将字符串中某个第一次匹配到的内容（regex正则匹配的内容）替换成指定的内容（replacement）

public String replaceFirst(String regex, String replacement) {
        return Pattern.compile(regex).matcher(this).replaceFirst(replacement);
    }

replaceAll将字符串中所有的某个内容（regex正则匹配的内容）替换成指定的内容（replacement）

public String replaceAll(String regex, String replacement) {
        return Pattern.compile(regex).matcher(this).replaceAll(replacement);
    }

三者的区别

replaceAll()和replace都是全部替换,即把源字符串中的某一字符或字符串全部换成指定的字符或字符串。

如果只想替换第一次出现的,可以使用replaceFirst(),这个方法也是基于规则表达式的替换,但与replaceAll()不同的是,只替换第一次出现的字符串;

replaceAll()和replaceFirst()所用的参数据如果不是基于规则表达式的,则与replace()替换字符串的效果是一样的,即这两者也支持字符串的操作。

replaceAll()和replaceFirst()所用的参数也可以使用正则表达式来匹配字符串。

13、substring方法用于提取子串

用String类的substring方法可以提取字符串中的子串，该方法有两种常用参数:
1)public String substring(int beginIndex)

该方法从beginIndex位置起，从当前字符串中取出剩余的字符作为一个新的字符串返回。

2)public String substring(int beginIndex, int endIndex)

该方法从beginIndex位置起，从当前字符串中取出到endIndex-1位置的字符作为一个新的字符串返回。

14、concat方法字符串连接

public String concat(String str)//将参数中的字符串str连接到当前字符串的后面，效果等价于"+"。
String str = "aa".concat("bb").concat("cc"); 相当于String str = "aa"+"bb"+"cc";

源码如下所示

public String concat(String str) {
        int otherLen = str.length();
        if (otherLen == 0) {
            return this;
        }
        int len = value.length;
        char buf[] = Arrays.copyOf(value, len + otherLen);
        str.getChars(buf, len);
        return new String(buf, true);
    }
 

参考

JAVA中替换字符的方法replace和replaceAll 区别

java 中String类的常用方法总结，带你玩转String类。