集合的其他内容

1.Iterator

迭代器遍历过程解析：

lastRet删除的时候会用到

2.ListIterator

运行结果：

3.Collections工具类

代码示例：

package com.zhang.collectionsTest;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class TestCollections {
    public static void main(String[] args) {
        ArrayList<integer> list = new ArrayList();
        //批量添加元素
        Collections.addAll(list,40,30,60,10);
        System.out.println(list);//[40, 30, 60, 10]
        //排序
        Collections.sort(list);
        System.out.println(list);//[10, 30, 40, 60]
        //查找（元素必须有序,折半查找）
        int i = Collections.binarySearch(list, 10);
        System.out.println(i);//0
        //最大值，最小值
        System.out.println(Collections.max(list));//60
        System.out.println(Collections.min(list));//10
        //填充集合
        //Collections.fill(list,33);
       // System.out.println(list);//[33, 33, 33, 33]
        //复制集合
        ArrayList<integer> list2 = new ArrayList();
        Collections.addAll(list2,0,0,0,0,0,0);//不加此行代码运行会报错 [10, 30, 40, 60, 0, 0]
        Collections.copy(list2,list);//目的dest集合的size大小>=原集合src的size
        System.out.println(list2);
        //同步集合
        ArrayList list3;//线程不安全，没有上锁，多线程操作会有安全问题
        List<integer> list4 = Collections.synchronizedList(list);//不安全-->安全
        System.out.println(list4);//[10, 30, 40, 60]
    }
}

源码：

 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);
        }
    }

在方法体加锁(synchronized)比在方法上加锁(synchronized)效率高

		public boolean isEmpty() {
            synchronized (mutex) {return c.isEmpty();}
        }
        public boolean contains(Object o) {
            synchronized (mutex) {return c.contains(o);}
        }
        public Object[] toArray() {
            synchronized (mutex) {return c.toArray();}
        }
        public <t> T[] toArray(T[] a) {
            synchronized (mutex) {return c.toArray(a);}
        }

        public Iterator<e> iterator() {
            return c.iterator(); // Must be manually synched by user!
        }

        public boolean add(E e) {
            synchronized (mutex) {return c.add(e);}
        }
        public boolean remove(Object o) {
            synchronized (mutex) {return c.remove(o);}
        }

        public boolean containsAll(Collection<!--?--> coll) {
            synchronized (mutex) {return c.containsAll(coll);}
        }
        public boolean addAll(Collection<!--? extends E--> coll) {
            synchronized (mutex) {return c.addAll(coll);}
        }
        public boolean removeAll(Collection<!--?--> coll) {
            synchronized (mutex) {return c.removeAll(coll);}
        }
        public boolean retainAll(Collection<!--?--> coll) {
            synchronized (mutex) {return c.retainAll(coll);}
        }