java
15일차 2023-03-28
choi Hoon
2023. 3. 28. 20:39
1.Package
1-1)
패키지.*;의 *(asterik)은 모든을 의미
import java.util.*;
은 util패키지 안에 있는 클래스나 인터페이스를 다 읽음.
그래서 *은 되도록 안 쓰는 게 좋다 시간이 더 걸림
util 패키지 안의 하위 패키지는 포함 안된다.
java.lang패키지 안의 클래스들은 기본 패키지로 import 안 해도 된다.
1-2)
.jar파일로 묶기
두 가지 경우가 있다
첫 번째). 컴파일된 .class파일들을 . jar로 묶기
1) 일단 메인이 있는 클래스를 한번 실행=>
2) File-Export-java-Runnable Jar file선택 -Next
3) Launch Configuration:main메소드가 있는 클래스 선택 => Export Destination: .jar로 저장할 위치 및 파일명 지정
위와 같이 묶는 경우 해당 프로젝트의 모든 패키지가 jar로 묶인다.
따라서 새 프로젝트를 만들어 실행하고자 하는 파일이 들어 있는 패키지나 클래스만 별도로
복사해서 실행가능한 .jar로 배포하도록 하자.
두 번째). 라이브러리용으로 묶기
1) 프로젝트 선택 후 마우스 우클릭 -Export -Java-Jar file선택 -Next-배포하고자 하는 패키지 선택(common.utility)
Export Destination: .jar로 저장할 위치 및 파일명 지정 그리고 Next~Finish
2) jar로 묶는 라이브로리 ㅣ프로젝트에서 가져다 쓰기
Build Path: 프로젝트마다 빌드 패스 해야 한다
새 프로젝트 생성 후 해당 프로젝트 마우스 우클릭 -Build path-Configure Bulid Path-Libraries탭 -Classpath 선택
PackageApp.java
//1]패키지 선언문
package package19;
//2]import선언문
import java.util.Date;
public class PackageApp {
public static void main(String[] args) {
//다른 패키지에 있는 클래스 접근 방법]
//방법1]import해서 사용-패키지 지정 불필요
Date utilDate = new Date();
System.out.println(utilDate);
//방법2]import불필요-직접 패키지 명까지 지정
java.sql.Date sqlDate = new java.sql.Date(new Date().getTime());
System.out.println(sqlDate);
}///////////////////main
}//////////////////////class2. 컬렉션 클래스
-Collection 인터페이스로 부터 구현된 클래스
- 데이타를 효율적으로 사용하기 위한 하나의 자료구조
- 객체(클래스)만 저장할 수 있다.
- get()메서드 혹은 Iterator, Enumeration인터페이스의 메서드릉 이용해서 객체를 꺼내 올 수 있다.
- 메모리 기반의 작은 데이타 베이스 역할을 한다(입력. 삭제. 검색등)
Collection 인터페이스의 주요 메서드
int size():컬렉션에 저장된 객체의 개수 리턴
boolean isEmpty(); 객체가 비었으면 true, 아니면 false반환
boolean add(Object obj): 객체 추가. 성공 시 true
boolean remove(Object obj): 객체 삭제. 성공시 true
boolean removeAll(Collection col) 저장된 객체 전체 삭제=>. clear를 사용하는 게 편함
boolean contains(Object obj): 해당 객체가 있으면 true.
Iterator iterator(): Iterator인터페이스 반환(꺼내올 때)
컬렉션의 계층 구조
Collection (인터페이스)
|
|
+----------------------------+
| |
Set List Map 이 줄=> (인터페이스들)
| | |
HashSet ArrayList, Vector HashMap, HashTable 이 줄=> (클래스들)
Map은 컬렉션 상속 x
-Set계열은 데이터 저장 시 중복 허용 x, 순서 없이 저장. (복주머니라고 생각하면 편함)
-List계열은 데이터 중복 허용, 순서 있게 저장된다. (배열이라 생각하면 편함)
-Map계열은 키와 값의 쌍으로 저장되고(key -value 형태)
인덱스가 아닌 키 값으로 검색해서 검색 속도가 빠르다.
3. HashSet
HashSet <String>을 넣으면 String타입만 가능 이렇게 사용하면 컴파일시점에서 다른 타입은 빨간 줄생김=>이걸 타입 안전성이라 함(실행하기 전에 빨간줄 경고)
HashSet <>를 안 한 new연산자를 사용하면 raw 타입
ex) HashSet set = new HashSet();
객체 저장할 때 set.add() 사용해서 저장
객체수 얻을 때 int size() 사용
중복 저장[x] =>. add()가 false반환한다
반복기 (Iterator)를 통해 꺼내옴
hashNext():꺼내올 객체가 있으면 true, 아니면 false
next():객체 꺼내옴
NoSuchElementException이 뜨면 객체가 없는데 꺼내려고 했나 한번 생각
검색: boolean (Object e)
삭제: boolean remove(Object e)
전체 삭제:set.clear();
HashSetApp.java
package collection20;
import java.util.Date;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Scanner;
import console.academy.Student;
public class HashSetApp {
public static void main(String[] args) {
/*
컬렉션 클래스들 : Generic Type에 속한다 즉 인스턴스화 할때 타입 파라미터(<T>또는 <E>)를 지정한다
예] HashSet<E>형태다
<E>를 지정하지 않은 타입을 Raw Type이라 한다
*/
//1]<T>타입 파라미터에 타입을 지정 안 한경우]
// -어느 타입의 객체든 저장 가능.
//1-1]컬렉션 생성
HashSet set = new HashSet();//이때 HashSet는 raw type
//1-2]컬렉션에 저장할 객체 생성
String strObj1="JAVA";
String strObj2=new String("WORLD");
java.sql.Date dateObj = new java.sql.Date(new Date().getTime());
Integer intObj=100;
Student stuObj = new Student("가길동", 20, "2023학번");
//1-3]컬렉션에 객체 저장-boolean add(Object)
System.out.println(set.add(strObj1)?"저장성공":"저장실패");
System.out.println(set.add(strObj2));
System.out.println(set.add(dateObj));
System.out.println(set.add(intObj));
System.out.println(set.add(stuObj));
//1-4]컬렉션에 저장된 객체수 얻기:int size()
System.out.println("중복 저장 전 저장된 객체 수:"+set.size());
//1-5]중복저장[x]-에러는 안나지만 저장이 안됨(즉 add()메소드가 false반환)
System.out.println(set.add(strObj1)?"저장성공":"저장실패");
System.out.println("중복 저장 후 저장된 객체 수:"+set.size());
//1-6]저장된 객체 꺼내오기
// -순서없이 저장됨(반복기를 통해서 꺼내오기)
/*
Iterator의 주요 추상 메소드]
※데이타가 순서 있게 저장된 자료구조(List 계열)
나 순서 없이 저장된 자료구조(Set계열)
에서 데이타를 꺼내올때 사용하는 타입(인터페이스)
단,확장 for문 써도 무방
hasNext():꺼내올 객체가 있으면 true반환
없으면 false반환.
hasNext()메소드로 판단후
next()메소드로 꺼내온다
*/
System.out.println("[반복기 사용]");
//1-6-1]iterator()메소드로 Iterator타입의 인스턴스 얻기
Iterator it= set.iterator();
while(it.hasNext()) {//1-6-2]hasNext()로 꺼내올 객체의 유무여부 판단
Object obj=it.next();
if(obj instanceof String) System.out.println("String타입:"+obj);
else if(obj instanceof java.sql.Date) System.out.println("Date타입:"+obj);
else if(obj instanceof Integer) System.out.println("Integer타입:"+obj);
else if(obj instanceof Student) System.out.println("Student타입:"+((Student) obj).get());
}
//※모든 객체 꺼내온 후 next()호출시 실행 오류발생]
/* next()메소드 호출시마다 하나씩 꺼내온다
만약 컬렉션에 꺼내올 객체가 없는데 next()를
호출한다면 예외 발생(java.util.NoSuchElementException)
*/
//it.next();//[x]실행 오류 발생
/*
확장 for문: 배열이나 컬렉션에 저장된 값(객체)을 꺼내올때
사용하는 for문의 확장형
형식]
for(자료형 객체를담을변수 : 배열명이나 혹은 컬렉션명){
}
*/
String[] mountains = {"비슬산","덕유산","태백산","속리산"};
for(String mountain:mountains) System.out.println(mountain);
System.out.println("[확장 for문 사용]");
for(Object obj:set) {
if(obj instanceof String) System.out.println("String타입:"+obj);
else if(obj instanceof java.sql.Date) System.out.println("Date타입:"+obj);
else if(obj instanceof Integer) System.out.println("Integer타입:"+obj);
else if(obj instanceof Student) System.out.println("Student타입:"+((Student) obj).get());
}
//1-7]검색:boolean contains(Object e)
System.out.println(set.contains(strObj2)?"strObj2가 있다":"strObj2가 없다");
System.out.println(set.contains(intObj));
System.out.println(set.contains("JAVA"));
System.out.println(set.contains("KOMSO"));
//1-8]삭제:boolean remove(Object e)
System.out.println(set.remove(strObj1)?"삭제성공":"삭제실패");
System.out.println(set.remove(strObj1)?"삭제성공":"삭제실패");
System.out.println("삭제 후 저장된 객체 수:"+set.size());
//1-9]전체 삭제 :boolean removeAll(Collection c)
//set.removeAll(set);
set.clear();
System.out.println("전체 삭제 후 저장된 객체 수:"+set.size());
//2]<?>타입 파라미터 사용- 해당 타입(?)만 저장 가능.
// 즉 컴파일시 타입체크 가능(타입 안정성:Type Safety)
//HashSet<Student> set2 = new HashSet<Student>();
HashSet<Student> set2 = new HashSet<>();//JDK 1.7부터 생성자의 타입 파라미터 생략가능
//HashSet<Student> 제너릭타입(제너릭 클래스)
//2-1]컬렉션에 저장할 객체 생성
Student stu1 = new Student("가길동", 30, "2019학번");
Student stu2 = new Student("나길동", 20, "2023학번");
Student stu3 = new Student("다길동", 25, "2020학번");
Student stu4 = new Student("라길동", 40, "2018학번");
//2-2]객체 저장
set2.add(stu1);
set2.add(stu2);
set2.add(stu3);
set2.add(stu4);
//set2.add(strObj2);//[x]타입 파리미터에 지정한 타입만 저장 가능.컴파일시 타입체크가 됨
//2-3]객체 꺼내오기
System.out.println("[반복기 사용]");
Iterator<Student> it2= set2.iterator();
while(it2.hasNext()) {
/*
next()메소드는 호출 할때마다 객체를
무조건 하나씩 꺼내온다
고로 아래는 반복 한번에
세개의 Student객체를 꺼내오는것
만약 더 이상 꺼내올 객체가 없는데
next()를 호출하면
java.util.NoSuchElementException예외 발생
*/
/*
System.out.println(String.format("이름:%s,나이:%s,학번:%s",
it2.next().name,
it2.next().age,
it2.next().stNumber
));*/
Student st = it2.next();
System.out.println(String.format("이름:%s,나이:%s,학번:%s",
st.name,
st.age,
st.stNumber
));
}///////while
System.out.println("[확장 for문 사용]");
for(Student st : set2) st.print();
//2-4]검색
System.out.println(set2.contains(stu1));
System.out.println(set2.contains(new Student(null,0,null)));
//2-5]삭제
//set2.remove(stu1);
//set2.clear();
//System.out.println("삭제후 저장된 객체 수:"+set2.size());
Scanner sc = new Scanner(System.in);
System.out.println("검색할 이름을 입력하세요?");
String searchName = sc.nextLine().trim();
/*문]컬렉션 set2에 저장된 객체를 이름으로 검색하자.있는 이름으로 검색해 보고
없는 이름으로 검색해보자.
있으면 해당 학생의 정보를 출력하고
없으면 "해당 학생이 없어요"라는 메시지 출력] */
boolean isExist= false;
for(Student s : set2)
if(searchName.equals(s.name)) {
s.print();
isExist=true;
break;
}
if(!isExist) System.out.println("해당 학생이 없어요");
}/////////////main
}////////////////classsol)
4. ArrayList
배열이라 생각하면 쉽다
중복 저장 가능 순서 있고
배열은 고정된 구조여서 크기를 바꿀 수 없다면
ArrayList는 크기가 변경 가능
중복 저장되면 인덱스가 빠른 게 삭제됨
ArrayList.java
package collection20;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Scanner;
import console.academy.Student;
/*
ArrayList: List(인터페이스)계열의 컬렉션 클래스
- 중복 저장 가능
- 순서 있게 저장
- 데이타 꺼내올때: iterator()/get(index)
*/
public class ArrayListApp {
public static void main(String[] args) {
//1]List 계열 컬렉션 객체 생성(Raw Type)
List list = new ArrayList();
//1-1]객체 저장:add() 계열
/*
boolean add(Object element):계속 추가되면서
인덱스는 0부터 자동 부여
boolean add(int index,Object element);
:계속 추가되면서 저장시
인덱스 위치 부여 할 수 있다.
인덱스번호 재배치됨.
*/
System.out.println(list.add("가산")?"저장 성공":"저장 실패");//인덱스 0번방에 저장
list.add("나산");//인덱스 1번방에 저장
list.add("다산");//인덱스 2번방에 저장
//list.add(5,"라산");//[x]런타임시 오류 IndexOutOfBoundsException
//※인덱스 지정시는 순차적으로 다음 인덱스를 지정하거나
// 기존에 존재하는 인덱스로 지정
list.add(3,"라산");
list.add(list.size(),"마산");
list.add(list.size(),"바산");//마지막 방 번호 다음
System.out.println("중복 저장 전 객체 수:"+list.size());
//1-2]중복저장:허용
System.out.println(list.add("가산")?"저장 성공":"저장 실패");
System.out.println("중복 저장 후 객체 수:"+list.size());
//1-3]출력
System.out.println("[일반 for문:get(index)]");
for(int i=0;i<list.size();i++) {
Object obj=list.get(i);
System.out.println(obj);
}
System.out.println("[확장 for문]");
for(Object obj:list) System.out.println(obj);
System.out.println("[반복기]");
Iterator it=list.iterator();
while(it.hasNext()) System.out.println(it.next());
/*1-4]특정 위치의 인덱스에 저장된 객체를 대체:
set(int index,Object obj)
특정 인덱스 위치에 새로운 객체가 저장이되고
기존 객체는 삭제됨.
*/
list.set(4,"MASAN(SET)");
System.out.println("[MASAN(SET)으로 대체후]");
for(Object obj:list) System.out.println(obj);
list.add(4,"MASAN(ADD)");
System.out.println("[MASAN(ADD)으로 추가후]");
for(Object obj:list) System.out.println(obj);
//1-5]검색
System.out.println(list.contains("다산"));
System.out.println(list.contains("아산"));
//1-6]삭제
//※삭제후에는 자동으로 인덱스가 다시 부여된다
//인스턴스(주소)로 삭제:boolean remove(Object obj)
//인덱스로 삭제:Object remove(int index):삭제된 객체(주소)를 반환
Object obj=list.remove(1);
System.out.println("삭제된 객체:"+obj);
System.out.println(list.remove("MASAN(SET)"));
System.out.println(list.remove("MASAN(ADD)"));
//중복된 객체 삭제하기-인덱스가 빠른거가 삭제된다 즉 앞에 객체가 삭제됨
list.remove("가산");
//전체 삭제:boolean removeAll(Collection<?> col) 혹은void clear()
//list.clear();
System.out.println("[삭제 후]");
for(Object o:list) System.out.println(o);
//1-7]객체의 인덱스 찾기:int indexOf(Object)
// 주소로 인덱스 찾을때 해당 주소가 없는 경우 -1반환
System.out.println("다산의 인덱스:"+list.indexOf("다산"));
//2]타입 파라미터 지정:<Student>
List<Student> list2 = new ArrayList<>();
//2-1]컬렉션에 저장할 객체 생성
Student stu1 = new Student("가길동", 30, "2019학번");
Student stu2 = new Student("나길동", 20, "2023학번");
Student stu3 = new Student("다길동", 25, "2020학번");
Student stu4 = new Student("라길동", 40, "2018학번");
//2-2]객체 저장
list2.add(stu1);
list2.add(stu2);
list2.add(stu3);
list2.add(stu4);
list2.add(stu2);//중복 저장
System.out.println("[중복 저장 후]");
for(Student s:list2) s.print();
list2.remove(stu2);//인스턴스(주소)로 중복 저장된 객체 삭제-하나만 삭제됨(인덱스가 빠른거)
System.out.println("[중복 저장된 객체 삭제 후]");
for(Student s:list2) s.print();
//2-3]출력
System.out.println("[일반 for문:get(index)]");
for(int i=0;i< list2.size();i++) list2.get(i).print();
System.out.println("[확장 for문]");
for(Student s:list2) s.print();
System.out.println("[반복기]");
Iterator<Student> it2= list2.iterator();
while(it2.hasNext()) it2.next().print();
//2-3]삭제
//인덱스로 삭제]
System.out.println("삭제된 객체(학생)의 이름:"+list2.remove(2).name);
Scanner sc = new Scanner(System.in);
System.out.println("삭제할 학생의 이름 입력?");
String name = sc.nextLine().trim();
/*문]사용자로부터 이름을 입력받아 그 이름으로 검색해서
인덱스 위치(indexOf사용)를 알아내서 해당 인덱스로
그 객체를 삭제하고 삭제된 객체의 정보(이름,나이,학번)를
출력하여라
*/
for(Student s : list2)
if(name.equals(s.name)) {
int index=list2.indexOf(s);
list2.remove(index).print();
break;
}
}
}sol)
5. Vector
List계열 컬렉션
VectorApp.java
package collection20;
import java.util.Enumeration;
import java.util.Iterator;
import java.util.Vector;
import console.academy.Student;
//Vector:List계열 컬렉션
public class VectorApp {
public static void main(String[] args) {
//컬렉션 객체 생성]
Vector<Student> vec = new Vector<>();
//컬렉션에 저장할 객체 생성
Student stu1=new Student("가길동",30,"2019학번");
Student stu2=new Student("나길동",20,"2023학번");
Student stu3=new Student("라길동",25,"2020학번");
Student stu4=new Student("다길동",40,"2018학번");
//객체 저장]
vec.add(stu1);
vec.add(stu2);
vec.add(stu3);
vec.add(stu4);
//출력
System.out.println("[일반 for문]");
for (int i = 0; i < vec.size(); i++)
vec.get(i).print();
System.out.println("[확장 for문]");
for (Student s : vec)
s.print();
System.out.println("[반복기]");
Iterator<Student> it = vec.iterator();
while (it.hasNext())
it.next().print();
/*
* 열거형으로 꺼내오기:elements()메소드로 Enumeration 타입얻기 Enumeration타입의 주요 메소드]
* hasMoreElements():저장된 객체가 있으면 true,없으면 false반환 nextElement();저장된 객체 얻을때
*/
System.out.println("[열거형]");
Enumeration<Student> em = vec.elements();
while(em.hasMoreElements()) em.nextElement().print();
// 삭제]
// 인덱스로 삭제]
// System.out.println("삭제된 학생의 이름:"+vec.remove(1).name);
// 인스턴스(주소)로 삭제]
// System.out.println(vec.remove(stu3));
// 문]vec컬렉션에 저장된 Student객체들을
// 나이가 높은 순으로 재 배치후
// 출력하여라.(나이순으로 내림차순 정렬)
// 단,List계열의 get(인덱스) 및 set(인덱스,객체)메소드 사용
for (int i = 0; i < vec.size() - 1; i++)
for (int k = i + 1; k < vec.size(); k++)
if (vec.get(i).age < vec.get(k).age) {
Student temp = vec.get(i);
vec.set(i, vec.get(k));
vec.set(k, temp);
}
System.out.println("[나이순으로 정렬]");
for(Student s:vec) s.print();
}
}sol)
6.HashMap
HashMapApp.java
package collection20;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.Vector;
import console.academy.Student;
/*
HashMap: Map(인터페이스)계열의 컬렉션 클래스
- key 와 value(객체)의 쌍으로 객체 저장
- 키값은 중복이 안된다
- 키값으로 검색하기 때문에 다른 컬렉션보다 검색 속도가 빠르다
데이타 꺼내올때:
keySet():Set<?>타입 반환
get(키값):키값에 해당하는 value(객체)값 반환
keys() :Enumeration<?>타입 반환(Hashtable의 메소드)
values():Collection<?>타입 반환,value값만 반환
*/
public class HashMapApp {
public static void main(String[] args) {
//1]컬렉션 객체 생성-Raw Type
Map map = new HashMap();
//2]객체 저장:Object put(키값,Value(객체)값);
//반환값(Value의 타입):키값으로 저장시 이전에 저장된 value(객체)
// 이전에 저장된 value(객체)가 없을시 null
System.out.println("name이라는 키값으로 이전에 저장된 객체:"+map.put("name", "가길동"));
map.put("age", 20);//오토박싱
map.put("gender", "남자");
map.put("address", new String("가산동"));
//3]저장된 객체 수:int size()
System.out.println("저장된 객체 수:"+map.size());
//4]키값을 중복해서 저장:
// 저장은 되나 기존 키값에 해당 하는 밸류이 새로운 객체로 대체됨.
System.out.println("name이라는 키값으로 이전에 저장된 객체:"+map.put("name", "KaKilDong"));
System.out.println("키값 중복 저장후 저장된 객체 수:"+map.size());
//5]출력
//5-1]키값을 알때:Object get(키값)
System.out.println("키값을 알때:"+map.get("name"));
//for(Object obj:map) {}//[x]확장for문은 배열이나 반복가능한(Iterable) 객체(Set 혹은 List계열 컬렉션)에만 적용가능
//5-2]키값을 모를때
//STEP1]Set<?> keySet()메소드 호출:키값들을 Set계열의 컬렉션 형태로 반환
//STEP2]STEP1에서 얻은 Set계열 컬렉션에 확장 for문 적용해서 키값 얻기
//STEP3]get(키값)으로 Value(객체)값 얻는다.
//STEP1]키값들이 저장된 Set컬렉션 얻기
Set keys= map.keySet();
//STEP2]확장 for문 적용해서 키값 가져오기
for(Object key:keys) {
//STEP3] get(키값)으로 Value값 얻기
Object value = map.get(key);
System.out.println(String.format("%s : %s",key,value));
}
//5-3]Value만 얻어 올때:values()
Collection values= map.values();
System.out.println("[values(객체들)만 얻기]");
for(Object value:values) System.out.println(value);
//6]검색:boolean containsKey(key)-해당 키가 존재하면 true,아니면 false
// boolean containsValue(value)-값이 존재하면 true,아니면 false
System.out.println(map.containsKey("name"));
System.out.println(map.containsKey("tall"));
System.out.println(map.containsValue("남자"));
System.out.println(map.containsValue("여자"));
//7]삭제:Object remove(키값)-삭제된 키값에 해당하는 value(객체) 반환
System.out.println("삭제된 객체(value):"+map.remove("gender"));
System.out.println("[삭제후 출력]");
for(Object key:keys) {
Object value = map.get(key);
System.out.println(String.format("%s : %s",key,value));
}
//전체 삭제:removeAll()는 없음.clear()로 삭제
map.clear();
System.out.println("삭제후 저장된 객체 수:"+map.size());
/*
Hashtable클래스(Map계열)에서는 keySet()/values()/get("키값")으로 모두 꺼내올 수 있다.
또한 keys()메소드를 통해서도 가능
HashMap클래스에는 keys()메소드가 없음
*/
map = new Hashtable();
//객체 저장]
map.put("기관","한국 소프트웨어 인재개발원");
map.put("위치","가산동");
map.put("대표","정영철");
Enumeration em= ((Hashtable)map).keys();
while(em.hasMoreElements()) {
//키값 얻기
Object key=em.nextElement();
//밸류값 얻기
Object value = map.get(key);
System.out.println(String.format("%s : %s",key,value));
}////////////////////////////
//타입 파라미터 지정-Generic Type(타입 안정성(컴파일 시점에 타입체크),형변환 불필요)
Map<String, Student> genericMap = new HashMap<>();
// 컬렉션에 저장할 객체 생성
Student stu1=new Student("가길동",30,"2019학번");
Student stu2=new Student("나길동",20,"2023학번");
Student stu3=new Student("라길동",25,"2020학번");
Student stu4=new Student("다길동",40,"2018학번");
//객체 저장]
genericMap.put("학생1", stu1);
genericMap.put("학생2", stu2);
genericMap.put("학생3", stu3);
genericMap.put("학생4", stu4);
System.out.println("[키값을 알때]");
genericMap.get("학생1").print();
System.out.println("[키값을 모를때]");
Set<String> kies= genericMap.keySet();
for(String kie:kies) {
Student value=genericMap.get(kie);
System.out.println(String.format("%s : %s",kie,value.get()));
}
//[맵계열 컬렉션에 저장된 객체 정렬하기]
Map<String,Integer> sortMap = new HashMap<>();
sortMap.put("D", 10);
sortMap.put("C", 5);
sortMap.put("A", 9);
sortMap.put("B", 7);
//1.Entry를 요소로 갖는 List컬렉션 객체 생성
// Entry는 Map인터페이스의 내부 정적 인터페이스이다
// Entry는 해당 맵의 key=value쌍을 요소로 갖는 객체다
// 즉 위의 sortMap에 저장된 키=값의 엔트리들을 저장한 리스트 컬렉션 생성
List<Entry<String,Integer>> entries= new Vector<>(sortMap.entrySet());
System.out.println("[Entry객체가 저장된 리스트 컬렉션 출력]");
for(Entry<String,Integer> entry:entries) {
System.out.println(entry);//key=value 형태의 Entry객체
}
//2. 1번에서 생성한 List컬렉션에 Collections.sort()적용
Collections.sort(entries,new Comparator<Entry<String,Integer>>() {
@Override
public int compare(Entry<String, Integer> o1, Entry<String, Integer> o2) {
//숫자인때는 - ,문자열일때는 compareTo()
//[value로 정렬하기]
//return o1.getValue()-o2.getValue();//오름차순(앞에꺼에서 뒤에껄 뺌)
//return o2.getValue()-o1.getValue();//내림차순
//[key로 정렬하기]
//return o1.getKey().compareTo(o2.getKey());//오름차순
return o2.getKey().compareTo(o1.getKey());//내림차순
}
});
System.out.println("정렬 후 출력");
for(Entry<String,Integer> entry:entries) {
System.out.println(entry);//key=value 형태의 Entry객체
}
}/////////// main
}////////////// classsol)
7. TreeMap
TreeMap.java
package collection20;
import java.util.Set;
import java.util.TreeMap;
/*
TreeMap:Map계열 컬렉션
키값이 정렬된 상태로 저장되어 있음 (디폴트는 오름차순 정렬)
HashMap보다는 성능이 떨어지나
정렬된 키값으로 출력하고자 할때 유리..
*/
public class TreeMapApp {
public static void main(String[] args) {
TreeMap<Character, String> map = new TreeMap<>();
//객체 저장]
map.put('ㄷ', "도길동");
map.put('ㅎ', "하길동");
map.put('ㅁ', "마길동");
map.put('ㄱ', "고길동");
map.put('ㅎ', "홍길동");
map.put('ㄱ', "곽길동");
System.out.println("[키로 오름차순해서 정렬-디폴트]");
Set<Character> keys= map.keySet();
for(Character key:keys) {
String value = map.get(key);
System.out.println(String.format("%s:%s",key,value));
}
System.out.println("[키로 내림차순해서 정렬]");
keys=map.descendingKeySet();
for(Character key:keys) {
String value = map.get(key);
System.out.println(String.format("%s:%s",key,value));
}
}////////////////main
}///////////////////classsol)
8. AcademyLogic.java를 컬렉션을 써서 코드 약간 수정
AcademyApp.java에서
AcademyCollectionLogic logic = new AcademyCollectionLogic();으로 변경 후
AcademyCollectionLogic.java으로 새로 만듦
Person []을 List로 만들어서 person [i]를 변경함
for문에서 person.size()로 변경
for문을 for문 확장으로 변경(Person p:person)
package console.academy;
import java.util.List;
import java.util.Scanner;
import java.util.Vector;
public class AcademyCollectionLogic {
//[멤버 상수]
public static final int MAX_PERSON = 3;//최대 인원수
//[멤버변수]
List<Person> person;
//[생성자]
public AcademyCollectionLogic() {
person = new Vector<>();
}//////////////////////
//[멤버 메소드]
/*
* 1]메뉴 출력용 메소드
* 매개변수:NO
* 반환타입:void
*/
public void printMainMenu() {
System.out.println("====================메인 메뉴====================");
System.out.println(" 1.입력 2.출력 3.수정 4.삭제 5.검색 6.파일저장 9.종료");
System.out.println("===============================================");
System.out.println("메인 메뉴번호를 입력하세요?");
}//////////////printMainMenu()
/*
* 2]메뉴 번호 입력용 메소드
* 매개변수:NO
* 반환타입:int
*/
public int getMenuNumber() {
Scanner sc = new Scanner(System.in);
String menuStr = sc.nextLine().trim();
return Integer.parseInt(menuStr);
}///////////////getMenuNumber()
/*
* 3]메뉴 번호에 따른 분기용 메소드
* 매개변수:int(메인메뉴)
* 반환타입:void
*/
public void seperateMainMenu(int mainMenu) {
switch(mainMenu) {
case 1://입력
while(true) {
//서브메뉴 출력]
printSubMenu();
//서브메뉴번호 입력받기]
int subMenu = getMenuNumber();
if(subMenu == 3) break;
switch(subMenu) {
case 1:
case 2:setPerson(subMenu);break;
default:System.out.println("서브메뉴에 없는 번호입니다");
}
}///while
break;
case 2://출력
printPerson();
break;
case 3://수정
updatePerson();
break;
case 4://삭제
deletePerson();
break;
case 5://검색
searchPerson();
break;
case 6://파일저장
break;
case 9://종료
System.out.println("프로그램을 종료 합니다");
System.exit(0);
default:System.out.println("메뉴에 없는 번호입니다");
}///switch
}///////////////////seperateMainMenu(int mainMenu)
/*
* 4]서브메뉴 출력용 메소드
* 매개변수:NO
* 반환타입:void
*/
private void printSubMenu() {
System.out.println("++++++++++서브 메뉴++++++++++");
System.out.println("1.학생 2.교사 3.메인메뉴로 이동");
System.out.println("+++++++++++++++++++++++++++");
System.out.println("서브 메뉴번호를 입력하세요?");
}///////////////printSubMenu()
/*
* 5]서브메뉴에 따른 학생 및 교사 데이타 입력용 메소드
* 매개변수:int(서브메뉴)
* 반환타입:void
*/
private void setPerson(int subMenu) {
if(person.size()==MAX_PERSON) {//이미 정원이 찬 경우
System.out.println("정원이 찼어요..더 이상 입력할 수 없어요");
return;
}
//정원이 안 찬 경우
Scanner sc = new Scanner(System.in);
System.out.println("이름을 입력하세요?");
String name = sc.nextLine().trim();
System.out.println("나이를 입력하세요?");
int age = Integer.parseInt(sc.nextLine().trim());
//학생과 교사를 구분해서 입력받기]
switch (subMenu) {
case 1://학생인 경우
System.out.println("학번을 입력하세요?");
String stNumber = sc.nextLine().trim();
person.add(new Student(name, age, stNumber));
break;
default:
System.out.println("과목을 입력하세요?");
String subject = sc.nextLine().trim();
person.add(new Teacher(name, age, subject));
}
}/////////////////setPerson(int subMenu)
/*
* 6]출력용 메소드
* 매개변수:NO
* 반환타입:void
*/
private void printPerson() {
StringBuffer student = new StringBuffer("[학생 목록]\r\n");
StringBuffer teacher = new StringBuffer("[교사 목록]\r\n");
for(Person p:person)
if(p instanceof Student)
student.append(p.get()+"\r\n");
else
teacher.append(p.get()+"\r\n");
System.out.println(student.toString()+teacher);
}//////////////printPerson()
/*
* 7]이름으로 검색하는 메소드
* 매개변수:String(수정/삭제/검색용 타이틀)
* 반환타입:Person타입
*/
private Person findPersonByName(String title) {
System.out.println(title+"할 사람의 이름을 입력하세요?");
Scanner sc = new Scanner(System.in);
String name= sc.nextLine().trim();
for(Person p:person)
if(p.name.equals(name))
return p;
System.out.println(name+"로(으로) 검색된 정보가 없어요");
return null;
}/////////////////findPersonByName(String title)
//8]검색용 메소드
private void searchPerson() {
Person findPerson=findPersonByName("검색");
if(findPerson !=null) {
System.out.printf("[%s로 검색한 결과]%n",findPerson.name);
findPerson.print();
}
}//////////searchPerson()
//9]수정용 메소드
private void updatePerson() {
Person findPerson=findPersonByName("수정");
if(findPerson !=null) {
Scanner sc = new Scanner(System.in);
//나이 수정
System.out.printf("(현재 %s살) 몇 살로 수정할래?%n",findPerson.age);
findPerson.age = Integer.parseInt(sc.nextLine().trim());
//학생인지 교사인지 판단
if(findPerson instanceof Student) {//학생
System.out.printf("(현재 %s) 몇 학번으로 수정할래?%n",((Student)findPerson).stNumber);
((Student)findPerson).stNumber = sc.nextLine().trim();
}
else {
System.out.printf("(현재 %s) 무슨 과목으로 수정할래?%n",((Teacher)findPerson).subject);
((Teacher)findPerson).subject = sc.nextLine().trim();
}
System.out.printf("[%s(이)가 아래와 같이 수정되었습니다]%n",findPerson.name);
findPerson.print();//수정내용을 확인하기 위한 출력
}//////////////
}///////////updatePerson()
//10]삭제용
//문]삭제처리 하시오(힌트:찾은 Person형 배열 요소를 null로 설정)
private void deletePerson() {
Person findPerson=findPersonByName("삭제");
if(findPerson !=null) {
for(Person p:person)
if(findPerson.equals(p)) {
person.remove(p);
System.out.printf("[%s가 삭제 되었습니다]%n",findPerson.name);
break;
}
}
}//////////////
}/////////////class