我女朋友老师布置的一道简单的作业！要求用java实现。

你把java 中的源码给老师了那个是最标准啦

据我"调查(我碰到的姐弟的才那么几对)",姐弟恋(姐弟夫妻)最爽啊,姐姐对弟弟照顾无微不至啊!爽歪歪啊!
不过我的MM对我还是超好.幸福ING……

import java.util.*;
import java.io.*;
public class Collections {
    private Collections() {}
    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;
    public static void sort(List list) {
Object a[] = list.toArray();
Arrays.sort(a);
ListIterator i = list.listIterator();
for (int j=0; j<a.length; j++) {
    i.next();
    i.set(a[j]);
}
    }
    public static void sort(List list, Comparator c) {
Object a[] = list.toArray();
Arrays.sort(a, c);
ListIterator i = list.listIterator();
for (int j=0; j<a.length; j++) {
    i.next();
    i.set(a[j]);
}
    }
    public static int binarySearch(List list, Object key) {
        if (list instanceof RandomAccess || list.size()<BINARYSEARCH_THRESHOLD)
            return indexedBinarySearch(list, key);
        else
            return iteratorBinarySearch(list, key);
    }    private static int indexedBinarySearch(List list, Object key) {
int low = 0;
int high = list.size()-1; while (low <= high) {
    int mid = (low + high) >> 1;
    Object midVal = list.get(mid);
    int cmp = ((Comparable)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, Object key) {
int low = 0;
int high = list.size()-1;
        ListIterator i = list.listIterator();        while (low <= high) {
            int mid = (low + high) >> 1;
            Object midVal = get(i, mid);
            int cmp = ((Comparable)midVal).compareTo(key);            if (cmp < 0)
                low = mid + 1;
            else if (cmp > 0)
                high = mid - 1;
            else
                return mid;
        }
        return -(low + 1);
    }
    private static Object get(ListIterator i, int index) {
        Object 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;
    }
    public static int binarySearch(List list, Object key, Comparator c) {
        if (c==null)
            return binarySearch(list, key);        if (list instanceof RandomAccess || list.size()<BINARYSEARCH_THRESHOLD)
            return indexedBinarySearch(list, key, c);
        else
            return iteratorBinarySearch(list, key, c);
    }    private static int indexedBinarySearch(List l, Object key, Comparator c) {
int low = 0;
int high = l.size()-1; while (low <= high) {
    int mid = (low + high) >> 1;
    Object 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;
}
return -(low + 1);
    }    private static int iteratorBinarySearch(List l, Object key, Comparator c) {
int low = 0;
int high = l.size()-1;
        ListIterator i = l.listIterator();        while (low <= high) {
            int mid = (low + high) >> 1;
            Object 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;
        }
        return -(low + 1);
    }    public static void reverse(List list) {
        int size = list.size();
        if (size < REVERSE_THRESHOLD || list instanceof RandomAccess) {
            for (int i=0, mid=size>>1, j=size-1; i<mid; i++, j--)
                swap(list, i, j);
        } else {
            ListIterator fwd = list.listIterator();
            ListIterator rev = list.listIterator(size);
            for (int i=0, mid=list.size()>>1; i<mid; i++) {
                Object tmp = fwd.next();
                fwd.set(rev.previous());
                rev.set(tmp);
            }
        }
    }    public static void shuffle(List list) {
        shuffle(list, r);
    }
    private static Random r = new Random();    public static void shuffle(List list, Random rnd) {
        int size = list.size();
        if (size < SHUFFLE_THRESHOLD || list instanceof RandomAccess) {
            for (int i=size; i>1; i--)
                swap(list, i-1, rnd.nextInt(i));
        } else {
            Object arr[] = list.toArray();
            for (int i=size; i>1; i--)
                swap(arr, i-1, rnd.nextInt(i));
            ListIterator it = list.listIterator();
            for (int i=0; i<arr.length; i++) {
                it.next();
                it.set(arr[i]);
            }
        }
    }
public static void swap(List list, int i, int j) {
        list.set(i, list.set(j, list.get(i)));
    }
    private static void swap(Object[] arr, int i, int j) {
        Object tmp = arr[i];
        arr[i] = arr[j];
        arr[j] = tmp;
    }

public static void fill(List list, Object obj) {
        int size = list.size();
        if (size < FILL_THRESHOLD || list instanceof RandomAccess) {
            for (int i=0; i<size; i++)
                list.set(i, obj);
        } else {
            ListIterator itr = list.listIterator();
            for (int i=0; i<size; i++) {
                itr.next();
                itr.set(obj);
            }
        }
    }
    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<srcSize; i++)
                dest.set(i, src.get(i));
        } else {
            ListIterator di=dest.listIterator(), si=src.listIterator();
            for (int i=0; i<srcSize; i++) {
                di.next();
                di.set(si.next());
            }
        }
    }
    public static Object min(Collection coll) {
Iterator i = coll.iterator();
Comparable candidate = (Comparable)(i.next());        while(i.hasNext()) {
    Comparable next = (Comparable)(i.next());
    if (next.compareTo(candidate) < 0)
candidate = next;
}
return candidate;
    }
    public static Object min(Collection coll, Comparator comp) {
        if (comp==null)
            return min(coll);
Iterator i = coll.iterator();
Object candidate = i.next();
        while(i.hasNext()) {
    Object next = i.next();
    if (comp.compare(next, candidate) < 0)
candidate = next;
}
return candidate;
    }
    public static Object max(Collection coll) {
Iterator i = coll.iterator();
Comparable candidate = (Comparable)(i.next());        while(i.hasNext()) {
    Comparable next = (Comparable)(i.next());
    if (next.compareTo(candidate) > 0)
candidate = next;
}
return candidate;
    }
    public static Object max(Collection coll, Comparator comp) {
        if (comp==null)
            return max(coll);
Iterator i = coll.iterator();
Object candidate = i.next();        while(i.hasNext()) {
    Object next = i.next();
    if (comp.compare(next, candidate) > 0)
candidate = next;
}
return candidate;
    }
     public static void rotate(List list, int distance) {
        if (list instanceof RandomAccess || list.size() < ROTATE_THRESHOLD)
            rotate1(list, distance);
        else
            rotate2(list, distance);
    }
    private static void rotate1(List list, int distance) {
        int size = list.size();
        if (size == 0)
            return;
        distance = distance % size;
        if (distance < 0)
            distance += size;
        if (distance == 0)
            return;
        for (int cycleStart = 0, nMoved = 0; nMoved != size; cycleStart++) {
            Object displaced = list.get(cycleStart);
            int i = cycleStart;
            do {
                i += distance;
                if (i >= size)
                    i -= size;
                displaced = list.set(i, displaced);
                nMoved ++;
            } 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;
        Collections.reverse(list.subList(0, mid));
        Collections.reverse(list.subList(mid, size));
        Collections.reverse(list);
    }

public static boolean replaceAll(List list, Object oldVal, Object newVal) {
        boolean result = false;
        int size = list.size();
        if (size < REPLACEALL_THRESHOLD || list instanceof RandomAccess) {
            if (oldVal==null) {
                for (int i=0; i<size; i++) {
                    if (list.get(i)==null) {
                        list.set(i, newVal);
                        result = true;
                    }
                }
            } else {
                for (int i=0; i<size; i++) {
                    if (oldVal.equals(list.get(i))) {
                        list.set(i, newVal);
                        result = true;
                    }
                }
            }
        } else {
            ListIterator itr=list.listIterator();
            if (oldVal==null) {
                for (int i=0; i<size; i++) {
                    if (itr.next()==null) {
                        itr.set(newVal);
                        result = true;
                    }
                }
            } else {
                for (int i=0; i<size; i++) {
                    if (oldVal.equals(itr.next())) {
                        itr.set(newVal);
                        result = true;
                    }
                }
            }
        }
        return result;
    }
    public static int indexOfSubList(List source, List target) {
        int sourceSize = source.size();
        int targetSize = target.size();
        int maxCandidate = sourceSize - targetSize;        if (sourceSize < INDEXOFSUBLIST_THRESHOLD ||
            (source instanceof RandomAccess&&target instanceof RandomAccess)) {
        nextCand:
            for (int candidate = 0; candidate <= maxCandidate; candidate++) {
                for (int i=0, j=candidate; i<targetSize; i++, j++)
                    if (!eq(target.get(i), source.get(j)))
                        continue nextCand;
                return candidate;
            }
        } else {
            ListIterator si = source.listIterator();
        nextCand:
            for (int candidate = 0; candidate <= maxCandidate; candidate++) {
                ListIterator ti = target.listIterator();
                for (int i=0; i<targetSize; i++) {
                    if (!eq(ti.next(), si.next())) {
                        for (int j=0; j<i; j++)
                            si.previous();
                        continue nextCand;
                    }
                }
                return candidate;
            }
        }
        return -1;
    }
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) {
        nextCand:
            for (int candidate = maxCandidate; candidate >= 0; candidate--) {
                for (int i=0, j=candidate; i<targetSize; i++, j++)
                    if (!eq(target.get(i), source.get(j)))
                        continue nextCand;
                return candidate;
            }
        } else {
            if (maxCandidate < 0)
                return -1;
            ListIterator si = source.listIterator(maxCandidate);
        nextCand:
            for (int candidate = maxCandidate; candidate >= 0; candidate--) {
                ListIterator ti = target.listIterator();
                for (int i=0; i<targetSize; i++) {
                    if (!eq(ti.next(), si.next())) {
                        if (candidate != 0) {
                            for (int j=0; j<=i+1; j++)
                                si.previous();
                        }
                        continue nextCand;
                    }
                }
                return candidate;
            }
        }
        return -1;
    }
    public static Collection unmodifiableCollection(Collection c) {
return new UnmodifiableCollection(c);
    }    static class UnmodifiableCollection implements Collection, Serializable {
private static final long serialVersionUID = 1820017752578914078L; 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 Object[] toArray(Object[] a) {return c.toArray(a);}
        public String toString()            {return c.toString();}

好长：）
呵呵题外话，对于中国现有的高等教育，我真的感到有点担忧。
其实也是老话题了，就是素质教育与应试教育说一个我们学校以前的笑话，一个学计算机专业的大四学生，居然连Windows98都不会装。以前我们班也不少这样的同学，整天抱着书本在啃，说起来都是一套一套的理论，考试分数从来都不会落后，但当老师布置一个很简单的实际操作作业，各个都束手无策。中国的教育制度不改的话（不是表面的改，而是彻底的改革），可能永远都是美国等的跟尾狗。

呵呵
大家说的有道理
我不是学计算机的，可是我相信计算机专业200多人里，比我强的决不超过5个，真不知道他们的计算机到底是怎么学的
举个例子，我向他们请教MySQL的问题（注意，我用的是请教），他们居然没有一个人知道，说MySQL是不是就是SQL Server呀
从此我不再向计算机系的人请教问题

hlding(淋东) ()
你给的程序怎么和 java.util.Collections 里面的原程序大部相同啊.

我Kao, hlding(淋东) (),你是在糊弄楼主还是在糊弄大家?
Copy&Paste一段原程序, 去掉注释就给放这儿来拉?

大家对计算机专业的学生偏见有点大了吧！当然在着发贴子的大侠太多了，显的计算机专业的学生有点逊色。计算机的领域实在是太广了，有那位大侠敢说自己对计算机无所不通。就那数据库来说吧，一个对oracle十分了解的dba也许db2的一些问题就可能速手无策。当然，没听说过mysql的计算机专业的学生还是有点夸张。

你们还在说什么什么的,
有人贴了一段 JDK 的源程序来糊弄大家，居然还没有意见．

同意Hontyou()：对于计算机这块谁都有技术盲点，我相信没有人敢说他全能——这样说那么他就是无知。
而且术有专功，我认为只要在某个方面能做好就可以了，当然，学计算机的人最好要有那种触类旁通的能力。

AndrewCSDN(无尽的永恒),没错,上面的程序段是以前的帖子曾经有过,由于没有时间,我只是改了一点,但话说回来,又有几个程序员是自己‘创造’的程序？不过，我觉得你要是有本事能够读懂其中的一点点就很了不起了！！！！

是的啊~现在的学习只可能是一个方面的了
全才是天才才有可能了吧~
但我知道一大4毕业了的很厉害的MM计算机系的高不高才我就不知道了她连死机按ctrl+ale+del不起作用后就急的不知道怎么办了寒~~~~~

hlding(淋东) ( ) 本人不才, 能够读懂, 事实上 Collection Framework 源码,特别是sorting, searching 我都做过研究, 和我的论文有关.

hlding(淋东) ( ) 我看你还是不明白我的意思,在 JDK 中原程序中已经有 java.util.Collections 这个类,
而且就是定义为 Collections.java, 我看了原来的那个帖, 他就是直接粘贴过来的
(去掉注释)
我估计你也是没有看, 把他的抄过来(而且不完整)
然后你把 package java.util; 这一行改为 import java.util;
这就整个的改变了意思啊!
我所以怀疑你在糊弄人.

调试易

我女朋友老师布置的一道简单的作业！要求用java实现。

解决方案 »