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 的各子类实现.
来源: http://www.bubuko.com/infodetail-3457674.html