字符串（1）：不可变字符串、重载“+”与StringBuilder、无意识的递归

偏执的太偏执、 2023-07-09 06:27 12阅读 0赞

可以证明，字符串操作是计算机程序设计中最常见的行为。尤其是在java大展拳脚的Web系统中更是如此。接下来我们将深入学习在java语言中应用最广泛的String类，并研究与之相关的类及工具。

### 一、不可变字符串 ###

String对象是不可变的。查看JDK文档你就会发现，String类中每一个看起来会修改String值的方法，实际上都是创建了一个全新的String对象，以包含修改后的字符串内容。而最初的String对象则丝毫未动。看下面的代码：

public class Immutable {
    	public static String upcase(String s) {
    		return s.toUpperCase();
    	}
    
    	public static void main(String[] args) {
    		String q = "howdy";
    		System.out.println(q);
    		String qq = upcase(q);
    		System.out.println(qq);
    		System.out.println(q);
    	}
    }

当把q传给upcase()方法时，实际传递的是引用的一个拷贝。其实，每当把String对象作为方法的参数时，都会复制一份引用，而该引用所指的对象其实一直待在单一的物理位置上，从未动过。

回到upcase()的定义，传入其中的引用有了名字s，只有upcase()运行的时候，局部引用s才存在。一旦upcase()运行结束，s就消失了。当然了，upcase()的返回值，其实只是最终结果的引用。这足以证明，upcase()返回的引用已经指向了一个新的对象，而原本的q则还在原地。

String的这种行为方式其实正是我们想要的。例如：

String s = "asdf";
    String x = Immutable.upcase(s);

难道你真的希望upcase()改变其参数吗？对于一个方法而言，参数是为该方法提供信息的，而不是像让该方法改变自己的。在阅读完这段代码时，自然就会有这样的感觉。这一点很重要，正是有了这种保障，才使得代码易于编写与阅读。

### 二、重载“+”与StringBuilder ###

String对象是不可变的，你可以给一个String对象加任意多的别名。因为String对象具有只读特性，所以指向它的任何引用都不可能改变它的值，因此，也就不会对其他的引用有什么影响。

不可变性会带来一定的效率问题。为String对象重载的“+”操作符就是一个例子。重载的意思就是，一个操作符在应用于特定的类时，被赋予了特殊的意义（用于String的“+”与“+=”是java中仅有的两个重载过的操作符，而java并不允许程序员重载任何操作符）。

操作符“+”可以用来连接String：

public class Concatenation {
    	public static void main(String[] args) {
    		String mango = "mango";
    		String s = "abc" + mango + "def" + 47;
    		System.out.println(s);
    	}
    }

可以想象一下，这段代码可能是这样工作的：String可能有一个append()方法，它会生成一个新的String对象，以包含“abc”与mango连接后的字符串。然后，该对象再与“def”相连，生成另一个新的String对象，以此类推。

这种工作方式当然也行得通，但是为了生成最终的String，此方法会产生一大堆需要垃圾回收的中间对象。我猜想，java设计师一开始就是这么做的（这也是软件设计中的一个教训：除非你用代码将系统实现，并让它动起来，否则你无法真正了解它会有什么问题），然后他们发现其性能相当糟糕。

想看看以上代码到底是如何工作的，可以用JDK自带的工具javap来反编译以上代码。命令如下：

![20200228105534376.png][]

这里-c标志表示将生产JVM字节码。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMjk4MzUx_size_16_color_FFFFFF_t_70][]

如果你有汇编语言的经验，以上代码一定看着眼熟，其中dup与invokevirtural语句相当于java虚拟机上的汇编语句。即使你完全不了解汇编语言也无需担心，需要注意的重点是：编译器自动引用了java.lang.StringBuilder类。虽然我们在源代码中并没有使用StringBuilder类，但是编译器却自作主张的使用了它，因为它更高效。

在这个例子中，编译器创建了一个StringBuilder，用以构造最终的String，并为每个字符串调用一次StringBuilder的append()方法。最后调用toString()生成结果，并存为s（使用的命令为astore\_2）。

现在，也许你会觉得可以随意使用String对象，反正编译器会为你自动地优化性能。可是在这之前，让我们更深入的看看编译器能为我们优化到什么程度。下面的程序采用两种方法生成一个String：方法一使用多个String对象；方法二在代码中使用了StringBuilder。

public class WhitherStringBuilder {
    	public String implicit(String[] fields) {
    		String result = "";
    		for (int i = 0; i < fields.length; i++)
    			result += fields[i];
    		return result;
    	}
    
    	public String explicit(String[] fields) {
    		StringBuilder result = new StringBuilder();
    		for (int i = 0; i < fields.length; i++)
    			result.append(fields[i]);
    		return result.toString();
    	}
    }

现在运行javap -c WitherStringBuilder，可以看到两个方法对应的字节码。首先是implicit()方法：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMjk4MzUx_size_16_color_FFFFFF_t_70 1][]

要注意的重点是：StringBuilder是在循环之内构造的，这意味着每经过循环一次，就会创建一个新的StringBuilder对象。

下面是explicit()方法对应的字节码：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMjk4MzUx_size_16_color_FFFFFF_t_70 2][]

可以看到，不仅循环部分的代码更简短、更简单，而且它只生成了一个StringBuilder对象。显示地创建StringBuilder还允许你预先为其指定大小。如果你已经知道最终的字符串大概有多长，那预先指定StringBuilder的大小可以避免多次重新分配缓冲。

因此，当你为一个类编写toString()方法时，如果字符串操作比较简单，那就可以信赖编译器，它会为你合理的构造最终的字符串结果。但是，如果你要在toString()方法中使用循环，那么最好自己创建一个StringBuilder对象，用它来构造最终的结果。请参考以下示例：

import java.util.Random;
    
    public class UsingStringBuilder {
    	public static Random r = new Random();
    
    	public String toString() {
    		StringBuilder result = new StringBuilder("[");
    		for (int i = 0; i < 25; i++) {
    			result.append(r.nextInt(100));
    			result.append(", ");
    		}
    		result.delete(result.length() - 2, result.length());
    		result.append("]");
    		return result.toString();
    	}
    
    	public static void main(String[] args) {
    		UsingStringBuilder usb = new UsingStringBuilder();
    		System.out.println(usb);
    	}
    }

最终的结果是用append()语句一点点拼接起来的。如果你想走捷径，例如append(a + ":" + c)，那编译器就会掉入陷阱，从而为你另外创建一个StringBuilder对象处理括号内的字符串操作。如果拿不准该用哪种方式，随刻可以用javap来分析你的程序。

StringBuilder提供了丰富而全面的方法，包括insert()、replace()、subString()甚至reverse()，但是最常用的还是append()和toString()。还有delete()方法，上面的例子中我们用它删除最后一个逗号与空格，以便添加右括号。

StringBuilder是java SE5引入的，在这之前java用的是StringBuffer。后者是线程安全的，因此开销也会大些。

### 三、无意识的递归 ###

java中的每个类从根本上都是继承自Object，标准容器类自然也不例外。因此容器类都有toString()方法，并且覆写了该方法，使得它生成的String结果能够表达容器自身，以及容器所包含的对象。例如ArrayList.toString()，它会遍历ArrayList中包含的所有对象，调用每个元素上的toString()方法：

import java.util.ArrayList;
    
    public class ArrayListDisplay {
    	public static void main(String[] args) {
    		ArrayList<String> list = new ArrayList<>();
    		list.add("qwer");
    		list.add("asdf");
    		list.add("zxcv");
    		list.add("1234");
    		System.out.println(list);
    	}
    }

如果希望toString()方法打印出对象的内存地址，也许你会考虑使用this关键字：

import java.util.ArrayList;
    import java.util.List;
    
    public class InfiniteRecursion {
    	public String toString() {
    		return "InfiniteRecursion address: " + this + "\n";
    	}
    
    	public static void main(String[] args) {
    		List<InfiniteRecursion> v = new ArrayList<>();
    		for (int i = 0; i < 10; i++)
    			v.add(new InfiniteRecursion());
    		System.out.println(v);
    	}
    }

当你创建InfiniteRecursion对象，并将其打印出来的时候，你会得到一串非常长的异常。如果你将该InfiniteRecursion对象存入一个ArrayList中，然后打印该ArrayList，你也会得到同样的异常。其实，当如下代码运行时：

"InfiniteRecursion address: " + this

这里发生了自动类型转换，由InfiniteRecursion类型转换成String类型。因为编译器看到一个String对象后面跟着一个“+”,而在后面的对象不是String，于是编译器试着将this转换成一个String。它怎么转换呢，正是通过调用this上的toString()方法，于是就发生了递归调用。

如果你真的想要打印出对象的内存地址。应该调用Object.toString()方法，这才是负责此任务的方法。所以，你不该使用this，而是应该调用super.toString()方法。

**如果本文对您有很大的帮助，还请点赞关注一下。**

[20200228105534376.png]: https://img-blog.csdnimg.cn/20200228105534376.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMjk4MzUx_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200228105743764.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMjk4MzUx,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMjk4MzUx_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20200228111955312.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMjk4MzUx,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMjk4MzUx_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20200228113104911.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMjk4MzUx,size_16,color_FFFFFF,t_70