【编写高质量代码：改善Java程序的151个建议】第4章:字符串___建议52~59

灰太狼 2021-08-24 23:07 287阅读 0赞

生活不只眼前的苟且。还有读不懂的诗和到不了的远方。 --闫妮

## 建议52：推荐使用String直接赋值 ##

## 建议53：注意方法中传递的参数要求 ##

## 建议54：正确使用String、StringBuffer、StringBuilder ##

### 1、Java String类 ###

字符串广泛应用在Java编程中，在Java中字符串属于对象，Java提供了String类来创建和操作字符串。

需要注意的是String的值是不可变的，这就导致每次对String的操作都会生成新的String对象，这样不仅效率低下，而且浪费有限的内存空间。

我们可以看到，初始String值为“hello”，然后在这个字符串后面加上新的字符串“world”，这个过程是需要重新在栈堆内存中开辟内存空间的，最终得到了“hello world”字符串也相应的需要开辟内存空间，这样短短的两个字符串，却需要开辟三次内存空间，不得不说这是对内存空间的**极大浪费**。为了应对经常性的字符串相关的操作，Java引入了两个新的类——StringBuffer类和StringBuild类来对此种变化字符串进行处理。

### 2、StringBuffer 和 StringBuilder 类 ###

三者区别：

string：不可变字符序列

StringBuffer：可变字符序列、线程安全、效率低

StringBuilder：可变字符序列、线程不安全、效率高

注：

String的使用陷阱：

String  ss = "a";

ss +="b";

如果多次执行这些改变字符串内容的操作，会导致大量副本字符串对象存在内存中，降低效率。如果这样的操作放在循环中，会极大影响程序的性能。

### 3、性能测试 ###

String的拼接与StringBuilder的使用对比，简单的12个字符串的循环解析拼接，相差了28毫秒，没有对比就没有伤害，以后用StringBuilder吧，暂时还不知道这个东西会有什么弊端，持续观察吧

![ee4f3054569c9dee6d67fe1f0b1f096dda7.jpg][]

## 建议55：注意字符串的位置 ##

public class Client55 {
        public static void main(String[] args) {
            String str1 = 1 + 2 + "apples";
            String str2 = "apples" + 1 + 2;
            System.out.println(str1);
            System.out.println(str2);
        }
    }

答案是不一致，str1的值是"3apples" ,str2的值是“apples12”。

## 建议56：自由选择字符串的拼接方法 ##

package OSChina.Client;
    
    public class Client1 {
        public static void main(String[] args) {
            // 加号拼接
            String str = "";
            long start1 = System.currentTimeMillis();
            for (int i = 0; i < 100000; i++) {
                str += "江疏影";
            }
            long end1 = System.currentTimeMillis();
            System.out.println("加号拼接耗时：" + (end1 - start1) + "ms");
    
            // concat拼接
            str = "";
            long start2 = System.currentTimeMillis();
            for (int i = 0; i < 100000; i++) {
                str = str.concat("江疏影");
            }
            long end2 = System.currentTimeMillis();
            System.out.println("concat拼接耗时：" + (end2 - start2) + "ms");
    
            // StringBuilder拼接
            str = "";
            StringBuilder buffer = new StringBuilder("");
            long start3 = System.currentTimeMillis();
            for (int i = 0; i < 10000000; i++) {
                buffer.append("江疏影");
            }
            long end3 = System.currentTimeMillis();
            System.out.println("StringBuilder拼接耗时：" + (end3 - start3) + "ms");
    
            // StringBuffer拼接
            str = "";
            StringBuffer sb = new StringBuffer("");
            long start4 = System.currentTimeMillis();
            for (int i = 0; i < 10000000; i++) {
                sb.append("江疏影");
            }
            long end4 = System.currentTimeMillis();
            System.out.println("StringBuffer拼接耗时：" + (end4 - start4) + "ms");
        }
    }

![85e258fed27efcfebf0c62a2cf20d881c90.jpg][]

从上面的执行结果来看，在字符串拼接方式中,StringBuilder的append方法最快，StringBuffer的append方法次之（因为StringBuffer的append方法是线程安全的，同步方法自然慢一点），其次是concat方法，加号最慢，这是为何呢？

速度：StringBuilder>StringBuffer>concat>String+

原理：

1、“+”方法拼接字符串：

str= new StringBuilder(str).append("c").toString();

它与纯粹使用StringBuilder的append方法是不同的：一是每次循环都会创建一个StringBuilder对象，二是每次执行完毕都要调用toString方法将其转换为字符串——它的执行时间就耗费在这里了！

2、concat方法拼接字符串：我们从源码上看一下concat方法的实现，代码如下：

public String concat(String str) {
            int otherLen = str.length();
            //如果追加字符长度为0，则返回字符串本身
            if (otherLen == 0) {
                return this;
            }
            int len = value.length;
            char buf[] = Arrays.copyOf(value, len + otherLen);
            str.getChars(buf, len);
            //产生一个新的字符串
            return new String(buf, true);
        }

其整体看上去就是一个数组拷贝，虽然在内存中处理都是原子性操作，速度非常快，不过，注意看最后的return语句，每次concat操作都会创建一个String对象，这就是concat速度慢下来的真正原因，它创建了10万个String对象呀。

3、append方法拼接字符串：StringBuilder的append方法直接由父类AbstractStringBuilder实现，其代码如下：

public AbstractStringBuilder append(String str) {
       //如果是null值，则把null作为字符串处理
       if (str == null) str = "null";
       int len = str.length();
       ensureCapacityInternal(count + len);
       //字符串复制到目标数组
       str.getChars(0, len, value, count);
       count += len;
       return this;
    }

整个append方法都在做字符数组处理，加长，然后拷贝数组，这些都是基本的数据处理，没有创建任何对象，所以速度也就最快。

4、StringBuffer的处理和此类似，只是方法是同步的而已。

## 建议57：推荐在复杂字符串操作中使用正则表达式 ##

## 建议58：强烈建议使用UTF编码 ##

注：一个系统使用统一的编码。

## 建议59：对字符串持有一种宽容的心态 ##

中文的排序问题很混乱，Java使用UNICODE编码，而中文UNICODE字符集来源于GB2312，GB2312是一个包含了7000多个字符的字符集，它是按照拼音排序，并且是连续的，之后的GBK、GB18030都是在其基础上扩充而来的，所以要让它们完整的排序也就难上加难了。

如果排序对象是经常使用的汉字，使用Collator类排序完全可以满足我们的要求，毕竟GB2312已经包含了大部分的汉字，如果需要严格排序，则要使用一些开源项目来自己实现了。

注意：如果排序不是一个关键算法，使用Collator类即可。

[ee4f3054569c9dee6d67fe1f0b1f096dda7.jpg]: /images/20210813/8abd09135a354cb4b529928e9591677b.png
[85e258fed27efcfebf0c62a2cf20d881c90.jpg]: /images/20210813/5904b357fc744c89821896c1b99c12af.png