Android中int,short,long和byte的转换

最新推荐文章于 2024-08-09 15:12:40 发布
最新推荐文章于 2024-08-09 15:12:40 发布
阅读量2.7k 收藏
点赞数
分类专栏： android开发
import java.nio.ByteOrder;
 
public class BytesTransUtils {
 
      private String TAG = "BytesTransUtils" ;
      private static BytesTransUtils instance = null ;
     
      private BytesTransUtils() {
       // Log.i(TAG, "instance BytesTransUtils");
      }
     
      public static BytesTransUtils getInstance() {
           if (instance == null ) {
               instance = new BytesTransUtils();
           }
           
           return instance;
      }
     
      public boolean testCPU() {
           if (ByteOrder.nativeOrder() == ByteOrder.BIG_ENDIAN) {
                // System.out.println("is big ending");
                return true ;
           } else {
                // System.out.println("is little ending");
                return false ;
           }
      }
     
      public byte [] getBytes( short s, boolean bBigEnding) {
           byte [] buf = new byte [ 2 ];
           
           if (bBigEnding){
                for ( int i = buf.length - 1 ; i >= 0 ; i--) {
                     buf[i] = ( byte ) (s & 0x00ff );
                     s >>= 8 ;
                 }
           }
           else {
                for ( int i = 0 ; i < buf.length; i++) {
                     buf[i] = ( byte ) (s & 0x00ff );
                     s >>= 8 ;
                }
           }
           
           return buf;
      }
     
      public byte [] getBytes( int s, boolean bBigEnding) {
           byte [] buf = new byte [ 4 ];
           
           if (bBigEnding) {
                for ( int i = buf.length - 1 ; i >= 0 ; i--) {
                     buf[i] = ( byte ) (s & 0x000000ff );
                     s >>= 8 ;
                }
           } else {
                System.out.println( "1" );
                for ( int i = 0 ; i < buf.length; i++) {
                     buf[i] = ( byte ) (s & 0x000000ff );
                     s >>= 8 ;
                }
           }
           
           return buf;
      }
     
      public byte [] getBytes( long s, boolean bBigEnding) {
           byte [] buf = new byte [ 8 ];
           
           if (bBigEnding) {
                for ( int i = buf.length - 1 ; i >= 0 ; i--) {
                     buf[i] = ( byte ) (s & 0x00000000000000ff );
                     s >>= 8 ;
                }
           }
           else {
                for ( int i = 0 ; i < buf.length; i++) {
                     buf[i] = ( byte ) (s & 0x00000000000000ff );
                     s >>= 8 ;
                }
           }
           
           return buf;
      }
     
      public short getShort( byte [] buf, boolean bBigEnding) {
           if (buf == null ) {
               throw new IllegalArgumentException( "byte array is null!" );
           }
           
           if (buf.length > 2 ) {
               throw new IllegalArgumentException( "byte array size > 2 !" );
           }
           
           short r = 0 ;
           if (bBigEnding) {
               for ( int i = 0 ; i < buf.length; i++) {
                   r <<= 8 ;
                   r |= (buf[i] & 0x00ff );
               }
           } else {
               for ( int i = buf.length - 1 ; i >= 0 ; i--) {
                   r <<= 8 ;
                   r |= (buf[i] & 0x00ff );
               }
           }
         
           return r;
      }
     
      public int getInt( byte [] buf, boolean bBigEnding) {
           if (buf == null ) {
               throw new IllegalArgumentException( "byte array is null!" );
           }
           
           if (buf.length > 4 ) {
               throw new IllegalArgumentException( "byte array size > 4 !" );
           }
           
           int r = 0 ;
           if (bBigEnding) {
               for ( int i = 0 ; i < buf.length; i++) {
                   r <<= 8 ;
                   r |= (buf[i] & 0x000000ff );
               }
           } else {
               for ( int i = buf.length - 1 ; i >= 0 ; i--) {
                   r <<= 8 ;
                   r |= (buf[i] & 0x000000ff );
               }
           }
           
           return r;
      }
     
      public long getLong( byte [] buf, boolean bBigEnding) {
           if (buf == null ) {
               throw new IllegalArgumentException( "byte array is null!" );
           }
           
           if (buf.length > 8 ) {
               throw new IllegalArgumentException( "byte array size > 8 !" );
           }
           
           long r = 0 ;
           if (bBigEnding) {
               for ( int i = 0 ; i < buf.length; i++) {
                   r <<= 8 ;
                   r |= (buf[i] & 0x00000000000000ff );
               }
           } else {
               for ( int i = buf.length - 1 ; i >= 0 ; i--) {
                   r <<= 8 ;
                   r |= (buf[i] & 0x00000000000000ff );
               }
           }
           
           return r;
      }
     
      /*----------------------------------------------------------*/
      /* 对转换进行一个简单的封装 */
      /*----------------------------------------------------------*/
      public byte [] getBytes( int i) {
          return getBytes(i, this .testCPU());
      }
     
      public byte [] getBytes( short s) {
          return getBytes(s, this .testCPU());
      }
     
      public byte [] getBytes( long l) {
          return getBytes(l, this .testCPU());
      }
     
      public int getInt( byte [] buf) {
          return getInt(buf, this .testCPU());
      }
     
      public short getShort( byte [] buf) {
          return getShort(buf, this .testCPU());
      }
     
      public long getLong( byte [] buf) {
          return getLong(buf, this .testCPU());
      }
     
      /****************************************/
      public short [] Bytes2Shorts( byte [] buf) {
          byte bLength = 2 ;
          short [] s = new short [buf.length / bLength];
          
          for ( int iLoop = 0 ; iLoop < s.length; iLoop++) {
              byte [] temp = new byte [bLength];
              
              for ( int jLoop = 0 ; jLoop < bLength; jLoop++) {
                  temp[jLoop] = buf[iLoop * bLength + jLoop];
              }
              
              s[iLoop] = getShort(temp);
          }
          
          return s;
      }
     
      public byte [] Shorts2Bytes( short [] s) {
          byte bLength = 2 ;
          byte [] buf = new byte [s.length * bLength];
          
          for ( int iLoop = 0 ; iLoop < s.length; iLoop++) {
              byte [] temp = getBytes(s[iLoop]);
              
              for ( int jLoop = 0 ; jLoop < bLength; jLoop++) {
                  buf[iLoop * bLength + jLoop] = temp[jLoop];
              }
          }
          
          return buf;
      }
     
      /****************************************/
      public int [] Bytes2Ints( byte [] buf) {
          byte bLength = 4 ;
          int [] s = new int [buf.length / bLength];
          
          for ( int iLoop = 0 ; iLoop < s.length; iLoop++) {
              byte [] temp = new byte [bLength];
              
              for ( int jLoop = 0 ; jLoop < bLength; jLoop++) {
                  temp[jLoop] = buf[iLoop * bLength + jLoop];
              }
              
              s[iLoop] = getInt(temp);
              
              System.out.println( "2out->" +s[iLoop]);
          }
          
          return s;
      }
     
      public byte [] Ints2Bytes( int [] s) {
          byte bLength = 4 ;
          byte [] buf = new byte [s.length * bLength];
          
          for ( int iLoop = 0 ; iLoop < s.length; iLoop++) {
              byte [] temp = getBytes(s[iLoop]);
              
              System.out.println( "1out->" +s[iLoop]);
              
              for ( int jLoop = 0 ; jLoop < bLength; jLoop++) {
                  buf[iLoop * bLength + jLoop] = temp[jLoop];
              }
          }
          
          return buf;
      }
     
      /****************************************/
      public long [] Bytes2Longs( byte [] buf) {
          byte bLength = 8 ;
          long [] s = new long [buf.length / bLength];
          
          for ( int iLoop = 0 ; iLoop < s.length; iLoop++) {
              byte [] temp = new byte [bLength];
              
              for ( int jLoop = 0 ; jLoop < bLength; jLoop++) {
                  temp[jLoop] = buf[iLoop * bLength + jLoop];
              }
              
              s[iLoop] = getLong(temp);
          }
          
          return s;
      }
     
      public byte [] Longs2Bytes( long [] s) {
          byte bLength = 8 ;
          byte [] buf = new byte [s.length * bLength];
          
          for ( int iLoop = 0 ; iLoop < s.length; iLoop++) {
              byte [] temp = getBytes(s[iLoop]);
              
              for ( int jLoop = 0 ; jLoop < bLength; jLoop++) {
                  buf[iLoop * bLength + jLoop] = temp[jLoop];
              }
          }
          
          return buf;
      }
 
}
ljcmeng
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java/Android 将字节数(long) 转化为KB,MB
qq_36335563的博客
03-13 1285
之前遇到了字节转化对应KB/MB的问题,这里记录一下,以便学习交流,不足之处,敬请指出.废话不多说,上代码. private String getFormatSize(long size) { //这里限定了输入 1T以内 不包括1T if (size <= 0 || size >= 1024 * 1024 * 1024) { t...
android中byte[] short[] int[] long[]数组数据转换
Android4chodison
04-16 2184
import java.nio.ByteOrder; public class BytesTransUtils { private String TAG = "BytesTransUtils"; private static BytesTransUtils instance = null; private BytesTransUtils() { // Lo
java android int和byte[]互转 short和byte[]互转
代码是贝多芬的音符
02-16 876
【代码】java android int和byte[]互转 short和byte[]互转。
android byte数组转int，int转byte数组，byte数组拷贝，byte数组拼接
最新发布
Rainman博的专栏
08-09 436
你可以根据需要选择最适合你的转换方法。如果不确定字节序，使用ByteBuffer是一种灵活且易于维护的方法。
Android中byte数组的转换
stop_pig的专栏
05-04 3721
package com.anyfish.common.api; //数据转换类 public class DataSwitch { public static long bytesToLong(byte[] bytes,int offset) { long l64; l64=0l; l64 =  (long)bytes[offset]&0xff; l64 |= (l
int与short之间的转换
chssheng2007的专栏
09-03 1万+
 写的一个 int 转 short 的类     前些时间做蓝牙.标准的蓝牙类没法建数据流,后来就出现了只能传送byte 可是我们的程序中数据类型有很多,所以必要做转化.这里做了个int转short的方法.     public class test   {    public static void main(String[] args)    {     System.out.println("-----     Test  ----------");           System.out.prin
java byte数组与int,long,short,byte的转换实现方法
09-01
本文将详细介绍如何在Java中将`byte`数组与其他基本数据类型（如`int`、`long`、`short`、`byte`）之间进行转换。 首先，我们来看`byte`到`int`的转换。Java中的`byte`类型是8位的，取值范围是-128到127。如果要将...
android byte[] 和short[]转换的方法代码
09-04
本篇文章将详细讲解如何在Android中进行 `byte[]` 与 `short[]` 的转换，并提供相应的代码示例。 1. **简介** 在Android系统中，`byte` 类型用于表示8位的无符号整数，取值范围是0到255。而 `short` 类型则是一个16...
Java中的基本数据类型byte、short、int和long
weixin_45155098的博客
11-02 5463
一、byte byte的表示位数为-128~127 当我们byte num01 = 128时，数字超过的byte的表示范围，会报错，因为128默认为int型； 所以我们要遵从：当表示范围大的数据类型转换成表示范围小的数据类型时，要强制转换 byte num01 = (byte)128得到-128（这里可以理解成127+1得到-128，回到最小，也表示-0） 注意：byte num01 = 1，num02 = 2；byte num03= num01+num02；也会报错 原因：int类型进
long、int和short与byte之间的转化
brickworkers的博客
04-01 1万+
昨天有个朋友问我long转byte要怎么转，然后吃饭期间我问了身边的人，发现也不会转。所以我想有必要写一些位操作符和转化规则，同时还有一些不常用，但是源码中经常出现的操作符。不可能所有的都写出来，但是举一反三就可以了。在技术点中介绍一些不常用但是常见的操作符，后半部分展示实现转化的代码。
将一个输入的int型数值转换到short范围内
热门推荐
whutlhc的博客
09-12 2万+
代码如下 static inline short convert(int value) { return short((value == short(value)) ? value:(value&gt;&gt;31)^Ox7FFF); } &nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 本题目基于32位的机器，代码的意思很容易理解，就是输入一...
java int转byte和long转byte的方法
09-01
下面小编就为大家带来一篇java int转byte和long转byte的方法。小编觉得挺不错的，现在就分享给大家，也给大家做个参考。一起跟随小编过来看看吧
byte数组转换工具类 byte数组转int，byte数组转short，short转byte数组
09-19
byte数组操作的工具类，支持byte数组转int，int转byte数组，byte数组转short，short转byte数组。。。 下载的人多了，csdn会自动涨分，现在可以手动调了，我给降到最低了
long类型值与bytes数组互转
分享式获得也是一种学习的态度
07-05 3300
每个人都有惰性，但不断学习是好好生活的根本，共勉！
变量的存储深入
soboer
10-19 213
变量值的存储变量被定义以后，系统在运行时会为该变量分配一个相应大小的存储空间，称为存储单元。 给变量赋值后，该变量对应的存储单元中会存放该值，这个值称为变量的值。 那么变量的值在变量的存储单元中是如何表示的呢？（1）整数是以补码的形式存放的。（正数的补码是其本身，负数的补码为原码按位取反加1） 如：int a=2, b; b= -2; (这里int是2个字节) a 00000000 00...
long、int与byte数组之间的相互转换
weixin_30426065的博客
07-08 119
byte数组转换成longpublic long byteArrayToLong(byte[] data) throws IOException { ByteArrayInputStream bai = new ByteArrayInputStream(data); DataInputStream dis =new DataInputStream(bai); return...
long类型数组转换成byte
心中无码
08-23 4342
问题描述： 有long类型的数组 long[] a，如何转化为byte、int类型 byte[] b 问题泛化：如何把类型A的数组、集合(List、Map、Stack等)转化为类型B . import java.util.Arrays; public class Main { public static void main(String[] args) { // We have a long type array, and want to convert to byte ar
longlong与byte数组互转
CODE实验室
03-01 9150
最近做通讯，自己写报文协议，收发4字节16进制数。将十进制与16进制转化，还区分有无符号，自己写的程序70多行，发现这位大神写的极为简单，测试半天没有错误，标记一下，待后期再深究。 原文： 参考简书：https://www.jianshu.com/p/0d75db2b3c14 作者：InterestingPDD 最近做一个项目 要传udp包 包里包含很多信息 就是把一些信息用byte表示...
short自动转int的小例子
qq_41268447的博客
08-18 3187
给大家分享一个做试题时遇到的一个很有意思的小例子 package com.Teng; public class Test1 { public static void main(String[] args) { // TODO Auto-generated method stub short y = 6; long z = 7; go(y); go(z); } pu...
byte int short long怎么执行
04-11
byte、int、short和long都是 Java 的原始数据类型，它们分别表示不同的数字范围。byte 的范围是 -128 到 127，short 的范围是 -32768 到 32767，int 的范围是 -2147483648 到 2147483647，long 的范围是 -...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值