home *** CD-ROM | disk | FTP | other *** search
/ S283 Planetary Science &n…he Search for Life DVD 2 / DVD-ROM.iso / install / jre1_3 / lib / rt.jar / java / util / Collections.class (.txt) < prev    next >
Encoding:
Java Class File  |  1979-12-31  |  7.2 KB  |  331 lines
  1. package java.util;
  2.  
  3. public class Collections {
  4.    // $FF: renamed from: r java.util.Random
  5.    private static Random field_0 = new Random();
  6.    public static final Set EMPTY_SET = new EmptySet((1)null);
  7.    public static final List EMPTY_LIST = new EmptyList((1)null);
  8.    public static final Map EMPTY_MAP = new EmptyMap((1)null);
  9.    private static final Comparator REVERSE_ORDER = new ReverseComparator((1)null);
  10.  
  11.    private Collections() {
  12.    }
  13.  
  14.    public static void sort(List var0) {
  15.       Object[] var1 = var0.toArray();
  16.       Arrays.sort(var1);
  17.       ListIterator var2 = var0.listIterator();
  18.  
  19.       for(int var3 = 0; var3 < var1.length; ++var3) {
  20.          var2.next();
  21.          var2.set(var1[var3]);
  22.       }
  23.  
  24.    }
  25.  
  26.    public static void sort(List var0, Comparator var1) {
  27.       Object[] var2 = var0.toArray();
  28.       Arrays.sort(var2, var1);
  29.       ListIterator var3 = var0.listIterator();
  30.  
  31.       for(int var4 = 0; var4 < var2.length; ++var4) {
  32.          var3.next();
  33.          var3.set(var2[var4]);
  34.       }
  35.  
  36.    }
  37.  
  38.    public static int binarySearch(List var0, Object var1) {
  39.       if (!(var0 instanceof AbstractSequentialList)) {
  40.          int var7 = 0;
  41.          int var8 = var0.size() - 1;
  42.  
  43.          while(var7 <= var8) {
  44.             int var4 = (var7 + var8) / 2;
  45.             Object var5 = var0.get(var4);
  46.             int var6 = ((Comparable)var5).compareTo(var1);
  47.             if (var6 < 0) {
  48.                var7 = var4 + 1;
  49.             } else {
  50.                if (var6 <= 0) {
  51.                   return var4;
  52.                }
  53.  
  54.                var8 = var4 - 1;
  55.             }
  56.          }
  57.  
  58.          return -(var7 + 1);
  59.       } else {
  60.          ListIterator var2 = var0.listIterator();
  61.  
  62.          while(var2.hasNext()) {
  63.             int var3 = ((Comparable)var2.next()).compareTo(var1);
  64.             if (var3 == 0) {
  65.                return var2.previousIndex();
  66.             }
  67.  
  68.             if (var3 > 0) {
  69.                return -var2.nextIndex();
  70.             }
  71.          }
  72.  
  73.          return -var2.nextIndex() - 1;
  74.       }
  75.    }
  76.  
  77.    public static int binarySearch(List var0, Object var1, Comparator var2) {
  78.       if (var2 == null) {
  79.          return binarySearch(var0, var1);
  80.       } else if (!(var0 instanceof AbstractSequentialList)) {
  81.          int var8 = 0;
  82.          int var9 = var0.size() - 1;
  83.  
  84.          while(var8 <= var9) {
  85.             int var5 = (var8 + var9) / 2;
  86.             Object var6 = var0.get(var5);
  87.             int var7 = var2.compare(var6, var1);
  88.             if (var7 < 0) {
  89.                var8 = var5 + 1;
  90.             } else {
  91.                if (var7 <= 0) {
  92.                   return var5;
  93.                }
  94.  
  95.                var9 = var5 - 1;
  96.             }
  97.          }
  98.  
  99.          return -(var8 + 1);
  100.       } else {
  101.          ListIterator var3 = var0.listIterator();
  102.  
  103.          while(var3.hasNext()) {
  104.             int var4 = var2.compare(var3.next(), var1);
  105.             if (var4 == 0) {
  106.                return var3.previousIndex();
  107.             }
  108.  
  109.             if (var4 > 0) {
  110.                return -var3.nextIndex();
  111.             }
  112.          }
  113.  
  114.          return -var3.nextIndex() - 1;
  115.       }
  116.    }
  117.  
  118.    public static void reverse(List var0) {
  119.       ListIterator var1 = var0.listIterator();
  120.       ListIterator var2 = var0.listIterator(var0.size());
  121.       int var3 = 0;
  122.  
  123.       for(int var4 = var0.size() / 2; var3 < var4; ++var3) {
  124.          Object var5 = var1.next();
  125.          var1.set(var2.previous());
  126.          var2.set(var5);
  127.       }
  128.  
  129.    }
  130.  
  131.    public static void shuffle(List var0) {
  132.       shuffle(var0, field_0);
  133.    }
  134.  
  135.    public static void shuffle(List var0, Random var1) {
  136.       for(int var2 = var0.size(); var2 > 1; --var2) {
  137.          swap(var0, var2 - 1, var1.nextInt(var2));
  138.       }
  139.  
  140.    }
  141.  
  142.    private static void swap(List var0, int var1, int var2) {
  143.       Object var3 = var0.get(var1);
  144.       var0.set(var1, var0.get(var2));
  145.       var0.set(var2, var3);
  146.    }
  147.  
  148.    public static void fill(List var0, Object var1) {
  149.       ListIterator var2 = var0.listIterator();
  150.  
  151.       while(var2.hasNext()) {
  152.          var2.next();
  153.          var2.set(var1);
  154.       }
  155.  
  156.    }
  157.  
  158.    public static void copy(List var0, List var1) {
  159.       try {
  160.          ListIterator var2 = var0.listIterator();
  161.          ListIterator var3 = var1.listIterator();
  162.  
  163.          while(var3.hasNext()) {
  164.             var2.next();
  165.             var2.set(var3.next());
  166.          }
  167.  
  168.       } catch (NoSuchElementException var4) {
  169.          throw new IndexOutOfBoundsException("Source does not fit in dest.");
  170.       }
  171.    }
  172.  
  173.    public static Object min(Collection var0) {
  174.       Iterator var1 = var0.iterator();
  175.       Comparable var2 = (Comparable)var1.next();
  176.  
  177.       while(var1.hasNext()) {
  178.          Comparable var3 = (Comparable)var1.next();
  179.          if (var3.compareTo(var2) < 0) {
  180.             var2 = var3;
  181.          }
  182.       }
  183.  
  184.       return var2;
  185.    }
  186.  
  187.    public static Object min(Collection var0, Comparator var1) {
  188.       if (var1 == null) {
  189.          return min(var0);
  190.       } else {
  191.          Iterator var2 = var0.iterator();
  192.          Object var3 = var2.next();
  193.  
  194.          while(var2.hasNext()) {
  195.             Object var4 = var2.next();
  196.             if (var1.compare(var4, var3) < 0) {
  197.                var3 = var4;
  198.             }
  199.          }
  200.  
  201.          return var3;
  202.       }
  203.    }
  204.  
  205.    public static Object max(Collection var0) {
  206.       Iterator var1 = var0.iterator();
  207.       Comparable var2 = (Comparable)var1.next();
  208.  
  209.       while(var1.hasNext()) {
  210.          Comparable var3 = (Comparable)var1.next();
  211.          if (var3.compareTo(var2) > 0) {
  212.             var2 = var3;
  213.          }
  214.       }
  215.  
  216.       return var2;
  217.    }
  218.  
  219.    public static Object max(Collection var0, Comparator var1) {
  220.       if (var1 == null) {
  221.          return max(var0);
  222.       } else {
  223.          Iterator var2 = var0.iterator();
  224.          Object var3 = var2.next();
  225.  
  226.          while(var2.hasNext()) {
  227.             Object var4 = var2.next();
  228.             if (var1.compare(var4, var3) > 0) {
  229.                var3 = var4;
  230.             }
  231.          }
  232.  
  233.          return var3;
  234.       }
  235.    }
  236.  
  237.    public static Collection unmodifiableCollection(Collection var0) {
  238.       return new UnmodifiableCollection(var0);
  239.    }
  240.  
  241.    public static Set unmodifiableSet(Set var0) {
  242.       return new UnmodifiableSet(var0);
  243.    }
  244.  
  245.    public static SortedSet unmodifiableSortedSet(SortedSet var0) {
  246.       return new UnmodifiableSortedSet(var0);
  247.    }
  248.  
  249.    public static List unmodifiableList(List var0) {
  250.       return new UnmodifiableList(var0);
  251.    }
  252.  
  253.    public static Map unmodifiableMap(Map var0) {
  254.       return new UnmodifiableMap(var0);
  255.    }
  256.  
  257.    public static SortedMap unmodifiableSortedMap(SortedMap var0) {
  258.       return new UnmodifiableSortedMap(var0);
  259.    }
  260.  
  261.    public static Collection synchronizedCollection(Collection var0) {
  262.       return new SynchronizedCollection(var0);
  263.    }
  264.  
  265.    static Collection synchronizedCollection(Collection var0, Object var1) {
  266.       return new SynchronizedCollection(var0, var1);
  267.    }
  268.  
  269.    public static Set synchronizedSet(Set var0) {
  270.       return new SynchronizedSet(var0);
  271.    }
  272.  
  273.    static Set synchronizedSet(Set var0, Object var1) {
  274.       return new SynchronizedSet(var0, var1);
  275.    }
  276.  
  277.    public static SortedSet synchronizedSortedSet(SortedSet var0) {
  278.       return new SynchronizedSortedSet(var0);
  279.    }
  280.  
  281.    public static List synchronizedList(List var0) {
  282.       return new SynchronizedList(var0);
  283.    }
  284.  
  285.    static List synchronizedList(List var0, Object var1) {
  286.       return new SynchronizedList(var0, var1);
  287.    }
  288.  
  289.    public static Map synchronizedMap(Map var0) {
  290.       return new SynchronizedMap(var0);
  291.    }
  292.  
  293.    public static SortedMap synchronizedSortedMap(SortedMap var0) {
  294.       return new SynchronizedSortedMap(var0);
  295.    }
  296.  
  297.    public static Set singleton(Object var0) {
  298.       return new SingletonSet(var0);
  299.    }
  300.  
  301.    public static List singletonList(Object var0) {
  302.       return new SingletonList(var0);
  303.    }
  304.  
  305.    public static Map singletonMap(Object var0, Object var1) {
  306.       return new SingletonMap(var0, var1);
  307.    }
  308.  
  309.    public static List nCopies(int var0, Object var1) {
  310.       return new CopiesList(var0, var1);
  311.    }
  312.  
  313.    public static Comparator reverseOrder() {
  314.       return REVERSE_ORDER;
  315.    }
  316.  
  317.    public static Enumeration enumeration(Collection var0) {
  318.       return new 6(var0);
  319.    }
  320.  
  321.    // $FF: renamed from: eq (java.lang.Object, java.lang.Object) boolean
  322.    private static boolean method_0(Object var0, Object var1) {
  323.       return var0 == null ? var1 == null : var0.equals(var1);
  324.    }
  325.  
  326.    // $FF: synthetic method
  327.    static boolean access$100(Object var0, Object var1) {
  328.       return method_0(var0, var1);
  329.    }
  330. }
  331.