java语言--------javaSE之StringBuffer与StringBuilder

最新推荐文章于 2024-11-08 23:31:31 发布

*咚咚咚*

最新推荐文章于 2024-11-08 23:31:31 发布

阅读量148

点赞数

文章标签： java

本文链接：https://blog.csdn.net/weixin_49522417/article/details/107687763

版权

StringBuffer与StringBuilder

StringBuffer类的概述

StringBuffer类概述
我们如果对字符串进行拼接操作，每次拼接，都会构建一个新的String对象，既耗时，又浪费空间。而StringBuffer就可以解决这个问题.
线程安全的可变字符序列

StringBuffer  线程安全的可变字符序列。相当于一个字符容器，你可以不断的往容器中追加字符。

StringBuffer类的构造方法

StringBuffer的构造方法：
public StringBuffer(): 无参构造方法
public StringBuffer(int capacity): 指定容量的字符串缓冲区对象

public StringBuffer(String str): 指定字符串内容的字符串缓冲区对象
StringBuffer的方法：
public int capacity()：返回当前容量。理论值
public int length():返回长度（字符数）。实际值

/* StringBuffer()
 构造一个其中不带字符的字符串缓冲区，初始容量为 16 个字符。*/
 //创建一个空的字符容器。
 StringBuffer sb = new StringBuffer();
 //往容器中追加数据
 sb.append("abcaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa");
 //获取容器的容量 一旦超过容量，可以自动扩容。
 int capacity = sb.capacity();
 System.out.println(capacity);
 //获取容器的长度。
 int length = sb.length();
 System.out.println(length);

StringBuffer的添加删除功能

StringBuffer的添加功能

public StringBuffer append(String str):可以把任意类型数据添加到字符串缓冲区里面,并返回字符串缓冲区本身
public StringBuffer insert(int offset,String str):在指定位置把任意类型的数据插入到字符串缓冲区里面,并返回字符串缓冲区本身

//构建时，可以指定这个字符容器的容量
StringBuffer sb = new StringBuffer(100);
System.out.println(sb.capacity());
//构建容器时，可以往容器中放入字符串
StringBuffer sb2= new StringBuffer("abbcdfdfd");

StringBuffer sb = new StringBuffer();
//append("abc"); 往容器中追加数据，返回的还是原来的那个容器对象。
StringBuffer sb2 = sb.append("abc");
System.out.println(sb==sb2);//true
sb.append(100).append(200).append(true).append(new char[]{'a','b','c'});
//StringBuffer 重写了toString()方法，然后把容器中的数据转换成字符串返回
System.out.println(sb.toString());//"abc100200trueabc"

insert(0, "eeee");  //在容器中的指定位置，插入数据，返回的还是原来的容器。
StringBuffer sb2 = sb.insert(1, "eeee");

StringBuffer的删除功能

public StringBuffer deleteCharAt(int index):删除指定位置的字符，并返回本身

public StringBuffer delete(int start,int end):删除从指定位置开始指定位置结束的内容，并返回本身

tringBuffer sb = new StringBuffer(str);
//根据指定索引，删除容器中的单个字符，返回的还是容器本身。
StringBuffer sb2 = sb.deleteCharAt(0);
System.out.println(sb);
System.out.println(sb==sb2);
//根据起始索引和终止索引，删除容器中的一部分内容，返回的还是容器本身。
StringBuffer buffer = sb.delete(0,10);
System.out.println(buffer);

StringBuffer的替换和反转功能

StringBuffer的替换功能
public StringBuffer replace(int start,int end,String str): 从start开始到end用str替换

//根据起始索引和终止索引，替换容器中的一部分内容。返回的还是容器本身。
StringBuffer replace = sb.replace(start, str.length(), "");
System.out.println(replace);

StringBuffer的反转功能
public StringBuffer reverse(): 字符串反转
```
StringBuffer reverse = sb.reverse();
System.out.println(reverse);
```

从头查找该字符串，在容器中第一次出现的索引，如果找不到就返回-1
int indexOf (String str)

//indexOf("爱"); 查找容器中该字符串第一次出现的索引，如果查找不到返回-1
int start = sb.indexOf("爱");

从指定索引处开始查找该字符串第一次出现的索引，如果找不到就返回-1
int indexOf (String str,int fromIndex)
从后往前找
int lastIndexOf (String str)
int lastIndexOf (String str,int fromIndex)

StringBuffer的截取功能及注意事项

StringBuffer的截取功能
public String substring(int start): 从指定位置截取到末尾
public String substring(int start,int end): 截取从指定位置开始到结束位置，包括开始位置，不包括结束位置

注意事项
注意:返回值类型不再是StringBuffer本身

//根据起始索引和 终止索引，截取容器中一部分内容返回，注意返回的是String类型
String str2 = sb.substring(0, 5); //含头不含尾
System.out.println(str2);

StringBuffer和String的相互转换

A:String – StringBuffer
a:通过构造方法
b:通过append()方法
B:StringBuffer – String
a: 使用substring方法
b:通过构造方法
c:通过toString()方法

/* A:
 String-- StringBuffer*/
String str="abc";
//方式1
 StringBuffer sb = new StringBuffer(str);
 //方式2：
 StringBuffer sb2 = new StringBuffer();
 sb2.append(str);
 //方式3：
 StringBuffer sb3 = new StringBuffer();
 sb2.insert(0,str);

/* B:
 StringBuffer-- String*/
 StringBuffer sb4 = new StringBuffer("aaaaa");
 //方式1：toString()
 String s = sb4.toString();
 String s1 = sb4.substring(0);
 //String 类中有一个构造方法
 String s2 = new String(sb4);

把数组转成字符串

A:案例演示
需求：把数组中的数据按照指定个格式拼接成一个字符串
举例：
int[] arr = {1,2,3};
输出结果：
“[1, 2, 3]”
用StringBuffer的功能实现

public static void main(String[] args) {
    int[] arr = {1, 2, 3};
    StringBuffer sb = new StringBuffer("[");
    for (int i = 0; i < arr.length; i++) {
        if(i==arr.length-1){
            sb.append(arr[i]).append("]");
        }else{
            sb.append(arr[i]).append(",");
        }
    }
    String s = sb.toString();
    System.out.println(s);
}

字符串反转

A:案例演示
需求：把字符串反转
举例：键盘录入"abc"
输出结果：“cba”
用StringBuffer的功能实现

public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);
    System.out.println("请输入一段字符串");
    String s = scanner.nextLine();
    String s1 = new StringBuffer(s).reverse().toString();
    System.out.println(s1);
}

StringBuffer和StringBuilder的区别

// StringBuffer  线程安全的字符序列，效率低
//  StringBuilder 一个可变的字符序列，线程不安全的，效率高
//  此类提供一个与 StringBuffer 兼容的 API，但不保证同步。
//  该类被设计用作 StringBuffer 的一个简易替换，用在字符串缓冲区被单个线程使用的时候（这种情况很普遍）。
//  如果可能，建议优先采用该类，因为在大多数实现中，它比 StringBuffer 要快。

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

（2）多线程操作字符串缓冲区下操作大量数据 StringBuffer；

（3）单线程操作字符串缓冲区下操作大量数据 StringBuilder。

String和StringBuffer分别作为参数传递

形式参数问题
String作为参数传递 String虽然是引用类型,但是它是一个常量,所以在做传递的时候,完全可以将其看成基本数据类型数据进行传递，String类型输入值传递
StringBuffer作为参数传递

public static void main(String[] args) {
    //引用类型作为参数传递，形参的改变会影响实参。
    //注意：String 类型作为参数传递，属于值传递。会这把字符串的值传递过去
    String str = "abc";
    change(str);                   //change方法
    System.out.println(str);       //abc 
    StringBuffer sb = new StringBuffer("Hello");
    change(sb);
    sb.reverse();                  //反转
    System.out.println(sb);        //呵呵哈哈olleH
}
private static void change(StringBuffer sb) {
    sb.append("哈哈").append("呵呵");
}
private static void change(String str) {
    str+="你好";
    System.out.println(str);        //abc你好
}