String类01 - Java-CSDN博客

本文链接：https://blog.csdn.net/yavlgloss/article/details/134737793

String 类

String 类
1、介绍
2、关系图
3、创建String对象的两种方式
4、字符串的特性
5、String类常用方法
- （1）常用1
- （2）常用2

String 类

1、介绍

String对象用于保存字符串，也就是一组字符序列
字符串常量对象是用双引号括起的字符序列。例如：“你好"、“12.97”、"boy"等
String name = “jack”；中， "jack"是字符串常量，name是变量。
字符串的字符使用Unicode字符编码，一个字符（不区分字母还是汉字）占两个空节
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);

2、关系图

在这里插入图片描述
String实现了 Serializable接口，表示可以串行化，网络输出。
String实现了 Comparable接口，表示 String对象可以比较。
String这个类还是个final类。不能被继承。

String有属性 private final char value[]; 用于存储字符串内容。一定要注意value是一个final类型，赋值之后，不能修改，指的是地址不可以修改，不是指值。即value不能指向新的地址，但是单个字符内容是可以变化。例子如下：

        String name = "jack";
        name = "tom";
        final char[] value = {'a','b','c'};
        value[0] = 'h';

但是不可以这么写：
在这里插入图片描述

3、创建String对象的两种方式

方式一：直接赋值 String s = “hsp”;
方式二：调用构造器 String s = new String(“hsp”);

【重要】两种方式区别：

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

【方式二】
在堆中 new 了一个空间，String类中有一个属性value，value去常量池中找。

4、字符串的特性

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

（1）题目1

以下语句创建了几个对象?画出内存布局图。
String s1 = “hello”;
s1 = “haha”;

分析：
s1直接指向常量池，
字符串是不可以变的（final），s1=“haha”，在常量池寻找是否有"haha"这个字符串，有就指向，没有就重新分配。
所以创建了两个对象。

String a=“hello”+“abc”;
创建了几个对象

（2）题目2

分析：
编译器会优化，优化等价于 String a = “helloabc”;
所以只创建了一个对象。

创建了几个对象？
String a = “hello”;
String b = “abc”;
String c = a+b;

分析：
关键在String c = a+b;到底是怎么执行的。【debug分析】
1、先创建一个 StringBuilder sb = StringBuilder()
2、执行 sb.append(“hello”);
3、sb.append(“abc”);
4、String c= sb.toString()
最后其实是 c 指向堆中的对象(String) value[] -> 池中 “helloabc”
如果现在加一个 String d = “helloabc”，c==d是假

小结：
底层是StringBuilder sb = new StringBuilder(); sb.append(a);sb.append(b); sb是在堆中，并且append是在原来字符串的基础上追加的。
重要规则：
String c1 = “ab” +“cd”;常量相加,看的是池。String c1 =a+b;变量相加,是在堆中。
String e = “hello” + “abc”;//直接看池， e指向常量池 System.out.println(d == e);//真还是假? 是true

（3）题目3

String s1 = “hspedu”;
String s2 = “java”;
String s5 = “hspedujava”;
String s6 = (s1 + s2).intern();
System.out.println(s5 == s6);
System.out.println(s5.equals(s6));

分析：
s1 指向池中的 “hspedu”
s2 指向池中的 “java”
s5 指向池中的 “hspedujava”
s6 intern 方法指向池中的 “hspedujava” 【intern方法查看《String类练习题》】

（4）题目4

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

    }
}

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';
    }

    public static void main(String[] args) {
        Test1 ex = new Test1();
        ex.change(ex.str, ex.ch);
        System.out.print(ex.str + " and ");
        System.out.println(ex.ch);
    }
}

分析：
① 程序从main中进入
② Test1 ex = new Test1(); 在堆中new一个Test1类的对象
③ String str = new String(“hsp”); new一个String类的对象，里面有一个属性value，指向方法区常量池中的"hsp"。
④ final char[] ch = {‘j’, ‘a’, ‘v’, ‘a’}; 这个ch是Test1对象的属性。ch是一个数组，默认情况方法在堆中。
⑤ ex.change(ex.str, ex.ch); 调用方法会产生新栈。
⑥ 【非常重要！重点理解！】 public void change(String str, char ch[])
由于参数传递规则，在change方法栈中，刚开始 str = ex.str (堆中的空间)。str = value。
str=“java”; value是final，不可以改变它指向的地址。str是String类型，final，指向了常量池中的java。
ch[0]=‘h’，修改了字符数组的第一个元素的值。
数组是引用数据类型，引用数据类型final是地址不能变，不是值不能变。
⑦【输出】hsp and hava.

p=473，不理解的话跳转链接看韩老师讲解。
在这里插入图片描述

5、String类常用方法

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

请分析代码：

String s = new String("");
for(int i = 0; i < 80000; i++) {
	s += "hello";
}

麻烦：s += “hello”; 每次修改都会开辟新的空间

（1）常用1

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

//1. equals 前面已经讲过了. 比较内容是否相同，区分大小写
String str1 = "hello";
String str2 = "Hello";
System.out.println(str1.equals(str2));//False 

// 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位置
//name.substring(2,5)表示从索引2开始截取，截取到索引 5-1=4位置
System.out.println(name.substring(2,5));//llo

（2）常用2

toUpperCase
toLowerCase
concat
replace 替换字符串中的字符
split 分割字符串，对于某些分割字符，我们需要转义比如：等

| \\

【案例】：String poem =“锄禾日当午,汗滴禾下土,谁知盘中餐,粒粒皆辛苦”;和文件路径

compareTo // 比较两个字符串的大小
toCharArray // 转换成字符数组
format // 格式字符串，%s字符串，%c字符，%d整型，%.2f 浮点型
【案例】：将一个人的信息格式化输出

// 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 林黛玉 林黛玉 林黛玉";
String s11 = s1.replace("宝玉", "jack");
System.out.println(s1);//宝玉 and 林黛玉 林黛玉 林黛玉
System.out.println(s11);//宝玉 and 薛宝钗 薛宝钗 薛宝钗
// 在s1中，将 所有的 林黛玉 替换成薛宝钗
// 解读: s1.replace() 方法执行后，返回的结果才是替换过的.
// 注意对 s1没有任何影响

// 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
// 先比较内容(两个字符串前缀有相同的部分)，返回不同字母ascitc码值之差，字母相同比较不了就再比较数组长度，返回数组长度之差。
String a = "jcck";// len = 3
String b = "jack";// len = 4
System.out.println(a.compareTo(b)); // 返回值是 'c' - 'a' = 2的值
// "jcck"-"jack" 长度相等 = 'c'-'a' = 2
// "jac"-"jack" 长度不等 = len1-len2 = -1
// "jc" - "jack" =  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);

//另一种方法
String formatStr = "我的姓名是%s 年龄是%d，成绩是%.2f 性别是%c.希望大家喜欢我！";
String info2 = String.format(formatStr, name, age, score, gender);
System.out.println("info2=" + info2);
//解读
//1. %s , %d , %.2f %c 称为占位符
//2. 这些占位符由后面变量来替换
//3. %s 表示后面由 字符串来替换
//4. %d 是整数来替换
//5. %.2f 表示使用小数来替换，替换后，只会保留小数点两位, 并且进行四舍五入的处理
//6. %c 使用char 类型来替换