《阿里巴巴 Java 开发手册》笔记——第1章编程约规（二）(待补充）

阅读量：2344 次

发布时间：2019-05-10

本文共 12285 字，大约阅读时间需要 40 分钟。

文章目录

声明：

本博客是本人在学习《阿里巴巴 Java 开发手册》后整理的笔记，旨在方便复习和回顾，并非用作商业用途。

本博客已标明出处，如有侵权请告知，马上删除。

5. 集合处理

【强制】关于 hashCode 和 equals 的处理，遵循如下规则：
- 只要重写 equals，就必须重写 hashCode。
- 因为 Set 存储的是不重复的对象，依据 hashCode 和 equals 进行判断，所以 Set 存储的对象必须重写这两个方法。
- 如果自定义对象作为 Map 的键，那么必须重写 hashCode 和 equals。
说明：String 重写了 hashCode 和 equals 方法，所以我们可以非常愉快地使用 String 对象作为 key 来使用。

【强制】ArrayList 的 subList 结果不可强转成 ArrayList，否则会抛出 ClassCastException 异常，即 java.util.RandomAccessSubList cannot be cast to java.util.ArrayList

说明：subList 返回的是 ArrayList 的内部类 SubList，并不是 ArrayList ，而是 ArrayList 的一个视图，对于 SubList 子列表的所有操作最终会反映到原列表上。

反例：

public static void main(String[] args) {
         ArrayList
     
       list = new ArrayList<>(3);    list.add("a");    list.add("b");    list.add("c");    ArrayList
      
        subList = (ArrayList
       
        ) list.subList(0, 1);}

运行结果：

Exception in thread "main" java.lang.ClassCastException: java.util.ArrayList$SubList cannot be cast to java.util.ArrayList	at arraylisttest.Test.main(Test.java:19)

正例：

public static void main(String[] args) {
         ArrayList
     
       list = new ArrayList<>(3);    list.add("a");    list.add("b");    list.add("c");    ArrayList
      
        subList = new ArrayList<>(list.subList(0, 1));}

【强制】在 subList 场景中，高度注意对原集合元素个数的修改，会导致子列表的遍历、增加、删除均会产生 ConcurrentModificationException 异常。

反例：

public static void main(String[] args) {
         ArrayList
     
       list = new ArrayList<>(3);    list.add("a");    list.add("b");    list.add("c");    List
      
        subList = list.subList(0, list.size());    // 遍历子列表    for (String s : subList) {
             System.out.println(s);    }    System.out.println("---------------------");    // 修改原集合个数    list.add("d");    // 再次遍历子列表，产生 ConcurrentModificationException 异常    for (String s : subList) {
             System.out.println(s);    }}

运行结果：

abc---------------------Exception in thread "main" java.util.ConcurrentModificationException	at java.util.ArrayList$SubList.checkForComodification(ArrayList.java:1231)	at java.util.ArrayList$SubList.listIterator(ArrayList.java:1091)	at java.util.AbstractList.listIterator(AbstractList.java:299)	at java.util.ArrayList$SubList.iterator(ArrayList.java:1087)	at arraylisttest.Test.main(Test.java:27)

【强制】使用集合转数组的方法，必须使用集合的 toArray(T[] array)，传入的是类型完全一样的数组，大小就是 list.size()。

说明：使用 toArray 带参方法，入参分配的数组空间不够大时，toArray 方法内部将重新分配内存空间，并返回新数组地址；如果数组元素个数大于实际所需，下标为[ list.size() ] 的数组元素将被置为 null，其它数组元素保持原值，因此最好将方法入参数组大小定义与集合元素个数一致。

正例：
```
public static void main(String[] args) {
         List
     
       list = new ArrayList
      
       (2);    list.add("guan");    list.add("bao");    String[] array = new String[list.size()];    array = list.toArray(array);}
      
     
```
反例：直接使用 toArray 无参方法存在问题，此方法返回值只能是 Object[] 类，若强转其它类型数组将出现 ClassCastException 错误。

【强制】使用工具类 Arrays.asList() 把数组转换成集合时，不能使用其修改集合相关的方法，它的 add/remove/clear 方法会抛出 UnsupportedOperationException 异常。

说明：asList 的返回对象是一个 Arrays 内部类，并没有实现集合的修改方法。Arrays.asList 体现的是适配器模式，只是转换接口，后台的数据仍是数组。
```
String[] str = new String[] {
      "you", "wu" }; List list = Arrays.asList(str);
```
第一种情况：list.add(“yangguanbao”); 会抛出 UnsupportedOperationException 异常。

第二种情况：str[0] = “gujin”; 那么 list.get(0) 也会随之修改。

要使用其修改集合相关的方法，应该新建一个 ArrayList：
```
public static void main(String[] args) {
         String[] str = new String[]{
     "you", "wu"};    List list = new ArrayList(Arrays.asList(str));}
```

【强制】泛型通配符 <? extends T> 来接收返回的数据，此写法的泛型集合不能使用 add 方法，而 <? super T> 不能使用 get 方法，作为接口调用赋值时易出错。

说明：扩展说一下 PECS(Producer Extends Consumer Super)原则：第一、频繁往外读取内容的，适合用 <? extends T>。第二、经常往里插入的，适合用 <? super T>。

【强制】不要在 foreach 循环里进行元素的 remove/add 操作，有可能产生 ConcurrentModificationException 异常。remove 元素请使用 Iterator 方式，如果并发操作，需要对 Iterator 对象加锁。

正例：
```
public static void main(String[] args) {
         Iterator
     
       iterator = list.iterator();    while (iterator.hasNext()) {
             String item = iterator.next();        if (删除元素的条件) {
                 iterator.remove();        }    }}
     
```
反例：
```
public static void main(String[] args) {
         List
     
       list = new ArrayList
      
       ();    list.add("1");    list.add("2");    for (String item : list) {
             if ("1".equals(item)) {
                 list.remove(item);        }    }}
      
     
```
说明：以上代码的执行结果肯定会出乎大家的意料，那么试一下把 “1” 换成 “2”，会是同样的结果吗？

把 “1” 换成 “2” 后，产生 ConcurrentModificationException 异常。

为什么会产生 ConcurrentModificationException 异常呢？
1. 首先，我们知道 foreach 循环实际上用根据 list 对象创建一个 iterator 迭代对象，通过 iterator 的 hasNext() 和 next() 方法来遍历 list
2. 通过集合对象删除元素后，只增加了实际修改次数，而预期修改次数不变
```
private void fastRemove(int index) {
           modCount++;	...}
```
3. 而调用迭代器的 next 方法时，检查到实际修改次数和预期修改次数不相等就会抛出 ConcurrentModificationException
```
final void checkForComodification() {
           if (modCount != expectedModCount)        throw new ConcurrentModificationException();}
```
4. 解决办法就是使用迭代器的 remove 方法，因为迭代器的删除方法会将实际修改次数赋值给预期修改次数
那为什么 “1” 时，不产生 ConcurrentModificationException 异常呢？
1. 如果删除的元素是倒数第二个的话，其实是不会报错的。
2. 之前说了 foreach 循环会走两个方法 hasNext() 和 next()。如果不想报错的话，只要不进 next() 方法就好啦，看看 hasNext() 的方法。
```
public boolean hasNext() {
           return cursor != size;}
```
3. 当遍历到倒数第二个元素时，cursor == size 就不会进入到 next() 方法中了，也就不会报错了。

【强制】在 JDK7 版本及以上，Comparator 要满足如下三个条件，不然 Arrays.sort，Collections.sort 会报 IllegalArgumentException 异常。

三个条件如下：
- 自反性：x，y 的比较结果和 y，x 的比较结果相反。
- 传递性：x>y，y>z，则 x>z。
- 对称性：x=y，则 x，z 比较结果和 y，z 比较结果相同。
反例：下例中没有处理相等的情况，实际使用中可能会出现异常：
```
new Comparator
     
      () {
         @Override    public int compare(Student o1, Student o2) {
             return o1.getId() > o2.getId() ? 1 : -1;    }};
     
```
正例：
```
new Comparator
     
      () {
         @Override    public int compare(Student o1, Student o2) {
             return (o1.getId() == o2.getId()) ? 0 : (o1.getId() > o2.getId() ? 1 : -1);    }};
     
```

【推荐】集合初始化时，指定集合初始值大小。

说明：HashMap 使用 HashMap(int initialCapacity) 初始化

正例：initialCapacity = (需要存储的元素个数 / 负载因子) + 1。注意负载因子（即 loader factor）默认为 0.75，如果暂时无法确定初始值大小，请设置为 16（即默认值）。

反例：HashMap 需要放置 1024 个元素，由于没有设置容量初始大小，随着元素不断增加，容量 7 次被迫扩大，resize 需要重建 hash 表，严重影响性能。

为什么使用 initialCapacity = (需要存储的元素个数 / 负载因子) + 1 设置初始值大小呢？
1. 当我们设置 HashMap 的初始化容量是遵循（需要存储的元素个数 / 负载因子）+ 1，比如需要存储的元素个数是 6 时， 6/0.75+1=9，此时 jdk 处理后会被设置成 16，大大降低了 HashMap 被扩容的几率。
2. 当我们通过 HashMap（int initialCapacity）设置初始容量时，HashMap 不一定会采取我们设置的初始容量，会根据计算得到一个新的值（2 的指数幂），以保证 hash 的效率。
为什么 HashMap 容量一定要是 2 的指数幂呢？
1. 使用减法替代取模，提升计算效率
  
  capacity 为 2 的整数次幂的话，计算保存位置 h&(length-1) 等同于求模运算：h%length，提升了计算效率。
2. 为了使不同 hash 值发生碰撞的概率更小，尽可能促使元素在哈希表中均匀地散列
  
  capacity 为 2 的整数次幂的话，为偶数，这样 capacity-1 为奇数，奇数的最后一位是 1，这样便保证了 h&(capacity-1) 的最后一位可能为 0，也可能为 1（这取决于 h 的值），即与后的结果可能为偶数，也可能为奇数，这样便可以保证散列的均匀性。
  
  而如果 capacity 为奇数的话，很明显 capacity-1 为偶数，它的最后一位是 0，这样 h&(capacity-1) 的最后一位肯定为 0，即只能为偶数，这样任何 hash 值都只会被散列到数组的偶数下标位置上，这便浪费了近一半的空间。

【推荐】使用 entrySet 遍历 Map 类集合 KV，而不是 keySet 方式进行遍历。

说明：keySet 其实是遍历了 2 次，一次是转为 Iterator 对象，另一次是从 hashMap 中取出 key 所对应的 value。而 entrySet 只是遍历了一次就把 key 和 value 都放到了 entry 中，效率更高。如果是 JDK8，使用 Map.foreach 方法。
```
public static void main(String[] args) {
         Map
     
       map = new HashMap<>(5);    map.put("a", "A");    map.put("b", "B");    map.put("c", "C");    // entrySet 遍历    for (Map.Entry
      
        entry : map.entrySet()) {
             System.out.println(entry.getKey() + "-" + entry.getValue());    }    // JDK 8    map.forEach((key, val) -> System.out.println(key + "-" + val));}
      
     
```
正例：values() 返回的是 V 值集合，是一个 list 集合对象；keySet() 返回的是 K 值集合，是一个 Set 集合对象；entrySet() 返回的是 K-V 值组合集合。

【推荐】高度注意 Map 类集合 K/V 能不能存储 null 值的情况，如下表格：

集合类	Key	Value	Super	说明
Hashtable	不允许为 null	不允许为 null	Dictionary	线程安全
ConcurrentHashMap	不允许为 null	不允许为 null	AbstractMap	锁分段技术（JDK8:CAS）
TreeMap	不允许为 null	允许为 null	AbstractMap	线程不安全
HashMap	允许为 null	允许为 null	AbstractMap	线程不安全

反例：由于 HashMap 的干扰，很多人认为 ConcurrentHashMap 是可以置入 null 值，而事实上，存储 null 值时会抛出 NPE 异常。

【参考】合理利用好集合的有序性（sort）和稳定性（order），避免集合的无序性（unsort）和不稳定性（unorder）带来的负面影响。

说明：有序性是指遍历的结果是按某种比较规则依次排列的。稳定性指集合每次遍历的元素次序是一定的。如：ArrayList 是 order/unsort；HashMap 是 unorder/unsort；TreeSet 是 order/sort。

【参考】利用 Set 元素唯一的特性，可以快速对一个集合进行去重操作，避免使用 List 的 contains 方法进行遍历、对比、去重操作。

正例：

public static void main(String[] args) {
         List
     
       list = new ArrayList<>(4);    list.add("a");    list.add("b");    list.add("b");    list.add("c");    list = new ArrayList<>(new HashSet<>(list));    list.forEach(System.out::println);}

6. 并发处理（待补充）

7. 控制语句

【强制】在一个 switch 块内，每个 case 要么通过 break/return 等来终止，要么注释说明程序将继续执行到哪一个 case 为止；在一个 switch 块内，都必须包含一个 default 语句并且放在最后，即使空代码。

【强制】在 if/else/for/while/do 语句中必须使用大括号。即使只有一行代码，避免采用单行的编码方式：if (condition) statements;

【强制】在高并发场景中，避免使用 ”等于” 判断作为中断或退出的条件。

说明：如果并发控制没有处理好，容易产生等值判断被 “击穿” 的情况，使用大于或小于的区间判断条件来代替。

反例：判断剩余奖品数量等于 0 时，终止发放奖品，但因为并发处理错误导致奖品数量瞬间变成了负数，这样的话，活动无法终止。

【推荐】表达异常的分支时，少用 if-else 方式，这种方式可以改写成：

if (condition) {
      	... 	return obj; } // 接着写 else 的业务逻辑代码;

说明：如果非得使用 if()…else if()…else… 方式表达逻辑，【强制】避免后续代码维护困难，请勿超过 3 层。

正例：超过 3 层的 if-else 的逻辑判断代码可以使用卫语句、策略模式、状态模式等来实现，其中卫语句示例如下：

public void today() {
         if (isBusy()) {
             System.out.println(“change time.”);        return;    }    if (isFree()) {
             System.out.println(“go to travel.”);        return;    }    System.out.println(“stay at home to learn Alibaba Java Coding Guidelines.”);    return;}

【推荐】除常用方法（如 getXxx/isXxx）等外，不要在条件判断中执行其它复杂的语句，将复杂逻辑判断的结果赋值给一个有意义的布尔变量名，以提高可读性。

说明：很多 if 语句内的逻辑相当复杂，阅读者需要分析条件表达式的最终结果，才能明确什么样的条件执行什么样的语句，那么，如果阅读者分析逻辑表达式错误呢？

正例：
```
// 伪代码如下final boolean existed = (file.open(fileName, "w") != null) && (...) || (...);if (existed) {
     	...}
```
反例：
```
if ((file.open(fileName, "w") != null) && (...) || (...)) {
     	...}
```

【推荐】循环体中的语句要考量性能，以下操作尽量移至循环体外处理，如定义对象、变量、获取数据库连接，进行不必要的 try-catch 操作（这个 try-catch 是否可以移至循环体外）。

【推荐】避免采用取反逻辑运算符。

说明：取反逻辑不利于快速理解，并且取反逻辑写法必然存在对应的正向逻辑写法。

正例：使用 if (x < 628) 来表达 x 小于 628。

反例：使用 if (!(x >= 628)) 来表达 x 小于 628。

【推荐】接口入参保护，这种场景常见的是用作批量操作的接口。

【参考】下列情形，需要进行参数校验：
- 调用频次低的方法。
- 执行时间开销很大的方法。此情形中，参数校验时间几乎可以忽略不计，但如果因为参数错误导致中间执行回退，或者错误，那得不偿失。
- 需要极高稳定性和可用性的方法。
- 对外提供的开放接口，不管是 RPC/API/HTTP 接口。
- 敏感权限入口。

【参考】下列情形，不需要进行参数校验：
- 极有可能被循环调用的方法。但在方法说明里必须注明外部参数检查要求。
- 底层调用频度比较高的方法。毕竟是像纯净水过滤的最后一道，参数错误不太可能到底层才会暴露问题。一般 DAO 层与 Service 层都在同一个应用中，部署在同一台服务器中，所以 DAO 的参数校验，可以省略。
- 被声明成 private 只会被自己代码所调用的方法，如果能够确定调用方法的代码传入参数已经做过检查或者肯定不会有问题，此时可以不校验参数。

8. 注释约规

【强制】类、类属性、类方法的注释必须使用 Javadoc 规范，使用 /**内容*/ 格式，不得使用 // xxx 方式。

说明：在 IDE 编辑窗口中，Javadoc 方式会提示相关注释，生成 Javadoc 可以正确输出相应注释；在 IDE 中，工程调用方法时，不进入方法即可悬浮提示方法、参数、返回值的意义，提高阅读效率。

【强制】所有的抽象方法（包括接口中的方法）必须要用 Javadoc 注释、除了返回值、参数、异常说明外，还必须指出该方法做什么事情，实现什么功能。

说明：对子类的实现要求，或者调用注意事项，请一并说明。

【强制】所有的类都必须添加创建者和创建日期。

【强制】方法内部单行注释，在被注释语句上方另起一行，使用 // 注释。方法内部多行注释使用 /* */ 注释，注意与代码对齐。

【强制】所有的枚举类型字段必须要有注释，说明每个数据项的用途。

【推荐】与其“半吊子”英文来注释，不如用中文注释把问题说清楚。专有名词与关键字保持英文原文即可。

反例：“TCP 连接超时”解释成“传输控制协议连接超时”，理解反而费脑筋。

【推荐】代码修改的同时，注释也要进行相应的修改，尤其是参数、返回值、异常、核心逻辑等的修改。

说明：代码与注释更新不同步，就像路网与导航软件更新不同步一样，如果导航软件严重滞后，就失去了导航的意义。

【参考】谨慎注释掉代码。在上方详细说明，而不是简单地注释掉。如果无用，则删除。

说明：代码被注释掉有两种可能性：
- 后续会恢复此段代码逻辑。
- 永久不用。前者如果没有备注信息，难以知晓注释动机。后者建议直接删掉（代码仓库保存了历史代码）。

【参考】对于注释的要求：第一、能够准确反应设计思想和代码逻辑；第二、能够描述业务含义，使别的程序员能够迅速了解到代码背后的信息。完全没有注释的大段代码对于阅读者形同天书，注释是给自己看的，即使隔很长时间，也能清晰理解当时的思路；注释也是给继任者看的，使其能够快速接替自己的工作。

【参考】好的命名、代码结构是自解释的，注释力求精简准确、表达到位。避免出现注释的一个极端：过多过滥的注释，代码的逻辑一旦修改，修改注释是相当大的负担。

反例：
```
// put elephant into fridge  put(elephant, fridge);
```
方法名 put，加上两个有意义的变量名 elephant 和 fridge，已经说明了这是在干什么，语义清晰的代码不需要额外的注释。

【参考】特殊注释标记，请注明标记人与标记时间。注意及时处理这些标记，通过标记扫描，经常清理此类标记。线上故障有时候就是来源于这些标记处的代码。
- 待办事宜（TODO）:（标记人，标记时间，[预计处理时间]）
  
  表示需要实现，但目前还未实现的功能。这实际上是一个 Javadoc 的标签，目前的 Javadoc 还没有实现，但已经被广泛使用。只能应用于类，接口和方法（因为它是一个 Javadoc 标签）。
- 错误，不能工作（FIXME）:（标记人，标记时间，[预计处理时间]）
  
  在注释中用 FIXME 标记某代码是错误的，而且不能工作，需要及时纠正的情况。

9. 其它

【强制】在使用正则表达式时，利用好其预编译功能，可以有效加快正则匹配速度。

说明：不要在方法体内定义：Pattern pattern = Pattern.compile(规则);

【强制】velocity 调用 POJO 类的属性时，建议直接使用属性名取值即可，模板引擎会自动按规范调用 POJO 的 getXxx()，如果是 boolean 基本数据类型变量（boolean 命名不需要加 is 前缀），会自动调用 isXxx() 方法。

说明：注意如果是 Boolean 包装类对象，优先调用 getXxx() 的方法。