Day19 io01作业

1.有这样的一个words数组，数组中每个字符串的格式为“词性:单词”
String[] words = {"verb:eat","verb:drink","verb:sleep","verb:play","noun:rice","noun:meat","noun:hand","noun:hair"};
根据单词性质动词verb全部存入verb.txt文件中
根据单词性质名词noun全部存入noun.txt文件中

2. 递归查找指定目录中(包括子目录中)，所有的.java文件，
并且，把所有这些找到的java文件，复制到一个指定的目录下
目录结构同昨天，递归删除那道题的firstLevel

参考答案：

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;


public class Demo{

    public static void main(String[] args) {
        String[] words = { "verb:eat", "verb:drink", "verb:sleep", "verb:play", "noun:rice", "noun:meat", "noun:hand",
                "noun:hair" };
        String verb = "verb";
        String noun = "noun";
        // 将所有的动词和名词分别拼接到verbs和nouns两个字符串中
        // 让后直接将包含所有 动词的字符串verbs 和 包含所有 名词的字符串nouns，分别写入verb.txt和noun.txt中
        String verbs = "";
        String nouns = "";
        for (String word : words) {
            if (word.contains(verb)) {
                verbs += word;
                verbs += "
";
            }
            if (word.contains(noun)) {
                nouns += word;
                nouns += "
";
            }
        }
        File verbFile = new File("D:\WorkSpace\verb.txt");
        File nounFile = new File("D:\WorkSpace\noun.txt");
        FileOutputStream verbFileOutputStream = null;
        FileOutputStream nounFileOutputStream = null;
        try {
            // 初始化输出流
            verbFileOutputStream = new FileOutputStream(verbFile);
            nounFileOutputStream = new FileOutputStream(nounFile);
            // 获得字节数组
            byte[] verbBytes = verbs.getBytes();
            byte[] nounBytes = nouns.getBytes();
            // 输出
            verbFileOutputStream.write(verbBytes);
            nounFileOutputStream.write(nounBytes);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 资源释放
            try {
                if (verbFileOutputStream != null) {
                    verbFileOutputStream.close();
                }
                if (nounFileOutputStream != null) {
                    nounFileOutputStream.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }

        }
    }

}

2.

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.Closeable;
import java.io.File;
import java.io.FileFilter;
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 Demo2 {

  public static void main(String[] args) {
    FileHandler fileHandler = null;
    try {
      //要查找的目录
      File dir = new File("d:\firstLevel");
      //利用fileHandler对象，完成递归查找，并将查找结果，存到d:
esult目录中
      fileHandler = new FileHandler("d:\result");

      //由FileFilter接口的匿名内部类对象，指明目标文件的筛选条件，开始递归查找，
      // 并对找到的目标文件做相应处理
      fileHandler.findFile(dir, new FileFilter() {
        @Override
        public boolean accept(File pathname) {
          return pathname != null
              && pathname.isFile()
              && pathname.getName().endsWith(".java");
        }
      });
    } catch (FileNotFoundException e) {
      e.printStackTrace();
    } catch (IOException e) {
      e.printStackTrace();
    }
  }
}

/*
      利用该类，完成文件的递归查找功能
 */
class FileHandler {
  //保存指定目录中，所有java文件的目录路径
  File dir;

  public FileHandler(String recordPath) throws FileNotFoundException {
    //利用目标文件的路径字符串，初始化，表示用来存储文件名的文件的File对象
    dir = new File(recordPath);
    //确保目标目录存在
    dir.mkdirs();
  }

  /*
        利用该方法，使用由FileFilter对象，所指明的筛选条件，筛选出符合条件的文件
        并将这些文件的绝对路径，保存到指定文件中
   */
  public void findFile(File file, FileFilter filter) throws IOException {
    File[] files = file.listFiles();

    if (files == null) {
      //说明当前File dir其实表示的是一个文件

      if (filter.accept(file)) {
        //满足筛选条件，就将满足条件的文件复制到目标目录下

        //创建File对象，表示复制的目标文件
        File destFile = new File(dir, file.getName());
        copyFile(file, destFile);

      }
      return;
    }
    for (int i = 0; i < files.length; i++) {
      findFile(files[i], filter);
    }
  }

  //利用缓冲流完成文件的复制
  public void copyFile(File srcFile, File destFile) {


    // 创建缓冲输入字节流对象
    InputStream in = null;

    // 创建缓冲字节输出流对象
    OutputStream out = null;
    try {
      in = new BufferedInputStream(
          new FileInputStream(srcFile));

      out = new BufferedOutputStream(
          new FileOutputStream(destFile));

      int len;
      byte[] buffer = new byte[1024];

      //复制文件
      while((len = in.read(buffer)) != -1) {
        out.write(buffer, 0, len);
      }
    } catch (FileNotFoundException e) {
      e.printStackTrace();
    } catch (IOException e) {
      e.printStackTrace();
    } finally {
      //关闭输入流
      closeQuietly(in);
      //关闭输出流
      closeQuietly(out);
    }


  }

  private void closeQuietly(Closeable closeable) {

    //关闭输出流
    try {
      if (closeable != null) {
        closeable.close();
      }

    } catch (IOException e) {
      e.printStackTrace();
    }

  }

}