Just Do "IT"

*         프로세스  : 실행중인 프로그램
*         쓰레드   : 프로세스 안에 여러가지 작업들을 의미, 동시 실행 가능(병렬처리)
*         생성방법 ) 1) 인터페이스 상속 이용
*                    2) 부모 클래스 상속 이용

public class BeepTask implements Runnable{
    // TODO : 메서드 구현
    //  쓰레드 작업을 실행시키는 함수
    @Override
    public void run() {
        // TODO : 예제 : 삐소리를 들려 주는 코딩
        //  멀티미디어 객체 가져오기
        Toolkit toolkit = Toolkit.getDefaultToolkit();
        for (int i = 0; i < 5; i++) {
            toolkit.beep(); // 컴퓨터 삐소리
            try {
                // 공유 함수
                Thread.sleep(500); // 0.5초 지연 후 삐 소리
            } catch (Exception e) {

            }
        }
    }
}

* description : 작업쓰레드 #1 : 삐소리
*               main 함수 : 메인 쓰레드 : 화면출력 : 띵 글자 5번 출력
*               동시 실행

public class BeepTaskApplication {
    public static void main(String[] args) {
//        TODO : 1) 작업쓰레드 객체 생성
        Runnable runnable = new BeepTask(); // 다형성
//        TODO : 2) 쓰레드 생성자의 매개변수로 전달
        Thread thread = new Thread(runnable);
//        TODO : 3) 작업쓰레드 # 1 : 삐소리 실행(run() 실행됨)
        thread.start();

//        TODO : 4) 메인쓰레드 : 화면에 띵 글자 출력
        for (int i = 0; i < 5; i++) {
            System.out.println("띵");
            try {
                Thread.sleep(500); // 0.5 지연
            } catch (Exception e){}
        }
    }
}

public class BeepThread extends Thread{
//    TODO : 쓰레드 작업을 실행시키는 함수
    @Override
    public void run() {
//         TODO: beep 를 들려주는 코드
//            자바쪽 멀티미디어 객체 : 소리, 그림, 이미지 등등 다루는 객체
        Toolkit toolkit = Toolkit.getDefaultToolkit();
        for (int i = 0; i < 5; i++) {
            toolkit.beep(); // 삐소리
            try {
                Thread.sleep(500); // 0.5 삐소리 지연
            } catch (Exception e) {}
        }
    }
}

public class BeepThreadApplication {
    public static void main(String[] args) {
//        TODO : 1) 쓰레드 객체 생성
        Thread thread = new BeepThread();   // 다형성
//        TODO : 2) 쓰레드 실행 #1 : 내부적으로 run() 함수가 실행됨
        thread.start();
//        TODO : 3) main 쓰레드 작업 #2 : 화면 출력 (띵 * 5 출력)
        for (int i = 0; i < 5; i++) {
            System.out.println("띵");
            try {
                Thread.sleep(500); // 0.5초 지연
            }catch (Exception e){}
        }
    }
}

* description : 특수클래스 -> 중첩 클래스 : 클래스안에 클래스
* 요약 :
* 클래스의 3요소 : 속성, 생성자, 함수
* 멤버 클래스 - 일반 속성 클래스 : 외부 클래스를 생성해야 내부 클래스를 사용가능
*             정적 속성 클래스 : 외부 클래스 생성없이 바로 사용 가능
* 로컬 클래스 - 함수(메소드) 안의 클래스 : 함수를 실행해야 사용 가능

public class Outer {
    // TODO : 클래스의 3요소 = 속성, 생성자, 함수
    // 생성자
    public Outer() {
        System.out.println("외부 클래스가 생성됨");
    }

    // TODO : 일반 속성 (내부)클래스
    public class Attr {
        //        생성자
        public Attr() {
            System.out.println("Attr 내부 클래스가 생성됨");
        }

        int field1;     // 속성

        void method1() {
        }
    }

    // TODO : 정적 속성(내부) 클래스
    static class Share {
        // 생성자
        public Share() {
            System.out.println("Share 정적 객체가 생성됨");
        }
        int filed1; // 일반 속성
        static int field2; // 정적 속성
        void method1(){};   // 일반 함수
        static void method2(){
            System.out.println("정작함수가 실행됨");
        };   // 정적 함수
    }
    
    // TODO : 로컬 클래스 : 함수 안의 클래스
    void method(){
        // TODO : 내부 클래스
        class Local{
            // 생성자
            public Local() {
                System.out.println("Local 객체가 생성됨");
            }
            int field1; // 속성
            void method1(){};   // 함수
        }
        // Local 객체 생성
        Local local = new Local();
        local.field1 = 3;       // 내부클래스 속성
        local.method1();        // 내부클래스 함수
    }
}

public class OuterApplication {
    public static void main(String[] args) {
//        TODO : 외부클래스 : Outer 객체 생성
        Outer outer = new Outer();

//        TODO : 1) 일반 속성 내부 클래스 객체 생성
//         사용법 : 외부클래스.내부클래스 객체변수 = 외부객체.new 내부생성자함수();
        Outer.Attr attr = outer.new Attr();
        attr.field1 = 3;    // 내부 클래스의 속성
        attr.method1();     // 내부 클래스의 함수

//        TODO : 2) 정적(공유) 속성 내부 클래스 객체 생성 없음 : 바로 호출
//         사용법 : 외부클래스.내부클래스.속성, 외부클래스.내부클래스.함수()
        Outer.Share.field2 = 3;     // 공유 내부 클래스의 공유속성 호출
        Outer.Share.method2();      // 공유 내부 클래스의 공유함수 호출

//        TODO : 3) 로컬 클래스 : 함수 안의 클래스
        outer.method(); // 안에서 클래스 자동 생성됨



    }
}

//         js   : 함수의 매개변수로 함수를 넣을 수 있음, 리턴값도 함수 내보내기 가능
//         java : 함수의 매개변수/리턴값으로 함수 사용 금지
//           => 부가기능 추가 : 5가지 경우의 대표 함수(형태)를 만들어서 사용
//           Runnable(실행) 함수   : 매개변수(x), 리턴값(x) 함수  예) void run()
//           Supplier(공급자) 함수 : 매개변수(x), 리턴값(o) 함수  예) int get()
//           Consumer(소비자) 함수 : 매개변수(o), 리턴값(x) 함수  예) void accept(int t)
//           Function(일반) 함수  : 매개변수(o), 리턴값(o) 함수  예) int apply(int t)
//           Predicate(논리(명제)) 함수  : 매개변수(o), 리턴값(o, 참/거짓) 함수  예) boolean apply(int t)

 /**
     * 1~100까지 중 10개의 랜덤 숫자 배열에 넣기 함수
     * 제네릭 함수 : 제네릭을 매개변수에 사용하는 함수, 반환타입 앞에 <T>를 붙임
     * T 클래스 : 대표 T : 임의의 어떤 클래스를 대표하는 클래스로 사용
     * 제네릭 함수 : static <T> 반환타입 함수명(매개변수타입 매개변수명...) {}
     *
     * @param s
     * @param list
     * @param <T>
     */
    static <T> void makeRandomList(Supplier<T> s, List<T> list) {
        for (int i = 0; i < 10; i++) {
            list.add(s.get()); // s.get() : 매개변수로 전달되는 생산자 함수를 대리하는 함수
        }
    }

    /**
     * List에 저장된 요소의 값이(i) 짝수인것만 화면에 출력
     *
     * @param p
     * @param c
     * @param list
     * @param <T>
     */
    static <T> void printEventNum(Predicate<T> p, Consumer<T> c, List<T> list) {
        for (T i : list) {
//            명제 : 참/거짓이 있는 문장
            if (p.test(i)) { //  p.test(값)   : 매개변수로 전달되는 논리(명제) 함수를 대리하는 함수
                c.accept(i); // c.accept(값) : 매개변수로 전달되는 소비자 함수를 대리하는 함수
            }
        }
        System.out.println(); // 줄바꿈
    }

    /**
     * 1의 자리를 없앤 새로운 배열을 만들어서 List에 저장하는 함수(1의 자리는 0으로 변경)
     * 제네릭 함수 : 함수의 리턴값 앞에 <T>, 제네릭표현식을 사용하는 함수
     *
     * @param f
     * @param list
     * @param <T>
     * @return
     */
    static <T> List<T> doSomething(Function<T, T> f, List<T> list) {
        List<T> newList = new ArrayList<T>(list.size());

        for (T i : list) {
            newList.add(f.apply(i)); //  p.apply(값)   : 매개변수로 전달되는 일반 함수를 대리하는 함수
        }
        return newList;
    }

 public static void main(String[] args) {

        Supplier<Integer> s = () -> (int)(Math.random()*100) + 1;   // 1 ~ 100까지 랜덤
        Consumer<Integer> c = i -> System.out.println(i + ",");     // i 출력 함수
        Predicate<Integer> p = i -> i % 2 == 0;                     // 2의 배수만 리턴하는 함수
        Function<Integer, Integer> f = i -> i/10*10;                // i의 값 중 1의 자리를 없애는 함수
                                                                    // 예) 9.7 -> 90

//        TODO : 결과 실행
        List<Integer> list = new ArrayList<>();

//        TODO : 정적 함수를 호출하면 마지막 매개변수(배열)에 값이 저장되어 리턴됨(화면출력됨)
        makeRandomList(s, list);
        System.out.println(list);   // 결과출력 : 1 ~ 100까지 랜덤수가 화면출력됨
        System.out.println("------------------------------------------------------");
        printEventNum(p, c, list);  // 결과 : 배열에 짝수인것만 화면에 출력
        System.out.println("------------------------------------------------------");
        List<Integer> list2 = doSomething(f, list);
        System.out.println(list2); // 결과 : 일의 자리를 없앤 배열



    }

* description : File 클래스 : 파일생성 또는 폴더 생성, 정보 보기 기능

public class FileApplication {
    public static void main(String[] args) throws Exception {
//        TODO : 1) 텍스트 파일을 읽어서 리스트 배열로 가져오기 : Files.readAllLines(Paths.get(경로))
        List<String> lines
                = Files.readAllLines(Paths.get("src/main/resources/file1.txt"));
        System.out.println(lines);  // 배열 출력

//        TODO : 2) byte 파일을 읽어서 데이터 가져오기
        byte[] bytes = Files.readAllBytes(Paths.get("src/main/resources/test1.db"));
        System.out.println(Arrays.toString(bytes)); // 결과 출력

    }
}

package chap15.sec02.exam06;

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

/**
 * packageName : chap14.sec02.exam06
 * fileName : Board
 * author : ds
 * date : 2022-10-07
 * description : 게시판 객체
 * ===========================================================
 * DATE            AUTHOR             NOTE
 * —————————————————————————————
 * 2022-10-07         ds          최초 생성
 */
// 모델(Model) : 순수객체, 속성, 생성자, Setter/Getter, 그외에 로직을 구하는 함수는 없음
//    목적 : 데이터 저장용/검색용
// Service : 업무가 들어가 있는 클래스(객체)
// Controller : 여러 화면을(View) 조작하는(컨트롤하는) 클래스
//    MVC 디자인패턴(종합편) : M(Model) / V(View) / C(Controller)
public class Board implements Serializable {
//    속성
//    게시판 번호
    private int bno;
//    제목
    private String title;
//    내용
    private String content;
//    작성자
    private String writer;
//    날짜
    private Date date;

//    생성자
    public Board(int bno, String title, String content, String writer, Date date) {
        this.bno = bno;
        this.title = title;
        this.content = content;
        this.writer = writer;
        this.date = date;
    }

//    함수 재정의
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Board board = (Board) o;
        return bno == board.bno && Objects.equals(title, board.title) && Objects.equals(content, board.content) && Objects.equals(writer, board.writer) && Objects.equals(date, board.date);
    }

    @Override
    public int hashCode() {
        return Objects.hash(bno, title, content, writer, date);
    }

    @Override
    public String toString() {
        return "Board{" +
                "bno=" + bno +
                ", title='" + title + '\'' +
                ", content='" + content + '\'' +
                ", writer='" + writer + '\'' +
                ", date=" + date +
                '}';
    }
}

public class ObjectApplication {
    //    객체 쓰기 공유 함수
    public static void writeList() throws Exception {
//        자료구조 : ArrayList
        List<Board> list = new ArrayList<>(); // List 생성 (ArrayList)

        list.add(new Board(1, "제목1", "내용1", "글쓴이1", new Date()));
        list.add(new Board(2, "제목2", "내용2", "글쓴이2", new Date()));
        list.add(new Board(3, "제목3", "내용3", "글쓴이3", new Date()));

//        TODO: 객체를 파일에 쓰기(파일 생성)
        FileOutputStream fileOutputStream
                = new FileOutputStream("src/main/resources/board.txt");
//        TODO : 보조스트림 적용(객체 쓰기)
//              .writeObject(객체배열)
        ObjectOutputStream objectOutputStream
                = new ObjectOutputStream(fileOutputStream);

        objectOutputStream.writeObject(list);   // 객체 -> 파일 쓰기 함수 호출
        objectOutputStream.flush();
        objectOutputStream.close();

    }

    //    객체 읽기 공유 함수
    public static List<Board> readList() throws Exception {
//        TODO: 파일 읽기로 접근
        FileInputStream fileInputStream
                = new FileInputStream("src/main/resources/board.txt");

//        TODO : 보조스트림 적용 : 파일 -> 객체 읽기
        ObjectInputStream objectInputStream
                = new ObjectInputStream(fileInputStream);

//        TODO : 파일 -> 객체배열로 원복해서 읽기 : .readObject()
//            대상 객체[배열]은 Serializable 인터페이스를 상속받아야 함
        List<Board> list = (List<Board>)objectInputStream.readObject(); // 객체로 바꾸기(원복)
        return list;
    }

    public static void main(String[] args) throws Exception{
        writeList(); // 쓰기 공유 함수 객체배열 List 파일에 쓰기
//        파일에 쓴 것을 읽기
        List<Board> list = readList(); // 읽기 공유 함수(역직렬화)

        System.out.println(list);
    }
}

 //    객체 쓰기 공유 함수
    public static void writeList() throws Exception {
//        자료구조 : ArrayList
        List<Board> list = new ArrayList<>(); // List 생성 (ArrayList)

        list.add(new Board(1, "제목1", "내용1", "글쓴이1", new Date()));
        list.add(new Board(2, "제목2", "내용2", "글쓴이2", new Date()));
        list.add(new Board(3, "제목3", "내용3", "글쓴이3", new Date()));

//        TODO: 객체를 파일에 쓰기(파일 생성)
        FileOutputStream fileOutputStream
                = new FileOutputStream("src/main/resources/board.txt");
//        TODO : 보조스트림 적용(객체 쓰기)
//              .writeObject(객체배열)
        ObjectOutputStream objectOutputStream
                = new ObjectOutputStream(fileOutputStream);

        objectOutputStream.writeObject(list);   // 객체 -> 파일 쓰기 함수 호출
        objectOutputStream.flush();
        objectOutputStream.close();

    }

//    객체 읽기 공유 함수
    public static List<Board> readList() throws Exception {
//        TODO: 파일 읽기로 접근
        FileInputStream fileInputStream
                = new FileInputStream("src/main/resources/board.txt");

//        TODO : 보조스트림 적용 : 파일 -> 객체 읽기
        ObjectInputStream objectInputStream
                = new ObjectInputStream(fileInputStream);

//        TODO : 파일 -> 객체배열로 원복해서 읽기 : .readObject()
//            대상 객체[배열]은 Serializable 인터페이스를 상속받아야 함
        List<Board> list = (List<Board>)objectInputStream.readObject(); // 객체로 바꾸기(원복)
        return list;
    }

 public static void main(String[] args) throws Exception{
        writeList(); // 쓰기 공유 함수 객체배열 List 파일에 쓰기
//        파일에 쓴 것을 읽기
        List<Board> list = readList(); // 읽기 공유 함수(역직렬화)

        System.out.println(list);
    }
}

public class PrintApplication {
    public static void main(String[] args) throws Exception {
        // TODO : 파일 쓰기용으로 생성
        FileOutputStream fileOutputStream
                = new FileOutputStream("src/main/resources/printstream.txt");

        // TODO : 보조스트림 적용 : print(), println() 함수가 있는 보조스트림
        PrintStream printStream =
                new PrintStream(fileOutputStream);

        // TODO : 파일에 한줄씩 내용쓰기
        printStream.println("프린터 보조 스트림");      // 줄바꿈 출력
        printStream.print("마치");                    // 줄바꿈 없음
        printStream.println("프린터가 출력되는 것처럼");
        printStream.println("파일에 작성합니다.");

        printStream.flush();    // 기본버퍼 -> 진짜파일에 쓰기
        printStream.close();    // 파일 닫기
    }
}

// TODO : 파일 쓰기용으로 생성
FileOutputStream fileOutputStream
        = new FileOutputStream("src/main/resources/printstream.txt");

// TODO : 보조스트림 적용 : print(), println() 함수가 있는 보조스트림
PrintStream printStream =
        new PrintStream(fileOutputStream);

// TODO : 파일에 한줄씩 내용쓰기
printStream.println("프린터 보조 스트림");      // 줄바꿈 출력
printStream.print("마치");                    // 줄바꿈 없음
printStream.println("프린터가 출력되는 것처럼");
printStream.println("파일에 작성합니다.");

printStream.flush();    // 기본버퍼 -> 진짜파일에 쓰기
printStream.close();    // 파일 닫기

public class DataInputApplication {
    public static void main(String[] args) throws Exception {   // 예외처리
        // TODO : 파일 쓰기용으로 파일 생성
        FileOutputStream fileOutputStream
                = new FileOutputStream("src/main/resources/primitive.txt");

        // TODO : 보조스트림 : 기본 자료형 사용하게 만들어주는 스트림
        //      사용법 : new DataOutputStream(기본스트림);
        DataOutputStream dataOutputStream
                = new DataOutputStream(fileOutputStream);

        // 파일에 기본 자료형 쓰기 함수들
        // TODO : writeUTF("문자열") -> 파일에 문자열 쓰기
        //        writeDouble(실수) -> 파일에 실수 쓰기
        //        writeInt(정수) -> 파일에 정수 쓰기
        dataOutputStream.writeUTF("홍길동");
        dataOutputStream.writeDouble(95.4);
        dataOutputStream.writeInt(1);

//        TODO: 여기서 부터 코딩
        dataOutputStream.writeUTF("감자바");
        dataOutputStream.writeDouble(90.3);
        dataOutputStream.writeInt(2);
        
        // TODO : 파일 닫기
        dataOutputStream.flush();   // 기본버퍼의 내용을 진짜파일에 쓰기
        dataOutputStream.close();

    }
}

// TODO : 파일 쓰기용으로 파일 생성
FileOutputStream fileOutputStream
        = new FileOutputStream("src/main/resources/primitive.txt");

// TODO : 보조스트림 : 기본 자료형 사용하게 만들어주는 스트림
//      사용법 : new DataOutputStream(기본스트림);
DataOutputStream dataOutputStream
        = new DataOutputStream(fileOutputStream);

// TODO : writeUTF("문자열") -> 파일에 문자열 쓰기
//        writeDouble(실수) -> 파일에 실수 쓰기
//        writeInt(정수) -> 파일에 정수 쓰기
dataOutputStream.writeUTF("홍길동");
dataOutputStream.writeDouble(95.4);
dataOutputStream.writeInt(1);

dataOutputStream.writeUTF("감자바");
dataOutputStream.writeDouble(90.3);
dataOutputStream.writeInt(2);

// TODO : 파일 닫기
dataOutputStream.flush();   // 기본버퍼의 내용을 진짜파일에 쓰기
dataOutputStream.close();

FileInputStream fileInputStream
        = new FileInputStream("src/main/resources/primitive.txt");

DataInputStream dataInputStream
        = new DataInputStream(fileInputStream);

        dataOutputStream.writeUTF("홍길동");
        dataOutputStream.writeDouble(95.4);
        dataOutputStream.writeInt(1);


        dataOutputStream.writeUTF("감자바");
        dataOutputStream.writeDouble(90.3);
        dataOutputStream.writeInt(2);

        // TODO : 반복문 실행 후 화면에 출력 : 두번 실행
        //     주의점 : 바이트 크기가 각각 다르므로 출력순서에 맞게 자료형을 읽어야 함
        for (int i = 0; i < 2; i++) {
//            dataOutputStream.writeUTF("감자바"); //
//            dataOutputStream.writeDouble(90.3); // 8byte
//            dataOutputStream.writeInt(2);       // 4byte
            String name = dataInputStream.readUTF();        // 파일에서 읽기
            double score = dataInputStream.readDouble();        // 파일에서 읽기
            int order = dataInputStream.readInt();        // 파일에서 읽기
            System.out.println(name + ", " + score + ", " + order);

        }

// TODO : 파일 닫기
dataInputStream.close();
fileInputStream.close();

public class BufferApplication {
    static int data = -1;

    // TODO : 정적(전역, 공유)함수 : 파일 copy 함수
    public static long copy(InputStream is, OutputStream os) throws Exception {     // 예외처리
        // 복사하는데 걸리는 시간 체크 : 시작시간 체크
        long start = System.nanoTime();

        // 복사 실행 코드
        while(true) {
            data = is.read();   // 읽기(원본)
            if(data == -1) break;   // 반복문 종료 조건, 파일의 끝 : -1 리턴
            os.write(data);     // 다른 파일에 쓰기(복사본)
        }

        // 종료 시간 체크
        long end = System.nanoTime();

        return (end - start);   // 걸린시간 리턴
    }

    public static void main(String[] args) throws Exception {
        // TODO : 원본 이미지 경로 지정
        String orgImgPath = "src/main/resources/images/boy.jpg";    // 일반복사 파일
        String orgImgPath2 = "src/main/resources/images/girl.jpg";  // 버퍼복사 파일

        // TODO : 복사본 이미지 경로 지정
        String cpyImgPath = "src/main/resources/images/boy_copy.jpg";   // 일반복사 파일
        String cpyImgPath2 = "src/main/resources/images/girl_copy.jpg"; // 버퍼복사 파일

        // FileInputStream 기본 스트림 중 1개
        // TODO : 파일 읽기용으로 원본 이미지 접근
        FileInputStream fileInputStream
                = new FileInputStream(orgImgPath);
        // TODO : 파일 쓰기용으로 복사본 이미지 생성
        FileOutputStream fileOutputStream
                = new FileOutputStream(cpyImgPath);

        // TODO : 복사함수(copy)를 이용해서 복사본 이미지 생성 + 소요시간 측정(리턴)
        long nonBufferTime = copy(fileInputStream, fileOutputStream);
        System.out.println("버퍼를 사용하지 않았을때 :" + nonBufferTime + "ns");

        fileInputStream.close();
        fileOutputStream.close();


    }
}

public static long copy(InputStream is, OutputStream os) throws Exception {     // 예외처리
    // 복사하는데 걸리는 시간 체크 : 시작시간 체크
    long start = System.nanoTime();

    // 복사 실행 코드
    while(true) {
        data = is.read();   // 읽기(원본)
        if(data == -1) break;   // 반복문 종료 조건, 파일의 끝 : -1 리턴
        os.write(data);     // 다른 파일에 쓰기(복사본)
    }

    // 종료 시간 체크
    long end = System.nanoTime();

    return (end - start);   // 걸린시간 리턴
}

public static void main(String[] args) throws Exception {
        // TODO : 원본 이미지 경로 지정
        String orgImgPath = "src/main/resources/images/boy.jpg";    // 일반복사 파일
        String orgImgPath2 = "src/main/resources/images/girl.jpg";  // 버퍼복사 파일

        // TODO : 복사본 이미지 경로 지정
        String cpyImgPath = "src/main/resources/images/boy_copy.jpg";   // 일반복사 파일
        String cpyImgPath2 = "src/main/resources/images/girl_copy.jpg"; // 버퍼복사 파일

        // FileInputStream 기본 스트림 중 1개
        // TODO : 파일 읽기용으로 원본 이미지 접근
        FileInputStream fileInputStream
                = new FileInputStream(orgImgPath);
        // TODO : 파일 쓰기용으로 복사본 이미지 생성
        FileOutputStream fileOutputStream
                = new FileOutputStream(cpyImgPath);

        // TODO : 복사함수(copy)를 이용해서 복사본 이미지 생성 + 소요시간 측정(리턴)
        long nonBufferTime = copy(fileInputStream, fileOutputStream);
        System.out.println("버퍼를 사용하지 않았을때 :" + nonBufferTime + "ns");

        fileInputStream.close();
        fileOutputStream.close();

//        ------------------- 버퍼 써서 파일 복사 ------------------

        // TODO : 파일 읽기용으로 원본 이미지 접근 : girl.jpg(이미지 경로 : orgImgPath2)
        FileInputStream fileInputStream2
                = new FileInputStream(orgImgPath2);
        // TODO : 파일 쓰기용으로 복사본 이미지 생성 (이미지 경로 : cpyImgPath2 )
        FileOutputStream fileOutputStream2
                = new FileOutputStream(cpyImgPath2);

        // TODO : 보조스트림(buffer) 적용 : new 보조스트림 생성자(기본스트림)
        BufferedInputStream bufferedInputStream
                = new BufferedInputStream(fileInputStream2);    // 읽기용(원본)
        BufferedOutputStream bufferedOutputStream
                = new BufferedOutputStream(fileOutputStream2);  // 쓰기용(복사본)

        // TODO : 복사(copy)와 함께 소요시간(리턴값) 체크
        long bufferTime = copy(bufferedInputStream, bufferedOutputStream);
        System.out.println("버퍼를 사용할때 : " + bufferTime + "ns");

        // TODO : 파일 닫기
        bufferedInputStream.close();
        bufferedOutputStream.close();

    }

// TODO : 원본 이미지 경로 지정
String orgImgPath = "src/main/resources/images/boy.jpg";    // 일반복사 파일
String orgImgPath2 = "src/main/resources/images/girl.jpg";  // 버퍼복사 파일

// TODO : 복사본 이미지 경로 지정
String cpyImgPath = "src/main/resources/images/boy_copy.jpg";   // 일반복사 파일
String cpyImgPath2 = "src/main/resources/images/girl_copy.jpg"; // 버퍼복사 파일

// FileInputStream 기본 스트림 중 1개
// TODO : 파일 읽기용으로 원본 이미지 접근
FileInputStream fileInputStream
        = new FileInputStream(orgImgPath);
// TODO : 파일 쓰기용으로 복사본 이미지 생성
FileOutputStream fileOutputStream
        = new FileOutputStream(cpyImgPath);

// TODO : 복사함수(copy)를 이용해서 복사본 이미지 생성 + 소요시간 측정(리턴)
long nonBufferTime = copy(fileInputStream, fileOutputStream);
System.out.println("버퍼를 사용하지 않았을때 :" + nonBufferTime + "ns");

fileInputStream.close();
fileOutputStream.close();

// TODO : 파일 읽기용으로 원본 이미지 접근 : girl.jpg(이미지 경로 : orgImgPath2)
FileInputStream fileInputStream2
        = new FileInputStream(orgImgPath2);
// TODO : 파일 쓰기용으로 복사본 이미지 생성 (이미지 경로 : cpyImgPath2 )
FileOutputStream fileOutputStream2
        = new FileOutputStream(cpyImgPath2);

// TODO : 보조스트림(buffer) 적용 : new 보조스트림 생성자(기본스트림)
BufferedInputStream bufferedInputStream
        = new BufferedInputStream(fileInputStream2);    // 읽기용(원본)
BufferedOutputStream bufferedOutputStream
        = new BufferedOutputStream(fileOutputStream2);  // 쓰기용(복사본)

// TODO : 복사(copy)와 함께 소요시간(리턴값) 체크
long bufferTime = copy(bufferedInputStream, bufferedOutputStream);
System.out.println("버터를 사용할때 : " + bufferTime + "ns");

// TODO : 파일 닫기
bufferedInputStream.close();
bufferedOutputStream.close();