Java Collection

Java에서 컬렉션이란 데이터의 집합, 그룹을 의미하며, JCF(Java Collections Framework)는 이러한 데이터, 자료구조인 컬렉션과 이를 구현하는 클래스를 정의하는 인터페이스를 제공한다.

다음은 Java 컬렉션 프레임워크의 상속구조를 나타낸다.

Collection 인터페이스는 List, Set, Queue로 크게 3가지 상위 인터페이스로 분류할 수 있다.

그리고 여기에 Map의 경우 Collection 인터페이스를 상속 받고 있지 않지만 Collection으로 분류된다.

 

Collection 인터페이스의 특징

인터페이스  구현클래스  특징 
 List  LinkedList
Vector
ArrayList
Stack		  순서가 있는 데이터의 집합으로 데이터의 중복을 허용한다.
 Set  HashSet
TreeSet		  순서를 유지하지 않는 데이터의 집합으로 데이터의 중복을 허용하지 않는다.
 Queue PriorityQueue 데이터의 선입선출, 순서가 중요한 업무에서 사용
 Map  Hashtable
HashMap
TreeMap		  키(Key), 값(Value)의 쌍으로 이루어진 데이터의 집합으로,
순서는 유지되지 않으며 키(Key)의 중복을 허용하지 않으나 값(Value)의 중복은 허용한다.
  1. List 인터페이스
    순서가 있는 데이터의 집합으로 데이터의 중복을 허용한다.
    1. LinkedList
      1. 양방향 포인터 구조로 데이터의 삽입, 삭제가 빈번할 경우 데이터의 위치정보만 수정하면 되기에 유용
      2. 스택, 큐, 양방향 큐 등을 만들기 위한 용도로 쓰임
    2. Vector
      1. 과거에 대용량 처리를 위해 사용했으며, 내부에서 자동으로 동기화 처리가 일어나 비교적 성능이 좋지 않고 무거워 잘 쓰이지 않음
    3. ArrayList
      1. 단방향 포인터 구조로 각 데이터에 대한 인덱스를 가지고 있어 조회 기능에 성능이 뛰어남
  2. Set 인터페이스
    순서를 유지하지 않는 데이터의 집합으로 데이터의 중복을 허용하지 않는다.
    1. HashSet
      1. 가장 빠른 임의 접근 속도
    2. TreeSet
      1. 정렬방법을 지정할 수 있음
  3. Map 인터페이스
    키(Key), 값(Value)의 쌍으로 이루어진 데이터의 집합으로, 순서는 유지되지 않으며 키(Key)의 중복을 허용하지 않으나 값(Value)의 중복은 허용한다.
    1. Hashtable
      1. HashMap보다는 느리지만 동기화 지원
      2. null 불가
    2. HashMap
      1. 중복과 순서과 허용되지 않으며 null 값이 올 수 있다.
    3. TreeMap
      1. 정렬된 순서대로 키(Key)와 값(Value)을 저장하여 검색이 빠름

ArrayList

ArrayList는 List 인터페이스를  상속받은 클래스로 크기가 가변적으로 변하는 선형리스트이다. 일반적인 배열과 같은 순차리스트이며 인덱스로 내부의 객체를 관리한다는 점이 유사하지만 한번 생성되면 크기가 변하지 않는 배열과는 달리 ArrayList는 객체들이 추가되어 저장 용량을 초과한다면 자동으로 부족한 크기만큼 저장 용량이 늘어난다는 특징을 갖고 있다.

ArrayList 사용법

ArrayList 선언

ArrayList list = new ArrayList();//타입 미설정 Object로 선언된다.
ArrayList<Student> members = new ArrayList<Student>();//타입설정 Student객체만 사용가능
ArrayList<Integer> num = new ArrayList<Integer>();//타입설정 int타입만 사용가능
ArrayList<Integer> num2 = new ArrayList<>();//new에서 타입 파라미터 생략가능
ArrayList<Integer> num3 = new ArrayList<Integer>(10);//초기 용량(capacity)지정
ArrayList<Integer> list2 = new ArrayList<Integer>(Arrays.asList(1,2,3));//생성시 값추가

 

ArrayList 선언 시 ArrayList list = new ArrayList()로 선언 후 내부에 임의의 값을 넣고 사용할 수도 있지만, 이렇게 사용할 경우 값을 뽑아내기 위해서는 캐스팅(Casting) 연산이 필요하고 잘못된 타입으로 캐스팅을 한 경우에는 에러가 발생하기 때문에 위와 같은 방식으로 사용하는 것을 지양한다. ArrayList를 사용할 경우 ArrayList에 타입을 명시해주는 것이 좋다. JDK 5.0 이후부터 자료형의 안정성을 위해 제너릭(Generics)라는 개념이 도입되었다. ArrayList<String> list = new ArrayList<String>();이라고 되어있다면 String 객체들만 add 될 수 있고, 다른 타입의 객체는 사용이 불가능하다.

ArrayList 값 추가

ArrayList<Integer> list = new ArrayList<Integer>();
list.add(3); //값 추가
list.add(null); //null값도 add가능
list.add(1,10); //index 1에 10 삽입

ArrayList<Student> members = new ArrayList<Student>();
Student student = new Student(name,age);
members.add(student);
members.add(new Member("홍길동",15));

 

ArrayList에 값을 추가하려면 ArrayList의 add(index, value) 메소드를 사용하면 된다. index를 생략하면 ArrayList 맨 뒤에 데이터가 추가되며 index 중간에 값을 추가하면 해당 인덱스부터 마지막 인덱스까지 모두 1씩 뒤로 밀려난다. 이 경우 데이터가 늘어나면 늘어날 수록 성능에 악영향을 미치기 때문에 ArrayList 중간에 데이터를 insert 해야할 경우가 많다면 ArrayList보다는 LinkedList를 활용하는 것도 좋은 방법이다.

ArrayList 값 변경

ArrayList<Integer> list = new ArrayList<Integer>();
list.add(1,10); //index 1에 10 삽입
list.set(1,15); //index 1이 15로 변경

 

ArrayList에 이전에 추가된 값을 바꾼다.

ArrayList 값 삭제

ArrayList<Integer> list = new ArrayList<Integer>(Arrays.asList(1,2,3));
list.remove(1);  //index 1 제거
list.clear();  //모든 값 제거

ArrayList에 값을 제거하려면 ArrayList의 remove(index) 메소드를 사용하면 된다. remove()함수를 사용하여 특정 인덱스의 객체를 제거하면 바로 뒤 인덱스부터 마지막 인덱스까지 모두 앞으로 1씩 당겨진다. 모든 값을 제거하려면 clear() 메소드를 사용하면 된다.

ArrayList 크기 구하기

ArrayList<Integer> list = new ArrayList<Integer>(Arrays.asList(1,2,3));
System.out.println(list.size()); //list 크기 : 3

ArrayList 값 출력

ArrayList<Integer> list = new ArrayList<Integer>(Arrays.asList(1,2,3));

System.out.println(list.get(0));//0번째 index 출력
		
for(Integer i : list) { //for문을 통한 전체출력
    System.out.println(i);
}

Iterator iter = list.iterator(); //Iterator 선언 
while(iter.hasNext()){//다음값이 있는지 체크
    System.out.println(iter.next()); //값 출력
}

ArrayList의 get(index) 메소드를 사용하면 ArrayList의 원하는 index의 값이 리턴된다. 전체출력은 대부분 for문을 통해서 출력을 하고, Iterator를 사용해서 출력할 수도 있다.

ArrayList 값 검색

ArrayList<Integer> list = new ArrayList<Integer>(Arrays.asList(1,2,3));
System.out.println(list.contains(1)); //list에 1이 있는지 검색 : true
System.out.println(list.indexOf(1)); //1이 있는 index반환 없으면 -1

ArrayList에서 찾고자 하는 값을 검색하려면 ArrayList의 contains(value) 메소드를 사용하면 된다. 만약 값이 있다면 true가 리턴되고 값이 없다면 false가 리턴된다. 값이 있는 index를 찾으려면 indexOf(value) 메소드를 사용하면 된다. 만약 값이 없다면 -1을 리턴한다.

LinkedList

연결 리스트(LinkedList)는 각 노드가 데이터와 포인터를 가지고 한 줄로 연결되어 있는 방식의 자료구조이다. 데이터를 담고 있는 노드들이 연결되어 있고, 노드의 포인터가 이전 노드와 다음 노드와의 연결을 담당한다. Node는 LinkedList에 객체를 추가하거나 삭제하면 앞 뒤 링크만 변경되고, 나머지 링크는 변경되지 않는다. 중간에 데이터를 추가, 삭제하더라도 전체의 인덱스가 한 칸 씩 뒤로 밀리거나 당겨지는 일이 없기 때문에, ArrayList에 비해서 데이터의 추가가 삭제가 용이하다. 하지만 인덱스가 없기 때문에 특정 요소에 접근하기 위해서는 순차 탐색이 필요하여 탐색 속도가 떨어진다는 단점이 있다. 따라서 탐색 또는 정렬을 자주 하는 경우에는 배열을 사용하고, 데이터의 추가/삭제가 많은 경우 연결리스트를 사용하는 것이 좋다.

ArrayList는 내부 배열에 객체를 저장해서 인덱스로 관리하는데 비해, LinkedList는 위와 같이 인접 참조를 링크해서 체인처럼 관리한다.

LinkedList 사용법

LinkedList 선언

LinkedList list = new LinkedList();//타입 미설정 Object로 선언된다.
LinkedList<Student> members = new LinkedList<Student>();//타입설정 Student객체만 사용가능
LinkedList<Integer> num = new LinkedList<Integer>();//타입설정 int타입만 사용가능
LinkedList<Integer> num2 = new LinkedList<>();//new에서 타입 파라미터 생략가능
LinkedList<Integer> list2 = new LinkedList<Integer>(Arrays.asList(1,2));//생성시 값추가


LinkedList 선언은 ArrayList 선언 방식과 같다. LinkedList에서는 초기의 크기를 미리 생성할 수 없다. LinkedList 선언 시 LinkedList list = new LinkedList()로 선언하고 내부에 임의의 값을 넣어 사용할 수도 있지만, 이렇게 사용할 경우 내부의 값을 사용할 때 캐스팅(Casting)을 해야 하고 잘못된 타입으로 캐스팅을 한 경우에는 에러가 발생한다. LinkedList를 생성할 때  LinkedList에 사용 타입을 명시해주는 것이 좋다. LinkedList<Integer> list = new LinkedList<Integer>();라면 int 자료형만 사용할 수 있고, 다른 타입은 사용이 불가능하다.

LinkedList 값 추가

LinkedList<Integer> list = new LinkedList<Integer>();
list.addFirst(1);//가장 앞에 데이터 추가
list.addLast(2);//가장 뒤에 데이터 추가
list.add(3);//데이터 추가
list.add(1, 10);//index 1에 데이터 10 추가

LinkedList<Student> list = new LinkedList<Student>();
Student student = new Student(name,age);
members.add(student);
members.add(new Member("홍길동",15));

LinkedList에 값을 추가하는 방법은 여러 개가 있는데, 보통 add(index, value) 메소드를 사용한다. index를 생략하면 가장 마지막에 데이터가 추가된다. addFirst(value)함수를 사용하게 되면 가장 앞에 있는 Header의 값이 변경되고 addLast(value) 메소드를 사용하면 LinkedList 맨 뒤에 데이터가 추가된다.

LinkedList의 값이 추가되는 방식은 위의 그림과 같다. 먼저 인자로 받은 값을 가지고, Node를 생성하여 이전 노드는 추가되는 노드를 가리키게 하고, 추가되는 노드는 그 다음 노드를 가리키도록 지정한다.

LinkedList 값 삭제

LinkedList<Integer> list = new LinkedList<Integer>(Arrays.asList(1,2,3,4,5));
list.removeFirst(); //가장 앞의 데이터 제거
list.removeLast(); //가장 뒤의 데이터 제거
list.remove(); //생략시 0번째 index제거
list.remove(1); //index 1 제거
list.clear(); //모든 값 제거

LinkedList에 값을 제거하는 방법도 값을 추가하는 것과 비슷하다. removeFirst() 메소드를 사용하면 가장 첫 데이터가 removeLast()를 사용하면 가장 뒤에 있는 데이터가 삭제된다. remove(index, value)를 사용하여 특정 index의 값을 제거할 수도 있다. 값을 전부 제거하려면 clear()메소드를 사용하면 된다.

LinkedList의 값이 제거되는 방식은 위의 그림과 같다. 삭제 대상 노드의 이전 노드가 삭제 대상 노드의 다음 노드를 가리키게 하고 해당 노드는 삭제된다.

LinkedList 크기 구하기

LinkedList<Integer> list = new LinkedList<Integer>(Arrays.asList(1,2,3));
System.out.println(list.size()); //list 크기 : 3

LinkedList 값 출력

LinkedList<Integer> list = new LinkedList<Integer>(Arrays.asList(1,2,3));

System.out.println(list.get(0));//0번째 index 출력
				
for(Integer i : list) { //for문을 통한 전체출력
    System.out.println(i);
}

Iterator<Integer> iter = list.iterator(); //Iterator 선언 
while(iter.hasNext()){//다음값이 있는지 체크
    System.out.println(iter.next()); //값 출력
}

LinkedList의 get(index) 메소드를 사용하면 LinkedList의 원하는 index의 값이 리턴된다. 전체 출력은 대부분 for 문을 통해서 출력을 하고 Iterator(반복자)를 사용해서 출력을 할 수도 있다. LinkedList의 경우 인덱스를 사용하여 연산을 수행할 수 있도록 get(index) 메소드를 제공하지만, 메소드 내부의 동작은 순차 탐색으로 이루어져 있어 ArrayList의 get(index) 메소드보다 속도가 느리다.

LinkedList 값 검색

ArrayList<Integer> list = new ArrayList<Integer>(Arrays.asList(1,2,3));
System.out.println(list.contains(1)); //list에 1이 있는지 검색 : true
System.out.println(list.indexOf(1)); //1이 있는 index반환 없으면 -1

 

LinkedList에서 찾고자 하는 값을 검색하려면 LinkedList의 contains(value) 메소드를 사용하면 된다. 만약 값이 있다면 true가 리턴되고 값이 없다면 false가 리턴된다. 값이 있는 index를 찾으려면 indexOf(value) 메소드를 사용하면 되고, 만약 값이 있다면 -1을 리턴한다.

 

Stack

상자에 물건을 쌓아 올리듯이 데이터를 쌓는 구조라고 할 수 있다. Stack의 가장 큰 특징은 나중에 들어간 것이 먼저 나오는(Last In First Out)의 형태를 띈다는 것이다. 이 방식을 가진 자료구조인 Stack을 활용하여 다양한 문제를 해결할 수 있다. 자바에서 Stack은 java.util.Stack을 import하면 바로 사용할 수 있다.

Stack의 특징

  1. 먼저 들어간 자료가 나중에 나온다. LIFO(Last In First Out) 구조
  2. 시스템 해킹에서 버퍼오버플로우 취약점을 이용한 공격을 할 때 스택 메모리의 영역에서 함
  3. 인터럽트처리, 수식의 계산, 서브루틴의 복귀 번지 저장 등에 쓰인다.
  4. 그래프의 깊이 우선 탐색(DFS)에 사용
  5. 재귀적(Recursion) 함수를 호출할 때 사용

Stack 사용법

Stack 선언

import java.util.Stack; //import
Stack<Integer> stack = new Stack<>(); //int형 스택 선언
Stack<String> stack = new Stack<>(); //char형 스택 선언

Java에서 Stack을 선언하려면 <stack> import java.util.Stack을 import한 뒤 Stack<Element> Stack = new Stack<>();과 같은 형식으로 선언하면 된다.

Stack 값 추가

Stack<Integer> stack = new Stack<>(); //int형 스택 선언
stack.push(1);     // stack에 값 1 추가
stack.push(2);     // stack에 값 2 추가
stack.push(3);     // stack에 값 3 추가

Stack에 값을 추가하고 싶다면 Push(value)라는 메소드를 활용하면 된다. Stack에 위의 예제와 같이 값을 계속해서 추가해나간다면 아래 그림과 같이 데이터가 쌓이게 된다.

Stack 값 삭제

Stack<Integer> stack = new Stack<>(); //int형 스택 선언
stack.push(1);     // stack에 값 1 추가
stack.push(2);     // stack에 값 2 추가
stack.push(3);     // stack에 값 3 추가
stack.pop();       // stack에 값 제거
stack.clear();     // stack의 전체 값 제거 (초기화)

스택에서 값을 제거하고 싶다면 pop()이라는 메소드를 사용하면 된다. pop을 하면 가장 위쪽에 있는 원소의 값이 아래 그림과 같이 제거된다. 스택의 값을 모두 제거하고 싶다면 clear()라는 메소드를 사용하면 된다.

Stack 가장 상단의 값 출력

Stack<Integer> stack = new Stack<>(); //int형 스택 선언
stack.push(1);     // stack에 값 1 추가
stack.push(2);     // stack에 값 2 추가
stack.push(3);     // stack에 값 3 추가
stack.peek();     // stack의 가장 상단의 값 출력

스택의 가장 위에 있는 값을 출력하고 싶다면 peek()이라는 함수를 사용하면 된다. 아래 그림과 같이 가장 마지막에 들어간 값이 출력된다.

Stack의 기타 메소드

Stack<Integer> stack = new Stack<>(); //int형 스택 선언
stack.push(1);     // stack에 값 1 추가
stack.push(2);     // stack에 값 2 추가
stack.size();      // stack의 크기 출력 : 2
stack.empty();     // stack이 비어있는지 check (비어있다면 true)
stack.contains(1) // stack에 1이 있는지 check (있다면 true)

그 밖에도 Stack에는 크기를 구하는 size() 메소드와 stack이 비어있는지 확인하는 empty() 메소드(비어있다면 true, 그렇지 않다면 false를 return) stack의 값을 search하는 contains(int value) 함수가 있다.

 

Vector

Vector는 ArrayList와 동일한 내부구조를 가지고 있다. ArrayList와 마찬가지로 Vector 내부에 값이 추가되면 자동으로 크기가 조절되며 그 다음 객체들은 한 자리 씩 뒤로 이동한다.
Vector와 ArrayList의 한 가지 다른 점이 있는데, Vector는 동기화 된 메소드로 구성되어 있기 때문에 멀티 스레드가 동시에 이 메소드들을 실행할 수 없고, 하나의 스레드가 실행을 완료해야만 다른 스레드들이 실행할 수 있다. 그래서 멀티 스레드 환경에서 안전하게 객체를 추가하고 삭제할 수 있다.

Vector의 단점

벡터는 항상 동기화되는 장점이자 단점을 가지고 있다. 스레드가 1개일때도 동기화를 하기 때문에 ArrayList보다 성능이 떨어진다. ArrayList는 기본적인 기능은 벡터와 동일하나 자동 동기화 기능이 빠져있고, 동기화 옵션이 존재한다. 그리고 벡터에 비해 속도가 더 빠르기 때문에 벡테에 비해 많이 쓰인다.

Vector 사용법

Vector 선언

Vector v = new Vector();//타입 미설정 Object로 선언된다.
Vector<Student> student = new Vector<Student>(); //타입설정 Student객체만 사용가능
Vector<Integer> num2 = new Vector<Integer>(); //타입설정 int타입만 사용가능
Vector<Integer> num3 = new Vector<>(); //new에서 타입 파라미터 생략가능
Vector<String> v2 = new Vector<String>(10);//초기 용량(capacity)지정
Vector<Integer> v3 = new Vector<Integer>(Arrays.asList(1,2,3)); //초기값 지정

Vector 선언 시 타입을 지정하지 않고, 임의의 타입을 값을 넣고 사용할 수도 있지만, 이렇게 사용할 경우 벡터 내부의 값을 사용하려면 캐스팅(Casting)연산이 필요하며, 잘못된 타입으로 캐스팅을 한 경우에는 에러가 발생하기 때문에 Vector를 사용할 때는 타입을 명시해주는 것이 좋다. Vector<Integer> v = new Vector<Integer>();이라고 되어 있다면 int 객체들만 add 되어질 수 있고 다른 타입의 객체는 사용이 불가능하다.

Vector 값 추가

Vector<Integer> v = new Vector<Integer>();
v.add(3); //값 추가
v.add(null); //null값도 add가능
v.add(1,10); //index 1뒤에 10 삽입

Vector v = new Vector();
Student student = new Student(name,age);
v.add(student);
v.add(new Member("홍길동",15));

Vector에 값을 추가하려면 Vector 의 add(index, value) 메소드를 사용하면 된다. 구조는 ArrayList나 LinkedList와 같다. Index를 생략하면 Vector의 맨 뒤에 값이 추가되며 index 중간에 값을 추가하면 해당 인덱스부터 마지막 인덱스까지 모두 한 칸씩 뒤로 밀려난다.

Vector 값 삭제

Vector<Integer> v = new Vector<Integer>(Arrays.asList(1,2,3));
v.remove(1);  //index 1 제거
v.removeAllElements(); //모든 값 제거
v.clear();  //모든 값 제거

Vector에서 값을 삭제하려면 Vector와 remove(index) 메소드를 사용하면 된다. remove() 함수를 사용하여 특정 인덱스의 값을 제거하면 바로 뒤에 있는 인덱스부터 마지막 인덱스까지 모두 앞으로 한 칸씩 당겨진다. 모든 값을 제거하려면 clear() 메소드나 removeAllElements() 메소드를 사용하면 된다.

Vector 크기 구하기

Vector<Integer> v = new Vector<Integer>(10);//초기용량 10
v.add(1); //값 추가
System.out.println(v.size()); //Vector 자료 개수 : 1
System.out.println(v.capacity()); //Vector 물리적크기 : 10

Vector의 값이 들어있는 개수를 구하려면 size() 메소드를 사용하면 되고 물리적 크기를 알고 싶다면 capacity() 메소드를 사용하면 된다.

Vector 값 출력

Vector<Integer> list = new Vector<Integer>(Arrays.asList(1,2,3));

System.out.println(list.get(0));//0번째 index 출력
				
for(Integer i : list) { //for문을 통한 전체출력
    System.out.println(i);
}

Iterator iter = list.iterator(); //Iterator 선언 
while(iter.hasNext()){//다음값이 있는지 체크
    System.out.println(iter.next()); //값 출력
}

Vector에서 값을 출력하는 방법은 ArrayList와 동일하다. get(index) 메소드를 사용하면 Vector의 원하는 index의 값이 리턴된다. 전체 출력은 대부분 for문을 통해서 출력을 하고 Iterator를 사용해서 출력을 할 수 있다.

 

HashSet

HashSet은 Set 인터페이스의 구현 클래스이다. Set의 성질을 그대로 상속받는다. Set은 객체를 중복해서 저장할 수 없고, 하나의 null값만 저장할 수 있다. 저장 순서가 유지되지 않는다. 만약 요소의 저장 순서를 유지해야 한다면 JDK 1.4 부터 제공하는 LinkedHashSet 클래스를 사용하면 된다. Set 인터페이스를 구현한 클래스로는 HashSet과 TreeSet이 있는데, HashSet의 경우 정렬을 해주지 않고, TreeSet의 경우 자동정렬을 해준다는 차이점이 있다. Set의 가장 큰 장점은 중복을 자동으로 제거해준다는 점이다. Set의 모양은 아래와 같다.

Set은 위 그림과 같이 주머니 형태로 되어있다. 비선형 구조이기 때문에 순서가 없으며, 인덱스도 존재하지 않는다. 따라서 값을 추가하거나 삭제할 때 내가 추가/삭제하고자 하는 값이 Set 내부에 있는지 검색한 뒤 추가/삭제를 해야하므로 속도가 List 구조에 비해 느리다.

중복을 걸러내는 과정

HashSet은 객체를 저장하기 전에 먼저 객체의 hashCode()메소드를 호출해서 해시 코드를 얻어낸 다음 저장되어 있는 객체들의 해시 코드와 비교한 뒤 같은 해시 코드가 있다면 다시 equals() 메소드로 두 객체를 비교해서 True가 나오면 동일한 객체로 판단하고 중복 저장을 하지 않는다. 문자열을 HashSet에 저장할 경우, 같은 문자열을 갖는 String 객체는 동일한 객체로 간주되고 다른 문자열을 갖는 String 객체는 다른 객체로 간주되는데, 그 이유는 String 클래스가 hashCode()와 equals() 메소드를 재정의해서 같은 문자열일 경우 hashCode()의 리턴 값을 같게, equals()의 리턴 값은 true가 나오도록 했기 때문이다.

HashSet 사용법

HashSet 선언

HashSet<Integer> set1 = new HashSet<Integer>();//HashSet생성
HashSet<Integer> set2 = new HashSet<>();//new에서 타입 파라미터 생략가능
HashSet<Integer> set3 = new HashSet<Integer>(set1);//set1의 모든 값을 가진 HashSet생성
HashSet<Integer> set4 = new HashSet<Integer>(10);//초기 용량(capacity)지정
HashSet<Integer> set5 = new HashSet<Integer>(10, 0.7f);//초기 capacity,load factor지정
HashSet<Integer> set6 = new HashSet<Integer>(Arrays.asList(1,2,3));//초기값 지정

HashSet을 기본으로 생성했을 때에는 initial capacity(16), load factor(0.75)의 값을 가진 HashSet 객체가 생성된다. HashSet도 저장공간보다 값이 추가로 들어오면 List처럼 저장공간을 늘리는데 Set은 한 칸씩 저장공간을 늘리지 않고, 저장 용량을 약 두배로 늘린다. 여기서 과부하가 많이 발생한다. 따라서 초기에 저장할 데이터의 갯수를 알고 있다면, Set의 초기용량을 지정해주는 것이 좋다.

HashSet 값 추가

HashSet<Integer> set = new HashSet<Integer>();//HashSet생성
set.add(1); //값 추가
set.add(2);
set.add(3);

입력되는 값이 HashSet 내부에 존재하지 않는다면, 그 값을 HashSet에 추가하고 True를 반환하고, 내부에 값이 존재한다면 False를 반환한다.

HashSet 값 삭제

HashSet<Integer> set = new HashSet<Integer>(Arrays.asList(1,2,3));//HashSet생성
set.remove(1);//값 1 제거
set.clear();//모든 값 제거

매개변수 value의 값이 HashSet 내부에 존재한다면 그 값을 삭제한 후 true를 반환하고 없다면 false를 반환한다. 모든 값을 제거하려면 clear() 메소드를 사용하면 된다.

HashSet 크기 구하기

HashSet<Integer> set = new HashSet<Integer>(Arrays.asList(1,2,3));//HashSet생성
System.out.println(set.size());//set 크기 : 3


HashSet 값 출력

HashSet<Integer> set = new HashSet<Integer>(Arrays.asList(1,2,3));//HashSet생성

System.out.println(set); //전체출력 [1,2,3]
		
Iterator iter = set.iterator();	// Iterator 사용
while(iter.hasNext()) {//값이 있으면 true 없으면 false
    System.out.println(iter.next());
}

Set컬렉션을 print하게 되면 대괄호 []로 묶여서 set의 전체 값이 출력된다. Set에는 인덱스로 객체를 가져오는 get(index) 메소드가 없다. 대신 전체 객체를 대상으로 한 번씩 반복해서 가져오는 반복자(Iterator)를 제공한다. Iterator에서 하나의 객체를 가져올 때는 next() 메소드를 사용한다. next() 메소드를 사용하기 전에 먼저 가져올 객체가 있는지 확인하는 것이 좋다. hasNext()메소드는 가져올 객체가 있으면 true를 리턴하고, 없으면 false를 리턴한다.

HashSet 값 검색

HashSet<Integer> set = new HashSet<Integer>(Arrays.asList(1,2,3));//HashSet생성
System.out.println(set.contains(1)); //set내부에 값 1이 있는지 check : true

HashSet 내부에 원하는 값이 있는지 확인하고 싶다면 contains(value) 메소드를 사용하면 된다. 파라미터로 주어진 객체를 HashSet이 가지고 있다면 true, 아니면 false를 반환한다.

 

TreeSet

JDK 1.2부터 제공되고 있는 TreeSet은 HashSet과 마찬가지로 Set 인터페이스를 구현한 클래스로써 객체를 중복해서 저장할 수 없고, 저장 순서가 유지되지 않는다는 Set의 성질을 그대로 가지고 있다. HashSet과는 다르게 TreeSet은 이진 탐색 트리 구조로 이루어져 있다. 이진 탐색 트리는 추가와 삭제에는 시간이 조금 더 걸리지만 정렬, 검색에 높은 성능을 보이는 자료구조이다. HashSet보다 데이터의 추가와 삭제는 시간이 더 걸리지만 검색과 정렬에는 유리하다. TreeSet은 생성자의 매개변수로 Comparator 객체를 입력하여 정렬 방법을 임의로 지정해 줄 수도 있다.

레드-블랙 트리(Red-Black Tree)

TreeSet은 이진탐색트리 중에서도 성능을 향상시킨 레드-블랙 트리로 구현되어있다. 일반적인 이진 탐색 트리는 트리의 높이만큼 시간이 걸린다.  데이터의 값이 트리에 잘 분산되어 있다면 효율성에 큰 문제가 없으나 데이터가 들어올 때 값이 편향되게 들어올 경우 한 쪽으로 크게 치우쳐진 트리가 되기 때문에 비효율적이다. 레드 블랙트리는 부모노드보다 작은 값을 가지는 노드는 왼쪽 자식으로 큰 값을 가지는 노드는 오른쪽 자식으로 배치하여 데이터의 추가나 삭제 시 트리가 한쪽으로 치우쳐지지 않도록 균형을 맞추어준다.

TreeSet 사용법

TreeSet 선언

TreeSet<Integer> set1 = new TreeSet<Integer>();//TreeSet생성
TreeSet<Integer> set2 = new TreeSet<>();//new에서 타입 파라미터 생략가능
TreeSet<Integer> set3 = new TreeSet<Integer>(set1);//set1의 모든 값을 가진 TreeSet생성
TreeSet<Integer> set4 = new TreeSet<Integer>(Arrays.asList(1,2,3));//초기값 지정

TreeSet을 생성하기 위해서는 저장할 객체 타입을 파라미터로 표기하고 기본 생성자를 호출하면 된다. 생성하는 명령어는 HashSet과 크게 다르지 않으나 선언 시 크기를 지정해 줄 수 없다.

TreeSet 값 추가

TreeSet<Integer> set = new TreeSet<Integer>();//TreeSet생성
set.add(7); //값추가
set.add(4);
set.add(9);
set.add(1);
set.add(5);

입력되는 값이 TreeSet 내부에 존재하지 않는다면 그 값을 추가한 뒤 true를 반환하고 내부에 값이 존재한다면 false를 반환한다.

TreeSet에 값이 추가되는 과정

7, 4, 9, 2, 5를 차례대로 TreeSet에 저장한다면 위와 같은 과정을 거치게 된다.

TreeSet 값 삭제

TreeSet<Integer> set = new TreeSet<Integer>();//TreeSet생성
set.remove(1);//값 1 제거
set.clear();//모든 값 제거

매개변수 value의 값이 존재한다면 그 값을 삭제한 후 true를 반환하고 없으면 false를 반환한다. 모든 값을 제거하려면 clear() 메소드를 사용한다.

TreeSet 크기 구하기

TreeSet<Integer> set = new TreeSet<Integer>(Arrays.asList(1,2,3));//초기값 지정
System.out.println(set.size());//크기 : 3

TreeSet 값 출력

TreeSet<Integer> set = new TreeSet<Integer>(Arrays.asList(4,2,3));//초기값 지정
System.out.println(set); //전체출력 [2,3,4]
System.out.println(set.first());//최소값 출력
System.out.println(set.last());//최대값 출력
System.out.println(set.higher(3));//입력값보다 큰 데이터중 최소값 출력 없으면 null
System.out.println(set.lower(3));//입력값보다 작은 데이터중 최대값 출력 없으면 null
		
Iterator iter = set.iterator();	// Iterator 사용
while(iter.hasNext()) {//값이 있으면 true 없으면 false
    System.out.println(iter.next());
}

TreeSet을 그냥 print하게 되면 대괄호로 묶어서 전체 값이 출력된다. 그리고 TreeSet에는 값을 리턴하는 다양한 메서드가 있는데 first() 메소드에서는 최소값, last()는 최댓값, higher(value)은 입력값보다 큰 데이터 중 최솟값, lower(value)은 입력값보다 작은 데이터 중 최댓값을 리턴한다. TreeSet에서 객체를 불러올 때에는 HashSet과 방법이 같다.

 

HashTable

HashMap과 구조가 비슷하지만 용도는 다르다. HashTable은 키와 값을 1:1 형태로 저장된다. HashMap과 반대로 동기화가 이루어진다. HashMap에서는 값으로 null 입력이 가능하지만 HashTable에서는 null 입력이 불가능하다.

HashTable 사용법

HashTable 선언

Hashtable ht = new Hashtable(); // 타입 설정x Object 설정
Hashtable<Integer, Integer> i = new Hashtable<Integer, Integer>(); // Integer, Integer 타입 선언
Hashtable<Integer, Integer> i2 = new Hashtable<>(); // new는 타입 생략 가능
Hashtable<Integer, Integer> i3 = new Hashtable<Integer, Integer>(i); // i의 Hashtable을 i3으로 값 이전
Hashtable<Integer, Integer> i4 = new Hashtable<Integer, Integer>(10); // 초기용량 지정
Hashtable<Integer, Integer> i5 = new Hashtable<Integer, Integer>() {
	{ // 변수 선언 + 초기값 지정
				put(1, 100);
				put(2, 200);
	}
};
Hashtable<String, String> str = new Hashtable<String, String>(); // String, String 타입 선언
Hashtable<Character, Character> ch = new Hashtable<Character, Character>(); // Char, Char 타입 선언


HashTable은 하나의 Entry에 Key, Value 2개를 가지고 있다. 타입을 선언하려면 두 개를 동시에 선언해야한다.

Hashtable<타입, 타입> 변수 명 = new Hashtable<타입, 타입>();으로 선언을 해준다.

HashTable 값 추가

Hashtable<String, String> ht = new Hashtable<String, String>(); // Hashtable 선언 
// 값 추가
ht.put("1", "Hello1"); 
ht.put("2", "World2"); 
ht.put("3", "Hello3"); 
ht.put("4", "World4"); 
ht.put("2", "WorldWorld2"); 
System.out.println(ht); // 결과출력

put(key, value) 메소드를 사용하여 값을 추가한다. Put() 메소드를 사용하여 key가 같고 value가 다른 값을 중복해서 넣으면 나중에 넣은 value값으로 변경된다.

HashTable 값 삭제

Hashtable<String, String> ht = new Hashtable<String, String>(); // Hashtable 선언 

// 값 추가 
ht.put("1", "Hello1"); 
ht.put("2", "World2"); 
ht.put("3", "Hello3"); 
ht.put("4", "World4"); 

System.out.println(ht); // 결과출력 

ht.remove("2"); 
System.out.println(ht); // 결과출력
 
ht.clear(); 
System.out.println(ht); // 결과출력

Remove(key) 메소드는 key값에 해당하는 값을 하나 삭제해준다. Clear() 메소드는 HashTable의 모든 값을 삭제할 때 사용한다.

HashTable 크기 구하기

Hashtable<String, String> ht = new Hashtable<String, String>(); // Hashtable 선언

// 값 추가 
ht.put("1", "Hello1"); 
ht.put("2", "World2"); 
ht.put("3", "Hello3"); 
ht.put("4", "World4"); 

System.out.println(ht); // 결과출력 
System.out.println("Size : " + ht.size());

Size() 메소드를 사용하면 HashTable안의 키의 개수를 출력해준다.

HashTable 값 출력(향상된 for문)

Hashtable<String, String> ht = new Hashtable<String, String>(); // Hashtable 선언 

// 값 추가 
ht.put("1", "Hello1"); 
ht.put("2", "World2");
ht.put("3", "Hello3"); 
ht.put("4", "World4"); 

/* 향상된for문을 사용하여 HashTable의 값을 출력 */ 
for(Map.Entry<String, String> e : ht.entrySet()) 
    System.out.println("Key : " + e.getKey() + ", Value : " + e.getValue());

entrySet을 사용하여 HashTable을 Map클래스의 Entry타입으로 변경해준다.

Entry의 메소드 getKey()와 getValue()를 사용하여 key값과 value값을 가져와 반복해서 출력한다.

HashTable 값 출력(Iterator)

Hashtable<String, String> ht = new Hashtable<String, String>(); // Hashtable 선언 

// 값 추가 
ht.put("1", "Hello1"); 
ht.put("2", "World2"); 
ht.put("3", "Hello3"); 
ht.put("4", "World4"); 

Iterator<Entry<String, String>> iter = ht.entrySet().iterator(); 
while(iter.hasNext()) {
    Map.Entry<String, String> entry = iter.next(); 
    System.out.println("Key : " + entry.getKey() + ", Value : " + entry.getValue()); 
} 
System.out.println("-----------------------------"); 

Iterator<String> iter2 = ht.keySet().iterator(); 
while(iter2.hasNext()) { 
    String key = iter2.next(); 
    System.out.println("Key : " + key + ", Value : " + ht.get(key)); 
}

Iterator를 Entry로 선언하여 향상된 for문처럼 entrySet()의 iterator() 방식으로 가져온다. 두 번째 방법은 Iterator를 String 타입으로 선언하여 HashTable의 키 값을 iterator 형태로 집어넣는다. String을 반복하여 String의 키 값에 해당하는 Value를 반복해서 출력한다.

 

HashMap

HashMap은 Map 인터페이스를 상속받기 때문에 Map의 성질을 갖고 있다. Map은 키와 값으로 구성된 Entry 객체를 저장하는 구조를 가지고 있는 자료구조이다. 여기서 키와 값은 모두 객체이다. 값은 중복 저장될 수 있지만 키는 중복 저장될 수 없다. 만약 기존에 저장된 키와 동일한 키로 값을 저장하면 기존의 값은 없어지고 새로운 값으로 대치된다. HashMap은 이름 그대로 해싱(Hashing)을 사용하기 때문에 많은 양의 데이터를 검색하는 데 있어서 뛰어난 성능을 보인다.

위 그림과 같이 HashMap은 내부에 키와 값을 저장하는 자료 구조를 가지고 있다. HashMap은 해시 함수를 통해 키와 값이 저장되는 위치를 결정하므로 사용자는 그 위치를 알 수 없고, 삽입되는 순서와 들어있는 위치 또한 관계가 없다.

HashMap 사용법

HashMap 선언

HashMap<String,String> map1 = new HashMap<String,String>();//HashMap생성
HashMap<String,String> map2 = new HashMap<>();//new에서 타입 파라미터 생략가능
HashMap<String,String> map3 = new HashMap<>(map1);//map1의 모든 값을 가진 HashMap생성
HashMap<String,String> map4 = new HashMap<>(10);//초기 용량(capacity)지정
HashMap<String,String> map5 = new HashMap<>(10, 0.7f);//초기 capacity,load factor지정
HashMap<String,String> map6 = new HashMap<String,String>(){{//초기값 지정
    put("a","b");
}};

HashMap을 생성하려면 키 타입과 값 타임을 파라미터로 주고 기본 생성자를 호출하면 된다. HashMap은 저장공간보다 값이 추가로 들어오면 List 처럼 저장공간을 추가로 늘리는데, List처럼 저장공간을 한 칸씩 늘리지 않고 약 두 배로 늘린다. 여기서 과부하가 많이 발생한다. 초기에 저장할 데이터 개수를 알고 있다면 Map의 초기 용량을 지정해주는 것이 좋다.

HashMap 값 추가

HashMap<Integer,String> map = new HashMap<>();//new에서 타입 파라미터 생략가능
map.put(1,"사과"); //값 추가
map.put(2,"바나나");
map.put(3,"포도");

HashMap에 값을 추가하려면, put(key, value) 메소드를 사용하면 된다. 선언 시 HashMap에 설정해준 타입과 같은 타입의 Key와 Value 값을 넣어야 하며 만약 입력되는 키 값이 HashMap 내부에 존재한다면 기존의 값은 새로 입력되는 값으로 대치된다.

HashMap 값 삭제

HashMap<Integer,String> map = new HashMap<Integer,String>(){{//초기값 지정
    put(1,"사과");
    put(2,"바나나");
    put(3,"포도");
}};
map.remove(1); //key값 1 제거
map.clear(); //모든 값 제거

HashMap에 값을 제거하려면 remove(key) 메소드를 사용하면 된다. 오직 키 값으로만 map의 요소를 삭제할 수 있다. 모든 값을 제거하려면 clear() 메소드를 사용하면 된다.

HashMap 값 출력

HashMap<Integer,String> map = new HashMap<Integer,String>(){{//초기값 지정
    put(1,"사과");
    put(2,"바나나");
    put(3,"포도");
}};
		
System.out.println(map); //전체 출력 : {1=사과, 2=바나나, 3=포도}
System.out.println(map.get(1));//key값 1의 value얻기 : 사과
		
//entrySet() 활용
for (Entry<Integer, String> entry : map.entrySet()) {
    System.out.println("[Key]:" + entry.getKey() + " [Value]:" + entry.getValue());
}
//[Key]:1 [Value]:사과
//[Key]:2 [Value]:바나나
//[Key]:3 [Value]:포도

//KeySet() 활용
for(Integer i : map.keySet()){ //저장된 key값 확인
    System.out.println("[Key]:" + i + " [Value]:" + map.get(i));
}
//[Key]:1 [Value]:사과
//[Key]:2 [Value]:바나나
//[Key]:3 [Value]:포도

HashMap을 출력하는 방법에는 다양한 방법이 있다. 그냥 print하게 되면 {}로 묶어 Map의 전체 key값, value값이 출력된다. 특정 key값의 value를 가져오고 싶다면 get(key)를 사용하면 되고 전체를 출력하려면 entrySet()이나 keySet() 메소드를 활용하여 Map의 객체를 반환받은 후 출력하면 된다. entrySet()은 key와 value 모두가 필요한 경우 사용하며 keySet()은 key값만 필요한 경우 사용하는데 key값만 받아서 get(key)를 활용하여 value도 출력할 수도 있기 때문에 어떤 메소드를 선택하든지 큰 상관이 없다. 대부분 코드가 간단한 keySet을 활용하는데 key값을 이용해서 value를 찾는 과정에서 시간이 많이 소모되므로 많은 양의 데이터를 가져와야 한다면, entrySet()이 좋다.

Iterator 사용

HashMap<Integer,String> map = new HashMap<Integer,String>(){{//초기값 지정
    put(1,"사과");
    put(2,"바나나");
    put(3,"포도");
}};
		
//entrySet().iterator()
Iterator<Entry<Integer, String>> entries = map.entrySet().iterator();
while(entries.hasNext()){
    Map.Entry<Integer, String> entry = entries.next();
    System.out.println("[Key]:" + entry.getKey() + " [Value]:" +  entry.getValue());
}
//[Key]:1 [Value]:사과
//[Key]:2 [Value]:바나나
//[Key]:3 [Value]:포도
		
//keySet().iterator()
Iterator<Integer> keys = map.keySet().iterator();
while(keys.hasNext()){
    int key = keys.next();
    System.out.println("[Key]:" + key + " [Value]:" +  map.get(key));
}
//[Key]:1 [Value]:사과
//[Key]:2 [Value]:바나나
//[Key]:3 [Value]:포도

HashMap의 전체 출력 시 반복문을 사용하지 않고 위처럼 Iterator를 사용하여 전체 요소를 출력할 수 있다.

 

TreeMap

TreeMap은 이진트리를 기반으로 한 Map 컬렉션이다. 같은 Tree 구조로 이루어진 TreeSet과의 차이점은 TreeSet은 그냥 값만 저장한다면, TreeMap은 키와 값이 저장된 Map, Entry를 저장한다는 점이다. TreeMap에 객체를 저장하면 자동으로 정렬되는데, 키는 저장과 동시에 오름차순으로 정렬되고 숫자 타입을 경우에는 값으로, 문자열 타입일 경우에는 유니코드로 정렬한다. 정렬 순서는 기본적으로 부모 키 값과 비교해서 키 값이 낮은 것은 왼쪽 자식 노드에, 키 값이 높은 것은 오른쪽 자식 노드에 Map.Entry 객체를 저장한다. TreeMap은 일반적으로 Map으로써의 성능이 HashMap보다 떨어진다. TreeMap은 데이터를 저장할 때 즉시 정렬하기 때문에 추가/삭제가 HashMap 보다 오래 걸린다. 하지만 정렬된 상태로 Map을 유지해야 하거나 정렬된 데이터를 조회해야 하는 범위 검색이 필요한 경우 TreeMap을 사용하는 것이 효율적이다. TreeMap은 이진탐색트리의 문제점을 보완한 레드-블랙 트리로 이루어져 있다. (HashSet 참고)

TreeMap 사용법

TreeMap 선언

TreeMap<Integer,String> map1 = new TreeMap<Integer,String>();//TreeMap생성
TreeMap<Integer,String> map2 = new TreeMap<>();//new에서 타입 파라미터 생략가능
TreeMap<Integer,String> map3 = new TreeMap<>(map1);//map1의 모든 값을 가진 TreeMap생성
TreeMap<Integer,String> map6 = new TreeMap<Integer,String>(){{//초기값 설정
    put(1,"a");
}};

TreeMap을 생성하기 위해서는 키로 저장할 객체 타입과 값으로 저장할 객체 타입을 파라미터로 주고 기본 생성자를 호출하면 된다. 생성하는 명령어는 HashMap과 크게 다르지 않으나 선언 시 크기를 지정해 줄 수 없다.

TreeMap 값 추가

TreeMap<Integer,String> map = new TreeMap<Integer,String>();//TreeMap생성
map.put(1, "사과");//값 추가
map.put(2, "복숭아");
map.put(3, "수박");

TreeMap은 구조만 HashMap과 다를 뿐 기본적으로 Map인터페이스를 같이 상속받고 있으므로 기본적인 메소드의 사용법 자체는 HashMap과 동일하다. TreeMap에 값을 추가하려면 put(key, value) 메소드를 사용하면 된다. TreeMap의 타입 파라미터와 같은 타입의 key와 value 값을 넣어야 정상적으로 값이 input 되며 만약 입력되는 키 값이 TreeMap 내부에 존재한다면 기존의 값은 새로 입력되는 값으로 대치된다.

TreeMap 값 삭제

TreeMap<Integer, String> map = new TreeMap<Integer,String>(){{//초기값 설정
    put(1, "사과");//값 추가
    put(2, "복숭아");
    put(3, "수박");
}};
map.remove(1); //key값 1 제거
map.clear(); //모든 값 제거

TreeMap에 값을 제거하려면 remove(key) 메소드를 사용하면 된다. 키 값으로만 TreeMap의 요소를 삭제할 수 있다. 모든 값을 제거하려면 clear() 메소드를 사용하면 된다.

TreeMap 단일 값 출력

TreeMap<Integer,String> map = new TreeMap<Integer,String>(){{//초기값 설정
    put(1, "사과");//값 추가
    put(2, "복숭아");
    put(3, "수박");
}};
		
System.out.println(map); //전체 출력 : {1=사과, 2=복숭아, 3=수박}
System.out.println(map.get(1));//key값 1의 value얻기 : 사과
System.out.println(map.firstEntry());//최소 Entry 출력 : 1=사과
System.out.println(map.firstKey());//최소 Key 출력 : 1
System.out.println(map.lastEntry());//최대 Entry 출력: 3=수박
System.out.println(map.lastKey());//최대 Key 출력 : 3

TreeMap을 그냥 print하면 {}로 묶어 Map의 전체 key값, value가 출력된다. 특정 키 값의 value를 가져오고 싶다면 get(key)를 사용하면 된다. TreeMap은 HashMap과는 달리 Tree구조로 이루어져 있기 때문에 항상 정렬이 되어있기 때문에 최솟값, 최댓값을 바로 가져오는 메소드를 지원한다. firstEntry는 최소 Entry값, firstKey는 최소 Key값, lastEntry는 최대 Entry값, lastKey는 최대 key값을 리턴한다.

TreeMap 전체 값 출력

TreeMap<Integer,String> map = new TreeMap<Integer,String>(){{//초기값 설정
    put(1, "사과");//값 추가
    put(2, "복숭아");
    put(3, "수박");
}};

//entrySet() 활용
for (Entry<Integer, String> entry : map.entrySet()) {
    System.out.println("[Key]:" + entry.getKey() + " [Value]:" + entry.getValue());
}
//[Key]:1 [Value]:사과
//[Key]:2 [Value]:복숭아
//[Key]:3 [Value]:수박

//KeySet() 활용
for(Integer i : map.keySet()){ //저장된 key값 확인
    System.out.println("[Key]:" + i + " [Value]:" + map.get(i));
}
//[Key]:1 [Value]:사과
//[Key]:2 [Value]:복숭아
//[Key]:3 [Value]:수박

TreeMap의 전체요소를 출력하려면 HashMap과 마찬가지로 entrySet()이나 keySet() 메소드를 활용하여 Map의 객체를 반환 받은 후 출력하면 된다. entrySet()은 key와 value 모두 필요할 경우 사용하며 keySet()은 key 값만 필요할 경우 사용하는데, key값만 받아서 get(key)를 활용하여 value도 출력할 수 있다. key값을 이용해서 value를 찾는 과정에서 시간이 많이 소모되므로 많은 양의 데이터를 가져와야 한다면 entrySet()이 좋다.

Iterator 사용

TreeMap<Integer,String> map = new TreeMap<Integer,String>(){{//초기값 설정
    put(1, "사과");//값 추가
    put(2, "복숭아");
    put(3, "수박");
}};
		
//entrySet().iterator()
Iterator<Entry<Integer, String>> entries = map.entrySet().iterator();
while(entries.hasNext()){
    Map.Entry<Integer, String> entry = entries.next();
    System.out.println("[Key]:" + entry.getKey() + " [Value]:" +  entry.getValue());
}
//[Key]:1 [Value]:사과
//[Key]:2 [Value]:복숭아
//[Key]:3 [Value]:수박
		
//keySet().iterator()
Iterator<Integer> keys = map.keySet().iterator();
while(keys.hasNext()){
    int key = keys.next();
    System.out.println("[Key]:" + key + " [Value]:" +  map.get(key));
}
//[Key]:1 [Value]:사과
//[Key]:2 [Value]:복숭아
//[Key]:3 [Value]:수박

 

Reference

반응형

'개발 (Development) > Java' 카테고리의 다른 글

[Java] 문자열을 timestampz 형식으로 변경  (0) 2024.04.02
[Java] 날짜 더하기 - Date  (0) 2024.04.02
[Java/JPA] Entity를 Map으로 변환 (Convert Entity to Map)  (0) 2024.04.02
[Java] 시간 차이 계산 - Date  (0) 2024.04.02
[Java] 리스트(LinkedList) 정렬  (0) 2024.04.02

티스토리툴바