Java 常用的系统类解析

单例

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

好处:

它能够避免实例对象的重复创建，不仅可以减少每次创建对象的时间开销，还可以节约内存空间；能够避免由于操作多个实例导致的逻辑错误。如果一个对象有可能贯穿整个应用程序，而且起到了全局统一管理控制的作用

在JDK1.5版本中 不仅引入了 StringBuffer 还引入了 StringBuillder 它们两个在使用方法上是一样的.

系统方法代码示例:

class Single{
    // 随着类的加载而创建这个对象
    private static Single single = new Single();

    //构造方法私有化
    private Single() {
    }
    // 创建单例对象   
    //开放一个访问这个对象的方法
    public static Single getInstance() {        
        return single;  
    }       
}

// 懒汉式 单例(只有调用获取对象的方法 才有可能去创建对象)
// 延迟加载(懒加载)
class SingleLan{
    //创建单例对象 引用
    private static SingleLan singlelan = null;
    //构造方法私有化
    private SingleLan(){

    }
    //获取单例对象的方法
    public static SingleLan getInstance() {
        if (singlelan == null) {
            singlelan = new SingleLan();
        }
        return singlelan;   
    }   
}
public class Demo02 {   
}

StringBuffer

线程安全的可变字符序列。一个类似于 String 的字符串缓冲区，但不能修改。虽然在任意时间点上它都包含某种特定的字符序列，但通过某些方法调用可以改变该序列的长度和内容。

系统方法 代码举例:

public static void main(String[] args) {
        //fun1();       
        //fun2();       
        // fun3();
        //fun4();
        //fun5();
        //funct();
    }
    /**
     * 
     */
    public static void funct() {
        //替换
        StringBuffer sb = new StringBuffer();
        sb.append("wanglong");
        //  [0,4)  开始角标不能越界  
        //sb.replace(0, 4, "di");
        //System.out.println(sb);
        //字符串截取
    //  String substring = sb.substring(4);
    //  System.out.println(substring);
        String substring = sb.substring(0, 4);
        System.out.println(substring);
    }

    /**
     * 输出
     */
    public static void fun5() {
        int[] array = new int[]{1,2,3,4};
        String string = "[";
        for (int i = 0; i < array.length; i++) {
            string = string + array[i] + ",";
        }
        String string2 = "]";   
        StringBuffer stringBuffer = new StringBuffer(string);
        stringBuffer.deleteCharAt(8);
        stringBuffer.append(string2);
        System.out.println(stringBuffer);
    }

    /**
     * 键盘输入字符串反转
     */
    public static void fun4() {
        Scanner scanner = new Scanner(System.in);
        String string = scanner.nextLine();
        //转换成StringBuffer
        StringBuffer st = new StringBuffer(string);
        st.reverse();
        System.out.println(st);
    }

    /**
     * 删除 反转
     */
    public static void fun3() {
        StringBuffer sb = new StringBuffer();
         sb.append("wanglong");
         // 注意开始坐标不能越界 结束坐标越界 系统当清空处理
        // sb.delete(0, 3);
        // System.out.println(sb);

        // sb.deleteCharAt(2);
         //System.out.println(sb);
         sb.reverse();
         System.out.println(sb);
    }

    /**
     * 插入和修改
     */
    public static void fun2() {
        // 有参创建 直接使用字符串创建StringBuffer
         StringBuffer sb = new StringBuffer("wanglong");
        //插入一个字符 把字符插入索引的位置上
         // 插入 boolean 类型 相当于把 true 和 false 当字符串插入
        // sb.insert(3, 'z');
        // System.out.println(sb);
         // 给索引位置进行字符替换 字符修改
         // 注意 插入字符和字符修改不能越界
        // sb.setCharAt(3, 'z');
         //System.out.println(sb);
         //传入角标 传出字符
         char charAt = sb.charAt(5);
         System.out.println(charAt);

         // buffrt 转字符数组 先变字符串 在变字符数组
         char[] charArray = sb.toString().toCharArray();
    }

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

上面我们看了一些常用的方法 但是StringBuffer 和 StringBuillder 有什么区别呢?

StringBuffer 线程安全 效率低 耗费系统资源
StringBuillder 线程不安全 效率高(相对于StringBuffer)

那我们在讨论一下 string 和 StringBuffer 的一些区别

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

String 和 StringBuffer 做为参数的区别

string测试字符串当参数方法 字符串作为参数的时候 跟基本数据类型作为参数一样 相当于值得传递
StringBuffer 作为参数的时候 跟引用数据类型一样 相当于地址的传递

Integer类

为什么要把基本数据类型 封装成一个类?

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

应用方法举例:

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

    }

    /**
     * 
     */
    public static void fun2() {
        //JDK 1.5 自动装箱 和 自动拆箱 num1 和 num2 是一样的 系统会自动装箱 调用这个方法
        // 初值不要给null 避免计算中发生错误
        Integer num1 = 10;
        Integer num2 = Integer.valueOf(10);

        // 系统帮你把Num1 进行自动拆箱 转换回了 int 类型
        int rel = num1 + 5;     
        System.out.println(rel);
    }

    /**
     * 各种类型之间的转换
     */
    public static void fun1() {
        //创建一个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 valueOf = Integer.valueOf(10);
        // 把Integer 类型转换成 int 类型
        int intValue = valueOf.intValue();  
        // string 和 Integer 之间的转换
        Integer valueOf2 = Integer.valueOf("100");
        String string = valueOf2.toString();    
        // 把字符串转换为int
        int parseInt = Integer.parseInt("100");
    }
}

权限修饰符

表示的访问权限 具体如下表