7/29 MyException, 컬렉션 프레임웍, List, Set, Map, ArrayList, Stack, LinkedList, Vector, HashSet, TreeSet, HashMap, HashTable

MyException.java

package ch10;

//개발자가 Exception을 만드려면 java에서 제공하는 Exception 상속받기.
public class MyException extends Exception {
	
	@Override
	public String getMessage() {
		//return super.getMessage(); //원래의 getMessage
		String errMsg;
		
		errMsg = "아니 10보다 크다니";
				
		return errMsg;
	}

}

 

MyExceptionEx.java

package ch10;

import java.util.Scanner;

public class MyExceptionEx {

	public static void main(String[] args) {
		int kkk = 0;
		//1.객체 선언
		Scanner sc = new Scanner(System.in);
		System.out.println("원하는 숫자 입력?");
		try {
			kkk = sc.nextInt();
			if (kkk>10) throw new MyException();			
		} catch (MyException e) { 	//내가 만든
			System.out.println("MyException-->"+e.getMessage());			
		} catch (Exception e) { 	//시스템에서 보여주는
			System.out.println("Exception-->"+e.getMessage());
		}
	}
}

출력 결과

 

MyException1.java

package ch10;

public class MyException1 extends Exception {
	@Override
	public String getMessage() {
		//return super.getMessage();
		String errMsg="";
		
		errMsg = "사장님 180만원보다 적어요!";
		
		return errMsg;
	}

}

MyException2.java (과제)

package ch10;

public class MyException2 extends Exception {
	// 사장님 1000만원 너무 많아요
	
	@Override
	public String getMessage() {
		String errMsg ="";
		errMsg = "사장님 1000만원 너무 많아요";
		return errMsg;
	}
}

 

 

MyExceptionEx2.java

package ch10;

public class MyExceptionEx2 {
	//parameter로 급여 받아 옴
	//과제 --> 180 < 급여 < 1000

	public static void main(String[] args) {
		try {
			int kkk = Integer.parseInt(args[0]); 	//args는 급여
			if(kkk<180) throw new MyException1();
			if(kkk>1000) throw new MyException2();
			
		} catch (ArrayIndexOutOfBoundsException e) {
			System.out.println("실행 매개값의 수가 부족합니다.");
			System.out.println("[실행 방법]");
			System.out.println("Java MyExceptionEx2 num1");
		//최저임금 오류
		} catch (MyException1 e) {
			System.out.println(e.getMessage());
        //최고임금 오류
		} catch (MyException2 e) {
			System.out.println(e.getMessage());
		} catch (Exception e) {
			System.out.println(e.getMessage());
		}
		
	}

}

출력 결과 (Run > Run configurations)

1) 아무것도 입력하지 않았을 때

2) 120 입력했을 때

3) aaa 입력했을 때

4) 1200 입력했을 때 (과제)

 

[11.제네릭과 컬렉션 (별 5개 가장 중요)]

p.2 컬렉션 프레임웍(collection framework)이란

1) 컬렉션 프레임웍(collection framework)

- 데이터 군을 저장하는 클래스들을 표준화한 설계

- 다수의 데이터를 쉽게 처리할 수 있는 방법을 제공하는 클래스들로 구성

- JDK1.2부터 제공

2) 컬렉션 (collection)

- 다수의 데이터, 즉, 데이터 그룹을 의미한다.

3) 프레임웍(framework)

- 표준화, 정형화된 체계적인 프로그래밍 방식

4) 컬렉션 클래스(collection class)

- 다수의 데이터를 저장할 수 있는 클래스(예, Vector, ArrayList, HashSet)

 

p.3 컬렉션 프레임웍의 핵심 인터페이스 (무조건 외워야 함. 별 3개. 면접 단골 질문, 중요)

화살표는 상속을 뜻함.

컬렉션 프레임웍의 핵심 인터페이스간의 상속계층도

이 세 가지의 특징과 구현 클래스 전부 외워야 함.

실무에서는 List 특히 ArrayList가 가장 많이 쓰인다.

map에서는 hashtable과 properties 가 많이 쓰인다.

List의 ArrayList와 Map의 HashMap, Properties는 실무에서도 많이 쓰임.

컬렉션 프레임웍의 핵심 인터페이스와 특징

 

p.6 ArrayList와 배열 차이점 : 배열은 크기가 고정되어 있다. 컬렉션 List는 가변적 길이를 가진다.

 

[ch11]

ArrayList1.java

package ch11;

import java.util.ArrayList;

public class ArrayList1 {

	public static void main(String[] args) {
		ArrayList<String> a1 = new ArrayList<>();
		//ArrayList는 <>안에 있는 자료가 무엇이든 넣는 대로 받아들여줌.
		a1.add("고양이");
		a1.add("길냥이");
		a1.add("강아지");
		a1.add("진도개");
		a1.add("고양이");
		for(int i =  0; i< a1.size(); i++) {
			System.out.println(a1.get(i));
		}
		System.out.println("===========향상형===========");
		for(String str : a1) {
			System.out.println(str);
		}
	}
}

 

출력 결과

 

ArrayList2.java + 과제있음.

package ch11;

import java.util.ArrayList;

//Array는 값을 수정하려면 자리를 수정하는데에 굉장히 불편한데
//ArrayList는 로직을 처리하는 데에 유연성이 있기 때문에 실무에서는 ArrayList를 쓴다.
//면접에서 둘의 차이점 물어볼 수 있음
public class ArrayList2 {
	
	public static void print(ArrayList<String> listPrint) {	//자주 쓸 것이므로 모듈화, reuse
		for (String str : listPrint) {
			System.out.print(str+"\t");
	}
	System.out.println("\n-------------------------------------------------------------");		
	}

	public static void main(String[] args) {
		String myString = "바나나";
		ArrayList<String> list = new ArrayList<>();
		list.add("바나나"); 	//add(값)은 추가
		list.add("수박");
		list.add("사과");
		list.add("바나나");
		list.add("수박");
		list.add("대추");
		list.add("바나나");
		System.out.println("갯수 : " + list.size());
		print(list); 	//7줄 실행
		list.add(1, "키위"); 		//add(자리, 값)은 자리에 값 추가 후 나머지 오른쪽으로 밀림
		print(list);
		list.set(4, "복숭아"); 	//set(자리, 값)은 해당 자리만 값 변경
		print(list);
		list.remove(0); 		//remove(자리)는 해당 자리 값 삭제되고 나머지 왼쪽으로 밀림
		print(list);
		System.out.println("3번 인덱스 -->" + list.get(3)); 	//.get(자리)는 해당 자리의 값을 불러옴
		System.out.println("바나나 문의 : " + list.contains("바나나")); 		//.contains(값)은 값이 포함되어있는지를 알려줌
		System.out.println("수박 문의 indexOf : " + list.indexOf("수박")); 	//.indexOf(값)은 값의 자리가 (앞에서) 몇 번째 자리인지 알려줌
		System.out.println("수박 문의 : " + list.lastIndexOf("수박")); 	//.lastIndexOf(값)은 값의 자리가 뒤에서 몇 번째 자리인지 알려줌
		
		//과제 : 수박을 찾아서 메론으로 바꾸는 것 for문으로 구현하기.
		for(int i = 0; i<list.size(); i++) {
			if (list.get(i) == "수박") 
				list.set(i, "메론");			
		}
		System.out.println("수박을 메론으로 변경 " );	
		print(list);
	}
}

출력 결과

 

ArrayList3.java

package ch11;

import java.util.ArrayList;
import java.util.Iterator;

//Iterator
public class ArrayList3 {

	public static void main(String[] args) {
		ArrayList<String> list=new ArrayList<String>();
		list.add("사과");		
		list.add("바나나");
		list.add("귤");
		list.add("오렌지");
		list.add("바나나");
		System.out.println("요소의 개수->" + list.size());
		System.out.println(">> Iterator 객체로 요소 얻기 <<");
		
		//이 방식은 오픈소스에 많이 나오는 코드. 고수들이 많이 씀
		Iterator elements = list.iterator();		//이 메소드를 쓰면 iterator 객체로 돌려줌.
		// 요소가 있다면 
		while(elements.hasNext()) { 	//iterator를 쓰면 이 while문을 쓸 수 있다.
			//요소를 얻어내어 출력
			System.out.print(elements.next()+"\t");
		}
		
		//이 방법으로 써도 됨.
		System.out.println("\n");
		System.out.println(">> get  메소드로 요소 얻기 <<");
		for (int i=0; i<list.size(); i++)
			System.out.print(list.get(i) + "\t");
		System.out.println();
	}
}

출력 결과

 

 

Car.java

package ch11;

public class Car {
	void print() {
		System.out.println("난 차야");
	}
}
class Bus extends Car {
	void print() {
		System.out.println("난 Bus야");
	}
	void move() {
		System.out.println("승객 50명이야");
	}
}
class Taxi extends Car {
	void print() {
		System.out.println("난 Taxi야");
	}
}

 

CarEx.java + 과제있음.

package ch11;

import java.util.ArrayList;

public class CarEx {

	public static void main(String[] args) {
		ArrayList<Car> al = new ArrayList<>();
		al.add(new Car());
		al.add(new Bus());
		al.add(new Taxi());
		for(Car c : al) {
			c.print();
			//과제 : for문으로 move를 출력하기
			if ( c instanceof Bus) {
				((Bus) c).move();
                //윗줄과 같은 동작
				//Bus b = (Bus)c;
				//b.move();
			}
		}

	}

}

출력 결과

 

 

StackEx.java

package ch11;

import java.util.Stack;

public class StackEx {

	public static void main(String[] args) {
		String[] pet = {"강아지", "야옹이", "물고기", "표범"};
		Stack<String> st = new Stack<>();
		for(String str : pet) {
			System.out.println("push-->" + str);
			st.push(str);
		}
		System.out.println("------------------------------");
		while(!st.isEmpty()) { 	//비어있지 않을 때 실행
			System.out.println("POP->"+st.pop()); 	//.pop은 FILO
		}
	}
}

출력 결과

 

Stack : FILO (First in Last out)

Queue : FIFO (First in First out)

 

 

LinkedListEx.java

package ch11;

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

public class LinkedListEx {

	public static void main(String[] args) {
		LinkedList<String> kk = new LinkedList<>();
		String[] animal = {"산토끼", "고양이", "진도개", "치와와", "토끼"};
		for (int i = 0; i<animal.length; i++) {
			kk.add(animal[i]); 	//원소가 다 들어감
		}
		int i = 0;
		Iterator<String> it = kk.iterator();
		while (it.hasNext()) {
			System.out.println(i+"->"+it.next());
			i++;
		}
		System.out.println("kk.iterator.size->" + kk.size());
	}
}

출력 결과

 

 

Vector2Ex.java

package ch11;

import java.util.ArrayList;
import java.util.Vector;

public class Vector2Ex {
	public static void print(Vector <String> vc) {
		for (String str : vc) {
			System.out.print(str+"\t");
		}
		System.out.println("\n-----------------------------------------------------");
	}
	
	public static void main(String[] args) {
		//순서를 지킨다. 중복을 허용한다.
		Vector<String> vc = new Vector<String>();
		vc.add("수박");
		vc.add("고추");
		vc.add("수박");
		vc.add("대추");
		vc.add("오이");
		System.out.println("갯수 : "+ vc.size());
		print(vc);
		
		//2번 자리에 끼워 넣기 가능하다
		vc.add(2, "키위");
		print(vc); 	//나머지는 뒤로 밀려남
		vc.set(3, "참외");
		print(vc); 	//교체이기 때문에 나머지는 뒤로 밀려나지 않음
		vc.remove(1);
		print(vc); 	//나머지는 앞으로 밀려옴
		System.out.println("2번 인덱스 -->" + vc.get(2));
		System.out.println("수박 문의(포함 여부) : " + vc.contains("수박"));
		System.out.println("수박 문의(Index) : "+vc.indexOf("수박"));
		System.out.println("수박 문의 : " + vc.lastIndexOf("수박"));
		
		
	}
}

출력 결과

 

 

HashSetEx.java

package ch11;

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

//순서를 유지하지 않는다.
public class HashSetEx {

	public static void main(String[] args) {
		HashSet<String> hs = new HashSet<String>();
		hs.add("표범");
		hs.add("사자");
		hs.add("호랑이");
		hs.add("하이에나");
		hs.add("표범");
		
		for(String str : hs) {
			System.out.println(str);
		}
		System.out.println("=======================");
		Iterator<String> it = hs.iterator(); //Interator도 디자인패턴 중 하나. 검증된 방법 (16~18줄과 같음)
		while(it.hasNext()) {
			System.out.println(it.next());
		}
	}
}

출력 결과

 

 

HastSetEx2.java

package ch11;

import java.util.HashSet;
import java.util.Scanner;

//중복을 허용하지 않는 복권
public class HastSetEx2 {

	public static void main(String[] args) {
		//scanner : 입력장치로 입력을 받아 그 값을 변수에 저장하는 역할
		Scanner sc = new Scanner(System.in);
		System.out.println("첫 번째 수");
		//.nextInt : sc에서 입력받은 값을 int로 바꾸는 역할.
		int num1 = sc.nextInt();
		
		System.out.println("두 번째 수");
		int num2 = sc.nextInt();
		
		HashSet<Integer> hs = new HashSet<>();
		hs.add(num1);
		hs.add(num2);
		
		//원하는 목적의 객체를 쓰는 것이 좋다. 사용자는 두 개만 선택할 권한이 있다.
		while (true) {
			int num = (int) (Math.random() * 45) + 1;
			System.out.println("num->" + num);
			hs.add(num);
			if (hs.size() == 6)
				break;
		}
		System.out.println(hs);
		sc.close();
	}
}

출력 결과 1) 중복되는 숫자를 넣었을 때

출력 결과 2) 중복되지 않는 숫자를 넣었을 때

 

 

TreeSetEx.java

package ch11;

import java.util.TreeSet;

//순서도 유지하지 않고 중복도 허용하지 않는다.
public class TreeSetEx {
	public static void main(String[] args) {
		int i = 0;
		TreeSet<Integer> ts = new TreeSet<>();
		ts.add(52);
		ts.add(24);
		ts.add(72);
		ts.add(34);
		ts.add(52);
		
		for(Integer t : ts) {
			i++;
			System.out.println(i+"번째 t -->" + t);
		}
	}
}

출력 결과

 

 

HashMapEx.java

package ch11;

import java.util.HashMap;

public class HashMapEx {

	public static void main(String[] args) {
		//<Key, Value>, 앞에만 선언하면 뒤에도 <>만 표시하면 따라함.
		//Key, Value로 이루어진 한 쌍이 HaspMap이다. 이것이 핵심임.
		//키를 주면 데이터값을 알 수 있음. 
		HashMap<String, String> hm = new HashMap<>(); 	
		hm.put("손흥민", "010-3333-3333");
		hm.put("김준수", "010-2222-3456");
		hm.put("조정은", "010-3456-7890");
		hm.put("조정은", "010-3456-7890");
		hm.put("조정은2", "010-3456-7890"); 	//키가 같으면 중복을 허용하지 않아서 조정은 키를 넣었을 떄 결과값이 1개임.
		//값(뒤)은 중복이 가능하지만 키(앞)는 중복을 허용하지 않는다.
		System.out.println("손흥민 TEL : " + hm.get("손흥민"));
		System.out.println("김준수 TEL : " + hm.get("김준수"));
		System.out.println("조정은 TEL : " + hm.get("조정은")); 	//"조정은" 키가 두개이지만 데이터는 한개만 출력된다.(키 중복 허용 안함)
		System.out.println("조정은2 TEL : " + hm.get("조정은2")); //데이터가 같지만 데이터는 2개 다 출력된다. (값 중복 허용)

	}

}

출력 결과

 

 

HashMapEx2.java

package ch11;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Set;

//Map 계열은 순서를 보장하지 않는다.
public class HashMapEx2 {

	public static void main(String[] args) {
		HashMap<String, String> hm = new HashMap<>();
		hm.put("손흥민", "010-3333-3333");
		hm.put("김준수", "010-2222-3456");
		hm.put("조정은", "010-3456-7890");
		
		Set<String> st = hm.keySet(); 	//.keySet은 HashMap에서 제공하는 함수(키 값만 받아옴)
		for(String str : st) {
			System.out.println(str + "의 전화[Set]-->" + hm.get(str)); 	//.get(키)를 하면 데이터값이 나옴.
		}
		
		//keySet().의 이터레이터를 가져옴. 위 3줄과 같음. 이것이 고수들이 더 많이 하는 코딩.
		Iterator<String> it = hm.keySet().iterator();
		while(it.hasNext()) {
			String key = it.next();
			System.out.println(key+"의 전화 " + hm.get(key));
		}

	}

}

출력 결과

 

 

HashTableEx.java

package ch11;

import java.util.Hashtable;

//HashTable을 많이 쓴다.
public class HashTableEx {

	public static void main(String[] args) {
		Hashtable<String, String> ht = new Hashtable<>();
		ht.put("손흥민", "010-3333-3333");
		ht.put("김준수", "010-2222-3456");
		ht.put("조정은", "010-3456-7890");
		
		System.out.println("손흥민 TEL : " + ht.get("손흥민"));
		System.out.println("김준수 TEL : " + ht.get("김준수"));
		System.out.println("조정은 TEL : " + ht.get("조정은"));
	}
}

출력 결과