本文涵盖了String类的多个重要方法并详细讲解了它们的作用：

String Methods

• 获取字符串的长度:
  length()方法
• 获取到字符串某个索引处的char：
  charAt()方法
• 用字符串生成char数组的方法：
  getChars()
• 比较字符串对象是否相等：
  equals()方法
• 忽略大小写时比较字符串对象是否相等：
  equalsIgnoreCase()方法
• 判断两个字符串对象的指定区间是否匹配：
  regionMatches()方法
• 判断字符串对象是否以指定的字符或字符串开头或结尾
  startsWith() & endsWith()方法：
• 定位字符或子字符串：
  indexOf() & lastIndexOf() 方法
• 从字符串中截取子字符串：
  substring()方法
• 拼接字符串：
  concat()方法
• 替换字符串中的某个字符或子字符串：
  replace()
• 将字符串对象大写或小写：
  toUpperCase()、toLowerCase()
• 去掉字符串对象前后的空格：
  trim()方法：
• 接收任何种类的参数，并将其转化为字符串对象：
  String.valueOf()方法：

最初和String类打交道的时候，因为它太常见了，一直都想当然地认为String类型也是基本类型的一种。
后来才发现，原来String也是一个类。
既然是类，那就肯定有对象，因此也必须要有构造器

java为String类提供了多个重载的构造器：

public class StringConstructors{
    public static void main(String[] args) {
//生成一个char数组，之后会用到其中的char来生成String对象
        char [] charArray = 
            new char[] {'h','e','l','l','o','w','o','r','l','d'}; 
        String st = new String("hello");

        //构造器
        String s1 = new String();
        String s2 = new String(st);
        String s3 = new String (charArray);
        String s4 = new String (charArray,5,5);

        System.out.printf("s1 = %s%ns2 = %s%ns3 = %s%ns4 = %s%n",
            s1,s2,s3,s4);
    }
}

输出：

s1 = 
s2 = hello
s3 = helloworld
s4 = world

注：s4用到的构造器传入的两个int类型的参数：

• 第一个表示index。由于数组是从0开始计数的，所以，index = 5 指的也就是从第6个插入开始算。
• 第二个表示往后数的个数，结合本例子中的index =5，也就是从第六个char开始，往后数5个char。

因此输出的就是 “world”。

获取字符串的长度——length()

获取到字符串某个索引处的char——charAt()

用字符串生成char数组——getChars()

public class StringMiscellaneous{
    public static void main(String[] args) {
        String s1 = "hello world";
        char [] charArray= new char [5];
//输出s1的值
        System.out.printf("s1的值: %s",s1);
//length()方法
        System.out.printf("%ns1的长度：%d ",s1.length());
//charAt()方法 输出s1的每一个char
        System.out.printf("%n输出s1的每一个char：%n");
        for (int count =0; count <s1.length() ; count ++) {
            System.out.printf("%c ",s1.charAt(count));
        }
        
//反转输出s1的每一个char
        System.out.printf("%n反转输出s1的每一个char：%n");
        for (int count = s1.length()-1 ;count >=0;count-- ) {
            System.out.printf("%c ",s1.charAt(count));
        }
        System.out.println();

        s1.getChars(0,5,charArray,0);
        System.out.printf("输出由s1得到的char数组：%n");
        for (char character : charArray ) {
            System.out.print(character);
        }
        System.out.println();
    }
}

输出：

s1的值: hello world
s1的长度：11 
输出s1的每一个char：
h e l l o   w o r l d 
反转输出s1的每一个char：
d l r o w   o l l e h 
输出由s1得到的char数组：
hello

注：s1.getChars(0,5,charArray,0);方法中的参数依次为：

• 第一个参数代表从String对象复制char的开始索引，这里传入1也就是从第一个char开始复制；
• 第二个参数代表从String对象复制字符时结尾的index，这里传入6，说明复制的范围应该是[0,6), 也就是说不包括该索引所在位置的char;
• 第三个参数传入存放char的数组;
• 第四个参数代表将char复制到指定数组的开始索引。这里传入0也就表示从charArray数组的index = 0的位置开始写入复制的char。

比较字符串对象是否相等：

public class StringComparation{
    public static void main(String[] args) {
        String s1 = new String("hello"); //s1复制了hello字符串的值
        String s2 = "good day";
        String s3 = "Have a nice day";
        String s4 = "have a nice day";
        //输出s1,s2,s3,s4的值：
        System.out.printf("s1 = %s%ns2 = %s%ns3 = %s%ns4 = %s%n%n",
            s1,s2,s3,s4);
        //equals()方法
        if (s1.equals("hello")) 
            System.out.println("s1 equals \"hello\"");
        else
            System.out.println("s1 does not equals \"hello\"");
    }
}

输出：

s1 = hello
s2 = good day
s3 = Have a nice day
s4 = have a nice day

s1 equals "hello"

从输出结果可以看出，equals()方法比较的是内容。也就是只要字符串的内容相等，equals()方法就返回true。

但是，如果用 “==”来做比较，情况则有所不同：

if (s1 == "hello") 
            System.out.println("s1 和\"hello\"是同一个对象");
        else
            System.out.println("s1 和 \"hello\"不是同一个对象");
        String s5 = new String("hello");
        if (s1 == s5) 
            System.out.println("s1和s5 是同一个对象");
        else
            System.out.println("s1和s5不是同一个对象");

输出：

s1和"hello"不是同一个对象
s1和s5不是同一个对象

在java中，当基础类型的值通过“==”来作比较时，如果两个基础类型的值相等，则返回true。但如果用“==”来比较引用类型，只有当两个同时指向内存中的同一个对象时才会返回true。
s1 = new String ("hello");语句的意思是，新建一个String对象，其值复制自"hello", 并让变量s1获得其引用。也就是变量s1指向了这个新生成的String对象。
如果换一种写法，写成s1 = "hello;"，结果就会不同了：

String s1 = "hello";
        if (s1 == "hello") 
            System.out.println("s1 和\"hello\"是同一个对象");
        else
            System.out.println("s1 和 \"hello\"不是同一个对象");
        String s5 = new String("hello");
        if (s1 == s5) 
            System.out.println("s1 和 s5 是同一个对象");
        else
            System.out.println("s1 和 s5 不是同一个对象");

输出：

s1 和"hello"是同一个对象
s1 和 s5 不是同一个对象

这一次，变量s1直接指向了字符串“hello”，而s5与上文中的s1类似。实际情况是s5指向了新生成的一个String对象，而该String对象的值是从“hello”复制得到的。
所以，

if (s1.equals(s5)) 
            System.out.println("s1 和 s5 值相等");
        else
            System.out.println("s1 和 s5 值不等");

的输出结果为：

s1 和 s5 值相等

忽略大小写时，判断字符串是否相等——equalsIgnoreCase()方法：

此方法在比较值是否相等时会忽略大小写：

public class StringComparation{
    public static void main(String[] args) {
        String s1 = new String("hello"); //s1复制了hello字符串的值
        String s2 = "good day";
        String s3 = "Have a nice day";
        String s4 = "have a nice day";
//输出s1,s2,s3,s4的值：
        System.out.printf("s1 = %s%ns2 = %s%ns3 = %s%ns4 = %s%n%n",
            s1,s2,s3,s4);
//equalsIgnoreCase()方法：
        if (s3.equalsIgnoreCase(s4)) 
            System.out.printf("忽略大小写时，%s 等于 %s%n",s3,s4);   
        else 
            System.out.printf("忽略大小写时，%s 不等于 %s%n",s3,s4);

输出：

s1 = hello
s2 = good day
s3 = Have a nice day
s4 = have a nice day

忽略大小写时，Have a nice day 等于 have a nice day

判断两个字符串对象的指定区间是否匹配——regionMatches()方法：

此方法用来比较两个String对象的某一区间是否相等：

        if (s3.regionMatches(0,s4,0,5)) //大小写敏感
            System.out.println("s3和s4的前五个字符相等");    
        else
            System.out.println("s3和s4的前五个字符不相等");

s3和s4的前五个字符不相等

regionMatches()方法接收4个参数时：

• 第一个参数，表示s3字符串要做比较的区间从哪儿开始算起；
• 第二个参数表示要与s3座比较的字符串，这里传入s4；
• 第三个参数与第一个类似；
• 第四个参数表示要作比较的区间的长度。
  这里由于'h'不等于‘H’，所以该方法返回false。

如果想要忽略掉大小写来进行比较的话，则可以用其重载的另一个方法，并将第一个参数设置为true：

if (s3.regionMatches(true,0,s4,0,5)) //大小写不敏感
            System.out.println("s3和s4的前五个字符相等");    
        else
            System.out.println("s3和s4的前五个字符不相等");

输出：

s3和s4的前五个字符相等

判断字符串对象是否以指定的字符或字符串开头或结尾——startsWith()&endsWith()方法：

顾名思义，这两个方法用来判断String对象是否以某字符串或字符开头或结尾：

public class StringStartsAndEnds{
    public static void main(String[] args) {
        String [] strings = 
            {"started","starting","to start", "ends","ended","to be ended" };
            //startsWith()方法
            for (String s  : strings) {
                if (s.startsWith("st")) {
                    System.out.printf("\"%s\" starts with \"st\"%n",s);
                }
            }
            //endsWith()方法
            for (String s  : strings) {
                if (s.endsWith("ed")) {
                    System.out.printf("\"%s\" ends with \"ed\"%n",s);
                }
            }
    }
}

输出：

"started" starts with "st"
"starting" starts with "st"
"started" ends with "ed"
"ended" ends with "ed"
"to be ended" ends with "ed"

定位字符或子字符串——indexOf() & lastIndexOf() 方法

public class MethodsForStringIndex{
    public static void main(String[] args) {
        String letters = "abcdefghigklmnabchilmnopqrstuvwabcde";
        //indexOf()方法
        System.out.printf(
            "'c' 在letters中第一次被找到时所在的index为：%d%n",
            letters.indexOf('c') );
        System.out.printf(
            "'c' 在letters中,从index=2处往后，第一次被找到时所在的index为：%d%n",
            letters.indexOf('c',2));//从letters的第三个字符开始 找
        System.out.printf(
            "'c' 在letters中,从index=3处往后，第一次被找到时所在的index为：%d%n",
            letters.indexOf('c',3));//从letters的第四个字符开始 找
    }
}

输出：

'c' 在letters中第一次被找到时所在的index为：2
'c' 在letters中,从index=2处往后，第一次被找到时所在的index为：2
'c' 在letters中,从index=3处往后，第一次被找到时所在的index为：16

同理，也可以用lastIndexOf()方法来检索得到某字符最后一次出现时的index：

System.out.printf(
            "'c' 在letters中最后一次被找到时所在的index为：%d%n",
            letters.lastIndexOf('c') );
        System.out.printf(
            "'c' 在letters中,从index=33处开始，向前检索，被再次找到时所在的index为：%d%n",
            letters.lastIndexOf('c',33) );
        System.out.printf(
            "'c' 在letters中,从index=32处开始，向前检索，被再次找到时所在的index为：%d%n",
            letters.lastIndexOf('c',32) );

输出：

'c' 在letters中最后一次被找到时所在的index为：33
'c' 在letters中,从index=33处开始，向前检索，被再次找到时所在的index为：33
'c' 在letters中,从index=32处开始，向前检索，被再次找到时所在的index为：16

以上是对单个字符的检索，对子字符串的检索同理：

String subString = "bc";
//indexOf()方法
        System.out.printf("\"bc\"第一次被定位到时的index为：%d%n",
            letters.indexOf(subString));
        System.out.printf(
            "'bc' 在letters中,从index=1处开始,被再次找到时所在的index为：%d%n",
            letters.indexOf(subString,1) );
        System.out.printf(
            "'c' 在letters中,从index=2处开始,被再次找到时所在的index为：%d%n",
            letters.indexOf(subString,2) );

输出：

"bc"第一次被定位到时的index为：1
'bc' 在letters中,从index=1处开始,被再次找到时所在的index为：1
'bc' 在letters中,从index=2处开始,被再次找到时所在的index为：15

lastIndexOf()方法的情况类似，不再举例。
最后需要说明的是，如果indexOf()或者lastIndexOf()方法找不到指定的字符或子字符串，则其返回-1:

System.out.println(letters.indexOf('z'));
System.out.println(letters.lastIndexOf("程序猿"));

输出：

-1
-1

从字符串中截取子字符串：substring()

public class SubStringTest{
    public static void main(String[] args) {
        String letters = "abcdefghigklmnabchilmnopqrstuvwabcde";
        System.out.printf("从index=20处截取到letters的末尾：\"%s\"%n",
            letters.substring(20));
        System.out.printf("从index=5处开始截取，"
            +"一直到index=20处(但不包括index=20)：\"%s\"%n",
            letters.substring(5,20));
        System.out.printf("从index=5处开始截取，"
            +"一直到index=21处(此时包括index=20)：\"%s\"%n",
            letters.substring(5,21));

    }
}

输出：

从index=20处截取到letters的末尾："mnopqrstuvwabcde"
从index=5处开始截取，一直到index=20处(但不包括index=20)："fghigklmnabchil"
从index=5处开始截取，一直到index=21处(此时包括index=20)："fghigklmnabchilm"

从输出结果可以看出，当参数为sbustring(5,21)时，实际截取到的值才位于区间[5,20]。
如果是substring(5,20)，则实际截取到的值位于区间[5,20)或者说[5,19]。

substring()方法结合之前的lastIndexOf()方法便可以很轻松地从一个下载链接中获取到要下载的文件的文件名：

//传入一个下载链接，这里以简书的app下载url为例：
        String url = "http://www.jianshu.com/apps";
//将url的长度保存在urlLength变量中:
        int urlLength = url.length();
//"/"符号最后一次出现时的index值为：
        int lastSlashIndex = url.lastIndexOf('/');
//用substring()方法截取文件名
        String fileName = url.substring(lastSlashIndex +1,urlLength -1);
        System.out.println("文件名为："+fileName);

输出：

文件名为：app

拼接字符串——concat()方法

concat()方法可以用来拼接字符串，拼接前后原字符串的值不会被修改：

//拼接字符串
        String s1 = "Hello ";
        String s2 = "World";

        System.out.printf("拼接s1和s2得到：%s%n",s1.concat(s2));
        System.out.printf("拼接过后s1的值为：%s%n",s1);

拼接s1和s2得到：Hello World
拼接过后s1的值为：Hello 

replace()、toUpperCase()、toLowerCase()、trim()方法：

public class StringMiscellaneous2{
    public static void main(String[] args) {
        String s1 = "hello";
        String s2 = "GOD BLESS YOU";
        String s3 = "      前后都有好多空格      ";

        System.out.printf("s1 = %s%ns2 = %s%ns3 = %s%n",
            s1,s2,s3);

//replace()方法：
        System.out.printf("用replace()方法把\"hello\"中的'l'换成'L':",
            s1.replace('l','L'));//注意不要漏了引号

//toLowerCase() & toUpperCase()方法：
        System.out.printf("s2.toLowerCase()=%s%n",s2.toLowerCase());
        System.out.printf("s1.toUpperCase()=%s%n",s1.toUpperCase());

//trim()方法去掉字符串前后多余的空格：
        System.out.printf("s3.trim()=%s%n",s3.trim());
    }
}

输出：

s1 = hello
s2 = GOD BLESS YOU
s3 =       前后都有好多空格      
用replace()方法把"hello"中的'l'换成'L':s2.toLowerCase()=god bless you
s1.toUpperCase()=HELLO
s3.trim()=前后都有好多空格

接收任何种类的参数，并将其转化为字符串对象——String.valueOf()方法：

众所周知，java中所有的对象都有一个valueOf()方法，用来输出该对象对自身的文字描述。但是基本类型的数据因为不能使用方法，所以无法做到这一点。
java中的String类提供了一个静态方法：valueOf()。此方法可以接收任何种类的参数，并将其转化为字符串对象：

public class StringValueOf{
    public static void main(String[] args) {

        char [] charArray = {'h','e','l','l','o'};
        boolean b = true;
        char ch = 'J';
        int i = 4;
        long l = 100000000L;
        float f= 2.5f;
        double d = 3.333;
        Object oReference = "world"; 

        System.out.printf("char array = %s%n",String.valueOf(charArray));
        System.out.printf("char array 的一部分 = %s%n",
            String.valueOf(charArray,2,3));

        System.out.printf("boolean= %s%n",String.valueOf(b));
        System.out.printf("char= %s%n",String.valueOf(ch));

        System.out.printf("int= %s%n",String.valueOf(i));
        System.out.printf("long= %s%n",String.valueOf(l));

        System.out.printf("float= %s%n",String.valueOf(f));
        System.out.printf("double= %s%n",String.valueOf(d));
        
        System.out.printf("Object= %s%n",String.valueOf(oReference));
    }
}

输出：

char array = hello
char array 的一部分 = llo
boolean= true
char= J
int= 4
long= 100000000
float= 2.5
double= 3.333
Object= world

水平有限，难免纰漏。
欢迎批评指正。
诸君共勉：）