Java_StringBuffer字符串缓冲类

  • 2020 年 09 月 27 日
  • 25次
  • 1392 字
  • 暂无评论

StringBuffer字符串缓冲类

public class StringBuffer字符串缓冲类 {
    /**
     * StringBuffer字符串缓冲类
     */
    public static void main(String[] args) {
        {
            /**
             * StringBuffer 类的构造方法
             */
            // StringBuffer()构造一个没有任何字符的 StringBuffer 类
            StringBuffer s; 
            // 构造一个没有任何字符的 StringBuffer 类,并且基长度 length
            StringBuffer sb = new StringBuffer(1);
            // 以 str 为初始值构造一个 StringBuffer 类
            String str = "s";
            StringBuffer sbf = new StringBuffer(str);
        }
        {
            /**
             * StringBuffer 类的方法
             *     说明:
             *         1.所有方法均为 public
             *         2.书写格式:[修饰符]<返回类型><方法名 ( [ 参数列表 ] ) >。
             */
            /**
             *    追加 
             */
            System.out.println("追加元素:");
            // StringBuffer append(boolean b):向字符串缓冲区 “追加” 元素,但是,这个 “元素” 参数可以是 布尔量
            StringBuffer s = new StringBuffer("a");
            System.out.println("向字符串缓冲区 “追加” 元素,但是,这个 “元素” 参数可以是 布尔量:s.append(true) = " + s.append(true));
            // StringBuffer append(char c):向字符串缓冲区 “追加” 元素,但是,这个 “元素” 参数可以是 字符
            System.out.println("向字符串缓冲区 “追加” 元素,但是,这个 “元素” 参数可以是 字符: s.append('b') = " + s.append('b'));
            // StringBuffer append(char[] ch):向字符串缓冲区 “追加” 元素,但是,这个 “元素” 参数可以是 字符数组
            char[] ch = {'a', 'b', 'c'};
            System.out.println("向字符串缓冲区 “追加” 元素,但是,这个 “元素” 参数可以是 字符数组: s.append(ch) = " + s.append(ch));
            // StringBuffer append(double d):向字符串缓冲区 “追加” 元素,但是,这个 “元素” 参数可以是 双精度数
            double d = 1.23d;
            System.out.println("向字符串缓冲区 “追加” 元素,但是,这个 “元素” 参数可以是 双精度数: s.append(d) = " + s.append(d));
            // StringBuffer append(float f):向字符串缓冲区 “追加” 元素,但是,这个 “元素” 参数可以是 浮点数
            float f = 4.5f;
            System.out.println("向字符串缓冲区 “追加” 元素,但是,这个 “元素” 参数可以是 浮点数: s.append(f) = " + s.append(f));
            // StringBuffer append(int i):向字符串缓冲区 “追加” 元素,但是,这个 “元素” 参数可以是 整数
            int i = 67890;
            System.out.println("向字符串缓冲区 “追加” 元素,但是,这个 “元素” 参数可以是 整数: s.append(i) = " + s.append(i));
            // StringBuffer append(long l):向字符串缓冲区 “追加” 元素,但是,这个 “元素” 参数可以是 长整型数
            long l = 987654321;
            System.out.println("向字符串缓冲区 “追加” 元素,但是,这个 “元素” 参数可以是 长整型数: s.append(l) = " + s.append(l));
            // StringBuffer append(Object obj):向字符串缓冲区 “追加” 元素,但是,这个 “元素” 参数可以是 对象类型的字符串
            Object obj = "Object";
            System.out.println("向字符串缓冲区 “追加” 元素,但是,这个 “元素” 参数可以是 对象类型的字符串:s.append(obj) = " + s.append(obj));
            // StringBuffer append(String str):向字符串缓冲区 “追加” 元素,但是,这个 “元素” 参数可以是 字符串
            String str = "String";
            System.out.println("向字符串缓冲区 “追加” 元素,但是,这个 “元素” 参数可以是 字符串:s.append(str) = " + s.append(str));
            // StringBuffer append(StringBuffer sb):向字符串缓冲区 “追加” 元素,但是,这个 “元素” 参数可以是  StringBuffer 类
            StringBuffer sb = new StringBuffer("StringBuffer");
            System.out.println("向字符串缓冲区 “追加” 元素,但是,这个 “元素” 参数可以是 StringBuffer 类:s.append(ss) = " + s.append(sb));
            System.out.println();

            /**
             * 查找/修改/替换/截取/提取/翻转:
             */
            StringBuffer sbf = new StringBuffer("abcdef123456abc123");
            System.out.println("修改/替换/截取/提取/翻转:");
            // int indexOf(String str):返回当前 StringBuffer 对象中,第一个满足 str 子串的位置
            System.out.println("返回当前 StringBuffer 对象中,第一个满足 \"bc\" 子串的位置:sbf.indexOf(\"bc\") = " + sbf.indexOf("bc"));
            // int indexOf(String str, int fromIndex):从当前 StringBuffer 对象的 fromIndex 开始查找,返回第一个满足 str 子串的位置
            System.out.println("从当前 StringBuffer 对象的 fromIndex 开始查找,返回第一个满足 \"bc\" 子串的位置:sbf.indexOf(\"bc\", 1) = " + sbf.indexOf("bc", 1));
            // int lastIndexOf(String str):返回当前 StringBuffer 对象中,最后一个满足 str 子串的位置
            System.out.println("返回当前 StringBuffer 对象中,最后一个满足 \"bc\" 子串的位置:sbf.lastIndexOf(\"bc\") = " + sbf.lastIndexOf("bc"));
            // int lastIndexOf(String str, int fromIndex):返回当前 StringBuffer 对象的 fromIndex 开始查找,最后一个满足 str 子串的位置
            System.out.println("返回当前 StringBuffer 对象的 fromIndex 开始查找,最后一个满足 \"bc\" 子串的位置:sbf.lastIndexOf(\"bc\") = " + sbf.lastIndexOf("bc", 5));
            System.out.println();            
            
            // void setCharAt(int index, char ch):设置索引号 index 的字符为 ch
            sbf.setCharAt(5, 'A');
            System.out.println("设置索引号 index 的字符为 'A':sbf.setCharAt(5, 'A') (注:该方法无返回值) = " + sbf);
            // StringBuffer replace(int start, int end, String str):替换当前 StringBuffer 对象的字符串。从  start 开始,到 end 结束的位置替换成 str
            System.out.println("替换当前 StringBuffer 对象的字符串。从  0 开始,到 5 结束的位置替换成 \"abc123\":sbf.replace(0, 5, \"abc123\") = " + sbf.replace(0, 5, "abc123"));
            System.out.println();
            // String substring(int start):取 StringBuffer 对象中,从 start 开始到结尾的子串
            System.out.println("取 StringBuffer 对象中,从 3 开始到结尾的子串:sbf.substring(3) = " + sbf.substring(3));
            // String subString(int start, int end):取当前 StringBuffer 对象中,从 start 开始到 end 结束的子串
            System.out.println("取当前 StringBuffer 对象中,从 0 开始到 3 结束的子串:sbf.substring(0, 3) = " + sbf.substring(0, 3));
            System.out.println();
            // StringBuffer delete(int start, int end):删除在当前 StringBuffer 对象中以索引号 start 开始,到 end 结束的字符。
            // 第一个字符的索引为 “0”,当前 StringBuufer 对象中以索引号 start 开始,到 end 结束的字符。
            System.out.println("删除在当前 StringBuffer 对象中以索引号 3 开始,到 9 结束的字符:sbf.delete(3, 9) = " + sbf.delete(3, 9));
            // StringBuffer deleteCharAt(int index):删除当前 StringBuffer 对象中索引号为 index 的字符
            System.out.println("删除当前 StringBuffer 对象中索引号为 0 的字符:sbf.deleteCharAt(0) = " + sbf.deleteCharAt(0));
            
            // void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)
            // 从当前 StringBuffer 对象的索引号 srcBegin 开始,到 srcEnd 结束,赋值到字符数组 dst中,并且从 dst 的索引号 dstBegin 开始
            System.out.print("从当前 StringBuffer 对象中截取字符并赋值给数组:sbf.getChars(2, 8, cha, 2) = ");
            char[] cha = new char[10];
            sbf.getChars(2, 8, cha, 2);
            for(char c : cha)
                System.out.print(c + ",");
            System.out.println();
            
            // StringBuffer reverse():将字符串翻转
            System.out.println("将字符串翻转:sbf.reverse() = " + sbf.reverse());
            System.out.println();

            /** 
             * 输出
             */
            // String toString():将当前 StringBuffer 对象转换成 String 对象
            System.out.println("将当前 StringBuffer 对象转换成 String 对象:sbf.toString():" + sbf.toString());
            System.out.println();
            
            /**
             * 字符串长度:
             */
            System.out.println("字符串长度:");
            // int length():返回当前 StringBuffer 对象(字符缓冲区)中字符串的长度。注意:此方法与 capacity() 不同
            System.out.println("返回当前 StringBuffer 对象(字符缓冲区)中字符串的长度:sbf.length() = " + sbf.length());
            // void setLength(int newLength):重新设置字符串缓冲区中字符串的长度,如果 newLength 小于当前的字符串长度,将截去多余的字符
            sbf.setLength(6);
            System.out.println("重新设置字符串缓冲区中字符串的长度,如果 6 小于当前的字符串长度,将截去多余的字符:sbf.setLength(6) (注:该方法无返回值) = " + sbf);

            System.out.println("缓冲区总空间:");
            // int capacity():返回当前 StringBuffer 对象(字符串缓冲区)的总空间,而非字符号串的长度
            System.out.println("返回当前 StringBuffer 对象(字符串缓冲区)的总空间,而非字符号串的长度:sbf.capacity() = " + sbf.capacity());
            // void ensureCapacity(int minimumCapacity):重新设置字符号串缓冲区的总空间
            // 如果 minimumCapacity 大于当前的总空间,则新的空间被设置:一种结果是 minimumCapacity; 另一种结果是{“老空间” 乘2加2}
            System.out.println("重新设置字符号串缓冲区的总空间 前总空间:sbf.capacity() = " + sbf.capacity());
            System.out.println("重新设置字符号串缓冲区的总空间:sbf.ensureCapacity(100)");
            sbf.ensureCapacity(100);
            System.out.println("重新设置字符号串缓冲区的总空间 后总空间:sbf.capacity() = " + sbf.capacity());
        }
    }
}

运行截图

StringBuffer字符串缓冲类.jpg


版权属于:Houzi0

本文链接:https://houzi0.com/archives/11.html



—— 暂无评论 ——

OωO