String类基本使用

文章目录

1. String类的理解和创建对象
2. 创建String对象的两种方式
3. 两种创建String对象的区别
4. 测试
5. 字符串的特性
6. String 类的常见方法

1. String类的理解和创建对象

String 对象用于保存字符串，也就是一组字符序列
字符串常量对象是用双引号括起的字符序列。例如：“你好”、“12.97”、"boy"等
字符串的字符使用Unicode字符编码
String类较常用构造器：一个字符(不区分字母还是汉字)占两个字节

String s1 = new String();
String s2 = new String(String original);
String s3 = new String(char[] a);
String s4 = new String(char[] a, intstartIndex, intcount);
String s5 = new String(byte[] b);

在这里插入图片描述

public static void main(String[] args) {
 //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地址
}

2. 创建String对象的两种方式

方式1：直接赋值 String s = “兮动人”;
方式2：调用构造器 String s = new String(“xdr”);

3. 两种创建String对象的区别

方式一：直接赋值 String s = "xdr";
方式二：调用构造器 String s2 = new String("xdr”):

方式一：先从常量池查看是否有“xdr”数据空间，如果有，直接指向；如果
没有则重新创建，然后指向。s最终指向的是常量池的空间地址
方式二：先在堆中创建空间，里面维护了value属性，指向常量池的xdr空间
如果常量池没有”xdr”，重新创建，如果有，直接通过value指向。最终指向的是堆中的空间地址
画出两种方式的内存分布图

在这里插入图片描述

4. 测试

测试1

String a = "abc";
String b = "abc";
System.out.println(a.equals(b)); // T
System.out.println(a == b);     // T

测试2

String a = new String("abc");
String b = new String("abc");
System.out.println(a.equals(b)); // T
System.out.println(a == b); // F

测试3

String a="xdr"; // a指向常量池的 "xdr"
String b=new String("xdr"); // b指向堆中对象
System.out.println(a.equals(b)); // T
System.out.println(a==b); // F
System.out.println(a==b.intern()); // T
System.out.println(b==b.intern()); // F

当调用intern方法时，如果池已经包含一个等于此String对象的字符串（用equals(Object）方法确定），则返回池中的字符串。否则，将此String对象添加到池中，并返回此String对象的引用
b.intern(方法最终返回的是常量池的地址（对象）
测试4

public class StringExercise04 {

    public static void main(String[] args) {
        String s1 = "xdr630"; // 指向常量池 xdr630
        String s2 = "java"; // 指向常量池 java
        String s3 = new String("java"); // 指向堆栈中的对象
        String s4 = "java"; // 指向常量池 java
        System.out.println(s1 == s2); // false
        System.out.println(s2 == s3); // false
        System.out.println(s2.equals(s3)); // true
        System.out.println(s2 == s4); // true
    }
}

测试5

public class StringExercise05 {

    public static void main(String[] args) {
        Person p1 = new Person();
        p1.name = "xdr630";
        Person p2 = new Person();
        p2.name = "xdr630";

        System.out.println(p1.name.equals(p2.name)); // 比较内容：true
        System.out.println(p1.name == p2.name); // true
        System.out.println(p1.name == "xdr630"); // true

        String s1 = new String("xdr");
        String s2 = new String("xdr");
        System.out.println(s1 == s2); // false
    }

}

5. 字符串的特性

String是一个final类，代表不可变的字符序列
字符串是不可变的。一个字符串对象一旦被分配，其内容是不可变的

6. String 类的常见方法

String类是保存字符串常量的。每次更新都需要重新开辟空间，效率较低，因
此java设计者还提供了StringBuilder和StringBuffer来增强String的功能
并提高效率。

String类的常见方法1

equals//区分大小写，判断内容是否相等
equalslgnoreCase//忽略大小写的判断内容是否相等
length//获取字符的个数，字符串的长度
indexOf//获取字符在字符串中第1次出现的索引，索引从0开始，如果找不到，返回-1
lastlndexOf//获取字符在字符串中最后1次出现的索引，索引从o开始，如找不到，返回-1
substring//截取指定范围的子串
trim//去前后空格
charAt:获取某索引l处的字符，注意不能使用Str[index]这种方式

public class StringMethod01 {
    public static void main(String[] args) {
        //1. equals 前面已经讲过了. 比较内容是否相同，区分大小写
        String str1 = "hello";
        String str2 = "Hello";
        System.out.println(str1.equals(str2));//

        // 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

    }
}

在这里插入图片描述

String类的常见方法2

toUpperCase
toLowerCase
concat
replace替换字符串中的字符
split分割字符串，对于某些分割字符，我们需要转义比如|\等
案例：Stringpoem=“锄禾日当午，汗滴禾下土，谁知盘中餐，粒粒皆辛苦”；和文
件路径.
compareTo//比较两个字符串的大小
toCharArray//转换成字符数组
format//格式字符串，%s字符串%c字符%d整型%.2f浮点型

案例，将一个人的信息格式化输出

public class StringMethod02 {
    public static void main(String[] args) {
        // 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 = "xdr630";
        int age = 27;
        double score = 96.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);
    }
}