File
java.io.File 클래스
- 파일, 디렉터리(폴더) 를 관리하는 클래스
- 파일, 디렉터리를 생성/삭제가 가능
- 파일, 디렉터리의 각종 정보(이름,크기, 최종수정일 등)을 확인 할 수 있음
경로 작성방법
- 윈도우 : 백슬래시(), Java에서 백슬래시 입력하는 방법(\)
- 리눅스 : 슬래시(/)
- java.io.File 클래스에는 플랫폼에 따라서 경로구분자를 자동으로 바꿔주는 separator 필드 값이 있음
디렉터리 생성/ 삭제
mkdirs()
//디렉터리 생성/ 삭제
//경로 구분자
String sep=File.separator;
//File 객체 선언/생성
File dir= new File("C:"+sep+"storage");//C드라이브아래 stroage디렉터리
//C:\storage 디렉터리가 없으면 만들고 있으면 지우기
if(dir.exists()==false)
{
dir.mkdirs();
System.out.println(dir.getPath()+"디렉터리 생성 성공");
}
else {
dir.delete();//지금 바로 지운다
//dir.deleteOnExit(); 자바의 실행이 끝나면 지운다.
System.out.println(dir.getPath()+"디렉터리 삭제 성공");
}
}
파일 생성/삭제
createNewFile()
//파일 생성/삭제
try {
//디렉터리를 File 객체로 생성
File dir=new File("C:/storage");//Windows 플랫폼에서도 슬래시가 인식됨
if(!dir.exists())
{
dir.mkdirs();
System.out.println(dir.getPath()+"디렉터리 생성 성공");
}
//파일을 객체로 생성
File file =new File(dir,"myfile.txt");
//파일이 있으면 지우고 없으면 생성
if(file.exists())
{
file.delete();
System.out.println(file.getPath()+"파일 삭제 성공");
}
else {
file.createNewFile(); //반드시 예외처리를 해야하는 코드(Checked Exception인 IOException 발생)
System.out.println("myfile.txt 파일 생성 완료");
}
}catch (IOException e) {
e.printStackTrace();
}
파일,디렉터리 정보확인
listFiles() : 모든 File 객체를 저장한 File[] 반환
getName() : 이름 반환
getParent() : 저장된 디렉터리 반환
getPath() : getParent() + getName()
lastModified() : 최종수정일을 long 타입으로 반환
length() : 크기를 long 타입의 바이트 단위로 반환
isDirectory() : 디렉터리이면 true 반환
isFile() : 파일이면 true 반환 //디렉터리를 File 객체로 생성
File dir=new File("C:/Program Files/Java/jdk-11");
//디렉터리에 있는 모든 File 객체(파일, 디렉터리) 가져오기
File[] files=dir.listFiles();
//디렉터리에 있는 모든 파일 객체 정보 확인하기
for(int i=0;i<files.length;i++)
{
//개별 File 객체
File file=files[i];
//출력 결과를 저장할 StringBuilder 생성
StringBuilder sb= new StringBuilder();
//File 객체 이름
sb.append(String.format("%-15s",file.getName() ));
//File 객체 최종 수정일
long lastModified=file.lastModified();
String strlastModified=new SimpleDateFormat("yyyy-MM-dd a h:mm").format(lastModified);
sb.append(String.format("%-20s", strlastModified));
long size= file.isFile()?file.length():0;//파일은 바이트 단위로 저장, 디렉터리면 크기를 표시할 필요없어서0
long kbsize=(size/1024)+(size%1024!=0?1:0);
if(size!=0)
{
sb.append(String.format("%10s",kbsize+"KB"));
}
// StringBuilder 객체를 String 으로 변환
String str=sb.toString();
//출력
System.out.println(str);
}
OutputStream 클래스
java.io.OutputStream 클래스
-
바이트 기반의 출력 클래스이다.
-
출력단위
1) int
2) byte[]
FileOutputStream
//디렉터리를 File 객체로 만들기
File dir=new File("C:storage");
if(!dir.exists())
{
dir.mkdirs();
System.out.println(dir.getPath()+"디렉터리가 생성되었습니다.");
}
//파일 객체로 만들기
File file=new File(dir,"ex01.dat");
//파일 출력 스트림 선언
FileOutputStream fout=null;
try {
//파일 출력 스트림 생성
//1.생성모드: 언제나 새로 만든다(덮어쓰기) new FileOutputStream(file)
//2. 추가모드: 새로만들거나. 기존 파일에 추가한다. new FileOutputStream(file,true)
fout= new FileOutputStream(file);
int c='A';
String s="pple";
byte[] b= s.getBytes();// byte[] : String 을 byte[]로 변환
//출력
fout.write(c);
fout.write(b);
}catch (IOException e) {
e.printStackTrace();
}finally {
try {
if(fout !=null)
{
fout.close();//출력스트림은 반드시 닫아줘야함.(반드시 예외처리가 필요한 코드)
}
}catch (IOException e) {
e.printStackTrace();
}
}
//디렉토리 파일객체로 만들기
File dir= new File("C:/storage");
if(!dir.exists())
{
dir.mkdirs();
System.out.println(dir.getPath()+"디렉토리가 생성됐습니다");
}
//파일을 파일객체로 만들기
File file =new File(dir,"ex02.dat");
//파일 스트림 선언
FileOutputStream fout=null;
try {
//파일 스트림 생성(반드시 예외처리가 필요)
fout=new FileOutputStream(file);
String s="파일스트림생성";
byte[]b=s.getBytes("UTF-8"); //String 을 byte[]로 변환
//출력
fout.write(b);
}
catch (IOException e) {
e.printStackTrace();
}finally {
try {
if(fout!=null)
{
fout.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}java.io.DataOutputStream 클래스
1.int,double,Strng 등의 변수를 그대로 출력하는 출력스트림이다.
2.보조 스트림이므로 메인스트림과 함께 사용한다.
//디렉토리 File 객체로 만들기
File dir =new File("C:/storage");
if(!dir.exists()) {
dir.mkdirs();
}
//파일을 File 객체로 만들기
File file =new File(dir,"ex04.dat");
//데이터출력스트림 선언
DataOutputStream dout=null;
try {
//데이터출력스트림 생성(반드시 예외처리 필요)
dout=new DataOutputStream(new FileOutputStream(file));
//출력할 데이터 (파일로 보낼 데이터)
String name="tom";
int age=50;
double height=180.5;
String school="가산대학교";
//출력(파일로 데이터 보내기)
dout.writeChars(name);// dout.writeChar('t'), dout.writeChar('o'), dout.writeChar('m')
dout.writeInt(age);
dout.writeDouble(height);
dout.writeUTF(school);
System.out.println(file.getPath()+"파일크기:"+file.length()+"바이트"
);
}catch (IOException e) {
}finally {
try {
if(dout!=null)
{
dout.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
java.io.ObjectOutputStream 클래스
1.객체를 그대로 출력하는 출력스트림이다.
2. 직렬화(Serializable)된 객체를 보낼 수 있다.
3. 보조스트림이므로 메인스트림과 함께 사용한다.
직렬화(Serializable) 처리하기
1. java.io.Serializable 인터페이스를 구현 (implements) 한다.
2. long serialVersionUID 필드 값을 생성(generate)한다.
// 디렉터리를 File 객체로 만들기
File dir = new File("C:/storage");
if(!dir.exists()) {
dir.mkdirs();
}
// 파일을 File 객체로 만들기
File file = new File(dir, "ex05.dat");
// 객체출력스트림 선언
ObjectOutputStream oout = null;
try {
// 객체출력스트림 생성 (반드시 예외 처리가 필요한 코드)
oout = new ObjectOutputStream(new FileOutputStream(file));
// 출력할 데이터(파일로 보낼 데이터)
String name = "tom";
int age = 50;
double height = 180.5;
String school = "가산대학교";
Student student = new Student(name, age, height, school);
// 출력(파일로 데이터 보내기)
oout.writeObject(student);
System.out.println(file.getPath() + " 파일 크기 : " + file.length() + "바이트");
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
if(oout != null) {
oout.close(); // 출력스트림은 반드시 닫아줘야 함 (반드시 예외 처리가 필요한 코드)
}
} catch (IOException e) {
e.printStackTrace();
}
}
java.io.InputStream 클래스
- 바이트 기반의 입력스트림이다.
- 입력 단위
1) int
2) byte[]
int read() 메소드
1. 1개 데이터를 읽어서 반환한다.
2. 읽은 내용이 없으면 -1을 반환한다.
1)int
// 디렉터리를 File 객체로 만들기
File dir = new File("C:/storage");
// 파일을 File 객체로 만들기
File file = new File(dir, "ex01.dat");
// 파일입력스트림 선언
FileInputStream fin = null;
try {
// 파일입력스트림 생성 (반드시 예외 처리 필요, 파일이 없으면 예외 발생)
fin = new FileInputStream(file);
// 입력된 데이터 저장 변수
int c = 0;
// 입력된 데이터를 누적할 StringBuilder 생성
StringBuilder sb = new StringBuilder();
// int read() 메소드
// 1. 1개 데이터를 읽어서 반환한다.
// 2. 읽은 내용이 없으면 -1을 반환한다.
// 반복문 : 읽은 내용이 -1이 아니면 계속 읽는다.
while( (c = fin.read()) != -1 ) {
sb.append((char)c);
}
// 결과 확인
System.out.println(sb.toString());
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
if(fin != null) {
fin.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}2)byte[]
// 바이트 기반 스트림은 원래 한글 처리가 안 된다.
// 디렉터리를 File 객체로 만들기
File dir = new File("C:/storage");
// 파일을 File 객체로 만들기
File file = new File(dir, "ex02.dat");
// 파일입력스트림 선언
FileInputStream fin = null;
try {
// 파일입력스트림 생성 (반드시 예외 처리 필요, 파일이 없으면 예외 발생)
fin = new FileInputStream(file);
// 입력된 데이터 저장 변수
byte[] b = new byte[4]; // 임의로 크기 설정(최대 4바이트 입력 가능)
// 실제로 읽은 바이트 수 저장 변수
int readByte = 0;
// 입력된 데이터를 누적할 StringBuilder 생성
StringBuilder sb = new StringBuilder();
// int read(byte[] b) 메소드
// 1. 파라미터로 전달된 byte[] b에 읽은 내용을 저장한다.
// 2. 실제로 읽은 바이트 수를 반환한다.
// 3. 읽은 내용이 없으면 -1을 반환한다.
// 반복문 : read()의 반환값이 -1이 아니면 계속 읽는다.
while( (readByte = fin.read(b)) != -1 ) {
sb.append(new String(b, 0, readByte)); // 배열 b의 인덱스 0부터 readByte개 데이터를 String으로 변환한다.
}
/*
* 15바이트 "abcdefghijklmno"를 4바이트씩 읽는 방식
*
* byte[] b readByte new String(b, 0, readByte)
*
* 1차 Loop
* ┌---------------┐
* │ a | b | c | d │ 4 배열 b의 인덱스 0부터 4개 데이터를 String으로 변환한다.
* └---------------┘
* 2차 Loop
* ┌---------------┐
* │ e | f | g | h │ 4 배열 b의 인덱스 0부터 4개 데이터를 String으로 변환한다.
* └---------------┘
* 3차 Loop
* ┌---------------┐
* │ i | j | k | l │ 4 배열 b의 인덱스 0부터 4개 데이터를 String으로 변환한다.
* └---------------┘
* 4차 Loop
* ┌---------------┐
* │ m | n | o | l │ 3 배열 b의 인덱스 0부터 3개 데이터를 String으로 변환한다.
* └---------------┘
* ↑
* └---- 이전 Loop에서 읽은 데이터이므로 사용하면 안 된다.
*/
// 결과 확인
System.out.println(sb.toString());
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
if(fin != null) {
fin.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
java.io.BufferedInputStream 클래스
-
내부 버퍼를 가지고 있는 입력스트림이다.
-
많은 데이터를 한 번에 입력받기 때문에 속도 향상을 위해서 사용한다.
-
보조스트림이므로 메인스트림과 함께 사용한다.
// 디렉터리를 File 객체로 만들기 File dir = new File("C:/storage"); // 파일을 File 객체로 만들기 File file = new File(dir, "ex03.dat"); // 버퍼입력스트림 선언 BufferedInputStream bin = null; try { // 버퍼입력스트림 생성 (반드시 예외 처리 필요, 파일이 없으면 예외 발생) bin = new BufferedInputStream(new FileInputStream(file)); // 입력된 데이터 저장 변수 byte[] b = new byte[4]; // 임의로 크기 설정(최대 4바이트 입력 가능) // 실제로 읽은 바이트 수 저장 변수 int readByte = 0; // 입력된 데이터를 누적할 StringBuilder 생성 StringBuilder sb = new StringBuilder(); // int read(byte[] b) 메소드 // 1. 파라미터로 전달된 byte[] b에 읽은 내용을 저장한다. // 2. 실제로 읽은 바이트 수를 반환한다. // 3. 읽은 내용이 없으면 -1을 반환한다. // 반복문 : read()의 반환값이 -1이 아니면 계속 읽는다. while( (readByte = bin.read(b)) != -1 ) { sb.append(new String(b, 0, readByte)); // 배열 b의 인덱스 0부터 readByte개 데이터를 String으로 변환한다. } // 결과 확인 System.out.println(sb.toString()); } catch (IOException e) { e.printStackTrace(); } finally { try { if(bin != null) { bin.close(); } } catch (IOException e) { e.printStackTrace(); } }
java.io.DataInputStream 클래스
- int, double, String 등의 변수를 그대로 입력받는 입력스트림이다.
- 보조스트림이므로 메인스트림과 함께 사용한다.
DataOutputStream과 DataInputStream을 사용하면
바이트 기반 입출력에서도 한글 처리가 가능하다.(writeUTF, readUTF 메소드 이용)
// 디렉터리를 File 객체로 만들기
File dir = new File("C:/storage");
// 파일을 File 객체로 만들기
File file = new File(dir, "ex04.dat");
// 데이터입력스트림 선언
DataInputStream din = null;
try {
// 데이터입력스트림 생성 (반드시 예외 처리 필요, 파일이 없으면 예외 발생)
din = new DataInputStream(new FileInputStream(file));
// 순서대로 입력 받기
char ch1 = din.readChar(); // 't'
char ch2 = din.readChar(); // 'o'
char ch3 = din.readChar(); // 'm'
int age = din.readInt(); // 50
double height = din.readDouble(); // 180.5
String school = din.readUTF(); // 가산대학교
// 결과 확인
System.out.println("" + ch1 + ch2 + ch3);
System.out.println(age);
System.out.println(height);
System.out.println(school);
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
if(din != null) {
din.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}java.io.ObjectInputStream 클래스
- 객체를 그대로 입력 받는 입력스트림이다.
- 직렬화(Serializable)된 객체를 입력 받을 수 있다.
- 보조스트림이므로 메인스트림과 함께 사용한다.
// 디렉터리를 File 객체로 만들기
File dir = new File("C:/storage");
// 파일을 File 객체로 만들기
File file = new File(dir, "ex05.dat");
// 객체입력스트림 선언
ObjectInputStream oin = null;
try {
// 객체입력스트림 생성 (반드시 예외 처리 필요, 파일이 없으면 예외 발생)
oin = new ObjectInputStream(new FileInputStream(file));
// 객체 순서대로 입력 받기
Student s = (Student)oin.readObject();
// 결과 확인
System.out.println(s);
} catch (IOException | ClassNotFoundException e) {
e.printStackTrace();
} finally {
try {
if(oin != null) {
oin.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
Writer
java.io.Writer 클래스
- 문자 기반의 출력스트림이다.
- 출력 단위
1) int
2) char[]
3) String1)int// 디렉터리를 File 객체로 만들기 File dir = new File("C:/storage"); if(dir.exists() == false) { dir.mkdirs(); } // 파일을 File 객체로 만들기 File file = new File(dir, "ex01.txt"); // 파일출력스트림 선언 FileWriter fw = null; try { // 파일출력스트림 생성(반드시 예외 처리가 필요한 코드) // 1. 생성모드 : 언제나 새로 만든다.(덮어쓰기) new FileWriter(file) // 2. 추가모드 : 새로 만들거나, 기존 파일에 추가한다. new FileWriter(file, true) fw = new FileWriter(file); // 출력할 데이터(파일로 보낼 데이터) int c = 'H'; char[] cbuf = {'e', 'l', 'l', 'o'}; String str = " world"; // 출력(파일로 데이터 보내기) fw.write(c); fw.write(cbuf); fw.write(str); // 메시지 System.out.println(file.getPath() + " 파일 생성 완료"); } catch (IOException e) { e.printStackTrace(); } finally { try { if(fw != null) { fw.close(); } } catch (IOException e) { e.printStackTrace(); } }
java.io.BufferedWriter 클래스
-
내부 버퍼를 가지고 있는 출력스트림이다.
-
많은 데이터를 한 번에 출력하기 때문에 속도 향상을 위해서 사용한다.
-
보조스트림이므로 메인스트림과 함께 사용한다.
2)char[]
// 디렉터리를 File 객체로 만들기 File dir = new File("C:/storage"); if(dir.exists() == false) { dir.mkdirs(); } // 파일을 File 객체로 만들기 File file = new File(dir, "ex02.txt"); // 버퍼출력스트림 선언 BufferedWriter bw = null; try { // 버퍼출력스트림 생성(반드시 예외 처리가 필요한 코드) bw = new BufferedWriter(new FileWriter(file)); // 출력할 데이터(파일로 보낼 데이터) String str1 = "Hello"; String str2 = "world"; // 출력(파일로 데이터 보내기) bw.write(str1, 0, 4); // 문자열 str1의 인덱스 0부터 4글자만 출력 bw.newLine(); // 줄 바꿈(bw.write("\n")과 동일하다.) BufferedWriter 클래스의 전용 메소드이다. bw.write(str2); // 메시지 System.out.println(file.getPath() + " 파일 생성 완료"); } catch (IOException e) { e.printStackTrace(); } finally { try { if(bw != null) { bw.close(); } } catch (IOException e) { e.printStackTrace(); } }
java.io.PrintWriter 클래스
-
print() 메소드와 println() 메소드를 지원하는 출력스트림이다.
-
println() 메소드를 사용하면 자동으로 줄 바꿈이 처리된다.
-
서버가 클라이언트에게 데이터를 전송할 때 사용하는 기본 Writer이다.
3)String
// 디렉터리를 File 객체로 만들기 File dir = new File("C:/storage"); if(dir.exists() == false) { dir.mkdirs(); } // 파일을 File 객체로 만들기 File file = new File(dir, "ex03.txt"); // PrintWriter 선언 PrintWriter out = null; try { // PrintWriter 생성(반드시 예외 처리가 필요한 코드) out = new PrintWriter(file); // 출력할 데이터(파일로 보낼 데이터) String str1 = "Hello"; String str2 = "world"; // 출력(파일로 데이터 보내기) out.println(str1); out.println(str2); // 메시지 System.out.println(file.getPath() + " 파일 생성 완료"); } catch (IOException e) { e.printStackTrace(); } finally { if(out != null) { out.close(); // try 체크를 하지 않는 PrintWriter 클래스의 close() 메소드 } }
Reader
java.io.Reader 클래스
-
문자 기반의 입력스트림이다.
-
입력 단위
1) int
2) char[]
3) String1)int
// 디렉터리를 File 객체로 만들기 File dir = new File("C:/storage"); // 파일을 File 객체로 만들기 File file = new File(dir, "ex01.txt"); // 파일입력스트림 선언 FileReader fr = null; try { // 파일입력스트림 생성(반드시 예외 처리 필요, 파일이 없으면 FileNotFoundException 발생) fr = new FileReader(file); // 입력된 문자 저장 변수 int ch = 0; // 입력된 문자를 누적할 StringBuffer 생성 StringBuffer sb = new StringBuffer(); // read() 메소드 // 1. 1개 문자를 읽어서 반환한다. // 2. 읽은 문자가 없으면 -1을 반환한다. // 반복문 : 읽은 문자가 -1이 아니면 계속 읽는다. while((ch = fr.read()) != -1) { sb.append((char)ch); } // 결과 확인 System.out.println(sb.toString()); } catch (IOException e) { e.printStackTrace(); } finally { try { if(fr != null) { fr.close(); } } catch (IOException e) { e.printStackTrace(); } }2)char[]
// 디렉터리를 File 객체로 만들기 File dir = new File("C:/storage"); // 파일을 File 객체로 만들기 File file = new File(dir, "ex02.txt"); // 파일입력스트림 선언 FileReader fr = null; try { // 파일입력스트림 생성(반드시 예외 처리 필요, 파일이 없으면 FileNotFoundException 발생) fr = new FileReader(file); // 입력된 문자 저장 배열 char[] cbuf = new char[2]; // 실제로 읽은 글자 수 저장 변수 int readChar = 0; // 입력된 문자를 누적할 StringBuffer 생성 StringBuffer sb = new StringBuffer(); // int read(char[] cbuf) 메소드 // 1. 파라미터로 전달된 char[] cbuf에 읽은 문자를 저장한다. // 2. 실제로 읽은 글자 수를 반환한다. // 3. 읽은 문자가 없으면 -1을 반환한다. // 반복문 : read()의 반환값이 -1이 아니면 계속 읽는다. while((readChar = fr.read(cbuf)) != -1) { sb.append(cbuf, 0, readChar); // 배열 cbuf의 인덱스 0부터 readChar개 문자를 sb에 추가한다. } // 결과 확인 System.out.println(sb.toString()); } catch (IOException e) { e.printStackTrace(); } finally { try { if(fr != null) { fr.close(); } } catch (IOException e) { e.printStackTrace(); } }3)String
java.io.BufferedReader 클래스
-
내부 버퍼를 가지고 있는 입력스트림이다.
-
많은 데이터를 한 번에 입력받기 때문에 속도 향상을 위해서 사용한다.
-
보조스트림이므로 메인스트림과 함께 사용한다.
// 디렉터리를 File 객체로 만들기 File dir = new File("C:/storage"); // 파일을 File 객체로 만들기 File file = new File(dir, "ex03.txt"); // 버퍼입력스트림 선언 BufferedReader br = null; try { // 버퍼입력스트림 생성(반드시 예외 처리 필요, 파일이 없으면 FileNotFoundException 발생) br = new BufferedReader(new FileReader(file)); // 입력된 문자열 저장 변수 String line = null; // 입력된 문자를 누적할 StringBuffer 생성 StringBuffer sb = new StringBuffer(); // String readLine() 메소드 // 1. 한 줄 전체를 반환한다. // 2. 읽은 문자가 없으면 null을 반환한다. // 반복문 : readLine()의 반환값이 null이 아니면 계속 읽는다. while((line = br.readLine()) != null) { sb.append(line + "\n"); // 읽은 라인에 줄 바꿈(\n)은 포함되어 있지 않다. } // 결과 확인 System.out.println(sb.toString()); } catch (IOException e) { e.printStackTrace(); } finally { try { if(br != null) { br.close(); } } catch (IOException e) { e.printStackTrace(); } }바이트 출력스트림으로 보낸 문자를 바이트 입력스트림으로 읽기(한글 실패)
바이트 출력스트림으로 보낸 문자를 문자 입력스트림으로 읽기(한글 성공)// 1단계. 바이트 출력스트림으로 문자 보내기 File dir = new File("C:/storage"); if(dir.exists() == false) { dir.mkdirs(); } File file = new File(dir, "server.dat"); BufferedOutputStream bout = null; try { bout = new BufferedOutputStream(new FileOutputStream(file)); String s1 = "안녕하세요"; String s2 = "Hello"; bout.write(s1.getBytes("UTF-8")); bout.write(s2.getBytes("UTF-8")); bout.close(); } catch (IOException e) { e.printStackTrace(); } // 2단계. 문자 입력스트림으로 읽기 /* * java.io.InputStreamReader 클래스 * 1. Reader 클래스를 상속 받는 클래스이다. (문자 입력스트림이다.) * 2. InputStream(바이트 입력스트림)을 받아서 Reader(문자 입력스트림)으로 변환한다. */ BufferedReader br = null; try { br = new BufferedReader(new InputStreamReader(new FileInputStream(file))); String line = null; StringBuffer sb = new StringBuffer(); while((line = br.readLine()) != null) { sb.append(line + "\n"); } System.out.println(sb.toString()); br.close(); } catch (IOException e) { e.printStackTrace(); }
try - catch - resources문
-
사용한 자원(대표적으로 입출력 스트림)을 자동으로 close 해 주는 try문이다.
-
형식
try (입출력 스트림 생성) { 코드 } catch(Exception e) { e.printStackTrace(); }예시)
// 디렉터리를 File 객체로 생성 File dir = new File("C:/storage"); if(dir.exists() == false) { dir.mkdirs(); } // 파일을 File 객체로 생성 File file = new File(dir, "ex01.txt"); // try 블록에서 출력스트림 생성하기 try (BufferedWriter bw = new BufferedWriter(new FileWriter(file, true))) { // 추가모드 // 출력할 데이터 String str1 = "안녕하세요"; String str2 = "반갑습니다"; // 출력 (추가모드이므로 기존 파일 뒤에 추가된다.) bw.newLine(); bw.write(str1); bw.newLine(); bw.write(str2); System.out.println(file.getPath() + " 파일에 데이터 추가 완료"); } catch (IOException e) { e.printStackTrace(); } }관련 예제
졸려요