JAVA String类

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" 还存在于内存中。