რატომ არის შეუცვლელობა პროგრამირებაში ასე მნიშვნელოვანი?

იმმუტაბელობა უზრუნველყოფს რიგ უპირატესობებს:

• უსაფრთხოება მრავალთრედიან გარემოში: არამოყვანილი ობიექტები შეიძლება უსაფრთხოდ გაიყოს თრედებს შორის სინქრონიზაციის ან ბლოკირების საჭიროების გარეშე, რაც ამარტივებს მრავალთრედიანი პროგრამების განვითარებას და თავიდან აცილებს მონაცემთა შეჯახებებს.
• განსაზღვრულობა: არამოყვანილი ობიექტის მდგომარეობა არასდროს იცვლება შექმნის შემდეგ. ეს ამარტივებს მონაცემთა ნაკადის გაგებას პროგრამაში და შეცდომების გამოსწორებას, რადგან იცით ზუსტად, რომ ობიექტი არ შეიცვლება მოულოდნელად.
• კეშირება და მემოიზაცია: არამოყვანილი ობიექტები ადვილად კეშდება. თუ ორი ობიექტი თანხვედრაშია (equals), მათი ჰეშ-კოდები ყოველთვის იქნება ერთნაირი (შესაბამისად, hashCode სწორად განხორციელებული უნდა იყოს), და მათი მდგომარეობა არ შეიცვლება, რაც საშუალებას იძლევა უსაფრთხოდ გამოიყენოთ გამოთვლილი შედეგები მეორედ.
• დიზაინის გამარტივება: გამოყენებით არამოყვანილ ობიექტებს, კოდი უფრო მოდულური და გასაგებია. ფუნქციები, რომლებიც იღებენ და აბრუნებენ არამოყვანილ ობიექტებს, სუფთაა და არ აქვს გვერდითი ეფექტები.
• შესაძლოა შესრულების გაუმჯობესება ზოგიერთ შემთხვევებში: მიუხედავად იმისა, რომ ახალი ობიექტის შექმნა ყოველ ცვლილებაზე შეიძლება იყოს ნაკლებეფექტიანი, JVM-ის გროვის აგროვებელი ოპტიმიზირებულია მუშაობისთვის დიდი რაოდენობით მოკლევადიანი ობიექტებით, და ბლოკირების არარსებობა მრავალთრედიან გარემოში შეიძლება კომპენსიროს ხარჯები.

მაგალითი არამოყვანილი კლასის შექმნის:

public final class ImmutableClass {

    private final int value;
    private final String name;

    public ImmutableClass(int value, String name) {
        this.value = value;
        this.name = name;
    }

    public int getValue() {
        return value;
    }

    public String getName() {
        return name;
    }

    // სეტერები არ არის
    // ფილდერები final
    // კლასი final
    // ყველა ფილი არის პრიმიტიული ან სხვა არამოყვანილი ობიექტი,
    // ან აბრუნებს შეცვლად ობიექტების კოპიებს საჭიროების შემთხვევაში (აქ არაა)

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        ImmutableClass that = (ImmutableClass) o;
        if (value != that.value) return false;
        return name != null ? name.equals(that.name) : that.name == null;
    }

    @Override
    public int hashCode() {
        int result = value;
        result = 31 * result + (name != null ? name.hashCode() : 0);
        return result;
    }
}