개요   패키지    클래스  사용   계층 트리   비추천 API   색인   헬프  
JavaTM 2 Platform
Standard Ed. 5.0
 이전 클래스    다음 클래스 프레임으로    프레임 없이    
개요:  NESTED  | 필드 | constructor　 　 | 메서드 상세:  필드 | constructor　 　 | 메서드

java.util
클래스 Collections

java.lang.Object 
  상위를 확장 java.util.Collections

public class Collections
extends Object

이 클래스는 컬렉션에 작용한다, 또는 컬렉션을 돌려주는 static 메서드만으로 구성됩니다. 이 클래스에는 지정된 컬렉션을 기본으로 한 새로운 컬렉션을 돌려주는 「래퍼」 등, 컬렉션에 대해서 작용하는 다양한 알고리즘이 있습니다.

이 클래스의 메서드에 제공되는 컬렉션 또는 클래스 객체가 null인 경우, 이 클래스의 메서드는 NullPointerException을 모두 Throw 합니다.

이 클래스에 있는 다양한 알고리즘의 문서에는 보통, 「구현」의 간단한 설명이 포함되어 있습니다. 이 설명은 「사양」의 일부에서는 없고 「구현 정보」라고 생각해 주세요. 구현자는 사양에 반하지 않는 한, 다른 알고리즘을 자유롭게 사용할 수 있습니다. 예를 들어, sort가 사용하는 알고리즘은 머지 소트일 필요는 없습니다만, 「고정 (stable)」의 알고리즘이 아니면 안됩니다.

컬렉션이 set 메서드와 같이 적절한 변이 원시형 메서드를 지원 하고 있지 않는 경우, 이 클래스 (처리되는 컬렉션을 수정하는 알고리즘)에 포함되어 있던 「파괴적」알고리즘은, UnsupportedOperationException을 Throw 하도록 지정되고 있습니다. 호출이 컬렉션에 영향을 주지 않는 경우, 이러한 알고리즘은 예외를 Throw 하는 경우가 있습니다만, 필수가 아닙니다. 예를 들어 소트 끝난 변경 불가능한 리스트로sort 메서드를 호출하면, UnsupportedOperationException이 발생되는 경우와 Throw 되지 않는 경우가 있습니다.

이 클래스는 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... a)
          지정된 모든 요소가 지정된 컬렉션에 추가합니다.
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
<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)
          디폴트의 random number generation의 원을 사용해, 지정된 리스트의 순서를 무작위로 바꿔 넣습니다.
static void shuffle (List <? > list, Random  rnd)
          디폴트의 random number generation의 원을 사용해, 지정된 리스트의 순서를 무작위로 바꿔 넣습니다.
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)
          지정된 컬렉션을 기본으로 하는 동기 (thread 세이프인) 컬렉션을 리턴합니다.
static
<T> List <T>
synchronizedList (List <T> list)
          지정된 리스트를 기본으로 하는 동기 (thread 세이프인) 리스트를 리턴합니다.
static
<K, V> Map <K, V>
synchronizedMap (Map <K, V> m)
          지정된 맵을 기본으로 하는 동기 (thread 세이프인) 맵을 리턴합니다.
static
<T> Set <T>
synchronizedSet (Set <T> s)
          지정된 세트를 기본으로 하는 동기 (thread 세이프인) 세트를 리턴합니다.
static
<K, V> SortedMap <K, V>
synchronizedSortedMap (SortedMap <K, V> m)
          지정된 소트 맵을 기본으로 하는 동기 (thread 세이프인) 소트 맵을 리턴합니다.
static
<T> SortedSet <T>
synchronizedSortedSet (SortedSet <T> s)
          지정된 소트 세트를 기본으로 하는 동기 (thread 세이프인) 소트 세트를 리턴합니다.
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을 Throw 해야 하지는 않습니다.

이 소트는 고정인 것이 보증되고 있습니다. 즉, 소트를 실행해도, 동등의 요소의 순서는 바뀌지 않습니다.

지정된 리스트는 변경 가능하지 않으면 안됩니다만, 사이즈 변경은 할 수 없어도 괜찮습니다.

소트 알고리즘은 수정 머지 소트입니다. 이 소트에서는 하위의 사브리 파업에 있어서의 최고 레벨의 요소가 상위의 사브리 파업에 있어서의 최저 레벨의 요소보다 작은 경우, 머지는 생략 됩니다. 이 알고리즘은 항상 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을 Throw 해야 하지는 않습니다.

이 소트는 고정인 것이 보증되고 있습니다. 즉, 소트를 실행해도, 동등의 요소의 순서는 바뀌지 않습니다.

소트 알고리즘은 수정 머지 소트입니다. 이 소트에서는 하위의 사브리 파업에 있어서의 최고 레벨의 요소가 상위의 사브리 파업에 있어서의 최저 레벨의 요소보다 작은 경우, 머지는 생략 됩니다. 이 알고리즘은 항상 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) 링크 traversal와 O(log n) 요소 비교를 실행하는 반복자 베이스의 바이너리 서치를 실시합니다.

파라미터:
list - 검색되는 리스트
key - 검색되는 키
반환값:
리스트에 검색 키가 있는 경우는 검색 키의 인덱스. 검색 키가 리스트에 없는 경우는 (-(삽입 포인트) - 1). 삽입 포인트란 리스트로 키가 삽입되는 포인트이다. 즉, 키보다 큰 최초의 요소의 인덱스인가 리스트의 모든 요소가 지정된 키보다 작은 경우는 list.size(). 이것에 의해 키가 발견되었을 경우에만 반환값이 >= 0 이 되는 것이 보증된다
예외:
ClassCastException - 리스트에 「서로 비교 가능」이 아닌 요소 (예를 들어 캐릭터 라인과 정수)가 있는 경우, 또는 검색 키가 리스트의 요소로 서로 비교 가능하지 않은 경우
관련 항목:
Comparable, sort(List)

binarySearch

public static <T> int binarySearch(List <?  extends T> list,
                                   T key,
                                   Comparator <?  super T> c)
바이너리 서치 알고리즘을 사용해, 지정된 리스트로부터 지정된 객체를 검색합니다. 리스트는 이 호출전에 Sort(List, Comparator) 메서드를 사용해, 지정된 컴퍼레이터에 따라 승순에 소트 하지 않으면 안됩니다. 리스트가 소트되어 있지 않은 경우, 결과는 정의되지 않습니다. 지정된 객체와 동일한 요소가 리스트에 다수 있는 경우, 어떤 것이 발견될까는 보증되지 않습니다.

「랜덤 액세스」리스트의 경우, 이 메서드는 log(n) 시간에 동작합니다 (위치를 지정한 액세스에 거의 일정한 시간이 필요). 지정된 리스트가 RandomAccess 인터페이스를 구현하지 않고, 큰 리스트인 경우, 이 메서드는 O(n) 링크 traversal와 O(log n) 요소 비교를 실행하는 반복자 베이스의 바이너리 서치를 실시합니다.

파라미터:
list - 검색되는 리스트
key - 검색되는 키
c - 리스트가 정렬 되는 컴퍼레이터. null 치는 요소의 「자연 정렬」를 사용하는 것을 나타낸다
반환값:
리스트에 검색 키가 있는 경우는 검색 키의 인덱스. 검색 키가 리스트에 없는 경우는 (-(삽입 포인트) - 1). 삽입 포인트란 리스트로 키가 삽입되는 포인트이다. 즉, 키보다 큰 최초의 요소의 인덱스인가 리스트의 모든 요소가 지정된 키보다 작은 경우는 list.size(). 이것에 의해 키가 발견되었을 경우에만 반환값이 >= 0 이 되는 것이 보증된다
예외:
ClassCastException - 리스트로 지정된 컴퍼레이터 로 「서로 비교 가능」이 아닌 요소가 있는 경우, 또는 검색 키가 이 컴퍼레이터를 사용해 리스트의 요소로 서로 비교할 수 없는 경우
관련 항목:
Comparable, sort(List, Comparator)

reverse

public static void reverse(List <? > list)
지정된 리스트의 요소의 순서를 반대로 합니다.

이 메서드는 1 차 시간에 동작합니다.

파라미터:
list - 요소의 순서가 반대로 되는 리스트
예외:
UnsupportedOperationException - 지정된 리스트 또는 그 리스트 반복자가 set 메서드를 지원 하지 않는 경우

shuffle

public static void shuffle(List <? > list)
디폴트의 random number generation의 원을 사용해, 지정된 리스트의 순서를 무작위로 바꿔 넣습니다. 모든 편성이, 거의 균등인 확률로 발생합니다.

상기의 설명으로 「거의」라고 하는 말을 사용하고 있는 것은 random number generation의 원이 되는 디폴트의 소스가 독립해 선택된 비트의 소스로서 편향이 없는 것은 근사적으로 마셔 성립하기 때문입니다. 랜덤에 선택된 완전한 소스이면, 알고리즘이 편성을 선택하는 확률은 완전하게 한결같게 됩니다.

이 구현은 리스트의 마지막 요소로부터 2번째의 요소까지 역방향으로 더듬어, 무작위로 선택된 요소를 「현재의 위치」에 반복해 바꿔 넣습니다. 요소는 리스트의 최초의 요소로부터 현재의 위치까지의 범위에서 무작위로 선택됩니다.

이 메서드는 1 차 시간에 동작합니다. 지정된 리스트가 RandomAccess 인터페이스를 구현하지 않는 큰 리스트인 경우, 리스트의 순서를 바꿔 넣기 전에 이 구현은 지정된 리스트를 배열에 덤프 해, 다음으로 바꾸어 넣은 배열을 리스트에 덤프의해 되돌립니다. 적절히 「차례차례 액세스」리스트의 순서를 바꿔 넣는 것에 의해 일어나는 2 차 동작을 피하기 때문에입니다.

파라미터:
list - 순서를 바꿔 넣을 수 있는 리스트
예외:
UnsupportedOperationException - 지정된 리스트 또는 그 리스트 반복자가 set 메서드를 지원 하지 않는 경우

shuffle

public static void shuffle(List <? > list,
                           Random  rnd)
디폴트의 random number generation의 원을 사용해, 지정된 리스트의 순서를 무작위로 바꿔 넣습니다. random number generation의 원이 한결같으면, 모든 편성은 균등인 확률로 발생합니다.

이 구현은 리스트의 마지막 요소로부터 2번째의 요소까지 역방향으로 더듬어, 무작위로 선택된 요소를 「현재의 위치」에 반복해 바꿔 넣습니다. 요소는 리스트의 최초의 요소로부터 현재의 위치까지의 범위에서 무작위로 선택됩니다.

이 메서드는 1 차 시간에 동작합니다. 지정된 리스트가 RandomAccess 인터페이스를 구현하지 않는 큰 리스트인 경우, 리스트의 순서를 바꿔 넣기 전에 이 구현은 지정된 리스트를 배열에 덤프 해, 다음으로 바꾸어 넣은 배열을 리스트에 덤프의해 되돌립니다. 적절히 「차례차례 액세스」리스트의 순서를 바꿔 넣는 것에 의해 일어나는 2 차 동작을 피하기 때문에입니다.

파라미터:
list - 순서를 바꿔 넣을 수 있는 리스트
rnd - 리스트의 순서를 바꿔 넣기 위해서 사용하는 random number generation의 원
예외:
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)
지정된 리스트의 모든 요소가 지정된 요소로 옮겨놓습니다.

이 메서드는 1 차 시간에 동작합니다.

파라미터:
list - 지정된 요소가 삽입되는 리스트
obj - 지정된 리스트에 삽입되는 요소
예외:
UnsupportedOperationException - 지정된 리스트 또는 그 리스트 반복자가 set 오퍼레이션을 지원 하지 않는 경우

copy

public static <T> void copy(List <?  super T> dest,
                            List <?  extends T> src)
어느 리스트로부터 다른 리스트에 모든 요소를 카피합니다. 이 오퍼레이션의뒤 카피처의 리스트에 카피된 각 요소의 인덱스는 카피원의 리스트의 인덱스와 같게 됩니다. 카피처의 리스트는 적어도 카피원의 리스트와 같은 길이가 아니면 안됩니다. 카피처의 리스트가 긴 경우에서도, 카피처의 리스트의 나머지의 요소는 영향을 받지 않습니다.

이 메서드는 1 차 시간에 동작합니다.

파라미터:
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을 Throw 해야 하지는 않습니다.

이 메서드는 컬렉션 전체로 반복 처리를 실시하므로 컬렉션의 사이즈에 비례한 시간이 필요합니다.

파라미터:
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을 Throw 해야 하지는 않습니다.

이 메서드는 컬렉션 전체로 반복 처리를 실시하므로 컬렉션의 사이즈에 비례한 시간이 필요합니다.

파라미터:
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을 Throw 해야 하지는 않습니다.

이 메서드는 컬렉션 전체로 반복 처리를 실시하므로 컬렉션의 사이즈에 비례한 시간이 필요합니다.

파라미터:
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을 Throw 해야 하지는 않습니다.

이 메서드는 컬렉션 전체로 반복 처리를 실시하므로 컬렉션의 사이즈에 비례한 시간이 필요합니다.

파라미터:
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)
지정된 컬렉션을 기본으로 하는 동기 (thread 세이프인) 컬렉션을 리턴합니다. 확실히 직렬 액세스를 실현하려면, 기가 되는 컬렉션에의 액세스는 모두 리턴된 컬렉션을 개입시켜 실시할 필요가 있습니다.

리턴된 컬렉션의 반복 처리를 실시하는 경우, 사용자는 다음에 나타내도록 수동으로 동기를 잡을 필요가 있습니다. 


  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)
지정된 세트를 기본으로 하는 동기 (thread 세이프인) 세트를 리턴합니다. 확실히 직렬 액세스를 실현하려면, 기가 되는 세트에의 액세스는 모두 리턴된 세트를 개입시켜 실시할 필요가 있습니다.

리턴된 세트의 반복 처리를 실시하는 경우, 사용자는 다음에 나타내도록 수동으로 동기를 잡을 필요가 있습니다. 


  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)
지정된 소트 세트를 기본으로 하는 동기 (thread 세이프인) 소트 세트를 리턴합니다. 확실히 직렬 액세스를 실현하려면, 기가 되는 소트 세트에의 액세스는 모두, 리턴된 소트 세트 (또는 그 뷰)를 개입시켜 실시할 필요가 있습니다.

리턴된 소트 세트, 또는 그 subSet, headSet, 혹은 tailSet 뷰의 반복 처리를 실시하는 경우, 사용자는 다음에 나타내도록 수동으로 동기를 잡을 필요가 있습니다. 


  SortedSet s = Collections.synchronizedSortedSet(new HashSortedSet());
      ...
  synchronized(s) {
      Iterator i = s.iterator(); // Must be in the synchronized block
      while (i.hasNext())
          foo(i.next());
  }
또는 

  SortedSet s = Collections.synchronizedSortedSet(new HashSortedSet());
  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)
지정된 리스트를 기본으로 하는 동기 (thread 세이프인) 리스트를 리턴합니다. 확실히 직렬 액세스를 실현하려면, 기본으로 되는 리스트에의 액세스는 모두, 리턴된 리스트를 개입시켜 실시할 필요가 있습니다.

리턴된 리스트의 반복 처리를 실시하는 경우, 사용자는 다음에 나타내도록 수동으로 동기를 잡을 필요가 있습니다. 


  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)
지정된 맵을 기본으로 하는 동기 (thread 세이프인) 맵을 리턴합니다. 확실히 직렬 액세스를 실현하려면, 기본으로 되는 맵에의 액세스는 모두, 리턴된 맵을 개입시켜 실시할 필요가 있습니다.

리턴된 맵의 코레크션뷰에서의 반복 처리를 실시하는 경우, 사용자는 다음에 나타내도록 수동으로 동기를 잡을 필요가 있습니다. 


  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)
지정된 소트 맵을 기본으로 하는 동기 (thread 세이프인) 소트 맵을 리턴합니다. 확실히 직렬 액세스를 실현하려면, 기본으로 되는 소트 맵에의 액세스는 모두, 리턴된 소트 맵 (또는 그 뷰)을 개입시켜 실시할 필요가 있습니다.

리턴된 소트 맵의 코레크션뷰, 또는 subMap, headMap, tailMap 뷰의 코레크션뷰에서의 반복 처리를 실시하는 경우, 사용자는 다음에 나타내도록 수동으로 동기를 잡을 필요가 있습니다. 


  SortedMap m = Collections.synchronizedSortedMap(new HashSortedMap());
      ...
  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 HashSortedMap());
  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... a)
지정된 모든 요소가 지정된 컬렉션에 추가합니다. 추가되는 요소는 개별적으로 지정될까 배열로서 지정됩니다. 이 편리한 메서드의 동작은, c.addAll(Arrays.asList(elements))와 동일합니다만, 이 메서드는 대부분의 구현으로 매우 고속으로 실행됩니다.

요소를 개별적으로 지정하는 경우, 이 메서드에서는 다음의 예의 같게, 여러종류의 요소를 기존의 컬렉션에 간단하게 추가할 수 있습니다. 


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

파라미터:
c - elements가 삽입되는 컬렉션
a - c에 삽입되는 요소
반환값:
이 호출의 결과, 컬렉션이 변경되었을 경우는 true
예외:
UnsupportedOperationException - c가 add 메서드를 지원 하지 않는 경우
NullPointerException - elements에 1개 이상의 null 요소가 포함되어 있어, c가 null 요소를 지원 하지 않는지, c 또는 elements가 null인 경우
IllegalArgumentException - elements 값의 특성이 원인으로c에 추가할 수 없는 경우
도입된 버전 :
1.5
관련 항목:
Collection.addAll(Collection)
개요   패키지    클래스  사용   계층 트리   비추천 API   색인   헬프  
JavaTM 2 Platform
Standard Ed. 5.0
 이전 클래스    다음 클래스 프레임으로    프레임 없이    
개요:  NESTED  | 필드 | constructor　 　 | 메서드 상세:  필드 | constructor　 　 | 메서드

Copyright 2004 Sun Microsystems, Inc. All rights reserved. Use is subject to license terms . Documentation Redistribution Policy 도 참조하십시오.