java - 如何在 Java 中制作只读数据类-6ren

java - 如何在 Java 中制作只读数据类

转载作者：行者123 更新时间：2023-11-29 07:45:08

我正在构建一个模拟器，我有一个名为 Emulator 的类，其中包含与字体相关的数据和一组稍后放入 CPU 的指令。但是，我想要一个包含所有这些信息的“容器”类，以便 Emulator 更短且更易读。这是面向对象的吗？什么是好的方法？

final int[] fontSet = {
        0xF0, 0x90, 0x90, 0x90, 0xF0, // 0
        0x20, 0x60, 0x20, 0x20, 0x70, // 1
        0xF0, 0x10, 0xF0, 0x80, 0xF0, // 2
        0xF0, 0x10, 0xF0, 0x10, 0xF0, // 3
        0x90, 0x90, 0xF0, 0x10, 0x10, // 4
        0xF0, 0x80, 0xF0, 0x10, 0xF0, // 5
        0xF0, 0x80, 0xF0, 0x90, 0xF0, // 6
        0xF0, 0x10, 0x20, 0x40, 0x40, // 7
        0xF0, 0x90, 0xF0, 0x90, 0xF0, // 8
        0xF0, 0x90, 0xF0, 0x10, 0xF0, // 9
        0xF0, 0x90, 0xF0, 0x90, 0x90, // A
        0xE0, 0x90, 0xE0, 0x90, 0xE0, // B
        0xF0, 0x80, 0x80, 0x80, 0xF0, // C
        0xE0, 0x90, 0x90, 0x90, 0xE0, // D
        0xF0, 0x80, 0xF0, 0x80, 0xF0, // E
        0xF0, 0x80, 0xF0, 0x80, 0x80  // F
};

private List<Instruction> initInstructions() {
    List<Instruction> instructions = new ArrayList<>(INSTRUCTIONS_NUM);

    add0Instructions(instructions);
    add1Instructions(instructions);
    add2Instructions(instructions);
    add3Instructions(instructions);
    add4Instructions(instructions);
    add5Instructions(instructions);
    add6Instructions(instructions);
    add7Instructions(instructions);
    add8Instructions(instructions);
    add9Instructions(instructions);
    addAInstructions(instructions);
    addBInstructions(instructions);
    addCInstructions(instructions);
    addDInstructions(instructions);
    addEInstructions(instructions);
    addFInstructions(instructions);
    return instructions;
}

private void add0Instructions(List<Instruction> instructions) {
    instructions.add(new Instruction() { //Clears Display
        public void execute(final CPU cpu) {
            cpu.getMemoryMap().getMemory(MemoryType.DISPLAY).clear();
            Platform.runLater(new Runnable() { // TODO: NO SE SI HACE FALTA
                @Override
                public void run() {
                    display.paint(cpu.getMemoryMap().getMemory(MemoryType.DISPLAY));
                }
            });
            cpu.getInstPointer().add(2);
        }
        public boolean validate(OpCode opCode) {
            return opCode.get() == 0x00E0;
        }
    });

    instructions.add(new Instruction() { //Return from a subroutine
        public void execute(CPU cpu) {
            cpu.getInstPointer().set(cpu.getStack().pop() + 2);
        }
        public boolean validate(OpCode opCode) {
            return opCode.get() == 0x00EE;
        }
    });
}

private void add1Instructions(List<Instruction> instructions) { // Set InstPointer to KKK // CHEQUEADA
    instructions.add(new Instruction() {
        public void execute(CPU cpu) {
            cpu.getInstPointer().set(cpu.getOpCode().get() & 0x0FFF);
        }
        public boolean validate(OpCode opCode) {
            return opCode.getNibble(0) == 0x01;
        }
    });
}

private void add2Instructions(List<Instruction> instructions) {
    instructions.add(new Instruction() { //Call subroutine at nnn
        public void execute(CPU cpu) {
            cpu.getStack().push(cpu.getInstPointer().get() & 0x0000FFFF);
            cpu.getInstPointer().set(cpu.getOpCode().get() & 0x0FFF);
        }
        public boolean validate(OpCode opCode) {
            return opCode.getNibble(0) == 0x02;
        }
    });
}

private void add3Instructions(List<Instruction> instructions) {
    instructions.add(new Instruction() { //Skip next instruction if Vx = kk
        public void execute(CPU cpu) {
            int position = Bitwise.getNibbleAsInt(cpu.getOpCode().get(), 1);
            int data = Bitwise.getByteAsInt(cpu.getOpCode().get(), 1);

            if(cpu.getRegistry(position).get() == data)
                cpu.getInstPointer().add(2);
            cpu.getInstPointer().add(2);
        }
        public boolean validate(OpCode opCode) {
            return opCode.getNibble(0) == 0x03;
        }
    });
}

private void add4Instructions(List<Instruction> instructions) {
    instructions.add(new Instruction() { //Skip next instruction if Vx != kk
        public void execute(CPU cpu) {
            int position = Bitwise.getNibbleAsInt(cpu.getOpCode().get(), 1);
            int data = Bitwise.getByte(cpu.getOpCode().get(), 1);

            if (cpu.getRegistry(position).get() != data)
                cpu.getInstPointer().add(2);
            cpu.getInstPointer().add(2);
        }
        public boolean validate(OpCode opCode) {
            return opCode.getNibble(0) == 0x04;
        }
    });
}

private void add5Instructions(List<Instruction> instructions) {
    instructions.add(new Instruction() { //Skip next instruction if Vx = Vy
        public void execute(CPU cpu) {
            int position1 = Bitwise.getNibbleAsInt(cpu.getOpCode().get(), 1);
            int position2 = Bitwise.getNibbleAsInt(cpu.getOpCode().get(), 2);

            if(cpu.getRegistry(position1).equals(cpu.getRegistry(position2)))
                cpu.getInstPointer().add(2);
            cpu.getInstPointer().add(2);
        }
        public boolean validate(OpCode opCode) {
            return opCode.getNibble(0) == 0x05 && opCode.getNibble(3) == 0x00;
        }
    });
}

private void add6Instructions(List<Instruction> instructions) {
    instructions.add(new Instruction() { //Set Vx = kk
        public void execute(CPU cpu) {
            int position = Bitwise.getNibbleAsInt(cpu.getOpCode().get(), 1);
            int data = Bitwise.getByteAsInt(cpu.getOpCode().get(), 1);

            cpu.getRegistry(position).set(data);
            cpu.getInstPointer().add(2);
        }
        public boolean validate(OpCode opCode) {
            return opCode.getNibble(0) == 0x6;
        }
    });
}

private void add7Instructions(List<Instruction> instructions) {
    instructions.add(new Instruction() { //Set Vx = Vx + kk
        public void execute(CPU cpu) {
            int position = Bitwise.getNibbleAsInt(cpu.getOpCode().get(), 1);
            int data = Bitwise.getByteAsInt(cpu.getOpCode().get(), 1);

            cpu.getRegistry(position).set(Bitwise.getByteAsInt(cpu.getRegistry(position).get() + data, 1));
            cpu.getInstPointer().add(2);
        }
        public boolean validate(OpCode opCode) {
            return opCode.getNibble(0) == 0x07;
        }
    });
}

private void add8Instructions(List<Instruction> instructions) {
    instructions.add(new Instruction() { //Set Vx = Vy
        public void execute(CPU cpu) {
            int position1 = Bitwise.getNibbleAsInt(cpu.getOpCode().get(), 1);
            int position2 = Bitwise.getNibbleAsInt(cpu.getOpCode().get(), 2);

            cpu.getRegistry(position1).set(cpu.getRegistry(position2).get());
            cpu.getInstPointer().add(2);
        }
        public boolean validate(OpCode opCode) {
            return opCode.getNibble(0) == 0x08 && opCode.getNibble(3) == 0x00;
        }
    });

    instructions.add(new Instruction() { //MUCHAS OPERACIONES LOGICAS
        public void execute(CPU cpu) { //Set Vx = Vx OR Vy
            int position1 = cpu.getOpCode().getNibble(1);
            int position2 = cpu.getOpCode().getNibble(2);

            cpu.getRegistry(position1).or(cpu.getRegistry(position2));
            cpu.getInstPointer().add(2);
        }
        public boolean validate(OpCode opCode) {
            return opCode.getNibble(0) == 0x08 && opCode.getNibble(3) == 0x01;
        }
    });

    instructions.add(new Instruction() {
        public void execute(CPU cpu) { //Set Vx = Vx AND Vy
            int position1 = cpu.getOpCode().getNibble(1);
            int position2 = cpu.getOpCode().getNibble(2);

            cpu.getRegistry(position1).and(cpu.getRegistry(position2));
            cpu.getInstPointer().add(2);
        }
        public boolean validate(OpCode opCode) {
            return opCode.getNibble(0) == 0x08 && opCode.getNibble(3) == 0x02;
        }
    });

    instructions.add(new Instruction() {
        public void execute(CPU cpu) { //Set Vx = Vx XOR Vy
            int position1 = cpu.getOpCode().getNibble(1);
            int position2 = cpu.getOpCode().getNibble(2);

            cpu.getRegistry(position1).xor(cpu.getRegistry(position2));
            cpu.getInstPointer().add(2);
        }
        public boolean validate(OpCode opCode) {
            return opCode.getNibble(0) == 0x08 && opCode.getNibble(3) == 0x03;
        }
    });

    instructions.add(new Instruction() {
        public void execute(CPU cpu) { //Set Vx = Vx + Vy, set VF = carry
            int position1 = cpu.getOpCode().getNibble(1);
            int position2 = cpu.getOpCode().getNibble(2);

            cpu.getRegistry(position1).add(cpu.getRegistry(position2));
            cpu.getRegistry(0xF).set(cpu.getRegistry(position1).get() > 255 ? 0x1 : 0x0);
            cpu.getInstPointer().add(2);
        }

        public boolean validate(OpCode opCode) {
            return opCode.getNibble(0) == 0x08 && opCode.getNibble(3) == 0x04;
        }
    });

    instructions.add(new Instruction() {
        public void execute(CPU cpu) { //Set Vx = Vx - Vy, set VF = NOT borrow
            int position1 = cpu.getOpCode().getNibble(1);
            int position2 = cpu.getOpCode().getNibble(2);

            cpu.getRegistry(position1).sub(cpu.getRegistry(position2));
            cpu.getRegistry(0xF).set(cpu.getRegistry(position1).get() > 0 ? 0x1 : 0x0);
            cpu.getInstPointer().add(2);
        }
        public boolean validate(OpCode opCode) {
            return opCode.getNibble(0) == 0x08 && opCode.getNibble(3) == 0x05;
        }
    });

    instructions.add(new Instruction() {
        public void execute(CPU cpu) { //Set Vx = Vx SHR 1
            int position = cpu.getOpCode().getNibble(1);

            cpu.getRegistry(0xF).set(cpu.getRegistry(position  & 0x0001).get());
            cpu.getRegistry(position).set(cpu.getRegistry(position).get() / 2);
            cpu.getInstPointer().add(2);
        }
        public boolean validate(OpCode opCode) {
            return opCode.getNibble(0) == 0x08 && opCode.getNibble(3) == 0x06;
        }
    });

    instructions.add(new Instruction() {
        public void execute(CPU cpu) { //Set Vx = Vy - Vx, set VF = NOT borrow
            int position1 = cpu.getOpCode().getNibble(1);
            int position2 = cpu.getOpCode().getNibble(2);
            int sub = cpu.getRegistry(position2).get() - cpu.getRegistry(position1).get();

            cpu.getRegistry(position1).set(sub);
            cpu.getRegistry(0xF).set(sub > 0 ? 0x1 : 0x0);
            cpu.getInstPointer().add(2);
        }
        public boolean validate(OpCode opCode) {
            return opCode.getNibble(0) == 0x08 && opCode.getNibble(3) == 0x07;
        }
    });

    instructions.add(new Instruction() {
        public void execute(CPU cpu) { //Set Vx = Vx SHL 1
            int position = cpu.getOpCode().getNibble(1);

            cpu.getRegistry(0x0F).set((cpu.getRegistry((position & 0x8000) == 0x8000 ? 1 : 0).get()));
            cpu.getRegistry(position).set(cpu.getRegistry(position).get() * 2);
            cpu.getInstPointer().add(2);
        }
        public boolean validate(OpCode opCode) {
            return opCode.getNibble(0) == 0x08 && opCode.getNibble(3) == 0x0E;
        }
    });
}

private void add9Instructions(List<Instruction> instructions) {
    instructions.add(new Instruction() { //Skip next instruction if Vx != Vy
        public void execute(CPU cpu) {
            int position1 = cpu.getOpCode().getNibble(1);
            int position2 = cpu.getOpCode().getNibble(2);

            if(!cpu.getRegistry(position1).equals(cpu.getRegistry(position2)))
                cpu.getInstPointer().add(2);
            cpu.getInstPointer().add(2);
        }
        public boolean validate(OpCode opCode) {
            return opCode.getNibble(0) == 0x09;
        }
    });
}

private void addAInstructions(List<Instruction> instructions) {
    instructions.add(new Instruction() { //Set I = nnn
        public void execute(CPU cpu) {
            cpu.getRegisterI().set(cpu.getOpCode().get() & 0x0FFF);
            cpu.getInstPointer().add(2);
        }
        public boolean validate(OpCode opCode) {
            return opCode.getNibble(0) == 0x0A;
        }
    });
}

private void addBInstructions(List<Instruction> instructions) {
    instructions.add(new Instruction() { //Jump to location nnn + V0
        public void execute(CPU cpu) {
            int sum = Bitwise.getByteAsInt(cpu.getRegistry(0x0).get(), 1) + (cpu.getOpCode().get() & 0x0FFF);
            cpu.getInstPointer().set(sum);
        }
        public boolean validate(OpCode opCode) {
            return opCode.getNibble(0) == 0x0B;
        }
    });
}

private void addCInstructions(List<Instruction> instructions) {
    instructions.add(new Instruction() { //Set Vx = random byte AND kk
        public void execute(CPU cpu) {
            int position = cpu.getOpCode().getNibble(1);
            int data = Bitwise.getByteAsInt(cpu.getOpCode().get(), 1);
            data = Bitwise.and(data, rand.nextInt(255 + 1)); // TODO: TAMBIEN NECESITA UN RAND
            cpu.getRegistry(position).set(data);
            cpu.getInstPointer().add(2);
        }
        public boolean validate(OpCode opCode) {
            return opCode.getNibble(0) == 0x0C;
        }
    });
}

private void addDInstructions(List<Instruction> instructions) {
    instructions.add(new Instruction() { //Display n-byte sprite starting at memory location I at (Vx, Vy), set VF = collision
        public void execute(final CPU cpu) {
            int position1 = cpu.getOpCode().getNibble(1);
            int position2 = cpu.getOpCode().getNibble(2);
            int height = cpu.getOpCode().getNibble(3);
            int x = Bitwise.getByteAsInt(cpu.getRegistry(position1).get(), 1);
            int y = Bitwise.getByteAsInt(cpu.getRegistry(position2).get(), 1);
            cpu.getRegistry(0x0F).set(0);

            for(int offsetY = 0; offsetY < height; offsetY++) {
                int line = cpu.getMemoryMap().getMemory(MemoryType.RAM).get(cpu.getRegisterI().get() + offsetY);
                for(int offsetX = 0; offsetX < 8; offsetX++) {
                    int pixel =  line & (0x80 >> offsetX);
                    if(pixel != 0) {
                        int totalX = x + offsetX;
                        int totalY = y + offsetY;
                        int index;

                        totalX = totalX % 64;
                        totalY = totalY % 32;
                        index = (totalY * 64) + totalX;
                        if(cpu.getMemoryMap().getMemory(MemoryType.RAM).get(index) == 1)
                            cpu.getRegistry(0x0F).set(1);
                        cpu.getMemoryMap().getMemory(MemoryType.RAM).set(index, cpu.getMemoryMap().getMemory(MemoryType.RAM).get(index) ^ 1);
                    }
                }
            }
            cpu.getInstPointer().add(2);
            //screen.setNeedRedraw(true); //ESTE BOOLEAN TIENE QUE IR EN ALGUN LADO
            Platform.runLater(new Runnable() {
                @Override
                public void run() {
                    display.paint(cpu.getMemoryMap().getMemory(MemoryType.DISPLAY));
                }
            });
        }
        public boolean validate(OpCode opCode) {
            return opCode.getNibble(0) == 0x0D;
        }
    });
}

private void addEInstructions(List<Instruction> instructions) {
    instructions.add(new Instruction() { //Skip next instruction if key with the value of Vx is pressed
        public void execute(CPU cpu) {
            int position = cpu.getOpCode().getNibble(1);
            int data = cpu.getRegistry(position).get();

            if(cpu.getMemoryMap().getMemory(MemoryType.KEYBOARD).get(data) == 1)
                cpu.getInstPointer().add(2);
            cpu.getInstPointer().add(2);
        }
        public boolean validate(OpCode opCode) {
            return opCode.getNibble(0) == 0x0E && (opCode.get() & 0x00FF) == 0x9E;
        }
    });

    instructions.add(new Instruction() {
        public void execute(CPU cpu) { //Skip next instruction if key with the value of Vx is not pressed
            int position = cpu.getOpCode().getNibble(1);
            int data = cpu.getRegistry(position).get();

            if(cpu.getMemoryMap().getMemory(MemoryType.KEYBOARD).get(data) == 0)
                cpu.getInstPointer().add(2);
            cpu.getInstPointer().add(2);
        }
        public boolean validate(OpCode opCode) {
            return opCode.getNibble(0) == 0x0E && (opCode.get() & 0x00FF) == 0xA1;
        }
    });
}

private void addFInstructions(List<Instruction> instructions) {
    instructions.add(new Instruction() {
        public void execute(CPU cpu) { //Set Vx = delay timer value
            int position = cpu.getOpCode().getNibble(1);

            cpu.getRegistry(position).set(cpu.getDelayTimer().get());
            cpu.getInstPointer().add(2);
        }
        public boolean validate(OpCode opCode) {
            return opCode.getNibble(0) == 0x0F && (opCode.get() & 0x00FF) == 0x07;
        }
    });

    instructions.add(new Instruction() {
        public void execute(CPU cpu) { //Wait for a key press, store the value of the key in Vx
            int position = cpu.getOpCode().getNibble(1);
            int keyboardSize = cpu.getMemoryMap().getMemory(MemoryType.KEYBOARD).size();

            for (int i = 0; i < keyboardSize; i++) {
                if (cpu.getMemoryMap().getMemory(MemoryType.KEYBOARD).get(i) == 1) {
                    cpu.getRegistry(position).set(cpu.getMemoryMap().getMemory(MemoryType.KEYBOARD).get(i));
                    cpu.getInstPointer().add(2);
                    cpu.getMemoryMap().getMemory(MemoryType.KEYBOARD).clear();
                    return;
                }
            }
        }
        public boolean validate(OpCode opCode) {
            return opCode.getNibble(0) == 0x0F && (opCode.get() & 0x00FF) == 0x0A;
        }
    });

    instructions.add(new Instruction() {
        public void execute(CPU cpu) { //Set delay timer = Vx
            int position = cpu.getOpCode().getNibble(1);

            cpu.getDelayTimer().set(cpu.getRegistry(position).get());
            cpu.getInstPointer().add(2);
        }
        public boolean validate(OpCode opCode) {
            return opCode.getNibble(0) == 0x0F && ((opCode.get() & 0x00FF) == 0x15);
        }
    });

    instructions.add(new Instruction() {
        public void execute(CPU cpu) { //Set sound timer = Vx
            int position = cpu.getOpCode().getNibble(1);

            cpu.getSoundTimer().set(cpu.getRegistry(position).get());
            cpu.getInstPointer().add(2);
        }
        public boolean validate(OpCode opCode) {
            return opCode.getNibble(0) == 0x0F && (opCode.get() & 0x00FF) == 0x18;
        }
    });

    instructions.add(new Instruction() {
        public void execute(CPU cpu) { //Set I = I + Vx
            int position = cpu.getOpCode().getNibble(1);

            cpu.getRegisterI().set(cpu.getRegisterI().get() + cpu.getRegistry(position).get());
            cpu.getInstPointer().add(2);
        }
        public boolean validate(OpCode opCode) {
            return opCode.getNibble(0) == 0x0F && (opCode.get() & 0x00FF) == 0x1E;
        }
    });

    instructions.add(new Instruction() {
        public void execute(CPU cpu) { //Set I = location of sprite for digit Vx
            int position = cpu.getOpCode().getNibble(1);
            int character = cpu.getRegistry(position).get();

            cpu.getRegisterI().set(0x0050 + character*5);
            cpu.getInstPointer().add(2);
        }
        public boolean validate(OpCode opCode) {
            return opCode.getNibble(0) == 0x0F && (opCode.get() & 0x00FF) == 0x29;
        }
    });

    instructions.add(new Instruction() { //Store BCD representation of Vx in memory locations I, I+1, and I+2
        public void execute(CPU cpu) {
            int position = cpu.getOpCode().getNibble(1);
            int data = cpu.getRegistry(position).get();
            int hundreds = (data - (data % 100)) / 100;
            int tens;

            data -= hundreds * 100;
            tens =  (data - (data % 10)) / 10;
            data -= tens * 10;
            cpu.getMemoryMap().getMemory(MemoryType.RAM).set(cpu.getRegisterI().get(), (byte)hundreds);
            cpu.getMemoryMap().getMemory(MemoryType.RAM).set(cpu.getRegisterI().get() + 1, (byte)tens);
            cpu.getMemoryMap().getMemory(MemoryType.RAM).set(cpu.getRegisterI().get() + 2, (byte)data);
            cpu.getInstPointer().add(2);
        }
        public boolean validate(OpCode opCode) {
            return opCode.getNibble(0) == 0x0F && (opCode.get() & 0x00FF) == 0x33;
        }
    });

    instructions.add(new Instruction() {
        public void execute(CPU cpu) { //Store registers V0 through Vx in memory starting at location I
            int index = cpu.getOpCode().getNibble(1);

            for(int i=0; i <= index; i++)
                cpu.getMemoryMap().getMemory(MemoryType.RAM).set(cpu.getRegisterI().get() + i, (byte)cpu.getRegistry(i).get());
            cpu.getInstPointer().add(2);
        }
        public boolean validate(OpCode opCode) {
            return opCode.getNibble(0) == 0x0F && (opCode.get() & 0x00FF) == 0x55;
        }
    });

    instructions.add(new Instruction() {
        public void execute(CPU cpu) { //Read registers V0 through Vx from memory starting at location I
            int index = cpu.getOpCode().getNibble(1);

            for(int i=0; i <= index; i++)
                cpu.getRegistry(i).set(cpu.getMemoryMap().getMemory(MemoryType.RAM).get(cpu.getRegisterI().get() + i));
            cpu.getRegisterI().set(cpu.getRegisterI().get() + index + 1);
            cpu.getInstPointer().add(2);
        }
        public boolean validate(OpCode opCode) {
            return opCode.getNibble(0) == 0x0F && (opCode.get() & 0x00FF) == 0x65;
        }
    });
}

最佳答案

如果您将数据存储在变量中:

方法一:

让它们最终

示例:public static final FieldType MYFIELD;

方法二:

您可以将所有变量设为私有(private)并为它们编写 getter。

示例 2:

private static FieldType myField;
public static FieldType getMyField() {
    return myField;
}

关于java - 如何在 Java 中制作只读数据类，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/26520129/

文章推荐： rust - 使用 bindgen 设置包含路径

文章推荐： mysql - 获取按某列排序的每个组的一条记录

文章推荐： enums - 为什么我不能从枚举中可变地借用一个原语？

android -/数据/数据/在哪里？
初学者 android 问题。好的，我已经成功写入文件。例如。 //获取文件名 String filename = getResources().getString(R.string.filename
安卓/数据/数据/mypackage/img
我已经将相同的图像保存到/data/data/mypackage/img/中，现在我想显示这个全屏，我曾尝试使用 ACTION_VIEW 来显示 android 标准程序，但它不是从/data/dat
ios - Swift 4:无法将“数据”类型的值转换为预期的参数类型“数据”
我正在使用Xcode 9，Swift 4。我正在尝试使用以下代码从URL在ImageView中显示图像: func getImageFromUrl(sourceUrl: String) -> UII
android - 基因运动。如何从设备中提取数据库。我的/数据/数据/文件夹似乎是空的
我的 Ubuntu 安装 genymotion 有问题。主要是我无法调试我的数据库，因为通过 eclipse 中的 DBMS 和 shell 中的 adb 我无法查看/data/文件夹的内容。没有显示
php - JSON 数据 ajax 不是正确的 POST 数据
我正在尝试用 PHP 发布一些 JSON 数据。但是出了点问题。这是我的 html -- {% for x in sets %}
r - lm(数据~时间)和tslm(数据~趋势)有什么区别
我观察到两种方法的结果不同。为什么是这样？我知道 lm 上发生了什么，但无法弄清楚 tslm 上发生了什么。 > library(forecast) > set.seed(2) > tts lm(t
Spring 数据 JPA 和 Spring 数据 Elasticsearch ；找不到类型的属性索引？
我不确定为什么会这样!我有一个由 spring data elasticsearch 和 spring data jpa 使用的类，但是当我尝试运行我的应用程序时出现错误。 Error creatin
d3.js - 数据过滤器适用于 json 数据，但不适用于 csv 数据
在 this vega 图表，如果我下载并转换 flare-dependencies.json使用以下 jq 到 csv命令， jq -r '(map(keys) | add | unique) as
php - 在 .php 文件中发送 mysql 数据/mysql 数据
我正在提交一个项目，我必须在其中创建一个带有表的 mysql 数据库。一切都在我这边进行，所以我只想检查如何将我所有的压缩文件发送给使用不同计算机的人。基本上，我如何为另一台计算机创建我的数据库文件，
android - 如何使用 Android Device Monitor 的文件资源管理器查找我的应用程序/数据/数据
我有一个应用程序可以将文本文件写入内部存储。我想仔细看看我的电脑。我运行了 Toast.makeText 来显示路径，它说:/数据/数据/我的包但是当我转到 Android Studio 的 An
android - 如何从 Genymotion 的 android 模拟器访问文件/数据/数据？
我喜欢使用 Genymotion 模拟器以如此出色的速度加载 Android。它有非常好的速度，但仍然有一些不稳定的性能。如何从 Eclipse 中的文件资源管理器访问 Genymotion 模拟器
silverlight - 如果我在 setter 中使用不同的值更改绑定(bind)数据，如何刷新绑定(bind)数据
我需要更改 Silverlight 中文本框的格式。数据通过 MVVM 绑定(bind)。例如，有一个 int 属性，我将 1 添加到 setter 中的值并调用 OnPropertyChanged
youtube - 通过 YouTube 数据 API 访问公共(public)数据，无需身份验证。
我想向 Youtube Data API 提出请求，但我不需要访问任何用户信息。我只想浏览公共(public)视频并根据搜索词显示视频。我可以在未经授权的情况下这样做吗？最佳答案 YouTube
python - 无法让 twilio 显示 'from' 数据，但它会显示 'to' 数据
我已经设置了一个 Twilio 应用程序，我想向人们发送更新，但我不想回复单个文本。我只是想让他们在有问题时打电话。我一切正常，但我想在发送文本时显示传入文本，以确保我不会错过任何问题。我正在使用 p
javascript - 向客户端发送 JSON 数据？ D3.js 渲染 JSON 数据
我有一个带有表单的网站(目前它是纯 HTML，但我们正在切换到 JQuery)。流程是这样的: 接受用户的输入 --- 5 个整数通过 REST 调用网络服务在服务器端运行一些计算...并生成一个
javascript - 如何检测一个 JavaScript 文件只包含 JSON 数据，还是打算包含 JSON 数据？
假设我们有一个名为 configuration.js 的文件，当我们查看内部时，我们会看到: 'use strict'; var profile = { "project": "%Projec
javascript - 在初始 .ajax 调用之外使用 JSON 数据 - 访问剩余的 JSON 数据
这部分是对 Previous Question 的扩展我的: 我现在可以从我的 CI Controller 成功返回 JSON 数据，它返回: {"results":[{"id":"1","Sourc
ios - 删除所有 Couchbase 数据/文档 ios(或删除所有 ios 数据？)
有什么有效的方法可以删除 ios 中 CBL 的所有文档存储？我对此有疑问，或者，如果有人知道如何从本质上使该应用程序像刚刚安装一样，那也会非常有帮助。我们正在努力确保我们的注销实际上将应用程序设置为
javascript - $.post(url, 函数(数据,状态) {警报(数据)});警报()不工作
我有一个 Rails 应用程序，它与其他 Rails 应用程序通信以进行数据插入。我使用 jQuery $.post 方法进行数据插入。对于插入，我的其他 Rails 应用程序显示 200 OK。但在
javascript - 断言错误 : expected { status: 'SUCCESS' , 数据 : [] } to equal { Object (status, 数据)}
我正在为服务于发布请求的 API 调用运行单元测试。我正在传递请求正文，并且必须将响应作为帐户数据返回。但我只收到断言错误注意:数据是从 Azure 中获取的 spec.js const accou

行者123

个人简介

我是一名优秀的程序员,十分优秀！

作者热门文章

滴滴打车优惠券免费领取

全站热门文章

首页

博学

6Ren·AI

商城

java - 如何在 Java 中制作只读数据类