/ / Java LinkedTree Help - java

Pomoc Java LinkedTree - java

Próbuję zaimplementować połączone drzewo, ale otrzymuję wyjątek nullpointer, gdy go uruchomię. Czy możesz mi pomóc to naprawić?

Wyjątek w wątku „main” java.lang.NullPointerException at assign2Trees.LinkedTree.size (LinkedTree.java:16) at assign2Trees.LinkedTree.main (LinkedTree.java:80)
import java.util.Iterator;
import java.util.NoSuchElementException;

public class LinkedTree<E> implements Tree<E>{

private Node<E> root;

public LinkedTree()
{
super();
}
public int size()
{
return root.getChildren().size() + 1;
}
public boolean isEmpty()
{
if(root == null)
return true;
else
return false;
}
public Iterator<E> iterator()
{
return new Iterator<E>()
{
private int i = 0;

public boolean hasNext()
{
return i < LinkedTree.this.size();
}
public E next() throws NoSuchElementException
{
if (!hasNext())
{
return null;
}
return (E) LinkedTree.this.root.getChildren().get(i++);
}
public void remove()
{

}
};
}
public E replace(E oldE, E newE)
{
int i = root.getChildren().indexOf(oldE);
root.getChildren().add(i, (Node<E>) newE);
return newE;
}
public E root() throws EmptyTreeException
{
if (isEmpty())
throw new EmptyTreeException ();
return this.root();
}
public E parent(E node)
{
return (E) ((Node<E>) root.getChildren()).getParent((root.getChildren().get(root.getChildren().indexOf(node))));
}
public Iterable<E> children(E node)
{
return (Iterable<E>) root.getChildren().listIterator();
}
public void delete(E node) throws RootNonDeletableException
{
if (node == null)
throw new RootNonDeletableException();
else
root.getChildren().remove(root.getChildren().indexOf(node));
}

public static void main(String[] args)
{
LinkedTree<Node<String>> tree = new LinkedTree<Node<String>>();
System.out.println(tree.size());

}


}


import java.util.ArrayList;
import java.util.List;

public class Node<E>{

protected E contents;
protected List<Node<E>> children;
protected Node<E> parent;

public Node()
{
super();
}
public Node(E contents)
{
this.setContents(contents);
}
public List<Node<E>> getChildren()
{
if(this.children == null)
{
return new ArrayList<Node<E>>();
}
return this.children;
}
public void setChildren(List<Node<E>> children)
{
this.children = children;
}
public void addChild(Node<E> child)
{
if (children == null)
{
children = new ArrayList<Node<E>>();
}
children.add(child);
}
public E getContents()
{
return this.contents;
}
public void setContents(E contents)
{
this.contents = contents;
}
public Node<E> getParent(Node<E> node)
{
return node.parent;
}
public void setParent(Node<E> parent, Node<E> child)
{
child.parent = parent;
}
}

Odpowiedzi:

2 dla odpowiedzi № 1

root ma wartość null. Nie intializujesz root do czegokolwiek lub sprawdzanie, czy nie jest null przed uzyskaniem dostępu do tego wiersza

return root.getChildren().size() + 1;

Być może:

return (root == null) ? 0 : root.getChildren().size()+1;

Więc więcej niż prawdopodobne, co naprawdę powinieneś zrobić, to ustawić root do zupełnie nowego węzła w twoim konstruktorze, powiedz:

public LinkedTree()
{
super();
root = new Node<E>();
}

Masz również błąd ze swoim root() funkcjonować:

public E root() throws Exception
{
if (isEmpty())
throw new Exception ();
return this.root();
}

Zadzwoni do siebie. Być może miałeś na myśli

public E root() throws Exception
{
if (isEmpty())
throw new Exception ();
return this.root;
}

Teraz, aby rozpocząć budowanie drzewa w głównej metodzie, możesz zrobić coś takiego:

tree.root().addChild(new Node<String>("test"));

To, co to robi, to pobranie katalogu głównego drzewa, a następnie dodanie do niego potomka.

Przypuśćmy, że chcesz dodać skomplikowaną strukturę, np. Węzeł z dzieckiem, możesz to zrobić:

Node<String> deepest = new Node<String>("deepest node");
Node<String> deeper  = new Node<String>("deeper node");
deeper.addChild(deepest);
tree.root().addChild(deeper);

To daje drzewo ze strukturą:

[root] + - [głębszy] + - najgłębszy

0 dla odpowiedzi nr 2

Zmiana

public List<Node<E>> getChildren()
{
if(this.children == null)
{
return new ArrayList<Node<E>>();
}
return this.children;
}

do

public List<Node<E>> getChildren()
{
if(this.children == null)
{
return this.children = new ArrayList<Node<E>>(); // set the this.children field and return.
}
return this.children;
}

Powiedz mi, jak to idzie.


0 dla odpowiedzi № 3

Węzeł główny nigdy nie jest inicjowany, więc próbujesz wywołać getChildren () na obiekcie, który nie istnieje.