java-File类-字节流

一 File

1.1 递归子目录

获取所有子目录中的内容

import java.io.File;

public class GetAllFiles {

    /**
     * @param args
     */
    public static void main(String[] args) {
        /*
         * File类的listFiles()列出当前目录下文件以及文件夹。
         *
         * 需求：能不能列出当前目录下的子目录中的所有内容。 思路： 1，在遍历当前目录时，会获取到当前的所有的文件以及文件夹，
         * 2，要遍历子目录需要对获取到的当前的file对象进行判断，只有是目录才可以作为子目录进行继续遍历。
         */

        File dir = new File("E:\\test");

        listAll(dir);

    }

    public static void listAll(File dir) {// dir:接收目录以及子目录。

        System.out.println("dir:" + dir.getName());
        File[] files = dir.listFiles();
        for (File file : files) {

            if (file.isDirectory()) {// 如果遍历到当前的file对象是个目录，继续遍历。
                listAll(file);
            } else {
                System.out.println("file:"+file.getName());
            }
        }

    }

}

1.2 使用队列遍历

import java.io.File;
import java.util.LinkedList;

public class GetAllFileByQueue {

    /**
     * @param args
     */
    public static void main(String[] args) {

        /*
         * 遍历文件夹，不用递归咋办？
         * 思路：
         * 1，可以通过对每一个目录进行for循环，但是目录层级很多，for会死掉。
         * 2，每遍历到一个目录，不对其进行遍历，而是先临时存储起来。 相当于把所有目录（无论同级不同级）都存储起来。
         * 3，遍历容器时取到就是目录，然后对目录遍历即可。 4，从容器中取到目录遍历时发现内部还有目录，一样将这些目录存储到容器中。
         * 5，只要不断的遍历这个容器就哦了。
         *
         * 通过图解：发现这个容器只要是一个简单的队列就可以解决这个问题。
         */

        File dir = new File("E:\\test");
        System.out.println(dir.getName());
        Queue<File> queue = new Queue<File>();

        // 1,对dir进行当前目录的遍历。
        File[] files = dir.listFiles();
        for (File file : files) {
            // 2, 如果有子目录，存储到队列中。
            if (file.isDirectory()) {
                queue.myAdd(file);
            } else {
                System.out.println(file.getName());
            }
        }
        System.out.println("---------------------");
        //3,遍历队列容器。因为子目录都在队列中。
        while(!queue.isNull()){

            File subDir = queue.myGet();//从队列中取出子目录。
            System.out.println(subDir.getName());
            //4,遍历子目录。
            File[] subFiles = subDir.listFiles();
            for(File subFile : subFiles){
                if(subFile.isDirectory()){//如果子目录中还有子目录，继续存储到队列中。
                    queue.myAdd(subFile);
                }else{
                    System.out.println(subFile.getName());
                }
            }

        }
    }

}

/**
 * 队列结构。先进先出。
 */
class Queue<E> {

    private LinkedList<E> link;

    /**
     * 提供了构造队列对象的构造器。
     */
    public Queue() {
        link = new LinkedList<E>();
    }

    /**
     * 添加元素的方法。
     */
    public void myAdd(E obj) {
        link.addFirst(obj);
    }

    /**
     * 获取的方法。
     */
    public E myGet() {
        return link.removeLast();
    }

    /**
     * 判断队列是否有元素。
     */
    public boolean isNull() {
        return link.isEmpty();
    }
}

1.3 文件数据写入

public class FileOutputStreamDemo {

    /**
     * @param args
     * @throws IOException
     */
    public static void main(String[] args) throws IOException {
        //需求：将数据写入到文件中。
        //创建临时目录，
        File dir = new File("tempfile");
        if(!dir.exists()){
            dir.mkdir();
        }

        //创建存储数据的文件。
        File file = new File(dir,"file.txt");

        //创建一个用于操作文件的字节输出流对象。一创建就必须明确数据存储目的地。
        //输出流目的是文件，会自动创建。如果文件存在，则覆盖。
        FileOutputStream fos = new FileOutputStream(file);

        //调用父类中的write方法。
        byte[] data = "abcde".getBytes();
        fos.write(data);

        //关闭流资源。
        fos.close();

    }
}

 续写&和换行

private static final String LINE_SEPARATOR = System.getProperty("line.separator");

    /**
     * @param args
     * @throws FileNotFoundException
     */
    public static void main(String[] args) throws Exception {

        //需求：将数据续写到已有文件中。
        //FileOutputStream(File file, boolean append) 续写。
        //在下一行写入新的数据。

        File file = new File("tempfile\\file.txt");

        FileOutputStream fos = new FileOutputStream(file, true);

        String str = LINE_SEPARATOR+"itcast";
        fos.write(str.getBytes());

        fos.close();

    }

1.4 异常处理

java-io流入门 这里面有异常的结构图

public class FileOutputStreamDemo3 {

    /**
     * @param args
     * @throws FileNotFoundException
     */
    public static void main(String[] args) {

        File file = new File("k:\\file.txt");
        FileOutputStream fos = null;
        try {
            fos = new FileOutputStream(file);
            fos.write("abcde".getBytes());

        } catch (IOException e) {
            System.out.println(e.toString() + "----");
        } finally {
            if (fos != null) {
                try {
                    fos.close();
                } catch (IOException e) {
                    throw new RuntimeException("");
                }
            }

        }

1.5 文件的读

第一种

public static void main(String[] args) throws IOException {
//        2,需求：读取文件中的数据，显示在屏幕上。

        File file = new File("tempfile\\file.txt");

        //创建一个字节输入流对象,必须明确数据源，其实就是创建字节读取流和数据源相关联。
        FileInputStream fis = new FileInputStream(file);

        //读取数据。使用 read();一次读一个字节。
        int ch = 0;
        while((ch=fis.read())!=-1){
            System.out.println("ch="+(char)ch);
        }
        // 关闭资源。
        fis.close();
    }

第二种

public static void main(String[] args) throws IOException {
        /*
         * 演示第二个读取方法， read(byte[]);
         */

        File file = new File("tempfile\\file.txt");

        // 创建一个字节输入流对象,必须明确数据源，其实就是创建字节读取流和数据源相关联。
        FileInputStream fis = new FileInputStream(file);

        //创建一个字节数组。
        byte[] buf = new byte[1024];//长度可以定义成1024的整数倍。

        int len = 0;
        while((len=fis.read(buf))!=-1){
            System.out.println(new String(buf,0,len));
        }

        fis.close();
    }

 1.6 复制文件

第一种

    public static void main(String[] args) throws IOException {

        /*
         * 练习：复制文件。
         * 原理；读取一个已有的数据，并将这些读到的数据写入到另一个文件中。
         */
        //1,明确源和目的。
        File srcFile = new File("E:\\1.mp3");
        File destFile = new File("E:\\copy_2.mp3");

        //2,明确字节流 输入流和源相关联，输出流和目的关联。
        FileInputStream fis = new FileInputStream(srcFile);
        FileOutputStream fos = new FileOutputStream(destFile);

        //3, 使用输入流的读取方法读取字节，并将字节写入到目的中。
        int ch = 0;
        while((ch=fis.read())!=-1){
            fos.write(ch);
        }

        //4,关闭资源。
        fos.close();
        fis.close();

    }

图解 

第二种

public static void main(String[] args) throws IOException {

        File srcFile = new File("E:\\1.mp3");
        File destFile = new File("E:\\copy_1.mp3");

        // 2,明确字节流 输入流和源相关联，输出流和目的关联。
        FileInputStream fis = new FileInputStream(srcFile);
        FileOutputStream fos = new FileOutputStream(destFile);

        // 3,定义一个缓冲区。
        byte[] buf = new byte[1024];

        int len = 0;
        while ((len = fis.read(buf)) != -1) {
            fos.write(buf, 0, len);// 将数组中的指定长度的数据写入到输出流中。
        }

        // 4,关闭资源。
        fos.close();
        fis.close();
    }

 图解

二 练习题

2.1 删除一个有内容的目录

public class Test2 {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // 2，请删除一个带有内容的目录。
        /*
         * 思路: 1，删除一个带有内容的目录原理；必须从里往外删。 2，到底有多级目录不确定，递归。
         */
        File dir = new File("E:\\test");

        // System.out.println(dir.delete());

        removeDir(dir);

    }

    /**
     * 删除一个目录。
     */
    public static void removeDir(File dir) {

        // 1,列出当前目录下的文件以及文件夹File[]
        File[] files = dir.listFiles();//如果目录是系统级文件夹，java没有访问权限，那么会返回null数组。最好加入判断。
        if (files != null) {
            // if(files.length == 0){
            // dir.delete();
            // return;
            // }

            for (File file : files) {

                // 2,对遍历到的file对象判断是否是目录。
                if (file.isDirectory()) {
                    removeDir(file);
                } else {
                    System.out.println(file + ":" + file.delete());// 删除文件。用打印语句验证是否删除成功，是否出现了误删操作。
                }
            }
        }
        System.out.println(dir + ":" + dir.delete());

    }
}

2.2 学生成绩存储

public class Test4 {

    private static final String LINE_SEPARATOR = System.getProperty("line.separator");

    /**
     * @param args
     * @throws IOException
     */
    public static void main(String[] args) throws IOException {
//        4，将学生对象(姓名，语文分数，数学分数，英语分数，总分)按照总分从高到低排序，
//        并将姓名和从高到低总分写入文件中。
        /*
         * 思路：
         * 1，描述学生。
         * 2，既然要按照总分从高到低排序，学生多要存储集合，TreeSet。
         * 3，将信息具体的信息保存到文件中。
         *         操作文件,持久化存储，涉及了IO技术。而且是将数据存储到文件中。所以写入。输出流。
         *
         */
        Set<Student> set = new TreeSet<Student>(Collections.reverseOrder());

        set.add(new Student("李四",,,));
        set.add(new Student("旺财",,,));
        set.add(new Student("小明",,,));
        set.add(new Student("小红",,,));
        set.add(new Student("小强",,,));

        File dir = new File("tempfile");
        if(!dir.exists()){
            dir.mkdir();
        }
        File destFile = new File(dir,"student_info.txt");
        write2File(set,destFile);
    }

    public static void write2File(Set<Student> set, File destFile) throws IOException {

        //1, 创建输出流对象和目的文件关联。并创建目的文件。OutputStream操作文件 FileOutputStream。
        FileOutputStream fos = null;
        try{
            fos = new FileOutputStream(destFile);
            //2,遍历集合中的对象数据。将数据写入到指定文件中。

            for(Student stu : set){
                String info = stu.getName()+"\t"+stu.getSum()+LINE_SEPARATOR;
                //3,将数据写入到文件中。
                fos.write(info.getBytes());
            }
        }finally{
            if(fos!=null){

                //关闭资源。
                try {
                    fos.close();
                } catch (IOException e) {
                    throw new RuntimeException("系统资源关闭失败");
                }
            }
        }

    }

}

2.3 文件清单列表

public class Test5 {

    private static final String LINE_SEPARATOR = SeparatorTool.LINE_SEPARATOR;

    /**
     * @param args
     * @throws IOException
     */
    public static void main(String[] args) throws IOException {
//        5，获取指定目录下所有的.java文件(包含子目录中的)，
//        并将这些java文件的绝路路径写入到一个文件中。
//        建立一个java文件清单列表。
        /*
         * 思路：
         * 1，一看到包含子目录，必须递归。
         * 2，写数据到文件，输出流。
         * 3，继续分析，发现只要.java ，需要过滤器。
         * 4，满足过滤的条件的文件有可能非常多，先进行存储。
         */
        //被遍历的目录。
        File dir = new File("E:\\Java_Code");

        //明确一个过滤器。
        FileFilter filter = new FileFilterBySuffix(".java");

        //符合过滤器条件的文件有很多，最好先存储起来，然后在进行操作。
        List<File> list = new ArrayList<File>();
        //获取指定文件清单。
        getFileList(dir,filter,list);
//        System.out.println(list.size());

        File destFile = new File(dir,"javalist.txt");
        write2File(list,destFile);
    }

    /**
     * 将集合中的数据的绝对路径写入到文件中。
     * @param list
     * @param destFile
     * @throws IOException
     */
    public static void write2File(List<File> list, File destFile) throws IOException {
        FileOutputStream fos = null;
        BufferedOutputStream bufos = null;
        try{
            fos = new FileOutputStream(destFile);
            bufos = new BufferedOutputStream(fos);

            for(File file : list){
                String info = file.getAbsolutePath()+LINE_SEPARATOR;
                bufos.write(info.getBytes());
                bufos.flush();//每写一个绝对路径就刷新一次。
            }
        }finally{
            if(bufos!=null){
                try {
                    fos.close();
                } catch (IOException e) {
                    throw new RuntimeException("关闭失败");
                }
            }
        }

    }

    /**
     * 根据指定的过滤器在指定目录下获取所有的符合过滤条件的文件，并存储到list集合中。
     * @param dir
     * @param filter
     * @param list
     */
    public static void getFileList(File dir,FileFilter filter,List<File> list) {

        File[] files = dir.listFiles();

        for(File file : files){

            if(file.isDirectory()){
                getFileList(file,filter,list);
            }else{
                //如果是文件，传递到过滤器中去过滤。将满足条件存储起来。
                if(filter.accept(file)){
                    list.add(file);
                }
            }
        }

    }

}