Annonyme Innere Klasse: Listen mit geradem Index ausgeben

Derya

Mitglied
Hallo alle zusammen,

ich studier Wirtschaftsinformatik und muss noch eine Java Klausur schreiben.
Beim Lernen bin ich auf folgende Aufgabe gestoßen:

Beispiel:

Eingabe ("wort0", "wort1", "wort2", "wort3", "wort4", "wort5")
Liefert ("wort0", "wort2", "wort4")

=> Das Ergebnis soll mittels annonymer innerer Klasse geliefert werden.
=> Originalliste wird nicht kopiert, sondern nur eine Berechnungsvorschrift definiert.
=> bei Indexüber- bzw. unterschreitungen liefert Liste eine Ausnahme.

Das ist der Methodenkopf: public static List takeEven(List list)


Ich bin jetzt soweit gekommen:

Java:
public static <T> List <T> takeEven (final List<T> list){
return new AbstractList<T>(){

public int size(){
return list.size();} 

public T get(int index) { 
	
				for(int j = 0; j<list.size(); j++){
					if(j%2 == 0)
						return list.get(index);}
				
				return (T) new IndexOutOfBoundsException(); 
		
}};}}

}

Bei der get()-Methode bin ich mir soweit eigentlich sicher, dass das so passen müsste,
aber die size()-Methode bekomme ich nicht hin.

Habt ihr vielleicht irgendwelche Vorschläge?

lieben Dank & VG
Derya
 
Zuletzt bearbeitet:
Soweit ich das durch kurzes Draufschauen sehe, stimmt die get-Methode so auch nicht. Am besten mal ein KSKB erstellen, wo die Eingabe und die Ausgabe ausgegeben werden, etwa wie
Java:
List<String> input = Arrays.asList("wort0", "wort1", "wort2", "wort3", "wort4", "wort5");
List<String> output = takeEven(input);
System.out.println(input);
System.out.println(output);
Dann ggf. noch ein, zwei tests mit "ungültigen" Indizes - so ähnlich wie ein Unit-Test (auch ohne JUnit).

Bei der Frage nach der 'size' könnte man im einfachsten Fall zwei Fälle unterscheiden:
1. Die Eingabeliste hat eine gerade Anzahl an Elementen
2. Die Eingabeliste hat eine UNgerade Anzahl an Elementen

Beim 'get' ... Überleg' dir mal, wie das "Mapping" der Indizes aussehen müßte: Wenn man auf der Ergebnisliste get(x) aufruft, dann muss man auf der Original-Liste auf get(y) zugreifen. Und dann
x=0, y=?
x=1, y=?
x=2, y=?
...
 
naja ich hätte des so gemacht...
hoffentlich habe ich nichts falsch verstanden

Java:
	public T get(int index) {
		return list.get(index * 2);
	}
	
	public int size(){
		return list.size() / 2;
	}

durch die multiplikation komme ich nur auf einen geraden index
 
Zuletzt bearbeitet:
Vielen Dank für eure schnelle Rückmeldung.

Habe mir eure Vorschläge angeschaut und noch Verständnisprobleme:

Java:
List<String> input = Arrays.asList("wort0", "wort1", "wort2", "wort3", "wort4", "wort5");
List<String> output = takeEven(input);
System.out.println(input);
System.out.println(output);

Wenn ich es so probiere, dann erzeuge ich ja sozusagen wieder Listen und kopiere den Inhalt da rein und genau das soll ich ja vermeiden, oder verstehe ich das falsch?


Bei der Frage nach der 'size' könnte man im einfachsten Fall zwei Fälle unterscheiden:
1. Die Eingabeliste hat eine gerade Anzahl an Elementen
2. Die Eingabeliste hat eine UNgerade Anzahl an Elementen

Ich hätte hier dann einfach folgendes gemacht:

Java:
public int size(){
if(list.size()%2==0)
return ....    // Was schreib ich den hier dann in die return-Anweisung rein?

else
....

Hier noch ein Beispiel um nochmal zu verdeutlichen, was ich meine:

Java:
	public static void main(String[] args) {
		List<Integer>liste = new ArrayList<Integer>(); 
		liste.add(1); //Index 0
		liste.add(1); //Index 1
		liste.add(2); //Index 2
		liste.add(3); //Index 3
		liste.add(4); //Index 4
		System.out.println(AnnonymeKlasse.takeEven(liste)); 
		//erwartete Ausgabe: 1, 2, 4	
	}
}



Java:
     public T get(int index) {
        return list.get(index * 2);
    }
    
    public int size(){
        return list.size() / 2;
    }

Das habe ich auch ausprobiert, und wenn ich die Methode mit obigem Beispiel teste, bekomme
ich die Ausgabe [1,2]. Das würde bedeuten die get-Methode() stimmt, aber die size() noch nicht...
Könnte man nicht irgendwie

Java:
public int size(){
return list.get(index).size()

schreiben, damit die size()-Methode wirklich nur die Elemente zählt, die in der get()-Methode geliefert werden? Eclipse zeigt mir da leider eine Fehlermeldung an.
 
sry war wohl etwas zu schnell 😀
da das erste element schon als gerade zählt (also die 0)
wird dieses nicht mit gezählt
deswegen einfach den index um eins verschieben

=>
Java:
    public int size(){
        return (list.size() + 1) / 2;
    }

da 1 / 2 = 0 ergibt sin d auch die grenzwerte sicher

mfg
 

Neue Themen


Zurück
Oben