Java StringBuilder类与StringBuffer类

Miz8

已于 2023-08-25 11:31:13 修改

阅读量104

点赞数

文章标签： java 开发语言

于 2023-08-25 10:34:38 首次发布

本文链接：https://blog.csdn.net/zqm_1994/article/details/132489692

版权

一、ShtringBuilder类是什么

StringBuilder类是final修饰的没有子类，不能被继承，表示一个可变的字符序列，不保证线程同步。

例：“hello”+"world"+"nihao"-----------"helloworldnihao"---一个存储空间

二、StringBuilder类的构造方法

1.StringBuilder()创建一个初始容量为16个字符的空StringBuilder对象。
2.StringBuilder(String str)创建一个初始值为指定字符串内容的StringBuilder对象。
3.StringBuilder(int capacity)创建一个指定初始容量的空StringBuilder对象。

public class TestMain1 {
	public static void main(String[] args) {
		/*
		StringBuilder类的构造方法
		1.StringBuilder()创建一个初始容量为16个字符的空StringBuilder对象。
		2.StringBuilder(String str)创建一个初始值为指定字符串内容的StringBuilder对象。  
		3.StringBuilder(int capacity)创建一个指定初始容量的空StringBuilder对象。
		*/
		//StringBuilder()创建一个初始容量为16个字符的空StringBuilder对象。
		StringBuilder str1=new StringBuilder();
		//StringBuilder(String str)创建一个初始值为指定字符串内容的StringBuilder对象。  
		StringBuilder str2=new StringBuilder("hello");
		String  teststr="world";
		StringBuilder str3=new StringBuilder(teststr);
		//StringBuilder(int capacity)创建一个指定初始容量的空StringBuilder对象。
		StringBuilder str4=new StringBuilder(20);
	}
}

三、StringBuilder类的常用方法

1.StringBuilder append(Object o)
将参数中指定的数据追加到StringBuilder表示的字符序列的末尾中。
append方是重载的，以便接受任何类型的数据，可以有效地将给定的数据转换为字符串。

2.int capacity()返回当前容量

3.char charAt(int index)得到元素字符串中指定位置的字符数据

4.StringBuilder delete(int start, int end)删除指定开始位置和指定结束位置之间的子字符串.

5.StringBuilder deleteCharAt(int index) 删除元素字符串中指定位置上的字符

6.int indexOf(String str)得到指定字符串在原始字符串中第一次出现的位置

7.int lastIndexOf(String str)得到指定字符串在原始字符串中最后一次出现的位置

8.StringBuilder insert(int index,Object o)将指定的数据插入到原始字符串中指定的位置。
insert方是重载的，以便接受任何类型的数据，可以有效地将给定的数据转换为字符串

9.int length() 返回长度（字符数）

10.StringBuilder replace(int start, int end, String str)使用指定的字符串替换开始位置和结束位置之间的字符串

11.StringBuilder reverse()反转字符串

12.void setCharAt(int index, char ch)使用指定的字符数据替换原始字符串中指定位置的字符

13.String substring(int start)从原始字符串的指定开始位置截取到结束之间的子字符串，返回的是【String】

14.String substring(int start, int end)从原始字符串的指定开始位置截取到结束位置之间的子字符串，返回的是【String】

15.String toString() 将StringBuilder可变字符串转换成String不可变字符串

    StringBuilder[可变字符串]与String[不可变字符串]转换
    String--->StringBuilder  ---  StringBuilder类的构造方法【StringBuilder(String str)】
    StringBuilder--->String --- 1.String类的构造方法【 String(StringBuilder buffer) 】
    StringBuilder--->String --- 2.StringBuilder类的toString()

public class StringBuilderClass1 {
    public static void main(String[] args) {
        /*
        StringBuilder类的常用方法
        1.StringBuilder append(Object o)
        将参数中指定的数据追加到StringBuilder表示的字符序列的末尾中。
        append方是重载的，以便接受任何类型的数据，可以有效地将给定的数据转换为字符串。
        2.int capacity()返回当前容量。
        3.char charAt(int index)得到元素字符串中指定位置的字符数据
        4.StringBuilder delete(int start, int end)删除指定开始位置和指定结束位置之间的子字符串.
        5.StringBuilder deleteCharAt(int index) 删除元素字符串中指定位置上的字符。
        6.int indexOf(String str)得到指定字符串在原始字符串中第一次出现的位置
        7.int lastIndexOf(String str)得到指定字符串在原始字符串中最后一次出现的位置
        8.StringBuilder insert(int index,Object o)将指定的数据插入到原始字符串中指定的位置。
        insert方是重载的，以便接受任何类型的数据，可以有效地将给定的数据转换为字符串。
        9.int length() 返回长度（字符数）。
        10.StringBuilder replace(int start, int end, String str)使用指定的字符串替换开始位置和结束位置之间的字符串
        11.StringBuilder reverse()反转字符串【？？？？】
        12.void setCharAt(int index, char ch)使用指定的字符数据替换原始字符串中指定位置的字符
        13.String substring(int start)从原始字符串的指定开始位置截取到结束之间的子字符串.【String】
        14.String substring(int start, int end)从原始字符串的指定开始位置截取到结束位置之间的子字符串.【String】
        15.String toString() 将StringBuilder可变字符串转换成String不可变字符串。
        */
         String mes = "我的StringBuilderTest";
         StringBuilder stringBuilder = new StringBuilder(mes);
         //StringBuilder append(Object o)在字符串末尾扩展  append方法是重载的  支持任意类型
         //System.out.println("StringBuilder append(Object o) ------ "+stringBuilder.append(20230824));
         //int capacity()返回当前容量
        System.out.println("int capacity() --------- "+stringBuilder.capacity());// 16*2+2
        //char charAt(int index)得到元素字符串中指定位置的字符数据
        System.out.println("char charAt(int index)  ---------- "+stringBuilder.charAt(0));
        //StringBuilder delete(int start, int end)删除指定开始位置和指定结束位置之间的子字符串.
        System.out.println("StringBuilder delete(int start, int end) ---------- "+stringBuilder.delete(2,8));
        //StringBuilder deleteCharAt(int index) 删除元素字符串中指定位置上的字符。
        System.out.println("StringBuilder deleteCharAt(int index) ---------- "+stringBuilder.deleteCharAt(1));
        //int indexOf(String str)得到指定字符串在原始字符串中第一次出现的位置
        System.out.println("int indexOf(String str) ------------ "+stringBuilder.indexOf("T"));
        //int lastIndexOf(String str)得到指定字符串在原始字符串中最后一次出现的位置
        System.out.println("int lastIndexOf(String str) ------------ "+stringBuilder.lastIndexOf("T"));
        //StringBuilder insert(int index,Object o)将指定的数据插入到原始字符串中指定的位置。
        //insert 方法是重载，以便接受任何类型的数据，可以有效地将给定的数据转换为字符串
        System.out.println("StringBuilder insert(int index,Object o) -------- "+stringBuilder.insert(1,"String"));
        //int length() 返回长度（字符数）
        System.out.println("int length() ------- "+stringBuilder.length());
        //StringBuilder replace(int start, int end, String str)使用指定的字符串替换开始位置和结束位置之间的字符串
        System.out.println("StringBuilder replace(int start, int end, String str) -------- "+stringBuilder.replace(0,1,"My"));
        //StringBuffer reverse()反转字符串
        //System.out.println("StringBuffer reverse() ----- "+stringBuilder.reverse());
        //void setCharAt(int index, char ch)使用指定的字符数据替换原始字符串中指定位置的字符
        stringBuilder.setCharAt(18,'a');//因为返回值为空，所以不能赋值变量，直接调用后，再重新输出
        System.out.println("void setCharAt(int index, char ch) ------- "+stringBuilder);
        //String substring(int start)从原始字符串的指定开始位置截取到结束之间的子字符串.【String】
        String str = stringBuilder.substring(15);
        System.out.println("String substring(int start) ------- "+str);
        //String substring(int start, int end)从原始字符串的指定开始位置截取到结束位置之间的子字符串.【String】
        String str1 = stringBuilder.substring(15,17);
        System.out.println("String substring(int start, int end) ------- "+str1);
        //String toString() 将StringBuilder可变字符串转换成String不可变字符串。
        String str2 = stringBuilder.toString();
        System.out.println(str2.concat("love"));


        //StringBuilder[可变字符串]与String[不可变字符串]转换
        //String--->StringBuilder  --  [StringBuilder类的构造方法【StringBuilder(String str)】]
        //StringBuilder--->String ---[1.String类的构造方法【 String(StringBuilder buffer) 】]
        //StringBuilder--->String ---[2.StringBuilder类的toString()]
        String st = "kjjsda";
        StringBuilder stringBuilder1 = new StringBuilder(st);
        System.out.println(stringBuilder1.reverse());

        String stname = new String(stringBuilder1);
        System.out.println(stname.concat("wewelei"));

        String a = stringBuilder1.toString();
        System.out.println(a.concat("jwe"));

    }
}

四、StringBuffer类

StringBuffer类和StringBuilder类的使用方法相同，构造方法和常用方法都一样，只不过是换了类名

五、String、StringBuilder、StringBuffer的区别？

1.String是不可变字符串;StringBuilder、StringBuffer可变字符串。可变与不可变是指，存储数据的存储空间可不可变

//String是不可变字符串
String  string1="hello";
string1=string1+"world";
System.out.println("string1=="+string1); //helloworld
/*
实际上保存"hello"字符串的存储空间没有变，"world"字符串的存储空间没有变，实际上就相当于开辟了3个存储空间，第一个存储空间保存"hello"，第二个存储空间保存"world"，第三个存储空间保存"helloworld"。
*/

//StringBuilder可变字符串
StringBuilder  sbui1=new StringBuilder("hello")
sbui1.append("world");
System.out.println("sbui1=="+sbui1); //helloworld
/*
实际上保存"hello"字符串的存储空间变化，在原来的存储空间上扩展，保存“helloworld”的存储空间和保存“hello”的存储空间是用一个。
*/

2.String、StringBuffer是线程安全[保证线程同步]，StringBuilder非线程安全,不保证线程同步

3.String不适合大量字符串的拼接,在JDK1.8时字符串常量拼接被自动优化成了StringBuiler

StringBuilder适合单线程情况下大量字符串的拼接

StringBuffer适合多线程大量字符串的拼接

4.执行速度String(慢) < StringBuffer(较快) < StringBuilder(快)

5.String[JDK1.0], StringBuffer[JDK1.0 ],StringBuilder[JDK1.5 ]

六、"=="与equals方法的区别？

String重写了Object类中的equals、hashCode方法

1."=="是比较运算符；equals是java.lang.Object类中的方法。

2."=="可以比较两个基本数据类型的变量是否相等，比较的是基本数据类型的数据值是否相等， "=="也可以比较两个引用数据类型的变量是否相等，只是比较的是引用数据类型所指向的对象的地址是否相等。

3.equals方法不能比较两个基本数据类型的变量是否相等，equals方法可以比较两个引用数据类型的变量是否相等，默认情况下比较的是引用数据类型变量所指向的对象的地址是否相等；equals方法被重写之后，比较的是引用数据类型变量所指向的对象的内容是否相等。

七、String s1 = new String("abc")到底创建了几个对象？

要想充分了解创建了几个对象，我们需要了解JVM底层原理，String s1 = new String("abc")
分别在栈，堆，常量池的位置。

在JDK1.6及以前，常量池位于JVM的方法区中

在JDK1.7及以后，常量池放在堆区中

创了两个对象：一个是堆空间中new结构[new String()]
一个是常量池中的数据："abc"

八、String s1="abc";到底创建了几个对象？

创建了一个对象,就是常量池中的数据"abc"

九、如何将字符串数据反转？

1.利用字符串的拼接(charAt()方法),把后遍历出来的放在前面即可实现反转

public static String charAtReverse (String s){
   int length = s.length();
   String reverse = "";
   for (int i = 0; i < length; i++) {
     //字符串中获取单个字符的字符的放法
     reverse = s.charAt(i)+reverse;
   }
   return reverse;
}

2.利用字符串的拼接(toCharArray()处理成字符数组的方法),把后遍历出来的放在前面即可实现反转

public static String reverseCharArrays(String s){
   char []array = s.toCharArray();//把字符串分割成单个字符的数组
   String reverse = "";
   for(int i = array.length -1 ; i>=0 ; i--){
	//遍历数组,从后向前拼接
    	reverse =reverse + array[i];
   }
   return reverse;
}

3.利用递归的方法,类似与二分查找的折半思想

public static String reverseRecursive(String s){
   int length = s.length();
   if(length<=1){
    return s;
   }
   String left  = s.substring(0,length/2);  //he
   String right = s.substring(length/2 ,length); llo
   //此处是递归的方法调用
   String afterReverse = reverseRecursive(right)+reverseRecursive(left);
  return  afterReverse;
}

4.利用StringBuffer的reverse()方法

public static String reverseStringBuffer(String s){
   StringBuffer sb = new StringBuffer(s);
   String afterReverse = sb.reverse().toString();
   return afterReverse;
  }

Miz8

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Java StringBuilder类与StringBuffer类

3.equals方法不能比较两个基本数据类型的变量是否相等，equals方法可以比较两个引用数据类型的变量是否相等，默认情况下比较的是引用数据类型变量所指向的对象的地址是否相等；2."=="可以比较两个基本数据类型的变量是否相等，比较的是基本数据类型的数据值是否相等， "=="也可以比较两个引用数据类型的变量是否相等，只是比较的是引用数据类型所指向的对象的地址是否相等。例：“hello”+"world"+"nihao"-----------"helloworldnihao"---一个存储空间。
复制链接

扫一扫