java Byte和各数据类型(short,int,long,float,double)之间的转换

本文介绍Java中不同数据类型(short、int、long、float、double)与byte数组之间的转换方法,包括转换核心原理及具体实现代码。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

 

本文引用此处

http://www.2cto.com/kf/201308/235099.html

 

在Java的网络编程中传输的经常是byte数组,但我们实际中使用的数据类型可能是任一种数据类型,这就需要在它们之间相互转换,转换的核心在于将其他类型的数据的每一位转换成byte类型的数据。下面给出相关的转换代码

1.short与byte数组的互转

 

[java]
/**
* 转换short为byte
*
* @param b
* @param s 需要转换的short
* @param index
*/ 
public static void putShort(byte b[], short s, int index) { 
     b[index + 1] = (byte) (s >> 8); 
     b[index + 0] = (byte) (s >> 0); 

 
/**
* 通过byte数组取到short
*
* @param b
* @param index  第几位开始取
* @return
*/ 
public static short getShort(byte[] b, int index) { 
      return (short) (((b[index + 1] << 8) | b[index + 0] & 0xff)); 

/**
* 转换short为byte
*
* @param b
* @param s 需要转换的short
* @param index
*/
public static void putShort(byte b[], short s, int index) {
     b[index + 1] = (byte) (s >> 8);
     b[index + 0] = (byte) (s >> 0);
}

/**
* 通过byte数组取到short
*
* @param b
* @param index  第几位开始取
* @return
*/
public static short getShort(byte[] b, int index) {
      return (short) (((b[index + 1] << 8) | b[index + 0] & 0xff));
}
2.int与byte数组的互转


[java]
/**
*将32位的int值放到4字节的byte数组
* @param num
* @return
*/ 
public static byte[] intToByteArray(int num) { 
   byte[] result = new byte[4]; 
   result[0] = (byte)(num >>> 24);//取最高8位放到0下标  
   result[1] = (byte)(num >>> 16);//取次高8为放到1下标  
   result[2] = (byte)(num >>> 8); //取次低8位放到2下标  
   result[3] = (byte)(num );      //取最低8位放到3下标  
   return result; 

 
/**
* 将4字节的byte数组转成一个int值
* @param b
* @return
*/ 
public static int byteArrayToInt(byte[] b){ 
    byte[] a = new byte[4]; 
    int i = a.length - 1,j = b.length - 1; 
    for (; i >= 0 ; i--,j--) {//从b的尾部(即int值的低位)开始copy数据  
        if(j >= 0) 
            a[i] = b[j]; 
        else 
            a[i] = 0;//如果b.length不足4,则将高位补0  
  } 
    int v0 = (a[0] & 0xff) << 24;//&0xff将byte值无差异转成int,避免Java自动类型提升后,会保留高位的符号位  
    int v1 = (a[1] & 0xff) << 16; 
    int v2 = (a[2] & 0xff) << 8; 
    int v3 = (a[3] & 0xff) ; 
    return v0 + v1 + v2 + v3; 

/**
*将32位的int值放到4字节的byte数组
* @param num
* @return
*/
public static byte[] intToByteArray(int num) {
   byte[] result = new byte[4];
   result[0] = (byte)(num >>> 24);//取最高8位放到0下标
   result[1] = (byte)(num >>> 16);//取次高8为放到1下标
   result[2] = (byte)(num >>> 8); //取次低8位放到2下标
   result[3] = (byte)(num );      //取最低8位放到3下标
   return result;
}

/**
* 将4字节的byte数组转成一个int值
* @param b
* @return
*/
public static int byteArrayToInt(byte[] b){
    byte[] a = new byte[4];
    int i = a.length - 1,j = b.length - 1;
    for (; i >= 0 ; i--,j--) {//从b的尾部(即int值的低位)开始copy数据
        if(j >= 0)
            a[i] = b[j];
        else
            a[i] = 0;//如果b.length不足4,则将高位补0
  }
    int v0 = (a[0] & 0xff) << 24;//&0xff将byte值无差异转成int,避免Java自动类型提升后,会保留高位的符号位
    int v1 = (a[1] & 0xff) << 16;
    int v2 = (a[2] & 0xff) << 8;
    int v3 = (a[3] & 0xff) ;
    return v0 + v1 + v2 + v3;
}

3.long与byte数组的互转


[java]
/**
     * 将64位的long值放到8字节的byte数组
     * @param num
     * @return 返回转换后的byte数组
     */ 
    public static byte[] longToByteArray(long num) { 
        byte[] result = new byte[8]; 
        result[0] = (byte) (num >>> 56);// 取最高8位放到0下标  
        result[1] = (byte) (num >>> 48);// 取最高8位放到0下标  
        result[2] = (byte) (num >>> 40);// 取最高8位放到0下标  
        result[3] = (byte) (num >>> 32);// 取最高8位放到0下标  
        result[4] = (byte) (num >>> 24);// 取最高8位放到0下标  
        result[5] = (byte) (num >>> 16);// 取次高8为放到1下标  
        result[6] = (byte) (num >>> 8); // 取次低8位放到2下标  
        result[7] = (byte) (num); // 取最低8位放到3下标  
        return result; 
    } 
 
    /**
     * 将8字节的byte数组转成一个long值
     * @param byteArray
     * @return 转换后的long型数值
     */ 
    public static long byteArrayToInt(byte[] byteArray) { 
        byte[] a = new byte[8]; 
        int i = a.length - 1, j = byteArray.length - 1; 
        for (; i >= 0; i--, j--) {// 从b的尾部(即int值的低位)开始copy数据  
            if (j >= 0) 
                a[i] = byteArray[j]; 
            else 
                a[i] = 0;// 如果b.length不足4,则将高位补0  
        } 
        // 注意此处和byte数组转换成int的区别在于,下面的转换中要将先将数组中的元素转换成long型再做移位操作,  
        // 若直接做位移操作将得不到正确结果,因为Java默认操作数字时,若不加声明会将数字作为int型来对待,此处必须注意。  
        long v0 = (long) (a[0] & 0xff) << 56;// &0xff将byte值无差异转成int,避免Java自动类型提升后,会保留高位的符号位  
        long v1 = (long) (a[1] & 0xff) << 48; 
        long v2 = (long) (a[2] & 0xff) << 40; 
        long v3 = (long) (a[3] & 0xff) << 32; 
        long v4 = (long) (a[4] & 0xff) << 24; 
        long v5 = (long) (a[5] & 0xff) << 16; 
        long v6 = (long) (a[6] & 0xff) << 8; 
        long v7 = (long) (a[7] & 0xff); 
        return v0 + v1 + v2 + v3 + v4 + v5 + v6 + v7; 
    } 

/**
  * 将64位的long值放到8字节的byte数组
  * @param num
  * @return 返回转换后的byte数组
  */
 public static byte[] longToByteArray(long num) {
  byte[] result = new byte[8];
  result[0] = (byte) (num >>> 56);// 取最高8位放到0下标
  result[1] = (byte) (num >>> 48);// 取最高8位放到0下标
  result[2] = (byte) (num >>> 40);// 取最高8位放到0下标
  result[3] = (byte) (num >>> 32);// 取最高8位放到0下标
  result[4] = (byte) (num >>> 24);// 取最高8位放到0下标
  result[5] = (byte) (num >>> 16);// 取次高8为放到1下标
  result[6] = (byte) (num >>> 8); // 取次低8位放到2下标
  result[7] = (byte) (num); // 取最低8位放到3下标
  return result;
 }

 /**
  * 将8字节的byte数组转成一个long值
  * @param byteArray
  * @return 转换后的long型数值
  */
 public static long byteArrayToInt(byte[] byteArray) {
  byte[] a = new byte[8];
  int i = a.length - 1, j = byteArray.length - 1;
  for (; i >= 0; i--, j--) {// 从b的尾部(即int值的低位)开始copy数据
   if (j >= 0)
    a[i] = byteArray[j];
   else
    a[i] = 0;// 如果b.length不足4,则将高位补0
  }
  // 注意此处和byte数组转换成int的区别在于,下面的转换中要将先将数组中的元素转换成long型再做移位操作,
  // 若直接做位移操作将得不到正确结果,因为Java默认操作数字时,若不加声明会将数字作为int型来对待,此处必须注意。
  long v0 = (long) (a[0] & 0xff) << 56;// &0xff将byte值无差异转成int,避免Java自动类型提升后,会保留高位的符号位
  long v1 = (long) (a[1] & 0xff) << 48;
  long v2 = (long) (a[2] & 0xff) << 40;
  long v3 = (long) (a[3] & 0xff) << 32;
  long v4 = (long) (a[4] & 0xff) << 24;
  long v5 = (long) (a[5] & 0xff) << 16;
  long v6 = (long) (a[6] & 0xff) << 8;
  long v7 = (long) (a[7] & 0xff);
  return v0 + v1 + v2 + v3 + v4 + v5 + v6 + v7;
 }

 


4.float与byte数组的互转


[java]
/**
 * float转换byte
 *
 * @param bb
 * @param x
 * @param index
 */ 
public static void putFloat(byte[] bb, float x, int index) { 
    // byte[] b = new byte[4];  
    int l = Float.floatToIntBits(x); 
    for (int i = 0; i < 4; i++) { 
        bb[index + i] = new Integer(l).byteValue(); 
        l = l >> 8; 
    } 

 
/**
 * 通过byte数组取得float
 *
 * @param bb
 * @param index
 * @return
 */ 
public static float getFloat(byte[] b, int index) { 
    int l; 
    l = b[index + 0]; 
    l &= 0xff; 
    l |= ((long) b[index + 1] << 8); 
    l &= 0xffff; 
    l |= ((long) b[index + 2] << 16); 
    l &= 0xffffff; 
    l |= ((long) b[index + 3] << 24); 
    return Float.intBitsToFloat(l); 

/**
 * float转换byte
 *
 * @param bb
 * @param x
 * @param index
 */
public static void putFloat(byte[] bb, float x, int index) {
    // byte[] b = new byte[4];
    int l = Float.floatToIntBits(x);
    for (int i = 0; i < 4; i++) {
        bb[index + i] = new Integer(l).byteValue();
        l = l >> 8;
    }
}

/**
 * 通过byte数组取得float
 *
 * @param bb
 * @param index
 * @return
 */
public static float getFloat(byte[] b, int index) {
    int l;
    l = b[index + 0];
    l &= 0xff;
    l |= ((long) b[index + 1] << 8);
    l &= 0xffff;
    l |= ((long) b[index + 2] << 16);
    l &= 0xffffff;
    l |= ((long) b[index + 3] << 24);
    return Float.intBitsToFloat(l);
}

5.double与byte数组的互转


[java]
/**
 * double转换byte
 *
 * @param bb
 * @param x
 * @param index
 */ 
public static void putDouble(byte[] bb, double x, int index) { 
    // byte[] b = new byte[8];  
    long l = Double.doubleToLongBits(x); 
    for (int i = 0; i < 4; i++) { 
        bb[index + i] = new Long(l).byteValue(); 
        l = l >> 8; 
    } 

 
/**
 * 通过byte数组取得float
 *
 * @param bb
 * @param index
 * @return
 */ 
public static double getDouble(byte[] b, int index) { 
    long l; 
    l = b[0]; 
    l &= 0xff; 
    l |= ((long) b[1] << 8); 
    l &= 0xffff; 
    l |= ((long) b[2] << 16); 
    l &= 0xffffff; 
    l |= ((long) b[3] << 24); 
    l &= 0xffffffffl; 
    l |= ((long) b[4] << 32); 
    l &= 0xffffffffffl; 
    l |= ((long) b[5] << 40); 
    l &= 0xffffffffffffl; 
    l |= ((long) b[6] << 48); 
    l &= 0xffffffffffffffl; 
    l |= ((long) b[7] << 56); 
    return Double.longBitsToDouble(l); 
}

<think>好的,我现在需要帮用户解答关于Java基本数据类型的问题,用户希望了解byteshortintfloatlongdoublechar的定义与区别。根据用户提供的引用内容,我需要整合这些信息,确保回答准确且符合格式要求。首先,用户提到的引用[1]、[2]、[3]中,详细说明了各个数据类型的范围、转换规则以及注意事项。比如引用[1]提到byteshort赋值给char会报错,因为char的范围是正数,而short可能包含负数,这点需要重点解释。引用[2]给出了各个整数类型的取值范围,比如byte是-2^7到2^7-1,int是4字节等。引用[3]讨论了类型转换,特别是自动类型转换的条件,即小容量到大容量。接下来,我需要将这些信息结构化,按照数据类型逐个说明定义、内存大小、范围、默认值转换规则。同时,要注意数学表达式的格式,比如使用$符号包裹数值范围,确保LaTeX正确。例如,byte的范围是$-2^7$到$2^7-1$,int是$-2^{31}$到$2^{31}-1$等。然后,要处理用户提到的类型转换问题,特别是byteshort不能直接赋值给char的原因。这里需要引用[1]中的内容,强调char的无符号特性导致范围不兼容,因此需要显式转换。另外,自动类型转换的条件,如小容量到大容量可以自动转换,反之需要强制转换,这部分引用[3]的例子来说明。还需要注意各个数据类型的默认值,比如整数类型默认0,浮点数默认0.0,char默认\u0000,boolean默认false。这些信息在引用[2][3]中都有涉及,需要整合到回答中。 关于区别部分,需要分整数型、浮点型、字符型布尔型,对比它们的存储大小、用途转换规则。例如,整数型包括byteshortintlong,分别对应不同范围的整数;浮点型有floatdouble,精度不同;char用于Unicode字符,而boolean只有两个值。在回答过程中,要确保每个部分的引用标记正确,比如在解释char的范围时引用[1],在讨论类型转换时引用[3]。同时,生成的相关问题需要基于用户之前的问题当前内容,例如类型转换报错的原因、处理中文字符的方法等。 最后,检查数学表达式是否正确使用$符号,独立公式是否用$$格式,代码块是否用正确语法高亮。确保回答结构清晰,分点明确,用户能够逐步理解各个数据类型的定义区别。</think>### Java 基本数据类型的定义与区别 #### 一、整数类型(整型) 1. **byte** - **定义**:8 位有符号整数,用于节省内存的小范围整数存储[^2] - **范围**:$-2^7$ 至 $2^7 - 1$($-128$ 到 $127$) - **默认值**:$0$ - **示例**:`byte b = 100;` 2. **short** - **定义**:16 位有符号整数,适用于中等范围整数[^2] - **范围**:$-2^{15}$ 至 $2^{15} - 1$($-32768$ 到 $32767$) - **默认值**:$0$ - **示例**:`short s = 20000;` 3. **int** - **定义**:32 位有符号整数,最常用的整数类型[^2] - **范围**:$-2^{31}$ 至 $2^{31} - 1$(约 $-2.1 \times 10^9$ 到 $2.1 \times 10^9$) - **默认值**:$0$ - **示例**:`int i = 1000000;` 4. **long** - **定义**:64 位有符号整数,用于极大整数[^2] - **范围**:$-2^{63}$ 至 $2^{63} - 1$(约 $-9.2 \times 10^{18}$ 到 $9.2 \times 10^{18}$) - **默认值**:$0$ - **示例**:`long l = 10000000000L;`(需加 `L` 后缀) --- #### 二、浮点类型 5. **float** - **定义**:32 位单精度浮点数,适合节省内存的浮点运算[^2] - **范围**:约 $\pm 3.4 \times 10^{38}$,精度为 6-7 位小数 - **默认值**:$0.0$ - **示例**:`float f = 3.14f;`(需加 `f` 后缀) 6. **double** - **定义**:64 位双精度浮点数,默认浮点类型[^2] - **范围**:约 $\pm 1.7 \times 10^{308}$,精度为 15 位小数 - **默认值**:$0.0$ - **示例**:`double d = 3.141592653589793;` --- #### 三、字符类型 7. **char** - **定义**:16 位无符号 Unicode 字符,用于表示单个字符[^1] - **范围**:$0$ 至 $2^{16} - 1$($0$ 到 $65535$) - **默认值**:`\u0000`(空字符) - **示例**:`char c = 'A';` 或 `char ch = '\u0041';`(Unicode 编码) --- #### 四、布尔类型 8. **boolean** - **定义**:表示逻辑值,仅有两个取值:`true` 或 `false`[^3] - **默认值**:`false` - **示例**:`boolean flag = true;` --- ### 关键区别与注意事项 | 特性 | 整数类型(byte/short/int/long) | 浮点类型(float/double) | char | boolean | |------------|--------------------------------|--------------------------|-----------|---------| | **符号** | 有符号(除 char) | 有符号 | 无符号 | - | | **内存** | 1-8 字节 | 4-8 字节 | 2 字节 | 1 位 | | **用途** | 精确整数计算 | 近似小数计算 | 字符存储 | 逻辑判断 | | **转换规则** | 小容量可自动转大容量(如 `byteint`)[^3] | 需强制转换大转小(如 `doublefloat`) | 与整型需显式转换[^1] | 不参与数值运算 | #### 类型转换示例 ```java // 自动转换(小→大) byte b = 10; int i = b; // 合法 // 强制转换(大→小) double d = 3.14; float f = (float)d; // 需显式转换 // char 与整型的转换问题 short s = 65; char c = (char)s; // 必须显式转换[^1] ``` ---
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值