Java-IO流（三）操作文件中的数据

对数据进行输入输出操作(往文件中写入数据)

            1，将内存中数据都写入到文件中。
                需要使用系统资源，Java中用于操作系统资源的对象是哪个呢？
                通过api的索引关键字 Output Input
                找到OutputStream InputStream。
            2，OutputStream InputStream
                字节输出流和字节输入流的超类。
                定义了write 和read方法。
            3，它们的子类都具备名称定义规律：后缀名是父类名，前缀名是流对象的功能。★★★
            4，依据这个规律，找到了可以用于操作文件的流对象。流可以理解系统资源。
            5，写入数据到文件的特点。
                5.1 必须明确目的地文件，会自动创建，如果文件存在则会覆盖。
                5.2 续写只要在构造函数中传递true。换行只要使用系统的行分隔符。
                5.2IO异常处理必须使用finally关闭资源，在关闭前做!=null的判断。★★★★
            6，读取文件数据的特点：★★★★★
                6.1 明确数据源，让读取流和数据源相关联。
                6.2 读取有两种方式。
                    read():一次读取一个字节并返回，没有数据返回-1.  
                    read(byte[])：读取一定数量的数据存储到byte[]中，返回读到字节的个数，没有数据返回-1.
                    第二种方式高效。字节数组的长度建议为 1024.
            7，复制文件：需要中转。建议使用字节数组作为中转，效率高。

字节输出流-数据写入到文件中

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

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();
        
    }
}

• 字节输出流-续写&换行

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

public class FileOutputStreamDemo2 {

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

    /**
     * @param args
     * @throws FileNotFoundException 
     */
    public static void main(String[] args) throws Exception {
        
        //需求：将数据续写到已有文件中。
        File file = new File("tempfile/file.txt");
        
                //FileOutputStream(File file, boolean append) 续写。
        FileOutputStream fos = new FileOutputStream(file, true);
        //  LINE_SEPARATOR 在下一行写入新的数据   
        String str = LINE_SEPARATOR+"haha";
        fos.write(str.getBytes());
        
        fos.close();
    }
}

• IO异常处理

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

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("");
                }
            }
        }
    }
}

字节输入流-读取数据

• read()方法

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

public class FileInputStreamDemo {

    /**
     * @param args
     * @throws IOException 
     */
    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();
    }
}

• read(byte[])方法（推荐）

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;

public class FileInputStreamDemo2 {

    /**
     * @param args
     * @throws IOException 
     */
    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));
        }
        
        /*int len1 = fis.read(buf);
        System.out.println(len1+":"+new String(buf,0,len1));
        int len2 = fis.read(buf);
        System.out.println(len2+":"+new String(buf,0,len2));
        int len3 = fis.read(buf);
        System.out.println(len3+":"+new String(buf,0,len3));
        int len4 = fis.read(buf);
        System.out.println(len4);
        */
        
        fis.close();
    }

}

练习：复制文件

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

public class CopyFileTest {

    /**
     * @param args
     * @throws IOException 
     */
    public static void main(String[] args) throws IOException {
        
        /*
         * 练习：复制文件。
         * 原理；读取一个已有的数据，并将这些读到的数据写入到另一个文件中。
         */
        //1,明确源和目的。
        File srcFile = new File("tempfile/file.txt");
        File destFile = new File("tempfile/copy_file.txt");
        
        //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();    
    }
}

字节流复制文件图解

• 自定义缓冲数组复制文件(推荐)

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

public class CopyFileByBufferTest {

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

        File srcFile = new File("tempfile/file.txt");
        File destFile = new File("tempfile/copy_file.txt");;

        // 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();
    }
}

字节流缓冲区对象复制图解

available方法

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class ByteStreamDemo {

    public static void main(String[] args) throws IOException {
        
        /*
         * 字节输入流。
         * available();
         */
        
        FileInputStream fis = new FileInputStream("tempfile/file.txt");
        
//      System.out.println(fis.available());//输出文件大小
        byte[] buf = new byte[fis.available()];//定义了一个刚刚好的数组。 注意：如果文件过大，容易溢出。
                                        //建议缓冲区的长度最好还是1024的整数倍。
        
        fis.read(buf);
        String str = new String(buf);
        System.out.println(str);
        
        
        fis.close();
    }
}

删除一个带有内容的目录

import java.io.File;
public class Test2 {

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

        // 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());

    }
}

获取指定目录下所有的.java文件(包含子目录中的)，并将这些java文件的绝路路径写入到一个文件中

import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileFilter;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

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("tempfile");
        
        //明确一个过滤器。
        FileFilter filter = new FileFilterBySuffix(".java");
        
        
        //符合过滤器条件的文件有很多，最好先存储起来，然后在进行操作。
        List list = new ArrayList();
        //获取指定文件清单。
        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 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 list) {
        
        File[] files = dir.listFiles();
        
        for(File file : files){
            
            if(file.isDirectory()){
                getFileList(file,filter,list);
            }else{
                //如果是文件，传递到过滤器中去过滤。将满足条件存储起来。
                if(filter.accept(file)){
                    list.add(file);
                }
            }
        }
        
    }
}