在java中将3个字节转换为int

我想在Java中将字节转换为int。 我想假设字节是无符号字节。 假设

byte a = (byte)0xFF;

int r = (some operation on byte a);

r的小数位数不应为-1

然后我想从3个字节创建int值。 假设

byte b1 = (byte)0x0F;

byte b2 = (byte)0xFF;

byte b3 = (byte)0xFF;

int r = (some operation in bytes b1, b2 and b3);

那么r应该是

0x000FFFFF

。在int值中，字节b1将置于较高的第3位，字节b3将置于较低的第1位。此外，我的b1将从0x00到0x0F，其他字节将从

0x00

到

0xFF

，假设字节的性质为无符号。如果字节b1大于0x0F，我将只提取最低位的4位。简而言之，我想从3个字节中提取int，但只使用3个字节中的20位。（b2和b3总共16位，b1最低4位）。int r必须为正，因为我们是从3个字节创建的，并且假设字节的无符号性质

以下是一个“仅限轮班”版本：

---

int r=（（b1>>12）|（b2使用位移位运算符和二进制and非常容易。您只需要使用b1的低位4位，这正是
b1&0x0F
所做的。其余的都是将位移位到不同的位置

int r = ( (b1 & 0x0F) << 16) + ((b2 & 0xFF) << 8) + (b3 & 0xFF)

intr=（（b1&0x0F）您必须小心这里的符号扩展-不幸的是，字节是用Java签名的（据我所知，这只会带来悲伤）

所以你必须做一些掩蔽

int r = (b3 & 0xFF) | ((b2 & 0xFF) << 8) | ((b1 & 0x0F) << 16);

intr=（b3&0xFF）|（（b2&0xFF）我假设您需要无符号字节值

int r = ((b1 & 0xF) << 16) | ((b2 & 0xFF) << 8) | (b3 & 0xFF);

intr=（（b1&0xF）我比较了一些答案，因为我很好奇哪个答案最快

波希米亚的方法似乎是最快的，但我无法解释为什么第一次跑慢11%

附：我没有检查答案的正确性

代码如下：

public class Test
{

  public static void main(String[] args)
  {
    final int RUNS = 10;
    final int TRIPLE = 3;
    final int N = 100000000;

    byte[] bytes = new byte[TRIPLE * 32768]; // 96 kB

    Random r = new Random();
    r.nextBytes(bytes);

    List<ByteConvertTester> testers = Arrays.asList(new Harold(), new Bohemian(), new Ppeterka());

    for (int i = 0; i < RUNS; i++)
    {
      System.out.println("RUN#" + i);
      System.out.println("----------------------");
      Integer compare = null;
      for (ByteConvertTester tester : testers)
      {
        System.out.println(tester.getClass().getSimpleName());
        long time = testAndMeasure(tester, bytes, N);
        System.out.print("time (in ms): " + time);
        if (compare != null) {
          System.out.println(" SpeedUp%: " + (double) ((int) (10000 * (1.0d - (double) time / compare))) / 100);
        } else {
          compare = (int) time;
          System.out.println();
        }
      }
      System.out.println("----------------------");
    }
  }

  private static long testAndMeasure(ByteConvertTester bct, byte[] bytes, int loops)
  {
    Calendar start = Calendar.getInstance();
    int r;
    for (int i = 0; i < loops; i += 3)
      r = bct.test(bytes[i % bytes.length], bytes[(i + 1) % bytes.length], bytes[(i + 2) % bytes.length]);

    Calendar end = Calendar.getInstance();
    long time = (end.getTimeInMillis() - start.getTimeInMillis());
    return time;
  }
}

interface ByteConvertTester
{
  public int test(byte msb, byte mid, byte lsb);
}

class Harold implements ByteConvertTester
{
  @Override
  public int test(byte msb, byte mid, byte lsb)
  {
    return (lsb & 0xFF) | ((mid & 0xFF) << 8) | ((msb & 0x0F) << 16);
  }
}

class Bohemian implements ByteConvertTester
{
  @Override
  public int test(byte msb, byte mid, byte lsb)
  {
    return ((msb << 28) >>> 12) | (mid << 8) | lsb;
  }
}

class Ppeterka implements ByteConvertTester
{

  @Override
  public int test(byte msb, byte mid, byte lsb)
  {
    return ((msb & 0x0F) << 16) + ((mid & 0xFF) << 8) + (lsb & 0xFF);
  }
}

你能解释一下你期望通过过度移位来实现什么吗？哇，移位36位来切掉最上面的4位：）Eeeeevil:）我喜欢这样！每天都能学到一些东西是一种乐趣！这将标志着扩展第20位。如果你不想用
>>
@Bohemian，你可以用一个简单的面具（使用&）来切割正如佩特卡·索霍在他/她的回答中所说的那样。@PeterLawrey你是对的。顺便说一句，我的移位量也错了：（.Fixed now（并经过测试）。我尝试了上面的-public class Main{public static void Main（String[]args）{byte b1=（byte）0x0f；byte b2=（byte）0xff；byte b3=（byte）0xff；int r=（b1&0x0F谢谢你，但你的解决方案是错误的。当我从b3而不是b1开始时，正如哈罗德所说，它给了我正确的答案。使用你的解决方案，它给了我32640，我想要1048575。比如说
b1=AB
，
b2=CD
和
b3=0E
你想要
AB CD0E
还是
0E CDAB
？@jlordo，我想要0B CD0E，我想要nt只使用b1的低4位。@user1508907在我的解决方案中发现了错误并修复了它。现在您的问题有了一个通用的解决方案…谢谢harold，我用您的解决方案得到了正确的答案。请解释一下为什么颠倒顺序，我的意思是从上面的b1开始，它给了我32640，这就是@ppeterka发布的解决方案。@user1508907 well顺序并不重要，但ppeterka的回答可能与
+
绑定的问题比
更强烈。是的，我知道了。ppeteka没有使用括号。由于运算符的优先规则，解决方案变得混乱
public class Test
{

  public static void main(String[] args)
  {
    final int RUNS = 10;
    final int TRIPLE = 3;
    final int N = 100000000;

    byte[] bytes = new byte[TRIPLE * 32768]; // 96 kB

    Random r = new Random();
    r.nextBytes(bytes);

    List<ByteConvertTester> testers = Arrays.asList(new Harold(), new Bohemian(), new Ppeterka());

    for (int i = 0; i < RUNS; i++)
    {
      System.out.println("RUN#" + i);
      System.out.println("----------------------");
      Integer compare = null;
      for (ByteConvertTester tester : testers)
      {
        System.out.println(tester.getClass().getSimpleName());
        long time = testAndMeasure(tester, bytes, N);
        System.out.print("time (in ms): " + time);
        if (compare != null) {
          System.out.println(" SpeedUp%: " + (double) ((int) (10000 * (1.0d - (double) time / compare))) / 100);
        } else {
          compare = (int) time;
          System.out.println();
        }
      }
      System.out.println("----------------------");
    }
  }

  private static long testAndMeasure(ByteConvertTester bct, byte[] bytes, int loops)
  {
    Calendar start = Calendar.getInstance();
    int r;
    for (int i = 0; i < loops; i += 3)
      r = bct.test(bytes[i % bytes.length], bytes[(i + 1) % bytes.length], bytes[(i + 2) % bytes.length]);

    Calendar end = Calendar.getInstance();
    long time = (end.getTimeInMillis() - start.getTimeInMillis());
    return time;
  }
}

interface ByteConvertTester
{
  public int test(byte msb, byte mid, byte lsb);
}

class Harold implements ByteConvertTester
{
  @Override
  public int test(byte msb, byte mid, byte lsb)
  {
    return (lsb & 0xFF) | ((mid & 0xFF) << 8) | ((msb & 0x0F) << 16);
  }
}

class Bohemian implements ByteConvertTester
{
  @Override
  public int test(byte msb, byte mid, byte lsb)
  {
    return ((msb << 28) >>> 12) | (mid << 8) | lsb;
  }
}

class Ppeterka implements ByteConvertTester
{

  @Override
  public int test(byte msb, byte mid, byte lsb)
  {
    return ((msb & 0x0F) << 16) + ((mid & 0xFF) << 8) + (lsb & 0xFF);
  }
}

RUN#0
----------------------
Harold
time (in ms): 489
Bohemian
time (in ms): 547 SpeedUp%: -11.86
Ppeterka
time (in ms): 479 SpeedUp%: 2.04
----------------------
RUN#1
----------------------
Harold
time (in ms): 531
Bohemian
time (in ms): 521 SpeedUp%: 1.88
Ppeterka
time (in ms): 537 SpeedUp%: -1.12
----------------------
RUN#2
----------------------
Harold
time (in ms): 531
Bohemian
time (in ms): 539 SpeedUp%: -1.5
Ppeterka
time (in ms): 532 SpeedUp%: -0.18
----------------------
RUN#3
----------------------
Harold
time (in ms): 529
Bohemian
time (in ms): 519 SpeedUp%: 1.89
Ppeterka
time (in ms): 531 SpeedUp%: -0.37
----------------------
RUN#4
----------------------
Harold
time (in ms): 527
Bohemian
time (in ms): 519 SpeedUp%: 1.51
Ppeterka
time (in ms): 530 SpeedUp%: -0.56
----------------------
RUN#5
----------------------
Harold
time (in ms): 528
Bohemian
time (in ms): 519 SpeedUp%: 1.7
Ppeterka
time (in ms): 532 SpeedUp%: -0.75
----------------------
RUN#6
----------------------
Harold
time (in ms): 529
Bohemian
time (in ms): 520 SpeedUp%: 1.7
Ppeterka
time (in ms): 532 SpeedUp%: -0.56
----------------------
RUN#7
----------------------
Harold
time (in ms): 529
Bohemian
time (in ms): 520 SpeedUp%: 1.7
Ppeterka
time (in ms): 533 SpeedUp%: -0.75
----------------------
RUN#8
----------------------
Harold
time (in ms): 530
Bohemian
time (in ms): 521 SpeedUp%: 1.69
Ppeterka
time (in ms): 532 SpeedUp%: -0.37
----------------------
RUN#9
----------------------
Harold
time (in ms): 529
Bohemian
time (in ms): 527 SpeedUp%: 0.37
Ppeterka
time (in ms): 530 SpeedUp%: -0.18
----------------------