IO流——常用IO流详解

1：字节流

　　字节流：用于处理以字节为单位的二进制文件（如音乐，图片等）

　　InputStream 是抽象类 它的对应子类FileInputStream可以被实例化

　　构造方法：

             FileInputStream常用构造方法：

                 FileInputStream(File file) ：通过File对象创建FileInputStream对象。                                             

            FileInputStream(String name) ：通过文件（非“目录”）路径创建FileInputStream对象。

　　常用方法：

            int read()：从输入流中读取单个字节的数据；如果已到达文件末尾，则返回 -1。

            int read(byte[] b)：从输入流中将最多b.length个字节的数据读入一个byte数组中，以整数形 式返回存入数组中的实际字节个数；如果已到达文件末尾，则返回 -1。                           void close()：关闭此文件输入流并释放与此流有关的所有系统资源

OutputStream是抽象类，它的子类FileOutputStream可以被实例化

　　构造方法：　　　

                            FileOutputStream(File file) ：通过File对象创建FileOutputStream对象。                                       

                               FileOutputStream(String name) ：通过文件（非“目录”）路径创建 FileOutputStream对象。 

                               FileOutputStream(File file, boolean append)：通过File对象创建 FileOutputStream对象；第二个参数如果为true ，则字节将被写入文件的末尾而不是开头

　　常用方法：

           FileOutputStream常用方法： 

                          void write(int b)：将指定的单个字节数据写入此文件输出流。

                            void write(byte[] b, int off, int len)：将byte数组中从off开始的len个字节写入此文件输出流。

                             void flush()：刷新字节输出流并强制写出缓冲内所有字节数据。

                             void close()：关闭此文件输出流并释放与此流有关的所有系统资源。

package com.xt.io;

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

public class FileInputStreamTest {

    public static void main(String[] args) {
        FileInputStream fis=null;
        FileOutputStream fos=null;
        try {
            /**
             * 读和写都是站在程序的角度来看的，读文件用FileInputStream  写文件用FileOutPutStream
             */
            fis=new FileInputStream("C:\中心.jpg");
            fos=new FileOutputStream("D:\重要.jpg");
            //第一种方法：一个字节一个字节的读
            /*int date;
            while((date=fis.read())!=-1) {
                System.out.println(date);
            }*/
            //第二种方法：1024个字节1024个字节的读
            byte[] bufferDate=new byte[1024];
            int length;
            while((length=fis.read(bufferDate))!=-1) {
                fos.write(bufferDate, 0, length);
            }
            fos.flush();//强制全部读出来所有的数据
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            //释放资源
            if(fos!=null) {
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            
            if(fis!=null) {
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

          1.1：缓冲字节流

　　缓冲输入流：BufferedInputStream      BufferedInputStream(InputStream in)：

　　缓冲输出流：BufferedOutputStream  BufferedOutputStream(OutputStream out)

package com.xt.io;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class BufferInputStreamTest {

    public static void main(String[] args) {
        try {
            BufferedInputStream bufferedInputStream=new BufferedInputStream(new FileInputStream("C:\中心.jpg"));
            BufferedOutputStream bufferedOutputStream=new BufferedOutputStream(new FileOutputStream("D:\重要k.jpg"));
        
            /*int b;
            while((b=bufferedInputStream.read())!=-1) {
                bufferedOutputStream.write(b);
            }*/
            
            byte[] bufferByte=new byte[1024];
            int length;
            while((length=bufferedInputStream.read(bufferByte))!=-1) {
                bufferedOutputStream.write(bufferByte, 0, length);
            }
            bufferedOutputStream.flush();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

2：字符流

    Reader是抽象类，它的子类FileReader 可以被实例化

　　构造方法：　　　

              FileReader常用构造方法： FileReader(File file) ：通过File对象创建FileReader对象。

　　　　　　　　　　　　　　　　 FileReader(String fileName) ：通过文件（非“目录”）路径创建FileReader对象。

　　常用方法：

　　　　　　　　FileReader常用方法： int read()：从输入流中读取单个字符的数据，如果已到达流的末尾，则返回 -1 。

　　　　　　　　　　　　　　　　　　 int read(char[] cbuf)：从输入流中将最多cbuf.length个字符的数据读入一个char数组中，以整数形式返回存入

　　　　　　　　　　　　　　　　　　　　　　　数组中的实际字节个数，如果已到达流的末尾，则返回 -1 。

　　　　　　　　　　　　　　　　　　 void close()：关闭此文件输入流并释放与此流有关的所有系统资源。

　　Writer是抽象类，它的子类FileWriter可以被实例化

　　构造方法：

　　　　　　FileWriter(File file) ：通过File对象创建FileWriter对象。

　　　　　　　　　　　　FileWriter(String fileName) ：通过文件（非“目录”）路径创建FileWriter对象。

　　　　　　　　　　　　 FileWriter(File file, boolean append)：通过File对象创建FileWriter对象；第二个参数如果为true ，则字节将被写入文件的末尾而不是开头。

　　常用方法：

　　　　　　void write(int c)：将指定的单个字符数据写入此文件输出流。

　　　　　　 void write(char[] cbuf, int off, int len)：将char数组中从off开始的len个字符写入此文件输出流。

　　　　　　　　void flush()：刷新字符输出流缓冲。

　　　　　　 void close()：关闭此文件输出流并释放与此流有关的所有系统资源。

package com.xt.io;

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Reader;
import java.io.Writer;

class FileReaderAndFileWriter {

    public static void main(String[] args) {
        Reader reader=null;
        Writer writer=null;
        try {
            reader=new FileReader("C:\unintall.log");
            writer=new FileWriter("D:\unintall.log");
            
            char[] buffer=new char[1024];
            int length;
            while((length=reader.read(buffer))!=-1) {
                writer.write(buffer, 0, length);
            }
            writer.flush();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }finally {
            try {
                if(writer!=null) {
                    writer.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if(reader!=null) {
                    reader.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        
        
    }
}

2.1：缓冲字符流

　　BufferedReader:缓冲字符输入流      BufferedReader(Reader in)：

　　BufferedWriter :缓冲字符输出流 BufferedWriter(Writer out)

package com.xt.io;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class BufferReaderTest {

    public static void main(String[] args) {
        try {
            BufferedReader bufferedReader =new BufferedReader(new FileReader("C:\unintall.log"));
            BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter("D:\unintall.log"));
            
            //第一种方法
//            int date;
//            while((date=bufferedReader.read())!=-1) {
//                bufferedWriter.write(date);
//            }
//            bufferedWriter.flush();
//            
//            
            //第二种方法
            char[] bufferDate=new char[1024];
            int length;
            while((length=bufferedReader.read(bufferDate))!=-1) {
                bufferedWriter.write(bufferDate, 0, length);
            }
            bufferedWriter.flush();
            
            
            //第三种方法
//            String lineDate;
//            while((lineDate=bufferedReader.readLine())!=null) {
//                bufferedWriter.write(lineDate);
//                bufferedWriter.newLine();
//            }
//            bufferedWriter.flush();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

3:转换流

转化只能是字节向字符转化

　　InputStreamReader(Reader in)　　

　　OutputStreamWriter(Writer out)

因为InputStreamReader是Reader的子类，所以同样可以用缓冲字符流BufferedReader(new InputStreamReader(Reader in))

t同理

package com.xt.io;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.UnsupportedEncodingException;

public class InputStreamReaderTest {

    public static void main(String[] args) {
        try {
            BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(new FileInputStream("C:\aa.txt"),"UTF-8"));
            BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("D:\bb.txt"), "UTF-8"));
            String lineDate;
            while((lineDate=bufferedReader.readLine())!=null) {
                bufferedWriter.write(lineDate);
                bufferedWriter.newLine();
            }
            bufferedWriter.flush();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

数据流

package com.xt.io;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.EOFException;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class DataInputStreamTest {

    public static void main(String[] args) {
        double[] scores = {20,50,42,62};
        DataOutputStream dataOutputStream=null ;
        try {
            dataOutputStream = new DataOutputStream(new FileOutputStream("D:\data.data")) ;
            for (double score : scores) {
                dataOutputStream.writeDouble(score);
            }
            dataOutputStream.flush();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if(dataOutputStream!=null) {
                try {
                    dataOutputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        
        
        try {
            DataInputStream dataInputStream=new DataInputStream(new FileInputStream("D:\data.data"));
            while(true) {
                System.out.println(dataInputStream.readDouble());
            }
            
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }catch(Exception e) {
            
        }
    }
}