String类

String结构剖析

//1.String 对象用于保存字符串，也就是一组字符序列
        // 2. "jack" 字符串常量, 双引号括起的字符序列
        // 3. 字符串的字符使用 Unicode 字符编码，一个字符(不区分字母还是汉字)占两个字节
        // 4. String 类有很多构造器，构造器的重载
        //常用的有 String s1 = new String();
        // String s2 = new String(String original);
        // String s3 = new String(char[] a);
        // String s4 = new String(char[] a,int startIndex,int count)
        // String s5 = new String(byte[] b)
        //5. String 类实现了接口 Serializable【String 可以串行化:可以在网络传输】
        //                接口 Comparable [String 对象可以比较大小]
        //6. String 是 final 类，不能被其他的类继承
        //7. String 有属性 private final char value[]; 用于存放字符串内容
        //8. 一定要注意：value 是一个 final 类型， 不可以修改(需要功力)：即 value 不能指向
        // 新的地址，但是单个字符内容是可以变化
        String name = "jack";
        name = "tom";
        final char value[] = {'a','b','c'};
        char[] v2 = {'t','o','m'}; 
        value[0] = 'H'; 
        //value = v2; 不可以修改 value 地址

String创建

• 两种创建String对象的区别

方式一：直接赋值 String s = "hsp";

方式二：调用构造器 String s2 = new String("hsp");

1. 方式一：先从常量池查看是否有"hsp"数据空间，如果有，直接指向；如果没有则重新创建，然后指向。s最终指向的是常量池的空间地址

2. 方式二：先在堆中创建空间，里面维护了value属性，指向常量池的hsp空间。如果常量池没有"hsp"，重新创建，如果有，直接通过value指向。最终指向的是堆中的空间地址

3. 画出两种方式的内存分布

• 课堂测试题1

String a = "abc";
String b = "abc";
System.out.println(a.equals(b));//T String中equals方法被重写
System.out.println(a == b);//T

• 课堂测试题2

        String a = "hsp";//a指向常量池的"hsp"
        String b = new String("hsp");//b指向堆中对象
        System.out.println(a.equals(b));//比较字符串 True
        System.out.println(a==b);//False
        System.out.println(a==b.intern());//True
        System.out.println(b==b.intern());//False
        //知识点：
        //当调用intern方法时，如果池中已经包含一个等于此String对象的字符串(用equals(Object)方法确定)，
        //则返回池中的字符串。否则，将此String对象添加到池中，并返回此String对象的引用
        //解读：b.intern()方法最终返回的是常量池的地址(对象)

• 课堂测试题3

        String s1 = "hspedu";//指向常量池"hspedu"
        String s2 = "java";//指向常量池"java"
        String s4 = "java";//指向常量池"java"
        String s3 = new String("java");//指向堆中对象，堆中value再指向
        System.out.println(s2==s3);//F
        System.out.println(s2==s4);//T
        System.out.println(s2.equals(s3));//T
        System.out.println(s1==s2);//F

• 课堂测试题4

        Person p1 = new Person();
        p1.name = "hspedu";
        Person p2 = new Person();
        p2.name = "hspedu";
        System.out.println(p1.name.equals(p2.name));//比较内容True
        System.out.println(p1.name == p2.name);//T
        System.out.println(p1.name == "hspedu");//T
        String s1 = new String("bcde");
        String s2 = new String("bcde");
        System.out.println(s1 == s2);//F

String对象特性

        String a = "hello";//创建a对象
        String b = "abc";//创建b对象
        //解读：
        //1.先创建一个StringBuilder sb = StringBuilder()
        //2.执行sb.append("hello");
        //3.sb.append("abc");
        //4.sb.toString
        //最后其实是c指向堆中的对象(String) value[] -> 池中"helloabc"
        String c = a + b;
        String d = "helloabc";
        System.out.println(c == d);//F
//重要规则：String c1 = "ab" + "cd";常量想加，看的是池。String c1 = a+b;变量相加，是在堆中

        String s1 = "hspedu";//s1指向池中的"hspedu"
        String s2 = "java";//s2指向池中的"java"
        String s5 = "hspedujava";//s5指向池中的"hspedujava"
        String s6 = (s1 + s2).intern();//s6指向池中的"hspedujava"
        System.out.println(s5 == s6);//T
        System.out.println(s5.equals(s6));//T

public class StringExercise10 {
    public static void main(String[] args) {
        Test1 ex = new Test1();
        ex.change(ex.str,ex.ch);
        System.out.println(ex.str + "and");
        System.out.println(ex.ch);
    }
}
class Test1{
    String str = new String("hsp");
    final char[] ch = {'j','a','v','a'};
    public void change(String str,char ch[]){
        str = "java";
        ch[0] = 'h';
    }
}

String常用方法

//1. equals 前面已经讲过了. 比较内容是否相同，区分大小写
String str1 = "hello";
String str2 = "Hello";
    System.out.println(str1.equals(str2));//F
    // 2.equalsIgnoreCase 忽略大小写的判断内容是否相等
    String username = "johN";
    if ("john".equalsIgnoreCase(username)) {
        System.out.println("Success!");
    } else {
        System.out.println("Failure!");
    }
    // 3.length 获取字符的个数，字符串的长度
    System.out.println("韩顺平".length());
    // 4.indexOf 获取字符在字符串对象中第一次出现的索引，索引从 0 开始，如果找不到，返回-1
    String s1 = "wer@terwe@g";
    int index = s1.indexOf('@');
    System.out.println(index);// 3
    System.out.println("weIndex="+s1.indexOf("we"));//0
    // 5.lastIndexOf 获取字符在字符串中最后一次出现的索引，索引从 0 开始，如果找不到，返回-1
    s1 ="wer@terwe@g@";
    index =s1.lastIndexOf('@');
    System.out.println(index);//11
    System.out.println("ter 的位置="+s1.lastIndexOf("ter"));//4
    // 6.substring 截取指定范围的子串
    String name = "hello,张三";
    //下面 name.substring(6) 从索引 6 开始截取后面所有的内容
    System.out.println(name.substring(6));//截取后面的字符
    //name.substring(0,5)表示从索引 0 开始截取，截取到索引 5-1=4 位置
    System.out.println(name.substring(2,5));//llo
    }
    

// 1.toUpperCase 转换成大写
    String s = "heLLo";
    System.out.println(s.toUpperCase());//HELLO
    // 2.toLowerCase
            System.out.println(s.toLowerCase());//hello
    // 3.concat 拼接字符串
            String s1 = "宝玉";
            s1 = s1.concat("林黛玉").concat("薛宝钗").concat("together");
            System.out.println(s1);//宝玉林黛玉薛宝钗 together
    // 4.replace 替换字符串中的字符
            s1 = "宝玉 and 林黛玉 林黛玉 林黛玉";
    //在 s1 中，将 所有的 林黛玉 替换成薛宝钗
    // 老韩解读: s1.replace() 方法执行后，返回的结果才是替换过的.
    // 注意对 s1 没有任何影响
            String s11 = s1.replace("宝玉", "jack");
            System.out.println(s1);//宝玉 and 林黛玉 林黛玉 林黛玉
            System.out.println(s11);//jack and 林黛玉 林黛玉 林黛玉
    // 5.split 分割字符串, 对于某些分割字符，我们需要 转义比如 | \\等
            String poem = "锄禾日当午,汗滴禾下土,谁知盘中餐,粒粒皆辛苦";
    //老韩解读：
    // 1. 以 , 为标准对 poem 进行分割 , 返回一个数组
    // 2. 在对字符串进行分割时，如果有特殊字符，需要加入 转义符 \
            String[] split = poem.split(",");
            poem = "E:\\aaa\\bbb";
            split = poem.split("\\\\");
            System.out.println("==分割后内容===");
            for (int i = 0; i < split.length; i++) {
        System.out.println(split[i]);
        }
    // 6.toCharArray 转换成字符数组
        s = "happy";
        char[] chs = s.toCharArray();
        for (int i = 0; i < chs.length; i++) {
        System.out.println(chs[i]);
        }
    // 7.compareTo 比较两个字符串的大小，如果前者大，
    // 则返回正数，后者大，则返回负数，如果相等，返回 0
    // 老韩解读
    // (1) 如果长度相同，并且每个字符也相同，就返回 0
    // (2) 如果长度相同或者不相同，但是在进行比较时，可以区分大小
    //
        // 就返回 if (c1 != c2) {
    //
    //    return c1 - c2;
    //
    //      }
// (3) 如果前面的部分都相同，就返回 str1.len - str2.len
        String a = "jcck";// len = 3
        String b = "jack";// len = 4
        System.out.println(a.compareTo(b)); // 返回值是 'c' - 'a' = 2 的值
        // 8.format 格式字符串
        /* 占位符有:
         * %s 字符串 %c 字符 %d 整型 %.2f 浮点型
         *
         */
        String name = "john";
        int age = 10;
        double score = 56.857;
        char gender = '男';
        //将所有的信息都拼接在一个字符串.
        String info =
        "我的姓名是" + name + "年龄是" + age + ",成绩是" + score + "性别是" + gender + "。希望大家喜欢我！
        ";
        System.out.println(info);
    //解读
    //1. %s , %d , %.2f %c 称为占位符
    //2. 这些占位符由后面变量来替换
    //3. %s 表示后面由 字符串来替换
    //4. %d 是整数来替换//5. %.2f 表示使用小数来替换，替换后，只会保留小数点两位, 并且进行四舍五入的处理
    //6. %c 使用 char 类型来替换
        String formatStr = "我的姓名是%s 年龄是%d，成绩是%.2f 性别是%c.希望大家喜欢我！";
        String info2 = String.format(formatStr, name, age, score, gender);
        System.out.println("info2=" + info2);