Java基础——数据类型

Java语言提供了八种基本类型。六种数字类型（四个整数型，两个浮点型），一种字符类型，还有一种布尔型。

数据类型包装

为了方便操作基本数据类型值，将其封装成了对象，在对象中定义了属性和行为丰富了该数据的操作。用于描述该对象的类就称为基本数据类型对象包装类

将一个字符串转化成一个Integer对象，然后再调用这个对象的intValue()方法返回其对应的int数值

int i=Integer.valueOf(“123”).intValue()

将一个字符串转化成一个Float对象，然后再调用这个对象的floatValue()方法返回其对应的float数值

float f=Float.valueOf(“123”).floatValue()

将一个字符串转化成一个Boolean对象，然后再调用这个对象的booleanValue()方法返回其对应的boolean数值。

boolean b=Boolean.valueOf(“123”).booleanValue()

将一个字符串转化成一个Double对象，然后再调用这个对象的doubleValue()方法返回其对应的double数值。

double d=Double.valueOf(“123”).doubleValue()

将一个字符串转化成一个Long对象，然后再调用这个对象的longValue()方法返回其对应的long数值。

long l=Long.valueOf(“123”).longValue()

将一个字符串转化成一个Character对象，然后再调用这个对象的charValue()方法返回其对应的char数值。

char=Character.valueOf(“123”).charValue()

基本类型转换成字符串

Integer类

Integer 类在对象中包装了一个基本类型 int 的值 该类提供了多个方法，能在 int 类型和 String 类型之间互相转换，还提供了处理 int 类型时非常有用的其他一些常量和方法,需要注意的是字符串必须是由数字字符组成。

public Integer(int value) 
public Integer(String s)

int类型和String类型的相互转换

常用的基本进制转换

运算符

public static void main(String[] args) {
        int number = 10;
        printInfo(number);
        number = number << 1;
        //左移一位
        printInfo(number);
        number = number >> 2;
        //右移一位
        printInfo(number);
        number = number >>> 1;
        printInfo(number);
        number = -10;
        printInfo(number);
        number = number << 1;
        //左移一位
        printInfo(number);
        number = number >> 2;
        //右移一位
        printInfo(number);
        number = number >>> 1;
        printInfo(number);
    }
    private static void printInfo(int num) {
        System.out.printf("%d-----%s\n",num,Integer.toBinaryString(num));
    }

基本类型

• byte/8
• char/16
• short/16
• int/32
• float/32
• long/64
• double/64
• boolean/~

boolean 只有两个值：true、false，可以使用 1 bit 来存储，但是具体大小没有明确规定。JVM 会在编译时期将 boolean 类型的数据转换为 int，使用 1 来表示 true，0 表示 false。JVM 支持 boolean 数组，但是是通过读写 byte 数组来实现的。

• Primitive Data Types

• The Java® Virtual Machine Specification

  包装类型

  基本类型都有对应的包装类型，基本类型与其对应的包装类型之间的赋值使用自动装箱与拆箱完成。
  Integer x = 2; // 装箱 调用了 Integer.valueOf(2)
  int y = x; // 拆箱 调用了 X.intValue()

• Autoboxing and Unboxing

  缓存池

  new Integer(123) 与 Integer.valueOf(123) 的区别在于：

• new Integer(123) 每次都会新建一个对象；

• Integer.valueOf(123) 会使用缓存池中的对象，多次调用会取得同一个对象的引用。

Integer x = new Integer(123);
Integer y = new Integer(123);
System.out.println(x == y); // false
Integer z = Integer.valueOf(123);
Integer k = Integer.valueOf(123);
System.out.println(z == k); // true
valueOf() 方法的实现比较简单，就是先判断值是否在缓存池中，如果在的话就直接返回缓存池的内容。
public static Integer valueOf(int i) {
if (i >= IntegerCache.low && i <= IntegerCache.high)
return IntegerCache.cache[i + (-IntegerCache.low)];
return new Integer(i);
}
在 Java 8 中，Integer 缓存池的大小默认为 -128~127。
static final int low = -128;
static final int high;
static final Integer cache[];

static {
// high value may be configured by property
int h = 127;
String integerCacheHighPropValue =
sun.misc.VM.getSavedProperty(“java.lang.Integer.IntegerCache.high”);
if (integerCacheHighPropValue != null) {
try {
int i = parseInt(integerCacheHighPropValue);
i = Math.max(i, 127);
// Maximum array size is Integer.MAX_VALUE
h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
} catch( NumberFormatException nfe) {
// If the property cannot be parsed into an int, ignore it.
}
}
high = h;

cache = new Integer[(high - low) + 1];<br />    int j = low;<br />    for(int k = 0; k < cache.length; k++)<br />        cache[k] = new Integer(j++);
// range [-128, 127] must be interned (JLS7 5.1.7)<br />    assert IntegerCache.high >= 127;<br />}<br />编译器会在自动装箱过程调用 valueOf() 方法，因此多个值相同且值在缓存池范围内的 Integer 实例使用自动装箱来创建，那么就会引用相同的对象。<br />Integer m = 123;<br />Integer n = 123;<br />System.out.println(m == n); // true<br />基本类型对应的缓冲池如下：

• boolean values true and false
• all byte values
• short values between -128 and 127
• int values between -128 and 127
• char in the range \u0000 to \u007F

在使用这些基本类型对应的包装类型时，如果该数值范围在缓冲池范围内，就可以直接使用缓冲池中的对象。
在 jdk 1.8 所有的数值类缓冲池中，Integer 的缓冲池 IntegerCache 很特殊，这个缓冲池的下界是 - 128，上界默认是 127，但是这个上界是可调的，在启动 jvm 的时候，通过 -XX:AutoBoxCacheMax= 来指定这个缓冲池的大小，该选项在 JVM 初始化的时候会设定一个名为 java.lang.IntegerCache.high 系统属性，然后 IntegerCache 初始化的时候就会读取该系统属性来决定上界。
StackOverflow : Differences between new Integer(123), Integer.valueOf(123) and just 123