국비학원 13일차) HashMap, Iterator, IO

오늘 아파서 빠져가지고...(병원 세군데 감ㅠㅠ)

진도 어디까지 뺐는지 듣고 따로 혼자 정리해보았다 ㅠ

 

 

<HashMap>

순서X 중복(키X 값O)

key와 value를 하나의 배열로 다룬다

 

key와 value는 각각 Object 타입이라 객체 저장 가능하지만

key에는 보통 String을 대문자나 소문자로 통일해서 사용한다

 

키는 저장된 값을 찾는데 사용하는 거라

컬렉션 내에서 "유일"해야하기 때문에 중복 허용 안한다

하지만 값은 중복이 가능하다!!

 

만약 저장할 때,

같은 키를 두번 사용해서 다른 값을 저장했다면

마지막에 넣은 값으로 덮어씌워진다

예)

map.put("holiday", "1234")

map.put("holiday","0000")

holiday 키의 값은 000이 됨(1234에 덮어씌워짐)

 

Set으로 변환 후 Iterator에 넣어서 한번에 출력 가능하다!

 

 

<Iterator>

컬렉션에 저장된 요소에 접근하는 데 사용되는 "인터페이스"

컬렉션에는 List와 Set이 있으니 얘네 둘을 같이 넣어서 읽어올 수도 있다

Map은 Set으로 변환 후 가져와야 한다

 

hasNext() - 가져올 값이 있는가?를 boolean으로 반환

next() - 순서대로 가져온다

 

얘는 일회용이어서

끝까지 다 읽어놓으면 다시 읽어올 수 없음(값을 다시 넣어줘야 함)

 

보통 while문으로 읽어온다

 

Iterator it = list.Iterator();

        while(it.hasNext()) {

            Object obj = it.next();

            System.out.println(obj);

        }

 

Map을 읽을 때는?

keySet() 이나 EntrySet()을 이용해

키와 값을 각가 따로 Set형대로 얻어온 후 쓸 수 있다

 

        Map map = new HashMap();
        Iterator it = map.entrySet().iterator();
        
//        Set eSet = map.entrySet();
//        Iterator it = eSet.iterator(); //위에 한줄을 두줄로 풀어낸 것

 

 

 

 

<IO> 바이트 기반 스트림, 문자 기반 스트림

 

스트림이란?

두 대상을 연결하고 데이터를 전송해주는 "연결 통로"

 

<바이트 기반 스트림>

InputStream 읽기

OutputStream 쓰기

1byte씩 읽어오거나 쓰는 특징이 있다

 

ByteArraysInputStream

read() 1byte를 읽어 온다, 더 이상 읽을 게 없으면 -1 반환

read(byte[] b) b 크기만큼 읽어서 채우고, 읽은 바이트의 "수" 반환

read(byte[] b, int off, int len) b[off]부터 len까지만 읽는다

ㄴ (b[10],3,5) -> b[3]부터 5개 까지만 저장 [3][4][5][6][7]

close() 스트림 닫고 사용 자원 반환

 

ByteArraysOutputStream

write(int b) 1바이트씩 출력(하나씩 출력)

write(byte[] b) b의 모든 바이트 출력(배열 저장 내용 전부)

write(byte[] b,int off,int len) b[off]부터 len개의 바이트 출력

flush() 버퍼 잔류 모든 바이트 출력

close() 스트림 닫고 사용 자원 반환

 

close() 는 필수 !!

 

package practice01;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.util.Arrays;

public class Stream01 {
    public static void main(String[] args) {

        byte[] inSrc = {0,1,2,3,4,5,6,7,8,9};
        byte[] outSrc = null;

        ByteArrayInputStream input = null; //입력 Input
        ByteArrayOutputStream output = null; //출력 Output

        input = new ByteArrayInputStream(inSrc); //inSrc 배열을 input(ByteArrayInputStream)에 담음
        output = new ByteArrayOutputStream(); //출력하기 위해 OutputStream 생성

        int data=0; //입출력할 때 매개(?)로 사용할 변수

        while((data=input.read())!=-1) { //input을 data에 넣고 하나씩 읽음(인트에 1byte씩(하나씩) 넣음)
            output.write(data); //output에 데이터를 하나씩 씀(스트림에)
            System.out.print(1); //10번 돔(0~9)
        }

        System.out.println();

        outSrc = output.toByteArray(); //스트림의 내용을 byte배열로 반환한다
        System.out.println("Input Source"+ Arrays.toString(inSrc));
        System.out.println("Output Source"+ Arrays.toString(outSrc));

        

    }
}

 

 

package practice01;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.util.Arrays;

public class Stream02 {
    public static void main(String[] args) {

        byte[] inSrc = {0,1,2,3,4,5,6,7,8,9};
        byte[] outSrc = null;
        byte[] temp = new byte[10];

        ByteArrayInputStream input = null;
        ByteArrayOutputStream output = null;

        input = new ByteArrayInputStream(inSrc); //인풋스트림에 inSrc 바이트 배열 담음
        output = new ByteArrayOutputStream();

        input.read(temp,0, temp.length); //temp의 index0부터 temp길이(10개) 까지 입력받음(temp에 넣음)
        output.write(temp,5,5); //temp의 인덱스5부터 5개 읽음 5,6,7,8,9

        outSrc = output.toByteArray(); //아웃풋스트림에 있는 데이터를 바이트 배열로 outSrc에 씀

        System.out.println("Input Source : "+ Arrays.toString(inSrc));
        System.out.println("temp : "+ Arrays.toString(temp));
        System.out.println("Output Source : "+ Arrays.toString(outSrc)); //5부터 5개만 읽었기에 5개만 넣어짐



        //인풋 스트림은 연결통로일뿐인가?에 대한 의문으로
        //스트림에 데이터가 계속 남아있나?궁금해서 써보았다

        byte[] tmp = new byte[10]; //데이터를 담을 새 배열

        input.read(tmp,0, tmp.length); //인풋 스트림에 있는 데이터를 tmp에 넣는다
        System.out.println(Arrays.toString(tmp)); //데이터가 있으면 써졌겠지?

    }
}

 

package practice01;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.util.Arrays;

public class Stream03 {
    public static void main(String[] args) {

        byte[] inSrc = {0,1,2,3,4,5,6,7,8,9};
        byte[] outSrc = null;
        byte[] temp = new byte[4];

        ByteArrayInputStream input = null;
        ByteArrayOutputStream output = null;

        input = new ByteArrayInputStream(inSrc); //인풋스트림에 inSrc 바이트 배열 담음
        output = new ByteArrayOutputStream();

        System.out.println("Input Source : "+Arrays.toString(inSrc)); //inSrc배열을 출력

        try {
            while(input.available()>0) { //스트림이 읽어올 수 있는 데이터 크기가 0일때까지 돌림
                input.read(temp); //input에 있는 걸 temp에 담고
                output.write(temp); //담은 걸 그대로 output에 쓸것임

                outSrc = output.toByteArray(); //output에 있는 걸 outSrc 배열에 넣음
                printArrays(temp, outSrc); //temp와 outSrc배열 출력(한바퀴씩)
            }
        } catch(IOException e) {

        }
    }

    //마지막 아웃풋소스가 0,1,2,3,4,5,6,7,8,9,6,7 인 이유?
    //왜냐하면 read가 읽을 때, 원래 있던 것에 덮어 씌우고 읽음
    //그래서 8,9를 담고 더 담을 게 없으니까 기존에 있던 6,7도 함께 넣은 것임
    //이 사태를 방지하려면 다음과 같이 코드를 작성해야 한다

//    while(input.available()>0) {
//        int len = input.read(temp); //tmp를 '하나'씩 읽을 int len 선언
//        output.write(temp, 0, len); //tmp[0]부터 '하나'씩만 output에 쓴다 그러면 배열에 한개씩 담아짐
//
//        outSrc = output.toByteArray();
//        printArrays(temp, outSrc);

    static void printArrays(byte[] temp, byte[] outSrc) {
        System.out.println("temp : "+ Arrays.toString(temp)); //temp배열 출력
        System.out.println("Output Source : "+ Arrays.toString(outSrc)); //outSrc배열 출력
    }
}

 

<문자 기반 스트림>

char는 2바이트라서, 문자 기반 스트림을 이용해야 함

 

Reader

read() 1개의 문자 읽고 리턴(더 이상 읽을 문자 없으면 -1)

read(char[] c) 문자를 읽어 한 자씩 배열에 저장하고 읽은 문자 수 리턴

read(char[] c, int off,int len) c[off]부터 len개만큼 읽기

close() 입력 스트림 닫고, 사용 메모리 해제

 

Writer

write(int c) 매개값인 한 문자 출력

write(char[] c) 배열 모든 문자 출력

write(char[] c, int off,int len) c[off]부터 len개의 문자 출력

write(String str) 매개값인 문자열 출력

flush() 버퍼 잔류 문자 모두 출력(비움)

clost() 출력 스트림 닫고 메모리 해제

 

 

 

FileInputStream 파일 입력 스트림

FileOutputStream 파일 출력 스트림

 

package practice01;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class Stream04_F {
    public static void main(String[] args) throws IOException {
        //읽어올 파일 가져옴
        FileInputStream fis = new FileInputStream("C:\\Users\\admin\\Desktop\\test.txt");

        int data = 0; //파일을 읽어들일 변수 선언

        while((data=fis.read())!=-1) { //데이터를 1byte씩 읽어서 int형 data에 저장, -1을 반환하면(읽을게없으면) 종료
            char c = (char)data; //받은 data를 char로 강제타입변환
            System.out.print(c); //읽어들인 내용을 출력
        }

    }
}

 

package practice01;

import java.io.*;

public class Stream05_F {
    public static void main(String[] args) {

        try {
            FileInputStream fis = new FileInputStream("C:\\Users\\admin\\Desktop\\test.txt"); //복사할 파일
            FileOutputStream fos = new FileOutputStream("C:\\Users\\admin\\Desktop\\testTo.txt"); //붙여넣을 파일

            int data=0;
            while((data=fis.read())!=-1) { //data로 fis의 데이터 하나씩 읽는다
                fos.write(data); //읽은 데이터를 fos에 바로 붙여넣는다
            }
            fis.close(); //스트림 닫아주기
            fos.close();
        } catch(IOException e) {
            e.printStackTrace();
        }
        char c = '1';

        //사실, 텍스트 파일을 다루는 경우엔,
        //문자 기반 스트림 FileReader/FileWriter 가 더 좋다

    }
}

 

<보조 스트림> 스트림 기능 향상, 새로운 기능 추가

 

보조스트림 참조변수 = new 보조스트림(입력스트림)

 

1.InputStream is = new FileInputStream //입력스트림(File)생성

2.InputStream reader = new InputStreamReader(is) //보조스트림에 입력스트림 대입

3.BufferedReader br = new BufferedReader(reader) //보조스트림 또 연결

 

 

<BufferedInput(Output)Stream> 성능 향상 스트림

프로그램이 입출력 소스와 직접 작업하지 않고

중간 메모리 버퍼와 작업하여 실행 성능 향상

 

프로그램 ----->메모리 버퍼----->하드디스크(한번에 전송)

데이터1개  ----->000000(여기다가 모음)--------->하드디스크

출력도 마찬가지로 성능 Up!!!

행 단위로 문자열 읽는 readLine() 메소드도 제공

 

package practice01;

import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class Stream06_FB {
    public static void main(String[] args) {
        try {
            FileOutputStream fos = new FileOutputStream("C:\\Users\\admin\\Desktop\\test.txt"); //출력할 파일
            BufferedOutputStream bos = new BufferedOutputStream(fos, 5); //버퍼 크기를 5로 한다

            for(int i='1';i<='9';i++) { //test.txt에 1부터 9까지 출력한다 '' 아스키코드로 인식
                bos.write(i);
            }
        } catch(IOException e) {
            e.printStackTrace();
        }

    }
}

 

package practice01;

import java.io.FileInputStream;
import java.io.FileReader;
import java.io.IOException;

public class Stream07_FRW {
    public static void main(String[] args) {

        try {
            String fileName = "C:\\Users\\admin\\Desktop\\test.txt";
            FileInputStream fis = new FileInputStream(fileName); //byte 기반 스트림
            FileReader fr = new FileReader(fileName); //문자 기반 스트림, 특정 인코딩으로 유니코드로 변환해줌

            int data=0;

            while((data=fis.read())!=-1) {
                System.out.print((char)data); //바이트 기반으로 받을 때는 한글 입력X
            }
            System.out.println();
            fis.close();

            while((data=fr.read())!=-1) { //유니코드간의 변환을 자동으로 처리해준다
                System.out.print((char)data); //문자 기반으로 받을 땐 한글 OK
            }
            System.out.println();
            fr.close();
        } catch (IOException e) {
            e.printStackTrace();
        }

    }
}

package practice01;

import java.io.*;

public class Stream08_FRW {
    public static void main(String[] args) throws Exception {
        BufferedReader br = new BufferedReader(new FileReader("C:\\Users\\admin\\Desktop\\test.txt"));
        //BufferedReader에 바로 FileReader객체 넣어서 사용 가능!!
        int lineNo = 1; //줄 번호를 알려줄 변수
        while (true) {
            String str = br.readLine(); //readLine() <-문자열을 한줄 읽어오는 메소드!
            if(str==null) break; //읽은 문자열이 없다면 멈춤
            System.out.println(lineNo+"\t"+str); //줄번호 띄어쓰기 한줄내용
            lineNo++; //한번 돌때마다 다음 줄이란 걸 알려주기 위해 +1함
        }
        br.close(); //다 실행되면 버퍼 닫기 필수!
    }
}

<File> - 기본적이면서 가장 많이 사용하는 입출력 대상

File 클래스를 통해 파일과 디렉토리를 다룰 수 있다

 

File file = new File("파일주소/파일이름")

ㄴ객체를 생성했다고 해서 파일/디렉토리가 생성되는 건 아님(없어도 예외 발생X)

 

file.exists() 로 파일이나 폴더가 존재하는지 알아내야 한다, 없다면?

file.createNewfile() 로 새로운 파일 생성!!

 

<Files> - 정적 메소드(static)으로 구성, 객체 생성 필요XX

운영체제의 파일 시스템에게 파일 작업 수행하도록 위임

 

<복사,생성,이동,삭제,존재,검색,비교,속성,디렉토리검색,데이터입출력> 가능

ㄴ매개값으로 Path 객체 받음(파일/디렉토리 경로 정보)

 

Path path = paths.get("파일경로")

 

 

 

 

 

-----예습

 

<람다식> 메서드를 하나의 식으로 표현한 "익명함수"

 

메서드에 이름과 반환 타입을 제거하고, 매개변수 선언부와 몸통 사이에 -> 추가

반환값이 있는 메서드? return문 대신 식으로 표현(; 안붙임)

매개변수 타입이 추론 가능한 경우 생략 가능(거의 대부분OK)

(a,b) -> a>b ? a:b

 

선언된 매개변수가 단 하나? 괄호() 생략 (단, 매개변수 타입 있으면 생략 불가)

a -> a*a //OK

int a -> a*a //에러

 

괄호{} 안의 문장이 하나면 괄호 생략OK

(name,i) -> System.out.println(name+"="+i)

단, return문이면 괄호 생략 불가

 

 

그렇다면, 람다식을 어떻게 써야할까???(이름이 없잖아~)

 

<함수형 인터페이스> - 람다식을 다루기 위한 인터페이스

@FunctionalInterface // 함수형 인터페이스란 걸 알려주는 애너테이션

interface MyFuntion{ public abstract int max(int a,int b);} //함수형 인터페이스는 반드시 하나의 추상 메서드만 가지고 있음

 

MyFunction f = (a,b) -> a>b ? a:b //라고 선언한 뒤

f.max(4,5) //라고 쓰면 됨

왜????? 얘가 완성한 메서드(람다식) 이름이 인터페이스에 선언되어있음!!(여기선 max)

그래서 f.max로 쓰면 되는 것

 

 

매개변수 타입이 함수형?

void aMethod(MyFunction f) { f.myFunction(); } //MyFunction에 정의된 메서드 호출

aMethod( () -> System.out.println("My Method()")); //람다식을 매개변수로!!

 

반환 타입이 함수형??

MyFunction myMethod() { return () -> {} } //람다식을 직접 반환함

 

 

Collections.sort(list, (s1,s2) -> s1.compare(s2) ) <-람다식

Comparator은 함수형 인터페이스임(!!) 그래서 람다식 사용 가능

 

 

(하지만 람다식은...잘 안 쓰인다고 들었음 ㅠㅠ

너무 남발하면 오히려 코드를 못알아보기 때문)

 

 

 

public class Lamda01 {
    public static void main(String[] args) {
        Student s1 = new Student("휴일",1,5);
        Student s2 = new Student("강일",1,3);
        Student s3 = new Student("나일",2,2);
        Student s4 = new Student("다일",2,7);

        List<Student> list = new ArrayList<Student>();

        list.add(s1);
        list.add(s2);
        list.add(s3);
        list.add(s4);

        Collections.sort(list, (s6,s5) -> s5.getBan() - s6.getBan()
        );

        Collections.sort(list, new Comparator<Student>() { //람다식 안 씀
                    @Override
                    public int compare(Student o1, Student o2) {
                        if(o1.getBan()==o2.getBan()) {
                            return o1.getNum()-o2.getNum();
                        } else {
                           return o1.getBan()-o2.getBan();
                        }
                    }
                }
        );

        for(Student s : list) {
            System.out.println(s);
        }

        Collections.sort(list, (s11,s22) -> s11.getName().compareTo(s22.getName())); //람다식 씀(간편)

        for(Student s : list) {
            System.out.println(s);
        }



    }