学习Java字符串实习生 - 一劳永逸

Question

根据String#intern()，如果在String池中找到String，则intern方法应该从String池返回String，否则将在String池和引用中添加新的字符串对象返回此String。

所以我试过这个：

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

我原本期望在{s}被关闭时打印s1 and s3 are same，并且不会打印s1 and s2 are same。但结果是：两行都打印出来。这意味着，默认情况下，字符串常量被实现。但如果是这样，那么为什么我们需要intern方法呢？换句话说，我们何时应该使用这种方法？

Answer 1

Java自动实习字符串文字。这意味着在许多情况下，==运算符似乎适用于字符串，就像它对整数或其他原始值一样。

由于对于字符串文字是自动的，因此intern()方法将用于使用new String()构建的字符串

使用您的示例：

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

将返回：

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

有关详细信息，请参阅JavaTechniques "String Equality and Interning"。

Answer 2

在最近的一个项目中，一些庞大的数据结构被设置为从数据库读入的数据（因此不是字符串常量/文字），但是有大量的重复。这是一个银行应用程序，像一个适度的集（可能是100或200）公司的名称似乎到处都是。数据结构已经很大，如果所有这些公司名称都是唯一的对象，那么它们就会溢出内存。相反，所有数据结构都引用了相同的100或200个String对象，从而节省了大量空间。

实习字符串的另一个小优点是==可以使用（成功！）来比较字符串，如果所有涉及的字符串都保证被实现。除了更精简的语法之外，这也是性能增强。但正如其他人所指出的那样，这样做会带来引入编程错误的巨大风险，所以这应该只是作为最后的绝对手段来实现。

缺点是，实际执行String需要花费更多时间而不是简单地将其抛出到堆上，并且可能会限制实习字符串的空间，具体取决于Java实现。当您处理已知合理数量的字符串并且有许多重复时，最好这样做。

Answer 3

我希望在使用==加上实习字符串时增加2美分。

String.equals做的第一件事是this==object。

因此虽然有一些微不足道的性能提升（你没有调用方法），但从维护者角度来看，使用==是一场噩梦，因为一些实习字符串倾向于变成非实习。 / p>

因此，我建议不要依赖==的特殊情况作为实习字符串，但始终使用equals作为Gosling的意图。

编辑：实习成为非实习生：

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

在版本2.0中，维护者决定公开hasReferenceVal，而没有详细说明它需要一个实体字符串数组。

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

现在您有一个可能很难找到的错误，因为在大多数情况下，数组包含文字值，有时使用非文字字符串。如果使用equals代替==，那么hasReferenceVal仍将继续有效。再一次，性能提升微乎其微，但维护成本很高。

Answer 4

默认情况下，字符串文字和常量是固定的。也就是说，"foo" == "foo"（由字符串文字声明），但是new String("foo") != new String("foo")。

Answer 5

学习Java字符串实习生 - 一劳永逸

java中的字符串是设计中的不可变对象。因此，默认情况下，两个具有相同值的字符串对象将是不同的对象。但是，如果我们希望节省内存，我们可以通过一个名为字符串实习的概念来指示使用相同的内存。

以下规则将帮助您以明确的术语理解该概念：

String类维护一个最初为空的intern-pool。此池必须保证包含仅具有唯一值的字符串对象。
具有相同值的所有字符串文字必须被视为相同的内存位置对象，因为它们没有区别的概念。因此，具有相同值的所有此类文字将在内部池中生成单个条目，并将引用相同的内存位置。
两个或多个文字的连接也是文字。（因此规则＃2将适用于他们）
作为对象创建的每个字符串（即除了文字之外的任何其他方法）将具有不同的内存位置，并且不会在intern-pool中创建任何条目
文字与非文字的连接将使非文字。因此，结果对象将具有新的内存位置，并且不会在内部池中创建条目。
在字符串对象上调用intern方法，或者创建一个进入内部池的新对象，或者从池中返回具有相同值的现有对象。对不在intern-pool中的任何对象的调用不会将对象移动到池中。它创建了另一个进入池的对象。

示例：

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

注意：此处不讨论字符串实习生的动机案例。但是，节省内存肯定是主要目标之一。

Answer 6

你应该计算两个周期时间，即编译时间和运行时间。例如：

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

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

一方面，在示例1中，我们发现结果都返回true，因为在编译时，jvm会将＆＃34; test＆＃34;到文字字符串池，如果jvm找到＆＃34; test＆＃34;存在，然后它将使用存在的，在例1中，＆＃34;测试＆＃34;字符串都指向相同的内存地址，因此示例1将返回true。另一方面，在示例2中，substring（）的方法在运行时间内执行，在＆＃34; test＆＃34;的情况下==＆＃34;！test＆＃34; .substring（1），池将创建两个字符串对象，＆＃34; test＆＃34; 和＆＃34;！test＆＃34;，所以它们是不同的引用对象，所以这种情况将返回false，在＆＃34; test＆＃34; ==＆＃34;！test＆＃34; .substring（1）.intern（），intern（）的方法将放置＆＃34;＆＃34;！test＆＃34; .substring（1）＆＃ 34;到文字字符串池，所以在这种情况下，它们是相同的引用对象，因此将返回true。

Answer 7

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

string interning是一种只存储每个不同字符串值的一个副本的方法，该值必须是不可变的。实习字符串使得一些字符串处理任务更加节省时间或空间，代价是在创建或实现字符串时需要更多时间。不同的值存储在字符串实习池中。

Answer 8

Interned Strings避免重复字符串。实习以节省更多CPU时间来节省RAM，以检测和替换重复的字符串。每个字符串只有一个被复制的副本，无论有多少引用都指向它。由于字符串是不可变的，如果两种不同的方法偶然使用相同的字符串，它们可以共享相同字符串的副本。将重复的字符串转换为共享字符串的过程称为 interning.String.intern（）为您提供规范主字符串的地址。您可以将实际的字符串与简单的==（比较指针）进行比较，而不是等于，它将逐个比较字符串的字符。因为字符串是不可变的，所以实习过程可以自由地进一步节省空间，例如，当它作为“hippopotamus”等其他文字的子字符串存在时，不为“pot”创建单独的字符串文字。

要查看更多http://mindprod.com/jgloss/interned.html

Answer 9

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

输出

s1 and s2 are same
s1 and s4 are same

Answer 10

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

当两个字符串独立创建时，intern()允许您比较它们，如果之前不存在引用，它还可以帮助您在字符串池中创建引用。

当你使用String s = new String(hi)时，java会创建一个新的字符串实例，但是当你使用String s = "hi"时，java会检查代码中是否有单词“hi”的实例，如果它存在，它只返回引用。

由于比较字符串是基于引用的，intern()有助于您创建引用并允许您比较字符串的内容。

在代码中使用intern()时，它会清除引用同一对象的字符串所使用的空间，并仅返回内存中已存在的相同对象的引用。

但是在使用p5的情况下：

String p5 = new String(p3);

仅复制p3的内容并重新创建p5。所以它不是实习。

所以输出将是：

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

Answer 11

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

Answer 12

string intern（）方法用于在字符串常量池中创建堆字符串对象的精确副本。字符串常量池中的字符串对象会自动实现，但堆中的字符串对象则不会。创建实习生的主要用途是节省内存空间并更快地比较字符串对象。

来源：What is string intern in java?

Answer 13

正如你所说，字符串intern()方法将首先从字符串池中找到，如果找到，则它将返回指向该字符串的对象，或者将新的字符串添加到池中。

    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

s1和s2是两个指向字符串池的对象＆＃34; Hello＆＃34;，使用"Hello".intern()会找到s1和{{} 1}}。因此s2会返回true，也会返回"s1 == s3"。

Answer 14

如果要获取相应的字符串常量池对象引用，请使用堆对象引用，那么我们应该使用 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

图片视图

步骤1： 在堆和字符串常量池中创建带有数据“ Rakesh”的对象。而且s1总是指向堆对象。

步骤2： 通过使用堆对象引用s1，我们尝试使用intern（）获得对应的字符串常量池对象引用s2

第3步： 故意在字符串常量池中创建数据为“ Rakesh”的对象，名称为s3

以“ ==”运算符表示参考比较。

获取s1 == s2的 false

获取s2 == s3

true

希望得到帮助！

我们何时应该在字符串文字上使用String的实习方法

14 个答案:

学习Java字符串实习生 - 一劳永逸