De Java String klass internera() metod returnerar den internerade strängen. Den returnerar den kanoniska representationen av sträng.

Den kan användas för att returnera sträng från minnet om den skapas av ett nytt nyckelord. Den skapar en exakt kopia av heap-strängobjektet i String Constant Pool.

Signatur

Signaturen för intern()-metoden ges nedan:

 public String intern()  

Returnerar

internt snöre

String.intern()-metodens behov och funktion

När en sträng skapas i Java upptar den minne i högen. Vi vet också att klassen String är oföränderlig. Därför, när vi skapar en sträng med det nya nyckelordet, allokeras nytt minne i högen för motsvarande sträng, vilket är oberoende av innehållet i arrayen. Tänk på följande kodavsnitt.

 String str = new String('Welcome to JavaTpoint.'); String str1 = new String('Welcome to JavaTpoint'); System.out.println(str1 == str); // prints false  

Uttrycket println skrivs ut falskt eftersom separat minne tilldelas för varje strängliteral. Således skapas två nya strängobjekt i minnet, dvs str och str1. som har olika referenser.

Vi vet att att skapa ett objekt är en kostsam operation i Java. Därför, för att spara tid, kom Java-utvecklare på konceptet String Constant Pool (SCP). SCP är ett område inuti heapminnet. Den innehåller de unika strängarna. För att lägga strängarna i strängpoolen måste man ringa till internera() metod. Innan ett objekt skapas i strängpoolen kontrollerar JVM om strängen redan finns i poolen eller inte. Om strängen finns, returneras dess referens.

 String str = new String('Welcome to JavaTpoint').intern(); // statement - 1 String str1 = new String('Welcome to JavaTpoint').intern(); // statement - 2 System.out.println(str1 == str); // prints true  

I ovanstående kodavsnitt anropas intern()-metoden på String-objekten. Därför allokeras minnet i SCP:n. För den andra satsen skapas inget nytt strängobjekt eftersom innehållet i str och str1 är detsamma. Därför returneras referensen för objektet som skapades i den första satsen för str1. Str och str1 pekar alltså båda på samma minne. Därför skrivs det tryckta uttalandet ut sant.

Java String intern() Metodexempel

Filnamn: InternExample.java

 public class InternExample{ public static void main(String args[]){ String s1=new String('hello'); String s2='hello'; String s3=s1.intern();//returns string from pool, now it will be same as s2 System.out.println(s1==s2);//false because reference variables are pointing to different instance System.out.println(s2==s3);//true because reference variables are pointing to same instance }}  

Produktion:

 false true  

Java String intern() Metodexempel 2

Låt oss se ytterligare ett exempel för att förstå strängpraktikkonceptet.

Filnamn: InternExample2.java

 public class InternExample2 { public static void main(String[] args) { String s1 = 'Javatpoint'; String s2 = s1.intern(); String s3 = new String('Javatpoint'); String s4 = s3.intern(); System.out.println(s1==s2); // True System.out.println(s1==s3); // False System.out.println(s1==s4); // True System.out.println(s2==s3); // False System.out.println(s2==s4); // True System.out.println(s3==s4); // False } }  

Produktion:

 true false true false true false  

Punkter att komma ihåg

Följande är några viktiga punkter att komma ihåg angående intern()-metoden:

1) En strängliteral anropar alltid intern()-metoden, oavsett om man nämner intern()-metoden tillsammans med strängen literal eller inte. Till exempel,

 String s = 'd'.intern(); String p = 'd'; // compiler treats it as String p = 'd'.intern(); System.out.println(s == p); // prints true  

2) När vi skapar ett String-objekt med hjälp av ny nyckelord skapas två objekt. Till exempel,

 String str = new ('Hello World');  

Här skapas ett objekt i högminnet utanför SCP på grund av användningen av det nya nyckelordet. Som vi har fått strängen bokstavlig också ('Hello World'); därför skapas ett objekt inuti SCP:n, förutsatt att det bokstavliga 'Hello World' inte redan finns i SCP:n.