Eigene Klasse mit "Enumeration"-Datentyp verknüpfe

[Michael G.]

Guten Morgen,

ich habe eine doppelt Verkettete Liste geschrieben, die diverse Listenelemente speichern kann (z.B. Rechtecke oder Kreise).

DIese wiederum sind simple Klassen die ich selbst geschrieben habe!

Nun haben wir gesehen, dass es z.b. für die Klasse Vector java.util.Vector;java.util.Vector folgende Methodengibt:

Zitat:
Enumeration days;
Vector dayNames = new Vector();
dayNames.add("Sunday");
dayNames.add("Monday");
days = dayNames.elements();

Da ich aber keinen Typ "Vector" benutzen sondern einen eigenen (VerketteteListe), muss ich die Methode elements(), die eine Enumeration der Liste zurückgeben soll, selbst schreiben.

Dazu wäre alleine schon hilfreich ein Code Beispiel zu sehen, welches die elements()-Funktion beim Vektor beschreibt damit ich dies auf unseren Fall sozusagen umdenken kann.

Ich bedanke mich für jede Art von Hilfestellung!

 

[SlaterB]

da hast du dir ja genau die falsche Klasse ausgesucht, Vector und Enumeration sind etwas veraltet,
Collections, List und Iterator sind nun die Kings,
Vector bietet übrigens auch einen Iterator an,

hier der Iterator aus der neuen Version des Vectors, aus ArrayList, bzw. dessen Superklasse AbstractList:

    public Iterator<E> iterator() {
	return new Itr();
    }




    private class Itr implements Iterator<E> {
        /**
         * Index of element to be returned by subsequent call to next.
         */
        int cursor = 0;

        /**
         * Index of element returned by most recent call to next or previous. Reset to -1
         * if this element is deleted by a call to remove.
         */
        int lastRet = -1;

        /**
         * The modCount value that the iterator believes that the backing List should
         * have. If this expectation is violated, the iterator has detected concurrent
         * modification.
         */
        int expectedModCount = modCount;

        public boolean hasNext() {
                return cursor != size();
        }

        public E next() {
                checkForComodification();
            try {
            E next = get(cursor);
            lastRet = cursor++;
            return next;
            } catch(IndexOutOfBoundsException e) {
            checkForComodification();
            throw new NoSuchElementException();
            }
        }

        public void remove() {
            if (lastRet == -1)
            throw new IllegalStateException();
                checkForComodification();

            try {
            AbstractList.this.remove(lastRet);
            if (lastRet < cursor)
                cursor--;
            lastRet = -1;
            expectedModCount = modCount;
            } catch(IndexOutOfBoundsException e) {
            throw new ConcurrentModificationException();
            }
        }

        final void checkForComodification() {
            if (modCount != expectedModCount)
            throw new ConcurrentModificationException();
        }
        }

E ist der generische Parameter der Liste, kann auch Object oder sonst was sein,
das get aus Zeile 28 ist das get von ArrayList


modCount ist eine Variable aus der Liste, die die Anzahl der Änderungen der Liste zählt,
kann auch wegfallen

 

[Guest]

Hallo Slater,

danke für deine schnelle Antwort.

Das "Problem" an der ganzen Sache ist nur, dass ich die Aufgabe explizit mit Enumerator lösen muss. Ist also nix mit Iterator etc.

Außerdem arbeite ich in meinem Code nicht mit nem Vector sondern mit der Klasse "ObjectList" die wiederum als Typ das "ListenElement" hat...

Implementiere eine Methode namens public Enumeration elements(), welche eine Implementierung des Enumeration-Interface für die Klasse LinkedList implementiert und zurückliefert.

Ich poste dir einfach mal den Code den ich geschrieben habe...

public class ObjectList {
 
	Rectangle test;
	public ListenElement start = new ListenElement(test);		// Prellbock für den Anfang der Liste
	public ListenElement ende = new ListenElement(test);		// Prellbock für das Ende der Liste
	
	
	// ----------------------------------------------------------- //
	// Konstruktor RectangleList() erstellt eine neue Liste indem  //
	// die Zeiger von den Prellböcken aufeinander gesetzt werden   //
	// --------------------------------------------------------- //
	
	public ObjectList()                            
	  {  
	  start.next = ende;										
	  start.prev = null;
	  ende.prev = start;
	  ende.next = null;
	  System.out.printf("Neue Rechteck-Liste erstellt!\n");  	
	  }
	  
	// --------------------------------------------------------- //
	// Neue Klasse ListenElement beinhaltet ein Rechteck und     //
	// zwei neue Listenelemente für die Verzeigerung			 //
	// --------------------------------------------------------- //
	
	  public class ListenElement {                 

		  public ListenElement next;
		  public ListenElement prev;
		  public Object element;      
		  
	// --------------------------------------------------------- //  
    // Konstruktor für das ListenElement übergibt ein Rechteck   //
    // und weist es dem Element zu. "Zeiger" werden auf null     //
	// gesetzt													 //
	// --------------------------------------------------------- //
		  public ListenElement(Object obj)  
		  {                           
		    element = obj;   
		    next = null;
		    prev = null;
		  }	 
	}
	
	// --------------------------------------------------------- //
	// Methode insertFirst(Rectangle r) fügt am Anfang der Liste //
	// ein neues Rechteck ein und korrigiert die Verzeigerung    //
	// --------------------------------------------------------- //
	  
	void insertFirst(Object r){
		ListenElement neuerEintrag = new ListenElement(r);
		
		neuerEintrag.next = start.next;
		start.next.prev = neuerEintrag;
		start.next = neuerEintrag;
		neuerEintrag.prev = start;
		
		System.out.printf("Rectangle Element am Anfang der Liste eingefügt!\n");
	}
	
	// --------------------------------------------------------- //
	// Methode insertLast(Rectangle r) fügt am Ende der Liste    //
	// ein neues Rechteck ein und korrigiert die Verzeigerung    //
	// --------------------------------------------------------- //
	
	void insertLast(Object r){
		ListenElement neuerEintrag = new ListenElement(r);
		
		neuerEintrag.prev = ende.prev;
		ende.prev.next = neuerEintrag;
		ende.prev = neuerEintrag;
		neuerEintrag.next = ende;
		
		System.out.printf("Rectangle Element am Ende der Liste eingefügt!\n");
	}

	// --------------------------------------------------------- //
	// Methode clear() setzt die beiden Prellböcke wieder auf-   //
	// einander. Alle Elemente in der Liste sind gelöscht		 //
	// --------------------------------------------------------- //
	
	void clear(){
	
		start.next = ende;
		ende.prev = start;
		
		System.out.printf("Liste aufgeräumt!\n");
	}

Die Main müsste dann in etwa wie folgt aussehen:

Es werden diverse Objekte erstellt, die neue Liste wird angelegt und am Anfang/Ende eingefügt!

public static void main(String[] args) {
	    System.out.printf("***********************************************************\n");
	    System.out.printf("********************* Programmanfang **********************\n");
	    System.out.printf("***********************************************************\n\n");
	    
	    
		System.out.printf("------------- Objekte werden erstellt---------------\n");
		Rectangle r = new Rectangle(1,2);
		Circle c = new Circle(5, 3 ,2);
		Circle d = new Circle(7, 3 ,7);
		char buchstabe = ('a');
		Rectangle s = new Rectangle(4,8)


                System.out.printf("-------------- Rechteck-Liste wird angelegt----------------\n");
		ObjectList liste = new ObjectList();
		System.out.printf("\n\n");
		
		
		System.out.printf("---------- 2 Elemente am Anfang und Ende einfügen ---------\n");
	    liste.insertFirst (r);
	    liste.insertFirst (s);
	    liste.insertFirst(c);
	    liste.insertFirst(buchstabe);
	    liste.insertLast(d);

Der Code in der Main müsste dann in etwa so aussehen:

Enumeration E;
E = liste.elements();
while (E.hasMoreElements())
System.out.println(E.nextElement());

Das Problem ist nun sozusagen dass ich in der Funktion "public Enumeration elements()" irgendwie den Typ Enumeration mit der Liste verknüpfen muss (Auf das erste Element setzen oder so). Ich aber absolut keinen Ansatz habe wie ich das lösen könnte!

 

[Michael G.]

Der letzte Eintrag stammt übrigens von mir

Hab nur den Namen vergessen gehabt.

 

[SlaterB]

ob nun Enumeration oder Iterator, das ist doch nur ein Name,

da du nun anscheinden explizit eine Aufgabenstellung zitierst,
werde ich mich mit Komplettlösungen lieber zurückhalten

schau dir an, was Enumaration für Methoden anbieten muss und fülle diese passend,
viel anders als Iterator kann das doch nicht,

fange mit den beiden zentralen Methoden hasNext() (heißt dort hasMoreElements()) + next() an (edit: es gibt nur diese beiden, kein remove()),
oben habe ich ein Beispiel gepostet, so ähnlich muss das aussehen,

wenn dir generell ganz fremd ist, eine Klasse zu füllen/ Verhalten nachzubauen, dann gehts eh nicht weiter

 

[Michael G.]

Soweit ich das verstanden habe, sollten nicht die Methoden "hastMoreElements" bzw "next.Element" nachgebaut werden, sondern einzig die Funktion "Enumeration elements()" soll irgendwas machen.

Was genau, verstehe ich nicht wirklich.

Deshalb habe ich mir das Beispiel mit dem Vector aus dem Netz rausgesucht gehabt (den ich im ersten Post angesprochen habe).

Dort wird der Vector eben mit dieser Funktion aufgerufen, die wiederum etwas vom Typ Enumerator zurück geben.

Leider habe ich nirgendwo ein Beispiel gefunden, was diese elements() Funktion genau macht.

 

[tfa]

Die elements()-Funktion liefert ein Objekt, das die Schnittstelle "Enumeration" implementiert. Und für dieses Objekt (bzw. dessen Klasse) musst du die Methoden hasMoreElements() und nextElement() implementieren (z.B. in einer inneren Klasse).

 

[SlaterB]

im Prinzig genau das gleiche wie

public Iterator<E> iterator() {
return new Itr();
}

weiter oben, es gibt nur ein Objekt der benötigten Klasse zurück,
die Klasse muss natürlich neu geschrieben und speziell auf die eigene Klasse angepasst sein, indem die Methoden "hasMoreElements" usw nun mal mit Inhalt gefüllt werden,

ich sehe gerade, dass das bei Vector mit Enumeration deutlich einfacher ist,
da mein erstes Iterator-Beispiel dann nur mehr verwirrt als hilft poste ich auch das aus Vector:

    /**
     * Returns an enumeration of the components of this vector. The 
     * returned <tt>Enumeration</tt> object will generate all items in 
     * this vector. The first item generated is the item at index <tt>0</tt>, 
     * then the item at index <tt>1</tt>, and so on. 
     *
     * @return  an enumeration of the components of this vector.
     * @see     Enumeration
     * @see     Iterator
     */
    public Enumeration<E> elements() {
	return new Enumeration<E>() {
	    int count = 0;

	    public boolean hasMoreElements() {
		return count < elementCount;
	    }

	    public E nextElement() {
		synchronized (Vector.this) {
		    if (count < elementCount) {
			return (E)elementData[count++];
		    }
		}
		throw new NoSuchElementException("Vector Enumeration");
	    }
	};
    }

elementCount und elementData sind wiederum Daten aus dem umgebenden Vector,
für eine verkettete Liste muss das grundsätzlich anders aussehen,

es gilt aber nach wie vor: du musst die Methoden wie hasMoreElements() implementieren,
dir ausdenken, wie diese auf deine Liste zugreifen sollen

 

[Michael G]

Also wenn ich das richtige verstanden habe müsste es in etwa so aussehen? :

public Enumeration<Object> elements() {
		   return new Enumeration<Object>() {
			   Object test = new Object();
			   test = start.next;
		       
		       public boolean hasMoreElements() {
		    	  return test != null;
		       }

		       public Object nextElement() {
		    	   if (test != null) {
		    		   return (Object) test;
		    	   	   }
		       }
		   };
	}

Oder bin ich grad auf nem absoluten Holzweg?

 

[SlaterB]

> test = start.next;

kannst du nicht direkt in eine Klasse schreiben,
aber das new Object() vorher ist auch unnötig,
kannst direkt

Object test = start.next;

schreiben, wenn start selber nicht benötigt wird?
außerdem wäre eigentlich zu prüfen, ob start null ist, falls das nicht ausgeschlossen ist

----

> return (Object) test;

ein cast auf Object ist unnötig, alle Objekte sind vom Typ Object

-----

nextElement() muss immer irgendwas zurückgeben (vielleicht null) oder besser eine Exception werfen, wenn nix da ist, du brauchst also noch einen else-Fall



im Grunde aber schon ziemlich gut, bin erleichtert

 

[Landei]

Wenn ich deine Implementierung richtig verstehe, dann etwa so:

public Enumeration<Object> elements() { 
         return new Enumeration<Object>() { 
            ListElement test = start; 
              
             public boolean hasMoreElements() { 
               return test.next != ende; 
             } 

             public Object nextElement() { 
                if (hasMoreElements()) { 
                   test = test.next;
                   return test.element; 
               } else {
                   throw new NoSuchElementException("Slater hat Recht!");
               } 
             } 
         }; 
   }

Aaaber ich würde mir an deiner Stelle mal überlegen, ob du deine Liste (und dann auch die Enumeration) generisch und damit typsicherer machst, anstatt mit Object rumzuhantieren.

 

[SlaterB]

eieiei, das Landei hat auch kein return im else-Fall (edit: nun doch)

aber der Fortschritt zum nächsten Element in nextElement() fehlte noch, stimmt

 

[Landei]

Korrigiert

 

[Michael G.]

Erstmal ein dickes Dankeschön. Das geht hier echt rasend schnell

*Daumen hoch*

@ Landei

Was du mit generisch meinst, verstehe ich nicht. Wir hatten bisher erst 5 Vorlesungen zu Java. Nix überstürzen

@ SlaterB

Mein Problem lag glaube ich nur darin, das für einen absoluten Java Anfänger die Aufgabenstellung doch ein wenig schwammig erscheint. Ich denke nun aber das Grundprinzip verstanden zu haben.

Ich schau mal ob ich das Zeugs implementieren kann und melde mich danach nochmal

 

[Michael G.]

Es funktioniert! Und ich glaube ich habe jetzt auch das Prinzip von Enumerator/Iterator unter Java verstanden.

An Hand der Aufgabenstellung hätte ich aber niemals erkannt, dass die beiden Methoden neu geschrieben werden müssen (Was aber im Endeffekt eigentlich doch logisch ist).

Ich habe mal meinen kompletten Code gepostet.

Die Exception habe ich mal rausgenommen weil mein Eclipse das irgendwie nicht erkennt. Anscheinend fehlt das ein Import oder sowas.

import java.util.Enumeration;

public class ObjectList {
 
	Object test;
	public ListenElement start = new ListenElement(test);		// Prellbock für den Anfang der Liste
	public ListenElement ende = new ListenElement(test);		// Prellbock für das Ende der Liste
	
	
	// ----------------------------------------------------------- //
	// Enumerator wird mit dem Anfang der Liste initialisiert      //
	// mit der Methode hasMoreElements() wird geprüft ob es noch   //
	// weitere Elemente in der Liste gibt.						   //
	//															   //
	// Mit der Funktion nextElement wird durch die Liste gelaufen  //
	// und jeweils das aktuelle Element zurückgegeben.			   //
	// ----------------------------------------------------------- //
	
	public Enumeration<Object> elements() {
        return new Enumeration<Object>() {
           ListenElement begin = start;
           
            
            public boolean hasMoreElements() {
              return begin.next != ende;
            }

            public Object nextElement() {
               if (hasMoreElements()) {
                  begin = begin.next;
                  return begin.element;
              } else {
                  return begin;
              }
            }
        };
  }
	// ----------------------------------------------------------- //
	// Konstruktor RectangleList() erstellt eine neue Liste indem  //
	// die Zeiger von den Prellböcken aufeinander gesetzt werden   //
	// --------------------------------------------------------- //
	
	public ObjectList()                            
	  {  
	  start.next = ende;										
	  start.prev = null;
	  ende.prev = start;
	  ende.next = null;
	  System.out.printf("Neue Rechteck-Liste erstellt!\n");  	
	  }
	  
	// --------------------------------------------------------- //
	// Neue Klasse ListenElement beinhaltet ein Rechteck und     //
	// zwei neue Listenelemente für die Verzeigerung			 //
	// --------------------------------------------------------- //
	
	  public class ListenElement {                 

		  public ListenElement next;
		  public ListenElement prev;
		  public Object element;      
		  
	// --------------------------------------------------------- //  
    // Konstruktor für das ListenElement übergibt ein Rechteck   //
    // und weist es dem Element zu. "Zeiger" werden auf null     //
	// gesetzt													 //
	// --------------------------------------------------------- //
		  public ListenElement(Object obj)  
		  {                           
		    element = obj;   
		    next = null;
		    prev = null;
		  }	 
	}
	
	// --------------------------------------------------------- //
	// Methode insertFirst(Rectangle r) fügt am Anfang der Liste //
	// ein neues Rechteck ein und korrigiert die Verzeigerung    //
	// --------------------------------------------------------- //
	  
	void insertFirst(Object r){
		ListenElement neuerEintrag = new ListenElement(r);
		
		neuerEintrag.next = start.next;
		start.next.prev = neuerEintrag;
		start.next = neuerEintrag;
		neuerEintrag.prev = start;
		
		System.out.printf("Rectangle Element am Anfang der Liste eingefügt!\n");
	}
	
	// --------------------------------------------------------- //
	// Methode insertLast(Rectangle r) fügt am Ende der Liste    //
	// ein neues Rechteck ein und korrigiert die Verzeigerung    //
	// --------------------------------------------------------- //
	
	void insertLast(Object r){
		ListenElement neuerEintrag = new ListenElement(r);
		
		neuerEintrag.prev = ende.prev;
		ende.prev.next = neuerEintrag;
		ende.prev = neuerEintrag;
		neuerEintrag.next = ende;
		
		System.out.printf("Rectangle Element am Ende der Liste eingefügt!\n");
	}

	// --------------------------------------------------------- //
	// Methode clear() setzt die beiden Prellböcke wieder auf-   //
	// einander. Alle Elemente in der Liste sind gelöscht		 //
	// --------------------------------------------------------- //
	
	void clear(){
	
		start.next = ende;
		ende.prev = start;
		
		System.out.printf("Liste aufgeräumt!\n");
	}
	
	// --------------------------------------------------------- //
	// Methode Rectangle find(int a, int b) sucht nach einem     //
	// Rechteck in der Liste das den übergebenen Koordinaten     //
	// entspricht											     //
	// --------------------------------------------------------- //
		
	/*public Rectangle find(int a, int b){
		Object vergleich = new Rectangle(a,b);
		ListenElement aktuellerKnoten = start.next;
		
		while (aktuellerKnoten.next != null){
			 vergleich = aktuellerKnoten.element;
	
			if ( vergleich.breite == b && vergleich.laenge == a){
				System.out.printf("Ich habe das Rechteckt in der Liste gefunden\n");
				return vergleich;
			}
			  aktuellerKnoten = aktuellerKnoten.next;
			
		   }
		System.out.printf("Rechteck nicht gefunden!\n");
		return test;
		
	}*/
                                 

	public static void main(String[] args) {
	    System.out.printf("***********************************************************\n");
	    System.out.printf("********************* Programmanfang **********************\n");
	    System.out.printf("***********************************************************\n\n");
	    
	    
		System.out.printf("------------- Vier Rechtecke werden erstellt---------------\n");
		Rectangle r = new Rectangle(1,2);
		Circle c = new Circle(5, 3 ,2);
		Circle d = new Circle(7, 3 ,7);
		char buchstabe = ('a');
		Rectangle s = new Rectangle(4,8);
		Rectangle t = new Rectangle(5,10);
		Rectangle u = new Rectangle(10,20);
		System.out.printf("\n\n");
		
		
		
		System.out.printf("-------------- Rechteck-Liste wird angelegt----------------\n");
		ObjectList liste = new ObjectList();
		System.out.printf("\n\n");
		
		
		
		System.out.printf("---------- 2 Elemente am Anfang und Ende einfügen ---------\n");
	    liste.insertFirst (r);
	    liste.insertFirst (s);
	    liste.insertFirst(c);
	    liste.insertFirst(buchstabe);
	    liste.insertLast (t);
	    liste.insertLast (u);
	    liste.insertLast(d);
	    System.out.printf("\n\n");
	    
	    
	       
	    System.out.printf("----------------- Liste wird ausgegeben -------------------\n");
	    Enumeration<Object> test;
		test = liste.elements();
		System.out.printf("Enumeration angelegt!");
		while (test.hasMoreElements())
			System.out.println(test.nextElement());
	    System.out.printf("\n\n");
	    
	    
	    System.out.printf("------------------ Liste wird gelöscht --------------------\n");
	    liste.clear();
	    System.out.printf("\n\n");
	    
	   

	    System.out.printf("***********************************************************\n");
	    System.out.printf("*********************** Programmende **********************\n");
	    System.out.printf("***********************************************************\n");

	}

}

 

[Michael G.]

Nochmal eine Frage zum Verständnis: Was ist denn der Unterschied von:

public Enumeration<Object> elements() {

und

public Enumeration elements() {

Heißt es, dass ich eine Enumeration NUR mit dem Datentyp Object erstellen kann?

 

[SlaterB]

genau, was wenig Sinn macht,

aber wenn man richtig generische Parameter verwendet,
dann könnstet du eine ObjectList vom Typ String definieren und die Enumeration liefert direkt Strings statt nur Objects