JAVA基础--IO输入输出(File使用)17

一、 File中的方法

　　1.  列举方法

/*
 * 获取指定目录以及子目录下的所有文件和文件夹
 */
public class ListFilesDemo {
    public static void main(String[] args) {
        
        File dir = new File("d:/test");
        getFiles(dir);
    }
    //获取指定目录下的文件或文件夹
    public static void getFiles(File dir) {
        
        //判断dir所表示的文件或文件夹是否存在
        if( !dir.exists() ){
            throw new RuntimeException("传递的文件或文件夹不存在");
        }
        //判断dir是否是目录
        if( !dir.isDirectory() ){
            throw new RuntimeException("传递的文件对象表示的不是一个有效的目录");
        }
        
        //获取指定目录 下的文件和文件夹
        File[] files = dir.listFiles();
        //判断当前指定的目录Java是否有权限访问，如果没有权限会得到null
        if( files != null ){
            //遍历文件数组
            for( File file : files ){
                //取出数组中的某个File对象
                if( file.isDirectory() ){
                    //判断 成立说明当前数组中保存的某个文件对象一定是目录（文件夹）
                    getFiles(file);
                }else{
                    //判断不成立，说明当前从数组中取出的文件对象一定是文件
                    System.out.println("正在删除的文件是："+file.getName()+",删除的结果是："+file.delete());
                }
                //程序如果执行到这里，说明一定将某个目录中的文件删除完成，紧接着删除这个目录
                System.out.println("被删除的文件夹是："+file.getName()+",删除的结果是："+file.delete());
            }
        }
    }
}

　　2. 递归技术

上述的遍历多级目录，使用到的方法在调用自己。这个技术被称为方法的递归调用。

递归：方法调用方法。

         直接递归：方法在自己的方法体中又调用自己。

         间接递归：A方法调用B方法，B方法调用C ...... 最后一个方法调用A方法。

    /*
 * 需求：计算1~5的和值，禁止使用循环。
 */
public class DiGui {
    public static void main(String[] args) {
        int num = 5;
        int sum = getSum( num );
        System.out.println(sum);
    }
    
    public static int getSum(int num) {
        
        if( num > 1 ){
            return num + getSum( num -1 );
        }
        return 1;
    }
}

         递归程序注意的细节：

                   1、递归调用一定要在程序添加判断，保证递归可以停止。否则就是无限递归调用。会导致栈内存溢出。

                   2、如果递归调用有判断，但是判断的语句还没有结束就可能导致栈溢出。因此递归的次数一定不要太多。

　　3.  文件队列

/*
 * 使用文件队列获取指定目录以及子目录下的文件和文件夹
 */
public class ListFilesDemo2 {
    public static void main(String[] args) {
        File dir = new File("d:/test");
        getFiles(dir);
    }
    //获取指定目录以及子目录下的文件和文件夹
    public static void getFiles(File dir) {
        //定义集合容器
        LinkedList<File> list = new LinkedList<File>();
        //将传递进来的文件夹先保存到集合容器中
        list.addLast(dir);
        //遍历集合容器
        while( list.size() > 0 ){
            //只要循环成立，说明集合容器中就会有文件夹存在
            File file = list.removeFirst();
            //获取从容器中取出的这个文件夹下的所有文件和文件夹
            File[] files = file.listFiles();
            //判断当前的目录Java是否有权限.判断files是否为null
            if( files != null ){
                for( File f : files ){
                    //遍历当前从容器中取出的这个文件夹下的每个文件或文件夹对象
                    if( f.isDirectory() ){
                        //判断成立，说明当前得到的子文件对象一定是文件夹，添加到集合中
                        list.addLast(f);
                    }else{
                        ///当前的f一定是文件
                        System.out.println(f);
                    }
                }
            }
        }
    }
}

 二、 文件过滤器

　　1. 文件过滤器介绍

我们在使用list或者listFiles方法列出某个目录下的文件或者文件夹的时候，是将所有的全部列出，有时我们并不需要某个目录下的所有文件或文件夹，而是希望列出符合条件的文件或文件夹。

可以在使用list或listFiles方法时，给方法传递一个符合用户需求的过滤对象，这个对象可以帮助list和listFiles方法在列出目录下文件或文件夹的时候，根据传递的过滤对象将符合条件的文件和文件夹列出，不符合的就会被过滤掉。

在Java中提供了2个负责过滤的过滤器：

         FilenameFilter：文件名过滤器：是通过文件或文件夹的名称过滤

         FileFilter：文件过滤器：通过文件或文件夹对象过滤器

　　2.  FilenameFilter接口

 

/*
 * 自己定义文件名过滤器
 */
public class MyFilenameFilter implements FilenameFilter{
    //定义成员变量，记录传递的过滤的名称
    private String suffix;
    //定义构造方法，让使用者在创建过滤器对象的时候指定需要过滤的条件
    public MyFilenameFilter(String suffix){
        this.suffix = suffix;
    }
    /*
     *  解释FilenameFilter中的accept方法上的两个参数
     *      File dir : 是当前需要列举的那个目录
     *      String name：是当前指定的目录下的文件或文件夹的名称
     */
    public boolean accept(File dir, String name) {
        //System.out.println(dir + "....." + name);
        return name.endsWith(this.suffix);
    }
    
}

/*
 * 演示FilenameFilter过滤器的使用
 */
public class FilenameFilterDemo {
    public static void main(String[] args) {
        
        //创建文件对象
        File dir = new File("d:/test/day07_code");
        /*
         * 当我们在程序中使用list方法的时候，list方法会先列出当前目录下的所有文件和文件夹
         * 然后将这些文件和文件夹传递给指定的过滤器对象，
         * 如果过滤器中的accept方法返回的true，就认为当前这个文件或文件夹是需要保留的
         * 如果过滤器中的accept方法返回的false，就认为当前这个文件或文件夹是不需要的
         */
        String[] list = dir.list(new MyFilenameFilter(".java"));
        
        //遍历
        for (String s : list) {
            System.out.println(s);
        }
    }
}

　　3. FileFilter接口

/*
 * 自定义FileFilter过滤器对象
 */
public class MyFileFilter implements FileFilter{
    private String suffix;
    public MyFileFilter(String suffix){
        this.suffix = suffix;
    }
    /*
     * 解释FileFilter中的accept方法上接收的参数
     *     File pathname : 表示的当前目录下的那个文件或文件夹对象
     */
    public boolean accept(File pathname) {
        //System.out.println(pathname.isDirectory() +".."+pathname.getName()+"..."+pathname.isFile());
        //需要将扩展名为 .mp3的文件保留下来
        return pathname.isFile() && pathname.getName().endsWith(this.suffix);
    }

}

/*
 * 演示FileFilter的使用
 */
public class FileFilterDemo {
    public static void main(String[] args) {
        
        //创建File对象
        File dir = new File("d:/test");
        
        /*
         * 获取指定目录下的文件或文件夹
         * 
         * 当我们调用File类中的listFiles方法，并传递以了一个FileFilter过滤器对象
         * listFiles方法也是先将指定目录下的所有文件和文件夹获取到，
         * 然后将这些文件或文件夹对象逐一传递给FileFilter中的accept方法。
         * 
         */
        File[] files = dir.listFiles(new MyFileFilter(".java"));
        
        for ( File file : files){
            System.out.println(file);
        }
    }
}

　　　4. 过滤器练习

需求：获取指定目录以及子目录下的文件（扩展名为.java）.

/*
 * 需求：获取指定目录以及子目录下的文件（扩展名为.java）
 * 
 */
public class FilterTest {
    public static void main(String[] args) {
        
        File dir = new File("d:/test");
        getFiles(dir);
    }

    public static void getFiles(File dir) {
        
        //列出指定目录下的文件和文件夹
        File[] files = dir.listFiles( new FileFilter(){

            /*
             * 书写过滤的条件：
             *     如果是只过滤当前的目录，那么在书写过滤器条件的时候，
             *     只需要判断是否是文件和文件的扩展名。
             * 
             *  如果需要多级目录文件获取，这时在书写过滤器的时候，
             *  判断的条件中需要保留文件夹，和文件（扩展名必须是符合条件）
             */
            public boolean accept(File pathname) {
                return (pathname.isDirectory())  || 
                        (pathname.isFile() && pathname.getName().endsWith(".txt"));
            }
            
        } );
        //判断
        if( files != null ){
            //遍历
            for (File file : files) {
                if( file.isDirectory() ){
                    getFiles(file);
                }else{
                    System.out.println(file);
                }
            }
        }
    }
}

 三、   IO流技术

　　1. 流的分类

File类：它主要是操作文件和文件夹，并不能读写文件中的数据。

我们如果需要操作保存在文件中的数据，这时只能使用Java中提供的IO流对象。

 　　

IO：Input   Output。

IO流：它是使用Java中提供的众多的对象，和文件中的数据进行交互。

IO流如果按照操作数据的方向：

         输入流：Input，读取数据。

         输出流：Output，写出数据。

IO流如果按照操作的数据类型：

         字节流：它全部是以字节形式操作（读写）的数据

         字符流：全部是以字符的形式操作（读写）数据

上课以数据类型分类：现讲字节流，再讲字符流。

         字节流和字符流它们对文件中的数据操作规律是一致的。主要会一种，其他的都可以照着模版代码进行抄写。

　　2. 字节流介绍

任何数据在电子设备中存储的方式都是二进制形式（字节）。我们就可以直接以字节方式读取文件中的数据，或者以字节的方式给文件中写数据。

字节流：

         字节输入流：它是负责以字节的方式从文件中读取数据。在程序中我们会获取到读取的字节数据。

         字节输出流：它是负责以字节的方式将程序（内存）中的数据写到文件中。

　　3.  字节输出流

OutputStream：它是所有字节输出流的超类（基类、根类）。它中肯定定义了应该如何将字节写到底层文件中的最基本（共性）的方法。

使用Java程序操作Java以外的其他数据（数据库，硬盘，网络，其他语言开发的程序），首先需要让我们的Java程序和其他的资源平台获取连接（关联），在这个连接中进行数据的交互。交互结束之后一定要记住将彼此之间的连接断开。因此我们使用Java中的IO流技术操作其他设备上的数据，这时操作完一定要记得调用close方法。

write(byte[] b) 将指定的字节数组中的全部数据写到底层指定的设备中。

write(byte[] b , int off , int len) 将指定的字节数组中的数据从off位置开始，共计写出len个。

write(int b) 将int类型数据中的最低位一个字节写出。

　　4.  文件字节输出流

FileOutputStream：它是专门负责将字节数据写到文件中。

        

/*
 * 演示字节输出流
 *   使用输出流，往出写数据的时候，如果指定的文件不存在，
 *   这时输出流会自动的在指定的目录下创建这个文件，并将数据写到文件中。
 *   
 *   使用输出流的时候，文件不存在会创建，如果文件存在，会覆盖。原来文件中的数据全部丢失。
 */
public class FileOutputStreamDemo {
    public static void main(String[] args)throws IOException {
        method3();
    }
    // write(byte b)
    public static void method3() throws IOException {
        //创建负责写字节数据的流对象
        FileOutputStream fos = new FileOutputStream("d:/aa.txt");
        /*
         * OutputSteam它写出的是字节数据，字节数据的范围是-128到127之间。
         *  其中提供的write(int b) 它本质只能写一个字节，但是接收的int类型的数据
         *   int类型的数据在内存中共计占用4个字节，write方法它其实只能将4个字节中
         *   最低一位上的那个字节数据写到文件中。
         *   
         *   97 ： 0000 0000 0000 0000 0000 0000 0110 0001
         *   353:0000 0000 0000 0000 0000 0001 0110 0001
         *       
         */
        fos.write(97);
        fos.write(353);
        
        fos.close();
    }
    //write(byte[] b , int off , int len)
    public static void method2() throws IOException {
        
        //创建负责写字节数据的流对象
        FileOutputStream fos = new FileOutputStream("d:/aa.txt");
        
        //创建字节数组
        byte[] b = {65,66,67,68,69};
        //调用写的方法写数据
        fos.write(b , 1 , 2);
        
        //关闭流对象
        fos.close();
        
    }
    //演示 write(byte[] b);
    public static void method() throws IOException {
        
        //创建负责写字节数据的流对象
        FileOutputStream fos = new FileOutputStream("d:/aa.txt");
        
        //创建字节数组
        byte[] b = {65,66,67,68,69};
        //调用写的方法写数据
        fos.write(b);
        
        //关闭流对象
        fos.close();
    }
}

　　5.  追加数据和换行

/*
     * 文件写字符串数据，并换行
     */
    public static void method5() throws IOException {

        FileOutputStream fos = new FileOutputStream("d:/aa.txt",true);
        
        //获取操作系统支持的换行符
        String line_separator = System.getProperty("line.separator");// 

        String s = "Java基础正在学习IO技术"+line_separator;
        
        fos.write(s.getBytes());
        
        fos.close();
    }
    /*
     * 在文件的末尾追加数据
     * FileOutputStream(String name, boolean append)
     *     如果创建FileOutputStream的时候，在构造方法中指定的boolean值为true
     *     这时需要关联的文件如果不存在，它会创建，
     *     如果已经存在，并且其中有数据，会在原来文件的末尾继续追加数据
     */
    public static void method4() throws IOException {
        
        FileOutputStream fos = new FileOutputStream("d:/aa.txt",true);
        
        fos.write(101);
        fos.write(102);
        fos.write(103);
        fos.write(104);
        
        //关流
        fos.close();
    }

　　6.  输出流练习

/*
 * 需求：将指定目录和子目录下的指定扩展名(.java)的文件所在路径写到一个文件中，形成一个文件清单。
 * 分析：
 *         获取符合条件的文件，然后将其路径得到。再使用输出流写到文件中即可
 */
public class FileOutputStreamTest {
    public static void main(String[] args) throws IOException {
        
        File dir = new File("d:/test");
        FileOutputStream fos = new FileOutputStream("d:/文件清单.txt");
        getListFile(dir,fos);
        fos.close();
    }
    //获取指定目录下的文件清单
    public static void getListFile(File dir ,FileOutputStream fos) throws IOException {
        
        File[] files = dir.listFiles( new FileFilter(){
            public boolean accept(File pathname) {
                return (pathname.isDirectory()) || 
                        (pathname.isFile() && pathname.getName().endsWith(".avi"));
            }
        } );
        //判断
        if( files != null ){
            for (File file : files) {
                if( file.isDirectory() ){
                    getListFile(file,fos);
                }else{
                    //一定是文件
                    System.out.println(file);
                    String path = file.getAbsolutePath() + System.getProperty("line.separator");
                    fos.write(path.getBytes());
                }
            }
        }
    }
}

　　7.  字节输入流

InputStream：它是字节输入流的超类（基类、根类），它中定义的是字节输入流如何读取字节数据的方法。

所有输入流：它们都有read方法，负责从底层读取数据的。如果读取到文件末尾统一返回的都是-1。

int read() 这个方法调用一次，就会从底层文件中获取一个字节数据，并返回这个字节数据。

int read(byte[] b) 调用一次，会从底层文件中读取若干个字节数据，并将这些字节数据存储在byte数组中，每次都是从数组的零位置开始往后存储。返回的int值表示的是给byte数组中真正存储的字节个数。

int read(byte[]b , int off , int len) 调用一次，从底层读取若干字节数据，将数据存储在b数组中，但是是从off位置开始存储，共计只能存储len个。返回的int值表示是的是给数组中存储的字节个数。

 　　8.   文件字节输入流

FileInputStream：它是专门负责从文件中读取字节数据。

/*
 * 演示字节输入流
 */
public class FileInputStreamDemo {

    public static void main(String[] args) throws IOException {
        method3();
    }
    //一次读取多个字节数据
    public static void method3() throws IOException {
        //创建输入流对象和需要被读取的文件进行关联
        FileInputStream fis = new FileInputStream("d:/aa.txt");
        /*
         * 定义数组充当临时的容器，存储每次从文件中读取到的若干个字节数据。
         * 一般定义的数组如果是存储读取到的数据，这个数组一般会是1024的整数倍
         */
        byte[] buf = new byte[1024];
        //定义变量，记录每次给数组中存储的字节个数
        int len = 0;
        //使用循环读取数据
        while( ( len = fis.read( buf ) ) != -1 ){
            /*
            for( int i = 0 ; i < len ; i++ ){
                System.out.print(buf[i]+" ");
            }
            */
            System.out.println(new String( buf , 0 , len ));
        }
        
        //关流
        fis.close();
    }
    //使用循环读取文件中的数据 ，一次读取一个
    public static void method2() throws IOException {
        
        //创建输入流对象和需要被读取的文件进行关联
        FileInputStream fis = new FileInputStream("d:/aa.txt");
        //定义变量记录每次读取到的字节数据
        int ch = 0;
        //使用while循环读取数据
        while( ( ch = fis.read( ) ) != -1 ){
            System.out.println(ch);
        }
        //关流
        fis.close();
    }
    //演示 read()
    public static void method() throws IOException {
        
        //创建输入流对象和需要被读取的文件进行关联
        FileInputStream fis = new FileInputStream("d:/aa.txt");
        
        //读取字节数据
        System.out.println(fis.read());
        System.out.println(fis.read());
        System.out.println(fis.read());
        System.out.println(fis.read());
        
        //关流
        fis.close();
    }
}

 9.  复制文件练习

/*
 * 需求：复制指定的文件到指定的目录下
 * 
 */
public class CopyFileTests {
    public static void main(String[] args) throws IOException{
        copyFile2();
    }
    //使用数组复制
    public static void copyFile2() throws IOException{

        //定义输入流读取文件
        FileInputStream fis = new FileInputStream("d:/1.avi");
        //定义输出流写文件
        FileOutputStream fos = new FileOutputStream("c:/1.avi");
        
        //在开始复制文件之前获取系统的时间
        long start = System.currentTimeMillis();
        
        //保存每次读取的字节个数
        int len = 0;
        /*
         * 定义字节数组保存数据
         * 8二进制 = 1字节
         * 8bit = 1Byte
         * 1024B = 1KB
         * 1024KB = 1MB
         * 1024MB = 1GB
         * 1024GB = 1TB
         * 1024TB = 1PB
         */
        byte[] buf = new byte[8192];
        //使用循环读取数据
        while( ( len = fis.read( buf ) ) != -1 ){
            //使用输出流写到文件中
            fos.write( buf, 0 , len );
        }
        
        //循环结束，数据已经复制完成
        long end = System.currentTimeMillis();
        System.out.println("复制文件所用时间："+(end - start));
        
        //关流
        fis.close();
        fos.close();        
    }
    //演示 一次读取一个字节的方式复制
    public static void copyFile() throws IOException{
        
        //定义输入流读取文件
        FileInputStream fis = new FileInputStream("d:/1.mp3");
        //定义输出流写文件
        FileOutputStream fos = new FileOutputStream("c:/1.mp3");
        
        //在开始复制文件之前获取系统的时间
        long start = System.currentTimeMillis();
        
        //保存每次读取的字节数据
        int ch = 0;
        //使用循环读取数据
        while( ( ch = fis.read() ) != -1 ){
            //使用输出流写到文件中
            fos.write(ch);
        }
        
        //循环结束，数据已经复制完成
        long end = System.currentTimeMillis();
        System.out.println("复制文件所用时间："+(end - start));
        
        //关流
        fis.close();
        fos.close();
    }
}