阿里巴巴Java开发手册中的开发规约之一(3)

包装类比较

• 【强制】所有的相同类型的包装类对象之间值的比较，全部使用 equals 方法比较。

  • 说明： 对于 Integer var=? 在-128 至 127 之间的赋值， Integer 对象是在
    IntegerCache.cache 产生，会复用已有对象，这个区间内的 Integer 值可以直接使用 == 进行
    判断，但是这个区间之外的所有数据，都会在堆上产生，并不会复用已有对象，这是一个大坑，
    推荐使用 equals 方法进行判断。

• 举例：

  @Test
  public void test(){
      Integer integer1 = new Integer(1);
      Integer integer2 = new Integer(1);
      System.out.println(integer1 == integer2);//false
  
      Integer integer3 = 1;
      Integer integer4 = 1;
      System.out.println(integer3 == integer4);//true
  
      System.out.println(integer1 == integer4);//false
  
      Integer integer5 = 128;
      Integer integer6 = 128;
      System.out.println(integer5 == integer6);//false
  }

---

ArrayList.subList

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

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

@Test
public void test(){
    List<String> list = new ArrayList<String>();
    list.add("a");
    System.out.println(list); //[a]
    
    // 使用构造器创建一个包含list的列表list1
    List<String> list1 = new ArrayList<String>(list);
    // 使用subList生成与list相同的列表list2
    List<String> list2 = list.subList(0, list.size());
    list2.add("b");

    System.out.println(list1);//[a]
    System.out.println(list);//[a,b]
    System.out.println(list2);//[a,b]
    System.out.println(list.equals(list1));
    System.out.println(list.equals(list2));
}

---

Arrays.asList()

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

  • 说明： asList 的返回对象是一个 Arrays 内部类，并没有实现集合的修改方法。Arrays.asList 体现的是适配器模式，只是转换接口，后台的数据仍是数组。

    String[] str = new String[] { "a", "b" };
    List list = Arrays.asList(str);

1. 第一种情况： list.add("c"); 运行时异常。
2. 第二种情况： str[0]= "gujin"; 那么 list.get(0)也会随之修改。

详细说明

• 报错信息

  Exception in thread "main" java.lang.UnsupportedOperationException
      at java.util.AbstractList.add(AbstractList.java:148)
      at java.util.AbstractList.add(AbstractList.java:108)
      at com.liu.date20170702.TestArrayToList.main(TestArrayToList.java:17)

当我们调用add()方法时抛出了异常。我们顺着堆栈信息往上找，提示的是AbstractList类的108行出了异常，这一行所在方法的具体实现如下：

public boolean add(E e) {
    add(size(), e);
    return true;
}

出现异常的第108行调用了add()方法，于是继续寻找这个add()方法的实现，具体如下：

public void add(int index, E element) {
    throw new UnsupportedOperationException();
}

到这里我们找到了异常抛出的地方，但是如果要找到真正的原因，我们还需要看下示例代码中的 asList() 方法的实现，具体如下：

public static <T> List<T> asList(T... a) {
    return new ArrayList<>(a);
}

可以发现，他返回的是一个ArrayList，但此ArrayList不是彼ArrayList。这个ArrayList是Arrays工具类中实现的 内部静态类 ，跟在java.util包中ArrayList不同。

private static class ArrayList<E> extends AbstractList<E>
    implements RandomAccess, java.io.Serializable
{
    private static final long serialVersionUID = -2764017481108945198L;
    private final E[] a;

    ArrayList(E[] array) {
        a = Objects.requireNonNull(array);
    }

    @Override
    public int size() {
        return a.length;
    }

    @Override
    public Object[] toArray() {
        return a.clone();
    }

    @Override
    @SuppressWarnings("unchecked")
    public <T> T[] toArray(T[] a) {
        int size = size();
        if (a.length < size)
            return Arrays.copyOf(this.a, size,
                                    (Class<? extends T[]>) a.getClass());
        System.arraycopy(this.a, 0, a, 0, size);
        if (a.length > size)
            a[size] = null;
        return a;
    }

    @Override
    public E get(int index) {
        return a[index];
    }

    @Override
    public E set(int index, E element) {
        E oldValue = a[index];
        a[index] = element;
        return oldValue;
    }

    @Override
    public int indexOf(Object o) {
        E[] a = this.a;
        if (o == null) {
            for (int i = 0; i < a.length; i++)
                if (a[i] == null)
                    return i;
        } else {
            for (int i = 0; i < a.length; i++)
                if (o.equals(a[i]))
                    return i;
        }
        return -1;
    }

    @Override
    public boolean contains(Object o) {
        return indexOf(o) != -1;
    }

    @Override
    public Spliterator<E> spliterator() {
        return Spliterators.spliterator(a, Spliterator.ORDERED);
    }

    @Override
    public void forEach(Consumer<? super E> action) {
        Objects.requireNonNull(action);
        for (E e : a) {
            action.accept(e);
        }
    }

    @Override
    public void replaceAll(UnaryOperator<E> operator) {
        Objects.requireNonNull(operator);
        E[] a = this.a;
        for (int i = 0; i < a.length; i++) {
            a[i] = operator.apply(a[i]);
        }
    }

    @Override
    public void sort(Comparator<? super E> c) {
        Arrays.sort(a, c);
    }
}

可以发现，这个类集成了 AbstractList 类，但是并没有重写add()方法，所以在我们调用 add() 方法时，实际是调用 父类AbstractList 的 add()方法，这也就回到了开头分析的那两个add()方法了，它们都没有具体实现，只会抛出UnsupportedOperationException。

原因总结

• 到这里我们可以稍稍理清下思路了，我们调用Arrays的asList()方法将数组转换成List时返回的是Arrays的静态内部类ArrayList，它自身并未重写add()方法，而其父类AbstractList实现的add()方法只会抛出UnsupportedOperationException，导致我们调用Arrays的静态内部类ArrayList的add()方法时，实际调用的是只会抛出UnsupportedOperationException的AbstractList的add()方法，这就是异常出现的原因了。

---