1.String 字符串
字符串广泛应用 在Java 编程中，在 Java 中字符串属于对象，Java 提供了 String 类来创建和操作字符串。
创建字符串：
public class StringDemo{
public static void main(String args[]){
String str = "我是字符串"; //最简单的创建字符串
char[] helloArray = { 'h', 'e', 'l', 'l', 'o', 'w'};
String helloString = new String(helloArray);
System.out.println( helloString ); //hello
}
}
1.1 length() 字符串长度
用于获取有关对象的信息的方法称为访问器方法。String 类的一个访问器方法是 length() 方法，它返回字符串对象包含的字符数。
public class StringDemo{
public static void main(String args[]){
String str = "我是字符串"; //最简单的创建字符串
System.out.println( helloString.length() ); //5
}
}
1.2 concat() 连接字符串
string1.concat(string2);
返回 string1 连接 string2 的新字符串。也可以对字符串常量使用 concat() 方法，如：
String str = "我是字符串".concat("哈哈哈哈"); //str为：我是字符串哈哈哈哈
但更常用的是使用'+'操作符来连接字符串，如：
String str = "我是字符串" + "哈哈哈哈"; //str为：我是字符串哈哈哈哈
1.3 format() 创建格式化字符串
我们知道输出格式化数字可以使用 printf() 和 format() 方法。String 类使用静态方法 format() 返回一个String 对象而不是 PrintStream 对象。String 类的静态方法 format() 能用来创建可复用的格式化字符串，而不仅仅是用于一次打印输出。
System.out.printf("浮点型变量的值为 " +
" %f, 整型变量的值为 " +
" %d, 字符串变量的值为 " +
" %s", floatVar, intVar, stringVar);
String fs;
fs = String.format("浮点型变量的值为 " +
" %f, 整型变量的值为 " +
" %d, 字符串变量的值为 " +
" %s", floatVar, intVar, stringVar);
2.StringBuffer 和 StringBuilder 类
当对字符串进行修改的时候，需要使用 StringBuffer 和 StringBuilder 类。
和 String 类不同的是，StringBuffer 和 StringBuilder 类的对象能够被多次的修改，并且不产生新的未使用对象。
StringBuilder 类在 Java 5 中被提出，它和 StringBuffer 之间的最大不同在于 StringBuilder 的方法不是线程安全的（不能同步访问）。
由于 StringBuilder 相较于 StringBuffer 有速度优势，所以多数情况下建议使用 StringBuilder 类。然而在应用程序要求线程安全的情况下，则必须使用 StringBuffer 类。
public class Test{
public static void main(String args[]){
StringBuffer sBuffer = new StringBuffer("百度：");
sBuffer.append("www");
sBuffer.append(".baidu");
sBuffer.append(".com");
System.out.println(sBuffer); //百度：www.baidu.com
}
}
2.1 StringBuffer 类支持的主要方法
public StringBuffer append(String s)
将指定的字符串追加到此字符序列。
public StringBuffer reverse()
将此字符序列用其反转形式取代。
public delete(int start, int end)
移除此序列的子字符串中的字符。
public insert(int offset, int i)
将 int 参数的字符串表示形式插入此序列中。
replace(int start, int end, String str)
使用给定 String 中的字符替换此序列的子字符串中的字符。
3.String方法
3.1 charAt()
charAt()方法用于返回指定索引处的字符。索引范围为从 0 到 length() - 1
public class Test {
public static void main(String args[]) {
String s = "http:www.baidu.com";
System.out.println(s.charAt(5)); //w
}
}
3.2 compareTo() 和 compareToIgnoreCase()
compareTo()方法用于比较两个字符串:str1.compareTo(str2)
compareToIgnoreCase()和compareTo()一样，只是在比较时不考虑字母大小写
返回值是整型,它是先比较对应字符的大小(ASCII码顺序),如果第一个字符和参数的第一个字符不等,结束比较,返回他们之间的差值,如果第一个字符和参数的第一个字符相等,则以第二个字符和参数的第二个字符做比较,以此类推,直到字符出现不同就计算这两个不同字符的ASCII码的差，作为返回值，若到最后某一个字符串结束了,此时返回的是两个字符串的长度差。
如果str1与str2相等，返回0
如果str1大于str2，返回一个大于0的整数
如果str1小于str2，返回一个小于0的整数
public class Test {
public static void main(String args[]) {
String str1 = "Strings";
String str2 = "Strings";
String str3 = "Strings123";
System.out.println(str1.compareTo( str2 )); //0
System.out.println(str2.compareTo( str3 )); //-3
System.out.println(str3.compareTo( str1 )); //3
String str4 = "abcde";
String str5 = "abdde";
System.out.println(str5.compareTo( str4 )) //-1 此时返回的才是ASCII差值
}
}
3.3 contentEquals()
contentEquals()方法用于将此字符串与指定的 StringBuffer 比较。如字符串与指定 StringBuffer 表示相同的字符序列，则返回 true；否则返回 false。
public class Test {
public static void main(String args[]) {
String str1 = "String1";
String str2 = "String2";
StringBuffer str3 = new StringBuffer( "String1");
System.out.println(str1.contentEquals( str3 ));//true
System.out.println(str2.contentEquals( str3 ));//false
}
}
3.4 equals() 和 equalsIgnoreCase()
equals()方法用于将字符串与指定的对象比较。如果给定对象与字符串相等，则返回 true；否则返回 false。
equalsIgnoreCase() 与 equals() 作用一样，只是比较时忽略大小写
public class Test {
public static void main(String args[]) {
String Str1 = new String("hello");
String Str2 = Str1;
String Str3 = new String("hello");
System.out.println(Str1.equals( Str2 )); //true
System.out.println(Str1.equals( Str3 )); //true
}
}
3.5 copyValueOf()
copyValueOf()方法有两种形式：
public static String copyValueOf(char[] data): 返回指定数组中表示该字符序列的字符串。
public static String copyValueOf(char[] data, int offset, int count): 返回指定数组中表示该字符序列的 字符串。
public class Test {
public static void main(String args[]) {
char[] Str1 = {'h', 'e', 'l', 'l', 'o', ' ', 'r', 'u', 'n', 'o', 'o', 'b'};
System.out.println(String.copyValueOf( Str1 ));//hello runoob
System.out.println(String.copyValueOf( Str1, 2, 6 ));//llo ru
}
}
3.6 startsWith() 和 endsWith()
startsWith()用于检测字符串是否以指定的前缀开始。
endsWith()用于测试字符串是否以指定的后缀结束。如果参数表示的字符序列是此对象表示的字符序列的后缀，则返回 true；否则返回 false。注意，如果参数是空字符串，或者等于此 String 对象（用 equals(Object) 方法确定），则结果为 true。
public class Test {
public static void main(String args[]) {
String Str = new String("https://www.baidu.com");
System.out.println(Str.startsWith( "https" )); //true
System.out.println(Str.startsWith( "www" )); //false
System.out.println(Str.startsWith( "www",8 )); //true
System.out.println(Str.endsWith( "baidu" )); //false
System.out.println(Str.endsWith( "com" ));//true
}
}
3.7 getBytes()
getBytes()方法有两种形式：
getBytes(String charsetName): 使用指定的字符集将字符串编码为 byte 序列，并将结果存储到一个新的 byte 数组中。
getBytes(): 使用平台的默认字符集将字符串编码为 byte 序列，并将结果存储到一个新的 byte 数组中。
import java.io.*;
public class Test {
public static void main(String args[]) {
String Str1 = new String("runoob");
try{
byte[] Str2 = Str1.getBytes();
System.out.println( Str2 );//[B@7852e922
Str2 = Str1.getBytes( "UTF-8" );
System.out.println(Str2 );//[B@4e25154f
Str2 = Str1.getBytes( "ISO-8859-1" );
System.out.println(Str2 );//
} catch ( UnsupportedEncodingException e){
System.out.println("不支持的字符集");//[B@70dea4e
}
}
}
3.8 getChars()
getChars()方法将字符从字符串复制到目标字符数组。
public void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)
srcBegin:字符串中要复制的第一个字符的索引。
srcEnd:字符串中要复制的最后一个字符之后的索引。
dst:目标数组。
dstBegin:目标数组中的起始偏移量。
没有返回值，但会抛出 IndexOutOfBoundsException 异常。
public class Test {
public static void main(String args[]) {
String Str1 = new String("www.baidu.com");
char[] Str2 = new char[5];
try {
Str1.getChars(4, 9, Str2, 0);
System.out.println(Str2 ); //baidu
} catch( Exception ex) {
System.out.println("触发异常...");
}
}
}
3.9 hashCode()
hashCode()方法用于返回字符串的哈希码。
字符串对象的哈希码根据以下公式计算：s[0]31^(n-1) + s[1]31^(n-2) + ... + s[n-1](使用 int 算法，这里 s[i] 是字符串的第 i 个字符，n 是字符串的长度，^ 表示求幂。空字符串的哈希值为 0。)
public class Test {
public static void main(String args[]) {
String Str = new String("www.runoob.com");
System.out.println( Str.hashCode() );//321005537
}
}
3.10 indexOf()
indexOf()方法有以下四种形式：
public int indexOf(int ch): 返回指定字符在字符串中第一次出现处的索引，如果此字符串中没有这样的字符，则返回 -1。
public int indexOf(int ch, int fromIndex): 返回从 fromIndex 位置开始查找指定字符在字符串中第一次出现处的索引，如果此字符串中没有这样的字符，则返回 -1。
int indexOf(String str): 返回指定字符在字符串中第一次出现处的索引，如果此字符串中没有这样的字符，则返回 -1。
int indexOf(String str, int fromIndex): 返回从 fromIndex 位置开始查找指定字符在字符串中第一次出现处的索引，如果此字符串中没有这样的字符，则返回 -1。
public class Main {
public static void main(String args[]) {
String string = "aaa456ac";
//查找指定字符是在字符串中的下标。在则返回所在字符串下标；不在则返回-1.
System.out.println(string.indexOf("b")); // indexOf(String str); 返回结果：-1，"b"不存在
// 从第四个字符位置开始往后继续查找，包含当前位置
System.out.println(string.indexOf("a",3));//indexOf(String str, int fromIndex); 返回结果：6
//（与之前的差别：上面的参数是 String 类型，下面的参数是 int 类型）参考数据：a-97,b-98,c-99
// 从头开始查找是否存在指定的字符
System.out.println(string.indexOf(99));//indexOf(int ch)；返回结果：7
System.out.println(string.indexOf('c'));//indexOf(int ch)；返回结果：7
//从fromIndex查找ch，这个是字符型变量，不是字符串。字符a对应的数字就是97。
System.out.println(string.indexOf(97,3));//indexOf(int ch, int fromIndex); 返回结果：6
System.out.println(string.indexOf('a',3));//indexOf(int ch, int fromIndex); 返回结果：6
}
}
3.11 lastIndexOf()
lastIndexOf()方法有以下四种形式：
public int lastIndexOf(int ch): 返回指定字符在此字符串中最后一次出现处的索引，如果此字符串中没有这样的字符，则返回 -1。
public int lastIndexOf(int ch, int fromIndex): 返回指定字符在此字符串中最后一次出现处的索引，如果此字符串中没有这样的字符，则返回 -1。
public int lastIndexOf(String str): 返回指定字符在此字符串中最后一次出现处的索引，如果此字符串中没有这样的字符，则返回 -1。
public int lastIndexOf(String str, int fromIndex): 返回指定字符在此字符串中最后一次出现处的索引，如果此字符串中没有这样的字符，则返回 -1。
public class Test {
public static void main(String args[]) {
String Str = new String("www.baidu.com");
String SubStr1 = new String("baidu");
String SubStr2 = new String("com");
System.out.print("查找字符 o 最后出现的位置 :" );
System.out.println(Str.lastIndexOf( 'o' ));
System.out.print("从第10个位置查找字符 o 最后出现的位置 :" );
System.out.println(Str.lastIndexOf( 'o', 10 ));
System.out.print("子字符串 SubStr1 最后出现的位置:" );
System.out.println( Str.lastIndexOf( SubStr1 ));
System.out.print("从5个位置开始搜索子字符串 SubStr1最后出现的位置 :" );
System.out.println( Str.lastIndexOf( SubStr1, 5 ));
System.out.print("子字符串 SubStr2 最后出现的位置 :" );
System.out.println(Str.lastIndexOf( SubStr2 ));
}
}
3.12 intern()
intern()方法返回字符串对象的规范化表示形式。
它遵循以下规则：对于任意两个字符串 s 和 t，当且仅当 s.equals(t) 为 true 时，s.intern() == t.intern() 才为 true。
public class Test {
public static void main(String args[]) {
String Str1 = new String("www.baidu.com");
String Str2 = new String("WWW.BAIDU.COM");
System.out.println(Str1.intern()); //www.baidu.com
System.out.println(Str2.intern()); //WWW.BAIDU.COM
}
}
尽管在输出中调用intern方法并没有什么效果，但是实际上后台这个方法会做一系列的动作和操作。在调用"ab".intern()方法的时候会返回"ab"，但是这个方法会首先检查字符串池中是否有"ab"这个字符串，如果存在则返回这个字符串的引用，否则就将这个字符串添加到字符串池中，然会返回这个字符串的引用。
可以看下面一个范例：
String str1 = "a";
String str2 = "b";
String str3 = "ab";
String str4 = str1 + str2;
String str5 = new String("ab");
System.out.println(str5.equals(str3));
System.out.println(str5 == str3);
System.out.println(str5.intern() == str3);
System.out.println(str5.intern() == str4);
得到的结果:
true
false
true
false
第一、str5.equals(str3)这个结果为true，不用太多的解释，因为字符串的值的内容相同。
第二、str5 == str3对比的是引用的地址是否相同，由于str5采用new String方式定义的，所以地址引用一定不相等。所以结果为false。
第三、当str5调用intern的时候，会检查字符串池中是否含有该字符串。由于之前定义的str3已经进入字符串池中，所以会得到相同的引用。
第四，当str4 = str1 + str2后，str4的值也为”ab”，但是为什么这个结果会是false呢？先看下面代码：
String a = new String("ab");
String b = new String("ab");
String c = "ab";
String d = "a" + "b";
String e = "b";
String f = "a" + e;
System.out.println(b.intern() == a);
System.out.println(b.intern() == c);
System.out.println(b.intern() == d);
System.out.println(b.intern() == f);
System.out.println(b.intern() == a.intern());
运行结果：
false
true
true
false
true
由运行结果可以看出来，b.intern() == a和b.intern() == c可知，采用new 创建的字符串对象不进入字符串池，并且通过b.intern() == d和b.intern() == f可知，字符串相加的时候，都是静态字符串的结果会添加到字符串池，如果其中含有变量（如f中的e）则不会进入字符串池中。但是字符串一旦进入字符串池中，就会先查找池中有无此对象。如果有此对象，则让对象引用指向此对象。如果无此对象，则先创建此对象，再让对象引用指向此对象。
当研究到这个地方的时候，突然想起来经常遇到的一个比较经典的Java问题，就是对比equal和 == 的区别，当时记得老师只是说“==”判断的是“地址”，但是并没说清楚什么时候会有地址相等的情况。现在看来，在定义变量的时候赋值，如果赋值的是静态的字符串，就会执行进入字符串池的操作，如果池中含有该字符串，则返回引用。
3.13 length()
length() 方法用于返回字符串的长度。
public class Test {
public static void main(String args[]) {
String Str1 = new String("www.baidu.com");
String Str2 = new String("baidu" );
System.out.println(Str1.length()); //13
System.out.println(Str2.length()); //5
}
}
3.14 matches()
matches()方法用于检测字符串是否匹配给定的正则表达式
public class Test {
public static void main(String args[]) {
String str = new String("www.baidu.com");
System.out.println(str.matches("(.*)baidu(.*)")); //true
System.out.println(str.matches("(.*)google(.*)")); //false
System.out.println(str.matches("www(.*)")); //true
}
}
3.15 regionMatches()
regionMatches()方法用于检测两个字符串在一个区域内是否相等.语法:
public boolean regionMatches(int toffset,
String other,
int ooffset,
int len)
或
public boolean regionMatches(boolean ignoreCase,
int toffset,
String other,
int ooffset,
int len)
参数说明:
ignoreCase -- 如果为 true，则比较字符时忽略大小写。
toffset -- 此字符串中子区域的起始偏移量。
other -- 字符串参数。
ooffset -- 字符串参数中子区域的起始偏移量。
len -- 要比较的字符数。
public class Test {
public static void main(String args[]) {
String Str1 = new String("www.baidu.com");
String Str2 = new String("baidu");
String Str3 = new String("BAIDU");
System.out.println(Str1.regionMatches(4, Str2, 0, 5)); //true
System.out.println(Str1.regionMatches(4, Str3, 0, 5)); //false
System.out.println(Str1.regionMatches(true, 4, Str3, 0, 5));//true
}
}
3.16 replace()
replace()通过用 newChar 字符替换字符串中出现的所有 oldChar 字符，并返回替换后的新字符串
public String replace(char oldChar, char newChar)
public class Test {
public static void main(String args[]) {
String Str = new String("hello");
System.out.println(Str.replace('o', 'l')); //helll
System.out.println(Str.replace('l', 'L')); //heLLo
}
}
3.17 replaceAll() 和 replaceFirst()
replaceAll()方法使用给定的参数 replacement 替换字符串所有匹配给定的正则表达式的子字符串。替换后生成的新字符串。
replaceFirst()方法使用给定的参数 replacement 替换字符串第一个匹配给定的正则表达式的子字符串。成功则返回替换的字符串，失败则返回原始字符串。
public String replaceAll(String regex, String replacement)
public String replaceFirst(String regex,String replacement)
public class Test {
public static void main(String args[]) {
String str1 = new String("www.baidu.com");
System.out.println(str1.replaceAll("(.*)baidu(.*)", "google" ));//google
System.out.println(str1.replaceAll("(.*)taobao(.*)", "google" ));//www.baidu.com
String str2 = new String("hello baidu，I am from baidu。");
System.out.println(str2.replaceFirst("baidu", "google" )); //hello google，I am from baidu
System.out.println(str2.replaceFirst("(.*)baidu(.*)", "google" )); //google
}
}
3.18 split()
split()根据匹配给定的正则表达式来拆分字符串。
注意：
. 、 | 和 * 等转义字符，必须加 \\
多个分隔符，可以用 | 作为连字符
public String[] split(String regex, int limit) //返回字符串数组
regex：正则表达式分隔符。
limit：分割的份数。
public class Test {
public static void main(String args[]) {
String str = new String("nice-to-meet-you");
String retval1 = str.split("-"); //["nice","to","meet","you"]
String retval12 = str.split("-",2); //["nice","to-meet-you"]
String str2 = new String("www.baidu.com");
String retval3 = str2.split("\\.", 3) //["www","baidu","com"]
String str3 = new String("acount=? and uu =? or n=?");
String retval4 = str3.split("and|or") //["acount=? "," uu =? "," n=?"]
}
}
3.19 subSequence() 和 substring()
subSequence()返回一个新的字符序列，它是此序列的一个子序列
substring()返回字符串的子字符串。
public CharSequence subSequence(int beginIndex, int endIndex)
public class Test {
public static void main(String args[]) {
String str = new String("www.baidu.com");
System.out.println(str.subSequence(4, 5) ); //baidu
System.out.println(str.substring(4) ); //baidu.com
System.out.println(str.substring(4, 9) ); //baidu
}
}
3.20 toCharArray()
toCharArray()将字符串转换为字符数组。
public class Test {
public static void main(String args[]) {
String str = new String("www.baidu.com");
System.out.println( str.toCharArray() ); //www.baidu.com
}
}
3.21 toLowerCase() 和 toUpperCase()
toLowerCase()使用默认语言环境的规则将此 String 中的所有字符都转换为小写。
toUpperCase()使用默认语言环境的规则将此 String 中的所有字符都转换为大写。
public class Test {
public static void main(String args[]) {
String str = new String("WWW.BAIDU.COM");
String str1 = new String("www.baidu.com");
System.out.println( str.toLowerCase() ); //www.baidu.com
System.out.println( str1.toUpperCase() ); //WWW.BAIDU.COM
}
}
3.22 toString()
toString()返回此对象本身（它已经是一个字符串）。
public class Test {
public static void main(String args[]) {
String str = new String("www.baidu.com");
System.out.println( str.toString() ); //www.baidu.com
}
}
3.23 trim()
trim()用于删除字符串的头尾空白符。
public class Test {
public static void main(String args[]) {
String str = new String(" www.baidu.com ");
System.out.println( str.trim() ); //www.baidu.com
}
}
3.24 基础面试题
第一题：
说说length() 方法，length 属性和 size() 方法的区别？
答：
1、length() 方法是针对字符串来说的，要求一个字符串的长度就要用到它的length()方法；
2、length 属性是针对 Java 中的数组来说的，要求数组的长度可以用其 length 属性；
3、Java 中的 size() 方法是针对泛型集合说的, 如果想看这个泛型有多少个元素, 就调用此方法来查看!
第二题：
为什么说String 类是不可改变的？
String s = "Google";
System.out.println(s); //Google
s = "Baidu";
System.out.println(s); //Baidu
原因在于实例中的 s 只是一个 String 对象的引用，并不是对象本身，当执行 s = "Baidu"; 创建了一个新的对象 "Baidu"，而原来的 "Google" 还存在于内存中。
