package day07;
public class Exception04 {
public static void main(String[] args) {
/* 멀티 캐치 구문, 다중 캐치 구문
* try {
*
* } catch(예외클래스명1 객체){
*
* } catch(예외클래스명2 객체){
*
* }
* 예외를 구체적으로 세분화해서 잡고 싶을 때 => 멀티 캐치
* 모든 예외의 최고 조상 : Exception
* 어떤 예외가 발생하던 다 캐치
*/
double res = 0;
try {
int arr[] = null;
arr[1] = 3;
int arr1[] = new int[3];
arr1[5] = 3;
res = 1/0;
} catch (NullPointerException e) {
System.out.println("객체가 null입니다.");
e.printStackTrace();
} catch (ArithmeticException e) {
e.printStackTrace();
} catch (Exception e) {
// 최고 조상은 가장 마지막에 처리
e.printStackTrace();
}
System.out.println("종료");
}
}
▷ 출력
출력 (1)
▣ Exception05
package day07;
import java.io.BufferedReader;
import java.io.InputStreamReader;
public class Exception05 {
public static void main(String[] args) {
// 1/0 Exception 발생 예제
InputStreamReader isr = new InputStreamReader(System.in);
BufferedReader br = new BufferedReader(isr);
String name;
try {
name = br.readLine();
System.out.println(name);
br.close();
isr.close();
} catch (Exception e){
e.printStackTrace();
}
}
}
▣ ExceptionEx01
package day07;
import java.util.Random;
public class ExceptionEx01 {
public static void main(String[] args) {
// 리턴 받은 배열을 출력
int start = 1, count = 10, size = 0;
int arr[] = null;
ExceptionEx01 ex01 = new ExceptionEx01();
try {
int arr2[] = new int[size];
// arr = ex01.createArr(size, start, count);
ex01.createArr(arr, start, count);
for(int t : arr) {
System.out.println(t);
}
}catch (Exception e) {
e.printStackTrace();
}
}
public int random(int start, int count) {
if(count <= 0){
throw new RuntimeException("random의 범위가 0보다 작습니다.");
}
return new Random().nextInt(count)+start;
}
/* 메서드 생성
* 기능 : size를 입력받아(매개변수) size만큼의 길이를 가지는 배열을 생성하여
* 랜덤값을 채워 배열을 리턴
* 랜덤값은 범위를 매개변수를 받아 start(시작값), count(개수)
* - size가 0보다 작으면 예외발생
* - 랜덤값의 개수가 0이면 예외발생
*/
public int[] createArr(int size, int start, int count) throws RuntimeException{
if(size < 0) {
throw new RuntimeException("배열의 길이가 0보다 작습니다.");
}
int arr[] = new int[size];
for(int i =0; i < arr.length; i++) {
// RuntimeException이 아닌 Checked Exception이였다면 이미 빨간 밑줄.
arr[i] = random(start, count);
}
return arr;
}
/* 메서드
* 기능 : 매개변수로 배열을 받아 랜덤값을 채우는 메서드
* 랜덤값은 범위를 매개변수를 받아 start(시작값), count(개수)
* - 랜덤값의 개수가 0이면 예외발생
* - 배열이 null이면 예외발생
* - 배열의 길이가 0보다 작으면 예외발생
*/
public void createArr(int arr[], int start, int count) throws RuntimeException{
if(arr == null) {
throw new RuntimeException("배열이 null입니다.");
}
if(arr.length < 0) {
throw new RuntimeException("배열의 길이가 0보다 작습니다.");
}
for(int i =0; i < arr.length; i++) {
// RuntimeException이 아닌 Checked Exception이였다면 이미 빨간 밑줄.
arr[i] = random(start, count);
}
}
}
▷ 출력
출력 (2)
▣ ExceptionEx02
package day07;
class PasswordTest{
private String password;
public String getPassword() {
return password;
}
public void setPassword(String password) {
// Exception 처리
if(password == null) {
throw new PasswordException("비밀번호는 null일 수 없습니다.");
}else if(password.length() < 5) {
throw new PasswordException("비밀번호는 5자 이상이어야 합니다.");
}else if(password.matches("[a-zA-Z]+")) {
throw new PasswordException("비밀번호는 숫자나 특수문자를 포함해야 합니다.");
}
this.password = password;
}
}
public class ExceptionEx02 {
public static void main(String[] args) {
PasswordTest pt = new PasswordTest();
String password = null;
// String password = "abc";
// String password = "abcdef";
// String password = "abcdef01";
try {
pt.setPassword(password);
System.out.println(pt.getPassword());
} catch(Exception e) {
e.printStackTrace();
}
/* 사용자 정의 Exception
* 사용자가 직접 Exception 클래스 생성시
* IllegalArgumentException 클래스 상속
* 메서드의 부적절한 인수를 사용자가 결정
*
* passwordException
* - 비밀번호는 null일 수 없다.
* - 비밀번호의 길이는 5자 이상
* - 비밀번호는 문자로만 이루어지면 안 됨.(숫+문, 문+특+숫)
*/
}
}
▣ PasswordException
package day07;
public class PasswordException extends IllegalArgumentException{
private static final long serialVersionUID = 1L;
public PasswordException(String message) {
super(message);
}
}
▷ 출력
출력 (3)
2. Anonymous
▣ Anonymous01
package day07;
public class Anonymous01 {
interface Power{
void turnOn();
void turnOff();
}
//class TV implements Power{
//
// @Override
// public void turnOn() {
// System.out.println("전원이 켜집니다.");
//
// }
//
// @Override
// public void turnOff() {
// System.out.println("전원이 꺼집니다");
//
// }
//
//}
public static void main(String[] args) {
/* 익명 클래스(Anonymous Class) : 내부 클래스의 일종
* - 인터페이스를 이용하여 객체를 생성할 때, 클래스는 인터페이스를 구현하여 객체를 생성
* 익명 클래스를 사용하는 이유
* - 인터페이스의 기능이 적고, 그 객체가 1개만 필요할 경우
*
* 메서드로 매개변수의 값이 들어와야 할 때 익명클래스를 사용함
*/
// Power t = new TV(); // Power를 구현한 클래스이기 때문에 Up Castion 가능
Anonymous01 a = new Anonymous01();
// a.product(t);
a.product(new Power() {
@Override
public void turnOn() {
System.out.println("익명클래스/전원이 켜집니다.");
}
@Override
public void turnOff() {
System.out.println("익명클래스/전원이 꺼집니다.");
}
});
}
public void product(Power p) {
p.turnOn(); // 켜짐
System.out.println("정상 작동중...");
p.turnOff(); // 꺼짐
}
}
class A { // 외부 클래스(outer class)
// 내부 클래스(inner class)
private class B{
// 내부 클래스를 사용하는 이유.
// A 클래스에만 필요한 클래스를 생성하기 위해
}
}
▷ 출력
출력 (1)
3. Collection
▣ Collection01
package day07;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
public class Collection01 {
public static void main(String[] args) {
/* 컬렉션 프레임워크 : 표준화된 방식의 자료구조
* List, Set, Map => 인터페이스, 반드시 구현 클래스로 객체를 생성
* 데이터를 묶어서 관리할 때 사용
* 주로 배열대신 사용
*
* List(배열과 동일)
* - 값을 하나씩 저장
* - index : 순서를 보장
* - 중복 허용
* - 배열 대신에 가장 많이 사용하는 구조
*
* Set
* - 값을 하나씩 저장
* - index 없음 : 순서를 보장하지 않음.
* - 중복허용안됨 (같은 값이 입력되면 덮어씀)
*
* Map
* - 값을 두 개씩 저장 key/value 쌍으로 저장
* - index는 없고, key가 index 역할을 함
* - key는 중복불가능 / value는 중복 가능.
* - key가 중복되면 value는 덮어써짐.
* - 2개의 값이 하나의 자료로 묶어야 할 때 사용
* - 아이디/패스워드, 제품명/가격, 학생명/점수
*
* 배열은 기본자료형
* int arr[], double arr[], String arr[], Student arr[] 다 가능
*
* Collection은 기본자료형은 불가능함. 클래스 자료형만 가능.
* 래퍼클래스(Wrapper Class) : 기본타입 자료형을 클래스 타입으로 변환한 클래스
* 기본자료형 ==(Boxing)> 클래스자료형
* 클래스 자료형 (UnBoxing)> 기본자료형
*
* 기본자료형 > 래퍼클래스
* int > Integer
* char > Character
* byte > Byte
* short > Short
* long > Long
* float > Float
* double > Double
* boolean > Boolean
*
* Collection에서 클래스를 지정하지 않으면 Object가 자동으로 설정
*
* 리스트 생성
* List<className> 객체명 = new 구현클래스<className>();
* List<Integer> list = new ArrayList<Integer>();
* List의 구현클래스 => ArrayList, LinkedList
*
* ArrayList : 검색 시 유리 (배열과 유사한 형태)
* - 머리 길이를 지정하지 않음. 추가되면 늘어남. 삭제되면 줄어듬
* - 추가, 삭제가 쉽다. 검색이 쉬움
*
* LinkedList : 추가 / 삭제가 많을 경우 유리
* - 중간에 값을 끼워넣거나, 빼는게 쉬움.
* - 검색이 느리다.
*/
int num = 10;
Integer boxNum = 20; // 자동 박싱
int a = boxNum; // 자동 언박싱
System.out.println(boxNum);
System.out.println(a);
// 클래스.parse+기본타입명 : 형변환 가능.
String str = "10"; // String => int
int i2 = Integer.parseInt(str);
List<Integer> list = new ArrayList<Integer>(); // 부모를 기준으로 생성
ArrayList<Integer> list2 = new ArrayList<Integer>(); // 자식 기준으로 생성
List list3 = new ArrayList(); // Object로 생성
ArrayList<Integer> list4 = new ArrayList<>(); // 구현체 클래스는 생략가능
List<Integer> linkedList = new LinkedList<>(); // LinkedList 생성
/* List Method
* - add() : 요소를 추가
*/
list.add(1);
list.add(2);
list.add(3);
System.out.println(list);
// - get(index) : index 번지의 요소를 가져오기
System.out.println(list.get(0));
// - set(index, value) : index 번지의 값을 value로 변경
System.out.println(list.set(0, 10));
System.out.println(list);
// - size() : list의 개수
for(int i = 0; i < list.size(); i++) {
System.out.println(list.get(i));
}
System.out.println("--list.size()--");
System.out.println(list.size());
// 문자열을 담는 리스트 생성
// 문자열 5개 저장한 후 출력
List<String> strList = new ArrayList<String>();
strList.add("새벽");
strList.add("아침");
strList.add("점심");
strList.add("저녁");
strList.add("밤");
System.out.println(strList);
for(int i = 0; i < strList.size(); i++) {
System.out.println(strList.get(i));
}
// 향상된 for문
for(String tmp : strList) {
System.out.println(tmp);
}
// - remove(index) : index번지의 값을 삭제 => List에서만 가능
// - remove(object) : object 요소를 삭제 => set/map
strList.remove(0);
System.out.println(strList);
strList.remove("밤");
System.out.println(strList);
System.out.println(list);
Integer re = 10;
list.remove(re); // object
System.out.println(list);
// - contains(object) : list에 값이 있는지 검사 true / false로 리턴
System.out.println(strList.contains("새벽"));
// - clear() : 리스트 비움
strList.clear();
System.out.println(strList);
// - isEmpty() : 리스트가 비었는지 확인 true / false
System.out.println(strList.isEmpty());
}
}
▷ 출력
출력 (1)
▣ ListEx01
package day07;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;
public class ListEx01 {
public static void main(String[] args) {
/* 하루 일과를 저장하는 list를 생성
* 출력 for / 향상된 for / Iterator 출력
* import 다축키 : ctrl+shift+o
*/
List<String> list = new ArrayList<>(); // 변수명을 list로 변경
list.add("기상");
list.add("씻기");
list.add("아침밥 먹기");
list.add("양치 하기");
list.add("학원 가기");
list.add("입실");
list.add("오전 수업");
list.add("점심밥 먹기");
list.add("양치 하기");
list.add("오후 수업");
list.add("퇴실");
list.add("자습");
list.add("귀가");
list.add("저녁밥 먹기");
list.add("씻기");
list.add("게임 하기");
list.add("취침");
System.out.println("--- 하루 일과 ---");
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i));
}
System.out.println("---------------");
for (String tmp : list) {
System.out.println(tmp);
}
System.out.println("---------------");
Iterator<String> it = list.iterator();
while (it.hasNext()) {
String tmp = it.next();
System.out.println(tmp);
}
// 정렬 list.sort(Comparator 구현체);
System.out.println(list);
// 오름차순
Collections.sort(list);
System.out.println(list);
// 내림차순
list.sort(new Comparator<String>() {
@Override
public int compare(String o1, String o2) {
return o2.compareTo(o1); // 내림차순
}
});
System.out.println(list);
// 같은 Object가 2개 이상이더라도 앞에 있는 하나만 삭제
List<String> ex = new ArrayList<>();
list.add("양치 하기");
list.removeAll(ex);
System.out.println(list);
}
}
▷ 출력
출력 (2)
▣ ListEx02
package day07;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
public class ListEx02 {
public static void main(String[] args) {
// 두 배열을 하나의 리스트로 합치기
// 정렬하여 출력 (오름, 내림차순)
// 직접 해당 값을 리스트로 옮기기
// Arrays.asList() : 배열 => 리스트
// toArray() : 리스트 => 배열
String arr1[] = {"a", "g", "f", "h", "c"};
String arr2[] = {"b", "t", "s", "p", "n", "m"};
List<String> list2 = Arrays.asList(arr1);
System.out.println(list2);
// 배열과 list가 연결되어있는 상태. 추가 불가능 / 수정가능
// 리스트 = 배열 원본 배열 변경
// list2.add("z");
// list2.set(0, "z");
// System.out.println(list2);
System.out.println("--- new ArrayList1 ---");
List<String> list3 = new ArrayList<>(Arrays.asList(arr1));
System.out.println(list3);
list3.add("z");
System.out.println(list3);
System.out.println("--- new ArrayList4 ---");
List<String> list4 = new ArrayList<>(Arrays.asList(arr2));
System.out.println(list4);
System.out.println("--- list addAll ---");
list3.addAll(list4);
System.out.println(list3);
// List를 배열로 변환
int listSize = list3.size();
System.out.println("--- 리스트를 배열로 변환 ---");
String[] arr = list3.toArray(new String[listSize]);
System.out.println(Arrays.toString(arr));
List<String> list = new ArrayList<>();
int cnt = arr1.length + arr2.length;
int i = 0, j = 0;
while(cnt > list.size()) {
if(i<arr1.length) {
list.add(arr1[i]);
i++;
}
if(j<arr2.length) {
list.add(arr2[j]);
j++;
}
}
System.out.println(list);
System.out.println(list);
Collections.sort(list);
System.out.println(list);
list.sort(new Comparator<String>() {
@Override
public int compare(String o1, String o2) {
return o2.compareTo(o1);
}
});
System.out.println(list);
}
}
▷ 출력
출력 (3)
▣ ListEx03
package day07;
import java.util.ArrayList;
public class ListEx03 {
public static void main(String[] args) {
/* 과제
* num의 값을 숫자 List를 생성하여 추가 => 출력
* 합계를 출력
* 70점 이상인 인원 수 출력
* 3/8명
*/
String num = "45,78,98,65,84,52,64,31";
String[] numbers = num.split(",");
ArrayList<Integer> list = new ArrayList<>();
int n = 0;
int sum = 0;
int cnt = 0;
for(String tmp : numbers) {
n = Integer.parseInt(tmp);
sum += n;
list.add(n);
if(n >= 70) {
cnt++;
}
}
System.out.println(list);
System.out.println("합계 : " + sum + " | 합격 : " + cnt + "/" + list.size());
}
}
▷ 출력
출력 (4)
▣ Set01
package day07;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
public class Set01 {
public static void main(String[] args) {
/* Set : index가 없음. (순서 보장X), 정렬X, 중복X
* HashSet(대표적인 Set) / TreeSet(정렬이 되는 Set)
*/
Set<String> set = new HashSet<String>();
set.add("a");
set.add("b");
set.add("c");
set.add("a");
set.add("b");
set.add("c");
System.out.println(set);
// set은 index가 없어서 get(i) / set(index, value) 없음
for(String s : set) {
System.out.println(s);
}
Iterator<String> it = set.iterator();
while(it.hasNext()) {
String tmp = it.next();
System.out.println(tmp);
}
System.out.println("--------");
// set => list 변경 후
List<String> list = new ArrayList<String>(set);
System.out.println(list);
}
}
