Java数据类型

海棠之数据类型
                                       

一点点汲取,一步步逝去;

                                       

生长在就里,成熟于无形

1.    类型杂论
1.1.    关于引用
    Java 语言首先便假定了我们只希望进行面向对象的程序设计，也就是说用它正式写程序之前首先必须先将自己的思想转入一个纯净的面向对象的世界,Java 中的一切都是对象即便一个Java 程序它本身也是一个对象。
    任何东西都可看作一个对象, 但要注意尽管将一切都看作对象，但操作的标识符实际是对一个对象的引用（Reference）。只是由于拥有一个引用并不表示必须有一个对象同它连接，所以如果想容纳一个词或句子可创建一个String 引用：
    String s;
    但这里创建的只是引用并不是对象，若此时向s 发送一条消息，就会获得一个运行时错误，这是由于s 实际并未与任何东西连接；因此一种更安全的做法是创建一个引用时记住，无论如何都进行初始化：
    String s = "asdf";
    创建一个引用时我们希望它同一个新对象建立连接，通常用new 关键字达到这一目的。new 的意思是把我变成这种类型的一个对象，所以上面的例子也可以表达成：
    String s = new String("asdf");
1.2.    Java类型
    在java语言中有这样几个概念：类（即我们自行创建的类型），基本类型（系统原有包含的），对象，引用；
    我们在java中用class标识的就是所谓的类，由类生产对象，对象隶属于类；对象由其类规定好的功能和成员；而基本类型，是靠程序来声明及初始化的，它没有方法；基本类型都对应有相应的封装器，封装器里有着相应的方法，从而实现基本类型到类对象的转化；
对于对象而言，通过引用操作对象，引用并非对象本身；对于基本类型来说，引用既是类型数值本身；
1.2.1.    基本类型
    在java中有一系列类型要求我们特殊对待，可将它们想象成基本主要或者主Primitive类型，进行程序设计时会频繁用到它们；之所以要特别对待，是由于用new 创建某些对象时，特别是那些小的简单的变量，效率并不是特别高，因为new 会把对象放到堆里；对于这些类型，Java 提供了和C和C++类似的做法，也就是说不要用new创建这些变量，而是创建一个自动变量，这种变量并非一个引用，为什么不是引用呢？因为其中容纳了具体的值，并放在堆栈，而不是内存堆中，从而获得更高的效率；
    Java 事先决定好了每种主类型的大小，就象在大多数语言中那样；这种大小并不随着你改换硬件平台操作系统而变化，而大小不可更改正是Java程序具有很强移植能力的原因之一；
    Java的数据类型分为三大类，即布尔型、字符型和数值型，而其中数值型又分为整型和浮点型；相对于数据类型，Java的变量类型为布尔型boolean；字符型char；整型byte、short、int、long；浮点型float、double。其中四种整型变量和两种浮点型变量分别对应于不同的精度和范围。

1. 主类型    大小    最小值    最大值    封装器类型
2. boolean    －    －    －    Boolean
3. Char    16-bit    Unicode 0    Unicode 216- 1    Character
4. byte    8-bit    -128    +127    Byte
5. Short    16-bit    -215    +215?1    Short
6. Int    32-bit    -231    +231?1    Integer
7. Long    64-bit    -263    +263?1    Long
8. Float    32-bit    IEEE754    IEEE754    Float
9. double    64-bit    IEEE754    IEEE754    Double
10. Void    －    －    －    Void

注意：
1、    所有数值类型都是有符号正负号的；
2、    boolean 布尔类型的大小没有明确规定，只要能容下true 或false 这两个文字值就OK 了；
    原始数据类型也拥有自己的封装器wrapper类，这意味着假如想让堆内一个非主对象表示那个主类型，就要使用对应的封装器；例如：
    char c = 'x';
    Character C = new Character(c);
也可直接使用：
    Character C = new Character('x');
1.2.2.    Java的包装类
    所谓包装类，就是可以直接将简单类型的变量表示为一个类，在执行变量类型的相互转换时，我们会大量使用这些包装类。
    Java共有六个包装类，分别是Boolean、Character、Integer、Long、Float和Double，从字面上我们就可以看出它们分别对应于 boolean、char、int、long、float和double。而String本身就是类。所以也就不存在什么包装类的概念了。
1.2.3.    基本类型、封装器及其互换
1.2.3.1.    整型、实型、字符型变量中的相互转换
   在Java中整型、实型、字符型被视为同一类数据，这些类型由低级到高级分别为(byte，short，char)??int??long??float??double，低级变量可以直接转换为高级变量，例如，下面的语句可以在Java中直接通过：
byte b;
int i=b;
而将高级变量转换为低级变量时，情况会复杂一些，你可以使用强制类型转换。即你必须采用下面这种语句格式：
   int i;
   byte b=(byte)i;
可以想象，这种转换肯定可能会导致溢出或精度的下降，因此我们并不推荐使用这种转换。
　　浮点数的赋值是带有小数点的数字缺省是double型的，如果在浮点数后面加f或者F则是float，后面加d或者D则是double，科学计数法形式的浮点数也是double型的，而double的精度比float高，将一个高精度的double赋值给一个低精度的float时需要进行强制类型转换，反之则不需要。
    float f = 11.1;（是错误的）
1.2.3.2.      简单类型变量和包装类之间的相互转换
   简单类型的变量转换为相应的包装类，可以利用包装类的构造函数。即：
Boolean(boolean value)；
Character(char value)；
Integer(int value)；
Long(long value)；
Float(float value)；
Double(double value)
  而在各个包装类中，总有形为××Value()的方法，来得到其对应的简单类型数据。利用这种方法，也可以实现不同数值型变量间的转换，例如，对于一个双精度实型类，intValue()可以得到其对应的整型变量，而doubleValue()可以得到其对应的双精度实型变量。
1.2.3.3.       String类和其它数据类型的相互转换
    对于上面的这些包装类，除了Character以外，都有可以直接使用字符串参数的构造函数，这也就使得我们将String类转换为这些数据类型变得相当之简单，即：
  Boolean(String s)；
  Integer(String s)；
  Long(String s)；
  Float(String s)；
  Double(String s)；
    现在我们还剩下一个字符型变量，事实上String类可以理解为一个char型数组，因此我们可以在String类中找到这样的方法来实现这种转换：charAt(int index)可以得到String类中某一位置上的字符，toCharArray()更可以将整个String类转换成一个char的数组。
对于所有的包装类都存在一个名为toString()的方法可以将其转换成对应的String类，而对于整型类和长整型类，还可以使用toBinaryString(int i)、toHexString(int i)、toOctalString(int i)分别以二进制、十六进制和八进制的形式进行到String类的转换。
1.2.3.4.    字符型直接做为数值转换为其它数据类型
    将字符型变量转换为数值型变量实际上有两种对应关系，在我们在第一部分所说的那种转换中，实际上是将其转换成对应的ASCII码，但是我们有时还需要另一种转换关系，例如，‘1’就是指的数值1，而不是其ASCII码，对于这种转换，我们可以使用Character的 getNumericValue(char ch)方法。

1. package com.minght.sys.util;
2.  
3. public class ObjConvert {
4.   private ObjConvert() {
5.   }
6.   /*********************基本类型与包装器的相互转化****************/
7.   /**
8.    * 将Integer包装器转化成int基本类型
9.    * @param I Integer
10.    * @return int
11.    */
12.   public static int integerToInt(Integer I){
13.     if(I==null)
14.       return 0;
15.     int i = I.intValue();
16.     return i;
17.   }
18.  
19.   /**
20.    * 将int基本类型转化成Integer包装器对象
21.    * @param i int
22.    * @return Integer
23.    */
24.   public static Integer intToInteger(int i){
25.     Integer I = new Integer(i);
26.     return I;
27.   }
28.  
29.   /**
30.    * 将Charater 包装器对象转化成char基本类型
31.    * @param C Character
32.    * @return char
33.    */
34.   public static char charaterToChar(java.lang.Character C){
35.     if(C==null)
36.       return '0';
37.     char c = C.charValue();
38.     return c;
39.   }
40.  
41.   /**
42.    * 将char基本类型转化成Charater 包装器对象
43.    * @param c char
44.    * @return Character
45.    */
46.   public static Character charToCharater(char c){
47.     Character C = new Character('c');
48.     return C;
49.   }
50.  
51.   /**
52.    * 将Long 包装器对象转化成long基本类型
53.    * @param L Long
54.    * @return long
55.    */
56.   public static long LongTolong(Long L){
57.     if(L==null){
58.       return 0l;
59.     }
60.     long l = L.longValue();
61.     return l;
62.   }
63.  
64.   /**
65.    * 将long基本类型转化为Long包装器对象
66.    * @param l long
67.    * @return Long
68.    */
69.   public static Long longToLong(long l){
70.     Long L = new Long(l);
71.     return L;
72.   }
73.   
74.   /**
75.    * 将Float包装器对象转化为float基本类型
76.    * @param F Float
77.    * @return float
78.    */
79.   public static float FloatTofloat(Float F){
80.     if(F==null){
81.       return -1f;
82.     }
83.     float f = F.floatValue();
84.     return f;
85.   }
86.   
87.   /**
88.    * 将float基本类型转化为Float包装器对象
89.    * @param f float
90.    * @return Float
91.    */
92.   public static Float floatToFloat(float f){
93.     Float F = new Float(f);
94.     return F;
95.   }
96.  
97.   /**
98.    * 将Double包装器对象转化为double基本类型
99.    * @param D Double
100.    * @return double
101.    */
102.   public static double DoubleTodouble(Double D){
103.     if(D==null)
104.       return 0D;
105.     double d = D.doubleValue();
106.     return d;
107.   }
108.  
109.   /**
110.    * 将double基本类型转化为Double包装器对象
111.    * @param d double
112.    * @return Double
113.    */
114.   public static Double doubleToDouble(double d){
115.     Double D = new Double(d);
116.     return D;
117.   }
118.  
119.   /**
120.    * 将Boolean包装器对象转化为boolean基本类型
121.    * @param B Boolean
122.    * @return boolean
123.    */
124.   public static boolean BooleanToboolean(Boolean B){
125.     if(B==null)
126.       return false;
127.     boolean b = B.booleanValue();
128.     return b;
129.   }
130.  
131.   /**
132.    * 将boolean基本类型转化为Boolean对象类型
133.    * @param b boolean
134.    * @return Boolean
135.    */
136.   public static Boolean booleanToBoolean(boolean b){
137.     Boolean B = new Boolean(b);
138.     return B;
139.   }
140.  
141.   /***************************各类型与string类型的相互转换***********************/
142.   /**
143.    * 将String对象转化为int基本类型
144.    * @param s String
145.    * @return int
146.    */
147.   public static int sToi(String s){
148.     int i = -1;
149.     if(s==null || s.trim().length()==0){
150.       return i;
151.     }
152.     try{
153.       i = Integer.parseInt(s);
154.     }catch(Exception e){
155.       Debug.print("Stirng  convet to int error ! ");
156.       return i;
157.     }
158.     return i;
159.   }
160.  
161.   /**
162.    * 将int类型转化为String
163.    * @param i int
164.    * @return String
165.    */
166.   public static String iTos(int i){
167.     String s = intToInteger(i).toString();
168.     return s;
169.   }
170.   
171.   /**
172.    * 将string类型转化为long类型
173.    * @param s String
174.    * @return long
175.    */
176.   public static long sTol(String s ){
177.     long l = -1L;
178.     if(s==null || s.trim().length()==0){
179.       return l;
180.     }
181.     try{
182.       l = Long.parseLong(s);
183.     }catch(Exception e){
184.       Debug.println("String convert to long error!");
185.       return l;
186.     }
187.    return l;
188.   }
189.  
190.   /**
191.    * 将long类型转化为String类型
192.    * @param l long
193.    * @return String
194.    */
195.   public static String lTos(long l){
196.     String s = longToLong(l).toString();
197.     return s;
198.   }
199.   /**
200.    * 将string类型转化为float类型
201.    * @param s String
202.    * @return float
203.    */
204.   public static float sTof(String s){
205.    float f = -1f;
206.    if(s==null || s.length()==0){
207.      return f;
208.    }
209.    
210.    try{
211.      f = Float.parseFloat(s);
212.    }catch(Exception e){
213.      Debug.println("String convert to float error");
214.      return f;
215.    }
216.    return f;
217.  }
218.  
219.  /**
220.   * 将float类型转化为String类型
221.   * @param f float
222.   * @return String
223.   */
224.  public static String fTos(float f){
225.   String s = floatToFloat(f).toString();
226.   return s;
227.  }
228.  
229.  /**
230.    * 将string类型转化为double类型
231.    * @param s String
232.    * @return double
233.    */
234.   public static double sTod(String s){
235.    double d = -1d;
236.    if(s==null || s.length()==0){
237.      return d;
238.    }
239.  
240.    try{
241.      d = Double.parseDouble(s);
242.    }catch(Exception e){
243.      Debug.println("String convert to double error");
244.      return d;
245.    }
246.    return d;
247.  }
248.  
249.  /**
250.   * 将double类型转化为String类型
251.   * @param d double
252.   * @return String
253.   */
254.  public static String dTos(double d){
255.   String s = doubleToDouble(d).toString();
256.   return s;
257.  }
258.  
259.   /**
260.    * 测试
261.    * @param args String[]
262.    */
263.   public static void main(String[] args){
264.     Integer I = new Integer(10);
265.     int i = integerToInt(I);
266.     System.out.println("convert Integer to int :"+i);
267.   }
268.  
269. }

1.2.4.    高精度数字
    Java 提供了两个类专门用于进行高精度运算BigInteger 和BigDecimal ，尽管它们可大致划分到与封装器相同的类别里，但两者都没有对应的主类型；这两个类都有自己的一系列方法，类似于我们针对主类型执行的操作，也就是说能用int 或float 做的事情，用BigInteger和BigDecimal 一样可以做，只是必须换用方法调用，而不是使用运算符。此外由于牵涉更多，所以运算速度会慢一点总之我们牺牲了速度，但换来了精度。
1.2.4.1.    高精度整数BigInteger
    BigInteger支持任意精度的整数，也就是说我们可精确表示任意大小的整数值；同时在运算过程中不会丢失任何信息；
在BigInteger类中有所有的基本算术运算方法，如加、减、乘、除，以及可能会用到的位运算如或、异或、非、左移、右移等。下面是一些方法的例子：当然，如果要有更多的使用方法，可以查阅java api 。

1. package com.minght.test;
2.  
3. import java.math.*;
4. /**
5.  * 
6.  * <p>Title: 开源,开放</p>
7.  * <p>Description: opeansource</p>
8.  * <p>Copyright: Copyright (c) 2004</p>
9.  * <p>Company: ?海棠</p>
10.  * @author HaiTang Ming
11.  * @version 1.0
12.  */
13.  
14. public class BigIntegerTest {
15.   public BigIntegerTest() {
16.   }
17.   /**
18.    * 测试BigInteger
19.    */
20.   public static void testBigInteger() {
21.     BigInteger bi = new BigInteger("888");
22.     //multiply :乘法
23.     BigInteger result = bi.multiply(new BigInteger("2"));
24.     System.out.println(result);
25.     //divide : 除法
26.     result = bi.divide(new BigInteger("2"));
27.     System.out.println(result);
28.     //add : 加法
29.     result = bi.add(new BigInteger("232"));
30.     System.out.println(result);
31.     //subtract :减法
32.     result = bi.subtract(new BigInteger("23122"));
33.     System.out.println(result);
34.     result = bi.shiftRight(2);
35.     System.out.println(result);
36.   }
37.  
38.   public static void main(String[] args) {
39.     testBigInteger();
40.   }
41.  
42. }

1.2.4.2.    高精度浮点数BigDecimal
    一些非整数值（如几美元和几美分这样的小数）需要很精确。浮点数不是精确值，所以使用它们会导致舍入误差。因此，使用浮点数来试图表示象货币量这样的精确数量不是一个好的想法。使用浮点数来进行美元和美分计算会得到灾难性的后果。浮点数最好用来表示象测量值这类数值，这类值从一开始就不怎么精确。
    从 JDK 1.3 起，Java 开发人员就有了另一种数值表示法来表示非整数：BigDecimal。BigDecimal 是标准的类，在编译器中不需要特殊支持，它可以表示任意精度的小数，并对它们进行计算。在内部，可以用任意精度任何范围的值和一个换算因子来表示 BigDecimal，换算因子表示左移小数点多少位，从而得到所期望范围内的值。因此，用 BigDecimal 表示的数的形式为 unscaledValue*10-scale。
　　用于加、减、乘和除的方法给 BigDecimal 值提供了算术运算。由于 BigDecimal 对象是不可变的，这些方法中的每一个都会产生新的 BigDecimal 对象。因此，因为创建对象的开销，BigDecimal 不适合于大量的数学计算，但设计它的目的是用来精确地表示小数。如果您正在寻找一种能精确表示如货币量这样的数值，则 BigDecimal 可以很好地胜任该任务。
　　如浮点类型一样，BigDecimal 也有一些令人奇怪的行为。尤其在使用 equals() 方法来检测数值之间是否相等时要小心。equals() 方法认为，两个表示同一个数但换算值不同（例如，100.00 和 100.000）的 BigDecimal 值是不相等的。然而，compareTo() 方法会认为这两个数是相等的，所以在从数值上比较两个 BigDecimal 值时，应该使用 compareTo() 而不是 equals()。
　　另外还有一些情形，任意精度的小数运算仍不能表示精确结果。例如，1 除以 9 会产生无限循环的小数 .111111...。出于这个原因，在进行除法运算时，BigDecimal 可以让您显式地控制舍入。movePointLeft() 方法支持 10 的幂次方的精确除法。
　　对于 BigDecimal，有几个可用的构造函数。其中一个构造函数以双精度浮点数作为输入，另一个以整数和换算因子作为输入，还有一个以小数的 String 表示作为输入。要小心使用 BigDecimal(double) 构造函数，因为如果不了解它，会在计算过程中产生舍入误差。请使用基于整数或 String 的构造函数。
　　如果使用 BigDecimal(double) 构造函数不恰当，在传递给 JDBC setBigDecimal() 方法时，会造成似乎很奇怪的 JDBC 驱动程序中的异常。例如，考虑以下 JDBC 代码，该代码希望将数字 0.01 存储到小数字段：
  PreparedStatement ps =
connection.prepareStatement("INSERT INTO Foo SET name=?, value=?");
  ps.setString(1, "penny");
  ps.setBigDecimal(2, new BigDecimal(0.01));
  ps.executeUpdate();
    在执行这段似乎无害的代码时会抛出一些令人迷惑不解的异常（这取决于具体的 JDBC 驱动程序），因为 0.01 的双精度近似值会导致大的换算值，这可能会使 JDBC 驱动程序或数据库感到迷惑。JDBC 驱动程序会产生异常，但可能不会说明代码实际上错在哪里，除非意识到二进制浮点数的局限性。相反，使用 BigDecimal("0.01") 或 BigDecimal(1, 2) 构造 BigDecimal 来避免这类问题，因为这两种方法都可以精确地表示小数。

1. package com.minght.sys.util;
2.  
3. import java.math.BigDecimal;
4. /**
5.  *
6.  * <p>Title: 开源,开放</p>
7.  * <p>Description: opeansource</p>
8.  * <p>Copyright: Copyright (c) 2004</p>
9.  * <p>Company: ?海棠</p>
10.  * @author HaiTang Ming
11.  * @version 1.0
12.  */
13. public class BigDecimalUtil {
14.   //默认除法运算精度,及即保留小数点多少位
15.   private static final int DEF_DIV_SCALE = 2;
16.   //这个类不能实例化
17.   private BigDecimalUtil (){
18.   }
19.   /**
20.    * 提供精确的加法运算。
21.    * @param v1 被加数
22.    * @param v2 加数
23.    * @return 两个参数的和
24.    */
25.   public static double add(double v1,double v2){
26.     BigDecimal b1 = new BigDecimal(Double.toString(v1));
27.     BigDecimal b2 = new BigDecimal(Double.toString(v2));
28.     return (b1.add(b2)).doubleValue();
29.   }
30.   /**
31.    * 提供精确的减法运算。
32.    * @param v1 被减数
33.    * @param v2 减数
34.    * @return 两个参数的差
35.    */
36.   public static double sub(double v1,double v2){
37.     BigDecimal b1 = new BigDecimal(Double.toString(v1));
38.     BigDecimal b2 = new BigDecimal(Double.toString(v2));
39.     return (b1.subtract(b2)).doubleValue();
40.   }
41.   /**
42.    * 提供精确的乘法运算。
43.    * @param v1 被乘数
44.    * @param v2 乘数
45.    * @return 两个参数的积
46.    */
47. public static double mul(double v1,double v2){
48.     BigDecimal b1 = new BigDecimal(Double.toString(v1));
49.     BigDecimal b2 = new BigDecimal(Double.toString(v2));
50.     return (b1.multiply(b2)).doubleValue();
51.   }
52.   /**
53.    * 提供（相对）精确的除法运算，当发生除不尽的情况时，精确到
54.    * 小数点以后多少位，以后的数字四舍五入。
55.    * @param v1 被除数
56.    * @param v2 除数
57.    * @return 两个参数的商
58.    */
59.   public static double div(double v1,double v2){
60.     return div(v1,v2,DEF_DIV_SCALE);
61.   }
62.   /**
63.    * 提供（相对）精确的除法运算。当发生除不尽的情况时，由scale参数指
64.    * 定精度，以后的数字四舍五入。
65.    * @param v1 被除数
66.    * @param v2 除数
67.    * @param scale 表示表示需要精确到小数点以后几位。
68.    * @return 两个参数的商
69.    */
70.   public static double div(double v1,double v2,int scale){
71.     if(scale<0){
72.       throw new IllegalArgumentException(
73.       "The scale must be a positive integer or zero");
74.     }
75.     BigDecimal b1 = new BigDecimal(Double.toString(v1));
76.     BigDecimal b2 = new BigDecimal(Double.toString(v2));
77.     return (b1.divide(b2,scale,BigDecimal.ROUND_HALF_UP)).doubleValue();
78.   }
79.   /**
80.    * 提供精确的小数位四舍五入处理。
81.    * @param v 需要四舍五入的数字
82.    * @param scale 小数点后保留几位
83.    * @return 四舍五入后的结果
84.    */
85.   public static double round(double v,int scale){
86.     if(scale<0){
87.       throw new IllegalArgumentException(
88.       "The scale must be a positive integer or zero");
89.     }
90.     BigDecimal b = new BigDecimal(Double.toString(v));
91.     BigDecimal one = new BigDecimal("1");
92.     return (b.divide(one,scale,BigDecimal.ROUND_HALF_UP)).doubleValue();
93.   }
94.  
95.   public static void main(String[] args){
96.     double a = 123.345678;
97.     double d = round(a,2);
98.     Debug.println("round("+a+",2)--->"+d);
99.   }
100. }

备注：
    来自于网络，回归于网络；