/**     * Randomly permutes the specified list using a default source of     * randomness.  All permutations occur with approximately equal     * likelihood.<p>     *     * The hedge "approximately" is used in the foregoing description because     * default source of randomness is only approximately an unbiased source     * of independently chosen bits. If it were a perfect source of randomly     * chosen bits, then the algorithm would choose permutations with perfect     * uniformity.<p>     *     * This implementation traverses the list backwards, from the last element     * up to the second, repeatedly swapping a randomly selected element into     * the "current position".  Elements are randomly selected from the     * portion of the list that runs from the first element to the current     * position, inclusive.<p>     *     * This method runs in linear time.  If the specified list does not     * implement the {@link RandomAccess} interface and is large, this     * implementation dumps the specified list into an array before shuffling     * it, and dumps the shuffled array back into the list.  This avoids the     * quadratic behavior that would result from shuffling a "sequential     * access" list in place.     *     * @param  list the list to be shuffled.     * @throws UnsupportedOperationException if the specified list or     *         its list-iterator does not support the <tt>set</tt> operation.     */    public static void shuffle(List<?> list) {        if (r == null) {            r = new Random();        }        shuffle(list, r);    }    private static Random r;

java.util.Random

  /**     * Randomly permute the specified list using the specified source of     * randomness.  All permutations occur with equal likelihood     * assuming that the source of randomness is fair.<p>     *     * This implementation traverses the list backwards, from the last element     * up to the second, repeatedly swapping a randomly selected element into     * the "current position".  Elements are randomly selected from the     * portion of the list that runs from the first element to the current     * position, inclusive.<p>     *     * This method runs in linear time.  If the specified list does not     * implement the {@link RandomAccess} interface and is large, this     * implementation dumps the specified list into an array before shuffling     * it, and dumps the shuffled array back into the list.  This avoids the     * quadratic behavior that would result from shuffling a "sequential     * access" list in place.     *     * @param  list the list to be shuffled.     * @param  rnd the source of randomness to use to shuffle the list.     * @throws UnsupportedOperationException if the specified list or its     *         list-iterator does not support the <tt>set</tt> operation.     */    public static void shuffle(List<?> list, Random rnd) {        int size = list.size();        if (size < SHUFFLE_THRESHOLD || list instanceof RandomAccess) {            for (int i=size; i>1; i--)                swap(list, i-1, rnd.nextInt(i));        } else {            Object arr[] = list.toArray();            // Shuffle array            for (int i=size; i>1; i--)                swap(arr, i-1, rnd.nextInt(i));            // Dump array back into list            ListIterator it = list.listIterator();            for (int i=0; i<arr.length; i++) {                it.next();                it.set(arr[i]);            }        }    }

    private static final int SHUFFLE_THRESHOLD        =    5;

    /**     * Swaps the elements at the specified positions in the specified list.     * (If the specified positions are equal, invoking this method leaves     * the list unchanged.)     *     * @param list The list in which to swap elements.     * @param i the index of one element to be swapped.     * @param j the index of the other element to be swapped.     * @throws IndexOutOfBoundsException if either <tt>i</tt> or <tt>j</tt>     *         is out of range (i &lt; 0 || i &gt;= list.size()     *         || j &lt; 0 || j &gt;= list.size()).     * @since 1.4     */    public static void swap(List<?> list, int i, int j) {    final List l = list; //这一步有什么用    l.set(i, l.set(j, l.get(i)));    }

java.util.List@org.intellij.lang.annotations.Flow(sourceIsContainer=true) public abstract E set(int index,                      @org.intellij.lang.annotations.Flow(targetIsContainer=true) E element)Replaces the element at the specified position in this list with the specified element (optional operation).Parameters:index - index of the element to replaceelement - element to be stored at the specified positionReturns:the element previously at the specified position

    /**     * Swaps the two specified elements in the specified array.     */    private static void swap(Object[] arr, int i, int j) {        Object tmp = arr[i];        arr[i] = arr[j];        arr[j] = tmp;    }

package com.collection;import java.util.LinkedList;import java.util.List;import java.util.ListIterator;public class ListIteratorTest { public static void main(String[] args) {  List<String> staff = new LinkedList<>();  staff.add("zhuwei");  staff.add("xuezhangbin");  staff.add("taozhiwei");  ListIterator<String> iter = staff.listIterator();  String first = iter.next();    //删除zhuwei  iter.remove();    //把zhuwei改为simei  //iter.set("simei");  System.out.println("first:"+first);    iter.add("xiaobai");    //遍历List元素  System.out.println("遍历List中元素，方法一：");  for(String str : staff)   System.out.println(str+"  ");    iter = staff.listIterator();  System.out.println("遍历List中元素，方法二：");  while(iter.hasNext())  {   System.out.println(iter.next());  } }}