首页 > 编程笔记 > Java笔记阅读：9

Java String字符串类的用法（非常详细，附带实例）

在 Java 中，字符串是作为内置对象进行处理的。在 java.lang 包中有两个专门处理字符串的类，分别是 String 和 StringBuffer。

String 类提供了十分丰富的功能特性，以方便处理字符串。由于 String 类定义在 java.lang 包中，因此可以自动被所有程序利用。String 类都被声明为 final，意味着它没有子类，也不能被用户自定义的类继承。

String 类表示了定长、不可变的字符序列。Java 程序中所有的字符串常量（如“abc”）都作为此类的实例来实现。

String 类的特点是一旦赋值便不能改变其指向的字符串对象，如果更改则会指向一个新的字符串对象。

Java String类常用方法

1) 创建字符串

String 类的构造方法，共有 13 个，如下所示：

String()
String(byte[]bytes)
String(byte[] ascii，int hibyte)
String(byte[] bytes，int offset，int length)
String(byte[] ascii，int hibyte，int offset，int count)
String(byte[]bytes，int offset，int length，String charsetName)
String(byte[] bytes，String charsetName)
String(char[] value)
String(char[] value，int offset，int count)
String(int[] codePoints，int offset，int count)
String(String original)
String(StringBuffer buffer)
String(StringBuilder builder)

在初始化一个字符串对象的时候，可以根据需要调用相应的构造方法。参数为空的构造方法是 String 类默认的构造方法，例如下面的语句：

String str=new String();

此语句创建一个 String 对象，该对象中不包含任何字符。

如果希望创建含有初始值的字符串对象，可以使用带参数的构造方法：

char[] chars={'H','I'}；
String s=new String(chars);

这个构造方法用字符数组 chars 中的字符初始化 s，结果 s 中的值就是“HI”。

使用下面的构造函数可以指定字符数组的一个子区域作为初始化值：

String(char[] value，int offset，int count)

其中，offset 指定区域的开始位置，count 表示区域的长度即包含的字符个数。例如在程序中有如下两条语句：

char chars[]={'W','e','l','c','o','m'};
String s=new String(chars,3,3);

执行以上两条语句后 s 的值就是 com。

用下面的构造方法可以构造一个 String 对象，该对象包括与另一个 String 对象相同的字符序列：

String(String original);

此处 original 是一个字符串对象。

【实例】使用不同的构造方法创建 String 对象：

public class CloneString {
    public static void main(String args[]) {
        char c[] = {'H', 'e', 'l', 'l', 'o'};
        String str1 = new String(c);
        String str2 = new String(str1);
        System.out.println(str1);
        System.out.println(str2);
    }
}

程序执行结果为：

Hello
Hello

这里需要注意的是，当从一个数组创建一个 String 对象时，数组的内容将被复制。在字符串被创建以后，如果改变数组的内容，String 对象不会随之改变。

上面的例子说明了如何使用不同的构造方法创建一个 String 对象，但是这些方法在实际的编程中并不常用。对于程序中的每一个字符串常量，Java 会自动创建 string 对象。

因此，可以使用字符串常量初始化 String 对象。例如，下面的程序代码段创建两个相等的字符串：

char chars[]={'W'，'a'，'n'，'g'};
String sl=new String(chars);
String s2="Wang";

执行此代码段，则s1和s2的内容相同。

需要区分，字符串常量创建的对象存储在字符串池中，而 new 创建的字符串对象在存储在堆区。示例代码如下：

String s1 = “hello”; //字符串常量直接创建
String s2 = “hello”; //字符串常量直接创建
String s3 = s1; //相同引用
String s4 = new String("Runoob"); // String 对象创建
String s5 = new String("Runoob"); // String 对象创建

上述代码对应的内存状态图如下图所示：

图 1 两种方式创建字符串的内存状态图

由于对应每一个字符串常量都有一个 String 对象被创建，因此在使用字符串常量的任何地方都可以使用 String 对象。使用字符串常量创建 String 对象最为常见。

2) 字符串长度

字符串的长度是指其所包含的字符的个数，调用 String 的 length() 方法可以得到这个值。

3) 字符串连接

“+”运算符可以连接两个字符串，产生一个 String 对象。

也允许使用多个“+”运算符，把多个字符串对象连接成一个字符串对象。

例如：

public class BookDetails {
    final String name = "《C语言入门教程》";
    final String author = "严长生";
    final String publisher = "C语言中文网";
    public static void main(String args[]) {
        BookDetails oneBookDetail = new BookDetails();
        System.out.println("the book detail:" + oneBookDetail.name +
                           " - " + oneBookDetail.author + " - " + oneBookDetail.publisher);
    }
}

程序执行结果为：

the book detail:《C语言入门教程》 - 严长生 - C语言中文网

4) 字符串与其他类型数据的连接

字符串除了可以连接字符串以外，还可以和其他基本类型数据连接，连接以后成为新的字符串。示例代码如下：

int age=43;
String s="He is "+age+"years old.";
System.out.println(s);

执行此段程序，输出结果为 He is 43 years old.

5) 利用charAt()方法截取一个字符

从一个字符串中截取一个字符，可以通过 charAt() 方法实现。其形式如下：

char charAt(int where)

这里，where 是想要获取的字符的下标，其值必须非负。它指定该字符在字符串中的位置。

例如下面两条语句：

char ch;
ch="abc".charAt(1);

执行以上两条语句，则 ch 的值为 'b'。

6) getChars()方法

如果想一次截取多个字符，可以使用 getChar() 方法。它的形式如下：

void getChars(int sourceStart,int sourceEnd,char targte[],int targetStart)

其中，sourceStart 表示子字符串的开始位置，sourceEnd 是子字符串中最后一个字符的下一个字符位置，因此截取的子字符串包含了从 sourceStart 到 sourceEnd-1 的字符。字符串存放在字符数组 target 中从 targetStart 开始的位置，在此必须确保 target 应该足够大，能容纳所截取的子串。

下面通过一个案例演示此方法的使用：

public class GetCharsDemo {
    public static void main(String[] args) {
        String s = "hello world";
        int start = 6;
        int end = 11;
        char buf[] = new char[end - start]; // 定义一个长度为 end-start 的字符数组
        s.getChars(start, end, buf, 0);
        System.out.println(buf);
    }
}

程序执行结果为：

world

7) getBytes()方法

byte[] getBytes() 方法使用平台的默认字符集将此字符串编码为 byte 序列，并将结果存储到一个新的 byte 数组中。也可以使用指定的字符集对字符串进行编码，把结果存到字节数组中。

String 类中提供了 getBytes() 的多个重载方法。在进行 java io 操作的过程中，此方法是很有用处的。使用本方法，还可以解决中文乱码问题。

8) 将字符串转换为一个字符数组

如果想将字符串对象中的字符转换为一个字符数组，最简单的方法就是调用 toCharArray() 方法。其一般形式为 char[] toCharArray()。此方法是为了便于使用而提供的，也可以使用 getChars() 方法获得相同的结果。

9) 字符串比较操作

String 类中包括了几个用于比较字符串或其子串的方法，下面分别介绍它们的用法。

① 使用 equals() 方法可以比较两个字符串是否相等，一般形式如下：

public boolean equals(Object obj)

如果两个字符串具有相同的字符和长度，返回 true，否则返回 false。这种比较是区分大小写的。

② 为了执行忽略大小写的比较，可以使用 equalsIgnoreCase() 方法，其形式如下：

public boolean equalsIgnoreCase(String anotherString)

例如，创建四个字符串，分别调用 equals() 和 equalsIgnoreCase() 方法判断字符串是否相等。

public class EqualDemo {
    public static void main(String[] args) {
        String s1 = "hello";
        String s2 = "hello";
        String s3 = "Good-bye";
        String s4 = "HELLO";
       
        System.out.println(s1 + " equals " + s2 + "->" + s1.equals(s2));
        System.out.println(s1 + " equals " + s3 + "->" + s1.equals(s3));
        System.out.println(s1 + " equals " + s4 + "->" + s1.equals(s4));
        System.out.println(s1 +
            " equalsIgnoreCase " + s4 + "->" + s1.equalsIgnoreCase(s4));
    }
}

程序执行结果为：

hello equals hello->true
hello equals Good-bye->false
hello equals HELLO->false
hello equalsIgnoreCase HELLO->true

③ startsWith() 方法判断该字符串是否以指定的字符串开始，而 endsWith() 方法判断该字符串是否以指定的字符串结尾。它们的形式如下：

public boolean startsWith(String prefix)
public boolean endsWith(String suffix)

此处，prefix 和 suffix 是被测试的字符串，如果字符串匹配，则这两个方法返回 true，否则返回 false。

例如，"Foobar".endWith("bar") 和 "Foobar".startsWith("Foo") 的结果都是 true。

④ equals() 方法与“==”运算的功能都是比较是否相等，但它们的具体含义却不同，理解它们之间的区别很重要。

如上面解释的那样，equals()方法比较字符串对象中的字符是否相等，而“==”运算符则比较两个对象引用是否指向同一个对象。

public class EqualsDemo {
    public static void main(String[] args) {
        String s1 = "book";
        String s2 = new String(s1);
        String s3 = s1;
        System.out.println("s1 equals s2->" + s1.equals(s2));
        System.out.println("s1 == s2->" + (s1 == s2));
        System.out.println("s1 == s3->" + (s1 == s3));
    }
}

程序执行结果为：

s1 equals s2->true
s1 == s2->false
s1 == s3->true

上述程序在内存中的状态如下图所示：

图 2 内存状态图

⑤ 通常，仅知道两个字符串是否相同是不够的。对于实现排序的程序来说，必须知道一个字符串是大于、等于还是小于另一个。字符串的大小关系是指它们在字典中出现的先后顺序，先出现的小，后出现的大。而 compareTo() 方法则实现了这样的功能。它的一般形式如下：

public int compareTo(String anotherString)

这里 anotherString 是被比较的对象，此方法的返回值有三个，分别代表不同的含义。

值小于 0：调用字符串小于 anotherString。
值大于 0：调用字符串大于 anotherString。
值等于 0：调用字符串等于 anotherString。

10) 字符串搜索

String 类提供两个方法实现在字符串中搜索指定的字符或子字符串：

indexOf() 方法用来搜索字符或子字符串首次出现的位置；
lastIndexOf() 方法用来搜索字符或子字符串最后一次出现的位置。

indexOf() 方法有 4 种形式，分别如下：

int indexOf(int ch)
int indexOf(int ch，int fromIndex)
int indexOf(String str)
int indexOf(String str，int fromlndex)

第一个方法返回指定字符在字符串中首次出现的位置，其中 ch 代表指定的字符；
第二个方法返回从指定搜索位置起，指定字符在字符串中首次出现的位置，其中指定字符由 ch 表示，指定位置由 fromIndex 表示；
第三个方法返回指定子字符串在字符串中首次出现的位置，其中指定子字符串由 str 给出；
第四个方法返回从特定搜索位置起，特定子字符串在字符串中首次出现的位置，其中特定的子字符串由 str 给定，特定搜索位置由 fromIndex 给定。

lastlndexOf 方法也有 4 种形式，分别如下：

int lastIndexOf(int ch)
int lastIndexOf(int ch,int fromIndex)
int lastIndexOf(String str)
int lastlndexOf(String str,int fromlndex)

其中每个方法中参数的具体含义和 indexOf() 方法类似。

11) 字符串修改

字符串的修改包括获取字符串中的子串、字符串之间的连接、替换字符串中的某字符、消除字符串的空格等功能。

在 String 类中有相应的方法来提供这些功能：

String substring(int startIndex)
String substring(int startIndex，int endlndex)
String concat(String str)
String replace(char original，char replacement)
String replace(CharSequence target，CharSequence replace ment
String trim()

substring() 方法用来得到字符串中的子串，这个方法有两种形式，这里 startIndex 指定开始下标，endIndex 指定结束下标：

第一种形式返回从 startIndex 开始到该字符串结束的子字符串的拷贝；
第二种形式返回的字符串包括从开始下标直到结束下标的所有字符，但不包括结束下标对应的字符。

concat() 方法用来连接两个字符串。这个方法会创建一个新的对象，该对象包含原字符串，同时把 str 的内容跟在原来字符串的后面。

concat() 方法与“+”运算符具有相同的功能。

replace() 方法用来替换字符串，这个方法也有两种形式，第一种形式中，original 是原字符串中需要替换的字符，replacement 是用来替换 original 的字符。第二种形式在编程中不是很常用。

trim() 方法是用来去除字符串前后多余的空格。

在此需要注意，因为字符串是不能改变的对象，因此调用上述修改方法对字符串进行修改都会产生新的字符串对象，原来的字符串保持不变。

12) valueOf()方法

valueOf() 方法是定义在 String 类内部的静态方法。利用这个方法，可以将几乎所有的 Java 简单数据类型转换为 String 类型。这个方法是 String 类型和其他 Java 简单类型之间的一座转换桥梁。

除了把 Java 中的简单类型转换为字符串之外，valueOf() 方法还可以把 Object 类和字符数组转换为字符串。

valueOf() 方法共有 9 种形式：

static String valueOf(boolean b)
static String valueOf(char c)
static String valueOf(char[]data)
static String valueOf(char[]data，int offset，int count)
static String valueOf(double d)
static String valueOf(float f)
static String valueOf(int i)
static String valueOf(1ong 1)
static String valueOf(Object obj)

13) toString()方法

当 Java 在使用连接运算符“+”将其他类型数据转换为字符串形式时，是通过调用字符串中定义的 valueOf() 的重载方法来完成的：

对于简单类型，valueOf() 方法返回一个字符串，该字符串包含了相应参数的可读值。
对于对象，valueOf() 方法调用 toString() 方法。

toString() 方法在 Object 中定义，所以任何类都有这个方法。然而 toString() 方法的默认实现是不够的。对于用户所创建的大多数类，通常都希望用自己提供的字符串表达式覆盖 toString() 方法。

下面的例子在 Person 类中覆盖 toString() 方法说明了这点。当 Person 对象在连接表达式中使用或在调用 println() 方法中时，Person 类的 toString() 方法被自动调用。

public class Student {
    String name;
    int age;
    Student(String n, int a) {
        this.name = n;
        this.age = a;
    }
    public String toString() { // 覆盖超类的 toString() 方法，返回自己的字符串对象
        return "姓名是" + name + "，年龄是" + age + "岁";
    }
    public static void main(String[] args) {
        Student s = new Student("王红", 18);
        System.out.println(s);
    }
}

程序执行结果为：

姓名是王红，年龄是18岁

Java String字符串类的用法（非常详细，附带实例）

Java String类常用方法

1) 创建字符串

2) 字符串长度

3) 字符串连接

4) 字符串与其他类型数据的连接

5) 利用charAt()方法截取一个字符

6) getChars()方法

7) getBytes()方法

8) 将字符串转换为一个字符数组

9) 字符串比较操作

10) 字符串搜索

11) 字符串修改

12) valueOf()方法

13) toString()方法

相关文章