Java의 문자열에 대한 심층적인 이해-java지도 시간-php.cn

이 글은 Java String에 대한 심층적인 이해를 위한 관련 정보를 주로 소개합니다. 이 글을 통해 누구나 String의 사용법을 이해할 수 있기를 바랍니다. 필요한 친구들은

Java String에 대한 심층적인 이해

를 참고하세요. 1. Java 메모리 모델

공식 성명에 따르면: Java 가상 머신에는 런타임 데이터 영역인 힙이 있으며 여기에서 모든 클래스 인스턴스와 배열의 메모리가 할당됩니다.

JVM은 주로 힙과 비힙 메모리 두 가지 유형을 관리합니다. 힙 메모리는 Java 가상 머신이 시작될 때 생성되며, 비힙 메모리는 JVM 힙 외부의 메모리입니다.

간단히 말하면, 비힙에는 메소드 영역, 내부 JVM 처리 또는 최적화에 필요한 메모리(예: JITCompiler, Just-in-time Compiler, Just-In-Time 컴파일된 코드 캐시 등), 각 클래스 구조(예: 런타임 상수 풀, 필드 및 메소드 데이터) 및 메소드 및 생성자를 위한 코드입니다.

Java의 힙은 클래스 객체가 공간을 할당하는 런타임 데이터 영역입니다. 이러한 객체는 new, newarray, anewarray 및 multianewarray와 같은 명령을 통해 생성되며 프로그램 코드를 명시적으로 해제할 필요가 없습니다. 힙의 장점은 메모리 크기를 동적으로 할당할 수 있다는 점이며, 런타임에 메모리를 동적으로 할당하고 Java의 가비지 수집기가 자동으로 수명을 지정하므로 컴파일러에 수명을 미리 알릴 필요가 없습니다. 사용되지 않는 것들을 수집합니다. 단점은 런타임 시 메모리의 동적 할당으로 인해 액세스 속도가 느리다는 것입니다. 스택의 장점은 액세스 속도가 레지스터에 이어 두 번째로 빠르며 스택 데이터를 사용할 수 있다는 것입니다. 그러나 단점은 스택에 저장되는 데이터의 크기와 수명을 결정해야 하며, 스택에는 주로 몇 가지 기본 유형의 가변 데이터(int, short, long, byte)가 저장된다는 점입니다. , float, double, boolean, char) 및 객체 핸들(참조). 가상 머신은 로드된 각 유형에 대해 상수 풀을 유지해야 합니다. 상수 풀은 직접 상수(문자열)를 포함하여 해당 유형에서 사용하는 상수의 정렬된 모음입니다. , 정수 및 부동 소수점) 및 기타 유형, 필드 및 메소드에 대한 기호 참조

문자열 상수의 경우 해당 값은 상수 풀에 있으며 JVM의 상수 풀은 테이블 형식으로 존재합니다. memory.에는 리터럴 문자열 값을 저장하는 데 사용되는 고정 길이 CONSTANT_String_info 테이블이 있습니다. 참고: 이 테이블은 기호 참조가 아닌 리터럴 문자열 값만 저장합니다. 상수 풀은 프로그램이 실행될 때 힙 대신 메소드 영역에 저장되며 공유가 가능하므로 효율성이 향상됩니다

2, 사례 분석

public static void main(String[] args) { 
    /** 
     * 情景一：字符串池 
     * JAVA虚拟机(JVM)中存在着一个字符串池，其中保存着很多String对象; 
     * 并且可以被共享使用，因此它提高了效率。 
     * 由于String类是final的，它的值一经创建就不可改变。 
     * 字符串池由String类维护，我们可以调用intern()方法来访问字符串池。 
     */ 
    String s1 = "abc";   
    //↑ 在字符串池创建了一个对象 
    String s2 = "abc";   
    //↑ 字符串pool已经存在对象“abc”(共享),所以创建0个对象，累计创建一个对象 
    System.out.println("s1 == s2 : "+(s1==s2));  
    //↑ true 指向同一个对象， 
    System.out.println("s1.equals(s2) : " + (s1.equals(s2)));  
    //↑ true 值相等 
    //↑------------------------------------------------------over 
    /** 
     * 情景二：关于new String("") 
     * 
     */ 
    String s3 = new String("abc"); 
    //↑ 创建了两个对象，一个存放在字符串池中，一个存在与堆区中； 
    //↑ 还有一个对象引用s3存放在栈中 
    String s4 = new String("abc"); 
    //↑ 字符串池中已经存在“abc”对象，所以只在堆中创建了一个对象 
    System.out.println("s3 == s4 : "+(s3==s4)); 
    //↑false  s3和s4栈区的地址不同，指向堆区的不同地址； 
    System.out.println("s3.equals(s4) : "+(s3.equals(s4))); 
    //↑true s3和s4的值相同 
    System.out.println("s1 == s3 : "+(s1==s3)); 
    //↑false 存放的地区多不同，一个栈区，一个堆区 
    System.out.println("s1.equals(s3) : "+(s1.equals(s3))); 
    //↑true 值相同 
    //↑------------------------------------------------------over 
    /** 
     * 情景三： 
     * 由于常量的值在编译的时候就被确定(优化)了。 
     * 在这里，"ab"和"cd"都是常量，因此变量str3的值在编译时就可以确定。 
     * 这行代码编译后的效果等同于： String str3 = "abcd"; 
     */ 
    String str1 = "ab" + "cd"; //1个对象 
    String str11 = "abcd";  
    System.out.println("str1 = str11 : "+ (str1 == str11)); 
    //↑------------------------------------------------------over 
    /** 
     * 情景四： 
     * 局部变量str2,str3存储的是存储两个拘留字符串对象(intern字符串对象)的地址。 
     * 
     * 第三行代码原理(str2+str3)： 
     * 运行期JVM首先会在堆中创建一个StringBuilder类， 
     * 同时用str2指向的拘留字符串对象完成初始化， 
     * 然后调用append方法完成对str3所指向的拘留字符串的合并， 
     * 接着调用StringBuilder的toString()方法在堆中创建一个String对象， 
     * 最后将刚生成的String对象的堆地址存放在局部变量str3中。 
     * 
     * 而str5存储的是字符串池中"abcd"所对应的拘留字符串对象的地址。 
     * str4与str5地址当然不一样了。 
     * 
     * 内存中实际上有五个字符串对象： 
     *    三个拘留字符串对象、一个String对象和一个StringBuilder对象。 
     */ 
    String str2 = "ab"; //1个对象 
    String str3 = "cd"; //1个对象                     
    String str4 = str2+str3;                    
    String str5 = "abcd";  
    System.out.println("str4 = str5 : " + (str4==str5)); // false 
    //↑------------------------------------------------------over 
    /** 
     * 情景五： 
     * JAVA编译器对string + 基本类型/常量 是当成常量表达式直接求值来优化的。 
     * 运行期的两个string相加，会产生新的对象的，存储在堆(heap)中 
     */ 
    String str6 = "b"; 
    String str7 = "a" + str6; 
    String str67 = "ab"; 
    System.out.println("str7 = str67 : "+ (str7 == str67)); 
    //↑str6为变量，在运行期才会被解析。 
    final String str8 = "b"; 
    String str9 = "a" + str8; 
    String str89 = "ab"; 
    System.out.println("str9 = str89 : "+ (str9 == str89)); 
    //↑str8为常量变量，编译期会被优化 
    //↑------------------------------------------------------over 
  }

로그인 후 복사

요약:

1. String 클래스는 초기화 후에 변경할 수 없습니다.
일단 String 인스턴스가 생성되면 할 말이 많습니다. 변경되지 않습니다. 예를 들어 다음과 같이 다시 변경됩니다. String str="kv"+"ill"+" "+"ans" 4개의 문자열 상수가 있습니다. 먼저 "kv" 및 "ill"은 "kvill"을 생성하고 저장합니다. , "kvill"은 ""와 결합하여 "kvill"을 생성하고 메모리에 저장되며 마지막으로 "kvill ans"와 결합하여 "kvill ans"를 생성하며 이 문자열의 주소는 다음과 같습니다. str에 할당된 String의 "불변성"으로 인해 많은 임시 변수가 생성되므로 StringBuffer를 사용하는 것이 좋습니다. 왜냐하면 StringBuffer는 변경 가능하기 때문입니다.

다음은 문자열과 관련된 몇 가지 일반적인 문제입니다.

String中的final用法和理解 
final StringBuffer a = new StringBuffer(“111”); 
final StringBuffer b = new StringBuffer(“222”); 
a=b;//此句编译不通过 final StringBuffer a = new StringBuffer(“111”); 
a.append(“222”);// 编译通过

로그인 후 복사

final은 참조의 "값"(예: 메모리 주소)에만 효과적이며 참조가 다음을 가리키도록 강제하는 것을 볼 수 있습니다. 처음에 가리키는 객체의 포인터를 변경하면 컴파일 타임 오류가 발생합니다. 그것이 가리키는 객체의 변경에 대해서는 final이 책임을 지지 않습니다.

2. 코드의 문자열 상수는 컴파일 과정에서 수집되어 "123", "123" + "456" 등과 같은 클래스 파일의 상수 영역에 배치됩니다. "123"+a와 같이 포함되지 않습니다.

3. JVM은 클래스를 로드할 때 상수 영역의 문자열을 기반으로 상수 풀을 생성합니다. "123"과 같은 각 문자 시퀀스는 인스턴스를 생성하여 상수 풀에 배치합니다. 힙에서는 GC가 아닙니다. 소스 코드의 생성자에서 이 인스턴스의 값 속성은 new로 생성되어 배열 123에 배치되어야 합니다. 따라서 내 이해에 따르면 값이 힙에 저장됩니다. 잘못된 경우 수정을 환영합니다.

4. 문자열을 사용한다고 해서 반드시 객체가 생성되는 것은 아닙니다.

在执行到双引号包含字符串的语句时，如String a = “123”，JVM会先到常量池里查找，如果有的话返回常量池里的这个实例的引用，否则的话创建一个新实例并置入常量池里。如果是 String a = “123” + b (假设b是”456”)，前半部分”123”还是走常量池的路线，但是这个+操作符其实是转换成[SringBuffer].Appad()来实现的，所以最终a得到是一个新的实例引用，而且a的value存放的是一个新申请的字符数组内存空间的地址(存放着”123456”)，而此时”123456”在常量池中是未必存在的。

要注意: 我们在使用诸如String str = “abc”；的格式定义类时，总是想当然地认为，创建了String类的对象str。担心陷阱！对象可能并没有被创建！而可能只是指向一个先前已经创建的对象。只有通过new()方法才能保证每次都创建一个新的对象

5.使用new String，一定创建对象

在执行String a = new String(“123”)的时候，首先走常量池的路线取到一个实例的引用，然后在堆上创建一个新的String实例，走以下构造函数给value属性赋值，然后把实例引用赋值给a：

public String(String original) {
  int size = original.count;
  char[] originalValue = original.value;
  char[] v;
   if (originalValue.length > size) {
     // The array representing the String is bigger than the new
     // String itself. Perhaps this constructor is being called
     // in order to trim the baggage, so make a copy of the array.
      int off = original.offset;
      v = Arrays.copyOfRange(originalValue, off, off+size);
   } else {
     // The array representing the String is the same
     // size as the String, so no point in making a copy.
    v = originalValue;
   }
  this.offset = 0;
  this.count = size;
  this.value = v;
  }

로그인 후 복사

从中我们可以看到，虽然是新创建了一个String的实例，但是value是等于常量池中的实例的value，即是说没有new一个新的字符数组来存放”123”。

如果是String a = new String(“123”+b)的情况，首先看回第4点，”123”+b得到一个实例后，再按上面的构造函数执行。

6.String.intern()

String对象的实例调用intern方法后，可以让JVM检查常量池，如果没有实例的value属性对应的字符串序列比如”123”(注意是检查字符串序列而不是检查实例本身)，就将本实例放入常量池，如果有当前实例的value属性对应的字符串序列”123”在常量池中存在，则返回常量池中”123”对应的实例的引用而不是当前实例的引用，即使当前实例的value也是”123”。

public native String intern();

로그인 후 복사

存在于.class文件中的常量池，在运行期被JVM装载，并且可以扩充。String的 intern()方法就是扩充常量池的一个方法；当一个String实例str调用intern()方法时，Java 查找常量池中是否有相同Unicode的字符串常量，如果有，则返回其的引用，如果没有，则在常量池中增加一个Unicode等于str的字符串并返回它的引用；看示例就清楚了

/**
 * Java学习交流QQ群：589809992 我们一起学Java！
 */
public static void main(String[] args) {
    String s0 = "kvill"; 
    String s1 = new String("kvill"); 
    String s2 = new String("kvill"); 
    System.out.println( s0 == s1 ); //false
    System.out.println( "**********" ); 
    s1.intern(); //虽然执行了s1.intern(),但它的返回值没有赋给s1
    s2 = s2.intern(); //把常量池中"kvill"的引用赋给s2 
    System.out.println( s0 == s1); //flase
    System.out.println( s0 == s1.intern() ); //true//说明s1.intern()返回的是常量池中"kvill"的引用
    System.out.println( s0 == s2 ); //true
  }

로그인 후 복사

最后我再破除一个错误的理解：有人说，“使用 String.intern() 方法则可以将一个 String 类的保存到一个全局 String 表中，如果具有相同值的 Unicode 字符串已经在这个表中，那么该方法返回表中已有字符串的地址，如果在表中没有相同值的字符串，则将自己的地址注册到表中”如果我把他说的这个全局的 String 表理解为常量池的话，他的最后一句话，”如果在表中没有相同值的字符串，则将自己的地址注册到表中”是错的：

public static void main(String[] args) {    
    String s1 = new String("kvill"); 
    String s2 = s1.intern(); 
    System.out.println( s1 == s1.intern() ); //false
    System.out.println( s1 + " " + s2 ); //kvill kvill
    System.out.println( s2 == s1.intern() ); //true
  }

로그인 후 복사

在这个类中我们没有声名一个”kvill”常量，所以常量池中一开始是没有”kvill”的，当我们调用s1.intern()后就在常量池中新添加了一个”kvill”常量，原来的不在常量池中的”kvill”仍然存在，也就不是“将自己的地址注册到常量池中”了。

　　 s1==s1.intern() 为false说明原来的”kvill”仍然存在；s2现在为常量池中”kvill”的地址，所以有s2==s1.intern()为true。

StringBuffer与StringBuilder的区别，它们的应用场景是什么？

jdk的实现中StringBuffer与StringBuilder都继承自AbstractStringBuilder，对于多线程的安全与非安全看到StringBuffer中方法前面的一堆synchronized就大概了解了。

这里随便讲讲AbstractStringBuilder的实现原理：我们知道使用StringBuffer等无非就是为了提高java中字符串连接的效率，因为直接使用+进行字符串连接的话，jvm会创建多个String对象，因此造成一定的开销。AbstractStringBuilder中采用一个char数组来保存需要append的字符串，char数组有一个初始大小，当append的字符串长度超过当前char数组容量时，则对char数组进行动态扩展，也即重新申请一段更大的内存空间，然后将当前char数组拷贝到新的位置，因为重新分配内存并拷贝的开销比较大，所以每次重新申请内存空间都是采用申请大于当前需要的内存空间的方式，这里是2倍，

StringBuffer 始于 JDK 1.0

StringBuilder 始于 JDK 1.5

从 JDK 1.5 开始，带有字符串变量的连接操作（+），JVM 内部采用的是
StringBuilder 来实现的，而之前这个操作是采用 StringBuffer 实现的。

我们通过一个简单的程序来看其执行的流程：

/**
 * Java学习交流QQ群：589809992 我们一起学Java！
 */
public class Buffer { 
   public static void main(String[] args) { 
      String s1 = "aaaaa"; 
      String s2 = "bbbbb"; 
      String r = null; 
      int i = 3694; 
      r = s1 + i + s2;  

      for(int j=0;i<10;j++){ 
        r+="23124"; 
      } 
   } 
}

로그인 후 복사

使用命令javap -c Buffer查看其字节码实现：

将清单1和清单2对应起来看，清单2的字节码中ldc指令即从常量池中加载“aaaaa”字符串到栈顶，istore_1将“aaaaa”存到变量1中，后面的一样，sipush是将一个短整型常量值(-32768~32767)推送至栈顶，这里是常量“3694”。

让我们直接看到13,13~17是new了一个StringBuffer对象并调用其初始化方法，20 ~ 21则是先通过aload_1将变量1压到栈顶，前面说过变量1放的就是字符串常量“aaaaa”，接着通过指令invokevirtual调用StringBuffer的append方法将“aaaaa”拼接起来，后续的24 ~ 30同理。最后在33调用StringBuffer的toString函数获得String结果并通过astore存到变量3中。

看到这里可能有人会说，“既然JVM内部采用了StringBuffer来连接字符串了，那么我们自己就不用用StringBuffer，直接用”+“就行了吧！“。是么？当然不是了。俗话说”存在既有它的理由”，让我们继续看后面的循环对应的字节码。

37~ 42都是进入for循环前的一些准备工作，37,38是将j置为1。44这里通过if_icmpge将j与10进行比较，如果j大于10则直接跳转到73，也即return语句退出函数；否则进入循环，也即47~66的字节码。这里我们只需看47到51就知道为什么我们要在代码中自己使用StringBuffer来处理字符串的连接了，因为每次执行“+”操作时jvm都要new一个StringBuffer对象来处理字符串的连接，这在涉及很多的字符串连接操作时开销会很大。

위 내용은 Java의 문자열에 대한 심층적인 이해의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!