Java-String、StringBuffer、StringBuilder详解

已于 2023-01-26 13:50:17 修改
阅读量915 收藏 12
点赞数 11
分类专栏： JavaSE 文章标签： java 哈希算法 开发语言 1024程序员节
于 2022-09-02 08:17:14 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_52533007/article/details/126654652
版权

String、StringBuffer、StringBuilder

前言

本博主将用CSDN记录软件开发求学之路上亲身所得与所学的心得与知识，有兴趣的小伙伴可以关注博主！
也许一个人独行，可以走的很快，但是一群人结伴而行，才能走的更远！让我们在成长的道路上互相学习，欢迎关注！

一、关于String的特性

⭕ String类：代表字符串，使用一对""引起来表示。
Java 程序中的所有字符串字面值（如 "abc" ）都作为此类的实例实现。

⭕ String是一个final类，不可被继承。

⭕ String实现了两个接口：
● 实现了Serializable接口：表示字符串是支持序列化的。
● 实现了Comparable接口：表示String可以比较大小。

⭕ String内部定义了final char[] value用于存储字符串数据，对象的字符内容是存储在一个字符数组value[]中的。

⭕ String源码：

public final class String implements java.io.Serializable, Comparable<String>, CharSequence {
/** The value is used for character storage. */
private final char value[];
/** Cache the hash code for the string */
private int hash; // Default to 0

⭕ 字符串常量池中是不会存储相同内容的字符串的。

⭕ String：代表不可变的字符序列，它们的值在创建之后不能更改，简称：不可变性。
体现：
● 当对字符串重新赋值时，需要重写指定内存区域赋值，不能使用原有的value进行赋值。
● 当对现有的字符串进行连接操作时，也需要重新指定内存区域赋值，不能使用原有的value进行赋值。
● 当调用String的replace()方法修改指定字符或字符串时，也需要重新指定内存区域赋值，不能使用原有的value进行赋值。

代码演示1：

@Test
    public void test1(){
        String s1 = "abc";//字面量的定义方式
        String s2 = "abc";
        //比较s1和s2的地址值
        System.out.println(s1 == s2);//true
        
        
        
        s1 = "hello";
        //比较s1和s2的地址值
        System.out.println(s1 == s2);//false
        System.out.println(s1);//hello
        System.out.println(s2);//abc


        String s3 = "abc";
        s3 += "def";
        System.out.println(s3);//abcdef
        System.out.println(s2);//abc


        String s4 = "abc";
        String s5 = s4.replace('a', 'm');
        System.out.println(s4);//abc
        System.out.println(s5);//mbc
}

代码演示2：

//面试题：体现了String的不可变性
public class StringTest {
String str = new String("good");
    char[] ch = { 't', 'e', 's', 't' };

    public void change(String str, char ch[]) {
        str = "test ok";
        ch[0] = 'b';
    }
    public static void main(String[] args) {
        StringTest ex = new StringTest();
        ex.change(ex.str, ex.ch);
        System.out.println(ex.str);//good
        System.out.println(ex.ch);//best
    }
}

二、String的实例化方式

1、两种实例方式

⭕通过字面量定义的方式。
通过字面量的方式（区别于new+构造器）给一个字符串赋值，此时的字符串值声明在字符串常量池中。

在这里插入图片描述

⭕通过new + 构造器的方式
问题：String s = new String("abc");方式创建对象，在内存中创建了几个对象？

一共两个:

  1. 一个是堆空间中new结构，
  2. 另一个是char[]对应的常量池中的数据："abc"

在这里插入图片描述

2、代码演示

代码演示1：

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

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

}

内存图解1：
在这里插入图片描述

代码演示2：

//Person类
public class Person {
    public String name;
    public  int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public Person() {
    }

}
public void test1(){
 
        Person p1 = new Person("Tom",12);
        Person p2 = new Person("Tom",12);

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

        p1.name = "Jerry";
        System.out.println(p2.name);//Tom
}

内存图解2：
在这里插入图片描述

三、String的拼接问题

1、概述

⭕常量与常量的拼接结果在常量池。且常量池中不会存在相同内容的常量。

⭕ 如果与拼接的对象里，只要其中有一个是变量，结果就在堆中。

⭕ 如果拼接的结果调用intern()方法，返回值就在常量池中。

2、代码演示

代码演示1：

      @Test
    public void test1(){
        String s1 = "javaEE";
        String s2 = "hadoop";
        String s3 = "javaEEhadoop";
        String s4 = "javaEE" + "hadoop";
        
        String s5 = s1 + "hadoop";
        String s6 = "javaEE" + s2;
        String s7 = s1 + s2;

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

        String s8 = s6.intern();//返回值得到的s8使用的常量值中已经存在的“javaEEhadoop”
        System.out.println(s3 == s8);//true
    }

代码演示2：

 @Test
    public void test4(){
        String s1 = "javaEEhadoop";
        String s2 = "javaEE";
        String s3 = s2 + "hadoop";
        System.out.println(s1 == s3);//false

        final String s4 = "javaEE";//s4:常量
        String s5 = s4 + "hadoop";
        System.out.println(s1 == s5);//true
    }

3、String使用陷阱

⭕ String s1 = "a";
说明：在字符串常量池中创建了一个字面量为"a"的字符串。

⭕ s1 = s1 + "b";
说明：实际上原来的"a"字符串对象已经丢弃了，现在在堆空间中产生了一个字符串s1+"b"（也就是"ab")。如果多次执行这些改变串内容的操作，会导致大量副本字符串对象存留在内存中，降低效率。如果这样的操作放到循环中，会极大影响程序的性能。

⭕ String s2 = "ab";
说明：直接在字符串常量池中创建一个字面量为"ab"的字符串。

⭕ String s3 = "a" + "b";
说明：s3指向字符串常量池中已经创建的"ab"的字符串。

⭕ String s4 = s1.intern();
说明：堆空间的s1对象在调用intern()之后，会将常量池中已经存在的"ab"字符串赋值给s4。

四、String常用方法

1、组1

序号方法作用
1int length()返回字符串的长度： return value.length
2char charAt(int index)返回某索引处的字符：return value[index]
3boolean isEmpty()判断是否是空字符串：return value.length == 0
4String toLowerCase()使用默认语言环境，将 String 中的所有字符转换为小写
5String toUpperCase()使用默认语言环境，将 String 中的所有字符转换为大写
6String trim()返回字符串的副本，忽略前导空白和尾部空白
7boolean equals(Object obj)比较字符串的内容是否相同
8boolean equalsIgnoreCase(String anotherString)与equals方法类似，忽略大小写
9String concat(String str)将指定字符串连接到此字符串的结尾，等价于用“+”
10int compareTo(String anotherString)比较两个字符串的大小
11String substring(int beginIndex)返回一个新的字符串，它是此字符串的从 beginIndex开始截取到最后的一个子字符串
12String substring(int beginIndex, int endIndex)返回一个新字符串，它是此字符串从beginIndex开始截取到endIndex(不包含)的一个子字符串

代码演示1-1：

    @Test
    public void test1() {
        String s1 = "HelloWorld";
        String s2 = "helloworld";
        System.out.println(s1.equals(s2));//false
        System.out.println(s1.equalsIgnoreCase(s2));//true

        String s3 = "abc";
        String s4 = s3.concat("def");
        System.out.println(s4);//abcdef

        String s5 = "abc";
        String s6 = new String("abe");
        //涉及到字符串排序
        System.out.println(s5.compareTo(s6));//-2

        String s7 = "学习之路一起成长";
        String s8 = s7.substring(2);
        System.out.println(s7);//学习之路一起成长
        System.out.println(s8);//之路一起成长

        String s9 = s7.substring(2, 5);
        System.out.println(s9);//之路一
    }   
}

代码演示1-2：

   @Test
    public void test1() {
        String s1 = "HelloWorld";
        System.out.println(s1.length());//10
        System.out.println(s1.charAt(0));//H
        System.out.println(s1.charAt(9));//d
        System.out.println(s1.charAt(10));//报错
        String s5 = "";
        System.out.println(s1.isEmpty());//false
        System.out.println(s5.isEmpty());//true

        String s2 = s1.toLowerCase();
        //s1不可变的，仍然为原来的字符串
        System.out.println(s1);//HelloWorld
        //改成小写以后的字符串
        System.out.println(s2);//helloworld

        String s3 = "   he  llo   world   ";
        String s4 = s3.trim();
        System.out.println("-----" + s3 + "-----");//-----   he  llo   world   -----
        System.out.println("-----" + s4 + "-----");//-----he  llo   world-----
    }

2、组2

序号方法作用
13boolean endsWith(String suffix)测试此字符串是否以指定的后缀结束
14boolean startsWith(String prefix)测试此字符串是否以指定的前缀开始
15boolean startsWith(String prefix, int toffset)测试此字符串从指定索引开始的 子字符串是否以指定前缀开始 。
16boolean contains(CharSequences)当且仅当此字符串包含指定的char 值序列时，返回 true
17int indexOf(String str)返回指定子字符串在此字符串中第一次出现处的索引
18int indexOf(String str, int fromIndex)返回指定子字符串在此字符串中第一次出现处的索引，从指定的索引开始 。
19int lastIndexOf(String str)返回指定子字符串在此字符串中最右边出现处的索引 。
20int lastIndexOf(String str, int fromIndex)返回指定子字符串在此字符串中最后一次出现处的索引，从指定的索引开始反向搜索。

注：indexOf和lastIndexOf方法如果未找到都是返回-1。

代码演示2-1

@Test
    public void test1(){
      String str1 = "hellowworld";
        boolean b1 = str1.endsWith("rld");
        System.out.println(b1);//true

        boolean b2 = str1.startsWith("He");
        System.out.println(b2);//false

        boolean b3 = str1.startsWith("ll",2);
        System.out.println(b3);//true

        String str2 = "wor";
        System.out.println(str1.contains(str2));//true

        System.out.println(str1.indexOf("lol"));//-1

        System.out.println(str1.indexOf("lo",5));//-1

        String str3 = "hellorworld";

        System.out.println(str3.lastIndexOf("or"));//7
        System.out.println(str3.lastIndexOf("or",6));//4

        //什么情况下，indexOf(str)和lastIndexOf(str)返回值相同？
        //情况一：存在唯一的一个str。情况二：不存在str
    }

3、组3

序号方法作用
21String replace(char oldChar, char newChar)返回一个新的字符串，它是通过用 newChar 替换此字符串中出现的所有 oldChar得到的
22String replace(CharSequence target, CharSequence replacement)使用指定的字面值替换序列替换此字符串所有匹配字面值目标序列的子字符串。
23String replaceAll(String regex,String replacement)使用给定的replacement替换此字符串所有匹配给定的正则表达式的子字符串。
24tring replaceFirst(String regex, String replacement)使用给定的replacement 替换此字符串匹配给定的正则表达式的第一个子字符串。
25boolean matches(String regex)告知此字符串是否匹配给定的正则表达式
26String[] split(String regex)根据给定正则表达式的匹配拆分此字符串
27String[] split(String regex, int limit)根据匹配给定的正则表达式来拆分此 字符串，最多不超过limit个，如果超过了，剩下的全部都放到最后一个元素中。
28public static String join(CharSequence delimiter,CharSequence... elements)返回一个新的字符串，由CharSequence elements的副本组成，并附有指定的delimiter的delimiter

代码演示3-1

  @Test
    public void test1(){
        String str1 = "学习之路一起成长";
        String str2 = str1.replace('学', '淼');

        System.out.println(str1);//学习之路一起成长
        System.out.println(str2);//淼习之路一起成长


        String str3 = str1.replace("学习", "淼秒");
        System.out.println(str3);//淼秒之路一起成长
        
        String str = "12hello34world5java7891mysql456";
        //把字符串中的数字替换成,，如果结果中开头和结尾有，的话去掉
        String string = str.replaceAll("\\d+", ",").replaceAll("^,|,$", "");
        System.out.println(string);//hello,world,java,mysql
        
        str = "12345";
        //判断str字符串中是否全部有数字组成，即有1-n个数字组成
        boolean matches = str.matches("\\d+");
        System.out.println(matches);//true
        String tel = "0571-4534289";
        //判断这是否是一个杭州的固定电话
        boolean result = tel.matches("0571-\\d{7,8}");
        System.out.println(result);//true


        
        str = "hello|world|java";
        String[] strs = str.split("\\|");
        for (int i = 0; i < strs.length; i++) {
            System.out.println(strs[i]);
        }
        /**
         * hello
         * world
         * java
         */
        System.out.println();
        str2 = "hello.world.java";
        String[] strs2 = str2.split("\\.");
        for (int i = 0; i < strs2.length; i++) {
            System.out.println(strs2[i]);
        }
        /**
         * hello
         * world
         * java
         */

    }

在这里插入图片描述

五、String与char[ ]、byte[ ]的转换

1、String与char[ ]

⭕ char[]–>String：调用String的构造器

序号构造器作用
1String(char[])用字符数组中的全部字符创建字符串对象
2String(char[]，int offset，int length)用字符数组中的部分字符创建字符串对象

⭕ String–>char[]：调用String的toCharArray()

序号方法作用
1public char[] toCharArray()将字符串中的全部字符存放在一个字符数组中的方法。
2public void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)提供了将指定索引范围内的字符串存放到数组中的方法。

代码演示

    @Test
    public void test17(){
        String str1 = "abc123";  //题目： a21cb3

        char[] charArray = str1.toCharArray();
        for (int i = 0; i < charArray.length; i++) {
            System.out.println(charArray[i]);
        }
        /**
         * a
         * b
         * c
         * 1
         * 2
         * 3
         */

        char[] arr = new char[]{'h','e','l','l','o'};
        String str2 = new String(arr);
        System.out.println(str2);//hello
    }

2、String与byte[ ]

⭕ 编码：String–>byte[]:调用String的getBytes()

序号方法作用
1public byte[] getBytes()使用平台的默认字符集将此 String 编码为byte 序列，并将结果存储到一个新的byte 数组中。
2public byte[] getBytes(String charsetName)使用指定的字符集将此String 编码到 byte 序列，并将结果存储到新的 byte 数组。

⭕ 解码：byte[]–>String:调用String的构造器

序号构造器作用
1String(byte[])通过使用平台的默认字符集解码指定的 byte 数组，构造一个新的 String
2String(byte[]，int offset，int length)用指定的字节数组的一部分,即从数组起始位置offset开始取length个字节构造一个字符串对象

⭕ 注意：解码时，要求解码使用的字符集必须与编码时使用的字符集一致，否则会出现乱码。

代码演示：

@Test
    public void test1() throws UnsupportedEncodingException {
        String str1 = "abc123中国";
        byte[] bytes = str1.getBytes();
        //使用默认的字符集，进行编码。
        System.out.println(Arrays.toString(bytes));//[97, 98, 99, 49, 50, 51, -28, -72, -83, -27, -101, -67]

        //使用gbk字符集进行编码。
        byte[] gbks = str1.getBytes("gbk");
        System.out.println(Arrays.toString(gbks));//[97, 98, 99, 49, 50, 51, -42, -48, -71, -6]

        //使用默认的字符集，进行解码。
        String str2 = new String(bytes);
        System.out.println(str2);//abc123中国

        String str3 = new String(gbks);
        //出现乱码。原因：编码集和解码集不一致！
        System.out.println(str3);//abc123�й�


        String str4 = new String(gbks, "gbk");
        没有出现乱码。原因：编码集和解码集一致！
        System.out.println(str4);//abc123中国

        String str = "中";
         -128~127
        System.out.println(str.getBytes("ISO8859-1").length);//1
        System.out.println(str.getBytes("GBK").length);//2
        System.out.println(str.getBytes("UTF-8").length);//3
        
         乱码，表示不了中文
        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"));//中
    }

六、String、StringBuffer、StringBuilder

1、概述

1.1 String(JDK1.0)

⭕ 不可变的字符序列；

⭕ 底层使用char[]存储

1.2 StringBuffer(JDK1.0)

⭕ 可变的字符序列；

⭕ 线程安全的，效率低；

⭕ 底层使用char[]存储，可以对字符串内容进行增删，此时不会产生新的对象。

⭕ 很多方法与String相同。

⭕ 作为参数传递时，方法内部可以改变值。

⭕ StringBuffer类不同于String，其对象必须使用构造器生成。有三个构造器：

序号构造器作用
1StringBuffer()初始容量为16的字符串缓冲区
2StringBuffer(int size)构造指定容量的字符串缓冲区
3StringBuffer(String str)将内容初始化为指定字符串内容

1.3 StringBuilder(JDK 5.0)

⭕ 可变的字符序列

⭕ jdk5.0新增的，线程不安全的，效率高；底层使用char[]存储。

代码演示：

    @Test
    public void test14(){
        StringBuffer sb1 = new StringBuffer("abc");
        sb1.setCharAt(0,'m');
        System.out.println(sb1);//mbc

        StringBuffer sb2 = new StringBuffer();
        System.out.println(sb2.length());//0
    }

注意：作为参数传递的话，方法内部String不会改变其值，StringBuffer和StringBuilder 会改变其值。

2、源码分析

    String str = new String();//char[] value = new char[0];
    String str1 = new String("abc");//char[] value = new char[]{'a','b','c'};

    StringBuffer sb1 = new StringBuffer();//char[] value = new char[16];底层创建了一个长度是16的数组。
    System.out.println(sb1.length());//0
    sb1.append('a');//value[0] = 'a';
    sb1.append('b');//value[1] = 'b';

    StringBuffer sb2 = new StringBuffer("abc");//char[] value = new char["abc".length() + 16];
    System.out.println(sb2.length());//3

⭕ 扩容问题:如果要添加的数据底层数组盛不下了，那就需要扩容底层的数组。 默认情况下，扩容为原来容量的 2倍 + 2，同时将原有数组中的元素复制到新的数组中。

⭕ 开发中建议大家使用：StringBuffer(int capacity) 或 StringBuilder(int capacity)

3、StringBuffer的常用方法

序号方法作用
1StringBuffer append(xxx)提供了很多的append()方法，用于进行字符串拼接
2StringBuffer delete(int start,int end)删除指定位置的内容
3StringBuffer replace(int start,int end, String str)把[start,end)位置替换为str
4StringBuffer insert(int offset, xxx)在指定位置插入xxx
5StringBuffer reverse()把当前字符序列逆转
6public int indexOf(String str)返回字符串str的索引
7public String substring(int start,int end)返回一个从start开始到end索引结束的左闭右开区间的子字符串
8public int length()获取长度
9public char charAt(int n )获取指定位置的字符
10public void setCharAt(int n ,char ch)将指定位置的字符设置为ch

总结：

总结方法
增append(xxx)
删delete(int start,int end)
改setCharAt(int n ,char ch) / replace(int start, int end, String str)
查charAt(int n )
插insert(int offset, xxx)
长度length()
遍历for() + charAt() / toString()

注意：

⭕ 当append()和insert()时，如果原来value数组长度不够，可扩容。

⭕ 如上这些方法支持方法链操作

代码演示1：

 @Test
    public void test6(){
        StringBuffer s1 = new StringBuffer("abc");
        s1.append(1);
        s1.append('1');
        System.out.println(s1);//abc11
        String s2 = s1.substring(1, 3);
        System.out.println(s1);//abc11
        System.out.println(s1.length());//5
        System.out.println(s2);//bc
        s1.delete(2,4);
        System.out.println(s1);//ab1
        s1.replace(2,4,"hello");
        System.out.println(s1);//abhello
        s1.insert(2,false);
        System.out.println(s1);//abfalsehello
        s1.reverse();
        System.out.println(s1);//olleheslafba

    }

代码演示2：

    @Test
    public void test1() {
        String str = null;
        StringBuffer sb = new StringBuffer();
        sb.append(str);
        System.out.println(sb.length());//4
        System.out.println(sb);//null
        StringBuffer sb1 = new StringBuffer(str);
        System.out.println(sb1);//报错
    }

4、对比String、StringBuffer、StringBuilder三者的效率：

效率从高到低排列：StringBuilder > StringBuffer > String

代码演示：

    @Test
    public void test3(){
        //初始设置
        long startTime = 0L;
        long endTime = 0L;
        String text = "";
        StringBuffer buffer = new StringBuffer("");
        StringBuilder builder = new StringBuilder("");
        //开始对比
        startTime = System.currentTimeMillis();
        for (int i = 0; i < 20000; i++) {
            buffer.append(String.valueOf(i));
        }
        endTime = System.currentTimeMillis();
        System.out.println("StringBuffer的执行时间：" + (endTime - startTime));//StringBuffer的执行时间：4

        startTime = System.currentTimeMillis();
        for (int i = 0; i < 20000; i++) {
            builder.append(String.valueOf(i));
        }
        endTime = System.currentTimeMillis();
        System.out.println("StringBuilder的执行时间：" + (endTime - startTime));//StringBuilder的执行时间：3

        startTime = System.currentTimeMillis();
        for (int i = 0; i < 20000; i++) {
            text = text + i;
        }
        endTime = System.currentTimeMillis();
        System.out.println("String的执行时间：" + (endTime - startTime));//String的执行时间：1284

    }
_GGBond_
关注
专栏目录
Java中String、StringBuffer、StringBuilder的区别详解
09-02
Java中的字符串处理是编程中常见的任务，涉及到三个关键类：String、StringBuffer和StringBuilder。它们在功能上相似，但有着重要的区别，主要体现在字符串的可变性、线程安全性和性能方面。 1. 可变性 - String类...
Java 的 String、StringBuffer 和 StringBuilder（一文讲透）
小康2022的博客
05-28 1686
你知道 Java 中的 String、StringBuffer 和 StringBuilder 的发展历史吗？你知道它们的区别吗？你知道它们的适用场景吗？想知道就赶紧进来看看吧！
java string与stringbuffer与stringbuilder详解
左安青的博客
05-13 1001
Java中的字符串类型有三种：String、StringBuffer和StringBuilder。它们的底层实现有很大的不同，下面我们来详细了解一下。
还搞不清楚String、StringBuilder、StringBuffer？
最新发布
qq_73617408的博客
07-27 2155
代码解释：在堆中创建StringBuilder对象，然后builder指向该对象，"hello"存在StringBuilder 的成员变量value中，value是指向堆的一个byte[]对象，这个byte[]对象的值为"hello"。代码解释：在堆中创建StringBuffer对象，然后buffer指向该对象，"hello"存在StringBuffer的成员变量value中，value是指向堆的一个byte[]对象，这个byte[]对象的值为"hello"。如果大于0，则需要扩容，然后通过复制达到扩容。
String、StringBuilder、StringBuffer区别；String底层详解，实例化、拼接、比较；String为什么不可变
qq_44700578的博客
04-21 1897
String、StringBuilder、StringBuffer区别；String底层详解，实例化、拼接、比较；String str1="abc"和String str2=new String("abc")区别；String为什么不可变
String、StringBuilder、StringBuffer、StringJoiner类的常用方法，以及区别
qq_46030254的博客
05-08 917
文章记载了String，StringBuilder 和 StringBuffer的区别点，
二、Java中的String类、StringBuffer类、StringBuilder类
在校大学生一枚
04-14 2962
String类、StringBuffer类、StringBuilder类
java String、StringBuilder和StringBuffer的区别详解
08-25
Java中的`String`、`StringBuilder`和`StringBuffer`都是用来处理字符串的类，它们各自有不同的特性和适用场景。在理解它们之间的区别之前，我们首先要知道它们的共同点。 **共同点：** 1. **都是字符串类**：这三...
Java 中String StringBuilder 与 StringBuffer详解及用法实例
08-31
在Java编程语言中，String、StringBuilder和StringBuffer都是用来处理字符串的重要类，它们各有特点，适用于不同的场景。这里我们将深入探讨这三个类的区别、特性和使用策略。 首先，String类是不可变的，这意味着...
Java String 和StringBuffer的详解及区别
08-30
Java String 和StringBuffer 的详解及区别 Java String 和StringBuffer 是 Java 语言中两个基本的字符串类，它们都是用于存储和操作字符串的，但是它们之间有着很大的区别。 String 类 String 类表示内容不可改变...
Java软件开发实战 Java基础与案例开发详解 9-2 StringBuffer和String Builder类共9页.pdf
07-07
### Java软件开发实战：StringBuffer和StringBuilder类 #### 1. 概述 在Java编程中，处理字符串是一项常见的需求。对于需要频繁修改的字符串，使用`String`类可能会导致性能问题，因为每次修改都会创建一个新的`...
String、StringBuffer和StringBuilder的详解
麒麟阁
02-26 5367
1.值的可变性String内部的value值是final修饰的，所以，它是不可变类；因此，每次修改String的值，都会产生一个新的对象。StringBuffer和StringBuilder是可变类，它们在字符串变更的时候，不会产生新的对象。2.线程安全String是不可变类，所以它是线程安全的。StringBuilder不是线程安全的。StringBuffer是线程安全的，因为它的每个操作方法都加了synchronized同步关键字。单线程情况下，建议使用StringBuilder。
String、StringBuffer、StringBuilder三者的区别、扩容机制等源码解析（详解）
PeaK欢迎大家评论留言，一起交流Java技术
09-07 3346
本篇文章主要从源码角度阐述了String的不可变性，StringBuffer和StringBuilder的扩容机制，三者的效率、线程安全等问题
CentOS 下 7z的安装
2401_84048161的博客
04-14 837
这份文档从构建一个键值数据库的关键架构入手，不仅带你建立起全局观，还帮你迅速抓住核心主线。除此之外，还会具体讲解数据结构、线程模型、网络框架、持久化、主从同步和切片集群等，帮你搞懂底层原理。相信这对于所有层次的Redis使用者都是一份非常完美的教程了。你的支持，我的动力；祝各位前程似锦，offer不断！！！《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！
Java基础：String、StringBuffer、StringBuilder的区别
热门推荐
weixin_42188778的博客
05-01 3万+
这篇文章主要介绍了String、StringBuffer、StringBuilder的区别详细教程,本文通过图文并茂的形式给大家介绍的非常详细，对大家的学习或工作具有一定的参考借鉴价值，需要的朋友可以参考下。放假在家里休息，闲来无事，想巩固巩固自己的基础知识。Java基础这个我会一直更新的，希望大家关注 收藏 点赞。
String、StringBuilder、StringBuffer的区别（超详细）
m0_51236688的博客
07-01 1902
String、StringBuilder、StringBuffer的区别，StringBuilder线程不安全，StringBuffer的常用方法，String的常用方法，StringBuilder的常用方法，String详解，StringBuilder详解，StringBuffer详解
String、StringBuilder和StringBuffer三者区别
hpf_coding的博客
10-01 9804
一、字符串的连接效率问题   Java当中对数组初始化之后，该数组所占的内存空间、数组长度的都是不可变的，我们在编写程序的时候，对于数组的初始化都需要给定长度才行。对于创建一个字符串，为字符串对象分配内存空间，会耗费掉一定的时间与空间的代价，也即CPU和内存的代价消耗，作为最基础的数据类型，大量频繁的创建字符串，会极大程度地影响程序的性能。   每次连接字符串时都会创建一个新的String对象，随着拼接次数的增多，这个对象会越来越大。比如说，进行100次拼接需要创建100个String对象才能够达到目的，对
Java中String、StringBuilder与StringBuffer
QYgujingjing的专栏
07-05 249
Java中String、StringBuilder与StringBuffer
Java学习笔记——String、StringBuffer、StringBuilder
D77的博客
05-01 1445
Java中处理字符串常用的三个类分别为：String、StringBuffer、StringBuilder 本文将对以下几方面阐述这三类的区别。 1、String、StringBuffer、StringBuffer都是final类，不允许被继承； 2、String声明的对象进行内容修改会产生一个新的对象，而StringBuffer、StringBuilder则是对自身进行修改，不会产生新的对象； 代码实例1 String str = new String("String"); StringBuf
评论 10
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

_GGBond_

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

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

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

打赏作者

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

抵扣说明：

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

余额充值