String类

1.String常用方法

public class Code01 {
    public static void main(String[] args) {
        //  定义字符串  012345678901234567890123456
        String str = " wo shi yi ge zi fu chuan! ";
        String str2 = " Wo Shi Yi Ge Zi fu chuan! ";
        System.out.println("获取字符串的长度："+str.length());//获取字符串的长度：27
        System.out.println("获取指定索引处的字符："+str.charAt(25));//获取指定索引处的字符：!
        System.out.println("获取str在字符串对象中第一次出现的索引"+str.indexOf("s"));//获取str在字符串对象中第一次出现的索引4
        System.out.println("字符串截取，从1到6（包含1不包含6）："+str.substring(1,6));//字符串截取，从1到6（包含1不包含6）：wo sh
        System.out.println("比较字符串的内容是否相同:"+str.equals(str2));//比较字符串的内容是否相同:false
        System.out.println("忽略大小写比较字符串的内容是否相同："+str.equalsIgnoreCase(str2));//忽略大小写比较字符串的内容是否相同：true
        System.out.println("判断字符串对象是否以指定的字符开头（区分大小写）:"+str.startsWith("w"));//判断字符串对象是否以指定的字符开头（区分大小写）:false
        System.out.println("判断字符串对象是否以指定位置的字符开头（区分大小写）"+str.startsWith("w",1));//判断字符串对象是否以指定位置的字符开头（区分大小写）true
        System.out.println("判断字符串对象是否以指定的字符结尾（区分大小写）"+str.endsWith("!"));//判断字符串对象是否以指定的字符结尾（区分大小写）false
        System.out.println("判断指定字符串是否为空:"+str.isEmpty());//判断指定字符串是否为空:false
        System.out.println("把字符串转换为小写字符串:"+str2.toLowerCase());//把字符串转换为小写字符串: wo shi yi ge zi fu chuan!
        System.out.println("把字符串转换为大写字符串:"+str2.toUpperCase());//把字符串转换为大写字符串: WO SHI YI GE ZI FU CHUAN!
        System.out.println("去除字符串两端空格:"+str.trim());//去除字符串两端空格:wo shi yi ge zi fu chuan!
        System.out.println("去除字符串中指定的的字符:"+Arrays.toString(str.split(" ")));// str.split去除字符串中指定的的字符，然后返回一个新的字符串,执行结果：[, wo, shi, yi, ge, zi, fu, chuan!]
        // replace与replaceAll的区别：前者就是基于字符串替换，后者可以基于规则表达式的替换
        System.out.println("将指定字符替换成另一个指定的字符:"+str.replace("i", "8"));//将指定字符替换成另一个指定的字符: wo sh8 y8 ge z8 fu chuan!
        System.out.println("将指定字符替换成另一个指定的字符:"+str.replaceAll("i", "8"));//将指定字符替换成另一个指定的字符: wo shI yi ge zi fu chuan!
        System.out.println("将指定第一个字符替换成另一个指定的字符:"+str.replaceFirst("i", "8"));//将指定第一个字符替换成另一个指定的字符: wo shI yi ge zi fu chuan!
        System.out.println("返回指定字符出现的最后一次的下标:"+str.lastIndexOf("i"));//返回指定字符出现的最后一次的下标:15
        System.out.println("查看字符串中是都含有指定字符:"+str.contains("o"));//查看字符串中是都含有指定字符:true
        System.out.println("在原有的字符串的基础上加上指定字符串:"+str.concat("aaaaaaaaa"));//在原有的字符串的基础上加上指定字符串: wo shi yi ge zi fu chuan! aaaaaaaaa
    }
}

2.StringBuilder

• 直接上代码

public class Code02 {
    public static void main(String[] args) {
        /**
         * public StringBuilder() { super(16);}
         * super(16) ---> AbstractStringBuilder(int capacity) { value = new char[capacity];}
         */
        //构造器调用父类构造器，默认初始char类型数组长度为16
        StringBuilder sb1 = new StringBuilder();

        /**
         * public StringBuilder(capacity) { super(capacity);}
         * super(16) ---> AbstractStringBuilder(int capacity) { value = new char[capacity];}
         */
        //构造器调用父类构造器，指定初始char类型数组长度为6
        StringBuilder sb2 = new StringBuilder(6);

        /**
         * public StringBuilder(String str) { super(str.length() + 16); append(str);}
         * super(16) ---> AbstractStringBuilder(int capacity) { value = new char[capacity];}
         */
        //构造器调用父类构造器，指定初始char类型数组长度为"abc".length+16，并追加"abc"
        StringBuilder sb3 = new StringBuilder("abc");
        System.out.println("在sb3后追加字符串 def："+sb3.append("def"));//执行结果：在sb3后追加字符串 def：abcdef
        System.out.println("指定位置删除字符："+sb3.delete(4, 5));//指定位置删除字符(4-5=e)：abcdf
        System.out.println("指定位置替换字符："+sb3.replace(4, 5, "aaa"));//指定位置替换字符：abcdaaa
        System.out.println("指定位置截取字符："+sb3.substring(2, 5));// 对sb3本身无影响--指定位置截取字符：cda
        System.out.println("查指定位置字符内容："+sb3.charAt(0));//查指定位置字符内容：a
    }
}

• StringBuilder append方法源码分析

1. 调用父类AbstractStringBuilder的append方法

    @Override
    public StringBuilder append(String str) {
        super.append(str);
        return this;
    }

2. 这里涉及到AbstractStringBuilder 的两个重要属性 char[] value char数组长度和 int count 数组内元素的个数

    public AbstractStringBuilder append(String str) {
        if (str == null)
            return appendNull();
        int len = str.length();
        // 这里会判断追加后的长度是否超出容量
        ensureCapacityInternal(count + len);
        // 字符串值更新
        str.getChars(0, len, value, count);
        // 数组元素值更新
        count += len;
        return this;
    }

3. 超出容量自动扩容

    private void ensureCapacityInternal(int minimumCapacity) {
        // overflow-conscious code
        // minimumCapacity==count + len,大于0执行扩容
        if (minimumCapacity - value.length > 0) {
            value = Arrays.copyOf(value,
                    newCapacity(minimumCapacity));
        }
    }

    private int newCapacity(int minCapacity) {
        // overflow-conscious code
        // 扩容算法
        int newCapacity = (value.length << 1) + 2;
        if (newCapacity - minCapacity < 0) {
            newCapacity = minCapacity;
        }
        return (newCapacity <= 0 || MAX_ARRAY_SIZE - newCapacity < 0)
            ? hugeCapacity(minCapacity)
            : newCapacity;
    }

4. 将此字符串的字符复制到目标字符串数组中

    public void getChars(int srcBegin, int srcEnd, char dst[], int dstBegin) {
        if (srcBegin < 0) {
            throw new StringIndexOutOfBoundsException(srcBegin);
        }
        if (srcEnd > value.length) {
            throw new StringIndexOutOfBoundsException(srcEnd);
        }
        if (srcBegin > srcEnd) {
            throw new StringIndexOutOfBoundsException(srcEnd - srcBegin);
        }
        System.arraycopy(value, srcBegin, dst, dstBegin, srcEnd - srcBegin);
    }

3.StringBuffer

• 用法与StringBuilder一致
• StringBuffer效率低，线程安全