자바(Java) - 입출력 스트림

입출력(I/O)?

• Input과 Output의 약자
• 컴퓨터 내부 또는 외부 장치와 프로그램 간의 데이터를 주고 받는 것
• 장치와 입출력을 위해서는 하드웨어 장치에 직접 접근이 필요한데 다양한 매체에 존재하는 데이터들을 사용하기 위해 입출력 데이터를 처리할 공통적인 방법으로 스트림을 이용함.

스트림

• 자바에서는 파일이나 콘솔의 입출력을 직접 다루지 않고, 스트림이라는 흐름을 통해 제어
• 실제의 입력이나 출력이 표현된 데이터의 이상화된 흐름
• 즉, 스트림은 운영체제에 의해 생성되는 가상의 연결 고리를 의미하며, 중간 매개자 역할을 함

스트림 특징

• FIFO구조
  🐶 먼저 들어간 데이터가 먼저 나오는 형태로 데이터의 순서가 바뀌지 않는다
• 단방향
  🐶 하나의 스트림에서 입출력이 동시에 이루어 지지 않는다 입력과 출력에 각각 스트림을 열어 사용해야 한다.
• 지연 가능
  🐶 스트림 내의 데이터가 모두 전송되기 전까지 프로그램이 지연 상태에 빠질 수 있다.

스트림 분류

용도에 의한 분류

• 1차 스트림 : 디바이스에 직접 연결되는 스트림
• 2차 스트림 : 1차 스트림과 연결을 통해 디바이스와 연결되는 스트림

전송 방향에 의한 분류

• 입력 스트림 : 디바이스로부터 데이터를 읽어오는 스트림
• 출력 스트림 : 디바이스로 데이터를 출력하는 스트림

전송단위에 의한 분류

• 바이트 스트림 : 1 Byte 단위로 입력, 출력하는 스트림
• 문자 스트림 : 한 문자(2 Byte) 단위로 입력, 출력하는 스트림

보조 스트림

• 스트림의 기능을 향상시키거나 새로운 기능을 추가시키며, 직접적인 데이터 입출력을 할 수 없다.

바이트 스트림

• 바이트 단위로 데이터 전송 (성능은 우수하나 파일로 저장시 결과 확인 불가함)
• 파일(동영상, 이미지, 음악)을 처리하기에 적합
• 바이트 스트림의 최상위 클래스는 InputStream, OutputStream

바이트 출력 스트림 : OutputStream

• 바이트 기반 출력 스트림의 최상위 클래스, 추상 클래스

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;

public class Main {
    public static void main(String[] args) throws IOException {
        OutputStream os = new FileOutputStream("test.bin");
        byte[] array = {10,20,30,40,50};
        os.write(array, 1, 4); // 배열 인덱스 1부터 4개 출력
        os.flush(); // write() 이후 반드시 버퍼를 비우는 동작이 필요 !!
        os.close(); // 자원 반납 및 스트림 닫기
    }
}

• write(int a, int b) : 배열 인덱스 a부터 b개 출력
• ⭐ flush() : 버퍼 비움. write() 이후 반드시 버퍼 비워야 함
• ⭐ close() : 스트림 닫기(자원 반납)

바이트 입력 스트림 : InputStream

• 바이트 기반 입력 스트림의 최상위 클래스, 추상 클래스

1바이트씩 읽기

import java.io.*;

public class Main {
    public static void main(String[] args) throws IOException {
        InputStream is = new FileInputStream("test.bin");
        byte[] buffer = new byte[100];
        while(true) {
            int data = is.read(); // 1바이트씩 읽기
            if(data == -1) break; // 파일의 끝에 도달
            System.out.print(data + " ");
        }
        is.close();
    }
}

20 30 40 50

1바이트씩 읽기 때문에 파일 크기가 클 경우, 굉장히 비효율적임.

배열의 길이만큼 읽기

import java.io.*;

public class Main {
    public static void main(String[] args) throws IOException {
        InputStream is = new FileInputStream("test.bin");
        byte[] buffer = new byte[100];
        while(true) {
            int readByteNum = is.read(buffer); // 매개변수로 전달한 buffer에 값을 담음
            if(readByteNum == -1) break;
            for(int i = 0; i < readByteNum; i++) {
                System.out.print(buffer[i] + " ");
        }
        is.close(); // 읽기 위해 열어둔 스트림 닫음(메모리에 자원 반납)
    }
}

byte[]을 생성하고 그 크기만큼 read()에 매개변수로 전달하여 int readByteNum에 담는다.
int readByteNum은 배열을 몇 개 소모했는지를 체크하는 용도이며, 자투리 공간까지 담고 while문 탈출

문자 스트림

Writer

• 문자열 기반 출력 스트림의 최상위 클래스, 추상 클래스

write(int c) 메소드

public static void main(String[] args) throws Exception {
		Writer writer = new FileWriter("test.txt");
		char[] data = "곰돌이사육사".toCharArray();
		for(int i=0; i<data.length; i++) {
			writer.write(data[i]);
		}
		writer.flush();
		writer.close();
	}

write(char[] c) 메소드

public static void main(String[] args) throws Exception {
		Writer writer = new FileWriter("test.txt");
		char[] data = "곰돌이사육사".toCharArray();
		writer.write(data);

		writer.flush();
		writer.close();
	}

write(char[] c, int off, int len) 메소드

public static void main(String[] args) throws Exception {
		Writer writer = new FileWriter("test.txt");
		//char[] data = "곰돌이사육사".toCharArray();
		String data = "곰돌이사육사";
		writer.write(data, 1, 2);

		writer.flush();
		writer.close();
	}

Reader

• 문자 기반 입력 최상위 클래스, 추상 클래스

read()

• 입력 스트림으로 부터 한 개의 문자(2바이트)를 읽고 4바이트(int)로 리턴 합니다.
• read() 메소드가 리턴한 int 값을 char형으로 변환하면 읽은 문자열 확인 가능

public static void main(String[] args) throws Exception {
    Reader reader = new FileReader("src/test.txt");
    int readData;
    while( true ) {
        readData = reader.read();
        if(readData == -1) break;
        System.out.print((char)readData);
    }
    reader.close();
}

read(char[] cbuf) 메소드

입력스트림으로 부터 매개변수로 주어진 문자 배열의 길이만큼 문자를 읽고 배열에 저장 합니다.

그리고, 읽은 문자 수를 리턴 합니다. 실제로 읽은 문자 수가 배열 길이 보다 작을 경우 읽은 수만큼만 리턴 합니다.

public static void main(String[] args) throws Exception {
    Reader reader = new FileReader("src/test.txt");
    int readCharNo;
    char[] cbuf = new char[10];
    String data = "";
    while( true ) {
        readCharNo = reader.read(cbuf);
        if(readCharNo == -1) break;
        data += new String(cbuf, 0, readCharNo);
    }
    System.out.println(data);

    reader.close();
}

파일 입출력

File 클래스

• 파일이나 디렉토리를 추상화한 클래스, 가장 많이 사용되는 입출력 대상

File file = new File("C:\\Temp\\file.txt");
File file = new File("C:/Temp/file.txt");

public static void main(String[] args) throws URISyntaxException, IOException {
    File temp = new File("src");
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd   a   HH:mm");
        File[] contents = temp.listFiles();
        System.out.println("날짜              시간         형태       크기    이름");
        System.out.println("-------------------------------------------------------------------");
        for(File file : contents) {
            System.out.print(sdf.format(new Date(file.lastModified()))); // 파일의 최종 갱신 시간
            if(file.isDirectory()) {
                System.out.print("\t<DIR>\t\t\t" + file.getName()); // 파일 이름을 스트링으로 반환
            } else {
                System.out.print("\t\t\t" + file.length() + "\t" + file.getName());
            }
            System.out.println();
        }
}

FileInputStream

• 파일로부터 바이트 단위로 읽어 들일 때 사용되는 바이트 기반 입력 스트림

public static void main(String[] args) {
        try {
            FileInputStream fis = new FileInputStream("src/파일인풋스트림/FileInputStreamEx.java");
            int data;
            while ( (data = fis.read() ) != -1 ) {
                System.out.write(data);
            }
            fis.close();
        } catch(Exception e) {
            e.printStackTrace();
        }
    }

FileOutputStream

• 바이트 단위로 데이터를 파일에 저장 할 때 사용하는 바이트 기반 출력 스트림
• 바이트 단위로 저장하기 때문에 그림, 오디오, 비디오, 텍스트 등 모든 종류의 데이터를 파일로 저장 가능

public static void main(String[] args) throws IOException {
    String originalFileName = "src/파일아웃풋스트림/house.jpg";
    String targetFileName = "src/house.jpg";

    FileInputStream fis = new FileInputStream(originalFileName);
    FileOutputStream fos = new FileOutputStream(targetFileName);

    int readByteNo;
    byte[] readBytes = new byte[100];
    while( (readByteNo = fis.read(readBytes)) != -1 ) {
        fos.write(readBytes, 0, readByteNo);
    }

    fos.flush();
    fos.close();
    fis.close();

    System.out.println("복사가 잘 되었습니다.");
}

FileInputStream과 Scanner 활용

• Scanner 입력으로 파일을 읽습니다.
• 스캐너의 hasNextLine()으로 읽을 내용 있는지 확인

package 파일입출력;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.util.Scanner;

public class FileInput {
    public static void main(String[] args) {
        FileInputStream inputStream = null;

        try {
            inputStream = new FileInputStream("src/파일입출력/chiken.txt");
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }

        Scanner sc = new Scanner(inputStream);
        while(sc.hasNextLine()) {
            String line = sc.nextLine();
            System.out.println(line);
        }
    }
}

보조 스트림

⭐성능 향상 보조스트림

BufferedOutputStream, BufferedWriter

BufferedInputStream, BufferedReader

버퍼 사용 전!!!

import java.io.*;

public class Main {
    public static void main(String[] args) throws IOException {
        FileInputStream fis = null;
        FileOutputStream fos = null;
        BufferedInputStream bis = null; // 입력 보조 스트림
        BufferedOutputStream bos = null; // 출력 보조 스트림

        int data = -1; // 더 이상 읽을 데이터가 없음을 의미
        long start = 0; // 경과 시간 계산을 위한 변수
        long end = 0; // 경과 시간 계산을 위한 변수

        fis = new FileInputStream("src/성능향상보조스트림0210/night.jpg");
        bis = new BufferedInputStream(fis);
        fos = new FileOutputStream("clone_night.jpg");
        start = System.currentTimeMillis(); // 1970년 1월 1일 0시 0분 0초로 부터 현재까지 경과 시간을 밀리초로 표시
        while((data = bis.read()) != -1) {
            fos.write(data);
        }
        fos.flush();
        end = System.currentTimeMillis();
        fos.close();
        bis.close();
        fis.close();
        System.out.println("버퍼 사용을 하지 않은 경우에 대한 시간 : " + (end - start) + "ms");

버퍼 사용을 하지 않은 경우에 대한 시간 : 588ms

버퍼 사용 후!!!!

import java.io.*;

public class Main {
    public static void main(String[] args) throws IOException {
        FileInputStream fis = null;
        FileOutputStream fos = null;
        BufferedInputStream bis = null; // 입력 보조 스트림
        BufferedOutputStream bos = null; // 출력 보조 스트림

        int data = -1; // 더 이상 읽을 데이터가 없음을 의미
        long start = 0; // 경과 시간 계산을 위한 변수
        long end = 0; // 경과 시간 계산을 위한 변수

        // 버퍼 보조 스트림 두어서 성능 측정
        fis = new FileInputStream("src/성능향상보조스트림0210/night.jpg");
        bis = new BufferedInputStream(fis);
        fos = new FileOutputStream("clone_night.jpg");
        bos = new BufferedOutputStream(fos);
        start = System.currentTimeMillis();
        while((data = bis.read()) != -1) {
            bos.write(data);
        }
        bos.flush();
        end = System.currentTimeMillis();
        fos.close();
        bis.close();
        fis.close();
        bos.close();
        System.out.println("버퍼를 사용하는 경우에 대한 시간 : " + (end - start) + "ms");
    }
}

버퍼를 사용하는 경우에 대한 시간 : 1ms

🐸 성능이 굉장히 좋아진 것을 확인 할 수 있다!

기본 타입 보조스트림

• Scanner로 대체 가능
• 바이트 스트림은 바이트 단위로 입출력 하기 때문에 자바의 기본 데이터 타입 사용할 수 없음.
  이를 해결하기 위해 보조 스트림을 연결해 사용함.

DataInputStream, DataOutputStream

import java.io.*;

public class Main {
    public static void main(String[] args) throws IOException {
        FileOutputStream fos = new FileOutputStream("기본타입보조스트림.bin");
        DataOutputStream dos = new DataOutputStream(fos); // 프로그램에서 사용할 수 있는 기본 타입을 지원하는 보조 스트림
        dos.writeUTF("이순신"); // 문자열 메소드
        dos.writeDouble(99.8); // 실수형 메소드
        dos.writeInt(1); // 정수형 메소드

        dos.writeUTF("한석봉");
        dos.writeDouble(64.5);
        dos.writeInt(2);

        dos.writeUTF("홍길동");
        dos.writeDouble(84.2);
        dos.writeInt(3);

        dos.flush();
        dos.close();

        FileInputStream fis = new FileInputStream("기본타입보조스트림.bin");
        DataInputStream dis = new DataInputStream(fis);

        for(int i = 0; i < 3; i++) {
            String name = dis.readUTF(); // 문자열을 읽음
            double score = dis.readDouble();
            int num = dis.readInt();
            System.out.println(name + " : " + score + num);
        }
    }
}

⭐객체 입출력 보조스트림

• 직렬화?
  ➡️ 프로그램에서 사용되는 객체를 파일이나 네트워크로 전송하기 위해서 연속적인 바이트 형태로 변경하는 것
• 직렬화된 바이트를 객체로 복원화는 것을 '역직렬화'라고 합니다.
• Serializable

직렬화 자체는 잘 쓰이지 않지만(객체 직렬화는 JAVA끼리만 호환되기 때문에 보통 JSON을 이용함)
직렬화를 쓰는 패턴은 백엔드에서 자주 쓰이므로 익숙해지도록 하자.

• 객체를 직렬화 하기 위해서는 Serializable 인터페이스를 상속 받아야 합니다.
• 클래스 내에 포함된 필드 중 직렬화 대상에서 제외할 내용이 있으면 transient 키워드를 사용하면 됩니다.

import java.io.Serializable;
import java.util.Date;

public class Board implements Serializable {
    private int number;
    private String title;
    private String content;
    private String writer;
    private Date date;
    transient String test;

    public Board(int number, String title, String content, String writer, Date date) {
        this.number = number;
        this.title = title;
        this.content = content;
        this.writer = writer;
        this.date = date;
    }

    public int getNumber() {
        return number;
    }

    public void setNumber(int number) {
        this.number = number;
    }

    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    public String getContent() {
        return content;
    }

    public void setContent(String content) {
        this.content = content;
    }

    public String getWriter() {
        return writer;
    }

    public void setWriter(String writer) {
        this.writer = writer;
    }

    public Date getDate() {
        return date;
    }

    public void setDate(Date date) {
        this.date = date;
    }
}

import java.io.*;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;

public class Main {
    public static void main(String[] args) throws IOException, ClassNotFoundException { // 객체애 대한 직렬화
        writeList();
        List<Board> list = readList();
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        for(Board e : list) {
            System.out.println("번호 : " + e.getNumber());
            System.out.println("제목 : " + e.getTitle());
            System.out.println("내용 : " + e.getContent());
            System.out.println("연출가 : " + e.getWriter());
            System.out.println("시간 : " + sdf.format(e.getDate()));
            System.out.println("------------------------------------");
        }
    }
    static void writeList() throws IOException {
        List<Board> list = new ArrayList<>();
        list.add(new Board(1, "나는 솔로","연애 예능","김땡떙", new Date()));
        list.add(new Board(2, "무엇이든 물어보살","예능","이땡떙", new Date()));
        list.add(new Board(3, "차트를 달리는 남자","차트 예능","박땡떙", new Date()));

        FileOutputStream fos = new FileOutputStream("board.bin");
        ObjectOutputStream oos = new ObjectOutputStream(fos);
        oos.writeObject(list); // 객체 출력 스트림을 이용해 list를 출력
        oos.flush();
        oos.close();
    }
    static List<Board> readList() throws IOException, ClassNotFoundException {
        FileInputStream fis = new FileInputStream("board.bin");
        ObjectInputStream ois = new ObjectInputStream(fis);
        List<Board> list = (List<Board>)ois.readObject(); // 파일의 바이너리를 역직렬화
        return list;
    }
}

번호 : 1
제목 : 나는 솔로
내용 : 연애 예능
연출가 : 김땡떙
시간 : 2023-02-10
------------------------------------
번호 : 2
제목 : 무엇이든 물어보살
내용 : 예능
연출가 : 이땡떙
시간 : 2023-02-10
------------------------------------
번호 : 3
제목 : 차트를 달리는 남자
내용 : 차트 예능
연출가 : 박땡떙
시간 : 2023-02-10
------------------------------------