{"id":16127,"date":"2020-10-06T09:00:25","date_gmt":"2020-10-06T07:00:25","guid":{"rendered":"https:\/\/www.happycoders.eu\/?p=16127"},"modified":"2025-06-12T08:43:06","modified_gmt":"2025-06-12T06:43:06","slug":"comparator-comparable-compareto","status":"publish","type":"post","link":"https:\/\/www.happycoders.eu\/de\/java\/comparator-comparable-compareto\/","title":{"rendered":"Comparator, Comparable, compareTo - Java-Objekte vergleichen"},"content":{"rendered":"\n<p>Dieser Artikel erkl\u00e4rt:<\/p>\n\n\n\n<ul class=\"wp-block-list\">\n<li>Wie vergleicht man zwei Objekte in Java?<\/li>\n\n\n\n<li>Was ist ein <code>Comparator<\/code> und wof\u00fcr ben\u00f6tigt man ihn?<\/li>\n\n\n\n<li>Welche M\u00f6glichkeiten gibt es, um einen <code>Comparator<\/code> zu erzeugen?<\/li>\n\n\n\n<li>Wie erzeugt man einen <code>Comparator<\/code> mit Java 8?<\/li>\n\n\n\n<li>Was ist der Unterschied zwischen <code style=\"background-color: rgb(255, 255, 255); font-size: 16px;\">Comparator<\/code> und <code style=\"background-color: rgb(255, 255, 255); font-size: 16px;\">Comparable<\/code>?<\/li>\n<\/ul>\n\n\n\n<p>Doch vorab die Frage: Warum m\u00f6chte man \u00fcberhaupt Java-Objekte miteinander vergleichen? <\/p>\n\n\n\n<p>Das wichtigste Einsatzgebiet f\u00fcr den Vergleich zweier Objekte ist sicherlich das <a href=\"\/de\/algorithmen\/sortieren-in-java\/\">Sortieren von Objekt-Listen oder -Arrays<\/a>. Um Objekte zu sortieren, muss das Programm sie vergleichen und herausfinden, ob ein Objekt kleiner, gr\u00f6\u00dfer oder gleich einem anderen ist.<\/p>\n\n\n\n<p>Den Quellcode zum Artikel findest du im zugeh\u00f6rigen <a href=\"https:\/\/github.com\/SvenWoltmann\/comparator-comparable-compareto\" target=\"_blank\" rel=\"noopener\">GitHub-Repository<\/a>.<\/p>\n\n\n\n<h2 class=\"wp-block-heading\" class=\"wp-block-heading\" id=\"wie-vergleicht-man-zwei-objekte-in-java\">Wie vergleicht man zwei Objekte in Java?<\/h2>\n\n\n\n<p>Java-Primitive (<code>int<\/code>, <code>long<\/code>, <code>double<\/code>, etc.) vergleicht man mit den Operatoren <code>&lt;<\/code>, <code>&lt;=<\/code>, <code>==<\/code>, <code>=&gt;<\/code>, <code>&gt;<\/code>.<\/p>\n\n\n\n<p>Bei Objekten funktioniert das nicht.<\/p>\n\n\n\n<p>Dort verwendet man stattdessen entweder eine <code>compare<\/code>- oder eine <code>compareTo<\/code>-Methode. Beide Methoden erkl\u00e4re ich am Beispiel von Strings und der selbst geschriebenen Klasse \"Student\".<\/p>\n\n\n\n<h3 class=\"wp-block-heading\" class=\"wp-block-heading\" id=\"wie-vergleicht-man-zwei-strings-in-java\">Wie vergleicht man zwei Strings in Java?<\/h3>\n\n\n\n<p>Nehmen wir an, wir haben die folgenden zwei Strings:<\/p>\n\n\n<pre class=\"wp-block-code\" aria-describedby=\"shcb-language-2\" data-shcb-language-name=\"Java\" data-shcb-language-slug=\"java\"><span><code class=\"hljs language-java\">String s1 = <span class=\"hljs-string\">\"Happy\"<\/span>;\nString s2 = <span class=\"hljs-string\">\"Coders\"<\/span>;<\/code><\/span><small class=\"shcb-language\" id=\"shcb-language-2\"><span class=\"shcb-language__label\">Code-Sprache:<\/span> <span class=\"shcb-language__name\">Java<\/span> <span class=\"shcb-language__paren\">(<\/span><span class=\"shcb-language__slug\">java<\/span><span class=\"shcb-language__paren\">)<\/span><\/small><\/pre>\n\n\n<p>Wir wollen nun herausfinden, ob <code>s1<\/code> kleiner, gr\u00f6\u00dfer oder gleich <code>s2<\/code> ist. Oder anders gesagt: ob \u2013 nach alphabetischer Sortierung* \u2013 <code>s1<\/code> vor oder nach <code>s2<\/code> k\u00e4me.<\/p>\n\n\n\n<p>Das tun wir wie folgt:<\/p>\n\n\n<pre class=\"wp-block-code\" aria-describedby=\"shcb-language-3\" data-shcb-language-name=\"Java\" data-shcb-language-slug=\"java\"><span><code class=\"hljs language-java\"><span class=\"hljs-keyword\">int<\/span> result = s1.compareTo(s2);<\/code><\/span><small class=\"shcb-language\" id=\"shcb-language-3\"><span class=\"shcb-language__label\">Code-Sprache:<\/span> <span class=\"shcb-language__name\">Java<\/span> <span class=\"shcb-language__paren\">(<\/span><span class=\"shcb-language__slug\">java<\/span><span class=\"shcb-language__paren\">)<\/span><\/small><\/pre>\n\n\n<p>Die Variable <code>result<\/code> enth\u00e4lt nun:<\/p>\n\n\n\n<ul class=\"wp-block-list\">\n<li>einen Wert kleiner als 0, wenn <code>s1<\/code> nach alphabetischer Sortierung <em>vor<\/em> <code>s2<\/code> kommt<\/li>\n\n\n\n<li>0, wenn <code>s1<\/code> und <code>s2<\/code> <em>gleich<\/em> sind (d. h., dass <code>s1.equals(s2) true<\/code> ergibt)<\/li>\n\n\n\n<li>einen Wert gr\u00f6\u00dfer als 0, wenn <code>s1<\/code> nach alphabetischer Sortierung <em>nach<\/em> <code>s2<\/code> kommt<\/li>\n<\/ul>\n\n\n\n<p>Im Beispiel oben w\u00e4re <code>result<\/code> gr\u00f6\u00dfer als 0, da \"Happy\" hinter \"Coders\" einsortiert werden w\u00fcrde.<\/p>\n\n\n\n<p class=\"hc-footnote\">(* <em>Alphabetisch<\/em> bedeutet im Fall von <code>String.compareTo()<\/code>: entsprechend der Unicode-Werte der Buchstaben, d. h. beispielsweise, dass ein Gro\u00dfbuchstabe immer vor einem Kleinbuchstaben kommt, und dass die deutschen Umlaute erst nach allen regul\u00e4ren Gro\u00df- und Kleinbuchstaben kommen)<\/p>\n\n\n\n<h3 class=\"wp-block-heading\" class=\"wp-block-heading\" id=\"sortieren-von-strings-in-java\">Sortieren von Strings in Java<\/h3>\n\n\n\n<p>Die <code>compareTo()<\/code>-Methode wird hinter den Kulissen verwendet, um ein Array oder eine Liste von Objekten zu sortieren, beispielsweise wie folgt:<\/p>\n\n\n<pre class=\"wp-block-code\" aria-describedby=\"shcb-language-4\" data-shcb-language-name=\"Java\" data-shcb-language-slug=\"java\"><span><code class=\"hljs language-java\"><span class=\"hljs-keyword\">public<\/span> <span class=\"hljs-class\"><span class=\"hljs-keyword\">class<\/span> <span class=\"hljs-title\">NameSortExample<\/span> <\/span>{\n  <span class=\"hljs-function\"><span class=\"hljs-keyword\">public<\/span> <span class=\"hljs-keyword\">static<\/span> <span class=\"hljs-keyword\">void<\/span> <span class=\"hljs-title\">main<\/span><span class=\"hljs-params\">(String&#091;] args)<\/span> <\/span>{\n    String&#091;] names = {<span class=\"hljs-string\">\"Mary\"<\/span>, <span class=\"hljs-string\">\"James\"<\/span>, <span class=\"hljs-string\">\"Patricia\"<\/span>, <span class=\"hljs-string\">\"John\"<\/span>, <span class=\"hljs-string\">\"Jennifer\"<\/span>, <span class=\"hljs-string\">\"Robert\"<\/span>};\n    Arrays.sort(names);\n    System.out.println(Arrays.toString(names));\n  }\n}<\/code><\/span><small class=\"shcb-language\" id=\"shcb-language-4\"><span class=\"shcb-language__label\">Code-Sprache:<\/span> <span class=\"shcb-language__name\">Java<\/span> <span class=\"shcb-language__paren\">(<\/span><span class=\"shcb-language__slug\">java<\/span><span class=\"shcb-language__paren\">)<\/span><\/small><\/pre>\n\n\n<p>Das Programm gibt die Namen in alphabetischer Reihenfolge aus:<\/p>\n\n\n<pre class=\"wp-block-code\" aria-describedby=\"shcb-language-5\" data-shcb-language-name=\"Klartext\" data-shcb-language-slug=\"plaintext\"><span><code class=\"hljs language-plaintext\">&#091;James, Jennifer, John, Mary, Patricia, Robert]<\/code><\/span><small class=\"shcb-language\" id=\"shcb-language-5\"><span class=\"shcb-language__label\">Code-Sprache:<\/span> <span class=\"shcb-language__name\">Klartext<\/span> <span class=\"shcb-language__paren\">(<\/span><span class=\"shcb-language__slug\">plaintext<\/span><span class=\"shcb-language__paren\">)<\/span><\/small><\/pre>\n\n\n<p><em>(Welche M\u00f6glichkeiten es noch gibt, um in Java Objekte oder Primitive, wie <code>int<\/code>, <code>long<\/code>, <code>double<\/code> zu sortieren, erf\u00e4hrst du im <a href=\"\/de\/algorithmen\/sortieren-in-java\/\">Tutorial \"Sortieren in Java\"<\/a>.)<\/em><\/p>\n\n\n\n<p>Was aber, wenn wir Strings gar nicht alphabetisch sortieren wollen, sondern beispielsweise nach ihrer L\u00e4nge? Dazu brauchen wir einen sogenannten <code>Comparator<\/code>. Bevor wir dazu kommen, erkl\u00e4re ich erst einmal das Interface <code>Comparable<\/code>, das wir soeben verwendet haben.<\/p>\n\n\n\n<h2 class=\"wp-block-heading\" class=\"wp-block-heading\" id=\"das-java-comparable-interface\">Das Java Comparable Interface<\/h2>\n\n\n\n<p>Die <code>String.compareTo()<\/code>-Methode, die wir oben angewendet haben, kommt aus dem <code><a rel=\"noopener\" href=\"https:\/\/docs.oracle.com\/en\/java\/javase\/15\/docs\/api\/java.base\/java\/lang\/Comparable.html\" target=\"_blank\">java.lang.Comparable<\/a><\/code>-Interface, welches von der <code>String<\/code>-Klasse implementiert wird.<\/p>\n\n\n\n<p>Das <code>Comparable<\/code>-Interface definiert nur diese eine Methode. Es wird von allen Klassen implementiert, deren Objekte vergleichbar (englisch: \"comparable\") sein sollen. Neben <code>String<\/code> sind das beispielsweise <code>Integer<\/code>, <code>BigInteger<\/code>, <code>Long<\/code>, <code>Date<\/code>, <code>LocalDateTime<\/code>, und viele mehr.<\/p>\n\n\n\n<p>Die Reihenfolge, die sich aus der <code>compareTo()<\/code>-Methode ergibt, nennt man \"nat\u00fcrliche Ordnung\": Strings werden alphabetisch sortiert, Datums- und Zeitwerte in ihrer zeitlichen Abfolge.<\/p>\n\n\n\n<p>Wie du eine selbst entwickelte Klasse vergleichbar (und damit sortierbar) machst, liest du im folgenden Abschnitt.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\" class=\"wp-block-heading\" id=\"java-comparable-beispiel\">Java Comparable Beispiel<\/h3>\n\n\n\n<p>Um selbstentwickelte Klassen vergleichbar und damit sortierbar zu machen, m\u00fcssen sie das Interface <code>Comparable<\/code> und dessen <code>compareTo()<\/code>-Methode implementieren.<\/p>\n\n\n\n<p>Das folgende Beispiel zeigt, wie man dies f\u00fcr eine <code>Student<\/code>-Klasse macht, die standardm\u00e4\u00dfig nach Matrikelnummer (ID) sortiert werden sollen:<\/p>\n\n\n<pre class=\"wp-block-code\" aria-describedby=\"shcb-language-6\" data-shcb-language-name=\"Java\" data-shcb-language-slug=\"java\"><span><code class=\"hljs language-java\"><span class=\"hljs-keyword\">public<\/span> <span class=\"hljs-class\"><span class=\"hljs-keyword\">class<\/span> <span class=\"hljs-title\">Student<\/span> <span class=\"hljs-keyword\">implements<\/span> <span class=\"hljs-title\">Comparable<\/span>&lt;<span class=\"hljs-title\">Student<\/span>&gt; <\/span>{\n  <span class=\"hljs-keyword\">private<\/span> <span class=\"hljs-keyword\">int<\/span> id;\n  <span class=\"hljs-keyword\">private<\/span> String firstName;\n  <span class=\"hljs-keyword\">private<\/span> String lastName;\n\n  <span class=\"hljs-comment\">\/\/ ... constructor ...<\/span>\n  <span class=\"hljs-comment\">\/\/ ... getters and setters ...<\/span>\n  <span class=\"hljs-comment\">\/\/ ... toString() method ...<\/span>\n\n  <span class=\"hljs-meta\">@Override<\/span>\n  <span class=\"hljs-function\"><span class=\"hljs-keyword\">public<\/span> <span class=\"hljs-keyword\">int<\/span> <span class=\"hljs-title\">compareTo<\/span><span class=\"hljs-params\">(Student o)<\/span> <\/span>{\n    <span class=\"hljs-keyword\">if<\/span> (<span class=\"hljs-keyword\">this<\/span>.id &lt; o.id) {\n      <span class=\"hljs-keyword\">return<\/span> -<span class=\"hljs-number\">1<\/span>;\n    } <span class=\"hljs-keyword\">else<\/span> <span class=\"hljs-keyword\">if<\/span> (<span class=\"hljs-keyword\">this<\/span>.id == o.id) {\n      <span class=\"hljs-keyword\">return<\/span> <span class=\"hljs-number\">0<\/span>;\n    } <span class=\"hljs-keyword\">else<\/span> {\n      <span class=\"hljs-keyword\">return<\/span> <span class=\"hljs-number\">1<\/span>;\n    }\n  }\n}<\/code><\/span><small class=\"shcb-language\" id=\"shcb-language-6\"><span class=\"shcb-language__label\">Code-Sprache:<\/span> <span class=\"shcb-language__name\">Java<\/span> <span class=\"shcb-language__paren\">(<\/span><span class=\"shcb-language__slug\">java<\/span><span class=\"shcb-language__paren\">)<\/span><\/small><\/pre>\n\n\n<p>Mit dem tern\u00e4ren Operator kannst du die <code>compareTo()<\/code>-Methode auch als Einzeiler notieren:<\/p>\n\n\n<pre class=\"wp-block-code\" aria-describedby=\"shcb-language-7\" data-shcb-language-name=\"Java\" data-shcb-language-slug=\"java\"><span><code class=\"hljs language-java\"><span class=\"hljs-meta\">@Override<\/span>\n<span class=\"hljs-function\"><span class=\"hljs-keyword\">public<\/span> <span class=\"hljs-keyword\">int<\/span> <span class=\"hljs-title\">compareTo<\/span><span class=\"hljs-params\">(Student o)<\/span> <\/span>{\n  <span class=\"hljs-keyword\">return<\/span> <span class=\"hljs-keyword\">this<\/span>.id &lt; o.id ? -<span class=\"hljs-number\">1<\/span> : (<span class=\"hljs-keyword\">this<\/span>.id == o.id ? <span class=\"hljs-number\">0<\/span> : <span class=\"hljs-number\">1<\/span>);\n}<\/code><\/span><small class=\"shcb-language\" id=\"shcb-language-7\"><span class=\"shcb-language__label\">Code-Sprache:<\/span> <span class=\"shcb-language__name\">Java<\/span> <span class=\"shcb-language__paren\">(<\/span><span class=\"shcb-language__slug\">java<\/span><span class=\"shcb-language__paren\">)<\/span><\/small><\/pre>\n\n\n<p>Noch eleganter ist es allerdings f\u00fcr den Vergleich der zwei <code>int<\/code>-Werte die statische Methode <code>Integer.compare()<\/code> aufzurufen:<\/p>\n\n\n<pre class=\"wp-block-code\" aria-describedby=\"shcb-language-8\" data-shcb-language-name=\"Java\" data-shcb-language-slug=\"java\"><span><code class=\"hljs language-java\"><span class=\"hljs-meta\">@Override<\/span>\n<span class=\"hljs-function\"><span class=\"hljs-keyword\">public<\/span> <span class=\"hljs-keyword\">int<\/span> <span class=\"hljs-title\">compareTo<\/span><span class=\"hljs-params\">(Student o)<\/span> <\/span>{\n  <span class=\"hljs-keyword\">return<\/span> Integer.compare(<span class=\"hljs-keyword\">this<\/span>.id, o.id);\n}<\/code><\/span><small class=\"shcb-language\" id=\"shcb-language-8\"><span class=\"shcb-language__label\">Code-Sprache:<\/span> <span class=\"shcb-language__name\">Java<\/span> <span class=\"shcb-language__paren\">(<\/span><span class=\"shcb-language__slug\">java<\/span><span class=\"shcb-language__paren\">)<\/span><\/small><\/pre>\n\n\n<p>Keine Sorge, die JVM inlined diesen Methodenaufruf, so dass es zu keinerlei Performance-Einbu\u00dfen kommt.<\/p>\n\n\n\n<p class=\"has-background\" style=\"background-color:#eeeeee\"><strong>Achtung Falle: ints subtrahieren<\/strong><br><br>Mitunter sieht man in einer&nbsp;<code>compareTo()<\/code>-Methode folgendes:<br><br><code>return this.id - o.id;<br><\/code><br>Das sollte man&nbsp;<strong>auf keinen Fall<\/strong>&nbsp;so schreiben, denn es funktioniert nicht, wenn beispielsweise&nbsp;<code>this.id<\/code>&nbsp;-2.000.000.000 ist und&nbsp;<code>o.id<\/code>&nbsp;1.000.000.000. Da in diesem Fall&nbsp;<code>this.id<\/code>&nbsp;kleiner ist, sollte die&nbsp;<code>compareTo()<\/code>-Methode eine negative Zahl zur\u00fcckliefern. Das tut sie aber nicht, da es bei der Subtraktion zu einem arithmetischen Unterlauf kommt \u2013 das Ergebnis der Subtraktion ist 1.294.967.296 \u2013 eine positive Zahl!<\/p>\n\n\n\n<p>Und hier ein Beispiel, in dem drei Studenten erzeugt, in eine Liste geschrieben und anschlie\u00dfend sortiert werden:<\/p>\n\n\n<pre class=\"wp-block-code\" aria-describedby=\"shcb-language-9\" data-shcb-language-name=\"Java\" data-shcb-language-slug=\"java\"><span><code class=\"hljs language-java\"><span class=\"hljs-keyword\">public<\/span> <span class=\"hljs-class\"><span class=\"hljs-keyword\">class<\/span> <span class=\"hljs-title\">StudentSortExample<\/span> <\/span>{\n  <span class=\"hljs-function\"><span class=\"hljs-keyword\">public<\/span> <span class=\"hljs-keyword\">static<\/span> <span class=\"hljs-keyword\">void<\/span> <span class=\"hljs-title\">main<\/span><span class=\"hljs-params\">(String&#091;] args)<\/span> <\/span>{\n    List&lt;Student&gt; students = <span class=\"hljs-keyword\">new<\/span> ArrayList&lt;&gt;();\n    students.add(<span class=\"hljs-keyword\">new<\/span> Student(<span class=\"hljs-number\">47271<\/span>, <span class=\"hljs-string\">\"Kerrie\"<\/span>, <span class=\"hljs-string\">\"Adkins\"<\/span>));\n    students.add(<span class=\"hljs-keyword\">new<\/span> Student(<span class=\"hljs-number\">99319<\/span>, <span class=\"hljs-string\">\"Aarron\"<\/span>, <span class=\"hljs-string\">\"Wicks\"<\/span>));\n    students.add(<span class=\"hljs-keyword\">new<\/span> Student(<span class=\"hljs-number\">11056<\/span>, <span class=\"hljs-string\">\"Kaya\"<\/span>, <span class=\"hljs-string\">\"Molina\"<\/span>));\n\n    Collections.sort(students);\n\n    System.out.println(<span class=\"hljs-string\">\"students = \"<\/span> + students);\n  }\n}<\/code><\/span><small class=\"shcb-language\" id=\"shcb-language-9\"><span class=\"shcb-language__label\">Code-Sprache:<\/span> <span class=\"shcb-language__name\">Java<\/span> <span class=\"shcb-language__paren\">(<\/span><span class=\"shcb-language__slug\">java<\/span><span class=\"shcb-language__paren\">)<\/span><\/small><\/pre>\n\n\n<p>Wie erwartet, werden die Studenten nach Matrikelnummer sortiert ausgegeben (die Zeilenumbr\u00fcche habe ich der \u00dcbersicht halber manuell eingef\u00fcgt):<\/p>\n\n\n<pre class=\"wp-block-code\" aria-describedby=\"shcb-language-10\" data-shcb-language-name=\"Klartext\" data-shcb-language-slug=\"plaintext\"><span><code class=\"hljs language-plaintext\">students = &#091;Student{id=11056, firstName='Kaya', lastName='Molina'},\n    Student{id=47271, firstName='Kerrie', lastName='Adkins'},\n    Student{id=99319, firstName='Aarron', lastName='Wicks'}]<\/code><\/span><small class=\"shcb-language\" id=\"shcb-language-10\"><span class=\"shcb-language__label\">Code-Sprache:<\/span> <span class=\"shcb-language__name\">Klartext<\/span> <span class=\"shcb-language__paren\">(<\/span><span class=\"shcb-language__slug\">plaintext<\/span><span class=\"shcb-language__paren\">)<\/span><\/small><\/pre>\n\n\n<p>Kommen wir zur\u00fcck zum String, den wir im n\u00e4chsten Schritt nicht alphabetisch, sondern nach L\u00e4nge sortieren wollen.<\/p>\n\n\n<div class=\"convertkit-form wp-block-convertkit-form\" style=\"\"><script async data-uid=\"1427197203\" src=\"https:\/\/happycoders.kit.com\/1427197203\/index.js\" data-jetpack-boost=\"ignore\" data-no-defer=\"1\" data-no-optimize=\"1\" nowprocket><\/script><\/div>\n\n\n\n<h2 class=\"wp-block-heading\" class=\"wp-block-heading\" id=\"das-java-comparator-interface\">Das Java Comparator Interface<\/h2>\n\n\n\n<p>Um zwei Objekte nach einer anderen als ihrer nat\u00fcrlicher Ordnung zu sortieren (oder um Objekte von Klassen zu sortieren, die <code>Comparable<\/code> <em>nicht<\/em> implementieren), verwenden wir das <code><a rel=\"noopener\" href=\"https:\/\/docs.oracle.com\/en\/java\/javase\/15\/docs\/api\/java.base\/java\/util\/Comparator.html\" target=\"_blank\">java.util.Comparator<\/a><\/code>-Interface.<\/p>\n\n\n\n<p>Dieses definiert die Methode <code>compare\u200b(T o1, T o2)<\/code>, mit der die zwei \u00fcbergebenen Objekte verglichen werden. Die Methode hat analog zur <code>compareTo()<\/code>-Methode folgende R\u00fcckgabewerte:<\/p>\n\n\n\n<ul class=\"wp-block-list\">\n<li>einen Wert kleiner als 0, wenn <code>o1<\/code> kleiner ist als <code>o2<\/code><\/li>\n\n\n\n<li>0, wenn <code>o1<\/code> und <code>o2<\/code> gleich sind (d. h., dass <code>o1.equals(o2) true<\/code> ergibt)<\/li>\n\n\n\n<li>einen Wert gr\u00f6\u00dfer als 0, wenn <code>o1<\/code> gr\u00f6\u00dfer ist als <code>o2<\/code><\/li>\n<\/ul>\n\n\n\n<h3 class=\"wp-block-heading\" class=\"wp-block-heading\" id=\"java-comparator-beispiel-strings-nach-laenge-sortieren\">Java Comparator Beispiel: Strings nach L\u00e4nge sortieren<\/h3>\n\n\n\n<p>Einen Comparator, der Strings nach ihrer L\u00e4nge vergleicht, w\u00fcrden wir wie folgt implementieren:<\/p>\n\n\n<pre class=\"wp-block-code\" aria-describedby=\"shcb-language-11\" data-shcb-language-name=\"Java\" data-shcb-language-slug=\"java\"><span><code class=\"hljs language-java\"><span class=\"hljs-keyword\">public<\/span> <span class=\"hljs-class\"><span class=\"hljs-keyword\">class<\/span> <span class=\"hljs-title\">StringLengthComparator<\/span> <span class=\"hljs-keyword\">implements<\/span> <span class=\"hljs-title\">Comparator<\/span>&lt;<span class=\"hljs-title\">String<\/span>&gt; <\/span>{\n  <span class=\"hljs-meta\">@Override<\/span>\n  <span class=\"hljs-function\"><span class=\"hljs-keyword\">public<\/span> <span class=\"hljs-keyword\">int<\/span> <span class=\"hljs-title\">compare<\/span><span class=\"hljs-params\">(String o1, String o2)<\/span> <\/span>{\n    <span class=\"hljs-keyword\">if<\/span> (o1.length() &lt; o2.length()) {\n      <span class=\"hljs-keyword\">return<\/span> -<span class=\"hljs-number\">1<\/span>;\n    } <span class=\"hljs-keyword\">else<\/span> <span class=\"hljs-keyword\">if<\/span> (o1.length() == o2.length()) {\n      <span class=\"hljs-keyword\">return<\/span> <span class=\"hljs-number\">0<\/span>;\n    } <span class=\"hljs-keyword\">else<\/span> {\n      <span class=\"hljs-keyword\">return<\/span> <span class=\"hljs-number\">1<\/span>;\n    }\n  }\n}<\/code><\/span><small class=\"shcb-language\" id=\"shcb-language-11\"><span class=\"shcb-language__label\">Code-Sprache:<\/span> <span class=\"shcb-language__name\">Java<\/span> <span class=\"shcb-language__paren\">(<\/span><span class=\"shcb-language__slug\">java<\/span><span class=\"shcb-language__paren\">)<\/span><\/small><\/pre>\n\n\n<p>Auch hier k\u00f6nnen wir den Code mit Hilfe des tern\u00e4ren Operators wieder auf eine Zeile komprimieren:<\/p>\n\n\n<pre class=\"wp-block-code\" aria-describedby=\"shcb-language-12\" data-shcb-language-name=\"Java\" data-shcb-language-slug=\"java\"><span><code class=\"hljs language-java\"><span class=\"hljs-meta\">@Override<\/span>\n<span class=\"hljs-function\"><span class=\"hljs-keyword\">public<\/span> <span class=\"hljs-keyword\">int<\/span> <span class=\"hljs-title\">compare<\/span><span class=\"hljs-params\">(String o1, String o2)<\/span> <\/span>{\n  <span class=\"hljs-keyword\">return<\/span> o1.length() &lt; o2.length() ? -<span class=\"hljs-number\">1<\/span> : (o1.length() == o2.length() ? <span class=\"hljs-number\">0<\/span> : <span class=\"hljs-number\">1<\/span>);\n}\n<\/code><\/span><small class=\"shcb-language\" id=\"shcb-language-12\"><span class=\"shcb-language__label\">Code-Sprache:<\/span> <span class=\"shcb-language__name\">Java<\/span> <span class=\"shcb-language__paren\">(<\/span><span class=\"shcb-language__slug\">java<\/span><span class=\"shcb-language__paren\">)<\/span><\/small><\/pre>\n\n\n<p>Eingesetzt wird der <code>StringLengthComparator<\/code> beispielsweise wie folgt:<\/p>\n\n\n<pre class=\"wp-block-code\" aria-describedby=\"shcb-language-13\" data-shcb-language-name=\"Java\" data-shcb-language-slug=\"java\"><span><code class=\"hljs language-java\"><span class=\"hljs-keyword\">public<\/span> <span class=\"hljs-class\"><span class=\"hljs-keyword\">class<\/span> <span class=\"hljs-title\">NameSortByLengthExample<\/span> <\/span>{\n  <span class=\"hljs-function\"><span class=\"hljs-keyword\">public<\/span> <span class=\"hljs-keyword\">static<\/span> <span class=\"hljs-keyword\">void<\/span> <span class=\"hljs-title\">main<\/span><span class=\"hljs-params\">(String&#091;] args)<\/span> <\/span>{\n    String&#091;] names = {<span class=\"hljs-string\">\"Mary\"<\/span>, <span class=\"hljs-string\">\"James\"<\/span>, <span class=\"hljs-string\">\"Patricia\"<\/span>, <span class=\"hljs-string\">\"John\"<\/span>, <span class=\"hljs-string\">\"Jennifer\"<\/span>, <span class=\"hljs-string\">\"Robert\"<\/span>};\n    Arrays.sort(names, <span class=\"hljs-keyword\">new<\/span> StringLengthComparator());\n    System.out.println(Arrays.toString(names));\n  }\n}<\/code><\/span><small class=\"shcb-language\" id=\"shcb-language-13\"><span class=\"shcb-language__label\">Code-Sprache:<\/span> <span class=\"shcb-language__name\">Java<\/span> <span class=\"shcb-language__paren\">(<\/span><span class=\"shcb-language__slug\">java<\/span><span class=\"shcb-language__paren\">)<\/span><\/small><\/pre>\n\n\n<p>Die Namen werden nun nicht mehr alphabetisch sortiert, sondern aufsteigend nach L\u00e4nge:<\/p>\n\n\n<pre class=\"wp-block-code\" aria-describedby=\"shcb-language-14\" data-shcb-language-name=\"Klartext\" data-shcb-language-slug=\"plaintext\"><span><code class=\"hljs language-plaintext\">&#091;Mary, John, James, Robert, Patricia, Jennifer]<\/code><\/span><small class=\"shcb-language\" id=\"shcb-language-14\"><span class=\"shcb-language__label\">Code-Sprache:<\/span> <span class=\"shcb-language__name\">Klartext<\/span> <span class=\"shcb-language__paren\">(<\/span><span class=\"shcb-language__slug\">plaintext<\/span><span class=\"shcb-language__paren\">)<\/span><\/small><\/pre>\n\n\n<h2 class=\"wp-block-heading\" class=\"wp-block-heading\" id=\"wie-erstellt-man-einen-comparator\">Wie erstellt man einen Comparator?<\/h2>\n\n\n\n<p>Bis Java 7 konnte man einen Comparator ausschlie\u00dflich \u2013 wie im Beispiel oben gezeigt \u2013 durch Implementierung des <code>Comparator<\/code>-Interfaces erstellen.<\/p>\n\n\n\n<p>Seit Java 8 kann man einen Comparator auch als Lambda notieren oder ihn \u2013 ziemlich komfortabel, wie du gleich sehen wirst \u2013 mit Hilfe der Methoden&nbsp;<code>Comparator.comparing()<\/code>, <code>thenComparing()<\/code> und <code>reversed()<\/code> erzeugen.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\" class=\"wp-block-heading\" id=\"comparator-als-oeffentliche-klasse\">Comparator als \u00f6ffentliche Klasse<\/h3>\n\n\n\n<p>Am Beispiel <code>StringLengthComparator<\/code> haben wir bereits die erste Variante kennengelernt: Wir schreiben eine \u00f6ffentliche Klasse und \u00fcbergeben der Sortiermethode eine Instanz davon:<\/p>\n\n\n<pre class=\"wp-block-code\" aria-describedby=\"shcb-language-15\" data-shcb-language-name=\"Java\" data-shcb-language-slug=\"java\"><span><code class=\"hljs language-java\">Arrays.sort(names, <span class=\"hljs-keyword\">new<\/span> StringLengthComparator());<\/code><\/span><small class=\"shcb-language\" id=\"shcb-language-15\"><span class=\"shcb-language__label\">Code-Sprache:<\/span> <span class=\"shcb-language__name\">Java<\/span> <span class=\"shcb-language__paren\">(<\/span><span class=\"shcb-language__slug\">java<\/span><span class=\"shcb-language__paren\">)<\/span><\/small><\/pre>\n\n\n<p>Wenn wir an mehreren Stellen nach Stringl\u00e4nge sortieren wollen, k\u00f6nnen wir auch eine Konstante extrahieren:<\/p>\n\n\n<pre class=\"wp-block-code\" aria-describedby=\"shcb-language-16\" data-shcb-language-name=\"Java\" data-shcb-language-slug=\"java\"><span><code class=\"hljs language-java\"><span class=\"hljs-keyword\">private<\/span> <span class=\"hljs-keyword\">static<\/span> <span class=\"hljs-keyword\">final<\/span> StringLengthComparator STRING_LENGTH_COMPARATOR =\n    <span class=\"hljs-keyword\">new<\/span> StringLengthComparator();<\/code><\/span><small class=\"shcb-language\" id=\"shcb-language-16\"><span class=\"shcb-language__label\">Code-Sprache:<\/span> <span class=\"shcb-language__name\">Java<\/span> <span class=\"shcb-language__paren\">(<\/span><span class=\"shcb-language__slug\">java<\/span><span class=\"shcb-language__paren\">)<\/span><\/small><\/pre>\n\n\n<p>Alternativ k\u00f6nnten wir ein Singleton definieren:<\/p>\n\n\n<pre class=\"wp-block-code\" aria-describedby=\"shcb-language-17\" data-shcb-language-name=\"Java\" data-shcb-language-slug=\"java\"><span><code class=\"hljs language-java\"><span class=\"hljs-keyword\">public<\/span> <span class=\"hljs-class\"><span class=\"hljs-keyword\">class<\/span> <span class=\"hljs-title\">StringLengthComparator<\/span> <span class=\"hljs-keyword\">implements<\/span> <span class=\"hljs-title\">Comparator<\/span>&lt;<span class=\"hljs-title\">String<\/span>&gt; <\/span>{\n  <span class=\"hljs-keyword\">public<\/span> <span class=\"hljs-keyword\">static<\/span> <span class=\"hljs-keyword\">final<\/span> StringLengthComparator INSTANCE = <span class=\"hljs-keyword\">new<\/span> StringLengthComparator();\n\n  <span class=\"hljs-function\"><span class=\"hljs-keyword\">private<\/span> <span class=\"hljs-title\">StringLengthComparator<\/span><span class=\"hljs-params\">()<\/span> <\/span>{}\n\n  <span class=\"hljs-meta\">@Override<\/span>\n  <span class=\"hljs-function\"><span class=\"hljs-keyword\">public<\/span> <span class=\"hljs-keyword\">int<\/span> <span class=\"hljs-title\">compare<\/span><span class=\"hljs-params\">(String o1, String o2)<\/span> <\/span>{\n    <span class=\"hljs-keyword\">return<\/span> Integer.compare(o1.length(), o2.length());\n  }\n}<\/code><\/span><small class=\"shcb-language\" id=\"shcb-language-17\"><span class=\"shcb-language__label\">Code-Sprache:<\/span> <span class=\"shcb-language__name\">Java<\/span> <span class=\"shcb-language__paren\">(<\/span><span class=\"shcb-language__slug\">java<\/span><span class=\"shcb-language__paren\">)<\/span><\/small><\/pre>\n\n\n<p>Eine \u00f6ffentliche Klasse gibt uns auch die M\u00f6glichkeit das Sortierverhalten \u00fcber Konstruktor-Parameter zu steuern. Z. B. k\u00f6nnten wir die Sortierreihenfolge konfigurierbar machen:<\/p>\n\n\n<pre class=\"wp-block-code\" aria-describedby=\"shcb-language-18\" data-shcb-language-name=\"Java\" data-shcb-language-slug=\"java\"><span><code class=\"hljs language-java\"><span class=\"hljs-keyword\">public<\/span> <span class=\"hljs-class\"><span class=\"hljs-keyword\">class<\/span> <span class=\"hljs-title\">StringLengthComparator<\/span> <span class=\"hljs-keyword\">implements<\/span> <span class=\"hljs-title\">Comparator<\/span>&lt;<span class=\"hljs-title\">String<\/span>&gt; <\/span>{\n  <span class=\"hljs-keyword\">public<\/span> <span class=\"hljs-keyword\">static<\/span> <span class=\"hljs-keyword\">final<\/span> StringLengthComparator ASC = <span class=\"hljs-keyword\">new<\/span> StringLengthComparator(<span class=\"hljs-keyword\">true<\/span>);\n  <span class=\"hljs-keyword\">public<\/span> <span class=\"hljs-keyword\">static<\/span> <span class=\"hljs-keyword\">final<\/span> StringLengthComparator DESC = <span class=\"hljs-keyword\">new<\/span> StringLengthComparator(<span class=\"hljs-keyword\">false<\/span>);\n\n  <span class=\"hljs-keyword\">private<\/span> <span class=\"hljs-keyword\">final<\/span> <span class=\"hljs-keyword\">boolean<\/span> ascending;\n\n  <span class=\"hljs-function\"><span class=\"hljs-keyword\">private<\/span> <span class=\"hljs-title\">StringLengthComparator<\/span><span class=\"hljs-params\">(<span class=\"hljs-keyword\">boolean<\/span> ascending)<\/span> <\/span>{\n    <span class=\"hljs-keyword\">this<\/span>.ascending = ascending;\n  }\n\n  <span class=\"hljs-meta\">@Override<\/span>\n  <span class=\"hljs-function\"><span class=\"hljs-keyword\">public<\/span> <span class=\"hljs-keyword\">int<\/span> <span class=\"hljs-title\">compare<\/span><span class=\"hljs-params\">(String o1, String o2)<\/span> <\/span>{\n    <span class=\"hljs-keyword\">int<\/span> result = Integer.compare(o1.length(), o2.length());\n    <span class=\"hljs-keyword\">return<\/span> ascending ? result : -result;\n  }\n}<\/code><\/span><small class=\"shcb-language\" id=\"shcb-language-18\"><span class=\"shcb-language__label\">Code-Sprache:<\/span> <span class=\"shcb-language__name\">Java<\/span> <span class=\"shcb-language__paren\">(<\/span><span class=\"shcb-language__slug\">java<\/span><span class=\"shcb-language__paren\">)<\/span><\/small><\/pre>\n\n\n<p>Diesen Comparator w\u00fcrden wir beispielsweise wie folgt einsetzen, um unsere Namensliste absteigend zu sortieren:<\/p>\n\n\n<pre class=\"wp-block-code\" aria-describedby=\"shcb-language-19\" data-shcb-language-name=\"Java\" data-shcb-language-slug=\"java\"><span><code class=\"hljs language-java\">Arrays.sort(names, StringLengthComparator.DESC);<\/code><\/span><small class=\"shcb-language\" id=\"shcb-language-19\"><span class=\"shcb-language__label\">Code-Sprache:<\/span> <span class=\"shcb-language__name\">Java<\/span> <span class=\"shcb-language__paren\">(<\/span><span class=\"shcb-language__slug\">java<\/span><span class=\"shcb-language__paren\">)<\/span><\/small><\/pre>\n\n\n<p>Eine \u00f6ffentliche Klasse gibt uns also gr\u00f6\u00dftm\u00f6gliche Freiheit und Flexibilit\u00e4t bei der Definition unseres Comparators.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\" class=\"wp-block-heading\" id=\"comparator-als-anonyme-klasse\">Comparator als anonyme Klasse<\/h3>\n\n\n\n<p>Ben\u00f6tigen wir einen Comparator nur an einer einzigen Stelle, k\u00f6nnen wir ihn auch als anonyme Klasse definieren.<\/p>\n\n\n\n<p>Mit dem folgenden Code beispielsweise sortieren wir unsere Studenten nach Nachnamen:<\/p>\n\n\n<pre class=\"wp-block-code\" aria-describedby=\"shcb-language-20\" data-shcb-language-name=\"Java\" data-shcb-language-slug=\"java\"><span><code class=\"hljs language-java\">students.sort(<span class=\"hljs-keyword\">new<\/span> Comparator&lt;Student&gt;() {\n  <span class=\"hljs-meta\">@Override<\/span>\n  <span class=\"hljs-function\"><span class=\"hljs-keyword\">public<\/span> <span class=\"hljs-keyword\">int<\/span> <span class=\"hljs-title\">compare<\/span><span class=\"hljs-params\">(Student o1, Student o2)<\/span> <\/span>{\n    <span class=\"hljs-keyword\">return<\/span> o1.getLastName().compareTo(o2.getLastName());\n  }\n});<\/code><\/span><small class=\"shcb-language\" id=\"shcb-language-20\"><span class=\"shcb-language__label\">Code-Sprache:<\/span> <span class=\"shcb-language__name\">Java<\/span> <span class=\"shcb-language__paren\">(<\/span><span class=\"shcb-language__slug\">java<\/span><span class=\"shcb-language__paren\">)<\/span><\/small><\/pre>\n\n\n<p>Da es Nachnamen gibt, die h\u00e4ufiger vorkommen, sollten wir vielleicht besser nach Nachnamen <em>und<\/em> nach Vornamen sortieren. Dies tun wir, in dem wir zun\u00e4chst pr\u00fcfen, ob die Nachnamen gleich sind. Wenn das der Fall ist, vergleichen wir auch die Vornamen:<\/p>\n\n\n<pre class=\"wp-block-code\" aria-describedby=\"shcb-language-21\" data-shcb-language-name=\"Java\" data-shcb-language-slug=\"java\"><span><code class=\"hljs language-java\">students.sort(<span class=\"hljs-keyword\">new<\/span> Comparator&lt;Student&gt;() {\n  <span class=\"hljs-meta\">@Override<\/span>\n  <span class=\"hljs-function\"><span class=\"hljs-keyword\">public<\/span> <span class=\"hljs-keyword\">int<\/span> <span class=\"hljs-title\">compare<\/span><span class=\"hljs-params\">(Student o1, Student o2)<\/span> <\/span>{\n    <span class=\"hljs-keyword\">int<\/span> result = o1.getLastName().compareTo(o2.getLastName());\n    <span class=\"hljs-keyword\">if<\/span> (result == <span class=\"hljs-number\">0<\/span>) {\n      result = o1.getFirstName().compareTo(o2.getFirstName());\n    }\n    <span class=\"hljs-keyword\">return<\/span> result;\n  }\n});\n<\/code><\/span><small class=\"shcb-language\" id=\"shcb-language-21\"><span class=\"shcb-language__label\">Code-Sprache:<\/span> <span class=\"shcb-language__name\">Java<\/span> <span class=\"shcb-language__paren\">(<\/span><span class=\"shcb-language__slug\">java<\/span><span class=\"shcb-language__paren\">)<\/span><\/small><\/pre>\n\n\n<p>In beiden F\u00e4llen wird uns eine moderne IDE wie IntelliJ darauf hinweisen, dass das ab Java 8 auch eleganter geht (und uns optimalerweise auch gleich anbieten den Code zu refactoren):<\/p>\n\n\n<div class=\"wp-block-image\">\n<figure class=\"aligncenter size-full\"><img decoding=\"async\" width=\"624\" height=\"260\" src=\"https:\/\/www.happycoders.eu\/wp-content\/uploads\/2020\/10\/java_comparator_lambda.png\" alt=\"Comparator-Refactoring zum Lambda-Ausdruck\" class=\"wp-image-16470\" srcset=\"https:\/\/www.happycoders.eu\/wp-content\/uploads\/2020\/10\/java_comparator_lambda.png 624w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2020\/10\/java_comparator_lambda-224x93.png 224w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2020\/10\/java_comparator_lambda-336x140.png 336w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2020\/10\/java_comparator_lambda-504x210.png 504w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2020\/10\/java_comparator_lambda-400x167.png 400w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2020\/10\/java_comparator_lambda-600x250.png 600w\" sizes=\"(max-width: 624px) 100vw, 624px\" \/><\/figure>\n<\/div>\n\n\n<p>Was dabei herauskommt, erf\u00e4hrst du im n\u00e4chsten Abschnitt.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\" class=\"wp-block-heading\" id=\"java-comparator-als-lambda-notieren\">Java Comparator als Lambda notieren<\/h3>\n\n\n\n<p>Ab Java 8 k\u00f6nnen wir statt der anonymen Klasse n\u00e4mlich auch ein Lambda verwenden. Das Sortieren nach Nachname erfolgt dann wie folgt:<\/p>\n\n\n<pre class=\"wp-block-code\" aria-describedby=\"shcb-language-22\" data-shcb-language-name=\"Java\" data-shcb-language-slug=\"java\"><span><code class=\"hljs language-java\">students.sort((o1, o2) -&gt; o1.getLastName().compareTo(o2.getLastName()));<\/code><\/span><small class=\"shcb-language\" id=\"shcb-language-22\"><span class=\"shcb-language__label\">Code-Sprache:<\/span> <span class=\"shcb-language__name\">Java<\/span> <span class=\"shcb-language__paren\">(<\/span><span class=\"shcb-language__slug\">java<\/span><span class=\"shcb-language__paren\">)<\/span><\/small><\/pre>\n\n\n<p>Auch das Sortieren nach Nach- <em>und<\/em> Vorname wird durch die Lambda-Notation k\u00fcrzer:<\/p>\n\n\n<pre class=\"wp-block-code\" aria-describedby=\"shcb-language-23\" data-shcb-language-name=\"Java\" data-shcb-language-slug=\"java\"><span><code class=\"hljs language-java\">students.sort((o1, o2) -&gt; {\n  <span class=\"hljs-keyword\">int<\/span> result = o1.getLastName().compareTo(o2.getLastName());\n  <span class=\"hljs-keyword\">if<\/span> (result == <span class=\"hljs-number\">0<\/span>) {\n    result = o1.getFirstName().compareTo(o2.getFirstName());\n  }\n  <span class=\"hljs-keyword\">return<\/span> result;\n});<\/code><\/span><small class=\"shcb-language\" id=\"shcb-language-23\"><span class=\"shcb-language__label\">Code-Sprache:<\/span> <span class=\"shcb-language__name\">Java<\/span> <span class=\"shcb-language__paren\">(<\/span><span class=\"shcb-language__slug\">java<\/span><span class=\"shcb-language__paren\">)<\/span><\/small><\/pre>\n\n\n<p>Richtig sch\u00f6n wird es mit der Methode, die ich im folgenden Abschnitt zeigen werde. Auch den Schritt dorthin bietet uns eine moderne IDE an:<\/p>\n\n\n<div class=\"wp-block-image\">\n<figure class=\"aligncenter size-full\"><img decoding=\"async\" width=\"670\" height=\"244\" src=\"https:\/\/www.happycoders.eu\/wp-content\/uploads\/2020\/10\/java_comparator_chain.png\" alt=\"Refactoring zur Comparator Chain\" class=\"wp-image-16473\" srcset=\"https:\/\/www.happycoders.eu\/wp-content\/uploads\/2020\/10\/java_comparator_chain.png 670w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2020\/10\/java_comparator_chain-224x82.png 224w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2020\/10\/java_comparator_chain-336x122.png 336w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2020\/10\/java_comparator_chain-504x184.png 504w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2020\/10\/java_comparator_chain-400x146.png 400w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2020\/10\/java_comparator_chain-600x219.png 600w\" sizes=\"(max-width: 670px) 100vw, 670px\" \/><\/figure>\n<\/div>\n\n\n<h3 class=\"wp-block-heading\" class=\"wp-block-heading\" id=\"java-8-comparator-erzeugen-mit-comparator-comparing\">Java 8: Comparator erzeugen mit Comparator.comparing()<\/h3>\n\n\n\n<p>Die eleganteste Methode zur Konstruktion eines Comparators, die ebenfalls seit Java 8 zur Verf\u00fcgung steht, ist die Verwendung von <code>Comparator.comparing()<\/code>, <code>Comparator.thenComparing()<\/code> und <code>Comparator.reversed()<\/code>&nbsp;\u2013 sowie deren Variationen f\u00fcr die primitiven Datentypen <code>int<\/code>, <code>long<\/code> und <code>double<\/code>.<\/p>\n\n\n\n<p>Um die Studenten nach Nachnamen zu sortieren, schreiben wir folgendes:<\/p>\n\n\n<pre class=\"wp-block-code\" aria-describedby=\"shcb-language-24\" data-shcb-language-name=\"Java\" data-shcb-language-slug=\"java\"><span><code class=\"hljs language-java\">students.sort(Comparator.comparing(Student::getLastName));<\/code><\/span><small class=\"shcb-language\" id=\"shcb-language-24\"><span class=\"shcb-language__label\">Code-Sprache:<\/span> <span class=\"shcb-language__name\">Java<\/span> <span class=\"shcb-language__paren\">(<\/span><span class=\"shcb-language__slug\">java<\/span><span class=\"shcb-language__paren\">)<\/span><\/small><\/pre>\n\n\n<p>Wir \u00fcbergeben also lediglich eine Referenz auf die Methode, die das Feld zur\u00fcckgibt, nach welchem sortiert werden soll.<\/p>\n\n\n\n<p>Nach Nach- und Vornamen sortieren wir wie folgt:<\/p>\n\n\n<pre class=\"wp-block-code\" aria-describedby=\"shcb-language-25\" data-shcb-language-name=\"Java\" data-shcb-language-slug=\"java\"><span><code class=\"hljs language-java\">students.sort(Comparator.comparing(Student::getLastName)\n        .thenComparing(Student::getFirstName));<\/code><\/span><small class=\"shcb-language\" id=\"shcb-language-25\"><span class=\"shcb-language__label\">Code-Sprache:<\/span> <span class=\"shcb-language__name\">Java<\/span> <span class=\"shcb-language__paren\">(<\/span><span class=\"shcb-language__slug\">java<\/span><span class=\"shcb-language__paren\">)<\/span><\/small><\/pre>\n\n\n<p>Diese Schreibweise macht es uns sehr einfach auch den Fall abzudecken, dass zwei Studenten nicht nur den gleichen Nach- sondern auch den gleichen Vornamen haben. Um sie in diesem Fall zus\u00e4tzlich nach ID zu sortieren, m\u00fcssen wir lediglich ein <code>thenComparingInt()<\/code> hinzuf\u00fcgen:<\/p>\n\n\n<pre class=\"wp-block-code\" aria-describedby=\"shcb-language-26\" data-shcb-language-name=\"Java\" data-shcb-language-slug=\"java\"><span><code class=\"hljs language-java\">students.sort(Comparator.comparing(Student::getLastName)\n        .thenComparing(Student::getFirstName)\n        .thenComparingInt(Student::getId));<\/code><\/span><small class=\"shcb-language\" id=\"shcb-language-26\"><span class=\"shcb-language__label\">Code-Sprache:<\/span> <span class=\"shcb-language__name\">Java<\/span> <span class=\"shcb-language__paren\">(<\/span><span class=\"shcb-language__slug\">java<\/span><span class=\"shcb-language__paren\">)<\/span><\/small><\/pre>\n\n\n<p><code>Comparator.comparing()<\/code> und die damit aufgebauten Comparator-Ketten machen den Code nicht nur k\u00fcrzer, sondern auch deutlich aussagekr\u00e4ftiger.<\/p>\n\n\n\n<h2 class=\"wp-block-heading\" class=\"wp-block-heading\" id=\"comparable-vs-comparator-zusammenfassung\">Comparable vs Comparator \u2013 Zusammenfassung<\/h2>\n\n\n\n<p>Wir haben im Laufe des Artikels die Interfaces <code>java.lang.Comparable<\/code> und <code>java.util.Comparator<\/code> kennengelernt. Hier noch einmal der Unterschied in wenigen S\u00e4tzen zusammengefasst:<\/p>\n\n\n\n<p>Durch die Implementierung der <code>Comparable<\/code>.<code>compareTo()<\/code>-Methode definieren wir die <em>nat\u00fcrliche Ordnung<\/em> von Objekten einer Klasse, d. h. diejenige Ordnung, nach der die Objekte der Klasse standardm\u00e4\u00dfig sortiert werden, also beispielsweise durch <code>Arrays.sort(arrayOfObjects)<\/code> oder <code>Collections.sort(listOfObjects)<\/code>.<\/p>\n\n\n\n<p>Mit einem <code>Comparator<\/code> k\u00f6nnen wir Objekte in einer anderen als ihrer nat\u00fcrlichen Ordnung sortieren. Und wir k\u00f6nnen Objekte sortieren, die das <code>Comparable<\/code>-Interface nicht implementieren, also keine nat\u00fcrliche Ordnung haben. <\/p>\n\n\n\n<p>Seit Java 8 lassen sich Comparatoren sehr elegant definieren, wie z. B. in <code>students.sort(Comparator.comparing(Student::getLastName)<\/code>.<\/p>\n<aside><p>Wenn dir der Artikel weitergeholfen hat, w\u00fcrde ich mich sehr \u00fcber eine positive Bewertung auf meinem <a href=\"https:\/\/www.provenexpert.com\/de-de\/sven-woltmann-happycoders-eu\/7smk\/\" target=\"_blank\" rel=\"noopener\">ProvenExpert-Profil<\/a> freuen. Dein Feedback hilft mir, meine Inhalte weiter zu verbessern und motiviert mich, neue informative Artikel zu schreiben.<\/p>\r\n                        <p>\ud83d\udc49 <a href=\"https:\/\/www.provenexpert.com\/de-de\/sven-woltmann-happycoders-eu\/7smk\/\" target=\"_blank\" rel=\"noopener\">Bewertung abgeben<\/a><\/p>\r\n                        <p>Du m\u00f6chtest \u00fcber alle neue Java-Features auf dem Laufenden sein? Dann <a href=\"#\" data-formkit-toggle=\"d8ee997126\">klicke hier<\/a>, um dich f\u00fcr den HappyCoders-Newsletter anzumelden.<\/p>\r\n                        <p>\ud83d\udc49 <a href=\"#\" data-formkit-toggle=\"d8ee997126\">Newsletter-Anmeldung<\/a><\/p><\/aside>","protected":false},"excerpt":{"rendered":"<p>Wie vergleicht man zwei Objekte in Java? Was ist der Unterschied zwischen Comparator und Comparable? Wie erzeugt man einen Comparator mit Java 8?<\/p>\n","protected":false},"author":1,"featured_media":34468,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_seopress_robots_primary_cat":"none","_seopress_titles_title":"Comparator, Comparable, compareTo - vergleicht Java-Objekte","_seopress_titles_desc":"Wie vergleicht man zwei Objekte in Java? Was unterscheidet Comparator und Comparable? Wie erzeugt man einen Comparator mit Java 8?","_seopress_robots_index":"","_uag_custom_page_level_css":"","_wp_convertkit_post_meta":{"form":"-1","landing_page":"","tag":"0","restrict_content":"0"},"_metis_text_type":"standard","_metis_text_length":14946,"_post_count":0,"footnotes":""},"categories":[64],"tags":[227],"class_list":["post-16127","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-java","tag-java-basics-de"],"uagb_featured_image_src":{"full":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2020\/10\/java-comparator-comparable-compareto.jpg",1770,986,false],"thumbnail":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2020\/10\/java-comparator-comparable-compareto.jpg",150,84,false],"medium":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2020\/10\/java-comparator-comparable-compareto.jpg",300,167,false],"medium_large":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2020\/10\/java-comparator-comparable-compareto.jpg",768,428,false],"large":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2020\/10\/java-comparator-comparable-compareto.jpg",1024,570,false],"feature_thumb_224":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2020\/10\/java-comparator-comparable-compareto-224x125.jpg",224,125,true],"feature_thumb_336":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2020\/10\/java-comparator-comparable-compareto-336x187.jpg",336,187,true],"feature_thumb_504":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2020\/10\/java-comparator-comparable-compareto-504x281.jpg",504,281,true],"feature_thumb_672":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2020\/10\/java-comparator-comparable-compareto-672x374.jpg",672,374,true],"half_400":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2020\/10\/java-comparator-comparable-compareto-400x223.jpg",400,223,true],"half_600":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2020\/10\/java-comparator-comparable-compareto-600x334.jpg",600,334,true],"full_800":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2020\/10\/java-comparator-comparable-compareto-800x446.jpg",800,446,true],"full_944":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2020\/10\/java-comparator-comparable-compareto-944x526.jpg",944,526,true],"full_1200":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2020\/10\/java-comparator-comparable-compareto-1200x668.jpg",1200,668,true],"wide_1180":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2020\/10\/java-comparator-comparable-compareto-1180x490.jpg",1180,490,true],"wide_1770":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2020\/10\/java-comparator-comparable-compareto-1770x735.jpg",1770,735,true],"1536x1536":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2020\/10\/java-comparator-comparable-compareto.jpg",1536,856,false],"2048x2048":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2020\/10\/java-comparator-comparable-compareto.jpg",1770,986,false]},"uagb_author_info":{"display_name":"Sven Woltmann","author_link":"https:\/\/www.happycoders.eu\/de\/author\/sven\/"},"uagb_comment_info":1,"uagb_excerpt":"Wie vergleicht man zwei Objekte in Java? Was ist der Unterschied zwischen Comparator und Comparable? Wie erzeugt man einen Comparator mit Java 8?","public_identification_id":"3fd32babf4604f13aae3f5dcac283dd7","private_identification_id":"2c25c796fbf9464b8cf125d850b92b57","_links":{"self":[{"href":"https:\/\/www.happycoders.eu\/de\/wp-json\/wp\/v2\/posts\/16127","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.happycoders.eu\/de\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.happycoders.eu\/de\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.happycoders.eu\/de\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.happycoders.eu\/de\/wp-json\/wp\/v2\/comments?post=16127"}],"version-history":[{"count":10,"href":"https:\/\/www.happycoders.eu\/de\/wp-json\/wp\/v2\/posts\/16127\/revisions"}],"predecessor-version":[{"id":52439,"href":"https:\/\/www.happycoders.eu\/de\/wp-json\/wp\/v2\/posts\/16127\/revisions\/52439"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.happycoders.eu\/de\/wp-json\/wp\/v2\/media\/34468"}],"wp:attachment":[{"href":"https:\/\/www.happycoders.eu\/de\/wp-json\/wp\/v2\/media?parent=16127"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.happycoders.eu\/de\/wp-json\/wp\/v2\/categories?post=16127"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.happycoders.eu\/de\/wp-json\/wp\/v2\/tags?post=16127"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}