Java第三阶段学习（二、IO流--------递归，字节流Stream）

一、递归

定义：指方法在方法内调用自己

适用于方法的运算主体不变，但运行的时候，参与运算的方法参数会变化
注意：一定要给递归一个出口，否则内存溢出

练习题1：使用递归打印文件夹中所有的文件，包含子目录中的文件

public static void main(String[] args) {
        File f=new File("e:\\java");
        getAllFile(f);
    }
    public static void getAllFile(File f){
        File[] file=f.listFiles();
        for(File f1:file){
            if(f1.isDirectory()){
                getAllFile(f1);   //如果判断为文件夹，则再次调用方法，一直到没有子目录结束
            }else{
                System.out.println(f1);  //打印就是相当于  这个递归方法的出口
            }    
        }
    }

 练习题2：使用递归搜索指定目录中的.java文件（包含子目录）

创建一个自定义过滤器类，用来选择.java文件：

import java.io.File;
import java.io.FileFilter;

public class MyFileter implements FileFilter {

    @Override
    public boolean accept(File pathname) {
        if(pathname.isDirectory()){
            return true;
        }
        //将文件名称全部转小写
        return pathname.getName().toLowerCase().endsWith(".java");
    }
    
}

 在主方法使用递归，并打印：

public static void main(String[] args) {
        // TODO Auto-generated method stub
        File file=new File("e:\\java");
        getFile(file);
    }
    public static void getFile(File file){
        //new MyFileter()  是listFiles调用的
        File[] files=file.listFiles(new MyFileter());
        for(File f:files){
            if(f.isDirectory()){
                getFile(f);
            }else{
                System.out.println(f);
            }
        }
    }

 二、字节流Stream

2.1字节输出流  OutputStream

OutputStream此抽象类，是表示输出字节流的所有类的超类。操作的数据都是字节，定义了输出字节流的基本共性功能方法。

输出流中定义都是写write方法，如下图:

2.2FileOutputStream类（文件输出流）

OutputStream有很多子类，其中子类FileOutputStream可用来写入数据到文件。

FileOutputStream类，即文件输出流，是用于将数据写入 File的输出流。

 构造方法： FileOutputStream fos=new FileOutputStream("文件的路径");

续写和换行：

　　续写：因为直接写入的时候会覆盖原有的文件，所以如果想要续写，就需要在路径后面加上true

　 　代码：FileOutputStream fos=new FileOutputStream("文件的路径",true);

　　 换行："\t\n"，在存在续写代码的前提下，加入代码即可实现换行

2.3 IO流异常的处理

 代码演示：

package com.oracle.Demo02;

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

public class Demo02 {
//续写和换行
    //FileOutputStream fos=new FileOutputStream(file,true);   续写加个true
    //在字符串后面加上  \r\n   就可以换行了
    //处理IO异常
    //1.保证你的对象变量作用域足够
    //2.catch块里面怎么处理异常
    //        (IOException一般不能处理)throw new RuntimeException
    //3.流对象建立失败，还需要关闭资源吗？
    //    不需要，加一个if(fos!=null)的判断close
    public static void main(String[] args){
        FileOutputStream fos=null;
        try{
            fos=new FileOutputStream("e:\\java\\output.txt",true);
            fos.write("abcd\r\n".getBytes());   //将字符串转为字节数组
        }catch(IOException ex){
            throw new RuntimeException("文件异常");
        }finally{
            try{
                if(fos!=null){
                    fos.close();
                }
            }catch(IOException ex){
                throw new RuntimeException("文件关闭异常");
            }
        }
    }

}

2.4 字节输入流InputStream

把硬盘中的数据读取到内存中，通过InputStream可以实现，InputStream此抽象类，是表示字节输入流的所有类的超类。定义了字节输入流的基本共性功能方法。

  方法：int read():读取一个字节并返回，没有字节返回-1.

　　　   int read(byte[]): 读取一定量的字节数，并存储到字节数组中，返回读取到的字节数。（字节数组的方式）。

2.5    FileInputStream类(文件输入流)

InputStream有很多子类，其中子类FileInputStream可用来读取文件内容。

FileInputStream 从文件系统中的某个文件中获得输入字节。

构造方法：FileInputStream fis=new FileInputStream("文件的路径");

 

2.6    FileInputStream类读取数据read方法

在读取文件中的数据时，调用read方法，实现从文件中读取数据

在读取文件中的数据时，调用read方法，每次只能读取一个，太麻烦了，于是我们可以定义数组作为临时的存储容器，这时可以调用重载的read方法，一次可以读取多个字符。

 

代码演示：

package com.oracle.Demo02;

import java.io.FileInputStream;
import java.io.IOException;
//用数组的方式读文件，并且只打印有效的字符
public class Demo05 {

    public static void main(String[] args) throws IOException {
        // TODO Auto-generated method stub
        FileInputStream fis=new FileInputStream("e:\\java\\output.txt");
        int len=0;
        byte[] bytes=new byte[3];
        while((len=fis.read(bytes))!=-1){    //len是有效长度
                System.out.print(new String(bytes,0,len)); //只打印有效长度的字符，并转为字符串
        }
        fis.close();

    }

}

 练习题：

 1.用普通方法复制文件：

package com.oracle.Demo02;

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

//复制文件的方法   copy
public class Copy {

    public static void main(String[] args) throws IOException {
        long time1=System.currentTimeMillis();
        //1.从数据源获取目标文件
        FileInputStream fis=new FileInputStream("e:\\study\\eclipse.zip");
        //2.确定目的地
        FileOutputStream fos=new FileOutputStream("e:\\java\\aaa\\eclipse.zip");
        //3.读取后写入
        int len=0;
        while((len=fis.read())!=-1){
            fos.write(len);
        }
        //释放资源
        fis.close();
        fos.close();
        long time2=System.currentTimeMillis();
        System.out.println((time2-time1)/1000+"秒");

    }

}

 2.用缓冲字节数组的方法复制文件：

package com.oracle.Demo02;

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

//快速复制文件   
public class Copy2 {

    public static void main(String[] args) throws IOException {
        long time1=System.currentTimeMillis();
        //1.获取数据源
        FileInputStream fis=new FileInputStream("e:\\java\\output.txt");
        //2.获取目的地
        FileOutputStream fos=new FileOutputStream("e:\\java\\aaa\\output.txt");
        //3.读取后写入
        byte[] bytes=new byte[1024];   //通过一个字节数组，一次性读，再一次性写
        int len=0;
        while((len=fis.read(bytes))!=-1){
            fos.write(bytes, 0, len);
        }
        fis.close();
        fos.close();
        long time2=System.currentTimeMillis();
        System.out.println((time2-time1)/1000);
    }

}