Question

我已经查看了尽可能多的先前问题，但从未看到过将布尔数组作为变量的问题。

这是我的班级：

public class Register {

private boolean[] register;
private int length;

    //Normal constructor
public Register(int n) {

    if (n == 8 || n == 16 || n == 32 || n == 64) {

        length = n;
        register = new boolean[length];

        for (int i = 0; i < length; i++) {

            register[i] = false;
        }

    } else {

        throw new RegisterException(
                "A register can only contain 8, 16, 32, or 64 bits");
    }

}

// Creates a copy of reg (an existing Register)
public Register(Register reg) {

    length = reg.length;
    register = new boolean[reg.register.length];

    System.arraycopy(reg.register, 0, this.register, 0, reg.register.length);
}

在我的驱动程序中，我将“1101101”加载到register1中，但是当我这样做时：寄存器register2 = new寄存器（register1）;

并打印出两个结果：

0000000001101101

0000000000010110

不确定O.o会发生什么。感谢任何帮助，谢谢！

这是我的加载方法。我把它放在这里是因为它可能很难阅读：

public void load(String binaryRep) {

    String allTheBits = binaryRep;
    int charPosition = 0;
    int loadLength;
    int binaryNum = 0;
    String index = "";
    String trimmedIndex = "";

    if (allTheBits.length() > 0 && allTheBits.length() <= length) {

        loadLength = allTheBits.length();

        for (int i = length - (loadLength); i < length; i++) {

            index = allTheBits.charAt(charPosition) + "";
            trimmedIndex = index.trim();
            binaryNum = Integer.parseInt(trimmedIndex);

            if (binaryNum == 1) {

                register[i] = true;

            } else if (binaryNum == 0) {

                register[i] = false;
            }

            charPosition++;

        }
    } else {
        throw new RegisterException("You can only load 0 - " + length
                + "bits.");
    }
}

Answer 1

这是一种更惯用的方式（使用Cloneable接口）：

public class Register implements Cloneable {

private boolean[] register;

public Register(boolean[] register) {

    int n = register.length;

    if (n == 8 || n == 16 || n == 32 || n == 64) {
        this.register = register;
    } else {

        throw new IllegalArgumentException(
                "A register can only contain 8, 16, 32, or 64 bits");
    }

}

@Override
public String toString() {

    StringBuilder builder = new StringBuilder();

    for ( boolean b : this.register ) {
        builder.append( b ? "1" : "0" );
    }

    return builder.toString();
}

public Register( int n ) {
    this( new boolean[n] );
}

public int getLength() {
    return this.register.length;
}

@Override
public Register clone() {

    boolean[] clonedRegister = new boolean[this.register.length];

    System.arraycopy(this.register, 0, clonedRegister,0, this.register.length);

    return new Register( clonedRegister );
}

}

一个JUnit测试显示它在行动：

import org.junit.Assert;
import org.junit.Test;


public class RegisterTest {

    @Test
    public void testRegisterToString() {

        Register source = new Register( new boolean[] {true, true, false, false, true, false, true, false } );

        String result = "11001010";

        Assert.assertEquals( result, source.toString() );

    }

    @Test
    public void testRegisterCloning() {

        Register source = new Register( new boolean[] {true, true, false, false, true, false, false, false } );
        Register clone = source.clone();

        Assert.assertEquals( source.toString(), clone.toString() );

    }

}

Answer 2

一些评论，以便你学习一些基本的东西。

正如@Ted所说，无需将长度字段保留为寄存器。长度会给你相同的
本地变量未使用默认值初始化，但是数组是存储在堆中的。所以没有必要迭代“register”数组来将其所有位置设置为false
使用布尔数组来做这件事可能很容易，但内存非常低效，因为每个布尔值在堆中至少需要32位。因此，为了表示64位寄存器，您使用的是至少32 * 64 + 32 = 2080位......使用字节数组和按位逻辑会有点困难，但是嘿，这是一个小小的挑战：）

无论如何，你的代码看起来很好（BTW，使用Arrays.copyOf方法因为它更具可读性），所以错误应该来自另一方。

Answer 3

我刚刚使用以下内容验证了您的加载方法：

public static void main(String [] args)
{
    Register r1 = new Register(8);
    r1.load("1101101");
    Register r2 = new Register(r1);
    for (int i=0; i<8; i++) System.out.println(r2.register[i]);
}

输出：

> run Register
false
true
true
false
true
true
false
true
>

就Register对象的内容而言，我认为是正确的，所以问题可能在于访问。

复制构造函数帮助，尝试复制布尔数组。 Java的

3 个答案: