Java数据类型

海棠之数据类型

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

生长在就里,成熟于无形

1.类型杂论
1.1.关于引用
Java语言首先便假定了我们只希望进行面向对象的程序设计，也就是说用它正式写程序之前首先必须先将自己的思想转入一个纯净的面向对象的世界,Java中的一切都是对象即便一个Java程序它本身也是一个对象。
任何东西都可看作一个对象,但要注意尽管将一切都看作对象，但操作的标识符实际是对一个对象的引用（Reference）。只是由于拥有一个引用并不表示必须有一个对象同它连接，所以如果想容纳一个词或句子可创建一个String引用：
Strings;
但这里创建的只是引用并不是对象，若此时向s发送一条消息，就会获得一个运行时错误，这是由于s实际并未与任何东西连接；因此一种更安全的做法是创建一个引用时记住，无论如何都进行初始化：
Strings="asdf";
创建一个引用时我们希望它同一个新对象建立连接，通常用new关键字达到这一目的。new的意思是把我变成这种类型的一个对象，所以上面的例子也可以表达成：
Strings=newString("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. Char16-bitUnicode0Unicode216-1Character
4. byte8-bit-128+127Byte
5. Short16-bit-215+215?1Short
6. Int32-bit-231+231?1Integer
7. Long64-bit-263+263?1Long
8. Float32-bitIEEE754IEEE754Float
9. double64-bitIEEE754IEEE754Double
10. Void－－－Void

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

1. packagecom.minght.sys.util;
3. publicclassObjConvert{
4. privateObjConvert(){
5. }
6. /*********************基本类型与包装器的相互转化****************/
7. /**
8. *将Integer包装器转化成int基本类型
9. *@paramIInteger
10. *@returnint
11. */
12. publicstaticintintegerToInt(IntegerI){
13. if(I==null)
14. return0;
15. inti=I.intValue();
16. returni;
17. }
19. /**
20. *将int基本类型转化成Integer包装器对象
21. *@paramiint
22. *@returnInteger
23. */
24. publicstaticIntegerintToInteger(inti){
25. IntegerI=newInteger(i);
26. returnI;
27. }
29. /**
30. *将Charater包装器对象转化成char基本类型
31. *@paramCCharacter
32. *@returnchar
33. */
34. publicstaticcharcharaterToChar(java.lang.CharacterC){
35. if(C==null)
36. return'0';
37. charc=C.charValue();
38. returnc;
39. }
41. /**
42. *将char基本类型转化成Charater包装器对象
43. *@paramcchar
44. *@returnCharacter
45. */
46. publicstaticCharactercharToCharater(charc){
47. CharacterC=newCharacter('c');
48. returnC;
49. }
51. /**
52. *将Long包装器对象转化成long基本类型
53. *@paramLLong
54. *@returnlong
55. */
56. publicstaticlongLongTolong(LongL){
57. if(L==null){
58. return0l;
59. }
60. longl=L.longValue();
61. returnl;
62. }
64. /**
65. *将long基本类型转化为Long包装器对象
66. *@paramllong
67. *@returnLong
68. */
69. publicstaticLonglongToLong(longl){
70. LongL=newLong(l);
71. returnL;
72. }
74. /**
75. *将Float包装器对象转化为float基本类型
76. *@paramFFloat
77. *@returnfloat
78. */
79. publicstaticfloatFloatTofloat(FloatF){
80. if(F==null){
81. return-1f;
82. }
83. floatf=F.floatValue();
84. returnf;
85. }
87. /**
88. *将float基本类型转化为Float包装器对象
89. *@paramffloat
90. *@returnFloat
91. */
92. publicstaticFloatfloatToFloat(floatf){
93. FloatF=newFloat(f);
94. returnF;
95. }
97. /**
98. *将Double包装器对象转化为double基本类型
99. *@paramDDouble
100. *@returndouble
101. */
102. publicstaticdoubleDoubleTodouble(DoubleD){
103. if(D==null)
104. return0D;
105. doubled=D.doubleValue();
106. returnd;
107. }
109. /**
110. *将double基本类型转化为Double包装器对象
111. *@paramddouble
112. *@returnDouble
113. */
114. publicstaticDoubledoubleToDouble(doubled){
115. DoubleD=newDouble(d);
116. returnD;
117. }
119. /**
120. *将Boolean包装器对象转化为boolean基本类型
121. *@paramBBoolean
122. *@returnboolean
123. */
124. publicstaticbooleanBooleanToboolean(BooleanB){
125. if(B==null)
126. returnfalse;
127. booleanb=B.booleanValue();
128. returnb;
129. }
131. /**
132. *将boolean基本类型转化为Boolean对象类型
133. *@parambboolean
134. *@returnBoolean
135. */
136. publicstaticBooleanbooleanToBoolean(booleanb){
137. BooleanB=newBoolean(b);
138. returnB;
139. }
141. /***************************各类型与string类型的相互转换***********************/
142. /**
143. *将String对象转化为int基本类型
144. *@paramsString
145. *@returnint
146. */
147. publicstaticintsToi(Strings){
148. inti=-1;
149. if(s==null||s.trim().length()==0){
150. returni;
151. }
152. try{
153. i=Integer.parseInt(s);
154. }catch(Exceptione){
155. Debug.print("Stirngconvettointerror!");
156. returni;
157. }
158. returni;
159. }
161. /**
162. *将int类型转化为String
163. *@paramiint
164. *@returnString
165. */
166. publicstaticStringiTos(inti){
167. Strings=intToInteger(i).toString();
168. returns;
169. }
171. /**
172. *将string类型转化为long类型
173. *@paramsString
174. *@returnlong
175. */
176. publicstaticlongsTol(Strings){
177. longl=-1L;
178. if(s==null||s.trim().length()==0){
179. returnl;
180. }
181. try{
182. l=Long.parseLong(s);
183. }catch(Exceptione){
184. Debug.println("Stringconverttolongerror!");
185. returnl;
186. }
187. returnl;
188. }
190. /**
191. *将long类型转化为String类型
192. *@paramllong
193. *@returnString
194. */
195. publicstaticStringlTos(longl){
196. Strings=longToLong(l).toString();
197. returns;
198. }
199. /**
200. *将string类型转化为float类型
201. *@paramsString
202. *@returnfloat
203. */
204. publicstaticfloatsTof(Strings){
205. floatf=-1f;
206. if(s==null||s.length()==0){
207. returnf;
208. }
210. try{
211. f=Float.parseFloat(s);
212. }catch(Exceptione){
213. Debug.println("Stringconverttofloaterror");
214. returnf;
215. }
216. returnf;
217. }
219. /**
220. *将float类型转化为String类型
221. *@paramffloat
222. *@returnString
223. */
224. publicstaticStringfTos(floatf){
225. Strings=floatToFloat(f).toString();
226. returns;
227. }
229. /**
230. *将string类型转化为double类型
231. *@paramsString
232. *@returndouble
233. */
234. publicstaticdoublesTod(Strings){
235. doubled=-1d;
236. if(s==null||s.length()==0){
237. returnd;
238. }
240. try{
241. d=Double.parseDouble(s);
242. }catch(Exceptione){
243. Debug.println("Stringconverttodoubleerror");
244. returnd;
245. }
246. returnd;
247. }
249. /**
250. *将double类型转化为String类型
251. *@paramddouble
252. *@returnString
253. */
254. publicstaticStringdTos(doubled){
255. Strings=doubleToDouble(d).toString();
256. returns;
257. }
259. /**
260. *测试
261. *@paramargsString[]
262. */
263. publicstaticvoidmain(String[]args){
264. IntegerI=newInteger(10);
265. inti=integerToInt(I);
266. System.out.println("convertIntegertoint:"+i);
267. }
269. }

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

1. packagecom.minght.test;
3. importjava.math.*;
4. /**
5. *
6. *<p>Title:开源,开放</p>
7. *<p>Description:opeansource</p>
8. *<p>Copyright:Copyright(c)2004</p>
9. *<p>Company:?海棠</p>
10. *@authorHaiTangMing
11. *@version1.0
12. */
14. publicclassBigIntegerTest{
15. publicBigIntegerTest(){
16. }
17. /**
18. *测试BigInteger
19. */
20. publicstaticvoidtestBigInteger(){
21. BigIntegerbi=newBigInteger("888");
22. //multiply:乘法
23. BigIntegerresult=bi.multiply(newBigInteger("2"));
24. System.out.println(result);
25. //divide:除法
26. result=bi.divide(newBigInteger("2"));
27. System.out.println(result);
28. //add:加法
29. result=bi.add(newBigInteger("232"));
30. System.out.println(result);
31. //subtract:减法
32. result=bi.subtract(newBigInteger("23122"));
33. System.out.println(result);
34. result=bi.shiftRight(2);
35. System.out.println(result);
36. }
38. publicstaticvoidmain(String[]args){
39. testBigInteger();
40. }
42. }

1.2.4.2.高精度浮点数BigDecimal
一些非整数值（如几美元和几美分这样的小数）需要很精确。浮点数不是精确值，所以使用它们会导致舍入误差。因此，使用浮点数来试图表示象货币量这样的精确数量不是一个好的想法。使用浮点数来进行美元和美分计算会得到灾难性的后果。浮点数最好用来表示象测量值这类数值，这类值从一开始就不怎么精确。
从JDK1.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)构造函数不恰当，在传递给JDBCsetBigDecimal()方法时，会造成似乎很奇怪的JDBC驱动程序中的异常。例如，考虑以下JDBC代码，该代码希望将数字0.01存储到小数字段：
PreparedStatementps=
connection.prepareStatement("INSERTINTOFooSETname=?,value=?");
ps.setString(1,"penny");
ps.setBigDecimal(2,newBigDecimal(0.01));
ps.executeUpdate();
在执行这段似乎无害的代码时会抛出一些令人迷惑不解的异常（这取决于具体的JDBC驱动程序），因为0.01的双精度近似值会导致大的换算值，这可能会使JDBC驱动程序或数据库感到迷惑。JDBC驱动程序会产生异常，但可能不会说明代码实际上错在哪里，除非意识到二进制浮点数的局限性。相反，使用BigDecimal("0.01")或BigDecimal(1,2)构造BigDecimal来避免这类问题，因为这两种方法都可以精确地表示小数。

1. packagecom.minght.sys.util;
3. importjava.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. *@authorHaiTangMing
11. *@version1.0
12. */
13. publicclassBigDecimalUtil{
14. //默认除法运算精度,及即保留小数点多少位
15. privatestaticfinalintDEF_DIV_SCALE=2;
16. //这个类不能实例化
17. privateBigDecimalUtil(){
18. }
19. /**
20. *提供精确的加法运算。
21. *@paramv1被加数
22. *@paramv2加数
23. *@return两个参数的和
24. */
25. publicstaticdoubleadd(doublev1,doublev2){
26. BigDecimalb1=newBigDecimal(Double.toString(v1));
27. BigDecimalb2=newBigDecimal(Double.toString(v2));
28. return(b1.add(b2)).doubleValue();
29. }
30. /**
31. *提供精确的减法运算。
32. *@paramv1被减数
33. *@paramv2减数
34. *@return两个参数的差
35. */
36. publicstaticdoublesub(doublev1,doublev2){
37. BigDecimalb1=newBigDecimal(Double.toString(v1));
38. BigDecimalb2=newBigDecimal(Double.toString(v2));
39. return(b1.subtract(b2)).doubleValue();
40. }
41. /**
42. *提供精确的乘法运算。
43. *@paramv1被乘数
44. *@paramv2乘数
45. *@return两个参数的积
46. */
47. publicstaticdoublemul(doublev1,doublev2){
48. BigDecimalb1=newBigDecimal(Double.toString(v1));
49. BigDecimalb2=newBigDecimal(Double.toString(v2));
50. return(b1.multiply(b2)).doubleValue();
51. }
52. /**
53. *提供（相对）精确的除法运算，当发生除不尽的情况时，精确到
54. *小数点以后多少位，以后的数字四舍五入。
55. *@paramv1被除数
56. *@paramv2除数
57. *@return两个参数的商
58. */
59. publicstaticdoublediv(doublev1,doublev2){
60. returndiv(v1,v2,DEF_DIV_SCALE);
61. }
62. /**
63. *提供（相对）精确的除法运算。当发生除不尽的情况时，由scale参数指
64. *定精度，以后的数字四舍五入。
65. *@paramv1被除数
66. *@paramv2除数
67. *@paramscale表示表示需要精确到小数点以后几位。
68. *@return两个参数的商
69. */
70. publicstaticdoublediv(doublev1,doublev2,intscale){
71. if(scale<0){
72. thrownewIllegalArgumentException(
73. "Thescalemustbeapositiveintegerorzero");
74. }
75. BigDecimalb1=newBigDecimal(Double.toString(v1));
76. BigDecimalb2=newBigDecimal(Double.toString(v2));
77. return(b1.divide(b2,scale,BigDecimal.ROUND_HALF_UP)).doubleValue();
78. }
79. /**
80. *提供精确的小数位四舍五入处理。
81. *@paramv需要四舍五入的数字
82. *@paramscale小数点后保留几位
83. *@return四舍五入后的结果
84. */
85. publicstaticdoubleround(doublev,intscale){
86. if(scale<0){
87. thrownewIllegalArgumentException(
88. "Thescalemustbeapositiveintegerorzero");
89. }
90. BigDecimalb=newBigDecimal(Double.toString(v));
91. BigDecimalone=newBigDecimal("1");
92. return(b.divide(one,scale,BigDecimal.ROUND_HALF_UP)).doubleValue();
93. }
95. publicstaticvoidmain(String[]args){
96. doublea=123.345678;
97. doubled=round(a,2);
98. Debug.println("round("+a+",2)--->"+d);
99. }
100. }

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