Du verwendest einen veralteten Browser. Es ist möglich, dass diese oder andere Websites nicht korrekt angezeigt werden. Du solltest ein Upgrade durchführen oder ein alternativer Browser verwenden.
Ich habe eine Methode geschrieben, die bei einer ArrayList die Reihenfolge der Elemente nach einem von mir ausgedachten Algorithmus ändert. Die ArrayList enthält Objekte vom Typ Person.
Wenn ich will, dass bei einer ArrayList mit Objekten vom Typ Klassenzimmer die Reihenfogle geändert wird, muss ich eine neue Methode schreiben. Wie muss ich die Methode schreiben, damit sie für beliebige ArrayLists funktioniert?
Aber man kann hier ja problemlos eigene Sortieralgorithmen nutzen.
Edit: Also ganz wichtig: List at bereits eine entsprechende Methode, d.h. Du musst da nichts implementieren. Das war also nur, wenn Du es selbst auch noch einmal programmieren willst (zur Übung oder so).
Mir geht es ums Prinzip. Mit ArrayList<Object>() hat es nicht funktioniert. Ich dachte, dass alle Klassen von Object erben!?
Meine zweite Idee war Generics, also z.B. ArrayList<T>() aber da kenne ich mich nicht aus.
Wenn du beliebige Objekte in einer Collection sortieren willst, dann bietet es sich an, dass diese Objekte das Interface Comparable implementieren. Die Methode Collections.sort(myList); kann dann ohne Comparator aufgerufen werden.
Java:
public interface NameSort extends Comparable<NameSort> {
String getName();
@Override
default int compareTo(final Sort o) {
return this.getName().compareTo(o.getName());
}
}
publich class MyRoom implements NameSort{
public String getName() { ... }
}
publich class MyPerson implements NameSort{
public String getName() { ... }
}
List<NameSort> myList = List.of(new MyRoom(), new MyPerson(), ...)
Collections.sort(myList);
public <T> void doSomething(List<T> list) {
for (T element : list) {
System.out.println(element);
}
}
Das funktioniert, weil jedes T von Object abgeleitet sein muss. Mehr als die Methoden von Object kannst Du hier aber nicht verwenden, da über den Typ nicht mehr bekannt ist. Insbesondere im Zusammenhang mit Listen muss Dich oft aber gar nicht mehr interessieren.
Java:
public class Something<T> {
private List<T> list;
public Something(List<T> aList) {
this.list = new ArrayList<>(aList);
}
}
Erzeuge ich nun ein Something-Objekt mit dem Typ Number, kann ich eine List<Number> übergeben - nicht aber eine List<Integer>. Zwar ist Integer von Number abgeleitet, nicht aber List<Integer> von List<Number>.
Code:
jshell> List<Number> numbers = List.of(1,2,3)
numbers ==> [1, 2, 3]
jshell> new Something<Number>(numbers)
$8 ==> Something@28c97a5
jshell> List<Integer> ints = List.of(1,2,3)
ints ==> [1, 2, 3]
jshell> new Something<Number>(ints)
| Error:
| incompatible types: java.util.List<java.lang.Integer> cannot be converted to java.util.List<java.lang.Number>
| new Something<Number>(ints)
| ^--^
Was man aber tun könnte, wäre die Elemente zu kopieren, dazu ändert man den Konstruktor wie folgt:
Java:
public class Something<T> {
private List<T> list;
public Something(List<? extends T> aList) { // aList ist eine Liste eines unbekannten Typs, der von T abgeleitet ist
this.list = new ArrayList<>();
for (T element : aList) {
this.list.add(element);
}
}
}
Der Konstruktor bekommt also eine Liste, von der man weiß, dass die Elemente von T abgeleitet sind. Daher kann man der Liste Elemente vom Typ T entnehmen und der List<T> hinzufügen. Damit funktioniert jetzt auch
Code:
jshell> new Something<Number>(ints)
$11 ==> Something@6d5380c2
Nachtrag: im Beispiel dient die List<? extends T> als Quelle. Wenn es dagegen Ziel ist, verwendet man <? super T>, hier mal beides:
Java:
public static <T> void copy(List<? extends T> source, List<? super T> destination) {
for (T element : source) {
destination.add(element);
}
}
Damit kann man zum Beispiel von einer List<Integer> in eine List<Number> kopieren.
Das Prinzip ist doch immer das Gleiche: Egal, was Du machen willst: Du brauchst eine Methode, die es für den Typ, den Du da (zwingend) hast, durchführt.
Wenn Du als Typ nur Object vorgibst, dann hast Du nur die Möglichkeiten, die Object vorgibt. Wenn Dir das nicht ausreicht, dann musst Du eine entsprechende Methode bereit stellen, die das für Object macht.
Und genau das siehst Du bei der Lösung von dem sort. Um etwas sortieren zu können. muss das Argument vergleichbar sein:
static <T extends Comparable<? super T>> void sort(List<T> list)
==> Der Typ T muss Comparable implementieren, damit das gegeben ist.
Wenn das nicht gegeben ist, dann muss man eine andere Möglichkeit dafür vorgeben:
static <T> void sort(List<T> list, Comparator<? super T> c)
==> Jetzt ist das Comparable verschwunden. Und statt dessen wird das Comparator als zweites Argument vorgegeben.
Und das ist der generelle Ansatz - egal, was dabei gemacht werden soll. Entweder Du erzwingst ein Verhalten in den Elementen, die Du erwartest oder Du gibst die Möglichkeit, dieses Verhalten von außen beizusteuern.
