Java 之StringBuffer方法的使用、单例以及权限修饰符

单例

单例 --- 设计模式(思想)
核心:在整个程序执行期间 有且只有一个该类的对象存在

懒汉式 单例(只有调用获取对象的方法才有可能去创建对象)
特点:延迟加载也叫懒加载
    class SingleLan{
        // 创建单例对象 引用
        private static SingleLan singleLan = null;
        // 构造方法私有化 不能创建对象
        private SingleLan() {
        }
        // 获取单例对象的方法
        public static Single() {
            // 判断如果没有这个对象 再创建 有就不创建
            if(singleLan == null) {
                singleLan = new SingleLan();
            }
            return singleLan;
        }
    }

饿汗式 单例
    class Single{
        // 创建单例对象 随着类的加载而创建这个对象
        private static Single single = new Single();
        // 构造方法私有化
        private Single() {

        }
        // 开放一个访问这个对象的方法
        public static Single getInstance() {
            return single;
        }
    }

StringBuffer

StringBuffer 是字符串缓冲区
特点:
    1.StringBuffer 相当于是一个可变序列(操作的是原字符串)
    2.线程安全(耗费资源)

StringBuffer 方法的使用

获取容量、长度:
    // 创建一个StringBuffer
    StringBuffer sb = new StringBuffer();
    // 获取容量(理论值) 默认值16
    System.out.println(sb.capacity());
    // 获取长度
    System.out.println(sb.length());

拼接:
    // 创建一个StringBuffer
    StringBuffer sb = new StringBuffer();
    // 拼接字符串 操作的是原对象
    sb.append("wanglong");
    // 如果直接打印对象 系统会帮你调用toString方法
    System.out.println(sb); 

插入和修改:
    // 直接使用字符串创建StringBuffer
    StringBuffer sb = new StringBuffer("wanglong");
    // 插入一个字符,把字符插入到索引的位置上
    sb.insert(0, 'z');
    System.out.println(sb);

    // 插入boolean 类型  就相当于 把true 和false 当字符串插入
    sb.insert(3,true);
    System.out.println(sb);

    // 给索引位置  进行字符替换 或者字符修改
    sb.setCharAt(0,'q');
    System.out.println(sb);
    // 注意: 插入字符和修改字符的时候 不能越界

    // 传入角标返回字符
    char charAt = sb.charAt(7);
    System.out.println(charAt);

    // buffer转成字符数组
    // 先变成字符串 然后再变字符数组
    char[] charArray = sb.toString().toCharArray();

删除:
    StringBuffer sb = new StringBuffer();
    sb.append("wanglong");

    // 删除 (删头不删尾)
    sb.delete(0, 4);
    // 注意: 开始坐标不能越界  结束坐标越界 系统当清空处理
    System.out.println(sb);

    // 删除字符
    sb.deleteCharAt(1);
    System.out.println(sb);

反转:
    StringBuffer sb = new StringBuffer();
    // 反转
    sb.reverse();
    System.out.println(sb); 

    例子:输入一个字符串 反转打印
            Scanner scanner = new Scanner(System.in);
            String string = scanner.nextLine();
            StringBuffer stringBuffer = new StringBuffer(string);
            stringBuffer.reverse();
            // 转化成字符串输出
            System.out.println(stringBuffer.toString());

替换:
    StringBuffer stringBuffer = new StringBuffer();
    stringBuffer.append("wanglong");

    // 替换 开始角标不能越界 
    stringBuffer.replace(0, 10, "sda");
    System.out.println(stringBuffer);

    // 字符串截取  返回了一个新的字符串
    String substring = stringBuffer.substring(5);
    System.out.println(substring);
    String substring1 = stringBuffer.substring(0, 4);
    System.out.println(substring1);

string与StringBuffer的相互转换:
        // string 转  StringBuffer 
        StringBuffer stringBuffer = new StringBuffer(string);

        // StringBuffer  转  string
        stringBuffer.toString();

String、StringBuffer与StringBuilder

String、StringBuffer 与 StringBuilder 作为方法的参数的区别:
        public static void fun1(String string) {
            string = "absc";
        }

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

        public static void fun3(StringBuilder stBuilder) {
            stBuilder.append("...");
        }

        public static void main(String[] args) {
            // 测试String做参数
            String string = "wanglong";
            fun8(string);
            System.out.println(string);

            // 测试StringBuffer做参数
            StringBuffer stringBuffer = new StringBuffer("wanglong");
            fun7(stringBuffer);
            System.out.println(stringBuffer);

            // 测试StringBuilder做参数
            StringBuilder stringBuilder = new StringBuilder("wanglong");
            fun9(stringBuilder);
            System.out.println(stringBuilder);
        }
总结:
    String 作为参数的时候跟基本数据类型作为参数一样相当于是值的传递
    StringBuffer 和 StringBuilder 作为参数的时候跟引用数据类型一样相当于是地址的传递

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

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

例子:
    /*
     * 需求
     * 把int[] array = new int[]{1,2,3,4};
     * 输出 [1, 2, 3, 4];
     * 要求:使用两种方法(String 和 StringBuffer)
     */

    // String 方法 
    public static void fun4() {
        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 fun5() {
        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);
    }

包装类

基本数据类型的          包装类
    byte                Byte
    short               Short
    int                 Integer
    long                Long
    float               Float
    double              Double
    boolean             Boolean
    char                Character
在类中可以声明方法,可以使用对象调用方法

    /**
     * Integer
     */
         // 创建一个Integer对象
         Integer integer = new Integer(10);
         System.out.println(integer);

        // 把字符串转换成 Integer类型
        // 注意:是数字格式字符串才能转换
        Integer integer2 = new Integer("111");
        System.out.println(integer2);

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

        // String和Integer之间转换
        Integer num3 = Integer.valueOf("100");
        String string3 = num3.toString();

        // 把字符串转换成 int
        int num4 = Integer.parseInt("100");

    /**
     * jdk1.5之后 自动装箱 和 自动拆箱
     */
        public static void fun2() {
            // 这样声明叫自动装箱 相当于调用这个方法 Integer num1 = Integer.valueOf(10);
            Integer num1 = 10; // 初值不要给null 避免计算中发生错误
            // 系统帮你把num1 进行自动拆箱  转换回了 int类型
            int rel = num1 + 5; // 相当于调用 num1.intValue
            System.out.println(rel);
        }

        Integer num1 = 100;
        Integer num2 = 100;
        // 地址
        System.out.println(num1 == num2);
        // Integer中的equals方法  比较int值
        System.out.println(num1.equals(num2));
注意:传入的值 如果在[-128,127]区间,就从数组中取出一个对象返回
            超出[-128,127]这个区间,返回的是新创建的对象

权限修饰符

权限修饰符(访问权限)
    1.public(公开的)
    2.private(私有的)
    3.protected(受保护的)
    4.默认的(default) 不写修饰符

             本类  同包类  同包子类  不同包类  不同包子类
public        √     √       √       √         √
private       √     ×       ×       ×         ×
protected     √     √       √       ×         √
默认的         √     √       √       ×         ×