API常用类-StringBuffer类

StringBuffer 类

JDK 1.0
java.lang.StrigBuffer（线程安全的可变字符串）
安全—-同步—数据是安全的
不安全—不同步—-效率高

public final class StringBuffer extends Object implements Serializable,CharSequence

我们如果对字符串进行拼接操作，每次拼接，都会构建一个新的String对象，既耗时，又浪费空间。而StringBuffer就可以解决这个问题。
StringBuffer和String的区别

• 前者长度和内容可变，后者不可变
• 如果使用前者做字符串的拼接，不会浪费太多的资源

构造方法

• StringBuffer():
• StringBuffer(CharSequence seq):实际参数，是一下实现类的某个对象。
  
  • 接口CharSequence 已知实现类 CharBuffer Segment StringBuffer StringBuilder String
• StringBuffer(int capacity):指定容量的字符串缓冲区对象
• StringBuffer(String str):指定字符串内容的字符串缓冲区对象

StringBuffer的方法：
public int capacity()：返回当前容量。理论值
public int length():返回长度（字符数）。实际值
public String toString():返回此序列中数据的字符串表示形式。

//StringBuffer():无参构造
StringBuffer sb = new StringBuffer();//造了一个缓冲区，相当于买一个水杯，还没有装水
System.out.println("sb:"+sb);
System.out.println("sb.capacity():"+sb.capacity());//16
System.out.println("sb.length()"+sb.length());//0

//StringBuffer(int capacity):指定容量的字符串缓冲区对象
StringBuffer sb2 = new StringBuffer(50);
System.out.println("sb2:"+sb2);
System.out.println("sb2.capacity():"+sb2.capacity());//50
System.out.println("sb2.length()"+sb2.length());//0

// StringBuffer(String str):指定字符串内容的字符串缓冲区对象
StringBuffer sb3 = new StringBuffer("hello");
System.out.println("sb3:"+sb3);//hello
System.out.println("sb3.capacity():"+sb3.capacity());//16+5=21
System.out.println("sb3.length()"+sb3.length());//5

capacity()分别对应的源码：

public StringBuffer(){
    super(16);
}
public StringBuffer(int capacity){
    super(capacity);
}
public StringBuffer(String str){
    super(str.length()+16);
    append(str);
}

添加功能

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

//创建字符串缓冲区
StringBiffer sb = new StringBuffer();

StringBuffer sb2 = sb.append("hello");
System.out.println("sb"+sb);//hello
System.out.println("sb2"+sb2);//hello
System.out.println(sb==sb2);//true
//append方法添加数据后返回的是字符串缓冲区本身，没有重新闯进对象

//一步一步的添加数据
sb.append("hello");
sb.append(true);
sb.append(12);
sb.append(34.56);
System.out.println("sb"+sb);//hellotrue1234.56

//链式编程,append 方法每次都是返回字符串缓冲区的对象
sb.append("hello").append(true).append(12).append(34.56);
System.out.println("sb"+sb);//hellotrue1234.56

//public StringBuffer insert(int offset,String str);在指定位置把任意类型的数据插入到字符串缓冲区里面，并返回字符串缓冲区本身。

sb.insert(5,"world");
System.out.println("sb:"+sb);//helloworldtrue1234.56

删除功能

• public StringBuffer deleteCharAt(int index):删除指定位置的字符，并返回本身。
• public StringBuffer delete(int start,int end):删除从指定位置开始指定位置结束的内容，并返回本身。
  包左不包右

sb.deleteCharAt(11);
//删除第11个字符r
sb.delete(5,10);
//删除world
sb.delete(0,sb.length());
//这个操作的好处是，清空字符串缓冲区，多次重复利用。

替换功能

• public StringBuffer replace(int start,int end,String str):从start开始到end用str替换，包左不包右。

//创建字符串缓冲区对象
StringBuffer sb = new StringBuffer();
//添加数据
sb.append("hello").append("world").append("java");
//替换数据
sb.replace(5,10,"你好");
System.out.println(sb);//hello你好java

反转功能

• public StringBuffer reverse();

//创建字符串缓冲区对象
StringBuffer sb = new StringBuffer();
//添加数据
sb.append("你好");
sb.reverse();
System.out.println("sb:"+sb);//好你

截取功能(返回值类型不再是StringBuffer本身，而StringBuffer本身不变)

• public String substring(int start);将截取到的字符串赋值给String
• public String substring(int start,int end);将截取到的字符串赋值给String，包左不包右

//创建字符串缓冲区对象
StringBuffer sb = new StringBuffer();
//添加数据
sb.append("hello").append("world");
//截取
String s = sb.substring(5);
System.out.println("s:"+s);//world
System.out.println("sb:"+sb);//helloworld

String ss = sb.substring(5,8);
System.out.println("ss:"+ss);//wor
System.out.println("sb:"+sb);//helloworld

案例

String和StringBuffer的相互转换

• 为什么要进行类之间的转换？
  
  • A—-B的转换
    
    • 我们把A转成B，其实是为了用B的功能
  • B—A的转换
    
    • 我们可能哟啊的结果是A 类型，所以还得转回来

//String--StringBuffer
String s = "hello";
//注意：不能直接把值赋值给StringBuffer
//StringBuffer sb = "hello";//错误
//StringBuffer sb = s;//错误

//方式1:通过构造方法。
StringBuffer sb = new StringBuffer(s);
//方式2 ： 通过append()方法
StringBuffer sb2 = new StringBuffer();
sb2.append(s);

//StringBuffer---String
StringBuffer buffer = new StringBuffer("java");
//String(StringBuffer buffer)
//方式1：通过该构造方法
String str = new String(buffer);
//方式2：通过toString()方法
String str2 = buffer.toString();
//任何引用类型，调toString方法都可以转成字符串。

数组拼接成字符串

int[] arr={12,34,23,56};
StringBuffer sb = new StringBuffer();

sb.append("[");
for(int x=0;x<arr.length;x++){
    if(x==arr.length-1){
        sb.append(arr[x]);
    }else{
        sb.append(arr[x]).append(", ");
    }
}
sb.append("]");
return sb.toString();

判断字符串对称

boolean flag = true;
char[] chs = s.toCharArray();
for(int start = 0 ,end = chs.length-1;start<=end;start++,end--){
    if(chs[start] != chs[end]){
        flag=false;
        break;
    }
}
return flag;

 return new StringBuffer(s).reverse().toString().equals(s);

StringBuilder 类

JDK 1.5
java.lang.StringBuilder

public final class StringBuilder extends Object implements Serializable,CharSequence

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

面试题

String ,StringBuffer,StringBuilder的区别

• String 是内容和长度都不可变的。StringBuffer和StringBuilder 是可变的。
• StringBuffer是同步的数据安全，效率低。StringBuilder 是不同步的，数据不安全，效率高。

StringBuffer 和数组的区别

• 二者都可以看成是一个容器，装其他的数据。
• StringBuffer的数据最终是一个字符串数据。
• 数组可以放置多种数据，但必须是同一种类型。

形式参数问题

• String 作为参数传递
• StringBuffer作为参数传递

public class StringBufferDemo{
    public static void main(String[] args){
        String s1 = "hello";
        String s2 = "world";
        System.out.println(s1+"-----"+s2);//hello----world
        change(s1,s2);
        System.out.println(s1+"-----"+s2);//hello---world

        StringBuffer sb1 = new StringBuffer("hello");
        StringBuffer sb2 = new StringBuffer("world");
        System.out.println(sb1+"-----"+sb2);//hello---world
        change(sb1,sb2);
        System.out.println(sb1+"-----"+sb2);//hello---worldworld
    }
    public static void change(StringBuffer sb1,StringBuffer sb2){
        sb1=sb2;
        sb2.append(sb1);
    }
    public static void change(String s1,String s2){
        s1=s2;
        s2=s1+s2;
    }
}

注意：String作为参数传递，效果和基本类型作为参数传递是一样的。
因为String是一种特殊的引用类型，他在内存中的位置，和其他引用类型不同。
形式参数：
基本类型：形式参数的改变不影响实际参数
引用类型：形式参数的改变直接影响实际参数