Wann sollten wir die interne Methode von String für Stringliterale verwenden?

Java automatisch Praktikanten String-Literale. Dies bedeutet, dass in vielen Fällen der = = - operator wird zu arbeiten für Zeichenfolgen in der gleichen Weise, dass es nicht für ints oder andere primitive Werte.

Da Praktikum erfolgt automatisch für String-Literale, die intern() Methode, die verwendet werden auf Strings konstruiert mit new String()

Mit Ihrem Beispiel:

String s1 = "Rakesh";
String s2 = "Rakesh";
String s3 = "Rakesh".intern();
String s4 = new String("Rakesh");
String s5 = new String("Rakesh").intern();

if ( s1 == s2 ){
    System.out.println("s1 and s2 are same");  //1.
}

if ( s1 == s3 ){
    System.out.println("s1 and s3 are same" );  //2.
}

if ( s1 == s4 ){
    System.out.println("s1 and s4 are same" );  //3.
}

if ( s1 == s5 ){
    System.out.println("s1 and s5 are same" );  //4.
}

zurück:

s1 and s2 are same
s1 and s3 are same
s1 and s5 are same

Finden JavaTechniques "String-Gleichheit und Praktikum" für weitere Informationen.

InformationsquelleAutor der Antwort Miguel Fonseca

Möchte ich hinzufügen, meine 2 cents über die Verwendung == mit Internierten strings.

Das erste, was String.equals tut, ist this==object.

So, obwohl es gibt einige winzige Leistung zu gewinnen ( Sie nicht den Aufruf einer Methode), der von der maintainer-Sicht mit == ist ein Alptraum, weil einige Internierten strings haben eine Tendenz zu nicht-interniert.

Also ich schlage vor, nicht darauf zu verlassen, auf den speziellen Fall der == für die Internierten strings, sondern immer equals als Gosling soll.

EDIT: interniert immer nicht interniert:

V1.0
public class MyClass
{
  private String reference_val;

  ...

  private boolean hasReferenceVal ( final String[] strings )
  {
    for ( String s : strings )
    {
      if ( s == reference_val )
      {
        return true;
      }
    }

    return false;
  }

  private void makeCall ( )
  {
     final String[] interned_strings =  { ... init with interned values ... };

     if ( hasReference( interned_strings ) )
     {
        ...
     }
  }
}

In der version 2.0 Betreuers entschieden hasReferenceVal öffentlichkeit, ohne dabei zu weit ins detail, dass es erwartet ein array von strings interniert.

V2.0
public class MyClass
{
  private String reference_val;

  ...

  public boolean hasReferenceVal ( final String[] strings )
  {
    for ( String s : strings )
    {
      if ( s == reference_val )
      {
        return true;
      }
    }

    return false;
  }

  private void makeCall ( )
  {
     final String[] interned_strings =  { ... init with interned values ... };

     if ( hasReference( interned_strings ) )
     {
        ...
     }
  }
}

Nun haben Sie einen bug, der möglicherweise sehr schwer zu finden, weil in der Mehrheit der Fälle array enthält Literale Werte, und manchmal ist ein nicht-literalen Zeichenfolge verwendet. Wenn equals verwendet wurden anstelle von == dann hasReferenceVal haben würde, noch weiter zu arbeiten. Wieder einmal, performance-Gewinn ist verschwindend klein, aber die Instandhaltungskosten sind hoch.

InformationsquelleAutor der Antwort Alexander Pogrebnyak

sollten Sie sich beiden Zeit, die compile-Zeit und Laufzeit-Zeit.zum Beispiel:

//example 1 
"test" == "test" //--> true 
"test" == "te" + "st" //--> true

//example 2 
"test" == "!test".substring(1) //--> false
"test" == "!test".substring(1).intern() //--> true

in der einen hand,im Beispiel 1,die wir finden, die Ergebnisse sind alle true zurück,da in der compile-Zeit der jvm wird der "test", um den pool von literalen strings verwendet werden,wenn die jvm finden "test" vorhanden ist,dann wird es die existiert,im Beispiel 1,der "test" - Saiten sind alle auf den gleichen Speicher-Adresse,so dass das Beispiel 1 wird true zurückgegeben.
in der anderen hand,im Beispiel 2,die Methode substring() ausführen, in der Laufzeit, Uhrzeit,
im Fall von "test" == "!testen".substring(1),der pool wird erstellen Sie zwei string-Objekt,"test"
und "!test",so dass Sie verschiedene Referenz-Objekte,also in diesem Fall den Wert false zurück,im Fall von "test" == "!testen".substring(1).intern(),die Methode intern () "setzen Sie die""!testen".substring(1)", um den pool von literal-Zeichenfolgen,so dass in diesem Fall,Sie sind die gleichen Objekte referenziert,so wird true zurückgegeben.

InformationsquelleAutor der Antwort thinkinjava

Interniert Saiten vermeiden Sie doppelte Strings. Praktikum spart RAM auf Kosten von mehr CPU-Zeit zu erkennen und ersetzen, doppelte Strings. Es ist nur eine Kopie von jedem String, der wurde interniert, egal wie viele Referenzen verweisen. Da Zeichenfolgen unveränderlich sind, wenn zwei verschiedene Methoden übrigens verwenden Sie denselben String, können Sie eine Kopie der gleichen Zeichenfolge. Der Prozess der Umwandlung von Zeichenketten dupliziert, um gemeinsame diejenigen genannt wird Praktikum.String.Praktikant (in) gibt Sie die Adresse des kanonischen master-String. Vergleichen Sie interniert Strings mit einfachen == (vergleicht Zeiger) statt gleich vergleicht die Zeichen des Strings einzeln. Da Zeichenfolgen unveränderlich sind, die intern Prozess ist frei, um weiteren Speicherplatz zu sparen, zum Beispiel, indem Sie nicht die Schaffung eines separaten String-literal für "Topf", wenn es existiert, als ein substring von einigen anderen literal wie "Nilpferd".

Mehr zu sehen http://mindprod.com/jgloss/interned.html

InformationsquelleAutor der Antwort inter18099

String p1 = "example";
String p2 = "example";
String p3 = "example".intern();
String p4 = p2.intern();
String p5 = new String(p3);
String p6 = new String("example");
String p7 = p6.intern();

if (p1 == p2)
    System.out.println("p1 and p2 are the same");
if (p1 == p3)
    System.out.println("p1 and p3 are the same");
if (p1 == p4)
    System.out.println("p1 and p4 are the same");
if (p1 == p5)
    System.out.println("p1 and p5 are the same");
if (p1 == p6)
    System.out.println("p1 and p6 are the same");
if (p1 == p6.intern())
    System.out.println("p1 and p6 are the same when intern is used");
if (p1 == p7)
    System.out.println("p1 and p7 are the same");

Wenn zwei Zeichenfolgen erstellt werden, unabhängig intern() können Sie Sie miteinander vergleichen und auch hilft es, Sie beim erstellen einer Referenz in die string-pool, wenn die Referenz vorher nicht existiert haben.

Wenn Sie String s = new String(hi) java erstellt eine neue Instanz von string, aber wenn Sie String s = "hi" java prüft, ob es eine Instanz von word "Hallo" im code oder nicht, und wenn es existiert, es gibt nur die Referenz.

Da vergleichen von Zeichenfolgen basiert auf Referenz intern() hilft, erstellen Sie eine Referenz und können Sie vergleichen den Inhalt des strings.

Wenn Sie intern() im code, löscht es den Platz, der von der saite auf dasselbe Objekt verweisen und nur die Renditen der Verweis auf die bereits bestehenden dasselbe Objekt im Speicher.

Aber im Fall von p5, wenn Sie:

String p5 = new String(p3);

Nur die Inhalte p3 kopiert werden und p5 neu geschaffen wird. So ist es nicht interniert.

So ist die Ausgabe:

p1 and p2 are the same
p1 and p3 are the same
p1 and p4 are the same
p1 and p6 are the same when intern is used
p1 and p7 are the same

InformationsquelleAutor der Antwort raja emani

Warum nicht auch string-Literale verwendet werden, in den Orten, wo intern ist requried zu verwenden?
String-literal Verwendung standardmäßig wird die Wiederverwendung der vorhandenen string-Literale.
Warum also brauchen wir erstellen new String("etwas").intern() statt nur die Zuordnung "etwas" ?

InformationsquelleAutor der Antwort user2861409

Als Sie sagte, dass string intern() Methode wird zuerst aus dem String-pool, wenn es findet, dann wird es das Objekt zurückgeben, dass die Punkte an, oder fügen Sie einen neuen String in den pool.

    String s1 = "Hello";
    String s2 = "Hello";
    String s3 = "Hello".intern();
    String s4 = new String("Hello");

    System.out.println(s1 == s2);//true
    System.out.println(s1 == s3);//true
    System.out.println(s1 == s4.intern());//true

Den s1 und s2 sind zwei Objekten zeigt auf den String-pool "Hallo", und mit "Hello".intern() finden, dass s1 und s2. So "s1 == s3" gibt true zurück, sowie auf die s3.intern().

InformationsquelleAutor der Antwort WendellWu