1.基本数据类型
-
整型：
byte: 1byte -2^7~2^7-1
short: 2byte -2^15~2^15-1
int: 4byte -2^31~2^31-1
long: 8byte -2^63~2^63-1 -
浮点型：
float： 4byte -2^31~2^31-1 （有效位数6~7位）
double： 8byte -2^63~2^63-1 （有效位数15位） -
字符型：
char： 2byte -2^15~2^15-1 unicode字符 -
布尔型：
boolean -
对应的类类型：
Byte、Short、Integer、Long、Float、Double、Character、Boolean汉字占用字节：”UTF-8编码长度:”+a.getBytes(“UTF-8”).length = 3
“GBK编码长度:”+a.getBytes(“GBK”).length = 2
“GB2312编码长度:”+a.getBytes(“GB2312”).length = 2
2.数据类型之间的转换
基本的数据类型由低级到高级分别为：（byte、short、char）——int——long——float——double
分为以下几种情况：
1）低级到高级的自动类型转换；
2）高级到低级的强制类型转换（会导致溢出或丢失精度）；
3）基本类型向类类型转换；
4）基本类型向字符串的转换；
5）类类型向字符串转换
3.基本数据类型之间的转换规则
1.在一个双操作数以及位运算等算术运算式中，会根据操作数的类型将低级的数据类型自动转换为高级的数据类型，分为以下几种情况：
1）只要两个操作数中有一个是double类型的，另一个将会被转换成double类型，并且结果也是double类型；
2）只要两个操作数中有一个是float类型的，另一个将会被转换成float类型，并且结果也是float类型；
3）只要两个操作数中有一个是long类型的，另一个将会被转换成long类型，并且结果也是long类型；
4）两个操作数（包括byte、short、int、char）都将会被转换成int类型，并且结果也是int类型。
2. 如果低级类型为char型，向高级类型（整型）转换时，会转换为对应ASCII码值，再做其它类型的自动转换。
3. 对于byte,short,char三种类型而言，他们是平级的，因此不能相互自动转换，可以使用下述的强制类型转换。 如：
short i=99 ;
char c=(char)i;
System.out.println("output:"+c);
4. 不能在布尔值和任何数字类型间强制类型转换；
5. 不同级别数据类型间的强制转换，可能会导致溢出或精度的下降。
6. 当字节类型变量参与运算，java作自动数据运算类型的提升，将其转换为int类型。例如：
byte b;
b=3;
b=(byte)(b*3);//必须声明byte。
4.包装数据类型与基本数据类型之间的转换
1.简单类型的变量转换为相应的包装类，可以利用包装类的构造函数：
Boolean(boolean value)、Character(char value)、Integer(int value)、Long(long value)、Float(float value)、Double(double value)
Integer i = Integer.valueOf(int a);或 Integer i = new Integer（int a）；
2.在各个包装类中，总有形为××Value()的方法，来得到其对应的简单类型数据：
例如，对于一个双精度实型类，intValue()可以得到其对应的整型变量，而doubleValue()可以得到其对应的双精度实型变量。
3.字符串与其它类型间的转换
(1)其它类型向字符串的转换
①调用类的串转换方法:X.toString();
②自动转换:X+“”;
③使用String的方法:String.valueOf(X);
(2)字符串作为值,向其它类型的转换
①先转换成相应的封装器实例,再调用对应的方法转换成其它类型
例如，字符中“32.1”转换double型的值的格式为:new Float(“32.1”).doubleValue()。也可以用:Double.valueOf(“32.1”).doubleValue()
②静态parseXXX方法
String s = "1";
byte b = Byte.parseByte( s );
short t = Short.parseShort( s );
int i = Integer.parseInt( s );
long l = Long.parseLong( s );
Float f = Float.parseFloat( s );
③Character的getNumericValue(char ch)方法
5.byte[]与其他类型之间转换
（1）其他类型>byte[]:
/**
*short to byte[]
*
* @param short
* @return byte[]
*/
public static byte[] getBytes(short data){
byte[] bytes = new byte[2];
bytes[0] = (byte) (data & 0xff);
bytes[1] = (byte) ((data & 0xff00) >> 8);
return bytes;
}
/**
*char to byte[]
*
* @param char
* @return byte[]
*/
public static byte[] getBytes(char data){
byte[] bytes = new byte[2];
bytes[0] = (byte) (data);
bytes[1] = (byte) (data >> 8);
return bytes;
} /**
*int to byte[]
*
* @param int
* @return byte[]
*/
public static byte[] getBytes(int data){
byte[] bytes = new byte[4];
bytes[0] = (byte) (data & 0xff);
bytes[1] = (byte) ((data & 0xff00) >> 8);
bytes[2] = (byte) ((data & 0xff0000) >> 16);
bytes[3] = (byte) ((data & 0xff000000) >> 24);
return bytes;
} /**
*long to byte[]
*
* @param long
* @return byte[]
*/
public static byte[] getBytes(long data){
byte[] bytes = new byte[8];
bytes[0] = (byte) (data & 0xff);
bytes[1] = (byte) ((data >> 8) & 0xff);
bytes[2] = (byte) ((data >> 16) & 0xff);
bytes[3] = (byte) ((data >> 24) & 0xff);
bytes[4] = (byte) ((data >> 32) & 0xff);
bytes[5] = (byte) ((data >> 40) & 0xff);
bytes[6] = (byte) ((data >> 48) & 0xff);
bytes[7] = (byte) ((data >> 56) & 0xff);
return bytes;
} /**
*float to byte[]
*
* @param float
* @return byte[]
*/
public static byte[] getBytes(float data){
int intBits = Float.floatToIntBits(data);
return getBytes(intBits);
} /**
*double to byte[]
*
* @param double
* @return byte[]
*/
public static byte[] getBytes(double data){
long intBits = Double.doubleToLongBits(data);
return getBytes(intBits);
} /**
*String to byte[]
*
* @param string,string(编码格式)
* @return byte[]
*/
public static byte[] getBytes(String data, String charsetName){
Charset charset = Charset.forName(charsetName);
return data.getBytes(charset);
}（2）byte[]>其他类型:
/**
* bytes[] to hexString
*
* @param bytes[]
* @return String(Hex)
*/
public String toHexString(byte[] bytes) {
String hexSSID = "";
for (int i = 0; i < bytes.length; i++) {
String hex = Integer.toHexString(bytes[i] & 0xFF);
if (hex.length() == 1) {
hex = '0' + hex;
}
hexSSID = hexSSID + hex;
}
return hexSSID;
} /**
*byte[] to string
*
* @param byte[],string(编码格式)
* @return string
*/
public static String getString(byte[] bytes, String charsetName){
return new String(bytes, Charset.forName(charsetName));
} /**
*byte[] to short
*
* @param byte[]
* @return short
*/
public static short getShort(byte[] bytes){
return (short) ((0xff & bytes[0]) | (0xff00 & (bytes[1] << 8)));
} /**
*byte[] to int
*
* @param byte[]
* @return int
*/
public static int getInt(byte[] bytes){
return (0xff & bytes[0])|
(0xff00 & (bytes[1] << 8))|
(0xff0000 & (bytes[2] << 16))|
(0xff000000 & (bytes[3] << 24));
} /**
*byte[] to long
*
* @param byte[]
* @return long
*/
public static long getLong(byte[] bytes){
return (0xffL & (long)bytes[0])|
(0xff00L & ((long)bytes[1] << 8))|
(0xff000000L & ((long)bytes[3] << 24))|
(0xff00000000L & ((long)bytes[4] << 32))|
(0xff0000000000L & ((long)bytes[5] << 40))|
(0xff000000000000L & ((long)bytes[6] << 48))|
(0xff00000000000000L & ((long)bytes[7] << 56));
} /**
*byte[] to float
*
* @param byte[]
* @return float
*/
public static float getFloat(byte[] bytes){
return Float.intBitsToFloat(getInt(bytes));
} /**
*byte[] to double
*
* @param byte[]
* @return double
*/
public static double getDouble(byte[] bytes){
long l = getLong(bytes);
System.out.println(l);
return Double.longBitsToDouble(l);
} /**
*byte[] to char
*
* @param byte[]
* @return char
*/
public static char getChar(byte[] bytes){
return (char) ((0xff & bytes[0]) | (0xff00 & (bytes[1] << 8)));
}IP地址格式转换
/**
* switch IP Address
*
* @param int
* @return String
*/
public String intToIp(int i) {
return (i & 0xFF) + "." + ((i >> 8) & 0xFF) + "." + ((i >> 16) & 0xFF)
+ "." + (i >> 24 & 0xFF);
}