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");// \r\n
         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();
     }
 }