前言
Java基础有很多方面，基本数据类型及其包装类型算是其一，我们必须得掌握。
一、基本数据类型
在Java中，基本数据类型可分为以下几类：
- 数值型
- 整数类型
- byte
- short
- int
- long
- 浮点类型
- float
- double
- 整数类型
- 字符型
- char
- 布尔型
- boolean
而整数类型又可使用三种进制来表示。
- 十进制 （默认）
- 八进制 （以0开头）
- 十六进制 （以0X或0x开头）
整数类型占用的内存及范围如下所示。默认的整数类型为int，如果要使用long，需要在数值末尾加上小写的l或大写的L，推荐使用大写的L，避免和字母i及其大写字母I混淆。
| 整数类型 | 内存 | 取值范围 |
|---|---|---|
| byte | 8 bit | -128 - 127 |
| short | 16 bit | -32768 - 32767 |
| int | 32 bit | -2^32 - 2^32-1 |
| long | 64 bit | -2^32 - 2^32-1 |
对于浮点类型，默认是double类型，如果要使用float，需在数值末尾加上小写的f或大写的F，推荐使用大写的F。
boolean类型只有1位，false用0表示，true用1表示。
char类型用于表示unicode表中的所有字符，unicode表几乎涵盖了所有国家所有语言的所有字符。其范围为0 - 65535。char为字符串的组成单元，有着举足轻重的作用。
char本质上还是一个数值，表示unicode表中的位置，例如下面的两个语句其实是等价的。
char ch = 'a';
char ch = 97;
另外，在数值未越界的情况下，char和int可以自动转换。
char word = 'd';
int p = 23045;
System.out.println("word is " + (int)word);
System.out.println("p is " + (char)p);
Java中有一些转意字符，有特殊的含义，例如：
- \' -- 单引号
- \\ -- 反斜杠
- \t -- 跳格
- \r -- 回车
- \n -- 换行
- \b -- 退格
- \f -- 换页
二、包装类型
上面我们提到了8种基本数据类型，而每种数据类型又对应一种包装类型，如下所示：
| 基本数据类型 | 包装类型 |
|---|---|
| boolean | Boolean |
| char | Character |
| int | Integer |
| byte | Byte |
| short | Short |
| long | Long |
| float | Float |
| double | Double |
为什么需要基本数据类型？
为了效率。new创建的对象存放在堆区，简单的小变量如果使用对象创建的方式，效率并不会很高。因此，这类变量是直接存放在栈区，从而提高了效率。
为什么需要包装类型？
- 基本类型不具备对象的特性，比如有属性和方法。包装类型是为了让基本类型具有对象的特性；
- 可以方便地使用泛型。例如，我们不能直接将基本数据类放入集合类。
为了灵活地支持包装类型，Java编译器提供了自动装箱和拆箱的机制。例如：
Integer x = new Integer(36);
int y = x;
int z = 36;
Integer u = new Integer(z);
基本类型和包装类型有一些区别，主要体现为下面几点：
- 基本类型不能使用new关键字来创建，包装类型必须使用new关键字来创建。
- 存储的位置不同。基本类型存储在栈区，包装类型存储在堆区。
- 初始值不同。基本类型中的int初始值为0，boolean初始值为false。包装类型初始值都为null。因此在进行自动装拆箱时一定要避免空指针异常。
- 使用场景不同。基本类型主要用于计算和赋值。包装类型用于泛型。
- 基本类型是值传递，包装类型是引用传递。
【注】：应尽量避免使用
xxx == yyy和xxx.equals(yyy)的方式进行比较，而是应该通过Objects.equals(xxx, yyy)的方式。
三、包装类型常用方法
1. Boolean
public static final Boolean TRUE = new Boolean(true);
public static final Boolean FALSE = new Boolean(false);
public static final Class<Boolean> TYPE = (Class<Boolean>) Class.getPrimitiveClass("boolean");
public Boolean(boolean value) {
this.value = value;
}
public Boolean(String s) {
this(parseBoolean(s));
}
public static boolean parseBoolean(String s) {
return ((s != null) && s.equalsIgnoreCase("true"));
}
public boolean booleanValue() {
return value;
}
public static Boolean valueOf(boolean b) {
return (b ? TRUE : FALSE);
}
public static Boolean valueOf(String s) {
return parseBoolean(s) ? TRUE : FALSE;
}
public static String toString(boolean b) {
return b ? "true" : "false";
}
public String toString() {
return value ? "true" : "false";
}
public static boolean parseBoolean(String s) {
return ((s != null) && s.equalsIgnoreCase("true"));
}
2. Integer
public static final int MIN_VALUE = 0x80000000;
public static final int MAX_VALUE = 0x7fffffff;
public static final Class<Integer> TYPE = (Class<Integer>) Class.getPrimitiveClass("int");
public static Integer valueOf(String s);
public static Integer valueOf(int i) {
if (i >= IntegerCache.low && i <= IntegerCache.high)
return IntegerCache.cache[i + (-IntegerCache.low)];
return new Integer(i);
}
public int intValue();
public static int parseInt(String s) throws NumberFormatException {
return parseInt(s,10);
}
3. Long
public static final long MIN_VALUE = 0x8000000000000000L;
public static final long MAX_VALUE = 0x7fffffffffffffffL;
public static final Class<Long> TYPE = (Class<Long>) Class.getPrimitiveClass("long");
public static Long valueOf(String s);
public static Long valueOf(long l) {
final int offset = 128;
if (l >= -128 && l <= 127) { // will cache
return LongCache.cache[(int)l + offset];
}
return new Long(l);
}
public long longValue();
public static long parseLong(String s) throws NumberFormatException {
return parseLong(s, 10);
}
4. Double
/**
* 用于表示正无穷大
* A constant holding the positive infinity of type
* {@code double}. It is equal to the value returned by
* {@code Double.longBitsToDouble(0x7ff0000000000000L)}.
*/
public static final double POSITIVE_INFINITY = 1.0 / 0.0;
/**
* 用于表示负无穷大
* A constant holding the negative infinity of type
* {@code double}. It is equal to the value returned by
* {@code Double.longBitsToDouble(0xfff0000000000000L)}.
*/
public static final double NEGATIVE_INFINITY = -1.0 / 0.0;
/**
* 用于表示非数字
* A constant holding a Not-a-Number (NaN) value of type
* {@code double}. It is equivalent to the value returned by
* {@code Double.longBitsToDouble(0x7ff8000000000000L)}.
*/
public static final double NaN = 0.0d / 0.0;
/**
* 最大值
* A constant holding the largest positive finite value of type
* {@code double},
* (2-2<sup>-52</sup>)·2<sup>1023</sup>. It is equal to
* the hexadecimal floating-point literal
* {@code 0x1.fffffffffffffP+1023} and also equal to
* {@code Double.longBitsToDouble(0x7fefffffffffffffL)}.
*/
public static final double MAX_VALUE = 0x1.fffffffffffffP+1023; // 1.7976931348623157e+308
/**
* 最小的正值
* A constant holding the smallest positive normal value of type
* {@code double}, 2<sup>-1022</sup>. It is equal to the
* hexadecimal floating-point literal {@code 0x1.0p-1022} and also
* equal to {@code Double.longBitsToDouble(0x0010000000000000L)}.
*
* @since 1.6
*/
public static final double MIN_NORMAL = 0x1.0p-1022; // 2.2250738585072014E-308
/**
* 最小值
* A constant holding the smallest positive nonzero value of type
* {@code double}, 2<sup>-1074</sup>. It is equal to the
* hexadecimal floating-point literal
* {@code 0x0.0000000000001P-1022} and also equal to
* {@code Double.longBitsToDouble(0x1L)}.
*/
public static final double MIN_VALUE = 0x0.0000000000001P-1022; // 4.9e-324
/**
* 最大的指数
* Maximum exponent a finite {@code double} variable may have.
* It is equal to the value returned by
* {@code Math.getExponent(Double.MAX_VALUE)}.
*
* @since 1.6
*/
public static final int MAX_EXPONENT = 1023;
/**
* 最小的指数
* Minimum exponent a normalized {@code double} variable may
* have. It is equal to the value returned by
* {@code Math.getExponent(Double.MIN_NORMAL)}.
*
* @since 1.6
*/
public static final int MIN_EXPONENT = -1022;
/**
* double的长度
* The number of bits used to represent a {@code double} value.
*
* @since 1.5
*/
public static final int SIZE = 64;
/**
* double占用的字节数
* The number of bytes used to represent a {@code double} value.
*
* @since 1.8
*/
public static final int BYTES = SIZE / Byte.SIZE;
/**
* The {@code Class} instance representing the primitive type
* {@code double}.
*
* @since JDK1.1
*/
@SuppressWarnings("unchecked")
public static final Class<Double> TYPE = (Class<Double>) Class.getPrimitiveClass("double");
public static Double valueOf(String s);
public static Double valueOf(double d) {
return new Double(d);
}
public double doubleValue() {
return value;
}
public static double parseDouble(String s) throws NumberFormatException {
return FloatingDecimal.parseDouble(s);
}
5. Float
/**
* A constant holding the positive infinity of type
* {@code float}. It is equal to the value returned by
* {@code Float.intBitsToFloat(0x7f800000)}.
*/
public static final float POSITIVE_INFINITY = 1.0f / 0.0f;
/**
* A constant holding the negative infinity of type
* {@code float}. It is equal to the value returned by
* {@code Float.intBitsToFloat(0xff800000)}.
*/
public static final float NEGATIVE_INFINITY = -1.0f / 0.0f;
/**
* A constant holding a Not-a-Number (NaN) value of type
* {@code float}. It is equivalent to the value returned by
* {@code Float.intBitsToFloat(0x7fc00000)}.
*/
public static final float NaN = 0.0f / 0.0f;
/**
* A constant holding the largest positive finite value of type
* {@code float}, (2-2<sup>-23</sup>)·2<sup>127</sup>.
* It is equal to the hexadecimal floating-point literal
* {@code 0x1.fffffeP+127f} and also equal to
* {@code Float.intBitsToFloat(0x7f7fffff)}.
*/
public static final float MAX_VALUE = 0x1.fffffeP+127f; // 3.4028235e+38f
/**
* A constant holding the smallest positive normal value of type
* {@code float}, 2<sup>-126</sup>. It is equal to the
* hexadecimal floating-point literal {@code 0x1.0p-126f} and also
* equal to {@code Float.intBitsToFloat(0x00800000)}.
*
* @since 1.6
*/
public static final float MIN_NORMAL = 0x1.0p-126f; // 1.17549435E-38f
/**
* A constant holding the smallest positive nonzero value of type
* {@code float}, 2<sup>-149</sup>. It is equal to the
* hexadecimal floating-point literal {@code 0x0.000002P-126f}
* and also equal to {@code Float.intBitsToFloat(0x1)}.
*/
public static final float MIN_VALUE = 0x0.000002P-126f; // 1.4e-45f
/**
* Maximum exponent a finite {@code float} variable may have. It
* is equal to the value returned by {@code
* Math.getExponent(Float.MAX_VALUE)}.
*
* @since 1.6
*/
public static final int MAX_EXPONENT = 127;
/**
* Minimum exponent a normalized {@code float} variable may have.
* It is equal to the value returned by {@code
* Math.getExponent(Float.MIN_NORMAL)}.
*
* @since 1.6
*/
public static final int MIN_EXPONENT = -126;
/**
* The number of bits used to represent a {@code float} value.
*
* @since 1.5
*/
public static final int SIZE = 32;
/**
* The number of bytes used to represent a {@code float} value.
*
* @since 1.8
*/
public static final int BYTES = SIZE / Byte.SIZE;
/**
* The {@code Class} instance representing the primitive type
* {@code float}.
*
* @since JDK1.1
*/
@SuppressWarnings("unchecked")
public static final Class<Float> TYPE = (Class<Float>) Class.getPrimitiveClass("float");
public static Float valueOf(String s) throws NumberFormatException {
return new Float(parseFloat(s));
}
public static Float valueOf(float f) {
return new Float(f);
}
public static float parseFloat(String s) throws NumberFormatException {
return FloatingDecimal.parseFloat(s);
}
public float floatValue() {
return value;
}
6. Byte
public static final byte MIN_VALUE = -128;
public static final byte MAX_VALUE = 127;
public static final Class<Byte> TYPE = (Class<Byte>) Class.getPrimitiveClass("byte");
public static Byte valueOf(byte b) {
final int offset = 128;
return ByteCache.cache[(int)b + offset];
}
public static byte parseByte(String s) throws NumberFormatException {
return parseByte(s, 10);
}
public static Byte valueOf(String s) throws NumberFormatException {
return valueOf(s, 10);
}
public byte byteValue() {
return value;
}
7. Short
public static final short MIN_VALUE = -32768;
public static final short MAX_VALUE = 32767;
public static final Class<Short> TYPE = (Class<Short>) Class.getPrimitiveClass("short");
public static short parseShort(String s) throws NumberFormatException {
return parseShort(s, 10);
}
public static Short valueOf(String s) throws NumberFormatException {
return valueOf(s, 10);
}
public static Short valueOf(short s) {
final int offset = 128;
int sAsInt = s;
if (sAsInt >= -128 && sAsInt <= 127) { // must cache
return ShortCache.cache[sAsInt + offset];
}
return new Short(s);
}
public short shortValue() {
return value;
}
8. Character
public static final Class<Character> TYPE = (Class<Character>) Class.getPrimitiveClass("char");
public static Character valueOf(char c) {
if (c <= 127) { // must cache
return CharacterCache.cache[(int)c];
}
return new Character(c);
}
public char charValue() {
return value;
}
9. 简单总结
通过对常用方法的分析，我们看到所有的包装类型都有一些类似的字段或函数，他们主要的作用是简化我们处理基本类型和包装类型的操作。而自动装箱和拆箱正是其中比较重要的一种机制。
四、自动装箱和拆箱的原理
java为了简化我们使用基本类型和包装类型的复杂度，特意引入了装箱和拆箱机制。
- 装箱机制 - 将基本数据类型转换为包装类型
- 拆箱机制 - 将包装类型转换为基本数据类型
public class Main {
public static void main(String[] args) {
Integer a = 32323;
int b = a;
}
}
上述代码，我们使用javap -c来反编译一下，看到如下结果：
C:\Users\Administrator>javap -c D:\zhangfb\ws\demo\target\classes\com\juconcurre
nt\demo\Main.class
Compiled from "Main.java"
public class com.juconcurrent.demo.Main {
public com.juconcurrent.demo.Main();
Code:
0: aload_0
1: invokespecial #1 // Method java/lang/Object."<init>":
()V
4: return
public static void main(java.lang.String[]);
Code:
0: sipush 32323
3: invokestatic #2 // Method java/lang/Integer.valueOf:
(I)Ljava/lang/Integer;
6: astore_1
7: aload_1
8: invokevirtual #3 // Method java/lang/Integer.intValue
:()I
11: istore_2
12: return
}
我们看到了#2和#3，他们分别对应的是装箱和拆箱。其实，装箱就是调用了valueOf()方法，而拆箱则调用了intValue()方法。与此类似，其他的类型有相同的机制。
总结
首先，我们引入了基本类型和包装类型，然后介绍了其异同和作用。
然后，了解了包装类型常用的字段和函数，他们的命名非常规范，函数的实现也非常简洁。
最后，我们通过自动装箱和拆箱机制，分析了这些函数在其中起到的作用。
网友评论