출처: https://bumcrush.tistory.com/182 [맑음때때로 여름]

–문자 스트림 


•유니코드로 된 문자를 입·출력 하는 스트림 
•2바이트를 입·출력 - 세계 모든 언어로 구성된 파일을 입·출력 하기에 적합 
•이미지, 동영상과 같은 바이너리 데이터는 입·출력 할 수 없음 
•문자 데이터만 입·출력 가능 

 

 

 

Reader의 대표적인 메소드

public int read() throws IOException
public abstract int read(char[] cbuf, int off, int len) throws IOException

Writer의 대표적인 메소드

public int write(int c) throws IOException

public abstract void write(char[] cbuf, int off, int len) throws IOException 

 

 

BufferedWriter

package io;

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;

public class StringWriter {

	public static void main(String[] args) throws IOException {

		// 필터스트림 : 기본 스트림 writer가 필요하다.
		Writer writer = new FileWriter("String.txt");  // 기본스트림
		BufferedWriter out = new BufferedWriter(writer); // 필터스트림
		
		out.write("Cos ah ah I’m in the stars tonight");
		out.newLine();
		out.write("So watch me bring the fire and set the night alight");
		out.newLine();
		out.write("Shining through the city with a little funk and soul");
		out.newLine();
		out.write("So I’mma light it up like dynamite, woah");
		out.newLine();
		out.newLine();
		out.write("BTS - Dynamite");
		
		// 스트림닫기
		out.close();
		
	}

}

BufferedReader

package io;

import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;
import java.io.BufferedReader;

public class StringReader {

	public static void main(String[] args) throws IOException{
		
	
	// 문자 기반 기본 스트림 인스턴스 생성
	Reader reader = new FileReader("String.txt");
	// 필터스트림
	BufferedReader in = new BufferedReader(reader);
	
	// 한행의 문자열을 담을 변수
	
	String str=null;
	while(true) {
		//한줄씩 읽어 문자열을 반환, 없으면 null
		str=in.readLine();
		if(str==null) {
		break;
	}
		System.out.println(str);
	
	}
}
}

 

문자 필터 스트림 PrintWriter

package io;

import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;

public class PrintWriterStream {

	public static void main(String[] args) throws IOException {

		PrintWriter out = new PrintWriter(new FileWriter("Print.txt"));
		
		out.printf("안녕하세요 저는 %d살 %s입니다.",12,"철수");
		out.println();
		out.print("저는 자바를 좋아합니다");
		out.println("IO 재미있네요.");
		out.close();
		
		System.out.println("파일작성 완료");
	}

}

'JAVA > basic' 카테고리의 다른 글

[ 입출력 ] 버퍼 스트림  (0) 2020.10.26
[ 입출력 ] File  (0) 2020.10.26
[ 입출력 ] 직렬화 (Serializable)  (0) 2020.10.26
[ 입출력 ] Stream / 바이트스트림  (0) 2020.10.26
Map <K, V> / HashMap <K, V> key-value  (0) 2020.10.23
[ 컬렉션 Collection<E> ] TreeSet  (0) 2020.10.23
[ 컬렉션 Collection<E> ] HashSet  (0) 2020.10.23

스트림(stream)이란?
- 데이터를 운반(입출력)하는데 사용되는 연결통로
- 연속적인 데이터의 흐름을 물(stream)에 비유해서 붙여진 이름
- 하나의 스트림으로 입출력을 동시에 수행할 수 없다.(단방향 통신)
- 입출력을 동시에 수행하려면, 2개의 스트림이 필요하다.

 

•자바의 스트림
–입·출력 장치와 프로그램을 연결하며, 이들 사이의 데이터 흐름을 처리하는 소프트웨어 모듈
–데이터를 처리하기 위한 공통된 방법을 제공함
–입력 스트림 : 입력 장치로부터 자바 프로그램으로 전달되는 데이터의 흐름 혹은 데이터 전송 소프트웨어 모듈
–출력 스트림 : 자바 프로그램에서 출력 장치로 보내는 데이터의 흐름 또는 데이터 전송 소프트웨어 모듈

 

자바 입·출력 스트림의 특징
–스트림은 FIFO 구조
• FIFO : 먼저 들어간 것이 먼저 나오는 형태 → 데이터의 순서가 바뀌지 않음
–스트림은 단방향
• 읽기, 쓰기가 동시에 되지 않음
• 읽는 스트림과 쓰는 스트림을 하나씩 열어 사용해야 함
–스트림은 지연될 수 있음
• 스트림은 넣어진 데이터가 처리되기 전까지는 스트림에 사용되는 스레드가 지연상태에 빠짐
• 네트워크 내에서는 데이터가 모두 전송되기 전까지 네트워크 스레드는 지연상태를 유지함

•InputStream 클래스의 대표적인 두 메소드

  public abstract int read() throws IOException

  public void close() throws IOException

 

•OutputStream 클래스의 대표적인 메소드

 public abstract void write(int b) throws IOException

 public void close() throws IOException

 

자바 입·출력 스트림의 종류


–바이트 스트림


•문자 단위/바이트 단위
•바이트 스트림은 1바이트를 입·출력 할 수 있는 스트림
•자바에서 입·출력 스트림을 통해 흘러가는 데이터의 기본 단위
•일반적으로 바이트로 구성된 파일을 처리하기에 적합

 

•바이트 스트림 클래스
–JAVA . IO 패키지 포함
–InputStream/OutputStream

 >추상 클래스로써 바이트 입·출력 스트림을 다루는 모든 클래스의 슈퍼 클래스
–FileInputStream/FileOutputStream 

 >파일로 부터 바이트 단위로 읽거나 저장하는 클래스

 >바이너리 파일을 입·출력을 할 때 사용

 

 

package io;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;

public class ByteFileCopy {

	public static void main(String[] args) throws IOException  {

		
		// 읽어올 대상 파일의 InputStream 인스턴스를 생성한다.

			InputStream in = new FileInputStream("org.pdf");
			
		// 출력 대상 파일의 OutpurStream 인스턴스 생성
			
			OutputStream out = new FileOutputStream("org_copy.pdf");

			
		// 필터스트림 인스턴스 생성
		BufferedInputStream bin = new BufferedInputStream(in, 1024*3);
		BufferedOutputStream bout = new BufferedOutputStream(out, 1024*3);
		
		int copyByte=0; // 복사한 사이즈
		int bData=0; // 원본에서 복사한 byte 사이즈의 데이터
		
//		byte[] buf = new byte[1024]; // 1kb 버퍼생성
//		int readLength = 0; // 얼마만큼 읽어왔는지.
		
		System.out.println("복사를 시작합니다.");
		
		while(true) {
			bData = in.read(); // 더이상 가져올 데이터가 없으면 -1을 반환
//			readLength = in.read(buf);
			
			if(bData==-1) { 
//			if(readLength==-1) { 
				break;
			}
			out.write(bData); // 출력 : 파일에 바이터리 코드를 쓴다.
//			out.write(buf,0,readLength);
//			copyByte+= readLength;
			copyByte++;
		}
		
		in.close(); // 스트림 인스턴스 소멸
		out.close(); 
		System.out.println("복사가 완료되었습니다.");
		System.out.println("복사된 사이즈 : " + copyByte + "byte");
}
}

 

protik.tistory.com/entry/javaioFileNotFoundException-ex141-%EC%A7%80%EC%A0%95%EB%90%9C-%ED%8C%8C%EC%9D%BC%EC%9D%84-%EC%B0%BE%EC%9D%84-%EC%88%98-%EC%97%86%EC%8A%B5%EB%8B%88%EB%8B%A4

'memo' 카테고리의 다른 글

url  (0) 2020.10.28
java.net.BindException:  (0) 2020.10.28
역직렬화  (0) 2020.10.26
제네릭  (0) 2020.10.22
코드블럭 꾸미기  (0) 2020.10.22
매개변수란? ( ) 안에 들어가는애들인듯  (0) 2020.10.14
string stringbuffer stringbuilder  (0) 2020.10.13

public int compareTo(String anotherString)

2개의 문자열을 비교하여(A coomparTo B) 같으면 0, A가 B보다 크면 양수, 적으면음수를 반환

맨 첫자리부터 차례대로 비교한다.

 

 (역주: "A"는 feff0041, "B"는 feff0042)
 비교는 스트링내의 각각의 문자의 Unicode 값에 근거해 행해집니다.
 String 객체에 의해 나타내지는 문자열이, 인자로 전달 받은 스트링의 문자열과 사전적으로 비교됩니다.
 String 객체가 사전적으로, 전달받은 스트링보다 전에 있는 경우는, 결과는 음의 정수가 됩니다.

 

equals(Object) 메소드가 true 를 돌려줄 때, compareTo 는 0 을 돌려줍니다.

"사전적의 순서"의 정의는 다음과 같습니다.
2 개의 스트링이 다르다고 한다면,
서로 다른 문자가 문자열 중에 있거나,
2 개의 스트링의 길이가 다르거나,
혹은 그 두 경우 다 해당되는 상황입니다.

 

만일 하나 또는 그 이상의 위치 (index) 에서 문자가 서로 다를 때,
index 중 가장 작은 숫자를 k 라고 가정합니다.
k 위치에 있는 두 문자를 < 연산자 로 비교하면, 두 문자중 하나는 다른 문자보다 작습니다.
이 문자를 가진 문자열을 사전적으로 (역주: "A"가 "B"보다 앞에 있는것 처럼) 앞에 있다고 합니다.
이 경우, compareTo 는 2 개의 스트링에서 위치 k 에 있는 2 개의 문자의 값의 차이를 돌려줍니다.
식으로 표현하면 다음과 같습니다.

this.charAt(k) - anotherString.charAt(k)

 


유효한 모든 인덱스 위치에 있어서의 문자가 같은 경우는, 짧은 길이의 스트링이 사전적으로 앞이 됩니다.
이 경우 compareTo 는 스트링의 길이의 차이를 돌려줍니다. 식으로 표현하면 다음과 같습니다.

 * this.length() - anotherString.length()

정의: compareTo in interface Comparable<string></string>
파라미터: 'anotherString - 비교 대상의 String'
반환값
인수 스트링이 스트링과 동일한 경우는 0.
스트링이 주어진 스트링보다 사전식에서 작은 경우는 음수.
주어진 스트링보다 스트링이 사전식에서 큰 경우는 양수.
 

 

package Chapter15_Overriding;
 
public class CompareTo {
 
    public static void main(String[] args) {
       
        String a = "ABC";
        String b = "ABC";
        String c = "BCD";
        String d = "ABCDEF";
       
        System.out.println(a.compareTo(b));
        //출력결과  : 0
       
        System.out.println(a.compareTo(c));
        //출력결과 : -1
       
        System.out.println(a.compareTo(d));
        //출력결과 : -3
       
    }
 
}
 
package Collection;

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

public class HashMapTest {

	public static void main(String[] args) {

		// Map : key-Value 형식으로 저장하는 객체
		// 대표적인 형식이 HashMap이다. HashMap<K, V>
		HashMap<Integer, String> map = new HashMap<Integer, String>();

		// 요소 추가 : put(T e)
		map.put(1, "김남준");
		map.put(2, "김석진");
		map.put(3, "민윤기");
		map.put(4, "정호석");
		map.put(5, "박지민");
		map.put(6, "김태형");
		map.put(7, "전정국");

		// 참조 : V get(K key)
		// put에서는 반복하는 Iterator가 없다
		// 그냥 하나 딱 뽑아쓰려고할 때 유용한 느낌

		System.out.println("1번 " + map.get(1));
		System.out.println("2번 " + map.get(2));
		System.out.println("3번 " + map.get(3));
		System.out.println("4번 " + map.get(4));
		System.out.println("5번 " + map.get(5));
		System.out.println("6번 " + map.get(6));
		System.out.println("7번 " + map.get(7));

		for (int i = 1; i < map.size(); i++) {
			System.out.print(map.get(i) + "\t");
		}

		// Set<Key Type>
		Set<Integer> set = map.keySet();
		Iterator<Integer> itr = set.iterator();
		
        System.out.println();
		while (itr.hasNext()) {
			int key = itr.next();
			System.out.println(key + "번 학생의 이름은 " + map.get(key));
		}

	}

}

<출력>

 

1번 김남준
2번 김석진
3번 민윤기
4번 정호석
5번 박지민
6번 김태형
7번 전정국
김남준 김석진 민윤기 정호석 박지민 김태형

1번 학생의 이름은 김남준
2번 학생의 이름은 김석진
3번 학생의 이름은 민윤기
4번 학생의 이름은 정호석
5번 학생의 이름은 박지민
6번 학생의 이름은 김태형
7번 학생의 이름은 전정국

 

 

<NavigableSet  / TreeMap에서만 사용가능>

- descendingInterator// Key값 내림차순 정렬

import java.util.Iterator;
import java.util.NavigableSet;
import java.util.TreeMap;

public class HashMapTest {

	public static void main(String[] args) {

		// Map : key-Value 형식으로 저장하는 객체
		// 대표적인 형식이 HashMap이다. HashMap<K, V>
		TreeMap<Integer, String> map = new TreeMap<Integer, String>();

		// 요소 추가 : put(T e)
		map.put(1, "김남준");
		map.put(2, "김석진");
		map.put(3, "민윤기");
		map.put(4, "정호석");
		map.put(5, "박지민");
		map.put(6, "김태형");
		map.put(7, "전정국");

		// NavigableSet<Key Type>
		NavigableSet<Integer> set = map.navigableKeySet();
		
		System.out.println("오름차순 출력...");
		Iterator<Integer> itr = set.iterator();
		while (itr.hasNext())
			System.out.println(map.get(itr.next()));

		System.out.println("내림차순 출력...");
		itr = set.descendingIterator(); // 내림차순 정렬
		while (itr.hasNext())
			System.out.println(map.get(itr.next()));
	}

}

< 출력 >

 

오름차순 출력...
김남준
김석진
민윤기
정호석
박지민
김태형
전정국


내림차순 출력...
전정국
김태형
박지민
정호석
민윤기
김석진
김남준

 

TreeSet<E> 클래스는 트리라는 자료구조를 기반으로 데이터를 저장한다.
데이터를 정렬된 순서로 저장하며, HashSet<E>와 마찬가지로 데이터의 중복저장 않는다.
정렬의 기준은 프로그래머가 직접 정의한다.

 

package Collection;

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

public class TreeSetTest {

	public static void main(String[] args) {

		
		// Treeset : 트리 구조로 저장하는 자료구조. 2진트리

		// Treeset 인스턴스 생성
		TreeSet<Integer> tSet = new TreeSet<Integer>();
		

		tSet.add(1);
		tSet.add(5);
		tSet.add(2);
		tSet.add(4);
		tSet.add(3);
		tSet.add(2);
		
		System.out.println("Treeset 요소의 갯수 : " + tSet.size());
		
		Iterator<Integer> itr = tSet.iterator();
		
		while(itr.hasNext()){
			System.out.println(itr.next());
		}

	}

}

 

<출력>

 

Treeset 요소의 갯수 : 5
1
2
3
4
5

 

package Collection;

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

public class Person implements Comparable<Person>{

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

	
	public int compareTo(Person o) {
//		if(age>o.age) {
//			return 1; // 양수반환 : 전달받은 객체의 값이 작을 때
//		}else if (age<o.age) {	
//			return -1; // 음수반환
//		}else {
		 // return age-o.age; // 작은수 > 큰수
		return o.age-age; // 큰수 > 작은수
	}
	
	

	

	public static void main(String[] args) {
		
		TreeSet<Person> tSet = new TreeSet<Person>();
		
		tSet.add(new Person("김태형", 24));
		tSet.add(new Person("박지민", 24)); // 그와중에 age가 같아서 중복이라 지워진다~~!!
		tSet.add(new Person("전정국", 23));
		tSet.add(new Person("김석진", 27));

		Iterator<Person> itr = tSet.iterator();
		
		while(itr.hasNext()) {
			System.out.println(itr.next());
			
		}
		
}
}

 

<출력>

 

김석진(27)
김태형(24)
전정국(23)

List<E>를 구현하는 클래스들과 달리 Set<E>를 구현하는 클래스들은 데이터의 중복저장을 허용하지 않는다.

(단, 동일 데이터에 대한 기준은 프로그래머가 정의)

 

 

package Collection;

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

public class SetTest {

	public static void main(String[] args) {

		// HashSet 인스턴스 생성 : 인스턴스를 저장하기 위한 저장 공간 생성
		// set : 집합, 저장순서 유지하지않는다.
		
		Set<String> set = new HashSet<String>();
		
		set.add("First");
		set.add("Second");
		set.add("Third");
		set.add("First");   // 중복이라 저장되지 않는다.
		

		System.out.println("set 요소의 개수 : "+ set.size());
		
		Iterator<String> itr=set.iterator();
		while(itr.hasNext()) {
			System.out.println(itr.next());
		}
	}

}

<출력>

 

set 요소의 개수 : 3
Second
Third
First

 

// Set<e>는 저장하는 순서를 가지지 않기 때문에 
// 일괄처리를 위해서는 Iterator<E> 인스턴스를 이용해서 처리한다.
// Collection<E>에는 Iterater() 메서드를 가지고 있고 Iterator<E>를 반환한다.

 

 

HashSet<E>클래스의 동등비교

String에는 Hashcode() 가 있어서 지 알아서 중복 분류해주지만 나머지는 해시코드를 만들어줘야한다

package Collection;

public class SimpleNumber {

	int num;

	public SimpleNumber(int num) {
		this.num = num;
	}

	@Override
	public String toString() {
		return String.valueOf(num);
	}
	
}
package Collection;

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

public class SimpleNumberMain {

	public static void main(String[] args) {

		// set  인스턴스 생성		
		Set<SimpleNumber> set=new HashSet<SimpleNumber>();
		
		set.add(new SimpleNumber(10));
		set.add(new SimpleNumber(20));
		set.add(new SimpleNumber(10));
		
		System.out.println("Set 요소의 개수 : "+set.size());
		
		Iterator<SimpleNumber> itr = set.iterator();
		
		while(itr.hasNext()) {
			System.out.println(itr.next());
		}

	}

}

<출력>

 

Set 요소의 개수 : 3
10
10
20

 

 

<SimpleNumber  수정>

쉬프트 알트 o > gernerate hashcode() and equals()

package Collection;

public class SimpleNumber {

	int num;

	
	// Set 동등 비교를 위한 Hashcode(), equals() 오버라이딩
	
	@Override
	public int hashCode() {
//		final int prime = 31;
//		int result = 1;
//		result = prime * result + num;
		return num%3; // 0 or 1 or 2
	}

	@Override
	public boolean equals(Object obj) {
		if (this == obj) // 참조 주소값 == 전달받은 참조 주소값
			return true;
		if (obj == null) // 들어오는 객체가 null  ex) set.add(null)인 경우
			return false;
		if (getClass() != obj.getClass()) // 클래스 이름비교, 같은 타입인가
			return false;
		SimpleNumber other = (SimpleNumber) obj;
		if (num != other.num)
			return false;
		return true;
	}

	public SimpleNumber(int num) {
		this.num = num;
	}

	@Override
	public String toString() {
		return String.valueOf(num);
	}
	
}

< 출력 >

 

Set 요소의 개수 : 2
10
20

반복자를 사용하면, 컬렉션 클래스의 종류에 상관없이 동일한 형태의 데이터 참조방식을 유지할 수 있다.
따라서 컬렉션 클래스의 교체에 큰 영향이 없다.
컬렉션 클래스별 데이터 참조 방식을 별도로 확인할 필요가 없다.

 

package Collection;

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

public class IteraorTest {

	public static void main(String[] args) {
		
		ArrayList<String> list = new ArrayList<String>();
		
		list.add("First");
		list.add("second");
		list.add("Third");
		list.add("Fourth");
		
		// Iterator<E> 인스턴스 생성 : Iterator 메서드 호출
		System.out.println("요소 출력");
		
		Iterator<String> itr=list.iterator();
		
		//hasNext(), Next(), remove();
		while(itr.hasNext()) {
			String str=itr.next(); // hasNext(있다면)  str(받아서)
			System.out.println(str); // print(출력)
			
			if(str.compareTo("Third")==0) {
				itr.remove();
				
			}
		}
		
		System.out.println("요소 삭제 후 요소 출력");
		
		itr = list.iterator();
		while(itr.hasNext()) {
			System.out.println(itr.next());
		}
	}

}

'JAVA > basic' 카테고리의 다른 글

Map <K, V> / HashMap <K, V> key-value  (0) 2020.10.23
[ 컬렉션 Collection<E> ] TreeSet  (0) 2020.10.23
[ 컬렉션 Collection<E> ] HashSet  (0) 2020.10.23
[ 컬렉션 Collection<E> ] ArrayList  (0) 2020.10.23
[ 컬렉션 Collection<E> ] 컬렉션 프레임워크  (0) 2020.10.22
generic / 제네릭  (0) 2020.10.22
예외처리 / Exception  (0) 2020.10.21

ArrayList<E>의 단점 

• 저장소의 용량을 늘리는 과정에서 많은 시간이 소요된다. 
• 데이터의 삭제에 필요한 연산과정이 매우 길다. 

ArrayList<E>의 장점
• 데이터의 참조가 용이해서 빠른 참조가 가능하다.

// 근데 어차피 대부분 ArrayList를 쓴다고 한다 (❌LinkedList)

 

ArrayList<int> arr=new ArrayList<int>( ); error
LinkedList<int> link=new LinkedList<int>( ); error

기본 자료형 정보를 이용해서 제네릭 인스턴스 생성 불가능!
따라서 Wraper 클래스를 기반으로 컬렉션 인스턴스를 생성한다. (Int 말고 Integer⭕)

 

 

 

 

- ArrayList <어떤Type> 이름

 

형식 기능 
이름.get(index) index에 저장된 저장값 불러오기
이름.size 저장된 요소의 갯수
이름.remove(index) index에 저장된 것 삭제
이름.add(추가할값)
추가
이름.add(index, 추가할값)
index에 추가할 값을 추가 (그 뒤는 index 하나씩 알아서 뒤로 밀림)
이름.containts(어떤값) 어떤값이 추가하는지 true/false 반환
이름.set(index,수정값) index 자리에 있는 값을 수정값으로 수정
이름.indexOf(특정값) 특정값이 잇는 index를 반환
이름.isEmpty(); 값을 가지고 있으면 true 아니면 false
이름clear(); 모든 원소 삭제

 

package Collection;

import java.util.ArrayList;

public class ArrayListTest {

	public static void main(String[] args) {

		// 인스턴스 저장을 목적으로 하는 클래스
		// List<E> : 저장 순서 유지 (반복문이용 용이), 중복저장 허용

		//ArrayList<Integer> list = new ArrayList<Integer>();
		//List<Integer> list = new ArrayList(); 
		List<Integer> list = new ArrayList<Integer>();
		
		list.add(1);
		list.add(2);
		list.add(3);
		list.add(4);

		System.out.println("list의 첫번째 요소의 값 : " + list.get(0));
		System.out.println("list 요소의 갯수 : " + list.size());

		System.out.println("list 출력");
		for (Integer i : list) {
			System.out.println(i);
		}
		
		// 삭제
		list.remove(2);
		
		System.out.println("삭제 후 list 출력");
		for (Integer i : list) {
			System.out.println(i);
		}
		
		
	}

}

<출력>

 

list의 첫번째 요소의 값 : 1
list 요소의 갯수 : 4
list 출력
1
2
3
4
삭제 후 list 출력
1
2
4

 

 

'JAVA > basic' 카테고리의 다른 글

[ 컬렉션 Collection<E> ] TreeSet  (0) 2020.10.23
[ 컬렉션 Collection<E> ] HashSet  (0) 2020.10.23
[ 컬렉션 Collection<E> ] Iterator  (0) 2020.10.23
[ 컬렉션 Collection<E> ] 컬렉션 프레임워크  (0) 2020.10.22
generic / 제네릭  (0) 2020.10.22
예외처리 / Exception  (0) 2020.10.21
예외처리 / throw  (0) 2020.10.21
package Friend;

import java.util.InputMismatchException;
import java.util.Scanner;

public class FriendInfoMain {

	public static void main(String[] args) {

		FriendInfoHandler handler = FriendInfoHandler.getInstance();
		Scanner sc = new Scanner(System.in);
		while (true) {
			try {
				System.out.println("** 메뉴선택 **");
				System.out.println(Number.INSERT + " : 입력");
				System.out.println(Number.SEARCH + " : 검색");
				System.out.println(Number.DELETE + " : 삭제");
				System.out.println(Number.ALLPRINT + " : 전체 정보 출력 ");
				System.out.println(Number.SIMPLEPRINT + " : 간단 정보 전체 출력 ");
				System.out.println(Number.EXIT + " : 종료 ");
				System.out.println("선택하세요 >>");
				
				int choice = oneSix();
				sc.nextLine();

				switch (choice) {
				case Number.INSERT:
					handler.addFriend();
					break;
				case Number.SEARCH:
					handler.searchInfo();
					break;
				case Number.DELETE:
					handler.deleteInfo();
					break;
				case Number.ALLPRINT:
					handler.showAllData();
					break;
				case Number.SIMPLEPRINT:
					handler.showAllSimpleData();
					break;
				case Number.EXIT:
					System.out.println("프로그램을 종료합니다.");
					return;
				}
			} catch (InputMismatchException | NumberRange e) {
				System.out.println("1에서 6사이의 숫자만 입력하세요");
				continue;
			}
		}
	}
		
		public static int oneSix() throws NumberRange{
			Scanner sc = new Scanner(System.in);
			int choice=sc.nextInt();			
			if(choice>=7 || choice<0) {
				NumberRange e = new NumberRange(choice);
				throw e;
			}
			return choice;
		} 

	

}
package Friend;

public class NumberRange extends Exception{
	
	int choice;
	
	public NumberRange(int choice) {
			}

}

+ Recent posts