常用数据类型转换(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);
    }
  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
1. 自动类型转换(隐式类型转换): 当 Java 虚拟机自动将一种数据类型转换为另一种数据类型时,就发生了自动类型转换。这种转换是在编译时期自动完成的,无需程序员进行干预。 自动类型转换的规则如下: 1. 一种数据类型可以自动转换为另一种数据类型,只要目标类型的范围大于源类型的范围。 2. 整型可以自动转换为浮点型,但浮点型不能自动转换为整型。 3. char 类型可以自动转换为 int 类型,但 int 类型不能自动转换为 char 类型。 示例: ```java int a = 10; double b = a; // 自动类型转换,将 int 类型转换为 double 类型 System.out.println(b); // 输出 10.0 char c = 'a'; int d = c; // 自动类型转换,将 char 类型转换为 int 类型 System.out.println(d); // 输出 97 ``` 2. 强制类型转换(显式类型转换): 当 Java 虚拟机无法自动将一种数据类型转换为另一种数据类型时,就需要进行强制类型转换。强制类型转换需要程序员手动指定要转换数据类型。 强制类型转换的语法格式如下: ```java 目标类型 变量名 = (目标类型) 原始类型; ``` 示例: ```java double a = 10.5; int b = (int) a; // 强制类型转换,将 double 类型转换为 int 类型 System.out.println(b); // 输出 10 ``` 需要注意的是,在进行强制类型转换时,可能会发生数据精度丢失的情况。例如,将一个 double 类型的值转换为 int 类型时,小数部分会被截断,只保留整数部分。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值