java.util.List

replaceAll

在Java8中引入该方法，用来替换list中的每个元素。

default void replaceAll(UnaryOperator
    
      operator) {        Objects.requireNonNull(operator);        final ListIterator
     
       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
    
      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
    
      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
     c) {        Object[] a = this.toArray();        Arrays.sort(a, (Comparator) c);        ListIterator
    
      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
    
      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);    }}
    

输出是：

1010100

说明创建的array是指向一个新的数组对象，但是数组中每一项保留的引用是指向原来的对象的。

spliterator

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

List存储的是有序的数组，所以划分时会按照顺序进行划分。