{"id":4611,"date":"2024-04-30T15:30:50","date_gmt":"2024-04-30T15:30:50","guid":{"rendered":"https:\/\/msgprogramator.sk\/?p=4611"},"modified":"2025-07-07T11:36:34","modified_gmt":"2025-07-07T11:36:34","slug":"java-objekte-vergleichen","status":"publish","type":"post","link":"https:\/\/msgprogramator.sk\/de\/java-objekte-vergleichen\/","title":{"rendered":"Wie man Objekte in Java richtig vergleicht"},"content":{"rendered":"<p>In einer objektorientierten Programmiersprache wie Java geh\u00f6rt der Vergleich von Objekten untereinander oder mit anderen primitiven Typen zu den h\u00e4ufig durchgef\u00fchrten grundlegenden Operationen. Aus der Praxis wissen wir jedoch, dass vor allem Anf\u00e4nger Schwierigkeiten haben, Daten korrekt miteinander zu vergleichen und wann sie die Operatoren Gleichheitszeichen (<strong>==<\/strong>) und Ungleichheitszeichen (<strong>!=<\/strong>) verwenden sollen und wann die Methoden <strong>equals()<\/strong> oder <strong>compareTo()<\/strong>. Dies ist f\u00fcr sie oft ziemlich verwirrend.<\/p>\n<p>Das Vergleichen von Objekten ist der Prozess der \u00dcberpr\u00fcfung, ob zwei Objekte gleich sind oder nicht, basierend auf ihren Daten oder Referenzen. In Java werden Objekte aus Klassen erstellt, und jedes Objekt hat seinen eigenen Satz von Daten und definiertem Verhalten. Wir k\u00f6nnen jedoch auch \u00fcberpr\u00fcfen, ob sich Objekte an derselben Stelle im Speicher befinden. Wenn dies der Fall ist, handelt es sich nicht um zwei verschiedene Objekte, sondern um ein und dasselbe.<\/p>\n<p>In diesem Artikel wird anhand von praktischen Beispielen gezeigt, wie man Objekte in Java richtig vergleicht, entweder auf der Basis der Daten in den Objekten oder ihrer Referenzen. Du wirst auch erfahren, wie die Methode equals() implementiert ist und funktioniert. Zudem werden wir auf die Bedeutung der Implementierung der Methode <strong> hashCode()<\/strong> eingehen, um Objekte effizient mithilfe von Hash-Algorithmen zu vergleichen.<\/p>\n<h2>Vergleich von Objekten mit primitiven Typen<\/h2>\n<p>In Java sind primitive Typen wie <strong>int<\/strong>, <strong>double<\/strong>, <strong>boolean<\/strong>, usw. keine Objekte, sondern grundlegende Datentypen. Beim Abgleich von Objekten mit primitiven Typen konvertiert Java das entsprechende <em>Wrapper-Objekt<\/em> einer Klasse automatisch in seinen primitiven Typ unter Verwendung der erweiterbaren primitiven Konvertierung<a href=\"https:\/\/docs.oracle.com\/javase\/specs\/jls\/se7\/html\/jls-5.html#jls-5.1.2\" target=\"_blank\" rel=\"nofollow noopener\">(\u00a75.1.2<\/a>). F\u00fcr letztere sind die folgenden Regeln festgelegt:   <\/p>\n<ul>\n<li>Wenn einer der Operanden vom Typ double ist, wird der andere in double umgewandelt.<\/li>\n<li>Andernfalls, wenn einer der Operanden vom Typ float ist, wird der andere in float umgewandelt.<\/li>\n<li>Andernfalls, wenn einer der Operanden vom Typ long ist, wird der andere in long konvertiert.<\/li>\n<li>Andernfalls werden beide Operanden in den Typ int konvertiert.<\/li>\n<\/ul>\n<p><u>Beispiel:<\/u><\/p>\n<pre><code class=\"language-java\" data-line=\"\">Integer I = new Integer(5);\nint i = 5;\n\nSystem.out.println(I == i);\n\/\/ =&gt; true\n\nSystem.out.println(I.equals(i));\n\/\/ =&gt; true\n<\/code><\/pre>\n<p>Soweit wir sehen k\u00f6nnen, ist der Vergleich eines Objekts mit seinem primitiven Typ, entweder \u00fcber den Operator <strong>==<\/strong> oder gleich, gleichwertig und wenn die Werte gleich sind, ist das Ergebnis ein boolescher Wert von true<strong>.<\/strong><\/p>\n<h2>Vergleich von Objekten anhand von Referenzen<\/h2>\n<p>Die Identit\u00e4t einer Variablen (auch Referenzgleichheit genannt) wird durch die Referenz (Verweis) definiert, die sie besitzt. Wenn zwei Variablen die gleiche Referenz haben, sind sie identisch. Dies wird mit dem == Operator \u00fcberpr\u00fcft. Es ist wichtig, sich daran zu erinnern, dass der == Operator in Java verwendet wird, um die Referenzen von zwei Objekten zu vergleichen, nicht deren Inhalte. Er pr\u00fcft also, ob beide Referenzen auf genau dasselbe Objekt im Speicher (oder dessen Adresse) zeigen.  <\/p>\n<p><u>Beispiel:<\/u><\/p>\n<pre><code class=\"language-java\" data-line=\"\">String s1 = new String(&quot;Java&quot;);\nString s2 = new String(&quot;Java&quot;);\nSystem.out.println(s1 == s2);\n\/\/ =&gt; false\n<\/code><\/pre>\n<p>In diesem Beispiel haben wir denselben Text in beiden Strings, aber da wir Referenzen (Speicherreferenzen auf zwei verschiedene Instanzen) vergleichen, ist das Ergebnis nat\u00fcrlich ein boolescher Wert von false<strong>.<\/strong><\/p>\n<p><u>Beispiel:<\/u><\/p>\n<pre><code class=\"language-java\" data-line=\"\">String s1 = new String(&quot;Java&quot;);\nString s2 = s1;\nSystem.out.println(s1 == s2);\n\/\/ =&gt; true\n<\/code><\/pre>\n<p>Wenn wir jedoch anstelle der Erstellung einer neuen Instanz die Referenz des ersten Strings in den zweiten String kopieren, ist das Ergebnis beim Vergleich der Referenzen true.<\/p>\n<h2>Vergleich von Objekten anhand ihrer Werte<\/h2>\n<p>Die Gleichheit einer Variable wird durch den Wert definiert, auf den sie verweist. Wenn zwei Variablen auf denselben Wert verweisen, sind sie gleich. Dies wird in Java mit der Methode equals() \u00fcberpr\u00fcft. Sie ist Teil der Klasse Object, die die \u00fcbergeordnete Klasse aller Java-Klassen ist. Das bedeutet, dass wir in Java die Methode equals verwenden k\u00f6nnen, um den Dateninhalt von zwei beliebigen Objekten zu vergleichen.    <\/p>\n<p><u>Beispiel:<\/u><\/p>\n<pre><code class=\"language-java\" data-line=\"\">String s1 = new String(&quot;Java&quot;);\nString s2 = new String(&quot;Java&quot;);\nSystem.out.println(s1.equals(s2));\n\/\/ =&gt; true\n<\/code><\/pre>\n<p>Das Beispiel zeigt den Vergleich von 2 verschiedenen Instanzen des Typs String mit demselben Text. Das Ergebnis des Aufrufs equals() liefert den booleschen Wert true. Wenn wir im vorherigen Beispiel einen Verweis auf dasselbe Objekt kopiert h\u00e4tten, w\u00e4re das Ergebnis des Vergleichs der Werte desselben Objekts ebenfalls wahr.  <\/p>\n<p><u>Beispiel:<\/u><\/p>\n<pre><code class=\"language-java\" data-line=\"\">String s1 = new String(&quot;Java&quot;);\nString s2 = s1;\nSystem.out.println(s1.equals(s2));\n\/\/ =&gt; true\n<\/code><\/pre>\n<p>Bisher haben wir in den Beispielen einfache Objekte verwendet, die von den Java-Autoren in den Bibliotheken bereitgestellt wurden. Jetzt werden wir ein eigenes Objekt erstellen und die Methode equals() genauer unter die Lupe nehmen. <\/p>\n<p><u>Beispiel:<\/u><\/p>\n<p>Klasse Shape<\/p>\n<pre><code class=\"language-java\" data-line=\"\">package pack;\n\npublic class Shape {\n    String colour;\n\n    public Shape(String colour) {\n        this.colour = colour;\n    }\n\n    public String getColour() {\n        return colour;\n    }\n\n    public void setColour(String colour) {\n        this.colour = colour;\n    }\n}\n<\/code><\/pre>\n<p>Klasse Circle<\/p>\n<pre><code class=\"language-java\" data-line=\"\">package pack;\n\npublic class Circle extends Shape {\n    double radius;\n\n    public Circle (String colour, double radius) {\n        super(colour);\n        this.radius = radius;\n    }\n\n    public double getRadius() {\n        return radius;\n    }\n\n    public void setRadius(double radius) {\n        this.radius = radius;\n    }\n}\n<\/code><\/pre>\n<p>Wir haben eine Klasse Circle erstellt, die von der \u00fcbergeordneten Klasse Shape erbt. Jetzt erstellen wir zwei Instanzen mit denselben Daten und vergleichen ihre Referenzen und ihre Werte mit der Methode equals. <\/p>\n<pre><code class=\"language-java\" data-line=\"\">Circle c1 = new Circle(&quot;green&quot;, 1);\nCircle c2 = new Circle(&quot;green&quot;, 1);\n\nSystem.out.println(c1 != c2);\n\/\/ =&gt; true\n\nSystem.out.println(c1.equals(c2));\n\/\/ =&gt; false\n<\/code><\/pre>\n<p>Die Tatsache, dass die Verweise auf die beiden verschiedenen Instanzen unterschiedlich sind, ist zwar das, was wir erwartet haben. Die \u00dcberraschung besteht jedoch darin, dass die Methode equals false zur\u00fcckgibt, obwohl die beiden Objekte dieselben Attributwerte enthalten und somit die Werte der beiden Objekte unterschiedlich sind. Das liegt daran, dass die Standardimplementierung von equals in der Klasse Object, die jedes Objekt erbt, die Speicheradressen der Objekte vergleicht, also genau wie der == Operator funktioniert. Daher m\u00fcssen wir diese Methode au\u00dfer Kraft setzen, um zu definieren, was Gleichheit f\u00fcr unsere Objekte bedeutet. Dazu m\u00fcssen wir jedoch zun\u00e4chst wissen, welche Regeln f\u00fcr die Methode equals gelten.    <\/p>\n<h3>Regeln der Methode Equals()<\/h3>\n<p>Nehmen wir an, wir haben die Referenzen x, y, z definiert. Dann sollte eine korrekt implementierte equals-Methode die folgenden Eigenschaften haben. <u>Reflexivit\u00e4t:<\/u> F\u00fcr jede Referenz x, die nicht Null ist, sollte x.equals(x) true zur\u00fcckgeben. <u>Symmetrie:<\/u> f\u00fcr alle Referenzen x und y, die nicht Null sind, sollte x.equals(y) nur dann true zur\u00fcckgeben, wenn y.equals(x) true zur\u00fcckgibt. <u>Transitivit\u00e4t:<\/u> f\u00fcr alle Referenzwerte x, y und z, die nicht Null sind, sollte x.equals(y) true und y.equals(z) true zur\u00fcckgeben, dann sollte x.equals(z) true zur\u00fcckgeben. <u>Konsistenz:<\/u> F\u00fcr jeden Referenzwert x und y, der nicht Null ist, werden mehrere Aufrufe von x.equals(y), vorausgesetzt, dass keine Informationen, die beim Gleichheitsvergleich der Objekte verwendet werden, ge\u00e4ndert werden, konsistent nacheinander dieselben wahren oder falschen Werte zur\u00fcckgeben. F\u00fcr jeden Referenzwert, der nicht null ist, sollte x.equals(null) false zur\u00fcckgeben. <\/p>\n<h2>Korrekte Implementierung der Methode equals()<\/h2>\n<p>Da wir nun die Regeln von equals kennen, k\u00f6nnen wir unsere eigene Version von equals f\u00fcr die Klasse Circle wie folgt implementieren.<\/p>\n<pre><code class=\"language-java\" data-line=\"\">@Override\npublic boolean equals(Object o) {\n    \/\/ self check\n    if (this == o) return true;\n\n    \/\/ Null check\n    if (o == null) return false;\n\n    \/\/ Type check and cast\n    if (getClass() != o.getClass())\n        return false;\n    \n    Circle circle = (Circle) o;\n\n    \/\/ Field comparison\n    return Objects.equals(radius,  circle.radius)\n            &amp;&amp; Objects.equals(colour, circle.colour);\n}\n<\/code><\/pre>\n<p>Wir \u00fcberpr\u00fcfen, ob beide Instanzen die gleichen Werte enthalten und ob die Methode equals korrekt funktioniert und true zur\u00fcckgibt.<\/p>\n<pre><code class=\"language-java\" data-line=\"\">Circle c1 = new Circle(&quot;green&quot;, 1);\nCircle c2 = new Circle(&quot;green&quot;, 1);\nSystem.out.println(c1.equals(c2));\n\/\/ =&gt; true\n<\/code><\/pre>\n<p>In unserer Implementierung von equals \u00fcberpr\u00fcfen wir zun\u00e4chst, ob wir das Objekt mit sich selbst vergleichen, und wenn ja, ist das Ergebnis true. Danach pr\u00fcfen wir, ob die Referenz auf das zweite Objekt, mit dem wir das erste vergleichen, g\u00fcltig ist (d. h. nicht null), und wenn sie null ist, geben wir false zur\u00fcck. Keine Instanz sollte gleich null sein, und durch diese Zeile stellen wir sicher, dass wir sp\u00e4ter keine NullPointerException erhalten, wenn wir auf Attribute zugreifen. Vor dem eigentlichen Vergleich der Attribute testen wir au\u00dferdem, ob beide zu vergleichenden Objekte derselben Klasse angeh\u00f6ren. Dies stellt sicher, dass selbst wenn die Klasse Circle von der Klasse Shape erbt, der Vergleich dieser Klassen immer false zur\u00fcckgibt.<\/p>\n<h2>Methode hashCode()<\/h2>\n<p>In der Java-Praxis ist es \u00fcblich, dass wenn wir die urspr\u00fcngliche Implementierung von equals() \u00fcberschreiben, wir auch die Methode hashCode() \u00fcberschreiben sollten, da beide Methoden zusammenarbeiten, insbesondere wenn wir mit Objektkollektionen arbeiten. Der Zusammenhang zwischen den beiden Methoden besteht darin, dass, wenn die equals-Methode feststellt, dass zwei Objekte gleich sind, sie auch denselben Hashcode berechnen sollten. Ohne eine korrekte Implementierung des Hashcodes funktionieren Sammlungen, die davon abh\u00e4ngen, wie <em>HashSet <\/em> und <em>HashMap<\/em>, nicht richtig. Nun zeigen wir an unserer Klasse Circle, wie wir die Methode hashCode() korrekt \u00fcberschreiben sollten.<\/p>\n<pre><code class=\"language-java\" data-line=\"\">@Override\npublic int hashCode() {\n    return Objects.hash(radius, colour);\n}\n<\/code><\/pre>\n<h2>Zusammenfassung<\/h2>\n<p>In Java ist der Vergleich zweier Objekte nicht so einfach wie der Vergleich zweier primitiver Datentypen. Es erfordert ein tieferes Verst\u00e4ndnis der Objektstruktur sowie der Art und Weise, wie sie im Speicher abgelegt werden. Die Methode equals() ist die prim\u00e4re Methode, die zum Vergleich zweier Objekte in Java verwendet wird. Wenn wir die Methode equals() \u00fcberschreiben, m\u00fcssen wir auch die Methode hashCode() \u00fcberschreiben, um sicherzustellen, dass zwei gleiche Objekte denselben Hashcode haben. Mit den Methoden equals() und hashCode() k\u00f6nnen wir zwei Objekte effektiv auf Grundlage ihres inneren Zustands vergleichen, anstatt anhand ihres Speicherorts.    <\/p>\n<p>Wenn du ein <a href=\"https:\/\/msg-life.sk\/de\/stellenangebote\/java-entwickler-senior\/\">Java Programmierer<\/a> bist und nach Arbeit suchst, schau dir unsere <a href=\"https:\/\/msg-life.sk\/de\/mitarbeiter-benefits\/\">Mitareiterbenefits <\/a> an und reagiere auf die <a href=\"https:\/\/msg-life.sk\/de\/stellenangebote\/\">neuesten Stellenangebote<\/a>.<\/p>\n","protected":false},"excerpt":{"rendered":"<p>In diesem Artikel zeigen wir, wie man Objekte in Java korrekt vergleicht, sei es auf Basis der in den Objekten enthaltenen Daten oder ihrer Referenzen anhand praktischer Beispiele.<\/p>\n","protected":false},"author":14,"featured_media":3230,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"footnotes":""},"categories":[62],"tags":[],"class_list":["post-4611","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-java"],"acf":[],"aioseo_notices":[],"_links":{"self":[{"href":"https:\/\/msgprogramator.sk\/de\/wp-json\/wp\/v2\/posts\/4611","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/msgprogramator.sk\/de\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/msgprogramator.sk\/de\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/msgprogramator.sk\/de\/wp-json\/wp\/v2\/users\/14"}],"replies":[{"embeddable":true,"href":"https:\/\/msgprogramator.sk\/de\/wp-json\/wp\/v2\/comments?post=4611"}],"version-history":[{"count":3,"href":"https:\/\/msgprogramator.sk\/de\/wp-json\/wp\/v2\/posts\/4611\/revisions"}],"predecessor-version":[{"id":8040,"href":"https:\/\/msgprogramator.sk\/de\/wp-json\/wp\/v2\/posts\/4611\/revisions\/8040"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/msgprogramator.sk\/de\/wp-json\/wp\/v2\/media\/3230"}],"wp:attachment":[{"href":"https:\/\/msgprogramator.sk\/de\/wp-json\/wp\/v2\/media?parent=4611"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/msgprogramator.sk\/de\/wp-json\/wp\/v2\/categories?post=4611"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/msgprogramator.sk\/de\/wp-json\/wp\/v2\/tags?post=4611"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}