目录

目标

相关概念

实战——方法演练

字节流

输入流

输出流

字符流

输入流

输出流

缓冲流

字节缓冲流

字符缓冲流

转换流

实战——例题

复制一张图片

• 熟悉流的分类和基本概念。
• 熟练使用各种流的常用方法。本文介绍最常用的子类来实现数据的读写，如果后续大家遇到其他字类也能举一反三。

相关概念

输入流

把数据读取到内存的流是输入流。java.io.InputStream抽象类是表示字节输入流的所有类的超类。java.io.Reader抽象类是表示字符输入流的所有类的超类。

输出流

把数据写出到其他设备的流是输出流。java.io.OutputStream抽象类是表示字节输出流的所有类的超类。java.io.Writer抽象类是表示字符输出流的所有类的超类。

字节流

以字节为单位读写数据的流是字节流。但是无论使用什么流，底层传输的始终为二进制数据。

字符流

以字符为单位读写数据的流是字符流。

字节缓冲流

创建字节流对象时会创建一个内置地缓冲区数组，默认大小为8192个byte。通过缓冲区读写减少I/O次数，提高效率。最常用的字节缓冲输入流是java.io.BufferedInputStream类。最常用的字节缓冲输出流是java.io.BufferedOutputStream类。

字符缓冲流

创建字节流对象时会创建一个内置地缓冲区数组，默认大小为8192个char。最常用的字符缓冲输入流是java.io.BufferedReader类。最常用的字符缓冲输出流是java.io.BufferedWriter类。

转换流

文件编码有很多种，使用转换流进行读写时可以指定编码，以此避免乱码问题。输入转换流是java.io.InputStreamReader类。输出转换流是java.io.OutputStreamWriter类。

---

实战——方法演练

字节流

输入流

package io;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;


public class FileInputStreamDemo {
    public static final String MY_PROJECT_FILE = "a/a.txt";

    public static void main(String[] args) {
        new FileInputStreamDemo().readBatchByte();
    }

    
    public void readOneByte() {
        FileInputStream fileInputStream = null;
        try {
            //没有指定盘符，则查询相对目录。
            fileInputStream = new FileInputStream(MY_PROJECT_FILE);
            //读取一个字节，返回int，强转成字符。
            char a = (char) fileInputStream.read();
            char b = (char) fileInputStream.read();
            char c = (char) fileInputStream.read();
            System.out.println(a);
            System.out.println(b);
            System.out.println(c);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //关闭流
            if (fileInputStream != null) {
                try {
                    fileInputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    
    public void readBatchByte() {
        FileInputStream fileInputStream = null;
        try {
            fileInputStream = new FileInputStream(MY_PROJECT_FILE);
            byte[] bytes =new byte[8];
            int flat;
            while((flat=fileInputStream.read(bytes) )!=-1){
                //如果末尾字节不足，则会追加补充多余字节，所以不推荐使用该方法。
                //System.out.println(new String(bytes));
                //读取多少个字节就输出多少个长度。
                System.out.println(new String(bytes,0,flat));
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //关闭流
            if (fileInputStream != null) {
                try {
                    fileInputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    
    public void readAll() {
        FileInputStream fileInputStream = null;
        try {
            fileInputStream = new FileInputStream(MY_PROJECT_FILE);
            int flag;
            List list = new ArrayList<>();
            //如果达到文件的末尾则返回-1 。
            while ((flag = fileInputStream.read()) != -1) {
                list.add((char) flag);
            }
            System.out.println(list);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //关闭流
            if (fileInputStream != null) {
                try {
                    fileInputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    
    
    public void readByteBySkip() {
        FileInputStream fileInputStream = null;
        try {
            fileInputStream = new FileInputStream(MY_PROJECT_FILE);
            fileInputStream.skip(2);
            int flag;
            List list = new ArrayList<>();
            //如果达到文件的末尾则返回-1 。
            while ((flag = fileInputStream.read()) != -1) {
                list.add((char) flag);
            }
            System.out.println(list);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //关闭流
            if (fileInputStream != null) {
                try {
                    fileInputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

输出流

package io;

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


public class FileOutputStreamDemo {
    public static final String MY_FILE = "C:\Users\huangshang\Desktop\demo\FileOutputStreamDemo.txt";

    public static final String MY_PROJECT_FILE = "a/a.txt";

    public static void main(String[] args) {
        new FileOutputStreamDemo().findFile();
    }

    
    public void coverWrite() {
        FileOutputStream fileOutputStream = null;
        try {
            fileOutputStream = new FileOutputStream(MY_FILE);
            //也可以这样写
            //fileOutputStream = new FileOutputStream(new File(MY_FILE));
            //往文件写入字节。
            fileOutputStream.write(97);
            fileOutputStream.write(98);
            fileOutputStream.write(99);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //关闭流
            if (fileOutputStream != null) {
                try {
                    fileOutputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    
    public void coverWriteArray() {
        FileOutputStream fileOutputStream = null;
        try {
            fileOutputStream = new FileOutputStream(MY_FILE);
            String a="hello world!";
            //往文件写入字节数组。
            fileOutputStream.write(a.getBytes());
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //关闭流
            if (fileOutputStream != null) {
                try {
                    fileOutputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    
    public void appendWrite() {
        FileOutputStream fileOutputStream = null;
        try {
            fileOutputStream = new FileOutputStream(MY_FILE,true);
            //也可以这样写
            //fileOutputStream = new FileOutputStream(new File(MY_FILE),true);
            String a="hello world!";
            //往文件写入字节数组。
            fileOutputStream.write(a.getBytes());
            //往文件写入字节。
            fileOutputStream.write(97);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //关闭流
            if (fileOutputStream != null) {
                try {
                    fileOutputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    
    public void offestAndLengthWrite() {
        FileOutputStream fileOutputStream = null;
        try {
            fileOutputStream = new FileOutputStream(MY_FILE);
            String a="hello world!";
            //从第三个位置开始写入，长度为2。所以将写入lo
            fileOutputStream.write(a.getBytes(),3,2);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //关闭流
            if (fileOutputStream != null) {
                try {
                    fileOutputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    
    public void findFile() {
        FileOutputStream fileOutputStream = null;
        try {
            //没有指定盘符，则查询相对目录。
            fileOutputStream = new FileOutputStream(MY_PROJECT_FILE);
            String a="hello world!";
            fileOutputStream.write(a.getBytes());
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //关闭流
            if (fileOutputStream != null) {
                try {
                    fileOutputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

---

字符流 输入流

package io;

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;


public class FileReaderDemo {
    public static final String MY_FILE = "C:\Users\huangshang\Desktop\demo\es.txt";

    public static void main(String[] args) {
        new FileReaderDemo().readAllByOne();
    }

    
    public void readOne() {
        FileReader fileReader = null;
        try {
            //创建字符输入流
            fileReader=new FileReader(MY_FILE);
            int a=fileReader.read();
            System.out.println((char) a);

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

    
    public void readAllByOne() {
        FileReader fileReader = null;
        try {
            //创建字符输入流
            fileReader=new FileReader(MY_FILE);
            int a=-2;
            while((a=fileReader.read()) !=-1){
                System.out.println((char) a);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (fileReader != null) {
                    fileReader.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    
    public void readBatch() {
        FileReader fileReader = null;
        try {
            //创建字符输入流
            fileReader=new FileReader(MY_FILE);
            char[] ch =new char[2];
            int a=fileReader.read(ch);
            if(a !=-1){
                //读取多少数据就数据多少数据。
                System.out.println(new String(ch,0,a));
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (fileReader != null) {
                    fileReader.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

输出流

package io;

import java.io.FileNotFoundException;
import java.io.FileWriter;
import java.io.IOException;


public class FileWriteDemo {
    public static final String MY_FILE = "C:\Users\huangshang\Desktop\demo\es.txt";
    public static final String MY_PROJECT_FILE = "a/a.txt";

    public static void main(String[] args) {
        new FileWriteDemo().writeFlush();
    }

    
    public void writeOne() {
        FileWriter fileWriter = null;
        try {
            //创建字符输入流
            fileWriter=new FileWriter(MY_FILE);
            fileWriter.write(98);
            fileWriter.write(98);

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

    
    public void writeBatch() {
        FileWriter fileWriter = null;
        try {
            //创建字符输入流
            fileWriter=new FileWriter(MY_FILE);
            char[] chars = "hello world!".toCharArray();
            fileWriter.write(chars);

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

    
    public void writeBatchByOffset() {
        FileWriter fileWriter = null;
        try {
            //创建字符输入流
            fileWriter=new FileWriter(MY_FILE);
            char[] chars = "hello world!".toCharArray();
            //写入llo
            fileWriter.write(chars,2,3);

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

    
    public void writeString() {
        FileWriter fileWriter = null;
        try {
            //创建字符输入流
            fileWriter=new FileWriter(MY_FILE);
            fileWriter.write("hello java!",3,4);

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

    
    public void writeStringByOffset() {
        FileWriter fileWriter = null;
        try {
            //创建字符输入流
            fileWriter=new FileWriter(MY_FILE);
            fileWriter.write("hello java!",3,4);

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

    
    public void writeFlush() {
        FileWriter fileWriter = null;
        try {
            //创建字符输入流
            fileWriter=new FileWriter(MY_PROJECT_FILE);
            fileWriter.write("hello ");
            fileWriter.flush();
            Thread.sleep(3000);
            fileWriter.write(" java ");
            fileWriter.flush();
            int a=1/0;
            Thread.sleep(3000);
            fileWriter.write(" c# ");
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            try {
                if (fileWriter != null) {
                    fileWriter.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

---

缓冲流

字节缓冲流

package io;

import java.io.*;


public class ByteBufferStreamDemo {
    public static final String MY_PROJECT_FILE = "a/a.txt";

    public static void main(String[] args) {
        new ByteBufferStreamDemo().outputStreamFun();
    }

    
    public void inputStreamFun(){
        BufferedInputStream bufferedInputStream =null;
        try {
            bufferedInputStream=new BufferedInputStream(new FileInputStream(MY_PROJECT_FILE));
            byte[] bytes=new byte[1024];
            int len;
            if((len=bufferedInputStream.read(bytes)) !=-1){
                //读了多少数据就输出多少数据
                System.out.println(new String(bytes,0,len));
            }

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

    
    public void outputStreamFun(){
        BufferedOutputStream  bufferedOutputStream =null;
        try {
            bufferedOutputStream=new BufferedOutputStream(new FileOutputStream(MY_PROJECT_FILE));
            byte[] bytes = "hello world !".getBytes();
            bufferedOutputStream.write(bytes);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(bufferedOutputStream !=null){
                try {
                    bufferedOutputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

字符缓冲流

package io;

import java.io.*;


public class CharBufferStreamDemo {
    public static final String MY_PROJECT_FILE = "a/a.txt";

    public static void main(String[] args) {
        new CharBufferStreamDemo().readLineFun();
    }
    
    public void inputStreamFun(){
        BufferedReader bufferedReader =null;
        try {
            bufferedReader=new BufferedReader(new FileReader(MY_PROJECT_FILE));
            char[] ch=new char[1024];
            int len;
            while((len=bufferedReader.read(ch))!=-1 ){
                System.out.println(new String(ch,0,len));
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally{
            try {
                if(bufferedReader !=null){
                    bufferedReader.close();
                }

            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    
    public void readLineFun(){
        BufferedReader bufferedReader =null;
        try {
            bufferedReader=new BufferedReader(new FileReader(MY_PROJECT_FILE));
            System.out.println("=========一行一行地读取数据=========");
            bufferedReader.readLine();
            String data;
            while((data=bufferedReader.readLine() )!= null){
                System.out.println(data);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally{
            try {
                if(bufferedReader !=null){
                    bufferedReader.close();
                }

            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    
    public void newLineFun(){
        BufferedWriter bufferedWriter =null;
        try {
            bufferedWriter=new BufferedWriter(new FileWriter(MY_PROJECT_FILE));
            bufferedWriter.write("hi");
            //换行
            bufferedWriter.newLine();
            bufferedWriter.write("Tom");

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

---

转换流

package io;

import java.io.*;

public class ConvertInputDemo {
    public static final String MY_FILE = "a/gbk.txt";

    public static void main(String[] args) {
        new ConvertInputDemo().inputStreamFun();
    }

    
    public void inputStreamFun() {
        InputStreamReader inputStreamReader = null;
        try {
            inputStreamReader = new InputStreamReader(new FileInputStream(MY_FILE), "GBK");
            char[] ch = new char[1024];
            int len;
            while ((len = inputStreamReader.read(ch)) != -1) {
                System.out.println(new String(ch, 0, len));
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    
    public void outputStreamFun() {
        OutputStreamWriter outputStreamWriter = null;
        try {
            outputStreamWriter = new OutputStreamWriter(new FileOutputStream(MY_FILE), "GBK");
            outputStreamWriter.write("你好n");
            outputStreamWriter.write("世界");
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                if(outputStreamWriter !=null){
                    outputStreamWriter.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

---

实战——例题

复制一张图片

package io;

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


public class CopyImgDemo {
    public static void main(String[] args) {
        FileInputStream fis = null;
        FileOutputStream fos = null;
        try {
            //第一步：创建输入流和输出流
            fis = new FileInputStream("C:\Users\huangshang\Pictures\logo\1.jpg");
            fos = new FileOutputStream("C:\Users\huangshang\Pictures\logo\2.jpg");
            //第二步：读取字节数据，写入字节数据。
            byte[] bytes = new byte[1024];
            int readLength = fis.read(bytes);
            while(readLength !=-1){
                fos.write(bytes);
                readLength=fis.read(bytes);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (fis == null) {
                    fis.close();
                }
                if (fos == null) {
                    fos.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}