В чем разница между строкой и кастомным объектом?

Разница между строкой (String) и кастомным объектом в Java

Это различие затрагивает фундаментальные аспекты: как работает память, какие операции доступны, и как объекты ведут себя в системе. String в Java - это специальный встроенный класс с особым статусом.

String - встроенный класс

String - это финальный класс в пакете java.lang, который обрабатывается JVM как особый тип.

public final class String implements Serializable, Comparable<String>, CharSequence {
    // String - финальный класс, нельзя наследоваться
    // Содержит массив char (или byte в Java 9+)
    private final char[] value;
    
    // НЕИЗМЕНЯЕМ (immutable) - это ключевое свойство
}

// Кастомный объект
public class User {
    private String name;
    private int age;  // может быть изменяемым
    
    public void setName(String newName) {
        this.name = newName;  // объект может быть изменен
    }
}

Неизменяемость (Immutability)

String - это неизменяемый класс. После создания String его нельзя изменить. Это главное отличие:

public class ImmutabilityExample {
    public static void main(String[] args) {
        // String
        String str = "Hello";
        str = str + " World";  // НЕ изменяет исходный String
        // Создается НОВЫЙ String объект
        // Старый "Hello" остается неизменным
        
        // Кастомный объект
        class MutableString {
            private String value;
            
            public void append(String text) {
                this.value += text;  // ИЗМЕНЯЕТ сам объект
            }
        }
        
        MutableString ms = new MutableString();
        ms.value = "Hello";
        ms.append(" World");  // Изменил исходный объект
    }
}

String Pool (String буквы в памяти)

Java имеет специальное место в памяти - String Pool (не в heap), где хранятся строковые литералы.

public class StringPoolExample {
    public static void main(String[] args) {
        // String литералы идут в String Pool
        String s1 = "Hello";      // Создается в String Pool
        String s2 = "Hello";      // Указывает на ТОТ ЖЕ объект в Pool
        System.out.println(s1 == s2);  // true! (одна ссылка)
        
        // String через new идет в heap
        String s3 = new String("Hello");  // В heap (отдельный объект)
        String s4 = new String("Hello");  // ЕЩЕ ОДИН объект в heap
        System.out.println(s3 == s4);     // false (разные ссылки)
        System.out.println(s3.equals(s4)); // true (одинаковое содержимое)
        
        // Кастомные объекты НЕ идут в String Pool
        User u1 = new User("John", 30);
        User u2 = new User("John", 30);
        System.out.println(u1 == u2);      // false (разные объекты)
        System.out.println(u1.equals(u2)); // false (equals не переопределен)
    }
}

Эффективность памяти

String оптимизирован на уровне JVM:

public class MemoryEfficiency {
    public static void main(String[] args) {
        // String конкатенация компилируется в StringBuilder
        String str = "Hello" + " " + "World";  // Оптимизируется
        // Эквивалент:
        // StringBuilder sb = new StringBuilder();
        // sb.append("Hello").append(" ").append("World");
        // str = sb.toString();
        
        // Кастомный объект требует явного использования StringBuilder
        class MyString {
            private char[] value;
            
            public MyString concatenate(String other) {
                // Нужно вручную управлять памятью
                char[] newValue = new char[value.length + other.length()];
                System.arraycopy(value, 0, newValue, 0, value.length);
                // ...
                return this;
            }
        }
    }
}

Встроенные методы

String имеет масс специальных встроенных методов, оптимизированных на уровне JVM:

public class StringMethods {
    public static void main(String[] args) {
        String str = "Hello World";
        
        // Встроенные методы (очень эффективные)
        str.length();          // Специальный метод (быстро)
        str.charAt(0);         // Доступ к символу (быстро)
        str.substring(0, 5);   // Подстрока
        str.contains("World"); // Поиск
        str.split(" ");        // Разбиение
        str.replaceAll("o", "0"); // Замена
        str.toUpperCase();     // В верхний регистр
        str.toLowerCase();     // В нижний регистр
        str.trim();            // Удаление пробелов
        
        // Кастомный объект требует всего писать самостоятельно
        class MyString {
            private char[] value;
            
            public int length() {
                return value.length;  // Нужно самому реализовать
            }
            
            public char charAt(int index) {
                return value[index];  // Нужно самому реализовать
            }
        }
    }
}

Хэширование и сравнение

String оптимизирован для использования в Collections и HashMap:

public class HashingExample {
    public static void main(String[] args) {
        // String хэш вычисляется один раз и кэшируется
        String str = "Hello";
        int hash1 = str.hashCode();  // Вычисляется
        int hash2 = str.hashCode();  // Возвращается кэшированное значение
        
        // String часто используется как ключ в HashMap
        Map<String, Integer> map = new HashMap<>();
        map.put("key", 1);  // Очень часто используется
        map.get("key");     // Быстро находит
        
        // Кастомный объект требует реализации hashCode и equals
        class User {
            private String name;
            private int age;
            
            @Override
            public int hashCode() {
                return Objects.hash(name, age);  // Нужно самому реализовать
            }
            
            @Override
            public boolean equals(Object obj) {
                // Нужно самому реализовать
                if (this == obj) return true;
                if (obj == null) return false;
                if (getClass() != obj.getClass()) return false;
                User other = (User) obj;
                return name.equals(other.name) && age == other.age;
            }
        }
    }
}

Потокобезопасность

String - потокобезопасный (thread-safe) благодаря неизменяемости:

public class ThreadSafetyExample {
    public static void main(String[] args) {
        // String безопасно передавать между потоками
        String str = "Hello";
        
        // Поток 1
        new Thread(() -> {
            System.out.println(str);  // Безопасно! Не может измениться
        }).start();
        
        // Поток 2
        new Thread(() -> {
            System.out.println(str);  // Безопасно! Не может измениться
        }).start();
        
        // Кастомный объект требует синхронизации
        class MutableObject {
            private String value = "initial";
            
            // Нужна синхронизация
            public synchronized void setValue(String newValue) {
                this.value = newValue;
            }
            
            public synchronized String getValue() {
                return value;
            }
        }
    }
}

Практический пример

public class ComparisonExample {
    static class User {
        String name;
        int age;
        
        User(String name, int age) {
            this.name = name;
            this.age = age;
        }
    }
    
    public static void main(String[] args) {
        // String
        String s1 = "John";
        String s2 = s1;  // Указывает на тот же объект
        s2 = s2 + " Doe";  // Создает НОВЫЙ String
        System.out.println(s1);  // John (не изменился)
        System.out.println(s2);  // John Doe
        
        // User
        User u1 = new User("John", 30);
        User u2 = u1;  // Указывает на тот же объект
        u2.name = u2.name + " Doe";  // ИЗМЕНЯЕТ исходный объект
        System.out.println(u1.name);  // John Doe (изменился!)
        System.out.println(u2.name);  // John Doe
    }
}

Резюме

String - это специальный встроенный класс с особыми свойствами и оптимизациями на уровне JVM.