StringBuffer：

字符串缓冲区

特点：

1.相当于一个可变的序列 操作的是原字符串
2.线程安全 耗费资源

拼接：

/**
 * 无参创建StringBuffer
 */
 public static void fun() {
    //  创建一个StringBuffer（拼接字符串）
    StringBuffer sb = new StringBuffer();
    //  获取容量（理论值） 默认值 16
    System.out.println(sb.capacity());
    //  获取长度
    System.out.println(sb.length());
    //  转化为字符串
    System.out.println(sb.toString());
    //  拼接字符串（操作的是原对象）
    sb.append("wangsong");
    //  如果直接打印对象 系统会帮你调用toString方法
    System.out.println(sb);
 }

插入：

/**
 * 插入 修改
 */
 public static void fun() {
    //  直接使用字符串创建StringBuffer
    StringBuffer sb = new StringBuffer("wangsong");
    //  插入一个字符 把字符插入到索引的位置上
    //  插入boolean类型 就相当于 把true和false当字符串插入
    sb.insert(3, false);
    System.out.println(sb);
    //  给索引位置进行 字符修改（替换）
    sb.setCharAt(6, 'k');
    System.out.println(sb);
    //  注意：插入字符和字符修改时 不可越界
    //  传入角标返回字符
    char c = sb.charAt(7);
    System.out.println(c);
    //  buffer转成字符数组
    //  先变字符串 然后再字符数组
    char[] charArray = sb.toString().toCharArray();
    System.out.println(charArray);
 }

删除：

/**
 * 删除
 */
 public static void fun() {
    StringBuffer sb = new StringBuffer();
    sb.append("wangsong");
    //  删除（删头不删尾）
    //sb.delete(0, 3);
    //  注意：开始坐标不能越界 结束坐标越界 系统当清空处理
    //System.out.println(sb);
    //  删除字符
    //sb.deleteCharAt(0);
    //System.out.println(sb);
    //  反转
    sb.reverse();
    System.out.println(sb);
 }

反转：

/**
 * 从键盘输入一个字符串 反转
 */
 public static void fun() {
    System.out.println("请输入一个字符串：");
    Scanner scanner = new Scanner(System.in);
    String string = scanner.nextLine();
    //  转成StringBuffer
    StringBuffer stringBuffer = new StringBuffer(string);
    //  反转
    stringBuffer.reverse();
    //  转化成字符串输出
    System.out.println(stringBuffer.toString());
 }

替换：

/**
 * 替换
 */
 public static void fun() {
    //  替换
    StringBuffer sb = new StringBuffer();
    sb.append("wangsong");
    //  [0,4)
    //  开始角标不能越界
    //sb.replace(5, 4, "lixiao");
    System.out.println(sb);
    //  字符串截取 返回了一个新的字符串给你
    //String substring = sb.substring(4);
    //System.out.println(substring);
    String substring1 = sb.substring(0, 4);
    System.out.println(substring1);
 }

拼接练习：

需求：

把int[] array = new int[]{1,2,3,4};
输出 [1, 2, 3, 4];

//  String方法
public static void fun() {
    int[] array = new int[]{1,2,3,4};
    String string = "[";
    //  遍历数组
    for (int i = 0; i < array.length; i++) {
        if (i < array.length - 1) {
            //  拼接字符串
            string = string + array[i] + ",";
        }else {
            string = string + array[i] + "]";
        }           
    }
    System.out.println(string);
}

//  StringBuffer方法
public static void fun() {
    int[] array = new int[]{1,2,3,4};
    StringBuffer stringBuffer = new StringBuffer();
    stringBuffer.append("[");
    //  遍历
    for (int i = 0; i < array.length; i++) {
        if (i < array.length - 1) {
            stringBuffer.append(array[i]).append(",");
        }else {
            stringBuffer.append(array[i]).append("]");
        }           
    }
    System.out.println(stringBuffer);
}

public static void fun1 (String string) {
    string = "fangsong";
}

public static void fun2 (StringBuffer sBuffer) {
        sBuffer.append("znb");
}

//  地址的传递
public static void fun3(StringBuilder sBuilder) {
    sBuilder.append("haha");
}

public static void main(String[] args) {    
    //  测试字符串当参数的方法
    //  字符串作为参数时 跟基本数据类型作为参数一样
    //  相当于值得传递
    String string = "wangsong";
    fun1(string);
    System.out.println(string);
    //  参数StringBuffer作参数
    //  StringBuffer作参数时 跟引用数据类型一样
    //  相当于 地址传递
    StringBuffer sBuffer = new StringBuffer("wangsong");
    fun2(sBuffer);
    System.out.println(sBuffer);
    //  地址的传递
    StringBuilder sBuilder = new StringBuilder("wangsong");
    fun3(sBuilder);
    System.out.println(sBuilder);
}

据上总结：

StringBuffer和StringBuilder区别
StringBuffer 线程安全 效率低（耗费系统资源）
StringBuilder 线程不安全 效率高（相对于StringBuffer消耗资源少）
StringBuffer和StringBuilder使用方法一样

String和StringBuffer的区别
String 是不可变得 线程不安全
StringBuffer 是可变的 操作的时对象本身

基本数据类型包装类：

包装类的作用：

类中可以声明方法 可以使用对象调用方法

举例：

public static void fun() {
    //  创建一个Integer对象
    Integer integer1 = new Integer(10);
    System.out.println(integer1);
    //  把字符串转化成 Integer类型
    //  注意：数字格式字符串 才能转换
    Integer integer2 = new Integer("100");
    System.out.println(integer2);

    int a = 60;
    //  转二进制 八进制 十六进制
    System.out.println(Integer.toBinaryString(a));
    System.out.println(Integer.toOctalString(a));
    System.out.println(Integer.toHexString(a));

    //  int和Integer之间的转换 静态方法
    Integer num1 = Integer.valueOf(10);
    //  把Integer类型转换成int类型
    int num2 = num1.intValue();

    //  string和Integer之间转换
    Integer num3 = Integer.valueOf("100");
    String string = num3.toString();
    //  把字符串转换成int
    int num4 = Integer.parseInt("100");
}

/**
 * JDK1.5 自动装箱 和 自动拆箱
 */
 public static void fun() {
    //  这样声明相当于 Integer.vakueOf(10)
    //  系统会自动装箱 调用这个方法
    //  初值不要给null
    Integer num1 = 10;
    //  系统把num1拆箱 转换成int类型
    int rel = num1 + 5; //  相当于调用num1.intValue---空指针异常
    System.out.println(rel);
}

public static void fun() {
    //  传入的值 如果在-128到127之间
    //  从数组中取出一个对象 返回
    //  超出[-128,127]这个区间
    //  返回 新创建的对象
    Integer num1 = 150;
    Integer num2 = 150;
    //  比较地址
    System.out.println(num1 == num2);
    //  Integer中的equals方法 比较int值
    System.out.println(num1.equals(num2));
}

权限修饰符：

default 什么都不要写

权限修饰符在不同类中的实现：