java中long,int,short与byte数组之间的转换
java中int与byte,以及long与byte之间的转换

java中int与byte,以及long与byte之间的转换原⽂地址:/zgyulongfei/article/details/7738970public class Utilities {public static byte[] int2Bytes(int num) {byte[] byteNum = new byte[4];for (int ix = 0; ix < 4; ++ix) {int offset = 32 - (ix + 1) * 8;byteNum[ix] = (byte) ((num >> offset) & 0xff);}return byteNum;}public static int bytes2Int(byte[] byteNum) {int num = 0;for (int ix = 0; ix < 4; ++ix) {num <<= 8;num |= (byteNum[ix] & 0xff);}return num;}public static byte int2OneByte(int num) {return (byte) (num & 0x000000ff);}public static int oneByte2Int(byte byteNum) {return byteNum > 0 ? byteNum : (128 + (128 + byteNum));}public static byte[] long2Bytes(long num) {byte[] byteNum = new byte[8];for (int ix = 0; ix < 8; ++ix) {int offset = 64 - (ix + 1) * 8;byteNum[ix] = (byte) ((num >> offset) & 0xff);}return byteNum;}public static long bytes2Long(byte[] byteNum) {long num = 0;for (int ix = 0; ix < 8; ++ix) {num <<= 8;num |= (byteNum[ix] & 0xff);}return num;}public static void main(String[] args) {int num = 129;System.out.println("测试的int值为:" + num);byte[] int2bytes = Utilities.int2Bytes(num);System.out.printf("int转成bytes: ");for (int i = 0; i < 4; ++i) {System.out.print(int2bytes[i] + " ");}System.out.println();int bytes2int = Utilities.bytes2Int(int2bytes);System.out.println("bytes转⾏成int: " + bytes2int);byte int2OneByte = Utilities.int2OneByte(num);System.out.println("int转⾏成one byte: " + int2OneByte);int oneByte2Int = Utilities.oneByte2Int(int2OneByte);System.out.println("one byte转⾏成int: " + oneByte2Int);System.out.println();long longNum = 100000;System.out.println("测试的long值为:" + longNum);byte[] long2Bytes = Utilities.long2Bytes(longNum);System.out.printf("long转⾏成bytes: ");for (int ix = 0; ix < long2Bytes.length; ++ix) {System.out.print(long2Bytes[ix] + " ");}System.out.println();long bytes2Long = Utilities.bytes2Long(long2Bytes); System.out.println("bytes转⾏成long: " + bytes2Long); }}测试的int值为:129int转成bytes: 0 0 0 -127bytes转⾏成int: 129int转⾏成one byte: -127one byte转⾏成int: 129测试的long值为:100000long转⾏成bytes: 0 0 0 0 0 1 -122 -96bytes转⾏成long: 100000。
Java的基本数据类型

Java的基本数据类型变量就是申请内存来存储值。
也就是说,当创建变量的时候,需要在内存中申请空间。
内存管理系统根据变量的类型为变量分配存储空间,分配的空间只能⽤来储存该类型数据。
因此,通过定义不同类型的变量,可以在内存中储存整数、⼩数或者字符。
Java的两⼤数据类型:内置数据类型引⽤数据类型内置数据类型Java语⾔提供了⼋种基本类型。
六种数字类型(四个整数型(默认是int 型),两个浮点型(默认是double 型)),⼀种字符类型,还有⼀种布尔型。
byte:byte数据类型是8位、有符号的,以⼆进制补码表⽰的整数;(256个数字),占1字节最⼩值是-128(-2^7);最⼤值是127(2^7-1);默认值是0;byte类型⽤在⼤型数组中节约空间,主要代替整数,因为byte变量占⽤的空间只有int类型的四分之⼀;例⼦:byte a = 100,byte b = -50。
short:short数据类型是16位、有符号的以⼆进制补码表⽰的整数,占2字节最⼩值是-32768(-2^15);最⼤值是32767(2^15 - 1);Short数据类型也可以像byte那样节省空间。
⼀个short变量是int型变量所占空间的⼆分之⼀;默认值是0;例⼦:short s = 1000,short r = -20000。
int:int数据类型是32位、有符号的以⼆进制补码表⽰的整数;占3字节最⼩值是-2,147,483,648(-2^31);最⼤值是2,147,485,647(2^31 - 1);⼀般地整型变量默认为int类型;默认值是0;例⼦:int a = 100000, int b = -200000。
long:long数据类型是64位、有符号的以⼆进制补码表⽰的整数;占4字节最⼩值是-9,223,372,036,854,775,808(-2^63);最⼤值是9,223,372,036,854,775,807(2^63 -1);这种类型主要使⽤在需要⽐较⼤整数的系统上;默认值是0L;例⼦: long a = 100000L,int b = -200000L。
JAVA试题集锦(含答案)

JAVA习题锦集(含答案)一、判断题1.(×)接口和类一样也可以有继承关系,而且都只能支持单继承2.(√)可以用FileOutputStream对象作为PrintWrite类的构造方法的参数3.(×)A subclass inherits all methods ( including the constructor ) from the superclass4.(×)Java中所有的类都是ng的子类5.(×)由于URL对象对应的Internet地址可以划分为“协议名”、“端口号”和“文件名”3部分,所以创建一个URL对象后,可以通过修改这3部分内容来修改这个URL对象的Internet地址6.(×)abstract方法不一定要声明在abstract类中7.(×)在Java中,异常(Exception)是指程序在编译和运行进出现的错误8.(√)我们可以方便地编写Java客户机/服务器程序,在客户机/服务器模式中,客户机一般通过套接字(Socket)使用服务器所提供的服务,Socket由两部分组成:IP地址和端口号9.(√)子类的域和方法的数目一定大于等于父类的域和方法的数目10.(×)最终方法只能存在于最终类中二、单选题1、Java语言具有许多优点和特点,下列选项中,哪个反映了Java程序并行机制的特点?B(A)安全性(B)多线性(C)跨平台(D)可移植2、下列选项中不是JAVA语言特点的是()D(A)面向对象(B)平台无关(C)安全性高(D)单线程3、异常包含下列那些内容?()D(A)程序中的语法错误(B)程序的编译错误(C)程序执行过程中遇到的事先没有预料到的情况(D)程序事先定义好的可能出现的意外情况4、JAVA语言中的语句是以()为结尾的。
B(A)句号(B)分号(C)双引号(D)逗号5、下列选项中,哪一个是打印语句的正确表达式:()A(A)System.out.println(); (B)System.out.Println();(C)System.Out.print(); (D)System.Out.println();6、下列哪一个是合法的JAVA语句标示符()C(A)#xyz (B)10Year (C)_Hello (D)@yahoo7、下列哪一个是JAVA语言的关键字()B(A)hello (B)void (C)num_01 (D)abc8、关于数据类型转换下面描述错误的是()D(A)当两个数据的类型不统一时,必须先进行数据类型的转换,再运算或赋值(B)byte类型数据可以转换为short,int,long类型数据(C)long类型数据有可能转换为byte,short,int类型数据(D)在语句int i=(int) 78.67;中,变量i的值为799、下列定义String变量s的语句中,错误的是()A(A)String s=new “Yes!”;(B)String s=new String(“yes!”) ;(C)String s; (D)String s=”Yes!”;10、下列关于注释语句的描述错误的是()DA、多行注释语句的内容,从/*开始,到*/结束B、多行注释语句也可以是单行语句C、文档注释语句的内容,从/**开始,到*/结束D、单行注释语句的内容,从//开始,以分号为结尾句11、定义一个长整型变量a的语句是()DA、int a ;B、a long ;C、float a ;D、long a;12、下列哪个是反斜杠字符的正确表示()AA、\\;B、*\\;C、\;D、\’\’;13.Main()方法的返回类型是()BA、intB、voidC、booleanD、static14. 编译运行以下程序后,关于输出结果的说明正确的是()Bpublic class Con{public static void main(String args[ ]){int x=2;System.out.println(“value is “+ ((x<1) ?22:2));}}A、输出结果为:value is 22.2B、输出结果为:value is 2C、输出结果为:value is 2.0D、编译错误15.给出下面代码:public class test{static int a[] = new a[10];public static void main(String args[]) {System.out.println(arr[10]);}}那个选项是正确的?()AA、编译时将产生错误;B、编译时正确,运行时将产生错误;C、输出零;D、输出空。
javabyte数组与int,long,short,byte的转换实现方法

javabyte数组与int,long,short,byte的转换实现⽅法实例如下:public class DataTypeChangeHelper {/*** 将⼀个单字节的byte转换成32位的int** @param b* byte* @return convert result*/public static int unsignedByteToInt(byte b) {return (int) b & 0xFF;}/*** 将⼀个单字节的Byte转换成⼗六进制的数** @param b* byte* @return convert result*/public static String byteToHex(byte b) {int i = b & 0xFF;return Integer.toHexString(i);}/*** 将⼀个4byte的数组转换成32位的int** @param buf* bytes buffer* @param byte[]中开始转换的位置* @return convert result*/public static long unsigned4BytesToInt(byte[] buf, int pos) {int firstByte = 0;int secondByte = 0;int thirdByte = 0;int fourthByte = 0;int index = pos;firstByte = (0x000000FF & ((int) buf[index]));secondByte = (0x000000FF & ((int) buf[index + 1]));thirdByte = (0x000000FF & ((int) buf[index + 2]));fourthByte = (0x000000FF & ((int) buf[index + 3]));index = index + 4;return ((long) (firstByte << 24 | secondByte << 16 | thirdByte << 8 | fourthByte)) & 0xFFFFFFFFL;}/*** 将16位的short转换成byte数组** @param s* short* @return byte[] 长度为2* */public static byte[] shortToByteArray(short s) {byte[] targets = new byte[2];for (int i = 0; i < 2; i++) {int offset = (targets.length - 1 - i) * 8;targets[i] = (byte) ((s >>> offset) & 0xff);}return targets;}/*** 将32位整数转换成长度为4的byte数组** @param s* int* @return byte[]* */public static byte[] intToByteArray(int s) {byte[] targets = new byte[2];for (int i = 0; i < 4; i++) {int offset = (targets.length - 1 - i) * 8;targets[i] = (byte) ((s >>> offset) & 0xff);}return targets;}/*** long to byte[]** @param s* long* @return byte[]* */public static byte[] longToByteArray(long s) {byte[] targets = new byte[2];for (int i = 0; i < 8; i++) {int offset = (targets.length - 1 - i) * 8;targets[i] = (byte) ((s >>> offset) & 0xff);}return targets;}/**32位int转byte[]*/public static byte[] int2byte(int res) {byte[] targets = new byte[4];targets[0] = (byte) (res & 0xff);// 最低位targets[1] = (byte) ((res >> 8) & 0xff);// 次低位targets[2] = (byte) ((res >> 16) & 0xff);// 次⾼位targets[3] = (byte) (res >>> 24);// 最⾼位,⽆符号右移。
byte[]数组和int之间的转换
![byte[]数组和int之间的转换](https://img.taocdn.com/s3/m/fbee3500f08583d049649b6648d7c1c708a10bba.png)
byte[]数组和int之间的转换这⾥简单记录下两种转换⽅式:第⼀种:1、int与byte[]之间的转换(类似的byte short,long型)[java]1. /**2. * 将int数值转换为占四个字节的byte数组,本⽅法适⽤于(低位在前,⾼位在后)的顺序。
和bytesToInt()配套使⽤3. * @param value4. * 要转换的int值5. * @return byte数组6. */7. public static byte[] intToBytes( int value )8. {9. byte[] src = new byte[4];10. src[3] = (byte) ((value>>24) & 0xFF);11. src[2] = (byte) ((value>>16) & 0xFF);12. src[1] = (byte) ((value>>8) & 0xFF);13. src[0] = (byte) (value & 0xFF);14. return src;15. }16. /**17. * 将int数值转换为占四个字节的byte数组,本⽅法适⽤于(⾼位在前,低位在后)的顺序。
和bytesToInt2()配套使⽤18. */19. public static byte[] intToBytes2(int value)20. {21. byte[] src = new byte[4];22. src[0] = (byte) ((value>>24) & 0xFF);23. src[1] = (byte) ((value>>16)& 0xFF);24. src[2] = (byte) ((value>>8)&0xFF);25. src[3] = (byte) (value & 0xFF);26. return src;27. }byte[]转int[java]1. /**2. * byte数组中取int数值,本⽅法适⽤于(低位在前,⾼位在后)的顺序,和和intToBytes()配套使⽤3. *4. * @param src5. * byte数组6. * @param offset7. * 从数组的第offset位开始8. * @return int数值9. */10. public static int bytesToInt(byte[] src, int offset) {11. int value;12. value = (int) ((src[offset] & 0xFF)13. | ((src[offset+1] & 0xFF)<<8)14. | ((src[offset+2] & 0xFF)<<16)15. | ((src[offset+3] & 0xFF)<<24));16. return value;17. }18.19. /**20. * byte数组中取int数值,本⽅法适⽤于(低位在后,⾼位在前)的顺序。
Java字节数组类型(byte[])与int类型互转方法
![Java字节数组类型(byte[])与int类型互转方法](https://img.taocdn.com/s3/m/9482581c53ea551810a6f524ccbff121dd36c5ff.png)
Java字节数组类型(byte[])与int类型互转⽅法代码如下:public class CommonUtils {//⾼位在前,低位在后public static byte[] int2bytes(int num){byte[] result = new byte[4];result[0] = (byte)((num >>> 24) & 0xff);//说明⼀result[1] = (byte)((num >>> 16)& 0xff );result[2] = (byte)((num >>> 8) & 0xff );result[3] = (byte)((num >>> 0) & 0xff );return result;}//⾼位在前,低位在后public static int bytes2int(byte[] bytes){int result = 0;if(bytes.length == 4){int a = (bytes[0] & 0xff) << 24;//说明⼆int b = (bytes[1] & 0xff) << 16;int c = (bytes[2] & 0xff) << 8;int d = (bytes[3] & 0xff);result = a | b | c | d;}return result;}public static void main(String[] args){int a = -64;System.out.println("-64="+Integer.toBinaryString(-64));byte[] bytes = CommonUtils.int2bytes(a);for(int i = 0 ; i<4 ; i++){System.out.println(bytes[i]);}a = CommonUtils.bytes2int(bytes);System.out.println(a);}}运⾏结果如下:-64=11111111111111111111111111000000-1-1-1-64-64说明1:-64转化为⼆进制原码为[10000000][00000000][00000000][01000000]将原码变为补码为[11111111][11111111][11111111][11000000],与控制台输出结果相同,可以看到在java中⼆进制以补码的形式表⽰-64 >>> 24后(⽆符号右移,⾼位补0),变为[00000000][00000000][00000000][11111111]将上步结果& 0xff后,依然为[00000000][00000000][00000000][11111111],由于0xff的值为[00000000][00000000] [00000000][11111111],故& 0xff的⽬的是将最低8位保持不变,其余位置为0然后将结果强转为byte类型,保留低位,截去⾼位,变为[11111111],可以看出上步的0xff其实是没有必要的,⽆论⾼位是多少,最终都会被截去故result[0]为[11111111]=-1依此类推:result[1]为[11111111]=-1result[2]为[11111111]=-1result[3]为[11000000]=-64说明2:byte[0]为[11111111],⾸先会将byte[0]转化为int类型(在位移运算前,会将byte类型转换为int类型,如果为正数,⾼位补0,如果为负数,⾼位补1),⾼位补1,变为[11111111][11111111][11111111][11111111]将上步结果& 0xff之后,将变为[00000000][00000000][00000000][11111111]然后将上步结果 << 24(左位移,低位补0),将变为[11111111][00000000][00000000][00000000] = a同理获得b、c、d最终a | b | c | d 即:[11111111][00000000][00000000][00000000] |[00000000][11111111][00000000][00000000] | 由于<<16位之前& 0xff,故保证b的最⾼8位都为0[00000000][00000000][11111111][00000000] | 由于<<8位之前& 0xff,故保证c的最⾼16位都为0[00000000][00000000][00000000][11000000] 由于& 0xff,故保证d的最⾼24为都为0=[11111111][11111111][11111111][11000000] = -64可以看到为了保证byte转换成int时,补位不对最终a | b | c | d的结果产⽣影响(置为0),& 0xff是必须的short与byte[]之间的转换,long与byte[]之间的转换也是类似的PS:1,int类型占4个字节,⽽byte类型只占1个字节2,原码:最⾼位为符号位,其余位⽤来表⽰数值⼤⼩2的原码:00000010-2的原码:100000103,反码:正数的反码与其原码相同;负数的反码符号位保持不变,其余位按位取反2的反码:00000010-2的反码:111111014,补码:正数的补码与其原码相同;负数的补码为该负数的反码+12的补码:00000010-2的补码:11111110以上这篇Java 字节数组类型(byte[])与int类型互转⽅法就是⼩编分享给⼤家的全部内容了,希望能给⼤家⼀个参考,也希望⼤家多多⽀持。
java中基本数据类型和引用数据类型
java中基本数据类型和引用数据类型在Java中,数据类型分为两大类:基本数据类型和引用数据类型。
基本数据类型是直接存储值的简单数据类型,而引用数据类型是指向对象的引用。
下面将详细介绍这两种数据类型。
1. 基本数据类型:基本数据类型是Java语言内置的八种数据类型,分别是byte、short、int、long、float、double、boolean和char。
它们分别代表整数、浮点数、布尔值和字符等数据类型。
- byte类型:byte类型是8位有符号的整数,取值范围为-128到127。
- short类型:short类型是16位有符号的整数,取值范围为-32768到32767。
- int类型:int类型是32位有符号的整数,取值范围为-231到231-1。
- long类型:long类型是64位有符号的整数,取值范围为-263到263-1。
- float类型:float类型是32位的浮点数,它可以表示大约6-7位有效数字的浮点数。
- double类型:double类型是64位的浮点数,它可以表示大约15位有效数字的浮点数。
- boolean类型:boolean类型只有两个取值:true和false。
它用于表示逻辑值。
- char类型:char类型是16位的Unicode字符,它可以表示任何字符。
这些基本数据类型在内存中占有固定的空间,所以被称为值类型。
它们的值保存在栈内存中,因此它们的赋值和比较都是直接比较值本身。
2. 引用数据类型:引用数据类型是通过类、接口和数组来定义的。
引用数据类型的变量存储的是对对象的引用,而非对象本身的值。
在Java中,所有的类都直接或间接地派生于Object类,因此每个对象都可以被看作是一个Object类型的实例。
引用数据类型包括类(如String、Integer等)、接口和数组。
它们通常占用的空间比较大,并且需要在堆内存中分配空间来存储对象。
引用数据类型的赋值和比较是比较引用本身,即判断两个引用是否引用同一个对象。
04填空题
1.软件开发具有多种程序设计方法,其中___结构化程序设计_______________和面向对象程序设计是最具代表性的。
2.面向对象程序设计的四个特性是:抽象性、__封装性 _______、____继承性_____、多态性。
3.根据程序结构和运行环境的不同,Java源程序分为两类,即__应用程序(Application) ______和___小应用程序______。
4.JVM的中文含义是___ Java虚拟机 _________,它的作用是_____执行Java 字节码代码_______________。
5.Java语言中,流程控制语句包括顺序结构、__分支结构_________、_____循环结构______。
6.在Java程序中,整数类型包含byte、__ short ____、int和long等四种类型。
7.在Java程序中,通过____接口 __的定义可以实现多继承。
8.Java中访问限定符有public、protected、private、默认。
9.如果用final修饰一个类,表明此类不可___作为父类(被继承)值不可被修改(为常量)_________。
如果用final修饰一个变量,表明此变量____________。
10.接口是一种只含有__抽象方法____或常量的一种特殊的抽象类。
11.每个应用程序(Application)可以包括许多方法,但必须且只能有一个_ main __ ___方法。
12.Java源文件中只能有一个___ __ public _类,其他类的个数不限。
13.面向对象的软件开发过程包括四个阶段:面向对象分析、面向对象设计、面向对象程序设计、面向对象测试。
14、String s = new String("xyz");创建了一个_______个字符串对象。
1. 创建类的对象时,使用运算符____ new _______给对象分配内存空间。
2. 定义类的构造方法不能有返回值类型,其名称与__类___名相同。
hutool unit16数值转byte数组
hutool unit16数值转byte数组Hutool是一个 Java 工具类库,它包含了大量的常用工具和方法,以简化Java 编程中的各种任务。
在处理字节和数值转换时,Hutool提供了非常便捷的 API。
在Hutool中,如果你想要将一个int、long或其他数值类型转换为byte数组,并且这个数值是按照大端序(Big-Endian)或小端序(Little-Endian)的UInt16(无符号16位整数)格式存储的,你可以使用ByteUtil或NumberUtil类中的方法。
但是,Java 本身并不直接支持无符号整数类型,因此这里的UInt16实际上可能是指一个short值(有符号16位整数),但在处理时将其视为无符号的。
要将一个int值(在这里我们假设它实际上是一个UInt16值,即其值范围在 0 到 65535 之间)转换为byte数组,你可以这样做:import cn.hutool.core.util.ByteUtil;public class UInt16ToByteArray {public static void main (String[] args) {int uint16Value = 30000; // 假设这是一个 UInt16 值if (uint16Value < 0 || uint16Value > 65535) {throw new IllegalArgumentException( "Value out ofUInt16 range");}// 使用 Hutool 的 ByteUtil 将 int 转换为 byte 数组(大端序)byte[] bytesBigEndian = ByteUtil.intToBytes(uint16Value, ByteOrder.BIG_ENDIAN);// 如果你需要小端序,可以这样做:byte[] bytesLittleEndian =ByteUtil.intToBytes(uint16Value,ByteOrder.LITTLE_ENDIAN);// 输出转换结果System.out.println( "Big Endian: " +ByteUtil.byteArrayToHex(bytesBigEndian));System.out.println( "Little Endian: " +ByteUtil.byteArrayToHex(bytesLittleEndian));}}请注意,上面的代码示例实际上并不是专门针对UInt16的,因为 Java 中没有UInt16类型。
java基本数据类型所占用的内存空间大小
java基本数据类型所占⽤的内存空间⼤⼩⼀、基本数据类型 Java语⾔提供了⼋种基本类型。
六种数值类型(四个整数型,两个浮点型),⼀种字符类型,还有⼀种布尔型。
java中基本数据类型中没有⽆符号类型(C、C++中有),只有有符号类型。
在计算机内,定点数有3种表⽰法:原码、反码和补码原码:⼆进制定点表⽰法,即最⾼位为符号位,“0”表⽰正,“1”表⽰负,其余位表⽰数值的⼤⼩。
反码:正数的反码与其原码相同;负数的反码是对其原码逐位取反,但符号位除外。
补码:正数的补码与其原码相同;负数的补码是将其原码的除符号位外的所有位,逐位取反,然后加1。
计算机中数据的运算都是通过补码进⾏的。
反码是为了解决减法运算,补码是为了解决反码产⽣的±0的问题。
计算机中负数是⽤补码的形式保存、并⽤它参与加减法运算的,减法会被转换为加法,计算机中没有减法运算。
在计算机中减法运算可以转换成加法运算,⽐如8-1 --> 8+(-1) = 7原码: 8: 0000 1000 -1: 1000 0001反码: 8: 0000 1000 -1: 1111 1110补码: 8: 0000 1000 -1: 1111 1111补码运算: (0000 1000) + (11111111) = 0000 0111 --> 4+2+1=7⽐如:-128+127 --> 127+(-128) = -1 0111 1111 + (1000 0000) = 1111 1111(补码) --> 1111 1110(反码) --> 1000 0001(原码) --> -1计算机都是以补码来存储的: ⑴⼀个数为正,则它的原码、反码、补码相同。
⑵⼀个数为负,则符号位为1,其余各位是对原码取反(符号位不变),然后整个数加1。
先⽤⼀个正数1举例原码:0000 0001反码:0000 0001补码:0000 0001正数的原码=反码=补码对于-1来说原码:1000 0001反码:1111 1110(符号位不变,其他相反)补码:1111 1111(补码是反码+1) Java中⽤补码表⽰⼆进制数。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
//long类型转成byte数组
public static byte[] longToByte(long number) {
long temp = number;
byte[] b = new byte[8];
for (int i = 0; i < b.length; i++) {
b[i] = new Long(temp & 0xff).byteValue();// 将最低位保存在最低位
temp = temp >> 8; // 向右移8位
}
return b;
}
//byte数组转成long
public static long byteToLong(byte[] b) {
long s = 0;
long s0 = b[0] & 0xff;// 最低位
long s1 = b[1] & 0xff;
long s2 = b[2] & 0xff;
long s3 = b[3] & 0xff;
long s4 = b[4] & 0xff;// 最低位
long s5 = b[5] & 0xff;
long s6 = b[6] & 0xff;
long s7 = b[7] & 0xff;
// s0不变
s1 <<= 8;
s2 <<= 16;
s3 <<= 24;
s4 <<= 8 * 4;
s5 <<= 8 * 5;
s6 <<= 8 * 6;
s7 <<= 8 * 7;
s = s0 | s1 | s2 | s3 | s4 | s5 | s6 | s7;
return s;
}
/**
* 注释:int到字节数组的转换!
*
* @param number
* @return
*/
public static byte[] intToByte(int number) {
int temp = number;
byte[] b = new byte[4];
for (int i = 0; i < b.length; i++) {
b[i] = new Integer(temp & 0xff).byteValue();// 将最低位保存在最低位
temp = temp >> 8; // 向右移8位
}
return b;
}
/**
* 注释:字节数组到int的转换!
*
* @param b
* @return
*/
public static int byteToInt(byte[] b) {
int s = 0;
int s0 = b[0] & 0xff;// 最低位
int s1 = b[1] & 0xff;
int s2 = b[2] & 0xff;
int s3 = b[3] & 0xff;
s3 <<= 24;
s2 <<= 16;
s1 <<= 8;
s = s0 | s1 | s2 | s3;
return s;
}
/**
* 注释:short到字节数组的转换!
*
* @param s
* @return
*/
public static byte[] shortToByte(short number) {
int temp = number;
byte[] b = new byte[2];
for (int i = 0; i < b.length; i++) {
b[i] = new Integer(temp & 0xff).byteValue();// 将最低位保存在最低位
temp = temp >> 8; // 向右移8位
}
return b;
}
/**
* 注释:字节数组到short的转换!
*
* @param b
* @return
*/
public static short byteToShort(byte[] b) { short s = 0;
short s0 = (short) (b[0] & 0xff);// 最低位 short s1 = (short) (b[1] & 0xff);
s1 <<= 8;
s = (short) (s0 | s1);
return s;
}。