精华内容
下载资源
问答
  • Java字节数组byte b[]与byte[] b

    千次阅读 2020-12-25 15:16:06
    Java字节数组仅用于存储字节数据类型值。字节数组中元素的默认值为0。 通过以下Java字节数组示例,您可以学习 如何声明Java字节数组? 如何为Java字节数组分配值? 如何从Java字节数组获取值? 如何在Java中将...

    Java中的字节数组

    Java字节数组仅用于存储字节数据类型值。字节数组中元素的默认值为0。

    通过以下Java字节数组示例,您可以学习

    • 如何声明Java字节数组?
    • 如何为Java字节数组分配值?
    • 如何从Java字节数组获取值?
    • 如何在Java中将String转换为字节数组?
    • 如何在Java中将字节数组转换为字符串?

    什么是字节?

    一组二进制数字或位(通常是八个)作为一个单元进行操作。一个字节,视为内存大小的单位。

    字节是数字信息的单位,通常由八位组成。从历史上看,字节是计算机中用于编码文本的单个字符的位数,因此,它是许多计算机体系结构中最小的可寻址存储单元。

    字节是一个数据测量单位,它包含八个位或一系列八个零和一。一个字节可用于表示2个8或256个不同的值。

    字节在Java中是什么意思?

    字节是Java中原始数据类型之一。这意味着Java字节的大小与计算机内存中的字节相同:它是8位,并且可以保存-128到127的值。字节数据类型以Java编程语言打包提供,无需特殊操作即可使其工作。

     
    分享此页面: 

    字节数组是什么意思?

    字节为8位(二进制数据)。

    字节数组是字节数组。

    您可以使用字节数组来存储二进制数据的集合,例如文件的内容。不利之处是必须将整个文件内容加载到内存中。

    Java中一个字节多少位?

    该字节在Java中等于8位。

    byte是Java中的关键字吗?

    字节是Java中的关键字,它指定8位带符号整数基元类型。

    标准Java整数数据类型以字节为单位:

    • 字节1字节-128至127
    • 短2字节-32768至32767
    • int 4字节-2147483648至2147483647
    • 长8字节-9223372036854775808至9223372036854775807
     
     
     

    如何在Java中声明字节数组?

    数组用[]声明(方括号)。如果将[](方括号)放在任何类型的任何变量之后,则仅该变量属于数组类型,而该声明中的其余变量不是属于该类型普通变量的数组变量。

    如果将[](方括号)放在任何数据类型之后,则该声明中的所有变量都是数组变量。数组中的所有元素都可以通过index访问。数组元素索引从0到n-1个数字开始,即,如果数组有5个元素,则开始索引为0,结束索引为4。

    // Java bytearray
    //声明字节数组
    byte [] byteArray;

    如何在Java中初始化(init)字节数组(byte [])?

    分配字节数组时,会将其初始化(init)为0。Java中的所有数组都初始化为type的默认值。这意味着将整数数组初始化为0,将布尔数组初始化为false,将引用类型数组初始化为null。

    如何初始化字节数组示例

    // Java bytearray
    //如何在Java
    byte []中初始化字节数组或byte [] byteArray = new byte [10];

    Java中字节数组的初始值或默认值是多少?

    字节数组的初始值为0。因为Java中字节数据类型的默认值为0。

    Java中字节数组的长度是多少?

    长度是Java中数组对象的属性,它返回给定数组中元素的数量。

    Java中字节数组的最大长度是多少?

    Java中字节数组的最大长度为2147483647。您最多可以存储2147483647个元素。

     

    Java中数组的长度是多少?

    在Java中,所有数组仅由int索引和声明。那就是数组的大小必须由一个int值指定,而不是long或short。所有数组索引从0开始到2147483646结束。您最多可以存储2147483647个元素。如果尝试将长(大)元素存储在数组中,则会遇到性能问题。如果您克服了性能问题,则应使用Java集合框架或简单地使用Vector

    句法 :

    < data type > < variable >[];
    < data type >[] < variable >;

    Java字节数组示例

    /*  Java byte Array Example
         Save with file name ByteArray.java  */
       
    public class ByteArray
    {
       public static void main(String args[])
       {
         //JAVA BYTE ARRAY DECLARATION
         byte b[];
         //MEMORY ALLOCATION FOR JAVA BYTE ARRAY
         b = new byte [ 4 ];
         //ASSIGNING ELEMENTS TO JAVA BYTE ARRAY
         b[ 0 ] = 20 ;
         b[ 1 ] = 10 ;
         b[ 2 ] = 30 ;
         b[ 3 ] = 5 ;
         //BYTE ARRAY OUTPUT
         System.out.println( "Java byte Array Example" );
         for ( int i= 0 ;i<b.length;i++)
         {
           System.out.println( "Element at Index : " + i + " " + b[i]);
         }
       }
    }

    在Java字节数组示例中,您可以学习如何在声明时将值分配给Java字节数组。

    声明时如何为Java字节数组分配值

    /*  How to assign values to java byte array at the time of declaration Example
         Save with file name ByteArray2.java */
       
    public class ByteArray2
    {
       public static void main(String args[])
       {
         //JAVA BYTE ARRAY DECLARATION AND ASSIGNMENT
         byte b[] = { 20 , 10 , 30 , 5 };
         //JAVA BYTE ARRAY OUTPUT
         System.out.println( "Java byte Array Example" );
         for ( int i= 0 ;i<b.length;i++)
         {
           System.out.println( "Element at Index : " + i + " " + b[i]);
         }
       }
    }

    在Java字节数组示例之后,您可以学习如何使用其他Java字节数组变量声明Java字节数组。

    如何使用其他Java字节数组变量声明Java字节数组

    /*  How to declare Java byte array with other Java byte array variables Example
         Save with file name ByteArray3.java */
       
    public class ByteArray3
    {
       public static void main(String args[])
       {
         //JAVA BYTE ARRAY DECLARATION
         byte b[], a; //b IS AN ARRAY a IS NOT AN ARRAY
         //MEMORY ALLOCATION FOR JAVA BYTE ARRAY
         b = new byte [ 4 ];
         //ASSIGNING ELEMENTS TO JAVA BYTE ARRAY
         b[ 0 ] = 20 ;
         b[ 1 ] = 10 ;
         b[ 2 ] = 30 ;
         b[ 3 ] = 5 ;
         a = 100 ;
         //JAVA BYTE ARRAY OUTPUT
         System.out.println( "Java byte Array Example" );
         System.out.println( "a value is : " +a);
         for ( int i= 0 ;i<b.length;i++)
         {
           System.out.println( "Element at Index : " + i + " " + b[i]);
         }
       }
    }

    在Java字节数组示例之后,您可以学习如何将Java字节数组分配给其他Java字节数组。

    如何将Java字节数组分配给其他Java字节数组

    /*  How to assign Java byte array to other Java byte array Example
         Save with file name ByteArray4.java */
       
    public class ByteArray4
    {
       public static void main(String args[])
       {
         //JAVA BYTE ARRAY DECLARATION
         byte [] a, b; //a AND b ARE ARRAY VARIABLES
         //MEMORY ALLOCATION FOR JAVA BYTE ARRAY
         b = new byte [ 4 ];
         //ASSIGNING ELEMENTS TO JAVA BYTE ARRAY
         b[ 0 ] = 20 ;
         b[ 1 ] = 10 ;
         b[ 2 ] = 30 ;
         b[ 3 ] = 5 ;
         //ASSIGNING b ARRAY TO a ARRAY VARIABLE
         a = b;
         //JAVA BYTE ARRAY OUTPUT
         System.out.println( "Java byte Array Example" );
         System.out.println( "b array values" );
         for ( int i= 0 ;i<b.length;i++)
         {
           System.out.println( "Element at Index : " + i + " " + b[i]);
         }
         System.out.println( "a array values" );
         for ( int i= 0 ;i<b.length;i++)
         {
           System.out.println( "Element at Index : " + i + " " + a[i]);
         }
       }
    }
     
     

    Java将字符串转换为字节[]

    我们可以通过两种方式将String转换为byte []。

    1. 通过使用String.getBytes()方法
    2. 通过在Java 8中使用Base64类

    如何在Java中将String转换为字节数组?

    若要从String转换为字节数组,请使用String.getBytes()方法。请注意,此方法使用平台的默认字符集。

    我们可以使用String类的getBytes()方法使用平台的默认charset将字符串编码为字节序列。此方法已重载,我们也可以将Charset作为参数传递。

    以下程序显示了如何在java中将String转换为字节数组。

    如何在Java中将String转换为字节数组?

    /*  How to convert String to byte array in Java Example
         Save with file name StringToByteArray.java */
      
    import java.util.Arrays;
      
    // Convert String to byte array in Java
    public class StringToByteArray
    {
       public static void main(String[] args)
       {
         String str = " convert String to byte Array in Java " ;
         byte [] bytearray = str.getBytes();
         System.out.println(Arrays.toString(bytearray));
       }
    }

    如何在Java 8中将String转换为字节数组?

    要在Java 8中从String转换为字节数组,请使用Base64.getDecoder()。decode()方法。Base64.getDecoder()。decode()方法将字符串转换为字节数组。Base64类自Java 1.8开始,因此此代码在Java 1.8之前不起作用。

    以下程序显示了如何在Java 8中将String转换为字节数组。

    如何在Java 8中将String转换为字节数组?

    /*  How to convert String to byte array in Java 8 Example
         Save with file name StringToByteArrayJava8.java */
    import java.util.Arrays;
    import java.util.Base64;
      
    // Convert String to byte array in Java 8
    public class StringToByteArrayJava8
    {
       public static void main(String[] args)
       {
         String str = " convert String to byte Array in Java " ;
         byte [] bytearray = Base64.getDecoder().decode(str);
         System.out.println(Arrays.toString(bytearray));
       }
    }
     

    如何在Java中将字节数组转换为字符串?

    我们可以通过两种方式将字节数组转换为String。

    1. 没有字符编码。
    2. 具有字符编码。
    3. 通过在Java 8中使用Base64类

    如何在不使用字符编码的Java中将字节数组转换为字符串?

    我们甚至可以不指定字符编码就将字节数组转换为String。只需将字节数组传递给String构造函数即可。

    如何在不使用字符编码的Java中将字节数组转换为字符串?

    /*  How to convert a byte Array to String in Java
         without character encoding Example
         Save with file name ByteArrayToString.java */
    import java.io.IOException;
    import java.util.Arrays;
      
    // Convert a byte array to String in Java
    public class ByteArrayToString
    {
       public static void main(String[] args) throws IOException
       {
      
         byte [] bytes = " convert a byte Array to String in Java without character encoding " .getBytes();
          System.out.println(Arrays.toString(bytes));
      
         // Create a string from the byte array
         // without specifying character encoding
         String string = new String(bytes);
         System.out.println(string);
       }
    }
     
     

    如何在Java中使用字符编码将字节数组转换为字符串?

    我们可以使用UTF-8字符编码将字节数组转换为String。

    如何在Java中使用字符编码将字节数组转换为字符串?

    /*  How to convert a byte Array to String in Java
         with character encoding Example
         Save with file name ByteArrayToString2.java */
    import java.io.IOException;
    import java.nio.charset.StandardCharsets;
      
    // Convert a byte array to String in Java
    class ByteArrayToString2
    {
       public static void main(String[] args) throws IOException
       {
         byte [] bytes = " convert a byte Array to String in Java with UTF-8 character encoding " .getBytes(StandardCharsets.UTF_8);
      
         // Create a string from the byte array with "UTF-8" encoding
         String str = new String(bytes, StandardCharsets.UTF_8);
         System.out.println(str);
       }
    }

    如何在Java 8中将字节数组转换为String?

    要将Java 8中的字节数组转换为String,请使用Base64.getEncoder()。encodeToString()方法。Base64.getEncoder()。encodeToString()方法将字节数组转换为String。Base64类自Java 1.8开始,因此此代码在Java 1.8之前不起作用。

    以下程序显示了如何在Java 8中将字节数组转换为String。

    如何在Java 8中将字节数组转换为String?

    /*  How to convert byte array to String in Java 8 Example
         Save with file name ByteArrayToStringJava8.java */
    import java.util.Arrays;
    import java.util.Base64;
      
    // Convert byte array String in Java 8
    public class ByteArrayToStringJava8
    {
       public static void main(String[] args)
       {
          
         byte [] bytearray = " convert byte Array to String in Java 8 " .getBytes();
         String str = Base64.getEncoder().encodeToString(bytearray);
         System.out.println(str);
       }
    }
     

    Java中的ByteBuffer是什么?

    字节缓冲区可以是direct或non-direct。给定直接字节缓冲区,Java虚拟机将尽最大努力直接在其上执行本机I / O操作。也就是说,它将尝试避免在每次调用底层操作系统的本机I / O操作之前(或之后)将缓冲区的内容复制到中间缓冲区(或从中间缓冲区复制)。

    java.nio.ByteBuffer类的allocate()方法用于分配新的字节缓冲区。

    新缓冲区的位置将为零,其极限将是其容量,其标记将是未定义的,并且其每个元素都将初始化为零。它将有一个支持数组,并且其数组偏移量将为零。

    如何将Java整数转换为字节数组?

    我们将讨论将int转换为字节数组的各种方法。在java int中,数据类型占用4个字节(32位),范围是-2147483648至2147483647。

    您可以使用Java NIO的ByteBuffer将Java整数转换为字节数组,这非常简单。下面的示例演示如何将Java整数转换为字节Array。

    如何将Java整数转换为字节数组?

    /*  How to convert Java integer to byte Array Example
         Save with file name IntToByteArray.java */
    import java.nio.ByteBuffer;
      
    // Convert integer to byte array
    public class IntToByteArray
    {
       public static void main(String[] args)
       {
         byte [] bytes = ByteBuffer.allocate( 4 ).putInt( 1695609641 ).array();
      
         for ( byte b : bytes)
         {
           System.out.format( "0x%x " , b);
         }
       }
    }
     
     

    如何将Java字节数组转换为long?

    Java提供了ByteBuffer类来做同样的事情。要转换任何字节数组,首先需要使用ByteBuffer的静态方法allocate分配8个字节,然后使用put方法放置byteArray并通过调用getLong()方法翻转字节缓冲区,我们可以获取该字节数组的long值。

    您可以使用Java NIO的ByteBuffer将Java字节数组转换为long,这非常简单。

    如何将Java字节数组转换为long?

    /*  How to convert Java byte Array to long Example
         Save with file name ByteArrayToLong.java */
    import java.nio.ByteBuffer;
      
    // Convert byte array to long
    public class ByteArrayToLong
    {
       public static void main(String[] args)
       {
         byte [] bytes = { 0 , 6 , 36 , - 84 , 113 , 125 , - 118 , - 47 };
         System.out.println(ByteBuffer.wrap(bytes).getLong());
         System.out.println(convertByteArrayToLong(bytes));
       }
       public static long convertByteArrayToLong( byte [] longBytes)
       {
         ByteBuffer byteBuffer = ByteBuffer.allocate(Long.BYTES);
         byteBuffer.put(longBytes);
         byteBuffer.flip();
         return byteBuffer.getLong();
       }
    }

    如何在Java中将对象转换为字节数组?

    1. 通过实现Serializable接口使所需的对象可序列化。
    2. 创建一个ByteArrayOutputStream对象。
    3. 通过传递在上一步中创建的ByteArrayOutputStream对象来创建ObjectOutputStream对象。
    4. 使用ObjectOutputStream类的writeObject()方法将对象的内容写入输出流。
    5. 使用flush()方法将内容刷新到流中。
    6. 最后,使用toByteArray()方法将ByteArrayOutputStream的内容转换为字节数组。

    下面的示例演示如何将对象转换为字节数组。准备要发送的字节数组:

    如何在Java中将对象转换为字节数组?

    /*  How to convert an object to byte array Example
         Save with file name ObjectToByteArray.java */
    import java.io.ByteArrayOutputStream;
    import java.io.ObjectOutputStream;
    import java.io.Serializable;
    import java.io.IOException;
      
    // Convert an object to byte array
    public class ObjectToByteArray
    {
       public static void main(String[] args)
       {
         Sample yourObject = null ;
         ByteArrayOutputStream bos = null ;
         ObjectOutputStream out = null ;
         try
         {
           yourObject = new Sample();
           bos = new ByteArrayOutputStream();
           out = new ObjectOutputStream(bos);
           out.writeObject(yourObject);
           out.flush();
           byte [] yourBytes = bos.toByteArray();
         }
         catch (Exception e)
         {
           // handle exception here.
         }
         finally
         {
           try
           {
             bos.close();
           } catch (IOException ex)
           {
             // ignore close exception
           }
         }
       }
    }
      
    class Sample implements Serializable
    {
       public void display()
       {
         System.out.println( "This is a sample class" );
       }
    }
     

    如何使用Java将byte [](数组)转换为文件?

    “ hello” .getBytes(); 使用平台的默认字符集将给定的String编码为字节序列,该字符集将结果存储到新的byte数组中。

    new File(“ c:\\ demo.txt”)通过将给定的路径名​​字符串转换为抽象路径名来创建一个新的File实例。

    new FileOutputStream(file)创建一个文件输出流,以写入指定File对象表示的文件。

    os.write(bytes)将指定字节数组中的字节数写入输出stream。

    下面的示例演示如何将byte [](数组)转换为File。

    如何使用Java将byte [](数组)转换为文件?

    /*  How to convert byte array to File Example
         Save with file name ByteArrayToFile.java */
    import java.io.BufferedReader;
    import java.io.File;
    import java.io.FileOutputStream;
    import java.io.FileReader;
    import java.io.OutputStream;
      
    // Convert byte array to File
    public class ByteArrayToFile
    {
       public static void main(String[] args)
       {
         byte [] bytes = "hello" .getBytes();
         File file = new File( "c:\\demo.txt" );
         try
         {
           OutputStream os = new FileOutputStream(file);
           os.write(bytes);
           System.out.println( "Write bytes to file." );
           printContent(file);
           os.close();
         }
         catch (Exception e)
         {
           e.printStackTrace();
         }
       }
       public static void printContent(File file) throws Exception
       {
         System.out.println( "Print File Content" );
         BufferedReader br = new BufferedReader( new FileReader(file));
         String line = null ;
         while ((line = br.readLine()) != null )
         {
           System.out.println(line);
         }
         br.close();
       }
    }

     

     

    展开全文
  • java是属于大端字节... * 比如字节数组转int,和int转字节数组 * java是属于大端字节序的,也就是高位放在低地址处 * 所有的操作都是针对的大端字节序 */ public class ByteUtils { private static String h...

    java是属于大端字节序列,以下的代码都是基于大端字节序列给出的。

     

    /**
     * 主要用于执行字节数组和基本数据类型之间的互相转换
     * 比如字节数组转int,和int转字节数组
     * java是属于大端字节序的,也就是高位放在低地址处
     * 所有的操作都是针对的大端字节序
     */
    public class ByteUtils {
    
        private static String hexStr =  "0123456789ABCDEF";
        private static String[] binaryArray =
                {"0000","0001","0010","0011",
                        "0100","0101","0110","0111",
                        "1000","1001","1010","1011",
                        "1100","1101","1110","1111"};
    
    
        /**
         * 字节数组转short
         * @param bytes 需要转换的字节数组
         * @return short
         */
        public static short byteArrToShort(byte[] bytes){
            int FF = 0xff;
            int first = (bytes[0] & FF) << 8;
            short result = (short) (first | (bytes[1] & FF));
            return result;
            //可以直接return (short) ((bytes[0] << 8) | bytes[1]);
            //之所以向上面那么写,是为了方便看的清楚
        }
    
        /**
         * short转字节数组
         * @param value 待转换的short
         * @return 字节数组
         */
        public static byte[] shortToByteArr(short value){
            byte highByte = (byte) (value >> 8);//获取高位的字节
            byte lowByte = (byte) value;//获取低位的字节
            byte[] result = new byte[2];
            result[0] = highByte;
            result[1] = lowByte;
            return result;
        }
    
        /**
         * 字节数组转int
         * @param bytes 待转换的字节数组
         * @return 转换之后的int
         */
        public static int byteArrToInt(byte[] bytes){
            int FF = 0xff;
            //假设字节数组 05 0A 07 04
            int h1 = (bytes[0] & FF) << 24;//左移24位之后,h1为05 00 00 00
            int h2 = (bytes[1] & FF) << 16;//左移16位之后,h2为00 0A 00 00
            int h3 = (bytes[2] & FF) << 8;//左移8位之后,h3为00 00 07 00
            int h4 = bytes[3] & FF;//h4为00 00 00 04
            int result = h1 | h2 | h3 | h4;
            return result;
        }
    
        /**
         * int转字节数组
         * @param value 待转换的int
         * @return 转换之后的字节数组
         */
        public static byte[] intToByteArr(int value){
            //假设原来的int的16进制为 05 0A 07 04
            byte[] bytes = new byte[4];
            bytes[0] = (byte) (value >> 24);//右移24位之后,返回值00 00 00 05,强转之后变成05
            bytes[1] = (byte) (value >> 16);//右移16位之后,返回值00 00 05 0A,强转之后变成0A
            bytes[2] = (byte) (value >> 8);//右移8位之后,返回值00 05 0A 07,强转之后变成07
            bytes[3] = (byte) value;
            return bytes;
        }
    
        /**
         * 把字节数组转换成long
         * 这个的处理手法和前面和int和short都有一点差异
         * @param bytes 待转换的字节数组
         * @return 转换之后的long
         */
        public static long byteArrToLong(byte[] bytes){
            long FF = 0xff;
            //假设字节数组为08 0A 01 03 05 07 02 0B
            long b0 = bytes[0] & FF;//00 00 00 00 00 00 00 08
            long h0 = b0 << 56;//08 00 00 00 00 00 00 00
            long b1 = bytes[1] & FF;//00 00 00 00 00 00 00 0A
            long h1 = b1 << 48;//00 0A 00 00 00 00 00 00
            long b2 = bytes[2] & FF;
            long b3 = bytes[3] & FF;
            long b4 = bytes[4] & FF;
            long b5 = bytes[5] & FF;
            long b6 = bytes[6] & FF;
            long b7 = bytes[7] & FF;
            long h2 = b2 << 40;
            long h3 = b3 << 32;
            long h4 = b4 << 24;
            long h5 = b5 << 16;
            long h6 = b6 << 8;
            long h7 = b7;
            return h0 | h1 | h2 | h3 | h4 | h5 | h6 | h7;
        }
    
        /**
         * long转换成字节数组
         * @param value 待转换的long
         * @return 转换之后的字节数组
         */
        public static byte[] longToByteArr(long value){
            //假设待转换的long为08 0A 01 03 05 07 02 0B
            byte[] bytes = new byte[8];
            bytes[0] = (byte) (value >> 56);//右移之后,00 00 00 00 00 00 00 08,强转之后08
            bytes[1] = (byte) (value >> 48);//右移之后,00 00 00 00 00 00 08 0A,强转之后0A
            bytes[2] = (byte) (value >> 40);//右移之后,00 00 00 00 00 08 0A 01,强转之后01
            bytes[3] = (byte) (value >> 32);
            bytes[4] = (byte) (value >> 24);
            bytes[5] = (byte) (value >> 16);
            bytes[6] = (byte) (value >> 8);
            bytes[7] = (byte) value;
            return bytes;
        }
    
        /**
         * 将字节数组转换成float
         * @param bytes 待转换的字节数组
         * @return 转换之后的float
         */
        public static float byteArrToFloat(byte[] bytes){
            int FF = 0xff;
            //假设字节数组 05 0A 07 04
            int b0 = bytes[0] & FF;// 00 00 00 05
            int b1 = bytes[1] & FF;// 00 00 00 0A
            int b2 = bytes[2] & FF;
            int b3 = bytes[3] & FF;
            int h0 = b0 << 24;// 05 00 00 00
            int h1 = b1 << 16;// 00 0A 00 00
            int h2 = b2 << 8;
            int h3 = b3;
            int h = h0 | h1 | h2 | h3;
            return Float.intBitsToFloat(h);
        }
    
    
        /**
         * float转字节数组
         * @param value 待转换的float
         * @return 转换之后的字节数组
         */
        public static byte[] floatToByteArr(float value){
            int i = Float.floatToIntBits(value);
            byte[] bytes = new byte[4];
            bytes[0] = (byte) (i >> 24);
            bytes[1] = (byte) (i >> 16);
            bytes[2] = (byte) (i >> 8);
            bytes[3] = (byte) (i);
            return bytes;
        }
    
        /**
         * 将字节数组转换成double
         * @param bytes 待转换的字节数组
         * @return 转换出来的double
         */
        public static double byteArrToDouble(byte[] bytes){
            //假设待转换的字节数组为05 0A 07 04 0B 00 03 01
            long FF  = 0xFF;
            long b0 = bytes[0] & FF;// 00 00 00 00 00 00 00 05
            long b1 = bytes[1] & FF;// 00 00 00 00 00 00 00 0A
            long b2 = bytes[2] & FF;
            long b3 = bytes[3] & FF;
            long b4 = bytes[4] & FF;
            long b5 = bytes[5] & FF;
            long b6 = bytes[6] & FF;
            long b7 = bytes[7] & FF;
            long h0 = b0 << 56;// 05 00 00 00 00 00 00 00
            long h1 = b1 << 48;// 00 0A 00 00 00 00 00 00
            long h2 = b2 << 40;
            long h3 = b3 << 32;
            long h4 = b4 << 24;
            long h5 = b5 << 16;
            long h6 = b6 << 8;
            long h7 = b7;
            long h = h0 | h1 | h2 | h3 | h4 | h5 | h6 | h7;
            return Double.longBitsToDouble(h);
        }
    
        /**
         * 将double转换成字节数组
         * @param value 待转换的double
         * @return 转换之后的字节数组
         */
        public static byte[] doubleToByteArr(double value){
            long lbits = Double.doubleToLongBits(value);
            byte[] bytes = new byte[8];
            bytes[0] = (byte) (lbits >> 56);
            bytes[1] = (byte) (lbits >> 48);
            bytes[2] = (byte) (lbits >> 40);
            bytes[3] = (byte) (lbits >> 32);
            bytes[4] = (byte) (lbits >> 24);
            bytes[5] = (byte) (lbits >> 16);
            bytes[6] = (byte) (lbits >> 8);
            bytes[7] = (byte) (lbits);
            return bytes;
        }
    
    
        /**
         * 将字节数组转换成十六进制字符串
         * @param bytes 待转换的字节数组
         * @return 转换之后的十六进制字符串
         */
        public static String bytesToHexStr(byte[] bytes) {
    
            String result = "";
            String hex = "";
            int F0 = 0xF0;
            int ZeroF = 0x0F;
            for (int i = 0; i < bytes.length; i++) {
                //字节高4位
                hex = String.valueOf("0123456789ABCDEF".charAt((bytes[i] & F0) >> 4));
                //字节低4位
                hex += String.valueOf("0123456789ABCDEF".charAt(bytes[i] & ZeroF));
                result += hex;
            }
            return result;
        }
    
        /**
         * 将16进制转换成二进制字节数组,注意16进制不要输入0x,只需输入ff,不要输入成0xff
         * @param hexString 带转换的十六进制字符串
         * @return 转换之后的字节数组
         */
        public static byte[] hexStringToBytes(String hexString) {
            if (hexString == null || hexString.equals("")) {
                return null;
            }
            hexString = hexString.toUpperCase();
            int length = hexString.length() / 2;
            char[] hexChars = hexString.toCharArray();
            byte[] d = new byte[length];
            for (int i = 0; i < length; i++) {
                int pos = i * 2;
                d[i] = (byte) (charToByte(hexChars[pos]) << 4 | charToByte(hexChars[pos + 1]));
            }
            return d;
        }
    
        public static byte charToByte(char c) {
            return (byte) "0123456789ABCDEF".indexOf(c);
        }
    
    
    
        /**
         * 二进制数组转换为二进制字符串   2-2
         */
        public static String bytesToBinStr(byte[] bArray) {
            String outStr = "";
            int pos = 0;
            for (byte b : bArray) {
                //高四位
                pos = (b & 0xF0) >> 4;
                outStr += binaryArray[pos];
                //低四位
                pos = b & 0x0F;
                outStr += binaryArray[pos];
            }
            return outStr;
        }
    
        /**
         * 将十六进制字符串转换为二进制字符串
         */
        public static String hexStr2BinStr(String hexString){
            return bytesToBinStr(hexStringToBytes(hexString));
        }
    
    }
    

     

    展开全文
  • java字节数组转File返回File对象

    千次阅读 2020-03-28 13:12:01
    public static File bytesToFile(byte[] bytes, String fileType) throws IOException { return FileUtils.createTmpFile(new ByteArrayInputStream(bytes), UUID.randomUUID().toString(), fileType);...
     <dependency>
         <groupId>commons-io</groupId>
         <artifactId>commons-io</artifactId>
         <version>2.6</version>
     </dependency>
    
    public class MyFileUtil {
    
        public static File createTmpFile(InputStream inputStream, String name, String ext, File tmpDirFile) throws IOException {
            File resultFile = File.createTempFile(name, '.' + ext, tmpDirFile);
            resultFile.deleteOnExit();
            FileUtils.copyToFile(inputStream, resultFile);
            return resultFile;
        }
    
        public static File bytesToFile(byte[] bytes, String fileType) throws IOException {
            return createTmpFile(new ByteArrayInputStream(bytes),
                    UUID.randomUUID().toString(),
                    fileType,
                    Files.createTempDirectory("tempFile").toFile());
        }
        
    	public static void main(String[] args) {
            File file = null;
            try {
                file = MyFileUtil.bytesToFile(new byte[1024], "jpg");
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                if (file != null) {
                    file.delete();
                }
            }
        }
    }
    
    展开全文
  • Java 对象字节数组相互转换

    千次阅读 2017-11-10 18:17:41
    Java利用反射实现的通用对象字节数组相互转换方法 1、对象字节数组 2、字节数组对象

    开发过程中,遇到需要通过Socket与C++通讯的情况,Java客户端需要向C++服务端发送请求包,同时接收返回的响应数据包。
    Java利用反射实现的通用对象与字节数组相互转换方法,在此记录与分享一下。

    这里写图片描述

    原理

    1、对象转字节数组: 通过反射,获取对象的所有字段以及字段的注解和字段的值,根据字段注解对应的字段类型,依次通过类型对应的处理方法,将字段的值,转化为字节或字节数组。
    2、字节数组转对象: 通过反射,获取对象的所有字段以及字段的注解,根据字段注解对应的字段类型,依次从字节数组中获取指定长度的字节数组,并将其转换为对应的值,赋值给此字段。

    测试结果

    1、请求对象

    这里写图片描述

    2、转换的字节数组解析

    100 0               #包类型号,100
    0 0 0 0 0 0 0 0     #seq,0
    12 0                #userName长度
    122 104 97 110 103 115 97 110 102 101 110 103   #userName,zhangsanfeng
    6 0                 #pwd长度
    49 50 51 52 53 54   #pwd,123456
    9 0                 #trueName长度
    -27 -68 -96 -28 -72 -119 -28 -72 -80            #trueName,张三丰
    -57 97 109 67 4 0 0 0                           #telNo,18311111111
    1                   #gender,1
    24 0                #age,24
    -80 0               #height,176
    0 0 -125 66         #weight,65.5
    3 0                 #list长度
    101 0               #二级包类型号,101     
    -50 7               #startYear,1998
    -45 7               #endYear,2003
    12 0                #school长度
    -27 -82 -98 -23 -86 -116 -27 -80 -113 -27 -83 -90   #school,实验小学
    101 0               #二级包类型号,101
    -45 7               #startYear,2003
    -39 7               #endYear,2009
    12 0                #school长度
    -27 -123 -85 -28 -72 -128 -28 -72 -83 -27 -83 -90   #school,八一中学
    101 0               #二级包类型号,101
    -39 7               #startYear,2009
    -35 7               #endYear,2013
    12 0                #school长度
    -26 -72 -123 -27 -115 -114 -27 -92 -89 -27 -83 -90  #school,清华大学

    3、通过数组转换获得的对象

    这里写图片描述

    源码

    1、请求包类:

    package com.daidai.pack.communication;
    
    import java.util.List;
    
    import com.daidai.pack.ColumnProperty;
    import com.daidai.pack.ColumnType;
    import com.daidai.pack.Pack;
    import com.daidai.pack.PackType;
    
    /**
     * 测试请求包
     * 
     * @author daidai
     */
    @PackType(typeNo = 100)
    public class TestRequest extends Pack {
    
        /**
         * 在进行tcp通讯时,根据此序列来对应请求包和返回包
         */
        @ColumnProperty(type = ColumnType.LONG)
        public long seq;
    
        /**
         * 用户名
         */
        @ColumnProperty(type = ColumnType.STRING)
        public String userName;
    
        /**
         * 密码
         */
        @ColumnProperty(type = ColumnType.STRING)
        public String pwd;
    
        /**
         * 真实姓名
         */
        @ColumnProperty(type = ColumnType.STRING)
        public String trueName;
    
        /**
         * 手机号
         */
        @ColumnProperty(type = ColumnType.LONG)
        public long telNo;
    
        /**
         * 性别,0为女性、1为男性
         */
        @ColumnProperty(type = ColumnType.BYTE)
        public byte gender;
    
        /**
         * 年龄
         */
        @ColumnProperty(type = ColumnType.SHORT)
        public short age;
    
        /**
         * 身高
         */
        @ColumnProperty(type = ColumnType.SHORT)
        public short height;
    
        /**
         * 体重
         */
        @ColumnProperty(type = ColumnType.FLOAT)
        public float weight;
    
        /**
         * 教育背景
         */
        @ColumnProperty(type = ColumnType.LIST_OBJECT)
        public List<EducationalBackground> eduBackground;
    
        @Override
        public String toString() {
            return "TestRequest [seq=" + seq + ", userName=" + userName + ", pwd="
                    + pwd + ", trueName=" + trueName + ", telNo=" + telNo
                    + ", gender=" + gender + ", age=" + age + ", height=" + height
                    + ", weight=" + weight + ", eduBackground=" + eduBackground
                    + "]";
        }
    
    }
    

    2、二级请求包类:

    package com.daidai.pack.communication;
    
    import com.daidai.pack.ColumnProperty;
    import com.daidai.pack.ColumnType;
    import com.daidai.pack.Pack;
    import com.daidai.pack.PackType;
    
    /**
     * 测试二级请求包
     * @author daidai
     */
    @PackType(typeNo = 101)
    public class EducationalBackground extends Pack{
    
        /**
         * 开始年份
         */
        @ColumnProperty(type=ColumnType.SHORT)
        public short startYear;
    
        /**
         * 结束年份
         */
        @ColumnProperty(type=ColumnType.SHORT)
        public short endYear;
    
        /**
         * 学校名称
         */
        @ColumnProperty(type=ColumnType.STRING)
        public String school;
    
        @Override
        public String toString() {
            return "EducationalBackground [startYear=" + startYear + ", endYear="
                    + endYear + ", school=" + school + "]";
        }
    
    }
    

    3、包类型注解类,一个类型号唯一对应一个请求包

    package com.daidai.pack;
    
    import java.lang.annotation.Retention;
    import java.lang.annotation.Target;
    
    /**
     * 包类型
     * @author daidai
     *
     */
    @Retention(value=java.lang.annotation.RetentionPolicy.RUNTIME)
    @Target(value={java.lang.annotation.ElementType.TYPE})
    public @interface PackType {
    
        /**
         * 包类型号
         * @return
         */
        public short typeNo();
    
    }
    

    4、字段类型注解类,用于注明字段类型

    package com.daidai.pack;
    
    import java.lang.annotation.Retention;
    import java.lang.annotation.Target;
    
    /**
     * 字段属性注解
     * @author daidai
     */
    @Retention(value=java.lang.annotation.RetentionPolicy.RUNTIME)
    @Target(value={java.lang.annotation.ElementType.FIELD})
    public @interface ColumnProperty {
    
        // 字段类型
        public ColumnType type();
    
        // 字段长度限制,0为不限制
    //  public int maxLen() default 0;
    }
    

    5、字段类型枚举,用于处理字段和字节数组的转换

    package com.daidai.pack;
    
    import java.nio.ByteBuffer;
    import java.util.ArrayList;
    import java.util.List;
    
    /**
     * 字段类型
     * @author daidai
     */
    public enum ColumnType {
    
        BYTE{
    
            @Override
            public void serialize(ByteBuffer bf, Object obj) throws Exception {
                Number n = (Number)obj;
                bf.put(n.byteValue());
            }
    
            @Override
            public Object deserialize(ByteBuffer bf) throws Exception {
                return bf.get();
            }
        },
    
        SHORT{
    
            @Override
            public void serialize(ByteBuffer bf, Object obj) throws Exception {
                Number n = (Number)obj;
                bf.putShort(n.shortValue());
            }
    
            @Override
            public Object deserialize(ByteBuffer bf) throws Exception {
                return bf.getShort();
            }
    
        },
    
        INT{
    
            @Override
            public void serialize(ByteBuffer bf, Object obj) throws Exception {
                Number n = (Number)obj;
                bf.putInt(n.intValue());
            }
    
            @Override
            public Object deserialize(ByteBuffer bf) throws Exception {
                return bf.getInt();
            }
    
        },
    
        LONG{
    
            @Override
            public void serialize(ByteBuffer bf, Object obj) throws Exception {
                Number n = (Number)obj;
                bf.putLong(n.longValue());
            }
    
            @Override
            public Object deserialize(ByteBuffer bf) throws Exception {
                return bf.getLong();
            }
        },
    
        FLOAT{
    
            @Override
            public void serialize(ByteBuffer bf, Object obj) throws Exception {
                Number n = (Number)obj;
                bf.putFloat(n.floatValue());
            }
    
            @Override
            public Object deserialize(ByteBuffer bf) throws Exception {
                return bf.getFloat();
            }
    
        },
    
        DOUBLE{
    
            @Override
            public void serialize(ByteBuffer bf, Object obj) throws Exception {
                Number n = (Number)obj;
                bf.putDouble(n.doubleValue());
            }
    
            @Override
            public Object deserialize(ByteBuffer bf) throws Exception {
                return bf.getDouble();
            }
    
        },
    
        STRING{
    
            @Override
            public void serialize(ByteBuffer bf, Object obj) throws Exception {
                byte[] bs = obj.toString().getBytes("UTF-8");
                bf.putShort((short)bs.length);
                bf.put(bs);
            }
    
            @Override
            public Object deserialize(ByteBuffer bf) throws Exception {
    
                short len = bf.getShort();
                if(len > 0){
                    byte[] bs = new byte[len];
                    bf.get(bs);
                    return new String(bs,"UTF-8");
                }
    
                return "";
            }
    
        },
    
        OBJECT{
    
            @Override
            public void serialize(ByteBuffer bf, Object obj) throws Exception {
                byte[] bs =new byte[]{};
                if (obj instanceof Pack) {
                    Pack newPack = (Pack) obj;
                    bs = newPack.serialize();
                }
                bf.put(bs);
            }
    
            @Override
            public Object deserialize(ByteBuffer bf) throws Exception {
                return Pack.deserialize(bf);
            }
    
        },
    
        BYTE_ARRAYS{
    
            @Override
            public void serialize(ByteBuffer bf, Object obj) throws Exception {
                byte[] bs = (byte[]) obj;
                bf.put(bs);
    
            }
    
            @Override
            public Object deserialize(ByteBuffer bf) throws Exception {
                short len = bf.getShort();
                byte[] bs = new byte[len];
                bf.get(bs);
                return bs;
            }
    
        },
    
        LIST_INT{
    
            @Override
            public void serialize(ByteBuffer bf, Object obj) throws Exception {
                @SuppressWarnings("unchecked")
                List<Object> list = (List<Object>)obj;
                bf.putShort((short) list.size());
                for (Object item : list) {
                    INT.serialize(bf, item);
                }
            }
    
            @Override
            public Object deserialize(ByteBuffer bf) throws Exception {
                short len = bf.getShort();
                List<Object> list = new ArrayList<Object>(len);
                if(len > 0){
                    for(int i=0; i<len; i++){
                        list.add(INT.deserialize(bf));
                    }
                }
                return list;
            }
    
        },
    
        LIST_STRING{
    
            @Override
            public void serialize(ByteBuffer bf, Object obj) throws Exception {
                @SuppressWarnings("unchecked")
                List<Object> list = (List<Object>)obj;
                bf.putShort((short) list.size());
                for (Object item : list) {
                    STRING.serialize(bf, item);
                }
    
            }
    
            @Override
            public Object deserialize(ByteBuffer bf) throws Exception {
                short len = bf.getShort();
                List<Object> list = new ArrayList<Object>(len);
                if(len > 0){
                    for(int i=0; i<len; i++){
                        list.add(STRING.deserialize(bf));
                    }
                }
                return list;
            }
    
        },
    
        LIST_OBJECT{
    
            @Override
            public void serialize(ByteBuffer bf, Object obj) throws Exception {
                @SuppressWarnings("unchecked")
                List<Object> list = (List<Object>)obj;
                bf.putShort((short) list.size());
                for (Object item : list) {
                    OBJECT.serialize(bf, item);
                }
            }
    
            @Override
            public Object deserialize(ByteBuffer bf) throws Exception {
                short len = bf.getShort();
                List<Object> list = new ArrayList<Object>(len);
                if(len > 0){
                    for(int i=0; i<len; i++){
                        list.add(OBJECT.deserialize(bf));
                    }
                }
                return list;
            }
    
        };
    
        /**
         * 序列化
         * @param bf
         * @param obj
         * @throws Exception
         */
        public abstract void serialize(ByteBuffer bf, Object obj) throws Exception;
    
        /**
         * 返序列化
         * @param bf
         * @return
         * @throws Exception
         */
        public abstract Object deserialize(ByteBuffer bf) throws Exception;
    }
    

    6、包授权管理类,用于初始化类型号和包类的对应关系,方便之后通过类型号找到对应的类

    package com.daidai.pack;
    
    import java.util.concurrent.ConcurrentHashMap;
    import java.util.concurrent.ConcurrentMap;
    
    
    /**
     * 包授权管理
     * @author daidai
     */
    public class PackAuthorize {
    
        /**
         * 存放通讯包类型号和通讯包对应关系
         */
        private static final ConcurrentMap<Short, Class<?>> typeNoAndPackMap ;
    
        static{
    
            typeNoAndPackMap = new ConcurrentHashMap<Short, Class<?>>();
    
            registerPack(
                    com.daidai.pack.communication.EducationalBackground.class,
                    com.daidai.pack.communication.TestRequest.class);
    
        }
    
        private PackAuthorize(){};
    
        private static PackAuthorize instance;
    
        public static PackAuthorize getInstance(){
            if(instance == null){
                synchronized(PackAuthorize.class){
                    if(instance == null){
                        instance = new PackAuthorize();
                    }
                }
            }
            return instance;
        }
    
        /**
         * 注册通讯包和包类型号的对应关系管理
         * @param pack
         */
        public static void registerPack(Class<?>... classes){
    
            for(Class<?> clazz : classes){
                PackType packType = (PackType) clazz.getAnnotation(PackType.class);
                typeNoAndPackMap.put(packType.typeNo(), clazz);
            }
    
        }
    
        public ConcurrentMap<Short, Class<?>> getTypenoandpackmap() {
            return typeNoAndPackMap;
        }
    
    }
    

    7、通用包父类,用于定义通用处理方法

    package com.daidai.pack;
    
    import java.lang.reflect.Field;
    import java.nio.ByteBuffer;
    import java.nio.ByteOrder;
    
    /**
     * 通用包父类
     * @author daidai
     */
    public abstract class Pack {
    
        // 字节序
        final ByteOrder byteOrder = ByteOrder.LITTLE_ENDIAN;
        // 当前包的允许最大长度
        final int packMaxSize = 1500;
    
        /**
         * 获取包类型号typeNo,包类型号不允许重复,一个包类型号对应一个包
         * @return
         */
        public final short getTypeNo(){
            @SuppressWarnings("rawtypes")
            Class clazz = this.getClass();
            @SuppressWarnings("unchecked")
            PackType packType = (PackType) clazz.getAnnotation(PackType.class);
            return packType.typeNo();
        }
    
        /**
         * 序列化,将包对象转化为字节数组
         * @return
         * @throws Exception
         */
        public byte[] serialize() throws Exception{
    
            ByteBuffer bf = ByteBuffer.allocate(packMaxSize);
            bf.order(byteOrder);
            bf.putShort(this.getTypeNo());
    
            Field[] fields = this.getClass().getDeclaredFields();
            for(Field field : fields){
                ColumnProperty cp = field.getAnnotation(ColumnProperty.class);
                Object obj = field.get(this);
                try {
                    final ColumnType type = cp.type();
                    type.serialize(bf, obj);
                } catch (Exception e) {
                    throw new Exception("#socket_serialize_error " + field + " " + obj + " " + cp + " " + e, e);
                }
            }
    
            byte[] result = new byte[bf.position()];
            System.arraycopy(bf.array(), 0, result, 0, result.length);
            return result;
        }
    
        /**
         * 返序列化,将字节数组转换为包对象
         * @param datas
         * @return
         * @throws Exception
         */
        public static final Pack deserialize(byte[] datas) throws Exception{
    
            ByteBuffer byteBuffer = ByteBuffer.wrap(datas);
            byteBuffer.order(ByteOrder.LITTLE_ENDIAN);
    
            return deserialize(byteBuffer);
        }
    
        /**
         * 返序列化,将字节缓冲区转换为包对象
         * @param byteBuffer
         * @return
         * @throws Exception
         */
        public static final Pack deserialize(ByteBuffer byteBuffer) throws Exception{
    
            short typeNo = byteBuffer.getShort();
    
            Class<?> clazz = PackAuthorize.getInstance().getTypenoandpackmap().get(typeNo);
    
            Pack pack = getPack(byteBuffer,clazz);
    
            return pack;
        }
    
        private static final Pack getPack(ByteBuffer byteBuffer, Class<?> clazz) throws Exception{
    
            Pack pack = (Pack) clazz.newInstance();
    
            Field[] fields = clazz.getDeclaredFields();
            for(Field field : fields){
                ColumnProperty cp = field.getAnnotation(ColumnProperty.class);
                field.setAccessible(true);
                try {
                    final ColumnType type = cp.type();
                    field.set(pack, type.deserialize(byteBuffer));
                } catch (Exception e) {
                    throw new Exception("#socket_serialize_error " + field + " " + cp + " " + e, e);
                }
            }
    
            return pack;
        }
    
    }
    

    8、唯一序列生成类,序列用于将请求包和响应包进行匹配对应,防止“答非所问”

    package com.daidai.pack.util;
    
    /**
     * 获取唯一序列
     * @author daidai
     */
    public class SequenceIdUtil {
        private final int beginValue = 0;
        private final int maxValue = Integer.MAX_VALUE;
        private static final int STEP = 1;
        private int value;
    
        private SequenceIdUtil(){}
    
        private static SequenceIdUtil instance;
    
        public static SequenceIdUtil getInstance() {
            if (instance == null)
                synchronized (SequenceIdUtil.class) {
                    if (instance == null)
                        instance = new SequenceIdUtil();
                }
            return instance;
        }
    
        /**
         * 获取一个序列值
         * @return
         */
        public synchronized int nextVal() {
            if (value < beginValue) {
                value = beginValue;
            }
    
            if(value >= maxValue){
                value = beginValue;
            }
    
            value += STEP;
    
            return value;
        }
    
    }

    9、测试类

    package com.daidai.test;
    
    import java.util.ArrayList;
    import java.util.List;
    
    import com.daidai.pack.Pack;
    import com.daidai.pack.communication.EducationalBackground;
    import com.daidai.pack.communication.TestRequest;
    
    public class Test {
    
        public static void main(String[] args) throws Exception {
    
            // 创建一个请求包对象,并给对象赋值 
            TestRequest request = new TestRequest();
            request.seq = 0;
            request.userName = "zhangsanfeng";
            request.pwd = "123456";
            request.trueName = "张三丰";
            request.telNo = 18311111111L;
            request.gender = 1;
            request.age = 24;
            request.height = 176;
            request.weight = 65.5F;
    
            EducationalBackground primarySchool = new EducationalBackground();
            primarySchool.startYear = 1998;
            primarySchool.endYear = 2003;
            primarySchool.school = "实验小学";
    
            EducationalBackground middleSchool = new EducationalBackground();
            middleSchool.startYear = 2003;
            middleSchool.endYear = 2009;
            middleSchool.school = "八一中学";
    
            EducationalBackground university = new EducationalBackground();
            university.startYear = 2009;
            university.endYear = 2013;
            university.school = "清华大学";
    
            List<EducationalBackground> list = new ArrayList<EducationalBackground>();
            list.add(primarySchool);
            list.add(middleSchool);
            list.add(university);
    
            request.eduBackground = list;
    
            // 打印创建完成的请求对象
            System.out.println(request.toString());
    
            // 调用序列化方法将对象转换成字节数组
            byte[] bs = request.serialize();
    
            // 打印生成的字节数组
            System.out.println(bs.toString());
            for(byte b : bs){
                System.out.print(b+" ");
            }
    
            // 调用返序列化方法,将字节数组转换为对象
            TestRequest request2 = (TestRequest) Pack.deserialize(bs);
    
            // 打印通过字节数组转换的对象
            System.out.println(request2);
        }
    
    }
    
    展开全文
  • 主要介绍了JAVA对象字节数组互转操作,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • 1、FileInputStream、FileOutputStream、FileReader、FileWriter...2、把源头换成电脑上的一块内存(字节数组),既然是一块内存那么java就可以直接访问,因为是java虚拟机的一块内存。不用关闭(释放)   3、所...
  • 对象转换为字节数组 BaseResponse baseResponse=new BaseResponse(); baseResponse.setStatus(0); ByteArrayOutputStream byt=new ByteArrayOutputStream(); ObjectOutputStream obj=new ObjectOutputStream(byt...
  • 读取对象字节数组转化为String,当String再转化字节数组时,无法还原Java对象的坑 网上的都没用,后来自己尝试解决了 写入对象 ByteArrayOutputStream out = new ByteArrayOutputStream(); ObjectOutputStream...
  • JAVA对象字节数组互转

    千次阅读 2020-06-29 16:15:27
    JAVA对象字节数组 0x01 创建要转换的类和主函数 注意这里一定要实现序列化 package day1; import java.io.Serializable; public class Test360 implements Serializable { @Override public String ...
  • java对象字节数组相互转换

    千次阅读 2016-08-26 21:53:40
    java对象字节数组相互转换
  • 1,怎样将一个字符串转换为字节数组: 2,将数字转换为字节数组: 3,将字节数组转化为字符串: 4,字节数组转化为数字: 5,返回16进制字符串对应的16进制对应的字节: 6,字节对应的16进制数转成对应的16进制数的...
  • java字节数组反序列化为对象

    千次阅读 2019-11-23 15:56:17
    public static Object dser(byte [] src) throws Exception{ ByteArrayInputStream baos =new ByteArrayInputStream(src); ObjectInputStream oos =new ObjectInputStream(baos); return oos.readObject(...
  • java代码-例子4-6 用字节数组初始化String对象
  • Java数组对象占用多少个字节?

    千次阅读 2020-12-15 17:40:27
    Java内存模型基础知识 对象内存中可以分为三块区域: 对象头(Header) MarkWord占用8字节 Class Point占用4字节 Length 数组占用4字节 实例数据(Instance Data) 对齐填充...
  • 字节数组对象字节数组对象分为输入流和输出流。分别是:ByteArrayInputStream和ByteArrayOutputStream。ByteArrayInputStream类字节数组输入流在内存创建一个字节数组缓冲区,从输入流读取的数据保存在该字节...
  • public static class DrawingSettings implements ByteObject { public double r; // red; public double g; // green; public double b; // blue; public double a; // 透明度 ... // 线号
  • Java对象字节数组相互转换

    千次阅读 2018-05-03 12:23:21
    1.首先对象要继承Serializable接口将字节转换为对象[java] view plain copy public static Object ByteToObject(byte[] bytes) { Object obj = null; try { // bytearray to object ...
  • java对象转换为字节数组

    千次阅读 2016-09-29 16:04:13
    import java.io.ObjectInputStream; import java.io.ObjectOutputStream; import java.io.ByteArrayInputStream; import java.io.*; import java.util.ArrayList; /**  * 目的是把一个类文件写入到字
  • java字节数组转换为字符串

    万次阅读 2017-05-29 21:56:59
    1、字节数组转换为字符串 byte[] byBuffer = new byte[20]; ... ... String strRead = new String(byBuffer); strRead=String.copyValueOf(strRead.toCharArray(), 0, byBuffer.length]); 2、字符串转换成字节...
  • import java.io.Serializable; public class test implements Serializable { public String hello(){ return "hello,word!"; } } 然后创建bytestoarrey类,内容如下 package com.company; import java.io....

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 255,847
精华内容 102,338
关键字:

java字节数组对象

java 订阅