Java中 String类的详解(非常全面细致)

已于 2023-05-29 10:31:10 修改
阅读量2.3w 收藏 151
点赞数 20
分类专栏： java笔记 文章标签： java 字符串 String String相关面试题 String具体特性
于 2021-05-22 16:46:52 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lu202032/article/details/117047712
版权
本文详细介绍了Java中的String类，包括其不可变性特性，如重新赋值、连接操作和replace()方法都会创建新对象。此外，还讨论了String的实例化方式，通过字面量和new关键字的不同效果。同时，文章通过多个测试题解析了String在内存中的布局，以及字符串拼接和intern()方法的应用，帮助读者深入理解Java字符串的内存管理和使用细节。
摘要由CSDN通过智能技术生成

博主前些天发现了一个巨牛的人工智能学习网站，通俗易懂，风趣幽默，忍不住也分享一下给大家，
👉点击跳转到网站

一、String类的使用：

  1. String：字符串，使用一对“”引起来表示
  2. String声明为final的，不可以被继承
  3. 字符串的字符使用Unicode进行编码，一个字符(不区分字母还是汉字)占两个字节
  4. String实现了Serializable接口：表示字符串是支持序列化的，说明可以在网络上传输。
    实现了Comparable接口：表示String可以比较大小
  5. String类内部定义了final char[] value用于存储字符串数据
  6. 一定要注意：value是一个final类型，不可以修改：即value不能指向新的地址，但是单个字符内容是可以变化的。
  7. String代表不可变的字符序列，简称：不可变性
    体现：1.当对字符串重新赋值时，需要重新指定内存区域赋值，不能使用原有的value进行赋值。
    2.当对现有的字符串进行连接操作时，也需要重新指定内存区域赋值，不能使用原有的value进行赋值。
    3.当调用String的replace()方法修改指定字符或字符串时，也需要重新指定内存区域赋值，不能使用原有的value进行赋值。
  8. 通过字面量的方式(区别于new)给一个字符串赋值，此时的字符串值声明在字符串常量池中
  9. 字符串常量池中是不会存储相同内容的字符串的
    案例代码如下：
package www.demo1;

import org.junit.Test;

public class StringTest {
    @Test
    public void test1(){
        final char[] value = {'a', 'b', 'c'};
        char[] v2 = {'t', '0', 'm'};
        value[0] = 'H';
//        value=v2; //不可以修改value地址

    	//"abc" 字符串常量，双引号括起的字符序列 
        String s1="abc"; //字面量的定义方式
        String s2="abc";
        //比较s1,s2的地址值,结果为true
        System.out.println(s1==s2);
        s1="hello";
        System.out.println(s1);
        System.out.println(s2);
        System.out.println("***********************");
   

        String s3="abc";
        s3+="def";
        System.out.println(s3);
        
        System.out.println("***********************");
        String s4="abc";
        String s5=s4.replace("a","m");
        System.out.println(s4);
        System.out.println(s5);
    }
}

二、String实例化的方式：
方式一：通过字面量定义的方式
方式二：通过new + 构造器() 的方式
代码理解：

		//通过字面量定义的方式:此时数据abc声明在方法区中的字符串常量池中
        String s1="abc";
        String s2="abc";
        //通过new+构造器的方式: 此时s3,s4保存的地址值，是数据在堆空间中开辟以后对应的地址值
        String s3 = new String("abc");
        String s4 = new String("abc");

        System.out.println(s1==s2);//true
        System.out.println(s1==s3);//false
        System.out.println(s1==s4);//false
        System.out.println(s3==s4);//false
        System.out.println("**************************");
        Person p1 = new Person("Tom",14);
        Person p2 = new Person("Tom",14);
        System.out.println(p1.name.equals(p2.name));//true,因为比较的是实体内容(String重写了equals()方法)
        System.out.println(p1==p2);//false new的两个对象地址值是不一样的
        System.out.println(p1.name==p2.name); //true
        p1.name="Lay";
        System.out.println(p2.name); //结果为Tom

结论：

  1. 常量与常量的拼接结果在常量池，且常量池中不会存在相同内容的常量
  2. 只要其中有一个结果是变量，结果就在堆中
  3. 如果拼接的结果调用intern()方法，返回值就在常量池中
    加上代码便于理解：
		String s1 = "Java";
        String s2 = "Android";
        String ss ="JavaAndroid";

        String s3 = "Java"+"Android";
        String s4 = s1 + "Android";
        String s5 = "Java" + s2;
        String s6 = s1 + s2;

        System.out.println(ss==s3);//true
        System.out.println(ss==s4); //false
        System.out.println(ss==s5);//false
        System.out.println(ss==s6);//false
        System.out.println(s4==s5);//false

        String s7=s4.intern();
        System.out.println(ss==s7);//true

额外补充**************************

创建String对象的两种方式：
在这里插入图片描述
String的内存布局
在这里插入图片描述
String的相关测试

测试题1：

public class StringExercise01 {
    public static void main(String[] args) {
        String a = "abc";
        String b = "abc";
        //String重写了equals方法 ,比较的是具体的值，所以为true
        System.out.println(a.equals(b)); //true
        
        //a 首先看常量池有没有abc
        //b 首先看常量池有没有abc 有，就将b直接指向abc
        //所以地址值是一样的
        System.out.println(a == b); //true
    }
}

测试题2：

public class StringExercise02 {
    public static void main(String[] args) {
        String a = "ly";
        String b = new String("ly");
        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对象的引用
        //解读：b.intern() 方法最终返回的是常量池的地址(对象)
    }
}

测试题3：

public class StringExercise03 {
    public static void main(String[] args) {
        String s1 = "ly"; //s1 指向常量池的ly
        String s2 = "java"; //s2 指向常量池的java
        String s4 = "java"; //s4 指向常量池的java
        String s3 = new String("java"); //指向堆中的对象 

        System.out.println(s2 == s3); //false
        System.out.println(s2 == s4); //true
        System.out.println(s2.equals(s3)); //true
        System.out.println(s1 == s2); //false
    }
}

测试题4：

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

        System.out.println(p1.name.equals(p2.name)); //比较的内容 true
        System.out.println(p1.name == p2.name); //true
        //"lyedu"返回的地址：就是在常量池中的地址
        //p1.name 指向的也是常量池中的"lyedu" 对应的地址
        System.out.println(p1.name == "lyedu"); //true

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

class Person {
    public String name;
}

对应的内存布局图如下：
在这里插入图片描述
测试题5：

//以下语句创建了几个对象，并画出内存布局图
String s1="hello";
s1="haha";
//创建了两个对象

内存布局图
在这里插入图片描述
String类相关的面试题

面试题1：

		//创建了几个对象？ 只有1个对象
        String a = "hello" + "abc";//等价于==>String a = "helloabc";
        System.out.println(a);

面试题2：
在这里插入图片描述
一共有3个对象，内存布局图如下：
在这里插入图片描述
具体代码和讲解如下：

public class StringExercise05 {
    public static void main(String[] args) {
        String a = "hello"; //创建a对象
        String b = "abc"; //创建b对象
        //解读
        //1.先创建一个StringBuilder sb = new StringBuilder();
        //2.执行 sb.append("hello");
        //3.执行sb.append("abc");
        //4.String c = sb.toString();
        //最后其实是 c 指向堆中对象的(String) value[]->池中 "helloabc"
        String c = a + b;  
        String d = "helloabc";
        System.out.println(c == d); //false

        String e = "hello" + "abc";
        System.out.println(d == e);//true
    }
}

该题小结：
底层是StringBuilder sb = new StringBuilder();
sb.append(a); sb.append(b); sb是在堆中，并且append是在原来字符串的基础上追加的。

重要规则：

  1. String c1=“ab” + “cd”; 常量相加，看的是池。
  2. String c1 = a + b; 变量相加，是在堆中。

面试题3：

public class StringExercise06 {
    public static void main(String[] args) {
        String s1 = "lyedu";//指向常量池中的"lyedu"
        String s2 = "java";//指向常量池中的"java"
        String s5 = "lyedujava"; //指向常量池中的"lyedujava"
        String s6 = (s1 + s2).intern(); //指向池中的 "lyedujava"
        System.out.println(s5 == s6); //true
        System.out.println(s5.equals(s6)); //true
    }
}

面试题4:

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

class Test1 {
    String str = new String("ly");
    final char[] ch = {'j', 'a', 'v', 'a'};

    public void change(String str, char ch[]) {
        str = "java";
        ch[0] = 'h';
    }
}

输出结果为：

ly and 
hava

以上是String字符串的讲解，有任何问题都可以在评论区指出！

路宇
关注
专栏目录
Java中的String详解
解忧杂货铺
07-01 2888
String类代表字符串。Java 程序中的所有字符串字面值（如 “abc” ）都作为此类的实例实现。 首先来看一个关于String示例： String s1 = "HelloWorld"; String s2 = "HelloWorld"; String s3 = new String("HelloWorld"); String s4 = "Hello"; String s5 = "Wor
详解java中的OOM及 java堆溢出分析
guanshengg的博客
08-06 2175
详解java中的OOM及 java堆溢出分析
java String详解
08-09
NULL 博文链接：https://hui-jing-880210.iteye.com/blog/2173166
16.Java中的String详解
weixin_30679823的博客
04-18 153
01.String（概述） 字符串是一个特殊对象。字符串最大特点：一旦被初始化就不可以改变。 ==是比较两个对象。而equals是比较对象引用的地址值。String类复写了Object类中的equals方法，该方法用于判断字符串是否相同。s1和s2的区别？String s1="abc";String s2=new String("abc");s1有一个对象，s2有两个对象。 02.Strin...
【Java基础】String详解
scj1022的博客
09-16 1295
String特性及内存占用详解
Java编程那些事儿75——String类使用
爪哇米工作室陈跃峰的移动开发博客
02-23 6773
Java编程那些事儿75——String类使用陈跃峰出自：http://blog.csdn.net/mailbomb9.5.3 String和StringBuffer         String和StringBuffer类都是代表字符串，也就是任意多个字符组成的序列。程序需要存储的大量文字一般都使用字符串进行代表。在这两个类中，包含了大部分关于字符串操作的方法，在实际操作字符串时
Java中String详解（重要！！！）
Jay112011的博客
04-23 891
原文地址https://zhuanlan.zhihu.com/p/29629508 注：参考博客深入理解Java中的String - 平凡希 - 博客园，然后自己加以总结，添加新问题。 做了这么多的笔试面试。 String s1="abc"; String s2=new String("abc"); 两者不相等这种简单的问题都已经清除了。还有另外一些形式，这里就不
详解java中的正则表达式
08-28
在Java中，`String`类提供了两种方法来使用正则表达式：`contains`和`matches`。`contains`方法用于判断字符串中是否包含指定的子串，而`matches`方法则用于判断整个字符串是否符合正则表达式定义的模式。 在使用...
Java反射：通过实例获取Annotation及Class类详解
Java课程中，"通过反射取得Annotation"这一主题主要探讨了Java反射机制如何在编程中发挥作用，特别是与类的注解（Annotation）的交互。在Java中，Reflection是一种强大的工具，它允许程序员在运行时检查和修改程序的...
37从零开始学Java之一文详解让你迷糊的this关键字
一一哥
05-31 285
在之前壹哥讲解构造方法的时候，我给大家提到过一个this关键字，但之前讲解得并不很细致。所以今天我们再利用一篇文章，专门讲解这个this关键字，我们好好探究一下它到底有哪些细节。前戏已做完，精彩即开始全文大约【2400】字，不说废话，只讲可以让你学到技术、明白原理的纯干货！本文带有丰富的案例及配图视频，让你更好地理解和运用文中的技术概念，并可以给你带来具有足够启迪的思考......我们知道，this是”这个“的意思。在java中表示当前类的对象，可以理解成指向对象本身的一个指针。
Java 虚拟机详解
pizicai007的博客
01-22 928
Java 虚拟机详解1. Java 虚拟机1.1 什么是虚拟机1.2 JVM 由哪些部分组成2. JVM 内存结构2.1 程序计数器（线程私有）2.2 虚拟机栈（线程私有）2.3 本地方法区（线程私有）2.4 堆（Heap - 线程共享）- 运行时数据区2.4.1 新生代2.4.1.1 Eden 区2.4.1.2 ServivorFrom2.4.1.3 ServivorTo2.4.2 老年代2.5 元数据（线程共享）2.5.1 静态常量池2.5.2 运行时常量池2.5.3 字符串常量池2.5.4 总结2.6
java：Java中的String详解
2303_80025768的博客
04-21 3171
本文档主要介绍了Java中的String类和StringBuffer/StringBuilder类的用法和区别，以及字符串常见操作的示例和实际应用场景。
Java字符串操作(String类)
一贯青蚨
09-07 3948
Java字符串 字符串是Java编程中最常用的数据类型之一，而Java基本数据类型中只有只能存储单个字符的char型，所以当需要存储例如姓名，词语，单词，句子等不止一个字符的数据就需要使用String类来存储数据。 Java中字符串一旦被创建就不能再进行修改 若想要更改字符串的值，只能通过对字符串重新复制来实现 定义字符串 String类提供了11种构造方法，这些方法提供不同的参数来初始化字符串，比如提供了一个字符数组参数： public class StringDemo{ public sta
Java String类详解
fengyuzhengfan的专栏
08-10 5490
Java字符串类(java.lang.String)是Java中使用最多的类，也是最为特殊的一个类，很多时候，我们对它既熟悉又陌生。
java基础之String详解
大佬请赐教
02-02 868
String简介 它是一个final类，不能被继承使用，所有成员方法都被隐式指定为final类型，实现了序列化Serializable，实例化对象大小比较Comparable<String>，只读字符序列CharSequence接口。 讲解String之前，先回顾一下字符串常量池、class文件常量池和运行时常量池的区别？ ①字符串常量池<=jdk6.0时，String Po...
java的String（详述）
最新发布
L326214的博客
10-22 1156
String是一种不可变对象，字符串中的内容是不可变的，一旦初始化完成后就无法改变了，虽然可以使用“+=”进行字符串追加，但是并不是真正意义上的追加，“+=”实际上是new了几个新对象进行追加成为一个新的对象最后再返回变成String类型，本质意义上也不是在原字符串的基础上追加。String类的字符实际是保存在内部维护的value字符数组中，并且该数组也被final修饰，表示value本身的引用对象不可以修改，即不可以引用其他的字符数组，但是value引用的数组内容是可以修改的。
JAVA中的String类
weixin_51517370的博客
06-09 1429
Java的八种基本数据类型： 字符型（char） 布尔型（boolean） 数值型（byte、short、int、long、float、double） String并不属于八中基本数据类型 String类位于java.lang包中，使用String类创建的字符串变量属于对象，默认值为null 注意：new String(); 和 new String("");都是声明一个空串，而不是null 如果需要对字符串做很多修改，那么应该选择使用 StringBuffer & StringBuilder类.
Java的String详解
u012256398的专栏
04-05 214
      Java的String类在开发时经常都会被使用到，由此可见String的重要性。经过这次认真仔细的学习了java的String类。发现了自己以前开发中对String使用的不足，特写此博客来记录自己对String的学习总结。      首先String不属于8种基本数据类型，String是一个对象。 因为对象的默认值是null，所以String的默认值也是null；但它又是一种特殊...
Java之String类详解
qq_43508801的博客
03-10 292
String类在所有项目开发之中都会使用到！ 1. 实例化方式 ① 直接赋值：String str= &amp;quot;Hello world&amp;quot;； ② 通过构造方法产生对象(传统法)：String str = new String(&amp;quot;Hello world&amp;quot;); public class ShiLiHua { public static void main(String[] args) { ...
评论 7
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

路宇

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值