001: package java.util;
002:
003: import java.io.Serializable;
004:
005: public class Collections {
006: private static boolean isSequential(List l) {
007: }
008:
009: private Collections() {
010: }
011:
012: public static final Set EMPTY_SET = new EmptySet();
013:
014: private static final class EmptySet extends AbstractSet implements
015: Serializable {
016: EmptySet() {
017: }
018:
019: public int size() {
020: }
021:
022: public Iterator iterator() {
023: }
024:
025: public boolean contains(Object o) {
026: }
027:
028: public boolean containsAll(Collection c) {
029: }
030:
031: public boolean equals(Object o) {
032: }
033:
034: public int hashCode() {
035: }
036:
037: public boolean remove(Object o) {
038: }
039:
040: public boolean removeAll(Collection c) {
041: }
042:
043: public boolean retainAll(Collection c) {
044: }
045:
046: public Object[] toArray() {
047: }
048:
049: public Object[] toArray(Object[] a) {
050: }
051:
052: public String toString() {
053: }
054: }
055:
056: public static final List EMPTY_LIST = new EmptyList();
057:
058: private static final class EmptyList extends AbstractList implements
059: Serializable, RandomAccess {
060: EmptyList() {
061: }
062:
063: public int size() {
064: }
065:
066: public Object get(int index) {
067: }
068:
069: public boolean contains(Object o) {
070: }
071:
072: public boolean containsAll(Collection c) {
073: }
074:
075: public boolean equals(Object o) {
076: }
077:
078: public int hashCode() {
079: }
080:
081: public int indexOf(Object o) {
082: }
083:
084: public int lastIndexOf(Object o) {
085: }
086:
087: public boolean remove(Object o) {
088: }
089:
090: public boolean removeAll(Collection c) {
091: }
092:
093: public boolean retainAll(Collection c) {
094: }
095:
096: public Object[] toArray() {
097: }
098:
099: public Object[] toArray(Object[] a) {
100: }
101:
102: public String toString() {
103: }
104: }
105:
106: public static final Map EMPTY_MAP = new EmptyMap();
107:
108: private static final class EmptyMap extends AbstractMap implements
109: Serializable {
110: EmptyMap() {
111: }
112:
113: public Set entrySet() {
114: }
115:
116: public boolean containsKey(Object key) {
117: }
118:
119: public boolean containsValue(Object value) {
120: }
121:
122: public boolean equals(Object o) {
123: }
124:
125: public Object get(Object o) {
126: }
127:
128: public int hashCode() {
129: }
130:
131: public Set keySet() {
132: }
133:
134: public Object remove(Object o) {
135: }
136:
137: public int size() {
138: }
139:
140: public Collection values() {
141: }
142:
143: public String toString() {
144: }
145: }
146:
147: static final int compare(Object o1, Object o2, Comparator c) {
148: }
149:
150: public static int binarySearch(List l, Object key) {
151: }
152:
153: public static int binarySearch(List l, Object key, Comparator c) {
154: }
155:
156: public static void copy(List dest, List source) {
157: }
158:
159: public static Enumeration enumeration(Collection c) {
160: }
161:
162: public static void fill(List l, Object val) {
163: }
164:
165: public static int indexOfSubList(List source, List target) {
166: }
167:
168: public static int lastIndexOfSubList(List source, List target) {
169: }
170:
171: public static ArrayList list(Enumeration e) {
172: }
173:
174: public static Object max(Collection c) {
175: }
176:
177: public static Object max(Collection c, Comparator order) {
178: }
179:
180: public static Object min(Collection c) {
181: }
182:
183: public static Object min(Collection c, Comparator order) {
184: }
185:
186: public static List nCopies(final int n, final Object o) {
187: }
188:
189: private static final class CopiesList extends AbstractList
190: implements Serializable, RandomAccess {
191: CopiesList(int n, Object o) {
192: }
193:
194: public int size() {
195: }
196:
197: public Object get(int index) {
198: }
199:
200: public boolean contains(Object o) {
201: }
202:
203: public int indexOf(Object o) {
204: }
205:
206: public int lastIndexOf(Object o) {
207: }
208:
209: public List subList(int from, int to) {
210: }
211:
212: public Object[] toArray() {
213: }
214:
215: public String toString() {
216: }
217: }
218:
219: public static boolean replaceAll(List list, Object oldval,
220: Object newval) {
221: }
222:
223: public static void reverse(List l) {
224: }
225:
226: public static Comparator reverseOrder() {
227: }
228:
229: private static final class ReverseComparator implements Comparator,
230: Serializable {
231: ReverseComparator() {
232: }
233:
234: public int compare(Object a, Object b) {
235: }
236: }
237:
238: public static void rotate(List list, int distance) {
239: }
240:
241: public static void shuffle(List l) {
242: }
243:
244: public static void shuffle(List l, Random r) {
245: }
246:
247: public static Set singleton(Object o) {
248: }
249:
250: private static final class SingletonSet extends AbstractSet
251: implements Serializable {
252: final Object element;
253:
254: SingletonSet(Object o) {
255: }
256:
257: public int size() {
258: }
259:
260: public Iterator iterator() {
261: }
262:
263: public boolean contains(Object o) {
264: }
265:
266: public boolean containsAll(Collection c) {
267: }
268:
269: public int hashCode() {
270: }
271:
272: public Object[] toArray() {
273: }
274:
275: public String toString() {
276: }
277: }
278:
279: public static List singletonList(Object o) {
280: }
281:
282: private static final class SingletonList extends AbstractList
283: implements Serializable, RandomAccess {
284: SingletonList(Object o) {
285: }
286:
287: public int size() {
288: }
289:
290: public Object get(int index) {
291: }
292:
293: public boolean contains(Object o) {
294: }
295:
296: public boolean containsAll(Collection c) {
297: }
298:
299: public int hashCode() {
300: }
301:
302: public int indexOf(Object o) {
303: }
304:
305: public int lastIndexOf(Object o) {
306: }
307:
308: public List subList(int from, int to) {
309: }
310:
311: public Object[] toArray() {
312: }
313:
314: public String toString() {
315: }
316: }
317:
318: public static Map singletonMap(Object key, Object value) {
319: }
320:
321: private static final class SingletonMap extends AbstractMap
322: implements Serializable {
323: SingletonMap(Object key, Object value) {
324: }
325:
326: public Set entrySet() {
327: }
328:
329: public boolean containsKey(Object key) {
330: }
331:
332: public boolean containsValue(Object value) {
333: }
334:
335: public Object get(Object key) {
336: }
337:
338: public int hashCode() {
339: }
340:
341: public Set keySet() {
342: }
343:
344: public int size() {
345: }
346:
347: public Collection values() {
348: }
349:
350: public String toString() {
351: }
352: }
353:
354: public static void sort(List l) {
355: }
356:
357: public static void sort(List l, Comparator c) {
358: }
359:
360: public static void swap(List l, int i, int j) {
361: }
362:
363: public static Collection synchronizedCollection(Collection c) {
364: }
365:
366: static class SynchronizedCollection implements Collection,
367: Serializable {
368: final Collection c;
369: final Object mutex;
370:
371: SynchronizedCollection(Collection c) {
372: }
373:
374: SynchronizedCollection(Object sync, Collection c) {
375: }
376:
377: public boolean add(Object o) {
378: }
379:
380: public boolean addAll(Collection col) {
381: }
382:
383: public void clear() {
384: }
385:
386: public boolean contains(Object o) {
387: }
388:
389: public boolean containsAll(Collection c1) {
390: }
391:
392: public boolean isEmpty() {
393: }
394:
395: public Iterator iterator() {
396: }
397:
398: public boolean remove(Object o) {
399: }
400:
401: public boolean removeAll(Collection col) {
402: }
403:
404: public boolean retainAll(Collection col) {
405: }
406:
407: public int size() {
408: }
409:
410: public Object[] toArray() {
411: }
412:
413: public Object[] toArray(Object[] a) {
414: }
415:
416: public String toString() {
417: }
418: }
419:
420: private static class SynchronizedIterator implements Iterator {
421: final Object mutex;
422:
423: SynchronizedIterator(Object sync, Iterator i) {
424: }
425:
426: public Object next() {
427: }
428:
429: public boolean hasNext() {
430: }
431:
432: public void remove() {
433: }
434: }
435:
436: public static List synchronizedList(List l) {
437: }
438:
439: static class SynchronizedList extends SynchronizedCollection
440: implements List {
441: final List list;
442:
443: SynchronizedList(List l) {
444: }
445:
446: SynchronizedList(Object sync, List l) {
447: }
448:
449: public void add(int index, Object o) {
450: }
451:
452: public boolean addAll(int index, Collection c) {
453: }
454:
455: public boolean equals(Object o) {
456: }
457:
458: public Object get(int index) {
459: }
460:
461: public int hashCode() {
462: }
463:
464: public int indexOf(Object o) {
465: }
466:
467: public int lastIndexOf(Object o) {
468: }
469:
470: public ListIterator listIterator() {
471: }
472:
473: public ListIterator listIterator(int index) {
474: }
475:
476: public Object remove(int index) {
477: }
478:
479: public Object set(int index, Object o) {
480: }
481:
482: public List subList(int fromIndex, int toIndex) {
483: }
484: }
485:
486: private static final class SynchronizedRandomAccessList extends
487: SynchronizedList implements RandomAccess {
488: SynchronizedRandomAccessList(List l) {
489: }
490:
491: SynchronizedRandomAccessList(Object sync, List l) {
492: }
493:
494: public List subList(int fromIndex, int toIndex) {
495: }
496: }
497:
498: private static final class SynchronizedListIterator extends
499: SynchronizedIterator implements ListIterator {
500: SynchronizedListIterator(Object sync, ListIterator li) {
501: }
502:
503: public void add(Object o) {
504: }
505:
506: public boolean hasPrevious() {
507: }
508:
509: public int nextIndex() {
510: }
511:
512: public Object previous() {
513: }
514:
515: public int previousIndex() {
516: }
517:
518: public void set(Object o) {
519: }
520: }
521:
522: public static Map synchronizedMap(Map m) {
523: }
524:
525: private static class SynchronizedMap implements Map, Serializable {
526: final Object mutex;
527:
528: SynchronizedMap(Map m) {
529: }
530:
531: SynchronizedMap(Object sync, Map m) {
532: }
533:
534: public void clear() {
535: }
536:
537: public boolean containsKey(Object key) {
538: }
539:
540: public boolean containsValue(Object value) {
541: }
542:
543: public Set entrySet() {
544: }
545:
546: public boolean equals(Object o) {
547: }
548:
549: public Object get(Object key) {
550: }
551:
552: public int hashCode() {
553: }
554:
555: public boolean isEmpty() {
556: }
557:
558: public Set keySet() {
559: }
560:
561: public Object put(Object key, Object value) {
562: }
563:
564: public void putAll(Map map) {
565: }
566:
567: public Object remove(Object o) {
568: }
569:
570: public int size() {
571: }
572:
573: public String toString() {
574: }
575:
576: public Collection values() {
577: }
578: }
579:
580: public static Set synchronizedSet(Set s) {
581: }
582:
583: static class SynchronizedSet extends SynchronizedCollection
584: implements Set {
585: SynchronizedSet(Set s) {
586: }
587:
588: SynchronizedSet(Object sync, Set s) {
589: }
590:
591: public boolean equals(Object o) {
592: }
593:
594: public int hashCode() {
595: }
596: }
597:
598: public static SortedMap synchronizedSortedMap(SortedMap m) {
599: }
600:
601: private static final class SynchronizedSortedMap extends
602: SynchronizedMap implements SortedMap {
603: SynchronizedSortedMap(SortedMap sm) {
604: }
605:
606: SynchronizedSortedMap(Object sync, SortedMap sm) {
607: }
608:
609: public Comparator comparator() {
610: }
611:
612: public Object firstKey() {
613: }
614:
615: public SortedMap headMap(Object toKey) {
616: }
617:
618: public Object lastKey() {
619: }
620:
621: public SortedMap subMap(Object fromKey, Object toKey) {
622: }
623:
624: public SortedMap tailMap(Object fromKey) {
625: }
626: }
627:
628: public static SortedSet synchronizedSortedSet(SortedSet s) {
629: }
630:
631: private static final class SynchronizedSortedSet extends
632: SynchronizedSet implements SortedSet {
633: SynchronizedSortedSet(SortedSet ss) {
634: }
635:
636: SynchronizedSortedSet(Object sync, SortedSet ss) {
637: }
638:
639: public Comparator comparator() {
640: }
641:
642: public Object first() {
643: }
644:
645: public SortedSet headSet(Object toElement) {
646: }
647:
648: public Object last() {
649: }
650:
651: public SortedSet subSet(Object fromElement, Object toElement) {
652: }
653:
654: public SortedSet tailSet(Object fromElement) {
655: }
656: }
657:
658: public static Collection unmodifiableCollection(Collection c) {
659: }
660:
661: private static class UnmodifiableCollection implements Collection,
662: Serializable {
663: final Collection c;
664:
665: UnmodifiableCollection(Collection c) {
666: }
667:
668: public boolean add(Object o) {
669: }
670:
671: public boolean addAll(Collection c) {
672: }
673:
674: public void clear() {
675: }
676:
677: public boolean contains(Object o) {
678: }
679:
680: public boolean containsAll(Collection c1) {
681: }
682:
683: public boolean isEmpty() {
684: }
685:
686: public Iterator iterator() {
687: }
688:
689: public boolean remove(Object o) {
690: }
691:
692: public boolean removeAll(Collection c) {
693: }
694:
695: public boolean retainAll(Collection c) {
696: }
697:
698: public int size() {
699: }
700:
701: public Object[] toArray() {
702: }
703:
704: public Object[] toArray(Object[] a) {
705: }
706:
707: public String toString() {
708: }
709: }
710:
711: private static class UnmodifiableIterator implements Iterator {
712: UnmodifiableIterator(Iterator i) {
713: }
714:
715: public Object next() {
716: }
717:
718: public boolean hasNext() {
719: }
720:
721: public void remove() {
722: }
723: }
724:
725: public static List unmodifiableList(List l) {
726: }
727:
728: private static class UnmodifiableList extends
729: UnmodifiableCollection implements List {
730: final List list;
731:
732: UnmodifiableList(List l) {
733: }
734:
735: public void add(int index, Object o) {
736: }
737:
738: public boolean addAll(int index, Collection c) {
739: }
740:
741: public boolean equals(Object o) {
742: }
743:
744: public Object get(int index) {
745: }
746:
747: public int hashCode() {
748: }
749:
750: public int indexOf(Object o) {
751: }
752:
753: public int lastIndexOf(Object o) {
754: }
755:
756: public ListIterator listIterator() {
757: }
758:
759: public ListIterator listIterator(int index) {
760: }
761:
762: public Object remove(int index) {
763: }
764:
765: public Object set(int index, Object o) {
766: }
767:
768: public List subList(int fromIndex, int toIndex) {
769: }
770: }
771:
772: private static final class UnmodifiableRandomAccessList extends
773: UnmodifiableList implements RandomAccess {
774: UnmodifiableRandomAccessList(List l) {
775: }
776: }
777:
778: private static final class UnmodifiableListIterator extends
779: UnmodifiableIterator implements ListIterator {
780: UnmodifiableListIterator(ListIterator li) {
781: }
782:
783: public void add(Object o) {
784: }
785:
786: public boolean hasPrevious() {
787: }
788:
789: public int nextIndex() {
790: }
791:
792: public Object previous() {
793: }
794:
795: public int previousIndex() {
796: }
797:
798: public void set(Object o) {
799: }
800: }
801:
802: public static Map unmodifiableMap(Map m) {
803: }
804:
805: private static class UnmodifiableMap implements Map, Serializable {
806: UnmodifiableMap(Map m) {
807: }
808:
809: public void clear() {
810: }
811:
812: public boolean containsKey(Object key) {
813: }
814:
815: public boolean containsValue(Object value) {
816: }
817:
818: public Set entrySet() {
819: }
820:
821: private static final class UnmodifiableEntrySet extends
822: UnmodifiableSet implements Serializable {
823: UnmodifiableEntrySet(Set s) {
824: }
825:
826: public Iterator iterator() {
827: }
828: }
829:
830: public boolean equals(Object o) {
831: }
832:
833: public Object get(Object key) {
834: }
835:
836: public Object put(Object key, Object value) {
837: }
838:
839: public int hashCode() {
840: }
841:
842: public boolean isEmpty() {
843: }
844:
845: public Set keySet() {
846: }
847:
848: public void putAll(Map m) {
849: }
850:
851: public Object remove(Object o) {
852: }
853:
854: public int size() {
855: }
856:
857: public String toString() {
858: }
859:
860: public Collection values() {
861: }
862: }
863:
864: public static Set unmodifiableSet(Set s) {
865: }
866:
867: private static class UnmodifiableSet extends UnmodifiableCollection
868: implements Set {
869: UnmodifiableSet(Set s) {
870: }
871:
872: public boolean equals(Object o) {
873: }
874:
875: public int hashCode() {
876: }
877: }
878:
879: public static SortedMap unmodifiableSortedMap(SortedMap m) {
880: }
881:
882: private static class UnmodifiableSortedMap extends UnmodifiableMap
883: implements SortedMap {
884: UnmodifiableSortedMap(SortedMap sm) {
885: }
886:
887: public Comparator comparator() {
888: }
889:
890: public Object firstKey() {
891: }
892:
893: public SortedMap headMap(Object toKey) {
894: }
895:
896: public Object lastKey() {
897: }
898:
899: public SortedMap subMap(Object fromKey, Object toKey) {
900: }
901:
902: public SortedMap tailMap(Object fromKey) {
903: }
904: }
905:
906: public static SortedSet unmodifiableSortedSet(SortedSet s) {
907: }
908:
909: private static class UnmodifiableSortedSet extends UnmodifiableSet
910: implements SortedSet {
911: UnmodifiableSortedSet(SortedSet ss) {
912: }
913:
914: public Comparator comparator() {
915: }
916:
917: public Object first() {
918: }
919:
920: public SortedSet headSet(Object toElement) {
921: }
922:
923: public Object last() {
924: }
925:
926: public SortedSet subSet(Object fromElement, Object toElement) {
927: }
928:
929: public SortedSet tailSet(Object fromElement) {
930: }
931: }
932: }
|