久久久国产精品黄毛片,日本高清成本人视频一区,欧美色幼

字符串相加

字符串相加在Java中使用非常頻繁，通常情況下使用＂＋＂就可以方便快捷的完成目標，但是你可能聽過＂＋＂在有些時候效率不高,需要用StringBuilder代替．但是這種說法的背后原因是什么呢，哪種情況下適用呢？下面結合Jdk命令Javap解釋這倆問題．

一個普通的字符串相加：

public class StringTest {
    public static void main(String[] args){
      String a = "a";
      String b = "b";
      String c = "c";
      String d = a + b + c;
      System.out.println(d);
    }
}

使用javap查看編譯后的字節碼：

zeal@zeal-ThinkPad:~/tobenew$ javap -c StringTest
Picked up JAVA_TOOL_OPTIONS: -javaagent:/usr/share/java/jayatanaag.jar 
Compiled from "StringTest.java"
public class StringTest {
  public StringTest();
    Code:
       0: aload_0       
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: return        
  public static void main(java.lang.String[]);
    Code:
       0: ldc           #2                  // String a
       2: astore_1      
       3: ldc           #3                  // String b
       5: astore_2      
       6: ldc           #4                  // String c
       8: astore_3      
       9: new           #5                  // class java/lang/StringBuilder
      12: dup           
      13: invokespecial #6                  // Method java/lang/StringBuilder."<init>":()V
      16: aload_1       
      17: invokevirtual #7                  // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
      20: aload_2       
      21: invokevirtual #7                  // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
      24: aload_3       
      25: invokevirtual #7                  // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
      28: invokevirtual #8                  // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
      31: astore        4
      33: getstatic     #9                  // Field java/lang/System.out:Ljava/io/PrintStream;
      36: aload         4
      38: invokevirtual #10                 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
      41: return        
}

我們并不討論具體的指令含義，簡單來看＂＋＂在編譯中被StringBuilder替換，所以說＂＋＂只是一個語法上的簡化，最后通過編譯器編譯成了StringBuilder的append實現．可以發現在這里＂＋＂和手寫append其實是一樣的，＂＋＂更易讀些．

循環中的字符串相加：

public class StringTest {
   public static void main(String[] args){
     final String a = "a";
     String b = "b";
     for(int i=0; i<5; i++) {
        b = b + a;
     }
     System.out.println(b);
   }
}

使用javap查看編譯后的字節碼：

zeal@zeal-ThinkPad:~/tobenew$ javap -c StringTest
Picked up JAVA_TOOL_OPTIONS: -javaagent:/usr/share/java/jayatanaag.jar 
Compiled from "StringTest.java"
public class StringTest {
  public StringTest();
    Code:
       0: aload_0       
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: return        

  public static void main(java.lang.String[]);
    Code:
       0: ldc           #2                  // String b
       2: astore_2      
       3: iconst_0      
       4: istore_3      
       5: iload_3       
       6: iconst_5      
       7: if_icmpge     36
      10: new           #3                  // class java/lang/StringBuilder
      13: dup           
      14: invokespecial #4                  // Method java/lang/StringBuilder."<init>":()V
      17: aload_2       
      18: invokevirtual #5                  // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
      21: ldc           #6                  // String a
      23: invokevirtual #5                  // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
      26: invokevirtual #7                  // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
      29: astore_2      
      30: iinc          3, 1
      33: goto          5
      36: getstatic     #8                  // Field java/lang/System.out:Ljava/io/PrintStream;
      39: aload_2       
      40: invokevirtual #9                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
      43: return        
}

仔細看可以發現StringBuilder對象創建被放在了循環里面(goto語句)，所以如果循環次數特別多就不適合用＂＋＂了，要不然會創建大量的StringBuilder對象．正確的用法是這樣：

public class StringTest {
   public static void main(String[] args){
     String a = "a";
     StringBuilder builder = new StringBuilder("b");
     for(int i=0; i<5; i++) {
        builder.append(a);
     }
     System.out.println(builder.toString());
   }
}

final字符串的相加：

public class StringTest {
    public static void main(String[] args){
      final String a = "a";
      final String b = "b";
      final String c = "c";
      String d = a + b + c;
      System.out.println(d);
    }
}

使用javap查看編譯后的字節碼：

zeal@zeal-ThinkPad:~/tobenew$ javap -c StringTest
Picked up JAVA_TOOL_OPTIONS: -javaagent:/usr/share/java/jayatanaag.jar 
Compiled from "StringTest.java"
public class StringTest {
  public StringTest();
    Code:
       0: aload_0       
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: return        
  public static void main(java.lang.String[]);
    Code:
       0: ldc           #2                  // String abc
       2: astore        4
       4: getstatic     #3                  // Field java/lang/System.out:Ljava/io/PrintStream;
       7: aload         4
       9: invokevirtual #4                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
      12: return        
}

我們發現根本沒有StringBuilder對象被創建，因為a,b,c值不會改變，所以d是一個確定值．Java在編譯期就進行了優化．

字符串常量池的位置

常量池的位置在Jdk1.6之前(包括1.6)屬于永久區的一部分，而在1.7之后(包括1.7)被移到了堆中管理．

import java.util.List;
import java.util.ArrayList;
public class StringTest {
   public static void main(String[] args){
        List<String> strList = new ArrayList<String>();
    int i=0;
    while(true){
        strList.add((i+"").intern());
        i++;
    }
   }
}

zeal@zeal-pc:~$ ./soft/jdk/jdk1.6.0_45/bin/java -Xmx10m -XX:MaxPermSize=5m -XX:-UseGCOverheadLimit StringTest
Exception in thread "main" java.lang.OutOfMemoryError: PermGen space
    at java.lang.String.intern(Native Method)
    at StringTest.main(StringTest.java:8)

zeal@zeal-pc:~$ ./soft/jdk/jdk1.7.0_65/bin/java -Xmx10m -XX:MaxPermSize=5m -XX:-UseGCOverheadLimit StringTest
Exception in thread "main" java.lang.OutOfMemoryError: Java heap space
    at StringTest.main(StringTest.java:8)

字符串比較

這個在整理的時候遇到一個奇葩情況解釋不了，請大神回復一下
首先來看一波符合預期的例子：

//In Jdk1.7
public class StringTest {
   public static void main(String[] args){
        String str1 = new String("world");
        String str2 = str1.intern();
        String str3 = "world";

        System.out.println(str1 == str2);  //false
        System.out.println(str2 == str3);  //true
   }
}

//In Jdk1.7
public class StringTest {
   public static void main(String[] args){
        String str0 = "world";
        String str1 = new String("world");
        String str2 = str1.intern();
        String str3 = "world";

        System.out.println(str0 == str1);  //false
        System.out.println(str0 == str2);  //true
        System.out.println(str1 == str2);  //false
        System.out.println(str2 == str3);  //true
        System.out.println(str0 == str3);  //true
   }
}

看一下intern的源碼注釋：(Jdk1.6和Jdk1.7是完全一樣的)

When the intern method is invoked, if the pool already contains a
string equal to this <code>String</code> object as determined by
the {@link #equals(Object)} method, then the string from the pool is
returned. Otherwise, this <code>String</code> object is added to the
pool and a reference to this <code>String</code> object is returned.

如果常量池中存在和當前對象equals相等的對象則返回常量池中的對象引用，否則將當前對象(應該是當前對象的拷貝)加入常量池并返回引用．
從這里可以看出，＂world＂這種創建字符串的方式會被加入到常量池，而new對象的方式是不會添加到常量池或者從常量池中獲取的．

不符合預期的情況

//In Jdk1.7
public class StringTest {
   public static void main(String[] args){
     String str1=new String("hell")+new String("o");
     String str2 = str1.intern();
     String str3 = "hello";
     String str4 = new String("hello");

     System.out.println(str1==str2);
     System.out.println(str2==str3);
     System.out.println(str1==str3);
     System.out.println(str3==str4);
   }
}

zeal@zeal-pc:~$ java StringTest
true
true
true
false

根據前文可以看到str1是由StringBuilder的toString方法構造出來的，查看源碼可以發現toString其實是new了一個新的String對象出來．按照之前理解str1==str2應為false.

madan坑好深,誰來解釋一下

public class StringTest {
   public static void main(String[] args){
        String str1 = new String("hell")+new String("o");
        String str2 = str1.intern();

        String str3 = new String("java");
        String str4 = str3.intern();

        String str5 = new String("world");
        String str6 = str5.intern();

        String str7 = "cat";
        String str8 = str7.intern();

        String str9 = new StringBuffer("hello").append("world").toString();
        String str10 = str9.intern();

        String str11 = new StringBuilder("hellojava").toString();
        String str12 = str11.intern();

        String str13=new StringBuilder("hello").append("2").toString();
        String str14 = "hello2";
        String str15=str13.intern();
    
                                           //Jdk1.7   //Jdk1.6
        System.out.println(str1 == str2);  //true?    //false
        System.out.println(str3 == str4);  //false    //false
        System.out.println(str5 == str6);  //false    //false
        System.out.println(str7 == str8);  //true     //true
        System.out.println(str9 == str10); //true?    //false
        System.out.println(str11 == str12);//false    //false
        System.out.println(str13==str14);  //false    //false
        System.out.println(str13==str15);  //false    //false
        System.out.println(str14==str15);  //true     //true
   }
}

之后進行了一系列測試，發現append和intern在一起的時候(＂＋＂等同于append)在1.7中會發生奇妙的現象．表面來看就好像append存在的時候往常量池中存放的不是String對象的拷貝而是String對象的引用．

只能把鍋給append了....　誰來解釋一下！

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美国产综合欧美视频

String中的秘密

String中的秘密

字符串相加

一個普通的字符串相加：

循環中的字符串相加：

final字符串的相加：

字符串常量池的位置

字符串比較

madan坑好深,誰來解釋一下

推薦閱讀更多精彩內容

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美 国产 综合 欧美 视频

String中的秘密

字符串相加

一個普通的字符串相加：

循環中的字符串相加：

final字符串的相加：

字符串常量池的位置

字符串比較

madan坑好深,誰來解釋一下

推薦閱讀更多精彩內容

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美国产综合欧美视频