Java数据结构学习—Collections类

标签：collections

java.util
类 Collections

java.lang.Object
  java.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 的 collection

elements - 插入 c 的元素

返回：

如果 collection 由于调用而发生更改，则返回 true

抛出：

UnsupportedOperationException - 如果 c 不支持 add 操作

NullPointerException - 如果 elements 包含一个或多个 null 值并且 c 不允许使用 null 元素，或者 c 或 elements 为 null

IllegalArgumentException - 如果 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) 性能。 指定列表必须是可修改的，但不必是可大小调整的。此实现将指定列表转储到一个数组中，并对数组进行排序，在重置数组中相应位置每个元素的列表上进行迭代。这避免了由于试图原地对链接列表进行排序而产生的 n² 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)

public static void reverse(List<?> list)

Java数据结构学习—Collections类,布布扣,bubuko.com

Java数据结构学习—Collections类

标签：collections

原文地址：http://blog.csdn.net/hephec/article/details/38438781