Warteschlange

[NullPlan]

ich wollte eine Warteschlange vom Typ java.util.LinkedList nutzen, deren Elemente vom Typ Car sind

import java.awt.Color;

public class Car
{	
	Color c;
	int id;
	static int counter = 0;
	
	//Element
	Car element;
	
	//Zeiger auf Vorgänger und Nachfolger
	Car prev,
		next;
	
	
	[b]public Car()
	{
		c = randomColor();
		id = counter ++;[/b]
		element = null;
		prev = null;
		next = null; 
	}
	
	private Color randomColor()
	{
		return new Color((int)(255*Math.random()), (int)(255*Math.random()), (int)(255*Math.random()));
	}
	
	public Color getColor()
	{
		return c;
	}
	
	public int getID()
	{
		return id;
	}
	

	//Konstruktor
	public Car(Car o, Car p, Car n)
	{
		element = o;
		prev = p;
		next = n;
	}//Node
	
	//Element neu belegen
	public void setElement(Car o)
	{
		element = o;
	}
	
	//Zugriff auf Element
	public Car getElement()
	{
		return element;
	}
	
	//Nachfolger setzen
	public void setNext(Car n)
	{
		next = n;
	}
	
	//Zugriff auf Nachfolger
	public Car getNext()
	{
		return next;
	}
	
	//Vorgaenger neu belegen
	public void setPrevious(Car p)
	{
		prev = p;
	}
	
	//Zugriff auf Vorgänger
	public Car getPrevious()
	{
		return prev;
	}
}

das dick geschriebene war die orginalklasse. habe zuersteinmal das grundgerüst der linkedList in diese klasse eingebunden.

habe dann in einer weiteren klasse:

import java.util.LinkedList;

/*
 * noch leere Klasse Road soll der Thread implementiert werden
 * 
 */
public class RoadTest extends Thread
{
	
//	Listenanfang
	private Car head = null;
	//Listenende
	private Car tail = null;
	
	public RoadTest()
	{
		//beide Knoten werden initialisiert
		head = new Car();
		tail = new Car();
		
		//Anfang und Ende "verknüpfen"
		head.setNext(tail);
		tail.setPrevious(head);
		tail.setNext(tail);
	}//DList
	
	//fuegt ein Element am Ende der Liste an
	public void addLast(Car c)
	{
		//Knoten zwischen tail und dessen Vorgaenger einfuegen
		Car l = tail.getPrevious();
		Car n = new Car(c,l,tail);
		l.setNext(n);
		tail.setPrevious(n);
	}//addLast
	
	//entfernt das vordere Element und gibt es zurück
	public Car removeFirst() throws QueueEmptyException
	{
		if(isEmpty())
			throw new QueueEmptyException();
		
		//Zugriff ueber Listenanfang
		Car o = head.getNext().getElement();
		
		//Knoten zwischen head und Nachfolger entfernen
		head.setNext(head.getNext().getNext());
		head.getNext().setPrevious(head);
		return o;
	}//removeFirst
	
	//liefert die Anzahl der Objekte
	public int size()
	{
		int s = 0;
		Car n = head;
		
		//Knoten zaehlen
		while(n.getNext() != null)
		{
			s++;
			n = n.getNext();
		}//while
		return s;
	}//size
	
	//testet, ob die Liste leer ist
	public boolean isEmpty()
	{
		//kleine Knoten zwischen head und tail
		return head.getNext() == tail;
	}//isEmpty
	
	//gibt alle Elemente in der Liste als String zurück
	public String toString() 
	{
		String result="";
		
		for (Car n = this.head.getNext(); n != null; n = n.getNext()) 
		{
			result += n.getElement();
			
			if (n.getNext() != null) 
				result += " , ";
		}//for
		
		return result;
	}//toString
	
	public LinkedList getRight() 
	{
		return null;
	}

	public LinkedList getMiddle() 
	{
		return null;
	}
	
}//class

die methoden der linkedlist vom typ queue implementiert.
ist das soweit richtig???

jetzt muss ich die elemente vom typ car machen, weiß aber nicht welchen fehler ich mache!

kann mir jemand weiterhelfen?

 

[Zilchinger]

Hi nullPlan,
ich würde mir das ganze nicht so kompliziert machen, da die LinkedList eigentlich alles hat was du brauchst um eine Queue zu implementieren.

import java.util.LinkedList;

/**
 * @author Zille
 *
 * TODO To change the template for this generated type comment go to
 * Window - Preferences - Java - Code Style - Code Templates
 */
public class Queue {
    
    private LinkedList data = new LinkedList();
    
    
    /**
     * Car-Element in die Queue schieben
     * @param auto
     */
    public void pushCar(Car auto){
        data.add(auto);
    }
    
    /** Das nächste Car-Element aus der Queue holen.
     *  Funktioniert nach dem FIFO-Prinzip (First In First Out)
     * @return
     */
    public Car popCar(){
        Car temp = (Car)data.get(0);
        data.remove(0);
        return temp;
    }
    
    /**
     * Anzahl der Car-Elemente zurückgeben
     * @return
     */
    public int carCount(){
        return data.size();
    }
    
    /**
     * Prüft ob die Queue leer ist
     * @return
     */
    public boolean isQueueEmpty(){
        if (data.size()==0)
            return true;
        else
            return false;
    }
}

Schau dir mal meine Implementierung der Queue an, sollte so funktionieren.
Ich hoffe ich habe deine Frage richtig verstanden...

 

[mic_checker]

    public boolean isQueueEmpty(){
        if (data.size()==0)
            return true;
        else
            return false;
    }

Das ist schöner :

return data.size() == 0;

 

[Sky]

Ansonsten noch der Verweise auf die Klasse 'AbstractQueue' und das Interface 'Queue'

btw.: 'Queue' wird von 'LinkedList' implementiert...

 

[messi]

    public Car popCar(){
        Car temp = (Car)data.get(0);
        data.remove(0);
        return temp;
    }

return data.remove(); reicht völlig aus.

    public boolean isQueueEmpty(){
        if (data.size()==0)
            return true;
        else
            return false;
    }

Niemals size()==0 zum Testen benutzen, weil die unterliegende Collection evtl keinen Zähler hat und die Elemente immer frisch zählen muß. LinkedList benutzt einen Zähler. Schlimm wäre es aber, wenn gerade eine verkettete Liste immer durchgegangen werden muß. Zum Testen benutzt man isEmpty(). Und dann schreibt man kein if( ), sondern direkt return data.isEmpty().

 

[Zilchinger]

Danke für die netten Verbesserungsvorschläge,
ich hatte mir die LinkedList auf die Schnelle nicht so genau angeschaut, aber die Verbesserungen leuchten natürlich vollkommen ein, kein Thema