반응형
1) Set
HashSet()
TreeSet()
2) Map
HashMap()
Hashtable()
TreeMap()
3)Collection 정리
2025.02.19 - [AWS활용 자바 부트캠프] - 자바/스프링 부트캠프 14일차( collection )
자바/스프링 부트캠프 14일차( collection )
1) 컬렉션 프레임워크 1-1) List 1-2 ) set 1) 컬렉션 프레임워크 * Collection 인터페이스 : 객체를 여러개저장할 수 있는 객체] * List : Collection 인터페이스의 하위* 객체들 저장할 때 저장된
ddkk1120.tistory.com
1) Set
어제 간략하게 다룬 Set을 다시한다!!!
객체추가시 중복 판단 기준
* 1 .equals 메서드의결과가 true
* 2. hashCode 메서드의 결과가 같다
* 1 & 2 모두만족 ㅣ 중복객체로판단
* equals , hashCode 메서드를 동시에 오버라이딩하도록 권장
package ex2_set;
import java.util.HashSet;
import java.util.Objects;
class Person{
String name;
int age;
public Person(String name, int age) {
super();
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "(name=" + name + ", age=" + age + ")";
}
@Override
public int hashCode() {
return name.hashCode()+age;
}
@Override
public boolean equals(Object obj) {
if(obj instanceof Person) {
Person p = (Person)obj;
return name.equals(p.name) && age==p.age;
//들어온객체가 Person객체를 포함한다면
//이름과 나이가같으면 같은객체로판단
}
else return false;
}
}
public class SetEx2 {
public static void main(String[] args) {
HashSet<Object> set = new HashSet<>();
set.add(new String("abc"));
set.add(new String("abc"));
set.add(new Person("유동곤",26));
set.add(new Person("유동곤",26));
//equals & hashCode 구현 안 할시 중복으로인식해 다 저장됨....
System.out.println(set);
}
}[abc, (name=유동곤, age=26)]
equals와 hashCode를 구현하지않는다면
( Set은 중복을 허용하지않지만
Person객체에 넣은 값들이 중복저장될것이다)
간단 예제_ )
Student클래스구현
* 멤버변수 : 학번 이름 전공
* 멤버메서드 학생정보출력하게 toString
* compareTo() 메서드에서 기본정렬방식이 학번순으로정렬되게 설정
* 이름과 학번이 같은경우 같은학생으로 인식하도록설정
TreeSet에 객체를 사용할떄는 객체가 Comparable을 구현해야함
Integer , String 등은 기본적으로 오버라이딩이 돼 있음.
package ex2_set;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.TreeSet;
class Student implements Comparable<Student>{
String name,major;
int studno;
public Student(String name, String major, int studno) {
super();
this.name = name;
this.major = major;
this.studno = studno;
}
public String toString() {
return "(전공 : "+major+", 학번 : "+studno+", 이름 : "+name+")";
}
@Override
public int compareTo(Student o) {
return studno - o.studno;//오름차순방법
//내림차순을 하고싶다면 결과에 -1 곱하자
}
@Override
public int hashCode() {
return name.hashCode()+studno;
}
@Override
public boolean equals(Object obj) {
if(obj instanceof Student) {
Student s = (Student)obj;
return name.equals(s.name) && studno==s.studno;
}
else return false;
}
}
//----------------------------------------------------------------------------------
public class Exam1 {
public static void main(String[] args) {
Set<Student> s = new HashSet<>();
s.add(new Student("유동", "전자공학", 19));
s.add(new Student("유동", "전자공학", 19));
s.add(new Student("유동", "전기", 15));
s.add(new Student("유동", "전기", 15));
s.add(new Student("하하", "통신", 13));
System.out.println(s);
System.out.println("--방법 1 --");
TreeSet<Student> treeSet = new TreeSet<>(s);
//TreeSet에 객체를 사용할떄는 객체가Comparable을 구현해야함
//Integer , String 등은 기본적으로 오버라이딩이 돼 있음.
System.out.println(treeSet);
System.out.println("--방법2--");
ArrayList<Student> arrayList = new ArrayList<>(s);
Collections.sort(arrayList);
System.out.println(arrayList);
}
}[(전공 : 전기, 학번 : 15, 이름 : 유동), (전공 : 전자공학, 학번 : 19, 이름 : 유동), (전공 : 통신, 학번 : 13, 이름 : 하하)]
--방법 1 --
[(전공 : 통신, 학번 : 13, 이름 : 하하), (전공 : 전기, 학번 : 15, 이름 : 유동), (전공 : 전자공학, 학번 : 19, 이름 : 유동)]
--방법2--
[(전공 : 통신, 학번 : 13, 이름 : 하하), (전공 : 전기, 학번 : 15, 이름 : 유동), (전공 : 전자공학, 학번 : 19, 이름 : 유동)]
TreeSet 예제 : 중복불가 , 정렬됨
* SortedSet의 구현클래스(set의 하위클래스)
package ex2_set;
import java.util.Comparator;
import java.util.HashSet;
import java.util.Set;
import java.util.SortedSet;
import java.util.TreeSet;
/*
* TreeSet 예제 : 중복불가 , 정렬됨
* SortedSet의 구현클래스(set의 하위클래스)
*/
public class SetEx3 {
public static void main(String[] args) {
SortedSet<String> set = new TreeSet<>(); /* 이것도 됨!!!! */
// Set<String> set = new TreeSet<>();
String from = "bat";
String to = "d";
set.add("abc");set.add("alien");set.add("bat");
set.add("azz");set.add("Car");set.add("disk");set.add("dance");
set.add("dzzzz");set.add("dZZZZ");set.add("elev");set.add("fan");
set.add("flower");
System.out.println(set);
//대문자로시작하는 C가 아스키코드가 가장 작으므로 맨앞에 배치
System.out.println("subSet(from, to+\"zzzz\") : "+
set.subSet(from, to+"zzzz"));
//from 부터 to 앞까지 가져와 라는 뜻 (SortedSet의 고유메서드임 Set으로는 사용불가능)
//부모는 자식의 기능을 사용할수없음
System.out.println("subSet(\"abc\", \"azz\") : "+
set.subSet("abc", "azz"));
//내림차순 정렬
System.out.println("==내림차순정렬==");
set = new TreeSet<>(Comparator.reverseOrder());
set.add("abc");set.add("alien");set.add("bat");
set.add("azz");set.add("Car");set.add("disk");set.add("dance");
set.add("dzzzz");set.add("dZZZZ");set.add("elev");set.add("fan");
set.add("flower");
System.out.println(set);
//대소문자 구분없이 정렬되도록
System.out.println("==대소문자 구분없이 정렬되도록==");
//람다방식
// Comparator<String> f= (s1,s2)->{
// return s1.compareToIgnoreCase(s2);
// };
//
// set = new TreeSet<String>(f);
//어차피 저 자리에 들어갈 인터페이스는 Comprator밖에없기때문에 생략가능!!
set =new TreeSet<String>((s1,s2)->s1.compareTo(s2));
set.add("abc");set.add("alien");set.add("bat");
set.add("azz");set.add("Car");set.add("disk");set.add("dance");
set.add("dzzzz");set.add("dZZZZ");set.add("elev");set.add("fan");
set.add("flower");
System.out.println(set);
}
}[Car, abc, alien, azz, bat, dZZZZ, dance, disk, dzzzz, elev, fan, flower]
subSet(from, to+"zzzz") : [bat, dZZZZ, dance, disk]
subSet("abc", "azz") : [abc, alien]
==내림차순정렬==
[flower, fan, elev, dzzzz, disk, dance, dZZZZ, bat, azz, alien, abc, Car]
==대소문자 구분없이 정렬되도록==
[abc, alien, azz, bat, Car, dance, disk, dzzzz, elev, fan, flower]
TreeSet (객체 정렬)
객체가 Comarable 또는 Comaprator를 구현해야함
(String , Integer 등은 기본적으로 구현돼 있지만 우리가 만드는 클래스들은
구현이 되어있지 않으므로 해줘야함)
package ex2_set;
import java.util.Set;
import java.util.TreeSet;
class Data implements Comparable<Data>{
int value;
Data(int value){
this.value = value;
}
@Override
public int compareTo(Data o) {
return value-o.value;
}
public String toString() {
return value+"";
}
}
public class SetEx4 {
public static void main(String[] args) {
Set<Data> set = new TreeSet<Data>((d1,d2)->d1.value - d2.value);
//Data가 Comarable 또는 Comaprator를 구현해야함
set.add(new Data(1));
set.add(new Data(4));
set.add(new Data(2));
set.add(new Data(3));
System.out.println(set);
}
}[1, 2, 3, 4]
2) Map
* Map인터페이스 : (key,객체) 쌍인 객체들의 모임
* put(key,value) : map에 데이터 추가
* get(key) : value값을 리턴
* Set keySet() : map객체중 key 목록 조회
* Set values() : map 객체중 values 목록조회
* Set<Map,Entry> entrySet() : (키,값)쌍 목록 조회
* Map.Entry 객체 : 키,객체(value) 쌍인 객체1개
* key : getKey()
* value : getValue()
* value remove(key) : key 에 해당하는 객체 제거 후 value값 리턴
key값이 존재하지않는다면 null 반환
package ex3_map;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map.Entry;
import java.util.Set;
public class MapEx1 {
public static void main(String[] args) {
String [] names = {"홍길동","김삿갓","이몽룡","임꺽정","김삿갓"};
int []nums= {1234,4567,2350,9850,3456};
HashMap<String,Integer> map = new HashMap<String, Integer>();
for (int i = 0; i < nums.length; i++) {
System.out.println(names[i]+"_"+nums[i]);
map.put(names[i], nums[i]);
}
System.out.println("== 최종 Map 구조 ==");
System.out.println(map);
System.out.println("홍길동의 값 : "+map.get("홍길동"));//key값이 존재하지않는다면null
System.out.println("map의 크기 : "+map.size());
//key 값만 조회
//keySet() : key값들만 조회 , key들을 Set객체로리턴
Set<String> keySet = map.keySet();
System.out.print("key : ");
for (String s : keySet) {
System.out.print(s+", ");
}System.out.println();
System.out.println("------------------------");
//값들만 조회
Collection<Integer> values = map.values();
System.out.printf("value : ");
for (Integer i : values) {
System.out.print(i+",");
}System.out.println();
System.out.println("--------------------------");
System.out.println("entryset() : (key,객체)쌍인 객체조회");
Set<Entry<String,Integer>> entrySet = map.entrySet();
for (Entry<String, Integer> entry :entrySet) {
if(entry.getValue()==2350) {
System.out.print("2350의 key값 : ");
System.out.println(entry.getKey());
}
System.out.println(entry);
/* System.out.println("("+entry.getKey()+"="+entry.getValue()+")"); */
}
System.out.println("제거 전 : "+map);
Integer tel = map.remove("홍길동");
Integer remove = map.remove("하하");//존재하지않는 key값 입력시 null반환
System.out.println("제거된 홍길동의 전화번호 "+tel);
System.out.println("제거 후 map객체의 요소 갯수 : "+map.size());
System.out.println("제거 후 : "+map);
}
}
홍길동_1234
김삿갓_4567
이몽룡_2350
임꺽정_9850
김삿갓_3456
== 최종 Map 구조 ==
{김삿갓=3456, 홍길동=1234, 이몽룡=2350, 임꺽정=9850}
홍길동의 값 : 1234
map의 크기 : 4
key : 김삿갓, 홍길동, 이몽룡, 임꺽정,
------------------------
value : 3456,1234,2350,9850,
--------------------------
entryset() : (key,객체)쌍인 객체조회
김삿갓=3456
홍길동=1234
2350의 key값 : 이몽룡
이몽룡=2350
임꺽정=9850
제거 전 : {김삿갓=3456, 홍길동=1234, 이몽룡=2350, 임꺽정=9850}
null
제거된 홍길동의 전화번호 1234
제거 후 map객체의 요소 갯수 : 3
제거 후 : {김삿갓=3456, 이몽룡=2350, 임꺽정=9850}
Map 예제)
* 1. 대한민국 : 서울 , 캐나다 : 오타와 , 영국 : 런던 , 일본 : 도쿄 저장하는 map 객체
* 2. 나라이름을 입력받아 수도를 출력해보자 등록된나라가 아니면 수도가 등록되지않았습니다 메시지출력
* 종료가 입력될때 까지 계속 입력받아
package ex3_map;
import java.util.HashMap;
import java.util.Scanner;
public class Exam1 {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
String [] world = {"대한민국","캐나다","영국","일본"};
String [] soodo = {"서울","오타와","런던","도쿄"};
HashMap<String, String> map = new HashMap<>();
//키값 value값 넣기
for (int i = 0; i < soodo.length; i++) {
map.put(world[i], soodo[i]);
}
while(true) {
System.out.print("나라 입력 : ");
String a = scan.next();
String s = map.get(a);
if(a.equals("종료")) {
System.out.println("@@수도찾기 종료@@");
break;
}
if(s != null) {
System.out.println(a+"의 수도는 "+s);
}
else {
System.out.println("수도가 등록되지 않았어요");
}
}
}
}없는 키 (등록되지않은 나라) 값을 입력한다면 null = map.get("없는나라");
null이 반환되므로 if문을 통해 처리를 해줬다
나라 입력 : 일본
일본의 수도는 도쿄
나라 입력 : 도쿄
수도가 등록되지 않았어요
나라 입력 : 대한민국
대한민국의 수도는 서울
나라 입력 : 종료
@@수도찾기 종료@@
추가 문제 ( key ,value , entry 조회 관련 )
위 문제에서 종료 시 등록된 나라 , 수도를 각각 출력하고
나라:수도 의 쌍도 출력하고 종료하자
(코드가 긴관계로 구동클래스는 일부만 보여주겠음)
if(a.equals("종료")) {
keySearch(map);
valueSearch(map);
EntrySearch(map);
break;
}종료 시 밑에 메서드3개를 출력하고 종료하는것임!!!!
private static void keySearch(Map map) {
Set keySet = map.keySet();
System.out.print("--등록 나라 : ");
for (Object o : keySet) {
System.out.print(o+",");
}System.out.println();
}
private static void valueSearch(Map map) {
Collection values = map.values();
System.out.print("--등록 수도 : ");
for (Object o : values) {
System.out.print(o+",");
}System.out.println();
}
private static void EntrySearch(Map map) {
System.out.println("--등록 된 쌍 : --");
Set entrySet = map.entrySet();
for (Object o : entrySet) {
System.out.println(o);
}
}나라 입력 : 종료
--등록 나라 : 캐나다,영국,일본,대한민국,
--등록 수도 : 오타와,런던,도쿄,서울,
--등록 된 쌍 : --
캐나다=오타와
영국=런던
일본=도쿄
대한민국=서울
4.등록된 나라가 아닌경우 수도를 입력받아 map객체에 추가해보자
(편의를 위해 코드의while문만 보여줌!!!)
while(true) {
System.out.print("나라 입력 : ");
String a = scan.next();
String s = map.get(a);
if(a.equals("종료")) {
keySearch(map);
valueSearch(map);
EntrySearch(map);
break;
}
if(s != null) {
System.out.println(a+"의 수도는 "+s);
}
else {
System.out.println("수도가 등록되지 않았어요");
System.out.println("수도를 등록할까요? (Y)");
String y = scan.next();
if(y.equalsIgnoreCase("Y")){
String sudo = scan.next();
map.put(a,sudo);
System.out.println("등록완료");
}
else continue;
}
}나라 입력 : 유동
수도가 등록되지 않았어요
수도를 등록할까요? (Y)
y
유동교
등록완료
나라 입력 : 유동
유동의 수도는 유동교
나라 입력 :
도서정보 예제( 맨 밑에 예제와 연관)
추가 삭제 검색 조회
package ex3_map;
import java.util.Collection;
import java.util.HashMap;
import java.util.InputMismatchException;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Scanner;
import java.util.Set;
class Book{
String title;
String author;
int price;
public Book(String title, String author, int price) {
this.title = title;
this.author = author;
this.price = price;
}
@Override
public String toString() {
return "(" + title + "," + author + "," + price + ")";
}
}
public class MapEx2 {
static Map<String,Book> books = new HashMap<>();
public static void main(String[] args) {
Scanner scan= new Scanner(System.in);
while(true) {
try {
System.out.println("1.추가 2.삭제 3.조회 4.검색 0.종료");
int choose = scan.nextInt();
if(choose==0)break;
switch(choose) {
case 1-> {addBoook();}
case 2-> {deleteBook();}
case 3-> {printBook();}
case 4-> {searchBook();}
default-> System.out.println("잘못된 입력입니다 1 2 3 4 0 중에입력 ");
}
}
catch (InputMismatchException e) {
System.out.println("1,2,3,4,0 숫자만 입력하세요");
scan.next();
}
}
}
private static void searchBook() {
Scanner scan = new Scanner(System.in);
System.out.println("책 검색 시작");
System.out.print(" 제목을 입력하세요 : ");
String name = scan.next();
Book book = books.get(name);
if(book==null) {
System.out.println("존재하지않는제목");
}
else {
System.out.println(book);
}
}
//------------------------------------------------------------------
private static void printBook() {
System.out.println("도서목록 조회");
Collection<Book> values = books.values();
for (Book book : values) {
System.out.println(book);
}
}
//------------------------------------------------------------------
private static void deleteBook() {
Scanner scan = new Scanner(System.in);
System.out.printf("삭제 할 책 이름을 입력 : ");
String title = scan.next();
Book remove = books.remove(title);//key값으로 삭제할요소를 찾아냄
if(remove ==null) {
System.out.println("없는 도서에요");}
else {
System.out.println(remove+" 삭제 완료");
System.out.println("현재 도서 재고 : "+books);}
}
//------------------------------------------------------------
private static void addBoook() {
System.out.println("도서를 추가할게요 ");
Scanner scan = new Scanner(System.in);
System.out.printf("제목 : ");
String title = scan.next();
System.out.printf("저자 : ");
String author = scan.next();
System.out.printf("가격 : ");
try {
int price = scan.nextInt();
Book book = new Book(title, author, price);
books.put(title,book);
System.out.println(book+" 도서 추가");}
catch(InputMismatchException e){
System.out.println("처음부터 다시입력해주세요");
scan.next();
}
}
}1.추가 2.삭제 3.조회 4.검색 0.종료
1
도서를 추가할게요
제목 : 채식주의자
저자 : 한강
가격 : 13000
(채식주의자,한강,13000) 도서 추가
1.추가 2.삭제 3.조회 4.검색 0.종료
1
도서를 추가할게요
제목 : 소년이온다
저자 : 한강
가격 : 14000
(소년이온다,한강,14000) 도서 추가
1.추가 2.삭제 3.조회 4.검색 0.종료
3
도서목록 조회
(채식주의자,한강,13000)
(소년이온다,한강,14000)
1.추가 2.삭제 3.조회 4.검색 0.종료
2
삭제 할 책 이름을 입력 : 채식주의자
(채식주의자,한강,13000) 삭제 완료
현재 도서 재고 : {소년이온다=(소년이온다,한강,14000)}
1.추가 2.삭제 3.조회 4.검색 0.종료
4
책 검색 시작
제목을 입력하세요 : 소년이온다
(소년이온다,한강,14000)
1.추가 2.삭제 3.조회 4.검색 0.종료
3
도서목록 조회
(소년이온다,한강,14000)
1.추가 2.삭제 3.조회 4.검색 0.종료
4
책 검색 시작
제목을 입력하세요 : 안녕하세요
존재하지않는제목
1.추가 2.삭제 3.조회 4.검색 0.종료
0TreeMap<k,v>( )
https://docs.oracle.com/en/java/javase/23/docs/api/java.base/java/util/TreeMap.html
TreeMap (Java SE 23 & JDK 23)
floorEntry
docs.oracle.com
key값 기준으로 정렬을 하는 map
package ex3_map;
import java.util.SortedMap;
import java.util.TreeMap;
/*
* TreeMap : key값 기준으로 정렬을하는 map
*/
public class MapEx3 {
public static void main(String[] args) {
TreeMap<String,Book> books = new TreeMap<>();
books.put("홍길동전",new Book("홍길동전","허균",10000));
books.put("춘향전",new Book("춘향전","미상",14000));
books.put("구운몽",new Book("구운몽","미상",5000));
System.out.println(books);
System.out.println("TreeMap에서만 구현 가능한 조회 메서드!!!");
System.out.println("첫번째 key : "+books.firstKey());
System.out.println("첫번째 entry : "+books.firstEntry());
System.out.println("마지막 key : "+books.lastKey());
System.out.println("마지막 entry : "+books.lastEntry());
//lowerEntry(key) : key 앞쪽 객체
System.out.println("춘향전 앞의 entry : "+books.lowerEntry("춘향전"));
//higherEntry(key) : key 뒤쪽 객체
System.out.println("춘향전 뒤의 entry : "+books.higherEntry("춘향전"));
//floorEntry("춘") : 춘 부터 앞쪽 객체(자신도 포함)
System.out.println("춘 앞의 entry : "+books.floorEntry("춘"));
//floorEntry("춘") : 춘 부터 뒤쪽 객체(자신도 포함)
System.out.println("춘 뒤의 entry : "+books.ceilingEntry("춘"));
}
}{구운몽=(구운몽,미상,5000), 춘향전=(춘향전,미상,14000), 홍길동전=(홍길동전,허균,10000)}
TreeMap에서만 구현 가능한 조회 메서드!!!
첫번째 key : 구운몽
첫번째 entry : 구운몽=(구운몽,미상,5000)
마지막 key : 홍길동전
마지막 entry : 홍길동전=(홍길동전,허균,10000)
춘향전 앞의 entry : 구운몽=(구운몽,미상,5000)
춘향전 뒤의 entry : 홍길동전=(홍길동전,허균,10000)
춘 앞의 entry : 구운몽=(구운몽,미상,5000)
춘 뒤의 entry : 춘향전=(춘향전,미상,14000)
TreeMap의 조회를 이용한 예제
package ex3_map;
import java.lang.reflect.Field;
import java.util.Comparator;
import java.util.TreeMap;
public class Exam2 {
public static void main(String[] args) {
TreeMap<Integer,String> scores = new TreeMap<>();
mapPut(scores);
System.out.println(scores);
System.out.println("첫번쨰key : "+scores.firstKey());
System.out.println("마지막 key : "+scores.lastKey());
// System.out.println("가장 높은 점수를 받은 사람의 이름 : "
// +scores.get(scores.lastKey()));
System.out.println("가장 높은 점수를 받은 사람의 이름 : "
+scores.lastEntry().getValue());
System.out.println("94점보다 앞의 점수 : "+scores.lowerKey(94));
System.out.println("94점보다 뒤의 점수 : "+scores.higherKey(94));
System.out.println("94를 포함한 앞의 점수 : "+scores.floorKey(94));
System.out.println("94를 포함한 뒤의 점수 : "+scores.ceilingKey(94));
System.out.println("======revverse!!(내림차순)========");
scores = new TreeMap<>(Comparator.reverseOrder());
mapPut(scores);
System.out.println(scores);
System.out.println("가장낮은 점수받은 사람의 이름 : "+scores.lastEntry().getValue());
System.out.println("94보다 큰 점수 : "+scores.lowerKey(94));
}
private static void mapPut(TreeMap<Integer,String> scores) {
scores.put(87, "홍길동");
scores.put(98, "이몽룡");
scores.put(75, "임꺽정");
scores.put(94, "조사병단");
scores.put(82, "유재석");
scores.put(88, "하하");
}
}
/*
{75=임꺽정, 82=유재석, 87=홍길동, 88=하하, 94=조사병단, 98=이몽룡}
첫번쨰key : 75
마지막 key : 98
가장 높은 점수를 받은 사람의 이름 : 이몽룡
94점보다 앞의 점수 : 88
94점보다 뒤의 점수 : 98
94를 포함한 앞의 점수 : 94
94를 포함한 뒤의 점수 : 94
======revverse!!(내림차순)========
{98=이몽룡, 94=조사병단, 88=하하, 87=홍길동, 82=유재석, 75=임꺽정}
가장낮은 점수받은 사람의 이름 : 임꺽정
94보다 큰 점수 : 98
*/
* Map 구현 클래스
* HashMap : (key , value) 쌓인 객체의 모임 . 순서를 모름
* TreeMap : (key , value) 쌓인 객체의 모임 . 키값으로정렬순서
* HashTable : (key , value) 쌓인 객체의 모임 , 순서를 모름 , **구버전(List의 Vector같은존재)**
* 동기화 : 스레드에 대해서 safe
package ex3_map;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.Map;
public class MapEx4 {
public static void main(String[] args){
Hashtable<String, String> map = new Hashtable<>();
map.put("학생", "student");
map.put("선생", "teacher");
// map.put(null, "null"); /* hashtable객체에서는 null을 key로사용할수없음 */
System.out.println(map);
Map<String, String> map2 = new HashMap<>();
map2.put("학생", "student");
map2.put("선생", "teacher");
map2.put(null, "null"); //hashmap객체에서는 null을 key로 사용가능
System.out.println(map2);
}
}{선생=teacher, 학생=student}
{null=null, 선생=teacher, 학생=student}
3 ) Collection 정리
1) List
순서유지 , 인덱스사용
정렬사용 ( Comparable , Comprator)
ex)ArrayList , Vector , LinkedList
2) set
중복불가
중복판별
(내가만든 객체는
hashCode와 equals를 구현해서 넣자)
HashSet , TreeSet , LinkedHashset
3)map
키값쌍으로 이루어짐
예제 리뷰(정렬과 Map에 관련된 예제)
문제1)
* 1 ~ 99까지의 정수를 입력받아서 TreeSet에 저장하고, 0 을 입력하면 입력을 종료한다.
* 입력된 값을 정렬하여 출력하기.
1 ~ 99 까지의 숫자가 아닌 경우 TreeSet에서 저장하지 말것.
*
* set1 오름차순 정렬되도록 출력.
* set2 내림차순 정렬되도록 출력하기.
*
*[결과]
1부터 99까지의 숫자를 입력하세요 (종료 : 0)
1 2 5 9 1 100 12 3 2 5 64 123 4 5 0
set1:[1, 2, 3, 4, 5, 9, 12, 64]
set2:[64, 12, 9, 5, 4, 3, 2, 1]
package test_setMap;
import java.util.Comparator;
import java.util.InputMismatchException;
import java.util.Scanner;
import java.util.TreeSet;
public class Test1 {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
TreeSet<Integer> set = new TreeSet<Integer>();
TreeSet<Integer> set2 = new TreeSet<>(Comparator.reverseOrder());
System.out.println("1~99사이의 숫자입력 : 종료(0)");
while(true) {
try {
int num = scan.nextInt();
if(num==0)break;
if(1<=num && num<=99) {
set.add(num);
set2.add(num);
}
}
catch(InputMismatchException e) {
scan.next();
}
}
System.out.println("set : "+set);
System.out.println("set2 : "+set2);
}
}1. 기본적으로 오름차순정렬하는 기본 TreeSet 생성
2. TreeSet을 하나 더 만들어준다 (Comparator.reverserOrder())로
내림차순정렬을 하는 TreeSet이다
3.nextInt()에 String문자열을 넣으면 발생되는 예외를 catch해 주고
scan.next()로 없애준다 그 후 계속 루프!!
4.1보다 크고 99보다 작은 num만 각 set에 넣는다
set1 , set2
0이입력되면
각 Treeset을 출력하면 됨
1~99사이의 숫자입력 : 종료(0)
1 2 6 24 4 5 78 65 32 21 17
0
set : [1, 2, 4, 5, 6, 17, 21, 24, 32, 65, 78]
set2 : [78, 65, 32, 24, 21, 17, 6, 5, 4, 2, 1]
예제 2)
1.궁합음식의 키를 입력받아 해당되는 음식을 출력하기.
종료가 입력될때 까지 계속 출력하기
2.종료 입력시 등록된 내용 출력하기
등록된음식 :
떡볶이 : 오뎅
짜장면 : 단무지
3. 등록이 안된경우
등록여부를 입력받아, 등록하는 경우 궁합음식을 입력받기
등록하시겠습니까(y)?
y입력 : foods객체에 추가.
궁합음식 입력받아서 foods에 추가함
y가아닌경우 :
음식을 다시 입력하기
[결과]
음식명을 입력하세요(종료:종료)
떡볶이
떡볶이의 궁합음식:오뎅
음식명을 입력하세요(종료:종료)
치킨
치킨의 궁합음식이 등록되어 있지 않습니다.등록하시겠습니까?
y
치킨의 궁합음식을 등록하세요
맥주
음식명을 입력하세요(종료:종료)
종료
{치킨=맥주, 떡볶이=오뎅, 라면=김치}여기서 생각해야할점
1. 등록이 안된경우를 찾는 방법
2.등록여부 확인문
3. foods 객체에 추가하는 방법
4. 추가를 하지 않을 시 루프의처음으로 돌아갈 방법
public class Test2 {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
HashMap<String,String> map = new HashMap<>();
map.put("떡볶이", "오뎅");
map.put("치킨", "맥주");
map.put("라면", "김치");
while(true) {
System.out.println("음식명을 입력하세요(종료:종료)");
String food = scan.next();
String food2 = map.get(food);
if(food.equals("종료")) {
System.out.println(map);
System.out.println("종료합니다");
break;
}
if(food2==null) {
System.out.println(food+"의 궁합음식이없어요");
System.out.println("등록할까요? (y)");
String y = scan.next();
if(y.equalsIgnoreCase("Y")) {
System.out.println(food+"의 궁합음식 등록");
String s= scan.next();
map.put(food, s);
}
else {
continue;
}
}
else {
System.out.println(food+"의 궁합 : "+food2);
}
}
}
}food는 map객체이다
map.get( key)로
key와 매핑하는 값이 있는지 확인이가능
만약 없다면 null을 반환함
등록한다고 한다면
궁합을 입력받고
map.put(food , s) 로 넣어준다
등록하지않는다면
contiue 로 처음으로 돌아감
음식명을 입력하세요(종료:종료)
떡볶이
떡볶이의 궁합 : 오뎅
음식명을 입력하세요(종료:종료)
닭갈비
닭갈비의 궁합음식이없어요
등록할까요? (y)
y
닭갈비의 궁합음식 등록
치즈
음식명을 입력하세요(종료:종료)
종료
{치킨=맥주, 닭갈비=치즈, 떡볶이=오뎅, 라면=김치}
종료합니다
예제3) 가장어려웠음
* MapEx2의 예제를 이용하기
*
* 조회를 입력했을 경우
* 제목,저자,가격순으로 조회되도록 프로그램 수정하기
*
* 검색을 입력했을 경우
* 제목,저장,가격으로 검색하도록 프로그램을 수정하기
*
* [결과]
1.추가 2.삭제 3.조회 4.검색 0.종료
3
정렬 방식을 입력하세요 (1.제목 2.저자 3.가격)
1
(춘향전,미상,5000)
(홍길동전,허균,10000)
1.추가 2.삭제 3.조회 4.검색 0.종료
4
도서를 검색합니다.
조회 기준을 입력하세요 (1.제목 2.저자 3.가격)
1
제목을 입력하세요
홍길동전
조회 정보 : (홍길동전,허균,10000) 입니다.이건 MapEx2의 예제까지 이용한거라
코드가 굉장히 길어졌다
그러므로
메서드별로 다 나눠서 보여주겠다
추가와 삭제메서드는 위에 도서예제에 있는거와 바뀌지않아 올리지않았음!!
Book클래스(map의 값으로 들어가게됨)
class Book implements Comparable<Book>{
String title;
String author;
int price;
public Book(String title, String author, int price) {
this.title = title;
this.author = author;
this.price = price;
}
@Override
public String toString() {
return "(" + title + "," + author + "," + price + ")";
}
@Override
public int compareTo(Book o) {
return title.compareTo(o.title);
}
}정렬을 위해
Comparable을 구현해 compareTo메서드를 오버라이딩했음( 제목기준)
구동클래스
public class Test3_A {
private static Map<String,Book> books = new HashMap<>();
public static void main(String[] args) {
Scanner scan= new Scanner(System.in);
//확인용
books.put("안녕", new Book("안녕", "하이", 10000));
books.put("채식주의자", new Book("채식주의자", "한강", 5000));
books.put("가나다", new Book("가나다", "당근", 8000));
books.put("마라", new Book("마라", "수박", 2000));
//확인용
while(true) {
try {
System.out.println("1.추가 2.삭제 3.조회 4.검색 0.종료");
int choose = scan.nextInt();
if(choose==0)break;
switch(choose) {
case 1-> {addBoook();}
case 2-> {deleteBook();}
case 3-> {printBook();}
case 4-> {searchBook();}
default-> System.out.println("잘못된 입력입니다 1 2 3 4 0 중에입력 ");
}
}
catch (InputMismatchException e) {
System.out.println("1,2,3,4,0 숫자만 입력하세요");
scan.next();
}
}
}검색(searchBooke ) 메서드
Map타입인 books의 값을 인자로받는 List나Set을 만든다
(books의 값이 List나 Set에 들어가는것)
그 후 번호를 입력받는다
try catch문을 사용해
문자를 입력했을 경우에 예외를 터트리지않고
호출메서드로 돌아감
switch문으로 번호마다 다른문장을 실행
1번 or 아무번호 입력 title을 포함하는 요소를 출력후 return;
(return 해야 호출메서드로 돌아갈 수 있음)
중요점 : title은 map에서의key 이기때문에
중복이 없으므로 하나라도 찾앗다면 return;
2번이면 저자를 입력받아 book에 존재한다면
새로만든 book을 요소로사용하는 bookList2에 저장
(리스트에 저장하지않고 출력후
return 시 중복되는 저자는 출력이 되지않음)
for문이 모두 종료됐을 시점에
bookList2.size가 0이면 존재하지않는 저자
그게아니라면 bookList2 출력
2번이면 가격을 입력받아 book에 존재한다면
새로만든 book을 요소로사용하는 bookList2에 저장
(저장하지않고 출력 후 return 시
중복되는 가격에 대한 객체는 출력이 되지않음)
for문이 모두 종료됐을 시점에
bookList2.size가 0이면 존재하지않는 가격
그게아니라면 bookList2 출력
책 검색 시작
검색기준 입력 : 1(제목) 2(저자) 3(가격) (아무거나입력시 제목!)
3
가격을 입력하세요8000
[(가나다,당근,8000), (유동곤,당근,8000)]
//title 부분처럼 포함되는 객체를 찾았다고 return하면 중복 되는 가격을 출력할 수 없음
private static void searchBook() {
Scanner scan = new Scanner(System.in);
System.out.println("책 검색 시작");
List<Book> bookList = new ArrayList<>(books.values());
// Set<Book> bookset = new HashSet<>(books.values());
System.out.println("검색기준 입력 : 1(제목) 2(저자) 3(가격) (아무거나입력시 제목!)");
try {
int num = scan.nextInt();
switch(num) {
case 1->{
System.out.print("제목을 입력하세요");
String next = scan.next();
Book book2 = null;
for (Book book : bookList) {
if(book.title.equals(next)){
System.out.println(book2);
return;//return으로 현재메서드를 종료하고 호출한곳으로 가게 됨 (104번째줄)
//map의 key값은 중복될수없으니 제목은 중복되는게 없을거다
}
}System.out.println(next+"는 없는 제목");
// for(Book book : bookset) {
// if(book.title.equals(next)){
// System.out.println(book);
// return;
// } 검색은 Set도 가능한 것을 확인
// }
}
case 2->{
System.out.print("저자를 입력하세요");
String next = scan.next();
ArrayList<Book> bookList2 = new ArrayList<Book>();
for (Book book : bookList) {
if(book.author.equals(next)){
bookList2.add(book);
}
}
if(bookList2.size()==0) {
System.out.println(next+"는 존재하지않는 저자");
}
else {
System.out.println(bookList2);
}
}
case 3->{
System.out.print("가격을 입력하세요");
int price = scan.nextInt();
ArrayList<Book> bookList2 = new ArrayList<Book>();
for (Book book : bookList) {
if(book.price==price){
bookList2.add(book);
}
}
if(bookList2.size()==0) {
System.out.println(price+"는 존재하지않는 가격");
}
else {
System.out.println(bookList2);
}
}
default->{
System.out.print("제목을 입력하세요");
String next = scan.next();
for (Book book : bookList) {
if(book.title.equals(next)){
System.out.println(book);
return;
}
}System.out.println(next+"존재하지않는 제목");
}
}
}
catch(InputMismatchException e) {
System.out.println("숫자만 입력");
scan.next();
return;
}
}
조회메서드(printBook)
조회메서드의 경우에도 제목 저자 가격별로 정렬을 요청하는 메서드이다
nextInt()로 숫자를 입력받기때문에
InputMismatchException이 발생할 수 있다/
try catch문으로 예외를 잡아 호출메서드로다시보내자.
1번을 선택했다면 book클래스에 CompareTo를 title기준으로
정렬해놨으니 Collection.sort() 후 bookList를 출력해주면 됨
2번은 저자 기준으로 정렬이다 저자는 String(래퍼객체)이기때문에
CompareTo 메서드사용가능!!!
람다식을 이용해
(S1,s2)->s1.author.compareTo(s2.author) 을 해주면
한글순으로 오름차순 정렬이 됨
3번은 가격입력부분이므로
그냥 s1.price - s2.price 로 오름차순정렬을 해줌
private static void printBook() {
Scanner scan = new Scanner(System.in);
System.out.println("도서목록 조회");
System.out.println("조회방식을 입력하세요 1제목 2저자 3가격(아무거나입력시 제목 순)");
try {
int print = scan.nextInt();
List<Book> bookList = new ArrayList<>(books.values());
switch(print) {
case 1->Collections.sort(bookList);//객체에 제목으로 compare을 오버라이딩해놨음
case 2->{Collections.sort(bookList,//저자로 정렬(compareTo활용)
(s1,s2)->s1.author.compareTo(s2.author));}
case 3->{Collections.sort(bookList,
(s1,s2)->s1.price-s2.price);}//가격으로 정렬
default ->Collections.sort(bookList);
}
System.out.println(bookList);
}
catch(InputMismatchException e) {
System.out.println("숫자만 입력 ");
scan.next();
}
}
'부트캠프(Java)' 카테고리의 다른 글
| 자바/스프링 부트캠프 17일차( 보조스트림 ,객체직렬화 , 파일) (1) | 2025.02.25 |
|---|---|
| 자바/스프링 부트캠프 16일차 ( 반복자 , 스트림) (0) | 2025.02.21 |
| 자바/스프링 부트캠프 14일차( collection ) (3) | 2025.02.19 |
| 자바/스프링 부트캠프 13일차( API {java.util}) (0) | 2025.02.18 |
| 자바/스프링 부트캠프 12일차(API (4) | 2025.02.17 |