Какой знаешь способ присвоить строке значение из String Pool?

# String Pool v Java

Chto takoe String Pool?

String Pool — spetsialnaya oblast pamyati v Java (v Heap), gde hranyatsya strokovy literaly. Java optimiziruet ispolzovanie pamyati, sohranyaya odnu kopiyu kazhdoy unikalnoj stroki.

Sposob 1: Strokovyj literal (samyj prostoj)

Eto samyj prostoj i effektivnyj sposob. Stroki, sozdavaemye napryamuyu kak literaly, avtomaticheski pomeshchayutsya v String Pool.

String str1 = "Hello";      // V String Pool
String str2 = "Hello";      // Pereispolzuetsya iz Pool

System.out.println(str1 == str2);      // true
System.out.println(str1.equals(str2)); // true

String str3 = new String("Hello");     // V Heap, vne Pool
System.out.println(str1 == str3);      // false
System.out.println(str1.equals(str3)); // true

Sposob 2: Metod intern()

Metod intern() yavno dobavlyaet stroku v String Pool ili vozvrashchaet ssilku na sushchestvuyushchuyu stroku iz Pool.

String str1 = new String("Hello");     // Vne Pool
String str2 = "Hello";                 // Iz Pool

System.out.println(str1 == str2);      // false

String str1Interned = str1.intern();   // Dobavlyaet v Pool

System.out.println(str1Interned == str2); // true!
System.out.println(str1 == str2);         // false

Prakticheskij primer s intern()

public class StringPoolExample {
    public static void main(String[] args) {
        String dynamicString = "Hello" + " " + "World";
        String literal = "Hello World";
        
        System.out.println(dynamicString == literal);       // false
        System.out.println(dynamicString.equals(literal));  // true
        
        String interned = dynamicString.intern();
        System.out.println(interned == literal);            // true!
    }
}

Sposob 3: Konkatenaciya s literalami

Esli konkatenirovat tolko literaly, rezultat srazhu popadaet v Pool (na etape kompilyacii).

String str1 = "Hello" + " " + "World";  // V Pool (kompilacija)
String str2 = "Hello World";             // Iz Pool

System.out.println(str1 == str2);      // true!

String word = "Hello";
String str3 = word + " World";          // Vne Pool (runtime)
System.out.println(str3 == str2);      // false

Sposob 4: StringBuilder + intern()

Kogda stroka formiruetsya dinamicheski, mozhno ispolzovat StringBuilder i zatem intern().

public class DynamicStringExample {
    public static void main(String[] args) {
        String[] words = {"Java", "is", "awesome"};
        
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < words.length; i++) {
            sb.append(words[i]);
            if (i < words.length - 1) {
                sb.append(" ");
            }
        }
        
        String result = sb.toString();      // Vne Pool
        String pooled = result.intern();    // V Pool
        
        String literal = "Java is awesome";
        System.out.println(pooled == literal);  // true
    }
}

Kak rabotaet String Pool vnutri

public class StringInternExample {
    private static Map<String, String> pool = new HashMap<>();
    
    public static String myIntern(String str) {
        if (pool.containsKey(str)) {
            return pool.get(str);
        }
        pool.put(str, str);
        return str;
    }
    
    public static void main(String[] args) {
        String str1 = new String("Hello");
        String str2 = new String("Hello");
        
        System.out.println(str1 == str2);           // false
        
        String interned1 = myIntern(str1);
        String interned2 = myIntern(str2);
        
        System.out.println(interned1 == interned2); // true
    }
}

Prakticheskij primer optimizaciya

public class StringOptimization {
    private static final Map<String, String> cache = new HashMap<>();
    
    public static String getCachedString(String str) {
        return cache.computeIfAbsent(str, String::intern);
    }
    
    public static void main(String[] args) {
        for (int i = 0; i < 1000; i++) {
            String dynamicStr = "String-" + (i % 10);
            String cached = getCachedString(dynamicStr);
        }
    }
}

Sravnenie sposobov

Vazhnye zamechaniya

Ok Strokovy literaly avtomaticheski dobavlyayutsya v Pool Ok intern() dobavlyaet stroku v Pool ili vozvrashchaet sushchestvuyushchuyu Ok Pool hranietsya v Heap (v Java 7+)

Ok == sravnivaet ssilki, .equals() sravnivaet znacheniya

Ok Izbytochnoe ispolzovanie intern() mozhet zamedellit programmu

Kogda izbegat intern()

Ne ispolzuj dlya ochen bolshih strok Ne ispolzuj dlya strok iz vneshnikh istochnikov Ne ispolzuj esli ne nuzhna optimizaciya Ne ispolzuj esli stroki sozdayutsya odnorazovo

Ispolzuj intern() tolko dlya strok, kotorye chasto povtoryayutsya