概要  パッケージ   クラス  使用  階層ツリー  非推奨 API  索引  ヘルプ 
JavaTM Platform
Standard Ed. 6
 前のクラス   次のクラス フレームあり    フレームなし    
概要: 入れ子 | フィールド | コンストラクタ | メソッド 詳細: フィールド | コンストラクタ | メソッド

java.util
クラス Collections

java.lang.Object
  上位を拡張 java.util.Collections

public class Collections
extends Object

このクラスは、コレクションに作用する、またはコレクションを返す static メソッドだけで構成されます。このクラスには、指定されたコレクションに連動した新しいコレクションを返す「ラッパー」など、コレクションに対して作用するさまざまなアルゴリズムがあります。  

このクラスのメソッドに提供されるコレクションまたはクラスオブジェクトが null の場合、このクラスのメソッドは NullPointerException をすべてスローします。  

このクラスにあるさまざまなアルゴリズムのドキュメントには、通常、「実装」の簡単な説明が含まれています。この説明は、「仕様」の一部ではなく「実装情報」と考えてください。実装者は、仕様に反しないかぎり、ほかのアルゴリズムを自由に使用できます。たとえば、sort が使用するアルゴリズムはマージソートである必要はありませんが、「固定 (stable)」のアルゴリズムでなければいけません。  

コレクションが set メソッドのような適切な変異プリミティブ型メソッドをサポートしていない場合、このクラス (処理されるコレクションを修正するアルゴリズム) に含まれていた「破壊的」アルゴリズムは、UnsupportedOperationException をスローするように指定されています。呼び出しがコレクションに影響しない場合、こうしたアルゴリズムは例外をスローする場合がありますが、必須ではありません。たとえば、ソート済みの変更不可能なリストで、sort メソッドを呼び出すと、UnsupportedOperationException がスローされる場合とスローされない場合があります。  

このクラスは、Java Collections Framework のメンバーです。

導入されたバージョン:
1.2
関連項目:
Collection, Set, List, Map

フィールドの概要
static List EMPTY_LIST
          空のリストです (不変)。
static Map EMPTY_MAP
          空のマップです (不変)。
static Set EMPTY_SET
          空のセットです (不変)。
 
メソッドの概要
static
<T> boolean
addAll(Collection<? super T> c, T... elements)
          指定されたすべての要素を指定されたコレクションに追加します。
static
<T> Queue<T>
asLifoQueue(Deque<T> deque)
          Deque のビューを後入れ先出し (Lifo) Queue として返します。
static
<T> int
binarySearch(List<? extends Comparable<? super T>> list, T key)
          バイナリサーチアルゴリズムを使用して、指定されたリストから指定されたオブジェクトを検索します。
static
<T> int
binarySearch(List<? extends T> list, T key, Comparator<? super T> c)
          バイナリサーチアルゴリズムを使用して、指定されたリストから指定されたオブジェクトを検索します。
static
<E> Collection<E>
checkedCollection(Collection<E> c, Class<E> type)
          指定されたコレクションの、動的に型保証されたビューを返します。
static
<E> List<E>
checkedList(List<E> list, Class<E> type)
          指定されたリストの動的に型保証されたビューを返します。
static
<K,V> Map<K,V>
checkedMap(Map<K,V> m, Class<K> keyType, Class<V> valueType)
          指定されたマップの動的に型保証されたビューを返します。
static
<E> Set<E>
checkedSet(Set<E> s, Class<E> type)
          指定されたセットの動的に型保証されたビューを返します。
static
<K,V> SortedMap<K,V>
checkedSortedMap(SortedMap<K,V> m, Class<K> keyType, Class<V> valueType)
          指定されたソートマップの動的に型保証されたビューを返します。
static
<E> SortedSet<E>
checkedSortedSet(SortedSet<E> s, Class<E> type)
          指定されたソートセットの動的に型保証されたビューを返します。
static
<T> void
copy(List<? super T> dest, List<? extends T> src)
          あるリストから別のリストにすべての要素をコピーします。
static boolean disjoint(Collection<?> c1, Collection<?> c2)
          指定された 2 つのコレクションに共通の要素が存在しない場合、true を返します。
static
<T> List<T>
emptyList()
          空のリストを返します (不変)。
static
<K,V> Map<K,V>
emptyMap()
          空のマップを返します (不変)。
static
<T> Set<T>
emptySet()
          空のセット (不変) を返します。
static
<T> Enumeration<T>
enumeration(Collection<T> c)
          指定されたコレクションの列挙を返します。
static
<T> void
fill(List<? super T> list, T obj)
          指定されたリストのすべての要素を指定された要素で置き換えます。
static int frequency(Collection<?> c, Object o)
          指定されたコレクション内で、指定されたオブジェクトと等価な要素の数を返します。
static int indexOfSubList(List<?> source, List<?> target)
          指定されたソースリスト内で、指定されたターゲットリストが最初に出現した位置の開始位置を返します。
static int lastIndexOfSubList(List<?> source, List<?> target)
          指定されたソースリスト内で、最後に出現した指定ターゲットリストの開始位置を返します。
static
<T> ArrayList<T>
list(Enumeration<T> e)
          指定された列挙により返された要素を含む配列リストを、返された順番で返します。
static
<T extends Object & Comparable<? super T>>
T
max(Collection<? extends T> coll)
          要素の「自然順序付け」に従って、指定されたコレクションの最大の要素を返します。
static
<T> T
max(Collection<? extends T> coll, Comparator<? super T> comp)
          指定されたコンパレータが示す順序に従って、指定されたコレクションの最大の要素を返します。
static
<T extends Object & Comparable<? super T>>
T
min(Collection<? extends T> coll)
          要素の「自然順序付け」に従って、指定されたコレクションの最小の要素を返します。
static
<T> T
min(Collection<? extends T> coll, Comparator<? super T> comp)
          指定されたコンパレータが示す順序に従って、指定されたコレクションの最小の要素を返します。
static
<T> List<T>
nCopies(int n, T o)
          指定されたオブジェクトの n 個のコピーで構成される不変のリストを返します。
static
<E> Set<E>
newSetFromMap(Map<E,Boolean> map)
          指定されたマップに連動するセットを返します。
static
<T> boolean
replaceAll(List<T> list, T oldVal, T newVal)
          リスト内に出現する指定された値をすべてほかの値に置き換えます。
static void reverse(List<?> list)
          指定されたリストの要素の順序を逆にします。
static
<T> Comparator<T>
reverseOrder()
          Comparable インタフェースを実装するオブジェクトのコレクションで「自然順序付け」の逆を義務付けるコンパレータを返します。
static
<T> Comparator<T>
reverseOrder(Comparator<T> cmp)
          指定されたコンパレータの逆順を義務付けるコンパレータを返します。
static void rotate(List<?> list, int distance)
          指定されたリストの要素を、指定された距離により回転します。
static void shuffle(List<?> list)
          デフォルトの乱数発生の元を使用して、指定されたリストの順序を無作為に入れ替えます。
static void shuffle(List<?> list, Random rnd)
          デフォルトの乱数発生の元を使用して、指定されたリストの順序を無作為に入れ替えます。
static
<T> Set<T>
singleton(T o)
          指定されたオブジェクトだけを格納している不変のセットを返します。
static
<T> List<T>
singletonList(T o)
          指定されたオブジェクトだけを格納している不変のリストを返します。
static
<K,V> Map<K,V>
singletonMap(K key, V value)
          指定された値に指定されたキーだけをマッピングする不変のマップを返します。
static
<T extends Comparable<? super T>>
void
sort(List<T> list)
          要素の「自然順序付け」に従って、指定されたリストを昇順にソートします。
static
<T> void
sort(List<T> list, Comparator<? super T> c)
          指定されたコンパレータが示す順序に従って、指定されたリストをソートします。
static void swap(List<?> list, int i, int j)
          指定されたリストの指定された位置にある要素をスワップします。
static
<T> Collection<T>
synchronizedCollection(Collection<T> c)
          指定されたコレクションに連動する同期 (スレッドセーフな) コレクションを返します。
static
<T> List<T>
synchronizedList(List<T> list)
          指定されたリストに連動する同期 (スレッドセーフな) リストを返します。
static
<K,V> Map<K,V>
synchronizedMap(Map<K,V> m)
          指定されたマップに連動する同期 (スレッドセーフな) マップを返します。
static
<T> Set<T>
synchronizedSet(Set<T> s)
          指定されたセットに連動する同期 (スレッドセーフな) セットを返します。
static
<K,V> SortedMap<K,V>
synchronizedSortedMap(SortedMap<K,V> m)
          指定されたソートマップに連動する同期 (スレッドセーフな) ソートマップを返します。
static
<T> SortedSet<T>
synchronizedSortedSet(SortedSet<T> s)
          指定されたソートセットに連動する同期 (スレッドセーフな) ソートセットを返します。
static
<T> Collection<T>
unmodifiableCollection(Collection<? extends T> c)
          指定されたコレクションの変更不可能なビューを返します。
static
<T> List<T>
unmodifiableList(List<? extends T> list)
          指定されたリストの変更不可能なビューを返します。
static
<K,V> Map<K,V>
unmodifiableMap(Map<? extends K,? extends V> m)
          指定されたマップの変更不可能なビューを返します。
static
<T> Set<T>
unmodifiableSet(Set<? extends T> s)
          指定されたセットの変更不可能なビューを返します。
static
<K,V> SortedMap<K,V>
unmodifiableSortedMap(SortedMap<K,? extends V> m)
          指定されたソートマップの変更不可能なビューを返します。
static
<T> SortedSet<T>
unmodifiableSortedSet(SortedSet<T> s)
          指定されたソートセットの変更不可能なビューを返します。
 
クラス java.lang.Object から継承されたメソッド
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
 

フィールドの詳細

EMPTY_SET

public static final Set EMPTY_SET
空のセットです (不変)。このセットは直列化が可能です。

関連項目:
emptySet()

EMPTY_LIST

public static final List EMPTY_LIST
空のリストです (不変)。このリストは直列化可能です。

関連項目:
emptyList()

EMPTY_MAP

public static final Map EMPTY_MAP
空のマップです (不変)。このマップは直列化可能です。

導入されたバージョン:
1.3
関連項目:
emptyMap()
メソッドの詳細

sort

public static <T extends Comparable<? super T>> void sort(List<T> list)
要素の「自然順序付け」に従って、指定されたリストを昇順にソートします。リストのすべての要素は、Comparable インタフェースを実装している必要があります。さらに、リストのすべての要素は、「相互に比較可能」でなければいけません。つまり、e1.compareTo(e2) はリストの要素が e1 と e2 の場合、ClassCastException をスローすべきではありません。

このソートは固定であることが保証されています。つまり、ソートを実行しても、同等の要素の順序は変わりません。

指定されたリストは変更可能でなければなりませんが、サイズ変更はできなくてもかまいません。

ソートアルゴリズムは修正マージソートです。このソートでは、下位のサブリストでの最高レベルの要素が上位のサブリストでの最低レベルの要素より小さい場合、マージは省略されます。このアルゴリズムは、常に n log(n) のパフォーマンスを提供します。 この実装は、指定されたリストの配列へのダンプ、配列のソート、リストの繰り返し処理を行うことにより、配列の対応する位置から各要素を再設定します。これは、リンクされたリストを適所にソートしようとした場合の n2 log(n) のパフォーマンスになるのを回避します。

パラメータ:
list - ソートされるリスト
例外:
ClassCastException - リストに「相互に比較可能」でない要素 (たとえば、文字列と整数) がある場合
UnsupportedOperationException - 指定されたリストのリスト反復子が set オペレーションをサポートしない場合
関連項目:
Comparable

sort

public static <T> void sort(List<T> list,
                            Comparator<? super T> c)
指定されたコンパレータが示す順序に従って、指定されたリストをソートします。リストのすべての要素は、指定されたコンパレータによって「相互に比較可能」でなければいけません。 つまり、c.compare(e1, e2) はリストの要素が e1 と e2 の場合 ClassCastException をスローすべきではありません。

このソートは固定であることが保証されています。つまり、ソートを実行しても、同等の要素の順序は変わりません。

ソートアルゴリズムは修正マージソートです。このソートでは、下位のサブリストでの最高レベルの要素が上位のサブリストでの最低レベルの要素より小さい場合、マージは省略されます。このアルゴリズムは、常に n log(n) のパフォーマンスを提供します。 指定されたリストは変更可能でなければなりませんが、サイズ変更はできなくてもかまいません。この実装は、指定されたリストの配列へのダンプ、配列のソート、リストの繰り返し処理を行うことにより、配列の対応する位置から各要素を再設定します。これは、リンクされたリストを適所にソートしようとした場合の n2 log(n) のパフォーマンスになるのを回避します。

パラメータ:
list - ソートされるリスト
c - リストの順序を決定するコンパレータ。null 値は、要素の「自然順序付け」を使用することを示す
例外:
ClassCastException - リストに指定されたコンパレータで「相互に比較」できない要素がある場合
UnsupportedOperationException - 指定されたリストのリスト反復子が set オペレーションをサポートしない場合
関連項目:
Comparator

binarySearch

public static <T> int binarySearch(List<? extends Comparable<? super T>> list,
                                   T key)
バイナリサーチアルゴリズムを使用して、指定されたリストから指定されたオブジェクトを検索します。リストは、この呼び出しの前に、sort(List) メソッドを使用して要素の自然順序付けに従って昇順にソートする必要があります。リストがソートされていない場合、結果は定義されません。指定されたオブジェクトと等しい要素がリストに複数ある場合、どれが見つかるかは保証されません。  

「ランダムアクセス」リストの場合、このメソッドは log(n) 時間で動作します (位置を指定したアクセスにほぼ一定の時間が必要)。指定されたリストが RandomAccess インタフェースを実装せず、大きなリストである場合、このメソッドは O(n) リンクトラバーサルと O(log n) 要素比較を実行する反復子ベースのバイナリサーチを行います。

パラメータ:
list - 検索されるリスト
key - 検索されるキー
戻り値:
リストに検索キーがある場合は検索キーのインデックス。検索キーがリストにない場合は (-(挿入ポイント) - 1)。挿入ポイントとは、リストでキーが挿入されるポイントである。つまり、キーより大きな最初の要素のインデックスか、リストのすべての要素が指定されたキーより小さい場合は list.size()。これにより、キーが見つかった場合にだけ戻り値が >= 0 になることが保証される
例外:
ClassCastException - リストに「相互に比較可能」でない要素 (たとえば、文字列と整数) がある場合、または検索キーがリストの要素と相互に比較可能でない場合

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 - リストに指定されたコンパレータで「相互に比較可能」でない要素がある場合、または検索キーがこのコンパレータを使ってリストの要素と相互に比較できない場合

reverse

public static void reverse(List<?> list)
指定されたリストの要素の順序を逆にします。

このメソッドは一次時間で動作します。

パラメータ:
list - 要素の順序が逆にされるリスト
例外:
UnsupportedOperationException - 指定されたリストまたはそのリスト反復子が set オペレーションをサポートしない場合

shuffle

public static void shuffle(List<?> list)
デフォルトの乱数発生の元を使用して、指定されたリストの順序を無作為に入れ替えます。あらゆる組み合わせが、ほぼ均等な確率で発生します。

上記の説明で「ほぼ」という言葉を使用しているのは、乱数発生の元となるデフォルトのソースが、独立して選択されたビットのソースとして偏りがないのは近似的にのみ成立するからです。ランダムに選択された完全なソースであれば、アルゴリズムが組み合わせを選択する確率は、完全に一様になります。

この実装は、リストの最後の要素から 2 番目の要素まで逆方向にトラバースし、無作為に選択された要素を「現在の位置」に繰り返し入れ替えます。要素は、リストの最初の要素から現在の位置までの範囲で無作為に選択されます。

このメソッドは一次時間で動作します。指定されたリストが RandomAccess インタフェースを実装しない、大きなリストである場合、リストの順序を入れ替える前に、この実装は指定されたリストを配列へダンプして、次に入れ替えた配列をリストにダンプして戻します。適切に「順次アクセス」リストの順序を入れ替えることによって起こる 2 次動作を避けるためです。

パラメータ:
list - 順序が入れ替えられるリスト
例外:
UnsupportedOperationException - 指定されたリストまたはそのリスト反復子が set オペレーションをサポートしない場合

shuffle

public static void shuffle(List<?> list,
                           Random rnd)
デフォルトの乱数発生の元を使用して、指定されたリストの順序を無作為に入れ替えます。乱数発生の元が一様であれば、すべての組み合わせは公平な確率で発生します。

この実装は、リストの最後の要素から 2 番目の要素まで逆方向にトラバースし、無作為に選択された要素を「現在の位置」に繰り返し入れ替えます。要素は、リストの最初の要素から現在の位置までの範囲で無作為に選択されます。

このメソッドは一次時間で動作します。指定されたリストが RandomAccess インタフェースを実装しない、大きなリストである場合、リストの順序を入れ替える前に、この実装は指定されたリストを配列へダンプして、次に入れ替えた配列をリストにダンプして戻します。適切に「順次アクセス」リストの順序を入れ替えることによって起こる 2 次動作を避けるためです。

パラメータ:
list - 順序が入れ替えられるリスト
rnd - リストの順序を入れ替えるために使う乱数発生の元
例外:
UnsupportedOperationException - 指定されたリストまたはそのリスト反復子が set オペレーションをサポートしない場合

swap

public static void swap(List<?> list,
                        int i,
                        int j)
指定されたリストの指定された位置にある要素をスワップします。指定された位置が同じである場合、このメソッドを呼び出しても、リストは変更されません。

パラメータ:
list - 要素をスワップするリスト
i - スワップされる 1 つの要素のインデックス
j - スワップされるもう 1 つの要素のインデックス
例外:
IndexOutOfBoundsException - i または j のいずれかが範囲外の場合 (i < 0 || i >= list.size() || j < 0 || j >= list.size())
導入されたバージョン:
1.4

fill

public static <T> void fill(List<? super T> list,
                            T obj)
指定されたリストのすべての要素を指定された要素で置き換えます。

このメソッドは一次時間で動作します。

パラメータ:
list - 指定された要素が挿入されるリスト
obj - 指定されたリストに挿入される要素
例外:
UnsupportedOperationException - 指定されたリストまたはそのリスト反復子が set オペレーションをサポートしない場合

copy

public static <T> void copy(List<? super T> dest,
                            List<? extends T> src)
あるリストから別のリストにすべての要素をコピーします。このオペレーションのあと、コピー先のリストにコピーされた各要素のインデックスは、コピー元のリストのインデックスと同じになります。コピー先のリストは、少なくともコピー元のリストと同じ長さでなければいけません。コピー先のリストが長い場合でも、コピー先のリストの残りの要素は影響を受けません。

このメソッドは一次時間で動作します。

パラメータ:
dest - コピー先のリスト
src - コピー元のリスト
例外:
IndexOutOfBoundsException - コピー先のリストがコピー元のリスト全体を格納するには小さすぎる場合
UnsupportedOperationException - コピーリストのリスト反復子が set オペレーションをサポートしない場合

min

public static <T extends Object & Comparable<? super T>> T min(Collection<? extends T> coll)
要素の「自然順序付け」に従って、指定されたコレクションの最小の要素を返します。コレクションのすべての要素は、Comparable インタフェースを実装している必要があります。さらに、コレクションのすべての要素は、「相互に比較可能」でなければいけません。 つまり、e1.compareTo(e2) は、コレクションの要素が e1 と e2 の場合 ClassCastException をスローすべきではありません。

このメソッドはコレクション全体で繰り返し処理を行うので、コレクションのサイズに比例した時間が必要です。

パラメータ:
coll - 最小の要素を決めるコレクション
戻り値:
要素の「自然順序付け」に従った、指定されたコレクションの最小の要素
例外:
ClassCastException - コレクションに「相互に比較可能」でない要素 (たとえば、文字列と整数) がある場合
NoSuchElementException - コレクションが空の場合
関連項目:
Comparable

min

public static <T> T min(Collection<? extends T> coll,
                        Comparator<? super T> comp)
指定されたコンパレータが示す順序に従って、指定されたコレクションの最小の要素を返します。コレクションのすべての要素は、指定されたコンパレータで「相互に比較可能」でなければいけません。 つまり、comp.compare(e1, e2) はコレクションの要素が e1 と e2 の場合 ClassCastException をスローすべきではありません。

このメソッドはコレクション全体で繰り返し処理を行うので、コレクションのサイズに比例した時間が必要です。

パラメータ:
coll - 最小の要素を決めるコレクション
comp - 最小の要素リストが決定されるコンパレータ。null 値は、要素の「自然順序付け」を使用することを示す
戻り値:
指定されたコンパレータに従った、指定されたコレクションの最小の要素
例外:
ClassCastException - コレクションに指定されたコンパレータで「相互に比較」できない要素がある場合
NoSuchElementException - コレクションが空の場合
関連項目:
Comparable

max

public static <T extends Object & Comparable<? super T>> T max(Collection<? extends T> coll)
要素の「自然順序付け」に従って、指定されたコレクションの最大の要素を返します。コレクションのすべての要素は、Comparable インタフェースを実装している必要があります。さらに、コレクションのすべての要素は、「相互に比較可能」でなければいけません。 つまり、e1.compareTo(e2) は、コレクションの要素が e1 と e2 の場合 ClassCastException をスローすべきではありません。

このメソッドはコレクション全体で繰り返し処理を行うので、コレクションのサイズに比例した時間が必要です。

パラメータ:
coll - 最大の要素を決めるコレクション
戻り値:
要素の「自然順序付け」に従った、指定されたコレクションの最大の要素
例外:
ClassCastException - コレクションに「相互に比較可能」でない要素 (たとえば、文字列と整数) がある場合
NoSuchElementException - コレクションが空の場合
関連項目:
Comparable

max

public static <T> T max(Collection<? extends T> coll,
                        Comparator<? super T> comp)
指定されたコンパレータが示す順序に従って、指定されたコレクションの最大の要素を返します。コレクションのすべての要素は、指定されたコンパレータで「相互に比較可能」でなければいけません。 つまり、comp.compare(e1, e2) はコレクションの要素が e1 と e2 の場合 ClassCastException をスローすべきではありません。

このメソッドはコレクション全体で繰り返し処理を行うので、コレクションのサイズに比例した時間が必要です。

パラメータ:
coll - 最大の要素を決めるコレクション
comp - 最大の要素リストを決定するコンパレータ。null 値は、要素の「自然順序付け」を使用することを示す
戻り値:
指定されたコンパレータに従った、指定されたコレクションの最大の要素
例外:
ClassCastException - コレクションに指定されたコンパレータで「相互に比較」できない要素がある場合
NoSuchElementException - コレクションが空の場合
関連項目:
Comparable

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] が含まれます。  

このメソッドをサブリストに有効に適用して、残りの要素の順序を保存しながら、リスト内の 1 つまたは複数の要素を移動することができます。たとえば、次の慣用法は、インデックス j にある要素を位置 k に移動します (k は j はより大きいか、等値である必要があります)。  

     Collections.rotate(list.subList(j, k+1), -1);
これを固定するために、list に [a, b, c, d, e] が含まれると仮定します。インデックス 1 (b) にある要素を 2 つの位置に進めるためには、次の呼び出しを実行します。  
     Collections.rotate(l.subList(1, 4), -1);
その結果として得られるリストは [a, c, d, b, e] になります。  

複数の要素を進めるためには、回転距離の絶対値を増加させます。後ろに移動させるには、正のシフト移動量を使用します。  

指定された値が小さいリストであるか、RandomAccess インタフェースを実装している場合、この実装は第 1 の要素を移動すべき位置に交換します。 次に、置き換えられた要素が最初の要素にスワップされるまで、置き換えられた要素を移動すべき位置に繰り返し交換します。必要に応じて、回転が完了するまで、第 2 要素および連続する要素についてこのプロセスが繰り返されます。指定されたリストが大きく、RandomAccess インタフェースを実装していない場合、この実装は、インデックス -distance mod size の 2 つのサブリストビューにリストを分割します。次に、reverse(List) メソッドは、それぞれのサブリストビューで呼び出され、最終的にはリスト全体で呼び出されます。2 つのアルゴリズムの詳細については、Jon Bentley の『Programming Pearls』(Addison-Wesley, 1986) のセクション 2.3 を参照してください。

パラメータ:
list - 回転されるリスト
distance - リストを回転する距離。この値に制約はなく、値は 0 でも、負でも、list.size() より大きくてもかまわない
例外:
UnsupportedOperationException - 指定されたリストまたはそのリスト反復子が set オペレーションをサポートしない場合
導入されたバージョン:
1.4

replaceAll

public static <T> boolean replaceAll(List<T> list,
                                     T oldVal,
                                     T newVal)
リスト内に出現する指定された値をすべてほかの値に置き換えます。つまり、list 内で (oldVal==null ? e==null : oldVal.equals(e)) となる各要素 e を newVal に置き換えます。このメソッドはリストのサイズには影響を及ぼしません。

パラメータ:
list - 置換が生じるリスト
oldVal - 置換前の値
newVal - oldVal の置換後の値
戻り値:
list が、(oldVal==null ? e==null : oldVal.equals(e)) となる 1 つまたは複数の要素 e を含む場合は true
例外:
UnsupportedOperationException - 指定されたリストまたはそのリスト反復子が set オペレーションをサポートしない場合
導入されたバージョン:
1.4

indexOfSubList

public static int indexOfSubList(List<?> source,
                                 List<?> target)
指定されたソースリスト内で、指定されたターゲットリストが最初に出現した位置の開始位置を返します。 こうした出現がない場合は -1 を返します。つまり、source.subList(i, i+target.size()).equals(target) となる最小のインデックス値 i を返し、こうしたインデックス値がない場合は -1 を返します(target.size() > source.size() の場合は -1 を返す)。  

この実装は、ソースリストをスキャニングする「強引な」技術を使用して、ソースリストの各位置でターゲットと一致するか順番に検索します。

パラメータ:
source - 最初に出現する target を検索するリスト
target - source のsubList として検索するリスト
戻り値:
指定されたソースリスト内で、最初に出現した指定ターゲットリストの開始位置。こうした出現がない場合は、-1
導入されたバージョン:
1.4

lastIndexOfSubList

public static int lastIndexOfSubList(List<?> source,
                                     List<?> target)
指定されたソースリスト内で、最後に出現した指定ターゲットリストの開始位置を返します。 こうした出現がない場合は -1 を返します。つまり、source.subList(i, i+target.size()).equals(target) となる最大のインデックス値 i を返し、こうしたインデックス値がない場合は -1 を返します(target.size() > source.size() の場合は -1 を返す)。  

この実装では、ソースリストの繰り返し処理を行う「強引な」技術を使用して、各位置でターゲットと一致するか順番に検索します。

パラメータ:
source - 最後に出現する target を検索するリスト
target - source のsubList として検索するリスト
戻り値:
指定されたソースリスト内で、最後に出現した指定ターゲットリストの開始位置。こうした出現がない場合は、-1
導入されたバージョン:
1.4

unmodifiableCollection

public static <T> Collection<T> unmodifiableCollection(Collection<? extends T> c)
指定されたコレクションの変更不可能なビューを返します。このメソッドを使うと、モジュールはユーザーに内部コレクションへの「読み取り専用」アクセス権を提供できます。返されたコレクションでのクエリーオペレーションは、指定されたコレクションを直接読み込みます。 直接かその反復子を使うかに関係なく、返されたコレクションを変更しようとすると UnsupportedOperationException がスローされます。

返されたコレクションは、hashCode オペレーションおよび equals オペレーションを基となるコレクションに渡すことはなく、Object の equals メソッドおよび hashCode メソッドに依存します。これは、基となるコレクションがセットまたはリストの場合にそれらのオペレーションの規約を守るために必要です。

返されたコレクションは、指定されたコレクションが直列化可能の場合は直列化可能です。

パラメータ:
c - 変更不可能なビューが返されるコレクション
戻り値:
指定されたコレクションの変更不可能なビュー

unmodifiableSet

public static <T> Set<T> unmodifiableSet(Set<? extends T> s)
指定されたセットの変更不可能なビューを返します。このメソッドを使うと、モジュールはユーザーに内部セットへの「読み取り専用」アクセス権を提供できます。返されたセットでのクエリーオペレーションは、指定されたセットを直接読み込み、直接かその反復子を使うかに関係なく、返されたセットを変更しようとすると UnsupportedOperationException がスローされます。

返されるセットは、指定されたセットが直列化可能の場合に直列化可能になります。

パラメータ:
s - 変更不可能なビューが返されるセット
戻り値:
指定されたセットの変更不可能なビュー

unmodifiableSortedSet

public static <T> SortedSet<T> unmodifiableSortedSet(SortedSet<T> s)
指定されたソートセットの変更不可能なビューを返します。このメソッドを使うと、モジュールはユーザーに内部ソートセットへの「読み取り専用」アクセス権を提供できます。返されたソートセットでのクエリーオペレーションは、指定されたソートセットを直接読み込みます。直接か、その反復子を使うか、あるいはビューの subSet、headSet、tailSet を使うかに関係なく、ソートセットを変更しようとすると UnsupportedOperationException がスローされます。

返されたソートセットは、指定されたソートセットが直列化可能の場合は直列化可能です。

パラメータ:
s - 変更不可能なビューが返されるソートセット
戻り値:
指定されたソートセットの変更不可能なビュー

unmodifiableList

public static <T> List<T> unmodifiableList(List<? extends T> list)
指定されたリストの変更不可能なビューを返します。このメソッドを使うと、モジュールはユーザーに内部リストへの「読み取り専用」アクセス権を提供できます。返されたリストでのクエリーオペレーションは、指定されたリストを直接読み込みます。 直接か、その反復子を使うかに関係なく、返されたリストを変更しようとすると UnsupportedOperationException がスローされます。

返されたリストは、指定されたリストが直列化可能の場合にだけ直列化可能になります。また、指定されたリストが RandomAccess を実装する場合にだけ、返されたリストは RandomAccess を実装します。

パラメータ:
list - 変更不可能なビューが返されるリスト
戻り値:
指定されたリストの変更不可能なビュー

unmodifiableMap

public static <K,V> Map<K,V> unmodifiableMap(Map<? extends K,? extends V> m)
指定されたマップの変更不可能なビューを返します。このメソッドを使うと、モジュールはユーザーに内部マップへの「読み取り専用」アクセス権を提供できます。返されたマップでのクエリーオペレーションは、指定されたマップを直接読み込みます。 直接か、そのコレクションビューを使うかに関係なく、返されたマップを変更しようとすると UnsupportedOperationException がスローされます。

返されたマップは、指定されたマップが直列化可能の場合は直列化可能です。

パラメータ:
m - 変更不可能なビューが返されるマップ
戻り値:
指定されたマップの変更不可能なビュー

unmodifiableSortedMap

public static <K,V> SortedMap<K,V> unmodifiableSortedMap(SortedMap<K,? extends V> m)
指定されたソートマップの変更不可能なビューを返します。このメソッドを使うと、モジュールはユーザーに内部ソートマップへの「読み取り専用」アクセス権を提供できます。返されたソートマップでのクエリーオペレーションは、指定されたソートマップを直接読み込みます。直接か、そのコレクションビューを使うか、またはビュー subMap、headMap、tailMap を使うかに関係なく、返されたソートマップを変更しようとすると UnsupportedOperationException がスローされます。

返されたソートマップは、指定されたソートマップが直列化可能の場合は直列化可能です。

パラメータ:
m - 変更不可能なビューが返されるソートマップ
戻り値:
指定されたソートマップの変更不可能なビュー

synchronizedCollection

public static <T> Collection<T> synchronizedCollection(Collection<T> c)
指定されたコレクションに連動する同期 (スレッドセーフな) コレクションを返します。確実に直列アクセスを実現するには、基となるコレクションへのアクセスはすべて返されたコレクションを介して行う必要があります。

返されたコレクションの繰り返し処理を行う場合、ユーザは、次に示すように手動で同期をとる必要があります。  

  Collection c = Collections.synchronizedCollection(myCollection);
     ...
  synchronized(c) {
      Iterator i = c.iterator(); // Must be in the synchronized block
      while (i.hasNext())
         foo(i.next());
  }
これを行わない場合、動作は保証されません。  

返されたコレクションは、hashCode オペレーションおよび equals オペレーションを基となるコレクションに渡すことはなく、Object の equals および hashCode メソッドに依存します。これは、基となるコレクションがセットまたはリストの場合にそれらのオペレーションの規約を守るために必要です。

返されたコレクションは、指定されたコレクションが直列化可能の場合は直列化可能です。

パラメータ:
c - 同期コレクションに「ラップ」されるコレクション
戻り値:
指定されたコレクションの同期ビュー

synchronizedSet

public static <T> Set<T> synchronizedSet(Set<T> s)
指定されたセットに連動する同期 (スレッドセーフな) セットを返します。確実に直列アクセスを実現するには、基となるセットへのアクセスはすべて返されたセットを介して行う必要があります。

返されたセットの繰り返し処理を行う場合、ユーザは、次に示すように手動で同期をとる必要があります。  

  Set s = Collections.synchronizedSet(new HashSet());
      ...
  synchronized(s) {
      Iterator i = s.iterator(); // Must be in the synchronized block
      while (i.hasNext())
          foo(i.next());
  }
これを行わない場合、動作は保証されません。  

返されるセットは、指定されたセットが直列化可能の場合に直列化可能になります。

パラメータ:
s - 同期セットに「ラップ」されるセット
戻り値:
指定されたセットの同期ビュー

synchronizedSortedSet

public static <T> SortedSet<T> synchronizedSortedSet(SortedSet<T> s)
指定されたソートセットに連動する同期 (スレッドセーフな) ソートセットを返します。確実に直列アクセスを実現するには、基となるソートセットへのアクセスはすべて、返されたソートセット (またはそのビュー) を介して行う必要があります。

返されたソートセット、またはその subSet、headSet、あるいは tailSet ビューの繰り返し処理を行う場合、ユーザは、次に示すように手動で同期をとる必要があります。  

  SortedSet s = Collections.synchronizedSortedSet(new TreeSet());
      ...
  synchronized(s) {
      Iterator i = s.iterator(); // Must be in the synchronized block
      while (i.hasNext())
          foo(i.next());
  }
または  
  SortedSet s = Collections.synchronizedSortedSet(new TreeSet());
  SortedSet s2 = s.headSet(foo);
      ...
  synchronized(s) {  // Note: s, not s2!!!
      Iterator i = s2.iterator(); // Must be in the synchronized block
      while (i.hasNext())
          foo(i.next());
  }
これを行わない場合、動作は保証されません。  

返されたソートセットは、指定されたソートセットが直列化可能の場合は直列化可能です。

パラメータ:
s - 同期ソートセットに「ラップ」されるソートセット
戻り値:
指定されたソートセットの同期ビュー

synchronizedList

public static <T> List<T> synchronizedList(List<T> list)
指定されたリストに連動する同期 (スレッドセーフな) リストを返します。確実に直列アクセスを実現するには、基になるリストへのアクセスはすべて、返されたリストを介して行う必要があります。

返されたリストの繰り返し処理を行う場合、ユーザは、次に示すように手動で同期をとる必要があります。  

  List list = Collections.synchronizedList(new ArrayList());
      ...
  synchronized(list) {
      Iterator i = list.iterator(); // Must be in synchronized block
      while (i.hasNext())
          foo(i.next());
  }
これを行わない場合、動作は保証されません。  

返されたリストは、指定されたリストが直列化可能の場合にだけ直列化可能になります。

パラメータ:
list - 同期リストに「ラップ」されるリスト
戻り値:
指定されたリストの同期ビュー

synchronizedMap

public static <K,V> Map<K,V> synchronizedMap(Map<K,V> m)
指定されたマップに連動する同期 (スレッドセーフな) マップを返します。確実に直列アクセスを実現するには、基になるマップへのアクセスはすべて、返されたマップを介して行う必要があります。

返されたマップのコレクションビューでの繰り返し処理を行う場合、ユーザは、次に示すように手動で同期をとる必要があります。  

  Map m = Collections.synchronizedMap(new HashMap());
      ...
  Set s = m.keySet();  // Needn't be in synchronized block
      ...
  synchronized(m) {  // Synchronizing on m, not s!
      Iterator i = s.iterator(); // Must be in synchronized block
      while (i.hasNext())
          foo(i.next());
  }
これを行わない場合、動作は保証されません。  

返されたマップは、指定されたマップが直列化可能の場合は直列化可能です。

パラメータ:
m - 同期マップに「ラップ」されるマップ
戻り値:
指定されたマップの同期ビュー

synchronizedSortedMap

public static <K,V> SortedMap<K,V> synchronizedSortedMap(SortedMap<K,V> m)
指定されたソートマップに連動する同期 (スレッドセーフな) ソートマップを返します。確実に直列アクセスを実現するには、基になるソートマップへのアクセスはすべて、返されたソートマップ (またはそのビュー) を介して行う必要があります。

返されたソートマップのコレクションビュー、または subMap、headMap、tailMap ビューのコレクションビューでの繰り返し処理を行う場合、ユーザは、次に示すように手動で同期をとる必要があります。  

  SortedMap m = Collections.synchronizedSortedMap(new TreeMap());
      ...
  Set s = m.keySet();  // Needn't be in synchronized block
      ...
  synchronized(m) {  // Synchronizing on m, not s!
      Iterator i = s.iterator(); // Must be in synchronized block
      while (i.hasNext())
          foo(i.next());
  }
または  
  SortedMap m = Collections.synchronizedSortedMap(new TreeMap());
  SortedMap m2 = m.subMap(foo, bar);
      ...
  Set s2 = m2.keySet();  // Needn't be in synchronized block
      ...
  synchronized(m) {  // Synchronizing on m, not m2 or s2!
      Iterator i = s.iterator(); // Must be in synchronized block
      while (i.hasNext())
          foo(i.next());
  }
これを行わない場合、動作は保証されません。  

返されたソートマップは、指定されたソートマップが直列化可能の場合は直列化可能です。

パラメータ:
m - 同期ソートマップに「ラップ」されるソートマップ
戻り値:
指定されたソートマップの同期ビュー

checkedCollection

public static <E> Collection<E> checkedCollection(Collection<E> c,
                                                  Class<E> type)
指定されたコレクションの、動的に型保証されたビューを返します。不正な型の要素を挿入しようとすると、すぐに ClassCastException がスローされます。動的に型保証されたビューが生成される前はコレクションに不正な型の要素が含まれず、後続のコレクションへのアクセスがすべてこのビューを介して行われる場合、コレクションには不正な型の要素が含まれないことが保証されます。  

言語内の総称メカニズムによりコンパイル時 (静的) の型チェックが提供されますが、チェックされないキャストを使用してこのメカニズムを無効にすることはできません。通常、この種のチェックされない操作すべてでコンパイラが警告を発行するため、これは問題にはなりません。ただし、時として、静的な型チェックだけでは不十分な場合があります。たとえば、コレクションがサードパーティーのライブラリに渡されるが、ライブラリコードが不正な型の要素を挿入してコレクションを破壊してしまうことがあってはならない場合などです。  

動的に型保証されたビューの別の用途は、デバッグです。プログラムが ClassCastException で失敗し、不正な型の要素がパラメータ化されたコレクションに入れられたことを示す場合を考えましょう。残念なことに、不正な要素が挿入されるとこの例外が常に発生する可能性があるため、この例外から問題のソースに関する情報をほとんどまたはまったく得ることができません。問題が再現可能な場合は、プログラムを変更して動的な型保証されたビューでコレクションを一時的にラップすることで、ソースをすばやく判定できます。たとえば、宣言  

     Collection<String> c = new HashSet<String>();
は、次の宣言で一時的に置き換えることができます。  
     Collection<String> c = Collections.checkedCollection(
         new HashSet<String>(), String.class);
プログラムを再度実行すると、不正な型の要素がコレクションに挿入された位置でプログラムが失敗するため、問題の原因をはっきりと識別できます。問題を修正したら、変更した宣言を元に戻します。  

返されたコレクションは、hashCode オペレーションおよび equals オペレーションを基となるコレクションに渡すことはなく、Object の equals メソッドおよび hashCode メソッドに依存します。これは、基となるコレクションがセットまたはリストの場合にそれらのオペレーションの規約を守るために必要です。  

返されたコレクションは、指定されたコレクションが直列化可能の場合は直列化可能です。

パラメータ:
c - 動的に型保証されたビューが返されるコレクション
type - c が保持することを許された要素の型
戻り値:
指定されたコレクションの、動的に型保証されたビュー
導入されたバージョン:
1.5

checkedSet

public static <E> Set<E> checkedSet(Set<E> s,
                                    Class<E> type)
指定されたセットの動的に型保証されたビューを返します。不正な型の要素を挿入しようとすると、すぐに ClassCastException がスローされます。動的に型保証されたビューが生成される前はセットに不正な型の要素が含まれず、セットへの後続のアクセスがすべてこのビューを介して行われる場合、セットには不正な型の要素が含まれないことが保証されます。  

動的に型保証されたビューの使用については、checkedCollection メソッドのドキュメントを参照してください。  

返されるセットは、指定されたセットが直列化可能の場合に直列化可能になります。

パラメータ:
s - 動的に型保証されたビューが返されるセット
type - s が保持することを許された要素の型
戻り値:
指定されたセットの動的に型保証されたビュー
導入されたバージョン:
1.5

checkedSortedSet

public static <E> SortedSet<E> checkedSortedSet(SortedSet<E> s,
                                                Class<E> type)
指定されたソートセットの動的に型保証されたビューを返します。不正な型の要素を挿入しようとすると、すぐに ClassCastException がスローされます。動的に型保証されたビューが生成される前はソートセットに不正な型の要素が含まれず、ソートセットへの後続のアクセスがすべてこのビューを介して行われる場合、ソートセットには不正な型の要素が含まれないことが保証されます。  

動的に型保証されたビューの使用については、checkedCollection メソッドのドキュメントを参照してください。  

返されたソートセットは、指定されたソートセットが直列化可能の場合は直列化可能です。

パラメータ:
s - 動的に型保証されたビューが返されるソートセット
type - s が保持することを許された要素の型
戻り値:
指定されたソートセットの動的に型保証されたビュー
導入されたバージョン:
1.5

checkedList

public static <E> List<E> checkedList(List<E> list,
                                      Class<E> type)
指定されたリストの動的に型保証されたビューを返します。不正な型の要素を挿入しようとすると、すぐに ClassCastException がスローされます。動的に型保証されたビューが生成される前はリストに不正な型の要素が含まれず、後続のリストへのアクセスがすべてこのビューを介して行われる場合、リストには不正な型の要素が含まれないことが保証されます。  

動的に型保証されたビューの使用については、checkedCollection メソッドのドキュメントを参照してください。  

返されたリストは、指定されたリストが直列化可能の場合にだけ直列化可能になります。

パラメータ:
list - 動的に型保証されたビューが返されるリスト
type - list が保持することを許された要素の型
戻り値:
指定されたリストの動的に型保証されたビュー
導入されたバージョン:
1.5

checkedMap

public static <K,V> Map<K,V> checkedMap(Map<K,V> m,
                                        Class<K> keyType,
                                        Class<V> valueType)
指定されたマップの動的に型保証されたビューを返します。キーまたは値が不正な型を保持するマッピングを挿入しようとすると、すぐに ClassCastException がスローされます。同様に、キーに現在関連付けられている値を変更しようとすると、変更がマップ自体を介して試みられるか、マップのエントリセットビューから取得された Map.Entry インスタンスを介して試みられるかにかかわらず、すぐに ClassCastException がスローされます。  

動的に型保証されたビューが生成される前に、不正な型のキーまたは値がマップに含まれず、マップへの後続のアクセスがすべてビュー (またはコレクションビューの 1 つ) を介して行われる場合、マップに不正な型のキーや値が含まれないことが保証されます。  

動的に型保証されたビューの使用については、checkedCollection メソッドのドキュメントを参照してください。  

返されたマップは、指定されたマップが直列化可能の場合は直列化可能です。

パラメータ:
m - 動的に型保証されたビューが返されるマップ
keyType - m が保持することを許されたキーの型
valueType - m が保持することを許された値の型
戻り値:
指定されたマップの動的に型保証されたビュー
導入されたバージョン:
1.5

checkedSortedMap

public static <K,V> SortedMap<K,V> checkedSortedMap(SortedMap<K,V> m,
                                                    Class<K> keyType,
                                                    Class<V> valueType)
指定されたソートマップの動的に型保証されたビューを返します。キーまたは値が不正な型を保持するマッピングを挿入しようとすると、すぐに ClassCastException がスローされます。同様に、キーに現在関連付けられている値を変更しようとすると、変更がマップ自体を介して試みられるか、マップのエントリセットビューから取得された Map.Entry インスタンスを介して試みられるかにかかわらず、すぐに ClassCastException がスローされます。  

動的に型保証されたビューが生成される前に、不正な型のキーまたは値がマップに含まれず、マップへの後続のアクセスがすべてビュー (またはコレクションビューの 1 つ) を介して行われる場合、マップに不正な型のキーや値が含まれないことが保証されます。  

動的に型保証されたビューの使用については、checkedCollection メソッドのドキュメントを参照してください。  

返されたマップは、指定されたマップが直列化可能の場合は直列化可能です。

パラメータ:
m - 動的に型保証されたビューが返されるマップ
keyType - m が保持することを許されたキーの型
valueType - m が保持することを許された値の型
戻り値:
指定されたマップの動的に型保証されたビュー
導入されたバージョン:
1.5

emptySet

public static final <T> Set<T> emptySet()
空のセット (不変) を返します。このセットは直列化が可能です。同様の名前が付けられたフィールドとは異なり、このメソッドはパラメータ化されます。  

次に、空のセットを取得するための型保証された方法の例を示します。  

     Set<String> s = Collections.emptySet();
実装にあたっての注意:このメソッドの実装では、呼び出しごとに個別の Set オブジェクトを作成する必要はありません。このメソッドは同様の名前が付けられたフィールドを使用した比較可能なコストがあるようなものです(このメソッドとは異なり、フィールドは型保証しない)。

導入されたバージョン:
1.5
関連項目:
EMPTY_SET

emptyList

public static final <T> List<T> emptyList()
空のリストを返します (不変)。このリストは直列化可能です。  

次に、空のリストを取得するための型保証された方法の例を示します。  

     List<String> s = Collections.emptyList();
実装にあたっての注意:このメソッドの実装では、各呼び出しごとに個別の List オブジェクトを作成する必要はありません。このメソッドは同様の名前が付けられたフィールドを使用した比較可能なコストがあるようなものです(このメソッドとは異なり、フィールドは型保証しない)。

導入されたバージョン:
1.5
関連項目:
EMPTY_LIST

emptyMap

public static final <K,V> Map<K,V> emptyMap()
空のマップを返します (不変)。このマップは直列化可能です。  

次に、空のセットを取得するための型保証された方法の例を示します。  

     Map<String, Date> s = Collections.emptyMap();
実装にあたっての注意:このメソッドの実装では、各呼び出しごとに個別の Map オブジェクトを作成する必要はありません。このメソッドは同様の名前が付けられたフィールドを使用した比較可能なコストがあるようなものです(このメソッドとは異なり、フィールドは型保証しない)。

導入されたバージョン:
1.5
関連項目:
EMPTY_MAP

singleton

public static <T> Set<T> singleton(T o)
指定されたオブジェクトだけを格納している不変のセットを返します。返されるセットは直列化可能です。

パラメータ:
o - 返されるセットに格納される唯一のオブジェクト
戻り値:
指定されたオブジェクトだけを格納している不変のセット

singletonList

public static <T> List<T> singletonList(T o)
指定されたオブジェクトだけを格納している不変のリストを返します。返されるリストは直列化可能です。

パラメータ:
o - 返されるリストに格納される唯一のオブジェクト
戻り値:
指定されたオブジェクトだけを格納している不変のリスト
導入されたバージョン:
1.3

singletonMap

public static <K,V> Map<K,V> singletonMap(K key,
                                          V value)
指定された値に指定されたキーだけをマッピングする不変のマップを返します。返されるマップは直列化可能です。

パラメータ:
key - 返されるマップに格納される唯一のキー
value - 返されるマップによって key がマッピングされる値
戻り値:
指定したキーと値のマッピングだけが格納される不変のマップ
導入されたバージョン:
1.3

nCopies

public static <T> List<T> nCopies(int n,
                                  T o)
指定されたオブジェクトの n 個のコピーで構成される不変のリストを返します。新しく割り当てられたデータオブジェクトは、データオブジェクトへの 1 つの参照を持つ小さなオブジェクトです。このメソッドは、List.addAll メソッドとともにリストを拡張するために使われます。返されるリストは直列化可能です。

パラメータ:
n - 返されるリストの要素数
o - 返されるリストに繰り返し現れる要素
戻り値:
指定されたオブジェクトの n 個のコピーで構成される不変のリスト
例外:
IllegalArgumentException - n < 0 の場合
関連項目:
List.addAll(Collection), List.addAll(int, Collection)

reverseOrder

public static <T> Comparator<T> reverseOrder()
Comparable インタフェースを実装するオブジェクトのコレクションで「自然順序付け」の逆を義務付けるコンパレータを返します。自然順序付けとは、オブジェクト自身の compareTo メソッドが示す順序のことです。これにより、Comparable インタフェースを実装するオブジェクトのコレクション (または配列) を簡単に逆自然順序でソート (または保守) できます。たとえば、a が文字列の配列であると仮定します。 
                Arrays.sort(a, Collections.reverseOrder());
逆引きの辞書編集順 (アルファベット順) で配列をソートします。

返されるコンパレータは直列化可能です。

戻り値:
Comparable インタフェースを実装するオブジェクトのコレクションで逆の自然順序を義務付けるコンパレータ
関連項目:
Comparable

reverseOrder

public static <T> Comparator<T> reverseOrder(Comparator<T> cmp)
指定されたコンパレータの逆順を義務付けるコンパレータを返します。指定されたコンパレータが null の場合、このメソッドは reverseOrder() と等価になります (つまり、Comparable インタフェースを実装するオブジェクトのコレクションに逆の「自然順序」を義務付けるコンパレータを返す)。  

返されるコンパレータは直列化可能です (指定されたコンパレータも直列化可能であるか null の場合)。

戻り値:
指定されたコンパレータの逆順を義務付けるコンパレータ
導入されたバージョン:
1.5

enumeration

public static <T> Enumeration<T> enumeration(Collection<T> c)
指定されたコレクションの列挙を返します。コレクションは、列挙を必要とする従来の API との相互運用性を提供します。

パラメータ:
c - 列挙が返されるコレクション
戻り値:
指定されたコレクションの列挙
関連項目:
Enumeration

list

public static <T> ArrayList<T> list(Enumeration<T> e)
指定された列挙により返された要素を含む配列リストを、返された順番で返します。このメソッドでは、列挙を返す従来の API と、コレクションを必要とする新規 API との相互運用性を実現しています。

パラメータ:
e - 返される配列リストの要素を提供する列挙
戻り値:
指定された列挙により返される要素を含む配列リスト
導入されたバージョン:
1.4
関連項目:
Enumeration, ArrayList

frequency

public static int frequency(Collection<?> c,
                            Object o)
指定されたコレクション内で、指定されたオブジェクトと等価な要素の数を返します。つまり、コレクション内で (o == null ? e == null :o.equals(e)) である要素 e の数を返します。

パラメータ:
c - o の頻度を判定するコレクション
o - 頻度を判定するオブジェクト
例外:
NullPointerException - c が null の場合
導入されたバージョン:
1.5

disjoint

public static boolean disjoint(Collection<?> c1,
                               Collection<?> c2)
指定された 2 つのコレクションに共通の要素が存在しない場合、true を返します。  

Collection の汎用規約に準拠しないコレクションに対してこのメソッドを使用する場合は、注意が必要です。実装が、一方のコレクションに対して処理を繰り返し実行し、他方のコレクション内に含まれるかどうかをテストする (または等価な計算を実行する) 場合があります。一方のコレクションが非標準の等価テストを使用する場合 (順序が等価との互換性を持たない SortedSet や、IdentityHashMap のキーセットのように) 、両方のコレクションで同じ非標準の等価テストを使用する必要があります。 そうでない場合のこのメソッドの結果は定義されていません。  

両方のパラメータ内で同じコレクションを渡すことは許容されています。 この場合、コレクションが空の場合にのみ、メソッドは true を返します。

パラメータ:
c1 - コレクション
c2 - コレクション
例外:
NullPointerException - どちらかのコレクションが null の場合
導入されたバージョン:
1.5

addAll

public static <T> boolean addAll(Collection<? super T> c,
                                 T... elements)
指定されたすべての要素を指定されたコレクションに追加します。追加される要素は個別に指定されるか配列として指定されます。この便利なメソッドの動作は、c.addAll(Arrays.asList(elements)) と同一ですが、このメソッドは大半の実装で非常に高速に実行されます。  

要素を個別に指定する場合、このメソッドでは、次の例のように、数種類の要素を既存のコレクションに簡単に追加できます。  

     Collections.addAll(flavors, "Peaches 'n Plutonium", "Rocky Racoon");

パラメータ:
c - elements が挿入されるコレクション
elements - c に挿入される要素
戻り値:
この呼び出しの結果、コレクションが変更された場合は true
例外:
UnsupportedOperationException - c が add オペレーションをサポートしない場合
NullPointerException - elements に 1 つ以上の null 要素が含まれており、c が null 要素を許可しない場合、あるいは c または elements が null の場合
IllegalArgumentException - elements の値のあるプロパティーが原因で、c に追加できない場合
導入されたバージョン:
1.5
関連項目:
Collection.addAll(Collection)

newSetFromMap

public static <E> Set<E> newSetFromMap(Map<E,Boolean> map)
指定されたマップに連動するセットを返します。結果として得られるセットには、その連動するマップと同じ順序、並行性、およびパフォーマンス特性が表示されます。このファクトリメソッドは、本質的に、Map 実装に対応する Set 実装を提供します。HashMap や TreeMap など対応する Set 実装がすでにある Map 実装では、このメソッドを使用する必要はありません。  

このメソッドによって返されるセットでのそれぞれのメソッド呼び出しによって、1 つの例外を除き、基になるマップかその keySet ビューでメソッド呼び出しが 1 つだけ発生します。addAll メソッドは、基になるマップの一連の put 呼び出しとして実装されます。  

指定されたマップは、このメソッドが呼び出された時点では空でなければならず、このメソッドの終了後は直接アクセスすることはできません。これらの条件は、次のコードの抜粋に示すように、マップが空の状態で作成され、このメソッドに直接渡され、マップへの参照が保持されない場合に保証されます。  

    Set<Object> weakHashSet = Collections.newSetFromMap(
        new WeakHashMap<Object, Boolean>());

パラメータ:
map - 基になるマップ
戻り値:
マップに連動しているセット
例外:
IllegalArgumentException - map が空でない場合
導入されたバージョン:
1.6

asLifoQueue

public static <T> Queue<T> asLifoQueue(Deque<T> deque)
Deque のビューを後入れ先出し (Lifo) Queue として返します。add メソッドは push にマップされ、remove メソッドは pop にマップされ、以下同様にマップされます。このビューは、Queue が必要なメソッドを使用したいが Lifo 順序付けが必要な場合に有効なことがあります。  

このメソッドによって返されるキューでのそれぞれのメソッド呼び出しによって、1 つの例外を除き、基になる両端キューでメソッド呼び出しが 1 つだけ発生します。addAll メソッドは、基になる両端キューの一連の addFirst 呼び出しとして実行されます。

パラメータ:
deque - 両端キュー
戻り値:
キュー
導入されたバージョン:
1.6
概要  パッケージ   クラス  使用  階層ツリー  非推奨 API  索引  ヘルプ 
JavaTM Platform
Standard Ed. 6
 前のクラス   次のクラス フレームあり    フレームなし    
概要: 入れ子 | フィールド | コンストラクタ | メソッド 詳細: フィールド | コンストラクタ | メソッド
バグの報告と機能のリクエスト
さらに詳しい API リファレンスおよび開発者ドキュメントについては、Java SE 開発者用ドキュメントを参照してください。開発者向けの詳細な解説、概念の概要、用語の定義、バグの回避策、およびコード実例が含まれています。

Copyright 2009 Sun Microsystems, Inc. All rights reserved. Use is subject to license terms. Documentation Redistribution Policy も参照してください。