`
fcm915
  • 浏览: 111087 次
  • 性别: Icon_minigender_1
  • 来自: 泰安
社区版块
存档分类
最新评论

short,int,long与byte数组之间的转换

    博客分类：
  • java
 
阅读更多
  1. package com.test;
  2. import java.nio.ByteBuffer;
  3. public class ByteUtil {
  4.     /**
  5.      * @param args
  6.      */
  7.     public static void main(String[] args) {
  8.         test2();
  9.     }
  10.     public static void test2()
  11.     {
  12.         short s = -20;
  13.         byte[] b = new byte[2];
  14.         putReverseBytesShort(b, s, 0);
  15.         ByteBuffer buf = ByteBuffer.allocate(2);
  16.         buf.put(b);
  17.         buf.flip();
  18.         System.out.println(getReverseBytesShort(b, 0));
  19.         System.out.println(Short.reverseBytes(buf.getShort()));
  20.         System.out.println("***************************");
  21.         int i = -40;
  22.         b = new byte[4];
  23.         putReverseBytesInt(b, i, 0);
  24.         buf = ByteBuffer.allocate(4);
  25.         buf.put(b);
  26.         buf.flip();
  27.         System.out.println(getReverseBytesInt(b, 0));
  28.         System.out.println(Integer.reverseBytes(buf.getInt()));
  29.         System.out.println("***************************");
  30.         long l = -50;
  31.         b = new byte[8];
  32.         putReverseBytesLong(b, l, 0);
  33.         buf = ByteBuffer.allocate(8);
  34.         buf.put(b);
  35.         buf.flip();
  36.         System.out.println(getReverseBytesLong(b, 0));
  37.         System.out.println(Long.reverseBytes(buf.getLong()));
  38.         System.out.println("***************************");
  39.     }
  40.     public static void test1()
  41.     {
  42.         short s = -20;
  43.         byte[] b = new byte[2];
  44.         putShort(b, s, 0);
  45.         ByteBuffer buf = ByteBuffer.allocate(2);
  46.         buf.put(b);
  47.         buf.flip();
  48.         System.out.println(getShort(b, 0));
  49.         System.out.println(buf.getShort());
  50.         System.out.println("***************************");
  51.         int i = -40;
  52.         b = new byte[4];
  53.         putInt(b, i, 0);
  54.         buf = ByteBuffer.allocate(4);
  55.         buf.put(b);
  56.         buf.flip();
  57.         System.out.println(getInt(b, 0));
  58.         System.out.println(buf.getInt());
  59.         System.out.println("***************************");
  60.         long l = -50;
  61.         b = new byte[8];
  62.         putLong(b, l, 0);
  63.         buf = ByteBuffer.allocate(8);
  64.         buf.put(b);
  65.         buf.flip();
  66.         System.out.println(getLong(b, 0));
  67.         System.out.println(buf.getLong());
  68.         System.out.println("***************************");
  69.     }
  70.     public static void putShort(byte b[], short s, int index) {
  71.         b[index] = (byte) (s >> 8);
  72.         b[index + 1] = (byte) (s >> 0);
  73.     }
  74.     public static void putReverseBytesShort(byte b[], short s, int index) {
  75.         b[index] = (byte) (s >> 0);
  76.         b[index + 1] = (byte) (s >> 8);
  77.     }
  78.     public static short getShort(byte[] b, int index) {
  79.         return (short) (((b[index] << 8) | b[index + 1] & 0xff));
  80.     }
  81.     public static short getReverseBytesShort(byte[] b, int index) {
  82.         return (short) (((b[index+1] << 8) | b[index] & 0xff));
  83.     }
  84.     // ///////////////////////////////////////////////////////
  85.     public static void putInt(byte[] bb, int x, int index) {
  86.         bb[index + 0] = (byte) (x >> 24);
  87.         bb[index + 1] = (byte) (x >> 16);
  88.         bb[index + 2] = (byte) (x >> 8);
  89.         bb[index + 3] = (byte) (x >> 0);
  90.     }
  91.     public static void putReverseBytesInt(byte[] bb, int x, int index) {
  92.         bb[index + 3] = (byte) (x >> 24);
  93.         bb[index + 2] = (byte) (x >> 16);
  94.         bb[index + 1] = (byte) (x >> 8);
  95.         bb[index + 0] = (byte) (x >> 0);
  96.     }
  97.     public static int getInt(byte[] bb, int index) {
  98.         return (int) ((((bb[index + 0] & 0xff) << 24)
  99.                 | ((bb[index + 1] & 0xff) << 16)
  100.                 | ((bb[index + 2] & 0xff) << 8) | ((bb[index + 3] & 0xff) << 0)));
  101.     }
  102.     public static int getReverseBytesInt(byte[] bb, int index) {
  103.         return (int) ((((bb[index + 3] & 0xff) << 24)
  104.                 | ((bb[index + 2] & 0xff) << 16)
  105.                 | ((bb[index + 1] & 0xff) << 8) | ((bb[index + 0] & 0xff) << 0)));
  106.     }
  107.     // /////////////////////////////////////////////////////////
  108.     public static void putLong(byte[] bb, long x, int index) {
  109.         bb[index + 0] = (byte) (x >> 56);
  110.         bb[index + 1] = (byte) (x >> 48);
  111.         bb[index + 2] = (byte) (x >> 40);
  112.         bb[index + 3] = (byte) (x >> 32);
  113.         bb[index + 4] = (byte) (x >> 24);
  114.         bb[index + 5] = (byte) (x >> 16);
  115.         bb[index + 6] = (byte) (x >> 8);
  116.         bb[index + 7] = (byte) (x >> 0);
  117.     }
  118.     public static void putReverseBytesLong(byte[] bb, long x, int index) {
  119.         bb[index + 7] = (byte) (x >> 56);
  120.         bb[index + 6] = (byte) (x >> 48);
  121.         bb[index + 5] = (byte) (x >> 40);
  122.         bb[index + 4] = (byte) (x >> 32);
  123.         bb[index + 3] = (byte) (x >> 24);
  124.         bb[index + 2] = (byte) (x >> 16);
  125.         bb[index + 1] = (byte) (x >> 8);
  126.         bb[index + 0] = (byte) (x >> 0);
  127.     }
  128.     public static long getLong(byte[] bb, int index) {
  129.         return ((((long) bb[index + 0] & 0xff) << 56)
  130.                 | (((long) bb[index + 1] & 0xff) << 48)
  131.                 | (((long) bb[index + 2] & 0xff) << 40)
  132.                 | (((long) bb[index + 3] & 0xff) << 32)
  133.                 | (((long) bb[index + 4] & 0xff) << 24)
  134.                 | (((long) bb[index + 5] & 0xff) << 16)
  135.                 | (((long) bb[index + 6] & 0xff) << 8) | (((long) bb[index + 7] & 0xff) << 0));
  136.     }
  137.     public static long getReverseBytesLong(byte[] bb, int index) {
  138.         return ((((long) bb[index + 7] & 0xff) << 56)
  139.                 | (((long) bb[index + 6] & 0xff) << 48)
  140.                 | (((long) bb[index + 5] & 0xff) << 40)
  141.                 | (((long) bb[index + 4] & 0xff) << 32)
  142.                 | (((long) bb[index + 3] & 0xff) << 24)
  143.                 | (((long) bb[index + 2] & 0xff) << 16)
  144.                 | (((long) bb[index + 1] & 0xff) << 8) | (((long) bb[index + 0] & 0xff) << 0));
  145.     }
  146. }
分享到：
| Validator.js 很好用的客户端表单验证
评论
2 楼 fcm915 2010-11-17  
你有什么高见？
1 楼 徐风子 2010-11-11  
都09年了，你还在main里面写测试呀。

不过java也挺操蛋的，居然没提供自带的int 到 byte[]  的转换工具。
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    java基本类型与byte数组互相转换.pdf

    Java 中的基本类型与 byte 数组之间的转换是非常重要的，以下是关于 Java 基本类型与 byte 数组互相转换的相关知识点： 1. short 类型转换成 byte 数组 在 Java 中，short 类型是 16 位的整数类型，而 byte 数组是...

    java基本类型与byte数组互相转换.doc

    例如，我们可以将byte数组转换为short类型、int类型、long类型、float类型、double类型、char类型等。这种转换可以使用相应的构造函数或方法来实现。 在Java编程中，将基本类型转换为byte数组或将byte数组转换为...

    java基本类型与byte数组互相转换文.pdf

    这些基本类型可以相互转换，例如将 short 类型转换成 byte 数组、int 类型转换成 byte 数组等。 在 Java 中，基本类型可以使用 bitwise 运算符来实现与 byte 数组的转换。例如，将 short 类型转换成 byte 数组可以...

    Java byte数组与其他类型转换

    本文将深入探讨如何在Java中将byte数组与其他基本类型（如short、int、long）进行转换，这些转换在处理二进制数据、网络通信或序列化等方面至关重要。 首先，我们来看byte数组与short之间的转换。在Java中，byte...

    java基本类型与byte数组互相转换

    在Java编程语言中，基本类型的变量（如`short`、`int`、`long`、`char`、`double`和`float`）和`byte`数组之间的相互转换是一项非常实用的技术，尤其是在网络通信、文件读写等场景下。下面将详细介绍如何进行这些...

    java整数与byte数组的转换实现代码

    在Java中，整数可以分为多种类型，如int、long、short等，每种类型都有其对应的byte数组长度。例如，int类型的整数可以转换为4字节的byte数组，而long类型的整数可以转换为8字节的byte数组。 在上面的代码中，我们...

    java数据类型转byte数组

    ip地址转4字节byte，char转2字节byte，byte数组转char，int整数转换为4字节的byte数组，byte数组转换为int整数，double类型转8字节数组，8位数组转double，long整数转换为8字节的byte数组，short整数转换为2字节的...

    java byte数组与int,long,short,byte的转换实现方法

    本文将详细介绍如何在Java中将`byte`数组与其他基本数据类型（如`int`、`long`、`short`、`byte`）之间进行转换。 首先，我们来看`byte`到`int`的转换。Java中的`byte`类型是8位的，取值范围是-128到127。如果要将...

    java实现的字节数组转换成基本类型，基本类型转换成byte[]

    char short int long float double 转换成byte数组

    int、char、double与byte类型之间相互转换

    ### 二、byte数组转换为int类型 #### 方法：byteToInt() 此方法接收一个byte数组作为参数，并将其转换回int类型。 ```java public static int byteToInt(byte[] b) { int s = 0; for (int i = 0; i ; i++) { if ...

    java基本类型与byte数组互相转换.rar

    原始类型包括整型（如byte、short、int、long）、浮点型（如float、double）、字符型（char）以及布尔型（boolean）。这些类型的数据可以直接在内存中存储值，而无需创建对象。然而，在某些场景下，我们可能需要将...

    Java基本类型与byte数组之间相互转换方法

    上述代码提供了一些静态方法，用于在基本类型与byte数组之间进行转换。我们逐一分析这些方法： 1. `getBytes(short data)` 和 `getShort(byte[] bytes)` - 这两个方法处理short类型。`getBytes(short data)` 将...

    java对象转成byte数组的3种方法

    java 对象转换为 byte 数组的 3 种方法 在 Java 中，将对象转换为 byte 数组是一种常见的操作，特别是在使用 Netty 进行通信协议传输的场景中。那么，如何方便地将一个 Java 对象构造成一个 byte 数组呢？ 方法 1...

    java_android_类型转换工具类的标准代码

    byte数组转换为int 保留几位小数 null转String String转Byte String转Boolean String转Int String转Short String转Double Int转String Double转Long Double转Int Long转Double Long转Int String转Long Long转String

    java 举例分析 equals hashcode 基本类型与基本对象的比较 shot与Short int与Integer long与Long

    举例分析 equals 和 hashcode 方法，hashcode应该怎么样生成 8个基本类型与基本对象的比较：byte与Byte shot与Short int与Integer long与Long float与Float double与Double char与Character

    ByteConvert_arduino:Arduino的库，可将变量转换为字节并返回

    字节转换什么事啊您是否曾经想过通过I2C，SPI，串行或其他协议或总线传输int ， short ， long ， double或任何其他数字类型，但是您已将变量转换为字符串以能够按char进行传输。 该库使您可以将任何数值转换为字节...

    long 和 int 的相互转换.docx

    原始数据类型包括byte、short、int、long、float、double、char和boolean，而引用数据类型则包括类(class)、接口(interface)和数组。在处理数值计算时，我们可能需要在不同数据类型之间进行转换，特别是当涉及到long...

    Java整型数与网络字节序byte[]数组转换关系详解

    "Java整型数与网络字节序byte[]数组转换关系详解" 本文主要介绍了Java整型数与网络字节序byte[]数组之间的转换关系，包括整型数到byte[]数组的转换和byte[]数组到整型数的转换。这些转换关系在Java和C/C++之间的...

    数据类型转换

    float、double等类型与byte数组相互转换，根据数据类型的位数不同，对应的数组大小也不同、例如int32位，4个字节，则需要大小为4的byte数组来进行转换，详情请看代码，里面有转换的实现和详细的注释

Magicbox
Global site tag (gtag.js) - Google Analytics