[JAVA] 예외처리, 입출력 스트림_Day12

1. 예외처리

프포그램이 런타임에 중단되는 것을 예방하기 위한 코드

자바에서 예외가 발생하면 자바 시스템은 예외가 발생한 프로그램에 예외 객체를 던진다

프로그램에 예외 객체를 맞으면 기본 동작이 죽는다

프로그램이 예외 객체를 맞아서 중단되지 않고 try-catch블록으로 발생한 예외객체를 잡아 예외를 처리할 수 있도록 하는 방법이 예외처리다

 

1) try-catch문

 

      try{ 예외 발생이 예상되는/ 강제 예외처리 요구 코드

           } catch (예외객체1) {                                   // try블록에서 발생한 예외 객체 중 타입이 일치하는 것만 받음

                예외처리 코드

                }catch (예외객체2) {

                    예외처리 코드

                    } catch (Exception e) {                        // 모든 예외를 받을 수 있음. 맨 끝에 위치. 위 catch블록들에서 받지 못한 예외를 여기서 처리

                        예외처리 코드

                         } finally{                                          // 정상실행, 예외처리, 중단되더라도 꼭 실행

                            }                                                   // 위 어느 케이스에나 무조건 실행되는 블록

                                                                                // 자원 해제 코드

 

catch블록은 try블록에서 발생한 예외 객체와 타입이 같아야 그 예외객체를 받아서 처리할 수 있다.

그러므로 catch블록은 타입별로 여러개 작성이 가능하다.

 

예제 1)

package 예외처리;
 
import java.io.IOException;
 
public class Ex1 {
 
    public static void main(String[] args) {
        // TODO Auto-generated method stub
 
        System.out.println("프로그램 시작");
        
        try {
            String s = null;
            s.charAt(0);                       // NullPointerException
        int x = 3/0;                           //ArithmeticException
        } catch(ArithmeticException e) {
            e.printStackTrace();
        } catch(NullPointerException e) {
            e.printStackTrace();
        }
        System.out.println("프로그램 종료");
        
        try {
            int ch = System.in.read();
        } catch (IOException e) { 
            e.printStackTrace();               // 예외 메세지 상세 출력
        }
    }
 
}

package 예외처리;
 
public class 예외처리기본 {
 
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int[] arr = {1, 2, 3};
        String s = null;
        try {
            System.out.println("실행1");
            for(int i = 0; i < arr.length+1; i++) {      // 일부러 length+1함(오류)
                System.out.println(arr[i]);              //catch문으로 점프.
            }
            System.out.println("실행2");   // 실행x
            s.charAt(0);
            System.out.println("실행3");   // 실행x
        }catch(NullPointerException e) {
                System.out.println(e);
        }catch(ArrayIndexOutOfBoundsException e) {
            System.out.println(e);
        }catch(Exception e) {
            System.out.println(e);
        } finally {
            System.out.println("무조건 실행되는 finally 불록");
        }
    }
 
}}

 

2) throws

예외처리 미루기

이 메서드를 호출하는 쪽에서 예외처리를 하도록 미룸.

 

 

예제)

package 예외처리;
 
import java.io.IOException;
 
class Test{
    public void f1() throws IOException {    //IOException 예외처리를 미룸. 이 메서드를 호출하는 쪽으로 미룸
        int ch = System.in.read();
    }
}
 
public class 예외처리미루기 {
 
    public static void main(String[] args) {
        Test t = new Test();
        try {
            t.f1();                             // 미뤘던 예외처리 처리
        } catch (IOException e) {
            e.printStackTrace();
        }                             // 미뤘던 예외처리 처리하거나 또 미룰 수 있음
    }
 
}

 

3) throw

예외 발생시킴.예외 객체 직접 던짐

내 프로그램 내에서 특수한 예외 상황을 구현하고자 할때 직접 예외 발생시킴

throw 예외객체;

 

예제)

package 예외처리;
 
class Test2 {
    private int[] datas;
    private int cnt;
 
    public Test2() {
        datas = new int[3];
    }
 
    public void add(int x) throws Exception { // 예외 미루기
        if (cnt == datas.length) {
            throw new Exception("배열참"); // 예외 발생. 예외 객체 생성시 생성자에 파라미터로 문자열 넣으면 예외 메세지로 사용됨
        }
 
        datas[cnt++] = x;
    }
 
    public void printArr() {
        for (int i = 0; i < cnt; i++) {
            System.out.println(datas[i]);
        }
    }
}
    public class 예외던지기 {
 
        public static void main(String[] args) {
            Test2 t = new Test2();
 
            for (int i = 0; i < 4; i++) {  // 배열 크기 3인데 오류발생하기 위해 4로 설정
                try {
                    t.add(i);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
            t.printArr();
        }
    }

 

4)사용자 정의 예외 클래스

Exception을 상속받아서 예외 종류별로 만든다

 

예제)

package 예외처리;
 
//사용자 정의 예외 클래스는 Exception을 상속받아 정의
class MyException extends Exception{
    public MyException() {
    }
    
    //생성자 파라미터로 받은 문자열 상위 클래스 생성자에 전달
    public MyException(String s) {
        super(s);
    }
}
 
 
 
class Test2 {
    private int[] datas;
    private int cnt;
 
    public Test2() {
        datas = new int[3];
    }
 
    public void add(int x) throws MyException { // 예외 미루기
        if (cnt == datas.length) {
            throw new MyException("배열참"); // 예외 발생. 예외 객체 생성시 생성자에 파라미터로 문자열 넣으면 예외 메세지로 사용됨
        }
 
        datas[cnt++] = x;
    }
 
    public void printArr() {
        for (int i = 0; i < cnt; i++) {
            System.out.println(datas[i]);
        }
    }
}
    public class 예외던지기 {
 
        public static void main(String[] args) {
            Test2 t = new Test2();
 
            for (int i = 0; i < 4; i++) {  // 배열 크기 3인데 오류발생하기 위해 4로 설정
                try {
                    t.add(i);
                } catch (MyException e) {
                    e.printStackTrace();
                }
            }
            t.printArr();
        }
    }
 

---

 

2. 입출력 스트림

입력 스트림 : 밖에서 프로그램쪽으로 데이터의 흐름을 소프트웨어로 구현한 모듈

출력 스트림 : 프로그램에서 밖으로 데이터의 흐름을 소프트웨어로 구현한 모듈

 

표준 입출력

   ㆍSystem.in : 표준입력. System.in.read() : 키보드 입력

   ㆍSystem.out : 표준출력. System.out.println(): 콘솔 출력

   ㆍSystem.err : 표준에러. 

 

자바스트림

   ㆍ입/출력

   ㆍ바이트 스트림 : 한 바이트식 읽고 씀. 그림, 멀티미디어, 문자 등 모든 종류의 데이터를 입출력할 때 사용

 

             - InputStream : FileInputStream(파일에서 1바이트씩 읽는 스트림)

                int read() : 1 바이트 읽어서 int 타입으로 반환

                int read( byte[] ) : 파라미터로 넣은 배열 크기만큼 읽어서 배열에 저장. 반환값은 읽은 바이트 수를 반환.

                int read( byte[], offs, size ) : size만큼 읽어서 배열에 저장. 저장 시작 위치를 offs로. 반환값은 읽은 바이트 수를 반환.

 

             - OutputStream : FileOutputStream(파일에 1바이트씩 출력 스트림)

                void write(int ch) : 1 바이트(ch) 출력 

                void write( byte[] ) : 배열 크기만큼 배열요소들을 출력. 출력한 바이트 수 반환

                void write( byte[], offs, size) : byte[] 배열에서 offs위치부터 size크기만큼을 출력. 출력한 바이트 수 반환

 

 

   ㆍ문자 스트림 : 한 문자씩(2byte) 읽고 씀. 문자만 입출력할 때 사용

 

             - Reader : FileReader(파일에서 2바이트씩 읽는 스트림)

                int read() : 2 바이트 읽어서 int 타입으로 반환

                int read( char[] ) : 파라미터로 넣은 배열 크기만큼 읽어서 배열에 저장. 반환값은 읽은 문자 수를 반환.

                int read( char[], offs, size ) : size만큼 읽어서 배열에 저장. 저장 시작 위치를 offs로. 반환값은 읽은 문자 수를 반환.

 

             - Writer :  FileWriter(파일에 2바이트씩 출력 스트림)

                void write(int ch) : 문자 한개 출력

                void write( char[] ) : 배열 크기만큼 배열요소들을 출력. 출력한 문자 수 반환

                void write( char[], offs, size) : byte[] 배열에서 offs위치부터 size크기만큼을 출력. 출력한 문자 수 반환

                void write(String str) : 문자열(String) 출력

 

 

텍스트 파일을 다루는 경우에는 FileInputStream / FileOutputStream 보다 문자기반의 스트림인 FileReader / FileWriter를 사용하는 것이 좋다.

 

---

바이트 스트림

 

int read() 예제)

17줄 : while ((ch = fi.read()) != -1)  => int read() 는 더이상 읽을 값이 없으면  -1 을 반환한다.

package 입출력스트림;
 
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
 
public class FileInputStreamTest {
 
    public static void main(String[] args) {
        try {
            //FileInputStream 객체 생성
            //생성자에 읽을 파일의 경로
            //생성자에 지정한 경로의 파일에서 한 바이트식 읽을 수 있는 스트림 생성
            FileInputStream fi = new FileInputStream("src/입출력스트림/files/a.txt");
            int ch;
            
            while ((ch = fi.read())!= -1) {      //EOF(End Of File) : -1
            System.out.print((char)ch);    
            }
            fi.close(); // 스트림 닫음
            
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
 
    }
 
}
 
 

 

int read( byte[] ) 예제)

17줄 : while ((ch = fi.read()) != -1)  => int read(byte[]) 는 더이상 읽을 값이 없으면  -1 을 반환한다.

 

 

 int write( ),  int write( byte[] ) 예제)

package 입출력스트림;
 
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
 
public class FileOutputStreamTest {
 
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        try {
            // 1바이트씩 파일에 출력하는 스트림
            // 쓰기용 파일은 있으면 그 파일에 덮어쓰기. 없으면 자동으로 생성하여 출력
            FileOutputStream fo = new FileOutputStream("src/입출력스트림/files/c.txt");
            
            byte[] buf = "hello java stream".getBytes();  //getBytes() : 문자열을 바이트배열로 반환
//            for(int i = 0; i< buf.length; i++) {
//                fo.write(buf[i]);  // for문으로 한글자 한글자씩 읽기. int write()
//            }
            fo.write(buf);   // 통채로 읽기. int write(byte[]) > 더 효율적임fo.flush();
            fo.close();
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
 
}

---

문자 스트림

 

 int read( char[]) 파일 복사하기 예제1)

 

 int read( ), void write(int ch) 파일 복사하기 예제2)

package 입출력스트림;
 
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
 
public class FileCopyTest2 {
 
    
    // 더 간결하게 만든 파일 복사 코드
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        String src = "src/입출력스트림/files/a.txt";  // 원본 파일 경로
        String des = "src/입출력스트림/files/z.txt";  // 복사 파일 경로
    
        try {
            FileReader fr = new FileReader(src);   // 원본 파일에서 1문자씩 읽는 스트림 생성
            FileWriter fw = new FileWriter(des);   // 복사 파일에서 1문자씩 출력 스트림 생성
            
            int ch;
            while ((ch = fr.read()) != -1) {       // 원본 파일에서 1문자씩 읽어서 ch에 저장
                fw.write(ch);;                     // ch값을 복사 파일에 출력
            }
            
            fr.close();
            fw.close();
            
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

 

int read( )FileReader 예제)

package 입출력스트림;
 
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.util.Arrays;
 
public class FileReaderTest {
 
    public static void main(String[] args) {
        try {
            // FileReader : 파일에서 문자단위로(2바이트씩) 읽는 스트림
            FileReader fr = new FileReader("src/입출력스트림/files/a.txt");
//            int ch;
//            while((ch=fr.read())!=-1) {
//                System.out.print((char)ch);
//            }
            char[] buf = new char[10];
            int size;
            while((size = fr.read(buf)) > 0) {
                System.out.print(new String(buf));
                Arrays.fill(buf, ' ');
            }
            fr.close();
            
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
 
}

package 입출력스트림;
 
import java.io.FileWriter;
import java.io.IOException;
 
public class FileWriterTest {
 
    public static void main(String[] args) {
        try {
            //파일에 문자 단위로 출력 스트림
            FileWriter fw = new FileWriter("src/입출력스트림/files/d.txt");
            String str = "hello java FileWriter";
            for (int i = 0; i < str.length();i++) {
                fw.write(str.charAt(i));        //문자열 길이만큼 문자 한개씩 출력
            }
            fw.write("\n");
            fw.write(str);                      //String 값 하나 출력
            fw.close();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
 
}

보조스트림

 

1차 스트림(기본 스트림) : 단독으로 사용가능

2차 스트림(보조 스트림) : 꼭 기본 스트림에 연결해서 사용해야 하고 단독으로 사용 불가능

                                          기본 스트림에 기능을 추가하기 위해서 사용

                                          출력성능 향상

 

기본 스트림 + 보조 스트림 => 서로 타입이 맞아야함. 읽기끼리, 쓰기용 끼리 연결

                                                 바이트 단위끼리, 문자 단위끼리 연결

 

* buffered 보조 스트림 : 속도 빠르게

  FileInputStream + BufferedInputStream

  FileOutputStream + BufferedOutputStream

  FileReader + BufferedReader

  FileWriter + BufferedWriter

 

* 바이트로 읽을 것을 문자로 변환

* 객체 단위 읽기

* 랜덤한 위치에서 읽기 / 쓰기

 

FileInputStream fi = new FileInputStream("file path");  // 기본 스트림 생성

BufferedInputStream bi = new BufferedInputStream(fi);  //보조 스트림 생성 기본스트림과 연결

 

 

input / output / buffered  예제)

package 입출력스트림;
 
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
 
public class BufferedStreamTest {
 
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        
        try {
            //기본 스트림
            FileInputStream fi = new FileInputStream("src/입출력스트림/files/a.txt");
            //보조 스트림
            BufferedInputStream bi = new BufferedInputStream(fi); //보조 스트림 생성자에 연결할 기본 스트림 객체 전달
            
            int ch; // = String line;
            while((ch=bi.read())!=-1) { // = while((line = bi.readLIne()) != null) {
                System.out.print((char)ch); // = System.out.print(line);
            }
            bi.close(); // 보조 스트림 닫음
            fi.close(); // 기본 스트림 닫음
            
            //기본 스트림 생성
            FileOutputStream fo = new FileOutputStream("src/입출력스트림/files/b.txt");
            //보조 스트림 생성
            BufferedOutputStream bo = new BufferedOutputStream(fo);
 
            for(int i = 'a'; i <= 'z'; i++) {
                bo.write(i);
            }
            bo.close();
            fo.close();
            
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }    
    }
}

 

Reader / Writer / buffered  예제)

package 입출력스트림;
 
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
 
public class BufferedReaderWriter {
 
    public static void main(String[] args) {
        // TODO Auto-generated method stub
 
        try {
            FileReader fr = new FileReader("src/입출력스트림/files/a.txt");
            BufferedReader br = new BufferedReader(fr); 
            
            int ch;
            while((ch = br.read())!=-1) {
                System.out.print((char)ch);
            }
            br.close();
            fr.close();
            
            FileWriter fw = new FileWriter("src/입출력스트림/files/b.txt");
            BufferedWriter bw = new BufferedWriter(fw);
            
            for(int i = 'A'; i <= 'Z'; i++) {
                bw.write((char)i);
            }
            bw.close();
            fw.close();
            
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
 
}

예제)

package 입출력스트림;
 
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
 
public class InputStreamReaderTest {
 
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int ch;                                // ↑ 한글 깨지는 것을 막기위해                       
        try {
            while((ch = br.read()) != '\n') {
                System.out.print((char)ch);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
     }
}

 

*객체 단위로 읽는 보조 스트림

 

ObjectInputStream / ObjectOutputStream 객체 단위로 읽고 씀

 

직렬화 : 객체 전달 시 참조값을 전달하는 것이 아니라 멤버변수 하나하나를 줄세워서 전달

              구현은 Serializable 인터페이스 상속받는 것으로 함.

 

예제1)

package 입출력스트림;
 
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
 
class Member implements Serializable{  // 직렬화
    String name;
    String tel;
    public Member(String name, String tel) {
        super();
        this.name = name;
        this.tel = tel;
    }
    @Override
    public String toString() {
        return "Member [name=" + name + ", tel=" + tel + "]";
    }
    
}
public class ObjInputOutputStream {
 
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Member m1 = new Member("aaa","111");
        Member m2 = null;                                // 파일에서 읽은 객체 저장할 변수
        String path = "src/입출력스트림/files/data.dat";
        try {
            // 파일에 바이트 단위로 쓰는 스트림 생성
            FileOutputStream fo = new FileOutputStream(path);
            // 위 기본 스트림에 객체 단위로 쓰는 보조 스트림을 생성해서 연결
            ObjectOutputStream oo = new ObjectOutputStream(fo);
            // writeObject() 객체 한개 출력
            oo.writeObject(m1);
            // 스트림 닫음
            oo.close();
            fo.close();
            
            // 파일에서 바이트 단위로 읽는 기본 스트림 생성
            FileInputStream fi = new FileInputStream(path);
            // 객체 단위로 읽는 보조 스트림을 생성해서 위 기본스트림(fi)와 연결
            ObjectInputStream oi = new ObjectInputStream(fi);
            // readObject() : 객체 한개를 읽어서 Object 타입으로 반환. 다운캐스팅 필요
            m2 = (Member) oi.readObject();
            System.out.println(m2);
            oi.close();
            fi.close();
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
 
}

 

예제 2)

package 입출력스트림;
 
import java.io.EOFException;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.util.ArrayList;
 
 
public class ObjInputOutStream2 {
 
    // ArrayList에 Member 객체 3개 저장
    // 리스트의 모든 객체를 파일에 저장
    // 파이르이 모든 객체를 읽어서 출력
    
    public static void main(String[] args) {
        // TODO Auto-generated method stub
 
        //리스트 생성하여 Member 객체 3개 저장
        ArrayList <Member> list = new ArrayList<>();
        list.add(new Member("aaa","010"));
        list.add(new Member("bbb","011"));
        list.add(new Member("ccc","016"));
        
        //읽고 쓸 파일의 경로
        String path = "src/입출력스트림/files/data2.txt";
        
        try {
        // 객체 단위로 출력하는 스트림 생성
        ObjectOutputStream oo = new ObjectOutputStream(new FileOutputStream(path));
        
        // 리스트에서 요소(Member 객체)를 하나씩 꺼내서
        for(Member m : list) {
            oo.writeObject(m); // 객체단위로 파일 출력
        }oo.writeObject(null); //끝을 인식시키기 위해 null저장
        oo.close();
        
        // 객체 단위로 읽는 스트림 생성
        ObjectInputStream oi = new ObjectInputStream(new FileInputStream(path));
        
        Member m = null;
        //파일에서 객체를 하나식 읽어서 변수 m에 저장
        while((m = (Member) oi.readObject()) != null) {
            System.out.println(m);
        }
        
        oi.close();
            
        }catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (EOFException e) {
            // TODO Auto-generated catch block
            System.out.println("파일 끝에 도달");
        }catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        System.out.println("프로그램 종료");
    }    
        
}

getFilePointer() : 현재 커서 위치 반환

seek(위치) : 읽고 쓸 위치 변경

예제)

package 입출력스트림;
 
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.RandomAccessFile;
 
public class RandomAccessTest {
 
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        try {
            RandomAccessFile acc = new RandomAccessFile("src/입출력스트림/files/b.txt", "r");
            byte[] buf = new byte[10];
            int size = acc.read(buf);     // read(byte[]) : 배열 크기만큼 읽음
            System.out.println(new String(buf));
            System.out.println("읽은 크기 : " + size);
            System.out.println("현재 위치 : " + acc.getFilePointer());  //getFilePointer() : 현재 커서 위치 반환
            System.out.println("현재 위치의 문자 : " + (char)acc.read());
            System.out.println("현재 위치 : " + acc.getFilePointer());
            acc.seek(acc.getFilePointer() + 5);   // seek(위치) : 읽고 쓸 위치 변경
            System.out.println("현재 위치 : " + acc.getFilePointer());
            System.out.println("현재 위치의 문자 : " + (char)acc.read());
            acc.close();
            
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

*파일제어

File클래스 : 파일에 대한 정보를 제공하고 파일을 제어할 수 있는 기능 제공

 

파일 존재 :  f.exists()
파일 절대경로 : f.getAbsolutePath()
파일명 : f.getName()
파일 크기 : f.length()  > 바이트 사이즈 크기를 변수타입 long으로 반환
파일 읽기가능 : f.canRead()
파일 쓰기가능 : f.canWrite()
파일 실행가능 : f.canExecute()
파일이냐? : f.isFile()
숨김파일이냐? : f.isHidden()

파일 생성 : createNewFile()

파일 삭제 : delete()

디렉토리 생성 : mkdir()
디렉토리 삭제 : delete()

 

// dname 디렉토리의 파일 목록 출력
File dir = new File(dname);
String[] fnames = dir.list(); // 파일 목록 읽음
for (int i = 0; i < fnames.length; i++) {
System.out.println(i + ". " + fnames[i]);
}

 

예제1)

package 입출력스트림;
 
import java.io.File;
import java.io.IOException;
 
public class FileTest {
 
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        //파라미터로 지정한 파일이 없어도 File 객체는 정상적으로 생성됨
        File f = new File("src/입출력스트림/files/a.txt");
        
        System.out.println("파일 존재 : " + f.exists());
        System.out.println("파일 절대경로 : " + f.getAbsolutePath());
        System.out.println("파일명 : " + f.getName());
        System.out.println("파일 크기 : " + f.length());
        System.out.println("파일 읽기가능 : " + f.canRead());
        System.out.println("파일 쓰기가능 : " + f.canWrite());
        System.out.println("파일 실행가능 : " + f.canExecute());
        System.out.println("파일이냐? : " + f.isFile());
        System.out.println("숨김파일이냐? : " + f.isHidden());
        
        //                                     ________현재 없는 파일
        File f2 = new File("src/입출력스트림/files/xxx.txt");
        if(f2.exists() == false) {
            try {
                f2.createNewFile(); // xxx파일 생성
                System.out.println("파일 생성됨");
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        f2.delete(); // 파일 삭제
    }
}

예제2)

package 입출력스트림;
 
import java.io.File;
 
public class DirTest {
 
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        File dir = new File("src/입출력스트림/files");
        System.out.println("디렉토리 존재 : " + dir.exists());
        System.out.println("디렉토리 맞냐? : " + dir.isDirectory());
        System.out.println("현재 작업 디렉토리 : " + dir.getAbsolutePath());
        System.out.println("파일 목록");
        String[] files = dir.list();  // dir.list() : 디렉토리에 속한 파일 목록의 파일명들
        for(String fname:files) {
            System.out.println(fname);
        }
        
        File dir2 = new File("src/입출력스트림/files/memo");
        if(dir2.exists() == false) {
            dir2.mkdir();  // 디렉토리 생성
        }
        dir2.delete(); //디렉토리 삭제
    }
}