De acordo com a String # intern () , o internmétodo deve retornar a String do pool de String se a String for encontrada no pool de String, caso contrário, um novo objeto de string será adicionado ao pool de String e a referência dessa String será retornada.

Então eu tentei isso:

String s1 = "Rakesh";
String s2 = "Rakesh";
String s3 = "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.
}

Eu esperava que s1 and s3 are samefosse impresso como s3 está internado e s1 and s2 are samenão será impresso. Mas o resultado é: ambas as linhas são impressas. Portanto, isso significa que, por padrão, as constantes String são internadas. Mas, se é assim, por que precisamos do internmétodo? Em outras palavras, quando devemos usar esse método?

Java internamente automaticamente literais de String. Isso significa que, em muitos casos, o operador == parece funcionar para Strings da mesma maneira que para ints ou outros valores primitivos.

Como a internação é automática para literais de String, o intern()método deve ser usado em Strings construídas comnew String()

Usando seu exemplo:

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.
}

retornará:

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

Em todos os casos, além da s4variável, cujo valor foi criado explicitamente usando o newoperador e onde o internmétodo não foi usado no resultado, é uma única instância imutável que está sendo retornada pelo conjunto constante de cadeias da JVM .

Consulte JavaTechniques "String Equality and Interning" para obter mais informações.

Em um projeto recente, algumas estruturas de dados enormes foram configuradas com dados lidos em um banco de dados (e, portanto, não constantes / literais de String), mas com uma enorme quantidade de duplicação. Era um aplicativo bancário, e coisas como os nomes de um conjunto modesto (talvez 100 ou 200) corporações apareciam em todo lugar. As estruturas de dados já eram grandes e, se todos esses nomes de corp tivessem sido objetos únicos, eles teriam excedido a memória. Em vez disso, todas as estruturas de dados tinham referências aos mesmos objetos de 100 ou 200 String, economizando muito espaço.

Outra pequena vantagem das Strings internas é que ==elas podem ser usadas (com sucesso!) Para comparar Strings, se todas as strings envolvidas tiverem a garantia de serem internadas. Além da sintaxe mais enxuta, isso também é um aprimoramento de desempenho. Mas, como outros já apontaram, isso acarreta um grande risco de introdução de erros de programação; portanto, isso deve ser feito apenas como uma medida desesperada de último recurso.

A desvantagem é que a internação de uma String leva mais tempo do que simplesmente jogá-la na pilha e que o espaço para as Strings internas pode ser limitado, dependendo da implementação do Java. É melhor fazer isso quando você lida com um número razoável conhecido de Strings com muitas duplicações.

Quero adicionar meus 2 centavos no uso ==com seqüências de caracteres internas.

A primeira coisa que String.equalsfaz é this==object.

Portanto, embora haja algum ganho minúsculo de desempenho (você não está chamando um método), do ponto de vista do mantenedor, o uso ==é um pesadelo, porque algumas seqüências de caracteres internas tendem a se tornar não-internas.

Portanto, sugiro não confiar no caso especial de ==para seqüências de caracteres internas, mas sempre use equalscomo Gosling pretendia.

EDIT: internado tornando-se não internado:

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 ) )
     {
        ...
     }
  }
}

Na versão 2.0, o mantenedor decidiu tornar hasReferenceValpúblico, sem entrar em muitos detalhes, que espera uma matriz de seqüências internas.

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 ) )
     {
        ...
     }
  }
}

Agora você tem um bug, que pode ser muito difícil de encontrar, porque na maioria dos casos a matriz contém valores literais e, às vezes, uma string não literal é usada. Se equalsfosse usado em vez de ==, hasReferenceValcontinuaria funcionando. Mais uma vez, o ganho de desempenho é minúsculo, mas o custo de manutenção é alto.

Literais e constantes de string são internados por padrão. Ou seja, "foo" == "foo"(declarado pelos literais String), mas new String("foo") != new String("foo").

Aprenda Java String Intern - uma vez por todas

Strings em java são objetos imutáveis ​​por design. Portanto, dois objetos de sequência, mesmo com o mesmo valor, serão objetos diferentes por padrão. No entanto, se desejarmos economizar memória, poderemos indicar o uso da mesma memória por um conceito chamado string intern.

As regras abaixo ajudarão você a entender o conceito em termos claros:

1. A classe String mantém um pool interno que está inicialmente vazio. Esse pool deve garantir a conter objetos de sequência com apenas valores exclusivos.
2. Todos os literais de cadeia de caracteres com o mesmo valor devem ser considerados o mesmo objeto de local de memória porque, de outra forma, não têm noção de distinção. Portanto, todos esses literais com o mesmo valor criarão uma única entrada no pool interno e se referirão ao mesmo local da memória.
3. A concatenação de dois ou mais literais também é literal. (Portanto, a regra nº 2 será aplicável a eles)
4. Cada string criada como objeto (ou seja, por qualquer outro método, exceto como literal) terá diferentes locais de memória e não fará nenhuma entrada no pool interno
5. A concatenação de literais com não literais fará com que não seja literal. Assim, o objeto resultante terá um novo local de memória e NÃO fará uma entrada no pool interno.
6. A chamada do método interno em um objeto de cadeia de caracteres cria um novo objeto que entra no conjunto interno ou retorna um objeto existente do conjunto que tem o mesmo valor. A invocação em qualquer objeto que não esteja no pool interno NÃO move o objeto para o pool. Em vez disso, cria outro objeto que entra no pool.

Exemplo:

String s1=new String (“abc”);
String s2=new String (“abc”);
If (s1==s2)  //would return false  by rule #4
If (“abc” == “a”+”bc” )  //would return true by rules #2 and #3
If (“abc” == s1 )  //would return false  by rules #1,2 and #4
If (“abc” == s1.intern() )  //would return true  by rules #1,2,4 and #6
If ( s1 == s2.intern() )      //wound return false by rules #1,4, and #6

Nota: Os casos motivacionais para estagiário de string não são discutidos aqui. No entanto, a economia de memória será definitivamente um dos objetivos principais.

você deve distinguir dois períodos de tempo, que são tempo de compilação e tempo de execução. por exemplo:

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

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

por um lado, no exemplo 1, descobrimos que todos os resultados são retornados verdadeiros, pois, no tempo de compilação, a jvm colocará o "teste" no conjunto de cadeias literais, se a jvm find "test" existir, então ele usará o existente, no exemplo 1, as seqüências de "teste" são todas apontadas para o mesmo endereço de memória, portanto o exemplo 1 retornará verdadeiro. por outro lado, no exemplo 2, o método de substring () é executado no tempo de execução, no caso de "test" == "! test" .substring (1), o pool criará dois objetos de string " test "e"! test ", portanto, são objetos de referência diferentes; portanto, este caso retornará false, no caso de" test "=="! test ".substring (1) .intern (), o método intern ( ) colocará ""! test ".substring (1)" no pool de cadeias literais,

http://en.wikipedia.org/wiki/String_interning

o interning de string é um método de armazenar apenas uma cópia de cada valor distinto de string, que deve ser imutável. As cadeias internas tornam algumas tarefas de processamento de cadeias mais eficientes em termos de tempo ou espaço, exigindo mais tempo quando a cadeia é criada ou internada. Os valores distintos são armazenados em um conjunto interno de cadeias.

Strings Internas evitam Strings duplicadas. Internar economiza RAM às custas de mais tempo de CPU para detectar e substituir seqüências de caracteres duplicadas. Há apenas uma cópia de cada String que foi internada, não importa quantas referências apontem para ela. Como Strings são imutáveis, se dois métodos diferentes usam acidentalmente a mesma String, eles podem compartilhar uma cópia da mesma String. O processo de conversão de Strings duplicadas em compartilhadas é chamado interning.String.intern () fornece o endereço da String canônica principal. Você pode comparar Strings internadas com simple == (que compara ponteiros) em vez de iguaisque compara os caracteres da String, um por um. Como Strings são imutáveis, o processo interno é livre para economizar espaço, por exemplo, não criando um literal String separado para "pot" quando ele existe como uma substring de algum outro literal, como "hippopotamus".

Para ver mais http://mindprod.com/jgloss/interned.html

String s1 = "Anish";
        String s2 = "Anish";

        String s3 = new String("Anish");

        /*
         * When the intern method is invoked, if the pool already contains a
         * string equal to this String object as determined by the
         * method, then the string from the pool is
         * returned. Otherwise, this String object is added to the
         * pool and a reference to this String object is returned.
         */
        String s4 = new String("Anish").intern();
        if (s1 == s2) {
            System.out.println("s1 and s2 are same");
        }

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

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

RESULTADO

s1 and s2 are same
s1 and s4 are same

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");

Quando duas strings são criadas independentemente, intern()permite compará-las e também ajuda na criação de uma referência no pool de strings, se a referência não existia antes.

Quando você usa String s = new String(hi), o java cria uma nova instância da string, mas quando você usa String s = "hi", o java verifica se há uma instância da palavra "oi" no código ou não e, se existir, apenas retorna a referência.

Como a comparação de strings é baseada em referência, intern()ajuda na criação de uma referência e permite comparar o conteúdo das strings.

Quando você usa intern()o código, ele limpa o espaço usado pela string referente ao mesmo objeto e apenas retorna a referência do mesmo objeto já existente na memória.

Mas no caso de p5 quando você estiver usando:

String p5 = new String(p3);

Somente o conteúdo de p3 é copiado e p5 é criado recentemente. Portanto, não é internado .

Portanto, a saída será:

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

    public static void main(String[] args) {
    // TODO Auto-generated method stub
    String s1 = "test";
    String s2 = new String("test");
    System.out.println(s1==s2);              //false
    System.out.println(s1==s2.intern());    //true --> because this time compiler is checking from string constant pool.
}

O método string intern () é usado para criar uma cópia exata do objeto string do heap no pool constante de strings. Os objetos de cadeia no conjunto constante de cadeias são internados automaticamente, mas os objetos de cadeia na pilha não são. O principal uso da criação de estagiários é economizar espaço de memória e realizar uma comparação mais rápida de objetos de sequência.

Fonte: O que é string intern em java?

Como você disse, esse intern()método de string primeiro encontrará no pool de String, se encontrar, retornará o objeto que aponta para ele ou adicionará uma nova String ao 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

O s1e s2dois objetos que apontam para a piscina String "Olá", e usando "Hello".intern()vai achar que s1e s2. Então "s1 == s3"retorna true, bem como para o s3.intern().

Usando a referência de objeto de heap, se queremos obter a referência de objeto de pool constante de string correspondente , devemos procurar intern ()

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

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

Vista pictórica

Etapa 1: o objeto com dados 'Rakesh' é criado no pool constante de heap e string. Também s1 está sempre apontando para o objeto heap.

Etapa 2: usando a referência de objeto de pilha s1, estamos tentando obter a referência de objeto de pool constante de string correspondente s2, usando intern ()

Etapa 3: criar intencionalmente um objeto com dados 'Rakesh' no pool constante de strings, referenciado pelo nome s3

Como operador "==" destinado à comparação de referência.

Ficando falso para s1 == s2

Obtendo a verdade para s2 == s3

Espero que esta ajuda!