Java回顾第七章

[懒懒张187]

1.包装类
概念：基本数据类型(int,double,char,boolean…),使用起来很方便，可以直接使用但是没有相关方法可以操作这些基本数据类型的值。故而我们可以使用一个类，把这些基本数据类型的值包装起来进行操作。

/**
    包装类:
        基本数据类型的值(int,double,char,boolean...),使用起来很方便,可以直接使用
        但是没有相关的方法,可以操作这些基本数据类型的值
        所以我们可以使用一个类,把这些基本数据类型的值包装起来
        在类中定义一些方法,用于操作这些基本数据类型的值
        这个类就叫做包装类
    基本数据类型:4类8种
        byte    short   int   long  float   double char boolean
    基本类型对应的包装类: java.lang包
        Byte    Short   Integer   Long  Float   Double Character Boolean
    java.lang.Integer类
        Integer 类在对象中包装了一个基本类型 int 的值。
 */
public class Demo01Integer {
    public static void main(String[] args) {
        /**
            装箱:把基本类型的值包装到包装类中 int--->Integer
            包装类的构造方法:
                Integer(int value) 传递整数
                Integer(String s) 传递一个字符串类型的整数
            包装类的静态方法:
                static Integer valueOf(int i)  传递整数
                static Integer valueOf(String s) 传递一个字符串类型的整数
            注意:
                两个传递字符串的方法,必须传递整数类型的字符串,否则会抛出异常
         */
        Integer in1 = new Integer(10);
        System.out.println(in1);//10 重写了toString方法
        Integer in2 = new Integer("10");
        System.out.println(in2);//10 重写了toString方法
        Integer in3 = Integer.valueOf(10);
        System.out.println(in3);//10
        Integer in4 = Integer.valueOf("10");
        System.out.println(in4);//10
        //Integer in5 = Integer.valueOf("a");//NumberFormatException(数字格式化异常): For input string: "a"
        //System.out.println(in5);
        Double d1 = Double.valueOf(5.5);
        System.out.println(d1);//5.5

        /**
            拆箱:在包装类中取出基本类型的值   Integer-->int
            Integer类中的方法:
                int intValue() 以 int 类型返回该 Integer 的值。
         */
        int a = in1.intValue();
        System.out.println(a);//10
    }
}

自动装箱，自动拆箱

/**
    自动装箱,自动拆箱:在JDK1.5以后,装箱和拆箱可以自动进行(基本类型的值和包装类的值可以自动相互转换)
        装箱:基本类型-->包装类
        拆箱:包装类-->基本类型
 */
public class Demo02Integer {
    public static void main(String[] args) {
        /**
            自动装箱:
                Integer in = 10;
                隐含了一个创建对象的过程
                Integer in = new Integer(10);
         */
        Integer in = 10;

        /**
            自动拆箱:
                in是包装类,无法直接参与计算
                in默认会调用intValue方法,把包装类转换为基本类型的整数在和1相加
                in.intValue()+1=11==>结果是一个基本类型的整数,又赋值给in这个包装类(自动装箱)
         */
        in = in+1;
        System.out.println("-----------------------------");
        ArrayList<Integer> list = new ArrayList<>();
        list.add(1);//自动装箱 相当于 list.add(new Intger(1));

        //int a = list.get(0).intValue();
        int a = list.get(0);//自动拆箱 get方法获取的元素是Integer类型,默认调用了intValue方法转换为了int类型的值
    }
}

3.基本数据类型和字符串之间的转换

/**
    基本类型与字符串之间的转换
    1.基本数据类型-->字符串
        a.基本数据类型的值+"":工作中最常用  1+""==>"1"
        b.使用包装类中的静态方法toString:
            static String toString(int i)返回一个表示指定整数的 String 对象。
        c.使用String类中的静态方法valueOf:
            static String valueOf(int i) 返回 int 参数的字符串表示形式。
    2.字符串-->基本数据类型
        在每个包装类中都有一个parseXXX方法,可以把字符串格式的基本类型的数据,转换为基本类型的数
            Integer类: static int parseInt(String s)
            Double类: static double parseDouble(String s)
            ...
        注意:
            字符串必须传递基本类型的字符串,否则会抛出数字格式化异常
 */
public class Demo03Integer {
    public static void main(String[] args) {
        //1.基本数据类型-->字符串
        //a.基本数据类型的值+"":工作中最常用  1+""==>"1"
        String s1 = 1+"";
        System.out.println(s1+10);//110

        //b.使用包装类中的静态方法toString:
        String s2 = Integer.toString(10);
        System.out.println(s2+10);//1010

        //c.使用String类中的静态方法valueOf:
        String s3 = String.valueOf(100);
        System.out.println(s3+10);//10010

        //2.字符串-->基本数据类型
        int a = Integer.parseInt("100");
        System.out.println(a+100);//200

        double d = Double.parseDouble("1.1");
        System.out.println(d+2.2);//3.3000000000000003

        //int abc = Integer.parseInt("abc");//NumberFormatException: For input string: "abc"
        //System.out.println(abc);
    }
}