JAVA IO的小小总结

    流： 可将流看做是一根“管道”，一端连着数据源，一端连着目标源，让数据像 水流 样的输入/输出。

---

分类

按方向分，以程序为基准

输入流	InputStream
输入流	OutputStream

 

 

 

按读取单位分

字节流 （每次读取一个字节）	xxxInputStream,xxxOutputStream
字符流 （每次读取一个字符（两个字节））	xxxReader,xxxWriter

 

 

 

 

 

按功能分

节点流 （“管道”的一端直接指向某一节点，如文件，内存(数组，管道，字符串））	FileInputStream,FileOutputStream, FileReader,FileWriter,ByteArrayInputStream.........
处理流 (对流“管道”再套一层“管道”的流)	BufferedReader/BufferedWriter BufferedInputStream/BufferedOutputStream ............

 

 

 

 

 

 

---

常用方法

   InputStream

//读取一个字节并以整数的形式返回（0~255），
//如果返回-1已到输入流的末尾
int read() throws IOException

//读取一系列字节并存储到一个数组buffer,
//返回实际读取的字节数，如果读取前已到输入流的末尾返回-1
//字节数组，将这个数组装满数据在进行处理 ，以减少对硬盘的访问次数
int read(byte[] buffer) throws IOException

//读取length个字节
//并存储到一个字节数组buffer，从length位置开始
//返回实际读取的字节数，如果读取前已到输入流的末尾返回-1
int read(byte[] buffer,int offset,int length) throws IOException

//关闭流释放内存资源
void close() throws IOException
//跳过n个字节不读，返回实际跳过的字节数
long skip(long n) throws IOException

     OutputStream

//向输入流中写入一个字节数据，该字节数据为参数b的第8位
void writer(int b) throws IOException
//将一个字节类型的数组中的数据写入输出流
void write(byte[] b) throws IOException
//将一个字节类型的数组中的从指定位置（off）开始的
//len个字节写入到输出流
void write(byte[] b,int off,int len) throws IOException
//关闭流释放内存资源
void close() throws IOException
//将输出流中缓冲的数据全部写出到目的地
void flush() throws IOException

 * 先调用flush()方法将缓冲的数据全部写入目的地，在调用close()关闭；

    Reader

//读取一个字符并以整数的形式返回（0~255），
//如果返回-1已到输入流的末尾
int read() throws IOException
//读取一系列字符并存储到一个数组buffer
//返回实际读取的字符数，如果读取前已到输入流的末尾返回-1
int read(char[] cbuf) throws IOException
//读取lenght个字符
//并存储到一个数组buffer，从length位置开始
//返回实际读取的字符数，如果读取前已到输入流的末尾返回-1
int read(char[] cbuf,int offset,int length)	throws IOException
//关闭流释放内存资源
void close() throws IOException
//跳过n个字符不读，返回实际跳过的字节数
long skip(long n) throws IOException

   Writer

//向输出流中写入一个字符数据，该数据为参数b的第16位
void write(int c) throws IOException
//将一个字符类型的数组中的数据写入输出流
void write(char[] cbuf) throws IOException
//将一个字符类型的数组中的从指定位置（offset）开始的
//length个字符写入到输出流
void write(char[] cbuf,int offset,int length) throws IOException
//将一个字符串中的字符写入到输出流
void write(String string) throws IOException
//将一个字符串从offset开始的length个字符写入到输出流
void write(String string.int offset,int length) throws IOException
//关闭流释放资源
void close() throws IOException
//将输出流中缓冲的数据全部写出到目的地
void flush() throws IOException

---

流的使用

字节流------FileInputStream/FileOutputStream

读取文件内容，将内容打印到控制台，每次只读取一个字节

import java.io.FileInputStream;
import java.io.FileNotFoundException;

public class TestFileInputStream {
    public static void main(String[] args) {
        int b=0;
        FileInputStream fileInputStream=null;
        try {
            fileInputStream=new FileInputStream("src\\main\\java\\stream\\example.txt");
        } catch (FileNotFoundException e) {
            System.out.println("No found file");
            System.exit(-1);
        }
        try{
            long num=0;//记录读取多少字节
            while ((b=fileInputStream.read())!=-1){
                System.out.print((char)b);
                num++;
            }
            System.out.println();
            System.out.println("共读取了"+num+"字节");
            fileInputStream.close();
        }catch (Exception e){
            System.out.println("文件读取错误");
            System.exit(-1);
        }
    }
}

 

输出结果

读取源文件内容，并同时写入目标文件，即文件复制

package stream;

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

public class TestFileOutputStream {
    public static void main(String[] args) {
        FileInputStream fileInputStream=null;
        FileOutputStream fileOutputStream=null;
        int b=0;
        try {
            fileInputStream=new FileInputStream("src\\main\\java\\stream\\example.txt");
            fileOutputStream=new FileOutputStream("src\\main\\java\\stream\\example_output.txt");
        } catch (FileNotFoundException e) {
            System.out.println("No found file");
            System.exit(-1);
        }
        try{
            while ((b=fileInputStream.read())!=-1){
                //每次读取一个字节，并写进一个字节
                fileOutputStream.write(b);
            }
        }catch (IOException e){
            System.out.println("文件复制错误");
            System.exit(-1);
        }

    }
}

字符流--------FileReader/FileWriter

从文件中读取数据，每次读取一个字符，并打印到控制台

 

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

public class TestFileReadStream {
    public static void main(String[] args) {
        FileReader  fileReader=null;
        int b=0;
        try {
            fileReader=new FileReader("src\\main\\java\\stream\\example_read.txt");
            while ((b=fileReader.read())!=-1){
                System.out.print((char)b);//此时占用两个字节
            }
            fileReader.close();
            System.out.println();
        } catch (FileNotFoundException e) {
            System.out.println("找不到指定文件");
        } catch (IOException e) {
            System.out.println("文件读取错误");
        }
    }
}

输出结果

读取源文件内容，并同时写入目标文件

package stream;

import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class TestFileWriteStream {
    public static void main(String[] args) {
        FileWriter fileWriter=null;
        FileReader fileReader=null;
        int b;
        try {
            fileReader=new FileReader("src\\main\\java\\stream\\example_read.txt");
            fileWriter=new FileWriter("src\\main\\java\\stream\\example_write.txt");
            while ((b=fileReader.read())!=-1){
                fileWriter.write(b);
            }
            fileReader.close();
            fileWriter.close();

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

    }
}

输入结果

 

缓冲流-----Bufferedxxx

  作用：减少系统实际对数据源的访问次数，一次能对多个数据单位（字节或字符）进行读取/写入

  使用：对现有流“管道”再套一层“管道”

package stream;

import java.io.*;

/**
 *
 */
public class TestBufferReadStream {
    public static void main(String[] args) {
        try {
            BufferedReader bufferedReader=new BufferedReader(new FileReader("src\\main\\java\\stream\\example_bufferedReader.txt"));
            BufferedWriter bufferedWriter=new BufferedWriter(new FileWriter("src\\main\\java\\stream\\example_bufferedWriter.txt"));
            String s=null;
            for(int i=0;i<100;i++){
                s=String.valueOf(Math.random());//0-1随机数
                bufferedWriter.write(s);
                bufferedWriter.newLine();//换行
            }
            bufferedWriter.flush();
            while ((s=bufferedReader.readLine())!=null){
                System.out.println(s);
            }
            bufferedReader.close();
            bufferedWriter.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }

    }
}

 

输出结果

转换流------InputStreamWriter/OutputStreamReader

   作用：将字节流转换为字符流

package stream;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;

public class TestTransformStream2 {
    public static void main(String[] args) {
        InputStreamReader inputStreamReader=new InputStreamReader(System.in);
        BufferedReader bufferedReader=new BufferedReader(inputStreamReader);//转换
        String s=null;
        System.out.println("请输入：");
        try {
            s=bufferedReader.readLine();
            while (s!=null){
                if(s.equals("exit"))break;
                System.out.println(s.toUpperCase());
                s=bufferedReader.readLine();
            }
            bufferedReader.close();
        } catch (IOException e) {
            e.printStackTrace();
        }

    }
}

   输出结果

 

对象流----ObjectInputStream/ObjectOutputStream

作用：将对象转换为字节流

注意：若对象要序列化，则该类需要实现Serializable接口，实现方式由java虚拟机控制；类中添加transient关键字，表示对象序列化时将其忽视。

          

package stream;

import java.io.*;

/**
 * Object流：将对象转换为字节流
 *
 */
public class TestObjectIO {
    public static void main(String[] args) {
        T t=new T();
        t.k=8;
        try {
            //指定输出文件
            FileOutputStream fileOutputStream=new FileOutputStream("src\\main\\java\\stream\\example_object.txt");
            //套一层ObjectOutputStream管道
            ObjectOutputStream objectOutputStream=new ObjectOutputStream(fileOutputStream);
            objectOutputStream.writeObject(t);
            objectOutputStream.flush();
            objectOutputStream.close();

            //读取信息
            FileInputStream fileInputStream=new FileInputStream("src\\main\\java\\stream\\example_object.txt");

            ObjectInputStream objectInputStream=new ObjectInputStream(fileInputStream);
            T tRead=(T)objectInputStream.readObject();
            System.out.println(tRead);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }

    }
}

/**
 * 若对象要序列化，则必须要实现Serializable接口
 */
class T implements Serializable{
    int i=0;
    int j=9;
    double d=2.3;

    //添加transient关键字，序列化时不做处理
    transient  int k=15;

    @Override
    public String toString() {
        return "T{" +
                "i=" + i +
                ", j=" + j +
                ", d=" + d +
                ", k=" + k +
                '}';
    }
}

输出结果