Compiler-Fehler Queue als ArrayList mit Exceptions

[MopedTobias]

Hallo,

ich habe die Aufgabe eine Warteschlange zu erstellen und Laufzeitfehler mit Exceptions abzufangen. Die Methoden: hinzufügen, herausnehmen und zeigen werden erwartet. Die Queue soll als Ringspeicher implementiert sein.
Das, was ich geschrieben habe, wird leider nicht kompiliert. Ich weiß nicht, wie ich das Ende der Warteschlange ansprechen kann. Offensichtlich gibt es da einen Fehler queue[tail] funktioniert also nicht. Ansonsten lass ich mich gerne noch weiter beraten.
Danke schonmal und viele Grüße.

import java.util.ArrayList;

/**	Prgramm zur Implementierung einer
	Warteschlange mit Exception-Handling
*/

class QueueException extends Exception {
	public QueueException() { super();} 		//Konstruktor
	public QueueException(String q) { super(q);}	//Konstruktor
}

public class Warteschlange {

	// Instanzvariablen
	private int head; // erstes Element in der Queue
	private int tail; // erster freier Platz in der Queue
	private static ArrayList<String> queue; // Integer-Array fuer die Elemente

	// Konstruktoren

	// Initialisierungskonstruktor
	// Leere Queue der Groesse max
	public Warteschlange(int laenge) {
		queue = new ArrayList<String>(laenge);
		head = 0;
		tail = 0;
	}

	// Standardkonstruktor
	// Leere Queue der Groesse 5
	public Warteschlange() {
		this(5);
	}

	// String in die Warteschlange einstellen
	public void enqueue(String e) throws QueueException{
		if (!full()) {
			queue[tail] = e;
			if (++tail == queue.size()) {
				tail = 0;
			}
		} else {
			throw new QueueException("Versuchtes Schreiben auf volle Queue");
		}
	}

	// String aus der Warteschlange herausnehmen
	public int dequeue() throws QueueException {
		if (!empty()) {
			int e = queue[head];
			if (++head == queue.size())
				head = 0;
			return e;
		} else {
			throw new QueueException("Versuchter Zugriff auf leere Queue");
		}
	}

	// Oberster Eintrag in der Warteschlange
	public int head() throws QueueException{
		if (!empty()) {
			return queue[head];
		} else {
			throw new QueueException("Versuchter Zugriff auf leere Queue");
		}
	}

	// Test, ob WS voll ist
	public boolean full() {
		return ((tail == queue.size() -1) && (head == 0))
					|| (head == (tail + 1));
	}

	// Test, ob WS leer ist
	public boolean empty() {
		return head == tail;
	}

	// Ausgabe der Warteschlange
	static void show(ArrayList<String> queue) {
		for (int i = 0; i < queue.size(); ++i) {
			System.out.println((String)queue.get(i));
		}
		System.out.println("---");
	}
	
	
	//public int size();

	public static void main(String args) {
		ArrayList<String> queue1 = new ArrayList<String>(3);
		queue1.enqueue("a");
		queue1.enqueue("b");
		queue1.enqueue("c");
		System.out.println(queue);
	}
}

 

[Volvagia]

Natürlich kompiliert das nicht.

queue[tail] und queue[head] ergeben 0 Sinn. [STRIKE]In dequeue gibt es e nicht.[/STRIKE] In einer ArrayList gibt es keine Methode enqueue. Und das die ArrayList statisch ist ist für mein Annahme ein schwerer Bug.

Zu schade, dass Kompiler keine Fehlermeldungen ausgeben, worin steht was er nicht mag.

[EDIT]Übersehen, das es auskommentiert ist.[/EDIT]

 

[MopedTobias]

Wieso gibt es denn in einer ArrayList kein enqueue? Ist was an meiner Methode falsch?
Kann ich eine ArrayList mit einer festen Größe erstellen, damit ich eine Exception bringen kann, wenn die Liste voll ist?

Danke für eure Antworten

Habe auch noch ein bisschen an dem Quellcode getüftelt:

import java.util.ArrayList;

/**	Prgramm zur Implementierung einer
	Warteschlange mit Exception-Handling

*/

class QueueException extends Exception {
	public QueueException() { super();} 		//Konstruktor
	public QueueException(String q) { super(q);}	//Konstruktor
}

public class Warteschlange {

	// Instanzvariablen
	private int head; // erstes Element in der Queue
	private int tail; // erster freier Platz in der Queue
	private ArrayList<Integer> queue; // Integer-Array fuer die Elemente

	// Konstruktoren

	// Initialisierungskonstruktor
	// Leere Queue der Groesse laenge
	public Warteschlange(int laenge) {
		queue = new ArrayList<Integer>(laenge);
		head = 1;
		tail = 2;
	}

	// Standardkonstruktor
	// Leere Queue der Groesse 5
	public Warteschlange() {
		this(5);
	}

	// String in die Warteschlange einstellen
	public void enqueue(int e) throws QueueException{
		if (!full()) {
			this.tail = e;
			if (++tail == queue.size()) {
				tail = 0;
			}
		} else {
			throw new QueueException("Versuchtes Schreiben auf volle Queue");
		}
	}

	// String aus der Warteschlange herausnehmen
	public int dequeue() throws QueueException {
		if (!empty()) {
			int e = this.head;
			if (++head == queue.size())
				head = 0;
			return e;
		} else {
			throw new QueueException("Versuchter Zugriff auf leere Queue");
		}
	}

	// Oberster Eintrag in der Warteschlange
	public int head() throws QueueException{
		if (!empty()) {
			return this.head;
		} else {
			throw new QueueException("Versuchter Zugriff auf leere Queue");
		}
	}

	// Test, ob WS voll ist
	public boolean full() {
		return ((tail == queue.size() -1) && (head == 0))
					|| (head == (tail + 1));
	}

	// Test, ob WS leer ist
	public boolean empty() {
		return head == tail;
	}

	// Ausgabe der Warteschlange
	public void show() {
		for (int i = 0; i < this.tail; ++i) {
			System.out.println(i);
		}
		System.out.println("---");
	}

	public static void main(String[] args) throws QueueException {
		Warteschlange queue1 = new Warteschlange(3);
		queue1.enqueue(1);
		queue1.enqueue(2);
		queue1.enqueue(3);
		queue1.show();
		queue1.enqueue(4);
		queue1.show();
		queue1.dequeue();
		queue1.show();
		queue1.enqueue(5);
		queue1.enqueue(6);
		queue1.enqueue(7);
		queue1.enqueue(8);
		queue1.show();
	}
}

 

[SlaterB]

> Wieso gibt es denn in einer ArrayList kein enqueue? Ist was an meiner Methode falsch?

diese pauschalen Fragen, kurz gestellt und andere können dann immer viel dazu erzählen

1. Volvagia meinte deinen queue1.enqueue()-Aufruf in der main-Methode,
das sollte sich gewiss auf ein Warteschlange-Objekt beziehen, wie du es jetzt ja hast,
insofern eigentlich schon erlegigt

2. in ArrayList gibt es in der Tat kein enqueue(), und das ist auch gut so!
denn eine ArrayList ist ja keine Queue, du baust das erst nach, das Höhere wird aus dem 'Kleineren' aufgebaut,
wer ein Haus aus Holzbalken baut, fragt ja auch nicht wieso der Holzbalken keine Tür hat

3. deine enqueue()-Methode in Warteschlange ist in der Tat falsch, z.B. fügt sie nichts in die ArrayList ein


> Kann ich eine ArrayList mit einer festen Größe erstellen, damit ich eine Exception bringen kann, wenn die Liste voll ist?

schwerlich und sowohl unnötig als auch im Sinne der Aufgabe falsch,
es ist gerade die Aufgabe deiner Methode(n), diesen Punkt zu kontrollieren, und das machst du mit der full()-Methode ja auch mehr oder weniger erfolgreich
(die Länge aus dem Konstruktor musst du anders merken und nutzen, nicht durch Übergabe an ArrayList),
vielleicht als zusätzliches Sicherheitsnetz nett, falls dein full()-Check versagt,
aber ich tendiere langsam zu: nein, das gibt wohl ganz und gar nicht


-----

head und tail sind in der Tat fraglich, die Elemente sollten alle in der Liste stehen,
maximal kannst du Indexe für die Liste merken, aber mit Index 0 für Anfang und ArrayList.size() für deren Ende bist du wohl gut ausgestattet

edit:
je mehr ich schaue, desto schlimmer wirds,
die Ausgabe der Methode gibt die i-Werte 1, 2, 3 usw. hintereinander aus?!
es wird ja gar nicht versucht, irgendwie gespeicherte Werte abzufragen..,
die Queue soll doch Zahlen abspeichern?

passend dazu dein Test

        queue1.enqueue(1);
        queue1.enqueue(2);
        queue1.enqueue(3);

..

speichere lieber 40805, 4895, -5689 und 38888 ab, wenn die so in dieser Reihenfolge gespeichert,
wieder ausgegeben werden, nach Löschung der negativen Zahl die anderen drei in richtiger Reihenfolge übrig bleiben,
dann sieht es langsam gut aus,
ok, in einer Warteschlange löscht man wohl nicht in der Mitte