java之基础数据类型学习————（一）

JAVA数据类型：　　　　　　　　　　　　　　　　　　　

总结来说，java的基本数据类型分为 四类八种

• 第一类：整数类型：byte、short、int、long

• 第二类：浮点型：float、double

• 第三类：字符类型：char

• 第四类：布尔类型：boolean

而基本数据类型与引用数据类型的区别是：

基本数据类型可以直接在栈中分配内存，而引用数据类型是在堆中分配内存的，栈中存储的只是一个数据的引用（指针）。

八种基本数据类型的字节大小：

boolean（布尔类型）	1/8字节
byte      （字节类型）	1字节
short     （短整型）	2字节
int          （整型）	4字节
long       （长整型）	8字节
float      （单精度浮点类型）	4字节
double  （双精度浮点类型）	8字节
char      （字符类型）	2字节

注意：java中所有的数据类型都有固定的存储范围和所占内存空间大小，而不受操作系统的影响，从而保证java程序的可移植性。

整形默认是 int型，浮点型默认是 double型。

表示 long型 要在数据后面加上 l or L，表示 float型要在数据后面加上 f or F。

基本数据类型的转换：

• 自动转换

　　byte -> short/char -> int -> long

　　float -> double

　　int -> float

　　long -> double

• 强制转换

　　由大转小，使用强制转换，但是注意精度的丢失！

　　另外，对于byte、short与char之间的转换，是先转化成int类型，然后再转换成目标类型。比如，byte转short：byte -> int ->short

---

Number类

jdk对Number类的介绍:

The abstract class Number is the superclass of classes BigDecimal, BigInteger, Byte, Double, Float, Integer, Long, and Short. 

Subclasses of Number must provide methods to convert the represented numeric value to byte, double, float, int, long, and short.

BigDecimal，BigInteger，Byte，Double，Float，Integer，Long与Short类都继承了Number类，这几个类都实现了Number的抽象方法。

看一下number的抽象方法：

 public abstract int intValue();
 public abstract long longValue();
 public abstract float floatValue();
 public abstract double doubleValue();
 public byte byteValue() {
         return (byte)intValue();
 }
 public short shortValue() {
         return (short)intValue();
 }

这几个抽象类主要实现了各个类型之间的转换，可以看到，在提供某类型转换成 byte 类型或者 short 类型时，经历了两个阶段，首先调用 intValue() 方法先转换成 int型，然后对得到的int型数据做一个强制转换，这就是转换成 byte、short的过程。

---

Byte类

 package java.lang;

 public final class Test extends Number implements Comparable<Byte> {

     /**
      * Byte类型能表示的最小的值，即:0x1000 0000
      * Byte类型能表示的最大值，即0x0111 1111
      *（最高位为符号位，java使用补码表示二进制数，正数补码为其本身，负数为反码+1）
      */
     public static final byte   MIN_VALUE = -128;
     public static final byte   MAX_VALUE = 127;

     /**
      * ①
      * 这里表示int类的实例
      */
     public static final Class<Byte>     TYPE = (Class<Byte>) Class.getPrimitiveClass("byte");

     /**
      * Byte的静态方法，作用是将byte类型转换为String类型
      * 实现过程是调用Integer类的头String方法，参数10表示是十进制
      */
     public static String toString(byte b) {
         return Integer.toString((int)b, 10);
     }

     /**
      * Byte的静态内部类，作用是创建一个Byte缓存数组
      * 将值为-128到127的256个Byte实例放到该缓存数组中
      */
     private static class ByteCache {
         private ByteCache(){}

         static final Byte cache[] = new Byte[-(-128) + 127 + 1];

         static {
             for(int i = 0; i < cache.length; i++)
                 cache[i] = new Byte((byte)(i - 128));
         }
     }

     /**
      * ②
      * Byte的静态方法，作用是将基本数据类型byte型转为Byte类的一个对象
      * 过程是去缓存类的缓存数组中去取对应的值
      */
     public static Byte valueOf(byte b) {
         final int offset = 128;
         return ByteCache.cache[(int)b + offset];
     }

     /**
      * Byte的静态方法，作用是将String按照给定的基数转化为相应的byte数据
      * 过程是调用Integer的parseInt方法实现将String转换为int型，
      * 然后进行一次强制转换。
      */
     public static byte parseByte(String s, int radix)
         throws NumberFormatException {
         int i = Integer.parseInt(s, radix);
         if (i < MIN_VALUE || i > MAX_VALUE)
             throw new NumberFormatException(
                 "Value out of range. Value:\"" + s + "\" Radix:" + radix);
         return (byte)i;
     }

     public static byte parseByte(String s) throws NumberFormatException {
         return parseByte(s, 10);
     }

     public static Byte valueOf(String s, int radix)
         throws NumberFormatException {
         return valueOf(parseByte(s, radix));
     }

     public static Byte valueOf(String s) throws NumberFormatException {
         return valueOf(s, 10);
     }

     /**
      * Byte的静态方法，作用是对String数据进行解码
      * 比如：-1 0x77 等不同进制的数据
      */
     public static Byte decode(String nm) throws NumberFormatException {
         int i = Integer.decode(nm);
         if (i < MIN_VALUE || i > MAX_VALUE)
             throw new NumberFormatException(
                     "Value " + i + " out of range from input " + nm);
         return valueOf((byte)i);
     }

     /**
      * 这个就是Byte类的值，这个属性由final修饰，表示value属性是不可变的
      */
     private final byte value;

     public Byte(byte value) {
         this.value = value;
     }

     public Byte(String s) throws NumberFormatException {
         this.value = parseByte(s, 10);
     }

     public byte byteValue() {
         return value;
     }

     public short shortValue() {
         return (short)value;
     }

     public int intValue() {
         return (int)value;
     }

     public long longValue() {
         return (long)value;
     }

     public float floatValue() {
         return (float)value;
     }

     public double doubleValue() {
         return (double)value;
     }

     public String toString() {
         return Integer.toString((int)value);
     }

     public int hashCode() {
         return (int)value;
     }

     public boolean equals(Object obj) {
         if (obj instanceof Byte) {
             return value == ((Byte)obj).byteValue();
         }
         return false;
     }

     /**
      * 实现了Comparable接口，这个另外开一个篇幅来说
      */
     public int compareTo(Byte anotherByte) {
         return compare(this.value, anotherByte.value);
     }

     public static int compare(byte x, byte y) {
         return x - y;
     }

     //表示一个byte由8位表示，也就是一个字节
     public static final int SIZE = 8;
 }

标注

①：看一下Byte.TYPE属性的toString

 System.out.println(Byte.TYPE);//byte
 System.out.println(byte.class);//byte
 System.out.println(Byte.class);//class java.lang.Byte

　　可以看出，Byte.TYPE属性表示基本类型 byte 的Class实例，这里注意是基本类型。

②：
　　在静态内部私有类中定义了一个缓存数组，这个缓存数组在什么时候初始化？是在ByteCache类加载的时候。
　　ByteCahe类什么时候加载呢？肯定是在调用ValueOf()方法中调用的时候。
　　如果Byte加载的时候就对这个数组进行初始化，那么有可能会造成资源的浪费，因为有可能程序根本用不到
　　除了提高效率外，这种方式还可以实现数据的共享。

---

short类

short类与byte类的很多方法是相同的，这里只拿出来一些不同的方法来看一下：

 package java.lang;

 public final class Short extends Number implements Comparable<Short> {

     /**
      * short型数据最大值32767 即：0111 1111 1111 1111
      * 最小值-32768 即1000 0000 0000 0000
      * short型占两个字节，即16bit
      */
     public static final short   MIN_VALUE = -32768;
     public static final short   MAX_VALUE = 32767;
     public static final int SIZE = 16;

     /**
      * ①
      * 与byte类一样，short也有一个自己的缓存私有内部类
      */
     private static class ShortCache {
         private ShortCache(){}

         static final Short cache[] = new Short[-(-128) + 127 + 1];

         static {
             for(int i = 0; i < cache.length; i++)
                 cache[i] = new Short((short)(i - 128));
         }
     }

     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);
     }

     /**
      * short的equals方法比较的是类型必须是Short类型，值必须相等
      */
     public boolean equals(Object obj) {
         if (obj instanceof Short) {
             return value == ((Short)obj).shortValue();
         }
         return false;
     }

     /**
      * 将二进制码顺序颠倒，我的理解是将大端序转换为小端序
      */
     public static short reverseBytes(short i) {
         return (short) (((i & 0xFF00) >> 8) | (i << 8));
     }
 }

①：byte类的大小允许其有256个值，所以ByteCache的缓存数组的长度是256，short类比byte的值多，为什么还是256个缓存值呢？

因为short类型的值有65534个，如果要建立这样一个缓存数组，首先非常没有效率（在初始化的以后），次之，非常的浪费空间。

而位于-128到127之间的这些值是使用频率非常高的，所以为了不过度浪费空间，并且通过共享数据而加快效率，包括Byte、Short、Integer、Long都是使用这样的方式，并且数组的值都是-128到127，而Character类也使用了这种共享方式，不同的是它的值是0~127

---

总结：

1、类型转换：注意byte、short（还包括char）之间的转换，都是先转换成int型，再转换成目标类型

2、数据共享：通过自己的私有内部类来缓存使用频率高的数据，实现数据共享（对于在范围内的数据，所有值相通的Byte类，其引用指向的类是同一个）

3、TYPE属性：表示基本类型（比如byte）的Class实例，这里注意是基本类型

在转换类型时，首先是转换成int型，再转换成byte、shortr型，所以，它们的很多方法是调用的Integer类的方法，下一次着重看一下这个类，以及分析一下Comparable接口。