Где можно посмотреть описание правил рефлексивности?

# Правила рефлексивности (Reflexivity) в Java

Определение

Рефлексивность — это свойство, которое гласит, что объект должен быть равен самому себе: x.equals(x) всегда должно возвращать true.

Это одно из пяти правил контракта метода equals().

Официальная документация

1. Javadoc метода Object.equals()

Основное описание находится в официальной документации Java для класса java.lang.Object:

public boolean equals(Object obj) {
    /**
     * Указывает, равны ли два объекта. Метод equals реализует отношение
     * эквивалентности на ненулевых ссылках:
     * - Рефлексивность (reflexive): x.equals(x) должно возвращать true
     * - Симметричность (symmetric): x.equals(y) => y.equals(x)
     * - Транзитивность (transitive): x.equals(y) && y.equals(z) => x.equals(z)
     * - Консистентность (consistent): повторные вызовы возвращают одно значение
     * - С null: x.equals(null) должно возвращать false
     */
}

2. Ссылки на документацию

Официальная документация Oracle:

• https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html#equals-java.lang.Object-
• В разделе "Specification" описаны все пять правил

Для Java 11+:

• https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html#equals(java.lang.Object)

Для Java 17 (LTS):

• https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Object.html#equals(java.lang.Object)

3. Java Language Specification (JLS)

Детальное описание находится в Java Language Specification:

4.3 String Literals
5.1 Type Conversion and Value Set Conversion
И в контексте equals() — в описании класса Object

Пять правил контракта equals()

1. Рефлексивность (Reflexivity)

// x.equals(x) ВСЕГДА должно быть true (для x != null)
String x = "Hello";
assert x.equals(x) == true;  // ✅

MyClass obj = new MyClass();
assert obj.equals(obj) == true;  // ✅

2. Симметричность (Symmetry)

// Если x.equals(y), то y.equals(x)
String a = "test";
String b = "test";

assert a.equals(b) == true;   // ✅
assert b.equals(a) == true;   // ✅ (следует из симметричности)

3. Транзитивность (Transitivity)

// Если x.equals(y) && y.equals(z), то x.equals(z)
Integer a = 5;
Integer b = 5;
Integer c = 5;

assert a.equals(b) == true;   // ✅
assert b.equals(c) == true;   // ✅
assert a.equals(c) == true;   // ✅ (следует из транзитивности)

4. Консистентность (Consistency)

// Повторные вызовы возвращают одно значение
String x = "data";
String y = "data";

assert x.equals(y) == true;  // ✅
assert x.equals(y) == true;  // ✅ (тот же результат)
assert x.equals(y) == true;  // ✅ (тот же результат)

5. Сравнение с null

// x.equals(null) ВСЕГДА должно быть false
String x = "Hello";
assert x.equals(null) == false;  // ✅

Object obj = new Object();
assert obj.equals(null) == false;  // ✅

Примеры в исходном коде Java

String.equals()

// Источник: java/lang/String.java
public boolean equals(Object anObject) {
    if (this == anObject) {  // Рефлексивность
        return true;
    }
    if (anObject instanceof String) {  // Проверка типа
        String anotherString = (String) anObject;
        int n = value.length;
        if (n == anotherString.value.length) {
            char v1[] = value;
            char v2[] = anotherString.value;
            int i = 0;
            while (n-- != 0) {
                if (v1[i] != v2[i])
                    return false;
                i++;
            }
            return true;  // Контент одинаков
        }
    }
    return false;  // Не String или разный контент
}

Integer.equals()

// Источник: java/lang/Integer.java
public boolean equals(Object obj) {
    if (obj instanceof Integer) {
        return value == ((Integer)obj).intValue();
    }
    return false;
}

// Очень просто, но соблюдает все правила контракта
// x.equals(x) => true (рефлексивность)
// x.equals(null) => false (null check)

ArrayList.equals()

// Источник: java/util/ArrayList.java
public boolean equals(Object o) {
    if (o == this)  // Рефлексивность: быстрая проверка
        return true;
    if (!(o instanceof List))
        return false;

    ListIterator<E> e1 = listIterator();
    ListIterator<?> e2 = ((List<?>) o).listIterator();
    while (e1.hasNext() && e2.hasNext()) {
        E o1 = e1.next();
        Object o2 = e2.next();
        if (!(o1==null ? o2==null : o1.equals(o2)))
            return false;
    }
    return !(e1.hasNext() || e2.hasNext());
}

Нарушение рефлексивности

Плохой пример

class BrokenClass {
    private int id;
    
    @Override
    public boolean equals(Object o) {
        // ❌ НЕПРАВИЛЬНО: нарушает рефлексивность
        if (o == null) return false;
        if (!(o instanceof BrokenClass)) return false;
        BrokenClass other = (BrokenClass) o;
        return this.id == other.id && !this.equals(this);  // Бесконечная рекурсия!
    }
}

BrokenClass obj = new BrokenClass();
assert obj.equals(obj) == true;  // ❌ Падает в бесконечной рекурсии

Правильный пример

class ProperClass {
    private int id;
    private String name;
    
    @Override
    public boolean equals(Object o) {
        // ✅ Проверка рефлексивности: если это один и тот же объект
        if (this == o) return true;  // Рефлексивность
        
        // ✅ Проверка null
        if (o == null) return false;
        
        // ✅ Проверка типа
        if (!(o instanceof ProperClass)) return false;
        
        // ✅ Сравнение полей
        ProperClass other = (ProperClass) o;
        return this.id == other.id && Objects.equals(this.name, other.name);
    }
    
    @Override
    public int hashCode() {
        return Objects.hash(id, name);
    }
}

ProperClass obj = new ProperClass();
assert obj.equals(obj) == true;  // ✅ Всегда true

Оптимизация через рефлексивность

Проверка рефлексивности используется как оптимизация:

class OptimizedClass {
    @Override
    public boolean equals(Object o) {
        // Быстрая проверка идентичности перед дорогостоящим сравнением
        if (this == o) return true;  // Рефлексивность + оптимизация
        
        // Остальные проверки
        if (o == null || !(o instanceof OptimizedClass)) return false;
        return compareExpensiveFields((OptimizedClass) o);
    }
    
    private boolean compareExpensiveFields(OptimizedClass other) {
        // Дорогостоящее сравнение (например, большие коллекции)
        return this.largeList.equals(other.largeList);
    }
}

Места в коде для проверки

1. IDE (IntelliJ IDEA)

Code → Generate → equals() and hashCode()

Automatic generation соблюдает все правила контракта.

2. Google Guava Library

// В google/common/base/Objects.java
public static boolean equal(@Nullable Object a, @Nullable Object b) {
    return a == b || (a != null && a.equals(b));
}

Соблюдает правило с null.

3. Apache Commons Lang

// org.apache.commons.lang3.builder.EqualsBuilder
new EqualsBuilder()
    .append(this.field1, other.field1)
    .append(this.field2, other.field2)
    .isEquals();

Автоматически обеспечивает все правила.

Тестирование рефлексивности

public class EqualsContractTest {
    @Test
    public void testReflexivity() {
        MyClass obj = new MyClass();
        assertTrue(obj.equals(obj));  // Рефлексивность
    }
    
    @Test
    public void testSymmetry() {
        MyClass a = new MyClass(1);
        MyClass b = new MyClass(1);
        assertEquals(a.equals(b), b.equals(a));  // Симметричность
    }
    
    @Test
    public void testTransitivity() {
        MyClass a = new MyClass(1);
        MyClass b = new MyClass(1);
        MyClass c = new MyClass(1);
        if (a.equals(b) && b.equals(c)) {
            assertTrue(a.equals(c));  // Транзитивность
        }
    }
    
    @Test
    public void testConsistency() {
        MyClass a = new MyClass(1);
        MyClass b = new MyClass(1);
        boolean first = a.equals(b);
        boolean second = a.equals(b);
        assertEquals(first, second);  // Консистентность
    }
    
    @Test
    public void testNullComparison() {
        MyClass a = new MyClass(1);
        assertFalse(a.equals(null));  // null comparison
    }
}

Выводы

1. Описание рефлексивности находится в Javadoc метода Object.equals() (официальная документация Oracle)
2. Пять правил контракта — это обязательные требования при переопределении equals()
3. Рефлексивность часто используется как оптимизация (if (this == o) return true)
4. Нарушение контракта приводит к неправильной работе в Collections и других местах
5. Инструменты (IDE, Google Guava, Apache Commons) помогают автоматически создавать корректные реализации