java字符串之使用StringBuffer

    String是不变类，用String修改字符串会新建一个String对象，如果频繁的修改，将会产生很多的String对象，开销很大.因此java提供了一个StringBuffer类，这个类在修改字符串方面的效率比String高了很多。
   
一、关键技术点
    1、StringBuffer的indexOf、lastIndexOf、substring、charAt方法的用途和String类一样。
    2、append实例方法往字符串尾部添加字符或者字符串。
    3、insert实例方法往字符串中间插入字符或字符串。
    4、delete和deleteCharAt方法删除字符串中的子串或者字符。
    5、replace方法用于替换子串。
    6、reverse方法将字符串倒序。
   
二、实例演示

 

/** */ /**
 * 文件名：UsingStringBuffer.java
 */
package  book.oo.String;

/** */ /**
 * 使用StringBuffer类操作字符串
 * @author joe
 *
 */
public   class  UsingStringBuffer  ... {
    
    /** *//**
     * 查找匹配字符串
     */
    public static void testFindStr() ...{
        StringBuffer sb = new StringBuffer("This is a StringBuffer!");
        //返回子字符串在字符串中最先出现的位置，如果不存在，返回负数
        System.out.println("sb.indexOf(/"is/") = " + sb.indexOf("is"));

        //给indexOf方法设置参数，指定匹配的起始位置
        System.out.println("sb.indexOf(/"is/", 4) = " + sb.indexOf("is", 4));
        //返回子字符串在字符串中最后出现的位置，如果不存在，返回负数
        System.out.println("sb.lastIndexOf(/"is/") = " + sb.lastIndexOf("is"));
        //给lastIndexOf方法设置参数，指定匹配的结束位置
        System.out.println("sb.lastIndexOf("/is/", 1) = " + sb.lastIndexOf("is", 1));
    }
    
    /** *//**
     * 截取字符串
     */
    public static void testSubStr() ...{
        StringBuffer sb = new StringBuffer("This is a StringBuffer!");
        //substring方法截取字符串，可以指定截取的起始位置和终止位置
        //默认的终止位置为字符串的末尾
        System.out.println("sb.substring(2) = " + sb.substring(2));
        System.out.println("sb.substring(2, 9) = " + sb.substring(2, 9));
    }
    
    /** *//**
     * 获取字符串中某个位置上的字符
     */
    public static void testCharAt() ...{
        StringBuffer sb = new StringBuffer("This is a StringBuffer!");
        //返回字符串中某个位置上的字符
        System.out.println("sb.charAt(2) = " + sb.charAt(2));
    }
    
    /** *//**
     * 添加各种类型的数据到字符串尾部
     */
    public static void testAppend() ...{
        StringBuffer sb = new StringBuffer("This is a StringBuffer!");
        //添加字符或者字符数组到StringBuffer的末尾
        sb.append('I');
        sb.append(new char[]...{' ', 'a', 'm'});
        System.out.println("Append char：" + sb.toString());
        //添加字符串到StringBuffer的末尾
        sb.append(" in 、Beijing.");
        System.out.println("Append String: " + sb.toString());
        //添加基本数字
        sb.append(15);
        sb.append(1.23f);
        sb.append(3.4d);
        sb.append(899L);
        System.out.println("Append number: " + sb.toString());
        //添加布尔值
        sb.append(false);
        sb.append(true);
        System.out.println("Append boolean: " + sb.toString());
    }
    
    /** *//**
     * 删除字符串中的数据
     */
    public static void testDelete() ...{
        StringBuffer sb = new StringBuffer("This is a StringBuffer!");
        //删除指定位置的字符
        sb.deleteCharAt(1);
        sb.deleteCharAt(2);
        System.out.println("Delete char: " + sb.toString());
        //删除指定范围的字符串
        sb.delete(1, 5);
        System.out.println("sb.delete(1, 5) = " + sb.toString());
    }
    
    /** *//**
     * 向字符串中插入各种类型的数据
     */
    public static void testInsert() ...{
        StringBuffer sb = new StringBuffer("This is a StringBuffer!");
        //能够在指定位置插入字符、字符数组、字符串以及各种数字和布尔值
        sb.insert(2, 'W');
        sb.insert(3, new char[]...{'A', 'B', 'C'});
        sb.insert(8, "abc");
        sb.insert(2, 3);
        sb.insert(3, 2.3f);
        sb.insert(6, 3.75d);
        sb.insert(5, 9843L);
        sb.insert(2, true);
        System.out.println("testInsert: " + sb.toString());
    }
    
    /** *//**
     * 替换字符串中的某些字符
     */
    public static void testReplace() ...{
        StringBuffer sb = new StringBuffer("This is a StringBuffer!");
        //将字符串中某段字符替换成另一个字符串
        sb.replace(3, 8, "replace");
        System.out.println("testReplace: " + sb.toString());
    }
    
    /** *//**
     * 将字符串倒序
     */
    public static void reverseStr() ...{
        StringBuffer sb = new StringBuffer("This is a StringBuffer!");
        System.out.println(sb.reverse());    //reverse方法将字符串倒序
    }
    
    public static void main(String[] args) ...{
        StringBuffer sb = new StringBuffer("This is a StringBuffer!");
        System.out.println("原始StringBuffer: " + sb.toString());
        
        UsingStringBuffer.testFindStr();
        UsingStringBuffer.testSubStr();
        UsingStringBuffer.testCharAt();
        UsingStringBuffer.testAppend();
        UsingStringBuffer.testDelete();
        UsingStringBuffer.testInsert();
        UsingStringBuffer.testReplace();
        UsingStringBuffer.reverseStr();
    }

}

 输出结果：

 

原始StringBuffer: This  is  a StringBuffer !
sb.indexOf( " is " )  =   2
sb.indexOf( " is " ,  4 )  =   5
sb.lastIndexOf( " is " )  =   5
sb.lastIndexOf( " is " ,  1 )  =   - 1
sb.substring( 2 )  =   is   is  a StringBuffer !
sb.substring( 2 ,  9 )  =   is   is  a
sb.charAt( 2 )  =  i
Append  char ：This  is  a StringBuffer ! I am
Append String: This  is  a StringBuffer ! I am  in  、Beijing.
Append number: This  is  a StringBuffer ! I am  in  、Beijing. 151.233 . 4899
Append boolean: This  is  a StringBuffer ! I am  in  、Beijing. 151.233 .4899falsetrue
Delete  char : Ti  is  a StringBuffer !
sb.delete( 1 ,  5 )  =  T a StringBuffer !
testInsert: Thtrue32. 984333 .75WABCisabc  is  a StringBuffer !
testReplace: Thireplacea StringBuffer !
! reffuBgnirtS a si sihT

小结：

StringBuffer不是不变类，在修改字符串内容时，不会创建新的对象，因此，它比String类更适合修改字符串。
StringBuffer类没有提供同String一样的toCharArray方法
StringBuffer类的replace方法同String类的replace方法不同,它的replace方法有三个参数,第一个参数指定被替换子串的起始位置，第二个参数指定被替换子串的终止位置，第三个参数指定新子串