zxman
zxman

集合框架源码分析四(Collections类详细分析)

我认为Collections类主要是完成了两个主要功能 
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 > void sort(List list) {
Object[] a = list.toArray(); //转化为对象数组
Arrays.sort(a); //对数组排序，使用了归并排序.对此归并的详细分析可见我另一篇博客
ListIterator i = list.listIterator();
for (int j=0; j //迭代元素
   i.next();
   i.set((T)a[j]); //在同样的位置重设排好序的值
}
    }
    
    


    /**
     * 传一个实现了Comparator接口的对象进来。
     * c.compare(o1,o2);来比较两个元素
     */
    public static void sort(List list, Comparator c) {
Object[] a = list.toArray();
Arrays.sort(a, (Comparator)c);
ListIterator i = list.listIterator();
for (int j=0; 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 int binarySearch(List> list, T key) {
        if (list instanceof RandomAccess || list.size()             return Collections.indexedBinarySearch(list, key);
        else
            return Collections.iteratorBinarySearch(list, key);
    }


    /**
     * 使用索引化二分查找。
     * size小于5000的链表也用此方法查找
     */
    private static int indexedBinarySearch(List> list, T key){
int low = 0; //元素所在范围的下界
int high = list.size()-1; //上界

while (low <= high) {
   int mid = (low + high) >>> 1;
   Comparable 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 int iteratorBinarySearch(List> list, T key){
int low = 0;
int high = list.size()-1;
       ListIterator> i = list.listIterator();

       while (low <= high) {
           int mid = (low + high) >>> 1;
           Comparable 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 get(ListIterator 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 int binarySearch(List list, T key, Comparator c) {
        if (c==null)
            return binarySearch((List) list, key);


        if (list instanceof RandomAccess || list.size()             return Collections.indexedBinarySearch(list, key, c);
        else
            return Collections.iteratorBinarySearch(list, key, c);
    }


    private static int indexedBinarySearch(List l, T key, Comparator 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 int iteratorBinarySearch(List l, T key, Comparator c) {
int low = 0;
int high = l.size()-1;
       ListIterator 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 {}




    /**
     * 
     * 逆序排列指定列表中的元素
     */
    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 //第一个与最后一个，依次交换
                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 //这..，一个思想你懂得
            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                 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 void fill(List list, T obj) {
        int size = list.size();


        if (size < FILL_THRESHOLD || list instanceof RandomAccess) {
            for (int i=0; i                 list.set(i, obj);
        } else {
            ListIterator itr = list.listIterator();
            for (int i=0; i                 itr.next();
                itr.set(obj);
            }
        }
    }


    /**
     * 
     * 复制源列表的所有元素到目标列表，
     * 如果src.size > dest.size 将抛出一个异常
     * 如果src.size < dest.size dest中多出的元素将不受影响
     * 同样是依次遍历赋值
     */
    public static void copy(List dest, List 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                 dest.set(i, src.get(i));
        } else { //一个链表一个线性表也可以用迭代器赋值
            ListIterator di=dest.listIterator();
            ListIterator si=src.listIterator();
            for (int i=0; i                 di.next();
                di.set(si.next());
            }
        }
    }


    /**
     * 
     * 返回集合中的最小元素。前提是其中的元素都是可比的，即实现了Comparable接口
     * 找出一个通用的算法其实不容易，尽管它的思想不难。
     * 反正要依次遍历完所有元素，所以直接用了迭代器
     */
    public static > T min(Collection coll) {
Iterator 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 min(Collection coll, Comparator comp) {
        if (comp==null)
        //返回默认比较器，其实默认比较器什么也不做，只是看集合元素是否实现了Comparable接口，
        //否则抛出ClassCastException
            return (T)min((Collection) (Collection) coll);


Iterator 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 max(Collection coll) {
Iterator 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 max(Collection coll, Comparator comp) {
        if (comp==null)
        return (T)max((Collection) (Collection) coll);


        Iterator 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 void rotate1(List 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 boolean replaceAll(List 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                     if (list.get(i)==null) {
                        list.set(i, newVal);
                        result = true;
                    }
                }
            } else {
                for (int i=0; i                     if (oldVal.equals(list.get(i))) {
                        list.set(i, newVal);
                        result = true;
                    }
                }
            }
        } else {
            ListIterator itr=list.listIterator();
            if (oldVal==null) {
                for (int i=0; i                     if (itr.next()==null) {
                        itr.set(newVal);
                        result = true;
                    }
                }
            } else {
                for (int i=0; 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                     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                     if (!eq(ti.next(), si.next())) {
                        // 回溯指针，然后跳到外部循环继续执行
                        for (int j=0; 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                     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                     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 Collection unmodifiableCollection(Collection c) {
    return new UnmodifiableCollection(c);
    }


    
    static class UnmodifiableCollection implements Collection, Serializable {
// use serialVersionUID from JDK 1.2.2 for interoperability
private static final long serialVersionUID = 1820017752578914078L;

final Collection c;

UnmodifiableCollection(Collection 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[] toArray(T[] a)       {return c.toArray(a);}
   public String toString()            {return c.toString();}

public Iterator iterator() {
   return new Iterator() {
Iterator 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 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 Set unmodifiableSet(Set s) {
    return new UnmodifiableSet(s);
    }


    /**
     * @serial include
     */
    static class UnmodifiableSet extends UnmodifiableCollection
    implements Set, Serializable {
private static final long serialVersionUID = -9215047833775013803L;

UnmodifiableSet(Set s) {super(s);}
public boolean equals(Object o) {return o == this || c.equals(o);}
public int hashCode() {return c.hashCode();}
    }


    /**
     * 返回一个不可修改的Sort Set
     */
    public static SortedSet unmodifiableSortedSet(SortedSet s) {
    return new UnmodifiableSortedSet(s);
    }


    static class UnmodifiableSortedSet
                    extends UnmodifiableSet
                    implements SortedSet, Serializable {
    private static final long serialVersionUID = -4929149591599911165L;
        private final SortedSet ss;


        UnmodifiableSortedSet(SortedSet s) {super(s); ss = s;}


        public Comparator comparator() {return ss.comparator();}


        public SortedSet subSet(E fromElement, E toElement) {
            return new UnmodifiableSortedSet(ss.subSet(fromElement,toElement));
        }
        public SortedSet headSet(E toElement) {
            return new UnmodifiableSortedSet(ss.headSet(toElement));
        }
        public SortedSet tailSet(E fromElement) {
            return new UnmodifiableSortedSet(ss.tailSet(fromElement));
        }


        public E first()           {return ss.first();}
        public E last()             {return ss.last();}
    }


    /**
     * 返回一个 不可修改的List
     * 如果原List实现了RandomAccess接口，返回的List也将实现此接口
     */
    public static List unmodifiableList(List list) {
return (list instanceof RandomAccess ?
               new UnmodifiableRandomAccessList(list) :
               new UnmodifiableList(list));
    }




    static class UnmodifiableList extends UnmodifiableCollection
     implements List {
        static final long serialVersionUID = -283967356065247728L;
final List list;

UnmodifiableList(List 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 c) {
   throw new UnsupportedOperationException();
       }
public ListIterator listIterator() {return listIterator(0);}

public ListIterator listIterator(final int index) {
   return new ListIterator() {
ListIterator 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 subList(int fromIndex, int toIndex) {
           return new UnmodifiableList(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(list)
   : this);
        }
    }


    
    static class UnmodifiableRandomAccessList extends UnmodifiableList
                                              implements RandomAccess{
        UnmodifiableRandomAccessList(List list) {
            super(list);
        }


        public List subList(int fromIndex, int toIndex) {
            return new UnmodifiableRandomAccessList(
                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(list);
        }
    }


    /**
     * 返回一个不可修改的map
     */
    public static Map unmodifiableMap(Map m) {
    return new UnmodifiableMap(m);
    }




    private static class UnmodifiableMap implements Map, Serializable {
// use serialVersionUID from JDK 1.2.2 for interoperability
private static final long serialVersionUID = -1034234728574286014L;

private final Map m;

UnmodifiableMap(Map 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 m) {
   throw new UnsupportedOperationException();
   }
public void clear() {
   throw new UnsupportedOperationException();
   }

private transient Set keySet = null;
private transient Set> entrySet = null;
private transient Collection values = null;

//返回的key集也是不可修改的
public Set keySet() {
   if (keySet==null)
    keySet = unmodifiableSet(m.keySet());
   return keySet;
}

//EntrySet被重新进行包装
public Set> entrySet() {
   if (entrySet==null)
    entrySet = new UnmodifiableEntrySet(m.entrySet());
   return entrySet;
}

public Collection 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 extends UnmodifiableSet> {
        private static final long serialVersionUID = 7854390611657943733L;


            UnmodifiableEntrySet(Set> s) {
                super((Set)s);
            }
            public Iterator> iterator() {
                return new Iterator>() {
                //父类UnmodifiableColletion的c
                Iterator> i = c.iterator();


                    public boolean hasNext() {
                        return i.hasNext();
                    }
                    public Map.Entry next() {
                    return new UnmodifiableEntry(i.next());
                    }
                    public void remove() {
                        throw new UnsupportedOperationException();
                    }
                };
            }


            public Object[] toArray() {
                Object[] a = c.toArray();
                for (int i=0; i                     a[i] = new UnmodifiableEntry((Map.Entry)a[i]);
                return a;
            }


            public T[] toArray(T[] a) {
               
            Object[] arr = c.toArray(a.length==0 ? a : Arrays.copyOf(a, 0));


                for (int i=0; i                     arr[i] = new UnmodifiableEntry((Map.Entry)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((Map.Entry) 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 implements Map.Entry {
                private Map.Entry e;


                UnmodifiableEntry(Map.Entry 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 SortedMap unmodifiableSortedMap(SortedMap m) {
    return new UnmodifiableSortedMap(m);
    }




    static class UnmodifiableSortedMap extends UnmodifiableMap
 implements SortedMap, Serializable {
    private static final long serialVersionUID = -8806743815996713206L;


        private final SortedMap sm;


        UnmodifiableSortedMap(SortedMap m) {super(m); sm = m;}


        public Comparator comparator() {return sm.comparator();}


        public SortedMap subMap(K fromKey, K toKey) {
            return new UnmodifiableSortedMap(sm.subMap(fromKey, toKey));
        }
        public SortedMap headMap(K toKey) {
            return new UnmodifiableSortedMap(sm.headMap(toKey));
        }
        public SortedMap tailMap(K fromKey) {
            return new UnmodifiableSortedMap(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 Collection synchronizedCollection(Collection c) {
    return new SynchronizedCollection(c);
    }


    static Collection synchronizedCollection(Collection c, Object mutex) {
    return new SynchronizedCollection(c, mutex);
    }


    /**
     * @serial include
     */
    static class SynchronizedCollection implements Collection, Serializable {
// use serialVersionUID from JDK 1.2.2 for interoperability
private static final long serialVersionUID = 3053995032091335093L;

final Collection c;  // 返回的集合
final Object mutex;     // 需要同步的对象

SynchronizedCollection(Collection c) {
       if (c==null)
            throw new NullPointerException();
   this.c = c;
       mutex = this;
   }
SynchronizedCollection(Collection 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[] toArray(T[] a) {
   synchronized(mutex) {return c.toArray(a);}
        }


public Iterator 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 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 Set synchronizedSet(Set s) {
    return new SynchronizedSet(s);
    }


    static Set synchronizedSet(Set s, Object mutex) {
    return new SynchronizedSet(s, mutex);
    }


    /**
     * @serial include
     */
    static class SynchronizedSet extends SynchronizedCollection implements Set {
    private static final long serialVersionUID = 487447009682186044L;


SynchronizedSet(Set s) {
           super(s);
   }
SynchronizedSet(Set 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 SortedSet synchronizedSortedSet(SortedSet s) {
    return new SynchronizedSortedSet(s);
    }


    /**
     * @serial include
     */
    static class SynchronizedSortedSet extends SynchronizedSetimplements SortedSet{
    private static final long serialVersionUID = 8695801310862127406L;


        final private SortedSet ss;


        SynchronizedSortedSet(SortedSet s) {
            super(s);
            ss = s;
        }
        SynchronizedSortedSet(SortedSet s, Object mutex) {
            super(s, mutex);
            ss = s;
        }


        public Comparator comparator() {
        synchronized(mutex) {return ss.comparator();}
        }


        public SortedSet subSet(E fromElement, E toElement) {
   synchronized(mutex) {
                return new SynchronizedSortedSet(
                    ss.subSet(fromElement, toElement), mutex);
            }
        }
        public SortedSet headSet(E toElement) {
        synchronized(mutex) {
                return new SynchronizedSortedSet(ss.headSet(toElement), mutex);
            }
        }
        public SortedSet tailSet(E fromElement) {
        synchronized(mutex) {
               return new SynchronizedSortedSet(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 List synchronizedList(List list) {
    return (list instanceof RandomAccess ?
                new SynchronizedRandomAccessList(list) :
                new SynchronizedList(list));
    }


    static List synchronizedList(List list, Object mutex) {
    return (list instanceof RandomAccess ?
                new SynchronizedRandomAccessList(list, mutex) :
                new SynchronizedList(list, mutex));
    }


    /**
     * @serial include
     */
    static class SynchronizedListextends SynchronizedCollection implements List {
        static final long serialVersionUID = -7754090372962971524L;


        final List list;


        SynchronizedList(List list) {
        super(list);
        this.list = list;
        }
        SynchronizedList(List 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 c) {
        synchronized(mutex) {return list.addAll(index, c);}
        }


        public ListIterator listIterator() {
        return list.listIterator(); // Must be manually synched by user
        }


        public ListIterator listIterator(int index) {
        return list.listIterator(index); // Must be manually synched by user
        }


        public List subList(int fromIndex, int toIndex) {
        synchronized(mutex) {
                return new SynchronizedList(list.subList(fromIndex, toIndex),
                                            mutex);
            }
        }




        private Object readResolve() {
            return (list instanceof RandomAccess
   ? new SynchronizedRandomAccessList(list)
   : this);
        }
    }


    /**
     * @serial include
     */
    static class SynchronizedRandomAccessListextends SynchronizedList
implements RandomAccess {


        SynchronizedRandomAccessList(List list) {
            super(list);
        }


        SynchronizedRandomAccessList(List list, Object mutex) {
            super(list, mutex);
        }


        public List subList(int fromIndex, int toIndex) {
        synchronized(mutex) {
                return new SynchronizedRandomAccessList(
                    list.subList(fromIndex, toIndex), mutex);
            }
        }


        static final long serialVersionUID = 1530674583602358482L;


        private Object writeReplace() {
            return new SynchronizedList(list);
        }
    }


    /**
     * 返回一个线程安全的map
     */
    public static Map synchronizedMap(Map m) {
return new SynchronizedMap(m);
    }


    /**
     * @serial include
     */
    private static class SynchronizedMap
implements Map, Serializable {
// use serialVersionUID from JDK 1.2.2 for interoperability
private static final long serialVersionUID = 1978198479659022715L;


private final Map m;     // Backing Map
        final Object      mutex; // Object on which to synchronize


SynchronizedMap(Map m) {
            if (m==null)
                throw new NullPointerException();
            this.m = m;
            mutex = this;
        }


SynchronizedMap(Map 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 map) {
   synchronized(mutex) {m.putAll(map);}
        }
public void clear() {
   synchronized(mutex) {m.clear();}
}


private transient Set keySet = null;
private transient Set> entrySet = null;
private transient Collection values = null;


public Set keySet() {
            synchronized(mutex) {
                if (keySet==null)
                    keySet = new SynchronizedSet(m.keySet(), mutex);
                return keySet;
            }
}


public Set> entrySet() {
            synchronized(mutex) {
                if (entrySet==null)
                    entrySet = new SynchronizedSet>(m.entrySet(), mutex);
                return entrySet;
            }
}


public Collection values() {
            synchronized(mutex) {
                if (values==null)
                    values = new SynchronizedCollection(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 SortedMap synchronizedSortedMap(SortedMap m) {
return new SynchronizedSortedMap(m);
    }




    /**
     * @serial include
     */
    static class SynchronizedSortedMap
extends SynchronizedMap
implements SortedMap
    {
private static final long serialVersionUID = -8798146769416483793L;


        private final SortedMap sm;


SynchronizedSortedMap(SortedMap m) {
            super(m);
            sm = m;
        }
SynchronizedSortedMap(SortedMap m, Object mutex) {
            super(m, mutex);
            sm = m;
        }


public Comparator comparator() {
   synchronized(mutex) {return sm.comparator();}
        }


        public SortedMap subMap(K fromKey, K toKey) {
   synchronized(mutex) {
                return new SynchronizedSortedMap(
                    sm.subMap(fromKey, toKey), mutex);
            }
        }
        public SortedMap headMap(K toKey) {
   synchronized(mutex) {
                return new SynchronizedSortedMap(sm.headMap(toKey), mutex);
            }
        }
        public SortedMap tailMap(K fromKey) {
   synchronized(mutex) {
               return new SynchronizedSortedMap(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 strings = new ArrayList();
     * ArrayList rawList = strings;
     * rawList.add(new Date());
     * add方法并不进行类型检查，所以存入了非String的对象。只有在重新获取该对象
     * 转化为String类型的时候才抛出异常。
     * 而动态类型安全的集合能在add时就会抛出ClassCastException。
     * 这种方法的优点是错误可以在正确的位置被报告
     * 
     *
     */
    public static Collection checkedCollection(Collection c,Class type) {
        return new CheckedCollection(c, type);
    }


    /**
     * @serial include
     */
    static class CheckedCollection implements Collection, Serializable {
        private static final long serialVersionUID = 1578914078182001775L;


        final Collection c;
        final Class 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 c, Class 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[] 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 iterator() {
   return new Iterator() {
private final Iterator 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 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 Set checkedSet(Set s, Class type) {
        return new CheckedSet(s, type);
    }


    /**
     * @serial include
     */
    static class CheckedSet extends CheckedCollection
                                 implements Set, Serializable{
        private static final long serialVersionUID = 4694047833775013803L;


        CheckedSet(Set s, Class elementType) { super(s, elementType); }


        public boolean equals(Object o) { return o == this || c.equals(o); }
        public int hashCode()           { return c.hashCode(); }
    }


    /**
     * 返回一个类型安全的集合SortedSet
     */
    public static SortedSet checkedSortedSet(SortedSet s,Class type) {
        return new CheckedSortedSet(s, type);
    }


    /**
     * @serial include
     */
    static class CheckedSortedSet extends CheckedSet
        implements SortedSet, Serializable{
        private static final long serialVersionUID = 1599911165492914959L;
        private final SortedSet ss;


        CheckedSortedSet(SortedSet s, Class type) {
            super(s, type);
            ss = s;
        }


        public Comparator comparator() { return ss.comparator(); }
        public E first()                   { return ss.first(); }
        public E last()                    { return ss.last(); }


        public SortedSet subSet(E fromElement, E toElement) {
            return new CheckedSortedSet(ss.subSet(fromElement,toElement),
                                           type);
        }
        public SortedSet headSet(E toElement) {
            return new CheckedSortedSet(ss.headSet(toElement), type);
        }
        public SortedSet tailSet(E fromElement) {
            return new CheckedSortedSet(ss.tailSet(fromElement), type);
        }
    }


    /**
     * 返回一个类型安全的集合List
     */
    public static List checkedList(List list, Class type) {
        return (list instanceof RandomAccess ?
                new CheckedRandomAccessList(list, type) :
                new CheckedList(list, type));
    }


    /**
     * @serial include
     */
    static class CheckedList extends CheckedCollection
                                implements List
    {
        static final long serialVersionUID = 65247728283967356L;
        final List list;


        CheckedList(List list, Class 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 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 listIterator()   { return listIterator(0); }


        public ListIterator listIterator(final int index) {
            return new ListIterator() {
                ListIterator 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 subList(int fromIndex, int toIndex) {
            return new CheckedList(list.subList(fromIndex, toIndex), type);
        }
    }


    /**
     * @serial include
     */
    static class CheckedRandomAccessList extends CheckedList
                                            implements RandomAccess
    {
        private static final long serialVersionUID = 1638200125423088369L;


        CheckedRandomAccessList(List list, Class type) {
            super(list, type);
        }


        public List subList(int fromIndex, int toIndex) {
            return new CheckedRandomAccessList(
                list.subList(fromIndex, toIndex), type);
        }
    }


    /**
     * 返回一个类型安全的集合Map
     */
    public static Map checkedMap(Map m, Class keyType,
                                              Class valueType) {
        return new CheckedMap(m, keyType, valueType);
    }




    /**
     * @serial include
     */
    private static class CheckedMap implements Map,
                                                         Serializable
    {
        private static final long serialVersionUID = 5742860141034234728L;


        private final Map m;
        final Class keyType;
        final Class 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 m, Class keyType, Class 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 keySet()                 { return m.keySet(); }
        public Collection 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 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> entrySet = null;


        public Set> entrySet() {
            if (entrySet==null)
                entrySet = new CheckedEntrySet(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 implements Set> {
            Set> s;
            Class valueType;


            CheckedEntrySet(Set> s, Class 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 e){
                throw new UnsupportedOperationException();
            }
            public boolean addAll(Collection> coll) {
                throw new UnsupportedOperationException();
            }




            public Iterator> iterator() {
                return new Iterator>() {
                    Iterator> i = s.iterator();


                    public boolean hasNext() { return i.hasNext(); }
                    public void remove()     { i.remove(); }


                    public Map.Entry next() {
                        return new CheckedEntry(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((Map.Entry)source[i],
                                                    valueType);
                return dest;
            }


            public 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[i] = new CheckedEntry((Map.Entry)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((Map.Entry) 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 implements Map.Entry {
                private Map.Entry e;
                private Class valueType;


                CheckedEntry(Map.Entry e, Class 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 SortedMap checkedSortedMap(SortedMap m,
                                                        Class keyType,
                                                        Class valueType) {
        return new CheckedSortedMap(m, keyType, valueType);
    }


    /**
     * @serial include
     */
    static class CheckedSortedMap extends CheckedMap
        implements SortedMap, Serializable
    {
        private static final long serialVersionUID = 1599671320688067438L;


        private final SortedMap sm;


        CheckedSortedMap(SortedMap m,
                         Class keyType, Class valueType) {
            super(m, keyType, valueType);
            sm = m;
        }


        public Comparator comparator() { return sm.comparator(); }
        public K firstKey()                       { return sm.firstKey(); }
        public K lastKey()                        { return sm.lastKey(); }


        public SortedMap subMap(K fromKey, K toKey) {
            return new CheckedSortedMap(sm.subMap(fromKey, toKey),
                                             keyType, valueType);
        }


        public SortedMap headMap(K toKey) {
            return new CheckedSortedMap(sm.headMap(toKey),
                                             keyType, valueType);
        }


        public SortedMap tailMap(K fromKey) {
            return new CheckedSortedMap(sm.tailMap(fromKey),
                                             keyType, valueType);
        }
    }


    // 其他


    /**
     * 不可变的空集
     */
    public static final Set EMPTY_SET = new EmptySet();


    /**
     *
     * 返回一个不可变的空集
     * size始终为0
     */
    public static final Set emptySet() {
return (Set) EMPTY_SET;
    }


    /**
     * @serial include
     */
    private static class EmptySet extends AbstractSet implements Serializable {
// use serialVersionUID from JDK 1.2.2 for interoperability
private static final long serialVersionUID = 1582296315990362920L;


        public Iterator iterator() {
            return new Iterator() {
                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 List emptyList() {
return (List) EMPTY_LIST;
    }


    /**
     * @serial include
     */
    private static class EmptyList extends AbstractList
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 Map emptyMap() {
return (Map) EMPTY_MAP;
    }


    private static class EmptyMap
extends AbstractMap
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 keySet()                {return Collections.emptySet();}


        public Collection values()         {return Collections.emptySet();}


        public Set> 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 Set singleton(T o) {
return new SingletonSet(o);
    }


    /**
     * @serial include
     */
    private static class SingletonSet extends AbstractSet
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 iterator() {
            return new Iterator() {
                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 List singletonList(T o) {
return new SingletonList(o);
    }


    private static class SingletonList
extends AbstractList
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 Map singletonMap(K key, V value) {
    return new SingletonMap(key, value);
    }


    private static class SingletonMap extends AbstractMap
 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 keySet = null;
        private transient Set> entrySet = null;
        private transient Collection values = null;


        public Set keySet() {
        if (keySet==null)
        keySet = singleton(k);
        return keySet;
        }


        public Set> entrySet() {
        if (entrySet==null)
        entrySet = Collections.>singleton(
        new SimpleImmutableEntry(k, v));
        return entrySet;
        }


public Collection values() {
   if (values==null)
values = singleton(v);
   return values;
}


    }


    /**
     * 
     * 返回一个包含N个o元素的比可变的集合
     * @param  n 添加的指定元素的个数
     * @param  o 被重复添加的元素
     */
    public static List nCopies(int n, T o) {
if (n < 0)
   throw new IllegalArgumentException("List length = " + n);
        return new CopiesList(n, o);
    }


    /**
     * @serial include
     */
    private static class CopiesListextends AbstractList
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[] 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 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 Comparator reverseOrder() {
        return (Comparator) REVERSE_ORDER;
    }


    private static final Comparator REVERSE_ORDER = new ReverseComparator();


    /**
     * @serial include
     */
    private static class ReverseComparator
implements Comparator>, Serializable {


// use serialVersionUID from JDK 1.2.2 for interoperability
private static final long serialVersionUID = 7207038068494060240L;


        public int compare(Comparable c1, Comparable c2) {
            return c2.compareTo(c1);
        }


        private Object readResolve() { return reverseOrder(); }
    }


    /**
     * 根据指定比较器的相反顺序排列集合
     */
    public static Comparator reverseOrder(Comparator cmp) {
        if (cmp == null)
        return reverseOrder();
        return new ReverseComparator2(cmp);
    }


    /**
     * @serial include
     */
    private static class ReverseComparator2 implements Comparator,
        Serializable{
        private static final long serialVersionUID = 4374092139857L;


 
        private Comparator cmp;


        ReverseComparator2(Comparator cmp) {
            assert cmp != null;
            this.cmp = cmp;
        }


        public int compare(T t1, T t2) {
            return cmp.compare(t2, t1);
        }
    }


    /**
     * 基于c之上返回一个枚举集
     */
    public static Enumeration enumeration(final Collection c) {
return new Enumeration() {
   Iterator i = c.iterator();

   public boolean hasMoreElements() {
    return i.hasNext();
   }

   public T nextElement() {
    return i.next();
   }
    };
    }


    /**
     * 根据枚举集中的元素返回一个ArrayList
     */
    public static ArrayList list(Enumeration e) {
        ArrayList l = new ArrayList();
        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 boolean addAll(Collection c, T... elements) {
        boolean result = false;
        for (T element : elements)
            result |= c.add(element);
        return result;
    }


    /**
     * 根据指定的map返回一个set
     * set存储的是map的键值
     */
    public static Set newSetFromMap(Map map) {
        return new SetFromMap(map);
    }


    private static class SetFromMap extends AbstractSet
        implements Set, Serializable
    {
        private final Map m;  // The backing map
        private transient Set s;       // Its keySet


        SetFromMap(Map 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 iterator()     { return s.iterator(); }
        public Object[] toArray()         { return s.toArray(); }
        public 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 Queue asLifoQueue(Deque deque) {
        return new AsLIFOQueue(deque);
    }


    static class AsLIFOQueue extends AbstractQueue
        implements Queue, Serializable {
private static final long serialVersionUID = 1802017725587941708L;
        private final Deque q;
        AsLIFOQueue(Deque 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 iterator()     { return q.iterator(); }
        public Object[] toArray()         { return q.toArray(); }
        public 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
    }
}

你可能感兴趣的:(菜鸟自学Java系列,collections,框架,object,list,distance,null)

  • android系统selinux中添加新属性property 辉色投像
    1.定位/android/system/sepolicy/private/property_contexts声明属性开头：persist.charge声明属性类型：u:object_r:system_prop:s0图12.定位到android/system/sepolicy/public/domain.te删除neverallow{domain-init}default_prop:property
  • Linux下QT开发的动态库界面弹出操作（SDL2） 13jjyao QT类qt开发语言sdl2linux
    需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
  • ArcGIS栅格计算器常见公式（赋值、0和空值的转换、补充栅格空值） 研学随笔 arcgis经验分享
    我们在使用ArcGIS时通常经常用到栅格计算器，今天主要给大家介绍我日常中经常用到的几个公式，供大家参考学习。将特定值（-9999）赋值为0，例如-9999.Con("raster"==-9999,0,"raster")2.给空值赋予特定的值（如0）Con(IsNull("raster"),0,"raster")3.将特定的栅格值(如1)赋值为空值，其他保留原值SetNull("raster"==
  • WPF中的ComboBox控件几种数据绑定的方式 互联网打工人no1 wpfc#
    一、用字典给ItemsSource赋值（此绑定用的地方很多，建议熟练掌握）在XMAL中：在CS文件中privatevoidBindData(){DictionarydicItem=newDictionary();dicItem.add(1,"北京");dicItem.add(2,"上海");dicItem.add(3,"广州");cmb_list.ItemsSource=dicItem;cmb_l
  • 利用LangChain的StackExchange组件实现智能问答系统 nseejrukjhad langchainmicrosoft数据库python
    利用LangChain的StackExchange组件实现智能问答系统引言在当今的软件开发世界中，StackOverflow已经成为程序员解决问题的首选平台之一。而LangChain作为一个强大的AI应用开发框架，提供了StackExchange组件，使我们能够轻松地将StackOverflow的海量知识库集成到我们的应用中。本文将详细介绍如何使用LangChain的StackExchange组件
  • node.js学习 小猿L node.jsnode.js学习vim
    node.js学习实操及笔记温故node.js，node.js学习实操过程及笔记~node.js学习视频node.js官网node.js中文网实操笔记githubcsdn笔记为什么学node.js可以让别人访问我们编写的网页为后续的框架学习打下基础，三大框架vuereactangular离不开node.jsnode.js是什么官网：node.js是一个开源的、跨平台的运行JavaScript的运行
  • 自我意识 徐立华
    ----读帕克.帕尔默《教学勇气》（P18----19）5.铸造我们的学科帕克.帕尔默说学科知识对我们的自身认同和外部世界有启发意义。学科会铸造我们。“在我们与学科的命题概念和学科的生活框架相遇之前，自我意识知识处于潜伏状态，通过回想学科是怎样唤醒自我意识，我们就可以找回教学心灵。”《教学勇气》（P18）我们的自我意识像冰山表面下无限延伸的冰层，常常处于潜伏状态。但是在我们对所教授的学科进行深入思
  • Redis系列：Geo 类型赋能亿级地图位置计算 Ly768768 redisbootstrap数据库
    1前言我们在篇深刻理解高性能Redis的本质的时候就介绍过Redis的几种基本数据结构，它是基于不同业务场景而设计的：动态字符串(REDIS_STRING)：整数(REDIS_ENCODING_INT)、字符串(REDIS_ENCODING_RAW)双端列表(REDIS_ENCODING_LINKEDLIST)压缩列表(REDIS_ENCODING_ZIPLIST)跳跃表(REDIS_ENCODI
  • 基于CODESYS的多轴运动控制程序框架：逻辑与运动控制分离，快速开发灵活操作 GPJnCrbBdl python开发语言
    基于codesys开发的多轴运动控制程序框架，将逻辑与运动控制分离，将单轴控制封装成功能块，对该功能块的操作包含了所有的单轴控制（归零、点动、相对定位、绝对定位、设置当前位置、伺服模式切换等等）。程序框架由主程序按照状态调用分归零模式、手动模式、自动模式、故障模式，程序状态的跳转都已完成，只需要根据不同的工艺要求完成所需的动作即可。变量的声明、地址的规划都严格按照C++的标准定义，能帮助开发者快速
  • C++菜鸟教程 - 从入门到精通 第二节 DreamByte c++
    一.上节课的补充(数据类型)1.前言继上节课,我们主要讲解了输入,输出和运算符,我们现在来补充一下数据类型的知识上节课遗漏了这个知识点,非常的抱歉顺便说一下,博主要上高中了,更新会慢,2-4周更新一次对了,正好赶上中秋节,小编跟大家说一句:中秋节快乐!2.int类型上节课,我们其实只用了int类型int类型,是整数类型,它们存贮的是整数,不能存小数(浮点数)定义变量的方式很简单inta;//定义一
  • SpringBlade dict-biz/list 接口 SQL 注入漏洞 文章永久免费只为良心 oracle数据库
    SpringBladedict-biz/list接口SQL注入漏洞POC:构造请求包查看返回包你的网址/api/blade-system/dict-biz/list?updatexml(1,concat(0x7e,md5(1),0x7e),1)=1漏洞概述在SpringBlade框架中，如果dict-biz/list接口的后台处理逻辑没有正确地对用户输入进行过滤或参数化查询（PreparedSta
  • insert into select 主键自增_mybatis拦截器实现主键自动生成 weixin_39521651 insertintoselect主键自增mybatisdelete返回值mybatisinsert返回主键mybatisinsert返回对象mybatisplusinsert返回主键mybatisplus插入生成id
    前言前阵子和朋友聊天，他说他们项目有个需求，要实现主键自动生成，不想每次新增的时候，都手动设置主键。于是我就问他，那你们数据库表设置主键自动递增不就得了。他的回答是他们项目目前的id都是采用雪花算法来生成，因此为了项目稳定性，不会切换id的生成方式。朋友问我有没有什么实现思路，他们公司的orm框架是mybatis，我就建议他说，不然让你老大把mybatis切换成mybatis-plus。mybat
  • 一文掌握python常用的list（列表）操作 程序员neil pythonpython开发语言
    目录一、创建列表1.直接创建列表：2.使用list()构造器3.使用列表推导式4.创建空列表二、访问列表元素1.列表支持通过索引访问元素，索引从0开始：2.还可以使用切片操作访问列表的一部分：三、修改列表元素四、添加元素1.append()：在末尾添加元素2.insert()：在指定位置插入元素五、删除元素1.del：删除指定位置的元素2.remove()：删除指定值的第一个匹配项3.pop()：
  • python中的深拷贝与浅拷贝 anshejd70787 python
    深拷贝和浅拷贝浅拷贝的时候，修改原来的对象，浅拷贝的对象不会发生改变。1、对象的赋值对象的赋值实际上是对象之间的引用：当创建一个对象，然后将这个对象赋值给另外一个变量的时候，python并没有拷贝这个对象，而只是拷贝了这个对象的引用。当对对象做赋值或者是参数传递或者作为返回值的时候，总是传递原始对象的引用，而不是一个副本。如下所示：>>>aList=["kel","abc",123]>>>bLis
  • 用Python实现读取统计单词个数 程序媛了了 python游戏java
    完整实例代码：fromcollectionsimportCounterdefpythonit():danci={}withopen("pythonit.txt","r",encoding="utf-8")asf:foriinf:words=i.strip().split()forwordinwords:ifwordnotindanci:danci[word]=1else:danci[word]+=
  • 2024.8.22 Python，链表两数之和，链表快速反转，二叉树的深度，二叉树前中后序遍历，N叉树递归遍历，翻转二叉树 RaidenQ python链表开发语言
    1.链表两数之和输入：l1=[2,4,3],l2=[5,6,4]输出：[7,0,8]解释：342+465=807.示例2：输入：l1=[0],l2=[0]输出：[0]示例3：输入：l1=[9,9,9,9,9,9,9],l2=[9,9,9,9]输出：[8,9,9,9,0,0,0,1]昨天的这个题，用自己的办法写的麻烦的要死，然后刚才一看chat归类的办法，感觉自己像个智障。classListNode
  • ArrayList 源码解析 程序猿进阶 Java基础ArrayListListjava面试性能优化架构设计idea
    ArrayList是Java集合框架中的一个动态数组实现，提供了可变大小的数组功能。它继承自AbstractList并实现了List接口，是顺序容器，即元素存放的数据与放进去的顺序相同，允许放入null元素，底层通过数组实现。除该类未实现同步外，其余跟Vector大致相同。每个ArrayList都有一个容量capacity，表示底层数组的实际大小，容器内存储元素的个数不能多于当前容量。当向容器中添
  • Java爬虫框架（一）--架构设计 狼图腾-狼之传说 java框架java任务html解析器存储电子商务
    一、架构图那里搜网络爬虫框架主要针对电子商务网站进行数据爬取，分析，存储，索引。爬虫：爬虫负责爬取，解析，处理电子商务网站的网页的内容数据库：存储商品信息索引：商品的全文搜索索引Task队列：需要爬取的网页列表Visited表：已经爬取过的网页列表爬虫监控平台：web平台可以启动，停止爬虫，管理爬虫，task队列，visited表。二、爬虫1.流程1)Scheduler启动爬虫器，TaskMast
  • Java：爬虫框架 dingcho Javajava爬虫
    一、ApacheNutch2【参考地址】Nutch是一个开源Java实现的搜索引擎。它提供了我们运行自己的搜索引擎所需的全部工具。包括全文搜索和Web爬虫。Nutch致力于让每个人能很容易,同时花费很少就可以配置世界一流的Web搜索引擎.为了完成这一宏伟的目标,Nutch必须能够做到:每个月取几十亿网页为这些网页维护一个索引对索引文件进行每秒上千次的搜索提供高质量的搜索结果简单来说Nutch支持分
  • Vue中table合并单元格用法 weixin_30613343 javascriptViewUI
    地名结果人名性别{{item.name}}已完成未完成{{item.groups[0].name}}{{item.groups[0].sex}}{{item.groups[son].name}}{{item.groups[son].sex}}exportdefault{data(){return{list:[{name:'地名1',result:'1',groups:[{name:'张三',sex
  • Android应用性能优化 轻口味 Android
    Android手机由于其本身的后台机制和硬件特点，性能上一直被诟病，所以软件开发者对软件本身的性能优化就显得尤为重要；本文将对Android开发过程中性能优化的各个方面做一个回顾与总结。Cache优化ListView缓存：ListView中有一个回收器，Item滑出界面的时候View会回收到这里，需要显示新的Item的时候，就尽量重用回收器里面的View；每次在getView函数中inflate新
  • tiff批量转png 诺有缸的高飞鸟 opencv图像处理pythonopencv图像处理
    目录写在前面代码完写在前面1、本文内容tiff批量转png2、平台/环境opencv,python3、转载请注明出处：https://blog.csdn.net/qq_41102371/article/details/132975023代码importnumpyasnpimportcv2importosdeffindAllFile(base):file_list=[]forroot,ds,fsin
  • Spring MVC 全面指南：从入门到精通的详细解析 一杯梅子酱 技术栈学习springmvcjava
    引言：SpringMVC，作为Spring框架的一个重要模块，为构建Web应用提供了强大的功能和灵活性。无论是初学者还是有一定经验的开发者，掌握SpringMVC都将显著提升你的Web开发技能。本文旨在为初学者提供一个全面且易于理解的学习路径，通过详细的知识点分析和实际案例，帮助你快速上手SpringMVC，让学习过程既深刻又高效。一、SpringMVC简介1.1什么是SpringMVC？Spri
  • [Unity]在场景中随机生成不同位置且不重叠的物体 Bartender_Jill Graphics图形学笔记unity游戏引擎动画
    1.前言最近任务需要用到Unity在场景中随机生成物体，且这些物体不能重叠，简单记录一下。参考资料:Howtoensurethatspawnedtargetsdonotoverlap?2.结果与代码结果如下所示：代码如下所示：usingSystem.Collections.Generic;usingUnityEngine;namespaceAssets.Scripts{publicclassNew
  • WebMagic：强大的Java爬虫框架解析与实战 Aaron_945 Javajava爬虫开发语言
    文章目录引言官网链接WebMagic原理概述基础使用1.添加依赖2.编写PageProcessor高级使用1.自定义Pipeline2.分布式抓取优点结论引言在大数据时代，网络爬虫作为数据收集的重要工具，扮演着不可或缺的角色。Java作为一门广泛使用的编程语言，在爬虫开发领域也有其独特的优势。WebMagic是一个开源的Java爬虫框架，它提供了简单灵活的API，支持多线程、分布式抓取，以及丰富的
  • 博客网站制作教程 2401_85194651 javamaven
    首先就是技术框架：后端：Java+SpringBoot数据库：MySQL前端：Vue.js数据库连接：JPA(JavaPersistenceAPI)1.项目结构blog-app/├──backend/│├──src/main/java/com/example/blogapp/││├──BlogApplication.java││├──config/│││└──DatabaseConfig.java
  • 00. 这里整理了最全的爬虫框架（Java + Python） 有一只柴犬 爬虫系列爬虫javapython
    目录1、前言2、什么是网络爬虫3、常见的爬虫框架3.1、java框架3.1.1、WebMagic3.1.2、Jsoup3.1.3、HttpClient3.1.4、Crawler4j3.1.5、HtmlUnit3.1.6、Selenium3.2、Python框架3.2.1、Scrapy3.2.2、BeautifulSoup+Requests3.2.3、Selenium3.2.4、PyQuery3.2
  • iOS内存管理简单理解 烧烤有点辣
    什么是引用计数引用计数（ReferenceCount）是一个简单而有效的管理对象生命周期的方式。当我们创建一个新对象的时候，它的引用计数为1，当有一个新的指针指向这个对象时，我们将其引用计数加1，当某个指针不再指向这个对象是，我们将其引用计数减1，当对象的引用计数变为0时，说明这个对象不再被任何指针指向了，这个时候我们就可以将对象销毁，回收内存。由于引用计数简单有效，除了Objective-C和S
  • 今天是总结 薛帅
    今天来个最后一天的总结。为什么要学习写作技巧呢？就如同建房子，如果想要住的安全、舒服，我们要先打地基，建房子的框架，这样才能随意的装修。那么我们要怎么建好才能建好写作的地基呢？1走直路，少弯路01利他：能够给别人带来价值。02吸引：吸住读者的眼球。03打动：打动人心，引起共鸣。04说服：用数据说话。05刻意：通过有意识的训练。06修改：好的文章至上修改10遍。07模仿：10万+的文章必有成功的道理
  • Python 课程10-单元测试 可愛小吉 Python教學python单元测试开发语言TDDunittest
    前言在现代软件开发中，单元测试已成为一种必不可少的实践。通过测试，我们可以确保每个功能模块在开发和修改过程中按预期工作，从而减少软件缺陷，提高代码质量。而测试驱动开发（TDD）则进一步将测试作为开发的核心部分，先编写测试，再编写代码，以测试为指导开发出更稳定、更可靠的代码。Python提供了强大的unittest模块，它是Python标准库的一部分，专门用于编写和执行单元测试。与其他测试框架相比，
  • 怎么样才能成为专业的程序员？ cocos2d-x小菜 编程PHP
      如何要想成为一名专业的程序员？仅仅会写代码是不够的。从团队合作去解决问题到版本控制，你还得具备其他关键技能的工具包。当我们询问相关的专业开发人员，那些必备的关键技能都是什么的时候，下面是我们了解到的情况。   关于如何学习代码，各种声音很多，然后很多人就被误导为成为专业开发人员懂得一门编程语言就够了？！呵呵，就像其他工作一样，光会一个技能那是远远不够的。如果你想要成为
  • java web开发 高并发处理 BreakingBad javaWeb并发开发处理高
    java处理高并发高负载类网站中数据库的设计方法（java教程,java处理大量数据，java高负载数据） 一：高并发高负载类网站关注点之数据库 没错,首先是数据库,这是大多数应用所面临的首个SPOF。尤其是Web2.0的应用，数据库的响应是首先要解决的。 一般来说MySQL是最常用的，可能最初是一个mysql主机，当数据增加到100万以上，那么，MySQL的效能急剧下降。常用的优化措施是M-S（
  • mysql批量更新 ekian mysql
    mysql更新优化： 一版的更新的话都是采用update set的方式，但是如果需要批量更新的话，只能for循环的执行更新。或者采用executeBatch的方式，执行更新。无论哪种方式，性能都不见得多好。 三千多条的更新，需要3分多钟。 查询了批量更新的优化，有说replace into的方式，即： replace into tableName(id,status) values
  • 微软BI（3） 18289753290 微软BI SSIS
    1) Q：该列违反了完整性约束错误；已获得 OLE DB 记录。源:“Microsoft SQL Server Native Client 11.0” Hresult: 0x80004005 说明:“不能将值 NULL 插入列 'FZCHID'，表 'JRB_EnterpriseCredit.dbo.QYFZCH'；列不允许有 Null 值。INSERT 失败。”。 A：一般这类问题的存在是
  • Java中的List g21121 java
            List是一个有序的 collection（也称为序列）。此接口的用户可以对列表中每个元素的插入位置进行精确地控制。用户可以根据元素的整数索引（在列表中的位置）访问元素，并搜索列表中的元素。         与 set 不同，列表通常允许重复
  • 读书笔记 永夜-极光 读书笔记
       1.  K是一家加工厂,需要采购原材料,有A,B,C,D 4家供应商,其中A给出的价格最低,性价比最高,那么假如你是这家企业的采购经理,你会如何决策?          传统决策: A:100%订单  B,C,D:0%     &nbs
  • centos 安装 Codeblocks 随便小屋 codeblocks
    1.安装gcc,需要c和c++两部分,默认安装下,CentOS不安装编译器的,在终端输入以下命令即可yum install gccyum install gcc-c++   2.安装gtk2-devel,因为默认已经安装了正式产品需要的支持库,但是没有安装开发所需要的文档.yum install gtk2* 3. 安装wxGTK    yum search w
  • 23种设计模式的形象比喻 aijuans 设计模式
    1、ABSTRACT FACTORY—追MM少不了请吃饭了，麦当劳的鸡翅和肯德基的鸡翅都是MM爱吃的东西，虽然口味有所不同，但不管你带MM去麦当劳或肯德基，只管向服务员说“来四个鸡翅”就行了。麦当劳和肯德基就是生产鸡翅的Factory 　　工厂模式：客户类和工厂类分开。消费者任何时候需要某种产品，只需向工厂请求即可。消费者无须修改就可以接纳新产品。缺点是当产品修改时，工厂类也要做相应的修改。如：
  • 开发管理 CheckLists aoyouzi 开发管理 CheckLists
    开发管理 CheckLists(23) -使项目组度过完整的生命周期 开发管理 CheckLists(22) -组织项目资源 开发管理 CheckLists(21) -控制项目的范围开发管理 CheckLists(20) -项目利益相关者责任开发管理 CheckLists(19) -选择合适的团队成员开发管理 CheckLists(18) -敏捷开发 Scrum Master 工作开发管理 C
  • js实现切换 百合不是茶 JavaScript栏目切换
    js主要功能之一就是实现页面的特效,窗体的切换可以减少页面的大小,被门户网站大量应用思路: 1,先将要显示的设置为display:bisible 否则设为none 2,设置栏目的id ,js获取栏目的id,如果id为Null就设置为显示 3,判断js获取的id名字;再设置是否显示   代码实现:   html代码: <di
  • 周鸿祎在360新员工入职培训上的讲话 bijian1013 感悟项目管理人生职场
            这篇文章也是最近偶尔看到的，考虑到原博客发布者可能将其删除等原因，也更方便个人查找，特将原文拷贝再发布的。“学东西是为自己的，不要整天以混的姿态来跟公司博弈，就算是混，我觉得你要是能在混的时间里，收获一些别的有利于人生发展的东西，也是不错的，看你怎么把握了”，看了之后，对这句话记忆犹新。  &
  • 前端Web开发的页面效果 Bill_chen htmlWebMicrosoft
    1.IE6下png图片的透明显示： <img src="图片地址" border="0" style="Filter.Alpha(Opacity)=数值(100),style=数值(3)"/> 或在<head></head>间加一段JS代码让透明png图片正常显示。 2.<li>标
  • 【JVM五】老年代垃圾回收：并发标记清理GC(CMS GC) bit1129 垃圾回收
      CMS概述 并发标记清理垃圾回收(Concurrent Mark and Sweep GC）算法的主要目标是在GC过程中，减少暂停用户线程的次数以及在不得不暂停用户线程的请夸功能，尽可能短的暂停用户线程的时间。这对于交互式应用，比如web应用来说，是非常重要的。   CMS垃圾回收针对新生代和老年代采用不同的策略。相比同吞吐量垃圾回收，它要复杂的多。吞吐量垃圾回收在执
  • Struts2技术总结 白糖_ struts2
      必备jar文件 早在struts2.0.*的时候，struts2的必备jar包需要如下几个： commons-logging-*.jar   Apache旗下commons项目的log日志包 freemarker-*.jar          
  • Jquery easyui layout应用注意事项 bozch jquery浏览器easyuilayout
    在jquery easyui中提供了easyui-layout布局，他的布局比较局限，类似java中GUI的border布局。下面对其使用注意事项作简要介绍：      如果在现有的工程中前台界面均应用了jquery easyui，那么在布局的时候最好应用jquery eaysui的layout布局，否则在表单页面（编辑、查看、添加等等）在不同的浏览器会出
  • java-拷贝特殊链表：有一个特殊的链表，其中每个节点不但有指向下一个节点的指针pNext，还有一个指向链表中任意节点的指针pRand，如何拷贝这个特殊链表？ bylijinnan java
    public class CopySpecialLinkedList { /** * 题目：有一个特殊的链表，其中每个节点不但有指向下一个节点的指针pNext，还有一个指向链表中任意节点的指针pRand，如何拷贝这个特殊链表？ 拷贝pNext指针非常容易，所以题目的难点是如何拷贝pRand指针。 假设原来链表为A1 -> A2 ->... -> An，新拷贝
  • color Chen.H JavaScripthtmlcss
    <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"  "http://www.w3.org/TR/html4/loose.dtd">    <HTML>    <HEAD>&nbs
  • [信息与战争]移动通讯与网络 comsci 网络
          两个坚持:手机的电池必须可以取下来                光纤不能够入户,只能够到楼宇       建议大家找这本书看看:<&
  • oracle flashback query(闪回查询) daizj oracleflashback queryflashback table
    在Oracle 10g中，Flash back家族分为以下成员： Flashback Database Flashback Drop Flashback Table Flashback Query(分Flashback Query,Flashback Version Query，Flashback Transaction Query) 下面介绍一下Flashback Drop 和Flas
  • zeus持久层DAO单元测试 deng520159 单元测试
    zeus代码测试正紧张进行中,但由于工作比较忙,但速度比较慢.现在已经完成读写分离单元测试了,现在把几种情况单元测试的例子发出来,希望有人能进出意见,让它走下去. 本文是zeus的dao单元测试: 1.单元测试直接上代码   package com.dengliang.zeus.webdemo.test; import org.junit.Test; import o
  • C语言学习三printf函数和scanf函数学习 dcj3sjt126com cprintfscanflanguage
    printf函数 /* 2013年3月10日20:42:32 地点：北京潘家园 功能： 目的： 测试%x %X %#x %#X的用法 */ # include <stdio.h> int main(void) { printf("哈哈！\n"); // \n表示换行 int i = 10; printf
  • 那你为什么小时候不好好读书? dcj3sjt126com life
    dady, 我今天捡到了十块钱, 不过我还给那个人了 good girl! 那个人有没有和你讲thank you啊 没有啦....他拉我的耳朵我才把钱还给他的, 他哪里会和我讲thank you   爸爸, 如果地上有一张5块一张10块你拿哪一张呢.... 当然是拿十块的咯... 爸爸你很笨的, 你不会两张都拿   爸爸为什么上个月那个人来跟你讨钱, 你告诉他没
  • iptables开放端口 Fanyucai linuxiptables端口
    1，找到配置文件 vi /etc/sysconfig/iptables   2，添加端口开放，增加一行，开放18081端口 -A INPUT -m state --state NEW -m tcp -p tcp --dport 18081 -j ACCEPT   3，保存 ESC :wq!   4，重启服务 service iptables
  • Ehcache（05）——缓存的查询 234390216 排序ehcache统计query
    缓存的查询 目录 1.    使Cache可查询 1.1     基于Xml配置 1.2     基于代码的配置 2     指定可搜索的属性 2.1     可查询属性类型 2.2 &
  • 通过hashset找到数组中重复的元素 jackyrong hashset
      如何在hashset中快速找到重复的元素呢?方法很多，下面是其中一个办法： int[] array = {1,1,2,3,4,5,6,7,8,8}; Set<Integer> set = new HashSet<Integer>(); for(int i = 0
  • 使用ajax和window.history.pushState无刷新改变页面内容和地址栏URL lanrikey history
    后退时关闭当前页面 <script type="text/javascript"> jQuery(document).ready(function ($) {         if (window.history && window.history.pushState) {
  • 应用程序的通信成本 netkiller.github.com 虚拟机应用服务器陈景峰netkillerneo
    应用程序的通信成本 什么是通信 一个程序中两个以上功能相互传递信号或数据叫做通信。 什么是成本 这是是指时间成本与空间成本。 时间就是传递数据所花费的时间。空间是指传递过程耗费容量大小。 都有哪些通信方式 全局变量 线程间通信 共享内存 共享文件 管道 Socket 硬件（串口，USB） 等等 全局变量 全局变量是成本最低通信方法，通过设置
  • 一维数组与二维数组的声明与定义 恋洁e生 二维数组一维数组定义声明初始化
    /**  *  */ package test20111005; /**  * @author FlyingFire  * @date:2011-11-18 上午04:33:36  * @author ：代码整理  * @introduce :一维数组与二维数组的初始化  *summary：  */ public c
  • Spring Mybatis独立事务配置 toknowme mybatis
    在项目中有很多地方会使用到独立事务，下面以获取主键为例   （1）修改配置文件spring-mybatis.xml  <!-- 开启事务支持 -->  <tx:annotation-driven transaction-manager="transactionManager" />   &n
  • 更新Anadroid SDK Tooks之后，Eclipse提示No update were found xp9802 eclipse
    使用Android SDK Manager 更新了Anadroid SDK Tooks 之后， 打开eclipse提示 This Android SDK requires Android Developer Toolkit version 23.0.0 or above, 点击Check for Updates  检测一会后提示 No update were found