我认为Collections类主要是完成了两个主要功能
1.提供了若干简单而又有用的算法,比如排序,二分查找,求最大最小值等等。
2.提供对集合进行包装的静态方法。比如把指定的集合包装成线程安全的集合、包装成不可修改的集合、包装成类型安全的集合等。
1.提供了若干简单而又有用的算法,比如排序,二分查找,求最大最小值等等。
2.提供对集合进行包装的静态方法。比如把指定的集合包装成线程安全的集合、包装成不可修改的集合、包装成类型安全的集合等。
- package java.util;
- import java.io.Serializable;
- import java.io.ObjectOutputStream;
- import java.io.IOException;
- import java.lang.reflect.Array;
- public class Collections{
- // Suppresses default constructor, ensuring non-instantiability.
- private Collections() {
- }
- // 算法
- /*
- *
- * 算法需要用到的一些参数。所有的关于List的算法都有两种实现,一种是适合随机访问的
- * List,另一种是适合连续访问的。
- */
- private static final int BINARYSEARCH_THRESHOLD = 5000;
- private static final int REVERSE_THRESHOLD = 18;
- private static final int SHUFFLE_THRESHOLD = 5;
- private static final int FILL_THRESHOLD = 25;
- private static final int ROTATE_THRESHOLD = 100;
- private static final int COPY_THRESHOLD = 10;
- private static final int REPLACEALL_THRESHOLD = 11;
- private static final int INDEXOFSUBLIST_THRESHOLD = 35;
- /**
- *
- * List中的所有元素必须实现Compareable接口,即每个 元素必须是可比的。
- *
- * 算法的实现原理为:
- * 把指定的List转化为一个对象数组,对数组进行排序,然后迭代List的每一个元素,
- * 在同样的位置重新设置数组中排好序的元素
- */
- public static <T extends Comparable<? super T>> void sort(List<T> list) {
- Object[] a = list.toArray(); //转化为对象数组
- Arrays.sort(a); //对数组排序,使用了归并排序.对此归并的详细分析可见我另一篇博客
- ListIterator<T> i = list.listIterator();
- for (int j=0; j<a.length; j++) { //迭代元素
- i.next();
- i.set((T)a[j]); //在同样的位置重设排好序的值
- }
- }
- /**
- * 传一个实现了Comparator接口的对象进来。
- * c.compare(o1,o2);来比较两个元素
- */
- public static <T> void sort(List<T> list, Comparator<? super T> c) {
- Object[] a = list.toArray();
- Arrays.sort(a, (Comparator)c);
- ListIterator i = list.listIterator();
- for (int j=0; j<a.length; j++) {
- i.next();
- i.set(a[j]);
- }
- }
- /**
- *
- * 使用二分查找在指定List中查找指定元素key。
- * List中的元素必须是有序的。如果List中有多个key,不能确保哪个key值被找到。
- * 如果List不是有序的,返回的值没有任何意义
- *
- * 对于随机访问列表来说,时间复杂度为O(log(n)),比如1024个数只需要查找log2(1024)=10次,
- * log2(n)是最坏的情况,即最坏的情况下都只需要找10次
- * 对于链表来说,查找中间元素的时间复杂度为O(n),元素比较的时间复杂度为O(log(n))
- *
- * @return 查找元素的索引。如果返回的是负数表明找不到此元素,但可以用返回值计算
- * 应该将key插入到集合什么位置,任然能使集合有序(如果需要插入key值的话)。
- * 公式:point = -i - 1
- *
- */
- public static <T> int binarySearch(List<? extends Comparable<? super T>> list, T key) {
- if (list instanceof RandomAccess || list.size()<BINARYSEARCH_THRESHOLD)
- return Collections.indexedBinarySearch(list, key);
- else
- return Collections.iteratorBinarySearch(list, key);
- }
- /**
- * 使用索引化二分查找。
- * size小于5000的链表也用此方法查找
- */
- private static <T> int indexedBinarySearch(List<? extends Comparable<? super T>> list, T key){
- int low = 0; //元素所在范围的下界
- int high = list.size()-1; //上界
- while (low <= high) {
- int mid = (low + high) >>> 1;
- Comparable<? super T> midVal = list.get(mid); //中间值
- int cmp = midVal.compareTo(key); //指定元素与中间值比较
- if (cmp < 0)
- low = mid + 1; //重新设置上界和下界
- else if (cmp > 0)
- high = mid - 1;
- else
- return mid; // key found
- }
- return -(low + 1); // key not found
- }
- /**
- * 迭代式二分查找,线性查找,依次查找得中间值
- *
- */
- private static <T> int iteratorBinarySearch(List<? extends Comparable<? super T>> list, T key){
- int low = 0;
- int high = list.size()-1;
- ListIterator<? extends Comparable<? super T>> i = list.listIterator();
- while (low <= high) {
- int mid = (low + high) >>> 1;
- Comparable<? super T> midVal = get(i, mid);
- int cmp = midVal.compareTo(key);
- if (cmp < 0)
- low = mid + 1;
- else if (cmp > 0)
- high = mid - 1;
- else
- return mid; // key found
- }
- return -(low + 1); // key not found
- }
- private static <T> T get(ListIterator<? extends T> i, int index) {
- T obj = null;
- int pos = i.nextIndex(); //根据当前迭代器的位置确定是向前还是向后遍历找中间值
- if (pos <= index) {
- do {
- obj = i.next();
- } while (pos++ < index);
- } else {
- do {
- obj = i.previous();
- } while (--pos > index);
- }
- return obj;
- }
- /**
- * 提供实现了Comparator接口的对象比较元素
- */
- public static <T> int binarySearch(List<? extends T> list, T key, Comparator<? super T> c) {
- if (c==null)
- return binarySearch((List) list, key);
- if (list instanceof RandomAccess || list.size()<BINARYSEARCH_THRESHOLD)
- return Collections.indexedBinarySearch(list, key, c);
- else
- return Collections.iteratorBinarySearch(list, key, c);
- }
- private static <T> int indexedBinarySearch(List<? extends T> l, T key, Comparator<? super T> c) {
- int low = 0;
- int high = l.size()-1;
- while (low <= high) {
- int mid = (low + high) >>> 1;
- T midVal = l.get(mid);
- int cmp = c.compare(midVal, key);
- if (cmp < 0)
- low = mid + 1;
- else if (cmp > 0)
- high = mid - 1;
- else
- return mid; // key found
- }
- return -(low + 1); // key not found
- }
- private static <T> int iteratorBinarySearch(List<? extends T> l, T key, Comparator<? super T> c) {
- int low = 0;
- int high = l.size()-1;
- ListIterator<? extends T> i = l.listIterator();
- while (low <= high) {
- int mid = (low + high) >>> 1;
- T midVal = get(i, mid);
- int cmp = c.compare(midVal, key);
- if (cmp < 0)
- low = mid + 1;
- else if (cmp > 0)
- high = mid - 1;
- else
- return mid; // key found
- }
- return -(low + 1); // key not found
- }
- private interface SelfComparable extends Comparable<SelfComparable> {}
- /**
- *
- * 逆序排列指定列表中的元素
- */
- public static void reverse(List<?> list) {
- int size = list.size();
- //如果是size小于18的链表或是基于随机访问的列表
- if (size < REVERSE_THRESHOLD || list instanceof RandomAccess) {
- for (int i=0, mid=size>>1, j=size-1; i<mid; i++, j--) //第一个与最后一个,依次交换
- swap(list, i, j); //交换i和j位置的值
- } else { //基于迭代器的逆序排列算法
- ListIterator fwd = list.listIterator();
- ListIterator rev = list.listIterator(size);
- for (int i=0, mid=list.size()>>1; i<mid; i++) { //这..,一个思想你懂得
- Object tmp = fwd.next();
- fwd.set(rev.previous());
- rev.set(tmp);
- }
- }
- }
- /**
- *
- * 对指定列表中的元素进行混排
- */
- public static void shuffle(List<?> list) {
- if (r == null) {
- r = new Random();
- }
- shuffle(list, r);
- }
- private static Random r;
- /**
- *
- * 提供一个随机数生成器对指定List进行混排
- *
- * 基本算法思想为:
- * 逆向遍历list,从最后一个元素到第二个元素,然后重复交换当前位置
- * 与随机产生的位置的元素值。
- *
- * 如果list不是基于随机访问并且其size>5,会先把List中的复制到数组中,
- * 然后对数组进行混排,再把数组中的元素重新填入List中。
- * 这样做为了避免迭代器大跨度查找元素影响效率
- */
- 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--) //从i-1个位置开始与随机位置元素交换值
- swap(list, i-1, rnd.nextInt(i));
- } else {
- Object arr[] = list.toArray(); //先转化为数组
- //对数组进行混排
- for (int i=size; i>1; i--)
- swap(arr, i-1, rnd.nextInt(i));
- // 然后把数组中的元素重新填入List
- ListIterator it = list.listIterator();
- for (int i=0; i<arr.length; i++) {
- it.next();
- it.set(arr[i]);
- }
- }
- }
- /**
- * 交换List中两个位置的值
- */
- public static void swap(List<?> list, int i, int j) {
- final List l = list;
- l.set(i, l.set(j, l.get(i))); //互换i和j位置的值
- }
- /**
- * 交换数组俩位置的值。好熟悉啊
- */
- private static void swap(Object[] arr, int i, int j) {
- Object tmp = arr[i];
- arr[i] = arr[j];
- arr[j] = tmp;
- }
- /**
- *
- * 用obj替换List中的所有元素
- * 依次遍历赋值即可
- */
- public static <T> void fill(List<? super T> list, T obj) {
- int size = list.size();
- if (size < FILL_THRESHOLD || list instanceof RandomAccess) {
- for (int i=0; i<size; i++)
- list.set(i, obj);
- } else {
- ListIterator<? super T> itr = list.listIterator();
- for (int i=0; i<size; i++) {
- itr.next();
- itr.set(obj);
- }
- }
- }
- /**
- *
- * 复制源列表的所有元素到目标列表,
- * 如果src.size > dest.size 将抛出一个异常
- * 如果src.size < dest.size dest中多出的元素将不受影响
- * 同样是依次遍历赋值
- */
- public static <T> void copy(List<? super T> dest, List<? extends T> src) {
- int srcSize = src.size();
- if (srcSize > dest.size())
- throw new IndexOutOfBoundsException("Source does not fit in dest");
- if (srcSize < COPY_THRESHOLD ||
- (src instanceof RandomAccess && dest instanceof RandomAccess)) {
- for (int i=0; i<srcSize; i++)
- dest.set(i, src.get(i));
- } else { //一个链表一个线性表也可以用迭代器赋值
- ListIterator<? super T> di=dest.listIterator();
- ListIterator<? extends T> si=src.listIterator();
- for (int i=0; i<srcSize; i++) {
- di.next();
- di.set(si.next());
- }
- }
- }
- /**
- *
- * 返回集合中的最小元素。前提是其中的元素都是可比的,即实现了Comparable接口
- * 找出一个通用的算法其实不容易,尽管它的思想不难。
- * 反正要依次遍历完所有元素,所以直接用了迭代器
- */
- public static <T extends Object & Comparable<? super T>> T min(Collection<? extends T> coll) {
- Iterator<? extends T> i = coll.iterator();
- T candidate = i.next();
- while (i.hasNext()) {
- T next = i.next();
- if (next.compareTo(candidate) < 0)
- candidate = next;
- }
- return candidate;
- }
- /**
- * 根据提供的比较器求最小元素
- */
- public static <T> T min(Collection<? extends T> coll, Comparator<? super T> comp) {
- if (comp==null)
- //返回默认比较器,其实默认比较器什么也不做,只是看集合元素是否实现了Comparable接口,
- //否则抛出ClassCastException
- return (T)min((Collection<SelfComparable>) (Collection) coll);
- Iterator<? extends T> i = coll.iterator();
- T candidate = i.next(); //假设第一个元素为最小元素
- while (i.hasNext()) {
- T next = i.next();
- if (comp.compare(next, candidate) < 0)
- candidate = next;
- }
- return candidate;
- }
- /**
- * 求集合中最大元素
- */
- public static <T extends Object & Comparable<? super T>> T max(Collection<? extends T> coll) {
- Iterator<? extends T> i = coll.iterator();
- T candidate = i.next();
- while (i.hasNext()) {
- T next = i.next();
- if (next.compareTo(candidate) > 0)
- candidate = next;
- }
- return candidate;
- }
- /**
- * 根据指定比较器求集合中最大元素
- */
- public static <T> T max(Collection<? extends T> coll, Comparator<? super T> comp) {
- if (comp==null)
- return (T)max((Collection<SelfComparable>) (Collection) coll);
- Iterator<? extends T> i = coll.iterator();
- T candidate = i.next();
- while (i.hasNext()) {
- T next = i.next();
- if (comp.compare(next, candidate) > 0)
- candidate = next;
- }
- return candidate;
- }
- /**
- *
- * 旋转移位List中的元素通过指定的distance。每个元素移动后的位置为:
- * (i + distance)%list.size.此方法不会改变列表的长度
- *
- * 比如,类表元素为: [t, a, n, k, s , w]
- * 执行Collections.rotate(list, 2)或
- * Collections.rotate(list, -4)后, list中的元素将变为
- * [s, w, t, a, n , k]。可以这样理解:正数表示向后移,负数表示向前移
- *
- */
- public static void rotate(List<?> list, int distance) {
- if (list instanceof RandomAccess || list.size() < ROTATE_THRESHOLD)
- rotate1((List)list, distance);
- else
- rotate2((List)list, distance);
- }
- private static <T> void rotate1(List<T> list, int distance) {
- int size = list.size();
- if (size == 0)
- return;
- distance = distance % size; //distance始终处于0到size(不包括)之间
- if (distance < 0)
- distance += size; //还是以向后移来计算的
- if (distance == 0)
- return;
- for (int cycleStart = 0, nMoved = 0; nMoved != size; cycleStart++) {
- T displaced = list.get(cycleStart);
- int i = cycleStart;
- do {
- i += distance; //求新位置
- if (i >= size)
- i -= size; //超出size就减去size
- displaced = list.set(i, displaced); //为新位置赋原来的值
- nMoved ++; //如果等于size证明全部替换完毕
- } while(i != cycleStart); //依次类推,求新位置的新位置
- }
- }
- private static void rotate2(List<?> list, int distance) {
- int size = list.size();
- if (size == 0)
- return;
- int mid = -distance % size;
- if (mid < 0)
- mid += size;
- if (mid == 0)
- return;
- //好神奇啊
- reverse(list.subList(0, mid));
- reverse(list.subList(mid, size));
- reverse(list);
- }
- /**
- *
- * 把指定集合中所有与oladVal相等的元素替换成newVal
- * 只要list发生了改变就返回true
- */
- public static <T> boolean replaceAll(List<T> list, T oldVal, T newVal) {
- boolean result = false;
- int size = list.size();
- if (size < REPLACEALL_THRESHOLD || list instanceof RandomAccess) {
- if (oldVal==null) {
- for (int i=0; i<size; i++) {
- if (list.get(i)==null) {
- list.set(i, newVal);
- result = true;
- }
- }
- } else {
- for (int i=0; i<size; i++) {
- if (oldVal.equals(list.get(i))) {
- list.set(i, newVal);
- result = true;
- }
- }
- }
- } else {
- ListIterator<T> itr=list.listIterator();
- if (oldVal==null) {
- for (int i=0; i<size; i++) {
- if (itr.next()==null) {
- itr.set(newVal);
- result = true;
- }
- }
- } else {
- for (int i=0; i<size; i++) {
- if (oldVal.equals(itr.next())) {
- itr.set(newVal);
- result = true;
- }
- }
- }
- }
- return result;
- }
- /**
- *
- * target是否是source的子集,如果是返回target第一个元素的索引,
- * 否则返回-1。
- * 其实这里和串的模式匹配差不多。这里使用的是基本的回溯法。
- *
- */
- public static int indexOfSubList(List<?> source, List<?> target) {
- int sourceSize = source.size();
- int targetSize = target.size();
- int maxCandidate = sourceSize - targetSize;
- if (sourceSize < INDEXOFSUBLIST_THRESHOLD ||
- (source instanceof RandomAccess&&target instanceof RandomAccess)) {
- nextCand:for (int candidate = 0; candidate <= maxCandidate; candidate++) {
- for (int i=0, j=candidate; i<targetSize; i++, j++)
- if (!eq(target.get(i), source.get(j)))
- continue nextCand; // 元素失配,跳到外部循环
- return candidate; // All elements of candidate matched target
- }
- } else { // Iterator version of above algorithm
- ListIterator<?> si = source.listIterator();
- nextCand:for (int candidate = 0; candidate <= maxCandidate; candidate++) {
- ListIterator<?> ti = target.listIterator();
- for (int i=0; i<targetSize; i++) {
- if (!eq(ti.next(), si.next())) {
- // 回溯指针,然后跳到外部循环继续执行
- for (int j=0; j<i; j++)
- si.previous();
- continue nextCand;
- }
- }
- return candidate;
- }
- }
- return -1; //没有找到匹配的子串返回-1
- }
- /**
- * 如果有一个或多个字串,返回最后一个出现的子串的第一个元素的索引
- */
- public static int lastIndexOfSubList(List<?> source, List<?> target) {
- int sourceSize = source.size();
- int targetSize = target.size();
- int maxCandidate = sourceSize - targetSize;
- if (sourceSize < INDEXOFSUBLIST_THRESHOLD ||
- source instanceof RandomAccess) { // Index access version
- nextCand:for (int candidate = maxCandidate; candidate >= 0; candidate--) {
- for (int i=0, j=candidate; i<targetSize; i++, j++)
- if (!eq(target.get(i), source.get(j))) //从source的maxCandidate位置开始比较。然后是maxCandidate-1,依次类推
- continue nextCand; // Element mismatch, try next cand
- return candidate; // All elements of candidate matched target
- }
- } else { // Iterator version of above algorithm
- if (maxCandidate < 0)
- return -1;
- ListIterator<?> si = source.listIterator(maxCandidate);
- nextCand: for (int candidate = maxCandidate; candidate >= 0; candidate--) {
- ListIterator<?> ti = target.listIterator();
- for (int i=0; i<targetSize; i++) {
- if (!eq(ti.next(), si.next())) {
- if (candidate != 0) {
- // Back up source iterator to next candidate
- for (int j=0; j<=i+1; j++)
- si.previous();
- }
- continue nextCand;
- }
- }
- return candidate;
- }
- }
- return -1; // No candidate matched the target
- }
- // Unmodifiable Wrappers
- /**
- *
- * 返回一个关于指定集合的不可修改的视图。
- * 任何试图修改该视图的操作都将抛出一个UnsupportedOperationException
- *
- * Collection返回的视图的equals方法不是调用底层集合的equals方法
- * 而是继承了Object的equals方法。hashCode方法也是一样的。
- * 因为Set和List的equals方法并不相同。
- */
- public static <T> Collection<T> unmodifiableCollection(Collection<? extends T> c) {
- return new UnmodifiableCollection<T>(c);
- }
- static class UnmodifiableCollection<E> implements Collection<E>, Serializable {
- // use serialVersionUID from JDK 1.2.2 for interoperability
- private static final long serialVersionUID = 1820017752578914078L;
- final Collection<? extends E> c;
- UnmodifiableCollection(Collection<? extends E> c) {
- if (c==null)
- throw new NullPointerException();
- this.c = c;
- }
- public int size() {return c.size();}
- public boolean isEmpty() {return c.isEmpty();}
- public boolean contains(Object o) {return c.contains(o);}
- public Object[] toArray() {return c.toArray();}
- public <T> T[] toArray(T[] a) {return c.toArray(a);}
- public String toString() {return c.toString();}
- public Iterator<E> iterator() {
- return new Iterator<E>() {
- Iterator<? extends E> i = c.iterator();
- public boolean hasNext() {return i.hasNext();}
- public E next() {return i.next();}
- public void remove() { //试图修改集合的操作都将抛出此异常
- throw new UnsupportedOperationException();
- }
- };
- }
- public boolean add(E e){
- throw new UnsupportedOperationException();
- }
- public boolean remove(Object o) {
- throw new UnsupportedOperationException();
- }
- public boolean containsAll(Collection<?> coll) {
- return c.containsAll(coll);
- }
- public boolean addAll(Collection<? extends E> coll) {
- throw new UnsupportedOperationException();
- }
- public boolean removeAll(Collection<?> coll) {
- throw new UnsupportedOperationException();
- }
- public boolean retainAll(Collection<?> coll) {
- throw new UnsupportedOperationException();
- }
- public void clear() {
- throw new UnsupportedOperationException();
- }
- }
- /**
- * 返回一个不可修改Set。
- * 调用的是底层集合的equals方法
- */
- public static <T> Set<T> unmodifiableSet(Set<? extends T> s) {
- return new UnmodifiableSet<T>(s);
- }
- /**
- * @serial include
- */
- static class UnmodifiableSet<E> extends UnmodifiableCollection<E>
- implements Set<E>, Serializable {
- private static final long serialVersionUID = -9215047833775013803L;
- UnmodifiableSet(Set<? extends E> s) {super(s);}
- public boolean equals(Object o) {return o == this || c.equals(o);}
- public int hashCode() {return c.hashCode();}
- }
- /**
- * 返回一个不可修改的Sort Set
- */
- public static <T> SortedSet<T> unmodifiableSortedSet(SortedSet<T> s) {
- return new UnmodifiableSortedSet<T>(s);
- }
- static class UnmodifiableSortedSet<E>
- extends UnmodifiableSet<E>
- implements SortedSet<E>, Serializable {
- private static final long serialVersionUID = -4929149591599911165L;
- private final SortedSet<E> ss;
- UnmodifiableSortedSet(SortedSet<E> s) {super(s); ss = s;}
- public Comparator<? super E> comparator() {return ss.comparator();}
- public SortedSet<E> subSet(E fromElement, E toElement) {
- return new UnmodifiableSortedSet<E>(ss.subSet(fromElement,toElement));
- }
- public SortedSet<E> headSet(E toElement) {
- return new UnmodifiableSortedSet<E>(ss.headSet(toElement));
- }
- public SortedSet<E> tailSet(E fromElement) {
- return new UnmodifiableSortedSet<E>(ss.tailSet(fromElement));
- }
- public E first() {return ss.first();}
- public E last() {return ss.last();}
- }
- /**
- * 返回一个 不可修改的List
- * 如果原List实现了RandomAccess接口,返回的List也将实现此接口
- */
- public static <T> List<T> unmodifiableList(List<? extends T> list) {
- return (list instanceof RandomAccess ?
- new UnmodifiableRandomAccessList<T>(list) :
- new UnmodifiableList<T>(list));
- }
- static class UnmodifiableList<E> extends UnmodifiableCollection<E>
- implements List<E> {
- static final long serialVersionUID = -283967356065247728L;
- final List<? extends E> list;
- UnmodifiableList(List<? extends E> list) {
- super(list);
- this.list = list;
- }
- public boolean equals(Object o) {return o == this || list.equals(o);}
- public int hashCode() {return list.hashCode();}
- public E get(int index) {return list.get(index);}
- public E set(int index, E element) {
- throw new UnsupportedOperationException();
- }
- public void add(int index, E element) {
- throw new UnsupportedOperationException();
- }
- public E remove(int index) {
- throw new UnsupportedOperationException();
- }
- public int indexOf(Object o) {return list.indexOf(o);}
- public int lastIndexOf(Object o) {return list.lastIndexOf(o);}
- public boolean addAll(int index, Collection<? extends E> c) {
- throw new UnsupportedOperationException();
- }
- public ListIterator<E> listIterator() {return listIterator(0);}
- public ListIterator<E> listIterator(final int index) {
- return new ListIterator<E>() {
- ListIterator<? extends E> i = list.listIterator(index);
- public boolean hasNext() {return i.hasNext();}
- public E next() {return i.next();}
- public boolean hasPrevious() {return i.hasPrevious();}
- public E previous() {return i.previous();}
- public int nextIndex() {return i.nextIndex();}
- public int previousIndex() {return i.previousIndex();}
- public void remove() {
- throw new UnsupportedOperationException();
- }
- public void set(E e) {
- throw new UnsupportedOperationException();
- }
- public void add(E e) {
- throw new UnsupportedOperationException();
- }
- };
- }
- public List<E> subList(int fromIndex, int toIndex) {
- return new UnmodifiableList<E>(list.subList(fromIndex, toIndex));
- }
- /**
- * UnmodifiableRandomAccessList instances are serialized as
- * UnmodifiableList instances to allow them to be deserialized
- * in pre-1.4 JREs (which do not have UnmodifiableRandomAccessList).
- * This method inverts the transformation. As a beneficial
- * side-effect, it also grafts the RandomAccess marker onto
- * UnmodifiableList instances that were serialized in pre-1.4 JREs.
- *
- * Note: Unfortunately, UnmodifiableRandomAccessList instances
- * serialized in 1.4.1 and deserialized in 1.4 will become
- * UnmodifiableList instances, as this method was missing in 1.4.
- * 这个,自己看吧...
- */
- private Object readResolve() {
- return (list instanceof RandomAccess
- ? new UnmodifiableRandomAccessList<E>(list)
- : this);
- }
- }
- static class UnmodifiableRandomAccessList<E> extends UnmodifiableList<E>
- implements RandomAccess{
- UnmodifiableRandomAccessList(List<? extends E> list) {
- super(list);
- }
- public List<E> subList(int fromIndex, int toIndex) {
- return new UnmodifiableRandomAccessList<E>(
- list.subList(fromIndex, toIndex));
- }
- private static final long serialVersionUID = -2542308836966382001L;
- /**
- * Allows instances to be deserialized in pre-1.4 JREs (which do
- * not have UnmodifiableRandomAccessList). UnmodifiableList has
- * a readResolve method that inverts this transformation upon
- * deserialization.
- */
- private Object writeReplace() {
- return new UnmodifiableList<E>(list);
- }
- }
- /**
- * 返回一个不可修改的map
- */
- public static <K,V> Map<K,V> unmodifiableMap(Map<? extends K, ? extends V> m) {
- return new UnmodifiableMap<K,V>(m);
- }
- private static class UnmodifiableMap<K,V> implements Map<K,V>, Serializable {
- // use serialVersionUID from JDK 1.2.2 for interoperability
- private static final long serialVersionUID = -1034234728574286014L;
- private final Map<? extends K, ? extends V> m;
- UnmodifiableMap(Map<? extends K, ? extends V> m) {
- if (m==null)
- throw new NullPointerException();
- this.m = m;
- }
- public int size() {return m.size();}
- public boolean isEmpty() {return m.isEmpty();}
- public boolean containsKey(Object key) {return m.containsKey(key);}
- public boolean containsValue(Object val) {return m.containsValue(val);}
- public V get(Object key) {return m.get(key);}
- public V put(K key, V value) {
- throw new UnsupportedOperationException();
- }
- public V remove(Object key) {
- throw new UnsupportedOperationException();
- }
- public void putAll(Map<? extends K, ? extends V> m) {
- throw new UnsupportedOperationException();
- }
- public void clear() {
- throw new UnsupportedOperationException();
- }
- private transient Set<K> keySet = null;
- private transient Set<Map.Entry<K,V>> entrySet = null;
- private transient Collection<V> values = null;
- //返回的key集也是不可修改的
- public Set<K> keySet() {
- if (keySet==null)
- keySet = unmodifiableSet(m.keySet());
- return keySet;
- }
- //EntrySet被重新进行包装
- public Set<Map.Entry<K,V>> entrySet() {
- if (entrySet==null)
- entrySet = new UnmodifiableEntrySet<K,V>(m.entrySet());
- return entrySet;
- }
- public Collection<V> values() {
- if (values==null)
- values = unmodifiableCollection(m.values());
- return values;
- }
- public boolean equals(Object o) {return o == this || m.equals(o);}
- public int hashCode() {return m.hashCode();}
- public String toString() {return m.toString();}
- /**
- *
- * 需要重新包装返回的EntrySet对象
- */
- static class UnmodifiableEntrySet<K,V> extends UnmodifiableSet<Map.Entry<K,V>> {
- private static final long serialVersionUID = 7854390611657943733L;
- UnmodifiableEntrySet(Set<? extends Map.Entry<? extends K, ? extends V>> s) {
- super((Set)s);
- }
- public Iterator<Map.Entry<K,V>> iterator() {
- return new Iterator<Map.Entry<K,V>>() {
- //父类UnmodifiableColletion的c
- Iterator<? extends Map.Entry<? extends K, ? extends V>> i = c.iterator();
- public boolean hasNext() {
- return i.hasNext();
- }
- public Map.Entry<K,V> next() {
- return new UnmodifiableEntry<K,V>(i.next());
- }
- public void remove() {
- throw new UnsupportedOperationException();
- }
- };
- }
- public Object[] toArray() {
- Object[] a = c.toArray();
- for (int i=0; i<a.length; i++)
- a[i] = new UnmodifiableEntry<K,V>((Map.Entry<K,V>)a[i]);
- return a;
- }
- public <T> T[] toArray(T[] a) {
- Object[] arr = c.toArray(a.length==0 ? a : Arrays.copyOf(a, 0));
- for (int i=0; i<arr.length; i++)
- arr[i] = new UnmodifiableEntry<K,V>((Map.Entry<K,V>)arr[i]);
- if (arr.length > a.length)
- return (T[])arr;
- System.arraycopy(arr, 0, a, 0, arr.length);
- if (a.length > arr.length)
- a[arr.length] = null;
- return a;
- }
- public boolean contains(Object o) {
- if (!(o instanceof Map.Entry))
- return false;
- return c.contains(new UnmodifiableEntry<K,V>((Map.Entry<K,V>) o));
- }
- public boolean containsAll(Collection<?> coll) {
- Iterator<?> e = coll.iterator();
- while (e.hasNext())
- if (!contains(e.next())) // Invokes safe contains() above
- return false;
- return true;
- }
- public boolean equals(Object o) {
- if (o == this)
- return true;
- if (!(o instanceof Set))
- return false;
- Set s = (Set) o;
- if (s.size() != c.size())
- return false;
- return containsAll(s); // Invokes safe containsAll() above
- }
- /**
- * 重新包装Entry。
- */
- private static class UnmodifiableEntry<K,V> implements Map.Entry<K,V> {
- private Map.Entry<? extends K, ? extends V> e;
- UnmodifiableEntry(Map.Entry<? extends K, ? extends V> e) {this.e = e;}
- public K getKey() {return e.getKey();}
- public V getValue() {return e.getValue();}
- public V setValue(V value) { //调用set方法将抛出一个异常
- throw new UnsupportedOperationException();
- }
- public int hashCode() {return e.hashCode();}
- public boolean equals(Object o) {
- if (!(o instanceof Map.Entry))
- return false;
- Map.Entry t = (Map.Entry)o;
- return eq(e.getKey(), t.getKey()) &&
- eq(e.getValue(), t.getValue());
- }
- public String toString() {return e.toString();}
- }
- }
- }
- /**
- * 返回一个不可修改的SortedMap
- */
- public static <K,V> SortedMap<K,V> unmodifiableSortedMap(SortedMap<K, ? extends V> m) {
- return new UnmodifiableSortedMap<K,V>(m);
- }
- static class UnmodifiableSortedMap<K,V> extends UnmodifiableMap<K,V>
- implements SortedMap<K,V>, Serializable {
- private static final long serialVersionUID = -8806743815996713206L;
- private final SortedMap<K, ? extends V> sm;
- UnmodifiableSortedMap(SortedMap<K, ? extends V> m) {super(m); sm = m;}
- public Comparator<? super K> comparator() {return sm.comparator();}
- public SortedMap<K,V> subMap(K fromKey, K toKey) {
- return new UnmodifiableSortedMap<K,V>(sm.subMap(fromKey, toKey));
- }
- public SortedMap<K,V> headMap(K toKey) {
- return new UnmodifiableSortedMap<K,V>(sm.headMap(toKey));
- }
- public SortedMap<K,V> tailMap(K fromKey) {
- return new UnmodifiableSortedMap<K,V>(sm.tailMap(fromKey));
- }
- public K firstKey() {return sm.firstKey();}
- public K lastKey() {return sm.lastKey();}
- }
- // 同步包装
- /**
- *
- * 返回一个线程安全的集合
- * 但是当用户遍历此集合时,需要手动进行同步
- * Collection c = Collections.synchronizedCollection(myCollection);
- * ...
- * synchronized(c) {
- * Iterator i = c.iterator(); // Must be in the synchronized block
- * while (i.hasNext())
- * foo(i.next());
- * }
- *
- */
- public static <T> Collection<T> synchronizedCollection(Collection<T> c) {
- return new SynchronizedCollection<T>(c);
- }
- static <T> Collection<T> synchronizedCollection(Collection<T> c, Object mutex) {
- return new SynchronizedCollection<T>(c, mutex);
- }
- /**
- * @serial include
- */
- static class SynchronizedCollection<E> implements Collection<E>, Serializable {
- // use serialVersionUID from JDK 1.2.2 for interoperability
- private static final long serialVersionUID = 3053995032091335093L;
- final Collection<E> c; // 返回的集合
- final Object mutex; // 需要同步的对象
- SynchronizedCollection(Collection<E> c) {
- if (c==null)
- throw new NullPointerException();
- this.c = c;
- mutex = this;
- }
- SynchronizedCollection(Collection<E> c, Object mutex) {
- this.c = c;
- this.mutex = mutex;
- }
- public int size() {
- synchronized(mutex) {return c.size();}
- }
- 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(); // 必须用户自己手动同步
- }
- 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);}
- }
- public void clear() {
- synchronized(mutex) {c.clear();}
- }
- public String toString() {
- synchronized(mutex) {return c.toString();}
- }
- private void writeObject(ObjectOutputStream s) throws IOException {
- synchronized(mutex) {s.defaultWriteObject();}
- }
- }
- /**
- * 返回一个线程安全的Set
- */
- public static <T> Set<T> synchronizedSet(Set<T> s) {
- return new SynchronizedSet<T>(s);
- }
- static <T> Set<T> synchronizedSet(Set<T> s, Object mutex) {
- return new SynchronizedSet<T>(s, mutex);
- }
- /**
- * @serial include
- */
- static class SynchronizedSet<E> extends SynchronizedCollection<E> implements Set<E> {
- private static final long serialVersionUID = 487447009682186044L;
- SynchronizedSet(Set<E> s) {
- super(s);
- }
- SynchronizedSet(Set<E> s, Object mutex) {
- super(s, mutex);
- }
- public boolean equals(Object o) {
- synchronized(mutex) {return c.equals(o);}
- }
- public int hashCode() {
- synchronized(mutex) {return c.hashCode();}
- }
- }
- /**
- * 返回一个线程安全的SortedSet
- */
- public static <T> SortedSet<T> synchronizedSortedSet(SortedSet<T> s) {
- return new SynchronizedSortedSet<T>(s);
- }
- /**
- * @serial include
- */
- static class SynchronizedSortedSet<E> extends SynchronizedSet<E>implements SortedSet<E>{
- private static final long serialVersionUID = 8695801310862127406L;
- final private SortedSet<E> ss;
- SynchronizedSortedSet(SortedSet<E> s) {
- super(s);
- ss = s;
- }
- SynchronizedSortedSet(SortedSet<E> s, Object mutex) {
- super(s, mutex);
- ss = s;
- }
- public Comparator<? super E> comparator() {
- synchronized(mutex) {return ss.comparator();}
- }
- public SortedSet<E> subSet(E fromElement, E toElement) {
- synchronized(mutex) {
- return new SynchronizedSortedSet<E>(
- ss.subSet(fromElement, toElement), mutex);
- }
- }
- public SortedSet<E> headSet(E toElement) {
- synchronized(mutex) {
- return new SynchronizedSortedSet<E>(ss.headSet(toElement), mutex);
- }
- }
- public SortedSet<E> tailSet(E fromElement) {
- synchronized(mutex) {
- return new SynchronizedSortedSet<E>(ss.tailSet(fromElement),mutex);
- }
- }
- public E first() {
- synchronized(mutex) {return ss.first();}
- }
- public E last() {
- synchronized(mutex) {return ss.last();}
- }
- }
- /**
- * 返回一个线程安全的List,
- * 如果List是基于随机访问的,返回的List同样实现了RandomAccess接口
- */
- public static <T> List<T> synchronizedList(List<T> list) {
- return (list instanceof RandomAccess ?
- new SynchronizedRandomAccessList<T>(list) :
- new SynchronizedList<T>(list));
- }
- static <T> List<T> synchronizedList(List<T> list, Object mutex) {
- return (list instanceof RandomAccess ?
- new SynchronizedRandomAccessList<T>(list, mutex) :
- new SynchronizedList<T>(list, mutex));
- }
- /**
- * @serial include
- */
- static class SynchronizedList<E>extends SynchronizedCollection<E> implements List<E> {
- static final long serialVersionUID = -7754090372962971524L;
- final List<E> list;
- SynchronizedList(List<E> list) {
- super(list);
- this.list = list;
- }
- SynchronizedList(List<E> list, Object mutex) {
- super(list, mutex);
- this.list = list;
- }
- public boolean equals(Object o) {
- synchronized(mutex) {return list.equals(o);}
- }
- public int hashCode() {
- synchronized(mutex) {return list.hashCode();}
- }
- public E get(int index) {
- synchronized(mutex) {return list.get(index);}
- }
- public E set(int index, E element) {
- synchronized(mutex) {return list.set(index, element);}
- }
- public void add(int index, E element) {
- synchronized(mutex) {list.add(index, element);}
- }
- public E remove(int index) {
- synchronized(mutex) {return list.remove(index);}
- }
- public int indexOf(Object o) {
- synchronized(mutex) {return list.indexOf(o);}
- }
- public int lastIndexOf(Object o) {
- synchronized(mutex) {return list.lastIndexOf(o);}
- }
- public boolean addAll(int index, Collection<? extends E> c) {
- synchronized(mutex) {return list.addAll(index, c);}
- }
- public ListIterator<E> listIterator() {
- return list.listIterator(); // Must be manually synched by user
- }
- public ListIterator<E> listIterator(int index) {
- return list.listIterator(index); // Must be manually synched by user
- }
- public List<E> subList(int fromIndex, int toIndex) {
- synchronized(mutex) {
- return new SynchronizedList<E>(list.subList(fromIndex, toIndex),
- mutex);
- }
- }
- private Object readResolve() {
- return (list instanceof RandomAccess
- ? new SynchronizedRandomAccessList<E>(list)
- : this);
- }
- }
- /**
- * @serial include
- */
- static class SynchronizedRandomAccessList<E>extends SynchronizedList<E>
- implements RandomAccess {
- SynchronizedRandomAccessList(List<E> list) {
- super(list);
- }
- SynchronizedRandomAccessList(List<E> list, Object mutex) {
- super(list, mutex);
- }
- public List<E> subList(int fromIndex, int toIndex) {
- synchronized(mutex) {
- return new SynchronizedRandomAccessList<E>(
- list.subList(fromIndex, toIndex), mutex);
- }
- }
- static final long serialVersionUID = 1530674583602358482L;
- private Object writeReplace() {
- return new SynchronizedList<E>(list);
- }
- }
- /**
- * 返回一个线程安全的map
- */
- public static <K,V> Map<K,V> synchronizedMap(Map<K,V> m) {
- return new SynchronizedMap<K,V>(m);
- }
- /**
- * @serial include
- */
- private static class SynchronizedMap<K,V>
- implements Map<K,V>, Serializable {
- // use serialVersionUID from JDK 1.2.2 for interoperability
- private static final long serialVersionUID = 1978198479659022715L;
- private final Map<K,V> m; // Backing Map
- final Object mutex; // Object on which to synchronize
- SynchronizedMap(Map<K,V> m) {
- if (m==null)
- throw new NullPointerException();
- this.m = m;
- mutex = this;
- }
- SynchronizedMap(Map<K,V> m, Object mutex) {
- this.m = m;
- this.mutex = mutex;
- }
- public int size() {
- synchronized(mutex) {return m.size();}
- }
- public boolean isEmpty(){
- synchronized(mutex) {return m.isEmpty();}
- }
- public boolean containsKey(Object key) {
- synchronized(mutex) {return m.containsKey(key);}
- }
- public boolean containsValue(Object value){
- synchronized(mutex) {return m.containsValue(value);}
- }
- public V get(Object key) {
- synchronized(mutex) {return m.get(key);}
- }
- public V put(K key, V value) {
- synchronized(mutex) {return m.put(key, value);}
- }
- public V remove(Object key) {
- synchronized(mutex) {return m.remove(key);}
- }
- public void putAll(Map<? extends K, ? extends V> map) {
- synchronized(mutex) {m.putAll(map);}
- }
- public void clear() {
- synchronized(mutex) {m.clear();}
- }
- private transient Set<K> keySet = null;
- private transient Set<Map.Entry<K,V>> entrySet = null;
- private transient Collection<V> values = null;
- public Set<K> keySet() {
- synchronized(mutex) {
- if (keySet==null)
- keySet = new SynchronizedSet<K>(m.keySet(), mutex);
- return keySet;
- }
- }
- public Set<Map.Entry<K,V>> entrySet() {
- synchronized(mutex) {
- if (entrySet==null)
- entrySet = new SynchronizedSet<Map.Entry<K,V>>(m.entrySet(), mutex);
- return entrySet;
- }
- }
- public Collection<V> values() {
- synchronized(mutex) {
- if (values==null)
- values = new SynchronizedCollection<V>(m.values(), mutex);
- return values;
- }
- }
- public boolean equals(Object o) {
- synchronized(mutex) {return m.equals(o);}
- }
- public int hashCode() {
- synchronized(mutex) {return m.hashCode();}
- }
- public String toString() {
- synchronized(mutex) {return m.toString();}
- }
- private void writeObject(ObjectOutputStream s) throws IOException {
- synchronized(mutex) {s.defaultWriteObject();}
- }
- }
- /**
- * 返回一个线程安全的SortedSet
- */
- public static <K,V> SortedMap<K,V> synchronizedSortedMap(SortedMap<K,V> m) {
- return new SynchronizedSortedMap<K,V>(m);
- }
- /**
- * @serial include
- */
- static class SynchronizedSortedMap<K,V>
- extends SynchronizedMap<K,V>
- implements SortedMap<K,V>
- {
- private static final long serialVersionUID = -8798146769416483793L;
- private final SortedMap<K,V> sm;
- SynchronizedSortedMap(SortedMap<K,V> m) {
- super(m);
- sm = m;
- }
- SynchronizedSortedMap(SortedMap<K,V> m, Object mutex) {
- super(m, mutex);
- sm = m;
- }
- public Comparator<? super K> comparator() {
- synchronized(mutex) {return sm.comparator();}
- }
- public SortedMap<K,V> subMap(K fromKey, K toKey) {
- synchronized(mutex) {
- return new SynchronizedSortedMap<K,V>(
- sm.subMap(fromKey, toKey), mutex);
- }
- }
- public SortedMap<K,V> headMap(K toKey) {
- synchronized(mutex) {
- return new SynchronizedSortedMap<K,V>(sm.headMap(toKey), mutex);
- }
- }
- public SortedMap<K,V> tailMap(K fromKey) {
- synchronized(mutex) {
- return new SynchronizedSortedMap<K,V>(sm.tailMap(fromKey),mutex);
- }
- }
- public K firstKey() {
- synchronized(mutex) {return sm.firstKey();}
- }
- public K lastKey() {
- synchronized(mutex) {return sm.lastKey();}
- }
- }
- // Dynamically typesafe collection wrappers
- /**
- *
- * 返回一个动态的类型安全的集合。任何试图插入错误类型的元素的操作将立刻抛出
- * ClassCastException
- * 动态类型安全视图的一个主要作用是用作debug调试,
- * 因为它能正确反映出出错的位置。
- * 例如:ArrayList<String> strings = new ArrayList<String>();
- * ArrayList rawList = strings;
- * rawList.add(new Date());
- * add方法并不进行类型检查,所以存入了非String的对象。只有在重新获取该对象
- * 转化为String类型的时候才抛出异常。
- * 而动态类型安全的集合能在add时就会抛出ClassCastException。
- * 这种方法的优点是错误可以在正确的位置被报告
- *
- *
- */
- public static <E> Collection<E> checkedCollection(Collection<E> c,Class<E> type) {
- return new CheckedCollection<E>(c, type);
- }
- /**
- * @serial include
- */
- static class CheckedCollection<E> implements Collection<E>, Serializable {
- private static final long serialVersionUID = 1578914078182001775L;
- final Collection<E> c;
- final Class<E> type;
- void typeCheck(Object o) {
- if (!type.isInstance(o)) //o是否能被转换成type类型
- throw new ClassCastException("Attempt to insert " +
- o.getClass() + " element into collection with element type "
- + type);
- }
- CheckedCollection(Collection<E> c, Class<E> type) {
- if (c==null || type == null)
- throw new NullPointerException();
- this.c = c;
- this.type = type;
- }
- public int size() { return c.size(); }
- public boolean isEmpty() { return c.isEmpty(); }
- public boolean contains(Object o) { return c.contains(o); }
- public Object[] toArray() { return c.toArray(); }
- public <T> T[] toArray(T[] a) { return c.toArray(a); }
- public String toString() { return c.toString(); }
- public boolean remove(Object o) { return c.remove(o); }
- public boolean containsAll(Collection<?> coll) {
- return c.containsAll(coll);
- }
- public boolean removeAll(Collection<?> coll) {
- return c.removeAll(coll);
- }
- public boolean retainAll(Collection<?> coll) {
- return c.retainAll(coll);
- }
- public void clear() {
- c.clear();
- }
- public Iterator<E> iterator() {
- return new Iterator<E>() {
- private final Iterator<E> it = c.iterator();
- public boolean hasNext() { return it.hasNext(); }
- public E next() { return it.next(); }
- public void remove() { it.remove(); }};
- }
- public boolean add(E e){
- typeCheck(e); //添加元素需要进行类型检查
- return c.add(e);
- }
- public boolean addAll(Collection<? extends E> coll) {
- E[] a = null;
- try {
- a = coll.toArray(zeroLengthElementArray()); //根据zero数组的类型来转换集合为数组。如果coll中含有其他类型这里就会抛出异常
- } catch (ArrayStoreException e) {
- throw new ClassCastException();
- }
- boolean result = false;
- for (E e : a)
- result |= c.add(e); //只要集合发生了改变就返回true
- return result;
- }
- private E[] zeroLengthElementArray = null; // Lazily initialized
- /*
- * We don't need locking or volatile, because it's OK if we create
- * several zeroLengthElementArrays, and they're immutable.
- */
- E[] zeroLengthElementArray() {
- if (zeroLengthElementArray == null)
- zeroLengthElementArray = (E[]) Array.newInstance(type, 0);
- return zeroLengthElementArray;
- }
- }
- /**
- * 返回一个会检查类型的集合Set
- */
- public static <E> Set<E> checkedSet(Set<E> s, Class<E> type) {
- return new CheckedSet<E>(s, type);
- }
- /**
- * @serial include
- */
- static class CheckedSet<E> extends CheckedCollection<E>
- implements Set<E>, Serializable{
- private static final long serialVersionUID = 4694047833775013803L;
- CheckedSet(Set<E> s, Class<E> elementType) { super(s, elementType); }
- public boolean equals(Object o) { return o == this || c.equals(o); }
- public int hashCode() { return c.hashCode(); }
- }
- /**
- * 返回一个类型安全的集合SortedSet
- */
- public static <E> SortedSet<E> checkedSortedSet(SortedSet<E> s,Class<E> type) {
- return new CheckedSortedSet<E>(s, type);
- }
- /**
- * @serial include
- */
- static class CheckedSortedSet<E> extends CheckedSet<E>
- implements SortedSet<E>, Serializable{
- private static final long serialVersionUID = 1599911165492914959L;
- private final SortedSet<E> ss;
- CheckedSortedSet(SortedSet<E> s, Class<E> type) {
- super(s, type);
- ss = s;
- }
- public Comparator<? super E> comparator() { return ss.comparator(); }
- public E first() { return ss.first(); }
- public E last() { return ss.last(); }
- public SortedSet<E> subSet(E fromElement, E toElement) {
- return new CheckedSortedSet<E>(ss.subSet(fromElement,toElement),
- type);
- }
- public SortedSet<E> headSet(E toElement) {
- return new CheckedSortedSet<E>(ss.headSet(toElement), type);
- }
- public SortedSet<E> tailSet(E fromElement) {
- return new CheckedSortedSet<E>(ss.tailSet(fromElement), type);
- }
- }
- /**
- * 返回一个类型安全的集合List
- */
- public static <E> List<E> checkedList(List<E> list, Class<E> type) {
- return (list instanceof RandomAccess ?
- new CheckedRandomAccessList<E>(list, type) :
- new CheckedList<E>(list, type));
- }
- /**
- * @serial include
- */
- static class CheckedList<E> extends CheckedCollection<E>
- implements List<E>
- {
- static final long serialVersionUID = 65247728283967356L;
- final List<E> list;
- CheckedList(List<E> list, Class<E> type) {
- super(list, type);
- this.list = list;
- }
- public boolean equals(Object o) { return o == this || list.equals(o); }
- public int hashCode() { return list.hashCode(); }
- public E get(int index) { return list.get(index); }
- public E remove(int index) { return list.remove(index); }
- public int indexOf(Object o) { return list.indexOf(o); }
- public int lastIndexOf(Object o) { return list.lastIndexOf(o); }
- public E set(int index, E element) {
- typeCheck(element);
- return list.set(index, element);
- }
- public void add(int index, E element) {
- typeCheck(element);
- list.add(index, element);
- }
- public boolean addAll(int index, Collection<? extends E> c) {
- // See CheckCollection.addAll, above, for an explanation
- E[] a = null;
- try {
- a = c.toArray(zeroLengthElementArray());
- } catch (ArrayStoreException e) {
- throw new ClassCastException();
- }
- return list.addAll(index, Arrays.asList(a));
- }
- public ListIterator<E> listIterator() { return listIterator(0); }
- public ListIterator<E> listIterator(final int index) {
- return new ListIterator<E>() {
- ListIterator<E> i = list.listIterator(index);
- public boolean hasNext() { return i.hasNext(); }
- public E next() { return i.next(); }
- public boolean hasPrevious() { return i.hasPrevious(); }
- public E previous() { return i.previous(); }
- public int nextIndex() { return i.nextIndex(); }
- public int previousIndex() { return i.previousIndex(); }
- public void remove() { i.remove(); }
- public void set(E e) {
- typeCheck(e);
- i.set(e);
- }
- public void add(E e) {
- typeCheck(e);
- i.add(e);
- }
- };
- }
- public List<E> subList(int fromIndex, int toIndex) {
- return new CheckedList<E>(list.subList(fromIndex, toIndex), type);
- }
- }
- /**
- * @serial include
- */
- static class CheckedRandomAccessList<E> extends CheckedList<E>
- implements RandomAccess
- {
- private static final long serialVersionUID = 1638200125423088369L;
- CheckedRandomAccessList(List<E> list, Class<E> type) {
- super(list, type);
- }
- public List<E> subList(int fromIndex, int toIndex) {
- return new CheckedRandomAccessList<E>(
- list.subList(fromIndex, toIndex), type);
- }
- }
- /**
- * 返回一个类型安全的集合Map
- */
- public static <K, V> Map<K, V> checkedMap(Map<K, V> m, Class<K> keyType,
- Class<V> valueType) {
- return new CheckedMap<K,V>(m, keyType, valueType);
- }
- /**
- * @serial include
- */
- private static class CheckedMap<K,V> implements Map<K,V>,
- Serializable
- {
- private static final long serialVersionUID = 5742860141034234728L;
- private final Map<K, V> m;
- final Class<K> keyType;
- final Class<V> valueType;
- //需要对key与value都进行类型检查
- private void typeCheck(Object key, Object value) {
- if (!keyType.isInstance(key))
- throw new ClassCastException("Attempt to insert " +
- key.getClass() + " key into collection with key type "
- + keyType);
- if (!valueType.isInstance(value))
- throw new ClassCastException("Attempt to insert " +
- value.getClass() +" value into collection with value type "
- + valueType);
- }
- CheckedMap(Map<K, V> m, Class<K> keyType, Class<V> valueType) {
- if (m == null || keyType == null || valueType == null)
- throw new NullPointerException();
- this.m = m;
- this.keyType = keyType;
- this.valueType = valueType;
- }
- public int size() { return m.size(); }
- public boolean isEmpty() { return m.isEmpty(); }
- public boolean containsKey(Object key) { return m.containsKey(key); }
- public boolean containsValue(Object v) { return m.containsValue(v); }
- public V get(Object key) { return m.get(key); }
- public V remove(Object key) { return m.remove(key); }
- public void clear() { m.clear(); }
- public Set<K> keySet() { return m.keySet(); }
- public Collection<V> values() { return m.values(); }
- public boolean equals(Object o) { return o == this || m.equals(o); }
- public int hashCode() { return m.hashCode(); }
- public String toString() { return m.toString(); }
- public V put(K key, V value) {
- typeCheck(key, value);
- return m.put(key, value);
- }
- public void putAll(Map<? extends K, ? extends V> t) {
- // See CheckCollection.addAll, above, for an explanation
- K[] keys = null;
- try {
- keys = t.keySet().toArray(zeroLengthKeyArray());
- } catch (ArrayStoreException e) {
- throw new ClassCastException();
- }
- V[] values = null;
- try {
- values = t.values().toArray(zeroLengthValueArray());
- } catch (ArrayStoreException e) {
- throw new ClassCastException();
- }
- if (keys.length != values.length)
- throw new ConcurrentModificationException();
- for (int i = 0; i < keys.length; i++)
- m.put(keys[i], values[i]);
- }
- // Lazily initialized
- private K[] zeroLengthKeyArray = null;
- private V[] zeroLengthValueArray = null;
- /*
- * We don't need locking or volatile, because it's OK if we create
- * several zeroLengthValueArrays, and they're immutable.
- */
- private K[] zeroLengthKeyArray() {
- if (zeroLengthKeyArray == null)
- zeroLengthKeyArray = (K[]) Array.newInstance(keyType, 0);
- return zeroLengthKeyArray;
- }
- private V[] zeroLengthValueArray() {
- if (zeroLengthValueArray == null)
- zeroLengthValueArray = (V[]) Array.newInstance(valueType, 0);
- return zeroLengthValueArray;
- }
- private transient Set<Map.Entry<K,V>> entrySet = null;
- public Set<Map.Entry<K,V>> entrySet() {
- if (entrySet==null)
- entrySet = new CheckedEntrySet<K,V>(m.entrySet(), valueType);
- return entrySet;
- }
- /**
- * We need this class in addition to CheckedSet as Map.Entry permits
- * modification of the backing Map via the setValue operation. This
- * class is subtle: there are many possible attacks that must be
- * thwarted.
- *
- * @serial exclude
- */
- static class CheckedEntrySet<K,V> implements Set<Map.Entry<K,V>> {
- Set<Map.Entry<K,V>> s;
- Class<V> valueType;
- CheckedEntrySet(Set<Map.Entry<K, V>> s, Class<V> valueType) {
- this.s = s;
- this.valueType = valueType;
- }
- public int size() { return s.size(); }
- public boolean isEmpty() { return s.isEmpty(); }
- public String toString() { return s.toString(); }
- public int hashCode() { return s.hashCode(); }
- public boolean remove(Object o) { return s.remove(o); }
- public boolean removeAll(Collection<?> coll) {
- return s.removeAll(coll);
- }
- public boolean retainAll(Collection<?> coll) {
- return s.retainAll(coll);
- }
- public void clear() {
- s.clear();
- }
- public boolean add(Map.Entry<K, V> e){
- throw new UnsupportedOperationException();
- }
- public boolean addAll(Collection<? extends Map.Entry<K, V>> coll) {
- throw new UnsupportedOperationException();
- }
- public Iterator<Map.Entry<K,V>> iterator() {
- return new Iterator<Map.Entry<K,V>>() {
- Iterator<Map.Entry<K, V>> i = s.iterator();
- public boolean hasNext() { return i.hasNext(); }
- public void remove() { i.remove(); }
- public Map.Entry<K,V> next() {
- return new CheckedEntry<K,V>(i.next(), valueType);
- }
- };
- }
- public Object[] toArray() {
- Object[] source = s.toArray();
- /*
- * Ensure that we don't get an ArrayStoreException even if
- * s.toArray returns an array of something other than Object
- */
- Object[] dest = (CheckedEntry.class.isInstance(
- source.getClass().getComponentType()) ? source :
- new Object[source.length]);
- for (int i = 0; i < source.length; i++)
- dest[i] = new CheckedEntry<K,V>((Map.Entry<K,V>)source[i],
- valueType);
- return dest;
- }
- public <T> T[] toArray(T[] a) {
- // We don't pass a to s.toArray, to avoid window of
- // vulnerability wherein an unscrupulous multithreaded client
- // could get his hands on raw (unwrapped) Entries from s.
- Object[] arr = s.toArray(a.length==0 ? a : Arrays.copyOf(a, 0));
- for (int i=0; i<arr.length; i++)
- arr[i] = new CheckedEntry<K,V>((Map.Entry<K,V>)arr[i],
- valueType);
- if (arr.length > a.length)
- return (T[])arr;
- System.arraycopy(arr, 0, a, 0, arr.length);
- if (a.length > arr.length)
- a[arr.length] = null;
- return a;
- }
- /**
- * This method is overridden to protect the backing set against
- * an object with a nefarious equals function that senses
- * that the equality-candidate is Map.Entry and calls its
- * setValue method.
- */
- public boolean contains(Object o) {
- if (!(o instanceof Map.Entry))
- return false;
- return s.contains(
- new CheckedEntry<K,V>((Map.Entry<K,V>) o, valueType));
- }
- /**
- * The next two methods are overridden to protect against
- * an unscrupulous collection whose contains(Object o) method
- * senses when o is a Map.Entry, and calls o.setValue.
- */
- public boolean containsAll(Collection<?> coll) {
- Iterator<?> e = coll.iterator();
- while (e.hasNext())
- if (!contains(e.next())) // Invokes safe contains() above
- return false;
- return true;
- }
- public boolean equals(Object o) {
- if (o == this)
- return true;
- if (!(o instanceof Set))
- return false;
- Set<?> that = (Set<?>) o;
- if (that.size() != s.size())
- return false;
- return containsAll(that); // Invokes safe containsAll() above
- }
- /**
- * This "wrapper class" serves two purposes: it prevents
- * the client from modifying the backing Map, by short-circuiting
- * the setValue method, and it protects the backing Map against
- * an ill-behaved Map.Entry that attempts to modify another
- * Map Entry when asked to perform an equality check.
- */
- private static class CheckedEntry<K,V> implements Map.Entry<K,V> {
- private Map.Entry<K, V> e;
- private Class<V> valueType;
- CheckedEntry(Map.Entry<K, V> e, Class<V> valueType) {
- this.e = e;
- this.valueType = valueType;
- }
- public K getKey() { return e.getKey(); }
- public V getValue() { return e.getValue(); }
- public int hashCode() { return e.hashCode(); }
- public String toString() { return e.toString(); }
- public V setValue(V value) {
- if (!valueType.isInstance(value))
- throw new ClassCastException("Attempt to insert " +
- value.getClass() +
- " value into collection with value type " + valueType);
- return e.setValue(value);
- }
- public boolean equals(Object o) {
- if (!(o instanceof Map.Entry))
- return false;
- Map.Entry t = (Map.Entry)o;
- return eq(e.getKey(), t.getKey()) &&
- eq(e.getValue(), t.getValue());
- }
- }
- }
- }
- /**
- * 返回一个类型安全的集合SortedMap
- */
- public static <K,V> SortedMap<K,V> checkedSortedMap(SortedMap<K, V> m,
- Class<K> keyType,
- Class<V> valueType) {
- return new CheckedSortedMap<K,V>(m, keyType, valueType);
- }
- /**
- * @serial include
- */
- static class CheckedSortedMap<K,V> extends CheckedMap<K,V>
- implements SortedMap<K,V>, Serializable
- {
- private static final long serialVersionUID = 1599671320688067438L;
- private final SortedMap<K, V> sm;
- CheckedSortedMap(SortedMap<K, V> m,
- Class<K> keyType, Class<V> valueType) {
- super(m, keyType, valueType);
- sm = m;
- }
- public Comparator<? super K> comparator() { return sm.comparator(); }
- public K firstKey() { return sm.firstKey(); }
- public K lastKey() { return sm.lastKey(); }
- public SortedMap<K,V> subMap(K fromKey, K toKey) {
- return new CheckedSortedMap<K,V>(sm.subMap(fromKey, toKey),
- keyType, valueType);
- }
- public SortedMap<K,V> headMap(K toKey) {
- return new CheckedSortedMap<K,V>(sm.headMap(toKey),
- keyType, valueType);
- }
- public SortedMap<K,V> tailMap(K fromKey) {
- return new CheckedSortedMap<K,V>(sm.tailMap(fromKey),
- keyType, valueType);
- }
- }
- // 其他
- /**
- * 不可变的空集
- */
- public static final Set EMPTY_SET = new EmptySet();
- /**
- *
- * 返回一个不可变的空集
- * size始终为0
- */
- public static final <T> Set<T> emptySet() {
- return (Set<T>) EMPTY_SET;
- }
- /**
- * @serial include
- */
- private static class EmptySet extends AbstractSet<Object> implements Serializable {
- // use serialVersionUID from JDK 1.2.2 for interoperability
- private static final long serialVersionUID = 1582296315990362920L;
- public Iterator<Object> iterator() {
- return new Iterator<Object>() {
- public boolean hasNext() {
- return false;
- }
- public Object next() {
- throw new NoSuchElementException();
- }
- public void remove() {
- throw new UnsupportedOperationException();
- }
- };
- }
- public int size() {return 0;}
- public boolean contains(Object obj) {return false;}
- // Preserves singleton property
- private Object readResolve() {
- return EMPTY_SET;
- }
- }
- public static final List EMPTY_LIST = new EmptyList();
- public static final <T> List<T> emptyList() {
- return (List<T>) EMPTY_LIST;
- }
- /**
- * @serial include
- */
- private static class EmptyList extends AbstractList<Object>
- implements RandomAccess, Serializable {
- // use serialVersionUID from JDK 1.2.2 for interoperability
- private static final long serialVersionUID = 8842843931221139166L;
- public int size() {return 0;}
- public boolean contains(Object obj) {return false;}
- public Object get(int index) {
- throw new IndexOutOfBoundsException("Index: "+index);
- }
- // Preserves singleton property
- private Object readResolve() {
- return EMPTY_LIST;
- }
- }
- public static final Map EMPTY_MAP = new EmptyMap();
- public static final <K,V> Map<K,V> emptyMap() {
- return (Map<K,V>) EMPTY_MAP;
- }
- private static class EmptyMap
- extends AbstractMap<Object,Object>
- implements Serializable {
- private static final long serialVersionUID = 6428348081105594320L;
- public int size() {return 0;}
- public boolean isEmpty() {return true;}
- public boolean containsKey(Object key) {return false;}
- public boolean containsValue(Object value) {return false;}
- public Object get(Object key) {return null;}
- public Set<Object> keySet() {return Collections.<Object>emptySet();}
- public Collection<Object> values() {return Collections.<Object>emptySet();}
- public Set<Map.Entry<Object,Object>> entrySet() {
- return Collections.emptySet();
- }
- public boolean equals(Object o) {
- return (o instanceof Map) && ((Map)o).size()==0;
- }
- public int hashCode() {return 0;}
- // Preserves singleton property
- private Object readResolve() {
- return EMPTY_MAP;
- }
- }
- /**
- *
- * 返回只包含一个元素的不可变的集合
- */
- public static <T> Set<T> singleton(T o) {
- return new SingletonSet<T>(o);
- }
- /**
- * @serial include
- */
- private static class SingletonSet<E> extends AbstractSet<E>
- implements Serializable{
- // use serialVersionUID from JDK 1.2.2 for interoperability
- private static final long serialVersionUID = 3193687207550431679L;
- final private E element;
- SingletonSet(E e) {element = e;}
- public Iterator<E> iterator() {
- return new Iterator<E>() {
- private boolean hasNext = true;
- public boolean hasNext() {
- return hasNext;
- }
- public E next() {
- if (hasNext) {
- hasNext = false;
- return element;
- }
- throw new NoSuchElementException();
- }
- public void remove() {
- throw new UnsupportedOperationException();
- }
- };
- }
- public int size() {return 1;}
- public boolean contains(Object o) {return eq(o, element);}
- }
- public static <T> List<T> singletonList(T o) {
- return new SingletonList<T>(o);
- }
- private static class SingletonList<E>
- extends AbstractList<E>
- implements RandomAccess, Serializable {
- static final long serialVersionUID = 3093736618740652951L;
- private final E element;
- SingletonList(E obj) {element = obj;}
- public int size() {return 1;}
- public boolean contains(Object obj) {return eq(obj, element);}
- public E get(int index) {
- if (index != 0)
- throw new IndexOutOfBoundsException("Index: "+index+", Size: 1");
- return element;
- }
- }
- public static <K,V> Map<K,V> singletonMap(K key, V value) {
- return new SingletonMap<K,V>(key, value);
- }
- private static class SingletonMap<K,V> extends AbstractMap<K,V>
- implements Serializable {
- private static final long serialVersionUID = -6979724477215052911L;
- private final K k;
- private final V v;
- SingletonMap(K key, V value) {
- k = key;
- v = value;
- }
- public int size() {return 1;}
- public boolean isEmpty() {return false;}
- public boolean containsKey(Object key) {return eq(key, k);}
- public boolean containsValue(Object value) {return eq(value, v);}
- public V get(Object key) {return (eq(key, k) ? v : null);}
- private transient Set<K> keySet = null;
- private transient Set<Map.Entry<K,V>> entrySet = null;
- private transient Collection<V> values = null;
- public Set<K> keySet() {
- if (keySet==null)
- keySet = singleton(k);
- return keySet;
- }
- public Set<Map.Entry<K,V>> entrySet() {
- if (entrySet==null)
- entrySet = Collections.<Map.Entry<K,V>>singleton(
- new SimpleImmutableEntry<K,V>(k, v));
- return entrySet;
- }
- public Collection<V> values() {
- if (values==null)
- values = singleton(v);
- return values;
- }
- }
- /**
- *
- * 返回一个包含N个o元素的比可变的集合
- * @param n 添加的指定元素的个数
- * @param o 被重复添加的元素
- */
- public static <T> List<T> nCopies(int n, T o) {
- if (n < 0)
- throw new IllegalArgumentException("List length = " + n);
- return new CopiesList<T>(n, o);
- }
- /**
- * @serial include
- */
- private static class CopiesList<E>extends AbstractList<E>
- implements RandomAccess, Serializable{
- static final long serialVersionUID = 2739099268398711800L;
- final int n;
- final E element;
- CopiesList(int n, E e) {
- assert n >= 0;
- this.n = n;
- element = e;
- }
- public int size() {
- return n;
- }
- public boolean contains(Object obj) {
- return n != 0 && eq(obj, element);
- }
- public int indexOf(Object o) {
- return contains(o) ? 0 : -1;
- }
- public int lastIndexOf(Object o) {
- return contains(o) ? n - 1 : -1;
- }
- public E get(int index) {
- if (index < 0 || index >= n)
- throw new IndexOutOfBoundsException("Index: "+index+
- ", Size: "+n);
- return element;
- }
- public Object[] toArray() {
- final Object[] a = new Object[n];
- if (element != null)
- Arrays.fill(a, 0, n, element);
- return a;
- }
- public <T> T[] toArray(T[] a) {
- final int n = this.n;
- if (a.length < n) {
- a = (T[])java.lang.reflect.Array
- .newInstance(a.getClass().getComponentType(), n);
- if (element != null)
- Arrays.fill(a, 0, n, element);
- } else {
- Arrays.fill(a, 0, n, element);
- if (a.length > n)
- a[n] = null;
- }
- return a;
- }
- public List<E> subList(int fromIndex, int toIndex) {
- if (fromIndex < 0)
- throw new IndexOutOfBoundsException("fromIndex = " + fromIndex);
- if (toIndex > n)
- throw new IndexOutOfBoundsException("toIndex = " + toIndex);
- if (fromIndex > toIndex)
- throw new IllegalArgumentException("fromIndex(" + fromIndex +
- ") > toIndex(" + toIndex + ")");
- return new CopiesList(toIndex - fromIndex, element);
- }
- }
- /**
- * 返回一个比较器,该比较器能使集合按降序排列
- * 例如:
- * Arrays.sort(a, Collections.reverseOrder());
- * 能按字母表相反的顺序排列数组
- *
- */
- public static <T> Comparator<T> reverseOrder() {
- return (Comparator<T>) REVERSE_ORDER;
- }
- private static final Comparator REVERSE_ORDER = new ReverseComparator();
- /**
- * @serial include
- */
- private static class ReverseComparator<T>
- implements Comparator<Comparable<Object>>, Serializable {
- // use serialVersionUID from JDK 1.2.2 for interoperability
- private static final long serialVersionUID = 7207038068494060240L;
- public int compare(Comparable<Object> c1, Comparable<Object> c2) {
- return c2.compareTo(c1);
- }
- private Object readResolve() { return reverseOrder(); }
- }
- /**
- * 根据指定比较器的相反顺序排列集合
- */
- public static <T> Comparator<T> reverseOrder(Comparator<T> cmp) {
- if (cmp == null)
- return reverseOrder();
- return new ReverseComparator2<T>(cmp);
- }
- /**
- * @serial include
- */
- private static class ReverseComparator2<T> implements Comparator<T>,
- Serializable{
- private static final long serialVersionUID = 4374092139857L;
- private Comparator<T> cmp;
- ReverseComparator2(Comparator<T> cmp) {
- assert cmp != null;
- this.cmp = cmp;
- }
- public int compare(T t1, T t2) {
- return cmp.compare(t2, t1);
- }
- }
- /**
- * 基于c之上返回一个枚举集
- */
- public static <T> Enumeration<T> enumeration(final Collection<T> c) {
- return new Enumeration<T>() {
- Iterator<T> i = c.iterator();
- public boolean hasMoreElements() {
- return i.hasNext();
- }
- public T nextElement() {
- return i.next();
- }
- };
- }
- /**
- * 根据枚举集中的元素返回一个ArrayList
- */
- public static <T> ArrayList<T> list(Enumeration<T> e) {
- ArrayList<T> l = new ArrayList<T>();
- while (e.hasMoreElements())
- l.add(e.nextElement());
- return l;
- }
- /**
- * 判断两对象是否相等或同位空
- */
- private static boolean eq(Object o1, Object o2) {
- return (o1==null ? o2==null : o1.equals(o2));
- }
- /**
- * 返回c中与o相等的元素的个数
- */
- public static int frequency(Collection<?> c, Object o) {
- int result = 0;
- if (o == null) {
- for (Object e : c)
- if (e == null)
- result++;
- } else {
- for (Object e : c)
- if (o.equals(e))
- result++;
- }
- return result;
- }
- /**
- *
- * 如果两指定集合没有共同的元素则返回true
- */
- public static boolean disjoint(Collection<?> c1, Collection<?> c2) {
- /*
- *
- * 优先遍历的始终是size小的集合或非Set的集合
- */
- if ((c1 instanceof Set) && !(c2 instanceof Set) ||
- (c1.size() > c2.size())) {
- Collection<?> tmp = c1;
- c1 = c2;
- c2 = tmp;
- }
- for (Object e : c1)
- if (c2.contains(e))
- return false;
- return true;
- }
- /**
- * 把所有指定元素添加到集合c中,
- * 有一个元素添加成功就返回true
- */
- public static <T> boolean addAll(Collection<? super T> c, T... elements) {
- boolean result = false;
- for (T element : elements)
- result |= c.add(element);
- return result;
- }
- /**
- * 根据指定的map返回一个set
- * set存储的是map的键值
- */
- public static <E> Set<E> newSetFromMap(Map<E, Boolean> map) {
- return new SetFromMap<E>(map);
- }
- private static class SetFromMap<E> extends AbstractSet<E>
- implements Set<E>, Serializable
- {
- private final Map<E, Boolean> m; // The backing map
- private transient Set<E> s; // Its keySet
- SetFromMap(Map<E, Boolean> map) {
- if (!map.isEmpty())
- throw new IllegalArgumentException("Map is non-empty");
- m = map;
- s = map.keySet();
- }
- public void clear() { m.clear(); }
- public int size() { return m.size(); }
- public boolean isEmpty() { return m.isEmpty(); }
- public boolean contains(Object o) { return m.containsKey(o); }
- public boolean remove(Object o) { return m.remove(o) != null; }
- public boolean add(E e) { return m.put(e, Boolean.TRUE) == null; }
- public Iterator<E> iterator() { return s.iterator(); }
- public Object[] toArray() { return s.toArray(); }
- public <T> T[] toArray(T[] a) { return s.toArray(a); }
- public String toString() { return s.toString(); }
- public int hashCode() { return s.hashCode(); }
- public boolean equals(Object o) { return o == this || s.equals(o); }
- public boolean containsAll(Collection<?> c) {return s.containsAll(c);}
- public boolean removeAll(Collection<?> c) {return s.removeAll(c);}
- public boolean retainAll(Collection<?> c) {return s.retainAll(c);}
- // addAll is the only inherited implementation
- private static final long serialVersionUID = 2454657854757543876L;
- private void readObject(java.io.ObjectInputStream stream)
- throws IOException, ClassNotFoundException
- {
- stream.defaultReadObject();
- s = m.keySet();
- }
- }
- /**
- *
- * 把指定Deque包装成一个后进先出的队列
- * add方法对应push,remove方法对应pop等。
- *
- */
- public static <T> Queue<T> asLifoQueue(Deque<T> deque) {
- return new AsLIFOQueue<T>(deque);
- }
- static class AsLIFOQueue<E> extends AbstractQueue<E>
- implements Queue<E>, Serializable {
- private static final long serialVersionUID = 1802017725587941708L;
- private final Deque<E> q;
- AsLIFOQueue(Deque<E> q) { this.q = q; }
- public boolean add(E e) { q.addFirst(e); return true; }
- public boolean offer(E e) { return q.offerFirst(e); }
- public E poll() { return q.pollFirst(); }
- public E remove() { return q.removeFirst(); }
- public E peek() { return q.peekFirst(); }
- public E element() { return q.getFirst(); }
- public void clear() { q.clear(); }
- public int size() { return q.size(); }
- public boolean isEmpty() { return q.isEmpty(); }
- public boolean contains(Object o) { return q.contains(o); }
- public boolean remove(Object o) { return q.remove(o); }
- public Iterator<E> iterator() { return q.iterator(); }
- public Object[] toArray() { return q.toArray(); }
- public <T> T[] toArray(T[] a) { return q.toArray(a); }
- public String toString() { return q.toString(); }
- public boolean containsAll(Collection<?> c) {return q.containsAll(c);}
- public boolean removeAll(Collection<?> c) {return q.removeAll(c);}
- public boolean retainAll(Collection<?> c) {return q.retainAll(c);}
- // We use inherited addAll; forwarding addAll would be wrong
- }
- }