자바7에서 추가된 기능으로 finally에서 작성했던 close처리를 try문에서 자동으로 close처리
Application1
import java.io.BufferedReader;
import java.io.EOFException;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
public class Application1 {
public static void main(String[] args) {
/* 위에서 배운 예외처리를 가장 많이 활용하는 것이 io(input/output)
* 이다. 아직 io를 배우지 않았지만 io문법보다는 try-catch 블럭의
* 실제 사용과 흐름에 집중해서 살펴보자. */
/* FileNotFoundException 발생 */
// BufferedReader in = new BufferedReader(new FileReader("test.dat"));
BufferedReader in = null;
/* try 블럭 내부와 finally 블럭 내부에서 모두 사용하기위해
* 지역변수가 아닌 전역 변수로 선언
* 즉, finally 블럭에서 사용하려면 레퍼런스 변수를 try 블럭
* 밖에서 선언해야 한다. */
try {
/* FileReader라는 클래스의 생성자에 예외를 throws해놓았다.
* 사용하는 쪽에서 반드시 예외 처리를 해야하기 때문에 try-catch
* 블럭안에서 생성자를 호출하여 인스턴스를 생성해야 한다. */
in = new BufferedReader(new FileReader("test.dat"));
// FileNotFoundException: test.dat
// (지정된 파일을 찾을 수 없습니다)
String s;
/* readLine메소드도 IOException을 throws 하므로
* catch 블록을 추가해서 예외처리 구문을 작성해야 한다. */
while ((s = in.readLine()) !=null) {
System.out.println(s);
}
/* FileNotFoundException와 EOFException 을
* 동시에 처리할 수 있다.
* 같은 레벨의 자손을 한 번에 처리할 수 있다.
* */
} catch (FileNotFoundException | EOFException e) {
e.printStackTrace();
} catch (IOException e) {
/*입출력에 관한 추상화 된 예외 클래스이다.
* FileNotFoundException와 EOFException은 IOException의 후손이다.
*
* catch 블럭은 여러개를 작성할 시 상위 타입이 하단에 오고
* 후손 타입이 먼저 작성되어야 한다.
*
* */
e.printStackTrace();
} finally {
/* 파일을 스트림 해왔다면 반드시 닫아주는 작업이 필요
* 예외 처리 구문과 상관없이 반드시 수행해야하는 경우 작성하며
* 보통 사용한 자원을 반납할 목적으로 사용하게 된다.
* */
try {
/* 입출력에 사용한 스트림을 닫아주는 메소드이다.
* IOException을 위임한 메소드이기 때문에 finally 블럭
* 안이더라도 예외처리를 중첩으로 해주어야 한다. */
/* 그냥 실행하면 NullPointerException이 발생한다.
* 파일을 찾지 못해 객체를 생성하지 못하고
* 레퍼런스 변수는 null 값을 가지고 있는데
* null 을 참조하는 상태에서 참조연산자 사용시 발생하는 예외이다.
* NullPointerException은 uncheckedException이므로
* try-catch로 처리하기 보다는
* 보통은 if-else 구문으로 해결가능하다.
* */
// in.close();
// java.lang.NullPointerException
if(in != null)
in.close();
} catch (IOException e) {
e.printStackTrace();
} // IOException 발생
}
}
}
Application2
import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
public class Application2 {
public static void main(String[] args) {
/* try-with-resource */
/* JDK 1.7에서 추가된 문법이다.
* close 해야 하는 인스턴스의 경우 try 옆에 괄호안에서 생성하면
* 해당 try-catch 블럭이 완료될 때 자동으로 close 처리 해준다.
* */
/* 소괄호 안에서 스트림을 읽어온다. */
try (BufferedReader in = new BufferedReader(new FileReader("test.dat"))) {
String s;
while ((s = in.readLine()) != null) {
System.out.println(s);
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
}
Exception과 오버라이딩
오버라이딩 시 throws하는 Exception의 개수와 상관없이 같거나 후손 범위여야 함
import java.io.IOException;
public class SuperClass {
/* 예외를 던지는 메소드를 하나 작성한다. */
public void method() throws IOException {}
}
class SubClass extends SuperClass
import java.io.FileNotFoundException;
import java.io.IOException;
public class SubClass extends SuperClass {
/* 예외없이 오버라이딩 할 수 있다. */
// @Override
// public void method() {}
// /* 같은 예외를 던져주는 구문으로 오버라이딩 할 수 있다. */
// @Override
// public void method() throws IOException {}
/* 부모의 예외 처리 클래스보다 상위의 예외로는
* 후손클래스를 오버라이딩 할 수 없다. */
// @Override
// public void method() throws Exception {}
/* 하지만 부모의 예외처리 클래스보다 더 하위에 있는 예외
* (즉, 더 구체적인 예외상황)인 경우에는 오버라이딩 할 수 있다. */
@Override
public void method() throws FileNotFoundException {}
}
입출력
File 클래스
파일 시스템의 파일을 표현하는 클래스
파일크기, 파일 속성, 파일 이름 등의 정보와 파일 생성 및 삭제 기능을 제공
File 인스턴스 생성
File file = new File(“file path");
File file = new File("C:/data/fileTest.txt");
파일/디렉토리 생성 및 삭제 메소드
파일/디렉토리 생성 및 삭제 메소드
Application
import java.io.File;
import java.io.IOException;
public class Application {
public static void main(String[] args) {
/* File을 이용한 스트림을 사용하기 앞서
* File 클래스의 기본사용법을 확인 해보자. */
/* jdk 1.0 부터 지원하는 API로 파일 처리를 수행하는 대표적인 클래스이다.
* 대상 파일에 대한 정보로 인스턴스를 생성하고
* 파일의 생성, 삭제 등등의 처리를 수행하는 기능을 제공하고 있다. */
/* 파일 클래스를 이용해서 인스턴스를 생성한다.
* 대상 파일이 존재하지 않아도 인스턴스를 생성할 수 있다.
* 메모리상에 인스턴스를 생성하기만 했기 때문 */
File file = new File("src/com/greedy/section01/file/test.txt");
/*실제로 만들어보자*/
try {
/* createNewFile을 통해 파일을 생성할 수 있고 성공실패여부를
* boolean 으로 반환한다. */
boolean createSuccess = file.createNewFile();
/* 제대로 생성이 됐는지 확인 */
/* 최초 실행시 새롭게 파일이 만들어지므로 true 가 반환
* 하지만, 파일이 한번 생성 되고 난 이후는 새롭게 파일을 만들지
* 않기 때문에 false를 반환한다. */
System.out.println("createSuccess : " + createSuccess);
// true (refresh 선행 필수)
} catch (IOException e) {
e.printStackTrace();
}
/* 생성한 파일의 정보 */
System.out.println("파일의 크기 : " + file.length() + "byte");
System.out.println("파일의 경로 : " + file.getPath());
System.out.println("현재 파일의 상위 경로 : " + file.getParent());
/* 절대 경로란 최상위 루트 위치로부터의 경로를 의미한다. */
System.out.println("파일의 절대 경로 : " + file.getAbsolutePath());
// 파일의 크기 : 0byte
// 파일의 경로 : src\com\greedy\section01\file\test.txt
// 현재 파일의 상위 경로 : src\com\greedy\section01\file
// 파일의 절대 경로 : D:\dev\1_java\workspace\chap14-io\src\com\greedy\section01\file\test.txt
/* 파일 삭제 */
/* 삭제 후 성공 여부를 boolean 으로 반환한다.
* */
boolean deleteSuccess = file.delete();
/* 지워졌는지 여부 확인 */
System.out.println("deleteSuccess : " + deleteSuccess);
// deleteSuccess : true
}
}
입출력
입출력(IO)란?
Input과 Output의 약자로 컴퓨터 내부 또는 외부 장치와 프로그램 간의 데이터를 주고 받는 것
장치와 입출력을 위해서는 하드웨어 장치에 직접 접근이 필요한데 다양한 매체에 존재하는 데이터들을 사용하기 위해 입출력 데이터를 처리 할 공통적인 방법으로 스트림을 이용
스트림
스트림(Stream)이란?
입출력 장치에서 데이터를 읽고 쓰기 위해서 자바에서 제공하는 클래스
모든 스트림은 단반향이며 각각의 장치마다 연결할 수 있는 스트림 존재
하나의 스트림으로 입출력을 동시에 수행할 수 없으므로 동시에 수행하려면 2개의 스트림이 필요
스트림 종류
기반 스트림이란? 실제 데이터가 전송되는 스트림, 보조스트림이란? 기반 스트림에 종속해 기능적인 역할을 하는 스트림
Application1
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
public class Application1 {
public static void main(String[] args) {
/* 입출력과 관련된 API는 java.io 에서 제공하고 있다.
* API 문서에서 목록을 확인해보면 대부분
* InputStream/OutputStream & Reader/Writer 로 끝난다.
* 이 중 InputStream과 Reader 는 데이터를 읽어오는 입력스트림이고
* OutputStream과 Writer는 데이터를 내보내는 출력스트림이다.
*
* 또한 InputStream과 OutputStream은 데이터를 1바이트 단위로
* 입/출력을 하고 Reader와 Writer는 문자 (2 or 3바이트) 단위로
* 작업을 한다.
*
* 자바 프로그램과 연결되는 외부 데이터의 타입이 무엇인지는 클래스
* 이름을 보고 유추가 가능하다.
* InputStream/OutputStream & Reader/Writer 를 빼고
* 남은 단어가 바로 외부 데이터의 타입이다.
*
* ex : FileInputStream 은 InputStream을 제거하고 남은단어가
* File 이므로 외부 데이터는 File임을 알 수 있다.
*
* */
/* FileInputStream */
FileInputStream fin = null;
try {
/* 대상 파일이 존재하지 않는 경우 발생하는
* FileNotFoundException 에 대해서 핸들링 해야 한다. */
/* 인스턴스만 생성한 후 실행해보면 예외가 발생한 것을 볼 수 있다. */
/* 파일을 직접 생성한 뒤 다시 실행 하면 예외가 발생하지 않는데
* 스트림인스턴스가 정상적으로 생성되었기 때문이다. */
fin = new FileInputStream("src/com/greedy/section02/stream/testInputStream.txt");
/* 파일 생성 : 해당 폴더 우클릭 - new - file - 하위 폴더 선택후 -
* 파일이름.txt 입력 */
int value;
/* read()는 throw IOException이므로
* 'add catch clause to surrounding try '
* 눌러서 catch block 추가
* read() : 파일에 기록 된 값을 순차적으로 읽어오고 더이상
* 읽어올 데이타가 없는 경우 -1반환
* */
// while ((value = fin.read()) != -1) {
//
// /* 값을 정수로 읽어온다. */
// System.out.println(value);
//
// /* 문자로 출력하고 싶은 경우 형변환 하면 된다. */
// System.out.println((char) value);
// }
/* 출력 */
// 97
// a
// 98
// b
// 99
// c
// 100
// d
// 101
// e
/* 1byte 씩 읽어와야 하는 경우도 존재하긴 하지만 대부분의 경우 비효율적이다.
* byte 배열을 이용해서 한 번에 데이터를 읽어오는방법도 제공한다.
* */
/* File 클래스의 length()로 파일의 길이를 알 수 있다. */
System.out.println("파일의 길이 : " + new File("src/com/greedy/section02/stream/testInputStream.txt").length());
/* File의 길이만큼의 byte 배열을 만든다. */
int fileSize = (int) new File("src/com/greedy/section02/stream/testInputStream.txt").length();
byte[] bar = new byte[fileSize];
/* read() 메소드의 인자로 생성한 byte 배열을 넣어주면
* 파일의 내용을 읽어서 byte 배열에 기록해준다. */
fin.read(bar);
/* 해당 스트림은 파일의 끝까지 다 읽어들인 스트림이기 때문에
* 위에 1바이트씩 읽어온 while 반복문을 주석해야 정상적으로 동작한다. */
for (int i=0; i < bar.length; i++) {
System.out.print((char) bar[i]);
}
// 파일의 길이 : 5
// abcde
/* 한글 값을 입력하는 경우 한글이 깨져서 나온다.
* 한글은 한 글자에 3byte 이기 때문에 3byte 데이터를
* 1byte로 읽어오면 글자가 깨지게 된다. */
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
/* fin 인스턴스가 null 이 아닌 경우 자원 반납을 해야한다. */
if (fin != null) {
try {
/* 자원해제를 하는 경우에도 IOException을 핸들링 해야한다.
* 이미 자원이 반납 된 경우 발생하는 Exception이다.
* */
/* 자원 반납을 해야하는 경우
*
* 1. 장기간 실행 중인 프로그램에서 스트림을 닫지않는 경우
* 다양한 리소스에 누수(leak)가 발생한다.
* 2. 뒤에서 배우는 버퍼를 이용하는 경우 마지막에 flush()로
* 버퍼에 있는 데이터를 강제로 전송해야 한다.
* 만약 잔류 데이터가 남은 상황에서 추가로 스트림을 사용한다면
* 데드락(deadlock)상태가 된다.
* 판단하기 어렵고 의도하지 않은 상황에서도 이런 현상이 발생할 수 있기
* 때문에 마지막에는 flush()를 무조건 실행해주는 것이 좋다.
* close() 메소드는 자원을 반납하며 flush() 를 해주기 때문에
* close() 만 제대로 해주어도 된다.
* */
fin.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
Application2
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
public class Application2 {
public static void main(String[] args) {
/* FileReader */
/* FileInputStream과 사용하는 방법이 거의 동일하다.
* 단, byte 단위가 아닌 character 단위로 읽어들이는 부분이 차이점이다.
* 따라서 2바이트던 3바이트던 글자단위로 읽어오기 때문에
* 한글을 정상적으로 읽어올 수 있는 방식이다. */
FileReader fr = null;
try {
/* 파일이 존재하지 않는 경우 파일을 찾지 못한다는 예외가 발생하므로
* 파일을 추가해서 정상적으로 스트림이 생성되게 한다. */
fr = new FileReader("src/com/greedy/section02/stream/testReader.txt");
// testReader.txt (지정된 파일을 찾을 수 없습니다)
/* 파일 생성 : 패키지에 대고 우클릭 - new - file - 해당패키지 재 클릭 -
* 파일명.txt 입력 */
/* 파일 내용을 읽어오는 것도 동일하다. */
/* 한글 값을 입력해도 하나의 글자 단위로 읽어온다. */
// int value;
//
// while((value = fr.read()) != -1) {
// System.out.print((char) value);
// }
// 안녕하세요 출력
/* 단 byte 배열로 읽어오면 한글은 깨지게 되므로
* char 배열로 내용을 읽어오는 기능을 제공하고 있다.
* */
/* 배열의 길이를 구하기 위한 과정 */
char[] carr = new char[(int) new File("src/com/greedy/section02/stream/testReader.txt").length()];
/* 위에서 길이를 구했다면 이번엔 내용을 읽어줘야함 */
fr.read(carr);
/* 길이만큼 반복을 돌며 읽어와 char로 형변환 한 carr의 인덱스를 출력함 */
for(int i = 0; i < carr.length; i++) {
System.out.print(carr[i]);
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
/* 사용이 끝났다면 반드시 닫아주어야 함 */
} finally {
if (fr != null) {
try {
fr.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
InputStream
바이트 기반 입력 스트림의 최상위 클래스로 추상 클래스
추상클래스이므로 객체를 생성할 수 없다.
OutputStream
바이트 기반 출력 스트림의 최상위 클래스로 추상 클래스
추상클래스이므로 객체를 생성할 수 없다.
Reader
문자 기반 입력 스트림의 최상위 클래스로 추상 클래스
Writer
문자 기반 입력 스트림의 최상위 클래스로 추상 클래스
Application3
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
public class Application3 {
public static void main(String[] args) {
/* FileOutputStream */
/* 프로그램의 데이터를 파일로 내보내기 위한 용도의 스트림이다.
* 1바이트 단위로 데이터를 처리한다.
* */
FileOutputStream fout = null;
try {
/* 스트림으로 길을 만들고 도착지가될 파일을 괄호속에 입력한다. */
/* FileNotFoundException을 핸들링해야하는 것은 동일하지만
* 실행해도 예외가 발생하지 않고 인스턴스가 잘 생성된다.
* 파일을 수동으로 만들어줘야하는 InputStream과 달리,
* OutputStream의 경우 대상 파일이 존재하지않으면 파일을 자동으로
* 생성해준다.
*
* 단, 만약 지정할 경로의 스펠링을 틀린다면()오류가 발생한다.
* 경로가 정확한 상태에서 파일만 없는 것은 자동으로 만들어 주는 것이다.
* FileNotFoundException이 핸들링하는 부분은 경로
* => (지정된 경로를 찾을 수 없습니다.)
*
* */
/* 두번째 인자로 true를 전달하면 이어쓰기가 된다.
* 전달하지 않으면 (false) 덮어쓰기가 된다.
* */
fout = new FileOutputStream("src/com/greedy/section02/stream/testOutputStream.txt");
/* 이어쓰기 해보자 */
fout = new FileOutputStream("src/com/greedy/section02/stream/testOutputStream.txt" /*, true*/);
/* write() 메소드는 IOException을 핸들링 해야한다. */
fout.write(97);
// IOException 이 발생할 가능성이 있기에 catch 블록 작성
/* byte 배열을 이용해서 한 번에 기록할 수도 있다.
* 10 : 개행문자 (엔터)
* */
/* byte 배열을 이용해서 한 번에 기록할 수도 있다. */
byte[] bar = new byte[] {98, 99, 100, 101, 102, 10, 103, 104, 105};
fout.write(bar);
/* bar의 1번 인덱스부터 3의 길이만큼 파일에 내보내기 */
fout.write(bar, 1, 3); // 1번인덱스부터 3의 길이만큼
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
if (fout != null) {
try {
/* IOException를 핸들링 해 주어야 한다. */
fout.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
Application4
import java.io.FileWriter;
import java.io.IOException;
public class Application4 {
public static void main(String[] args) {
/* FileWriter */
/* 프로그램의 데이터를 파일로 내보내기 위한 용도의 스트림이다.
* 1글자 단위로 데이터를 처리한다.
* */
FileWriter fw = null;
try {
/* IOException을 핸들링 해주기 위해 try-catch 구문실행 */
/* 단, 경로를 잘못 입력하면 FileNotFoundException
* 에러가 발생한다. Writer의 경우 대상파일이 존재하지 않으면
* 파일을 자동으로 생성해준다.
* */
/* 두번째 인자로 true 전달시 내용을 이어쓰기가 된다.
* 인자를 전달하지 않으면 (또는 false) 덮어쓰기가 된다. */
fw = new FileWriter("src/com/greedy/section02/stream/testWriter.txt", true);
/* write() 메소드도 IOException을 핸들링 해야 한다. */
/* true 가 두번째 인자로 전해져있기 때문에 새로고침을 누를 수록
* a가 이어써서 늘어난다. */
fw.write(97);
/* 문자 단위 출력도 내부 버퍼를 사용하므로 쌓여있는 데이터를
* flush()로 내보내 줘야 최종적으로 파일에 출력되는
* 모습을 확인 할 수 있다. 또는 close()로 자원을 반납하면
* 반납 전에 flush()가 호출되므로 파일에 출력되는 모습을
* 확인할 수 있다.
* */
// fw.flush();
/* 문자 기반 스트림은 직접 char 자료형으로 내보내기도 가능하다. */
fw.write('A');
/* 혹은 char 배열도 가능하며 */
fw.write(new char[] {'a', 'p', 'p', 'l', 'e'});
/* 문자열도 가능하다. */
fw.write("우리나라 대한민국");
// 이어쓰는 상황이므로 새로고침시 같은 내용이 한번 더 출력된다.
// 출력 : aaaaAapple우리나라 대한민국
} catch (IOException e) {
e.printStackTrace();
} finally {
/* 1 바이트가 아닌 데이터를 다룰 때는 내부적으로
* 데이터를 쌓아서 다 차면 내보내기 때문에 의도한다면
* 자체적으로 닫아서 내보내기 해주어야 한다.
* 그게 flush와 close이다. */
try {
fw.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
FileInputStream
파일로부터 바이트 단위로 읽을 때 사용하며, 그림, 오디오,비디오,텍스트 파일 등 모든 종류의 파일 읽기 가능
InputStream의 하위 클래스로 InputStream의 메소드를 그대로 사용 가능
FileInputStream 인스턴스 생성
FileInputStream객체가 생성될 때 파일과 직접 연결
만약 파일이 존재하지 않으면 FileNotFoundException이 발생하므로 예외처리 필수
FileInputStream fis = new FileInputStream("C:/data/test.txt");
FileReader
텍스트 파일로부터 Byte 단위가 아닌 character 단위로 읽어 들임 (2바이트이던 3바이트이던 글자 단위로 읽어 오기 때문에 한글을 정상적으로 읽어올 수 있음)
FileInputStream과 사용하는 방법이 거의 동일
Reader의 하위 클래스로 Reader의 메소드를 그대로 사용 가능
FileReader 인스턴스 생성
1. FileReader객체가 생성될 때 파일과 직접 연결 됨 2. 만약 파일이 존재하지 않으면 FileNotFoundException이 발생하므로 예외처리 필수
FileReader fr = new FileReader("C:/data/test.txt");
FileReader fr = new FileReader(new File("C:/data/test.txt"));
FileOutputStream
파일로부터 바이트 단위로 출력할 때 사용하며, 그림, 오디오,비디오,텍스트 파일 등 모든 종류의 파일 읽기 가능
OutputStream의 하위 클래스로 OutputStream의 메소드를 그대로 사용 가능
FileOutputStream 인스턴스 생성
FileOutputStream객체가 생성될 때 파일과 직접 연결 만약 파일이 존재하지 않으면 자동으로 생성하지만 이미 파일이 존재하는 경우 파일을 덮어쓰는 단점이 있음
FileIOutputStream fis = new FileOutputStream("C:/data/test.txt");
만일 기존 파일에 이어서 계속 추가 작성하고 싶다면 아래와 같이 작성
FileIOutputStream fis = new FileOutputStream("C:/data/test.txt", true);
FileWriter
텍스트 파일에 Byte 단위가 아닌 character 단위로 출력 (FileReader와 마찬가지로 글자 단위로 데이터를 처리)
FileOutputStream과 사용하는 방법이 거의 동일
Writer의 하위 클래스로 Writer의 메소드를 그대로 사용 가능
FileWriter 인스턴스 생성
FileWriter객체가 생성될 때 파일과 직접 연결 됨 만약 파일이 존재하지 않으면 자동으로 생성하지만 이미 파일이 존재하는 경우 파일을 덮어쓰는 단점이 있음
FileWriter fw = new FileWriter("C:/data/test.txt");
만일 기존 파일에 이어서 계속 추가 작성하고 싶다면 아래와 같이 작성
FileWriter fw = new FileWriter("C:/data/test.txt", true);
보조 스트림
스트림의 기능을 향상시키거나 새로운 기능을 추가하기 위해서 사용
보조 스트림은 실제 데이터를 주고 받는 스트림이 아니기 때문에 입출력 처리가 불가능
기반 스트림을 먼저 생성한 후 이를 이용하여 보조 스트림을 생성
보조 스트림의 종류
입출력 성능(BufferedInputStream/BufferedOutputStream)
기본 데이터 타입 출력(DataInputStream, DataOutputStream)
객체 입출력(ObjectInputStream/ObjectOutputStream) 등의 기능을 제공하는 보조스트림이 있다
EX)
FileInputStream fis = new FileInputStream("sample.txt"); //기반 스트림 생성
BufferedInputStream bis = new BufferedInputStream(fis); //보조스트림 생성
bis.read(); //보조스트림으로부터 데이터 읽어옴
