Java efficace Chapitre 3

Chapitre 3. Méthodes communes à tous les objets

• Ce chapitre se concentre sur la façon de remplacer la méthode Objects.

10. La dérogation égale devrait faire l'objet de contrats généraux

• Les contrats généraux sont réflexifs, symétriques, transitifs, cohérents et non nuls.
• Si vous utilisez l'AutoValue de Google, il remplacera bien.

11. Si vous remplacez égal, remplacez également le hashcode

• Selon le contrat général de hashCode, deux objets égaux doivent renvoyer des valeurs de hashCode égales. Par conséquent, si égal à est remplacé et qu'ils sont logiquement égaux mais pas la même référence, ils renverront des valeurs différentes que si hashCode n'était pas remplacé.

• Si vous vous souciez des performances, mettez en cache la valeur calculée par hashCode.

12. Toujours remplacer toString

• Le toString de Thread.java est le suivant.

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

13. Soyez prudent lorsque vous remplacez le clone

• Appelez super.clone pour lancer. S'il existe une variable mutable, copiez-la en profondeur.

• Dans la plupart des cas, il est plus facile de faire une copie d'un objet avec un constructeur ou une méthode de fabrique qu'avec une méthode de clonage. Seul le clone peut faire une meilleure copie des séquences.

14. Envisager de mettre en œuvre Comparable

• Les classes de valeur de la bibliothèque Java, y compris enum, implémentent généralement Comparable.
• En ce qui concerne BigDecimal, BigDecimal ("1.0") et BigDecimal ("1.00") sont traités différemment en égal, mais ils sont traités de la même manière dans compareTo. Par conséquent, lorsque vous placez ces deux éléments dans HashSet, deux éléments restent, mais lorsque vous les placez dans TreeSet, ils deviennent un.
• Comparer en utilisant l'inégalité dans compareTo est fastidieux et peut provoquer des erreurs, vous devriez donc utiliser compare, une classe wrapper pour les types primitifs.
• Lorsque vous envisagez un tri multi-clés, pensez à utiliser la méthode de construction de Comparator. Il semble que ce soit mieux que de comparer un par un et de diviser par if.

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();
    }
}