有没有办法在java中创建一个128位对象，可以像long或int那样进行位操作？我想做32位移位，我希望能够对整个128位结构进行一些OR运算。
答案 0 :(得分：4)
在这里，我向你介绍......一个古老的想法。现在它被降级（没有代码增强器，没有任何东西）到简单的128位东西，应该超级快。我真正想要的是一个基于ByteBuffer的C类似结构数组，但在java中完全可用。
主要思想是一次分配多个对象并使用指向数组的指针。因此，它极大地节省了内存，并且内存在连续区域中分配，因此缓存丢失较少（总是很好）。
我做了一些温和的测试（但代码仍未经过测试）。 它允许基本操作，如add，xor，或set / get，具有128位数字。 标准规则：遗憾的是，文档少于预期。 为额外操作添加额外的代码应该是直截了当的。
这是代码，请看一些用法的主要方法。干杯！
package bestsss.util;
import java.util.Random;
public class Bitz {
final int[] array;
private Bitz(int n){
array=new int[n<<2];
}
public int size(){
return size(this.array);
}
private static int size(int[] array){
return array.length>>2;
}
/**
* allocates N 128bit elements. newIdx to create a pointer
* @param n
* @return
*/
public static Bitz allocate(int n){
return new Bitz(n);
}
/**
* Main utility class - points to an index in the array
* @param idx
* @return
*/
public Idx newIdx(int idx){
return new Idx(array).set(idx);
}
public static class Idx{
private static final long mask = 0xFFFFFFFFL;
//dont make the field finals
int idx;
int[] array;//keep ref. here, reduce the indirection
Idx(int[] array){
this.array=array;
}
public Idx set(int idx) {
if (Bitz.size(array)<=idx || idx<0)
throw new IndexOutOfBoundsException(String.valueOf(idx));
this.idx = idx<<2;
return this;
}
public int index(){
return idx>>2;
}
public Idx shl32(){
final int[] array=this.array;
int idx = this.idx;
array[idx]=array[++idx];
array[idx]=array[++idx];
array[idx]=array[++idx];
array[idx]=0;
return this;
}
public Idx shr32(){
final int[] array=this.array;
int idx = this.idx+3;
array[idx]=array[--idx];
array[idx]=array[--idx];
array[idx]=array[--idx];
array[idx]=0;
return this;
}
public Idx or(Idx src){
final int[] array=this.array;
int idx = this.idx;
int idx2 = src.idx;
final int[] array2=src.array;
array[idx++]|=array2[idx2++];
array[idx++]|=array2[idx2++];
array[idx++]|=array2[idx2++];
array[idx++]|=array2[idx2++];
return this;
}
public Idx xor(Idx src){
final int[] array=this.array;
int idx = this.idx;
int idx2 = src.idx;
final int[] array2=src.array;
array[idx++]^=array2[idx2++];
array[idx++]^=array2[idx2++];
array[idx++]^=array2[idx2++];
array[idx++]^=array2[idx2++];
return this;
}
public Idx add(Idx src){
final int[] array=this.array;
int idx = this.idx+3;
final int[] array2=src.array;
int idx2 = src.idx+3;
long l =0;
l += array[idx]&mask;
l += array2[idx2--]&mask;
array[idx--]=(int)(l&mask);
l>>>=32;
l += array[idx]&mask;
l += array2[idx2--]&mask;
array[idx--]=(int)(l&mask);
l>>>=32;
l += array[idx]&mask;
l += array2[idx2--]&mask;
array[idx--]=(int)(l&mask);
l>>>=32;
l += array[idx]&mask;
l += array2[idx2--];
array[idx]=(int)(l&mask);
// l>>>=32;
return this;
}
public Idx set(long high, long low){
final int[] array=this.array;
int idx = this.idx;
array[idx+0]=(int) ((high>>>32)&mask);
array[idx+1]=(int) ((high>>>0)&mask);
array[idx+2]=(int) ((low>>>32)&mask);
array[idx+3]=(int) ((low>>>0)&mask);
return this;
}
public long high(){
final int[] array=this.array;
int idx = this.idx;
long res = (array[idx]&mask)<<32 | (array[idx+1]&mask);
return res;
}
public long low(){
final int[] array=this.array;
int idx = this.idx;
long res = (array[idx+2]&mask)<<32 | (array[idx+3]&mask);
return res;
}
//ineffective but well
public String toString(){
return String.format("%016x-%016x", high(), low());
}
}
public static void main(String[] args) {
Bitz bitz = Bitz.allocate(256);
Bitz.Idx idx = bitz.newIdx(0);
Bitz.Idx idx2 = bitz.newIdx(2);
System.out.println(idx.set(0, 0xf));
System.out.println(idx2.set(0, Long.MIN_VALUE).xor(idx));
System.out.println(idx.set(0, Long.MAX_VALUE).add(idx2.set(0, 1)));
System.out.println("==");
System.out.println(idx.add(idx));//can add itself
System.out.println(idx.shl32());//left
System.out.println(idx.shr32());//and right
System.out.println(idx.shl32());//back left
//w/ alloc
System.out.println(idx.add(bitz.newIdx(4).set(0, Long.MAX_VALUE)));
//self xor
System.out.println(idx.xor(idx));
//random xor
System.out.println("===init random===");
Random r = new Random(1112);
for (int i=0, s=bitz.size(); i<s; i++){
idx.set(i).set(r.nextLong(), r.nextLong());
System.out.println(idx);
}
Idx theXor = bitz.newIdx(0);
for (int i=1, s=bitz.size(); i<s; i++){
theXor.xor(idx.set(i));
}
System.out.println("===XOR===");
System.out.println(theXor);
}
}
答案 1 :(得分：3)
已确定三种可能性：
BitSet类提供了您需要的一些操作，但没有“shift”方法。要实现这种缺失的方法，您需要执行以下操作：
BitSet bits = new BitSet(128);
...
// shift left by 32bits
for (int i = 0; i < 96; i++) {
bits.set(i, bits.get(i + 32));
}
bits.set(96, 127, false);
BigInteger类提供了所有方法（或多或少），但由于BigInteger是不可变的，可能导致过多的对象创建率...取决于你如何使用bitsets。 （还有一个问题是shiftLeft(32)不会删除最左边的位...但是你可以通过使用and来掩盖索引128及更高位的位来解决这个问题。）
如果性能是您的主要考虑因素，那么实施包含4个int或2个long字段的自定义类可能会提供最佳性能。 （这实际上两者中更快的选择将取决于硬件平台，JVM等。我可能会选择long版本，因为它更容易编码......并且只是尝试进一步优化如果分析表明这是一项有潜在价值的活动。）
此外，您可以将API设计为完全按照您的要求运行（以Java语言的约束为模）。缺点是您必须实现并测试所有内容，并且您将把神奇的数字128连接到代码库中。
答案 2 :(得分：2)
不再有long的数据类型（我已将其记录为RFE以及128位浮点数;）
您可以创建一个包含四个32位int值的对象，并且可以非常轻松地支持这些操作。
答案 3 :(得分：1)
否
抱歉没有更好的答案。
一种方法可能是为两个长值创建包装器对象，并在考虑相关运算符的签名的同时实现所需的功能。还有BigInteger [从rlibby的答案更新]，但它没有提供所需的支持。
快乐的编码。
答案 4 :(得分：1)
您无法定义可以应用Java内置按位运算符的任何新类型。
但是，您可以使用java.math.BigInteger吗？ BigInteger定义了为整数类型定义的所有按位操作（作为方法）。例如，这包括BigInteger.or(BigInteger)。
答案 5 :(得分：1)
或许BitSet对您有用。
它具有逻辑运算，并且我认为根据它们的实用方法，转移并不是那么难以实现。
答案 6 :(得分：0)
Afaik，JVM只会将您编码的任何内容转换为32位块，无论您做什么。 JVM是32位。我认为即使是64位版本的JVM也主要以32位块的形式处理。它当然应该节省内存......当JIT试图优化您创建的混乱时，您只会减慢代码速度。在C / C ++等中，没有必要这么做，因为你最有可能使用的硬件中的32位或64位寄存器仍会产生阻抗。即使是Intel Xenon Phi（具有512位向量寄存器）也只是32位和64位元素的串联。
如果你想实现类似的东西，你可以尝试在GLSL或OpenCL中使用GPU硬件。 2015年Java Sumatra将作为Java 9的一部分发布，至少这是计划。然后，您将能够将Java与GPU代码集成在一起。这是一个大问题，因此这个杰出的名字！