Was ist der Output des folgenden Codes?
String a = new String(“Test”);
StringBuffer b = new StringBuffer(“Test”);
StringBuffer c = new StringBuffer(“Test”);
System.out.println(a.equals(b));
System.out.println(b==c);
System.out.println(b.equals(c));
| Antwort/ answer | |
|---|---|
Was ist der Output des folgenden Codes?
Pattern p = Pattern.compile(“\\s”);
Matcher m = p.matcher(“Dies ist eine Übung”);
while (m.find())
System.out.println(m.start());
| Antwort/ answer | |
|---|---|
Was ist die Ausgabe bei folgendem Code?
Pattern p = Pattern.compile(“\\d*” );
Matcher m = p.matcher(“Test4u21″);
while(m.find()) {
System.out.println(m.start() + ” ” +m.group());
| Antwort/ answer | |
|---|---|
Was ist der Output des folgenden Codes:
String a = “Java”;
int b =10;
String c = new String(“Java”);
if (b <=10){
if (a instanceof Object){
System.out.println(a.equals(“Java”));
System.out.println(b==10);
System.out.println(a==”Java”);
System.out.println(a==c);
System.out.println(a.equals(c));
}
}
| Antwort/ answer | |
|---|---|
Was ist der Output des folgenden Codes:
String a = “abc”;
String b = “abc”;
if(a == b)
System.out.println(“a==b”);;
else
System.out.println(“a!=b”);;
if(a.equals(b))
System.out.println(“a.equals(b)”);;
else
System.out.println(“!a.equals.b”);
| Antwort/ answer | |
|---|---|
zur Verdeutlichung hier eine Funktion ohne die Überschreibung beider Methoden:
class Angestellter {
public int PersNr;
public static void main(String[] args) {
Angestellter a = new Angestellter();
Angestellter b = new Angestellter();
Angestellter c = new Angestellter();
a=b;
System.out.println(a.equals(b)); // true
System.out.println(a.equals(c)); // false
System.out.println(a.hashCode()); // gleicher Hash-code wie bei b
System.out.println(b.hashCode()); // gleicher Hash-code wie bei a
System.out.println(c.hashCode()); // Hash-code ist unterschiedlich zu a und b
}
}
Die Ausgabe ist ähnlich dieser:
true
false
1671711
1671711
11394033
Man kann an diesem Beispiel sehr gut sehen, dass equals() und hashCode() zusammenarbeiten.
Als gleich angesehende Werte bekommen auch den gleichen Hash-Code.
Die Methode hashCode() hat die Aufgabe, zu jedem Objekt eine möglichst eindeutigen int-Wert (=HashCode) zu liefern, der das Objekt identifiziert.
Daher hängen die Methoden equals() und hashCode() eng zusammen; wenn sich der Vergleich ändert, sollte sich der HashCode ebenfalls ändern, um zu gewährleisten, das bei gleichen Objekten auch der gleiche Hash-Code zurückgeliefert wird.
Verwendet werden HashCode`s überall dort, wo direkt oder indirekt mit Hashtables oder HashSets gearbeitet wird. Nähere Infos zu Hashtables und HashSets werde ich zu einem späteren Zeitpunkt veröffentlichen. Vorteil ist in jedem Fall ein effizienterer Zugriff auf die Elemente.
Um die Sache mal wieder etwas komplizierter zu machen, kann man auch verschiedene Objekte miteinander vergleichen:
class Angestellter {
public int PersNr;
public boolean equals(Angestellter c){
if (c.PersNr==this.PersNr){
return true;
}
else
return false;
}
public static void main(String[] args) {
Angestellter a = new Angestellter();
Buchhalter b = new Buchhalter();
a.PersNr=1;
b.PersNr=1;
System.out.println(a.equals(b));
}
}
class Buchhalter extends Angestellter {
}
Die Ausgabe ist hier natürlich auch true.
Es empfielt sich, abzufragen, ob beide Objekte den gleichen Ursprung haben, da es ansonsten im Verlaufe des weiteren Code zu Verwirrungen kommen kann.
Die Abänderung sähe dann so aus: if (c.PersNr==this.PersNr && c instanceof Angestellter)
Wie alle Methoden kann auch die equals-Methode überschrieben werden. Nun wieder die Frage aller Fragen: Für was soll das gut sein?
Die Antwort ist relativ einfach; manchmal möchte man die Gleichheit eines Objektes nicht an einem kompletten Objekt ausmachen, sondern nur an bestimmten Eigenschaften:
class Angestellter {
public int PersNr;
public static void main(String[] args) {
Angestellter a = new Angestellter();
Angestellter b = new Angestellter();
System.out.println(a.equals(b));
a.PersNr=1;
b.PersNr=1;
System.out.println(a.equals(b));
}
}
Hier ist der Output jeweils false; da die Objekte ja nicht komplett identisch sind. Wollen wir aber einen Vergleich anhand der Personalnummer müssen wir die equals-Methode überschreiben:
class Angestellter {
public int PersNr;
public boolean equals(Angestellter c)
{
if (c.PersNr==this.PersNr){
return true;
}
else {
return false;
}
public static void main(String[] args) {
Angestellter a = new Angestellter();
Angestellter b = new Angestellter();
System.out.println(a.equals(b));
a.PersNr=1;
b.PersNr=1;
System.out.println(a.equals(b));
}
}
Hier ist der Output jeweils true; die Objekte werden ja nur anhand der Personalnummer verglichen, welche Standardmäßig mit 0 vorbelegt wurde und später jeweils den Wert 1 zugewiesen bekam.
Heute geht es um den Unterschied von == und equals.
== gibt immer das Ergebniss des Zeigervergleiches zurück; also ob beide Variablen auf das gleiche Objekt zeigen;
equals gibt immer das Ergebnis des Wertevergleiches zurück; also ob diese beide Variablen inhaltlich gleich sind.
Hier ein Beispiel:
class Angestellter {
public static void main(String[] args) {
String d = new String(“Hello”);
String e = new String(“Hello”);
System.out.println(e == d); //false (Zeigervergleich)
System.out.println(e.equals(d)); //true (Wertevergleich)
String a, b;
a = “Hello”;
b = a;
System.out.println(a == b); //true (Zeigervergleich)
System.out.println(a.equals(b)); //true (Wertevergleich)
String c = “Hello”;
System.out.println(a == c); //true (Zeigervergleich)Achtung: Da hier nicht “New String” angelegt wurde, zeigt dieser String automatisch auf den existierenden!!!
System.out.println(a.equals(c)); //true (Wertevergleich)
}
}
