Java 当中的基本类型包装类
01
基本数据类型对象的包装类
什么是基本数据类型对象包装类呢? 就是把基本数据类型封装成对象, 这样就可以提供更多的操作基本数值的功能了.
基本数据类型对象的包装类 8 个:
基本数据类型 | 包装类 |
---|---|
byte | Byte |
short | Short |
int | Integet |
long | Long |
float | Float |
double | Double |
boolean | Boolean |
char | character |
java.lang
类 Integer
- java.lang.Object
- -> java.lang.Number
- -> java.lang.Integer
- public final class Integer
- extends Number
- implements Comparable<Integer>
Integer 类 是将一个基本类型为 int 的值包装成为对象的包装类.
Integer 类型的对象中包含了一个 int 类型的字段.
基本数据类型对象的包装类, 就是为了提供更多的操作方法, 这里的 Integer 类中 Java 提供了多个方法, 而且 Integer 类能够在 int 类型和 String 类型之间互相进行转换, 还可以处理一些 int 类型有关一些常量和方法等.
一些常量:
常量 | 返回的类型 |
---|---|
MAX_VALUE | static int 为返回的是静态整数类型,表示为 int 类型的最大值 |
MIN _VALUE | static int 为返回的是静态整数类型,表示为 int 类型的最小值 |
SIZE | static int 为返回的是静态整数类型,表示 int 值的比特位数 |
TYPE | static Class 表示返回基本类型 Int 的 Class 实例 |
一些构造方法:
方法 | 说明 |
---|---|
Integer(int value) | 构造一个 Integer 对象,表示指定 int 的值 |
Integer(String s) | 构造一个分配的 Integer 对象,表示 String 参数所指的 int 值 |
方法 | 说明 |
---|---|
decode(String nm) | static Integer 该方法可以将 String 解码为 Integer |
doubleValue() | 返回为 double 类型 是以 double 类型返回该 Integer 的值 |
equals(Object obj) | 返回 boolean 类型 比较此对象与指定对象 |
floatValue() | 返回 float 类型 以 float 类型返回该 Integer 的值 |
getInteger(String nm) | 返回的是 static Integer,确定具有指定名称的系统属性的整数值 |
getInteger(String nm, int val) | 返回的是 static Integer,确定具有指定名称的系统属性的整数值 |
getInteger(String nm, Integer val) | 返回的是 static Integer,返回具有指定名称的系统属性的整数值 |
hashCode() | 返回此 Integer 的哈希码 |
intValue() | 返回 int 类型 以 Int 类型返回给 Integer 的值 |
longValue() | 返回 long 类型 以 long 类型返回该 Integer 的值 |
toBinaryString(int i) | 返回 static String 类型,以二进制无符号整数形式返回一个整数参数的字符串表示形式 |
toHexString(int i) | 返回 static String 类型,以十六进制无符号整数形式返回一个整数参数的字符串表示形式 |
toOctalString(int i) | 返回 static String 类型,以八进制无符号整数形式返回一个整数参数的字符串表示形式 |
toString() | 返回 String 类型,返回一个表示该 Integer 值的 String 对象 |
toString(int i) | 返回类型为 static String,返回一个表示指定整数的 String 对象 |
toString(int i, int radix) | 返回类型为 static String,返回用第二个参数指定基数表示的第一个参数的字符串形式 |
valueOf(int i) | 返回类型为 static Integer,返回一个表示指定的 int 值的 Integer 实例 |
valueOf(String s) | 返回类型为 static Integer,返回一个表示指定的 String 值的 Integer 实例 |
02
基本数据类型对象包装类: 用于基本数据和字符串之间的转换.
parseInt(String s) 是将字符串参数作为有符号的十进制整数进行解析.
xxx.parseXxx(string);
注意只有 Character 没有解析的方法, 我们举个例子: int parseInt(string); -> byte parseByte(string); -> boolean parseBoolean(string);
- System.out.println("12"+3);
- // 结果为 123
- System.out.println(Integer.parseInt("12")+3);
- // 结果为 15
- parseInt
- public static int parseInt(String s) throws NumberFormatException
这个方法是将字符串参数作为有符号的十进制整数进行解析
参数 s: 包含解析的 int 表现形式的 String.
返回为: 带有符号的十进制的整数值.
抛出为 NumberFormatException: 如果字符串不含有可解析的整数.
异常:
- System.out.println(Integer.parseInt("a12")+3);
- // 抛出为 NumberFormatException
- System.out.println("a12",6);
- // 这种方法将其他进制转换为别的进制数
基本数值转换为字符串:
- 12+" ";
- String.valueOf(12);
- Integer.toString(int);
基本数据类型转换为包装类对象
- Integer i = new Integer(2);
- Integer i2 = new Integer("2");
- Integer i3 = Integer.valueOf(2);
包装类的对象转换为基本数据类型值
- // intValue(): 为以 int 类型返回该 Integer 的值
- Integer i = new Integer(2);
- int num = i.intValue();
基本数据类型包装类的自动装箱和拆箱
- int i = 3;
- Integer i = new Integer(3);
- // 为装箱
在 JDK1.5 后, java 提供了一个包装类的新的特性, 为自动装箱. 自然有自动拆箱咯~
- Integer i = 3;
- // 这样表示即为新特性, 自动装箱.
- // 一般我们是这样写
- Integer i = Integer.valueOf(3);
- // 如今
- Integer i = 3;
- // 系统会为它自动装箱
- i = i + 2;
- // 此时等于这样
- i = i.intValue() + 2; // 等同于 i = Integer.valueOf(i.intValue() + 2);
- // 为自动拆箱 i.intValue(), 然后再次装箱即可
Integer 包装类, 自动装箱和自动拆箱的重点
为 JDK1.5 前, 没有新特性
- Integer a = new Integer(3); // 为手动装箱
- Integer b = new Integer(3); // 为手动装箱
- System.out.println(a == b); // 结果为: false
- System.out.println(a.equals(b)); // 结果为: true
自动装箱和自动拆箱新特性
- Integer x = 100; // 自动
- Integer y = 100; // 自动
- System.out.println(x == y); // 结果为 true
- System.out.println(x.equals(y)); // 结果为 true
- Integer x = 200; // 自动
- Integer y = 200; // 自动
- System.out.println(x == y); // 结果为 false
- System.out.println(x.equals(y)); // 结果为 true
- Integer integer1 = 127;
- Integer integer2 = 127;
- System.out.println(integer1 == integer2);
- // true
- Integer integer1 = 128;
- Integer integer2 = 128;
- System.out.println(integer1 == integer2);
- // false
- Integer x = 127;
- Integer y = 127;
- System.out.println(x==y); // 结果为 true
- System.out.println(x.equals(y)); // 结果为 true
- Integer x = 128;
- Integer y = 128;
- System.out.println( x == y); // 结果为 false
- System.out.println( x.equals(y) ); // 结果为 true
因为在 JDK1.5 中, Java 面对在 -128~127 之间的 Integer 的值, 用的是原生基本数据类型 int, 会在内存中共用, 不会再新创建对象空间. 就是在这个范围之间的 Integer 值比较 "==", 是进行 int 原生数据类型的比较, 超出范围的比较, 就会创建新的对象空间.
有人问这究竟是为啥呢? 你问我?
这个是 jdk1.5 之后的新特性, 规定是数值在 byte 范围内不会创建新的对象空间, 而是用原来的空间, 这样就可以节省内存空间了哦~
03
案例
- // 一堆字符串, 定义字符串数字的变量
- String nums = "12 34 56 23 7 83";
- // 字符串中数值的排序, 定义一个方法为排序所要定义的字符串数字的变量, 完成任务
- nums = sortNumsString(nums);
- // 打印排序后的字符串
- System.out.println("nums" + nums);
- // 静态 String 类型
- public static String sortNumsString(String numsString){
- // 空格分割
- String[] strs = numsString.split(" ");
- // 字符串数组转换 int 数组, 定义了一个方法 parseIntArray()
- int[] nums = parseIntArray(strs);
- // 对数组进行排序
- Arrays.sort(nums);
- // 将数组转换为字符串
- return toString(nums);
- }
- // 字符串数组转换 int 数组
- private static int[] parseIntArray(String[] strs){
- // 定义 int 数组
- int[] arr = new int[strs.length];
- // 遍历字符串数组
- for(int i = 0; i < strs.length; i++){
- arr[i] = Integer.parseInt[strs[i]);
- }
- return arr;
- }
- // 将数组转换为字符串
- private static String toString(int[] nums){
- // 创建 StringBuilder 对象
- StringBuilder sb = new StringBuilder();
- // 循环添加
- for(int i = 0; i < nums.length; i++){
- if(i != nums.length-1){
- sb.append(nums[i]+" ");
- }else{
- sb.append(nums[i]);
- }
- }
- // 返回 sb.toString(); 方法
- return sb.toString();
- }
来源: http://www.jianshu.com/p/945f6354ebd6