之前写过一篇较为详细的String博客，大家可以去看一下，本文注重整理和
总结。
👉String类，这一篇就够了

文章目录

• 创建字符串
• 字符串长度
• 连接字符串
• 创建格式化字符串
• String方法
• • char charAt(int index)
  • int compareTo(Object object)
  • bollean equals(Object anObject)
  • getChars()方法
  • int indexOf(int ch)
  • int indexOf(int ch,int fromIndex)
  • int indexOf(String str)
  • int indexOf(String str,int fromIndex)
  • int length()
  • boolean matches(String regex)
• split() 方法
• • subSequence() 方法
• substring() 方法（左闭右开）
• • String trim()
  • String contains()方法

---

字符串广泛应用 在 Java 编程中，在 Java 中字符串属于对象（常量池不例外），Java 提供了 String 类来创建和操作字符串。

创建字符串

//最简单的方式
String string = "Gremmie102";
1
2

在代码中遇到字符串常量时，这里的值是"Gremmie102"，编译器会使用该值创建一个String对象。
和其他对象一样，可以使用关键字和构造方法来创建String对象

用构造函数创建字符串：👇

String string2 = new String("Gremmie102");
1

String创建的字符串存储在公共池中，而new创建的字符串对象在堆上；

String s1 = "Gremmie";              // String 直接创建
String s2 = "Gremmie";              // String 直接创建
String s3 = s1;                    // 相同引用
String s4 = new String("Gremmie");   // String 对象创建
String s5 = new String("Gremmie");   // String 对象创建
1
2
3
4
5

String 类有 11 种构造方法，这些方法提供不同的参数来初始化字符串，比如提供一个字符数组参数:

public class StringDemo{
   public static void main(String args[]){
      char[] helloArray = { 'G', 'r', 'e', 'm', 'm', 'm','i','e'};
      String helloString = new String(helloArray);  
      System.out.println( helloString );
   }
}
//编译结果为: Gremmie
1
2
3
4
5
6
7
8

注意：
String 类是不可改变的，所以你一旦创建了 String 对象，那它的值就无法改变了（详看上篇博客部分解析）。👉String类，这一篇就够了
如果需要对字符串做很多修改，那么应该选择使用 StringBuffer & StringBuilder 类。（这个我后面的博客会单独拎出来整理）

字符串长度

用于获取有关对象的信息的方法称为访问器方法。
String 类的一个访问器方法是 length() 方法，它返回字符串对象包含的字符数。
下面的代码执行后，len 变量等于 14:

public class StringDemo {
    public static void main(String args[]) {
        String site = "https://www.yuque.com/gremmie";
        int len = site.length();
        System.out.println( "Gremmie的知识库网址长度: " + len );
   }
}
//Gremmie的知识库网址长度: 29
1
2
3
4
5
6
7
8

连接字符串

String类提供了连接两个字符串的方法：

string.concat(string2);
1

这里返回string2连接上string1的心字符串。
同样，也可以对字符串常量使用concat()方法，如：👇

"My name is ".concat("Gremmie");
1

但对于字符串来说，我们其实更常用的是使用"+"操作符来连接字符串，如：

"Hello,"+"Gremmie"
1

创建格式化字符串

我们知道输出格式化数字可以使用printf()和format（）方法。
String类使用静态方法format()返回一个String对象而不是PrintStream对象
String类的静态方法format()能够用来创建可复用的格式化字符串，而不仅仅是用于一次打印输出

System.out.printf("浮点型变量的值为 " +
                  "%f, 整型变量的值为 " +
                  " %d, 字符串变量的值为 " +
                  "is %s", floatVar, intVar, stringVar);
1
2
3
4

同样也可以这样写：

String fs;
fs = String.format("浮点型变量的值为 " +
                   "%f, 整型变量的值为 " +
                   " %d, 字符串变量的值为 " +
                   " %s", floatVar, intVar, stringVar);
1
2
3
4
5

String方法

char charAt(int index)

返回索引处的char值

int compareTo(Object object)

将该字符串和另一个对象进行比较
返回值

返回值是整型，它是先比较对应字符的大小(ASCII码顺序)，如果第一个字符和参数的第一个字符不等，结束比较，返回他们之间的长度差值，如果第一个字符和参数的第一个字符相等，则以第二个字符和参数的第二个字符做比较，以此类推,直至比较的字符或被比较的字符有一方结束。

public class Test {
 
    public static void main(String args[]) {
        String str1 = "Strings";
        String str2 = "Strings";
        String str3 = "Strings123";
 
        int result = str1.compareTo( str2 );
        System.out.println(result);
      
        result = str2.compareTo( str3 );
        System.out.println(result);
     
        result = str3.compareTo( str1 );
        System.out.println(result);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

输出结果为：

0
-3
3

bollean equals(Object anObject)

public class Test {
    public static void main(String args[]) {
        String Str1 = new String("runoob");
        String Str2 = Str1;
        String Str3 = new String("runoob");
        boolean retVal;

        retVal = Str1.equals( Str2 );
        System.out.println("返回值 = " + retVal );

        retVal = Str1.equals( Str3 );
        System.out.println("返回值 = " + retVal );
    }
}
//返回值 = true
//返回值 = true
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

使用 == 和 equals() 比较字符串。
String 中 == 比较引用地址是否相同，equals() 比较字符串的内容是否相同：

String s1 = "Hello";              // String 直接创建
String s2 = "Hello";              // String 直接创建
String s3 = s1;                   // 相同引用
String s4 = new String("Hello");  // String 对象创建
String s5 = new String("Hello");  // String 对象创建
 
s1 == s1;         // true, 相同引用
s1 == s2;         // true, s1 和 s2 都在公共池中，引用相同
s1 == s3;         // true, s3 与 s1 引用相同
s1 == s4;         // false, 不同引用地址
s4 == s5;         // false, 堆中不同引用地址
 
s1.equals(s3);    // true, 相同内容
s1.equals(s4);    // true, 相同内容
s4.equals(s5);    // true, 相同内容
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

getChars()方法

getChars() 方法将字符从字符串复制到目标字符数组。

语法

public void getChars(int srcBegin, int srcEnd, char[] dst,  int dstBegin)
1

参数
srcBegin – 字符串中要复制的第一个字符的索引。
srcEnd – 字符串中要复制的最后一个字符之后的索引。
dst – 目标数组。
dstBegin – 目标数组中的起始偏移量。

偏移量就是起始位置和0的距离

返回值
没有返回值，但会抛出 IndexOutOfBoundsException 异常。

public class Test {
    public static void main(String args[]) {
        String Str1 = new String("www.Gremmie.com");
        char[] Str2 = new char[6];

        try {
            Str1.getChars(4, 10, Str2, 0);
            System.out.print("拷贝的字符串为：" );
            System.out.println(Str2 );
        } catch( Exception ex) {
            System.out.println("触发异常...");
        }
    }
}
//拷贝的字符串为：Gremmie
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

int indexOf(int ch)

返回指定字符在此字符串中第一次出现处的索引。

int indexOf(int ch,int fromIndex)

返回在此字符串中第一次出现指定字符处的索引，从指定的索引开始搜索。

int indexOf(String str)

返回指定子字符串在此字符串中第一次出现处的索引

int indexOf(String str,int fromIndex)

返回指定子字符串在此字符串中第一次出现处的索引，从指定的索引开始。

int length()

返回此字符串的长度

boolean matches(String regex)

通过regex正则表达式来看字符串是否匹配格式

replace() 方法通过用 newChar 字符替换字符串中出现的所有 searchChar 字符，并返回替换后的新字符串。

public String replace(char searchChar, char newChar)  
1

参数

• searchChar – 原字符。
• newChar – 新字符。

返回值
替换后生成的新字符串
实例

public class Main {
    public static void main(String args[]) {
        String Str = new String("Runoob");

        System.out.print("返回值 :" );
        System.out.println(Str.replace('o', 'T'));

        System.out.print("返回值 :" );
        System.out.println(Str.replace('u', 'D'));
    }
}
1
2
3
4
5
6
7
8
9
10
11

返回值 :RunTTb
返回值 :RDnoob

split() 方法

split() 方法根据匹配给定的正则表达式来拆分字符串。

注意： . 、 $、 | 和 * 等转义字符，必须得加 \。

注意：多个分隔符，可以用 | 作为连字符。

public String[] split(String regex, int limit)
1

regex – 正则表达式分隔符。
limit – 分割的份数。

返回值为字符串数组

public class Test {
    public static void main(String args[]) {
        String str = new String("Welcome-to-Runoob");
 
        System.out.println("- 分隔符返回值 :" );
        for (String retval: str.split("-")){
            System.out.println(retval);
        }
 
        System.out.println("");
        System.out.println("- 分隔符设置分割份数返回值 :" );
        for (String retval: str.split("-", 2)){
            System.out.println(retval);
        }
 
        System.out.println("");
        String str2 = new String("www.runoob.com");
        System.out.println("转义字符返回值 :" );
        for (String retval: str2.split("\\.", 3)){
            System.out.println(retval);
        }
 
        System.out.println("");
        String str3 = new String("acount=? and uu =? or n=?");
        System.out.println("多个分隔符返回值 :" );
        for (String retval: str3.split("and|or")){
            System.out.println(retval);
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

分隔符返回值 :
Welcome
to
Runoob

分隔符设置分割份数返回值 :
Welcome
to-Runoob

转义字符返回值 :
www
runoob
com

多个分隔符返回值 :
acount=?
uu =?
n=?

subSequence() 方法

subSequnence()方法返回一个新的字符序列，它是此序列的一个子序列

public CharSequence subSequence(int beginIndex, int endIndex)
1

参数
beginIndex – 起始索引（包括）。
endIndex – 结束索引（不包括）。

返回值

返回一个新的字符序列，它是此序列的一个子序列。

public class Test {
    public static void main(String args[]) {
         String Str = new String("www.runoob.com");

         System.out.print("返回值 :" );
         System.out.println(Str.subSequence(4, 10) );
    }
}
1
2
3
4
5
6
7
8

返回值 :runoob

substring() 方法（左闭右开）

substring() 方法返回字符串的子字符串。

public String substring(int beginIndex)

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

参数
beginIndex – 起始索引（包括）, 索引从 0 开始。
**endIndex **-- 结束索引（不包括）。

返回值为子字符串

public class RunoobTest {
    public static void main(String args[]) {
        String Str = new String("This is text");
 
        System.out.print("返回值 :" );
        System.out.println(Str.substring(4) );
 
        System.out.print("返回值 :" );
        System.out.println(Str.substring(4, 10) );
    }
}
1
2
3
4
5
6
7
8
9
10
11

返回值 : is text
返回值 : is te

String trim()

返回字符串的副本，忽略前导空白和尾部空白。

String contains()方法

contains() 方法用于判断字符串中是否包含指定的字符或字符串。

public boolean contains(CharSequence chars)
1

chars – 要判断的字符或字符串。

如果包含指定的字符或字符串返回 true，否则返回 false。

public class Main {
    public static void main(String[] args) {
        String myStr = "Runoob";
        System.out.println(myStr.contains("Run"));
        System.out.println(myStr.contains("o"));
        System.out.println(myStr.contains("s"));
    }
}
1
2
3
4
5
6
7
8

true
true
false

感谢阅读~考试月加油