深入Java基础(一)——基本数据类型及其包装类

文章结构:

1. 基本数据类型的系统描述;

2.数据类型的包装类理解(含源码解析);

3.数据类型转换、装包拆包等一些小坑。

 

一、基本数据类型的系统描述:

1. 总述

Java基本数据类型分为两大类:boolean类型和数值类型。数值类型可分为整数类型和浮点类型,而其中字符类型可单独对待。所以Java只包含8种基本数据类型。

注意!字符串不是基本数据类型,字符串是一个类,是一个引用类型。

boolean 数值只有true和false,不能用0代替。其他数值类型不能转换成boolean。包装类–Boolean

byte 内存8位,无符号位时最大存储255,表数范围:-128~127。包装类–Byte

short 内存16位,无符号位时最大存储65536,表数范围:-32768~32767。包装类–Short

int 内存32位,无符号位时最大存储2的32次方减1,表数范围:负的2的31次方到正的2的31次方减1。包装类–Integer。

long 内存64位,无符号位时最大存储2的64次方减1,表数范围:负的2的63次方到正的2的63次方减1。包装类–Long。

float 内存32位,数据范围在3.4e-45~1.4e38,直接赋值时必须在数字后加上f或F。包装类–Float。

double 内存64位,数据范围在4.9e-324~1.8e308,赋值时可以加d或D也可以不加。包装类–Double。

char:16位,存储Unicode字符集,用单引号赋值。可以参与加减乘除运算的,也可以比较大小的!!包装类–Character。

二、数据类型的包装类理解(含部分源码解析)

Java会为每一个基础数据类型都提供一个相应包装类的目的,在于将Java的所有东西都抽象成对象,可以更方便的控制和使用。这就是面向对象!

对于包装类:

主要作用是:

1.作为和基本数据类型对应的类类型存在,方便涉及到对象的操作。

2.包含每种基本数据类型的相关属性如最大值、最小值等,以及相关的操作方法。

1.深入boolean基本类型、Boolean类以及细节点:

 1 //看接口是可序列化,是一个final修饰的类
 2 public final class Boolean implements java.io.Serializable,
 3                                       Comparable<Boolean>{
 4      //看这两个对应的原始对象。享元模式的使用,达到多个对象都使用一份内存。至于什么是享元,以及它与单例的区别,这里就不多说了。
 5      public static final Boolean TRUE = new Boolean(true);
 6      public static final Boolean FALSE = new Boolean(false);
 7      private final boolean value;
 8      //两个构造器,可见它是可以为null的啦,使用Boolean这个类的话
 9      public Boolean(boolean value) {
10         this.value = value;
11     }
12      public Boolean(String s) {
13         this(parseBoolean(s));
14     }
15      public static boolean parseBoolean(String s) {
16         return ((s != null) && s.equalsIgnoreCase("true"));
17     }
18     //jdk文档建议用valueOf代替new方式来创建Boolean类对象。new创建的Boolean对象是不断的新创建一个实例对象,而valueOf则是返回Boolean类里的静态成员变量,也就是使用享元模式的那个对象。
19     public static Boolean valueOf(String s) {
20         return parseBoolean(s) ? TRUE : FALSE;
21     }
22 
23     //下面是令人困惑的设计了,我也是看了下stackoverflow里面讨论才有点懂。
24     //原汁原味链接:http://stackoverflow.com/questions/3912303/boolean-hashcode
25     //1. 使用质素是因为假如要把Boolean指插入到hashtable中,如果不是质素的话可能会比较容易造成哈希冲突。符合对象计算hashcode的时候通常会把各个属性的hashcode相加然后再做hash,如果是比较小的质素,容易造成hash分布不均匀。
26     //2. Maps是可以包裹Boolean的,而如果map除了包含Boolean对象,还包含其他对象,那么如果不适当处理,就很容易有冲突了
27      public static int hashCode(boolean value) {
28         return value ? 1231 : 1237;
29     }

总括下:

1.boolean是基础数据类型,而Boolean是一个类。

2.boolean一般存在于桟空间中,而Boolean对象存在堆空间中。

3.boolean有true和false俩种值,Boolean除了true和false外,还有null。

 

 1 public class Main {
 2     public static void main (String []args)
 3     {
 4         Boolean bool1 = Boolean.valueOf(true);       //这里均使用valueof创建对象,new创建的Boolean对象是不断的新创建一个实例对象,而valueOf则是返回Boolean类里的静态成员变量
 5         Boolean bool2 = Boolean.valueOf("True");    //这里上一句代码验证使用String变量作为参数时,不区分大小写的。
 6         Boolean bool3 = Boolean.valueOf("ASD");
 7         boolean x1 = bool1.booleanValue();
 8         boolean x2 = bool2.booleanValue();
 9         System.out.println("bool1:" + x1 + ",bool2:" + x2 + ",bool3:" + bool3);
10         boolean x3 = bool1.equals(bool2);       //这个就是验证享元模式,使用的是同一个对象
11         boolean x4 = bool1.equals(bool3);       //肯定不是同一对象啦。
12         System.out.println("bool1.equals(bool2):" + x3 + ",bool1.equals(bool3):" + x4);
13         String str1 = Boolean.toString(bool1);      //可见Boolean对象是可以转换成字符的
14         String str2 = Boolean.toString(false);      
15         String str3 = bool3.toString();
16         System.out.println("bool1:" + str1 + ",str2:" + str2 + ",bool3:" + str3);
17         boolean x5 = Boolean.parseBoolean("ASD");         //源码是直接判断然后与true对比,因此打印为false
18         System.out.println(x5);
19     }
20 }

 

2.深入byte基本类型

 1 //也可以看到是一个final修饰的类,只能用,不能被继承咯
 2 public final class Byte extends Number implements Comparable<Byte>{
 3     public static final int SIZE = 8;   //只能是一个字节咯
 4     //两个构造器
 5     public Byte(byte value) {
 6         this.value = value;   //传入的要为Byte类型的值
 7     }
 8     public Byte(String s) throws NumberFormatException {
 9         this.value = parseByte(s, 10);  //传入的要求是可转换成Byte的字符串
10     }
11     //这个Byte做了缓存
12     private static class ByteCache {
13         private ByteCache(){}
14 
15         static final Byte cache[] = new Byte[-(-128) + 127 + 1];//声明缓存数组的长度为256
16 
17         static {
18             for(int i = 0; i < cache.length; i++)
19                 cache[i] = new Byte((byte)(i - 128));//然后将-128~127进行缓存
20         }
21     }
22     //两个解析字符串方法
23     public static byte parseByte(String s, int radix)
24         throws NumberFormatException {
25         //radix是解析字符串时候的基数,在此方法下有个解析基数的含义。
26         int i = Integer.parseInt(s, radix);//解析字符串并返回,所以s必须是-128~127的字符,至于为什么用这个方法int的包装类方法来解析,一会我们会谈到。
27         if (i < MIN_VALUE || i > MAX_VALUE)
28             throw new NumberFormatException(
29                 "Value out of range. Value:\"" + s + "\" Radix:" + radix);
30         return (byte)i;
31     }
32     //也是解码转码方法,将String转为Byte
33     public static Byte decode(String nm) throws NumberFormatException {
34         int i = Integer.decode(nm);//一会重点讲解Integer的系列方法
35         if (i < MIN_VALUE || i > MAX_VALUE)
36             throw new NumberFormatException(
37                     "Value " + i + " out of range from input " + nm);
38         return valueOf((byte)i);
39     }
40 }

解释radix的作用

b[0] = Byte.parseByte(“11”, 2) = 3

表示 字符串11以2为基数表示为10进制的byte值是 3 ,这里的11表示的是一个2进制数

b[0] = Byte.parseByte(“11”, 3) = 4

表示 字符串11以3为基数表示为10进制的byte值是 4 ,这里的11表示的是一个3进制数

3、int和Integer

 

  1 public final class Integer extends Number implements Comparable<Integer> {
  2 
  3      public static final Class<Integer>  TYPE = (Class<Integer>) Class.getPrimitiveClass("int");//原始类型int的Class实例。
  4      //所有可能的将数字表示为字符串的字符集合做缓存。
  5      final static char[] digits = {
  6         '0' , '1' , '2' , '3' , '4' , '5' ,
  7         '6' , '7' , '8' , '9' , 'a' , 'b' ,
  8         'c' , 'd' , 'e' , 'f' , 'g' , 'h' ,
  9         'i' , 'j' , 'k' , 'l' , 'm' , 'n' ,
 10         'o' , 'p' , 'q' , 'r' , 's' , 't' ,
 11         'u' , 'v' , 'w' , 'x' , 'y' , 'z'
 12     };
 13     //两个构造器
 14      public Integer(int value) {
 15         this.value = value;
 16     }
 17     public Integer(String s) throws NumberFormatException {
 18         this.value = parseInt(s, 10);//涉及了String转换成int,一会仔细讨论这个。
 19     }
 20     //像上面Byte类型中解释的那样的方法,返回第二个参数所指定的进制数的第一个参数的字符串表示形式。处理各种进制的Integer.
 21     public static String toString(int i, int radix) {
 22         if (radix < Character.MIN_RADIX || radix > Character.MAX_RADIX)             
 23         radix = 10;//默认为10进制 
 24         /* Use the faster version */         
 25         if (radix == 10) {             
 26             return toString(i);         
 27         }
 28         char buf[] = new char[33];         
 29         boolean negative = (i < 0);         
 30         int charPos = 32;
 31         //统一转为负数去处理
 32         if (!negative) {             
 33             i = -i;         
 34         }
 35         while (i <= -radix) {             
 36             buf[charPos--] = digits[-(i % radix)];             
 37             i = i / radix;         
 38         }         
 39         buf[charPos] = digits[-i];
 40         if (negative) {             
 41             buf[--charPos] = '-';         
 42         }
 43         return new String(buf, charPos, (33 - charPos));     
 44     }
 45     //一会有事例代码演示这个,这个其实就是把int型包装成Integer然后再转化成String字符串
 46      public static String toString(int i) {
 47         if (i == Integer.MIN_VALUE)
 48             return "-2147483648";
 49         int size = (i < 0) ? stringSize(-i) + 1 : stringSize(i);
 50         char[] buf = new char[size];
 51         getChars(i, size, buf);
 52         return new String(buf, true);
 53     }
 54     //与toString组合形成一方法去转换成字符串咯
 55     static void getChars(int i, int index, char[] buf) {
 56         int q, r;
 57         int charPos = index;
 58         char sign = 0;
 59 
 60         if (i < 0) { //如果i为负数,则设置i的符号字符为'-'。
 61             sign = '-';  //确定正负数
 62             i = -i;  //将负数转化为正数处理,提高效率 
 63         }
 64 
 65         // Generate two digits per iteration
 66         while (i >= 65536) { //如果i大于65536,则每一次都获取十位和个位上的数字对应的字符。将值判断大小后取每个数字,较大的数字一次取两位(大数字运算消耗大)
 67             q = i / 100;
 68         // really: r = i - (q * 100);
 69             r = i - ((q << 6) + (q << 5) + (q << 2)); //利用位运算,每次获得i的最后两位数,不断循环提取处理
 70             i = q;//重新赋值,准备下一次循环 
 71             buf [--charPos] = DigitOnes[r]; //存储r中在个位数集合中对应的字符
 72             buf [--charPos] = DigitTens[r]; //存储r中在十位数集合中对应的字符
 73         }
 74 
 75         // Fall thru to fast mode for smaller numbers
 76         // assert(i <= 65536, i);
 77         for (;;) { //i<65536的情况,小数字运算消耗较小,故一次只取一位
 78             q = (i * 52429) >>> (16+3);//52429/(2*19)约等于1,此处这样设计是为了提高精度
 79             r = i - ((q << 3) + (q << 1));  // r = i-(q*10) ... //每次获得i的最后两位数
 80             buf [--charPos] = digits [r];//取最后一位的数字  
 81             i = q;//重新赋值,准备下一次循环  
 82             if (i == 0) break;
 83         }
 84         if (sign != 0) {
 85             buf [--charPos] = sign; //设置符号
 86         }
 87     }
 88     //下面两个是用来确定字符串长度的。
 89     //定义sizeTable表示int中每个位数中最大的数,用于简便确定int数的长度。
 90     final static int [] sizeTable = { 9, 99, 999, 9999, 99999, 999999, 9999999,
 91                                       99999999, 999999999, Integer.MAX_VALUE };
 92     //使用上面的sizeTable定义来确定int数的字符串表示长度。           
 93     static int stringSize(int x) {
 94         for (int i=0; ; i++)
 95             if (x <= sizeTable[i])
 96                 return i+1;
 97     }
 98     //炒鸡重要的方法啦!!parseInt(String s,int radix)使用第二个参数指定的基数,将字符串参数解析为有符号的整数。 parseInt(String s)只能将数字字符串转化十进制数
 99      public static int parseInt(String s, int radix)
100                 throws NumberFormatException
101     {
102         /*
103          * WARNING: This method may be invoked early during VM initialization
104          * before IntegerCache is initialized. Care must be taken to not use
105          * the valueOf method.
106          */
107 
108         if (s == null) {//参数检验,调用方法前检查参数的正确性。
109             throw new NumberFormatException("null");
110         }
111 
112         if (radix < Character.MIN_RADIX) {
113             throw new NumberFormatException("radix " + radix +
114                                             " less than Character.MIN_RADIX");
115         }
116 
117         if (radix > Character.MAX_RADIX) {
118             throw new NumberFormatException("radix " + radix +
119                                             " greater than Character.MAX_RADIX");
120         }
121 
122         int result = 0;
123         boolean negative = false;
124         int i = 0, len = s.length();//i表示当前遍历的s的位数
125         int limit = -Integer.MAX_VALUE;//设置最小值为负的Integer的最大值
126         int multmin;
127         int digit;
128 
129         if (len > 0) {//如果字符串长度大于0,则进行转换
130             char firstChar = s.charAt(0);//获取第一位字符
131             if (firstChar < '0') { // Possible leading "+" or "-"
132                 if (firstChar == '-') {//判断是否为负数 
133                     negative = true; 
134                     limit = Integer.MIN_VALUE;//将限制转换为Integer的最小值,不能小于Integer的最小值  
135                 } else if (firstChar != '+')
136                     throw NumberFormatException.forInputString(s);//第一个char不为+也不为-,则抛出异常  
137 
138                 if (len == 1) // Cannot have lone "+" or "-"
139                     throw NumberFormatException.forInputString(s);//若只有一个符号,则抛出异常
140                 i++;
141             }
142             multmin = limit / radix;//设定不同进制下的极限值  
143             while (i < len) {//进行进制的转换
144                 // Accumulating negatively avoids surprises near MAX_VALUE
145                 digit = Character.digit(s.charAt(i++),radix);//将数字字符串转换成要求的进制数,使用工具类,每次遍历对一个字符进行操作转换  
146                 if (digit < 0) {
147                     throw NumberFormatException.forInputString(s);
148                 }
149                 if (result < multmin) {
150                     throw NumberFormatException.forInputString(s);
151                 }
152                 result *= radix;
153                 if (result < limit + digit) {
154                     throw NumberFormatException.forInputString(s);
155                 }
156                 result -= digit;
157             }
158         } else {
159             throw NumberFormatException.forInputString(s);
160         }
161         return negative ? result : -result;//根据符号返回正数还是负数
162     }
163     //看吧,我们经常用的parseInt只是个帮我们制定好10进制规则的静态方法
164     public static int parseInt(String s) throws NumberFormatException {
165         return parseInt(s,10);
166     }
167     //强大的内部类缓存机制吗,内部字符缓存类
168     private static class IntegerCache {
169         //缓存的下界,-128,不可变  
170         static final int low = -128;
171          //缓存上界,暂为null
172         static final int high;
173         static final Integer cache[];//利用数组来缓存
174         //原理:初始化数组将一定范围的整数放到cache数组中,然后在调valueOf方法的时候首先判断范围然后从缓存数组中去抓取数据
175 
176         static {
177             // high value may be configured by property
178             // 缓存上届,可以通过JVM属性来配置
179             int h = 127;
180             String integerCacheHighPropValue =
181                 sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
182             //获取,得到上界
183             if (integerCacheHighPropValue != null) {
184                 try {
185                     int i = parseInt(integerCacheHighPropValue);
186                     i = Math.max(i, 127);
187                     // Maximum array size is Integer.MAX_VALUE
188                     h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
189                 } catch( NumberFormatException nfe) {
190                     // If the property cannot be parsed into an int, ignore it.
191                 }
192             }
193             high = h;
194             //获取Integer中所有能保存的数据,初始化缓存数组
195             cache = new Integer[(high - low) + 1];
196             int j = low;
197             //缓存所有Integer的数据
198             for(int k = 0; k < cache.length; k++)
199                 cache[k] = new Integer(j++);
200 
201             // range [-128, 127] must be interned (JLS7 5.1.7)
202             assert IntegerCache.high >= 127;
203         }
204 
205         private IntegerCache() {}
206     }
207     //还有这个我们经常用的,官方也推荐使用这个方法去创建对象的
208        public static Integer valueOf(int i) {
209        //如果i在Integer缓存中,则直接取出
210         if (i >= IntegerCache.low && i <= IntegerCache.high)
211             return IntegerCache.cache[i + (-IntegerCache.low)];
212        //否则,直接创建一个实例
213         return new Integer(i);
214     }
215 }

 

使用Integer事例代码:

 1 public static void main(String[] args) {
 2         Integer a1 = 1;
 3         Integer a2 = 1;
 4 
 5         Integer b1 = 200;
 6         Integer b2 = 200;
 7 
 8         Integer c1 = Integer.valueOf(1);
 9 //        Integer c2 = new Integer(1);      官方不推荐这种建对象的方法喔
10         Integer c2 = Integer.valueOf(1);
11 
12         Integer d1 = Integer.valueOf(200);
13         Integer d2 = Integer.valueOf(200);
14 
15 
16         System.out.println("a1==a2?" + (a1 == a2));
17         System.out.println("b1==b2?" + (b1 == b2));
18         System.out.println("c1==c2?" + (c1 == c2));
19         System.out.println("d1==d2?" + (d1 == d2));
20     }

运行结果:

a1==a2? true 
b1==b2? false 
c1==c2? false 
d1==d2? false

4.Character的基本了解

Character 类在对象中包装一个基本类型 char 的值。Character 类型的对象包含类型为 char 的单个字段。该类提供了几种方法,以确定字符的类别(小写字母,数字,等等),并将字符从大写转换成小写,从小写转换成大写。Character 类的方法和数据是通过 UnicodeData 文件中的信息定义的。至于Unicode 大家就百度了解下就好。

5.Long类:

  1 public final class Long extends Number implements Comparable<Long> {
  2     @Native public static final long MIN_VALUE = 0x8000000000000000L;//最小值为2的63次方-1 
  3     @Native public static final long MAX_VALUE = 0x7fffffffffffffffL;//最大值为-2的63次方 
  4     public static final Class<Long>     TYPE = (Class<Long>) Class.getPrimitiveClass("long");
  5     //toString方法与Integer中的toString实现原理一样的。
  6 
  7     //转换成对应的进制的字符串表示
  8     public static String toUnsignedString(long i, int radix) {
  9         if (i >= 0)
 10             return toString(i, radix);
 11         else {
 12             switch (radix) {
 13             case 2:
 14                 return toBinaryString(i);//将Long转为2进制  
 15 
 16             case 4:
 17                 return toUnsignedString0(i, 2);//将Long转为4进制  
 18 
 19             case 8:
 20                 return toOctalString(i);//将Long转为8进制  
 21 
 22             case 10:
 23                 /*
 24                  * We can get the effect of an unsigned division by 10
 25                  * on a long value by first shifting right, yielding a
 26                  * positive value, and then dividing by 5.  This
 27                  * allows the last digit and preceding digits to be
 28                  * isolated more quickly than by an initial conversion
 29                  * to BigInteger.
 30                  */
 31                 long quot = (i >>> 1) / 5;、//十进制嘛
 32                 long rem = i - quot * 10;
 33                 return toString(quot) + rem;
 34 
 35             case 16:
 36                 return toHexString(i);
 37 
 38             case 32:
 39                 return toUnsignedString0(i, 5);
 40 
 41             default:
 42                 return toUnsignedBigInteger(i).toString(radix);
 43             }
 44         }
 45     }
 46     //返回一个BigInteger等于参数的无符号值
 47      private static BigInteger toUnsignedBigInteger(long i) {
 48         if (i >= 0L)
 49             return BigInteger.valueOf(i);
 50         else {
 51             int upper = (int) (i >>> 32);
 52             int lower = (int) i;
 53 
 54             // return (upper << 32) + lower
 55             return (BigInteger.valueOf(Integer.toUnsignedLong(upper))).shiftLeft(32).
 56                 add(BigInteger.valueOf(Integer.toUnsignedLong(lower)));
 57         }
 58     }
 59     public static String toHexString(long i) {//将Long转为16进制  
 60         return toUnsignedString(i, 4);  
 61     }  
 62     public static String toOctalString(long i) {//将Long转为8进制  
 63         return toUnsignedString(i, 3);  
 64     }  
 65     public static String toBinaryString(long i) {//将Long转为2进制  
 66         return toUnsignedString(i, 1);  
 67     static int stringSize(long x) {//展示Long的字符串长度  
 68         long p = 10;  
 69         for (int i=1; i<19; i++) {//每次乘十进行比较  
 70             if (x < p)  
 71                 return i;  
 72             p = 10*p;  
 73         }  
 74         return 19;  
 75     }  
 76     //这个也跟Integer的实现差不多。将字符串参数解析为有符号的整数。
 77     public static long parseLong(String s, int radix)
 78               throws NumberFormatException
 79     {
 80         if (s == null) {//参数检验
 81             throw new NumberFormatException("null");
 82         }
 83 
 84         if (radix < Character.MIN_RADIX) {
 85             throw new NumberFormatException("radix " + radix +
 86                                             " less than Character.MIN_RADIX");
 87         }
 88         if (radix > Character.MAX_RADIX) {
 89             throw new NumberFormatException("radix " + radix +
 90                                             " greater than Character.MAX_RADIX");
 91         }
 92 
 93         long result = 0;
 94         boolean negative = false;//这,,跟Integer基本一样的呀
 95         int i = 0, len = s.length();
 96         long limit = -Long.MAX_VALUE;
 97         long multmin;
 98         int digit;
 99 
100         if (len > 0) {
101             char firstChar = s.charAt(0);
102             if (firstChar < '0') { // Possible leading "+" or "-"
103                 if (firstChar == '-') {
104                     negative = true;
105                     limit = Long.MIN_VALUE;
106                 } else if (firstChar != '+')
107                     throw NumberFormatException.forInputString(s);
108 
109                 if (len == 1) // Cannot have lone "+" or "-"
110                     throw NumberFormatException.forInputString(s);
111                 i++;
112             }
113             multmin = limit / radix;
114             while (i < len) {
115                 // Accumulating negatively avoids surprises near MAX_VALUE
116                 digit = Character.digit(s.charAt(i++),radix);
117                 if (digit < 0) {
118                     throw NumberFormatException.forInputString(s);
119                 }
120                 if (result < multmin) {
121                     throw NumberFormatException.forInputString(s);//转化为了负数进行计算,所以要用<号  
122                 }
123                 result *= radix;
124                 if (result < limit + digit) {
125                     throw NumberFormatException.forInputString(s);
126                 }
127                 result -= digit;
128             }
129         } else {
130             throw NumberFormatException.forInputString(s);
131         }
132         return negative ? result : -result;
133     }
134     public static long parseLong(String s) throws NumberFormatException {//默认转成10进制  
135         return parseLong(s, 10);  
136     }  
137     //官方推荐的创建Long对象的方法啦
138     public static Long valueOf(String s, int radix) throws NumberFormatException {  
139         return Long.valueOf(parseLong(s, radix));  
140     }  
141     public static Long valueOf(String s) throws NumberFormatException  
142     {  
143         return Long.valueOf(parseLong(s, 10));  
144     }
145     //Long的默认缓存,-128~127,缓存模块与Integer相同  
146      private static class LongCache {
147         private LongCache(){}
148 
149         static final Long cache[] = new Long[-(-128) + 127 + 1];
150 
151         static {
152             for(int i = 0; i < cache.length; i++)
153                 cache[i] = new Long(i - 128);
154         }
155     }
156     public static Long valueOf(long l) {
157         final int offset = 128;
158         //在缓存范围内则直接使用咯
159         if (l >= -128 && l <= 127) { // will cache
160             return LongCache.cache[(int)l + offset];
161         }
162         return new Long(l);
163     }
164     public int hashCode() {//重写hashcode()方法,无符号右移32位后乘value本身  
165         return (int)(value ^ (value >>> 32));  
166     }  
167     public boolean equals(Object obj) {  
168         if (obj instanceof Long) {  
169             return value == ((Long)obj).longValue();//比较的是value的地址值,所以在缓存范围内的相等,缓存范围外的不等(两个对象指向同一个Long除外)  
170         }  
171         return false;  
172     }    
173 }

6.列出一下包装类的共性

(1)带有基本值参数并创建包装类对象的构造函数.如可以利用Integer包装类创建对象,Integer obj=new Integer(145)

      Integer obj=new Integer(145);

(2)带有字符串参数并创建包装类对象的构造函数.如new Integer(“-45.36”);

(3)可生成对象基本值的typeValue方法,如obj.intValue();

      int num=obj.intValue();

(4)将字符串转换为基本值的 parseType方法,如Integer.parseInt(args[0]);

(5)因为有装进Map的几率,所以java设计了包装类里的哈希值,生成哈稀表代码的hashCode方法,如obj.hasCode();

(6)对同一个类的两个对象进行比较的equals()方法,如obj1.eauqls(obj2);

(7)生成字符串表示法的toString()方法,如obj.toString().

(8)自动装包/拆包大大方便了基本类型数据和它们包装类地使用。

自动装包:基本类型自动转为包装类。例如(int >> Integer)

自动拆包:包装类自动转为基本类型。例如(Integer >> int)

      

三、数据类型转换、装包拆包

(1).类型转换:

基础:1.自动类型转换-系统支持把某种基本类型的值直接赋给另一种基本类型的变量。

规则:如下图,从左到右自动转换。

2.强制类型转换-视图把表数范围大的类型转换为表数范围小的类型时,容器引起信息丢失。

另:字符串不能直接转换为基本类型,但可通过基本类型对应的包装类实现转换成基本类型。如以下代码:

1 String a = "45";
2 int value=Integer.parseInt(a);

3.自动提升规则:当一个算术表达式中包含多个基本类型的值时,所有的byte类、short和char类型会被提示到int类型

(2)自动装包与拆包:自动装包/拆包大大方便了基本类型数据和它们包装类地使用。

自动装包:基本类型自动转为包装类.(int >> Integer)

自动拆包:包装类自动转为基本类型.(Integer >> int)

使用装包后,我们就可以用集合去存放基本类型啦。比如:Integer先自动转换为int进行加法运算,然后int再次转换为Integer。

1 int a = 3;
2 Collection c = new ArrayList();
3 c.add(a);//自动转换成Integer.自动装包
4 Integer b = new Integer(2);
5 c.add(b + 2);

 

 

 

 

 

 

 

 

 

 

posted @ 2018-01-11 19:38  huster-stl  阅读(432)  评论(0编辑  收藏  举报