[자바] 보유 대상

1. 용기 류
자바 용기 클래스 라 이브 러 리 의 용 도 는 저장 대상 이 고 이 를 두 가지 서로 다른 개념 으로 나 누 는 것 입 니 다.
1) Collection: 하나의 독립 된 요소 의 서열 로 이 요소 들 은 모두 한 가지 또는 여러 가지 규칙 에 따른다.List 는 삽 입 된 순서대로 요 소 를 저장 해 야 하 며, set 에는 중복 요소 가 있어 서 는 안 됩 니 다.Queue 는 줄 서기 규칙 에 따라 대상 이 발생 하 는 순 서 를 확인한다.
2) 맵: 한 쌍 으로 구 성 된 키 쌍 의 대상 은 키 를 사용 하여 값 을 찾 을 수 있 습 니 다.맵 은 다른 대상 을 사용 하여 대상 을 찾 을 수 있 습 니 다. 관련 배열 이 라 고도 부 르 거나 사전 이 라 고도 부 릅 니 다. 맵 은 강력 한 프로 그래 밍 도구 입 니 다.
자바. util 패키지 의 Arrays 와 Collections 류 에는 실 용적 인 방법 이 많 습 니 다. 하나의 Collection 에 요 소 를 추가 할 수 있 습 니 다.Arrays. asList () 방법 은 배열 이나 쉼표 로 구 분 된 요소 목록 을 받 아들 여 List 대상 으로 변환 합 니 다.Collections. addAll () 방법 은 Collections 대상 과 하나의 배열 또는 쉼표 로 구 분 된 목록 을 받 아들 여 요 소 를 Collection 에 추가 합 니 다. 예 를 들 어:

Collection<Integer> collection = new ArrayList<Integer>(Arrays.asList(1, 2, 3));
Integer[] moreInts = {4, 5, 6};
collection.addAll(Arrays.asList(moreInts));
Collection.addAll(collection, 7, 8, 9);
Collection.addAll(collection, moreInts);

2. List
List 는 요 소 를 특정한 시퀀스 에 유지 할 수 있 습 니 다. List 인 터 페 이 스 는 Collection 을 바탕 으로 대량의 방법 을 추가 하여 List 의 중간 에 요 소 를 삽입 하고 제거 할 수 있 습 니 다.두 가지 유형의 List 가 있 습 니 다. 기본 적 인 Array List 는 무 작위 로 요 소 를 방문 하 는 것 이 장점 이지 만 중간 에 요 소 를 삽입 하고 제거 할 때 느 립 니 다.LinkedList 는 List 중간 에 삽입 되 고 * * * 작업 대가 가 낮 지만 무 작위 방문 에 있어 서 상대 적 으로 느 립 니 다.
배열 과 달리 List 는 생 성 된 후에 요 소 를 추가 하고 요 소 를 제거 할 수 있 습 니 다. contains () 방법 으로 대상 이 목록 에 있 는 지 확인 할 수 있 습 니 다. 대상 을 제거 하려 면 이 대상 의 인용 을 reove () 방법 으로 전달 할 수 있 습 니 다. 마찬가지 로 대상 의 인용 이 있 으 면 index Of () 를 사용 할 수 있 습 니 다.이 대상 이 List 에 있 는 위치 에 있 는 색인 번 호 를 발견 합 니 다. 예 를 들 어:

List<Pet> pets = Pets.arrayList(7);
pets.add(3, new Mouse());
Hamster h = new Hamster();
pets.add(h);
System.out.println(pets.contains(h));
pets.remove(h);
Pet p = pets.get(2);
pets.remove(p);
Pet cymric = new Cymric();
System.out.println(pets.indexOf(cymric));

subList () 방법 은 비교적 큰 목록 에서 세 션 을 쉽게 만 들 수 있 습 니 다. 그 결 과 를 contains All () 방법 에 전달 하면 true 를 얻 을 수 있 습 니 다. retainAll () 방법 은 효과 적 인 교차 작업 입 니 다. 두 세 션 에 동시에 있 는 모든 요 소 를 유지 합 니 다. removeAll () 방법 은 List 에서 매개 변수 List 에 있 는 모든 요 소 를 제거 합 니 다. 예 를 들 어:

List<Pet> pets = Pets.arrayList(7);
List<Pet> sub = pets.subList(1, 4);
System.out.println(pets.containsAll(sub));
lIST<Pet> copy = new ArrayList<Pet>(pets);
copy.retainAll(sub);
copy = new ArrayList<Pet>(pets);
copy.set(1, new Mouse());
copy.addAll(2, sub);
copy.removeAll(sub);
copy.clear();

3. 교체 기
교체 기 는 대상 입 니 다. 작업 은 시퀀스 의 대상 을 옮 겨 다 니 며 선택 하 는 것 입 니 다. 클 라 이언 트 프로그래머 는 이 시퀀스 의 바 텀 구 조 를 알 거나 관심 을 가 질 필요 가 없습니다.그 밖 에 교체 기 대상 은 경량급 대상 이 라 고 불 리 며 만 든 대가 가 비교적 적다. 예 를 들 어 자바 의 Iterator 는 단 방향 으로 만 이동 할 수 있 고 이 Iterator 는 다음 과 같이 만 사용 할 수 있다.
1) 사용 방법 iterator () 는 용기 에 Iterator 를 되 돌려 달라 고 요구 하 며, 서열 로 돌아 가 는 첫 번 째 요 소 를 준비 합 니 다.
2) next () 를 사용 하여 시퀀스 의 다음 요 소 를 얻 습 니 다.
3) hasNext () 를 사용 하여 시퀀스 에 요소 가 있 는 지 확인 합 니 다.
4) remove () 를 사용 하여 교체 기 를 최근 에 사용 한 요소 * * *.
예 를 들 면:

List<Pet> pets = Pets.arrayList(10);
Iterator<Pet> it = pets.iterator();
while(it.hasNext) {
  Pet p = it.next();
  System.out.println(p.id());
}
for(Pet p : pets) {
  System.out.println(p.id());
}
it = pets.iterator();
for(int i = 0; i < 6;i ++) {
  it.next();
  it.remove();
}

4. Stack
스 택 은 보통 후진 에서 먼저 나 오 는 용 기 를 말 하 는데 가끔 스 택 을 중첩 스 택 이 라 고 부 르 기 때문에 마지막 에 스 택 에 들 어 가 는 요소 도 첫 번 째 로 스 택 을 나 옵 니 다.LinkedList 는 스 택 의 모든 기능 을 직접 실현 할 수 있 는 방법 이 있 기 때문에 LinkedList 를 스 택 으로 직접 사용 할 수 있 습 니 다. 예 를 들 어:

import java.util.LinkedList
public class Stack<T> {
  private LinkedList<T> storage = new LinkedList<T>();
  public void push(T v) {storage.addFirst(v);}
  public T peek() {return storage.getFirst();}
  public T pop() {return storage.removeFirst();}
  public boolean empty() {return storage.isEmpty();}
  public String toString() {return storage.toString();}
}

5. Set
set 는 중 복 된 요 소 를 저장 하지 않 습 니 다. 같은 대상 의 여러 인 스 턴 스 를 set 에 추가 하려 고 하면 이러한 중복 현상 을 방지 할 수 있 습 니 다.Set 는 Collection 과 똑 같은 인 터 페 이 스 를 가지 고 있 기 때문에 별도의 기능 이 없고 실제 Set 은 Collection 이 며 행동 만 다르다.찾기 는 Set 에서 가장 중요 한 동작 이기 때문에 보통 HashSet 을 선택 합 니 다. 이 는 빠 른 검색 을 최적화 시 켰 습 니 다. 예 를 들 어:

Random rand = new Random(50);
Set<Integer> intset = new HashSet<Integer>();
for(int i = 0; i < 10000; i++) {
  intset.add(rand.nextInt(30));
}
System.out.println(intset);

결 과 를 정렬 하려 면 HashSet 대신 TreeSet 을 사용 하 는 방식 입 니 다. 예 를 들 어:

Random rand = new Random(50);
SortedSet<Integer> intset = new TreeSet<Integer>();
for(int i = 0; i < 10000; i++) {
  intset.add(rand.nextInt(30));
}
System.out.println(intset);

6. Map
대상 을 다른 대상 에 비 추 는 능력 은 프로 그래 밍 문 제 를 해결 하 는 관건 적 인 수단 이다. 예 를 들 어 한 프로그램 이 자바 의 Random 류 의 임 의 성 을 검사 하려 면 대량의 임 의 수 를 생 성하 고 다양한 범위 에 떨 어 진 숫자 를 계산 해 야 한다. Map 은 이 문 제 를 쉽게 해결 할 수 있다. 예 를 들 어:

Random rand = new Random(50);
Map<Integer.Integer> m = new HashMap<Integer.Integer>();
for(int i = 0; i < 10000; i++) {
  int r = rand.nextInt(20);
  Integer freq = m.get(r);
  m.put(r, freq == null ? 1 : freq + 1);
}
System.out.println(m);

7. Queue
대기 열 은 전형 적 인 선진 적 인 용기 이다. 즉, 용기 의 한 끝 에서 사물 을 넣 고 다른 한 끝 에서 꺼 내 면 대기 열 은 항상 신뢰 할 수 있 는 대상 을 프로그램의 한 구역 에서 다른 구역 으로 전송 하 는 경로 로 여 겨 진다.LinkedList 는 대기 열의 행동 을 지원 하 는 방법 을 제공 하고 Queue 인 터 페 이 스 를 실현 합 니 다. 예 를 들 어:

Queue<Integer> queue = new LinkedList<Integer>();
Random rand = new Random(50);
for (int i = 0; i < 10; i++) {
  queue.offer(rand.nextInt(i+10));
}
while(queue.peek() != null) {
  System.out.print(queue.remove() + " ");
}

offer () 방법 은 Queue 와 관련 된 방법 중 하나 입 니 다. 허용 되 는 상황 에서 하나의 요 소 를 팀 끝 에 삽입 하거나 false 로 되 돌려 줍 니 다. peek () 와 element () 는 제거 되 지 않 은 상태 에서 팀 머리 로 돌아 갑 니 다. 그러나 peek () 방법 은 대기 열 이 비어 있 을 때 null 로 돌아 갑 니 다. element () 는 이상 을 던 집 니 다.poll () 과 reove () 방법 은 팀 헤드 를 제거 하고 되 돌려 줍 니 다. 그러나 poll () 은 대기 열 이 비어 있 을 때 null 로 돌아 가 고 reove () 는 이상 을 던 집 니 다.
8. foreach
foreach 는 모든 Collection 대상 에 적용 할 수 있 습 니 다. 예 를 들 어:

Collection<String> cs = new LinkedList<String>();
Collection.addAll(cs, "Hello World !".split(" "));
for (String s : cs) {
  System.out.print("'" + s + "' ");
}

자바 SE5 는 Iterable 이 라 고 불 리 는 새로운 인 터 페 이 스 를 도입 했다. 이 인 터 페 이 스 는 Iterable 을 만 들 수 있 는 iterator () 방법 을 포함 하고 있 으 며, Iterable 인 터 페 이 스 는 foreach 에 의 해 시퀀스 에서 이동 되 기 때문에 Iterable 을 실현 하 는 모든 클래스 를 만 들 면 foreach 구문 에 사용 할 수 있다. 예 를 들 어:

public class IterableClass implements Iterable<String> {
  protected String[] words = "Hello World !".split(" ");
  public Iterator<String> iterator() {
    return new Iterator<String>() {
      private int index = 0;
      public boolean hasNext() {
        return index < words.length;
      }
      public String next() {
        return words[index++];
      }
      public void remove() {
        throw new UnsupportedOperationException();
      }
    }
  }
  public static void maint(String[] args) {
    for (String s : new IterableClass()) {
      System.out.print(s + " ");
    }
  }
}

본 고 는 '청봉 노트' 블 로그 에서 나 왔 으 니 전재 하 는 것 을 사절 합 니 다!