Java字符串JVM结构分析

最新推荐文章于 2024-03-26 12:45:31 发布

人畜无害的萌新史莱姆

最新推荐文章于 2024-03-26 12:45:31 发布

阅读量295

点赞数 1

分类专栏： java 文章标签： java

本文链接：https://blog.csdn.net/qq_38762390/article/details/119897019

版权

java 专栏收录该内容

23 篇文章 0 订阅

订阅专栏

1、字符串String类（型）本身是final声明的，即不能继承String类。
2、字符串对象也是不可变对象，意味着一旦修改，即产生新的对象。
3、String对象内部是用字符数组保存的。

JDK1.9之前有一个char[] value数组，JDK1.9之后byte[]数组

"abc" 等效于 char[] data={ 'a' , 'b' , 'c' }。
4、因为字符串对象设计为不可变，所以字符串有常量池来保存很多常量对象。
常量池在方法区。

如果细致的划分：
（1）JDK1.6及其之前：方法区
（2）JDK1.7：堆
（3）JDK1.8：元空间

示例一

使用String str1 = “abc”;创建字符串，存储结构

在方法区创建对象 abc
在栈指向方法区对象（引用）
方法区对象可以被共享

String s1 = "abc"; //在常量池中
String s2 = "abc";
System.out.println(s1 == s2);
// 内存中只有一个"abc"对象被创建，同时被s1和s2共享。

在这里插入图片描述

示例二

如果使用String str2 = new String(“www”);创建字符串，存储结构

首先在方法区创建对象 www
在堆创建方法对象副本 www
方法区对象和堆里面指向同一个数组
在栈在栈指向堆对象（引用）

String str = new String("www");
//str首先指向堆中的一个字符串对象，然后堆中字符串的value数组指向常量池中常量对象的value数组
//实际创建了2个数组

在这里插入图片描述
字符串拼接
原则：

（1）常量+常量：结果是常量池

（2）常量与变量或变量与变量：结果是堆

（3）拼接后调用intern方法：结果在常量池

（4）concat方法拼接，哪怕是两个常量对象拼接，结果也是在堆。

	@Test
	public void test06(){
		String s1 = "hello";
		String s2 = "world";
		String s3 = "helloworld";
		
		String s4 = (s1 + "world").intern();//把拼接的结果放到常量池中
		String s5 = (s1 + s2).intern();
		
		System.out.println(s3 == s4);//true
		System.out.println(s3 == s5);//true
	}
	
	@Test
	public void test05(){
		final String s1 = "hello";
		final String s2 = "world";
		String s3 = "helloworld";
		
		String s4 = s1 + "world";//s4字符串内容也helloworld，s1是常量，"world"常量，常量+ 常量 结果在常量池中
		String s5 = s1 + s2;//s5字符串内容也helloworld，s1和s2都是常量，常量+ 常量 结果在常量池中
		String s6 = "hello" + "world";//常量+ 常量 结果在常量池中，因为编译期间就可以确定结果
		
		System.out.println(s3 == s4);//true
		System.out.println(s3 == s5);//true
		System.out.println(s3 == s6);//true
	}
	
	@Test
	public void test04(){
		String s1 = "hello";
		String s2 = "world";
		String s3 = "helloworld";
		
		String s4 = s1 + "world";//s4字符串内容也helloworld，s1是变量，"world"常量，变量 + 常量的结果在堆中
		String s5 = s1 + s2;//s5字符串内容也helloworld，s1和s2都是变量，变量 + 变量的结果在堆中
		String s6 = "hello" + "world";//常量+ 常量 结果在常量池中，因为编译期间就可以确定结果
		
		System.out.println(s3 == s4);//false
		System.out.println(s3 == s5);//false
		System.out.println(s3 == s6);//true
	}

public class TestString {
	public static void main(String[] args) {
		String str = "hello";
		String str2 = "world";
		String str3 ="helloworld";
		
		String str4 = "hello".concat("world");
		String str5 = "hello"+"world";
		
		System.out.println(str3 == str4);//false
		System.out.println(str3 == str5);//true
	}
}

附：

字符串的常用方法

1、系列1

（1）boolean isEmpty()：字符串是否为空

（2）int length()：返回字符串的长度

（3）String concat(xx)：拼接，等价于+

（4）boolean equals(Object obj)：比较字符串是否相等，区分大小写

（5）boolean equalsIgnoreCase(Object obj)：比较字符串是否相等，区分大小写

（6）int compareTo(String other)：比较字符串大小，区分大小写，按照Unicode编码值比较大小

（7）int compareToIgnoreCase(String other)：比较字符串大小，不区分大小写

（8）String toLowerCase()：将字符串中大写字母转为小写

（9）String toUpperCase()：将字符串中小写字母转为大写

（10）String trim()：去掉字符串前后空白符

	@Test
	public void test01(){
		//将用户输入的单词全部转为小写，如果用户没有输入单词，重新输入
		Scanner input = new Scanner(System.in);
		String word;
		while(true){
			System.out.print("请输入单词：");
			word = input.nextLine();
			if(word.trim().length()!=0){
				word = word.toLowerCase();
				break;
			}
		}
		System.out.println(word);
	}

	@Test
	public void test02(){
        //随机生成验证码，验证码由0-9，A-Z,a-z的字符组成
		char[] array = new char[26*2+10];
		for (int i = 0; i < 10; i++) {
			array[i] = (char)('0' + i);
		}
		for (int i = 10,j=0; i < 10+26; i++,j++) {
			array[i] = (char)('A' + j);
		}
		for (int i = 10+26,j=0; i < array.length; i++,j++) {
			array[i] = (char)('a' + j);
		}
		String code = "";
		Random rand = new Random();
		for (int i = 0; i < 4; i++) {
			code += array[rand.nextInt(array.length)];
		}
		System.out.println("验证码：" + code);
		//将用户输入的单词全部转为小写，如果用户没有输入单词，重新输入
		Scanner input = new Scanner(System.in);
		System.out.print("请输入验证码：");
		String inputCode = input.nextLine();
		
		if(!code.equalsIgnoreCase(inputCode)){
			System.out.println("验证码输入不正确");
		}
	}

2、系列2：查找

（11）boolean contains(xx)：是否包含xx

（12）int indexOf(xx)：从前往后找当前字符串中xx，即如果有返回第一次出现的下标，要是没有返回-1

（13）int lastIndexOf(xx)：从后往前找当前字符串中xx，即如果有返回最后一次出现的下标，要是没有返回-1

	@Test
	public void test01(){
		String str = "尚硅谷是一家靠谱的培训机构，尚硅谷可以说是IT培训的小清华，JavaEE是尚硅谷的当家学科，尚硅谷的大数据培训是行业独角兽。尚硅谷的前端和运维专业一样独领风骚。";
		System.out.println("是否包含清华：" + str.contains("清华"));
		System.out.println("培训出现的第一次下标：" + str.indexOf("培训"));
		System.out.println("培训出现的最后一次下标：" + str.lastIndexOf("培训"));
	}

3、系列3：字符串截取

（14）String substring(int beginIndex) ：返回一个新的字符串，它是此字符串的从beginIndex开始截取到最后的一个子字符串。

（15）String substring(int beginIndex, int endIndex) ：返回一个新字符串，它是此字符串从beginIndex开始截取到endIndex(不包含)的一个子字符串。

	@Test
	public void test01(){
		String str = "helloworldjavaatguigu";
		String sub1 = str.substring(5);
		String sub2 = str.substring(5,10);
		System.out.println(sub1);
		System.out.println(sub2);
	}

	@Test
	public void test02(){
		String fileName = "快速学习Java的秘诀.dat";
		//截取文件名
		System.out.println("文件名：" + fileName.substring(0,fileName.lastIndexOf(".")));
		//截取后缀名
		System.out.println("后缀名：" + fileName.substring(fileName.lastIndexOf(".")));
	}

4、系列4：和字符相关

（16）char charAt(index)：返回[index]位置的字符

（17）char[] toCharArray()：将此字符串转换为一个新的字符数组返回

（18）String(char[] value)：返回指定数组中表示该字符序列的 String。

（19）String(char[] value, int offset, int count)：返回指定数组中表示该字符序列的 String。

（20）static String copyValueOf(char[] data)：返回指定数组中表示该字符序列的 String

（21）static String copyValueOf(char[] data, int offset, int count)：返回指定数组中表示该字符序列的 String

（22）static String valueOf(char[] data, int offset, int count) ：返回指定数组中表示该字符序列的 String

（23）static String valueOf(char[] data) ：返回指定数组中表示该字符序列的 String

	@Test
	public void test01(){
		//将字符串中的字符按照大小顺序排列
		String str = "helloworldjavaatguigu";
		char[] array = str.toCharArray();
		Arrays.sort(array);
		str = new String(array);
		System.out.println(str);
	}
	
	@Test
	public void test02(){
		//将首字母转为大写
		String str = "jack";
		str = Character.toUpperCase(str.charAt(0))+str.substring(1);
		System.out.println(str);
	}

5、系列5：编码与解码

（24）byte[] getBytes()：编码，把字符串变为字节数组，按照平台默认的字符编码进行编码

byte[] getBytes(字符编码方式)：按照指定的编码方式进行编码

（25）new String(byte[] ) 或 new String(byte[], int, int)：解码，按照平台默认的字符编码进行解码

new String(byte[]，字符编码方式 ) 或 new String(byte[], int, int，字符编码方式)：解码，按照指定的编码方式进行解码

	/*
	 * GBK，UTF-8，ISO8859-1所有的字符编码都向下兼容ASCII码
	 */
	public static void main(String[] args) throws Exception {
		String str = "中国";
		System.out.println(str.getBytes("ISO8859-1").length);// 2
		// ISO8859-1把所有的字符都当做一个byte处理，处理不了多个字节
		System.out.println(str.getBytes("GBK").length);// 4 每一个中文都是对应2个字节
		System.out.println(str.getBytes("UTF-8").length);// 6 常规的中文都是3个字节

		/*
		 * 不乱码：（1）保证编码与解码的字符集名称一样（2）不缺字节
		 */
		System.out.println(new String(str.getBytes("ISO8859-1"), "ISO8859-1"));// 乱码
		System.out.println(new String(str.getBytes("GBK"), "GBK"));// 中国
		System.out.println(new String(str.getBytes("UTF-8"), "UTF-8"));// 中国
	}

6、系列6：开头与结尾

（26）boolean startsWith(xx)：是否以xx开头

（27）boolean endsWith(xx)：是否以xx结尾

	@Test
	public void test2(){
		String name = "张三";
		System.out.println(name.startsWith("张"));
	}
	
	@Test
	public void test(){
		String file = "Hello.txt";
		if(file.endsWith(".java")){
			System.out.println("Java源文件");
		}else if(file.endsWith(".class")){
			System.out.println("Java字节码文件");
		}else{
			System.out.println("其他文件");
		}
	}

7、系列7：正则匹配

（28）boolean matchs(正则表达式)：判断当前字符串是否匹配某个正则表达式

常用正则表达式：

字符类

[abc]：a、b 或 c（简单类）

[^abc]：任何字符，除了 a、b 或 c（否定）

[a-zA-Z]：a 到 z 或 A 到 Z，两头的字母包括在内（范围）

预定义字符类

.：任何字符（与行结束符可能匹配也可能不匹配）

\d：数字：[0-9]

\D：非数字： [^0-9]

\s：空白字符：[ \t\n\x0B\f\r]

\S：非空白字符：[^\s]

\w：单词字符：[a-zA-Z_0-9]

\W：非单词字符：[^\w]

边界匹配器

^：行的开头

$：行的结尾

Greedy 数量词

X?：X，一次或一次也没有

X*：X，零次或多次

X+：X，一次或多次

X{n}：X，恰好 n 次

X{n,}：X，至少 n 次

X{n,m}：X，至少 n 次，但是不超过 m 次

Logical 运算符

XY：X 后跟 Y

X|Y：X 或 Y

(X)：X，作为捕获组

	@Test
	public void test1(){
		//简单判断是否全部是数字，这个数字可以是1~n位
		String str = "12a345";
		
		//正则不是Java的语法，它是独立与Java的规则
		//在正则中\是表示转义，
		//同时在Java中\也是转义
		boolean flag = str.matches("\\d+");
		System.out.println(flag);
	}
	
	@Test
	public void test2(){
		String str = "123456789";
		
		//判断它是否全部由数字组成，并且第1位不能是0，长度为9位
		//第一位不能是0，那么数字[1-9]
		//接下来8位的数字，那么[0-9]{8}+
		boolean flag = str.matches("[1-9][0-9]{8}+");
		System.out.println(flag);
	}

1.验证用户名和密码，第一个字必须为字母，一共6~16位字母数字下划线组成：（"¹\w{5,15}$"）

2.验证电话号码：（"^(\d{3,4}-)\d{7,8}$"）正确格式：xxx/xxxx-xxxxxxx/xxxxxxxx

3.验证手机号码：("^1[3|4|5|7|8][0-9]{9}$")

4.验证身份证号（15位）：("\d{14}[[0-9],0-9xX]")，（18位）：("\d{17}(\d|X|x)")

5.验证Email地址：("^\w+([-+.]\w+)@\w+([-.]\w+).\w+([-.]\w+)*$")

6.只能输入由数字和26个英文字母组成的字符串：("²+$")

7.整数或者小数：("³+([.][0-9]+){0,1}$")

8、系列8：替换

（29）String replace(xx,xx)：不支持正则

（30）String replaceFirst(正则，value)：替换第一个匹配部分

（31）String repalceAll(正则， value)：替换所有匹配部分

	@Test
	public void test4(){
		String str = "hello244world.java;887";
		//把其中的非字母去掉
		str = str.replaceAll("[^a-zA-Z]", "");
		System.out.println(str);
	}

9、系列9：拆分

（32）String[] split(正则)：按照某种规则进行拆分

	@Test
    public void test4(){
    	String str = "张三.23|李四.24|王五.25";
    	//|在正则中是有特殊意义，我这里要把它当做普通的|
    	String[] all = str.split("\\|");
    	
    	//转成一个一个学生对象
    	Student[] students = new Student[all.length];
    	for (int i = 0; i < students.length; i++) {
    		//.在正则中是特殊意义，我这里想要表示普通的.
    		String[] strings = all[i].split("\\.");//张三,  23
    		String name = strings[0];
    		int age = Integer.parseInt(strings[1]);
    		students[i] = new Student(name,age);
    	}
    	
    	for (int i = 0; i < students.length; i++) {
    		System.out.println(students[i]);
    	}
    	
    }
    
    @Test
    public void test3(){
    	String str = "1Hello2World3java4atguigu5";
    	str = str.replaceAll("^\\d|\\d$", "");
    	String[] all = str.split("\\d");
    	for (int i = 0; i < all.length; i++) {
    		System.out.println(all[i]);
    	}
    }
    
    @Test
    public void test2(){
    	String str = "1Hello2World3java4atguigu";
    	str = str.replaceFirst("\\d", "");
    	System.out.println(str);
    	String[] all = str.split("\\d");
    	for (int i = 0; i < all.length; i++) {
    		System.out.println(all[i]);
    	}
    }
    
    @Test
    public void test1(){
    	String str = "Hello World java atguigu";
    	String[] all = str.split(" ");
    	for (int i = 0; i < all.length; i++) {
    		System.out.println(all[i]);
    	}
    }

### 10.3.9  相关面试题

1、面试题：字符串的length和数组的length有什么不同？

字符串的length()，数组的length属性

2、字符串对象不可变

```

a-zA-Z ↩︎
A-Za-z0-9 ↩︎
0-9 ↩︎

人畜无害的萌新史莱姆

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java字符串JVM结构分析

1、字符串String类（型）本身是final声明的，即不能继承String类。2、字符串对象也是不可变对象，意味着一旦修改，即产生新的对象。3、String对象内部是用字符数组保存的。JDK1.9之前有一个char[] value数组，JDK1.9之后byte[]数组"abc" 等效于 char[] data={ 'a' , 'b' , 'c' }。4、因为字符串对象设计为不可变，所以字符串有常量池来保存很多常量对象。常量池在方法区。如果细致的划分：（1）JDK1.6及其之前：方法区
复制链接

扫一扫

专栏目录