반응형

객체 스트림을 사용하기 위해서 우선 객체 파일을 생성합니다.

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 +
                '}';
    }
}

Serializable (직렬화)

 Object 또는 Data를 다른 컴퓨터의 자바 시스템에서도 사용 할수 있도록 바이트 스트림(stream of bytes) 형태로 연속전인(serial) 데이터로 변환하는 포맷 변환 기술을 일컫는다. 그 반대 개념인 역직렬화는(Deserialize)는 바이트로 변환된 데이터를 원래대로 자바 시스템의 Object 또는 Data로 변환하는 기술이다.

객체 클래스(위에서는 Borad)에 Serializable 을 상속받으면 가능

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();

    }
}

우선 FileOutputStream을 사용하여 파일을 생성합니다.

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

 

보조 스트림을 사용합니다.

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

dataOutputStream에는 여러 함수들이 존재합니다.

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

마무리로 .flush()와 .close()를 실행합니다.

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

 

파일 읽기

생성한 파일을 읽기 위해 접근 생성자를 생성합니다.

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

 

보조스트림을 적용하여 기본자료형 기능을 추가해줍니다.

DataInputStream dataInputStream
        = new DataInputStream(fileInputStream);

 

반복문을 실행하여 화면에 출력합니다.

이때 반복문은 2번 실행합니다. 그 이유는 위에 요소를 2개 추가하였기 때문입니다.

        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();

실행결과

홍길동, 95.4, 1
감자바, 90.3, 2

반응형

'Java > Java 이론' 카테고리의 다른 글

objectstream  (0) 2023.10.02
printstream  (0) 2023.10.02
파일 복사 성능 테스트(일반복사 vs 버퍼 사용복사)  (0) 2023.10.02
보조스트림  (0) 2023.09.27
입출력 Stream  (0) 2023.09.27
반응형

일반복사와 버퍼사용복사

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();


    }
}

여기서 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();

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

        // 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 기본 스트림을 사용하여 읽기/쓰기용으로 생성자를 생성합니다.

// 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();

일반 복사를 실행하였을 경우 실행속도는 다음과 같습니다.

버퍼를 사용하지 않았을때 :112719101ns

 

다음은 버퍼를 사용하여 파일을 복사해보겠습니다.

 

먼저 파일 읽기/쓰기용으로 이미지 접근, 복사본 이미지 생성 생성자를 코딩합니다.

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

 

보조스트림을 적용합니다.

보조스트림 적용은 new 보조스트림 생성자안에 매개변수로 기본스트림을 넣어주는 형태입니다.

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

 

다음은 copy함수를 사용하여 소요시간을 측정합니다.

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

마무리로 파일을 닫아줍니다.

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

 

버퍼를 사용하였을 때 복사소요시간은 다음과 같습니다.

버퍼를 사용할때 : 2299000ns

 

즉, 일반 복사를 할 때보다 버퍼를 사용하여 복사하였을 때 성능향상이 있는 것을 알 수 있습니다.

 

버퍼를 사용하지 않았을 때(일반복사) 118145200ns
버퍼를 사용하였을 때 (버퍼 사용 복사) 2299000ns

 

반응형

'Java > Java 이론' 카테고리의 다른 글

printstream  (0) 2023.10.02
보조스트림 : 기본 자료형으로 입출력하기  (0) 2023.10.02
보조스트림  (0) 2023.09.27
입출력 Stream  (0) 2023.09.27
Arrays 클래스  (0) 2023.09.27
반응형
*        보조스트림 : 다른 스트림과 연결되어 편리한 추가 기능을 제공해주는 객체
*        예) 문자 변환, 입출력속도향상, 객체 직렬화 등
*        기능 추가 방법 : new 보조스트림클래스(기본스트림클래스)
*        => 디자인패턴 : 데코레이션 패턴
*        => 예) new 보조스트림클래스2(보조스트림클래스(1기본스트림클래스))
*        1) 문자 변환 : 소스파일이 byte 기반 입출력 파일인데 문자 기능을 추가
*           => OutputStreamWriter, InputStreamReader
*        2) 성능 향상 : 기본적으로 제공하는 버퍼는 크기가 작음
*           => BufferedOutputStream/BufferedInputStream
*        3) 기본자료형 입출력 : InputStream/OutputStream => 1byte, char
*           => DataInputStream/DataOutputStream
*           => 기본자료형 int, double, String 자료형을 사용해서 입출력할 수 있음

 

// 파일 쓰기 함수
public class CharConvertApplication {
    public static void write(String str) throws Exception {
        // TODO : byte 파일 쓰기용 파일 생성
        FileOutputStream fos = new FileOutputStream("src/main/resources/test1.txt");

        // TODO : 보조 스트림 사용 : 문자 기반 객체로 변환 : new 보조스트림(기본스트림)
        Writer writer = new OutputStreamWriter(fos);
        // TODO : 파일에(버퍼) 쓰기
        writer.write(str);
        writer.flush();
        writer.close();
    }

    // 파일 읽기 함수
    public static String read() throws Exception {

        // TODO : 파일을 읽기용으로 접근(기본스트림)
        FileInputStream fileInputStream =
                new FileInputStream("src/main/resources/test1.txt");

        // TODO : 보조스트림 기능 더하기 : new 보조스트림(기본스트림)
        Reader reader = new InputStreamReader(fileInputStream);

        // TODO : 속도 향상 : 배열 만들기
        char[] buffer = new char[100];

        // TODO : 파일 읽기
        int readNum = reader.read(buffer);  // 한번에 100문자 읽기
        reader.close(); // 파일 닫기

        // TODO : char[] -> String 바꾸기
        String data = new String(buffer,0, readNum);

        return data;
    }

    public static void main(String[] args) throws Exception{

        // 파일 쓰기 함수 호출 : 파일 생성(문자 변환 스트림을 사용합니다.)
        write("문자 변환 스트림을 사용합니다.");
        // 파일 읽기 함수 호출
        String data = read();
        System.out.println(data);
    }
}
반응형

'Java > Java 이론' 카테고리의 다른 글

보조스트림 : 기본 자료형으로 입출력하기  (0) 2023.10.02
파일 복사 성능 테스트(일반복사 vs 버퍼 사용복사)  (0) 2023.10.02
입출력 Stream  (0) 2023.09.27
Arrays 클래스  (0) 2023.09.27
Stream 클래스  (0) 2023.09.27
반응형
*      스트림 뜻 : 가상의 통로
*      입출력 스트림(InputStream/OutputStream) : 자바에서는 데이터는 스트림을
*      통해 입출력이 이루어짐, 읽기용(Input)/쓰기용(Output)에 따라 각자 클래스를
*      만듬
*      => 대표 4가지 부모 클래스 소개
*      InputStream : 1byte 기반 입력(==읽기용), 최상위 추상 클래스
*      OutputStream : 1byte 기반 출력(==쓰기용), 최상위 추상 클래스
*      Reader : 문자기반(char:2byte) 입력(==읽기용), 최상위 추상 클래스
*      Writer : 문자기반(char:2byte) 출력(==쓰기용), 최상위 추상 클래스
*      활용 : InputStream/OutputStream : 주로 멀티미디어 파일(동영상, 이미지등)
*            Reader/Writer            : 주로 텍스트 파일에 활용

1Byte 기반 입력/출력

package chap15.sec01.exam01;

import java.io.FileOutputStream;
import java.io.OutputStream;

public class WriteApplication {
    public static void main(String[] args) throws Exception {
//      TODO: 파일 출력용(==쓰기용) 객체 생성
//        자식 클래스 : FileOutputStream
//        사용법: OutputStream outputStream = new FileOutputStream(경로);
//        gradle(빌드) 의 기본경로(root 경로) : build.gradle 파일이 있는 위치
        OutputStream outputStream
                = new FileOutputStream("src/main/resources/test1.db");

        byte a = 10;
        byte b = 20;
        byte c = 30;

//        TODO: 파일에 쓰기 : outputStream.write(값)
//         버퍼(buffer) : 임의의 메모리 배열공간 : 값을 저장
//         장점 : 파일입출력에 바로 접근하는 행위 : 속도가 굉장히 느림
//             => 임시배열(buffer)에 모아놓고 한번에 파일에 쓰기를 함
        outputStream.write(a);
        outputStream.write(b);
        outputStream.write(c);
//        TODO: 버퍼에 내용을 진짜 파일에 쓰기
        outputStream.flush();
//        TODO: 파일 닫기(무조건)
        outputStream.close();
    }
}
배열을 파일에 쓰기
package chap15.sec01.exam02;

import java.io.FileOutputStream;
import java.io.OutputStream;

/**
* packageName : chap15.sec02
* fileName : WriteApplication
* author : GGG
* date : 2023-09-27
* description : 1byte 배열을 파일에 쓰기(출력)
* 요약 :
*
* ===========================================================
* DATE            AUTHOR             NOTE
* —————————————————————————————
* 2023-09-27         GGG          최초 생성 */
public class WriteApplication {
    public static void main(String[] args) throws Exception {
//        TODO : 파일을 쓰기용(출력용)으로 열기
        OutputStream outputStream =
                new FileOutputStream("src/main/resources/test2.db");

//        TODO : 배열 준비
        byte[] array = {10, 20, 30};
//        TODO : 배열 -> 파일에(버퍼) 쓰기 :  outputStream.write(배열)
        outputStream.write(array);
//        TODO : 버퍼 내용 -> 진짜 파일 쓰기
        outputStream.flush();
//        TODO : 파일 닫기
        outputStream.close();
    }
}

 

배열 중 일부 데이터만 파일에 쓰기
package chap15.sec01.exam03;

import java.io.FileOutputStream;
import java.io.OutputStream;

/**
 * packageName : chap15.sec01.exam03
 * fileName : WriteApplication
 * author : GGG
 * date : 2023-09-27
 * description : 배열 중 일부 데이터만 파일에 쓰기
 * 요약 :
 * <p>
 * ===========================================================
 * DATE            AUTHOR             NOTE
 * —————————————————————————————
 * 2023-09-27         GGG          최초 생성
 */
public class WriteApplication {
    public static void main(String[] args) throws Exception{
//      TODO: 파일을 쓰기용(출력용)으로 열기
        OutputStream outputStream =
                new FileOutputStream("src/main/resources/test3.txt");
//      TODO: 배열 일부만 쓰기
        byte[] array = {10,20,30,40,50};
//      TODO: outputStream.write(배열변수, 시작인덱스, 개수)
        outputStream.write(array, 1, 3); // 20,30,40
//      TODO: 버퍼 -> 파일
        outputStream.flush();
        outputStream.close(); // 파일 닫기
    }
}

 

파일 읽기
package chap15.sec01.exam04;

import java.io.FileInputStream;
import java.io.InputStream;

/**
 * packageName : chap15.sec01.exam04
 * fileName : ReadApplication
 * author : GGG
 * date : 2023-09-27
 * description : 1byte 씩 파일 읽기 (byte 파일 : 이진파일(binary file))
 * 요약 :
 * <p>
 * ===========================================================
 * DATE            AUTHOR             NOTE
 * —————————————————————————————
 * 2023-09-27         GGG          최초 생성
 */
public class ReadApplication {
    public static void main(String[] args) throws Exception {
        // TODO : 파일읽기용(==입력용) 파일 접근
        InputStream inputStream =
                new FileInputStream("src/main/resources/test1.db");

        // TODO : 반복문으로 1byte 씩 읽고 화면에 출력하기
        while (true){
            // TODO : 파일 읽기(1byte) => 리턴 : 읽은 값이(1byte) 리턴됨(1byte씩 자동증가)
            //                             => 읽은 값이 파일의 끝이라면 -1이 리턴됨
            int data = inputStream.read();
            // TODO : 반복문 종료조건 : 파일의 끝
            if(data == -1) break;
            // TODO : 화면 출력
            System.out.println(data);
        }

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

    }
}

 

배열의 크기 만큼 파일에서 읽기
package chap15.sec01.exam05;

import java.io.FileInputStream;
import java.io.InputStream;

/**
 * packageName : chap15.sec01.exam05
 * fileName : ReadApplication
 * author : GGG
 * date : 2023-09-27
 * description : 배열의 크기만큼 파일에서 읽기
 * 요약 :
 * <p>
 * ===========================================================
 * DATE            AUTHOR             NOTE
 * —————————————————————————————
 * 2023-09-27         GGG          최초 생성
 */
public class ReadApplication {
    public static void main(String[] args) throws Exception {
        // TODO : 파일 읽기용(입력)으로 접근
        InputStream inputStream =
                new FileInputStream("src/main/resources/test2.db");

        // TODO : 성능향상 : 1byte -> 여러 byte씩 한번에 읽기
        byte[] buffer = new byte[100];

        // TODO : 반복문
        while (true){
            // TODO : 파일 읽기 : buffer(배열크기 만큼)
            //   -> buffer : 파일에서 읽은 내용이 저장
            //   -> 리턴 : 파일에서 읽은 byte 수가 리턴됨, 파일의 끝 : -1
            int data = inputStream.read(buffer);
            if(data == -1) break;   // 종료 조건
            // TODO :  읽은 내용 화면 출력 : buffer 배열 출력, data(읽은 파일 byte 수)
            for (int i = 0; i < data; i++) {
                System.out.println(buffer[i]);
            }
        }
        // TODO : 파일 닫기
        inputStream.close();

    }
}
파일에서 지정된 크기 만큼 파일 읽기
package chap15.sec01.exam06;

import java.io.FileInputStream;
import java.io.InputStream;

/**
 * packageName : chap15.sec01.exam06
 * fileName : ReadApplication
 * author : GGG
 * date : 2023-09-27
 * description : 파일에서 지정된 길이 만큼만 읽기
 * 요약 :
 * <p>
 * ===========================================================
 * DATE            AUTHOR             NOTE
 * —————————————————————————————
 * 2023-09-27         GGG          최초 생성
 */
public class ReadApplication {
    public static void main(String[] args) throws Exception {
        // TODO : 파일 읽기로(입력용) 열기
        InputStream inputStream =
                new FileInputStream("src/main/resources/test3.txt");

        // TODO : 읽기용 배열 크기 지정
        byte[] buffers = new byte[5];

        // TODO : 일부만 읽기 : (인덱스 2번부터 읽어서 3개 저장 : buffers)
        int data = inputStream.read(buffers, 2, 3);

        // TODO : 화면 출력
        if(data != -1) {
            for (int i = 0; i < buffers.length; i++) {
                System.out.println(buffers[i]);
            }
        }
        // TODO : 파일 닫기
        inputStream.close();
    }
}

 

문자기반 입력/출력

한 문자씩 파일에 쓰기(출력)
public class WriteApplication {
    public static void main(String[] args) throws Exception {
        // TODO : 파일 쓰기용(출력용) 생성(문자기반(char) : 2byte)
        //  사용법 : Writer 변수 = new FileWriter("파일생성경로");
        Writer writer = new FileWriter("src/main/resources/test7.txt");
        // TODO : 파일에 쓸 변수
        char a = 'A';
        char b = 'B';
        char c = 'C';
        // TODO : 파일(임시버퍼) 쓰기 : writer.write(변수명);
        writer.write(a);
        writer.write(b);
        writer.write(c);
        // TODO : 임시버퍼 -> 진짜 파일에 쓰기
        writer.flush();
        writer.close();
    }
}

 

배열 전체를 파일에 쓰기
public class WriteApplication {
    public static void main(String[] args) throws Exception {
//        TODO : 파일 열기(문자기반)
        Writer writer = new FileWriter("src/main/resources/test8.txt");

        // TODO : 배열 정의
        char[] array = {'A', 'B', 'C'};
        // TODO : 파일(임시버퍼) 쓰기
        writer.write(array);
        // TODO : 임시버퍼 -> 진짜파일에 쓰기
        writer.flush();
        writer.close();

    }
}

 

배열의 일부분만 파일에 쓰기
public class WriteApplication {
    public static void main(String[] args) throws Exception {
        // TODO : 파일 생성(문자기반)
        Writer writer = new FileWriter("src/main/resources/test9.txt");

        // TODO : 배열 정의
        char[] array = {'A','B','C','D','E'};

        // TODO : 일부만 파일에 쓰기
        writer.write(array, 1, 3);  // BCD
        // TODO : 임시 버퍼 -> 진짜파일에 쓰기
        writer.flush();
        writer.close();



    }
}

 

문자열을 파일에 쓰기
public class WriteApplication {
    public static void main(String[] args) throws Exception {
        // TODO : 파일 생성(문자기반)
        Writer writer = new FileWriter("src/main/resources/test10.txt");

        // TODO : 문자열 준비
        String str = "ABC";
        // TODO : 파일에 쓰기
        writer.write(str);
        // TODO : 임시버퍼 -> 진짜파일에 쓰기
        writer.flush();
        writer.close();
    }
}

 

한 문자씩 읽기
public class ReadApplication {
    public static void main(String[] args) throws Exception {
        // TODO: 파일 읽기용(입력용)으로 열기
        Reader reader = new FileReader("src/main/resources/test7.txt");

        // TODO: 무한 반복문 실행
        while (true){
            // TODO : 한 문자씩 읽기(자동증가) => 리턴 : 아스키코드값이 리턴됨
            int data = reader.read();
            // TODO : 반복문 종료조건 : 파일의 끝 -1
            if(data == -1) break;
            // TODO : 읽은 것을 화면 출력
            System.out.println((char)data);     // 아스키코드값이 문자로 변환
        }
        reader.close(); // 파일 닫기
    }
}

 

배열의 길이 만큼 읽기
public class ReadApplication {
    public static void main(String[] args) throws Exception {
        // TODO : 파일 읽기용으로 접근(문자기반)
        Reader reader =
                new FileReader("src/main/resources/test8.txt");

        // TODO : 버퍼 배열 준비 : 속도 향상 -> 배열 크기만큼 한번에 읽기
        char[] buffer = new char[100];

        // TODO : 무한 반복문
        while (true){
            // TODO : 파일 읽기(배열크기만큼) : buffer에 읽은 내용이 저장됨
            //            리턴 : 읽은 문자수, 파일의 끝은 -1
            int readNum = reader.read(buffer);
            // TODO : 종료 조건
            if(readNum == -1) break;
            // TODO : 화면 출력
            for (int i = 0; i < readNum; i++) {
                System.out.println(buffer[i]);
            }
        }
        reader.close();
    }
}
반응형

'Java > Java 이론' 카테고리의 다른 글

파일 복사 성능 테스트(일반복사 vs 버퍼 사용복사)  (0) 2023.10.02
보조스트림  (0) 2023.09.27
Arrays 클래스  (0) 2023.09.27
Stream 클래스  (0) 2023.09.27
Optional 클래스  (0) 2023.09.27
반응형

Collections 클래스의 유용한 함수들에 대해 알아봅시다!

 

빈 배열 생성하기
public class CollectionsApplication {
    public static void main(String[] args) {
        List list = new ArrayList();        // 빈 배열
    }
}

 

데이터 넣기
System.out.println("--- 데이터 넣기 ---");
Collections.addAll(list, 1,2,3,4,5);
System.out.println(list);   // 1,2,3,4,5

 

배열의 값을 오른쪽으로 이동
//         사용법 : Collections.rotate(자료구조, 이동칸 숫자);
        System.out.println("--- 오른쪽으로 값을 두 칸 이동 ---");
        Collections.rotate(list, 2); // 4,5,1,2,3
        System.out.println(list);

 

배열의 원소값 서로 맞바꾸기
//         사용법 : Collections.swap(자료구조, 원본인덱스번호, 바꿀인덱스번호)
        System.out.println("--- 배열의 원소의 값 서로 맞바꾸기 ---");
        Collections.swap(list, 0, 2);
        System.out.println(list);

 

배열의 원소 무작위로 섞기
System.out.println("--- 배열 원소 무작위로 섞기 ---");
Collections.shuffle(list);
System.out.println(list);

 

오름차순 정렬
System.out.println("--- 오름차순 정렬 ---");
Collections.sort(list); // 오름차순 정렬
System.out.println(list);

 

내림차순 정렬
System.out.println("--- 내림차순 정렬 ---");
Collections.sort(list, Collections.reverseOrder());
System.out.println(list);

 

이진탐색 (미리 오름차순으로 정렬해야 함)
System.out.println("--- 이진탐색 ---");
Collections.sort(list); // 오름차순 정렬
System.out.println(Collections.binarySearch(list, 2));

 

최대/최소값 찾기
System.out.println("--- 최대/최소값 찾기 ---");
System.out.println(Collections.max(list));      // 최대값
System.out.println(Collections.min(list));      // 최소값
반응형
반응형

Arrays 클래스의 유용한 함수들

 

public class ArraysApplication {
    public static void main(String[] args) {
        int[] arr = {0,1,2,3,4};
        int[][] arr2D = { {11,12,13}, {21,22,23}};

    }
}
배열을 문자열로 변환
//        TODO : 1) 배열 -> 문자열로 변환
        System.out.println(Arrays.toString(arr));   // 1차원 배열
        System.out.println(Arrays.deepToString(arr2D));   // 2차원 배열

 

배열 복사
int[] arr2 = Arrays.copyOf(arr, arr.length); // 전체 복사(깊은 복사)
int[] arr3 = Arrays.copyOfRange(arr, 2, 4);     // 2부터 (4-1) 인덱스까지 일부 복사
System.out.println(Arrays.toString(arr));
System.out.println(Arrays.toString(arr3));

 

배열 동등비교
System.out.println(Arrays.equals(arr, arr2));   // true (틀리면 false)

 

배열 오름차순 정렬
char[] chArr = {'A', 'D', 'C', 'B', 'E'};
Arrays.sort(chArr);
System.out.println(Arrays.toString(chArr)); // 결과 출력

 

이진탐색(결과, 조회) : 리턴값 -> 인덱스번호
// 사용시 미리 정렬해야함!!
System.out.println("B의 인덱스 번호 : " + Arrays.binarySearch(chArr, 'B'));

 

결과값

--- 배열 -> 문자열 변환 ---
[0, 1, 2, 3, 4]
[[11, 12, 13], [21, 22, 23]]


--- 배열 복사 ---
[0, 1, 2, 3, 4]
[2, 3]


--- 배열 동등 비교 ---
true


--- 배열 오름차순 정렬 ---
[A, B, C, D, E]


--- 이진탐색 ---
B의 인덱스 번호 : 1

반응형

'Java > Java 이론' 카테고리의 다른 글

보조스트림  (0) 2023.09.27
입출력 Stream  (0) 2023.09.27
Stream 클래스  (0) 2023.09.27
Optional 클래스  (0) 2023.09.27
제네릭  (0) 2023.09.27
반응형
*      1) Stream 은 함수형 프로그래밍에서 차용한 클래스로 내부적으로 반복문이 자동 실행됨
*      2) Stream 은 정렬된 결과를 자료구조(컬렉션프레임워크)으로 결과 내보내기가 가능함
*      3) Stream 은 함수(메소드) 체이닝을 이용 (jquery 사용)
*         예) 함수().함수2()....
*      4) Stream 원본을 조작하지 않고 복사본을 사용함
*      5) Stream 사용규칙 : (1) 정의 (2) 가공 (3) 결과 내보내기 : 3단계 규칙
package chap14.sec01.exam03;

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;

/**
 * packageName : chap14.sec01.exam03
 * fileName : SteamApplication
 * author : GGG
 * date : 2023-09-27
 * description : Stream 클래스 : 함수형 프로그래밍 기법 받아들임
 * 요약 :
 *      1) Stream 은 함수형 프로그래밍에서 차용한 클래스로 내부적으로 반복문이 자동 실행됨
 *      2) Stream 은 정렬된 결과를 자료구조(컬렉션프레임워크)으로 결과 내보내기가 가능함
 *      3) Stream 은 함수(메소드) 체이닝을 이용 (jquery 사용)
 *         예) 함수().함수2()....
 *      4) Stream 원본을 조작하지 않고 복사본을 사용함
 *      5) Stream 사용규칙 : (1) 정의 (2) 가공 (3) 결과 내보내기 : 3단계 규칙
 * <p>
 * ===========================================================
 * DATE            AUTHOR             NOTE
 * —————————————————————————————
 * 2023-09-27         GGG          최초 생성
 */
public class StreamApplication {
    public static void main(String[] args) {
//        TODO : 샘플 ArrayList
        List<String> list = new ArrayList<>();
        list.add("apple");
        list.add("ball");
        list.add("car");
        list.add("daddy");
        list.add("ear");
        list.add("fox");

//        TODO : 단순 출력 : forEach
//         list.forEach(System.out::println);
//         사용법 : 매개변수 -> 실행문(매개변수);     // 람다식(화살표함수)
        list.forEach(s -> System.out.println(s));

//        TODO : map 함수 ( 배열의 값을 조작 : 배열의 개수 동일 )
//         예제 : 리스트 값들을 모두 대문자로 변경
        System.out.println("---- map 함수 ----");
//        TODO : 스트림 사용
//            1) 정의 : list.stream()
//            2) 가공 : .map(s -> s.toUpperCase())
//            3) 결과내보내기 : .collect(Collectors.toList());
//             .collect(자료구조)
//             => Collectors.toList() : 리스트로 내보내기
        List<String> list2 = list.stream()
                .map(s -> s.toUpperCase())
                .collect(Collectors.toList());
//        결과 출력
        list2.forEach(s -> System.out.println(s));

        System.out.println("---- filter 함수 ----");

//        TODO : filter 함수 ( 배열의 값을 조작 : 배열의 개수 다름 )
//         예제 : 문자의 길이가 3자 이상만 뽑아내기
        List<String> list3 = list.stream()
                .filter(s -> s.length() > 3)
                .collect(Collectors.toList());
//        결과 출력
        list3.forEach(s -> System.out.println(s));

        System.out.println("---- array로 내보내기 ----");
//        TODO (참고) array 로 내보내기
        Object[] obj = list.stream()
                .filter(s -> s.length() > 3)
                .toArray(); // 배열로 내보내기
//        결과 출력
        for (Object o: obj) {
            System.out.println((String) o);
        }


    }
}

apple
ball
car
daddy
ear
fox
---- map 함수 ----
APPLE
BALL
CAR
DADDY
EAR
FOX
---- filter 함수 ----
apple
ball
daddy
---- array로 내보내기 ----
apple
ball
daddy

 

 

반응형

'Java > Java 이론' 카테고리의 다른 글

입출력 Stream  (0) 2023.09.27
Arrays 클래스  (0) 2023.09.27
Optional 클래스  (0) 2023.09.27
제네릭  (0) 2023.09.27
날짜 함수  (0) 2023.09.26
반응형

Optional<T> 클래스는 Integer나 Double 클래스처럼 'T'타입의 객체를 포장해 주는 래퍼 클래스(Wrapper class)입니다.

따라서 Optional 인스턴스는 모든 타입의 참조 변수를 저장할 수 있습니다.

 

Optional 객체를 사용하면 예상치 못한 NullPointerException 예외를 제공되는 메소드로 간단히 회피할 수 있습니다.

즉, 복잡한 조건문 없이도 널(null) 값으로 인해 발생하는 예외를 처리할 수 있게 됩니다.

 

Optional 객체의 생성

of() 메소드나 ofNullable() 메소드를 사용하여 Optional 객체를 생성할 수 있습니다.

 

public class OptionalApplication {
    public static void main(String[] args) {
//        TODO : Optional 객체
//         사용법 : Optional.of(값) : Optional 객체에 들어감
//        String str = "abcde";
        Optional<String> optional = Optional.of("abcde");

//        TODO : 가져오기(꺼내기) : 옵셔널객체변수.get()
        System.out.println(optional.get()); // abcde 출력

//        TODO : 정수 넣기
        Optional<Integer> optional2 = Optional.of(0);

//        TODO : 빈것 넣기
        Optional<Object> optional3 = Optional.empty(); // 빈 것

//        TODO : 현재 옵셔널 객체에 값이 있는지 확인 : isPresent() : 있으면 true / 없으면 false
        System.out.println(optional2.isPresent());  // true
        System.out.println(optional3.isPresent());  // false

//        TODO : 빈 것 또는 null 일 경우 아래와 같이 코딩
//          옵셔널객체변수.orElse("대체할 문자열");
        System.out.println(optional3.orElse("없음")); // null 일 경우 없음으로 출력


    }
}
반응형

'Java > Java 이론' 카테고리의 다른 글

Arrays 클래스  (0) 2023.09.27
Stream 클래스  (0) 2023.09.27
제네릭  (0) 2023.09.27
날짜 함수  (0) 2023.09.26
JAVA API 함수  (0) 2023.09.26
반응형

Generic


향상된 배열에서 자료를 추가할 때 자료형을 제한하는 것을 의미합니다.

자바에서 제네릭(generic)이란 데이터의 타입(data type)을 일반화한다(generalize)는 것을 의미합니다.

제네릭은 클래스나 메소드에서 사용할 내부 데이터 타입을 컴파일 시에 미리 지정하는 방법입니다.

 

제네릭에 대한 예제를 살펴봅시다. ^o^

 

package chap14.sec01.exam01;

import java.util.ArrayList;
import java.util.Arrays;

public class GenericApplication {
    public static void main(String[] args) {
//        TODO: 여기부터 코딩
//    TODO : 제네릭 : 향상된 배열에서 자료를 추가할 때 자료형을 제한하는 것을 의미
//        사용법 : List<제한할자료형> list = new ArrayList<>();
//        부모클래스 : product, 자식 : Tv, Audio 클래스
        ArrayList<Product> productArrayList = new ArrayList<>();
        ArrayList<Tv> tvArrayList = new ArrayList<>();
//        TODO : 1) 아래 에러 사항
//        ArrayList<Product> tvArrayList = new ArrayList<Tv>(); // 이렇게 사용하면 안됨!

//        TODO : 2) productArrayList : 부모 클래스 배열에 자식 넣기 가능할까?
        productArrayList.add(new Tv());     // ok 가능
        productArrayList.add(new Audio());     // ok 가능

//        TODO : 3) tvArrayList : 당연히 Tv 객체만 배열에 추가 가능함
        tvArrayList.add(new Tv());

        System.out.println("---- 함수의 매개변수에 제네릭 사용 ----");
        printAll(productArrayList); // 매개변수의 제네릭으로 Product로 제한되어있기 때문
//        TODO : 에러발생 : 부모라도 자식 클래스는 사용안됨 : 대상 클래스(Product)만 가능
//        printAll(tvArrayList);  // 오류 발생 : Product의 자식들 사용불가

        System.out.println("---- 제네릭의 특수한 형태 ----");
        System.out.println("---- <? extend Tv> ----");
//        TODO : <? extend Tv> : Tv의 자식 클래스만 가능함(부모는 불가)
        printAll2(tvArrayList); // 가능
//        printAll2(productArrayList);    // 불가 

        System.out.println("---- <? super Product> ----");
//        TODO : <? super Product> : Product의 부모 클래스만 가능함(자식클래스는 불가)
        printAll3(productArrayList);    // 가능
//        printAll3(tvArrayList); // 불가, 자식클래스는 사용불가

        System.out.println("---- <?> ----");
//        TODO : <?> : 모든 자료형이 가능
        printAll4(productArrayList); // ok
        printAll4(tvArrayList); // ok

    }


    public static void printAll(ArrayList<Product> list) {      // 함수의 매개변수로 제네릭 사용
        for(Object p : list) {
            System.out.println(p);
        }
    }

    public static void printAll2(ArrayList<? extends Tv> list) {
        for(Object p : list) {
            System.out.println(p);
        }
    }

    public static void printAll3(ArrayList<? super Product> list) {
        for(Object p : list) {
            System.out.println(p);
        }
    }

    public static void printAll4(ArrayList<?> list) {
        for(Object p : list) {
            System.out.println(p);
        }
    }
}
반응형

'Java > Java 이론' 카테고리의 다른 글

Stream 클래스  (0) 2023.09.27
Optional 클래스  (0) 2023.09.27
날짜 함수  (0) 2023.09.26
JAVA API 함수  (0) 2023.09.26
예외처리  (0) 2023.09.26
반응형

Date

package chap11.sec02.exam01;

import java.text.SimpleDateFormat;
import java.util.Date;

/**
 * packageName : chap11.sec02.exam01
 * fileName : DateApplication
 * author : ds
 * date : 2022-10-05
 * description : Date ( 날짜 함수 : 현재 날짜 ), 과거 코딩
 *               월 : 0 ~ 11까지
 *
 * ===========================================================
 * DATE            AUTHOR             NOTE
 * —————————————————————————————
 * 2022-10-05         ds          최초 생성
 */
public class DateApplication {
    public static void main(String[] args) {
//      TODO : 날짜함수
        Date now = new Date();              // 현재날짜 가져오기
        String strNow = now.toString();     // 현재날짜 문자열로 변환
        System.out.println(strNow);         // 출력하기

//      TODO : 날짜포맷(대소문자구분) : yyyy-MM-dd hh:mm:ss  (vs SQL : YYYY-MM-DD HH24:MI:SS)
        SimpleDateFormat simpleDateFormat
                = new SimpleDateFormat("yyyy년 MM월 dd일 hh시 mm분 ss초");
        String strNow2 = simpleDateFormat.format(now);  // 기본포맷 -> 사용자정의 포맷으로 변경
        System.out.println(strNow2);
    }
}

-------- 실행결과
Tue Sep 26 17:23:25 KST 2023
2023년 09월 26일 05시 23분 25초

Calendar

package chap11.sec02.exam02;

import java.util.Calendar;

/**
 * packageName : chap11.sec02.exam02
 * fileName : CalendarApplication
 * author : ds
 * date : 2022-10-05
 * description : Calendar ( (날짜객체 : Date -> Calendar(날짜연산기능) ), 과거 코딩
 *               월 : 0 ~ 11까지
 * ===========================================================
 * DATE            AUTHOR             NOTE
 * —————————————————————————————
 * 2022-10-05         ds          최초 생성
 */
public class CalendarApplication {
    public static void main(String[] args) {
//        TODO : 날짜 연산 객체
        Calendar now = Calendar.getInstance();  // 싱글톤(디자인패턴) : 공유(정적)객체
//        TODO : Calendar객체변수.get(날짜상수들) : 날짜 정보를 얻을 수 있음
        int year = now.get(Calendar.YEAR);          // 년도
        int month = now.get(Calendar.MONTH) + 1;    // 월(0 ~ 11)
        int week = now.get(Calendar.DAY_OF_WEEK);   // 요일(1(일요일) ~ 7(토요일))
        int day = now.get(Calendar.DAY_OF_MONTH);   // 일
//        TODO : 현재 날짜 정보 출력
        System.out.println(year + "년");
        System.out.println(month + "월");
        System.out.println(week + "요일");
        System.out.println(day+ "일");
//        TODO : 현재 시간 정보
        int hour = now.get(Calendar.HOUR);          // 시
        int minute = now.get(Calendar.MINUTE);      // 분
        int second = now.get(Calendar.SECOND);      // 초
//        TODO : 결과 출력
        System.out.println(hour + "시");
        System.out.println(minute + "분");
        System.out.println(second + "초");
    }
}

---- 실행결과
2023년
9월
3요일
26일
5시
32분
50초

 

LocalDate, LocalTime

package chap11.sec02.exam03;

import java.time.LocalDate;
import java.time.LocalTime;

/**
 * packageName : chap11.sec02.exam03
 * fileName : LocalDateApplication
 * author : GGG
 * date : 2023-09-26
 * description : 컴퓨터의 현재 날짜를 가져와서 출력, LocalDate, LocalTime
 *               JAVA 8 버전부터 지원(현재 많이 사용됨)
 * 요약 :
 * <p>
 * ===========================================================
 * DATE            AUTHOR             NOTE
 * —————————————————————————————
 * 2023-09-26         GGG          최초 생성
 */
public class LocalDateApplication {
    public static void main(String[] args) {
//      TODO : 날짜 가져오기 객체
        LocalDate localDate = LocalDate.now();  // 현재날짜 가져오기
        System.out.println(localDate);  // 결과 출력

//      TODO : 시간 가져오기 객체
        LocalTime localTime = LocalTime.now();  // 현재시간 가져오기
        System.out.println(localTime);  // 결과 출력
    }
}

--- 결과
2023-09-26
17:40:17.860481900

 

반응형

'Java > Java 이론' 카테고리의 다른 글

Optional 클래스  (0) 2023.09.27
제네릭  (0) 2023.09.27
JAVA API 함수  (0) 2023.09.26
예외처리  (0) 2023.09.26
자료구조 - Stack / Queue  (0) 2023.09.26

+ Recent posts