[JAVA+국비교육] ArrayList, List, Map, Generic

2022.01.07(14일 차)

Day 14 ~ing

 

 

오늘의 수업 내용

 

오늘은 Collection 프레임워크에 있는 Arraylist, List, Map을 배웠다.

 

주요 인터페이스 특징

 

List

• 순서가 있는 데이터의 집합
• 데이터의 중복을 허용함
• 구현 클래스 - LinkedList  ,   Stack  ,  Vector (Vector : 동기화 보장 O / ArrayList : 동기화 보장 X)

List 클래스 주요 메서드

• boolean add(E e) : 주어진 객체를 맨 끝에 추가
• void add(int index, E element) : 주어진 index에 객체를 추가
• set(int index, E element) : 주어진 index에 저장된 객체를 주어진 객체로 변경
• boolean contains(Object o) : 주어진 객체가 저장되어 있는지에 대한 여부를 반환
• E get(int index) : 주어진 index에 저장된 객체를 반환
• boolean isEmpty() : 컬렉션이 비어있는지 여부를 반환
• int size() : 저장되어 있는 객체 수를 반환
• E remove(int index) : 주어진 index에 저장된 객체를 삭제
• void clear() : 컬렉션에 저장된 전체 객체를 삭제
• boolean remove(Object o) : 주어진 객체를 삭제

---

Set

• 순서를 유지하지 않는 데이터의 집합
• 데이터의 중복을 허용하지 않음
• 구현 클래스  :   HashSet -> Set계열의 대표 클래스  /  TreeSet ->정렬을 위한 Set계열의 클래스

Set 클래스 주요 메서드

• boolean add(E e) : 주어진 객체를 저장 후, 성공적이면 true, 중복 객체면 false를 반환
• boolean contains(Object o) : 주어진 객체가 저장되어 있는지에 대한 여부를 반환
• Iterator <E> iterator() : 저장된 객체를 한 번씩 가져오는 반복자를 반환
• boolean isEmpty() : 컬렉션이 비어있는지에 대한 여부를 반환
• int size() : 저장되어 있는 객체 수를 반환
• void clear() : 컬렉션에 저장된 전체 객체를 삭제
• boolean remove(Object o) : 주어진 객체를 삭제

---

Map

• (key, value)의 쌍으로 이루어진 데이터의 집합.
• 순서는 유지되지 않고, key는 중복을 허용하지 않으며, value의 중복은 허용함.
• 구현 클래스 : HashMap  ->  동기화 보장 O    /    HashTable  -> 동기화 보장 X                                                                TreeMap  -> 정렬을 위한 Map계열의 클래스                                                                                          Properties  -> HashTable의 하위 클래스,  파일 입출력 지원

Map 클래스 주요 메서드

• V put(K key, V value) : 주어진 key와 value를 추가하여, 저장되면 value를 반환
• boolean containsKey(Object Key) : 주어진 key가 컬렉션에 존재하는지 여부를 반환
• boolean containsValue(Object value) : 주어진 value가 컬렉션에 존재하는지 여부를 반환
• Set <Map, Entry <K, V>> entrySet() : 모든 Map, Entry 객체를 Set에 담아 반환
• Set <K> keySet() : 모든 key를 Set객체에 담아서 반환
• V get(Object Key) : 주어진 key에 있는 value를 반환
• boolean isEmpty() : 컬렉션이 비어있는지에 대한 여부를 반환
• int size() : 저장되어 있는 객체 수를 반환
• Collection <V> values() : 저장된 모든 value를 컬렉션에 담아서 반환
• void clear() : 저장된 모든 Map, Entry를 삭제
• V remove(Object Key) : 주어진 key와 일치하는 Map, Entry를 삭제하고 value를 반환

---

ArrayList와 List

package com.day13;

//	ArrayList
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;

public class Test1_1 {

	public static void main(String[] args) {
		
		ArrayList<String> lists = new ArrayList<>();
		
		lists.add("서울");//데이터 넣기
		lists.add("부산");
		lists.add("대구");
		
		//데이터 출력하기위해 Iterator
		Iterator<String> it = lists.iterator();
		while(it.hasNext()) {
			String str = it.next();// 이 두줄을 한줄로 바꾸면
			System.out.print(str + " ");// System.out.print(it.next() + " ");
		}
		System.out.println();
		
		//ListIterator
		ListIterator<String> it1 = lists.listIterator();
		while(it1.hasNext()) {
			System.out.print(it1.next() + " ");
		}
		System.out.println();
		System.out.println("===================");
		
		while(it1.hasPrevious()) {
			System.out.print(it1.previous() + " "); //순서를 반대로 넣어준다.
		}
		System.out.println();
		
		List<String> lists1 = new ArrayList<String>();
		lists1.addAll(lists);
		lists1.add("인천");
		
		int n = lists1.indexOf("부산");	
		lists1.add(n+1,"광주");
		
		for(String s : lists1) {
			System.out.print(s+ " ");
			
		}
		System.out.println("\n-----------------");
		
		Iterator<String> it2 = lists1.iterator();
		while(it2.hasNext()) {
			String str = it2.next();
			if(str.startsWith("부")) { //String의 메서드 : startsWith
				System.out.println(str);
			}
		}
	
	}

}

Test 1_1 실행 결과

 

 

Map <키, 값> 인터페이스

list와 Map이 가장 많이 사용된다. 속도는 Map이 더 빠름( 고윳값이 존재, key)

키는 중복 값을 가질 수 없다.(key:set)

키가 중복되면 마지막 값이 저장된다.  --> 키가 같으면 수정된다.

Map은 Iterator가 없다. (Set의 Iterator를 빌려 쓴다.)

put(키, 값) : 추가

it.next : keyt를 읽음

get(키, 값) : 읽기

 

package com.day13;

import java.util.Hashtable;
import java.util.Iterator;

//Map(I) - Hashtable(C), HashMap(C)
//Hashtable : Vector와 동일
//HashMap : ArrayList와 동일

//Map<key, value>
//키는 중복값을 가질수 없다.(key:Set)
//키가 중복되면 마지막 값이 저장된다.(수정)
//Map은 Iterator가 없다.
//put(키, 값) : 추가
//it.next : key를 읽음
//get(키, 값) : 읽기
public class Test2 {
	
	//key
	public static final String[] tel = { "11-111", "222-222", "333-333", "1111-111", "444-444"};
	
	//value
	public static final String[] name = {"배수지", "유인나", "정인성", "안젤리나", "정인아"};

	
	public static void main(String[] args) {
		
		//데이터 타입이 다 String이라서 확인가능하다
		Hashtable<String, String> h = new Hashtable<>();
		
		for(int i=0; i<name.length; i++) {
			h.put(tel[i], name[i]);
		}
		
		System.out.println(h);
		
		String str;
		
		//key를 주면 value를 가져온다
		str = h.get("111-111");
		
		
		if(str==null || str.equals("")) { //if(str==null)
			System.out.println("자료없음!");
		} else {
			System.out.println(str);
		}
		
		//값이 존재하는지 검사
		if(h.containsKey("222-222")) {
			System.out.println("222-222가 존재");
		}
		
		//값이 존재하는지 검사
		if(h.containsKey("유인나")) {
			System.out.println("유인나 여기 있어요~");
		
		}
		
		
		//삭제
		h.remove("222-222");
		if(h.containsKey("222-222")) {
			System.out.println("222-222가 존재");
		} else {
			System.out.println("222-222가 존재x ");
		}
		
		//Map의 key자료형은 set이다
		Iterator<String> it = h.keySet().iterator(); // 이 방법밖에 없으니 외우기!!!
		while(it.hasNext()) {
			
			String key = it.next(); //key만 읽음
			String value = h.get(key); // value을 읽음 - key를 value한테 주면 값을 읽어온다.
			
			System.out.println(key + ":" + value);
		}

	}
}

Test 2 실행 결과

 

Map & List

List

• 동기화를 지원하냐에 따라 속도 차이가 많이 남. ArrayList : 동기화 지원 X. 그래서 속도가 더 빠름
• List <저장할 자료형> lists = new ArrayList <저장할 자료형>();
• List <저장할 자료형> lists = new Vector <저장할 자료형>();
• ArrayList <저장할 자료형> lists = new ArrayList <저장할 자료형>();
• Vector <저장할 자료형> lists = new Vector<저장할 자료형>();

Map

• HashMap과 HashTable은 속도 차이가 거의 없음
• Map <key자료형, 저장할 자료형> map = new HashMap<key자료형, 저장할 자료형>();
• Map <key자료형, 저장할 자료형> map = new HashTable <key자료형, 저장할 자료형>();
• HashMap <key자료형, 저장할 자료형> map = new HashMap <key자료형, 저장할 자료형>();
• MapTable <key자료형, 저장할 자료형> map = new HashTable <key자료형, 저장할 자료형>();

package com.day13;

import java.util.Arrays;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;
import java.util.Set;
import java.util.Stack;

public class Test3 {

	public static void main(String[] args) {
		
		//Set : 중복값을 허용하지 않는다.
		
		Set<String> s = new HashSet<String>();
		
		s.add("서울");
		s.add("부산");
		s.add("대구");
		
		System.out.println(s); //서울,부산,대구
		
		s.add("서울"); //Set은 중복값을 허용하지 않는다.덮어씌운다.
		
		System.out.println(s); //서울,부산,대구 서울이 또 찍히지않고 덮어씌운다.
		
		System.out.println("=================");
		
		//Stack
		Stack<String> st = new Stack<String>();
		
		//Stack의 데이터추가
		st.push("서울");
		st.push("부산"); // add랑 push둘다 가능
		st.add("대구"); //대구 부산 서울 입력한것의 역순으로 나온다. 서울이 먼저 입력받아 들어가 밑에 쌓인다.
		
		//Set의 출력
		while(!st.empty()) {//데이터가 비여있지 않을때까지 (데이터가 있을 때까지)
			System.out.println(st.pop());
		}
		System.out.println("=================");

		//Queue
		Queue<String> q = new LinkedList<String>();
		
		//Queue의 데이터추가
		q.offer("서울");
		q.offer("부산");
		q.offer("대구");
		q.add("광주");
		
		//Queue의 출력
		while(q.peek()!=null) {
			System.out.println(q.poll());// Queue의 출력은 poll이다
		}
		System.out.println("=================");

		List<String> lists1 = new LinkedList<String>();
		lists1.add("A");
		lists1.add("B");
		lists1.add("C");
		lists1.add("D");
		lists1.add("E");
		lists1.add("F");
		lists1.add("G");
		lists1.add("H");
		lists1.add("I");

		List<String> lists2 = new LinkedList<String>();
		lists2.add("서울");
		lists2.add("부산");
		lists2.add("대구");
		
		lists2.addAll(lists1); //컬렉션에 컬렉션을 추가 할 수 있다.
		
		System.out.println("lists1.............");
		for(String ss : lists1) {
			System.out.println(ss);
		}
		System.out.println("\nlists2.............");
		for(String ss : lists2) {
			System.out.println(ss);
		}
	
		lists2.subList(2, 5).clear();
		System.out.println("\nlists2.............");
		for(String ss : lists2) {
			System.out.println(ss);
		}
		
		String[] str = {"라","카","하","나","마","가","다"};
		for(String ss : str)
			System.out.print(ss + " ");
		
		System.out.println();
		
		Arrays.sort(str);
		for(String ss : str)
			System.out.print(ss + " ");		
	}

}

---

 

요즘 복습하느라 기술 블로그 작성이 계속 밀린다.. 계획대로면 1일 1 커밋 & 1 기술 블로그 작성인데 1일 1 커밋만 

실천되고 있다. 분발하자! 따라가기 벅차고 할게 많아 힘들지만 미래의 나를 위해 조금만 더 노력하자!