day20(下)_IO流5(递归穷举与删除,Properties,PrintStream,PrintWriter,SequenceInputStream)

1.对目录和文件递归穷举

/*
列出指定目录下的文件或者文件夹,包含子目录中的内容
也就是列出目录下所有的内容
例如:new File(d:\\);
 在d盘下还有一个abc目录而abc下还有文件和目录,而用list()方法只能获取到
 d盘下的文件和目录
*/
package filedemo;
import java.util.Arrays;
import java.io.File;

class FileFilterDemo2{
    /*
     采用了递归(重复调用使用自身功能),即首先遍历该目录下所有文件/目录
     一旦遍历到目录,在调用自身进行遍历.
   */
     public static String level(int n){
      StringBuilder sb=new StringBuilder();
      sb.append("|-");
      while((n--)!=0)
        sb.insert(0," ");//不断的向"|-"前插入空格
      return sb.toString();
     }
     public static void getFiles(File f,int level){
    
      System.out.println(level(level)+f);
      level++;//递归调用为下一级目录
      File[] dirFiles=f.listFiles();//获取到该目录下所有的文件和目录,其中File对象都采用File(File parent,String child)构造
      if(dirFiles==null||dirFiles.length==0)//说明传入的pathName不表示目录或目录为空,那么不需要遍历
          return;
      else
         for(File file : dirFiles){
             if(file.isDirectory())//当file中的对象的child依然是目录接着遍历
                getFiles(file,level);
             else
                System.out.println(level(level)+file);
            }
       
      
}
     
     public static void main(String[] args){
     
        getFiles(new File("f:\\a"),0);
     }
}

关于递归注意事项:

/*
递归注意:
  一定要有出口(也就是限定条件),不然相当于死循环
  递归次数过多,会导致OutOfMemoryError(内存溢出)
*/
class RecursionTest{
  /*十进制->二进制*/
  public static void toBin(int num){
 
   if(num>0)
   {
      toBin(num/2);
      System.out.print(num%2);
   }
  }
  
  /*求前n项和*/
  public static int getSum(int n){
    if(n==1)
     return 1;
    else
      return n+getSum(n-1);
 
  }
  public static void main(String[] args){
     toBin(10);
     System.out.println("\n"+getSum(80000));//不断在内存中开辟空间->OutOfMemoryError(内存溢出) 
  }
}

2.递归删除指定目录:

/*
 删除一个带内容的目录
 删除原理:
    在windows中,删除目录从目录里面往外删除
 从里往外删->递归
*/
package filedemo;
import java.io.File;
class RemoveDir{
    public static void removeDir(File f){
     File[] allFile=f.listFiles();
     if(allFile==null||allFile.length==0)//空文件夹/文件 直接删除
       System.out.println(f.delete());
     
      else{//遍历到最内层->删除,删除完内层->逐步往外删
        for(File files : allFile){
           if(files.isFile())
              System.out.println(files.delete());
           else
              removeDir(files);
        }
         System.out.println(f.delete());//当for执行完,说明该目录下文件已经全部删除,需要删除该目录 
      }
    }
    public static void main(String[] args){
       removeDir(new File("h:\\a"));
    }
}

对于运行结果,(依然是上面遍历的测试目录)会删除9次,会有9个boolean值并且必须都为true,否则可能为同一个文件/目录多次删除

3.File练习:

/*
 获取到指定目录中所有java文件的路径,并输出到一个文件中.
思想:
①对目录进行递归搜索
②对于文件只要以.java结尾文件
③把.java文件路径存入ArrayList集合中.

*/
package filedemo;
import java.io.File;
import java.io.IOException;
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.util.ArrayList;
import java.util.List;
class JavaFilesList{
  
  public static void getJavaFiles(File dir,List<File> list){
      File[] files=dir.listFiles();
      
      if(files!=null && files.length!=0)
         for(File f : files)
            if(f.isDirectory())
                getJavaFiles(f,list);
            else
              if(f.getName().endsWith(".java"))
                 list.add(f);
                
  }
  
  public static void writeFile(List<File> list,String javaListFile){
    BufferedWriter bfw=null;
    File[] javaFiles=list.toArray(new File[list.size()]);//集合转数组
    try{
    bfw=new BufferedWriter(new FileWriter(javaListFile));
    for(File f : javaFiles){
      bfw.write(f.getAbsolutePath());//获取到绝对路径写入,list存入File对象不一定封装的是绝对路径,可能是相对路径
      bfw.newLine();
      bfw.flush();
    }
    bfw.write("一共"+list.size()+"个java文件");
   }
   catch(IOException e){
     throw new RuntimeException("写文件异常");
   }
   finally{
    try{
     if(bfw!=null)
         bfw.close();
    }
    catch(IOException e){
       throw new RuntimeException("关闭流异常");
    }
    try{
    Runtime.getRuntime().exec("notepad.exe "+javaListFile);//写完后,自动用记事本打开查看内容
    }
    catch(IOException e){
      e.printStackTrace();
    }
   }
  }
  public static void main(String[] args){    
    
    List<File> list=new ArrayList<File>();
    getJavaFiles(new File("g:\\JavaCode"),list);
    System.out.println(list.size());
    
    writeFile(list,"f:\\JavaFiles.txt");//写入文件
    }
}

将制定文件夹从源路径复制到目的路径下:

/*
采用递归方法遍历文件夹中的内容
例如:C:\s\abc->d:\ 将abc文件夹及文件夹的所有文件/文件夹拷贝到d盘下
              AbsolutePath
abc         
   1.txt      ->d:\abc
   def        ->d:\abc\ def
     2.txt    ->d:\abc\def\ 2.txt
     ghk      ->d:\abc\def\ ghk
       3.txt  ->d:\abc\def\ghk\ 3.txt
   mnl        ->d:\abc\mnl
*/
/*
递归过程:
 1.                      
  src: c:\s\abc 
  dest: d:\
  
  dest<-d:\abc 创建abc
  
  copyFile(c:\s\abc\1.txt,d:\abc\1.txt)
  copyDir(c:\s\abc\def,d:\abc)
2.
  src:c:\s\abc\def
  dest:d:\abc
  
  dest<-d:\abc\def 创建def

  copyFile(c:\s\abc\def\2.txt,d:\abc\def\2.txt)
  copyDir(c:\s\abc\def\ghk,d:\abc\def)
3....
*/
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
class CopyDirectory{
 
 public static void copyFile(File src,File dest)throws IOException{
  FileInputStream fis=new FileInputStream(src);
  FileOutputStream fos=new FileOutputStream(dest);
  byte[] byteArr=new byte[1024*1024];
  int bytes=0;
  while((bytes=fis.read(byteArr))!=-1)
      fos.write(byteArr,0,bytes);
  fis.close();
  fos.close();
 }
 public static void copyDir(File src,File dest)throws IOException{
  File[] files=src.listFiles();
  dest=new File(dest.getPath()+"\\"+src.getName());//例如:第一次 创建 d:+\+abc
  dest.mkdir();                               //     第二次 创建 d:\abc +\+ def
  
  for(File f : files)
    if(f.isFile())
      copyFile(new File(f.getAbsolutePath()),new File(dest.getPath()+"\\"+f.getName()));//例如:当遍历到1.txt时 
                                                                                      //C:\s\abc\1.txt,d:\abc\1.txt
    else//对于文件夹操作
      copyDir(new File(f.getAbsolutePath()),dest);//例如:当遍历到def时
                                                 //C:\s\abc\def,d:\abc
    
 } 
 public static void main(String[] args)throws IOException{
  
  copyDir(new File("C:\\s\\abc"),new File("d:\\"));//abc文件夹以及文件夹中的内容拷贝到D盘下
                                             
  
  System.out.println(new File("d:\\def\\"+"\\"+"\\"+"abc").getPath());
  System.out.println(new File("d:\\def\\"+"abc"));
/*

以上两者结果相同(d:\def\abc),也就是说文件系统中会去除多余的\,但是d:\\与d:结果不同,一个为d:\\,一个为d:

*/
 }

}

4.Properties类方法:

/*
在System类中的获取系统属性用到Properties

Properties 类表示了一个持久的属性集。
Properties 可保存在流中或从流中加载。
属性列表中每个键及其对应值都是一个字符串。 

该集合是和IO技术相结合的集合容器
该对象特点:可以用于键值对形式的配置文件(.ini)
在加载数据时,需要数据有固定格式:Key=Value
*/
package propertydemo;
import java.util.Properties;
import java.util.Set;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.BufferedReader;
import java.io.IOException;
class PropertiesDemo{
    
    /*
    自定义方法将文件中的数据存储到Properties集合中
    该文件中的数据是以键值对形式存在
    例如:info.txt: 
    zhangsan=18
    lisi=25
    ...
    */
    public static void storeInProperties()throws IOException{
     BufferedReader bfr=new BufferedReader(new FileReader("info.txt"));
     Properties pro=new Properties();
     String line=null;
     while((line=bfr.readLine())!=null)
      
         if(!line.startsWith("#")){//注释信息不再加入集合
         String[] keyValue=line.split("=");//以"="分割
         pro.setProperty(keyValue[0],keyValue[1]); 
      }
     
     System.out.println(pro);
     bfr.close();
    }
    
    
    /*
    利用Properties中的load方法完成
     void load(InputStream inStream) 
          从输入流中读取属性列表（键和元素对）。 
     void load(Reader reader) 
          按简单的面向行的格式从输入字符流中读取属性列表（键和元素对）。
          
    */
    public static void storeInProperties_2()throws IOException{
      FileReader fr=new FileReader("info.txt");
      Properties pro=new Properties();
      pro.load(fr);
      System.out.println(pro);
      pro.list(System.out);// void list(PrintStream out)
                            //将属性列表输出到指定的输出流。
     
     /*
     此时如果改变了键值对信息,但是改变后的信息
     依然在内存中,如果想把改变反映到文件中,需要用到
     store方法
     */
     pro.setProperty("zhangsan","30");
     System.out.println(pro);
     FileWriter fw=new FileWriter("info.txt");
     pro.store(fw,"heihei");//heihei为注释信息
                      //在文件中为#heihei
     fr.close();
     fw.close();
    }
    
    
    
    /*Properties存储和获取方法*/
    public static void propertiesMethodDemo(){
        Properties prop=new Properties();
        prop.setProperty("zhang","15");//底层在使用HashTable<Object,Object>的put方法
        prop.put("li","30");
        System.out.println(prop);
        
        Set<String> names=prop.stringPropertyNames();//返回Key的set集合
        for(String n : names)
          System.out.println(n+"="+prop.getProperty(n));
    
    }
    
    public static void main(String[] args)throws IOException{
      propertiesMethodDemo();
      System.out.println();
      
      storeInProperties();
      System.out.println();
      storeInProperties_2();

    } 
}

5.Properties的load与store练习:

/*
需求:用于记录应用程序运行次数.如果使用次数已到,那么
     给出注册提示.
分析:
  很容易想到的是:计数器
  可是该计数器
用程序的退出,该计数器也在内存中消失了
下一次在启动该程序,又重新开始从0计数.
这样不是所需要的

程序即使结束,该计数器的值也存在
下次程序启动会先加载该计数器的值
并+1后重新存储起来

所以需要建立一个配置文件.用于记录软件使用次数

该配置文件使用键值对的形式
这样便于阅读数据,并操作数据

键值对数据是map集合.
数据是以文件形式存储,使用io技术
那么map+io-->properties

配置文件可以实现应用程序数据共享
*/
package propertiestest;
import java.util.Properties;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.File;
class PropertiesTest{
 /*每次程序运行获取使用次数(counts),并在获取完之后,++counts存入到配置文件中*/
 public static void checkCounts()throws IOException{ 
  File f=new File("set.ini");
  Properties pro=new Properties();
 if(!f.exists())//文件第一次不存在需要创建
   f.createNewFile();
 FileReader fr=new FileReader(f);
 pro.load(fr);
 
 int count=0;
String value=pro.getProperty("counts");
if(value!=null)//新建文件中没有counts,此时不再获取,只写
    count=Integer.parseInt(pro.getProperty("counts"));

if(count>=3){//该软件只能够使用三次
        System.out.println("免费次数已用完");
        return;//>=3不再写入直接返回
 }

FileWriter fw=new FileWriter(f);
pro.setProperty("counts",(++count)+"");
pro.store(fw,"number of use"); 
fr.close();
fw.close();
/*
 关于pro.store():
    所有写入各个项后,刷新输出流(内部在把属性集写入输出流后调用了flush)
    此方法返回后，输出流仍保持打开状态。 
    但没有关闭写入流
*/

}

public static void main(String[] args)throws IOException{
   checkCounts();
 }
}
/*
注意:①配置文件不存在,需要创建
     ②需要写入键值对
     
*/

6.PrintStream与PrintWriter

/*
打印流:
 该流提供了打印方法,可以将各种数据类型的数据都原样打印
字节打印流:PrintStream
 PrintStream(File file) 
  file-
    同下
 PrintStream(String fileName) 
 fileName -
 要用作此打印流目标的文件名称。
 如果存在该文件，则将其大小截取为零；
 否则，创建一个新文件。将输出写入文件中，并对其进行缓冲处理。 

 PrintStream(OutputStream out) 

字符打印流:PrintWriter
PrintWriter(File file) 
PrintWriter(OutputStream out)

根据现有的 OutputStream 创建不带自动行刷新的新 PrintWriter。此便捷构造方法创建必要的中间 OutputStreamWriter，后者使用默认字符编码将字符转换为字节。

  
PrintWriter(String fileName) 
PrintWriter(Writer out)//比PrintStream多了一个可以接收字符输出流的构造函数
*/
package printdemo;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;
import java.io.PrintStream;
import java.io.PrintWriter;
import java.io.FileWriter;
class PrintStreamDemo{
    public static void main(String[] args)throws IOException{
     BufferedReader bufr =new BufferedReader(new InputStreamReader(System.in));
     //PrintWriter out=new PrintWriter(System.out);//PrintWriter通用性比较强,在写入流后,需要刷新

     /*

          System.out在内部会被封装为new BufferedWriter(new OutputStreamWriter(System.out))

     */
     //PrintWriter out=new PrintWriter(System.out,true);//autoFlush-boolean 变量；如果为 true，则 println、printf 或 format 方法将刷新输出缓冲区,下面由于用到println所以可以不用out.flush
       PrintWriter out=new PrintWriter(new FileWriter("PrintWriter.txt"),true);//true含义同上,这样写可以把new FileWriter中的数据刷新到文本中,而不用在out.flush  
                       
     String line=null;
     while((line=bufr.readLine())!=null){
         out.println(line);//将值打印初始化的流对象中
         //out.flush();//刷新的是初始化时的流对象
     }
     bufr.close();
     out.close();
    }
}

7.SequenceInputStream:

/*
SequenceInputStream(顺序输入流):
    表示其他输入流的逻辑串联。
    它从输入流的有序集合开始，
    并从第一个输入流开始读取，
    直到到达文件末尾，
    接着从第二个输入流读取，
    依次类推，直到到达包含的最后一个输入流的文件末尾为止。 
该类的由来:
  例如:
  已知:四个文件:src1.txt,src2.txt,src3.txt,dest.txt;
  需求:把前三个文件中数据写入到dest.txt中
  分析:
   src1.txt--->FileReader("src.txt")--->FileWriter("dest.txt",true)-->dest.txt
   src2.txt,src3.txt同理    
   每个源和目的需要单独的IO流对象操作,非常麻烦
 SequenceInputStream作用:对多个源依次操作,更加方便.


*/
package sequenceinputstream;
import java.io.*;
import java.util.*;
class SequenceDemo{
    public static void main(String[] args)throws IOException{
    /*
    SequenceInputStream(Enumeration<? extends InputStream> e) 
    该构造函数形参为枚举->集合Vector<E>的elements返回Enumeration<E>
    */    
     Vector<FileInputStream> vector=new Vector<FileInputStream>();
     vector.add(new FileInputStream("f:\\src1.txt"));
     vector.add(new FileInputStream("f:\\src2.txt"));
     vector.add(new FileInputStream("f:\\src3.txt"));
     Enumeration<FileInputStream> en=vector.elements();
     SequenceInputStream sis=new SequenceInputStream(en);
     BufferedOutputStream bufos=new BufferedOutputStream(new FileOutputStream("f:\\dest.txt"));
     //FileOutputStream fis=new FileOutputStream("f:\\dest.txt");
     int aByte=0;
     //byte[] b=new byte[1024];
    
     while((aByte=sis.read())!=-1){
        bufos.write(aByte);
        bufos.flush();
     }
     /*
     int bytes;
     while((bytes=sis.read(b))!=-1)
        fis.write(b,0,bytes); 
      }
      */
      bufos.close();
      sis.close();

    
   }

}

文件切割和合并综合练习:

/*
切割文件:其实就是一个源(该文件)对应多个目的(多个碎片文件)
切割
    ①需要一个输入流对象关联该文件
    ②为了控制每次读取大小,自定义一个缓冲(数组)
    ③循环读取,每次读取将读取的数据,通过输出流写入一个文件中,直至源文件末尾(-1)
合并
    多个源对应一个目的,这里可以采用SequenceInputStream
*/

import java.io.FileInputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.io.SequenceInputStream;
import java.util.Enumeration;
import java.util.Iterator;
class SplitFileTest{
   /*当文件不太大时,指定的缓冲区可以为分割的文件大小*/
   public static void splitFile_1(String file)throws IOException{
    /*以切割图片为例*/
   FileInputStream fis=new FileInputStream(file);
   byte[] b=new byte[1024*1024];//每次最多分割1MB
   FileOutputStream fos=null;
   int bytes=0,count=1;
   while((bytes=fis.read(b))!=-1){
      fos=new FileOutputStream("f:\\part"+(count++)+".part");//每次新建一个流对象关联一个新的文件  
      fos.write(b,0,bytes); 
      fos.close();//每次循环关闭上次的流对象
   }
   fis.close();
 }
 /*

当文件特别大(例如2GB),而需要按400MB分割,不建议定义400MB缓冲区,定义小点缓冲区40MB,使切割文件满足制定大小*/
  public static File[] splitFile_2(File f)throws IOException{
   FileInputStream fis=new FileInputStream(f);
   byte[] byteArr=new byte[1024*1024];
   ArrayList<File> arrList=new ArrayList<File>();
   int bytes=0;
  int count=0;
  File wf=null;
  FileOutputStream fos=null;
  while((bytes=fis.read(byteArr))!=-1){
     if(wf==null||wf.length()==2*1024*1024){
        if(fos!=null)
            fos.close();//关闭与上一个文件相关联的写入流对象
         wf=new File("C:\\Users\\ZhangHongQ\\Desktop\\java复习\\"+(++count)+".part");
         arrList.add(wf);
         fos=new FileOutputStream(wf);
     }
     fos.write(byteArr,0,bytes);
  }
  fis.close();
  return arrList.toArray(new File[arrList.size()]);
 }
  
  /*对以上分割的文件进行合并*/
  public static void mergeFile(File[] file)throws IOException{
    ArrayList<FileInputStream>al=new ArrayList<FileInputStream>();
    for(File f : file)
      al.add(new FileInputStream(f));
    final Iterator<FileInputStream>it=al.iterator();
    SequenceInputStream sis=new SequenceInputStream(new Enumeration<FileInputStream>(){
     public boolean hasMoreElements(){
       return  it.hasNext();
     }
     public FileInputStream nextElement(){
     
       return it.next();
     }
    });
    FileOutputStream fos=new FileOutputStream(new File("C:\\Users\\ZhangHongQ\\Desktop\\java复习\\Bandari.mp3"));
    int aByte=0;
    while((aByte=sis.read())!=-1)
      fos.write(aByte);
    sis.close();
    fos.close();
  }
  public static void main(String[] args)throws IOException{
    
    File[] file=splitFile_2(new File("F:\\SONG\\Bandari - 爱尔兰风笛.mp3"));//例如:8.93MB的MP3文件
    System.out.println(Arrays.toString(file));//2MB 2MB 2MB 2MB 934KB
    
    mergeFile(file);
  }
}