# Liste von Strings umkehren und als neue Liste zurückgeben?



## CyberClaw (27. Nov 2006)

Huhu!
Ich hab hier eine Aufgabe, zu der mir nicht so recht eine Lösung einfallen will. Genauer gesagt zu einer einzigen Methode.
Ich habe eine Liste mit Zeichen ("abc", "def", usw..) die ich umkehren möchte.
Will heissen, die normale Ausgabe ist, wenn ich die Methode mHinzu aufraufe.
Kombination(def,Kombination(abc,LeereListe()))
und diese soll jetzt umgedreht werden.

hier der Code.


```
package zeichenketten;
//Abstakte Klasse, die die notwendigen Methoden vererbt.
//mAnzahl() berechnet die Anzahl der vorhandenen Zeichenketten.
//mVerkettung() fügt die Zeichenketten zusammen.
//mReverse() dreht die Zeichenketten um.
//mEnthaelt(final String a) sucht nach String a in den vorhanden Ketten und gibt true zurück, 
//wenn vorhanden.

abstract class ListeVonZeichenketten {
	
	public ListeVonZeichenketten(){
		super();
		}
	
	public abstract int mAnzahl();	
	public abstract String mVerkettung();
	public abstract boolean mEnthaelt(final String a);
	public abstract ListeVonZeichenketten mReverse();
	
	public ListeVonZeichenketten mHinzu(String s){
		return new Kombination(s, this);
	}
	
}
```


```
package zeichenketten;
//Kombination erbt von ListeVonZeichenketten und implementiert die Methoden.

public class Kombination extends ListeVonZeichenketten {

	private final String wort;
	private final ListeVonZeichenketten liste;
	
	public Kombination(String wort, ListeVonZeichenketten liste) {
		super();
		this.wort = wort;
		this.liste = liste;
	}

	@Override
	public int mAnzahl() {
		return liste.mAnzahl() +1;
	}

	@Override
	public boolean mEnthaelt(final String a) {
		if (a.equals(wort)){
			return true;
		}else{
			return liste.mEnthaelt(a);
			}
	}

	@Override
	public String mVerkettung() {
		return wort + liste.mVerkettung();
	}

	@Override
	public ListeVonZeichenketten mReverse() {

	}
	
	public String toString(){
		return getClass().getName() + "(" + wort + "," + liste + ")"; 
	}


}
```


```
package zeichenketten;
//Klasse, die von ListeVonZeichenketten erbt und eine leere Liste repräsentiert.
//Dient als Endpunkt bzw. Abbruchbedingung für die Methoden.

public class LeereListe extends ListeVonZeichenketten {

	public LeereListe() {
		// TODO Auto-generated constructor stub
		super();
	}

	@Override
	public int mAnzahl() {
		// TODO Auto-generated method stub
		return 0;
	}

	@Override
	public boolean mEnthaelt(String a) {
		// TODO Auto-generated method stub
		return false;
	}

	@Override
	public String mVerkettung() {
		// TODO Auto-generated method stub
		return "";
	}
	
	public String toString(){
		return getClass().getName() + "(" + ")";
	}

	@Override
	public ListeVonZeichenketten mReverse() {
		// TODO Auto-generated method stub
		return new LeereListe();
	}

}
```


```
package zeichenketten;

public class Init {

	/**
	 * @author CyberClaw
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//Erstellen einer neuen ListeVonZeichenketten.
		ListeVonZeichenketten l = new LeereListe().mHinzu("abc").mHinzu("def");
		//Consolenausgaben
		System.out.println(l);
		System.out.println(l.mVerkettung());
		System.out.println("Die Liste enthält " + l.mAnzahl() + " Zeichenketten.");
		System.out.println(l.mEnthaelt("abc"));
		System.out.println(l.mEnthaelt("ghj"));
		System.out.println(l.mReverse());
	}

}
```

Muss ich die mReverse() überhaupt abstract machen? bin echt am verzweifeln.

Gruß
CyberClaw


----------



## SlaterB (27. Nov 2006)

du erzeugst ein neues List-Objekt
und dann durchläufst du die Ursprungsliste von hinten nach vorne und gibts diese einzeln ein,
mit get kannst du auf jedes Element zugreifen,


----------



## Roar (27. Nov 2006)

oder du benutzt einfach Collections.reverse() :lol:


----------



## CyberClaw (27. Nov 2006)

Also mit Collections.reverse() geht es nicht, da ich ja kin List Element habe sondern eine ListeVonZeichenketten.

Das Durchlaufen hab ich mir auch schon überlegt, nur bin ich gerad etwas planlos, wie ich das am Besten löse/anfange ^^


----------

