【Java】【常用类】String

String表示字符串,Java所有的字符串字面值都是String类的实例实现

String是一个final修饰的类，代表不可变的字符序列

字符串是常量，用双引号表示，值在创建之后不能更改

String对象实际的字符内容是存储在一个字符数组value[]中的

- 被final修饰，String类不能被继承

- 实现了可序列化接口，字符串可以序列化

- 实现了可比较接口，字符串可以进行大小比较

- final char value[] 不可改动

1 字符串重新赋值时，需要重写指定区域赋值，不能使用原有value进行赋值

2 对现有字符串拼接操作时，也是重写指定区域赋值，不能使用原有value进行赋值

3 调用replace方法时，也是重写指定区域赋值，不能使用原有value进行赋值

- 可以得知如果直接使用String频繁更改字面值，性能是很低的

- 字面值的声明方式是引用了字符串的常量池中

- 字符串常量池并不会存储相同内容

字面量 & new 的区别？

public class StringTest {

    public static void main(String[] args) {
        String str1 = "Hello String!!!";
        String str2 = "Hello String!!!";

        String str3 = new String("Java SE");
        String str4 = new String("Java SE");

        System.out.println("str1 == str2 ? "+ (str1 == str2));
        System.out.println("str3 == str4 ? "+ (str3 == str4));
    }
}

拼接是否一样？

    public static void main(String[] args) {
        String str1 = "AA";
        String str2 = "BB";

        String str3 = "AABB";   // 字面值
        String str4 = "AA" + "BB";  // 字面值链接，还是属于常量池里的

        String str5 = str1 + "BB"; // 在堆中重新开辟的
        String str6 = "AA" + str2; // 在堆中重新开辟的
        String str7 = str1 + str2; // 在堆中重新开辟的

        System.out.println("str3 == str4 ? " + (str3 == str4));
        System.out.println("str3 == str5 ? " + (str3 == str5));
        System.out.println("str3 == str6 ? " + (str3 == str6));
        System.out.println("str3 == str7 ? " + (str3 == str7));

        String str8 = str5.intern(); // 返回常量池里面的值给Str8
        System.out.println("str3 == str8 ? " + (str3 == str8));
    }

常见方法

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

        String str = "Hello String!";

        // 返回字符串的字符个数
        int length = str.length();
        System.out.println("str.length() ? " + length);

        // 返回索引位置的字符
        char charAt = str.charAt(2);
        System.out.println("str.charAt(2) ? " + charAt);

        // 是否为空？
        boolean empty = str.isEmpty();
        System.out.println("str.isEmpty() ? " + empty);

        // 返回全大写
        String lowerCase = str.toLowerCase();
        System.out.println("str.toLowerCase() ? " + lowerCase);

        // 返回全小写
        String upperCase = str.toUpperCase();
        System.out.println("str.toUpperCase() ? " + upperCase);

        // 返回去除左右空白的字符串
        String trim = str.trim();
        System.out.println("str.trim() ? " + trim);

        // 普通内容比较
        boolean equals = lowerCase.equals(upperCase);
        System.out.println("lowerCase.equals(upperCase) ? " + equals);

        // 忽略大小写比较
        boolean ignoreCase = lowerCase.equalsIgnoreCase(upperCase);
        System.out.println("lowerCase.equalsIgnoreCase(upperCase) ? " + ignoreCase);

        // 拼接字符串到结尾
        String concat = str.concat(" concat str!!!");
        System.out.println("str.concat(\" concat str!!!\") ? " + concat);

        // 比较大小
        int compare = lowerCase.compareTo(upperCase);
        System.out.println("lowerCase.compareTo(upperCase) ? " + compare);

        // 截取片段 包含开始索引，不包含结束索引
        String substring = concat.substring(4, 8);
        System.out.println(concat + ":" + substring);

        // 是否按指定后缀结尾
        boolean ends = str.endsWith("s");
        System.out.println("str.endsWith(\"s\") ?" + ends);

        // 是否按指定前缀结尾
        boolean starts = str.startsWith("a");
        System.out.println("str.startsWith(\"a\") ?" + starts);

        // 是否，从指定索引开始的字符串，匹配指定的字符串
        boolean with = str.startsWith("aa", 4);
        System.out.println("str.startsWith(\"aa\", 4) ? " + with);

        // 是否包含字符
        boolean e = str.contains("e");
        System.out.println("str.contains(\"e\") ? " + e);

        // 返回指定字符串在 这个字符串中第一次出现的位置
        int index1 = str.indexOf("ring");

        // 返回指定字符串在 这个字符串中指定的位置后出现的位置
        int index2 = str.indexOf("ell",2);

        // 返回指定字符串在 这个字符串中最后一次出现的位置 从右边开始检索
        int index3 = str.lastIndexOf("ring");

        // 返回指定字符串在 这个字符串中指定的位置后出现的位置 从右边开始检索
        int index4 = str.lastIndexOf("ell",2);

        // 正则表达式相关 ---------------------------------------------------

        // 替换字符串中指定的单个字符，     所有s全部替换a
        String replace = str.replace('s', 'a');

        // 替换整个字符串              所有字符串替换
        String string = str.replace("string","hello");

        // 字符是否匹配指定的正则表达式
        boolean matches = str.matches("这里填写正则表达式规则");

        //
        String all = str.replaceAll("regex?","www");

        //
        String all2 = str.replaceAll("regex?","www");

        // 按正则表达式分割字符 全切
        String[] split = str.split("regex");

        // 按个数切,多出的全部放到最后一个
        String[] split2 = str.split("regex",3);

    }
}

常见方法

String - charArray 转换

public class StringTest {
    public static void main(String[] args) {
        String str = "String & charArray";

        // 转字符数组
        char[] chars = str.toCharArray();

        // 转字符串
        String str2 = new String(chars);
    }
}

String - byteArray 转换

public class StringTest {
    public static void main(String[] args) throws UnsupportedEncodingException {
        String str = "String & charArray";

        // 转字节数组 参数默认字符集ASCII
        byte[] bytes = str.getBytes();
        System.out.println(bytes.length + " == " + str.length());
        System.out.println(str);
        for (int i = 0; i < bytes.length; i++) {
            System.out.print(bytes[i] + "\t");
            if (i == bytes.length - 1) System.out.println();
        }

        String zh_cn = "爱我中华！！"; // 汉字占用3个字节 参数设置GBK 汉字占用2个字节
        byte[] bytes1 = zh_cn.getBytes();
        System.out.println(bytes1.length + " == " + zh_cn.length());
        System.out.println(zh_cn);
        for (int i = 0; i < bytes1.length; i++) {
            System.out.print(bytes1[i] + "\t");
            if (i == bytes1.length - 1) System.out.println();
        }

        String s = new String(bytes);
        String s1 = new String(bytes1,"gbk"); // 如果设置的编码不一致，可以传参设置

        System.out.println(s);
        System.out.println(s1);
    }
}

再谈拼接问题

public class StringTest {
    public static void main(String[] args) throws UnsupportedEncodingException {

        String str = "HelloWorld";
        String str2 = "World";  //
        final String str4 = "World";

        String str3 = "Hello" + str2;   // 拼接变量默认做堆空间引用
        String str5 = "Hello" + str4;   // 拼接常量就常量引用

        System.out.println(str == str3);
        System.out.println(str == str5);

        /*
        字符串常量 + 字符串常量 结果还是在常量
        其中一个是变量，结果在堆中
        intern方法从常量池返回
         */
    }
}