java基础-包装类

Posted 2021-03-06 社会主义虫不胖

 
    java中的类把方法和数据链接在一起，构成了包含式的处理单元。java中不能定义基本数据类型对象，为了能将基本类型视为对象处理，并能连接相关的方法，java为每个基本类型提供了包装类，如int型数值的包装类Integer和boolean型数值的包装类Boolean。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);
        }

    }
}

 

1、Integer

 

    java.lang中包含Integer类、Long类、Short类，分别是基本类型int、long、short封装成一个类，都是Number的子类。Integer类在对象中包装了一个基本类型int值，该类的对象包含一个int类型字段，此外还提供了多个方法，能在int类型和String类型之间转换，同时还提供了其他一些处理int类型时有用的常量和方法。

 

    （1）构造方法

 

    Integer（int Number）

 

    以int型变量作为参数，获取Integer对象。

Integer number = new Integer(7);

 

    Integer（String Number）

    以String型变量为参数获取Integer对象。

Integer number = new Integer(\'7\');

    注意：要用数值型String作为参数，例如123，否则会抛出NumberFormatException异常。

    （2）常用方法

 

 

 

 parseInt()方法返回与调用该方法的数值字符串相应的整型（int）值。

    代码示例：

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);
    }
}

 

 

 

 

Integer类的toString()方法，可将Integer对象转为十进制字符串表示，toBinaryString()、toHexString()、toOctalString()方法分别将值转换为二进制、十六进制、八进制字符串。

 

代码示例：

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);
    }
}

 

 

 

  （3）常量

    Integer类提供了4个常量：

    MAX_VALUE：表示int类型可去的最大值，即 2^31-1

    MIN_VALUE：表示int类型可去的最小值，即 -2^31

    SIZE：用来以二进制补码形式表示int的位数

    TYPE：表示基本类型int的Class实例

 

    代码示例：

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);
    }
}

 

 

2、Boolean

 

    Boolean是将boolean类型的值包装在一个对象中，一个Boolean类型的对象只包含一个类型为boolean的字段。还为boolean和String相互转换提供了方法。

 

（1）构造方法

 

    Boolean(boolean value) === 创建一个表示value参数的Boolean对象

 

    Boolean b = new Boolean(true);

 

 

 

    Boolean(String str) ==== 以String变量作为参数创建Boolean对象。如果String参数不为null且忽略大小写时，等于true，则分配一个表示为true值得Boolean对象，否则活得一个false值得Boolean对象。

 

    Boolean bool = new Boolean("ok");

 

 

 

（2）常用方法

 

 

    代码示例：

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 "));

    }
}

（3）常量

    TRUE：对应基值为true的Boolean对象

    FALSE：对应基值为false的Boolean对象

    TYPE：基本类型boolean的Class对象

 

 

3、Byte

 

   Byte是将基本类型为byte的值包装在一个对象中。一个Byte类型的对象只能包含一个类型为byte的字段。还为byte、String相互转换提供了方法。

 

    （1）构造方法

 

    Byte(byte value) === 可表示指定的byte值

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

 

 Byte(String str) === 可表示String参数所指示的byte值。

Byte mybyte2 = new Byte("12");

    注意：要用数值型String变量作为参数，如123，否则会抛出NumberFormatException异常。

 

    （2）常用方法

    （3）常量

    MIN_VALUE：byte类型可取得最小值

    MAX_VALUE：byte类型可取的最大值

    SIZE：用于以二进制补码形式表示byte值得位数

    TYPE：表示基本类型byte的Class实例

 

代码示例：

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);
    }
}

 

 

 

4、Chatacter

 

   （1）构造方法

 

    Character(char value) === 必须是一个char类型的数据，通过该构造方法创建的Character类对象包含由char类型参数提供的值，一旦Character类被创建，它包含的数值就不能改变了。

 

    Character mychar  = new Character(\'s\');

 

 

 

    （2）常用方法

 

 

 

 

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\'));
    }
}

 

 

 

 

    （3）常量

 

    CONNETOR_PUNCTUATION：返回byte型值，表示Unicode规范中的常规类别“Pc”

 

    UNASSIGNED：返回byte型值，表示Unicode规范中的常规类别“Cn”

 

    TITLECASE_LETTER：返回byte型值，表示Unicode规范中的常规类别“Lt”

 

 

5、Double

 

　　Double和Float包装类是对double、float基本类型的封装，都是Number的子类，又都是对小数进行操作，所以常用方法基本相同。Double类在对象中包装了一个基本类型为Double的值，每个Double类的对象都包含一个double类型的字段，此外该类还提供多个方法，将double转换为String，也可以将String转为double。

 

    （1）构造方法

 

    Double(double value):基于double参数创建Double类对象

 

    Double(String value)：构造一个新分配的Double对象，表示用字符串表示的double类型浮点值

 

    

 

    注意：如果不是以数值类型的字符串作为参数，则抛出NumberFormatException异常

 

 

 

    （2）常用方法

 

 

 

 

    （3）常量

    MAX_EXPONENT：返回int值，表示有限double变量可能具有的最大指数

    MIN_EXPONENT：返回int值，表示标准化double变量可能具有的最小指数

    NEGATIVE_INFINITY：返回double值，表示保存double类型的负无穷大值得常量

    POSITIVE_INFINITY：返回double值，表示保存double类型的正无穷大值得常量

 

 

6、Number

    抽象类Number是BigDecimal、BigInteger、Byte、Double、Float、Integer、Long、Short类的父类，Number的子类必须通过方法，用来将表示的数值byte,double,float,int,long,short的方法。Number类的方法分别被Number的各子类实现。