首页 > 代码库 > Java数据结构学习—Collections类
Java数据结构学习—Collections类
java.util
类 Collections
java.lang.Objectjava.util.Collections
public class Collections
- extends Object
此类完全由在 collection 上进行操作或返回 collection 的静态方法组成。它包含在 collection 上操作的多态算法，即“包装器”，包装器返回由指定 collection 支持的新 collection，以及少数其他内容。
如果为此类的方法所提供的 collection 或类对象为 null，则这些方法都将抛出 NullPointerException。
此类中所含多态算法的文档通常包括对实现 的简短描述。应该将这类描述视为实现注意事项，而不是规范 的一部分。实现者应该可以随意使用其他算法替代，只要遵循规范本身即可。（例如，sort 使用的算法不一定是合并排序算法，但它必须是稳定的。）
此类中包含的“破坏性”算法，即可修改其所操作的 collection 的算法，该算法被指定在 collection 不支持适当的可变基元（比如 set 方法）时抛出UnsupportedOperationException。如果调用不会对 collection 产生任何影响，那么这些算法可能（但不要求）抛出此异常。例如，在已经排序的、不可修改列表上调用sort 方法可能会（也可能不会）抛出 UnsupportedOperationException。
此类是 Java Collections Framework 的成员。
/***********************************************************************************************/package com.hephec;
/**
*Instanceless class contains static methods that operate on collections
*/
public class Collections{
private Collection(){
}
/**
*Return a comparator that imposes the reverse of the default ordering on collection of obejects that implement the Comparator interface
*Return the comparator
*/
public static <AnyType> Comparator<AnyType> reverseOrder(){
return new ReverseComparator<AnyType>();
}
private static class ReverseComparator<AnyType> implements Comparator<AnyType>{
public int compare(AnyType lhs,AnyType rhs){
return -((Comparator)lhs.compareTo(rhs));
}
}
static class DefaultComparator<AnyType extends Comparator<? super AnyType>> implements Cmparator<AnyType>{
public int compare(AnyType lhs,AnyType rhs){
return lhs.compareTo(rhs);
}
}
}
/***********************************************************************************************/
一些常见的方法摘要：
addAll
public static <T> boolean addAll(Collection<? super T> c,
T... elements)- 将所有指定元素添加到指定 collection 中。可以分别指定要添加的元素，或者将它们指定为一个数组。此便捷方法的行为与 c.addAll(Arrays.asList(elements)) 的行为是相同的，但在大多数实现下，此方法运行起来可能要快得多。
在分别指定元素时，此方法提供了将少数元素添加到现有 collection 中的一个便捷方式：
Collections.addAll(flavors, "Peaches ‘n Plutonium", "Rocky Racoon");
- 参数：
c- 要插入 elements 的 collectionelements- 插入 c 的元素- 返回：
- 如果 collection 由于调用而发生更改，则返回 true
- 抛出：
UnsupportedOperationException- 如果c 不支持 add 操作NullPointerException- 如果elements 包含一个或多个 null 值并且 c 不允许使用 null 元素，或者 c 或 elements 为nullIllegalArgumentException- 如果elements 中值的某个属性不允许将它添加到 c 中- 从以下版本开始：
- 1.5
- 另请参见：
Collection.addAll(Collection)
sort
public static <T> void sort(List<T> list,
Comparator<? super T> c)- 根据指定比较器产生的顺序对指定列表进行排序。此列表内的所有元素都必须可使用指定比较器相互比较（也就是说，对于列表中的任意 e1 和 e2 元素，c.compare(e1, e2) 不得抛出 ClassCastException）。
此排序被保证是稳定的：不会因调用 sort 而对相等的元素进行重新排序。
排序算法是一个经过修改的合并排序算法（其中，如果低子列表中的最高元素小于高子列表中的最低元素，则忽略合并）。此算法提供可保证的 n log(n) 性能。 指定列表必须是可修改的，但不必是可大小调整的。此实现将指定列表转储到一个数组中，并对数组进行排序，在重置数组中相应位置每个元素的列表上进行迭代。这避免了由于试图原地对链接列表进行排序而产生的 n2 log(n) 性能。
- 参数：
list- 要排序的列表。c- 确定列表顺序的比较器。null 值指示应该使用元素的自然顺序。- 抛出：
ClassCastException- 如果列表中包含不可使用指定比较器相互比较 的元素。UnsupportedOperationException- 如果指定列表的列表迭代器不支持set 操作。- 另请参见：
Comparator
binarySearch
public static <T> int binarySearch(List<? extends T> list,
T key,
Comparator<? super T> c)- 使用二分搜索法搜索指定列表，以获得指定对象。在进行此调用之前，必须根据指定的比较器对列表进行升序排序（通过
sort(List, Comparator)方法）。如果没有对列表进行排序，则结果是不确定的。如果列表包含多个等于指定对象的元素，则无法保证找到的是哪一个。此方法对“随机访问”的列表运行 log(n) 次（它提供接近固定时间的位置访问）。如果指定列表没有实现
RandomAccess接口并且是一个大型列表，则此方法将执行基于迭代器的二分搜索，执行 O(n) 次链接遍历和 O(log n) 次元素比较。 - 参数：
list- 要搜索的列表。key- 要搜索的键。c- 排序列表的比较器。null 值指示应该使用元素的自然顺序。- 返回：
- 如果搜索键包含在列表中，则返回搜索键的索引；否则返回 (-(插入点) - 1)。插入点 被定义为将键插入列表的那一点：即第一个大于此键的元素索引；如果列表中的所有元素都小于指定的键，则为list.size()。注意，这保证了当且仅当此键被找到时，返回的值将 >= 0。
- 抛出：
ClassCastException- 如果列表中包含使用指定的比较器不可相互比较 的元素，或者使用此比较器无法相互比较搜索键与列表元素。
replaceAll
public static <T> boolean replaceAll(List<T> list,
T oldVal,
T newVal)- 使用另一个值替换列表中出现的所有某一指定值。更确切地讲，使用 newVal 替换 list 中满足 (oldVal==null ? e==null : oldVal.equals(e)) 的每个e 元素。（此方法对列表的大小没有任何影响。）
- 参数：
list- 在其中进行替换的列表。oldVal- 将被替换的原值。newVal- 替换 oldVal 的新值。- 返回：
- 如果 list 包含一个或多个满足 (oldVal==null ? e==null : oldVal.equals(e)) 的e 元素，则返回 true。
- 抛出：
UnsupportedOperationException- 如果指定列表或其列表迭代器不支持set 操作。- 从以下版本开始：
- 1.4
rotate
public static void rotate(List<?> list,
int distance)- 根据指定的距离轮换指定列表中的元素。调用此方法后，对于 0 和 list.size()-1（包括）之间的所有 i 值，索引 i 处的元素将是以前位于索引 (i - distance) mod list.size() 处的元素。（此方法对列表的大小没有任何影响。）
例如，假设 list 包含 [t, a, n, k, s]。在调用 Collections.rotate(list, 1)（或Collections.rotate(list, -4)）之后，list 将包含 [s, t, a, n, k]。
注意，此方法用于子列表时非常有用，可以在保留其余元素顺序的同时，在列表中移动一个或多个元素。例如，以下语句可以将索引 j 处的元素向前移动到位置k 上（k 必须大于等于 j）：
Collections.rotate(list.subList(j, k+1), -1);
为了具体说明这一点，假设 list 包含 [a, b, c, d, e]。要将索引 1 处的元素（b）向前移动两个位置，请执行以下调用：Collections.rotate(l.subList(1, 4), -1);
得到的列表是 [a, c, d, b, e]。要将多个元素向前移动，则需要增加循环移动距离的绝对值。要将元素向后移动，请使用一个正的移动距离。
如果指定列表是一个小型列表，或者它实现了
RandomAccess接口，则此实现会将第一个元素交换到它应该去的位置上，然后重复执行交换操作，将替换的元素交换到它们应该去的位置上，直到替换的元素交换成第一个元素。如有必要，需要在第二个或后续元素上重复这个过程，直到完成轮换。如果指定的列表是大型列表并且没有实现RandomAccess 接口，则此实现会将列表拆分成位于 -distance mod size 索引两边的两个子列表视图。然后在每个子列表视图上调用reverse(List)方法，并最终在整个列表上调用此方法。有关这两种算法更为完整的描述，请参阅 Jon Bentley 撰写的Programming Pearls (Addison-Wesley, 1986) 一书中的第 2.3 小节。 - 参数：
list- 要轮换的列表。distance- 列表轮换的距离。在此值上没有任何限制；它可以是 0、负数或大于 list.size() 的数。- 抛出：
UnsupportedOperationException- 如果指定列表或其列表迭代器不支持set 操作。- 从以下版本开始：
- 1.4
max
public static <T extends Object & Comparable<? super T>> T max(Collection<? extends T> coll)
- 根据元素的自然顺序，返回给定 collection 的最大元素。collection 中的所有元素都必须实现 Comparable 接口。此外，collection 中的所有元素都必须是可相互比较的（也就是说，对于 collection 中的任意e1 和 e2 元素，e1.compareTo(e2) 不得抛出 ClassCastException）。
此方法在整个 collection 上进行迭代，所以它需要的时间与 collection 的大小成正比。
- 参数：
coll- 将确定其最大元素的 collection。- 返回：
- 根据元素的自然顺序 返回给定 collection 的最大元素。
- 抛出：
ClassCastException- 如果 collection 包含不可相互比较 的元素（例如，字符串和整数）。NoSuchElementException- 如果 collection 为空。- 另请参见：
Comparable
min
public static <T extends Object & Comparable<? super T>> T min(Collection<? extends T> coll)
- 根据元素的自然顺序 返回给定 collection 的最小元素。collection 中的所有元素都必须实现 Comparable 接口。此外，collection 中的所有元素都必须是可相互比较的（也就是说，对于 collection 中的任意e1 和 e2 元素，e1.compareTo(e2) 不得抛出 ClassCastException）。
此方法在整个 collection 上进行迭代，所以它需要的时间与 collection 的大小成正比。
- 参数：
coll- 将确定其最小元素的 collection。- 返回：
- 根据元素的自然顺序，返回给定 collection 的最小元素。
- 抛出：
ClassCastException- 如果 collection 包含不可相互比较 的元素（例如，字符串和整数）。NoSuchElementException- 如果 collection 为空。- 另请参见：
Comparable
copy
public static <T> void copy(List<? super T> dest,
List<? extends T> src)- 将所有元素从一个列表复制到另一个列表。执行此操作后，目标列表中每个已复制元素的索引将等同于源列表中该元素的索引。目标列表的长度至少必须等于源列表。如果目标列表更长一些，也不会影响目标列表中的其余元素。
此方法以线性时间运行。
- 参数：
dest- 目标列表。src- 源列表。- 抛出：
IndexOutOfBoundsException- 如果目标列表太小而无法包含整个源列表。UnsupportedOperationException- 如果目标列表的列表迭代器不支持set 操作。
fill
public static <T> void fill(List<? super T> list,
T obj)- 使用指定元素替换指定列表中的所有元素。
此方法以线性时间运行。
- 参数：
list- 使用指定元素填充的列表。obj- 用来填充指定列表的元素。- 抛出：
UnsupportedOperationException- 如果指定列表或其列表迭代器不支持set 操作。
swap
public static void swap(List<?> list,
int i,
int j)- 在指定列表的指定位置处交换元素。（如果指定位置相同，则调用此方法不会更改列表。）
- 参数：
list- 进行元素交换的列表。i- 要交换的一个元素的索引。j- 要交换的另一个元素的索引。- 抛出：
IndexOutOfBoundsException- 如果i 或 j 超出范围 (i < 0 || i >= list.size() || j < 0 || j >= list.size())。- 从以下版本开始：
- 1.4
shuffle
public static void shuffle(List<?> list)
- 使用默认随机源对指定列表进行置换。所有置换发生的可能性都是大致相等的。
前面描述中使用了不确定的词“大致”，因为随机源只是大致上独立选择位的无偏源。如果它是一个随机选择位的最佳源，那么算法将完全一致的选择置换。
此实现向后遍历列表，从最后一个元素一直到第二个元素，将随机选择的元素重复交换到“当前位置”。元素是从列表的一部分随机选择的，该部分列表从第一个元素一直到当前位置（包括）。
此方法以线性时间运行。如果指定列表没有实现
RandomAccess接口并且是一个大型列表，则此实现在改组列表前将指定列表转储到数组中，并将改组后的数组转储回列表中。这避免了二次行为，该行为是原地改组一个“有序访问”列表引起的。 - 参数：
list- 要改组的列表。- 抛出：
UnsupportedOperationException- 如果指定列表或其列表迭代器不支持 set 操作。
reverse
public static void reverse(List<?> list)
- 反转指定列表中元素的顺序。
此方法以线性时间运行。
- 参数：
list- 元素要被反转的列表。- 抛出：
UnsupportedOperationException- 如果指定列表或其列表迭代器不支持set 操作。