【Java学习日记】#12 包装类

java.lang包中的 Integer类、 Long类、 Short类，可以将基本类型 int、 long、 short封装成一个类。这些类都是 Number的子 类，区别就是封装了不同的数据类型。

Integer

Integer类在对象中包装了一个基本类型int的值。该类的对象包含一个int类型的字段。此外，该类提供了多个方法，能在int类和String类之间相互转换，同时还提供了其他一些处理int类型时非常有用的常量和方法。

构造方法

Integer类有两种构造方法：

1. Integer(int number)
   以一个int型变量为参数来获取integer对象。

Integer number = new Integer(7);

2. Integer(String str)
   以一个String型变量为参数来获取Integer对象。

Integer number = new Integer("7");

必须使用数值型String变量作为参数。

常用方法

Integer类的常用方法：

方法	返回值	功能
byteValue()	byte	以byte类型返回该Integer的值
copareTo(Integer anotherInteger)	int	在数字上比较两个Integer对象。相等返回0；调用的小于anotherInteger，返回负值；大于正值
equals(Object IntegerObj)	boolean	比较此对象与指定对象是否相等
intValue()	int	以int型返回此integer对象
shortValue()	short	以short类型返回此Integer对象
toString()	String	返回一个表示该Integer值的String对象
ValueOf(String str)	Integer	返回保存指定的String值的Integer对象
perseInt(String str)	int	返回包含在由str指定得字符串中的数字的等价整数值

使用

perseInt()

public class IntegerUse {
    public static void main(String[] args) {
       String str[] = {"12","34","56"};
       int sum = 0;
       for(int i=0;i<str.length;i++){
           sum += Integer.parseInt(str[i]);
       }
        System.out.println(sum);
    }
}

输出结果：102

字符串中同样只能有数字。

toString()

public class toString {
    public static void main(String[] args) {
        String str = Integer.toString(456);
        String str1 = Integer.toBinaryString(456);
        String str2 = Integer.toHexString(456);
        String str3 = Integer.toOctalString(456);
        System.out.println("十进制 "+str);
        System.out.println("二进制 "+str1);
        System.out.println("十六进制 "+str2);
        System.out.println("八进制 "+str3);
    }
}

输出结果：

十进制 456
二进制 111001000
十六进制 1c8
八进制 710

常量

MAX_VALUE 表示int类型的最大值，2^31-1
MIN_VALUE 表示int类型的最小值，-2^31
SIZE 二进制补码形式表示int值的位数
TYPE 表示基本类型int的Class实例

public class toString {
    public static void main(String[] args) {
        System.out.println(Integer.MAX_VALUE);
        System.out.println(Integer.MIN_VALUE);
        System.out.println(Integer.SIZE);
        System.out.println(Integer.TYPE);
    }
}

2147483647
-2147483648
32
int

Boolean

构造方法

1. Boolean(boolean value)
   该方法创建一个表示value参数的Boolean对象

Boolean a = new Boolean(true);

2. Boolean(String str)
   该方法以String变量作为参数创建Boolean对象。

   如果String参数不为null且在忽略大小写时等于true，则分配一个表示true值的Boolean对象，否则获得一个false值的Boolean对象。

   意思是说："true"这个字符串的任意字母换为大写传进去之后都是true，其他字符串都是false。
   来自问答，感谢各位大佬！

Boolean bool = new Boolean("ok");

常用方法

方法	返回值	功能描述
booleanValue()	boolean	将boolean对象的值以对应的boolean值返回
equals(Object obj)	boolean	判断用该方法的对象和obj是否相等。当且仅当参数不是null，而且与调用该方法的对象一样都表示同一个boolean值的Boolean对象时，才能返回true
parseBoolean()	boolean	将字符串参数解析为boolean值
toString()	String	返回表示该boolean值的String对象
valueOf(String s)	boolean	返回一个用指定的字符串表示值的boolean值

常量

TRUE：对应基值true的Boolean对象
FALSE：对应基值false的Boolean对象
TYPE：基本类型boolean的class对象

使用

调用常值：

public class BooleanUse {
    public static void main(String[] args) {
        System.out.println(Boolean.TRUE);
        System.out.println(Boolean.FALSE);
        System.out.println(Boolean.TYPE);
    }
}

输出：

true
false
boolean

创建对象：

public class BooleanUse {
    public static void main(String[] args) {
        Boolean b1 = new Boolean(true);
        Boolean b2 = new Boolean("ok");
        Boolean b3 = new Boolean("True");
        System.out.println(b1);
        System.out.println(b2);
        System.out.println(b3);
    }
}

true
false
true

valueOf()：

public class BooleanUse {
    public static void main(String[] args) {
        Boolean b1 = Boolean.valueOf(true);
        Boolean b2 = Boolean.valueOf("False");
        System.out.println(b1);
        System.out.println(b2);
    }
}

true
false

public class BooleanUse {
    public static void main(String[] args) {
        Boolean b1 = Boolean.parseBoolean("true");
        Boolean b2 = Boolean.parseBoolean("ok");
        System.out.println(b1);
        System.out.println(b2);
    }
}

true
false

Byte

构造方法

用byte作为参数：

Byte b = new Byte((byte)15);

用String作为参数：

Byte b = new Byte("15");

自动装箱
java虚拟机自动将byte的值转为Byte对象。

Byte b = 15;

前两种已经过时，会出现划掉的效果：

valueOf()

Byte b1 = Byte.valueOf((byte)15);
Byte b2 = Byte.valueOf("15");

常用方法

常量

MAX_VALUE
MIN_VALUE
SIZE
TYPE

public class ByteUse {
    public static void main(String[] args) {
        System.out.println(Byte.MAX_VALUE);
        System.out.println(Byte.MIN_VALUE);
        System.out.println(Byte.SIZE);
        System.out.println(Byte.TYPE);
    }
}

127
-128

方法	返回值	功能描述
byteValue()	byte	以一个byte值返回Byte对象
compareTo(Byte anotherByte)	int	在数字上比较两个byte对象
doubleValue	double	以一个double值返回此Byte的值
intValue()	int	以一个int值返回此Byte的值
parseByte(String s)	byte	将String型参数解析成等价的字节（byte） 形式
toString	String	返回表示此Byte的值的String对象
valueOf(String str)	byte	返回一个保持指定String所给出的值的Byte对象
equals(Object obj)	boolean	将此对象与指定对象比较，相等返回true，不相等返回false

使用

public class ByteUse {
    public static void main(String[] args) {
        String s = "100";
        byte b1 = Byte.valueOf(s);//自动拆箱，下面那种方式也可行
        byte b2 = Byte.valueOf(s).byteValue();
        byte b3 = Byte.parseByte(s);//将一个字符串变成byte值
        System.out.println(b1);
        System.out.println(b2);
        System.out.println(b3);
        System.out.println(b1==b3);
    }
}

输出：

100
100
100
true

Character

构造方法

Character(Char value)

常用方法使用

public class CharacterUse {
    public static void main(String[] args) {
        Character c = new Character('A');
        System.out.println(c);
        //判断大小写
        System.out.println("是否为大写："+Character.isUpperCase(c));
        System.out.println("是否为小写："+Character.isLowerCase(c));
        //大小写转换
        System.out.println("转换为大写："+Character.toUpperCase(c));
        System.out.println("转换为小写："+Character.toLowerCase(c));
        //判断是否为字母
        System.out.println("是否为字母："+Character.isLetter(c));
        //判断是否为数字
        System.out.println("是否为数字："+Character.isDigit(c));
    }
}

A
是否为大写：true
是否为小写：false
转换为大写：A
转换为小写：a
是否为字母：true
是否为数字：false

Double

与上基本相同

public class DoubleUse {
    public static void main(String[] args) {
        //常量
        System.out.println("double类型的最大值："+Double.MAX_VALUE);
        System.out.println("double类型的最小值："+Double.MIN_VALUE);
        System.out.println("double类型的长度："+Double.SIZE);
        System.out.println("double类型的类型："+Double.TYPE);
        //创建
        Double num1 = new Double(11.23);
        Double num2 = new Double("11.23");
        System.out.println(num1);
        System.out.println(num2);
        //valueOf
        Double num3 = Double.valueOf("3.14");
        System.out.println(num3);
        //判断是否为非数字
        System.out.println(Double.isNaN(num3.doubleValue()));//num3.doubleValue 返回num3的double值
        //转换为int值
        System.out.println(num3.intValue());
        //十六进制
        System.out.println(Double.toHexString(num3.doubleValue()));
    }
}

double类型的最大值：1.7976931348623157E308
double类型的最小值：4.9E-324
double类型的长度：64
double类型的类型：double
11.23
11.23
3.14
false
3
0x1.91eb851eb851fp1

Number

抽象类Number是BigDecimal、BigInteger、Byte、Double、Float、Integer、Long和Short类的共同父类。

因为是抽象类，所以不能被实例化。但是它的子类可以创造他的对象并且继承和实现他的所有方法。

public class NumberUse {
    public static void main(String[] args) {
        Number num1 = new Double(12.34);
        System.out.println(num1);
        System.out.println(num1.doubleValue());
        System.out.println(num1.intValue());
        System.out.println(num1.byteValue());
        //超出子类长度会溢出
        Number num2 = new Double(120000.34);
        System.out.println(num2);
        System.out.println(num2.doubleValue());
        System.out.println(num2.intValue());
        System.out.println(num2.byteValue());
    }
}

12.34
12.34
12
12
120000.34
120000.34
120000
-64