编写高质量代码:改善Java程序的151个建议 --[65~78]

原始类型数组不能作为asList的输入参数，否则会引起程序逻辑混乱。

public class Client65 {

    public static void main(String[] args) {

        int data [] = {1,2,3,4,5};

        List list= Arrays.asList(data);

        System.out.println("元素类型是："+list.get(0).getClass());

        System.out.println("前后是否相等："+data.equals(list.get(0)));

    }

}

输出的结果是：元素类型是：class [I 前后是否相等：true

如果要转换，建议转换为对应的包装类，再使用 List list= Arrays.asList(data)来转换

asList方法产生的List的对象不可更改

添加修改Arrays.asList后的list数据会产生如下错误

频繁插入和删除时使用LinkList

在修改动作上，LinkedList比ArrayList慢很多，特别是要进行大量的修改时，两者完全不在一个数量级上。

LinkedList删除和插入效率高；ArrayList修改元素效率高。

判断集合是否相等时只须关注元素是否相等即可

import java.util.ArrayList;

import java.util.Vector;

public class Client69 {

    public static void main(String[] args) {

        ArrayList<String> strs = new ArrayList<String>();

        strs.add("A");

        Vector<String> strs2 = new Vector<String>();

        strs2.add("A");

        System.out.println(strs.equals(strs2));

    }

}

AbstractList看下源码：

public boolean equals(Object o) {

            if (o == this)

                return true;

            //是否是列表，注意这里：只要实现List接口即可

            if (!(o instanceof List))

                return false;

            //通过迭代器访问List的所有元素

            ListIterator<E> e1 = listIterator();

            ListIterator e2 = ((List) o).listIterator();

            //遍历两个List的元素

            while (e1.hasNext() && e2.hasNext()) {

                E o1 = e1.next();

                Object o2 = e2.next();

                //只要存在着不相等就退出

                if (!(o1==null ? o2==null : o1.equals(o2)))

                    return false;

            }

            //长度是否也相等

            return !(e1.hasNext() || e2.hasNext());

        }

子列表只是原列表的一个视图

SubList类也是AbstractList的子类，其所有的get、set、add、remove等都是在原始列表上的操作，它自身并没有生成一个新的数组或是链表，也就是子列表只是原列表的一个视图(View)而已。所有的修改动作都映射到了原列表上。

实现了compareTo方法就应该覆写equals方法，确保两者同步

indexOf依赖equals方法查找，binarySearch则依赖compareTo方法查找；

equals是判断元素是否相等，compareTo是判断元素在排序中的位置是否相同。

既然一个决定排序位置，一个是决定相等，那我们就应该保证当排序相同时，其equals也相同，否则就会产生逻辑混乱。

集合运算时使用最优雅方式

并集：

public static void main(String[] args) {

        List<String> list1 = new ArrayList<String>();

        list1.add("A");

        list1.add("B");

        List<String> list2 = new ArrayList<String>();

        list2.add("C");

        // 并集

        list1.addAll(list2);

    }

交集：

//交集

list1.retainAll(list2);

差集：

//差集

list1.removeAll(list2);

无重复的并集：

 	   //删除在list1中出现的元素

        list2.removeAll(list1);

        //把剩余的list2元素加到list1中

        list1.addAll(list2);

使用shuffle打乱列表

举个栗子：

public static void main(String[] args) {

        int tagCloudNum = 10;

        List<String> tagClouds = new ArrayList<String>(tagCloudNum);

        // 初始化标签云，一般是从数据库读入，省略

        //打乱顺序

        Collections.shuffle(tagClouds);

    }

shuffle使用场景：

可用在程序的 "伪装" 上：比如我们例子中的标签云，或者是游侠中的打怪、修行、群殴时宝物的分配策略。
可用在抽奖程序中：比如年会的抽奖程序，先使用shuffle把员工顺序打乱，每个员工的中奖几率相等，然后就可以抽出第一名、第二名。
可以用在安全传输方面：比如发送端发送一组数据，先随机打乱顺序，然后加密发送，接收端解密，然后进行排序，即可实现即使是相同的数据源，也会产生不同密文的效果，加强了数据的安全性。