Java进阶——String字符串（2）

目录

一、字符串使用方法

二、intern（）用法

三、包装类

1.包装类

valueOf() 类方法

---

一、字符串使用方法

字符串不可变, 字符串内容存储内容的元素是 final 修饰的所以不可变

public static void main(String[] args) {
        /*
            字符串不可变, 字符串内容存储内容的元素是 final 修饰的所以不可变
         */
        String str = "hello";
        String str1 = "hello";
​
        System.out.println(str == str1);
​
        // 创建了几个对象
        String s1 = new String("abc");
​
        byte b = 123;
        Character c = '你';
​
        System.out.println("你".getBytes().length);
​
        String s = "1";
        for (int i = 0; i < 10; i++) {
            s += i;
        }
    }
}

public class Demo06 {
​
    public static void main(String[] args) {
        String str = "hello";
​
        // 字符串拼接
//        str = str.concat(" world");
        str = str + " world";
        System.out.println(str);
        // 字符串只能做 + 操作,表示拼接。任何类型的元素和字符串做 + 操作都字符串的拼接
        String s = 1 + 1 + "1" + 1 + 1;
//        String s = new Person("张三", '男', 20, false) + str;
        System.out.println(s);// 2111 212
​
​
        // 判断是否包含
        boolean contains = str.contains("hello world");
        System.out.println(contains);
​
        // 是否以某个字符串结尾
        String email = "xxxx@qq.com";
        boolean end = email.endsWith(".com");
        System.out.println(end);
​
        // 是否以某个字符串开头
        boolean start = email.startsWith("xxx");
        System.out.println(start);
​
        // 子串在字符串中第一次出现的位置(下标), -1 表示没出现
        int index = str.indexOf("e");
        System.out.println(index);
​
        int hello = str.indexOf("le");
        System.out.println(hello); // -1
​
        // 从 fromIndex开始第一次出现的下标
        index = str.indexOf("l", 3);
        System.out.println(index);
​
        // 最后一次出现的位置
        index = str.lastIndexOf("l");
        System.out.println(index); // 9
​
        str = """
            先天下之忧而忧，
            后天下之乐而乐。
            """;
        System.out.println(str);
        s = str.indent(2);
        System.out.println(s);
​
        // 分隔字符串
        str = "1-2-3-4-5-6";
        String[] strs = str.split("-");
        System.out.println(Arrays.toString(strs));
​
​
        str = "1.2.3.4.5.6";
        strs = str.split("\\.");
        System.out.println(Arrays.toString(strs));
​
        str = "123456";
        char[] chs = str.toCharArray();
        strs = str.split("");
        System.out.println(Arrays.toString(strs));
​
        str = "--1-2-3-4-5-6------";
        strs = str.split("-");
        System.out.println(Arrays.toString(strs));
​
        // 合并 static方法
        str = String.join(".", "a", "b", "c", "d");
        System.out.println(str);
​
        // 重复
        str = "666";
        str = str.repeat(3);
        System.out.println(str);
​
        // 替换
        str = "abcdabcd";
//        str = str.replace("a","A");
        str = str.replaceFirst("a", "A");
        System.out.println(str);
​
​
        // 格式化
        str = "我是%s".formatted("张三");
        System.out.println(str);
​
        // 占位符 %s 字符串  %b boolean %c char  %d integer  %f 浮点数
        str = """
                我是%s
                我说%s
                """.formatted("秦始皇", "打钱");
        System.out.println(str);
​
​
        str = String.format("我今年%d岁", 23);
        System.out.println(str);
​
    }
}

二、intern（）用法

intern 如果字符串在常量池中有就返回常量池中的对象，如果没有就将对

象放入常量池中,并将这个对象返回.

public class Demo07 {
​
    public static void main(String[] args) {
        /*
         intern 如果字符串在常量池中有就返回常量池中的对象，
                如果没有就将对象放入常量池中,并将这个对象返回
         */
​
//        String str = "你好啊";
//
//
//        System.out.println(str);
//        System.out.println(System.identityHashCode(str));
//
//        String s = new String("你好啊").intern();
//
//        System.out.println(System.identityHashCode(s));
​
        // 1.
//        String str = "abc";
//
//        String s = new String("abc");
//
//        String s1 = s.intern();
//
//        System.out.println(str == s); // false
//        System.out.println(str == s1); // true
//        System.out.println(s == s1); // false
​
          // 2.
//        String s = new String("abc");
//
//        String s1 = s.intern();
//
//        String str = "abc";
//
//        System.out.println(str == s); // false
//        System.out.println(str == s1); // true
//        System.out.println(s == s1); // false
​
          // 3.
//        String  a = "a";
//        String s = new String(a + "bc");
//
//        String s1 = s.intern();
//
//        String str = "abc";
//
//        System.out.println(str == s); //  true
//        System.out.println(str == s1); // true
//        System.out.println(s == s1); //   true
​
​
        // 4.
        String  a = "a";
        String s = new String(a + "bc");
​
        String str = "abc";
​
        String s1 = s.intern();
​
​
        System.out.println(str == s); //  false
        System.out.println(str == s1); // true
        System.out.println(s == s1); //   false
​
    }
}

三、包装类

1.包装类

自动装箱操作是通过 包装类.valueOf 进行的

自动拆箱操作是通过 包装类对象.xxxValue() 进行

1. valueOf() 类方法

   有很多重载方法。涵盖了所有的数据类型转换 字符串的方法；

   字符串 <---> 基本数据类型

public class Demo08 {
​
    public static void main(String[] args) {
        /*
               valueOf() 类方法，有很多重载方法。涵盖了所有的数据类型转换 字符串的方法；
​
               字符串 <---> 基本数据类型
         */
        // 任意类型转换为字符串
        byte b = 1;
        String str = String.valueOf(b);
        String.valueOf(true);
        String.valueOf(1.1);
​
        // int <---> String
​
        // 字符串 --> int  包装类.valueOf
        Integer a = Integer.valueOf("11");
        Integer.parseInt("11");
        System.out.println(a);
        // int  --> 字符串  String.valueOf()
        String s = String.valueOf(a);
    }
}

public class Demo09 {
​
    public static void main(String[] args) {
        /*
            包装类
                自动装箱操作是通过 包装类.valueOf 进行的
                自动拆箱操作是通过 包装类对象.xxxValue() 进行
            包装类结构
         */
​
        Integer a = 1;
        int b = a;
//        Integer n = Integer.valueOf(1);
//        Integer num = new Integer(1);
//        Integer num1 = new Integer("12");
​
        Integer num = 100;//  Integer.valueOf(100)
        Integer num1 = 100; // Integer.valueOf(100)
​
        System.out.println(num == num1);
​
        num = 200; // new Integer()
        num1 = 200; // new Integer();
        System.out.println(num == num1);
​
        // Byte  Short Character(0~127)  Integer Long 都有缓存对象数组
        Character c = '(';
​
        System.out.println(Character.isMirrored('['));
​
​
​
    }
}

四、StringBuffer、 StringBuilder

StringBuffer 和 StringBuilder 都是继承自抽象类 AbstractStringBuilder

StringBuffer 从 jdk1.0 开始就提供了，而StringBuilder 是jdk1.5才提供的

两个类大部分实现都一样, 不同点在于 StringBuffer 中大部分方法都有 synchronized 修饰synchronized 表

示同步，修饰的方法表示同步方法。是多线程中一种线程安全的实现方法。

StringBuffer 是线程安全的类，

StringBuilder是非线程安全的

String 不可变，是线程安全

执行效率 StringBuilder 相对较高.

public class StringBuilderDemo {
​
    public static void main(String[] args) {
​
        // 16个长度的字符构建器
        StringBuilder sb = new StringBuilder();
        // 创建指定长度的 StringBuilder 对象
        sb = new StringBuilder(3);
        // 创建指定内容的 StringBuilder 对象
//        sb = new StringBuilder("hello");
​
        System.out.println(sb.capacity());
​
        // 修改 StringBuilder 内容
        sb.append("a");
        sb.append("b");
​
        // 链式调用
        sb.append("c").append("d").append("e");
​
        // 删除某个位置
//        sb.deleteCharAt(0);
        // 删除某个范围
//        sb.delete(0, 2);
​
        sb.insert(3, "A");
​
        // 数组长度 arr.length 字符串 str.length()
//        System.out.println(sb.length());
​
​
​
        // StringBuilder --> String
        String str = sb.toString();
        System.out.println(str);
        System.out.println(sb.capacity());
​
        sb.reverse();
        System.out.println(sb.toString());
    }
}