Day13 Java String字符串学习

Day 13

1 包装类/封装类

• 知识点：包装类/封装类
  • 理解：包装类是8种基本数据类型对应的类
  • 出现原因：

  •  	Java为纯面向对象语言（万物皆对象），但是8种基本数据类型不能new对象，
    

  •  	破坏了Java为纯面向对象语言的特征，所以Java又为8种基本你数据类型分别
    

  •  	匹配了对应的类，这种类叫做包装类/封装类
    

  • 基本数据类型 引用数据类型 继承关系
  • byte Byte Object.Number.Byte
  • short Short Object.Number.Short
  • int Integer Object.Number.Integer
  • long Long Object.Number.Long
  • float Float Object.Number.Float
  • double Double Object.Number.Double
  • char Character Object.Character
  • boolean Boolean Object.Boolean
  • 注意：int类型对应的包装类是Integer，char类型对应的包装类是Character
  • 经验：学习包装类要举一反三

2 StringBuilder底层源码

abstract class AbstractStringBuilder {
//字符容器 - 34
//['n','u','l','l','a','a','a','a','a','b','b','b','b','b','c','c','c','c','c'...]
char[] value;
//有效字符数
int count;//24

//capacity - 16
AbstractStringBuilder(int capacity) {
    value = new char[capacity];
}

//str - "cccccccccc"
public AbstractStringBuilder append(String str) {
    if (str == null)
        return appendNull();
    int len = str.length();//len - 10
    ensureCapacityInternal(count + len);//14 + 10
    
    //将str下标为0开始的数据添加到value数组count下标的位置，拷贝len长度
    str.getChars(0, len, value, count);
    count += len;
    return this;
}

 private AbstractStringBuilder appendNull() {
    int c = count;//c - 0
    ensureCapacityInternal(c + 4);//扩容 -> 0+4
    final char[] value = this.value;
    value[c++] = 'n';//value[0] = 'n';
    value[c++] = 'u';//value[1] = 'u';
    value[c++] = 'l';//value[2] = 'l';
    value[c++] = 'l';//value[3] = 'l';
    count = c;
    return this;
}

//minimumCapacity - 24
private void ensureCapacityInternal(int minimumCapacity) {
    // 有溢出意识的代码
    //if(24 - 16 > 0)
    if (minimumCapacity - value.length > 0) {
        //value = Arrays.copyOf(value,34);
        value = Arrays.copyOf(value,newCapacity(minimumCapacity));
    }
}

//面试题：StringBuilder的扩容机制为什么是原来的2倍+2
//答：因为怕用户使用new StringBuilder(0)来创建对象，0<<1还是0，所以要加个2

//minCapacity - 24
private int newCapacity(int minCapacity) {
    //扩容机制：数组原来长度的2倍+2
    //int newCapacity = (16 << 1) + 2; --- 34
    int newCapacity = (value.length << 1) + 2;
    if (newCapacity - minCapacity < 0) {
        newCapacity = minCapacity;
    }
    return (newCapacity <= 0 || MAX_ARRAY_SIZE - newCapacity < 0)
        ? hugeCapacity(minCapacity)
        : newCapacity;
}
}

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

@Override
public synchronized StringBuffer append(String str) {//自动上锁
    toStringCache = null;
    super.append(str);
    return this;
}//自动解锁
}

public final class StringBuilder extends AbstractStringBuilder {
    
    public StringBuilder() {
        super(16);
    }
    
    //capacity - 10000
    public StringBuilder(int capacity) {
        super(capacity);
    }
    
    //str - "abc"
    public StringBuilder(String str) {
        super(str.length() + 16);//3 + 16
        append(str);
    }
    
    //str - "aaaaa"
    @Override
    public StringBuilder append(String str) {
        super.append(str);
        return this;
    }
    
}
//默认长度：10000
//StringBuffer sb = new StringBuffer(10000);

//默认长度："abc".length() + 16
//StringBuffer sb = new StringBuffer("abc");

//默认长度：16
StringBuffer sb = new StringBuffer();

String str = null;
sb.append(str);
sb.append("aaaaa");
sb.append("bbbbb");
sb.append("cccccccccc");

System.out.println(sb.toString());

经验：看底层，找场景

1. 看类的继承关系
2. 看属性
3. 看创建对象的过程
4. 研究场景