1.使用Files. walkFileTree()找出指定文件夹下所有扩展名为.txt和.java的文件。

  1. import java.io.IOException;
  2. import java.nio.file.FileSystems;
  3. import java.nio.file.FileVisitResult;
  4. import java.nio.file.Files;
  5. import java.nio.file.Path;
  6. import java.nio.file.PathMatcher;
  7. import java.nio.file.Paths;
  8. import java.nio.file.SimpleFileVisitor;
  9. import java.nio.file.attribute.BasicFileAttributes;
  10.  
  11. public class Search {
  12.  
  13.     public static void main(String args[]) throws IOException {
  14.         String glob = "glob:**/*.{java,txt}";
  15.         String path = "F:/";
  16.         match(glob, path);
  17.     }
  18.  
  19.     public static void match(String glob, String location) throws IOException {
  20.  
  21.         final PathMatcher pathMatcher = FileSystems.getDefault().getPathMatcher( glob);
  22.  
  23.         Files.walkFileTree(Paths.get(location), new SimpleFileVisitor<Path>() {
  24.  
  25.             @Override
  26.             public FileVisitResult visitFile(Path path,
  27.                     BasicFileAttributes attrs) throws IOException {
  28.                 if (pathMatcher.matches(path)) {
  29.                     System.out.println(path);
  30.                 }
  31.                 return FileVisitResult.CONTINUE;
  32.             }
  33.  
  34.             @Override
  35.             public FileVisitResult visitFileFailed(Path file, IOException exc)
  36.                     throws IOException {
  37.                 return FileVisitResult.CONTINUE;
  38.             }
  39.         });
  40.     }
  41. }

2.使用Files. walkFileTree()找出指定文件夹下所有大于指定大小（比如1M）的文件。

  1. import java.io.IOException;
  2. import java.nio.file.FileSystems;
  3. import java.nio.file.FileVisitOption;
  4. import java.nio.file.FileVisitResult;
  5. import java.nio.file.FileVisitor;
  6. import java.nio.file.Files;
  7. import java.nio.file.Path;
  8. import java.nio.file.PathMatcher;
  9. import java.nio.file.Paths;
  10. import java.nio.file.attribute.BasicFileAttributes;
  11. import java.util.EnumSet;
  12. public class Search implements FileVisitor {
  13.  private final PathMatcher matcher;
  14.  private final long accepted_size;
  15.  public Search(String glob,long accepted_size) {
  16.       matcher= FileSystems.getDefault().getPathMatcher("glob:" +glob);
  17.       this.accepted_size=accepted_size;
  18.     }
  19.    void search(Path file) throws IOException {
  20.     long size = (Long) Files.getAttribute(file, "basic:size");
  21.     if(size ==accepted_size) {
  22.      System.out.println(file);
  23.     }
  24.    }
  25.    public FileVisitResult postVisitDirectory(Object dir, IOException exc)throws IOException {
  26.     return FileVisitResult.CONTINUE;
  27.    }
  28.    public FileVisitResult preVisitDirectory(Object dir, BasicFileAttributes attrs)throws IOException {
  29.     return FileVisitResult.CONTINUE;
  30.    }
  31.    public FileVisitResult visitFile(Object file, BasicFileAttributes attrs)throws IOException {
  32.   search((Path) file);
  33.      return  FileVisitResult.CONTINUE;
  34.   }
  35.    public FileVisitResult visitFileFailed(Object file, IOException exc)throws IOException {
  36.   return FileVisitResult.CONTINUE;
  37.    }
  38.    public static void main(String[] args) throws IOException{
  39.     String glob= "*.jpg";
  40.     long size = 1048576;
  41.     Path fileTree = Paths.get("F:/");
  42.     Search walk=new Search(glob, size);
  43.     EnumSet opts=EnumSet.of(FileVisitOption.FOLLOW_LINKS);
  44.     System.out.println("F盘中大小等于1M的文件有");
  45.     Files.walkFileTree(fileTree, opts, Integer.MAX_VALUE, walk);
  46.    }
  47. }

3.使用Files. walkFileTree()找出指定文件夹下所有包容指定字符串的txt文件。

  1. import java.io.IOException;
  2. import java.io.*;
  3. import java.nio.file.FileSystems;
  4. import java.nio.file.FileVisitResult;
  5. import java.nio.file.Files;
  6. import java.nio.file.Path;
  7. import java.nio.file.PathMatcher;
  8. import java.nio.file.Paths;
  9. import java.nio.file.SimpleFileVisitor;
  10. import java.nio.file.attribute.BasicFileAttributes;
  11.  
  12. public class Search {
  13.  
  14.     public static void main(String args[]) throws IOException {
  15.         String glob = "glob:**/*.txt";
  16.         String path = "F:/";
  17.         match(glob, path);
  18.     }
  19.  
  20.     public static void match(String glob, String location) throws IOException {
  21.  
  22.         final PathMatcher pathMatcher = FileSystems.getDefault().getPathMatcher( glob);
  23.  
  24.         Files.walkFileTree(Paths.get(location), new SimpleFileVisitor<Path>() {
  25.  
  26.             @Override
  27.             public FileVisitResult visitFile(Path path,
  28.                     BasicFileAttributes attrs) throws IOException {
  29.                 if (pathMatcher.matches(path)) {
  30.                  BufferedReader reader =Files.newBufferedReader(path);//读取文件内的内容
  31.                   String line=null;
  32.                   while((line = reader.readLine()) !=null) {
  33.                    if(line=="student")//若读取的内容等于“student"则输出文件名
  34.                    {
  35.                          System.out.println(path);
  36.                          break;
  37.                    }
  38.                   }
  39.                 }
  40.                   return FileVisitResult.CONTINUE;
  41.             }
  42.  
  43.             @Override
  44.             public FileVisitResult visitFileFailed(Path file, IOException exc)
  45.                     throws IOException {
  46.                 return FileVisitResult.CONTINUE;
  47.             }
  48.         });
  49.     }
  50.  
  51. }

4.请通过查询JDK文件和使用搜索引擎等方式，看懂此示例代码，并弄明白Watchable、WatchService等类型之间的关系，使用UML类图表示出这些类之间的关系。

java.nio.file.WatchService文件系统监视服务的接口类，它的具体实现由监视服务提供者负责加载。

java.nio.file.Watchable 实现了 java.nio.file.Watchable 的对象才能注册监视服务 WatchService。java.nio.file.Path实现了 watchable 接口，后文使用 Path 对象注册监视服务。

java.nio.file.WatchKey 该类代表着 Watchable 对象和监视服务 WatchService 的注册关系。WatchKey 在 Watchable 对象向 WatchService 注册的时候被创建。它是 Watchable 和 WatchService 之间的关联类。

5.编写一个程序，指定一个文件夹，能自动计算出其总容量

  1. import java.io.File;
  2. import java.util.ArrayList;
  3. public class Size {
  4.     static long size=0;
  5.     private static ArrayList<String> filelist=new ArrayList<String>();
  6.     public void getFiles(String filePath)
  7.     {
  8.         File root=new File(filePath);
  9.         File[] files=root.listFiles();
  10.         for(File file:files)
  11.         {
  12.             if(file.isDirectory())
  13.             {
  14.                 getFiles(file.getAbsolutePath());
  15.                 filelist.add(file.getAbsolutePath());
  16.             }
  17.             else
  18.             {
  19.                 size+=file.getAbsolutePath().length();
  20.             }
  21.         }
  22.         System.out.println("大小是"+size);
  23.     }
  24.     public static void main(String[] args)
  25.     {
  26.         Size s=new Size();
  27.         String filePath="F:\\Program Files";
  28.         s.getFiles(filePath);
  29.     }
  30.  
  31. }

6.编写一个文件加解密程序，通过命令行完成加解密工作

  1. import java.io.File;
  2. import java.io.InputStream;
  3. import java.io.OutputStream;
  4. import java.io.FileInputStream;
  5. import java.io.FileOutputStream;
  6. public class Secret {
  7.     private static final int numOfEncAndDec=0x99;//加密解密密钥
  8.      private static int dataOfFile=0;//文件字节内容
  9.  
  10.      public static void main(String[] args) {
  11.       File srcFile=new File("a.txt");//初始化文件
  12.       File encFile=new File("b.txt"); //加密文件
  13.       File decFile=new File("c.txt");  //解密文件
  14.  
  15.       try {
  16.        EncFile(srcFile,encFile);  //加密操作
  17.        DecFile(encFile,decFile);
  18.       }catch(Exception e) {
  19.        e.printStackTrace();
  20.       }
  21.      }
  22.      private static void EncFile(File srcFile,File encFile)throws Exception{
  23.       if(!srcFile.exists()) {
  24.        System.out.println("source file not exixt");
  25.        }
  26.       if(!encFile.exists()) {
  27.        System.out.println("encrypt file created");
  28.        encFile.createNewFile();//若无加密文件，新建一个加密文件
  29.       }
  30.       InputStream fis=new FileInputStream(srcFile);
  31.       OutputStream fos=new FileOutputStream(encFile);
  32.  
  33.       while((dataOfFile=fis.read())>-1) {//当读到文件内容时
  34.        fos.write(dataOfFile^numOfEncAndDec);//将读出的内容加密后写入
  35.       }
  36.       fis.close();
  37.       fos.flush();
  38.       fos.close();
  39.      }
  40.      private static void DecFile(File encFile,File decFile)throws Exception{
  41.       if(!encFile.exists()) {
  42.        System.out.println("encrypt file not exixt");
  43.       }
  44.       if(!decFile.exists()) {
  45.        System.out.println("decrypt file created");
  46.        decFile.createNewFile();
  47.       }
  48.       InputStream fis=new FileInputStream(encFile);
  49.       OutputStream fos=new FileOutputStream(decFile);
  50.  
  51.       while((dataOfFile=fis.read())>-1) {
  52.        fos.write(dataOfFile^numOfEncAndDec);
  53.       }
  54.       fis.close();
  55.       fos.flush();
  56.       fos.close();
  57.      }
  58.  
  59. }

7.编写一个文件分割工具，能把一个大文件分割成多个小的文件。并且能再次把它们合并起来得到完整的文件。

i

  1. mport java.io.File;
  2. import java.io.FileInputStream;
  3. import java.io.FileNotFoundException;
  4. import java.io.FileOutputStream;
  5. import java.io.IOException;
  6. public class Wenjian {
  7.     private static void cutFile(String src, String endsrc, int num) {
  8.         FileInputStream fis = null;
  9.         File file = null;
  10.         try {
  11.             fis = new FileInputStream(src);
  12.             file = new File(src);
  13.             //创建规定大小的byte数组
  14.             byte[] b = new byte[num];
  15.             int len = 0;
  16.             //name为以后的小文件命名做准备
  17.             int name = 1;
  18.             //遍历将大文件读入byte数组中，当byte数组读满后写入对应的小文件中
  19.             while ((len = fis.read(b)) != -1) {
  20.                 //分别找到原大文件的文件名和文件类型，为下面的小文件命名做准备
  21.                 String name2 = file.getName();
  22.                 int lastIndexOf = name2.lastIndexOf(".");
  23.                 String substring = name2.substring(0, lastIndexOf);
  24.                 String substring2 = name2.substring(lastIndexOf, name2.length());
  25.                 FileOutputStream fos = new FileOutputStream(endsrc + "\\\\"+ substring + "-" + name + substring2);
  26.                 //将byte数组写入对应的小文件中
  27.                 fos.write(b, 0, len);
  28.                 //结束资源
  29.                 fos.close();
  30.                 name++;
  31.             }
  32.         } catch (FileNotFoundException e) {
  33.             e.printStackTrace();
  34.         } catch (IOException e) {
  35.             e.printStackTrace();
  36.         } finally {
  37.             try {
  38.                 if (fis != null) {
  39.                     //结束资源
  40.                     fis.close();
  41.                 }
  42.             } catch (IOException e) {
  43.                 e.printStackTrace();
  44.             }
  45.         }
  46.     }
  47.     private static void togetherFile(String src, String endsrc){
  48.         FileOutputStream fos = null;
  49.         File file1 = null;
  50.         File file2 = null;
  51.         try {
  52.             file1 = new File(endsrc);
  53.             file2 = new File(src);
  54.             //获得大文件的存储路径的FileOutputStream对象
  55.             fos = new FileOutputStream(endsrc);
  56.             //循环遍历对应文件夹中的所有小文件
  57.             for(File file : file2.listFiles()){
  58.  
  59.                 FileInputStream fis = new FileInputStream(file.getAbsolutePath());
  60.  
  61.                 byte[] b = new byte[1024*1024];
  62.                 int len = 0;
  63.                 //将小文件读入byte数组，之后再将byte数组写入大文件中
  64.                 while((len = fis.read(b)) != -1){
  65.                     fos.write(b, 0, len);
  66.                 }
  67.                 //结束资源
  68.                 fis.close();
  69.             }
  70.         } catch (FileNotFoundException e) {
  71.             e.printStackTrace();
  72.         } catch (IOException e) {
  73.             e.printStackTrace();
  74.         }finally{
  75.             try {
  76.                 if(fos != null){
  77.                     //结束资源
  78.                     fos.close();
  79.                 }
  80.             } catch (IOException e) {
  81.                 e.printStackTrace();
  82.             }
  83.         }
  84.     }
  85.     public static void main(String[] args){
  86.         cutFile("D:\\文件\\a.txt", "D:\\文件",10 * 10 * 20);
  87.         //调用togetherFile()函数合并小文件到大文件 参数列表分别为 （小文件所在的父文件夹路径，所合成的大文件的路径）
  88.         togetherFile("D:\\文件","D:\\文件1\\a.txt");
  89.     }
  90. }

第九周java动手动脑的更多相关文章

  1. Java动手动脑——多态和继承

    Java动手动脑——继承和多态 实验一 预估输出答案:100  200  201  202 输出结果:100  200  201  202 输出答案分析:100 创建parent类的对象,调用对象的方 ...

  2. 20145322第九周JAVA程序设计基础学习总结

    20145322第九周JAVA程序设计基础学习总结 JDBC简介 JDBC全名Java DataBase Connectivity,是java联机数据库的标准规范.它定义一组标准类与接口,应用程序需要 ...

  3. java动手动脑和课后实验型问题String类型

    1.请运行以下示例代码StringPool.java,查看其输出结果.如何解释这样的输出结果?从中你能总结出什么? true true false 总结: 使用new关键字创建字符串对象时, 每次申请 ...

  4. 第九周java学习总结

    20145306<java程序设计>第九周学习总结 教材学习内容总结 第十六章 一.JDBC入门 1.JDBC简介 JDBC是用于执行SQL的解决方案,开发人员使用JDBC的标准接口,数据 ...

  5. 20165223《Java程序设计》第九周Java学习总结

    教材学习内容总结 第13章- URL类 InetAddress类 套接字 UDP数据报 广播数据报 Java远程调用(RMI) 教材学习中的问题和解决过程 1. URL类 URL类构造方法: 使用字符 ...

  6. java 动手动脑7

    ---恢复内容开始--- 一.动手动脑:多层的异常捕获-1 阅读以下代码(CatchWho.java),写出程序运行结果: ArrayIndexOutOfBoundsException/内层try-c ...

  7. java动手动脑和动手实验

    动手动脑一: EnumTest.java: 程序代码: public class EnumTest { public static void main(String[] args) { Size s= ...

  8. 20175215 2018-2019-2 第九周java课程学习总结

    第十一章 JDBC与MySQL数据库 11.1 MySQL数据库管理系统 下载安装过程略 使用的是MySQL 5.6而非5.7 11.2 启动MySQL数据库服务器 启动和root用户过程略 11.3 ...

  9. java动手动脑和课后实验型问题第四讲

    1.完全"手写代码实现"随机数生成 动手动脑: 编写一个方法,使用以上算法生成指定数目(比如1000个)的随机整数. Modulus=231-1=int.MaxValue Mult ...

随机推荐

  1. nuget cli常用命令简介

    起因:使用nuget,但是部分同事用的mac,不能用vs的包管理器查看私有nuget库里面的包,所以,就总结了几个常用的 nuget cli 命令,方便全平台使用nuget 废话不多,直入主题 准备: ...

  2. HTML5 storage事件监听

    引用<h5移动web开发指南>上的话: “当同源页面的某个页面修改了localStorage,其余的同源页面只要注册了storage事件,就会触发” 所以,localStorage  st ...

  3. Spring学习之旅(十一)--JDBC

    JDBC 是数据持久化的一种比较常见的方案,Spring 也对它进行了支持. 在开始 JDBC 的使用之前,我们要先做下一些准备工作. 配置数据源 在 Spring 上下文中可以数据源 Bean 有如 ...

  4. Spring学习之旅(三)--装配Bean

    装配 Bean 的方式 在 XML 中进行显式配置 在 Java 中进行显式配置 隐式的 Bean 发现机制和自动装配 Spring 提供了以上三种方式进行 Bean 的配置,可以根据自己的需求选择一 ...

  5. ECMAScript---object对象类型详解

    普通对象:由大括号包裹起来的,由零到多个属性名和属性值(键值对)组成的 那什么是属性呢? 属性:描述当前对象特征的,属性名是当前具备这个特征,属性值是这个特征的描述(专业语法,属性名称为键[key], ...

  6. JavaScript 数据结构与算法之美 - 线性表（数组、栈、队列、链表）

    前言 基础知识就像是一座大楼的地基,它决定了我们的技术高度. 我们应该多掌握一些可移值的技术或者再过十几年应该都不会过时的技术,数据结构与算法就是其中之一. 栈.队列.链表.堆 是数据结构与算法中的基 ...

  7. Java线程之线程简介

    Java线程之线程简介 一.何谓线程 明为跟踪处理流程,实为跟踪线程 阅读程序时,我们会按处理流程来阅读. 首先执行这条语句 ↓ 然后执行这条语句 ↓ 接着再执行这条语句…… 我们就是按照上面这样的流 ...

  8. C#开发BIMFACE系列8 服务端API之获取文件上传状态信息

    系列目录     [已更新最新开发文章,点击查看详细] 在BIMFACE控制台上传文件,上传过程及结束后它会自动告诉你文件的上传状态,目前有三种状态:uploading,success,failure ...

  9. list 分批

    public class TestList { public static void main(String[] args){ List<Integer> list = new Array ...

  10. JavaScript img标签自带的onload和onerror函数

    onload 加载完成时调用触发 原生: <img src="" alt="Park" onload=“handleImageLoaded()”/> ...