如何调用未知 object 的前一个节点？

Question

我正在使用定制的数据结构，并且在这个项目中，我正在使用双重 LinkedList 来实现区块链。

所以我做了一个 Main class 和一个 Block class，当然还有 LinkedList class，LinkedList class 被用来接受 Block 类型的数据，所以当我尝试将元素添加到我的列表时，我传递一个新的块，其中包含以下信息问题是在第一个元素之后我不知道如何调用前一个块的 hash 值。

基本上在每个块 class 中应该有一个 hash 和块 1 中前一个块的 hash 没有 prev hash 所以它的 0 但第二个块及以后是我迷路的地方。

这是我的街区 class

import java.util.Date;

public class Block {

    public String hash;
    public String previousHash;
    private String data;
    private long timeStamp;

    public Block(String data, String previousHash) {
        this.data = data;
        this.previousHash = previousHash;
        this.timeStamp = new Date().getTime();
        this.hash = calculateHash();
    }

    public String calculateHash() {
        String calculatehash = StringUtil.applySha256(
                previousHash + Long.toString(timeStamp) + data);

        return calculatehash;
    }
}

这是我的双重 LinkedList 文件

class Node {

    private Block data; // node storing int data
    private Node nextNode; // the next pointer node, the arrow in drawing
    private Node prevNode;

    // don't forget the class constructor
    public Node(Block data2) {
        this.data = data2;
    }

    // since we made variable private
    // to access them we need setters and getters
    public Block getData() {
        return this.data;
    }

    public Node getNextNode() {
        return this.nextNode;
    }

    public Node getPrevNode() {
        return this.prevNode;
    }

    public Block setData(Block data) {
        return this.data = data;
    }

    public Node setNextNode(Node nextNode) {
        return this.nextNode = nextNode;
    }

    public Node setpervNode(Node prevNode) {
        return this.prevNode = prevNode;
    }

    @Override
    public String toString() {
        return "Data: " + this.data;
    }

   
}

public class DoublyLinkedlist {

    private Node head;
    private Node tail;
    private int size = 0;


    public DoublyLinkedlist() {
        
    }

    public int getSize() {
        return this.size;
    }

    public void addFirst(Block data) {
        Node node = new Node(data);
        if (this.tail == null && this.head == null) {
            this.tail = node;
            this.head = node;
        } else if (this.head == null) {
            this.head = node;
        } else {
            Node old = this.head;
            node.setNextNode(old);
            this.head = node;
            old.setpervNode(this.head);
        }
        this.size++;
    }

    public void addLast(Block data) {
        Node node = new Node(data);
        if (this.tail == null && this.head == null) {
            this.tail = node;
            this.head = node;
        } else if (this.tail == null) {
            this.tail = node;
        } else {
            Node old = this.tail;
            this.tail.setNextNode(node);
            this.tail = node;
            this.tail.setpervNode(old);
        }
        this.size++;
    }

    public Node removeFirst() {
        Node removed = this.head;
        this.head = this.head.getNextNode();
        this.size--;
        return removed;
    }

    @Override
    public String toString() {
        String output = "[size=" + this.size + "] >> ";
        Node fromHead = this.head;
        while (fromHead != null) {
            output = output + fromHead.getData();
            if (fromHead != this.tail)
                output = output + " >> ";
            fromHead = fromHead.getNextNode();
        }
        output += "\n";
        Node fromTail = this.tail;
        while (fromTail != null) {
            output = output + fromTail.getData();
            if (fromTail != this.head)
                output = output + " << ";
            fromTail = fromTail.getPrevNode();
        }
        return output;
    }

    public boolean contains(Block data) {
        Node current = this.head;
        while (current != null) {
            if (current.getData() == data) {
                return true;
            }
            current = current.getNextNode();
        }
        return false;
    }

    public void clear() {
        while (this.head != null) {
            this.removeFirst();
        }
        System.out.println("List Is Cleared!");
    }
    
}

这是我的主 class

public class Main {

    public static DoublyLinkedlist blockchain = new DoublyLinkedlist();
    public static void main(String[] args) {
        
        
        blockchain.addFirst(new Block("hi i am the first block", "0"));
        blockchain.addLast(new Block("yo i am the second block", blockchain.get(blockchain.getSize()-1.hash)));       
              
       
       


    }
}

我尝试根据使用 arraylist 实现的教程使用 get 方法，但显然这是错误的语法。

Answer 1

要在当前块中获取前一个块的 hash，可以将前一个块作为成员变量存储在当前块中，并从中检索 hash 值。

import java.util.Date;

public class Block {

    public String hash;
    public String previousHash;
    private String data;
    private long timeStamp;
    private Block previousBlock; // reference to previous Block

    public Block(String data, String previousHash, Block previousBlock) { //accept the previousBlock as an argument
        this.data = data;
        this.previousHash = previousHash;
        this.timeStamp = new Date().getTime();
        this.previousBlock = previousBlock; // store the previous block in a member variable
        this.hash = calculateHash();
    }

    public String calculateHash() {
        String calculatehash = StringUtil.applySha256(
                previousHash + Long.toString(timeStamp) + data);

        return calculatehash;
    }

    public Block getPreviousBlock() { //return the previous block
        return this.previousBlock;
    }
}

这样你就可以通过在块 object 上调用getPreviousBlock().hash来检索前一个块的 hash。

Answer 2

主程序不必处理检索哈希，甚至不必处理创建块。 相反，你的主要代码应该是这样的：

public class Main {
    public static DoublyLinkedlist blockchain = new DoublyLinkedlist();

    public static void main(String[] args) {
        blockchain.addLast("Hi, I am the first block");
        blockchain.addLast("Yo, I am the second block");       
    }
}

那么你的其他类也需要一些调整。 在Node中，我会添加一个可以接受第二个参数的构造函数，因此它可以与前一个节点建立链接：

    public Node(Block data, Node prevNode) { // Additional constructor
        this.data = data;
        this.prevNode = prevNode;
        if (prevNode != null) {
            prevNode.setNextNode(this);
        }
    }

在DoublyLinkedList class 中，删除addFirst方法：您不想在任何现有块之前添加块，因为这会使列表中已存在的块的哈希值无效。 块只能在最后添加。

addLast方法应该采用字符串而不是Block实例，并且此方法也可用于添加第一个块。

    public void addLast(String data) {
        tail = new Node(new Block(data, tail != null ? tail.getData().hash : "0"), tail);
        if (head == null) head = tail;
        size++;
    }