What I did was basically follow the OP's answer, but I had beforehand to create the .jar file. To do so, I just prepared my custom class in test.java:

import java.lang.System;

public class Test {
    public static void main(String[] args) {
        System.out.println("Hello, world!");
    }
}

And then

javac Test.java
jar cf test.jar Test.class

Now you should see the .jar created. From this point, you are able to access it from Javascript:

let java= require('java');
java.classpath.push('test.jar');

let test = java.import("Test");
test.main(null) // should print "Hello, World!"

While implementing the custom LinkedList/Tree, we need Node. Here is demo of creating Node and LinkedList. I have not put in all the logic. Just basic skeleton is here and you can then add more on yourself.

To better way to use 'node-java' package for inoking the java methods instead of node child process. 'node-java' package allows you to invoke java methods and use java classes within node js application.

For example: First create the java file with name TestJava.java.

public class TestJava {
    public String helloJava(String name) {
        return "Test, " + name + "!";
    }
}

Then compile the java file to generate the .class file. After the generating the class file then create the node.js script with name callJavaMethod.js.

// callJavaMethod.js
const java = require('java');

// Add the current directory to the classpath
java.classpath.push('.');

// Import the Java class
java.import('TestJava');

// Create an instance of the Java class
const testJava= new java.newInstanceSync('TestJava');

// Call the Java method
const result = testJava.helloJava('Java');

// Print the result
console.log(result);

after that you run the node js script and you will get the following answer

Test Java

Try a cloneNode followed by an adoptNode to use a child element as the root element of a new Document.

    String xml = "<hello><world /></hello>";
    try {
        DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
        DocumentBuilder db = dbf.newDocumentBuilder();

        Document document0 = db.parse(new InputSource(new StringReader(xml)));
        Document document1 = db.newDocument();


        NodeList nodeList = document0.getDocumentElement().getChildNodes();
        document1.appendChild(document1.adoptNode(nodeList.item(0).cloneNode(true)));

        // Serialize the two documents to check that the copy was correct.
        ByteArrayOutputStream output = new ByteArrayOutputStream();
        Transformer transformer = TransformerFactory.newInstance().newTransformer();
        transformer.transform(new DOMSource(document0), new StreamResult(output));
        System.out.println(output.toString("UTF-8"));

        output.reset();
        transformer.transform(new DOMSource(document1), new StreamResult(output));
        System.out.println(output.toString("UTF-8"));
    } catch (TransformerException e) {
    } catch (IOException e) {
    } catch (SAXException e) {
    } catch (ParserConfigurationException e) {
    }

Welcome to Java! This Nodes are like a blocks, they must be assembled to do amazing things! In this particular case, your nodes can represent a list, a linked list, You can see an example here:

public class ItemLinkedList {
    private ItemInfoNode head;
    private ItemInfoNode tail;
    private int size = 0;

    public int getSize() {
        return size;
    }

    public void addBack(ItemInfo info) {
        size++;
        if (head == null) {
            head = new ItemInfoNode(info, null, null);
            tail = head;
        } else {
            ItemInfoNode node = new ItemInfoNode(info, null, tail);
            this.tail.next =node;
            this.tail = node;
        }
    }

    public void addFront(ItemInfo info) {
        size++;
        if (head == null) {
            head = new ItemInfoNode(info, null, null);
            tail = head;
        } else {
            ItemInfoNode node = new ItemInfoNode(info, head, null);
            this.head.prev = node;
            this.head = node;
        }
    }

    public ItemInfo removeBack() {
        ItemInfo result = null;
        if (head != null) {
            size--;
            result = tail.info;
            if (tail.prev != null) {
                tail.prev.next = null;
                tail = tail.prev;
            } else {
                head = null;
                tail = null;
            }
        }
        return result;
    }

    public ItemInfo removeFront() {
        ItemInfo result = null;
        if (head != null) {
            size--;
            result = head.info;
            if (head.next != null) {
                head.next.prev = null;
                head = head.next;
            } else {
                head = null;
                tail = null;
            }
        }
        return result;
    }

    public class ItemInfoNode {

        private ItemInfoNode next;
        private ItemInfoNode prev;
        private ItemInfo info;

        public ItemInfoNode(ItemInfo info, ItemInfoNode next, ItemInfoNode prev) {
            this.info = info;
            this.next = next;
            this.prev = prev;
        }

        public void setInfo(ItemInfo info) {
            this.info = info;
        }

        public void setNext(ItemInfoNode node) {
            next = node;
        }

        public void setPrev(ItemInfoNode node) {
            prev = node;
        }

        public ItemInfo getInfo() {
            return info;
        }

        public ItemInfoNode getNext() {
            return next;
        }

        public ItemInfoNode getPrev() {
            return prev;
        }
    }
}

EDIT:

Declare ItemInfo as this:

public class ItemInfo {
    private String name;
    private String rfdNumber;
    private double price;
    private String originalPosition;

    public ItemInfo(){
    }

    public ItemInfo(String name, String rfdNumber, double price, String originalPosition) {
        this.name = name;
        this.rfdNumber = rfdNumber;
        this.price = price;
        this.originalPosition = originalPosition;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getRfdNumber() {
        return rfdNumber;
    }

    public void setRfdNumber(String rfdNumber) {
        this.rfdNumber = rfdNumber;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    public String getOriginalPosition() {
        return originalPosition;
    }

    public void setOriginalPosition(String originalPosition) {
        this.originalPosition = originalPosition;
    }
}

Then, You can use your nodes inside the linked list like this:

public static void main(String[] args) {
    ItemLinkedList list = new ItemLinkedList();
    for (int i = 1; i <= 10; i++) {
        list.addBack(new ItemInfo("name-"+i, "rfd"+i, i, String.valueOf(i)));

    }
    while (list.size() > 0){
        System.out.println(list.removeFront().getName());
    }
}