Liste filtern und sortieren

Java-Forum Java-Grundlagen
1

Hi!

Ich habe mir gerade etwas schwer getan, in einer Liste nur Items zu behalten, bei denen (price > 100) ist und danach die Liste nach (DateSold) aufsteigend zu sortieren.

In C# erledige ich das mit diesem Einzeiler:
[CSHARP]itemList = (List)itemList.Where(c => c.Price > 100).OrderBy(c => c.DateSold).ToList();[/CSHARP]

Nach vielem Suchen im Internet habe ich nichts gefunden, was mir irgendwie vernünftig erscheint. Ich habe zwar schon eine Lösung, aber die kommt mir dank einer Schleife und der Verwendung einer Treemap ziemlich umständlich vor, da der ganze Code fast eine Bildschrimseite füllt.

Könnte mir bitte jemand, auch nur mit ein paar kurzen und einfachen Sätzen, erklären, wie man sowas in Java am elegantesten macht.

lg

DPO

2 
{ 
if(item.getPrice().equals(100))
{
//...
}
}```

Erweiterte for-Schleife um zu iterieren und den getter() um den Wert abzufragen.
Das equals ersetzt du dann noch natürlich durch dein <>==!?
Die Anweisung dann in in die if Abfrage.
3

Falls du Java 8 hast geht es auch mit einem Einzeiler:

List<Foo> filtered = foos.stream()
				.filter(e -> e.getPrice() > 10)
				.sorted((a,b)-> a.getSold().compareTo(b.getSold()))
				.collect(Collectors.toList());
4

Sortieren geht in Java entweder mit Collections.sort(), wenn man eine [JAPI]List[/JAPI] und kein [JAPI]Set[/JAPI] hat, oder man wirft alles in ein [JAPI]TreeSet[/JAPI].
In beiden Fällen brauchst Du den passenden [JAPI]Comparator[/JAPI]:

  public int compare(Item item1, Item item2){
    return item1.getDateSold().compareTo(item2.getDateSold()); // ggf noch null-Check
  }
}

// anwendung:

Collections.sort(itemList, new ItemDateSoldComparator());

//oder 
TreeSet<Item> sortedItems = new TreeSet( new ItemDateSoldComparator());
sortedItems.addAll(itemCollection);```

Da braucht man schon einen sehr sehr großen Font um das auf eine Bildschirmseite aufzublähen..
;o)

bye
TT
5

Kleiner Verbesserungsvorschlag zu @ButAlive 's Code:

                .filter(e -> e.getPrice() > 10)
                .sorted(Comparator.comparing(Foo::getSold))
                .collect(Collectors.toList());
6

hoffentlich wird die Syntax da noch bald besser,
entweder ohne oder mit, das ist eine Entscheidung, aber wenn mit dann doch gleich richtig

über .collect(Collectors.toList()); an enorm wichtiger Stelle, potentiell millionenfach auf der Welt,
statt was simplen wie .toList() staune ich immer noch,

gut dass es immerhin eine Sortierung nach nur einer Methode gibt statt anstrengendes Compare zweier Elemente,
aber die unterschiedliche Behandlung, mal Methode = .getSold(), mal Klasse::getSold, ist auch ganz übel, wozu Erinnerungen an Reflection auslösen?
das muss sich doch auch viel kürzer schreiben lassen, .sorted(e -> e.getSold()), oder so, gleiche Sprache halten…

7

Super Danke!

Dank Eurer Hilfe habe ich sogar die passenden Suchbegriffe gefunden und wenn ich nach Lambda und Collection suche, dann finde ich sogar einiges :slight_smile: Das Thema macht Java wieder interessanter …

8

[QUOTE=SlaterB]aber die unterschiedliche Behandlung, mal Methode = .getSold(), mal Klasse::getSold, ist auch ganz übel, wozu Erinnerungen an Reflection auslösen?
das muss sich doch auch viel kürzer schreiben lassen, .sorted(e -> e.getSold()), oder so, gleiche Sprache halten…[/QUOTE]

Du kannst natürlich statt Comparator.comparing(Foo::getSold) auch Comparator.comparing(e -> e.getSold()) schreiben.