Java中的快速位操作

我试图创建一个程序，快速生成特定的序列

通过迭代给出顺序，如下所示：

new = old + 1 + (-1*(old reversed))

例如：

old = [1]
new = [1]+[1]+[-1] = [1, 1, -1]

old = [1, 1, -1]
new = [1, 1, -1] + [1] + [1, -1, -1] = [1, 1, -1, 1, 1, -1, -1]

我希望这个过程尽可能快，我认为由于序列只包含-1或1，我可以使用逐位运算，让每个位表示

true

或

false

，然后我可以映射到

-1

或

1

然后我得到了一个位序列，我可以使用逐位操作来处理它。我有一个自定义类，它创建一个

长[]

，并将位分成64位

一切正常，我得到了正确的答案，但是这个解决方案比仅仅使用

byte[]

数组和循环槽要慢得多

最耗时的函数是反转位的顺序并反转每个位的函数

现在看来：

//this function is inside the custom class I defined
public void set(int n, int d) { //set bit n as the inverse value of bit d
    storage[n/64] ^= ~(storage[ind/64] & (1L << ind)) << (n-ind);
}

//sequence is an instance of my custom class 
//the length of the sequence is sequenceLength 
for (int i = 1; i < sequenceLength; i++) {
    sequence.set(sequenceLength+i, sequenceLength-i);
}

//此函数位于我定义的自定义类中
公共空集（int n，int d）{//将位n设置为位d的倒数
存储器[n/64]^=~（存储器[ind/64]&（1L您可以尝试一个位集，尽管它通常会跟踪所设置的位，因此您可能需要跟踪您感兴趣的位的数量：

public static void main(String[] args) {
    BitSet bitSet = new BitSet();
    bitSet.set(0,true);
    bitSet.set(1, true);
    bitSet.set(2, false);

    final int length = 3;
    printBitSet(bitSet, length);

    BitSet newBitSet = new BitSet(length * 2 + 1);
    for (int i = 0; i <length; i++) {
        newBitSet.set(i, bitSet.get(i));
    }
    newBitSet.set(length, true);
    for (int i = 0; i < length; i++) {
        newBitSet.set(length + i + 1, !bitSet.get(length - i - 1));
    }
    printBitSet(newBitSet, 2*length +1);
}
private static void printBitSet(BitSet bitSet, int length) {
    for (int i = 0; i < length; i++) {
        System.out.print(" " +( bitSet.get(i) ? "1" : "-1"));
    }
    System.out.println();
}

publicstaticvoidmain（字符串[]args）{
比特集比特集=新比特集（）；
bit set.set（0，真）；
bit set.set（1，true）；
bit set.set（2，false）；
最终整数长度=3；
打印位集（位集，长度）；
BitSet NEBITSET=新的位集（长度*2+1）；
对于（int i=0；i您没有要求它，但对于您的序列有一个直接公式：

public static void main(String[] args) {
    for( int n=1 ; n<=15 ; n++ ){
        int fold = 1 - ((n/(n&-n))&2);
        System.out.print(" " + fold);
    }
    System.out.println();
}

publicstaticvoidmain（字符串[]args）{
对于（int n=1；nI实际上从未使用过位集，但据我所知，使用位运算应该快3-10倍上面的速度是通过字节数组循环速度的两倍，位集会更快吗？你有这里的所有代码，我会尝试两种方法并进行测量。位集为高效位存储提供了一个很好的接口，如果它不够快，至少你会有一个很好的基线来开始，看看你能以多快的速度获得它。使用位集是一个很好的选择about为我提供了大约500毫秒的25次迭代，而我的自定义类在大约300毫秒内完成了任务。然而，当在标准字节数组上循环时，我得到的时间大约为120-130毫秒。使用
Long.reverse（）
。另外，请展示真实的代码；您的示例无法编译。哦，我现在明白了。您正在绘制一条分形龙曲线！您是对的！这是很久以前的事了，但我想从龙曲线创建超大的分形图像，我的内存用完了。所以我的想法是将曲线中的每一个转折点都存储为一个长数组中的一位。哇，回答很好！这实际上比我最快的解决方案快30%左右，并且似乎给出了正确的答案。现在我只需要了解这里发生了什么…它没有回答更广泛的问题，但仍然是一个很好的答案。
public static void main(String[] args) {
    for( int n=1 ; n<=15 ; n++ ){
        int fold = 1 - ((n/(n&-n))&2);
        System.out.print(" " + fold);
    }
    System.out.println();
}