6.2（java学习笔记）字节流

一、FileInputStream

文件输入流从文件中获取输入字节。简单的说就是读取文件。

1.构造方法

FileInputStream(File file)//根据指定文件对象创建一个输入流

2.常用方法

int read(byte[] b)

读取b.lenght个字节到字符数组中。返回读取到缓冲区的字节总数，如果没有数据可读则返回-1。

int read();

读取一个字节

int read(byte[] b,int off, int len);

读取len个字节，从b[off]开始放入。

举个例子，例如事先定义byte b = new byte[1024]

read(b,512,512),意思就是读取512个字节，放入b[512~1023]位中。

最后byte转为字符数组也需要从512开始转换。

new String(b,512,512);

void close()//关闭该文件的输入流并释放相关资源

3.例子

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

public class Test {
    public static void main(String[] args) {
        String pathR = "F:"+File.separator+"依风"+File.separator+"Desktop"+File.separator+"temp.txt";//被读取文件路径信息
    //    String pathW = "F:"+File.separator+"依风"+File.separator+"Desktop"+File.separator+"tempW.txt";
        File fr = new File(pathR);//建立文件对象
    //    File fw = new File(pathW);
        OutputStream write = null;
        InputStream read = null; //输入流
        try {
    //        fw.createNewFile();
            read = new FileInputStream(fr);//初始化文件输入流
    //        write = new FileOutputStream(fw);
            int len = 0;                 //记录读取字节数
            byte[] car=new byte[1024];//设置读取字节数组
            while(-1 != (len = read.read(car))){//数据充足情况下，每次读取1024byte
    //            write.write(car, 0, len);
                System.out.println(new String(car,0,len));//将字节数组b转换为数组
            }
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
            System.out.println("文件未找到！");
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
            System.out.println("读取文件失败！");
        }finally{
            try {
                read.close();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
                System.out.println("释放资源失败！");
            }
        }
    }
}

运行结果：
略，
会显示读取文件中内容，由指定文件决定。

二、FileOutputStream

文件输出流是用于将数据写入文件.

1.构造函数

FileOutputStream(File file)

FileOutputStream(String name)

根据指定文件对象创建一个输出流。

传递参数为字符串的构造函数实际上也是用传递进去的字符串创建一个File对象。

FileOutputStream(File file, boolean append)//创建一个输入流对象，并可以指定写入形式是否为追加。默认为false即不追加

写入形式为追加，即原有数据会保留，并且在原有数据之后写入数据。

如果不是为追加，即将原有数据全部删除，然后写入数据。

举个简单的例子，假如一个文件中有123。用追加的形式写入4，此时文件中有1234。

如果不是用追加的形式写入，此时文件中只有4。

2.常用方法

void write(byte[] b)

//将b.lenght长度字节写入指定文件。

void write(byte[] b, int off, int len)

//将数组[off]位开始的len个字节写入。

void close()

//关闭该文件的输出流，并释放与此流关联的任何资源。

public void flush()

将缓冲区中字节写入，因为读取的字节是放在缓冲区，而系统会等缓冲区满后才将缓冲区中的字节写入文件。

为了防止有字节遗留在缓冲区中，最好在最后调用这个函数。

3.例子

想用前面的输入流读取文件，然后将读取的内容写入一个新文件。（相当于文件的拷贝）

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.Flushable;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;

public class Test {
    public static void main(String[] args) {
        String pathR = "F:"+File.separator+"依风"+File.separator+"Desktop"+File.separator+"temp.txt";//被读取文件路径信息
        String pathW = "F:"+File.separator+"依风"+File.separator+"Desktop"+File.separator+"tempW.txt";
        File fr = new File(pathR);//建立文件对象
        File fw = new File(pathW);
        OutputStream write = null;
        InputStream read = null; //输入流
        try {
            fw.createNewFile();
            read = new FileInputStream(fr);//初始化文件输入流
            write = new FileOutputStream(fw);
            int len = 0;                 //记录读取字节数
            byte[] car=new byte[1024];//设置读取字节数组
            while(-1 != (len = read.read(car))){//数据充足情况下，每次读取1024byte
                write.write(car,0,len);//写入读取的字节
                System.out.println(new String(car,0,len));//将字节数组b转换为数组
            }
          write.flush();//将缓冲区中字节写入
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
            System.out.println("文件未找到！");
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
            System.out.println("读取文件失败！");
        }finally{
            try {
                read.close();//关闭资源
                write.close();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
                System.out.println("释放资源失败！");
            }
        }
    }
}

运行结果：
略，
运行完程序，会新建一个.txt文件,并将读取的内容写入。

我们将上面的write = new FileOutputStream(fw)中添加一个true，

FileOutputStream(fw,true),写入这时就是在原有数据后面追加。

例如将上列例子运行完或，将写入方式修改为追加，再次运行程序后，就会在原有内容之后追加。

下面结合上述知识举一个拷贝文件夹的例子。

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.Flushable;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
//将pathR文件夹拷贝到pahtW文件夹下。
public class Test {
    public static void main(String[] args) {
        String pathR = "E:\\ssm";//文件夹路径信息
        String pathW = "F:" + "依风" + File.separatorChar + "Desktop";//
        File fr = new File(pathR);//建立文件对象
        File fw = new File(pathW);
        directoryCopy(fr,fw);//文件夹拷贝

    }
    public static void directoryCopy(File fr,File fw){//问价夹拷贝
        if(fr.isDirectory()){//如果是文件夹则创建需要拷贝的文件夹，并调用文件夹拷贝函数。
            File fi = new File(fw,fr.getName());//如果fr是文件夹则在fw路径下新建一个文件夹
            fi.mkdirs();
            File[] child = fr.listFiles();//获取文件夹下所有子对象
            for(File temp:child){//遍历子对象
                directoryCopy(temp,fi);//递归
            }
        }else{//如果不是文件夹则拷贝文件
            fileCopy(fr,new File(fw,fr.getName()));
            }
    }

    public static void fileCopy(File fr,File fw){//文件拷贝函数，只是将上列例子中代码写成了一个方法
        OutputStream write = null;
        InputStream read = null; //输入流
        try {
            read = new FileInputStream(fr);//初始化文件输入流
            write = new FileOutputStream(fw);
            int len = 0;                 //记录读取字节数
            byte[] car=new byte[1024*10];//设置读取字节数组
            while(-1 != (len = read.read(car))){//数据充足情况下，每次读取1024byte
                write.write(car,0,len);//写入读取的字节
                System.out.println(new String(car,0,len));//将字节数组b转换为数组
            }
          write.flush();//将缓冲区中字节写入
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
            System.out.println("文件未找到！");
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
            System.out.println("读取文件失败！");
        }finally{
            try {
                write.close();
                read.close();//关闭资源
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
                System.out.println("释放资源失败！");
            }
        }
    }
}

运行结果：
略，
会发现pathW所指向的路径下有pathR所指向的文件夹，
即文件拷贝成功。

下面结合上列代码综合下，将文件、文件夹的拷贝写成一个FileUtil类。

FileUtil类

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

public class FileUtil {
    //只支持文件拷贝到文件、文件夹.
    public static void fileCopy(File pathR,File pathW){
        if(pathR.isDirectory()){
            try {
                throw new IOException("只支持文件拷贝到文件、文件夹," +"\n"+
                           "不支持文件夹拷贝到文件、文件夹.");
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            return;
        }
        OutputStream write = null;
        InputStream read = null; //输入流
        try {
            read = new FileInputStream(pathR);//初始化文件输入流
            if(pathW.isDirectory()){//如果是将文件拷贝到文件夹，则先在文件夹下创建文件，然后拷贝。
                File fi = new File(pathW,pathR.getName());
                fi.createNewFile();
                write = new FileOutputStream(fi);
            }else{//文件拷贝到文件。
                write = new FileOutputStream(pathW);
            }
            int len = 0;                 //记录读取字节数
            byte[] car=new byte[1024*10];//设置读取字节数组
            while(-1 != (len = read.read(car))){//数据充足情况下，每次读取1024byte
                write.write(car,0,len);//写入读取的字节
                System.out.println(new String(car,0,len));//将字节数组b转换为数组
            }
          write.flush();//将缓冲区中字节写入
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
            System.out.println("文件未找到！");
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
            System.out.println("读取文件失败！");
        }finally{
            try {
                write.close();
                read.close();//关闭资源
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
                System.out.println("释放资源失败！");
            }
        }
    }
    //只支持文件、文件夹拷贝到文件夹
    public static void directoryCopy(File pathR,File pathW){
        if(pathR.isDirectory() && pathW.isFile()){
            try {
                throw new IOException("只支持文件、文件夹拷贝到文件夹," +"\n"+
                           "不支持文件、文件夹拷贝到文件.");
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            return;
        }
        if(pathR.isDirectory()){//如果是文件夹则创建文件夹，并且获取文件夹下所有子对象
            File fi = new File(pathW,pathR.getName());
            fi.mkdirs();
            File[] child = pathR.listFiles();
            for(File temp:child){//遍历文件夹下子对象
                directoryCopy(temp,fi);//递归
            }
        }else{//如果是文件则直接拷贝
            fileCopy(pathR,new File(pathW,pathR.getName()));
        }
    }
}

import java.io.File;

public class Test {
    public static void main(String[] args) {
        String pathDir01 = "E:\\ssm";//文件夹
        String pathDir02 = "F:";
        String pathFile01 = "F:" + "依风" + File.separatorChar + "Desktop"+ File.separatorChar +"temp01.xml";//文件
        String pathFile02 = "F:" + "依风" + File.separatorChar + "Desktop"+ File.separatorChar +"temp02.xml";
        File dir01 = new File(pathDir01);//文件夹
        File dir02 = new File(pathDir02);//文件夹
        File f1 = new File(pathFile01);//文件
        File f2 = new File(pathFile02);
        //注：dir01，dir02，f1，f2所指向的文件、文件夹必须存在，否则会出现FileNotFound异常
        //（f1，f2）将f1拷贝给f2
        FileUtil.fileCopy(f1, f2);//文件拷贝到文件。
        FileUtil.fileCopy(f1, dir02);//文件拷贝到文件夹。
        FileUtil.directoryCopy(f2, dir01);//文件拷贝到文件夹
        FileUtil.directoryCopy(dir01, dir02);//文件夹拷贝到文件夹

    }
}

三、字符流

字符流用法与字节流操作方法类似，但字符流只能处理字符，

不能处理其他格式文件（例如.jpg等不能处理）。

但字节流没有这个局限性，字节流可以处理任意类型数据。

Writer字符流写操作的抽象类，其子类有FileWtriter等.

Reader字符流读操作的抽象类，其子类有FileReader等.

FileWtriter构造方法：

FileWriter(File file)
FileWriter(File file, boolean append)
FileWriter(String fileName)
FileWriter(String fileName, boolean append)

构造方法和字节流类似，传递的参数可为文件对象或对应字符串地址，

append指定写方式是否为追加，默认为false。

FileReader构造方法：

FileReader(File file)
FileReader(String fileName)

Wtrite类常用方法：

public void write(int c)
public void write(String str)
public void write(String str, int off, int len)

可写入单个字符，也可写入字符串。

Reader类常用方法

int read()//读取单个字符，返回用int类型表示的字符，如果已到末尾返回-1
int read(char[] cbuf)//返回读取的字符个数，如果已到末尾返回-1.

字符流操作方法与字节流操作方法类似：

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

public class Test {
    public static void main(String[] args){
        String pathW = "F:\\依风\\Desktop\\writer.txt";
        String pathR = "F:\\依风\\Desktop\\reader.txt";

        File fr = new File(pathR);
        File fw = new File(pathW);

        Writer w1 = null;
        Reader r1 = null;
        try {
            int c = 0;
            //先reader.txt件中写入字符
            w1 = new FileWriter(fr);
            w1.write("hello IO!");
            w1.flush();//刷新缓冲区，关闭文件
            w1.close();

            w1 = new FileWriter(fw);
            r1 = new FileReader(fr);
            //读取reader.txt文件，然后将读取数据写入wtriter.txt中
            //相对于拷贝
            while(-1 != (c = r1.read())){//读取单个字符，返回该字符的int型表示
                w1.write(c);
                System.out.print((char)c);
            }
            w1.flush();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }finally{
            try {
                w1.close();
                r1.close();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }
}

运行结果：
hello IO！