TJI读书笔记17-字符串

字符串操作可能是计算机程序设计中最常见的行为之一. 而我们常见的字符串类型有String类,StringBuffer类和StringBuilder类. 其中,String类型代表的是一个不可变的字符串类型,而StringBuffer是一个线程安全的可变字符串序列. StringBuilder类是一个可变的字符串序列,但是并不是线程安全的,性能上比StringBuffer好,可以说是在单线程中的StringBuffer的一个理想代替.

不可变的String

String类型是不可变的. String类型是不可变的. String类型是不可变的. 所有看上去修改了String类型的操作实际上都是创建了一个新的String实例. 同时String类型的equals方法也被重写了,使得当String类型的”值”一样的时候,equals判断就为真. 这更符合人类对字符串的理解. 但同时也会给String是不可变的这一特性的理解带来一定的困扰.

1.public class Immutable {
2.    public static String upcase(String s){
3.        return s.toUpperCase();
4.    }
5.    public static void main(String[] args) {
6.        String str="hello";
7.        System.out.println(str);
8.        String str2 = upcase(str);
9.        System.out.println(str2);
10.    }
11.}/*output:
12.hello
13.HELLO
14.*/

这是一个简单的例子,没有什么太多好说的. 只有一点,str2的操作,实际上是在内存中新开辟一个区域,然后存入转换后的字符串. 用python的话说,这不是一个”原地操作”.

重载”+”和StringBuilder

java是不允许操作符重载的. 但是java给了两个特例,那就是字符串操作中的”+”和”+=”
首先,一定要接受一个事实,String类型是不可变的. 那么问题来了,因为String类型是不可变的,那由此带来的每次String相关的一些操作在效率上就会存在问题. 比如字符串连接"hey"+"hello"+"world"这个操作应该要如何进行. 假设String类型有个append()方法,那么先创建一个内存区域,存放”hey”和”hello”连接后的字符串假设叫str1,这是一个中间对象,然后在整一个新的内存区域,存放str1和”world”连接后的字符串. 如果说有大量的这种字符串连接操作,那么就会产生大量的中间对象. 显然这种方式开销是很大的.
那么java实际上是不是这么做的呢?据埃大爷说java早期真的是这么做的.(我年纪小,没有经历过这些,捂脸). 一个例子看看现在的java是怎么执行字符串连接操作的.

1.package ch13_String;
2.
3.public class Concatenation {
4.    public static void main(String[] args) {
5.        String mango ="mango";
6.        String s = "abc"+mango+"def"+47;
7.        System.out.println(s);
8.    }
9.}/*output:
10.Compiled from "Concatenation.java"
11.public class ch13_String.Concatenation {
12.  public ch13_String.Concatenation();
13.    Code:
14.       0: aload_0
15.       1: invokespecial #8                  // Method java/lang/Object."<init>":()V
16.       4: return
17.
18.  public static void main(java.lang.String[]);
19.    Code:
20.       0: ldc           #16                 // String mango
21.       2: astore_1
22.       3: new           #18                 // class java/lang/StringBuilder
23.       6: dup
24.       7: ldc           #20                 // String abc
25.       9: invokespecial #22                 // Method java/lang/StringBuilder."<init>":(Ljava/lang/String;)V
26.      12: aload_1
27.      13: invokevirtual #25                 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
28.      16: ldc           #29                 // String def
29.      18: invokevirtual #25                 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
30.      21: bipush        47
31.      23: invokevirtual #31                 // Method java/lang/StringBuilder.append:(I)Ljava/lang/StringBuilder;
32.      26: invokevirtual #34                 // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
33.      29: astore_2
34.      30: getstatic     #38                 // Field java/lang/System.out:Ljava/io/PrintStream;
35.      33: aload_2
36.      34: invokevirtual #44                 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
37.      37: return
38.}
39.*/

java有一个反编译的工具,可以看到JVM生成的字节码,是一种类似汇编的玩意儿. 当然,现在除了极少数底层程序员之外,很少有人懂汇编了. (这是一件多么悲哀的事情)但是贴心的java给出了一些注释.关于如何在eclipse中使用javap进行反编译,请参考这篇文章(http://blog.csdn.net/ricciozhang/article/details/46994485)
简单来看,实际上,在做字符串连接的时候使用了StringBuider类,并调用StringBuilder类的append方法.这是一种更高效的方法.
也就是说,java其实是对String类型的连接做了优化. 那么这种优化到底有多大的作用呢?

1.package ch13_String;
2.
3.public class WhitherStringBuilder {
4.    public String implicit(String[] fileds){
5.        String result = "";
6.        for(int i =0;i<fileds.length;i++){
7.            result+=fileds[i];
8.        }
9.        return result;
10.    }
11.    public String explicit(WhitherStringBuilder[] fileds){
12.        StringBuilder result = new StringBuilder();
13.        for(int i =0;i<fileds.length;i++){
14.            result.append(fileds[i]);
15.        }
16.        return result.toString();
17.    }
18.
19.}/*output:
20.Compiled from "WhitherStringBuilder.java"
21.public class ch13_String.WhitherStringBuilder {
22.  public ch13_String.WhitherStringBuilder();
23.    Code:
24.       0: aload_0
25.       1: invokespecial #8                  // Method java/lang/Object."<init>":()V
26.       4: return
27.
28.  public java.lang.String implicit(java.lang.String[]);
29.    Code:
30.       0: ldc           #16                 // String
31.       2: astore_2
32.       3: iconst_0
33.       4: istore_3
34.       5: goto          32
35.       8: new           #18                 // class java/lang/StringBuilder
36.      11: dup
37.      12: aload_2
38.      13: invokestatic  #20                 // Method java/lang/String.valueOf:(Ljava/lang/Object;)Ljava/lang/String;
39.      16: invokespecial #26                 // Method java/lang/StringBuilder."<init>":(Ljava/lang/String;)V
40.      19: aload_1
41.      20: iload_3
42.      21: aaload
43.      22: invokevirtual #29                 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
44.      25: invokevirtual #33                 // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
45.      28: astore_2
46.      29: iinc          3, 1
47.      32: iload_3
48.      33: aload_1
49.      34: arraylength
50.      35: if_icmplt     8
51.      38: aload_2
52.      39: areturn
53.
54.  public java.lang.String explicit(ch13_String.WhitherStringBuilder[]);
55.    Code:
56.       0: new           #18                 // class java/lang/StringBuilder
57.       3: dup
58.       4: invokespecial #46                 // Method java/lang/StringBuilder."<init>":()V
59.       7: astore_2
60.       8: iconst_0
61.       9: istore_3
62.      10: goto          24
63.      13: aload_2
64.      14: aload_1
65.      15: iload_3
66.      16: aaload
67.      17: invokevirtual #47                 // Method java/lang/StringBuilder.append:(Ljava/lang/Object;)Ljava/lang/StringBuilder;
68.      20: pop
69.      21: iinc          3, 1
70.      24: iload_3
71.      25: aload_1
72.      26: arraylength
73.      27: if_icmplt     13
74.      30: aload_2
75.      31: invokevirtual #33                 // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
76.      34: areturn
77.}
78.*/

虽然我是一个不懂汇编的菜鸟,但是单纯从两个方法的注释上就能直观的感觉到,直接使用StringBuilder类的时候,明显方法调用和实例的创建要简洁…实际上是,第一个方法,循环中的每一次都会创建一个StringBuilder类. 显然,这种开销依旧是很大的. 所以说单纯的把String类型的性能优化交给java是不靠谱的.

所以在使用字符串的时候,或者为一个类重写toString()方法的时候,如果字符串操作比较简单,可以相信编译器的优化. 但是如果有频繁的字符串操作,比如有循环的时候,最好自己创建StringBuilder对象.

1.import java.util.Random;
2.
3.public class UsingStringBuilder {
4.    Random rand = new Random(47);
5.    public String toString(){
6.        StringBuilder result = new StringBuilder("[");
7.        for(int i=0;i<25;i++){
8.            result.append(rand.nextInt(100));
9.            result.append(",");
10.        }
11.        result.delete(result.length()-1, result.length());
12.        result.append("]");
13.        return result.toString();
14.    }
15.    public static void main(String[] args) {
16.        UsingStringBuilder usb = new UsingStringBuilder();
17.        System.out.println(usb);
18.    }
19.}

toString()方法的一个坑

toString()方法用于返回一个对象的字符串表示. 如果没有重写的时候,这个方法会返回一个内存标识符的字符串.重写它可以在调用类似 System.out.println()的时候,得到一个你所期望的字符串的样式.

1.import java.util.ArrayList;
2.import java.util.Random;
3.
4.class Apple{
5.    static long counter;
6.    static String[] names = {"Fuji","Red delicious","YanTai"};
7.    private String name;
8.    private long id = counter++;
9.    Random rand = new Random();
10.    public Apple(){
11.        this.name = names[rand.nextInt(3)];
12.    }
13.    public static ArrayList<Apple> AppleGenerator(int count){
14.        ArrayList<Apple> apples = new ArrayList<>();
15.        for(int i=0;i<count;i++ ){
16.            apples.add(new Apple());
17.        }
18.        return apples;
19.    }
20.    public String toString(){
21.        return this.name+":"+this.id;
22.    }
23.}
24.
25.public class ArrayListDisplay {
26.    public static void main(String[] args) {
27.        ArrayList<Apple> apples = new ArrayList<>();
28.        for(Apple eachApple:Apple.AppleGenerator(10)){
29.            apples.add(eachApple);
30.        }
31.        System.out.println(apples);
32.    }
33.}

比如下面这段代码

1.import java.util.ArrayList;
2.import java.util.List;
3.
4.public class InfiniteRecursion {
5.    public String toString(){
6.//      return "InfiniteRecursion address:"+super.toString()+"
";
7.        return "InfiniteRecursion address:"+this+"
";
8.    }
9.    public static void main(String[] args) {
10.//      List<InfiniteRecursion> v = new ArrayList<>();
11.//      for(int i =0;i<10;i++){
12.//          v.add(new InfiniteRecursion());
13.//      }
14.//      System.out.println(v);
15.        InfiniteRecursion infiniteRecursion = new InfiniteRecursion();
16.        System.out.println(infiniteRecursion);
17.    }
18.}

显然,它是想在toString()方法中返回内存标识符的字符串但是又像加上一些其他的字符串.但是这种调用行不行呢?显然是不行的. 16行打印的时候调用了InfiniteRecursion类的toString方法. 然后在toString方法中,将一个字符串和一个非字符串拼接的时候,那个非字符串类型需要强转. 强转的时候会再次调用该类型下的toString()方法,这时候,会陷入一个无限的迭代中. 埃大爷说会看到一个很长的字符串,但是在javaSE8中是会报错的.所以正确的做法是,调用Object类的toString方法.

String上的操作

String类提供了很多很多很多的方法. 感觉我是记不住的,所以文档里,随用随查吧.

格式化输出

回忆一下C语言,printf(),通过格式修饰符占位的方法进行格式化输出.
printf("Row1: [%d %f]",x,y);

javaSE5之后也推出了类似printf()风格的格式化输出.

1.public class SimpleFormat {
2.    public static void main(String[] args) {
3.        int x =5;
4.        double y =2.3333333;
5.        System.out.println("Row1: ["+x+ " "+y+"]");
6.
7.        System.out.printf("Row1: [%d %f]
", x,y);
8.
9.        System.out.format("Row1: [%d %f]
", x,y);
10.    }
11.}

和C的printf很像.熟悉C的童鞋应该会觉得很亲切. 可是我已经觉得不亲切了…

Formatter类

Formatter是一个printf风格字符串的解释程序,可以用来将格式化的字符串和数据翻译成需要的结果.

1.import java.io.PrintStream;
2.import java.util.Formatter;
3.
4.public class Turtle {
5.    private String name;
6.    private Formatter f;
7.    public Turtle(String name,Formatter f){
8.        this.name = name;
9.        this.f=f;
10.    }
11.    public void move(int x,int y){
12.        f.format("%s The Turtle is at (%d,%d)
",name,x,y);
13.    }
14.    public static void main(String[] args) {
15.        PrintStream outAlias = System.out;
16.
17.        Turtle tommy = new Turtle("Tommy", new Formatter(outAlias));
18.        Turtle terry = new Turtle("Terry", new Formatter(System.out));
19.
20.        tommy.move(0, 0);
21.        terry.move(4, 8);
22.
23.        tommy.move(3, 4);
24.        terry.move(2, 5);
25.
26.    }
27.}

格式化说明符
格式化说明符的的抽象语法:
%[argument_index$][flags][width][.precision]conversion

width 控制最小宽度,可以用来控制至少达到某个长度
precision 这个字段用于字符串的时候表示输出字符的最大数量. 用于浮点数的时候,表示显示小数的位数

1.import java.util.Formatter;
2.
3.public class Receipt {
4.    private double total =0;
5.    private Formatter f = new Formatter(System.out);
6.
7.    public void printTitlle(){
8.        f.format("%-15s %5s %10s 
", "Item","Qty","Price");
9.        f.format("%-15s %5s %10s
", "----","----","----");
10.    }
11.
12.    public void print(String name,int qty,double price){
13.        f.format("%-15.15s %5d %10.2f
", name,qty,price);
14.        total+=price;
15.    }
16.
17.    public void printTotal(){
18.         f.format("%-15s %5s %10.2f
", "Tax", "", total*0.06); 
19.         f.format("%-15s %5s %10s
", "", "", "-----"); 
20.         f.format("%-15s %5s %10.2f
", "Total", "", total * 1.06);
21.    }
22.    public static void main(String[] args) {
23.        Receipt receipt = new Receipt();
24.        receipt.printTitlle();
25.        receipt.print("Jack’s Magic Beans", 4, 4.25); 
26.        receipt.print("Princess Peas", 3, 5.1); 
27.        receipt.print("Three Bears Porridge", 1, 14.29); 
28.        receipt.printTotal();
29.    }
30.}/*output:
31.Item              Qty      Price 
32.----             ----       ----
33.Jack’s Magic Be     4       4.25
34.Princess Peas       3       5.10
35.Three Bears Por     1      14.29
36.Tax                         1.42
37.                           -----
38.Total                      25.06
39.*/

Formater的转换
Formatter是使用了占位符的,比如%s表示一个String类型. %d表示int类型等等. 如果占位符和实际变量类型对不上的时候会发生什么呢? 答,异常或者强转.

String的format()方法
String下提供了format()方法,可以用于字符串的格式化输出. 其基本使用方法和Formatter.format()一样,只不过返回的是一个String类型. 如果仅仅是需要单次使用format()方法的话String.format()方法会方便很多.