Java小白一文简单普及Java中的String关键字

Kerwin要坚持日更

于 2024-08-20 19:34:37 发布

阅读量293

点赞数 9

分类专栏： JavaSE 文章标签： java 开发语言

本文链接：https://blog.csdn.net/Kerwin_D/article/details/141366547

版权

JavaSE 专栏收录该内容

11 篇文章 0 订阅

订阅专栏

String类

String对象用于保存字符串，也就是一组字符序列
字符串常量对象是用双引号括起的字符序列，例如 “Kerwin”
字符串的字符使用Unicode字符编码，一个字符（不区分字母还是汉字）占两个字节
String类较常用构造方法

String s1 = new String();

String s2 = new String(String original);

String s3 = new String(char[] a);

String s4 = new String(char[] ,int startIndex,int count);

String 实现了Serializable和Comparable 接口，说明String可以串行化，String对象可以比较大小

可串行化：可以在网络传输

String是final 类，不能被其他的类继承
String有属性private final char value[]; 用于存放字符串内容
一定要注意： value 是一个final类型，赋值之后不可修改；
- 这里的不可修改是指地址不可修改，不是指字符串内容不可修改，即value不能指向新的地址，但是单个字符内容是可以变化

        final char[] value = {'a','b','c'};
        value[0]= 'H';//这样修改value数组中的值是可以的，不会报错
        char[] value2 = {'t','o','m'};//再创建一个char数组
//        value = value2;//此时就会报错，不能再value指向新的数组了
        //但是，如果把上面的final去掉，则上面的语句不会报错

在这里插入图片描述

创建String 对象的两种方式

直接赋值String s = “essence”；
- 先从常量池查看是否有“essence”数据空间，如果有，直接指向；如果没有则重新创建，
  
  然后指向，s 最终指向的是常量池中的空间地址
调用构造器String s = new String(“essence”)；
- 先在堆中创建空间，里面维护了value属性，指向了常量池中的“essence”空间，如果常量池中没有“essence”，
  
  重新创建，如果有，直接通过value指向，最终指向的是堆中的空间地址

练习

在这里插入图片描述

//输出如下
true  //String已经重写了equals方法，所以二者内容相同，返回true
true  //a和b二者都是先到常量池去看有没有“abc”,发现有，则二者指向的地址是一样的，所以return  true

在这里插入图片描述

//输出如下
true  //重写equals后，比较的是内容，二者内容相同，所以true
false	//二者指向的地址不同
true
false
    String a = "hsp";// a 指向常量池中的“hsp”;
	String b = new String("hsp");//b 指向堆中的对象，堆中对象的value再指向常量池中的“hsp”;
	System.out.println(a.equals(b));//此时重写之后，比较的是字符串内容，返回true
	System.out.println(a==b);//a指向的是常量池中的“hsp”,b是指向堆的，堆中有个对象，对象中有个value。
			//value指向常量池中的“hsp”,而a、b指向的对象不同，所以return  false
	System.out.println(a==b.intern());
		//a的内容是“hsp”,b.intern()会去看对象b的内容是什么，是hsp,它就到常量池中看，有没有一个字符串也是hsp
		// 之前已经放进去了hsp到常量池中，此时是有的，如果有的话，它就直接把这个hsp返回，此时再比较，
		//二者都是hsp,自然就相等，返回true了
	System.out.println(b==b.intern());
		//此中的b指向的是堆中的对象，而b.intern()则指向的是常量池中的“hsp”,
		//二者不一样，所以return false
//拓展普及
	当调用intern方法时，如果池中已经包含了一个等于此String对象的字符串(用equals(Object)方法确定)，则返回池中的字符串，
    否则，将该String对象添加到池中，并返回此String对象的引用
        //b.intern()方法最终返回的是常量池的地址（对象）

在这里插入图片描述

//输出如下
false
    //二者指向的对象不同，前者指向常量池中的“Java”，而后者指向堆，堆中的value指向常量池中的“Java”
true
    //二者的内容相同,所以指向常量池中的同一位置，so相等
true
    //equals比较的是内容，二者内容相同，所以true
false
    //二者内容都不同，就要各自在常量池中创建，二者指向常量池中的指向不同

在这里插入图片描述

//输出如下
true
    //equals比较内容，所以相等
true
    //二者的name指向的都是常量池中的“hspedu”,指向相同，so true
true
    //前者指向常量池中的“hspedu”,后者本就是在常量池中，so true
false
    //二者是指向两个不同的对象，指向不同，无非二者的name属性值相同罢了

在这里插入图片描述

字符串的特性

说明：

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

在这里插入图片描述

//千万不要认为第二个语句是把常量池中的“hello”给直接覆盖替换了，
//第二个语句，它会先看常量池中有没有“haha”,如果有，那就直接指向，反之，
//它就会在常量池中创建“haha”,然后让s1重新指向“haha”,原先指向“hello”的那条线就莫得了
    //综上，在常量池中创建了两个对象

在这里插入图片描述

//String a = "hello" + "abc",这个语句编译器会将其优化为String a = "helloabc"
	//所以，综上，创建了一个对象 

//分析
	1.编译器不傻，做一个优化，判断创建的常量池对象，是否有引用指向
        	//如果创建了3个，那么单个的hello、abc，没人用，你说创建它干什么
    2.String a = "hello"+"abc"; ---> String a = "helloabc";

在这里插入图片描述

//注意，此中的String c = a+b 和 String "hello"+"abc"是不一样的哈
	String c = a + b;
	//剖析底层执行流程
	1.创建一个StringBuilder sb = StringBuilder();
	2.执行  sb.append("hello");
	3.sb.append("abc");
	4.String c = sb.toString();//	toString()方法底层仍然是new
	5.最后，其实是c指向堆中的String类型对象，其中的value数组再指向池中的"helloabc"
//所以，综上创建了3个对象，a、b指向常量池中对象，c指向堆
        如果此时再来句String  d = "helloabc";试问下面这句的返回值
            System.out.println(d==c);

//答案是false,因为c指向的是堆中的对象，而d指向的是常量池中的"helloabc";

//重要规则：
	String c = "ab" + "cd"; 常量相加，看的是池；String  c1 =  a + b ;变量相加，是在堆中;
再来多问一句：
    	String d = "helloabc";
    	System.out.println(d==c);//此时返回的就是true哟，因为二者都是指向池的；

在这里插入图片描述

//输出入下
true
true
解析：
    //s6是指向常量池中的hspedujava

在这里插入图片描述

//
hsp and hava
    /**
    new String("hsp") 这一行首先在常量池中查找是否有 "hsp" 字符串。如果没有，
    则在常量池中创建 "hsp"。
    然后通过 new String("hsp") 在堆中创建一个新的 String 对象，并将该对象的值设为 "hsp"，
    并且 str 引用指向这个堆中的 String 对象。inal char[] ch = {'j', 'a', 'v', 'a'} 
    创建了一个字符数组 ch，该数组存储在堆中。数组的内容为 {'j', 'a', 'v', 'a'}，
    ch 引用指向这个堆中的数组。调用 ex.change(ex.str, ex.ch); 时，
    ex.str 和 ex.ch 被传递到 change 方法中。
    在 Java 中，参数传递是按值传递的。对于引用类型，传递的是引用的副本。
    在 change 方法中，str 变量指向了一个新的字符串 "java"，
    这个字符串查找常量池中是否有 "java"，如果没有，则在常量池中创建 "java" 字符串，
    并让 str 变量指向这个常量池中的 "java"。
    需要注意的是，这里 change 方法中的 str 是 ex.str 的副本，
    对它的修改不会影响 ex.str 原本的引用。
    因此，ex.str 仍然指向堆中那个值为 "hsp" 的 String 对象。
    ch[0] = 'h'; 这行代码修改了数组 ch 的第一个元素，将其从 'j' 改为 'h'。
	由于 ch 是一个引用，传递的是引用的副本，但它仍然指向堆中的同一个数组，
	因此这个修改会影响到 ex.ch 数组。
	最终，ex.ch 的内容变为 {'h', 'a', 'v', 'a'}。
	因为在 change 方法中对 str 的修改没有影响到原始的 ex.str，
	所以此时输出语句中ex.str 仍然是 "hsp"。
	而ex.ch 数组被修改过，因此其内容为 {'h', 'a', 'v', 'a'}，打印时会输出 "hava"。
	因此，最后的输出结果是    hsp and java									*/