常用数据类型转换（JAVA）

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))| 
                (0xff0000L & ((long)bytes[2] << 16))| 
                (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);
    }