Java容器類研究2：List

java.util.List

replaceAll

在Java8中引入該方法，用來替換list中的每一個元素。

default void replaceAll(UnaryOperator<E> operator) {
        Objects.requireNonNull(operator);
        final ListIterator<E> li = this.listIterator();
        while (li.hasNext()) {
            li.set(operator.apply(li.next()));
        }
    }

Iterator的set方法，只能在next或previous以後使用，也就是確保當前Iterator指向了一個存在的項。該方法使用很方便，使用lambda運算能夠很清晰的表達想要進行的替換操做。

public class Ripper {
    public static void main(String[] args) {
        List<Integer> numbers = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            numbers.add(i);
        }
        numbers.replaceAll(item -> item * item);
    }
}

sort

public class Ripper {
    public static void main(String[] args) {
        List<Integer> numbers = new ArrayList<>();
        for (int i = 10; i > 0; i--) {
            numbers.add(i);
        }

        numbers.sort(Integer::compare);

        numbers.sort(null);

        numbers.sort((a, b) -> a - b);

        numbers.sort(Comparator.comparingInt(a -> a * a));
    }
}

一樣sort函數也是在1.8中引入，而且能夠使用lambda表達式定義本身的比較規則，上面四種排序結果都是同樣的。這裏使用了Comparator.comparingInt，該方法能夠將非int對象先映射爲int型，而後進行比較。

具體實現：

default void sort(Comparator<? super E> c) {
        Object[] a = this.toArray();
        Arrays.sort(a, (Comparator) c);
        ListIterator<E> i = this.listIterator();
        for (Object e : a) {
            i.next();
            i.set((E) e);
        }
    }

這裏首先將原來的list的copy爲一個數組，而後再進行排序，這裏採用的是merge sort。爲何要先copy下來，排序完成後再設置原list？官方解釋是在原數組上進行排序可能會致使n²log(n)的複雜度。

toArray函數將基於Collection的結構轉化成了數組結構，這裏的ListArray的toArray方法是淺拷貝，從下面例子能夠看出：

public class Ripper {
    int value;

    public Ripper(int v) {
        value = v;
    }

    public static void main(String[] args) {
        List<Ripper> numbers = new ArrayList<>();
        for (int i = 10; i > 0; i--) {
            numbers.add(new Ripper(i));
        }
        Object[] array = numbers.toArray();
        array[0] = array[1];
        System.out.println(numbers.get(0).value);
        Ripper a1 = (Ripper) array[0];
        a1.value = 100;
        System.out.println(numbers.get(0).value);
        System.out.println(numbers.get(1).value);

    }
}

輸出是：

10
10
100

說明建立的array是指向一個新的數組對象，可是數組中每一項保留的引用是指向原來的對象的。

spliterator

default Spliterator<E> spliterator() {
        return Spliterators.spliterator(this, Spliterator.ORDERED);
    }

List存儲的是有序的數組，因此劃分時會按照順序進行劃分。