String、StringBuilder与StringBuffer

最新推荐文章于 2024-06-02 22:05:12 发布
最新推荐文章于 2024-06-02 22:05:12 发布
阅读量135 收藏
点赞数
分类专栏： JAVA 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43788522/article/details/115569197
版权

String、StringBuilder与StringBuffer

一、 String

1、String概述

String:字符串，使用一对""引起来表示。

  1. String声明为final的，不可被继承。
    在这里插入图片描述

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

  3. String内部定义了final char[] value用于存储字符串数据
    在这里插入图片描述

  4. String:代表不可变的字符序列。简称不可变性（体现：1.当对字符串重新赋值时，需要重新指定内存区域赋值，不能使用原有的value进行赋值；2.当对现有的字符串进行连接操作时，也需要重新指定内存区域赋值，不能使用原有的value进行赋值；3.当调用String的replace()方法修改指定字符或字符串时，也需要重新指定内存区域赋值，不能使用原有的value进行赋值。）

  5. 通过字面量的方式（区别于new）给一个字符串赋值，此时的字符串声明在字符串常量池中。

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

public void test1(){
        String s1="abc";//字面量的定义方式
        String s2="abc";
        s1="hello";
        System.out.println(s1 == s2);

        System.out.println(s1);//hello
        System.out.println(s2);//abc

        System.out.println("*******************");

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

        System.out.println("******************");

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

    }

2、创建字符串对象的两种方式

  1. 采用字面值的方式赋值
String str="abc";
  1. 采用new关键字新建一个字符串对象。
String str=new String("abc");

Java为了避免产生大量的字符串对象，设计了一个字符串池（String Pool），通过字面值方式创建的字符串对象都会存在字符串池中，其字符串常量池中的字符串不会重复，以便可以被共享使用，提高存储效率。

工作原理是：
当使用初始化的方式创建对象时，JVM会首先检查字符串池中是否存在值相等的字符串，如果存在，则不进行创建，而是直接返回字符串池中该字符串的引用地址。如果不存在，则创建该对象，并放入字符串池中，返回新创建的字符串的引用地址。

当使用new关键字创建对象时，JVM仍然首先检查字符串池中是否存在要创建的字符串，如果不存在，则在字符串池中创建一个字符串对象，然后在堆内存中继续创建一个字符串对象，返回该对象的引用地址。如果存在，则只在堆内存中创建一个字符串对象，返回该对象的引用地址。
1. 采用字面值的方式赋值内存图

String str="abc";

在这里插入图片描述
2.通过new+构造器的方式内存图
面试题：String str=new String(“abc”);方式创建对象，在内存中创建了几个对象？

两个：一个是堆空间中new结构，另一个是char[]对应的常量池中的数据：“abc”。其中堆中创建的字符串对象的value数组指向常量池中字符串的value数组。原因如下：

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

3、字符串拼接

1、字面量的拼接
在这里插入图片描述

上面的字符串，会进行编译期优化，直接合并成为完整的字符串，我们可以反编译验证：
在这里插入图片描述
内存结构图：
在这里插入图片描述
2、有变量参与的字符串拼接

在这里插入图片描述
a变量在编译的时候不知道a是“abc”字符串，所以不会进行编译期优化，不会直接合并为“abcdef”。下面通过反汇编来进行查看。反汇编过程是为了更好的帮我们分析字节码文件是如何进行解析的：
在这里插入图片描述
上面调用了StringBuilder的toString()方法重新返回了一个字符串对象，将该对象的引用给了b。
在这里插入图片描述
结论：
在这里插入图片描述
在这里插入图片描述
面试题

4、String中的常用方法

public class StringMethodTest {
        /*
        替换：
        String replace(char oldChar, char newChar)：返回一个新的字符串，它是通过用 newChar 替换此字符串中出现的所有 oldChar 得到的。
        String replace(CharSequence target, CharSequence replacement)：使用指定的字面值替换序列替换此字符串所有匹配字面值目标序列的子字符串。
        String replaceAll(String regex, String replacement)：使用给定的 replacement 替换此字符串所有匹配给定的正则表达式的子字符串。
        String replaceFirst(String regex, String replacement)：使用给定的 replacement 替换此字符串匹配给定的正则表达式的第一个子字符串。
        匹配:
        boolean matches(String regex)：告知此字符串是否匹配给定的正则表达式。
        切片：
        String[] split(String regex)：根据给定正则表达式的匹配拆分此字符串。
        String[] split(String regex, int limit)：根据匹配给定的正则表达式来拆分此字符串，最多不超过limit个，如果超过了，剩下的全部都放到最后一个元素中。
     */
        @Test
        public void test1(){
            String str1="你走之后，一个夏季熬成一个秋。我的书上你的正楷眉清目秀，一字一字宣告我们和平分手，好委婉的交流，还带一点征求";
            System.out.println(str1.replace("我", "你"));

            System.out.println(str1.replace("你走之后", "我走之后"));

            //把字符串中的数字替换成，如果结果中开头和结尾有，的话去掉
            String str = "12hello34world5java7891mysql456";
            String s1 = str.replaceAll("\\d+", ",").replaceAll("^,|,$", "");
            System.out.println(s1);

            //判断str字符串中是否全部有数字组成，即1-n个数字组成
            boolean matches=str.matches("\\d+");
            System.out.println(matches);
            //判断这是否是一个杭州的固定电话
            String tel="0571-4534289";
            boolean result = tel.matches("0571-\\d{7,8}");
            System.out.println(result);

            str="hello|world|java";
            String[] strs = str.split("\\|");
            System.out.println(Arrays.toString(strs));

            str="hello.world.java";
            String[] strs2 = str.split("\\.");
            System.out.println(Arrays.toString(strs2));

        }
         /*
        boolean endsWith(String suffix)：测试此字符串是否以指定的后缀结束
        boolean startsWith(String prefix)：测试此字符串是否以指定的前缀开始
        boolean startsWith(String prefix, int toffset)：测试此字符串从指定索引开始的子字符串是否以指定前缀开始

        boolean contains(CharSequence s)：当且仅当此字符串包含指定的 char 值序列时，返回 true
        int indexOf(String str)：返回指定子字符串在此字符串中第一次出现处的索引
        int indexOf(String str, int fromIndex)：返回指定子字符串在此字符串中第一次出现处的索引，从指定的索引开始
        int lastIndexOf(String str)：返回指定子字符串在此字符串中最右边出现处的索引
        int lastIndexOf(String str, int fromIndex)：返回指定子字符串在此字符串中最后一次出现处的索引，从指定的索引开始反向搜索

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

     */
         @Test
    public void test3(){

             String  str="待我长发及腰 少年娶我可好 待你青丝馆正 铺十里红妆可愿 却怕长发及腰 少年倾心他人 待你青丝馆正 笑看君怀她笑颜";
             System.out.println(str.endsWith("笑看君怀她笑颜"));//true

             System.out.println(str.startsWith("少年娶我可好"));//false
             System.out.println(str.startsWith("待我长发及腰", 0));//true

             System.out.println(str.contains("铺十里红妆可愿"));//true
             System.out.println(str.indexOf("少年倾心他人"));//36
             System.out.println(str.indexOf("少年娶我可好", 7));//7
             System.out.println(str.lastIndexOf("笑"));//55
             System.out.println(str.lastIndexOf("待"));//43

         }
             /*
            int length()：返回字符串的长度： return value.length
            char charAt(int index)： 返回某索引处的字符return value[index]
            boolean isEmpty()：判断是否是空字符串：return value.length == 0
            String toLowerCase()：使用默认语言环境，将 String 中的所有字符转换为小写
            String toUpperCase()：使用默认语言环境，将 String 中的所有字符转换为大写
            String trim()：返回字符串的副本，忽略前导空白和尾部空白
            boolean equals(Object obj)：比较字符串的内容是否相同
            boolean equalsIgnoreCase(String anotherString)：与equals方法类似，忽略大小写
            String concat(String str)：将指定字符串连接到此字符串的结尾。 等价于用“+”
            int compareTo(String anotherString)：比较两个字符串的大小
            String substring(int beginIndex)：返回一个新的字符串，它是此字符串的从beginIndex开始截取到最后的一个子字符串。
            String substring(int beginIndex, int endIndex) ：返回一个新字符串，它是此字符串从beginIndex开始截取到endIndex(不包含)的一个子字符串。
     */
            @Test
             public  void test4(){
                 String str="戏子入画 一生天涯 彼年豆蔻 谁许谁地老天荒";
                 System.out.println(str.length());//22
                 System.out.println(str.charAt(3));//画
                 System.out.println(str.isEmpty());//false

                 str="Life was like a box of chocolates, you never know what you’re gonna get";
                 System.out.println(str.toLowerCase());
                 System.out.println(str.toUpperCase());

                 str="    举目见日 不见长安   ";
                 System.out.println(str.trim());

                 System.out.println("我行四方 以日以年".equals(str));//false

             }

}

两个重要方法的解析：
1、equals()方法

String s6 = new String("abc");
String s7 = new String("abc");
System.out.println(s6.equals(s7));

在这里插入图片描述
2、compareTo（）方法

String s8 = new String("abc");
String s9 = new String("abc");
System.out.println(s8.compareTo(s9));

在这里插入图片描述

5、String与其它类的转换

public class StringConversionToOtherClass {

    /*
      复习：
      String与基本数据类型、包装类之间的转换。

      String-->基本数据类型、包装类：调用包装类的静态方法：parseXxx(str)
      基本数据类型、包装类-->String：调用String重载的valueOf(xxx)
     */
    @Test
    public void test1(){
        String str1="123";
        //int num=(int)str1;//错误的
        int i = Integer.parseInt(str1);

        //int-->String
        String value = String.valueOf(i);
        String str2= i+"";
        System.out.println(str1==str2);//false
    }

    /*
        String与char[]之间的转换

        String--->char[]：调用String的toCharArray()
        char[]--->String:调用String的构造器
     */
    @Test
    public void test2(){
        String str1="abc123";
        char[] charArray = str1.toCharArray();
        System.out.println(Arrays.toString(charArray));

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

    /*
        String 与byte[]之间的转换
        编码：String-->byte[]：调用String的getBytes()
        解码：byte[]-->String:调用String的构造器

        编码：字符串-->字节（看的懂-->看不懂的二进制数据)
        解码：编码的逆过程，字节-->字符串（看不懂的二进制数据-->看得懂）
        说明：解码时，要求解码使用的字符集必须与编码时使用的字符集一致，否则会出现乱码。
     */

    @Test
    public void test3() throws UnsupportedEncodingException {
        String str1="abc123中国";
        byte[] bytes=str1.getBytes();//使用默认的字符集进行编码。
        System.out.println(Arrays.toString(bytes));

        byte[] gbks=str1.getBytes("gbk");
        System.out.println(Arrays.toString(gbks));

        String str2=new String(bytes);//使用默认的编码格式进行解码
        System.out.println(str2);

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

        String str4=new String(gbks,"gbk");
        System.out.println(str4);
    }
}

二、StringBuilder、StringBuffer

1、源码分析

String源码分析

方式一：String str = new String();//底层存储：char[] value = new char[0];

在这里插入图片描述

方式二：String str1 = new String("abc");//底层存储：char[] value = new char[]{'a','b','c'};

在这里插入图片描述
StringBuilder、StringBuffer源码分析
StringBuilder和StringBuffer类是一样的，唯一区别是StringBuilder线程不安全，StringBuffer线程安全。我们以StringBuffer为例。

StringBuffer的两个重要属性：
在这里插入图片描述

方式一：StringBuffer sb1 = new StringBuffer();//char[] value = new char[16];底层创建了一个长度是16的数组。

在这里插入图片描述
在这里插入图片描述

sb1.append('a');//value[0] = 'a';
 sb1.append('b');//value[1] = 'b';

方式二：StringBuffer sb2 = new StringBuffer("abc");//char[] value = new char["abc".length() + 16];

在这里插入图片描述

方式三：StringBuffer str=new StringBuffer(16);

在这里插入图片描述
在这里插入图片描述
扩容问题：如果要添加的数据底层数组盛不下了，那就需要扩容底层的数组。
默认情况下，扩容为原来容量的2倍+2，同时将原有数组中的元素复制到新的数组中。
在这里插入图片描述
指导意义：开发中如果大概知道要多少个容量，建议大家使用：StringBuffer(int capacity)或StringBuilder(int capacity)。可以避免数组的拷贝。

/**
 * 关于String、StringBuilder、StringBuffer的使用
 * @author 刘瘦瘦
 * @create 2021-04-09-10:25
 */
public class StringBufferBuilderTest {

    /*
        String、StringBuffer、StringBuilder三者的异同？
        String：不可变的字符系列；底层使用char[]存储
        StringBuffer：可变的字符序列：线程安全的，效率低；底层使用char[]存储
        StringBuilder：可变的字符序列；jdk5.0新增的，线程不安全的，效率高；底层使用char[]存储

        源码分析：
          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());//
    sb1.append('a');//value[0] = 'a';
    sb1.append('b');//value[1] = 'b';

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

    问题1:system.out.println(sb2.length());//3
    问题2：扩容问题：如果要添加的数据底层数组盛不下了，那就需要扩容底层的数组。
    默认情况下，扩容为原来容量的2倍+2，同时将原有数组中的元素复制到新的数组中。

        指导意义：开发中建议大家使用：StringBuffer(int capacity)或StringBuilder(int capacity)
     */
    @Test
    public void test1(){
        StringBuffer sb1=new StringBuffer("abc");
        sb1.setCharAt(0,'m');
        System.out.println(sb1);

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

      /*
    StringBuffer的常用方法：
    StringBuffer append(xxx)：提供了很多的append()方法，用于进行字符串拼接
    StringBuffer delete(int start,int end)：删除指定位置的内容
    StringBuffer replace(int start, int end, String str)：把[start,end)位置替换为str
    StringBuffer insert(int offset, xxx)：在指定位置插入xxx
    StringBuffer reverse() ：把当前字符序列逆转
    public int indexOf(String str)
    public String substring(int start,int end):返回一个从start开始到end索引结束的左闭右开区间的子字符串
    public int length()
    public char charAt(int n )
    public void setCharAt(int n ,char 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()
     */

      @Test
      public void test2(){
          StringBuffer sb=new StringBuffer();
          sb.append("不知余生几光阴 ").append("且待佳人日日新");
          System.out.println(sb);
          sb.delete(0,1);
          System.out.println(sb);
          System.out.println(sb.replace(0, 4, "不知余生"));
          System.out.println(sb.length());
          System.out.println(sb.insert(14,'!'));
          System.out.println(sb.reverse());

          sb=new StringBuffer();
          System.out.println(sb.append("全世界拼成首诗").append("我爱你当做最后一行"));
          System.out.println(sb.substring(7, 10));
      }
}
安慕希ai
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
StringBuffer与stringBuilder
lvxinyan
07-31 7405
String是不可变的，而StringBuffer和StringBuilder是可变类。StringBuffer是线程安全和同步的，而StringBuilder不是。这就是StringBuilder比StringBuffer快的原因。字符串连接运算符(+)在内部使用StringBuilder类。对于非多线程环境中的字符串操作，我们应该使用StringBuilder否则使用StringBuffer类。...
C# StringBuilder 的使用
熊思雨的博客
08-06 8910
字符串一旦创建就不可修改大小，每次使用System.String类中的方法之一时，都要在内存中创建一个新的字符串对象，这就需要为该新对象分配新的空间。在需要对字符串执行重复修改的情况下，与创建新的String对象相关的系统开销可能会非常昂贵。如果要修改字符串而不创建新的对象，则可以使用System.Text.StringBuilder类。所以对字符串添加或删除操作不频繁的话，就几个固定的string累加的时候就不需要StringBuilder了,毕竟StringBuilder的初始化也是需要时间的。...
StringBuilder的基本操作
qq_48269763的博客
07-16 589
StringBuilder的基本操作，StringBuilder的作用是可以提高字符串的操作效率。
String，StringBuffer ，StringBuilder 的区别及其详解
最新发布
m0_73940426的博客
06-02 1399
String 类代表的字符串,程序中任何字符串都是String类的对象字符串是常量；它们的值在创建之后不能更改。通过上图发现String被final修饰，所以字符串的值创建之后就不可以被修改，具有不可变性也就是因为String类字符串定义后不能改变，所以提供了StringBuffer类（字符串缓冲区）来操作字符串。可将字符串缓冲区安全地用于多个线程看完上面，你也就知道String 和StringBuffer的最大区别了那就是StringBuffer创建的字符串可以改变。
java中stringBuilder的用法
My Heart Will Go On
06-02 17万+
String对象是不可改变的。每次使用 System.String类中的方法之一时，都要在内存中创建一个新的字符串对象，这就需要为该新对象分配新的空间。在需要对字符串执行重复修改的情况下，与创建新的 String对象相关的系统开销可能会非常昂贵。如果要修改字符串而不创建新的对象，则可以使用System.Text.StringBuilder类。例如，当在一个循环中将许多字符串连接在一起时，使用
String,StringBuffer与StringBuilder的区别??
热门推荐
Java天空
01-24 79万+
String 字符串常量StringBuffer 字符串变量（线程安全）StringBuilder 字符串变量（非线程安全） 简要的说， String 类型和 StringBuffer 类型的主要性能区别其实在于 String 是不可变的对象, 因此在每次对 String 类型进行改变的时候其实都等同于生成了一个新的 String 对象，然后将指针指向新的 String 对象，所以经常改变内容的字
Java 中String StringBuilder 与 StringBuffer详解及用法实例
08-31
其中，StringBuilder是Java 5引入的新类，它与StringBuffer功能类似，但不保证线程安全。这意味着在单线程环境下，StringBuilder通常比StringBuffer更快，因为它省去了同步开销。 StringBuffer是在多线程环境下使用...
java String、StringBuilder和StringBuffer的区别详解
08-25
Java中的`String`、`StringBuilder`和`StringBuffer`都是用来处理字符串的类，它们各自有不同的特性和适用场景。在理解它们之间的区别之前，我们首先要知道它们的共同点。 **共同点：** 1. **都是字符串类**：这三...
String，StringBuffer，StringBuilder区别
09-14
String，StringBuffer，StringBuilder区别。几乎所有的应用开发都离不开操作字符串，理解字符串的设计和实现以及相关 工具如拼接类的使用，对写出高质量代码是非常有帮助的
String、StringBuilder、StringBuffer 用法比较
09-07
stringbuilder用法 String、StringBuilder、StringBuffer 用法比较String、StringBuilder、StringBuffer 用法比较String、StringBuilder、StringBuffer 用法比较String、StringBuilder、StringBuffer 用法比较String...
C#中String StringBuilder StringBuffer类的用法
08-30
C#中String StringBuilder StringBuffer类的用法 C#中String、StringBuilder和StringBuffer三个类是字符串操作中经常使用的类，本文将对这三个类的用法进行详细介绍。 String类 String类是C#中最基本的字符串类型...
Java中StringBuilder字符串类型的操作方法及API整理
09-02
Java中的StringBuffer类继承于AbstractStringBuilder,用来创建非线程安全的字符串类型对象,下面即是对Java中StringBuilder字符串类型的操作方法及API整理
简单的讲一下String，StringBuilder和StringBuffer的区别
weixin_43786099的博客
08-27 1万+
String、StringBuilder和StringBuffer的区别 String类： String是一个长度不可变的字符序列，底层是一个被final修饰的char[]数组，所以说，任何对 String 类型进行改变的操作实际上都是重新生成了一个新的String对象，然后将指针指向新的 String 对象，这样不仅效率低下，而且大量浪费有限的内存空间，所以经常改变内容的字符串最好不要用 String 。 上图中，首先执行了一个String s = “JAVA” 对象，对象s入栈，对应的堆中生成了...
StringBuffer与StringBuilder的区别
m0_46331585的博客
09-28 2万+
StringBuffer与StringBuilder的区别 一、String,StringBuffer与StringBuilder String字符串常量 String的值是不可变的，这就导致每次对String的操作都会生成新的String对象，这样不仅效率低下，而且大量浪费有限的内存空间。 StringBuffer与StringBuilder是字符串变量 StringBuffer 和 StringBuilder 类的对象能够被多次的修改，并且不产生新的未使用对象 二、StringBuf
String、stringBuffer、stringBuilder详解
LYQ20010417的博客
03-02 422
String、stringBuffer、stringBuilder详解
String、StringBuffer和StringBuilder
读书郎
01-06 284
String 类是不可变类，即一旦一个 String 对象被创建以后，包含在这个对象中的字符序列是不可改变的，直至这个对象被销毁。 `StringBuilder `类代表可变字符串对象。
String、StringBuilder和StringBuffer的理解
qq_26930295的博客
01-19 1302
(1) 在编译阶段就能够确定的字符串常量，完全没有必要创建String或StringBuffer对象。直接使用字符串常量的"+"连接操作效率最高。(2) StringBuffer对象的append效率要高于String对象的"+"连接操作。(3) 不停的创建对象是程序低效的一个重要原因。那么相同的字符串值能否在堆中只创建一个String对象那。显然拘留字符串能够做到这一点，除了程序中的字符串常量会被JVM自动创建拘留字符串之外，调用String的intern()方法也能做到这一点。
String,Stringbuilder,Stringbuffer的区别
Wdoing的博客
10-30 1662
String,Stringbuilder,Stringbuffer的区别
StringBuilder和StringBuffer的区别
rj2017211811的博客
10-19 2万+
StringBuilder和StringBuffer都实现了继承了AbstractStringBuilder(核心类，对char[]进行操作)，实现了Serializable接口(支持序列化和反序列化)和CharSequence(主要定义了length、charAt、subSquence方法) StringBuilder和StringBuffer主要不同在于，StringBuffer的append、delete、replace、length等方法前都加了synchronized关键字保证线程安全，而St
String StringBuilder和StringBuffer
08-24
- *1* *2* *3* [String、StringBuffer与StringBuilder类详解](https://blog.csdn.net/weixin_38568503/article/details/113794751)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值