宋体字符java输入输出流（I/O）总结

废话就不多说了，开始。。。

    

 io流的四个基本类

    

      java.io包中含包了流式I/O所要需的有所类。在java.io包中有四个基本类：InputStream、OutputStream及Reader、Writer类，它们别分理处节字流和字符流：

    

 

    

基本据数流的I/O

    

输入/输出

节字流

字符流

输入流

Inputstream

Reader

输出流

OutputStream

Writer

    

    

     Java中其他多种多样化变的流均是由它们派生出来的:

    

    

    

    

    

      JDK1.4版本开始引入了新I/O库类，它位于java.nio包中，新I/O库类利用通道和缓冲区等来高提I/O作操的效率。

    

      在java.io包中， java.io.InputStream 示表节字输入流， java.io.OutputStream示表节字输出流，处于java.io包最顶层。这两个类均为抽象类，也就是说它们不能被实例化，必须生成子类后之才能现实必定的功能。

    

 

    

1. io流的详细分类

    

 

    

一、按I/O型类来体总分类：

    

     1. Memory 1）从/向内存数组写读据数: CharArrayReader、 CharArrayWriter、ByteArrayInputStream、ByteArrayOutputStream
                   2）从/向内存字符串写读据数 StringReader、StringWriter、StringBufferInputStream
     2.Pipe管道  现实管道的输入和输出（进程间通信）: PipedReader、PipedWriter、PipedInputStream、PipedOutputStream
     3.File 文件流。对文件停止读、写作操 ：FileReader、FileWriter、FileInputStream、FileOutputStream
     4. ObjectSerialization 对象输入、输出 ：ObjectInputStream、ObjectOutputStream
     5.DataConversion据数流 按基本据数型类读、写（理处的据数是Java的基本型类（如尔布型，节字，整数和浮点数））：DataInputStream、DataOutputStream
     6.Printing 含包便方的打印方法 ：PrintWriter、PrintStream
     7.Buffering缓冲  在读入或写出时，对据数停止缓存，以加增I/O的次数：BufferedReader、BufferedWriter、BufferedInputStream、BufferedOutputStream
     8.Filtering 滤流，在据数停止读或写时停止过滤：FilterReader、FilterWriter、FilterInputStream、FilterOutputStream过
     9.Concatenation合并输入 把多个输入流连接成一个输入流 ：SequenceInputStream 
    10.Counting数计  在读入据数时对行记数 ：LineNumberReader、LineNumberInputStream
    11.Peeking Ahead 通过缓存制机，停止预读 ：PushbackReader、PushbackInputStream
    12.Converting between Bytes and Characters 按照必定的编码/解码准标将节字流换转为字符流，或停止反向换转（Stream到Reader,Writer的换转类）：InputStreamReader、OutputStreamWriter

    

二、按据数源来（向去）分类： 
1、File（文件）： FileInputStream, FileOutputStream, FileReader, FileWriter 
2、byte[]：ByteArrayInputStream, ByteArrayOutputStream 
3、Char[]: CharArrayReader, CharArrayWriter 
4、String: StringBufferInputStream, StringReader, StringWriter 
5、络网据数流：InputStream, OutputStream, Reader, Writer 

    

 

    

2. 节字流InputStream/OutputStream

    

 1.1. InputStream抽象类 

    

      InputStream 为节字输入流，它本身为一个抽象类，必须依托其子类现实各种功能，此抽象类是示表节字输入流的有所类的超类。 继承自InputStream  的流都是向序程中输入据数的，且据数单位为节字（8bit）；

    

InputStream是输入节字据数用的类，所以InputStream类供提了3种载重的read方法.Inputstream类中的经常使用方法： 
（1） public abstract int read( )：读取一个byte的据数，返回值是高位补0的int型类值。若返回值=-1明说没有读取到任何节字读取作工束结。
（2） public int read(byte b[ ])：读取b.length个节字的据数放到b数组中。返回值是读取的节字数。该方法现实上是调用下一个方法现实的 
（3） public int read(byte b[ ], int off, int len)：从输入流中最多读取len个节字的据数，寄存到偏移量为off的b数组中。 
（4） public int available( )：返回输入流中可以读取的节字数。注意：若输入塞阻，以后线程将被挂起，如果InputStream对象调用这个方法的话，它只会返回0，这个方法必须由继承InputStream类的子类对象调用才用有， 
（5） public long skip(long n)：略忽输入流中的n个节字，返回值是现实略忽的节字数, 跳过一些节字来读取 
（6） public int close( ) ：我们在应用完后，必须对我们打开的流停止关闭. 

    

         重要的子类：

    

        

    

         1） FileInputStream把一个文件作为InputStream，现实对文件的读取作操     
 2） ByteArrayInputStream：把内存中的一个缓冲区作为InputStream应用 
 3） StringBufferInputStream：把一个String对象作为InputStream 
 4） PipedInputStream：现实了pipe的念概，重要在线程中应用 
 5） SequenceInputStream：把多个InputStream合并为一个InputStream 

    

 

    

 2.1．OutputStream抽象类 

     OutputStream供提了3个write方法来做据数的输出，这个是和InputStream是相对应的。 
1. public void write(byte b[ ])：将参数b中的节字写到输出流。 
2. public void write(byte b[ ], int off, int len) ：将参数b的从偏移量off开始的len个节字写到输出流。 
3. public abstract void write(int b) ：先将int换转为byte型类，把低节字入写到输出流中。 
4. public void flush( ) : 将据数缓冲区中据数全体输出，并空清缓冲区。 
5. public void close( ) : 关闭输出流并释放与流关相的统系资源。 

    

    

       重要的子类：

    

        

    

      1) ByteArrayOutputStream：把信息存入内存中的一个缓冲区中 
      2) FileOutputStream：把信息存入文件中 
      3) PipedOutputStream：现实了pipe的念概，重要在线程中应用 
      4) SequenceOutputStream：把多个OutStream合并为一个OutStream 

    

流束结的判断：方法read()的返回值为-1时；readLine()的返回值为null时。

    

1.3. 文件输入流： FileInputStream类

    

      FileInputStream可以应用read()方法一次读入一个节字，并以int型类返回，或者是应用read()方法时读入至一个byte数组，byte数组的元素有多少个，就读入多少个节字。在将全部文件读取实现或入写毕完的过程当中，这么一个byte数组平日被看成缓冲区，因为这么一个byte数组平日表演承接据数的旁边角色。

    

 

    

 

    

    

    

 

    

 

    

 

    用作：以文件作为据数输入源的据数流。或者说是打开文件，从文件读据数到内存的类。

    

    应用方法(1)    

    

       File  fin=new File("d:/abc.txt"); 

    

      FileInputStream in=new FileInputStream( fin);

    

 

    

应用方法(2)
   FileInputStream  in=new  FileInputStream(“d: /abc.txt”);

    

序程举例：
将InputFromFile.java的序程的内容表现在表现器上

    


    

 

    

  1. import java.io.IOException;  
  2. import java.io.FileInputStream;  
  3. ;  
  4. public class TestFile {  
  5.     public static void main(String args[]) throws IOException {  
  6.         try{      
  7.                FileInputStream rf=new   FileInputStream("InputFromFile.java");  
  8.                int n=512;   byte  buffer[]=new  byte[n];     
  9.                while((rf.read(buffer,0,n)!=-1)&&(n>0)){  
  10.                    System.out.println(new String(buffer) );  
  11.                 }  
  12.                 System.out.println();  
  13.                 rf.close();  
  14.         } catch(IOException  IOe){        
  15.               System.out.println(IOe.toString());  
  16.         }  
  17.   
  18.     }  
  19.   
  20. }  

    

 

    

1.4.文件输出流:FileOutputStream类

      用作：用来理处以文件作为据数输出目标据数流；或者说是从内存区读据数入文件

    

    

 

    

      FileOutputStream类用来理处以文件作为据数输出目标据数流；一个示表文件名的字符串，也可是以File或FileDescriptor对象。 
创立一个文件流对象有两种方法： 
方法1： 
 File   f=new  File (“d:/myjava/write.txt ");
        FileOutputStream  out= new FileOutputStream (f);
方法2： 
FileOutputStream out=new FileOutputStream(“d:/myjava/write.txt "); 
方法3：构造函数将 FileDescriptor()对象作为其参数。 
FileDescriptor() fd=new FileDescriptor(); 
FileOutputStream f2=new FileOutputStream(fd); 
方法4：构造函数将文件名作为其第一参数，将尔布值作为第二参数。 
FileOutputStream f=new FileOutputStream("d:/abc.txt",true); 
注意： （1）文件中写据数时，若文件已存在，则盖覆存在的文件；（2）的读/写作操束结时，应调用close方法关闭流。 

    

 

    

序程举例： 应用盘键输入一段文章，将文章保存在文件write.txt中

    

  1. import java.io.IOException;  
  2. import java.io.FileOutputStream;  
  3. public class TestFile {  
  4.     public static void main(String args[]) throws IOException {  
  5.         try {  
  6.             System.out.println("please Input from      Keyboard");  
  7.             int count, n = 512;  
  8.             byte buffer[] = new byte[n];  
  9.             count = System.in.read(buffer);  
  10.             FileOutputStream wf = new FileOutputStream("d:/myjava/write.txt");  
  11.             wf.write(buffer, 0, count);  
  12.             wf.close(); // 当流写作操束结时，调用close方法关闭流。  
  13.             System.out.println("Save to the write.txt");  
  14.         } catch (IOException IOe) {  
  15.             System.out.println("File Write Error!");  
  16.         }  
  17.     }  
  18.   
  19. }  

1.5. FileInputStream流和FileOutputStream的应用

    每日一道理
曾经辉煌过，曾经凋零过，这可是你至死不渝的生活吗？我亲爱的母亲—大自然。多少次，我伏在地上，去聆听你沉重的脉搏声；多少次，我伫立在山前，去感受那松涛千年的浩瀚。你的豪壮，足以让中华民族腾飞；你的无私，谱写了一曲曲感人至深的千古壮曲。

    

利用序程将文件file1.txt 拷贝到file2.txt中。
  1. import java.io.File;  
  2. import java.io.IOException;  
  3. import java.io.FileOutputStream;  
  4. import java.io.FileInputStream;  
  5.   
  6. public class TestFile {  
  7.     public static void main(String args[]) throws IOException {  
  8.         try {  
  9.             File inFile = new File("copy.java");  
  10.             File outFile = new File("copy2.java");  
  11.             FileInputStream finS = new FileInputStream(inFile);  
  12.             FileOutputStream foutS = new FileOutputStream(outFile);  
  13.             int c;  
  14.             while ((c = finS.read()) != -1) {  
  15.                 foutS.write(c);  
  16.             }  
  17.             finS.close();  
  18.             foutS.close();  
  19.         } catch (IOException e) {  
  20.             System.err.println("FileStreamsTest: " + e);  
  21.         }  
  22.     }  
  23.   
  24. }  

    

    

1.6. 缓冲输入输出流 BufferedInputStream/ BufferedOutputStream

        

    

      

    

       计算机问访外部设备非常耗时。问访外存的频率越高，成造CPU闲置的概率就越大。为了加增问访外存的次数，应该在一次对外设的问访中，写读更多的据数。为此，除了序程和流节点间换交据数需必的写读制机外，还应该加增缓冲制机。缓冲流就是每个据数流分配一个缓冲区，一个缓冲区就是一个时临存储据数的内存。这样可以加增问访硬盘的次数,高提输传效率。

 

BufferedInputStream:当向缓冲流入写据数时候，据数先写到缓冲区，待缓冲区写满后，统系一次性将据数发送给输出设备。

BufferedOutputStream :当从向缓冲流读取据数时候，统系先从缓冲区读出据数，待缓冲区为空时，统系再从输入设备读取据数到缓冲区。

    

1）将文件读入内存：

    

将BufferedInputStream与FileInputStream相接

  FileInputStream in=new  FileInputStream( “file1.txt ” );

  BufferedInputStream bin=new  BufferedInputStream( in); 

2）将内存入写文件：

将BufferedOutputStream与 FileOutputStream相接

FileOutputStreamout=new FileOutputStream(“file1.txt”);

BufferedOutputStream  bin=new BufferedInputStream(out);


3）盘键输入流读到内存

    

将 BufferedReader 与 准标的据数流 相接 

    

 InputStreamReader  sin=new InputStreamReader ( System.in) ；

    

BufferedReader bin=new             BufferedReader( sin);

    

  1. import java.io.*;  
  2.   
  3. public class ReadWriteToFile {  
  4.     public static void main(String args[]) throws IOException {  
  5.         InputStreamReader sin = new InputStreamReader(System.in);  
  6.         BufferedReader bin = new BufferedReader(sin);  
  7.         FileWriter out = new FileWriter("myfile.txt");  
  8.         BufferedWriter bout = new BufferedWriter(out);  
  9.         String s;  
  10.         while ((s = bin.readLine()).length() > 0) {  
  11.             bout.write(s, 0, s.length());  
  12.         }  
  13.   
  14.     }  
  15. }  

    序程明说：

    

    从盘键读入字符，并入写到文件中

    BufferedReader类的方法：

    String readLine()

    

    用作：读一行字符串，以回车符为束结。

    

    BufferedWriter类的方法：

    bout.write(String s,offset,len)

    

    用作：从缓冲区将字符串s从offset开始，len度长的字符串写到某处。

    

    

    

 

    

 

    

2. 字符流Writer/Reader

    

        Java中字符是采取Unicode准标，一个字符是16位，即一个字符应用两个节字来示表。为此，JAVA中引入了理处字符的流。

    

 

    

1. Reader抽象类

    

 

    

    用于读取字符流的抽象类。子类必须现实的方法只有 read(char[], int, int) 和 close()。但是，数多子类将重写此处定义的一些方法，以供提更高的效率和/或其他功能。

           

    

    

        1) FileReader :与FileInputStream对应  
           重要用来读取字符文件，应用省缺的字符编码，有三种构造函数： 
   (1）将文件名作为字符串 ：FileReader f=new FileReader(“c:/temp.txt”); 
   (2）构造函数将File对象作为其参数。 
           File f=new file(“c:/temp.txt”); 
           FileReader f1=new FileReader(f); 
  (3)  构造函数将FileDescriptor对象作为参数 
         FileDescriptor() fd=new FileDescriptor() 
         FileReader f2=new FileReader(fd); 
               (1) 用指定字符数组作为参数：CharArrayReader(char[]) 
               (2) 将字符数组作为输入流:CharArrayReader(char[], int, int) 
        读取字符串，构造函数如下： public StringReader(String s); 
        2) CharArrayReader：与ByteArrayInputStream对应  
3) StringReader : 与StringBufferInputStream对应 
4) InputStreamReader 
     从输入流读取节字，在将它们换转成字符:Public inputstreamReader(inputstream is); 
5) FilterReader: 答应过滤字符流 
     protected filterReader(Reader r); 
6) BufferReader :接受Reader对象作为参数，并对其加添字符缓冲器，应用readline()方法可以读取一行。 
  Public BufferReader(Reader r); 

    

      重要方法：

    

      (1)  public int read() throws IOException; //读取一个字符，返回值为读取的字符 

    

(2)  public int read(char cbuf[]) throws IOException; /*读取一系列字符到数组cbuf[]中，返回值为现实读取的字符的数量*/ 
 (3)  public abstract int read(char cbuf[],int off,int len) throws IOException; 
 /*读取len个字符，从数组cbuf[]的下标off处开始寄存，返回值为现实读取的字符数量，该方法必须由子类现实*/ 

    

2. Writer抽象类

    

     入写字符流的抽象类。子类必须现实的方法唯一 write(char[], int, int)、flush() 和 close()。但是，数多子类将重写此处定义的一些方法，以供提更高的效率和/或其他功能。 其子类如下：

    

    

    

      1） FileWrite: 与FileOutputStream对应  
将字符型类据数入写文件，应用省缺字符编码和缓冲器巨细。 
Public FileWrite(file f); 
2)  chararrayWrite:与ByteArrayOutputStream对应 ,将字符缓冲器用作输出。 
   Public CharArrayWrite(); 
3) PrintWrite:生成格式化输出 
   public PrintWriter(outputstream os); 
4) filterWriter:用于入写过滤字符流 
   protected FilterWriter(Writer w); 
5) PipedWriter：与PipedOutputStream对应   

    

      6) StringWriter：无与之对应的以节字为导向的stream  

    

      重要方法：

    

(1)  public void write(int c) throws IOException； //将整型值c的低16位入写输出流 
(2)  public void write(char cbuf[]) throws IOException； //将字符数组cbuf[]入写输出流 
(3)  public abstract void write(char cbuf[],int off,int len) throws IOException； //将字符数组cbuf[]中的从引索为off的位置处开始的len个字符入写输出流 
(4)  public void write(String str) throws IOException； //将字符串str中的字符入写输出流 
(5)  public void write(String str,int off,int len) throws IOException； //将字符串str 中从引索off开始处的len个字符入写输出流 
(6)  flush( ) //刷空输出流，并输出有所被缓存的节字。 
(7)close()    关闭流 public abstract void close() throws IOException

    

 

    

 

    

3 .InputStream与Reader差异 OutputStream与Writer差异

    

 

    

InputStream和OutputStream类理处的是节字流，据数流中的最小单位是节字(8个bit)
Reader与Writer理处的是字符流，在理处字符流时及涉了字符编码的换转问题

    

 

    

  1. import java.io.*;  
  2. public class EncodeTest {  
  3.     private static void readBuff(byte [] buff) throws IOException {  
  4.        ByteArrayInputStream in =new ByteArrayInputStream(buff);  
  5.         int data;  
  6.         while((data=in.read())!=-1)   System.out.print(data+"  ");  
  7.         System.out.println();     in.close();     }  
  8.   
  9.    public static void main(String args[]) throws IOException {  
  10.        System.out.println("内存中采取unicode字符编码：" );  
  11.        char   c='好';  
  12.        int lowBit=c&0xFF;     int highBit=(c&0xFF00)>>8;  
  13.        System.out.println(""+lowBit+"   "+highBit);  
  14.        String s="好";  
  15.        System.out.println("当地作操统系认默字符编码：");  
  16.        readBuff(s.getBytes());  
  17.        System.out.println("采取GBK字符编码：");  
  18.        readBuff(s.getBytes("GBK"));  
  19.        System.out.println("采取UTF-8字符编码：");        
  20.        readBuff(s.getBytes("UTF-8"));      }  
  21. }  

    

    

    Reader类可以将输入流中采取其他编码型类的字符换转为Unicode字符，然后在内存中为其分配内存

    

    Writer类可以将内存中的Unicode字符换转为其他编码型类的字符，再写到输出流中。

    

    

    

 

    

3. IOException异常类的子类

    

 

    

1.public class  EOFException ：
   非正常达到文件尾或输入流尾时，抛出种这型类的异常。
2.public class FileNotFoundException：
   当文件找不到时，抛出的异常。
3.public class InterruptedIOException：
   当I/O作操被断中时，抛出种这型类的异常。

文章结束给大家分享下程序员的一些笑话语录： 一个合格的程序员是不会写出 诸如 “摧毁地球” 这样的程序的，他们会写一个函数叫 “摧毁行星”而把地球当一个参数传进去。

【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/xinyuyuanm/p/3036437.html