Java学习记录 包装类篇
Integer
Integer构造方法
- new Integer（int number）
- 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构造方法
- new Boolean（boolean value）
- 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构造方法
- new Byte（byte value）
- 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构造方法
- new Double（double value）
- 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