JAVA IO API 사용 설명

이론 적 준비
흐름 은 추상 적 인 개념 으로 입 출력 장치 에 대한 추상 이다.자바 프로그램 에서 데이터 에 대한 입 출력 작업 은 모두'흐름'방식 으로 진행 되 고 장 치 는 파일,네트워크,메모리 등 이 될 수 있다.흐름 은 방향 성 을 가지 고 입력 흐름 인지 출력 흐름 인지 에 대해 상대 적 인 개념 이다.보통 프로그램(작은 말 형 이 말 하 는 기계)을 참고 로 데이터 의 흐름 이 프로그램 에서 장치 까지 라면 우 리 는 수출 흐름 이 되 고 반대로 우 리 는 입력 흐름 이 라 고 부 르 며 흐름 을'수류 관'(많은 자료 가 이렇게 말 하 는 것)이 라 고 상상 할 수 있 으 며 자 연 스 럽 게 방향 개념 이 나 타 났 다.
흐름 은 I/O 장치 내부 의 구체 적 인 조작 을 숨 겼 다.모든 InputStream 과 Reader 의 파생 류 는 하나의 기본 적 인 것 이 있 습 니 다.계 승 된 것 은 하나의 또는 byte 배열 의 read()방법 을 읽 을 수 있 습 니 다.
자바 는 바이트 흐름(Stream 끝)과 문자 흐름(Reader,Write 끝)으로 나 뉘 고 입력 흐름(InputStream,Reader)과 출력 흐름(OutputStream,Write)으로 나 뉘 며 입력 출력 은 메모리 에 비해 나 뉜 다.문 자 를 읽 을 때 텍스트 파일,XML 등 문자 흐름 을 사용 합 니 다.기다리다바 이 너 리 파일 을 읽 을 때 RAR,EXE 등 텍스트 이외 의 파일(그림)이 아 닌 바이트 흐름 을 사용 합 니 다.버 프 레 드 의 시작 흐름 은 읽 기와 쓰기 의 효율 을 높이 기 위해 버퍼 만 추가 되 었 다.문자 흐름 은 직접 출력 할 수 없습니다.바이트 흐름 으로 변환 해 야 출력 할 수 있 습 니 다.(이것 은 확실히 방금 알 았 습 니 다)!
자바 2 SDK 에는 세 가지 기본 유형의 노드 가 있 습 니 다.파일(file),메모리(memory),파이프(pipe)입 니 다.
다음은 정 리 교재 에 있 는 IO 장절 의 그 고전 사진 을 살 펴 보 자.
InputStream/OutputStream 에서 계승 하 는 흐름 은 모두 프로그램 에 데 이 터 를 입력/출력 하 는 데 사용 되 고 데이터 의 단 위 는 바이트(byte=8bit)입 니 다.그림 과 같이 짙 은 색 은 노드 흐름 이 고 옅 은 색 은 처리 흐름 입 니 다.

Reader/Writer 에서 계승 하 는 흐름 은 모두 프로그램 에 데 이 터 를 입력/출력 하 는 데 사용 되 고 데이터 의 단 위 는 모두 문자(2byte=16bit)입 니 다.그림 과 같이 짙 은 색 은 노드 흐름 이 고 옅 은 색 은 처리 흐름 입 니 다.

용법 분석
자바 IO 의 일반 사용 원칙(부분 은 바 이 두 라 이브 러 리 에서):
(1)데이터 원본(행방)에 따라 분류:
파일:FileInputStream,FileOutputStream,FileReader,FileWriter
byte[]:ByteArray InputStream,ByteArray OutputStream 입 니 다.
Char[]:CharArray Reader,CharArray Writer 입 니 다.
String:StringBufferInputStream,StringReader,StringWriter 입 니 다.
네트워크 데이터 흐름:InputStream,OutputStream,Reader,Writer
(2)출력 을 포맷 할 지 여부 에 따라:
출력 포맷 하기:PrintStream,PrintWriter
(3)버퍼 링 할 지 여 부 를 누 르 십시오.
버퍼 링:BufferedInputStream,BufferedOutputStream,BufferedReader,BufferedWriter.
(4)데이터 형식 으로 나 누 기:
바 이 너 리 형식(일반 텍스트 가 확실 하지 않 으 면):InputStream,OutputStream 및 모든 스 트림 이 끝 난 하위 클래스
순수한 텍스트 형식(순수한 영어 와 한자 또는 기타 인 코딩 방식 포함);Reader,Writer 및 모든 Reader,Writer 가 있 는 하위 클래스
(5)입 출력 에 따라:
입력:Reader,InputStream 형식의 하위 클래스;출력:Writer,Output Stream 형식의 하위 클래스
(6)특수 수요:
Stream 에서 Reader,Writer 로 의 전환 클래스:InputStreamReader,OutputStreamWriter
대상 입 출력:ObjectInputStream,ObjectOutputStream
프로 세 스 간 통신:PipeInputStream,PipeOutputStream,PipeReader,PipeWriter
병합 입력:SequenceInputStream
더 특별한 필요:PushbackInputStream,PushbackReader,LineNumberInputStream,LineNumberReader
       (7)어떤 종류 와 그 구조 프로 세 스 를 사용 할 것 인 지 를 결정 하 는 일반적인 준칙 은 다음 과 같다(특수 수 요 를 고려 하지 않 음).
가장 원시 적 인 데이터 형식 이 무엇 인지 고려 하 십시오.텍스트 입 니까?입 출력 입 니까?스 트림 변환 이 필요 합 니까:InputStreamReader,OutputStreamWriter?데이터 원본(행방)이 무엇 입 니까:파일?메모리네트워크버퍼 링 할 지 여부:bufferedReader(특별 설명:readLine()이 정의 되 어 있 는 지,read,write 보다 더 특별한 입력 이나 출력 방법 이 있 는 지 주의해 야 합 니 다)출력 을 포맷 할 지 여부:print.
실례
아니면 겨울방학 때 쓴 거 예요?권 은 복습 을 해 야 돼 요.코드 를 접 는 플러그 인 을 찾 을 수 없어 요.먼저 보 세 요.
1.System.in

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
/*
 * System.in InputStream static final ，     ,         
 *   ASCII      (  )，     ASCII  (    )。
 */
public class TestSystemIn {
 public static void main(String[] args) {
 InputStreamReader isr = new InputStreamReader(System.in);
 BufferedReader br = new BufferedReader(isr);// readline
 String s = null;
 try {
  s = br.readLine();
  while(s!=null) {
  if(s.equalsIgnoreCase("exit")) {
   break;
  }
  System.out.println(s.toUpperCase());
  s = br.readLine();
  }
  br.close();
 }catch (IOException e) {
  e.printStackTrace();
 }
 }
}

2.buffer

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
public class TestBuffer {
 public static void main(String[] args) {
 try {
  //                   
  BufferedWriter bw = new BufferedWriter(new FileWriter("d:/java.txt"));
  BufferedReader br = new BufferedReader(new FileReader("d:/java.txt"));
  String s = null;
  for(int i=1; i<100; i++) {
  s = String.valueOf(Math.random());
  bw.write(s);
  bw.newLine();//  
  }
  //       ，br     
  bw.flush();
  while((s=br.readLine())!=null) {
  System.out.println(s);
  }
  bw.close();
  br.close();
 }catch (IOException e) {
  e.printStackTrace();
 }
 }
}

3.FileInputStream

import java.io.*;
public class TestFileInputStream {
 public static void main(String[] args) {
 FileInputStream in = null;
 try {
  in = new FileInputStream("e:/1.txt");
 }catch(FileNotFoundException e) {
  System.out.println("     ");
  System.exit(-1);
 }
 //         
 int tag = 0;
 try {
  long num = 0;
  while((tag = in.read())!=-1) {
  //read    ，            ,  reader    
  System.out.print((char)tag);
  num++;
  }
  in.close();
  System.out.println();
  System.out.println("    " + num + "  ");
 }catch(IOException e1) {//read close    IOException
  System.out.println("      ");
  System.exit(-1);
 }
 }
}

4.FileOutputStream 복사 기능 구현

import java.io.*;
/*
 *       
 */
public class TestFileOutputStream {
 public static void main(String[] args) {
 int b = 0;
 FileInputStream in = null;
 FileOutputStream out = null;
 try {
  in = new FileInputStream("d:/java.txt");
  //               
  out = new FileOutputStream("d:/my_java.txt");
  while((b=in.read())!=-1) {
  out.write(b);
  }
  in.close();
  out.close();
 }catch(FileNotFoundException e) {
  System.out.println("       ");
  System.exit(-1);
 }catch(IOException e1) {
  System.out.println("      ");
  System.exit(-1);
 
 }
 System.out.println("     "); 
 }
}

5.ObjectOutputStream 과 Serializable

import java.io.*;
/*
 * transient（   ），          ，
 *            ，  int   ，         
 *      0
 */
public class TestObjectIO {
 public static void main(String[] args) throws Exception {
 T t = new T();
 t.k = 8;
 FileOutputStream fos = new FileOutputStream("d:/1.txt");
 ObjectOutputStream oos = new ObjectOutputStream(fos);
 oos.writeObject(t);
 oos.flush();
 oos.close();
 
 FileInputStream fis = new FileInputStream("d:/1.txt");
 ObjectInputStream ois = new ObjectInputStream(fis);
 T tRead = (T)ois.readObject();
 System.out.println(tRead.i + " " + tRead.j + " " + tRead.k);
 }
}
class T implements Serializable {
 int i = 10;
 int j = 9;
 double d = 2.3;
 int k = 15;
}

6.인 코딩 방식 전환

import java.io.*;
/*
 *   windows  GBK    
 *           ，      
 */
public class TestTransForm {
 public static void main(String[] args) {
 try {
  OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("d:/java.txt"));
  osw.write("  123");//         ，    ,         
  System.out.println("    ：" + osw.getEncoding());//ISO8859_1     ，  latin-1，        ，  （ISO） Unicode
  osw.close();
  osw = new OutputStreamWriter(new FileOutputStream("d:/java.txt",true),"ISO8859_1");//true    
  osw.write("       ");
  System.out.println("    ：" + osw.getEncoding());
  osw.close();
 }catch(IOException e) {
  e.printStackTrace();
 }
 }
}

7.출력 방향 변경

import java.io.*;
/*
 * Print      ，          ，
 * PrintWriter PrintStream     ，              ，
 *     flush  ，     , jsp         ，
 *         。
 */
public class TestPrintStream {
 public static void main(String[] args) {
 PrintStream ps = null;
 try {
  FileOutputStream fos = new FileOutputStream("d:/java.txt");
  ps = new PrintStream(fos);
  
 }catch (IOException e) {
  e.printStackTrace();
 }
 if(ps!=null) {
  System.setOut(ps);//     
 }
 int ln = 0;
 for(char c=0; c<65535; c++) {
  System.out.print(c + " ");
  if(ln++>100) {
  System.out.println();
  ln = 0; 
  }
 }
 }
}

8.DataStream

import java.io.*;
public class TestDataStream {
 public static void main(String[] args) {
 //             ，     OutputStream，        
 ByteArrayOutputStream baos = new ByteArrayOutputStream();
 DataOutputStream dos = new DataOutputStream(baos);
 try {//    
  dos.writeDouble(Math.random());
  dos.writeBoolean(true);
  ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
  System.out.println(bais.available());//       
  DataInputStream dis = new DataInputStream(bais);
  ////     （  ）,            ,       double      
  System.out.println(dis.readDouble());
  System.out.println(dis.readBoolean());
  dos.close();
  dis.close();
 }catch (IOException e) {
  e.printStackTrace(); 
 }
 }
}

사소한 문제
왜 Writer/Reader 는 자체 Stream 을 계승 하지 않 습 니까?문자 도 결국 바 이 너 리 로 바 꿔 야 지.Writer/Readre 는 OutputStream/InputStream 을 계승 합 니 다.이러한 계승 차원 이 더 좋 지 않 습 니 다.왜 단독으로 하 나 를 만들어 야 합 니까?그리고 Stream 도 문자열 의 읽 기와 쓰 기 를 실현 할 수 있 는 하위 클래스 가 있 습 니 다.대신 대답:단일 직책.너무 억지 야.