자바 회고 집합 에 대한 요약

자바 의 집합 은 주로 2 부분 에 집중 되 어 있 으 며,일 부 는 자바 util 가방 에 있 으 며,일 부 는 자바 util.concurrent 에 있 으 며,후 자 는 전 자 를 바탕 으로 동기 화 기능 을 실현 하 는 집합 을 정의 하 였 다.
이 글 은 주로 자바 util 의 각종 집합 대상 에 주목 하고 있다.자바 의 집합 대상 은 대략 3 가지 로 나 눌 수 있다.List,Set,Map.대응 하 는 UML 그림 은 다음 과 같 습 니 다(java.util 의 대부분 집합 대상 포함):Collection 개요
자바 집합 중의 List 와 Set 은 모두 Collection 에서 나 옵 니 다.이것 은 학습 집합 이 매우 좋 은 입구 입 니 다.이것 은 집합 에 있어 서 일반적으로 필요 한 조작 을 포함 합 니 다.
    요소 추가:add/addAll    클 리 어 집합:clear    요소 삭제:remove/removeAll    집합 에 어떤 요소 가 포함 되 어 있 는 지 판단 하기:contains/contains All    집합 이 비어 있 는 지 판단 하기:isEmpty    집합 요소 의 개 수 를 계산 합 니 다:size    집합 을 배열 로 변환:toArray    교체 기 가 져 오기:iterator
우 리 는 간단 한 예 를 살 펴 보 자.아래 의 코드 는 하나의 집합 으로 돌아 갈 것 이다.집합 중의 요 소 는 무 작위 로 생 성 된 정수 이다.

private static Collection initCollection()
 {
     Collection<Integer> collection = new ArrayList<Integer>();
     Random r = new Random();
     for (int i = 0 ; i < 5; i++)
     {
         collection.add(new Integer(r.nextInt(100)));
     }

     return collection;
 }

집합 을 조작 하 는 과정 에서 자주 사용 하 는 조작 이다.우 리 는 두 가지 방식 으로 집합 을 옮 겨 다 닐 수 있다.
1)교체 기 를 사용 하여 집합 을 옮 겨 다 닌 다.위 에서 설명 한 Collection 인터페이스 에서 말 한 바 와 같이 모든 집합 에는 교체 기 가 있 습 니 다.우 리 는 그것 으로 집합 을 옮 겨 다 닐 수 있 습 니 다.

private static void accessCollectionByIterator(Collection<Integer> collection)
 {
     Iterator<Integer> iterator = collection.iterator();
     System.out.println("The value in the list:");
     while(iterator.hasNext())
     {
         System.out.println(iterator.next());
     }
 }

2)foreach 를 사용 하여 집합 합 니 다.

private static void accessCollectionByFor(Collection<Integer> collection)
 {
     System.out.println("The value in the list:");
     for(Integer value : collection)
     {
         System.out.println(value);
     }
 }

List
자바 의 List 는 배열 에 대한 효과 적 인 확장 입 니 다.이러한 구조 입 니 다.범 형 을 사용 하지 않 으 면 모든 종류의 요 소 를 수용 할 수 있 습 니 다.범 형 을 사용 하면 범 형 이 지정 한 유형의 요소 만 수용 할 수 있 습 니 다.배열 에 비해 List 의 용량 은 동적 으로 확장 할 수 있 습 니 다.
List 의 요 소 는 중복 할 수 있 습 니 다.안의 요 소 는'질서'입 니 다.여기 의'질서'는 정렬 의 뜻 이 아니 라 특정한 요소 가 집합 에 있 는 위 치 를 지정 할 수 있 습 니 다.
List 에서 자주 사용 하 는 집합 대상 은 Array List,Vector 와 LinkedList 를 포함한다.그 중에서 앞의 두 가 지 는 배열 을 바탕 으로 저장 되 고 후 자 는 링크 를 바탕 으로 저장 된다.그 중에서 Vector 는 스 레 드 가 안전 하고 나머지 두 개 는 스 레 드 가 안전 하지 않 습 니 다.
List 에는 범 형 을 사용 하 더 라 도 null 을 포함 할 수 있 습 니 다.
Array List 는 우리 가 평소에 가장 많이 사용 하 는 집합 대상 일 수도 있 습 니 다.상기 예제 코드 에서 우 리 는 그것 을 사용 하여 Collection 대상 을 예화 시 켰 습 니 다.여기 서 더 이상 군말 하지 않 습 니 다.Vector
Vector 의 예 는 다음 과 같 습 니 다.먼저 Vector 를 어떻게 생 성하 고 출력 하 는 지 보 겠 습 니 다.

private static void vectorTest1()
 {
     List<Integer> list = new Vector<Integer>();
     for (int i = 0 ; i < 5; i++)
     {
         list.add(new Integer(100));
     }
     list.add(null);
     System.out.println("size of vector is " + list.size());
     System.out.println(list);
 }

그 요소 에는 중복 요소 도 포함 되 어 있 고 null 도 포함 되 어 있 습 니 다.출력 결 과 는 다음 과 같 습 니 다.

size of vector is 6
[100, 100, 100, 100, 100, null]

아래 의 예 는 Vector 에서 자주 사용 하 는 방법 을 보 여 주 었 습 니 다.

private static void vectorTest2()
 {
     Vector<Integer> list = new Vector<Integer>();
     Random r = new Random();
     for (int i = 0 ; i < 10; i++)
     {
         list.add(new Integer(r.nextInt(100)));
     }
     System.out.println("size of vector is " + list.size());
     System.out.println(list);
     System.out.println(list.firstElement());
     System.out.println(list.lastElement());
     System.out.println(list.subList(3, 8));
     List<Integer> temp = new ArrayList<Integer>();
     for(int i = 4; i < 7; i++)
     {
         temp.add(list.get(i));
     }
     list.retainAll(temp);
     System.out.println("size of vector is " + list.size());
     System.out.println(list);
 }

그의 출력 결 과 는 다음 과 같 습 니 다.

size of vector is 10
[39, 41, 20, 9, 29, 32, 54, 12, 94, 82]

[9, 29, 32, 54, 12]
size of vector is 3
[29, 32, 54]

LinkedList
LinkedList 는 링크 시트 를 사용 하여 데 이 터 를 저장 합 니 다.예제 코드 는 다음 과 같 습 니 다.

LinkedList  
 private static void linkedListTest1()
 {
     LinkedList<Integer> list = new LinkedList<Integer>();
     Random r = new Random();
     for (int i = 0 ; i < 10; i++)
     {
         list.add(new Integer(r.nextInt(100)));
     }
     list.add(null);
     System.out.println("size of linked list is " + list.size());
     System.out.println(list);
     System.out.println(list.element());
     System.out.println(list.getFirst());
     System.out.println(list.getLast());
     System.out.println(list.peek());
     System.out.println(list.peekFirst());
     System.out.println(list.peekLast());
     System.out.println(list.poll());
     System.out.println(list.pollFirst());
     System.out.println(list.pollLast());
     System.out.println(list.pop());
     list.push(new Integer(100));
     System.out.println("size of linked list is " + list.size());
     System.out.println(list);
 }

여 기 는 LinkedList 가 자주 사용 하 는 여러 방법 을 보 여 줍 니 다.방법 명 을 통 해 알 수 있 듯 이 LinkedList 도 스 택 과 대기 열 을 실현 할 수 있 습 니 다.
출력 결 과 는 다음 과 같 습 니 다.

size of linked list is 11
[17, 21, 5, 84, 19, 57, 68, 26, 27, 47, null]

null

null

null
size of linked list is 8
[100, 84, 19, 57, 68, 26, 27, 47]

Set
set 는 List 와 유사 합 니 다.모두 하나의 요 소 를 저장 하 는 데 사 용 됩 니 다.하나의 요소 의 수량 이 확실 하지 않 습 니 다.그러나 Set 는 중복 요 소 를 포함 할 수 없습니다.Set 에 같은 요 소 를 두 개 삽입 하면 다음 요 소 는 삽입 되 지 않 습 니 다.
Set 는 크게 두 가지 로 나 눌 수 있 습 니 다.Set 과 정렬 Set 을 정렬 하지 않 고 정렬 하지 않 습 니 다.Set 은 HashSet 과 LinkedHashSet 를 포함 하고 정렬 Set 은 주로 TreeSet 을 말 합 니 다.그 중에서 HashSet 과 LinkedHashSet 은 null 을 포함 할 수 있 습 니 다.HashSet
HashSet 은 Hash 표 가 지원 하 는 집합 입 니 다.스 레 드 가 안전 한 것 이 아 닙 니 다.
우 리 는 아래 의 예 시 를 살 펴 보 겠 습 니 다.이것 은 Vector 의 첫 번 째 예제 와 대체적으로 같 습 니 다.

private static void hashSetTest1()
 {
     Set<Integer> set = new HashSet<Integer>();

     for (int i = 0; i < 3; i++)
     {
         set.add(new Integer(100));
     }
     set.add(null);

     System.out.println("size of set is " + set.size());
     System.out.println(set);
 }

여기 HashSet 에는 중복 요소 도 포함 되 어 있 고 null 도 포함 되 어 있 습 니 다.Vector 와 달리 여기 의 출력 결 과 는 다음 과 같 습 니 다.

size of set is 2
[null, 100]

HashSet 이 두 요소 가 중복 되 는 지 여 부 를 어떻게 판단 하 는 지 에 대해 우 리 는 깊이 살 펴 볼 수 있 습 니 다.Object 에서 도 equals 방법 을 정 의 했 습 니 다.HashSet 의 요소 에 대해 equals 방법 에 따라 요소 가 일치 하 는 지 여 부 를 판단 합 니 다.이 를 증명 하기 위해 우 리 는'비정 상'유형 을 정의 할 수 있 습 니 다.

  MyInteger  
class MyInteger
{
    private Integer value;

    public MyInteger(Integer value)
    {
        this.value = value;
    }

    public String toString()
    {
        return String.valueOf(value);
    }

    public int hashCode()
    {
        return 1;
    }

    public boolean equals(Object obj)
    {
        return true;
    }
}

볼 수 있 습 니 다.MyInteger 에 있어 서 임 의 두 사례 에 대해 우 리 는 모두 같 지 않다 고 생각 합 니 다.
다음은 해당 하 는 테스트 방법 입 니 다.

private static void hashSetTest2()
 {
     Set<MyInteger> set = new HashSet<MyInteger>();

     for (int i = 0; i < 3; i++)
     {
         set.add(new MyInteger(100));
     }

     System.out.println("size of set is " + set.size());
     System.out.println(set);
 }

출력 결 과 는 다음 과 같 습 니 다.

size of set is 3
[100, 100, 100]

현재 HashSet 에'중복'요소 가 있 지만 MyInteger 에 게 는'동일'이 아 닙 니 다.TreeSet
TreeSet 는 정렬 을 지원 하 는 Set 입 니 다.부모 인 터 페 이 스 는 SortedSet 입 니 다.
먼저 TreeSet 에 어떤 기본 동작 이 있 는 지 살 펴 보 겠 습 니 다.

private static void treeSetTest1()
 {
     TreeSet<Integer> set = new TreeSet<Integer>();

     Random r = new Random();
     for (int i = 0 ; i < 5; i++)
     {
         set.add(new Integer(r.nextInt(100)));
     }

     System.out.println(set);
     System.out.println(set.first());
     System.out.println(set.last());
     System.out.println(set.descendingSet());
     System.out.println(set.headSet(new Integer(50)));
     System.out.println(set.tailSet(new Integer(50)));
     System.out.println(set.subSet(30, 60));
     System.out.println(set.floor(50));
     System.out.println(set.ceiling(50));
 }

출력 결 과 는 다음 과 같 습 니 다.

[8, 42, 48, 49, 53]

[53, 49, 48, 42, 8]
[8, 42, 48, 49]
[53]
[42, 48, 49, 53]

TreeSet 의 요 소 는 보통 Comparable 인 터 페 이 스 를 실현 합 니 다.기본 적 인 상황 에서 Integer 에 게 Sorted List 는 오름차 로 저장 되 고 저 희 는 Compare 방식 을 사용자 정의 할 수 있 습 니 다.예 를 들 어 내림차 순 으로 저장 할 수 있 습 니 다.
다음은 Integer:

  MyInteger2  
 class MyInteger2 implements Comparable
 {
     public int value;

     public MyInteger2(int value)
     {
         this.value = value;
     }

     public int compareTo(Object arg0) 
     {
         MyInteger2 temp = (MyInteger2)arg0;
         if (temp == null) return -1;
         if (temp.value > this.value)
         {
             return 1;
         }
         else if (temp.value < this.value)
         {
             return -1;
         }
         return 0;
     }

     public boolean equals(Object obj)
     {
         return compareTo(obj) == 0;
     }

     public String toString()
     {
         return String.valueOf(value);
     }
 }

다음은 테스트 코드 입 니 다.

private static void treeSetTest2()
 {
     TreeSet<Integer> set1 = new TreeSet<Integer>();
     TreeSet<MyInteger2> set2 = new TreeSet<MyInteger2>();
     Random r = new Random();
     for (int i = 0 ; i < 5; i++)
     {
         int value = r.nextInt(100);
         set1.add(new Integer(value));
         set2.add(new MyInteger2(value));
     }
     System.out.println("Set1 as below:");
     System.out.println(set1);
     System.out.println("Set2 as below:");
     System.out.println(set2);
 }

코드 의 운행 결 과 는 우리 가 예상 한 바 와 같이 다음 과 같 습 니 다.

Set1 as below:
[13, 41, 42, 45, 61]
Set2 as below:
[61, 45, 42, 41, 13]

Map
Map 에 저 장 된 것 은"키 쌍"입 니 다.set 와 유사 합 니 다.자바 의 Map 도 두 가지 가 있 습 니 다.정렬 된 것 과 정렬 되 지 않 은 것 은 HashMap,Hashtable 과 LinkedHashMap 을 포함 하고 정렬 된 것 은 TreeMap 을 포함 합 니 다.비 정렬 맵
HashMap 과 Hashtable 은 모두 Hash 표 의 방식 으로 저장 합 니 다.HashMap 은 스 레 드 가 안전 한 것 이 아니 라 Hashtable 은 스 레 드 가 안전 합 니 다.우 리 는 HashMap 을'간략화'판 Hashtable 로 볼 수 있 습 니 다.
HashMap 은 Key 든 Value 든 null 을 저장 할 수 있 습 니 다.Hashtable 은 null 을 저장 할 수 없습니다.
HashMap 이 든 Hashtable 이 든 우 리 는 그의 구조 함 수 를 관찰 하면 두 개의 매개 변 수 를 발견 할 수 있다.initial Capacity 와 loadFactor 는 기본 적 인 상황 에서 initial Capacity 는 16 이 고 loadFactor 는 0.75 이다.이것 은 Hash 표 에 저장 할 수 있 는 요소 의 수량 과 관계 가 있 습 니 다.요소 의 수량 이 initialCapacity*loadFactor 를 초과 할 때 rehash 방법 을 촉발 하여 hash 표를 확대 합 니 다.만약 우리 가 그 안에 너무 많은 요 소 를 삽입 해 야 한다 면,이 두 개의 인 자 를 적당 하 게 조정 해 야 한다.
우 리 는 먼저 HashMap 의 예 시 를 살 펴 보 겠 습 니 다.

private static void hashMapTest1()
 {
     Map<Integer,String> map = new HashMap<Integer, String>();

     map.put(new Integer(1), "a");
     map.put(new Integer(2), "b");
     map.put(new Integer(3), "c");

     System.out.println(map);
     System.out.println(map.entrySet());
     System.out.println(map.keySet());
     System.out.println(map.values());
 }

이것 은 HashMap 의 요소 정 보 를 출력 할 것 입 니 다.다음 과 같 습 니 다.

{1=a, 2=b, 3=c}
[1=a, 2=b, 3=c]
[1, 2, 3]
[a, b, c]

아래 의 예 는 null 에 대한 프 리 젠 테 이 션 입 니 다.

private static void hashMapTest2()
 {
     Map<Integer,String> map = new HashMap<Integer, String>();

     map.put(null, null);
     map.put(null, null);
     map.put(new Integer(4), null);
     map.put(new Integer(5), null);

     System.out.println(map);
     System.out.println(map.entrySet());
     System.out.println(map.keySet());
     System.out.println(map.values());
 }

실행 결 과 는 다음 과 같 습 니 다.

{null=null, 4=null, 5=null}
[null=null, 4=null, 5=null]
[null, 4, 5]
[null, null, null]

다음 에 우 리 는 Hashtable 을 보 여 드 리 겠 습 니 다.상기 두 예제 와 대체적으로 똑 같 습 니 다.(코드 가 더 이상 전개 되 지 않 습 니 다)실행 결 과 는 다음 과 같 습 니 다.

Hashtable  
 private static void hashTableTest1()
 {
     Map<Integer,String> table = new Hashtable<Integer, String>();

     table.put(new Integer(1), "a");
     table.put(new Integer(2), "b");
     table.put(new Integer(3), "c");

     System.out.println(table);
     System.out.println(table.entrySet());
     System.out.println(table.keySet());
     System.out.println(table.values());
 }

 private static void hashTableTest2()
 {
     Map<Integer,String> table = new Hashtable<Integer, String>();

     table.put(null, null);
     table.put(null, null);
     table.put(new Integer(4), null);
     table.put(new Integer(5), null);

     System.out.println(table);
     System.out.println(table.entrySet());
     System.out.println(table.keySet());
     System.out.println(table.values());
 }

우리 가 null 을 hashtable 에 삽입 하려 고 할 때 빈 지침 이상 을 보 여 주 었 습 니 다.정렬 맵
정렬 맵 은 주로 TreeMap 을 말 하 는데 요소 의 증가,삭제,검사 작업 시의 시간 복잡 도 는 모두 O(log(n)이다.그것 은 라인 이 안전 한 것 이 아니다.
그것 의 특징 은 TreeSet 과 매우 비슷 해서 더 이상 군말 하지 않 는 다.