Effektives Java Kapitel 3

Kapitel 3. Allen Objekten gemeinsame Methoden

• Dieses Kapitel befasst sich mit dem Überschreiben der Objects-Methode.

10. Gleiche Überschreibung sollte allgemeinen Verträgen unterliegen

• Allgemeine Verträge sind reflexiv, symmetrisch, transitiv, konsistent und nicht null.
• Wenn Sie den AutoValue von Google verwenden, wird dieser gleich gut überschrieben.

11. Wenn Sie gleich überschreiben, überschreiben Sie auch den Hashcode

• Gemäß dem allgemeinen Vertrag für hashCode müssen zwei gleiche Objekte gleiche hashCode-Werte zurückgeben. Wenn also equals überschrieben wird und sie logisch gleich, aber nicht dieselbe Referenz sind, geben sie andere Werte zurück, als wenn hashCode nicht überschrieben wurde.

• Wenn Sie Wert auf Leistung legen, speichern Sie den von hashCode berechneten Wert zwischen.

12. Überschreiben Sie immer toString

• Der toString von Thread.java lautet wie folgt.

    public String toString() {
        ThreadGroup group = getThreadGroup();
        if (group != null) {
            return "Thread[" + getName() + "," + getPriority() + "," +
                           group.getName() + "]";
        } else {
            return "Thread[" + getName() + "," + getPriority() + "," +
                            "" + "]";
        }
    }

13. Seien Sie vorsichtig, wenn Sie den Klon überschreiben

• Rufe super.clone auf, um zu wirken. Wenn es eine veränderbare Variable gibt, kopieren Sie sie tief.

• In den meisten Fällen ist es einfacher, eine Kopie eines Objekts mit einem Konstruktor oder einer Factory-Methode zu erstellen als mit einer Klonmethode. Nur Klone können Sequenzen besser kopieren.

14. Erwägen Sie die Implementierung von Comparable

• Java-Bibliothekswertklassen, einschließlich Enum, implementieren im Allgemeinen Comparable.
• In Bezug auf BigDecimal werden BigDecimal ("1.0") und BigDecimal ("1.00") gleichberechtigt unterschiedlich behandelt, in compareTo jedoch gleich. Wenn Sie diese beiden Elemente in HashSet einfügen, bleiben zwei Elemente übrig. Wenn Sie sie jedoch in TreeSet einfügen, werden sie eins.
• Das Vergleichen mit Ungleichung in compareTo ist langwierig und kann zu Fehlern führen. Verwenden Sie daher compare, eine Wrapper-Klasse für primitive Typen.
• Wenn Sie eine Sortierung mit mehreren Schlüsseln in Betracht ziehen, sollten Sie die Konstruktionsmethode von Comparator verwenden. Es scheint, dass dies besser ist, als eins nach dem anderen zu vergleichen und durch die if-Anweisung zu teilen.

package tryAny.effectiveJava;

import static java.util.Comparator.*;
import java.util.Comparator;
import java.util.stream.Stream;

public class CompareTest {
    public static void main(String[] args) {
	Stream<PhoneNum> s = Stream.of(new PhoneNum(111, 222, 333), new PhoneNum(111, 222, 222),
		new PhoneNum(111, 333, 111), new PhoneNum(000, 999, 1));
	s.sorted().forEach(System.out::println);
    }
}

class PhoneNum implements Comparable<PhoneNum> {
    int areaCode;
    int prefix;
    int lineNum;

    public PhoneNum(int areaCode, int prefix, int lineNum) {
	this.areaCode = areaCode;
	this.prefix = prefix;
	this.lineNum = lineNum;
    }

    private static final Comparator<PhoneNum> COMPARATOR = comparingInt((PhoneNum pn) -> pn.areaCode)
	    .thenComparingInt(pn -> pn.prefix).thenComparingInt(pn -> pn.lineNum);

    @Override
    public int compareTo(PhoneNum pn) {
	return COMPARATOR.compare(this, pn);
    }

    @Override
    public String toString() {
	StringBuilder sb = new StringBuilder();
	sb.append("areaCode:").append(areaCode).append(",prefix:").append(prefix).append(",lineNum:").append(lineNum);
	return sb.toString();
    }
}