Java(17) - HashSet, TreeSet, Map

1) 컬렉션

   1-1) HashSet

   1-2) TreeSet

   1-3) Map

2) 예제 풀이

 

 

 

 

1) 컬렉션

1-1) HashSet

 

 

 

 

 

 

 

1-2) TreeSet

 

 

 

 

 

1-3) Map

 

 

 

 

 

 

 

2) 예제 풀이

패키지 chapter14.collection

LinkedList_Test1.class

package chapter14.collection;

import java.util.Iterator;
import java.util.LinkedList;
import java.util.ListIterator;

public class LinkedList_Test1 {

	public static void main(String[] args) {
		LinkedList<String> arName = new LinkedList<>();
		arName.add("전두환");
		arName.add("김영삼");
		arName.add("김대중");
		arName.add(1, "노태우");  // index 1에 값 추가
		arName.remove("노태우");  // 해당 객체를 삭제
		
		for (String s : arName) {
			System.out.println(s);
		}
		
		// Iterator 반복자
		System.out.println("=============");
		Iterator<String> it = arName.iterator();
		while (it.hasNext()) {
			System.out.println(it.next());
		}
		
		// Iterator 반복자 - 역순
		System.out.println("=============");
		ListIterator<String> it2 = arName.listIterator(arName.size());
		while (it2.hasPrevious()) {
			System.out.println(it2.previous());
		}

	}

}

 

 

 

 

LinkedList_Test2.class

package chapter14.collection;

import java.util.LinkedList;

public class LinkedList_Test2 {

	public static void main(String[] args) {
		LinkedList<String> arName = new LinkedList<>();
		// 추가
		arName.add("장보고");
		arName.add("김유신");
		arName.add("강감찬");
		arName.add("을지문덕");
		arName.addLast("곽재우");
		arName.addFirst("이순신");
		
		for (String name : arName) {
			System.out.print(name + " ");
		}
		System.out.println("\n==============================");
		
		// 검색
		System.out.println(arName.size());  // 저장된 객체의 개수 반환
		System.out.println(arName.isEmpty());  // 리스트가 비어있는지 확인
		// 지정된 객체가 저장된 위치를 반환
		System.out.println(arName.indexOf("강감찬"));
		System.out.println(arName.get(3));  // 지정된 위치에 저장된 객체 반환
		
		// 변경
		arName.set(0,  "광개토대왕");
		
		for (String name : arName) {
			System.out.print(name + " ");
		}
		System.out.println("\n==============================");
		
		// 제거
		arName.removeFirst();   // 첫번째 노드 제거
		arName.removeLast();   // 마지막 노드 제거
		arName.remove(2);   // index 위치의 객체 제거
		arName.remove("을지문덕");   // 지정된 객체 제거
		
		for (String name : arName) {
			System.out.print(name + " ");
		}

	}

}

 

 

 

 

HashSet_Test.class

package chapter14.collection;

import java.util.HashSet;
import java.util.Iterator;

public class HashSet_Test {

	public static void main(String[] args) {
		/*
		       Set
		        - 객체를 중복해서 저장할 수 없으며, null이라도 하나만 저장 가능
		        - 중복을 자동으로 제거하며, 순서를 보장하지 않음
		*/
		
		HashSet<String> kangwon = new HashSet<String>();
		kangwon.add("춘천시");
		kangwon.add("철원군");
		kangwon.add("정선군");
		kangwon.add("강릉시");
		kangwon.add("화천군");
		kangwon.add("춘천시");  // 중복 데이터는 Set에 저장되지 않음!
		
		Iterator<String> it = kangwon.iterator();
		while (it.hasNext()) {
			System.out.println(it.next());
		}
		
		System.out.println("=====================");
		System.out.println(kangwon.size());
		System.out.println(kangwon.contains("화천군"));
		
		kangwon.remove("정선군");
		kangwon.clear();     // clear() : 모든 값 제거
		System.out.println("=====================");
		for (String s : kangwon) {
			System.out.println(s);
		}

	}

}

 

 

 

 

TreeSet_Test.class

package chapter14.collection;

import java.util.Iterator;
import java.util.TreeSet;

public class TreeSet_Test {

	public static void main(String[] args) {
		TreeSet<Integer> ts = new TreeSet<>();
		ts.add(3);
		ts.add(2);
		ts.add(5);
		ts.add(1);
		ts.add(4);
		ts.add(2);   // 중복
		
		System.out.println(ts.first());   // 최소값 출력
		System.out.println(ts.last());    // 최대값 출력
		System.out.println(ts.contains(2));  // 해당 값을 포함하고 있는지, 아닌지를 true, false 값으로 출력함!
		System.out.println("=====================");
		Iterator<Integer> it = ts.iterator();
		while (it.hasNext()) {
			System.out.println(it.next());
		}
		
		// TreeSet을 이용한 로또
		TreeSet<Integer> lotto = new TreeSet<>();
		for (int i = 0; lotto.size() < 6; i++) {
			lotto.add((int) (Math.random() * 45) + 1);
		}
		for (Integer i : lotto) {
			System.out.print(i + " ");
		}

	}

}

 

 

 

 

HashMap_Test1.class

package chapter14.collection;

import java.util.HashMap;

public class HashMap_Test1 {

	public static void main(String[] args) {
		// HashMap - hash 구조를 가지며 key, value 쌍을 저장
		HashMap<String, Integer> snack = new HashMap<>();
		snack.put("오징어 땅콩", 2500);
		snack.put("죠리퐁", 1900);
		snack.put("핫브레이크", 450);
		snack.put("빼빼로", 900);
		
		String mySnack = "죠리퐁";
		System.out.println(mySnack + "의 가격은 " + snack.get(mySnack));
		
		snack.remove("빼빼로");   // key와 일치하는 데이터 삭제
		System.out.println(snack.containsKey("빼빼로"));
		snack.replace("죠리퐁", 3000);   // 해당 key에 일치하는 value 수정
		System.out.println(snack.get("죠리퐁"));
		System.out.println(snack.isEmpty());

	}

}

 

 

 

 

HashMap_Test2.class

package chapter14.collection;

import java.util.HashMap;
import java.util.Objects;

class Human {
	int age;
	String name;
	
	Human(int age, String name) {
		this.age = age;
		this.name = name;
	}

	@Override
	public int hashCode() {
		return name.length() + age;
	}

	@Override
	public boolean equals(Object obj) {
		if (obj instanceof Human) {
			Human other = (Human) obj;
			return age == other.age && name.equals(other.name);
		} else {
			return false;
		}
	}
	
	
}

public class HashMap_Test2 {

	public static void main(String[] args) {
		HashMap<Human, Integer> donate = new HashMap<>();
		donate.put(new Human(42, "김기남"), 10000);
		donate.put(new Human(24, "박수빈"), 20000);
		donate.put(new Human(20, "박수현"), 5000);
		donate.put(new Human(11, "최상미"), 8000);
		
		Human park = new Human(20, "박수현");
		System.out.println(park.name + "씨의 기부금 = " + donate.get(park));

	}

}

 

 

 

 

TreeMap_Test.class

package chapter14.collection;

import java.util.Iterator;
import java.util.Set;
import java.util.TreeMap;

public class TreeMap_Test {

	public static void main(String[] args) {
		TreeMap<Integer, String> treeMap = new TreeMap<>();
		treeMap.put(1, "부산");
		treeMap.put(2, "인천");
		treeMap.put(3, "대구");
		treeMap.put(4, "대전");
		treeMap.put(5, "광주");
		treeMap.put(6, "울산");
		
		int size = treeMap.size();
		System.out.println(size);   // 저장된 총 요소 수
		
		// 객체 찾기
		Object object = treeMap.get(1);
		System.out.println(object);
		
		// key를 요소로 가지는 Set 생성
		Set<Integer> keySet = treeMap.keySet();
		System.out.println(keySet);
		
		// value 값 읽기
		Iterator<Integer> keyIterator = keySet.iterator();
		while (keyIterator.hasNext()) {
			Integer key = keyIterator.next();
			String value = treeMap.get(key);
			System.out.println("키: " + key + ", 값: " + value);
		}
		
		treeMap.remove(1);   // index가 아니라 key 값이 1인 데이터 삭제

	}

}

 

 

 

 

Comparable_Test.class

package chapter14.collection;

import java.util.Set;
import java.util.TreeSet;

class Member implements Comparable<Member> {
	String name;
	int age;
	
	public Member(String name, int age) {
		this.name = name;
		this.age = age;
	}
	
	@Override
	public String toString() {
		return "Member [name=" + name + ", age=" + age + "]";
	}

	@Override
	public int compareTo(Member m) {
		// return (this.name.compareTo(m.name));    // 가, 나, 다 순서대로 이름을 출력함!
		return (this.name.compareTo(m.name)) * -1;   // 역순으로 출력하기 위해 "* -1"을 하면 된다!
	}
	
}

public class Comparable_Test {

	public static void main(String[] args) {
		// 정렬에 대한 비교
		// Comparable : 자기 자신과 비교
		// Comparator : 서로 다른 두 객체를 비교
		
		Set<Member> set = new TreeSet<>();
		set.add(new Member("홍길동", 20));
		set.add(new Member("강감찬", 50));
		set.add(new Member("이순신", 35));
		
		for (Member m : set) {
			System.out.println(m);
		}

	}

}

 

 

 

 

Comparator_Test.class

package chapter14.collection;

import java.util.Comparator;
import java.util.Set;
import java.util.TreeSet;

class Person {
	String name;
	int age;
	
	public Person(String name, int age) {
		this.name = name;
		this.age = age;
	}
	
	@Override
	public String toString() {
		return "Person [name=" + name + ", age=" + age + "]";
	}
}

class MyComparator implements Comparator<Person> {
	@Override
	public int compare(Person p1, Person p2) {
		return p1.name.compareTo(p2.name);   // 역순으로 출력하려면 "* -1"을 하면 된다!
	}
}

public class Comparator_Test {

	public static void main(String[] args) {
		Set<Person> set1 = new TreeSet<>(new MyComparator());
		set1.add(new Person("홍길동", 50));
		set1.add(new Person("강감찬", 80));
		set1.add(new Person("이순신", 45));
		
		for (Person p : set1) {
			System.out.println(p);
		}
		
		System.out.println("================================");
		Set<Person> set2 = new TreeSet<>(
				new Comparator<Person>() {  // 익명객체
					@Override
					public int compare(Person p1, Person p2) {
						return p1.name.compareTo(p2.name);
					}
				});
		set2.add(new Person("홍길동", 50));
		set2.add(new Person("강감찬", 80));
		set2.add(new Person("이순신", 45));
		
		for (Person p : set2) {
			System.out.println(p);
		}
		System.out.println("================================");

	}

}