Ok jongens, dus ik probeer te leren hoe ik een gelinkte lijst kan afdrukken. Ik heb alle methoden die ik voor de lijst zou moeten gebruiken, maar ik kan er niet achter komen hoe ik de waarden van de knooppunten moet weergeven. Op dit moment is er niets in mijn hoofdmethode omdat ik steeds fouten kreeg bij het proberen om niet-statische methoden in de hoofdmethode aan te roepen. Ik heb een toString-methode die de inhoud van de lijst weergeeft. Hoe zou ik dit toString kunnen noemen om de waarde van elk knooppunt weer te geven? Elk advies wordt zeer op prijs gesteld.
Hier is de knooppuntklasse:
public class LinkedListNode
{
private int data;
private LinkedListNode next;
public LinkedListNode(int data)
{
this.data = data;
this.next = null;
}
public int getData()
{
return data;
}
public void setData(int d)
{
data = d;
}
public LinkedListNode getNext()
{
return next;
}
public void setNext(LinkedListNode n)
{
next = n;
}
}
Hier is de klasse LinkedList die de hoofd- en methoden bevat om de lijst te manipuleren:
public class LinkedList {
public LinkedListNode head;
public static void main(String[] args) {
LinkedList l = new LinkedList();
l.insertFront(0);
System.out.println(l.toString());
}
public LinkedList() {
this.head = null;
}
public int removeFront(){
if(head == null){
System.out.println("Error - Attempting to call removeFront() on empty list");
return 0;
}else{
int temp = head.getData();
head = head.getNext();
return temp;
}
}
public void insertFront(int data){
if(head == null){
head = new LinkedListNode(data);
}else{
LinkedListNode newNode = new LinkedListNode(data);
newNode.setNext(head);
head = newNode;
}
}
public void insertBack(int data){
if(head == null){
head = new LinkedListNode(data);
}else{
LinkedListNode newNode = new LinkedListNode(data);
LinkedListNode current = head;
while(current.getNext() != null){
current = current.getNext();
}
current.setNext(newNode);
}
}
public int removeBack(){
if(head == null){
System.out.println("Error - Attempting to call removeBack() on empty list");
return 0;
}else if (head.getNext() == null){
int temp = head.getData();
head = null;
return temp;
}else{
LinkedListNode current = head;
while(current.getNext().getNext() != null){
current = current.getNext();
}
int temp = current.getNext().getData();
current.setNext(null);
return temp;
}
}
public String toString(){
String retStr = "Contents:\n";
LinkedListNode current = head;
while(current != null){
retStr += current.getData() + "\n";
current = current.getNext();
}
return retStr;
}
public LinkedListNode getHead() {
return head;
}
public void setHead(LinkedListNode head) {
this.head = head;
}
}
Antwoord 1, autoriteit 100%
public static void main(String[] args) {
LinkedList list = new LinkedList();
list.insertFront(1);
list.insertFront(2);
list.insertFront(3);
System.out.println(list.toString());
}
String toString() {
String result = "";
LinkedListNode current = head;
while(current.getNext() != null){
result += current.getData();
if(current.getNext() != null){
result += ", ";
}
current = current.getNext();
}
return "List: " + result;
}
Antwoord 2, autoriteit 57%
Zoals in sommige andere antwoorden en opmerkingen is opgemerkt, ontbreekt hier een aanroep van de JVM System-klasse om de tekenreeks af te drukken die door uw methode toString() is gegenereerd.
LinkedList myLinkedList = new LinkedList();
System.out.println(myLinkedList.toString());
Dit zal de klus klaren, maar ik zou het niet aanraden om het op die manier te doen. Als we de javadocs voor de klasse Object bekijken, vinden we deze beschrijving voor toString():
Retourneert een tekenreeksrepresentatie van het object. Over het algemeen retourneert de methode toString een tekenreeks die dit object “tekstueel vertegenwoordigt”. Het resultaat moet een beknopte maar informatieve weergave zijn die voor een persoon gemakkelijk te lezen is. Het wordt aanbevolen dat alle subklassen deze methode overschrijven.
De nadruk die daar wordt gelegd, is die van mij. U maakt een tekenreeks die de volledige status van de gekoppelde lijst bevat, wat iemand die uw klas gebruikt waarschijnlijk niet verwacht. Ik zou de volgende wijzigingen aanbevelen:
- Voeg een methode toString() toe aan uw klasse LinkedListNode.
- Werk de methode toString() in uw LinkedList-klasse bij om het beknopter te maken.
- Voeg een nieuwe methode toe met de naam printList() aan uw LinkedList-klasse die doet wat u momenteel van toString() verwacht.
In LinkedListNode:
public String toString(){
return "LinkedListNode with data: " + getData();
}
In LinkedList:
public int size(){
int currentSize = 0;
LinkedListNode current = head;
while(current != null){
currentSize = currentSize + 1;
current = current.getNext();
}
return currentSize;
}
public String toString(){
return "LinkedList with " + size() + "elements.";
}
public void printList(){
System.out.println("Contents of " + toString());
LinkedListNode current = head;
while(current != null){
System.out.println(current.toString());
current = current.getNext();
}
}
Antwoord 3, autoriteit 14%
Wanneer de JVM uw applicatie probeert uit te voeren, roept het uw hoofdmethode statisch aan; zoiets als dit:
LinkedList.main();
Dat betekent dat er geen instantie is van uw head-klasse. Om uw methode override aan te roepen, kunt u een nieuwe instantie van uw klasse head maken.
Dus de hoofdtekst van uw main-methode zou er als volgt uit moeten zien:
public static void main(String[] args){
// creating an instance of LinkedList class
LinkedList ll = new LinkedList();
// adding some data to the list
ll.insertFront(1);
ll.insertFront(2);
ll.insertFront(3);
ll.insertBack(4);
System.out.println(ll.toString());
}
Antwoord 4, autoriteit 14%
Ik doe het op de volgende manier:
public static void main(String[] args) {
LinkedList list = new LinkedList();
list.insertFront(1);
list.insertFront(2);
list.insertFront(3);
System.out.println(list.toString());
}
String toString() {
StringBuilder result = new StringBuilder();
for(Object item:this) {
result.append(item.toString());
result.append("\n"); //optional
}
return result.toString();
}
Antwoord 5
Een heel eenvoudige oplossing is om de override-methode toString() in de Node. Vervolgens kun je print aanroepen door de head van head door te geven.
U hoeft geen enkele vorm van lus te implementeren.
Code:
public class LinkedListNode {
...
//New
@Override
public String toString() {
return String.format("Node(%d, next = %s)", data, next);
}
}
public class LinkedList {
public static void main(String[] args) {
LinkedList l = new LinkedList();
l.insertFront(0);
l.insertFront(1);
l.insertFront(2);
l.insertFront(3);
//New
System.out.println(l.head);
}
}