eigenartige Ausgabe nach dem Einlesen

[zooza]

Hi, folgender Code:


Main

public class Main {

    public static void main(String[] args) {

        LinkedList<Termin> termin = new LinkedList<Termin>();
        LinkedList<Tank> tank = new LinkedList<Tank>();
        
        termin = termin.read("termine.csv");
        tank = tank.reader("tank.csv");


        while (termin.next() != null) {

            termin = termin.next();
            System.out.println(termin.getItem());
            System.out.println("");
        }
        
        while (tank.next() != null) {

            tank = tank.next();
            System.out.println(tank.getItem());
            System.out.println("");
        }
    }
}

Tank:

public class Tank implements Comparable<Tank> {

    /**
     * Definiert die kilometer
     */
    private String kilometer;

    /**
     * Definiert die Liter
     */
    private String liter;

    /**
     * Definiert den Betrag
     */
    private String betrag;

    /**
     * Definiert den Fuellstand
     */
    private String fuellstand;
    
    public Tank(String[] tank) {
        this.kilometer = tank[0];
        this.liter = tank[1];
        this.betrag = tank[2];
        this.fuellstand = tank[3];
    }
    
    public String getKilometer() {
	return this.kilometer;
    }
    
    public String getLiter() {
	return this.liter;
    }
    
    public String getBetrag() {
	return this.betrag;
    }
    
    public String getFuellstand() {
	return this.fuellstand;
    }
    
    public int compareTo(Tank x) {

        int kmstand = Integer.parseInt(this.kilometer);
        int kmstandzwei = Integer.parseInt(x.kilometer);
        
        if (kmstand < kmstandzwei) {
            return -1;
        } else {
            return 1;

}
}
}

LinkedList:

import java.io.FileInputStream;
import java.io.IOException;
import java.util.Scanner;

public class LinkedList<T extends Comparable<T>> implements List<T> {

    /**
     * count repraesentiert die Anzahl der Elemente in der Liste, ist zu Beginn auf 0 gesetzt
     */
    private int count = 0;

    /**
     * repraesentiert den Termin
     */
    private T item;

    /**
     * next representiert das naechste Element der Liste
     */
    private LinkedList<T> next;

    /**
     * Konstruktor der Klasse LinkedList
     */
    public LinkedList() {
        this.item = null;
        this.next = null;
    }
    /**
     * @return gibt den Termin zurueck
     */
    public T getItem() {
        return this.item;
    }

    /**
     * @return gibt den Termin zurŸck
     */

    /**
     * @return gibt das naechste Element zurueck
     */
    public LinkedList<T> next() {
        return this.next;
    }

    /**
     * @return Prueft ob die Liste leer ist
     */
    public boolean isEmpty() {
        return (this.next == null);
    }

    /**
     * @return gibt die Anzahl der Elemente der Liste zurueck
     */
    public int length() {
        if (this.isEmpty()) {
            return 0;
        } else {
            return 1 + this.next.length();
        }
    }

    /**
     * @return gibt den ersten Termin zurueck
     */
    public T erstesElement() {
        if (this.isEmpty()) {
            return null;
        } else {
            return this.next.item;
        }
    }

    /**
     * @param x fuegt einen Termin der Liste hinzu
     * @return gibt eine Liste inklusive des neuen Termins zurueck
     */
    public LinkedList<T> insert(T x) {

        LinkedList<T> newItem = new LinkedList<T>();
        this.count++;

        if (this.isEmpty()) {   // die Liste ist leer, also neuen Termin einfach so einfuegen

            newItem.item = x;
            newItem.next = this.next;
            this.next = newItem;

        } else {                // die liste enthaelt schon Termine, also sortiert einfuegen

            LinkedList<T> tmp = new LinkedList<T>();
            tmp = this;

            while (tmp.next != null && tmp.next.item.compareTo(x) <= 0) {
                tmp = tmp.next;
            }

            newItem.item = x;
            newItem.next = tmp.next;
            tmp.next = newItem;

            return tmp;
        }

        return this;
    }

    /**
     * @param x loescht den Termin der uebergeben wurde
     * @return gibt die Liste ohne den geloeschten Termin zurŸck
     */
    public LinkedList<T> delete(T x) {
        return this;
    }

    /**
     * @param pfad Verzeichnispfad zur CSV-Datei
     * @return gibt die fertige Liste zurueck
     */
    public LinkedList<Termin> read(String pfad) {

        String line = "";
        LinkedList<Termin> liste = new LinkedList<Termin>();

        try {

            FileInputStream datei = new FileInputStream(pfad);
            Scanner s = new Scanner(datei);

            LinkedList<Termin> ll = new LinkedList<Termin>();

            while (s.hasNextLine()) {
                line = s.nextLine();
                String[] item = line.split(";");
                ll.insert(new Termin(item));
            }
            liste = ll;
            datei.close();
            s.close();

        } catch (IOException e) {
            System.out.println("Fehler mit der Termin-Datei!");
        }
        return  liste;
    }
    
    //für Tankdatei
    public LinkedList<Tank> reader(String pfad) {
        String lines = "";
        LinkedList<Tank> listet = new LinkedList<Tank>();

        try {

            FileInputStream datei = new FileInputStream(pfad);
            Scanner sc = new Scanner(datei);

            LinkedList<Tank> lls = new LinkedList<Tank>();

            while (sc.hasNextLine()) {
                lines = sc.nextLine();
                String[] item = lines.split(";");
                lls.insert(new Tank(item));
            }
            listet = lls;
            datei.close();
            sc.close();

        } catch (IOException e) {
            System.out.println("Fehler mit der Tank-Datei!");
        }
        return  listet;
    }
}

Es kompiliert ohne Fehler, aber als Ausgabe für die Tank-Datei erhalte ich lediglich:

Tank@63bed674

Tank@5f18cd5

Tank@3554f6ff

Was bedeutet das? Wo liegt der Fehler?

LG

 

[njans]

Lösung: Überschreibe die toString Methode deiner Tank Klasse.
Momentan bekommst du die Standardausgabe von toString von dem Basis Object in Java.

 

[zooza]

Danke, hat geklappt