首页 / JAVA / Java优先级 – 转换和按位运算符
Java优先级 – 转换和按位运算符
内容导读
互联网集市收集整理的这篇技术教程文章主要介绍了Java优先级 – 转换和按位运算符，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含8272字，纯文字阅读大概需要12分钟。
内容图文
我很难理解一些代码,这些代码显示了如何将Java中的double转换为byte []的示例,反之亦然.
以下是用于将double转换为byte []的代码：
public static byte [] doubleToByteArray (double numDouble)
{
byte [] arrayByte = new byte [8];
long numLong;
// Takes the double and sticks it into a long, without changing it
numLong = Double.doubleToRawLongBits(numDouble);
// Then we need to isolate each byte
// The casting of byte (byte), captures only the 8 rightmost bytes
arrayByte[0] = (byte)(numLong >>> 56);
arrayByte[1] = (byte)(numLong >>> 48);
arrayByte[2] = (byte)(numLong >>> 40);
arrayByte[3] = (byte)(numLong >>> 32);
arrayByte[4] = (byte)(numLong >>> 24);
arrayByte[5] = (byte)(numLong >>> 16);
arrayByte[6] = (byte)(numLong >>> 8);
arrayByte[7] = (byte)numLong;
for (int i = 0; i < arrayByte.length; i++) {
System.out.println("arrayByte[" + i + "] = " + arrayByte[i]);
}
return arrayByte;
}
这里是用于将byte []转换回double的代码：
public static double byteArrayToDouble (byte [] arrayByte)
{
double numDouble;
long numLong;
// When putting byte into long, java also adds the sign
// However, we don't want to put bits that are not from the orignal value
//
// The rightmost bits left unaltered because we "and" them with a 1
// The left bits become 0 because we "and" them with a 0
//
// We are applying a "mask" (& 0x00 ... FFL)
// 0 & 0 = 0
// 0 & 1 = 0
// 1 & 0 = 0
// 1 & 1 = 1
//
// So, the expression will put byte in the long (puts it into the right most position)
// Then we apply mask to remove the sign applied by java
// Then we move the byte into its position (shift left 56 bits, then 48 bits, etc.)
// We end up with 8 longs, that each have a byte set up in the appropriate position
// By doing an | with each one of them, we combine them all into the orignal long
//
// Then we use Double.longBitsToDouble, to convert the long bytes into double.
numLong = (((long)arrayByte[0] & 0x00000000000000FFL) << 56) | (((long)arrayByte[1] & 0x00000000000000FFL) << 48) |
(((long)arrayByte[2] & 0x00000000000000FFL) << 40) | (((long)arrayByte[3] & 0x00000000000000FFL) << 32) |
(((long)arrayByte[4] & 0x00000000000000FFL) << 24) | (((long)arrayByte[5] & 0x00000000000000FFL) << 16) |
(((long)arrayByte[6] & 0x00000000000000FFL) << 8) | ((long)arrayByte[7] & 0x00000000000000FFL);
numDouble = Double.longBitsToDouble(numLong);
return numDouble;
}
好的,这是我不太了解的部分.
((long)arrayByte[0] & 0x00000000000000FFL) << 56
似乎演员在实际的按位操作之前发生,因为作者说
the expression will put byte in the long […] Then we apply mask to remove the sign applied by java
为什么字节在实际转换之前被转换为很长时间？操作不应该像这样吗？
(((long)arrayByte[0]) & 0x00000000000000FFL) << 56
还是有其他我不明白的东西？
解决方法:
这是由于运算符优先级和关联性在Java.1中的工作原理
不幸的是,Oracle Java Tutorial只提供了部分概述,而Java Language Specification也没有太大的帮助,因为它主要是通过陈述以下方式来确定运算符优先级给读者：
Precedence among operators is managed by a hierarchy of grammar productions.
通常,表达式从左到右进行评估.在运算符优先级方面,以下表2适用：
╔═══════╦══════════════╦══════════════════════╦═════════════════╗
║ Level ║ Operator ║ Description ║ Associativity ║
╠═══════╬══════════════╬══════════════════════╬═════════════════╣
║ 16 ║ [] ║ access array element ║ left to right ║
║ ║ . ║ access object member ║ ║
║ ║ () ║ parentheses ║ ║
╠═══════╬══════════════╬══════════════════════╬═════════════════╣
║ 15 ║ ++ ║ unary post-increment ║ not associative ║
║ ║ -- ║ unary post-decrement ║ ║
╠═══════╬══════════════╬══════════════════════╬═════════════════╣
║ 14 ║ ++ ║ unary pre-increment ║ right to left ║
║ ║ -- ║ unary pre-decrement ║ ║
║ ║ + ║ unary plus ║ ║
║ ║ - ║ unary minus ║ ║
║ ║ ! ║ unary logical NOT ║ ║
║ ║ ~ ║ unary bitwise NOT ║ ║
╠═══════╬══════════════╬══════════════════════╬═════════════════╣
║ 13 ║ () ║ cast ║ right to left ║
║ ║ new ║ object creation ║ ║
╠═══════╬══════════════╬══════════════════════╬═════════════════╣
║ 12 ║ * ║ multiplicative ║ left to right ║
║ ║ / ║ ║ ║
║ ║ % ║ ║ ║
╠═══════╬══════════════╬══════════════════════╬═════════════════╣
║ 11 ║ + - ║ additive ║ left to right ║
║ ║ + ║ string concatenation ║ ║
╠═══════╬══════════════╬══════════════════════╬═════════════════╣
║ 10 ║ << >> ║ shift ║ left to right ║
║ ║ >>> ║ ║ ║
╠═══════╬══════════════╬══════════════════════╬═════════════════╣
║ 9 ║ < <= ║ relational ║ not associative ║
║ ║ > >= ║ ║ ║
║ ║ instanceof ║ ║ ║
╠═══════╬══════════════╬══════════════════════╬═════════════════╣
║ 8 ║ == ║ equality ║ left to right ║
║ ║ != ║ ║ ║
╠═══════╬══════════════╬══════════════════════╬═════════════════╣
║ 7 ║ & ║ bitwise AND ║ left to right ║
╠═══════╬══════════════╬══════════════════════╬═════════════════╣
║ 6 ║ ^ ║ bitwise XOR ║ left to right ║
╠═══════╬══════════════╬══════════════════════╬═════════════════╣
║ 5 ║ | ║ bitwise OR ║ left to right ║
╠═══════╬══════════════╬══════════════════════╬═════════════════╣
║ 4 ║ && ║ logical AND ║ left to right ║
╠═══════╬══════════════╬══════════════════════╬═════════════════╣
║ 3 ║ || ║ logical OR ║ left to right ║
╠═══════╬══════════════╬══════════════════════╬═════════════════╣
║ 2 ║ ?: ║ ternary ║ right to left ║
╠═══════╬══════════════╬══════════════════════╬═════════════════╣
║ 1 ║ = += -= ║ assignment ║ right to left ║
║ ║ *= /= %= ║ ║ ║
║ ║ &= ^= |= ║ ║ ║
║ ║ <<= >>= >>>= ║ ║ ║
╚═══════╩══════════════╩══════════════════════╩═════════════════╝
对于您的特定问题,这意味着不需要在强制转换操作周围放置额外的括号,因为强制转换运算符()的优先级高于按位AND和&的强度.运算符(13级与7级).
1我写这篇文章是一个规范的答案,用于解决有关Java中运算符优先级和关联性的问题.我找到了许多现有的答案,给出了部分信息,但我找不到一个概述完整优先级和关联表的人.
2运算符优先级和关联表从https://introcs.cs.princeton.edu/java/11precedence/再现.
内容总结
以上是互联网集市为您收集整理的Java优先级 – 转换和按位运算符全部内容，希望文章能够帮你解决Java优先级 – 转换和按位运算符所遇到的程序开发问题。 如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。
内容备注
版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。
内容手机端
扫描二维码推送至手机访问。