《改善java代码》第五章：数组与集合代码优化

时间 2019-11-13

原文原文链接

码云地址：https://gitee.com/yaohuiqin/codeimprove/tree/master/src/per/yhq/objectimprove/listorarrayprovejava

性能方面优先考虑数组：
对基本类型进行求和运算时，数组的效率是集合的10倍。

对数组扩容方法：

public class expandCapacity {
    public static void main(String[] args) {
        String arrays[] = new String[10];
        System.out.println(arrays.length);
        arrays = expandCapacity(arrays,13);
        System.out.println(arrays.length);
    }
    public static  <T> T[] expandCapacity(T[] datas,int newlen){
        newlen = newlen < 0 ? 0 : newlen;
        return Arrays.copyOf(datas,newlen);
    }
}

警戒数组的浅拷贝：

public class shallowCopy {
    public static void main(String[] args) {
        int balloonNum=7;
        Balloon[] box = new Balloon[balloonNum];
        for (int i=0;i<balloonNum;i++){
            box[i]=new Balloon(Color.values()[i],i);
        }
        Balloon[] copybox = Arrays.copyOf(box,box.length);
        copybox[6].setColor(Color.blue);
       //打印：
        for (Balloon ballon:box){
            System.out.print(ballon.getColor()+"id:"+ballon.getId()+"  ");
        }
        System.out.println();
        System.out.println("copybox数组的值：");
        for (Balloon ballon:copybox){
            System.out.print(ballon.getColor()+"id:"+ballon.getId()+"  ");
        }
    }
    public static class Balloon{
        Color color;
        int id;
        @Override
        public String toString() {
            return "Balloon{" +
                    "color='" + color + '\'' +
                    ", id=" + id +
                    '}';
        }
        public Balloon(Color color, int id) {
            this.color = color;
            this.id = id;
        }
        public Color getColor() {
            return color;
        }
        public void setColor(Color color) {
            this.color = color;
        }
        public int getId() {
            return id;
        }
        public void setId(int id) {
            this.id = id;
        }
    }
    public static enum Color{
        Red,Orange,yellow,green,indigo,blue,violet;
    }
}

输出的值是：node

在明确场景下为集合指定初始化容量：
集合在add操做时，会自动给集合扩容，例如，ArrayList就按1.5倍扩容，每次扩容会执行
```
Arrays.copyOf(elementData, newCapacity)，影响性能。
```
获取次大于最大值的元素:
注意，最大值多是多个，因此排序后取次大值的元素的方式不可取。首先须要去重复而后再排序，去重不须要本身写，数组不能自动去重，可是Set集合却能够，并且Set的子类TreeSet还能自动排序。
```
public static int getSecond(Integer[] data){
        List<Integer> dataList = Arrays.asList(data);
        TreeSet<Integer> ts = new TreeSet<Integer>(dataList);
        return  ts.lower(ts.last());
    }
```

注意，原始数据类型不能做为aslist参数，不然会引发程序混乱。
asList转换后的arraylist 是Array类下的子类ArrayList，不能进行add操做，会报错：

Exception in thread "main" java.lang.UnsupportedOperationException
    at java.util.AbstractList.add(AbstractList.java:148)
    at java.util.AbstractList.add(AbstractList.java:108)
    at per.yhq.objectimprove.listorarrayprove.GetSecondMax.main(GetSecondMax.java:21)

对数据排序时，推荐使用Comparator 进行排序：
　　在java中，想要给数据排序，有两种实现方式，一种是实现Comparable接口，一种是实现Comparator接口。
　　先看一个例子：给公司职员排序时的代码，先按员工工号排序，代码以下：

public class Compareobjectoflist {
    public static void main(String[] args) {
        List<Employee> list = new ArrayList<Employee>(5);
        list.add(new Employee(1001,"张三",Position.Boss));
        list.add(new Employee(1342,"李四",Position.Manage));
        list.add(new Employee(990,"姚慧芹",Position.Staff));
        list.add(new Employee(1003,"位喜会",Position.Boss));
        list.add(new Employee(890,"张三",Position.Staff));
        Collections.sort(list);
        //改善代码，利用实现了接口的Comparator类重写compare方法，改变排序规则，无需改变Employee类的代码
        //Collections.sort(list,new PositionComparator());
        for (Employee e:list){
            System.out.println(e);
        }
    }

    private static class Employee implements Comparable<Employee>{
        private int id;
        private String name;
        private Position position;

        public Employee(int id, String name, Position position) {
            this.id = id;
            this.name = name;
            this.position = position;
        }
        @Override
        public int compareTo(Employee o) {
            return new CompareToBuilder().append(id,o.id).toComparison();
        }

        @Override
        public String toString() {
            return ToStringBuilder.reflectionToString(this);
        }

        public int getId() {
            return id;
        }
        public void setId(int id) {
            this.id = id;
        }
        public String getName() {
            return name;
        }
        public void setName(String name) {
            this.name = name;
        }
        public Position getPosition() {
            return position;
        }
        public void setPosition(Position position) {
            this.position = position;
        }
    }
    private enum Position{
        Boss,Manage,Staff
    }

//    static class PositionComparator implements Comparator<Employee>{
//
//        @Override
//        public int compare(Employee o1, Employee o2) {
//            return o1.getPosition().compareTo(o2.position);
//        }
//    }
}

　　上面的代码只是根据员工的id进行排序，但咱们想要按照职位来排序时，再改Employee时已不合适了，Employee是一个稳定类，为了排序而修改它显然不是好办法，而实现git

Comparator接口再重写compare()方法时，改Collections.sort(list)  为  Collections.sort(list,new PositionComparator())时，能够更好的修改排序方式。
　　若是想修改为先根据员工的职位排序，再根据员工id排序时，能够用apache的工具类简化处理：

//改为职工排序和根据工号排序
    static class PositionComparator2 implements Comparator<Employee>{
        @Override
        public int compare(Employee o1, Employee o2) {
            return new CompareToBuilder().append(o1.position,o2.position).append(o1.id,o2.id).toComparison();
        }
    }

实现了compareTo方法，就应该覆写equals方法，确保二者同步。
indexOf依赖equals方法查找，binarySearch则依赖compareTo方法查找
equals是判断元素是否相等，compareTo是判断元素在排序中的位置是否相同。
推荐用两个集合的运算：交集，并集，差集。
若是用对两个集合进行遍从来计算，并不优雅。
交集：list.retainAll(list2);
并集：list.addAll(list2);
差集：list.removeAll(list2);
无重复的并集： list.removeAll(list2); list.addAll(list2)
利用Collections.shuffle(lists); 方法打乱lists的排序，能够用来抽奖，也能够用在安全传输方面。

查询集合类中是否包含某元素，推荐用hashMap而不是用list集合，注意，HashMap中的HashCode应避免冲突。

public class QuickFindElementByHashMap {
    public static void main(String[] args) {
        int size = 10000;
        List<String> list = new ArrayList<String>(size);
        for(int i =0;i<size;i++){
            list.add("value"+i);
        }
        long start = System.nanoTime();
        list.contains("value"+(size-1));
        System.out.println("list执行时间：" + (System.nanoTime()-start)+"ns");
        Map<String,String> map = new HashMap<String, String>(size);
        for (int i=0;i<size;i++){
            map.put("key"+i,"value"+i);
        }
        start = System.nanoTime();
        map.containsKey("value"+(size-1));
        System.out.println("hashmap执行时间：" + (System.nanoTime()-start)+"ns");
    }
}

执行结果：

缘由分析：list.contains("value"+(size-1)); 须要循环遍历，源代码：apache

public boolean contains(Object o) {
        return indexOf(o) >= 0;
    }

public int indexOf(Object o) {
        if (o == null) {
            for (int i = 0; i < size; i++)
                if (elementData[i]==null)
                    return i;
        } else {
            for (int i = 0; i < size; i++)
                if (o.equals(elementData[i]))
                    return i;
        }
        return -1;
    }

而 map.containsKey("value"+(size-1)); 无需循环遍历源代码：数组

public boolean containsKey(Object key) {
    return getNode(hash(key), key) != null;
}

static final int hash(Object key) {
    int h;
    return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}

final Node<K,V> getNode(int hash, Object key) {
        Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
        if ((tab = table) != null && (n = tab.length) > 0 &&
            (first = tab[(n - 1) & hash]) != null) {
            if (first.hash == hash && // always check first node
                ((k = first.key) == key || (key != null && key.equals(k))))
                return first;
            if ((e = first.next) != null) {
                if (first instanceof TreeNode)
                    return ((TreeNode<K,V>)first).getTreeNode(hash, key);
                do {
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        return e;
                } while ((e = e.next) != null);
            }
        }
        return null;
    }

　　解析： tab[(n - 1) & hash] 根据hash值和table的长度获取数组的下标，先讲解HashMap中的table是如何存储元素的，首先要说明如下三点：一、table数组的长度永远是2的n次幂。二、table数组中的元素是Entry类型。三、table数组中的元素位置是不连续的。

安全

Vector是ArrayList的多线程版本，HashTable是HashMap的多线程版本
Set 的元素不可重复，List的元素是能够重复的，这里的重复是equals方法的返回值相等。
Set有一个经常使用的类：TreeSet。改类实现了默认排序为升序的Set集合。若是插入一个元素，默认会按照升序排列。可是这仅限于集合加入元素时对其排序，可是并不试用于可变量的排序。
解决方式：修改元素后：Set = new TreeSet<Person> (new ArrayList<Person> (Set)) 不可用方法Set = new TreeSet（set），形成浅拷贝。或者不用treeset，改用List
总结：
一、List：实现了List接口的集合主要有：ArrayList、LinkedList、Vector、Stack，其中ArrayList是一个动态数组，LinkedList是一个双向链表，Vector是一个线程安全的动态数组，Stack是一个对象栈，遵循先进后出的原则。

二、Set是不包含重复元素的集合，其主要的实现类有：EnumSet、HashSet、TreeSet。其中EnumSet是枚举类型的专用Set，全部元素都是枚举类型；HashSet是以哈希码决定其元素位置的Set，其原理与HashMap类似，它提供快速的插入和查找方法； TreeSet是一个自动排序的Set，它实现了SortedSet接口。
三、Map能够分为排序Map和非排序Map。排序Map主要是TreeMap类，它根据Key值进行排序。非排序Map主要包括：HashMap、HashTable、Properties、EnumMap等，其中Properties是HashTable的子类。它的主要用途是从Property文件中加载数据，并提供方便的读写操做。EnumMap则要求其Key必须是某一个枚举类型。

四、Queue，队列，分为两类，一类是阻塞式队列，队列满了之后再插入元素则会抛出异常。主要包括：ArrayBlockingQueue、PriorityBlockingQueue、LinkedBlockingQueue。其中ArrayBlockingQueue是一个以数组方式实现的有界阻塞队列。PriorityBlockingQueue是依照优先级组建的队列，LinkedBlockingQueue是经过链表实现的阻塞队列。另外一类是非阻塞队列，无边界的，只要内存容许，均可以持续追加元素。咱们常用的是PriorityQueue类。

五、数组：数组与集合最大的区别就是数组可以容纳基本类型。全部的集合底层存储都是数组。

六、工具类：数组的工具类是java.util. Arrays 和 java.lang.reflect.Array 集合的工具类：java.util.Collections
多线程