java之StringBuilder和关于数组怎么扩容

1
2
3
4
5
6
7
8
9
public final class StringBuffer
extends AbstractStringBuilder
implements java.io.Serializable, CharSequence
//同样有final修饰，因此不能被修改继承了。
//继承与AbstractStringBuilder，看下他源码，一个抽象类，并且源码中，
//也有valve数组，只是这里是char[] value;不是private final；而是没有加修饰词，
//则是dafault类型,默认类型，只准许下同一个包下面的类改。（封装知识）

//因为StringBulider是继承父类的，因此也有value数组，等等一些东西。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
构造方法；
public StringBuffer() {
        super(16);
    }
 直接调用父类的构造方法；
  AbstractStringBuilder(int capacity) {
        value = new char[capacity];
    }
因此这个构造方法就是创建了一个为16的数组、默认16；
 public StringBuffer(int capacity) {
        super(capacity);
    }
同样还是调用上面那个继承的方法，但是值不是16了，而是自己传入的。
public StringBuffer(String str) {
        super(str.length() + 16);
        append(str);
    }
传入一个字符串，那么他字符串的长度就是这个字符串的长度再加16；
并且还调用了append()方法，（就是累加的意思）然后这个方法里面用调用父类的append方法，父类的方法中用调用了很多方法，这些都可以进行点击其源码进行了解。Ctrl+点击；
StringBuilder sb = new StringBuilder();//字符数组长度为16，默认；
StringBuilder sb1 = new StringBuilder(32);//那么字符数组的长度就是32；
StringBuilder sb2 = new StringBuilder("asrh");
//4+16;并且在value[]={‘a'， 's','r','h',/u0000.........}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
append()方法。在StringBuilder中很常用的一种方法。对字符串进行追加。
并且他还有很多重载方法。
1
sb2.append("123");//就进行了追加了，因此也验证了这是可变字符数列。
sb2.append(true);//在后面就直接添加ture了。
System.out.println(sb2);//返回asrh123true
2
 public synchronized StringBuffer append(String str) {
        super.append(str);
        return this;
    }
  注意一下append方法中有很多return this。这样有什么好处呢。
  通过return this可以实现方法链；
StringBuilder sb3 = new StringBuilder("asrh");
sb3.append("12").append("345");//可以进行叠加就是因为返回的是this、
System.out.println(sb3);//输出asrh12345
这个也解决了前面那个String中的问题，怎么去为字符串追加字符。其实用StringBuilder是最好的。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
在append追加的时候，如果出现容量问题时是怎么解决的。
进去源码里面找。
子类append都会调用父类的append，则进入父类的append方法中看。
父类源码中有ensureCapacityInternal(count + len);//确保容量；
在点进源码，有expandCapacity(minimumCapacity);//扩容。
//则进行扩容了，不是真的这个数组扩容了，而是用新的进行了替换。
void expandCapacity(int minimumCapacity) {
        int newCapacity = value.length * 2 + 2;//注意扩展的是两倍加2；
        if (newCapacity - minimumCapacity < 0)
            newCapacity = minimumCapacity;
        if (newCapacity < 0) {
            if (minimumCapacity < 0) // overflow
                throw new OutOfMemoryError();//抛出异常；
            newCapacity = Integer.MAX_VALUE;
        }
        value = Arrays.copyOf(value, newCapacity);
    }
//同样数组大小定义了是不能再变的了，因此要重新建一个数组。在copyOf方法里面定义了一个新的数组。
public static char[] copyOf(char[] original, int newLength) {
        char[] copy = new char[newLength];
        System.arraycopy(original, 0, copy, 0,
                         Math.min(original.length, newLength));
        return copy;
    }

后面讲的容器也是这样的思路来进行扩容的。

1
2
3
4
5
6
7
8
9
修改数组。
 public StringBuilder delete(int start, int end) {
        super.delete(start, end);
        return this;
    }
 、、、、、、、
    StringBuilder sb = new StringBuilder("abcdefghijklnmopqsr");
    sb.delete(2, 5).delete(2, 5);//删除索引，抱头不包尾；[2，5）；是可以实现方法链的。因为return this。
    System.out.println(sb);//abijklnmopqsr

1
2
3
4
5
replac（）；替换，跟数组差不多，不同的就是实现机制不同。它是直接操作数组的，因为是可变的。
 public StringBuilder replace(int start, int end, String str) {
        super.replace(start, end, str);
        return this;
    }

1
2
insert；在索引处插入字符，索引往后推，
数组是插入不方便，查询方便。

1
public StringBuilder reverse()翻转一遍。