『Java』String类

时间：2021-02-20 11:48:26 收藏：0 阅读：0

Java中的字符串

java.lang.String类表示字符串类，Java程序中所有字符串文字都可以看作实现该类的实例。

特点：

字符串不可变：字符串的值在创建后不能在发生改变

public class Dome001_String {
    public static void main(String[] args) {
        String s = "abc";
        // hashCode()获取对象在内存中的地址
        System.out.println(s.hashCode()); // 96354
        s += "d";
        System.out.println(s.hashCode()); // 2987074

        System.out.println("abc".hashCode()); // 96354
        System.out.println("abcd".hashCode()); // 2987074
    }
}

通过上述代码的输出结果，我们可以发现，执行s += "d"时，不是在"abc"字符串后面加一个"d"（因为"abc"被创建之后值就不能再被改变），而是创建了一个新的字符串"abcd"并赋值给了s。

正是String对象不可变，所以它们可以被共享

public class Dome001_String {
    public static void main(String[] args) {
        String s1 = "asdf";
        String s2 = "asdf";

        System.out.println(s1.hashCode()); // 3003444
        System.out.println(s2.hashCode()); // 3003444
        System.out.println(s1 == s2); // true
    }
}

"asdf"被s1和s2共享。

关于底层实现：jdk1.8及以前String使用的是char数组，jdk1.9及以后使用的是byte数组。

构造方法

public String()：初始化新创建的字符串对象，使其表示空字符序列。**没有必要使用这个构造函数，因为字符串是不可变的。 **
public String(original)：
public String(char[] value)
public String(byte[] bytes)

public class Dome001_String {
    public static void main(String[] args) {
        String s3 = new String("abc");
        System.out.println(s3); // abc

        byte[] bytes = {97, 98, 99};
        char[] value = {‘a‘, ‘b‘, ‘c‘};
        String s1 = new String(bytes);
        String s2 = new String(value);
        System.out.println(s1);
        System.out.println(s2);
    }
}

public String(byte bytes[], int offset, int length)
public String(char value[], int offset, int count)

public class Dome001_String {
    public static void main(String[] args) {
        byte[] bytes = {97, 98, 99, 100, 101, 102, 103, 104, 105, 106};
        char[] value = {‘a‘, ‘b‘, ‘c‘, ‘d‘, ‘e‘, ‘f‘, ‘g‘, ‘h‘, ‘i‘, ‘k‘};

        String s1 = new String(bytes, 2, 5); // 从索引2开始的连续的5个元素构成的字符串
        System.out.println(s1); // cdefg
        String s2 = new String(value, 5, 3); // 从索引5开始的连续的3个元素构成的字符串
        System.out.println(s2); // fgh
    }
}

常用方法

public boolean equals(Object anObject)：判断字符串内容是否相等
public boolean equalsIgnoreCase(String anotherString)：忽略大小写判断字符串内容是否相等

public class Dome001_String {
    public static void main(String[] args) {
        String s1 = "hello";
        String s2 = "hello";
        String s3 = "HELlo";

        System.out.println(s1.equals(s2)); // true
        System.out.println(s1.equals(s3)); // false
        System.out.println(s1.equalsIgnoreCase(s3)); // true
    }
}

public int length()：public int length()：获取字符串当中含有的字符个数，拿到字符串长度。
public String concat(String str)：将当前字符串和参数字符串拼接成为返回值新的字符串。
public char charAt(int index)：获取指定索引位置的单个字符（索引从0开始）
public int indexOf(String str)：查找参数字符串在本字符串当中首次出现的索引位置，如果没有返回-1值。
public String substring(int index)：截取从参数位置一直到字符串末尾，返回新字符串。
public String substring(int begin, int end)：截取从begin开始，一直到end结束，中间的字符串。

public class Dome001_String {
    public static void main(String[] args) {
        // 获取字符串的长度
        int length = "ueyvb".length();
        System.out.println(length); // 5

        // 拼接字符串
        String str1 = "Hello";
        String str2 = "World";
        String str3 = str1.concat(str2);
        System.out.println(str1); // Hello，原封不动
        System.out.println(str2); // World，原封不动
        System.out.println(str3); // HelloWorld，新的字符串

        // 获取指定索引位置的单个字符
        char ch = "Hello".charAt(1);
        System.out.println(ch); // e

        // 查找参数字符串在本来字符串当中出现的第一次索引位置
        String original = "HelloWorldHelloWorld";
        int index = original.indexOf("llo");
        System.out.println(index); // 2
        // 如果根本没有，返回-1值
        System.out.println(original.indexOf("abc")); // -1

        // 截取字符串
        String str4 = "HelloWorld";
        String str5 = str4.substring(5);
        System.out.println(str4); // HelloWorld，原封不动
        System.out.println(str5); // World，新字符串

        String str6 = str4.substring(2, 7); // 从索引2开始一直截取到索引7（不包含索引7）
        System.out.println(str6); // lloWo
    }
}

public char[] toCharArray()：将当前字符串拆分成为字符数组作为返回值。
public byte[] getBytes()：获得当前字符串底层的字节数组。
public String replace(CharSequence oldString, CharSequence newString)：将所有出现的老字符串替换成为新的字符串，返回替换之后的结果新字符串。

CharSequence是一个接口，也是一种引用类型。作为参数类型，可以把String对象传递到方法中。

public class Dome001_String {
    public static void main(String[] args) {
        // 转换成为字符数组
        char[] chars = "Hello".toCharArray();
        System.out.println(Arrays.toString(chars)); // [H, e, l, l, o]

        // 转换成为字节数组
        byte[] bytes = "abc".getBytes();
        System.out.println(Arrays.toString(bytes)); // [97, 98, 99]

        // 字符串的内容替换
        String str1 = "How do you do?";
        String str2 = str1.replace("o", "*");
        System.out.println(str1); // How do you do?
        System.out.println(str2); // H*w d* y*u d*?
    }
}

public String[] split(String regex)：按照给定的正则表达式规则，将字符串切分成为若干部分。

import java.util.Arrays;

public class Dome001_String {
    public static void main(String[] args) {
        String str1 = "aaa,bbb,ccc";
        String[] array1 = str1.split(",");
        System.out.println(Arrays.toString(array1)); // [aaa, bbb, ccc]

        String str3 = "XXX.YYY.ZZZ";
        String[] array3 = str3.split("\\."); // “.”是正则表达式中的元字符，如果想以元字符分割的话需要加上转义符号“\\”
        System.out.println(Arrays.toString(array3)); // [XXX, YYY, ZZZ]

        String str4 = "1a111a1aa11aaa11";
        String[] array4 = str4.split("1+");
        System.out.println(Arrays.toString(array4)); // [, a, a, aa, aaa]
        // 除此之外，我们还发现，str4的第一个元素1就跟regex匹配了，所以array4中第一个字符串是""
        // 而str4结尾是11，同样跟regex匹配，但是array4最后并没有一个元素为""
    }
}