학습 // Java // IO

업데이트 :: 2018.10.16

---

• IO package

IO package

package docs.io;

import java.io.*;

/**
 * # 스트림이란
 *
 *  스트림은 단일 방향으로 연속적으로 흘러가는 것을 말합니다.
 *  입력스트림 :: 프로그램이 데이터를 입력
 *  출력스트림 :: 프로그램이 데이터를 출력
 *
 * # 자바의입출력
 *
 *  자바는 입출력 API를 "java.io" 패키지에서 처리합니다.
 *  스트림은 크게 두 종류로 구분되고 사용하는 파일이 다릅니다.
 *      - 바이트(byte)기반 스트림
 *      - 문자(character)기반 스트림입
 *
 * */
public class Doc_IO {

    public static String BASE_FILE = System.getProperty("user.dir") + "/txt/tutorial.txt";

    public static void main(String[] args) {

        readByByte();
        writeByByte();
        readByChar();
        writeByChar();

    }

    /**
     * read() - 바이트단위 InputStream
     *
     * @date 2018.10.16
     * @author SDM
     * @version 1.0
     * */
    public static void readByByte() {

        /*
         * InputStream
         *   - FileInputStream
         *   - BufferedInputStream
         *   - DataInputStream
         * */

        try {

            /*
             * File f = new File(file);
             * InputStream is = new FileInputStream(f);
             * */
            InputStream is = new FileInputStream(BASE_FILE);

            int readByte;
            int readByteSize;
            byte[] readBytes = new byte[100];

            /*
             * ### read() => int ###
             *
             * => 1바이트를 읽고 4바이트 int로 리턴
             * */
            while((readByte = is.read()) != -1) { /**/ }

            /*
             * ### read(byte[] b) => int ###
             *
             * => 바이트 배열의 길이만큼 바이트를 읽고 배열에 저장, 그리고 읽은 바이트수 리턴
             * */
            while((readByteSize = is.read(readBytes)) != -1) { /**/ }

            /*
             * ### read(byte[] b, int off, int len) => int ###
             *
             * => 바이트 배열에 'off' 만큼 떨어진 위치에 'len' 만큼 바이트를 읽고 배열에 저장, 그리고 읽은 바이트수 리턴
             * => is.read(readBytes) == is.read(readBytes, 0, readBytes.length);
             * */
            readByteSize = is.read(readBytes, 0, 100);

            /*
             * ### close() => void ###
             *
             * => 시스템 자원해제
             * */
            is.close();

        } catch (IOException e) {
            e.printStackTrace();
        }

    }

    /**
     * write() - 바이트단위 OutputStream
     *
     * @date 2018.10.16
     * @author SDM
     * @version 1.0
     * */
    public static void writeByByte() {

        /*
         * OutputStream
         *   - FileOutputStream
         *   - PrintStream
         *   - BufferedOutputStream
         *   - DataOutputStream
         * */

        try {

            /*
             * @TIP 파일이 덮어씌어 지는게 싫다면, 2번째 매개값에 "true"를 입력해주세요.
             * OutputStream os = new FileOutputStream(file, true);
             * */
            OutputStream os = new FileOutputStream(BASE_FILE);
            byte[] data = "ABCDEF".getBytes();

            /*
             * ### write(int b) => void ###
             *
             * => 1바이트를 보냄
             * */
            for(int i=0; i<data.length; i++)
                os.write(data[i]);

            /*
             * ### write(byte[] b) => void ###
             *
             * => 바이트배열의 모든 바이트를 보냄
             * */
            os.write(data);

            /*
             * ### write(byte[] b, int off, int len) => void ###
             *
             * => 바이트배열['off'] 부터 'len' 개의 바이트를 보냄
             * */
            os.write(data, 1, 2);

            /*
             * ### flush() => void ###
             *
             * => 출력스트림은 내부에 작은 버퍼가 있어 데이터가 출력되기 전에 버퍼에 쌓았다가 순서대로 출력
             * => 버퍼에 잔류하는 모든 바이트를 출력하고 버퍼를 비움
             * */
            os.flush();

            /*
             * ### close() => void ###
             *
             * => 시스템 자원해제
             * */
            os.close();

        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * read() - 문자단위 InputStream (Reader)
     *
     * @date 2018.10.16
     * @author SDM
     * @version 1.0
     * */
    public static void readByChar(){

        /*
         * Reader
         *   - FileReader
         *   - BufferedReader
         *   - IntputReader
         * */

        try {
            Reader reader = new FileReader(BASE_FILE);

            int readChar;
            int readCharSize;
            char[] cbuf = new char[100];

            /*
             * ### read() => int ###
             *
             * => 한개의 문자를 읽고 리턴
             * */
            while((readChar = reader.read()) != -1) { /**/ }

            /*
             * ### read(char[] c) => int ###
             *
             * => 문자 배열에 읽은 문자를 저장하고, 읽은 문자수를 리턴
             * */
            while((readCharSize = reader.read(cbuf)) != -1) { /**/ }

            /*
             * ### read(char[] c, int off, int len) => int ###
             *
             * => 문자 배열의 'off' 부터 'len' 개의 문자를 저장, 읽은 문자수를 리턴
             * => reader.read(cbuf) == cbuf.read(cbuf, 0, cbuf.length);
             * */
            readCharSize = reader.read(cbuf, 0, 100);

            /*
             * ### close() => void ###
             *
             * => 시스템 자원해제
             * */
            reader.close();

        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * write() - 문자단위 OutnputStream (Writer)
     *
     * @date 2018.10.16
     * @author SDM
     * @version 1.0
     * */
    public static void writeByChar(){

        /*
        * Writer
        *   - FileWriter
        *   - BufferedWriter
        *   - PrintWriter
        *   - OutputWriter
        * */

        try {
            /*
             * @TIP 파일이 덮어씌어 지는게 싫다면, 2번째 매개값에 "true"를 입력해주세요.
             * Writer writer = new FileWriter(file, true);
             * */
            Writer writer = new FileWriter(BASE_FILE);

            String str = "Hello Java?";
            char[] data = str.toCharArray();

            /*
             * ### write(int c) => void ###
             *
             * => 주어진 한 문자를 보냄 (끝의 2바이트)
             * */
            for( int i=0; i< data.length; i++ )
                writer.write(data[i]);

            /*
             * ### write(char[] cbuf) => void ###
             *
             * => 주어진 문자 배열을 보냄
             * */
            writer.write(data);

            /*
             * ### write(char[] cbuf, int off, int len) => void => void ###
             *
             * => 문자 배열의 'off' 부터 'len' 만큼을 보냄
             * */
            writer.write(data, 1, 2);

            /*
             * ### write(Strig str) => void ###
             *
             * => 주어진 문자열을 보냄
             * */
            writer.write(str);

            /*
             * ### write(Strig str, int off, int len) => void ###
             *
             * => 문자열의 'off' 부터 'len' 길이 만큼을 보냄
             * */
            writer.write(str, 1, 3);

            /*
             * ### flush() => void ###
             *
             * => 출력스트림은 내부에 작은 버퍼가 있어 데이터가 출력되기 전에 버퍼에 쌓았다가 순서대로 출력
             * => 버퍼에 잔류하는 모든 바이트를 출력하고 버퍼를 비움
             * */
            writer.flush();

            /*
             * ### close() => void ###
             *
             * => 시스템 자원해제
             * */
            writer.close();

        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

---

Created by MoonsCoding

e-mail :: jm921106@gmail.com