36、Java 中的 String、StringBuilder、StringBuffer、字符串常量池和 intern 方法

简介: 36、Java 中的 String、StringBuilder、StringBuffer、字符串常量池和 intern 方法


一、String

✏️ Java 中用 java.lang.String 类代表字符串

✏️ 底层用char[]存储字符数据。从 Java9 开始,底层使用 byte[]存储字符数据

public class TestDemo {
    public static void main(String[] args) {
        String bigBrother = "林哥"; // char[] value = {'林', '哥'};
    }
}

🌿 字符串的底层是 char[],但是 char 数组和字符串不能等价。char 数组是 char 数组,字符串是字符串。

🌿 C 语言中是可以把 char 数组和字符串等价的

✏️ 所有的 字符串字面量(如:"林哥")都是 String 类的实例

✏️ String 对象创建完毕后,String 对象的字符内容是不可以修改的

🌿 String 对象的引用变量的指向是可以修改的

public class TestDemo {
    public static void main(String[] args) {
        String s = "林哥";
        s += "love";
        s = "666";
        test(s);
        // s = 666
        System.out.println("s = " + s);
    }
    private static void test(String str) {
        // str 是局部变量, 生命周期只在 test 方法中
        str += 123;
    }
}

二、字符串常量池

✏️ 字符串常量池:String Constant Pool

✏️ 从 Java7 开始,字符串常量池是在空间(之前是在方法区)

🌿 当遇到字符串字面量的时候,会先在 SCP 中检索

🌿 看 SCP 中是否存在与字面量内容一样的字符串对象 A

🌿 如果有,返回字符串对象 A

🌿 否则,创建一个新的字符串对象 B,并将其加入到 SCP 中,然后返回 B

public class TestDemo {
    public static void main(String[] args) {
        String s1 = "林哥";
        String s2 = "林哥";
        // true
        System.out.println(s1 == s2);
    }
}

三、字符串的初始化

public class TestDemo {
    public static void main(String[] args) {
        String s1 = "林哥";
        String s2 = new String("林哥");
        // 字符串对象 s3 的值和字符串对象 s1 的值是一样的
        // 底层指向的都是同一个 char 数组
        String s3 = new String(s1);
        String s4 = new String(s2);
        char[] cs = {'林', '哥'};
        String s5 = new String(cs);
        String s6 = new String(s5);
    }
}


String s1 = "林哥";
 String s2 = new String("林哥");

✏️ 上面的两行代码中,字符串对象 s1 底层的 char 数组 value 和字符串对象 s2 底层的 char 数组是同一个

✏️ 如下图所示:String 的构造方法会把传入的字符串对象的 value 直接赋值给当前对象(当前创建的新字符串对象)的 value

可通过 debug 的方式验证...

✏️ 上图:字符串对象 s1 底层的 value 的 id 号是 541

✏️ 字符串对象 s2 底层的 value 的 id 号也是 541

✏️ 给 String 对象的构造方法传入字符数组的时候,底层会拷贝一份该字符数组,然后才赋值给当前创建的 String 对象的 char 数组 value

四、String 类的 intern 方法

先看下面的代码,思考打印结果:

public class TestDemo {
    public static void main(String[] args) {
        String s0 = "林哥";
        String s1 = s0.intern();
        // true
        System.out.println(s1 == s0);
        String s2 = new String(s0);
        // false
        System.out.println(s2 == s0);
        String s3 = s2.intern();
        System.out.println(s3 == s0); // true
        System.out.println(s3 == s2); // false 
    }
}

✏️ 当字符串的 intern() 方法被调用的时候,如果字符串常量池中已经包含一个字符串对象的内容等于调用 intern()的字符串对象的内容,则返回字符串常量池中的字符串对象。否则,把调用 intern()的字符串对象添加到字符串常量池中,并返回该字符串对象(调用 intern()的字符串对象)

String s3 = s2.intern();

✏️ s2 调用了intern()方法,如果字符串常量池中存在与 s2 内容一样的字符串对象 s 的话,返回字符串常量池中的 s 对象;否则,将 s2 添加到字符串常量池中,并返回 s2


只有遇到字符串字面量的时候,才会在字符串常量池中检索

public class TestDemo {
    public static void main(String[] args) {
        int a = 1, b = 2, c = 3;
        String s1 = String.format("%d_%d_%d", a, b, c);
        String s2 = String.format("%d_%d_%d", a, b, c);
        System.out.println(s1 == s2); // output: false
        
        /*
            只有【字符串字面量】才会在字符串常量池中找检索
         */
    }
}
public class TestDemo {
    public static void main(String[] args) {
        int a = 1, b = 2, c = 3;
        String s1 = String.format("%d_%d_%d", a, b, c);
        String s2 = String.format("%d_%d_%d", a, b, c);
        System.out.println(s1 == s2); // output: false
        /*
            会把 s1 放入字符串常量池,并返回 s1 指向对象
            s3 和 s1 指向的是同一个对象
         */
        String s3 = s1.intern();
        /*
            会把被 s1 指向的字符串常量池中的字符串对象返回
            s1 和 s4 指向的是同一个对象
         */
        String s4 = s2.intern();
        /*
            返回字符串常量池中的字符串对象, 若 SCP 中没有, 创建一个放入 SCP, 并返回
         */
        String s5 = "1_2_3";
        System.out.println(s1 == s3); // true
        System.out.println(s1 == s4); // true
        System.out.println(s1 == s5); // true
    }
}

五、字符串常用方法

public class TestDemo {
    public static void main(String[] args) {
        // trim: 去除左右的空格
        String s1 = "  111 2222  ".trim();
        String s = "hAve A niCe Day";
        // toUpperCase: 把小写字母转为大写字母
        String s2 = s.toUpperCase();
        // toLowerCase: 把大写字母转换为小写字母
        String s3 = s.toLowerCase();
        // contains: 是否包含某个子字符串片段
        boolean contains = "Have a nice Day".contains("nice");
        // startsWith: 是否以某个子字符串片段开头
        boolean startsWith = "Love is love.".startsWith("love");
        // endsWith: 是否以某个子字符串片段结尾
        boolean endsWith = "Love is love".endsWith("love");
        // 将字符串分隔为字符串数组
        String[] split = "Today_we_have_a_new_student".split("_");
        // output: [Today, we, have, a, new, student]
        System.out.println(Arrays.toString(split));
    }
}

字符串的截取:

public class TestDemo {
    public static void main(String[] args) {
        String nice = "goodMorning";
        // 从下标 4 位置开始截取, 截取到最后
        String s1 = nice.substring(4);
        // output: s1 = Morning
        System.out.println("s1 = " + s1);
        String s = "believe";
        // 从下标 2 位置开始截取, 截取到下标为 5 的位置(不包括下标5位置的字符)
        // 左闭右开
        String s2 = s.substring(2, 5);
        // s2 = lie
        System.out.println("s2 = " + s2);
    }
}

indexOf: 定位字符串所在索引

public class TestDemo {
    public static void main(String[] args) {
        int result1 = "hello".indexOf("e");
        int result2 = "hello".indexOf("a");
        System.out.println(result1); // 1
        System.out.println(result2); // -1
    }
}

🌿 如果字符串中不包含该子字符串,返回 -1

lastIndexOf: 定位字符串所在索引

public class TestDemo {
    public static void main(String[] args) {
        // 从左往右开始定位字符串索引
        int result1 = "hello log".indexOf("lo");
        // 从右往左开始定位字符串索引(但数的时候还是从左往右数)
        int result2 = "hello log".lastIndexOf("lo");
        System.out.println(result1); // 3
        System.out.println(result2); // 6
    }
}

字符串替换:

public class TestDemo {
    public static void main(String[] args) {
        String s1 = "I live you";
        String s2 = s1.replace("live", "like");
        // s1 = I live you
        System.out.println("s1 = " + s1);
        // s2 = I like you
        System.out.println("s2 = " + s2);
    }
}

六、StringBuilder 和 StringBuffer

✒️ 需要进行大量的字符串改动操作(如拼接、替换)的时候,使用 String 会非常消耗内存、会降低程序性能

✒️StringBuilderStringBuffer 进行大量字符串拼接或替换的时候,程序性能和内存的消耗特别小

public class TestDemo {
    public static void main(String[] args) {
        String s = "1";
        s += "2";
        s += "3";
        s += "4";
        // s = 1234
        System.out.println("s = " + s);
    }
}

🌿 上面代码,每一次的拼接操作都会产生一个新的字符串对象

🌿 由于字符串内容的不可变性,每次的拼接操作必定都会产生一个新的字符串对象(如上图),会存在大量的字符串对象的创建和销毁操作


public class TestDemo {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder("1");
        sb.append("2");
        sb.append("3");
        sb.append("4");
        // 1234
        System.out.println(sb.toString());
        // 链式调用
        StringBuffer sBuffer = new StringBuffer("1")
                .append("2")
                .append("3")
                .append("4");
        // 1234
        System.out.println(sBuffer);
    }
}

🌿 使用 StringBuilder 和 StringBuffer 则会非常高效

🌿 StringBuilder 和 StringBuffer 的使用方式(API)都一样

🌿 区别:StringBuilder 线程安全;StringBuffer 线程安全


✏️ 常用方法:append、insert、delete、replace、reverse

✏️ StringBuider 或 StringBuffer 与 String 并不存在继承关系

✏️ StringBuilder、StringBuffer、String 都实现了 CharSequence 接口

✏️ StringBuilder 的 append 原理:动态数组

动态数组的实现博主后期在学习,后期再写文章

结束,如有错误请不吝赐教

目录
打赏
0
0
0
0
11
分享
相关文章
Java中的异常处理方法
本文深入剖析Java异常处理机制,介绍可检查异常、运行时异常和错误的区别与处理方式。通过最佳实践方法,如使用合适的异常类型、声明精确异常、try-with-resources语句块、记录异常信息等,帮助开发者提高代码的可靠性、可读性和可维护性。良好的异常处理能保证程序稳定运行,避免资源泄漏和潜在问题。
|
1天前
|
Java代码结构解析:类、方法、主函数(1分钟解剖室)
### Java代码结构简介 掌握Java代码结构如同拥有程序世界的建筑蓝图,类、方法和主函数构成“黄金三角”。类是独立的容器,承载成员变量和方法;方法实现特定功能,参数控制输入环境;主函数是程序入口。常见错误包括类名与文件名不匹配、忘记static修饰符和花括号未闭合。通过实战案例学习电商系统、游戏角色控制和物联网设备监控,理解类的作用、方法类型和主函数任务,避免典型错误,逐步提升编程能力。 **脑图速记法**:类如太空站,方法即舱段;main是发射台,static不能换;文件名对仗,括号要成双;参数是坐标,void不返航。
14 5
|
6月前
|
java基础(13)String类
本文介绍了Java中String类的多种操作方法,包括字符串拼接、获取长度、去除空格、替换、截取、分割、比较和查找字符等。
64 0
java基础(13)String类
【c++丨STL】string类的使用
本文介绍了C++中`string`类的基本概念及其主要接口。`string`类在C++标准库中扮演着重要角色,它提供了比C语言中字符串处理函数更丰富、安全和便捷的功能。文章详细讲解了`string`类的构造函数、赋值运算符、容量管理接口、元素访问及遍历方法、字符串修改操作、字符串运算接口、常量成员和非成员函数等内容。通过实例演示了如何使用这些接口进行字符串的创建、修改、查找和比较等操作,帮助读者更好地理解和掌握`string`类的应用。
116 2
|
5月前
|
【编程基础知识】(讲解+示例实战)方法参数的传递机制(值传递及地址传递)以及String类的对象的不可变性
本文深入探讨了Java中方法参数的传递机制,包括值传递和引用传递的区别,以及String类对象的不可变性。通过详细讲解和示例代码,帮助读者理解参数传递的内部原理,并掌握在实际编程中正确处理参数传递的方法。关键词:Java, 方法参数传递, 值传递, 引用传递, String不可变性。
100 1
【编程基础知识】(讲解+示例实战)方法参数的传递机制(值传递及地址传递)以及String类的对象的不可变性
String类-知识回顾①
这篇文章回顾了Java中String类的相关知识点,包括`==`操作符和`equals()`方法的区别、String类对象的不可变性及其好处、String常量池的概念,以及String对象的加法操作。文章通过代码示例详细解释了这些概念,并探讨了使用String常量池时的一些行为。
String类-知识回顾①
Java零基础-StringBuffer 类详解
【10月更文挑战第9天】Java零基础教学篇,手把手实践教学!
126 2
让星星月亮告诉你,通过反射创建类的实例对象,并通过Unsafe theUnsafe来修改实例对象的私有的String类型的成员属性的值
本文介绍了如何使用 Unsafe 类通过反射机制修改对象的私有属性值。主要包括: 1. 获取 Unsafe 的 theUnsafe 属性:通过反射获取 Unsafe类的私有静态属性theUnsafe,并放开其访问权限,以便后续操作 2. 利用反射创建 User 类的实例对象:通过反射创建User类的实例对象,并定义预期值 3. 利用反射获取实例对象的name属性并修改:通过反射获取 User类实例对象的私有属性name,使用 Unsafe`的compareAndSwapObject方法直接在内存地址上修改属性值 核心代码展示了详细的步骤和逻辑,确保了对私有属性的修改不受 JVM 访问权限的限制
91 4
|
5月前
|
【C++打怪之路Lv8】-- string类
【C++打怪之路Lv8】-- string类
48 1
|
5月前
|
【一步一步了解Java系列】:认识String类
【一步一步了解Java系列】:认识String类
50 2

热门文章

最新文章

AI助理

你好,我是AI助理

可以解答问题、推荐解决方案等