Collections

java.lang.Object
- ptolemy.backtrack.util.java.util.Collections

All Implemented Interfaces:

Rollbackable
```
public class Collections
extends java.lang.Object
implements Rollbackable
```
Utility class consisting of static methods that operate on, or return Collections. Contains methods to sort, search, reverse, fill and shuffle Collections, methods to facilitate interoperability with legacy APIs that are unaware of collections, a method to return a list which consists of multiple copies of one element, and methods which "wrap" collections to give them extra properties, such as thread-safety and unmodifiability.
All methods which take a collection throw a {

Since:

1.2

Author:

Original author unknown, Eric Blake (ebb9@email.byu.edu)

See Also:

Collection, Set, List, Map, Arrays

Status

updated to 1.4

Field Summary

Fields
Modifier and Type	Field and Description
`protected Checkpoint`	`$CHECKPOINT`
`protected CheckpointRecord`	`$RECORD$$CHECKPOINT`
`static List`	`EMPTY_LIST` An immutable, serializable, empty List, which implements RandomAccess.
`static Map`	`EMPTY_MAP` An immutable, serializable, empty Map.
`static Set`	`EMPTY_SET` An immutable, serializable, empty Set.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`$COMMIT(long timestamp)` Commit changes up to the given timestamp, but not including changes made at timestamp and afterward.
`Checkpoint`	`$GET$CHECKPOINT()` Get the checkpoint object that monitors this rollbackable object.
`void`	`$RESTORE(long timestamp, boolean trim)` Restore a previous state to all the private fields of this rollbackable object.
`java.lang.Object`	`$SET$CHECKPOINT(Checkpoint checkpoint)` Set the checkpoint object of this rollbackable object.
`static int`	`binarySearch(List l, java.lang.Object key)` Perform a binary search of a List for a key, using the natural ordering of the elements.
`static int`	`binarySearch(List l, java.lang.Object key, java.util.Comparator c)` Perform a binary search of a List for a key, using a supplied Comparator.
`static void`	`copy(List dest, List source)` Copy one list to another.
`static List`	`emptyList()` Returns the empty list (immutable).
`static Map`	`emptyMap()` Returns the empty list (immutable).
`static java.util.Enumeration`	`enumeration(Collection c)` Returns an Enumeration over a collection.
`static void`	`fill(List l, java.lang.Object val)` Replace every element of a list with a given value.
`static int`	`indexOfSubList(List source, List target)` Returns the starting index where the specified sublist first occurs in a larger list, or -1 if there is no matching position.
`static int`	`lastIndexOfSubList(List source, List target)` Returns the starting index where the specified sublist last occurs in a larger list, or -1 if there is no matching position.
`static ArrayList`	`list(java.util.Enumeration e)` Returns an ArrayList holding the elements visited by a given Enumeration.
`static java.lang.Object`	`max(Collection c)` Find the maximum element in a Collection, according to the natural ordering of the elements.
`static java.lang.Object`	`max(Collection c, java.util.Comparator order)` Find the maximum element in a Collection, according to a specified Comparator.
`static java.lang.Object`	`min(Collection c)` Find the minimum element in a Collection, according to the natural ordering of the elements.
`static java.lang.Object`	`min(Collection c, java.util.Comparator order)` Find the minimum element in a Collection, according to a specified Comparator.
`static List`	`nCopies(int n, java.lang.Object o)` Creates an immutable list consisting of the same object repeated n times.
`static boolean`	`replaceAll(List list, java.lang.Object oldval, java.lang.Object newval)` Replace all instances of one object with another in the specified list.
`static void`	`reverse(List l)` Reverse a given list.
`static java.util.Comparator`	`reverseOrder()` Get a comparator that implements the reverse of natural ordering.
`static void`	`rotate(List list, int distance)` Rotate the elements in a list by a specified distance.
`static void`	`shuffle(List l)` Shuffle a list according to a default source of randomness.
`static void`	`shuffle(List l, Random r)` Shuffle a list according to a given source of randomness.
`static Set`	`singleton(java.lang.Object o)` Obtain an immutable Set consisting of a single element.
`static List`	`singletonList(java.lang.Object o)` Obtain an immutable List consisting of a single element.
`static Map`	`singletonMap(java.lang.Object key, java.lang.Object value)` Obtain an immutable Map consisting of a single key-value pair.
`static void`	`sort(List l)` Sort a list according to the natural ordering of its elements.
`static void`	`sort(List l, java.util.Comparator c)` Sort a list according to a specified Comparator.
`static void`	`swap(List l, int i, int j)` Swaps the elements at the specified positions within the list.
`static Collection`	`synchronizedCollection(Collection c)` Returns a synchronized (thread-safe) collection wrapper backed by the given collection.
`static List`	`synchronizedList(List l)` Returns a synchronized (thread-safe) list wrapper backed by the given list.
`static Map`	`synchronizedMap(Map m)` Returns a synchronized (thread-safe) map wrapper backed by the given map.
`static Set`	`synchronizedSet(Set s)` Returns a synchronized (thread-safe) set wrapper backed by the given set.
`static SortedMap`	`synchronizedSortedMap(SortedMap m)` Returns a synchronized (thread-safe) sorted map wrapper backed by the given map.
`static SortedSet`	`synchronizedSortedSet(SortedSet s)` Returns a synchronized (thread-safe) sorted set wrapper backed by the given set.
`static Collection`	`unmodifiableCollection(Collection c)` Returns an unmodifiable view of the given collection.
`static List`	`unmodifiableList(List l)` Returns an unmodifiable view of the given list.
`static Map`	`unmodifiableMap(Map m)` Returns an unmodifiable view of the given map.
`static Set`	`unmodifiableSet(Set s)` Returns an unmodifiable view of the given set.
`static SortedMap`	`unmodifiableSortedMap(SortedMap m)` Returns an unmodifiable view of the given sorted map.
`static SortedSet`	`unmodifiableSortedSet(SortedSet s)` Returns an unmodifiable view of the given sorted set.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - $CHECKPOINT
```
protected transient Checkpoint $CHECKPOINT
```
  - EMPTY_SET
```
public static final Set EMPTY_SET
```
    An immutable, serializable, empty Set.
    
    See Also:
    
    Serializable
  - EMPTY_LIST
```
public static final List EMPTY_LIST
```
    An immutable, serializable, empty List, which implements RandomAccess.
    
    See Also:
    
    Serializable, RandomAccess
  - EMPTY_MAP
```
public static final Map EMPTY_MAP
```
    An immutable, serializable, empty Map.
    
    See Also:
    
    Serializable
  - $RECORD$$CHECKPOINT
```
protected transient CheckpointRecord $RECORD$$CHECKPOINT
```
- Method Detail
  - emptyList
```
public static final List emptyList()
```
    Returns the empty list (immutable). This list is serializable.
  - emptyMap
```
public static final Map emptyMap()
```
    Returns the empty list (immutable). This list is serializable.
  - binarySearch
```
public static int binarySearch(List l,
                               java.lang.Object key)
```
    Perform a binary search of a List for a key, using the natural ordering of the elements. The list must be sorted (as by the sort() method) - if it is not, the behavior of this method is undefined, and may be an infinite loop. Further, the key must be comparable with every item in the list. If the list contains the key more than once, any one of them may be found.
    This algorithm behaves in log(n) time for {
    
    Parameters:
    
    l - the list to search (must be sorted)
    
    key - the value to search for
    
    Returns:
    
    the index at which the key was found, or -n-1 if it was not found, where n is the index of the first value higher than key or a.length if there is no such value
    
    Throws:
    
    java.lang.ClassCastException - if key could not be compared with one of the elements of l
    
    java.lang.NullPointerException - if a null element has compareTo called
    
    See Also:
    
    sort(List)
  - binarySearch
```
public static int binarySearch(List l,
                               java.lang.Object key,
                               java.util.Comparator c)
```
    Perform a binary search of a List for a key, using a supplied Comparator. The list must be sorted (as by the sort() method with the same Comparator) - if it is not, the behavior of this method is undefined, and may be an infinite loop. Further, the key must be comparable with every item in the list. If the list contains the key more than once, any one of them may be found. If the comparator is null, the elements' natural ordering is used.
    This algorithm behaves in log(n) time for {
    
    Parameters:
    
    l - the list to search (must be sorted)
    
    key - the value to search for
    
    c - the comparator by which the list is sorted
    
    Returns:
    
    the index at which the key was found, or -n-1 if it was not found, where n is the index of the first value higher than key or a.length if there is no such value
    
    Throws:
    
    java.lang.ClassCastException - if key could not be compared with one of the elements of l
    
    java.lang.NullPointerException - if a null element is compared with natural ordering (only possible when c is null)
    
    See Also:
    
    sort(List, Comparator)
  - copy
```
public static void copy(List dest,
                        List source)
```
    Copy one list to another. If the destination list is longer than the source list, the remaining elements are unaffected. This method runs in linear time.
    
    Parameters:
    
    dest - the destination list
    
    source - the source list
    
    Throws:
    
    java.lang.IndexOutOfBoundsException - if the destination list is shorter than the source list (the destination will be unmodified)
    
    java.lang.UnsupportedOperationException - if dest.listIterator() does not support the set operation
  - enumeration
```
public static java.util.Enumeration enumeration(Collection c)
```
    Returns an Enumeration over a collection. This allows interoperability with legacy APIs that require an Enumeration as input.
    
    Parameters:
    
    c - the Collection to iterate over
    
    Returns:
    
    an Enumeration backed by an Iterator over c
  - fill
```
public static void fill(List l,
                        java.lang.Object val)
```
    Replace every element of a list with a given value. This method runs in linear time.
    
    Parameters:
    
    l - the list to fill.
    
    val - the object to vill the list with.
    
    Throws:
    
    java.lang.UnsupportedOperationException - if l.listIterator() does not support the set operation.
  - indexOfSubList
```
public static int indexOfSubList(List source,
                                 List target)
```
    Returns the starting index where the specified sublist first occurs in a larger list, or -1 if there is no matching position. If target.size() > source.size(), this returns -1, otherwise this implementation uses brute force, checking for source.sublist(i, i + target.size()).equals(target) for all possible i.
    
    Parameters:
    
    source - the list to search
    
    target - the sublist to search for
    
    Returns:
    
    the index where found, or -1
    
    Since:
    
    1.4
  - lastIndexOfSubList
```
public static int lastIndexOfSubList(List source,
                                     List target)
```
    Returns the starting index where the specified sublist last occurs in a larger list, or -1 if there is no matching position. If target.size() > source.size(), this returns -1, otherwise this implementation uses brute force, checking for source.sublist(i, i + target.size()).equals(target) for all possible i.
    
    Parameters:
    
    source - the list to search
    
    target - the sublist to search for
    
    Returns:
    
    the index where found, or -1
    
    Since:
    
    1.4
  - list
```
public static ArrayList list(java.util.Enumeration e)
```
    Returns an ArrayList holding the elements visited by a given Enumeration. This method exists for interoperability between legacy APIs and the new Collection API.
    
    Parameters:
    
    e - the enumeration to put in a list
    
    Returns:
    
    a list containing the enumeration elements
    
    Since:
    
    1.4
    
    See Also:
    
    ArrayList
  - max
```
public static java.lang.Object max(Collection c)
```
    Find the maximum element in a Collection, according to the natural ordering of the elements. This implementation iterates over the Collection, so it works in linear time.
    
    Parameters:
    
    c - the Collection to find the maximum element of
    
    Returns:
    
    the maximum element of c
    
    Throws:
    
    java.util.NoSuchElementException - if c is empty
    
    java.lang.ClassCastException - if elements in c are not mutually comparable
    
    java.lang.NullPointerException - if null.compareTo is called
  - max
```
public static java.lang.Object max(Collection c,
                                   java.util.Comparator order)
```
    Find the maximum element in a Collection, according to a specified Comparator. This implementation iterates over the Collection, so it works in linear time.
    
    Parameters:
    
    c - the Collection to find the maximum element of
    
    order - the Comparator to order the elements by, or null for natural ordering
    
    Returns:
    
    the maximum element of c
    
    Throws:
    
    java.util.NoSuchElementException - if c is empty
    
    java.lang.ClassCastException - if elements in c are not mutually comparable
    
    java.lang.NullPointerException - if null is compared by natural ordering (only possible when order is null)
  - min
```
public static java.lang.Object min(Collection c)
```
    Find the minimum element in a Collection, according to the natural ordering of the elements. This implementation iterates over the Collection, so it works in linear time.
    
    Parameters:
    
    c - the Collection to find the minimum element of
    
    Returns:
    
    the minimum element of c
    
    Throws:
    
    java.util.NoSuchElementException - if c is empty
    
    java.lang.ClassCastException - if elements in c are not mutually comparable
    
    java.lang.NullPointerException - if null.compareTo is called
  - min
```
public static java.lang.Object min(Collection c,
                                   java.util.Comparator order)
```
    Find the minimum element in a Collection, according to a specified Comparator. This implementation iterates over the Collection, so it works in linear time.
    
    Parameters:
    
    c - the Collection to find the minimum element of
    
    order - the Comparator to order the elements by, or null for natural ordering
    
    Returns:
    
    the minimum element of c
    
    Throws:
    
    java.util.NoSuchElementException - if c is empty
    
    java.lang.ClassCastException - if elements in c are not mutually comparable
    
    java.lang.NullPointerException - if null is compared by natural ordering (only possible when order is null)
  - nCopies
```
public static List nCopies(int n,
                           java.lang.Object o)
```
    Creates an immutable list consisting of the same object repeated n times. The returned object is tiny, consisting of only a single reference to the object and a count of the number of elements. It is Serializable, and implements RandomAccess. You can use it in tandem with List.addAll for fast list construction.
    
    Parameters:
    
    n - the number of times to repeat the object
    
    o - the object to repeat
    
    Returns:
    
    a List consisting of n copies of o
    
    Throws:
    
    java.lang.IllegalArgumentException - if n < 0
    
    See Also:
    
    List.addAll(Collection), Serializable, RandomAccess
  - replaceAll
```
public static boolean replaceAll(List list,
                                 java.lang.Object oldval,
                                 java.lang.Object newval)
```
    Replace all instances of one object with another in the specified list. The list does not change size. An element e is replaced if oldval == null ? e == null : oldval.equals(e).
    
    Parameters:
    
    list - the list to iterate over
    
    oldval - the element to replace
    
    newval - the new value for the element
    
    Returns:
    
    true if a replacement occurred.
    
    Throws:
    
    java.lang.UnsupportedOperationException - if the list iterator does not allow for the set operation
    
    java.lang.ClassCastException - if newval is of a type which cannot be added to the list
    
    java.lang.IllegalArgumentException - if some other aspect of newval stops it being added to the list
    
    Since:
    
    1.4
  - reverse
```
public static void reverse(List l)
```
    Reverse a given list. This method works in linear time.
    
    Parameters:
    
    l - the list to reverse
    
    Throws:
    
    java.lang.UnsupportedOperationException - if l.listIterator() does not support the set operation
  - reverseOrder
```
public static java.util.Comparator reverseOrder()
```
    Get a comparator that implements the reverse of natural ordering. In other words, this sorts Comparable objects opposite of how their compareTo method would sort. This makes it easy to sort into reverse order, by simply passing Collections.reverseOrder() to the sort method. The return value of this method is Serializable.
    
    Returns:
    
    a comparator that imposes reverse natural ordering
    
    See Also:
    
    Comparable, Serializable
  - rotate
```
public static void rotate(List list,
                          int distance)
```
    Rotate the elements in a list by a specified distance. After calling this method, the element now at index i was formerly at index (i - distance) mod list.size(). The list size is unchanged.
    For example, suppose a list contains [t, a, n, k, s]. After either Collections.rotate(l, 4) or Collections.rotate(l, -1), the new contents are [s, t, a, n, k]. This can be applied to sublists to rotate just a portion of the list. For example, to move element a forward two positions in the original example, use Collections.rotate(l.subList(1, 3+1), -1), which will result in [t, n, k, a, s].
    If the list is small or implements {
    
    Parameters:
    
    list - the list to rotate
    
    distance - the distance to rotate by; unrestricted in value
    
    Throws:
    
    java.lang.UnsupportedOperationException - if the list does not support set
    
    Since:
    
    1.4
  - shuffle
```
public static void shuffle(List l)
```
    Shuffle a list according to a default source of randomness. The algorithm used iterates backwards over the list, swapping each element with an element randomly selected from the elements in positions less than or equal to it (using r.nextInt(int)).
    This algorithm would result in a perfectly fair shuffle (that is, each element would have an equal chance of ending up in any position) if r were a perfect source of randomness. In practice the results are merely very close to perfect.
    This method operates in linear time. To do this on large lists which do not implement {
    
    Parameters:
    
    l - the list to shuffle
    
    Throws:
    
    java.lang.UnsupportedOperationException - if l.listIterator() does not support the set operation
  - shuffle
```
public static void shuffle(List l,
                           Random r)
```
    Shuffle a list according to a given source of randomness. The algorithm used iterates backwards over the list, swapping each element with an element randomly selected from the elements in positions less than or equal to it (using r.nextInt(int)).
    This algorithm would result in a perfectly fair shuffle (that is, each element would have an equal chance of ending up in any position) if r were a perfect source of randomness. In practise (eg if r = new Random()) the results are merely very close to perfect.
    This method operates in linear time. To do this on large lists which do not implement {
    
    Parameters:
    
    l - the list to shuffle
    
    r - the source of randomness to use for the shuffle
    
    Throws:
    
    java.lang.UnsupportedOperationException - if l.listIterator() does not support the set operation
  - singleton
```
public static Set singleton(java.lang.Object o)
```
    Obtain an immutable Set consisting of a single element. The return value of this method is Serializable.
    
    Parameters:
    
    o - the single element
    
    Returns:
    
    an immutable Set containing only o
    
    See Also:
    
    Serializable
  - singletonList
```
public static List singletonList(java.lang.Object o)
```
    Obtain an immutable List consisting of a single element. The return value of this method is Serializable, and implements RandomAccess.
    
    Parameters:
    
    o - the single element
    
    Returns:
    
    an immutable List containing only o
    
    Since:
    
    1.3
    
    See Also:
    
    Serializable, RandomAccess
  - singletonMap
```
public static Map singletonMap(java.lang.Object key,
                               java.lang.Object value)
```
    Obtain an immutable Map consisting of a single key-value pair. The return value of this method is Serializable.
    
    Parameters:
    
    key - the single key
    
    value - the single value
    
    Returns:
    
    an immutable Map containing only the single key-value pair
    
    Since:
    
    1.3
    
    See Also:
    
    Serializable
  - sort
```
public static void sort(List l)
```
    Sort a list according to the natural ordering of its elements. The list must be modifiable, but can be of fixed size. The sort algorithm is precisely that used by Arrays.sort(Object[]), which offers guaranteed nlog(n) performance. This implementation dumps the list into an array, sorts the array, and then iterates over the list setting each element from the array.
    
    Parameters:
    
    l - the List to sort
    
    Throws:
    
    java.lang.ClassCastException - if some items are not mutually comparable
    
    java.lang.UnsupportedOperationException - if the List is not modifiable
    
    java.lang.NullPointerException - if some element is null
    
    See Also:
    
    Arrays.sort(Object[])
  - sort
```
public static void sort(List l,
                        java.util.Comparator c)
```
    Sort a list according to a specified Comparator. The list must be modifiable, but can be of fixed size. The sort algorithm is precisely that used by Arrays.sort(Object[], Comparator), which offers guaranteed nlog(n) performance. This implementation dumps the list into an array, sorts the array, and then iterates over the list setting each element from the array.
    
    Parameters:
    
    l - the List to sort
    
    c - the Comparator specifying the ordering for the elements, or null for natural ordering
    
    Throws:
    
    java.lang.ClassCastException - if c will not compare some pair of items
    
    java.lang.UnsupportedOperationException - if the List is not modifiable
    
    java.lang.NullPointerException - if null is compared by natural ordering (only possible when c is null)
    
    See Also:
    
    Arrays.sort(Object[], Comparator)
  - swap
```
public static void swap(List l,
                        int i,
                        int j)
```
    Swaps the elements at the specified positions within the list. Equal positions have no effect.
    
    Parameters:
    
    l - the list to work on
    
    i - the first index to swap
    
    j - the second index
    
    Throws:
    
    java.lang.UnsupportedOperationException - if list.set is not supported
    
    java.lang.IndexOutOfBoundsException - if either i or j is < 0 or >= list.size()
    
    Since:
    
    1.4
  - synchronizedCollection
```
public static Collection synchronizedCollection(Collection c)
```
    Returns a synchronized (thread-safe) collection wrapper backed by the given collection. Notice that element access through the iterators is thread-safe, but if the collection can be structurally modified (adding or removing elements) then you should synchronize around the iteration to avoid non-deterministic behavior:
```
 Collection c = Collections.synchronizedCollection(new Collection(...));
 ...
 synchronized (c)
 {
 Iterator i = c.iterator();
 while (i.hasNext())
 foo(i.next());
 }
 
```
    Since the collection might be a List or a Set, and those have incompatible equals and hashCode requirements, this relies on Object's implementation rather than passing those calls on to the wrapped collection. The returned Collection implements Serializable, but can only be serialized if the collection it wraps is likewise Serializable.
    Parameters:
    
    c - the collection to wrap
    
    Returns:
    
    a synchronized view of the collection
    
    See Also:
    
    Serializable
  - synchronizedList
```
public static List synchronizedList(List l)
```
    Returns a synchronized (thread-safe) list wrapper backed by the given list. Notice that element access through the iterators is thread-safe, but if the list can be structurally modified (adding or removing elements) then you should synchronize around the iteration to avoid non-deterministic behavior:
```
 List l = Collections.synchronizedList(new List(...));
 ...
 synchronized (l)
 {
 Iterator i = l.iterator();
 while (i.hasNext())
 foo(i.next());
 }
 
```
    The returned List implements Serializable, but can only be serialized if the list it wraps is likewise Serializable. In addition, if the wrapped list implements RandomAccess, this does too.
    Parameters:
    
    l - the list to wrap
    
    Returns:
    
    a synchronized view of the list
    
    See Also:
    
    Serializable, RandomAccess
  - synchronizedMap
```
public static Map synchronizedMap(Map m)
```
    Returns a synchronized (thread-safe) map wrapper backed by the given map. Notice that element access through the collection views and their iterators are thread-safe, but if the map can be structurally modified (adding or removing elements) then you should synchronize around the iteration to avoid non-deterministic behavior:
```
 Map m = Collections.synchronizedMap(new Map(...));
 ...
 Set s = m.keySet(); // safe outside a synchronized block
 synchronized (m) // synch on m, not s
 {
 Iterator i = s.iterator();
 while (i.hasNext())
 foo(i.next());
 }
 
```
    The returned Map implements Serializable, but can only be serialized if the map it wraps is likewise Serializable.
    Parameters:
    
    m - the map to wrap
    
    Returns:
    
    a synchronized view of the map
    
    See Also:
    
    Serializable
  - synchronizedSet
```
public static Set synchronizedSet(Set s)
```
    Returns a synchronized (thread-safe) set wrapper backed by the given set. Notice that element access through the iterator is thread-safe, but if the set can be structurally modified (adding or removing elements) then you should synchronize around the iteration to avoid non-deterministic behavior:
```
 Set s = Collections.synchronizedSet(new Set(...));
 ...
 synchronized (s)
 {
 Iterator i = s.iterator();
 while (i.hasNext())
 foo(i.next());
 }
 
```
    The returned Set implements Serializable, but can only be serialized if the set it wraps is likewise Serializable.
    Parameters:
    
    s - the set to wrap
    
    Returns:
    
    a synchronized view of the set
    
    See Also:
    
    Serializable
  - synchronizedSortedMap
```
public static SortedMap synchronizedSortedMap(SortedMap m)
```
    Returns a synchronized (thread-safe) sorted map wrapper backed by the given map. Notice that element access through the collection views, subviews, and their iterators are thread-safe, but if the map can be structurally modified (adding or removing elements) then you should synchronize around the iteration to avoid non-deterministic behavior:
```
 SortedMap m = Collections.synchronizedSortedMap(new SortedMap(...));
 ...
 Set s = m.keySet(); // safe outside a synchronized block
 SortedMap m2 = m.headMap(foo); // safe outside a synchronized block
 Set s2 = m2.keySet(); // safe outside a synchronized block
 synchronized (m) // synch on m, not m2, s or s2
 {
 Iterator i = s.iterator();
 while (i.hasNext())
 foo(i.next());
 i = s2.iterator();
 while (i.hasNext())
 bar(i.next());
 }
 
```
    The returned SortedMap implements Serializable, but can only be serialized if the map it wraps is likewise Serializable.
    Parameters:
    
    m - the sorted map to wrap
    
    Returns:
    
    a synchronized view of the sorted map
    
    See Also:
    
    Serializable
  - synchronizedSortedSet
```
public static SortedSet synchronizedSortedSet(SortedSet s)
```
    Returns a synchronized (thread-safe) sorted set wrapper backed by the given set. Notice that element access through the iterator and through subviews are thread-safe, but if the set can be structurally modified (adding or removing elements) then you should synchronize around the iteration to avoid non-deterministic behavior:
```
 SortedSet s = Collections.synchronizedSortedSet(new SortedSet(...));
 ...
 SortedSet s2 = s.headSet(foo); // safe outside a synchronized block
 synchronized (s) // synch on s, not s2
 {
 Iterator i = s2.iterator();
 while (i.hasNext())
 foo(i.next());
 }
 
```
    The returned SortedSet implements Serializable, but can only be serialized if the set it wraps is likewise Serializable.
    Parameters:
    
    s - the sorted set to wrap
    
    Returns:
    
    a synchronized view of the sorted set
    
    See Also:
    
    Serializable
  - unmodifiableCollection
```
public static Collection unmodifiableCollection(Collection c)
```
    Returns an unmodifiable view of the given collection. This allows "read-only" access, although changes in the backing collection show up in this view. Attempts to modify the collection directly or via iterators will fail with {
    
    Parameters:
    
    c - the collection to wrap
    
    Returns:
    
    a read-only view of the collection
    
    See Also:
    
    Serializable
  - unmodifiableList
```
public static List unmodifiableList(List l)
```
    Returns an unmodifiable view of the given list. This allows "read-only" access, although changes in the backing list show up in this view. Attempts to modify the list directly, via iterators, or via sublists, will fail with {
    
    Parameters:
    
    l - the list to wrap
    
    Returns:
    
    a read-only view of the list
    
    See Also:
    
    Serializable, RandomAccess
  - unmodifiableMap
```
public static Map unmodifiableMap(Map m)
```
    Returns an unmodifiable view of the given map. This allows "read-only" access, although changes in the backing map show up in this view. Attempts to modify the map directly, or via collection views or their iterators will fail with {
    
    Parameters:
    
    m - the map to wrap
    
    Returns:
    
    a read-only view of the map
    
    See Also:
    
    Serializable
  - unmodifiableSet
```
public static Set unmodifiableSet(Set s)
```
    Returns an unmodifiable view of the given set. This allows "read-only" access, although changes in the backing set show up in this view. Attempts to modify the set directly or via iterators will fail with {
    
    Parameters:
    
    s - the set to wrap
    
    Returns:
    
    a read-only view of the set
    
    See Also:
    
    Serializable
  - unmodifiableSortedMap
```
public static SortedMap unmodifiableSortedMap(SortedMap m)
```
    Returns an unmodifiable view of the given sorted map. This allows "read-only" access, although changes in the backing map show up in this view. Attempts to modify the map directly, via subviews, via collection views, or iterators, will fail with {
    
    Parameters:
    
    m - the map to wrap
    
    Returns:
    
    a read-only view of the map
    
    See Also:
    
    Serializable
  - unmodifiableSortedSet
```
public static SortedSet unmodifiableSortedSet(SortedSet s)
```
    Returns an unmodifiable view of the given sorted set. This allows "read-only" access, although changes in the backing set show up in this view. Attempts to modify the set directly, via subsets, or via iterators, will fail with {
    
    Parameters:
    
    s - the set to wrap
    
    Returns:
    
    a read-only view of the set
    
    See Also:
    
    Serializable
  - $COMMIT
```
public void $COMMIT(long timestamp)
```
    Description copied from interface: Rollbackable
    
    Commit changes up to the given timestamp, but not including changes made at timestamp and afterward.
    
    Specified by:
    
    $COMMIT in interface Rollbackable
    
    Parameters:
    
    timestamp - The timestamp.
  - $RESTORE
```
public void $RESTORE(long timestamp,
                     boolean trim)
```
    Description copied from interface: Rollbackable
    
    Restore a previous state to all the private fields of this rollbackable object.
    
    Specified by:
    
    $RESTORE in interface Rollbackable
    
    Parameters:
    
    timestamp - The timestamp taken at the time when the previous state was recorded.
    
    trim - Whether to delete the records used for the rollback.
    
    See Also:
    
    Checkpoint.rollback(long, boolean)
  - $GET$CHECKPOINT
```
public final Checkpoint $GET$CHECKPOINT()
```
    Description copied from interface: Rollbackable
    
    Get the checkpoint object that monitors this rollbackable object.
    
    Specified by:
    
    $GET$CHECKPOINT in interface Rollbackable
    
    Returns:
    
    The checkpoint object.
  - $SET$CHECKPOINT
```
public final java.lang.Object $SET$CHECKPOINT(Checkpoint checkpoint)
```
    Description copied from interface: Rollbackable
    
    Set the checkpoint object of this rollbackable object. A merge operation is performed on the current checkpoint object and the new checkpoint object, so that the two checkpoint objects monitor the same set of objects when this function returns.
    
    Specified by:
    
    $SET$CHECKPOINT in interface Rollbackable
    
    Parameters:
    
    checkpoint - The new checkpoint object.
    
    Returns:
    
    This rollbackable object itself.
    
    See Also:
    
    Checkpoint.setCheckpoint(Checkpoint)

Class Collections

Field Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

$CHECKPOINT

EMPTY_SET

EMPTY_LIST

EMPTY_MAP

$RECORD$$CHECKPOINT

Method Detail

emptyList

emptyMap

binarySearch

binarySearch

copy

enumeration

fill

indexOfSubList

lastIndexOfSubList

list

max

max

min

min

nCopies

replaceAll

reverse

reverseOrder

rotate

shuffle

shuffle

singleton

singletonList

singletonMap

sort

sort

swap

synchronizedCollection

synchronizedList

synchronizedMap

synchronizedSet

synchronizedSortedMap

synchronizedSortedSet

unmodifiableCollection

unmodifiableList

unmodifiableMap

unmodifiableSet

unmodifiableSortedMap

unmodifiableSortedSet

$COMMIT

$RESTORE

$GET$CHECKPOINT

$SET$CHECKPOINT