第二章：String类

系列文章目录

---

---

前言

Sting类是常量字符串的包装类。

---

一、String类

1.1 String 类的理解和创建对象

public class String01 {
	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 地址
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

1.2 创建 String 对象的两种方式

1.3 两种创建 String 对象的区别

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

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


String a = "abc";
String b = new String("abc");
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对象的引用。
//intern()方法最终返回的是常量池的地址


Person p1 = new Person();
p1.name = "jack";
Person p2 = new Person();
p2.name = "jack";

System.out.println(p1.name.equals(p2.name));//true
System.out.println(p1.name == p2.name);//true
System.out.prinltn(p1.name == "jack");//true

String s1 = new String("jack");
String s2 = new String("jack");
System.out.println(s1==s2);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

二、字符串的特性

String s1 = "hello";
s1 = "hahaha";
//创建了2个对象

String a = "hello" + "world";
//创建了1个对象

String a = "hello";
String b = "world";
//1.先创建一个 StringBuilder sb = StringBuilder();
//2.执行sb.append("hello");
//3.执行sb.append("world");
//4.String c = sb.toString();
//最后其实是C指向堆中的对象(String)value[] -> 池中 "helloworld"
String c = a+ b;
//创建了3个对象
String d = new String("helloworld");
System.out.println(c == d);//false

String s1 = "hello";
String s2 = "world";
String s3 = "helloworld";//指向池中“helloworld"
String s4 = (s1 + s2).intern();//指向池中"helloworld"
System.out.println(s3 == s4);//true
System.out.println(s3.euqals(s4));//ture

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

public class Test1
{
	String str = new String("jack");
	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 Test();
		ex.change(ex.str, ex.ch);
		System.out.print(ex.str + "and");
		System.out.println(ex.ch);
	}
}
//输出"jack and hava"

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

三、String 类的常见方法

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

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
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

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 = "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);
		
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84

---

总结

String类可以完成字符串数据的处理。