Java

[Java] Stack, Queue, Collection

삶_ 2022. 7. 12. 13:25

 

Stack, Queue

  • collection 인터페이스를 상속받음
  • java.util 내의 클래스

 

Stack

  • 마지막에 저장된 것을 제일 먼저 꺼내게 된다
    • 활용 예시) 수식계산, 웹브라우저의 뒤로/앞으로

 

 

Stack의 메서드

boolean empty() Stack이 비어있는지 알려준다
Object peek() Stack의 맨 위에 저장된 객체를 반환
Object pop() Stack의 맨 위에 저장된 객체를 꺼낸다(삭제)
Object push(Object item) Stack에 객체(item)을 저장한다
int search(Object o) Stack에서 주어진 객체를 찾아서 그 위치를 반환.
만약 못찾으면 -1을 반환
(배열과 달리 0이 아닌 1부터 시작(처음이 1))

 

Queue

  • 제일 먼저 저장한 것을 제일 먼저 꺼내게 된다
  • 활용 예시) 최근 사용문서, 인쇄작업 대기목록 (중 제일 먼저 저장한 것을 제일 먼저 꺼내게 된다)

 

 

Queue의 메서드

isEmpty() 비어있는지 확인
boolean add(Object o) 지정된 객체를 Queue에 추가한다.
Object remove() Queue에서 객체를 꺼내 반환. (삭제)
Object element() 삭제 없이 요소를 읽어옴.
boolean offer(Object o) Queue에 객체(item)을 저장한다
Object poll() Queue에서 객체를 꺼내 반환.(삭제) 비어있으면 null 반환.
Object peek() 삭제 없이 요소를 읽어온다.



Iterator, Listlterator, Eunmeration

  • 컬렉션에 저장된 요소를 접근하는데 사용되는 인터페이스
  • Eunmeration : Iterator의 구버전
  • Listlterator : Iterator의 접근성을 향상시킨 것 (단뱡향 → 양방향)

 

 

Iterator

  • 컬렉션 요소에 접근할 때 단반향으로만 이동할 수 있음
  • 컬렉션에 저장된 요소들을 읽어오는 방법을 표준화한 것
    • 코드의 재사용성을 높임
    • 1회용
    • 재사용을 위해 불러올 때 it = original.iterator(); 해도 됨 (앞의 Iterator 생략)
  • 메서드
    • it.hasNext() : 읽어올 요소가 있는지 확인 (true/false)
    • it.next() : 다음 요소를 읽어옴 (hasNext() 후에 하는게 기본적임)
  • 컬렉션에 iterator()을 호출 → Iterator을 구현한 객체를 얻어서 사용
List list = new ArrayList();
Iterator it = list.iterator(); //Iterator객체를 반환. 1회용.

while(it.hasNext()) {    //읽어올 요소 있는지 확인
	System.out.println(it.next()); //요소를 읽기
}

public interface Collection {
	...
	public Iterator iterator();
	...
}
  • Map에는 iterator() 직접 호출 불가능
    • 키와, 값을 쌍으로 갖고있어서
    • KeySet(), entrySet() 을 통해 키와 값을 따로 얻음 -> 다시 iterator() 호출
Map map = new HashMap();

//문장(1)
Iterator it = map.entrySet().iterator();

//문장(1) - 같은문장
Set eSet = map.entrySet();
Iterator it = eSet.iterator();

 

 

 

Listlterator

  • Iterator을 상속받아 기능을 추가한 것
  • 컬렉션 요소에 접근할 때 양방향으로 이동이 가능함
  • ArrayList나 LinkedList 같은 List인터페이스를 구현한 컬렉션에서만 사용가능
  • 예시 ) ListIterator it = list.listIterator();
  • 메서드
    • it.add(Object o) : 컬렉션에 새로운 객체를 추가함
    • it.hasNext() : 읽어올 다음요소가 있는지 확인
    • it.hasPrevious() : 읽어올 이전요소가 있는지 확인
    • it.next() : 다음 요소를 읽어옴
    • it.previous() : 이전요소를 읽어옴
    • it.nextIndex() : 다음요소의 index를 반환
    • it.previousIndex() : 이전요소의 index를 반환
    • it.remove() : next() 나 previous() 로 읽어온 요소를 삭제 (전에 그런 객체가 없으면 사용하지 말아야함)
    • it.set(Object o) : next() 나 previous() 로 읽어온 요소를 지정된 객체로 변경 (위와 동일)



Comparator과 Comparable

  • 객체 정렬에 필요한 메서드를 정의한 인터페이스 (정렬기준 제공)
    • Comparable : 기본 정렬기준을 구현하는데 사용 (자동정렬  ex.오름차순)
    • Comparator : 기본 정렬기준 외에 다른 기준으로 정렬하고자 할 때 사용
public interface Comparator {
	int compare(Object o1, Object o2);   // o1, o2 두 객체를 비교
	boolean equals(Object obj);    // equals를 오버라이딩하라는 뜻
}

public interface Comparable {
	int compareto(Object obj);    // 주어진 객체(o)를 자신(this)과 비교
}

// 비교 결과 값이 같으면 0, 오른쪽이 크면 음수(-), 작으면 양수(+)
  • compare(), compareTo()는 두 객체의 비교결과를 반환하도록 작성
    • 비교 결과 값이 같으면 0, 오른쪽이 크면 음수(-), 작으면 양수(+)



 

 

Collections

  • 컬렉션과 관련된 메서드를 제공
  • 컬렉션 채우기, 복사, 정렬, 검색 - fill(), copy(), sort(), binarySearch()

 

컬렉션의 동기화

  • synchronizedXXX()
  • 구버전은 자체적으로 동기화가 되어있음 (Vector, Hashtable)
    • 새로 추가된 버전은 동기화가 안되어있음 (ArrayList, HashMap)
    • 동기화 : 동기화된 해당 특성 외에는 접근 불가능하게 하는것
  • java.util.Collections 클래스 내의 동기화 메서드를 이용
    • static Collection synchronizedCollection (Collection c)
    • static List synchronizedList (List list)
    • static Set synchronizedSet (Set s)
    • static Map synchronizedMap (Map m)
    • static SortedSet synchronizedSortedSet (SortedSet s)
    • static sortedMap synchronizedSortedMap (SortedMap m)
  • 위를 아래와 같이 활용
    • List syncList = Collections.synchronizedList (new ArrayList(...));

 

 

변경불가 컬렉션 만들기

  • 컬렉션의 데이터를 보호하기 위해 읽기전용으로 만들기 (변경 불가) 
    • static Collection unmodifiableCollection(Collection c)
    • static List unmodifiableList (List list)
    • static Set unmodifiableSet (Set s)
    • static Map unmodifiableMap (Map m)
    • static NavigableSet unmodifiableNavihableSet (NavigableSet s)
    • static sortedSet unmodifiableSortedSet (SortedSet s)
    • static NavigableMap unmodifiavleNavigableMap (NavigableMap m)
    • static SortedMap unmodifiavleSortedMap (SortedMap m)

 

 

싱글톤 컬렉션 만들기

  • 단 하나의 객체만을 저장하는 컬렉션 만들기
    • static List singletonList (Object o)
    • static Set singleton (Object o)
    • static Map singletonMap (Object key, Object value)

 

 

한 종류의 객체만 저장하는 컬렉션 만들기

  • 한 종류의 객체만!
    • 지네릭스로 간단히 처리할 수 있음
    • 지네릭스 나오기 전에 지네릭스 대신 썼었음
    • 이젠 잘 안씀
static Collection checkedCollection(Collection c, Class type)
static List checkedList (List list, Class type)
static Set checkedSet (Set s, Class type)
static Map checkedMap (Map m, class keyType, class valueType)
static Queue checkedQueue (Queue queue, Class type)
static NavigableSet checkedNavigableSet (NavigableSet s, Class type)
static SortedSet checkedSortedSet (SortedSet s, Class type)
static NavigableMap checkedNavigableMap (NavigableMap m, Class keytype, Class valuetype)
static SortedMap checkedSortedMap (SortedMap m, Class keyType, Class valueType)

//사용방법

List list = new ArrayList();
List checkedList = checkedList(list, String.class); //String 클래스 타입만 넣을 수 있다
checkedList.add("abc");
checkedList.add(new Integer(3)); //에러 뜸.

 

 

 

열거헝 enum

  • 서로 관련된 여러 상수를 편리하게 선언함
  • enum 열거형이름 { 상수명1, 상수명2, ...}
  • java.lang.Enum 메서드
    • Class<E> getDeclaringClass() : 열거형의 Class 객체를 반환
    • String name()  : 열거형 상수의 이름을 문자열로 반환
    • int ordinal() : 열거형 상수가 정의된 순서를 반환 (0부터 시작)
    • T valueOf(Class<T> enumType, String name) : 지정된 열거형에서 name과 일치하는 열거형 상수를 반환
    • valueOf(String name) : 위와 같음.
  • 열거형에 멤버 추가하기
    • enum Direction {
    • EAST(1), SOUTH(5);
    • private final int value;
    • }




컬렉션 프레임웍

  • 컬렉션을 다루기 위한 표준화된 프로그래밍 방식
    • 컬렉션 : 다수의 객체를 모은 그룹
    • 프레임웍 : 표준화/정형화된 체계적인 프로그래밍 방식
  • 컬렉션을 쉽고 편리하게 다룰 수 있는 다양한 클래스를 제공
  • java.util패키지에 포함.
  • List, set, Map
    • List : 순서가 있는 데이터의 집합. 중복 O
    • Set : 순서가 없는 데이터의 집합. 중복 X
    • Map : 키(id)와 값(pwd)의 쌍으로 이루어진 데이터의 집합 (값만 중복 허용)

 

컬렉션 클래스

  • 다수의 데이터를 저장할 수 있는 클래스

주의사항

  • Vector, Hashtable과 같은 기존의 컬렉션클래스들은 가능하면 사용하지 않는 것이 좋다
  • 대신 새로 추가된 ArrayList나 HashMap 을 이용하자

 

 

 

Collection 인터페이스

  • List와 Set의 조상
  • 컬렉션을 검색, 추가, 삭제하는 기본적인 메서드를 정의함
    • boolean이 붙은 메서드는, 작업이 성공하면 true, 아니면 false 반환
  • 메서드
    • 추가
      • boolean add(Object o), addAll(Collection c) : 지정된 객체, Collection의 객체들을 추가
    • 검색
      • binarySearch(list, 3) : list의 인덱스 3 부분을 반환
      • boolean contains(Object o), containsAll(Collection c)
        • : 지정된 객체, Collection의 객체들이 포함되어 있는지 확인
      • boolean equals(Object o) : 동일한 Collection 인지 확인
      • hashCode() : Collection의 hashcode를 반환
      • boolean isEmpty() : Collection이 비어있는지 확인
      • iterator() : Collection의 iterator을 얻어서 반환
    • 삭제
      • clear() : Collection의 모든 객체를 삭제
      • boolean remove(Object o) : 지정된 객체를 삭제
      • boolean removeAll(Collection c) : 지정된 Collection에 포함된 객체들을 삭제
      • retainAll(Collection c) : 지정된 Collection에 포함된 객체만을 남기고 다른 객체들은 Collection에서 삭제
    • 반환
      • size() : Collection에 저장된 객체의 개수를 반환




List 인터페이스

  • 중복 허용, 저장 순서가 유지되는 컬렉션을 구현하는 데 사용함
  • ArrayList, LinkedList
  • 메서드
    • 추가
      • add(index, object), addAll(index, object) : 지정된 인덱스에 객체/컬렉션에 포함된 객체들을 추가함
    • 검색
      • get(index) : 지정된 인덱스에 있는 객체를 반환
      • indexOf(Object o) : 지정된 객체의 위치를 반환 (첫번째 요소부터 찾음)
      • lastIndexOf(Object o) : 지정된 객체의 위치를 반환 (마지막 요소부터 찾음)
    • 삭제
      • remove(index) : 지정된 인덱스에 있는 객체를 삭제. 삭제된 객체를 반환
    • 변경
      • sort(Comparator c) : 지정된 비교자로 List를 정렬함
      • subList(a,b) : 지정된 인덱스 a부터 b까지의 객체를 반환



ArrayList

  • 기존의 List 중 Vector를 개선함(기능적인 면에서 비슷함)
  • Object 배열이 멤버변수로 있기에, 모든 종류의 객체를 담을 수 있다
  • Object 배열을 이용해서 순차적으로 데이터를 저장
    • 첫번째로 저장한 객체 → Object 0번째 위치에 저장
    • 두번째로 저장한 객체 → Object 1번째 위치에 저장
  • 메서드


생성

ArrayList() 크기가 10인 ArrayList를 생성
ArrayList(Collection c) 주어진 컬렉션이 저장된 ArrayList를 생성
ArrayList(int initialCapacity) 지정된 초기 용량을 갖는 ArrayList를 생성


추가

boolean add(Object o) ArrayList의 마지막에 객체를 추가. 성공하면 true.
void add(int) 지정된 위치(index)에 객체를 저장
boolean addAll(Collection c) 주어진 컬렉션의 모든 객체를 저장한다
boolean addAll(int index, Collection c) 지정된 위치부터 주어진 컬렉션의 모든 객체를 저장한다


삭제

boolean remove(Object o) 지정된 객체를 제거한다. 성공하면 true.
Object remove(int index) 지정된 위치(index)에 있는 객체를 제거한다
boolean removeAll(Correction c) 지정된 컬렉션에 저장된 것과 동일한 객체들을 ArrayList에서 제거한다
void clear() ArrayList의 모든 객체를 삭제한다


검색(1)

int indexOf(Object o) 지정된 객체가 저장된 위치를 찾아 반환한다
int lastIndexOf(Object o) 객체(o)가 저장된 위치를 끝부터 역뱡향으로 검색해서 반환
boolean contains(Object o) 지정된 객체(o)가 ArrayList에 포함되어 있는지 확인
Object get(int index) 지정된 위치(index)에 저장된 객체를 반환함
Object set(int index, Object element) 주어진 객체(element)를 지정된 위치(index)에 저장한다


검색(2)

List sublist(int fromIndex, int tolndex) fromIndex ~ tolndex까지 저장된 객체를 반환함
Object[] toArray() ArrayList에 저장된 모든 객체들을 객체배열로 반환함
Object[] toArray(Object[] a) ArrayList에 저장된 모든 객체들을 객체배열 a에 담아 반환함
boolean isEmpty() ArrayList가 비어있는지 확인한다
void trimToSize() 용량을 크기에 맞게 줄인다(빈 공간을 없앰)
int size() ArrayList에 저장된 객체의 개수를 반환한다




LinkedList

  • 배열의 단점을 보완함
    • 배열의 장점: 구조가 간단, 데이터를 읽는데 걸리는 시간이 짧다
    • 배열의 단점: 크기를 변경할 수 없다 (배열의 크기가 정해져 있어서)
      • 새로운 배열 생성 후 데이터를 복사해야 크기 변경 가능
      • 비순차적인 데이터는 추가, 삭제에 시간이 많이 걸림
  • 불연속적으로 존재하는 데이터를 연결함
    • 각각의 데이터가 노드로 구성되어있음 (변경이 쉽다)
    • 각각의 노드는 다음노드, 이전노드 값을 내부적으로 가짐
  • Arraylist vs LinkList
    • 순차적으로 추가, 삭제 : ArrayList가 빠름
    • 비순차적으로 추가, 삭제 : LinkedList가 빠름
    • 접근시간 : ArrayList가 빠름
      • 인덱스가 n인 데이터의 주소 = 배열의주소 + n * 데이터 타입의 크기
  • 메서드 종류/기능은 ArrayList와 거의 같다
  • 그 외 메서드
    • addFirst(1) : 가장 앞에 데이터 추가
    • addLast(2) : 가장 뒤에 데이터 추가
    • removeFirst() : 가장 앞의 데이터 삭제
    • removeLast() : 가장 뒤의 데이터 삭제



Linked list

  • 연결리스트. 데이터 접근성이 나쁨(앞으로 이동 접근만 가능)

doubly linked list

  • 이중 연결리스트. 접근성 향상(위치 앞뒤 이동 접근 가능)

doubly circular linked list

  • 이중 원형 연결리스트. 접근성 향상(위치 앞뒤, 앞과 맨끝 이동 접근 가능)

 

 

 

Set 인터페이스

  • 중복 허용 X. 저장순서 유지되지 않는 컬렉션 클래스를 구현하는 데 사용됨
  • HashSet, TreeSet
  • Collection 인터페이스와 메서드가 동일하다

 

Hashset

  • 순서X, 중복X
    • 객체를 저장하기 전에 기존에 같은 객체가 있는지 확인
    • int a = 1 과, Integer a = 1 은 서로 다른 객체로 취급함 (같은 1로 중복값이 가능)
    • 같은 객체가 없으면 저장, 있으면 저장하지 X
  • Set인터페이스를 구현한 대표적인 컬렉션 클래스
  • 저장 순서를 유지하려면, LinkedHashSet클래스를 사용하면 된다
  • 메서드
    • 생성
      • HashSet() : HashSet 객체를 생성
      • HashSet(Collection c) : 컬렉션을 포함하는 HashSet객체 생성
      • HashSet(int initialCapacity) : 주어진 값을 초기용량으로 하는 HashSet객체 생성
      • HashSet(int initialCapacity, float loadFactor) : 초기용량 , loadFactor(컬렉션 공간이 이정도 꽉차면 2배로 늘린다는 뜻 (0~1))
    • 추가
      • boolean add(Object o) : 객체 추가
      • boolean addAll(Collection c) : 모든 객체 추가 (합집합)
    • 삭제
      • boolean remove(Object o) : 객체 삭제
      • boolean removeAll(Collection c) : 컬렉션 내 객체들 모두 삭제 (교집합)
      • boolean retainAll(Collection c) : 컬렉션 내 객체들과 동일한 것만 남김 (차집합)
      • void clear() : 전체 삭제
    • 포함
      • boolean contains(Object o) : 해당 객체를 포함하고 있는지
      • boolean containsAll(Collection c) : 컬렉션 내 객체들을 모두 포함하고 있는지
      • boolean isEmpty() : HashSet이 비어있는지
    • 반환
      • lterator iterator() : Iterator 을 반환
      • int size() : 저장된 객체의 개수를 반환
      • toArray() : 저장된 객체들을 객체 배열의 형태로 반환
      • toArray(Object[] a) : 저장된 객체들을 주어진 객체배열에 담는다

 

 

TreeSet

  • 순서O(set이라 안되지만 이진탐색트리라서. 대문자가 앞순위로 옴), 중복 X
  • HashSet 보다 추가, 삭제 시간이 오래 걸림(이진탐색트리 구조라서)
  • LinkedList 보다 범위 검색과 정렬에 유리한 컬렉션 클래스

 

주요 메서드

  • 생성
    • TreeSet() : 기본 생성자
    • TreeSet(Collection c) : 컬렉션을 저장하는 TreeSet 생성
    • TreeSet(Comparator comp) : 주어진 정렬조건으로 정렬하는 TreeSet을 생성
  • 추가
    • add(Object o) : 객체 추가
    • addAll(Collection c) : 컬렉션의 객체들 추가
  • 반환
    • Object first() : 첫번째 객체를 반환
    • Object last() : 마지막 객체를 반환
    • Object ceiling(Object o) : 지정된 객체와 같거나 큰값(제일 가까운 값)을 가진걸 반환
    • Object floor(Object o) : 지정된 객체와 같거나 작은값(제일 가까운 값)을 가진걸 반환
    • Object higher(Object o) : 지정된 객체보다 큰 값(제일 가까운 값)을 반환
    • Object lower(Object o) : 지정된 객체보다 작은 값(제일 가까운 값)을 반환
  • 반환 
    • SortedSet subSet(Object fromElement, Object toElement) : fromElement~toElement 사이 결과 반환
    • SortedSet headSet(Object toElement) : 객체보다 작은 값들 반환
    • SortedSet tailSet(Object fromElement) : 객체보다 큰 값들 반환

 

 

HashMap

  • Hashtable의 신버전.
  • 해싱 함수를 이용한 Map
    • Hashtable : 링크드리스트가 배열로 조합된 형태
    • hashing : 사용자의 키값 -> 해시함수 -> 해시코드(배열의 인덱스)로 반환해 데이터를 검색
  • 키와 값으로 구성된 객체를 저장
    • 값은 중복 허용
    • hashTable 과 다르게 key, value 값에 null을 허용함
  •  스레드가 안전하지 않음 (멀티스레드 X. 싱글스레드에서 사용 권장)
    • synchronized 키워드가 없어서 동기화가 보장되지 못함
    • 두 스레드에서 같은 hashmap에 동시 접근시, 
      스레드a가 캐시값을 업데이트 해도, 스레드 b는 또 연산을 하게 됨
    • 캐시 : 동일한 input에 대해 같은 작업을 하지 않도록 하는 것

 

 

주요 메서드

  • 생성
    • HashMap() : 객체 생성
    • HashMap(int initialCapacity) : 지정된 초기용량으로하는 객체 생성
    • HashMap(int initialCapacity, float loadFactor) : 지정된 초기용량, 얼만큼 찼을때 용량을 늘린건지
    • HashMap(Map m) : m의 모든 요소를 포함한 HashMap 생성
  • 추가
    • Object put(Object key, Object value) : 지정된 키와 값을 저장
    • void putAll(Map m) : m의 모든 요소를 저장
  • 삭제
    • Object remove(Object key) : 지정된 키와 연결된 값 둘다 제거
    • void clear() : 전체 삭제
  • 변경
    • Object replace(Object key, Object value) : 지정된 키의 값을 value로 변경
    • boolean replace(Object key, Object oldValue, Object newValue) : 지정된 키와 oldValue가 모두 일치하면, newValue로 대체
  • 반환
    • Set entrySet() : 저장된 키와 값을 entry(키와 값의 결합) 형태로 Set에 저장해서 반환
    • Set keySet() : 저장된 모든 키를 Set에 저장해서 반환
    • Collection values() : 저장된 모든 값을 컬렉션의 형태로 반환
    • Object get(Object key) : 키의 값을 반환.
    • Object getOrDefault(Object key, Object defaultValue) : 키의 값을 반환
      • 키가 hashmap 안에 없을시 → defaultValue을 반환.
  • 포함 확인
    • boolean containsKey(Object key) : 키가 포함되어 있는지 확인
    • boolean containsValue(Object value) : 값이 포함되어 있는지 확인
  • 그 외
    • int size() : 크기 확인
    • boolean isEmpty() : 비어있는지
    • Object clone() : 복제

 

 

해싱과 해싱함수

  • 해싱 : 해시함수를 이용해 데이터를 해시테이블에 저장하고 검색하는 기법
  • HashSet, HashMap

 

저작자표시