minghaitang－－dataType1.0
?b海棠之数据类型
一点点汲取,一步步逝去;
生长在就里,成熟于无形
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。其中四种整型变量和两种浮点型变量分别对应于不同的精度和范围。
|
主类型 |
大小 |
最小值 |
最大值 |
封装器类型 |
|
boolean |
——— |
—————— |
———— |
Boolean |
|
Char |
16-bit |
Unicode 0 |
Unicode 216- 1 |
Character |
|
byte |
8-bit |
-128 |
+127 |
Byte |
|
Short |
16-bit |
-215 |
+215—1 |
Short |
|
Int |
32-bit |
-231 |
+231—1 |
Integer |
|
Long |
64-bit |
-263 |
+263—1 |
Long |
|
Float |
32-bit |
IEEE754 |
IEEE754 |
Float |
|
double |
64-bit |
IEEE754 |
IEEE754 |
Double |
|
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码，但是我们有时还需要另一种转换关系，例如，‘
package com.minght.sys.util;
public class ObjConvert {
private ObjConvert() {
}
/*********************基本类型与包装器的相互转化****************/
/**
* 将Integer包装器转化成int基本类型
* @param I Integer
* @return int
*/
public static int integerToInt(Integer I){
if(I==null)
return 0;
int i = I.intValue();
return i;
}
/**
* 将int基本类型转化成Integer包装器对象
* @param i int
* @return Integer
*/
public static Integer intToInteger(int i){
Integer I = new Integer(i);
return I;
}
/**
* 将Charater 包装器对象转化成char基本类型
* @param C Character
* @return char
*/
public static char charaterToChar(java.lang.Character C){
if(C==null)
return '0';
char c = C.charValue();
return c;
}
/**
* 将char基本类型转化成Charater 包装器对象
* @param c char
* @return Character
*/
public static Character charToCharater(char c){
Character C = new Character('c');
return C;
}
/**
* 将Long 包装器对象转化成long基本类型
* @param L Long
* @return long
*/
public static long LongTolong(Long L){
if(L==null){
return
}
long l = L.longValue();
return l;
}
/**
* 将long基本类型转化为Long包装器对象
* @param l long
* @return Long
*/
public static Long longToLong(long l){
Long L = new Long(l);
return L;
}
/**
* 将Float包装器对象转化为float基本类型
* @param F Float
* @return float
*/
public static float FloatTofloat(Float F){
if(F==null){
return
}
float f = F.floatValue();
return f;
}
/**
* 将float基本类型转化为Float包装器对象
* @param f float
* @return Float
*/
public static Float floatToFloat(float f){
Float F = new Float(f);
return F;
}
/**
* 将Double包装器对象转化为double基本类型
* @param D Double
* @return double
*/
public static double DoubleTodouble(Double D){
if(D==null)
return 0D;
double d = D.doubleValue();
return d;
}
/**
* 将double基本类型转化为Double包装器对象
* @param d double
* @return Double
*/
public static Double doubleToDouble(double d){
Double D = new Double(d);
return D;
}
/**
* 将Boolean包装器对象转化为boolean基本类型
* @param B Boolean
* @return boolean
*/
public static boolean BooleanToboolean(Boolean B){
if(B==null)
return false;
boolean b = B.booleanValue();
return b;
}
/**
* 将boolean基本类型转化为Boolean对象类型
* @param b boolean
* @return Boolean
*/
public static Boolean booleanToBoolean(boolean b){
Boolean B = new Boolean(b);
return B;
}
/***************************各类型与string类型的相互转换***********************/
/**
* 将String对象转化为int基本类型
* @param s String
* @return int
*/
public static int sToi(String s){
int i = -1;
if(s==null || s.trim().length()==0){
return i;
}
try{
i = Integer.parseInt(s);
}catch(Exception e){
Debug.print("Stirng convet to int error ! ");
return i;
}
return i;
}
/**
* 将int类型转化为String
* @param i int
* @return String
*/
public static String iTos(int i){
String s = intToInteger(i).toString();
return s;
}
/**
* 将string类型转化为long类型
* @param s String
* @return long
*/
public static long sTol(String s ){
long l =
if(s==null || s.trim().length()==0){
return l;
}
try{
l = Long.parseLong(s);
}catch(Exception e){
Debug.println("String convert to long error!");
return l;
}
return l;
}
/**
* 将long类型转化为String类型
* @param l long
* @return String
*/
public static String lTos(long l){
String s = longToLong(l).toString();
return s;
}
/**
* 将string类型转化为float类型
* @param s String
* @return float
*/
public static float sTof(String s){
float f =
if(s==null || s.length()==0){
return f;
}
try{
f = Float.parseFloat(s);
}catch(Exception e){
Debug.println("String convert to float error");
return f;
}
return f;
}
/**
* 将float类型转化为String类型
* @param f float
* @return String
*/
public static String fTos(float f){
String s = floatToFloat(f).toString();
return s;
}
/**
* 将string类型转化为double类型
* @param s String
* @return double
*/
public static double sTod(String s){
double d = -1d;
if(s==null || s.length()==0){
return d;
}
try{
d = Double.parseDouble(s);
}catch(Exception e){
Debug.println("String convert to double error");
return d;
}
return d;
}
/**
* 将double类型转化为String类型
* @param d double
* @return String
*/
public static String dTos(double d){
String s = doubleToDouble(d).toString();
return s;
}
/**
* 测试
* @param args String[]
*/
public static void main(String[] args){
Integer I = new Integer(10);
int i = integerToInt(I);
System.out.println("convert Integer to int :"+i);
}
}
1.2.4. 高精度数字
Java 提供了两个类专门用于进行高精度运算BigInteger 和BigDecimal ，尽管它们可大致划分到与封装器相同的类别里，但两者都没有对应的主类型；这两个类都有自己的一系列方法，类似于我们针对主类型执行的操作，也就是说能用int 或float 做的事情，用BigInteger和BigDecimal 一样可以做，只是必须换用方法调用，而不是使用运算符。此外由于牵涉更多，所以运算速度会慢一点总之我们牺牲了速度，但换来了精度。
1.2.4.1. 高精度整数BigInteger
BigInteger支持任意精度的整数，也就是说我们可精确表示任意大小的整数值；同时在运算过程中不会丢失任何信息；
在BigInteger类中有所有的基本算术运算方法，如加、减、乘、除，以及可能会用到的位运算如或、异或、非、左移、右移等。下面是一些方法的例子：当然，如果要有更多的使用方法，可以查阅java api 。
package com.minght.test;
import java.math.*;
/**
*
* <p>Title: 开源,开放</p>
* <p>Description: opeansource</p>
* <p>Copyright: Copyright (c) 2004</p>
* <p>Company: ?b海棠</p>
* @author HaiTang Ming
* @version 1.0
*/
public class BigIntegerTest {
public BigIntegerTest() {
}
/**
* 测试BigInteger
*/
public static void testBigInteger() {
BigInteger bi = new BigInteger("888");
//multiply :乘法
BigInteger result = bi.multiply(new BigInteger("2"));
System.out.println(result);
//divide : 除法
result = bi.divide(new BigInteger("2"));
System.out.println(result);
//add : 加法
result = bi.add(new BigInteger("232"));
System.out.println(result);
//subtract :减法
result = bi.subtract(new BigInteger("23122"));
System.out.println(result);
result = bi.shiftRight(2);
System.out.println(result);
}
public static void main(String[] args) {
testBigInteger();
}
}