java基础-包装类

            import
             java.util.HashMap;

            import
             java.util.Map;


            public
            class
             WrapperClassesForNumberPrimaryTypesAppMain {
    
            public
            static
            void
             main(String[] args) {
        
            //
             >> TODO 从 Java 第一个版本开始，Java 就为每种基本数据类型提供了封装的类，以便可以将其当作类而非基本数据类型使用
        
            //
             >> TODO 比如 List，Map这些类，都是操作的Object，无法操作基本数据类型
        
            //
             >> TODO 和数字相关的基本数据类型对应的类依次为：Byte，Short，Integer，Long，Float, Double
            int a = 99;
        // TODO 可以使用数字创建一个Integer类，下面的方法在别的数字类中也都类似。
        Integer i1 = new Integer(a);
        Integer i2 = new Integer("789");
        int b = Integer.valueOf(a);
        int c = Integer.parseInt("998");

        System.out.println("-------------自动封箱拆箱----------------");
        // >> TODO Java 提供了自动为每种基本数据类型和其封装类之间的转换功能
        // >> TODO 从基本数据类型到封装类，我们叫做自动封箱，英文叫做auto boxing，反之叫做自动拆箱，叫做auto unboxing
        Integer ab = 987;
        int cd = ab;

        // TODO 自动封箱为Integer，作为Map中的key
        Map<Integer, String> int2Str = new HashMap<>();
        int2Str.put(1, "壹");
        int2Str.put(2, "贰");
        int2Str.put(3, "叁");
        System.out.println(int2Str.get(1));

        // TODO 自动拆箱为int，并给key赋值for (int key : int2Str.keySet()) {
            System.out.println(key);
        }

        System.out.println("-------------有用的方法----------------");

        System.out.println(Integer.toBinaryString(-1024));
        System.out.println(Integer.toOctalString(-1024));
        System.out.println(Integer.toHexString(-1024));

        System.out.println("-------------Number类----------------");

        // TODO 所有和数字相关的封装类，都继承自Number类
        Number num = 9;
        num = new Integer(12345);
        Number numD = 9.99;
        numD = new Double(12.30294);

        // TODO 使用Number类可以方便的进行数字类型的转换
        // TODO 当然所有的类都继承了Number的这些转换方法
        System.out.println("使用number将double转为long：" + numD.longValue());


        System.out.println("-------------自动拆箱可能的NPE----------------");

        int2Str.put(null, "无");
        System.out.println(int2Str.get(null));

        // TODO 自动拆箱为int，并给key赋值，但是有一个key为null，null是无法转成一个 int 的，注意，null 不是0，
        // TODO 其实自动拆箱，后面是Java帮我们调用了对应的方法，在这里就是intValue()这个方法
        // TODO 所以当引用为null时候自动拆箱，相当于是调用null的方法，所以这时候就会发生NPE
        // TODO 对于其它封装类型的自动拆装箱，也是一样的，for (int key : int2Str.keySet()) {
            System.out.println(key);
        }

    }
}

Integer number = new Integer(7);

Integer number = new Integer(‘7‘);

            public
            class
             Summation {
    
            public
            static
            void
             main(String[] args) {
        String str[] = {"85","12","10","15","22","45"};
        int sum = 0 ;
        for(int i = 0 ; i < str.length ; i++){
            int myint = Integer.parseInt(str[i]);
            sum += myint;
        }
        System.out.println("数组中各元素相加和是："+sum);
    }
}

            public
            class
             Charc {
    
            public
            static
            void
             main(String[] args) {
        String str = Integer.toString(456); //获取数字的十进制表示
        String str2 = Integer.toBinaryString(456);//获取数字的二进制表示
        String str3 = Integer.toHexString(456); // 获取数字的十六进制表示
        String str4 = Integer.toOctalString(456);//获取数字的八进制表示
        System.out.println("数字“456”的十进制表示：" + str);
        System.out.println("数字“456”的2进制表示：" + str2);
        System.out.println("数字“456”的16进制表示：" + str3);
        System.out.println("数字“456”的8进制表示：" + str4);
    }
}

            public
            class
             GetCon {
    
            public
            static
            void
             main(String[] args) {
        
            int maxint = Integer.MAX_VALUE;
        int minint = Integer.MIN_VALUE;
        int intsize = Integer.SIZE;

        System.out.println("int类型可取得最大值是："+maxint);
        System.out.println("int类型可取得最小值是："+minint);
        System.out.println("int类型二进制位数是："+intsize);
    }
}

            public
            class
             GetBoolean {
    
            public
            static
            void
             main(String[] args) {
        Boolean b1 = new Boolean(true);
        Boolean b2 = new Boolean("ok");
        System.out.println("b1:"+b1.booleanValue());
        System.out.println("b2:"+b2.booleanValue());
    }
}

            public
            class
             WrapperClassForBooleanAppMain {
    
            public
            static
            void
             main(String[] args) {
        
            //
             TODO boolean对应的类为Boolean，布尔值因为只有两个值，所以Boolean类直接提供了这两个值的静态变量
        System.out.println("-------------静态变量----------------");

        System.out.println(Boolean.TRUE);
        System.out.println(Boolean.FALSE);

        System.out.println("-------------valueOf----------------");
        // TODO 只有不分大小写的true才是true，剩下的字符串都是false
        System.out.println(Boolean.valueOf("true"));
        System.out.println(Boolean.valueOf("false"));
        System.out.println(Boolean.valueOf("asdf"));
        System.out.println(Boolean.valueOf(" true "));

    }
}

            byte mybyte = 45;
Byte b = new Byte(mybyte);

Byte mybyte2 = new Byte("12");

            public
            class
             ByteCom {
    
            public
            static
            void
             main(String[] args) {
        Byte b1 = Byte.MAX_VALUE;
        Byte b2 = Byte.MIN_VALUE;
        Byte b3 = Byte.SIZE;

        System.out.println(b1);
        System.out.println(b2);
        System.out.println(b3);
    }
}

            public
            class
             WrapperClassForCharAppMain {
    
            public
            static
            void
             main(String[] args) {
        
            //
             TODO char对应的类为Character，里面有很多isXXX方法比较实用，比如判断字符是否为数字
        System.out.println(Character.isDigit(‘A‘));
        System.out.println(Character.isDigit(‘字‘));
        System.out.println(Character.isDigit(‘0‘));
        System.out.println(Character.isDigit(‘9‘));
    }
}