Java常用类之包装类

包装类

1.基本类型做对应的引用类型
2.Object可同一所有数据，包装类的默认值是null。

public class ClassSwitch {
    public static void main(String[] args) {
        //类型转换：装箱   将基本类型转换为数据类型   即从栈中移至堆中
        int num1 = 18;
        Integer integer1 = new Integer(num1);
        Integer integer2 = Integer.valueOf(num1);
        System.out.println(integer1);
        System.out.println(integer2);

        //类型转换：拆箱    将数据类型转换为基本类型
        Integer integer3 = new Integer(100);
        int num2 = integer3.intValue();
        System.out.println(num2);

        //JDK1.5之后，编译器具有了自动装箱，拆箱的功能
        int age = 16;
        Integer integer4 = age;
        System.out.println(integer4);

        int age2 = integer4;
        System.out.println(age2);
    }
}

基本类型与字符串的转换

1.   8种包装类提供不同类型之间的转换方式
       1. Number父类中提供的6个共性方法
       2. parseXX()提供的静态方法
       3. valueOf()静态方法
2.   注意：需要保证类型兼容，否则抛出异常。

public class ClassSwitch {
    public static void main(String[] args) {
        //字符串和基本类型的转换

        //基本类型---->字符串
        int num3 = 15;
        //1.用+来转换
        String s1 = num3+"";
        //2.toString()方法 转换
        String s2 = Integer.toString(num3,16);
        System.out.println(s1);
        System.out.println(s2);

        //字符串----->基本类型
        String str = "152";    //注意：所转换的字符串中在转换为基本类型是不能出现非数字
        //使用Integer中的parseXX转换
        int num4 = Integer.parseInt(str);
        System.out.println(num4);

        //boolean字符串转换： “true”——>true  非“true”——>false
        String str2 = "true";
        String str3 = "dkfjs";
        boolean s3 = Boolean.parseBoolean(str2);
        boolean s4 = Boolean.parseBoolean(str3);
        System.out.println(s3);
        System.out.println(s4);
    }
}

Integer内存缓冲区

1. Java预先创建了256个常用的整数包装类型对象
2. 在实际应用中，对已创建的对象复用。

public class Demo01 {
    public static void main(String[] args) {
        Integer integer1 = new Integer(100);
        Integer integer2 = new Integer(100);
        System.out.println(integer1==integer2);   //输出false

        Integer integer3 = 100;  //自动装箱  ：Integer integer3 = Integer.intValue(100);
        Integer integer4 = 100;
        System.out.println(integer3==integer4);   //输出true

        Integer integer5 = 500;  //自动装箱
        Integer integer6 = 500;
        System.out.println(integer5==integer6);   //输出false
        
        //原因：看源码valueOf   IntegerCache
        /*     
        public static Integer valueOf(int i) {
        if (i >= IntegerCache.low && i <= IntegerCache.high)
            return IntegerCache.cache[i + (-IntegerCache.low)];
        return new Integer(i);
        }
    */
    }
}

String类

1. 字符串是一个常量，创建后就不可以改变。
2. 字符串字面值储存在字符串池中，可以共享；
3. String s = “Hello”;  产生一个对象，字符串池中储存；
4. String s = new String（“Hello”）; 产生两个对象，堆、池各储存一个。

public class Demo02 {
    public static void main(String[] args) {
        String name = "hello";  //"hello"常量  ，储存在字符串池中；
        name = "张三";    //"张三"赋值给name，但是原先的hello常量并不改变，也不消失，而是在字符串池中新建一个空间。
        String name2 = "张三";  //原字符串池中已经存在，因此name2直接调用字符串池中的数据

        //字符串的另一种方式 new String();
        String s = new String("java");  //在字符串池 和 堆中各开辟一个空间，常量在字符串池中存在
        String s1 = new String("java");
        System.out.println(s==s1);          //比较的是内存空间位置
        System.out.println(s.equals(s1));  //比较字符串的相同
    }
}

String常用方法

1. public int length();  返回字符串的长度；
2. public char charAt(int index);  根据下标获取字符；
3. public boolean contains(String str);  判断当前字符串中是否包含str。
4. public char[] toCharArray()  返回字符串中所对应的数值
5.  public int indexOf(String str)     返回字符串首次出现的位置
6. public int lastIndexOf(String str) 返回字符串最后一次出现的位置
7. public String trim() 去掉字符串前后的空格
8. public String toUpperCase() 把小写转换为大写 toLowerCode() 把大写转换为小写
9. public boolean endWith(String str) 判断是否以str结尾 startWith(str) 判断是否以str开始
10. public String replace(char old , char new) 用新的字符串替换旧的字符串
11. public String[] split(String str) 对字符串进行拆分

public class Demo02 {
    public static void main(String[] args) {
        //String常用方法1：
        /*
        1.length();  2.charAt()    3.contains()
        4.toCharArray()  返回字符串中所对应的数值
        5. indexOf()     返回字符串首次出现的位置
        6. lastIndexOf() 返回字符串最后一次出现的位置
        7.trim() 去掉字符串前后的空格
        8.toUpperCase() 把小写转换为大写 toLowerCode() 把大写转换为小写
        9.endWith(str) 判断是否以str结尾 startWith(str) 判断是否以str开始
        10.replace(char old , char new) 用新的字符串替换旧的字符串
        11.split() 对字符串进行拆分
         */
        String str = "java学习是一件快乐java而痛苦的事情,java你好";
        System.out.println(str.length());
        System.out.println(str.charAt(str.length()-1));
        System.out.println(str.contains("java"));
        System.out.println(str.contains("学习的痛苦"));


        System.out.println(Arrays.toString(str.toCharArray()));
        System.out.println(str.indexOf("java"));
        System.out.println(str.indexOf("java",10));//从哪个脚标开始
        System.out.println(str.lastIndexOf("java"));

        String str1 = "   Hello   world  ";
        System.out.println(str1.trim());
        System.out.println(str.toUpperCase());
        System.out.println(str.toLowerCase());
        String str2 = "hello.java";
        System.out.println(str2.endsWith("java"));
        System.out.println(str2.startsWith("he"));

        System.out.println(str2.replace("java","php"));
        String say = "java is the best programing language,java";
        String[] arr = say.split("[ ,]");
        System.out.println(arr.length);
        for (String string : arr){
            System.out.println(string);
        }
        /*
        补充：  equals  compare()方法比较大小
         */
        String s3 = "hello";
        String s4 = "HELLO";
        String s5 = "HELLOadka";
        System.out.println(s3.equalsIgnoreCase(s4));//忽略大小写的比较
        System.out.println(s3.compareTo(s4));
        System.out.println(s4.compareTo(s5));  //比较字符串的长度
    }
}

StringBuffer 和 StringBuilder类

运行效率高于String类

public class Demo03 {
    public static void main(String[] args) {
        //StringBuffer buffer = new StringBuffer();
        StringBuilder buffer = new StringBuilder();
        //1.追加方法 append()
        buffer.append("java");
        System.out.println(buffer.toString());
        buffer.append("hello");
        System.out.println(buffer.toString());
        //2.添加insert();
        buffer.insert(0,"hello");    // 在哪个位置添加什么数据
        System.out.println(buffer.toString());
        //3.替换replace();
        buffer.replace(0,5,"你好");  // 从哪里开始，到哪里结束，替换为什么
        System.out.println(buffer.toString());
        //4.删除 delete();
        buffer.delete(0,2);   //  从哪里开始，到哪里结束
        System.out.println(buffer.toString());
        //清空
        buffer.delete(0,buffer.length());
    }
}

BigDecimal类

用于精准计算浮点型数字

import java.math.BigDecimal;

public class Demo04 {
    public static void main(String[] args) {
        double s1 = 1.0;
        double s2 = 0.9;
        System.out.println((s1-s2));

        //面试题
        double s3 = (1.4-0.5)/0.9;
        System.out.println(s3);

        BigDecimal bigDecimal = new BigDecimal("1.0");
        BigDecimal bigDecimal1 = new BigDecimal("0.9");
        BigDecimal result1 = bigDecimal.subtract(bigDecimal1);
        System.out.println(result1);  //bigDecimal-bigDecimal1  减法

        BigDecimal result2 = bigDecimal.add(bigDecimal1);
        System.out.println(result2);  //加法

        BigDecimal result3 = bigDecimal.multiply(bigDecimal1);
        System.out.println(result3);  //乘法

        BigDecimal result4 = new BigDecimal("10")
                .divide(new BigDecimal(3),3,BigDecimal.ROUND_HALF_UP);  // 保留几位小数，四舍五入
        System.out.println(result4);  //除法
    }
}