Java学习记录 包装类篇

Integer

Integer构造方法

1. new Integer（int number）
2. new Integer（String str）

以上有两种方式获取 Integer对象

Integer常量

Integer.MAX_VALUE  返回int型的最大值

Integer.MIN_VALUE   返回int型的最小值

Integer.SIZE 用二进制补码形式表示 int位数

Integer.TYPE 基本类型int

public static void main(String[] args) {
    System.out.println("int最大值（max）："+Integer.MAX_VALUE);
    System.out.println("int最小值（min）："+Integer.MIN_VALUE);
    System.out.println("max："+Integer.SIZE);
    System.out.println("max："+Integer.TYPE);
}

运行结果

int最大值（max）：2147483647
int最小值（min）：-2147483648
max：32
max：int

Integer方法

Integer.byteValue（）  以 byte类型 返回

Integer.compareTo（Integer i）  比较是否相同，两值相同则返回 0，对象小于 参数i 返回负值，否则为正值

Integer.intValue（）  以 int类型 返回

Integer.shortValue（）  以 short类型 返回

Integer.toString（）  返回 Integer值 的 String对象，返回String

Integer.valueOf（String str）  返回保存参数的 Integer对象

Integer.parseInt（String str）  返回参数中的数值

public class no1 {
    public static void main(String[] args) {
        Integer n = new Integer(12);
        
        System.out.println("byteValue（） 以 byte类型 返回(12)："+n.byteValue());
        
        System.out.println("compareTo（Integer i）比较是否相同(12 v 10)："+n.compareTo(10));
    
        System.out.println("intValue（）以 int类型 返回："+n.intValue());
    
        System.out.println("shortValue（）以 short类型 返回："+n.shortValue());
    
        String str = new String("123");
        System.out.println("toString（）返回 Integer值 的 String对象："+str.toString());
    
        System.out.println("valueOf（String str） 返回保存参数的 Integer对象((String)123) : "+n.valueOf("123"));
    
        System.out.println("parseInt（String str） 返回参数中的数值((String)123)："+n.parseInt("123"));
    }
}

运行结果

byteValue（） 以 byte类型 返回(12)：12
compareTo（Integer i）比较是否相同(12 v 10)：1
intValue（）以 int类型 返回：12
shortValue（）以 short类型 返回：12
toString（）返回 Integer值 的 String对象：123
valueOf（String str） 返回保存参数的 Integer对象((String)123) : 123
parseInt（String str） 返回参数中的数值((String)123)：123

Boolean

Boolean构造方法

1. new Boolean（boolean value）
2. new Boolean（String str）

以上有两种方式获取 Boolean对象

Boolean常量

Boolean.TRUE 对应基于true的 Boolean对象

Boolean.FALSE 对应基于false的 Boolean对象

Boolean.TYPE 基本类型Boolean

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

Boolean.TRUE：true
Boolean.FALSE：false
Boolean.TYPE：boolean

Boolean方法

Boolean.BooleanValue（）  将Boolean对象的值对应返回 Boolean值

Boolean.equsla（Object obj）  对象相同返回true，否则false

Boolean.parseBoolean（String s）  参数字符串解析为 Boolean值

Boolean.toString()  返回boolean值的String对象，返回String

Boolean.valueOf（String s）  返回参数Boolean值

public static void main(String[] args) {
    Boolean b1 = new Boolean(true);
    //默认false
    Boolean b2 = new Boolean("yes");
    System.out.println("BooleanValue(b1) : "+b1.booleanValue());
    System.out.println("BooleanValue(b2) : "+b2.booleanValue());

    System.out.println("b1.equsla(b2)："+b1.equals(b2));

    System.out.println("valueOf（b1）："+Boolean.valueOf(b1));
    System.out.println("valueOf（b2）："+Boolean.valueOf(b2));
    
    //String.valueOf(b1)：把b1引用的对象字符串化
    System.out.println("parseBoolean（b1）："+Boolean.parseBoolean(String.valueOf(b1)));
    //String.valueOf(b1)：把b2引用的对象字符串化
    System.out.println("parseBoolean（b2）："+Boolean.parseBoolean(String.valueOf(b2)));
}

运行结果

BooleanValue(b1) : true
BooleanValue(b2) : false
b1.equsla(b2)：false
valueOf（String s）：true
valueOf（String s）：false
parseBoolean（String s）：true
parseBoolean（String s）：false

Byte

Byte构造方法

1. new Byte（byte value）
2. new Byte（String str）

以上有两种方式获取 Byte对象

Byte常量

Byte.MAX_VALUE  返回byte型的最大值

Byte.MIN_VALUE   返回byte型的最小值

Byte.SIZE 用二进制补码形式表示 byte位数

Byte.TYPE 基本类型byte

    public static void main(String[] args) {
        System.out.println("Byte.MAX："+Byte.MAX_VALUE);
        System.out.println("Byte.MIN："+Byte.MIN_VALUE);
        System.out.println("Byte.SIZE："+Byte.SIZE);
        System.out.println("Byte.TYPE："+Byte.TYPE);
    }

运行结果

Byte.MAX：127
Byte.MIN：-128
Byte.SIZE：8
Byte.TYPE：byte

Byte方法

Byte.parseByte（String str）  参数String以byte值返回

Byte.valueOf（String str）  参数String以byte对象返回

Byte.equals（Object obj）  两个Byte对象判断是否相同

Byte.byteValue（）  返回此对象的byte值

Byte.intValue（）  返回此对象的int值

Byte.doubleValue（）  返回此对象的double值

public static void main(String[] args) {
//        Byte be = new Byte(12);  过时了
//        实例化对象的例子需要调用valueOf方法
        Byte b = Byte.valueOf((byte) 12);
//        或者
        Byte b2 = (byte)12;
    
        System.out.println("parseByte（String str）参数String以byte值返回："+b.parseByte("23"));
    
        System.out.println("valueOf（String str）参数String以byte对象返回："+b.valueOf("22"));
    
        System.out.println("equals（Object obj）两个Byte对象判断是否相同："+b.equals(b2));
    
        System.out.println("byteValue（） 返回此对象的byte值："+b.byteValue());
    
        System.out.println("intValue（）返回此对象的int值："+b.intValue());
    
        System.out.println("doubleValue（） 返回此对象的double值："+b.doubleValue());
    }
}

运行结果

parseByte（String str）参数String以byte值返回：23
valueOf（String str）参数String以byte对象返回：22
equals（Object obj）两个Byte对象判断是否相同：true
byteValue（） 返回此对象的byte值：12
intValue（）返回此对象的int值：12
doubleValue（） 返回此对象的double值：12.0

Character

Character构造方法

Character（char value）

Character常量

Character.CONNECTOR_PUNCTUATION 返回byte型值，表示Unicode的常规类别 Pc

Character.UNASSIGNED 返回byte型值，表示Unicode的常规类别 Cn

Character.TITLECASE_LETTER  返回byte型值，表示Unicode的常规类别 Lt

Character方法

Character.compareTo（Charcter char） 比较两个对象是否相同，相同则0

Character.equals（Object obj）  比较两对象的值，返回boolean值

Character.toUpperCase（char ch）  参数字母转化为大写doubleValue（）

Character.toLowerCase（char ch）  参数字母转化为小写

Character.toString（）  返回指定的char值的String对象

Character.charValue（）  返回Character对象的值

Character.isUpperCase（char ch）  判断参数字符是否是大写

Character.isLowerCase（char ch）  判断参数字符是否是小写

public static void main(String[] args) {
        Character ch = new Character('S');
        Character ch2 = new Character('s');
    
        System.out.println("compareTo（Charcter char）比较两个对象是否相同，相同则0："+ch.compareTo(ch2));
        
        System.out.println("equals（Object obj）比较两对象的值，返回boolean值："+ch.equals(ch2));
    
        System.out.println("toUpperCase（char ch）参数字母转化为大写："+Character.toUpperCase(ch));
    
        System.out.println("toLowerCase（char ch）参数字母转化为小写："+Character.toLowerCase(ch));
        
        System.out.println("toString（）返回指定的char值的String对象："+ch.toString());
    
        System.out.println("charValue（） 返回Character对象的值："+ch.charValue());
        
        System.out.println("isUpperCase（char ch） 判断参数字符是否是大写(S)："+Character.isUpperCase(ch));
        System.out.println("isUpperCase（char ch） 判断参数字符是否是大写(s)："+Character.isUpperCase(ch2));
        
        System.out.println("isLowerCase（char ch） 判断参数字符是否是小写(S)："+Character.isLowerCase(ch));
        System.out.println("isLowerCase（char ch） 判断参数字符是否是小写(s)："+Character.isLowerCase(ch2));
        
}

运行结果

compareTo（Charcter char）比较两个对象是否相同，相同则0：-32
equals（Object obj）比较两对象的值，返回boolean值：false
toUpperCase（char ch）参数字母转化为大写：S
toLowerCase（char ch）参数字母转化为小写：s
toString（）返回指定的char值的String对象：S
charValue（） 返回Character对象的值：S
isUpperCase（char ch） 判断参数字符是否是大写(S)：true
isUpperCase（char ch） 判断参数字符是否是大写(s)：false
isLowerCase（char ch） 判断参数字符是否是小写(S)：false
isLowerCase（char ch） 判断参数字符是否是小写(s)：true

Double

Double构造方法

1. new Double（double value）
2. new Double（String str）

以上有两种方式获取 Double对象

Double常量

Double.MAX_EXPONENT 返回int值，double最大指数

Double.MIN_EXPONENT  返回int值，double最小指数

Double.TYPE 基本类型double

Double.SIZE 用二进制补码形式表示 double位数

Double.NEGATIVE_INFINITY  返回double值，保存double类型的负穷大值

Double.POSITIVE_INFINITY  返回double值，返回double类型的正无穷大值

public static void main(String[] args) {
     System.out.println("Double.MAX："+Double.MAX_EXPONENT);
     System.out.println("Double.NIN："+Double.MIN_EXPONENT);
     System.out.println("Double.SIZE："+Double.SIZE);
     System.out.println("Double.TYPE："+Double.TYPE);
}

运行结果

Double.MAX：1023
Double.NIN：-1022
Double.SIZE：64
Double.TYPE：double

Double方法

Double.byteValue（）  以byte形式返回Double对象值

Double.compareTo（Double d）  两Double对象进行数值比较，相同则0

Double.equals（Object obj）  比较两对象是否相同，返回boolean

Double.intValue（）  以int形式返回double值

Double.isNaN（）  非数字值，则返回true，否则false

String.toString（）  返回Double对象的字符串形式

Double.valueOf（String str）  返回保存参数的double值的对象

Double.doubleValue（）  以double形式返回Double对象

Double.longValue（）  以long形式返回double值

Double.parseDouble（String str） 返回参数中的数值

public static void main(String[] args) {
        Double d = new Double(11.22);
        Double d2 = new Double(22);
        Double d3 = new Double(11.22);
        
        System.out.println("byteValue（） 以byte形式返回Double对象值："+d.byteValue());
        
        System.out.println("compareTo（Double d） 两Double对象进行数值比较，相同则0(d2)："+d.compareTo(d2));
        System.out.println("compareTo（Double d） 两Double对象进行数值比较，相同则0(d3)："+d.compareTo(d3));
        
        System.out.println("equals（Object obj）比较两对象是否相同，返回boolean(d2)："+d.equals(d2));
        System.out.println("equals（Object obj）比较两对象是否相同，返回boolean(d3)："+d.equals(d3));
        
        System.out.println("intValue（）以int形式返回double值："+d.intValue());
        
        System.out.println("isNaN（）非数字值，则返回true，否则false(d2)："+d2.isNaN());
        
        System.out.println("toString（）返回Double对象的字符串形式："+d.toString());
    
        System.out.println("valueOf（String str）返回保存参数的double值的对象："+d.valueOf("22.33"));
        
        System.out.println("doubleValue（）以double形式返回Double对象："+d.doubleValue());
        
        System.out.println("longValue（） 以long形式返回double值："+d.longValue());
    
    	System.out.println("parseDouble（String str）返回参数中的数值："+d.parseDouble("33.2"));
}

运行结果

byteValue（） 以byte形式返回Double对象值：11
compareTo（Double d） 两Double对象进行数值比较，相同则0(d2)：-1
compareTo（Double d） 两Double对象进行数值比较，相同则0(d3)：0
equals（Object obj）比较两对象是否相同，返回boolean(d2)：false
equals（Object obj）比较两对象是否相同，返回boolean(d3)：true
intValue（）以int形式返回double值：11
isNaN（）非数字值，则返回true，否则false(d2)：false
toString（）返回Double对象的字符串形式：11.22
valueOf（String str）返回保存参数的double值的对象：22.33
doubleValue（）以double形式返回Double对象：11.22
longValue（） 以long形式返回double值：11
parseDouble（String str）返回参数中的数值：33.2

Number

Number数值类是byte、Integer、long、float、Double、··· 的父类，Number的方法子类都可以用！！

Number方法

方法	返回值	说明
byteValue（）	byte	以byte形式返回数值
intValue（）	int	以int形式返回数值
floatValue（）	float	以float形式返回数值
shortValue（）	short	以short形式返回数值
longValue（）	long	以long形式返回数值
doubleValue（）	double	以double形式返回数值

public static void main(String[] args) {
     Number num = new Double(23000.23);
 
     System.out.println("以byte形式返回数值："+num.byteValue());
  
     System.out.println("以int形式返回数值："+num.intValue());
     
     System.out.println("以float形式返回数值："+num.floatValue());
     
     System.out.println("以short形式返回数值："+num.shortValue());
     
     System.out.println("以long形式返回数值："+num.longValue());
     
     System.out.println("以double形式返回数值："+num.doubleValue());
 }

运行结果

以byte形式返回数值：-40
以int形式返回数值：23000
以float形式返回数值：23000.23
以short形式返回数值：23000
以long形式返回数值：23000
以double形式返回数值：23000.23