Input/Output (io)

이현주·2023년 8월 2일
0

JAVA

목록 보기
4/12
post-thumbnail

File

java.io.File 클래스

  1. 파일, 디렉터리(폴더) 를 관리하는 클래스
  2. 파일, 디렉터리를 생성/삭제가 가능
  3. 파일, 디렉터리의 각종 정보(이름,크기, 최종수정일 등)을 확인 할 수 있음

경로 작성방법

  1. 윈도우 : 백슬래시(), Java에서 백슬래시 입력하는 방법(\)
  2. 리눅스 : 슬래시(/)
  3. java.io.File 클래스에는 플랫폼에 따라서 경로구분자를 자동으로 바꿔주는 separator 필드 값이 있음

디렉터리 생성/ 삭제
mkdirs()

//디렉터리 생성/ 삭제
		//경로 구분자
		String sep=File.separator;
		
		//File 객체 선언/생성
		File dir= new File("C:"+sep+"storage");//C드라이브아래 stroage디렉터리
		
		//C:\storage 디렉터리가 없으면 만들고 있으면 지우기
		if(dir.exists()==false)
		{
			dir.mkdirs();
			System.out.println(dir.getPath()+"디렉터리 생성 성공");
		}
		else {
			dir.delete();//지금 바로 지운다
			//dir.deleteOnExit(); 자바의 실행이 끝나면 지운다.
			System.out.println(dir.getPath()+"디렉터리 삭제 성공");
		}

}


파일 생성/삭제

createNewFile()

//파일 생성/삭제
		
		try {
			
			
			//디렉터리를 File 객체로 생성
			
			File dir=new File("C:/storage");//Windows 플랫폼에서도 슬래시가 인식됨 
		
			if(!dir.exists())
			{
				dir.mkdirs();
				System.out.println(dir.getPath()+"디렉터리 생성 성공");
			}
			
			//파일을 객체로 생성
			File file =new File(dir,"myfile.txt");
			
			
			//파일이 있으면 지우고 없으면 생성
			if(file.exists())
			{
				file.delete();
				System.out.println(file.getPath()+"파일 삭제 성공");
				
			}
			else {
				file.createNewFile(); //반드시 예외처리를 해야하는 코드(Checked Exception인 IOException 발생)
				System.out.println("myfile.txt 파일 생성 완료");
			}
		
			
		
		
		}catch (IOException e) {
	 e.printStackTrace();
		}

파일,디렉터리 정보확인

listFiles()    : 모든 File 객체를 저장한 File[] 반환
getName()      : 이름 반환
getParent()    : 저장된 디렉터리 반환
getPath()      : getParent() + getName()
lastModified() : 최종수정일을 long 타입으로 반환
length()       : 크기를 long 타입의 바이트 단위로 반환
isDirectory()  : 디렉터리이면 true 반환
isFile()       : 파일이면 true 반환
 		//디렉터리를 File 객체로 생성
		File dir=new File("C:/Program Files/Java/jdk-11");
		
		
		//디렉터리에 있는 모든  File 객체(파일, 디렉터리) 가져오기
		File[] files=dir.listFiles();
		
		//디렉터리에 있는 모든 파일 객체 정보 확인하기
		for(int i=0;i<files.length;i++)
		{
			//개별 File 객체
			File file=files[i];
			
			//출력 결과를 저장할 StringBuilder 생성
			StringBuilder sb= new StringBuilder();
			
			//File 객체 이름
			sb.append(String.format("%-15s",file.getName() ));
			
			//File 객체 최종 수정일
			long lastModified=file.lastModified();
			String strlastModified=new SimpleDateFormat("yyyy-MM-dd a h:mm").format(lastModified);
			sb.append(String.format("%-20s", strlastModified));
			
			long size= file.isFile()?file.length():0;//파일은 바이트 단위로 저장, 디렉터리면 크기를 표시할 필요없어서0
			long kbsize=(size/1024)+(size%1024!=0?1:0);
			
			if(size!=0)
			{
				sb.append(String.format("%10s",kbsize+"KB"));
			}
		// StringBuilder 객체를 String 으로 변환
			String str=sb.toString();
			
			//출력
			System.out.println(str);
			
			
		
		}
		

OutputStream 클래스

java.io.OutputStream 클래스

  1. 바이트 기반의 출력 클래스이다.

  2. 출력단위

    1) int
    2) byte[]

FileOutputStream

 
 	//디렉터리를 File 객체로 만들기
		File dir=new File("C:storage");
		
		if(!dir.exists())
		{
			dir.mkdirs();
			System.out.println(dir.getPath()+"디렉터리가 생성되었습니다.");
		}
		
		//파일 객체로 만들기
		File file=new File(dir,"ex01.dat");
		
		
		//파일 출력 스트림 선언
		FileOutputStream fout=null;
		
		try {
			//파일 출력 스트림 생성
			//1.생성모드: 언제나 새로 만든다(덮어쓰기) 						new FileOutputStream(file)
			//2. 추가모드: 새로만들거나. 기존 파일에 추가한다.		new FileOutputStream(file,true)
			fout= new FileOutputStream(file);
			
			int c='A';
			String s="pple"; 
			byte[] b= s.getBytes();// byte[] : String 을 byte[]로 변환
			
			
			//출력
			fout.write(c);
			fout.write(b);
			
			}catch (IOException e) {

			e.printStackTrace();
			
			}finally {
				try {
					if(fout !=null)
					{
						fout.close();//출력스트림은 반드시 닫아줘야함.(반드시 예외처리가 필요한 코드)
					}
					
				}catch (IOException e) {
					e.printStackTrace();
				}
			}

	//디렉토리 파일객체로 만들기
		File dir= new File("C:/storage");
		if(!dir.exists())
		{
			dir.mkdirs();
			System.out.println(dir.getPath()+"디렉토리가 생성됐습니다");
		}
		
		//파일을 파일객체로 만들기
		File file =new File(dir,"ex02.dat");
		
		//파일 스트림 선언
		FileOutputStream fout=null;
		
		try {
		//파일 스트림 생성(반드시 예외처리가 필요)
			fout=new FileOutputStream(file);
			
			
			String s="파일스트림생성";
			byte[]b=s.getBytes("UTF-8"); //String 을 byte[]로 변환
			
			//출력
			fout.write(b);
		}
		catch (IOException e) {
			e.printStackTrace();
		}finally {
			
			try {
				
				if(fout!=null)
				{
					fout.close();
					
				}
			} catch (IOException e) {
				e.printStackTrace();
				
				
			}
		}

java.io.DataOutputStream 클래스

1.int,double,Strng 등의 변수를 그대로 출력하는 출력스트림이다.
2.보조 스트림이므로 메인스트림과 함께 사용한다.

		//디렉토리 File 객체로 만들기
		
		File dir =new File("C:/storage");
		if(!dir.exists()) {
			dir.mkdirs();
		}
		
		//파일을 File 객체로 만들기
		File file =new File(dir,"ex04.dat");
		
		//데이터출력스트림 선언
		DataOutputStream dout=null;
		
		try {
			//데이터출력스트림 생성(반드시 예외처리 필요)
			dout=new DataOutputStream(new FileOutputStream(file));
		
			//출력할 데이터 (파일로 보낼 데이터)
			String name="tom";
			int age=50;
			double height=180.5;
			String school="가산대학교";
			
			
			//출력(파일로 데이터 보내기)
			dout.writeChars(name);// dout.writeChar('t'), dout.writeChar('o'), dout.writeChar('m')
			dout.writeInt(age);
			dout.writeDouble(height);
			dout.writeUTF(school);
			
			System.out.println(file.getPath()+"파일크기:"+file.length()+"바이트"
					);
		
		}catch (IOException e) {

		}finally {
			try {
				
				if(dout!=null)
				{
					dout.close();
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
		}

java.io.ObjectOutputStream 클래스

1.객체를 그대로 출력하는 출력스트림이다.
2. 직렬화(Serializable)된 객체를 보낼 수 있다.
3. 보조스트림이므로 메인스트림과 함께 사용한다.

직렬화(Serializable) 처리하기
1. java.io.Serializable 인터페이스를 구현 (implements) 한다.
2. long serialVersionUID 필드 값을 생성(generate)한다.

// 디렉터리를 File 객체로 만들기
   File dir = new File("C:/storage");
   if(!dir.exists()) {
     dir.mkdirs();
   }
   
   // 파일을 File 객체로 만들기
   File file = new File(dir, "ex05.dat");
   
   // 객체출력스트림 선언
   ObjectOutputStream oout = null;
   
   try {
     
     // 객체출력스트림 생성 (반드시 예외 처리가 필요한 코드)
     oout = new ObjectOutputStream(new FileOutputStream(file));
     
     // 출력할 데이터(파일로 보낼 데이터)
     String name = "tom";
     int age = 50;
     double height = 180.5;
     String school = "가산대학교";
     Student student = new Student(name, age, height, school);
   
     // 출력(파일로 데이터 보내기)
     oout.writeObject(student);
     
     System.out.println(file.getPath() + " 파일 크기 : " + file.length() + "바이트");

   } catch (IOException e) {
     e.printStackTrace();
   } finally {
     try {
       if(oout != null) {
         oout.close();  // 출력스트림은 반드시 닫아줘야 함 (반드시 예외 처리가 필요한 코드)
       }
     } catch (IOException e) {
       e.printStackTrace();
     }
   }
   
   
   

java.io.InputStream 클래스

  1. 바이트 기반의 입력스트림이다.
  2. 입력 단위
    1) int
    2) byte[]

int read() 메소드
1. 1개 데이터를 읽어서 반환한다.
2. 읽은 내용이 없으면 -1을 반환한다.

1)int

 // 디렉터리를 File 객체로 만들기
   File dir = new File("C:/storage");
   
   // 파일을 File 객체로 만들기
   File file = new File(dir, "ex01.dat");
   
   // 파일입력스트림 선언
   FileInputStream fin = null;
   
   try {
     
     // 파일입력스트림 생성 (반드시 예외 처리 필요, 파일이 없으면 예외 발생)
     fin = new FileInputStream(file);
     
     // 입력된 데이터 저장 변수
     int c = 0;
     
     // 입력된 데이터를 누적할 StringBuilder 생성
     StringBuilder sb = new StringBuilder();
     
     // int read() 메소드
     // 1. 1개 데이터를 읽어서 반환한다.
     // 2. 읽은 내용이 없으면 -1을 반환한다.
     
     // 반복문 : 읽은 내용이 -1이 아니면 계속 읽는다.
     while( (c = fin.read()) != -1 ) {
       sb.append((char)c);
     }
     
     // 결과 확인
     System.out.println(sb.toString());
     
   } catch (IOException e) {
     e.printStackTrace();
   } finally {
     try {
       if(fin != null) {
         fin.close();
       }
     } catch (IOException e) {
       e.printStackTrace();
     }
   }

2)byte[]

 
   // 바이트 기반 스트림은 원래 한글 처리가 안 된다.
   
   // 디렉터리를 File 객체로 만들기
   File dir = new File("C:/storage");
   
   // 파일을 File 객체로 만들기
   File file = new File(dir, "ex02.dat");
   
   // 파일입력스트림 선언
   FileInputStream fin = null;
   
   try {
     
     // 파일입력스트림 생성 (반드시 예외 처리 필요, 파일이 없으면 예외 발생)
     fin = new FileInputStream(file);
     
     // 입력된 데이터 저장 변수
     byte[] b = new byte[4];  // 임의로 크기 설정(최대 4바이트 입력 가능)
     
     // 실제로 읽은 바이트 수 저장 변수
     int readByte = 0;
     
     // 입력된 데이터를 누적할 StringBuilder 생성
     StringBuilder sb = new StringBuilder();
     
     // int read(byte[] b) 메소드
     // 1. 파라미터로 전달된 byte[] b에 읽은 내용을 저장한다.
     // 2. 실제로 읽은 바이트 수를 반환한다.
     // 3. 읽은 내용이 없으면 -1을 반환한다.
     
     // 반복문 : read()의 반환값이 -1이 아니면 계속 읽는다.
     while( (readByte = fin.read(b)) != -1 ) {
       sb.append(new String(b, 0, readByte));  // 배열 b의 인덱스 0부터 readByte개 데이터를 String으로 변환한다.
     }
     
     /*
      * 15바이트 "abcdefghijklmno"를 4바이트씩 읽는 방식
      * 
      * byte[] b            readByte    new String(b, 0, readByte)
      * 
      * 1차 Loop
      * ┌---------------┐
      * │ a | b | c | d │  4           배열 b의 인덱스 0부터 4개 데이터를 String으로 변환한다.
      * └---------------┘
      * 2차 Loop
      * ┌---------------┐
      * │ e | f | g | h │  4           배열 b의 인덱스 0부터 4개 데이터를 String으로 변환한다.
      * └---------------┘
      * 3차 Loop
      * ┌---------------┐
      * │ i | j | k | l │  4           배열 b의 인덱스 0부터 4개 데이터를 String으로 변환한다.
      * └---------------┘
      * 4차 Loop
      * ┌---------------┐
      * │ m | n | o | l │  3           배열 b의 인덱스 0부터 3개 데이터를 String으로 변환한다.
      * └---------------┘
      *                ↑
      *                └---- 이전 Loop에서 읽은 데이터이므로 사용하면 안 된다.
      */
     
     // 결과 확인
     System.out.println(sb.toString());
     
   } catch (IOException e) {
     e.printStackTrace();
   } finally {
     try {
       if(fin != null) {
         fin.close();
       }
     } catch (IOException e) {
       e.printStackTrace();
     }
   }
   

java.io.BufferedInputStream 클래스

  1. 내부 버퍼를 가지고 있는 입력스트림이다.

  2. 많은 데이터를 한 번에 입력받기 때문에 속도 향상을 위해서 사용한다.

  3. 보조스트림이므로 메인스트림과 함께 사용한다.

    
       
       // 디렉터리를 File 객체로 만들기
       File dir = new File("C:/storage");
       
       // 파일을 File 객체로 만들기
       File file = new File(dir, "ex03.dat");
       
       // 버퍼입력스트림 선언
       BufferedInputStream bin = null;
       
       try {
         
         // 버퍼입력스트림 생성 (반드시 예외 처리 필요, 파일이 없으면 예외 발생)
         bin = new BufferedInputStream(new FileInputStream(file));
         
         // 입력된 데이터 저장 변수
         byte[] b = new byte[4];  // 임의로 크기 설정(최대 4바이트 입력 가능)
         
         // 실제로 읽은 바이트 수 저장 변수
         int readByte = 0;
         
         // 입력된 데이터를 누적할 StringBuilder 생성
         StringBuilder sb = new StringBuilder();
         
         // int read(byte[] b) 메소드
         // 1. 파라미터로 전달된 byte[] b에 읽은 내용을 저장한다.
         // 2. 실제로 읽은 바이트 수를 반환한다.
         // 3. 읽은 내용이 없으면 -1을 반환한다.
         
         // 반복문 : read()의 반환값이 -1이 아니면 계속 읽는다.
         while( (readByte = bin.read(b)) != -1 ) {
           sb.append(new String(b, 0, readByte));  // 배열 b의 인덱스 0부터 readByte개 데이터를 String으로 변환한다.
         }
         
         // 결과 확인
         System.out.println(sb.toString());
         
       } catch (IOException e) {
         e.printStackTrace();
       } finally {
         try {
           if(bin != null) {
             bin.close();
           }
         } catch (IOException e) {
           e.printStackTrace();
         }
       }

java.io.DataInputStream 클래스

  1. int, double, String 등의 변수를 그대로 입력받는 입력스트림이다.
  2. 보조스트림이므로 메인스트림과 함께 사용한다.

DataOutputStream과 DataInputStream을 사용하면
바이트 기반 입출력에서도 한글 처리가 가능하다.(writeUTF, readUTF 메소드 이용)


 // 디렉터리를 File 객체로 만들기
   File dir = new File("C:/storage");
   
   // 파일을 File 객체로 만들기
   File file = new File(dir, "ex04.dat");
   
   // 데이터입력스트림 선언
   DataInputStream din = null;
   
   try {
     
     // 데이터입력스트림 생성 (반드시 예외 처리 필요, 파일이 없으면 예외 발생)
     din = new DataInputStream(new FileInputStream(file));
     
     // 순서대로 입력 받기
     char ch1 = din.readChar();        // 't'
     char ch2 = din.readChar();        // 'o'
     char ch3 = din.readChar();        // 'm'
     int age = din.readInt();          // 50
     double height = din.readDouble(); // 180.5
     String school = din.readUTF();    // 가산대학교
     
     // 결과 확인
     System.out.println("" + ch1 + ch2 + ch3);
     System.out.println(age);
     System.out.println(height);
     System.out.println(school);      
     
   } catch (IOException e) {
     e.printStackTrace();
   } finally {
     try {
       if(din != null) {
         din.close();
       }
     } catch (IOException e) {
       e.printStackTrace();
     }
   }

java.io.ObjectInputStream 클래스

  1. 객체를 그대로 입력 받는 입력스트림이다.
  2. 직렬화(Serializable)된 객체를 입력 받을 수 있다.
  3. 보조스트림이므로 메인스트림과 함께 사용한다.
  // 디렉터리를 File 객체로 만들기
    File dir = new File("C:/storage");
    
    // 파일을 File 객체로 만들기
    File file = new File(dir, "ex05.dat");
    
    // 객체입력스트림 선언
    ObjectInputStream oin = null;
    
    try {
      
      // 객체입력스트림 생성 (반드시 예외 처리 필요, 파일이 없으면 예외 발생)
      oin = new ObjectInputStream(new FileInputStream(file));
      
      // 객체 순서대로 입력 받기
      Student s = (Student)oin.readObject();
      
      // 결과 확인
      System.out.println(s);
      
    } catch (IOException | ClassNotFoundException e) {
      e.printStackTrace();
    } finally {
      try {
        if(oin != null) {
          oin.close();
        }
      } catch (IOException e) {
        e.printStackTrace();
      }
    }
    

Writer

java.io.Writer 클래스

  1. 문자 기반의 출력스트림이다.
  2. 출력 단위
    1) int
    2) char[]
    3) String1)int
     // 디렉터리를 File 객체로 만들기
     File dir = new File("C:/storage");
     if(dir.exists() == false) {
       dir.mkdirs();
     }
     
     // 파일을 File 객체로 만들기
     File file = new File(dir, "ex01.txt");
     
     // 파일출력스트림 선언
     FileWriter fw = null;
     
     try {
       
       // 파일출력스트림 생성(반드시 예외 처리가 필요한 코드)
       
       // 1. 생성모드 : 언제나 새로 만든다.(덮어쓰기)        new FileWriter(file)
       // 2. 추가모드 : 새로 만들거나, 기존 파일에 추가한다. new FileWriter(file, true)
       fw = new FileWriter(file);
       
       // 출력할 데이터(파일로 보낼 데이터)
       int c = 'H';
       char[] cbuf = {'e', 'l', 'l', 'o'};
       String str = " world";
       
       // 출력(파일로 데이터 보내기)
       fw.write(c);
       fw.write(cbuf);
       fw.write(str);
       
       // 메시지
       System.out.println(file.getPath() + " 파일 생성 완료");
       
     } catch (IOException e) {
       e.printStackTrace();
     } finally {
       try {
         if(fw != null) {
           fw.close();
         }
       } catch (IOException e) {
         e.printStackTrace();
       }
     }

java.io.BufferedWriter 클래스

  1. 내부 버퍼를 가지고 있는 출력스트림이다.

  2. 많은 데이터를 한 번에 출력하기 때문에 속도 향상을 위해서 사용한다.

  3. 보조스트림이므로 메인스트림과 함께 사용한다.

    2)char[]

    // 디렉터리를 File 객체로 만들기
     File dir = new File("C:/storage");
     if(dir.exists() == false) {
       dir.mkdirs();
     }
     
     // 파일을 File 객체로 만들기
     File file = new File(dir, "ex02.txt");
     
     // 버퍼출력스트림 선언
     BufferedWriter bw = null;
     
     try {
       
       // 버퍼출력스트림 생성(반드시 예외 처리가 필요한 코드)
       bw = new BufferedWriter(new FileWriter(file));
       
       // 출력할 데이터(파일로 보낼 데이터)
       String str1 = "Hello";
       String str2 = "world";
       
       // 출력(파일로 데이터 보내기)
       bw.write(str1, 0, 4);  // 문자열 str1의 인덱스 0부터 4글자만 출력
       bw.newLine();          // 줄 바꿈(bw.write("\n")과 동일하다.) BufferedWriter 클래스의 전용 메소드이다.
       bw.write(str2);
       
       // 메시지
       System.out.println(file.getPath() + " 파일 생성 완료");
       
     } catch (IOException e) {
       e.printStackTrace();
     } finally {
       try {
         if(bw != null) {
           bw.close();
         }
       } catch (IOException e) {
         e.printStackTrace();
       }
     }
     
    

java.io.PrintWriter 클래스

  1. print() 메소드와 println() 메소드를 지원하는 출력스트림이다.

  2. println() 메소드를 사용하면 자동으로 줄 바꿈이 처리된다.

  3. 서버가 클라이언트에게 데이터를 전송할 때 사용하는 기본 Writer이다.

    3)String

    // 디렉터리를 File 객체로 만들기
     File dir = new File("C:/storage");
     if(dir.exists() == false) {
       dir.mkdirs();
     }
     
     // 파일을 File 객체로 만들기
     File file = new File(dir, "ex03.txt");
     
     // PrintWriter 선언
     PrintWriter out = null;
     
     try {
       
       // PrintWriter 생성(반드시 예외 처리가 필요한 코드)
       out = new PrintWriter(file);
       
       // 출력할 데이터(파일로 보낼 데이터)
       String str1 = "Hello";
       String str2 = "world";
       
       // 출력(파일로 데이터 보내기)
       out.println(str1);
       out.println(str2);
       
       // 메시지
       System.out.println(file.getPath() + " 파일 생성 완료");
       
     } catch (IOException e) {
       e.printStackTrace();
     } finally {
         if(out != null) {
           out.close();  // try 체크를 하지 않는 PrintWriter 클래스의 close() 메소드
       }
     }  
    
    

Reader

java.io.Reader 클래스

  1. 문자 기반의 입력스트림이다.

  2. 입력 단위
    1) int
    2) char[]
    3) String

    1)int

       // 디렉터리를 File 객체로 만들기
     File dir = new File("C:/storage");
     
     // 파일을 File 객체로 만들기
     File file = new File(dir, "ex01.txt");
     
     // 파일입력스트림 선언
     FileReader fr = null;
     
     try {
       
       // 파일입력스트림 생성(반드시 예외 처리 필요, 파일이 없으면 FileNotFoundException 발생)
       fr = new FileReader(file);
       
       // 입력된 문자 저장 변수
       int ch = 0;
       
       // 입력된 문자를 누적할 StringBuffer 생성
       StringBuffer sb = new StringBuffer();
       
       // read() 메소드
       // 1. 1개 문자를 읽어서 반환한다.
       // 2. 읽은 문자가 없으면 -1을 반환한다.
       
       // 반복문 : 읽은 문자가 -1이 아니면 계속 읽는다.
       while((ch = fr.read()) != -1) {
         sb.append((char)ch);
       }
       
       // 결과 확인
       System.out.println(sb.toString());
       
     } catch (IOException e) {
       e.printStackTrace();
     } finally {
       try {
         if(fr != null) {
           fr.close();
         }
       } catch (IOException e) {
         e.printStackTrace();
       }
     }
     
    

    2)char[]

       // 디렉터리를 File 객체로 만들기
      File dir = new File("C:/storage");
      
      // 파일을 File 객체로 만들기
      File file = new File(dir, "ex02.txt");
      
      // 파일입력스트림 선언
      FileReader fr = null;
      
      try {
        
        // 파일입력스트림 생성(반드시 예외 처리 필요, 파일이 없으면 FileNotFoundException 발생)
        fr = new FileReader(file);
        
        // 입력된 문자 저장 배열
        char[] cbuf = new char[2];
        
        // 실제로 읽은 글자 수 저장 변수
        int readChar = 0;
        
        // 입력된 문자를 누적할 StringBuffer 생성
        StringBuffer sb = new StringBuffer();
        
        // int read(char[] cbuf) 메소드
        // 1. 파라미터로 전달된 char[] cbuf에 읽은 문자를 저장한다.
        // 2. 실제로 읽은 글자 수를 반환한다.
        // 3. 읽은 문자가 없으면 -1을 반환한다. 
        
        // 반복문 : read()의 반환값이 -1이 아니면 계속 읽는다.
        while((readChar = fr.read(cbuf)) != -1) {
          sb.append(cbuf, 0, readChar);  // 배열 cbuf의 인덱스 0부터 readChar개 문자를 sb에 추가한다.
        }
        
        // 결과 확인
        System.out.println(sb.toString());
        
      } catch (IOException e) {
        e.printStackTrace();
      } finally {
        try {
          if(fr != null) {
            fr.close();
          }
        } catch (IOException e) {
          e.printStackTrace();
        }
      }
    

    3)String

java.io.BufferedReader 클래스

  1. 내부 버퍼를 가지고 있는 입력스트림이다.

  2. 많은 데이터를 한 번에 입력받기 때문에 속도 향상을 위해서 사용한다.

  3. 보조스트림이므로 메인스트림과 함께 사용한다.

    
      
      // 디렉터리를 File 객체로 만들기
      File dir = new File("C:/storage");
      
      // 파일을 File 객체로 만들기
      File file = new File(dir, "ex03.txt");
      
      // 버퍼입력스트림 선언
      BufferedReader br = null;
      
      try {
        
        // 버퍼입력스트림 생성(반드시 예외 처리 필요, 파일이 없으면 FileNotFoundException 발생)
        br = new BufferedReader(new FileReader(file));
        
        // 입력된 문자열 저장 변수
        String line = null;
        
        // 입력된 문자를 누적할 StringBuffer 생성
        StringBuffer sb = new StringBuffer();
        
        // String readLine() 메소드
        // 1. 한 줄 전체를 반환한다.
        // 2. 읽은 문자가 없으면 null을 반환한다. 
        
        // 반복문 : readLine()의 반환값이 null이 아니면 계속 읽는다.
        while((line = br.readLine()) != null) {
          sb.append(line + "\n");  // 읽은 라인에 줄 바꿈(\n)은 포함되어 있지 않다.
        }
        
        // 결과 확인
        System.out.println(sb.toString());
        
      } catch (IOException e) {
        e.printStackTrace();
      } finally {
        try {
          if(br != null) {
            br.close();
          }
        } catch (IOException e) {
          e.printStackTrace();
        }
      }
      

    바이트 출력스트림으로 보낸 문자를 바이트 입력스트림으로 읽기(한글 실패)
    바이트 출력스트림으로 보낸 문자를 문자 입력스트림으로 읽기(한글 성공)

    
      
      // 1단계. 바이트 출력스트림으로 문자 보내기
      File dir = new File("C:/storage");
      if(dir.exists() == false) {
        dir.mkdirs();
      }
      File file = new File(dir, "server.dat");
      BufferedOutputStream bout = null;
      try {
        bout = new BufferedOutputStream(new FileOutputStream(file));
        String s1 = "안녕하세요";
        String s2 = "Hello";
        bout.write(s1.getBytes("UTF-8"));
        bout.write(s2.getBytes("UTF-8"));
        bout.close();
      } catch (IOException e) {
        e.printStackTrace();
      }
      
      // 2단계. 문자 입력스트림으로 읽기
      /*
       * java.io.InputStreamReader 클래스
       * 1. Reader 클래스를 상속 받는 클래스이다. (문자 입력스트림이다.)
       * 2. InputStream(바이트 입력스트림)을 받아서 Reader(문자 입력스트림)으로 변환한다.
       */
      BufferedReader br = null;
      try {
        br = new BufferedReader(new InputStreamReader(new FileInputStream(file)));
        String line = null;
        StringBuffer sb = new StringBuffer();
        while((line = br.readLine()) != null) {
          sb.append(line + "\n");
        }
        System.out.println(sb.toString());
        br.close();
      } catch (IOException e) {
        e.printStackTrace();
      }

try - catch - resources문

  1. 사용한 자원(대표적으로 입출력 스트림)을 자동으로 close 해 주는 try문이다.

  2. 형식

       try (입출력 스트림 생성) {
      코드
      } catch(Exception e) {
         e.printStackTrace();
       }

    예시)

     
      // 디렉터리를 File 객체로 생성
      File dir = new File("C:/storage");
      if(dir.exists() == false) {
        dir.mkdirs();
      }
      
      // 파일을 File 객체로 생성
      File file = new File(dir, "ex01.txt");
      
      // try 블록에서 출력스트림 생성하기
      try (BufferedWriter bw = new BufferedWriter(new FileWriter(file, true))) {  // 추가모드
        
        // 출력할 데이터
        String str1 = "안녕하세요";
        String str2 = "반갑습니다";
        
        // 출력 (추가모드이므로 기존 파일 뒤에 추가된다.)
        bw.newLine();
        bw.write(str1);
        bw.newLine();
        bw.write(str2);
        
        System.out.println(file.getPath() + " 파일에 데이터 추가 완료");
        
      } catch (IOException e) {
        e.printStackTrace();
      }
      
    }
    

    관련 예제

profile
졸려요

0개의 댓글