资讯详情

Java String、StringBuffer 和 StringBuilder 的区别和理解

String

String：字符串常量，字符串长度不变。Java中String是immutable(不可变)。

String声明为final的，不可被继承

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

String内部定义final的char型数组（final char用于存储字符串数据。

String代表不可变的字符序列。不变性。

/** The value is used for character storage. */ private final char value[];   /** The offset is the first index of the storage that is used. */ private final int offset;   /** The count is the number of characters in the String. */ private final int count;

初始化方法：常用的两种：

 ////通过字面量定义 String s1 = "java"; //通过new   构造器方式 String s2 = new String("java2");

String的常用用法详解

String s1 ="HelloWorld";

System.out.println(s1.length());//10

 

     

String s1 ="HelloWorld";
System.out.println(s1.charAt(5));//W

String s1 ="HelloWorld";
System.out.println(s1.isEmpty());//false

 

String s1 ="HelloWorld";
String s2 = s1.toLowerCase();
System.out.println(s2);//helloworld

toLowerCase() 小写

String str = "HELLO" ; 
System.out.println(str.toLowerCase());  //hello


String str = "hello" ; 
System.out.println(str.toUpperCase());  // HELLO

 

String s3 = "     he   ll   o   w  or l d      ";
String s4 = s3.trim();
System.out.println("----------" + s4 + "-----------");
//"he   ll   o   w  or l d"

 

 String s6 = "abc";
 String s7 = "cde";
 System.out.println(s6.equals(s7));//false

 

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

 

String s6 = "abc";
String s7 = "cde";
int i = s6.compareTo(s7);
System.out.println(i);//-2

 

 String s8 = "你是如此美丽";
 String s9 = s8.substring(2);
 System.out.println(s9);//如此美丽

String str1 = "helloworld";
String str2 = "wo";
boolean b4 = str1.contains(str2);//true

String str1 = "helloworld";
System.out.println(str1.indexOf("lo"));//3
//若不存在，返回-1

 

String str1 = "helloworld";
System.out.println(str1.lastIndexOf("o"));//6

 

StringBuffer 

 接口文档:详情可自行查看

  • StringBuffer 类的对象可被多次修改，且对 StringBuffer 对象本身操作；
  • StringBuffer 类使用 

  • StringBuffer()：构造一个没有字符的字符串缓冲区，初始容量为16字符；
  • StringBuffer(String str)：构造一个初始化为指定内容的字符串缓冲区；
  • StringBuffer(int capacity)：构造一个没有字符的字符串缓冲区和指定的初始容量；  

实例：

/* 构造方法 */
// 构造一个没有字符的字符串缓冲区，初始容量为16
StringBuffer sb1 = new StringBuffer();
System.out.println(sb1.capacity()); // 16
System.out.println(sb1.length()); // 0
 
// 构造一个指定字符串的字符串缓冲区，容量 = 16(初始容量) + 字符串长度
StringBuffer sb2 = new StringBuffer("Java");
System.out.println(sb2.capacity()); // 20 = 16 + 4
System.out.println(sb2.length());  // 4
 
// 构造指定容量的字符串缓冲区
StringBuffer sb3 = new StringBuffer(12);
System.out.println(sb3.capacity()); // 12
System.out.println(sb3.length()); // 0

  1. append(): 追加，在字符串末尾添加；
  2. delete()：删除，删除指定索引处的字符；
  3. replace()：替换，用指定的String中的字符替换子字符串中的String；
  4. reverse()：反转；
  5. substring()：截取返回一个新的 String，它包含此序列当前所包含的字符子序列
  6. insert()：插入，指定位置插入字符串；  
/* 常用方法 */
StringBuffer str1 = new StringBuffer("I love ");
 
// append(): 追加
System.out.println("append()前str1: " + str1);  // I love
str1.append("Java!");
System.out.println("append()后str1: " + str1);  // I love Java!
 
// delete(): 删除
System.out.println("delete()前str1: " + str1);  // I love Java!
str1.delete(3, 5);
System.out.println("delete()后str1: " + str1);  // I le Java!
 
// replace(): 替换
System.out.println("replace()前str1: " + str1);  // I le Java!
str1.replace(1, 4, "*******");
System.out.println("replace()后str1: " + str1);  // I******* Java!
 
// reverse(): 反转
System.out.println("reverse()前str1: " + str1);  // I******* Java!
str1.reverse();
System.out.println("reverse()后str1: " + str1);  // !avaJ *******I
 
// substring(): 截取
System.out.println("substring()前str1: " + str1);  // !avaJ *******I
String str2 = str1.substring(3, 8);
System.out.println("substring()后str1: " + str2);  // aJ **
 
// insert(): 插入
System.out.println("insert()前str1: " + str1);  // !avaJ *******I
str1.insert(3, "hahaha");
System.out.println("insert()后str1: " + str1);  // !avhahahaaJ *******I

运行结果：

append()前str1: I love 
append()后str1: I love Java!
delete()前str1: I love Java!
delete()后str1: I le Java!
replace()前str1: I le Java!
replace()后str1: I******* Java!
reverse()前str1: I******* Java!
reverse()后str1: !avaJ *******I
substring()前str1: !avaJ *******I
substring()后str1: aJ **
insert()前str1: !avaJ *******I
insert()后str1: !avhahahaaJ *******I

  public static void main(String[] args){
            /* 构造方法 */
            // 构造一个没有字符的字符串缓冲区，初始容量为16
            StringBuffer sb1 = new StringBuffer();
            System.out.println(sb1.capacity()); // 16
            System.out.println(sb1.length()); // 0

            // 构造一个指定字符串的字符串缓冲区，容量 = 16(初始容量) + 字符串长度
            StringBuffer sb2 = new StringBuffer("Java");
            System.out.println(sb2.capacity()); // 20 = 16 + 4
            System.out.println(sb2.length());  // 4

            // 构造指定容量的字符串缓冲区
            StringBuffer sb3 = new StringBuffer(12);
            System.out.println(sb3.capacity()); // 12
            System.out.println(sb3.length()); // 0

            /* 常用方法 */
            StringBuffer str1 = new StringBuffer("I love ");

            // append(): 追加
            System.out.println("append()前str1: " + str1);  // I love
            str1.append("Java!");
            System.out.println("append()后str1: " + str1);  // I love Java!

            // delete(): 删除
            System.out.println("delete()前str1: " + str1);  // I love Java!
            str1.delete(3, 5);
            System.out.println("delete()后str1: " + str1);  // I le Java!

            // replace(): 替换
            System.out.println("replace()前str1: " + str1);  // I le Java!
            str1.replace(1, 4, "*******");
            System.out.println("replace()后str1: " + str1);  // I******* Java!

            // reverse(): 反转
            System.out.println("reverse()前str1: " + str1);  // I******* Java!
            str1.reverse();
            System.out.println("reverse()后str1: " + str1);  // !avaJ *******I

            // substring(): 截取
            System.out.println("substring()前str1: " + str1);  // !avaJ *******I
            String str2 = str1.substring(3, 8);
            System.out.println("substring()后str1: " + str2);  // aJ **

            // insert(): 插入
            System.out.println("insert()前str1: " + str1);  // !avaJ *******I
            str1.insert(3, "hahaha");
            System.out.println("insert()后str1: " + str1);  // !avhahahaaJ *******I
        }


16
0
20
4
12
0
append()前str1: I love 
append()后str1: I love Java!
delete()前str1: I love Java!
delete()后str1: I le Java!
replace()前str1: I le Java!
replace()后str1: I******* Java!
reverse()前str1: I******* Java!
reverse()后str1: !avaJ *******I
substring()前str1: !avaJ *******I
substring()后str1: aJ **
insert()前str1: !avaJ *******I
insert()后str1: !avhahahaaJ *******I

StringBuilder 

接口文档：详情可自行查看

字符串变量（非线程安全）。在内部，StringBuilder 对象被当作是一个包含字符序列的变长数组。

java.lang.StringBuilder 是一个可变的字符序列，是 JDK5.0 新增的。此类提供一个与 StringBuffer 兼容的 API，但不保证同步。该类被设计用作 StringBuffer 的一个简易替换，用在字符串缓冲区被单个线程使用的时候（这种情况很普遍）

三种重载构造器的使用案例

 //几种重载构造器的使用案例
            StringBuilder sb1 =new StringBuilder();//#1 无参
            StringBuilder sb2=new StringBuilder("123");//#2   
            StringBuilder sb3=new StringBuilder(123);//#3 有参

在StringBuilder类重载的三种构造器中都调用了父类abstractStringBuilder重载的构造器，在StringBuilder类重载的三种构造器中传参，实际上都是在指定继承于父类中的char类型数组的长度

  1. 调用StringBuilder类中的空参构造器，在调用abstractStringBuilder父类的构造器时默认传入16，即char类型value数组的长度为16.
  2. 调用StringBuilder类中的形参为string类型的构造器，在调用abstractStringBuilder父类的构造器时传入该string类型字符串的长度string.length()+16,即char类型value数组的长度为string.length()+16.（16为构造器默认长度）
  3. 调用StringBuilder类中的形参为int类型的构造器，在调用abstractStringBuilder父类的构造器时传入该int类型数据，即char类型value数组的长度为该int类型数据值.

对于string类型的字符串，在实现拼接操作时可以使用“+”连接符、concat()方法、join()方法（join()方法用于多个字符串或字符串数组按照指定字符串逐个拼接）

这三个方法的使用都不会改变原字符串，而是返回一个新的字符串

        String str="x";
        str=str+"a";
        str=str.concat("b");
        System.out.println(str);
        
        String str1="w";
        str=str.join("@", str,str1);
        System.out.println(str);

运行结果：

xab
xab@w

StringBuilder类中append（）方法的具体使用：在原字符串尾部直接追加一个字符串或字符，改变原字符串


            //append（）方法的使用
            StringBuilder le =new StringBuilder("好好");
            le.append("学习").append("天天向上");
            System.out.println(le);
        }

运行结果是：

好好学习天天向上

 string类中replace()方法：将指定原字符串中的子字符串或字符替换为指定的字符串或字符。不会改变原字符串，而是返回一个新的字符串

 //string类中replace()方法的使用
            String str="人生在世，孰能无错";
            str=str.replace("人生", "老子").replace('错', '过');
            System.out.println(str);

运行结果：

老子在世，孰能无过

StringBuilder类中replace()方法的具体使用：将从指定启使下标开始到指定结尾下标（不含尾下标）的子字符串替换为指定字符串。

   replace()方法的使用
            StringBuilder le =new StringBuilder("不知所措啊");
            le.replace(1, 3, "lel");
            System.out.println(le);
        }

不lel措啊

delete()方法的使用：将从指定启使下标至指定结尾下标（不含尾下标）的子字符串删除

//delete()方法的使用
        StringBuilder le = new StringBuilder("好好学习");
        le.delete(1, 3);
        System.out.println(le);


    }

运行结果：

好习

insert()方法的使用：在指定下标位置插入字符串、字符、布尔值等

//insert()方法的使用
        StringBuilder le=new StringBuilder("好好学习");
        le.insert(3, "天").insert(4, '弟').insert(0, "好的");
        System.out.println(le);

好的好好学天弟习

reverse()方法的使用：将原字符串逆序

//reverse()方法的使用
        StringBuilder le=new StringBuilder("不服就干别哔哔");
        le.reverse();
        System.out.println(le);

哔哔别干就服不

public class RunoobTest{
    public static void main(String args[]){
        StringBuilder sb = new StringBuilder(10);
        sb.append("Runoob..");
        System.out.println(sb);  
        sb.append("!");
        System.out.println(sb); 
        sb.insert(8, "Java");
        System.out.println(sb); 
        sb.delete(5,8);
        System.out.println(sb);  
    }
}

运行结果：

Runoob..
Runoob..!
Runoob..Java!
RunooJava!

StringBuffer 和 StringBuilder 类的对象能够被多次的修改，并且不产生新的未使用对象。

StringBuilder 类在 Java 5 中被提出，它和 StringBuffer 之间的最大不同在于 StringBuilder 的方法不是线程安全的（不能同步访问）。

由于 StringBuilder 相较于 StringBuffer 有速度优势，所以多数情况下建议使用 StringBuilder 类。然而在应用程序要求线程安全的情况下，则必须使用 StringBuffer 类。

1

2

3

4

5

6

7

public class Test{   public static void main(String args[]){

    StringBuffer sBuffer = new StringBuffer("菜鸟教程官网：");    

    sBuffer.append("www");    

    sBuffer.append(".runoob");    

    sBuffer.append(".com");    

    System.out.println(sBuffer);     

    }}   

以上实例编译运行结果如下：

1

菜鸟教程官网：www.runoob.com

1. String是不可变的{final修饰}，如果尝试去修改，会新⽣成⼀个字符串对象，StringBuffer和StringBuilder是可变的

2. StringBuffer是线程安全的{synchronized}，StringBuilder是线程不安全的，所以在单线程环境下StringBuilder效率会更⾼

使用建议：

        （1） 如果要操作少量的数据，建议用String；

        （2） 如果在多线程操作字符串缓冲区下操作大量的数据，建议使用SreingBuffer；

        （3） 如果在单线程操作字符串缓冲区下操作大量数据，建议使用StringBuilder。

描述

将一个由英文字母组成的字符串转换成从末尾开始每三个字母用逗号分隔的形式。

输入描述：

一个字符串

输出描述：

修改后的字符串

理解解释：

因为String类型字符串不可变，我们用这个字符串创建一个新的StringBuilder型的字符串，然后从字符串末尾第3位开始，每次三位三位地遍历，将逗号用insert函数插入其中。最后将StringBuilder型转变成String输出即可。

 public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String str = scanner.next();
        //write your code here......
        StringBuilder m = new StringBuilder();
        //用str初始化m
        m.append(str);
        //遍历m，每次跳跃3个字符，然后插入一个','
        for(int i=str.length()-3;i>=0;i-=3)
        {
            //利用for循环在每3个后加入逗号
            m.insert(i,",");
        }
        //输出改变后的字符串
        System.out.println(m.toString());
    }


aaabbbcccd
a,aab,bbc,ccd

标签： 02重载连接器he

锐单商城拥有海量元器件数据手册、 IC替代型号，打造 电子元器件IC百科大全！

锐单商城 - 一站式电子元器件采购平台