Java-IO操作

IO流包括字节流（Byte）和字符流（String/char）

字节流：

在JDK中定义了两个抽象类InputStream和OutputStream，它们是字节流的顶级父亲。

InputStream的常用方法：

int read()，从输入流读取一个8位的字节，把它转换为0~255之间的整数，并返回这一整数。

int read(byte[] b )，从输入流读取若干个字节，把它们保存到参数b指定的字节数组中，返回的整数表示读取字节数。

int read(byte[] b ,int  off,int len)，从输入流读取若干个字节，把它们保存到参数b指定的字节数组中，off指定字节数组开始保存数据的起始下标，len表示读取的字节数目。

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

OutputStream的常用方法：

void write()，像输出流写入一个8位的字节。

void write(byte[] b )，参数b指定的字节数组的所有字节写到输出流。

void read(byte[] b ,int  off,int len)，把参数b指定的字节数组中从off指定开始的len个字节写入输入流。

void flush()，刷新此输出流并强制写出所有缓冲的输出字节。

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

FileInputStream

package stream;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
public class FileInputStreamDemo{
    public static void main(String[] args) {
        File srcFile=new File("CopyStreamDemo.txt");
        try {
            InputStream inputStream=new FileInputStream(srcFile);
            byte[] buffer=new byte[1024];
            int len=-1;
            while((len=inputStream.read(buffer))!=-1) {//从输入流inputStream读取若干字节，把它们保存到参数buffer中去，同时判断是否读到文件末尾
                String text=new String(buffer,0, len, "utf-8");//将字节数组转换为字符串
                System.out.printf(text);
            }
            inputStream.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

FileOutputStream

package stream;

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

public class FileOutputStreamDemo {

    public static void main(String[] args) {
        File desfile=new File("target.txt");
        try {
            String text="我的第一个记事本程序\r\n还有第二行";
            OutputStream os=new FileOutputStream(desfile);
            byte[] buffer=text.getBytes("utf-8");//将字符串转换为字节数组
            os.write(buffer);
            System.out.println("文件写入完成！");
            os.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

此外，注意在IO包中提供的两个带缓冲的字节流，BufferedInputStream和BufferedOutputStream，它们的构造方法中分别接收InputStream和OutputStream类型的参数作为被包装的对象。

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

public class FileCopy{
    public static void main(String[] args) {
        File srcFile=new File("CopyStreamDemo.txt");
        File desFile=new File("target.java");
        try {
            /**
             * 带缓冲的字节流，BufferedInputStream和BufferedOutputStream，二者接收InputStream和OutputStream作为参数
             */
            BufferedInputStream is=new BufferedInputStream(new FileInputStream(srcFile));
            BufferedOutputStream os=new BufferedOutputStream(new FileOutputStream(desFile));
            byte[] buffer=new byte[1024];
            int len=-1;
            System.out.println("正在复制文件，请稍后...");
            while((len=is.read(buffer))!=-1) {
                os.write(buffer,0,len);
            } 
            System.out.println("文件复制完成！");
            is.close();
            os.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

字符流：

字符流也有两个顶级父亲，分别是Reader和Writer，其中Reader是字符输入流，用于从某个源设备读取字符，Writer是字符输出流，用于向某个目标设备写入字符。

其中，FileReader和FileWriter用于读写文件，BufferedReader和BufferedWriter是具有缓冲功能的流，它们可以提高读写效率。

FileReader和FileWriter实现文件读写：

package chars;

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

public class CopyByCharsDemo {
    public static void main(String[] args) {
        File srcFile=new File("BufferedReaderDemo.txt");
        File desFile=new File("dest.txt");
        try {
            Reader reader=new FileReader(srcFile);
            Writer writer=new FileWriter(desFile);
            char[] buffer=new char[1024];
            int len=-1;
            while((len=reader.read(buffer))!=-1) {
                writer.write(buffer);
            }
            System.out.println("复制完成！");
            reader.close();
            writer.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        
    }
}

BufferedReader

package chars;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
/**
 * 文件Reader,BufferedReader同BufferedInputStream一样，内部参数是new FileReader(srcFile)
 * @author Administrator
 *
 */
public class BufferedReaderDemo {
    public static void main(String[] args) {
        File srcFile=new File("CopyByCharsDemo.txt");
        try {
            BufferedReader bReader=new BufferedReader(new FileReader(srcFile));
            String res=null;
            while((res=bReader.readLine())!=null) {//每次读取一行文本，判断是否到文件结尾
                System.out.println(res);
            }
            bReader.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

}

总结：

1.文件读取时，不论是用InputStream还是Reader还是BufferedInputStream读取时都用len，while（（len=is.read(buffer)）!=-1）,但是在BufferedReader中，定义一个String res=null,这时的判断条件是 while((res=br.readLine())!=null)
2.文件读写完成后，记得要善后，即is.close()