文件操作,文件字节流,字符流操作,字节缓存流,字符缓存流

文件操作

package com.demo.file;

import java.io.File;
import java.io.IOException;
import java.util.Date;

/**
 * 定义文件操作类
 * 
 * @author Administrator
 *
 */
public class FileDemo {

    public static void main(String[] args) {
        // testCreateFile();
        // testCreateDirAndFile();
        //listDirFiles();
        listDirAllFiles("D:/J2EE/workspace/boot");
    }
    
    

    /**
     * 递归方法遍历一个目录下面所有文件
     */
    private static void listDirAllFiles(String path) {
        File dir = new File(path);
        // 获取到path根目录下面所有文件
        File[] files = dir.listFiles();
        
        if (files != null  && files.length > 0) {
            for (File file :  files) {
                // 判断如果当前遍历这个是一个目录，直接继续查找该目录下面所有文件
                if (file.isDirectory()) {
                    // System.out.println(file.getAbsolutePath());
                    // 递归查找该目录下面所有文件
                    listDirAllFiles(file.getAbsolutePath());
                } else {
                    // 直接输出文件的路径
                    System.out.println(file.getAbsolutePath());
                }
            }
        }
    }



    /**
     * 列出某个目录下面的文件
     */
    private static void listDirFiles() {
        File dir = new File("C:/");
        // 获取c盘根目录下面所有文件名称组成数组
        /*String[] list = dir.list();
        for (String path : list) {
            System.out.println(path);
        }*/
        System.out.println("--------------------");
        // 获取C判断根目录下面所有文件
        File[] listFiles = dir.listFiles();
        for (File file : listFiles) {
            System.out.println(file.getAbsolutePath());
        }
    }



    /**
     * 测试创建目录及文件的方法
     */
    private static void testCreateDirAndFile() {
        File file = new File("D:/a/b/c/d/a.bat");
        // 判断创建文件的目录是存在
        String dir = file.getParent();
        File dirFile = new File(dir);
        if (!dirFile.exists()) {
            // 创建目录使用是mkdir方法
            //dirFile.mkdir(); // 创建一级目录
            dirFile.mkdirs(); //  创建多级目录
        }
        
        // 创建这个文件
        try {
            boolean flag = file.createNewFile();
            System.out.println(flag ? "创建成功" : "创建失败");
        } catch (IOException e) {
            e.printStackTrace();
        }
        
        // 文件属性
        System.out.println("最后修改时间:"+new Date(file.lastModified()));
        System.out.println("文件路径:"+file.getAbsolutePath());
        System.out.println("文件名称:"+file.getName());
        System.out.println("文件的大小:"+file.length());
        System.out.println("是否可读:"+file.canRead());
        System.out.println("是否可写:"+file.canWrite());
        System.out.println("是否隐藏:"+file.isHidden());
        
        // 删除文件（文档才能直接删除，文件夹必须为空才能删除）
        file.delete();
        
    }

    /**
     * 测试创建文件的方法
     */
    private static void testCreateFile() {
        // 创建文件对象
        // pathname 文件的绝对路径
        // CTRL+2,L 自动补全
        File file = new File("D:/test.txt"); // 这个文件还在内存中在本地是存在.

        // 判断文件是否存在
        System.out.println(file.exists());
        // 判断是否为文件
        System.out.println(file.isFile());
        // 判断是否为目录
        System.out.println(file.isDirectory());

        try {
            if (!file.exists()) {
                // 调用创建文件的方法
                boolean flag = file.createNewFile();
                System.out.println(flag ? "成功" : "失败");
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

}

 

字节流的操作

package com.stream.demo;

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

import org.junit.Test;

/**
 * 演示字节流的操作
 * InputStream 
 * OutputStream
 * @author Administrator
 *
 */
public class BytestreamDemo {
    @Test // 测试字节输出流写入文件内容
    public void testOutStream() {
        // 创建一个文件
        File file = new File("D:/a/b/c/d","out.txt");
        
        try {
            // 只要目录存在，即使文件不存在，文件流会自动创建这个文件
            FileOutputStream fos = new FileOutputStream(file);
            // 使用write方法把内存中内容写入到文件
            fos.write("我爱我的家".getBytes());
            // 关闭流
            fos.flush();
            fos.close();
            
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    
    @Test // 测试字节输出流写入文件内容
    public void testInputStream() {
        // 创建一个文件
        File file = new File("D:/a/b/c/d","out.txt");
        
        try {
            // 创建文件输入流
            FileInputStream fis = new FileInputStream(file);
            // 读取文件中的内容
            System.out.println("可用字节数:"+fis.available());

            // 定义读取内容缓冲区
            byte[] buffer = new byte[fis.available()];
            fis.read(buffer, 0, buffer.length);
            
            // 把字节数组转换为一个字符串
            String content = new String(buffer);
            System.out.println(content);
            
            // 关闭流
            fis.close();
            
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

字符流

package com.stream.demo;

import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

import org.junit.Test;

/**
 * 测试字符流
 * @author Administrator
 *
 */
public class CharstreamDemo {
    
    @Test
    public void testFileWriter() {
        try {
            // 创建字符输出流, 追加写入的内容
            FileWriter writer = new FileWriter("D:\\a\\b\\c\\d\\out.txt", true);
            // 操作流
            writer.write("|我是字符流");
            
            // 关闭流
            writer.flush();
            writer.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    
    @Test
    public void testFileReader() {
        try {
            File file = new File("D:\\a\\b\\c\\d\\out.txt");
            // 创建字符输入流
            FileReader reader = new FileReader(file);
            // 操作流
            char[] cbuf = new char[(int) file.length()];
            reader.read(cbuf, 0, cbuf.length);
            
            String content = new String(cbuf);
            System.out.println(content.trim());
            
            // 关闭流
            reader.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

拷贝大文件的方法

package com.stream.demo;

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

/**
 * 文件操作工具类
 * @author Administrator
 *
 */
public class FileUtils {
    
    public static void main(String[] args) {
        String srcFile = "D:/vip/java02/javavip02_12_20180420(LinkedList模拟Stack，Queue)/javavip02_12_20180420(LinkedList模拟Stack，Queue).wmv";
        String destFile = "C:/copy_back.wmv";
        copyBigFile(srcFile, destFile);
    }

    /**
     * 拷贝大文件的方法
     * @param srcFile 源文件
     * @param desFile 目标文件
     */
    private static void copyBigFile(String srcFile, String destFile) {
        
        try {
            // 创建文件输入流
            FileInputStream in = new FileInputStream(srcFile);
            // 创建文件输出流
            FileOutputStream out = new FileOutputStream(destFile);
            // 定义读取内容的缓存区
            byte[] buffer = new byte[1024];
            // 定义记录长度的变量
            int len = 0;
            
            while((len = in.read(buffer)) != -1) {
                System.out.println(len);
                // 把循环读取到缓冲区中数据写入到目标文件中
                out.write(buffer, 0, len);
            }
            
            // 关闭流(谁最后使用就先关闭谁)
            out.flush();
            out.close();
            in.close();
            
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

}

 字节缓存流

package com.stream.demo.sup;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;

import org.junit.Test;

/**
 * 字节缓存流的演示
 * @author Administrator
 *
 */
public class ByteBufferedDemo {
    @Test // 测试输出流
    public void testBufferedOutputStream() {
        // 创建一个文件对象
        File file = new File("D:/a/b/c/d/buffered.txt");
        try {
            // 创建文件低级的输出流对象(是可以最近文件内容)
            FileOutputStream out = new FileOutputStream(file, true);
            // 创建缓存输出流
            BufferedOutputStream bout = new BufferedOutputStream(out);
            // 向文件中写入内容
            bout.write("我学会使用BufferedOutputStream流啦|".getBytes());
            // 释放资源
            bout.flush();
            bout.close();
            out.flush();
            out.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    
    @Test // 测试输出流
    public void testBufferedInputStream() {
        // 创建一个文件对象
        File file = new File("D:/a/b/c/d/buffered.txt");
        try {
            // 创建文件低级的输入流对象(是可以最近文件内容)
            FileInputStream in = new FileInputStream(file);
            // 创建缓存输入流
            BufferedInputStream bin = new BufferedInputStream(in);
            
            byte[] buffer = new byte[1024];
            
            // 存储每次读取字节
            int len = 0;
            
            while ((len = bin.read(buffer)) != -1) {
                System.out.println(len);
                String content = new String(buffer, 0, len);
                System.out.println(content);
            }
            // 释放资源
            bin.close();
            in.close();
            
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

字节缓存流

package com.stream.demo.sup;

import java.awt.image.BufferedImageFilter;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Date;

import org.junit.Test;

/**
 * 演示字符缓存流
 * 
 * @author Administrator
 *
 */
public class CharBufferedDemo {
    @Test // 测试高级的字符输出流
    public void testFileWriter() {
        try {
            // 创建高级字符输出流对象
            BufferedWriter bw = new BufferedWriter(new FileWriter(new File("D:/a/b/c/d/bufferedChar.txt")));

            // 写入内容
            bw.write("我学会了使用BufferedWriter对象");
            bw.newLine(); // 写入一个换行
            bw.write(new Date().toLocaleString());

            // 关闭流
            bw.flush();
            bw.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    @Test
    public void testFileReader() {
        try (
                BufferedReader br = new BufferedReader(new FileReader(new File("D:/a/b/c/d/bufferedChar.txt")));
                
            ) {
            String content = null;
            while((content = br.readLine()) != null) {
                System.out.println(content);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

文件搬家

package com.stream.demo.home;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;

/**
 * 实现文件搬家
 * @author Administrator
 *
 */
public class MoveFile {
    
    public static void main(String[] args) {
        String srcPath = "C:\\eclipse4.7";
        String destPath = "D:\\base";
        moveFile(srcPath, destPath);
    }

    /**
     * 文件搬家的方法
     * @param srcPath
     * @param destPath
     */
    private static void moveFile(String srcPath, String destPath) {
        // 获取源文件
        File srcFile = new File(srcPath);
        // 获取源文件中所有子文件
        File[] files = srcFile.listFiles();
        
        // 判断是否为空
        if (files != null  && files.length > 0) {
            for (File file : files) {
                // 获取拷贝文件路径
                String targetPath = file.getAbsolutePath().replace(srcPath, destPath);
                System.out.println(targetPath);
                
                // 判断是否为目录
                if (file.isDirectory()) {
                    // 创建拷贝目标目录
                    createDirectory(targetPath);
                    // 递归查找文件
                    moveFile(file.getAbsolutePath(), targetPath);
                    
                } else {
                    copyFile(file.getAbsolutePath(), targetPath);
                }
                
                // 删除目录
                file.delete();
                
            }
        }
        
        // 删除最外面文件夹
        srcFile.delete();
        
    }

    /**
     * 定义创建目录的方法
     * @param targetPath
     */
    private static void createDirectory(String targetPath) {
        File dir = new File(targetPath);
        
        if (!dir.exists()) {
            dir.mkdirs();
        }
    }

    /**
     * 定义拷贝文件的方法
     * @param srcPath
     * @param destPath
     */
    private static void copyFile(String srcPath, String destPath) {
        File srcFile = new File(srcPath);
        
        try (
                // 获取文件输入流
                BufferedInputStream in = new BufferedInputStream(new FileInputStream(srcFile));
                // 获取文件输出流
                BufferedOutputStream out = new BufferedOutputStream(new FileOutputStream(new File(destPath)));
            ){
            // 定义缓存区
            byte[] buffer = new byte[1024];
            // 定义存储每次读取字节数
            int len = 0;
            
            while ((len = in.read(buffer)) != -1) {
                out.write(buffer, 0, len);
            }
            // 删除源文件
            srcFile.delete();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

}

 对象流

package com.stream.demo.sup;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;

import org.junit.Test;

/**
 * 数据流的简单使用
 * 可以指定写入数据类型
 * @author Administrator
 * 
 * 注意： 所有流程是否无法创建目录的
 *
 */
public class DataStreamDemo {
    
    @Test
    public void testDataOutputStream() {
        try {
            // 创建数据的输出流对象
            DataOutputStream dos = new DataOutputStream(new FileOutputStream(new File("D:/a/b/c/d/data.txt")));
            // 向文件写入内容
            dos.writeBoolean(false);
            dos.writeLong(1000L);
            dos.writeUTF("我学会使用DataOutputStream输出流对象写入文件内容");
            
            // 释放资源
            dos.flush();
            dos.close();
            
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    
    @Test
    public void testDataInputStream() {
        try {
            // 创建数据的输入流对象
            DataInputStream dis = new DataInputStream(new FileInputStream(new File("D:/a/b/c/d/data.txt")));
            // 读取文件中内容
            System.out.println(dis.readBoolean());
            System.out.println(dis.readLong());
            System.out.println(dis.readUTF());
            
            // 释放流
            dis.close();
            
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

 串行化流/对象流操作

package com.stream.demo.sup.entity;

import java.io.Serializable;

/**
 * Cat类实现Serializable接口后就能够被对象输出流序列化
 * @author Administrator
 *
 */
public class Cat implements Serializable {
    /**
     * 
     */
    private static final long serialVersionUID = 1L;
    
    private String name; // 名称
    private String sex; // 性别
    private int age; // 年龄
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getSex() {
        return sex;
    }
    public void setSex(String sex) {
        this.sex = sex;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    
    
}

package com.stream.demo.sup;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.ArrayList;
import java.util.List;

import org.junit.Test;

import com.stream.demo.sup.entity.Cat;

/**
 * 串行化流/对象流操作实例
 * @author Administrator
 *
 */
public class ObjectStreamDemo {
    
    @Test
    public void objectOutputStream() {
        // java.io.NotSerializableException: java.lang.Object
        // 异常就是被序列化的对象没有实现Serializable接口
        try {
            // 创建一个对象流程
            ObjectOutputStream os = new ObjectOutputStream(new FileOutputStream(new File("D:/a/b/c/d/object.txt")));
            // 创建一个Cat对象
            Cat cat = new Cat();
            cat.setAge(4);
            cat.setName("咖啡猫");
            cat.setSex("母");
            
            // 序列化一个对象到文件中
            os.writeObject(cat);
            
            // 释放流
            os.flush();
            os.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    
    @Test
    public void objectInputStream() { // 反序列化出来
        // java.io.NotSerializableException: java.lang.Object
        // 异常就是被序列化的对象没有实现Serializable接口
        try {
            // 创建一个对象流程
            ObjectInputStream os = new ObjectInputStream(new FileInputStream(new File("D:/a/b/c/d/object.txt")));
            
            // 反序列化文件内容
            try {
                //System.out.println(os.readObject());
                Object obj = os.readObject();
                
                if (obj instanceof Cat) {
                    Cat cat = (Cat) obj;
                    System.out.println(cat.getName());
                }
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }
            
            // 释放流
            os.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

package com.stream.demo.sup;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.Arrays;
import java.util.List;

import org.junit.Test;

import com.stream.demo.sup.entity.Cat;

/**
 * 串行化流/对象流操作实例
 * @author Administrator
 *
 */
public class ObjectStreamDemo1 {
    
    @Test
    public void objectOutputStream() {
        // java.io.NotSerializableException: java.lang.Object
        // 异常就是被序列化的对象没有实现Serializable接口
        try {
            // 创建一个对象流程
            ObjectOutputStream os = new ObjectOutputStream(new FileOutputStream(new File("D:/a/b/c/d/objects.txt")));
            // 创建一个Cat对象
            Cat cat1 = new Cat();
            cat1.setAge(4);
            cat1.setName("咖啡猫1");
            cat1.setSex("母");
            
            Cat cat2 = new Cat();
            cat2.setAge(4);
            cat2.setName("咖啡猫2");
            cat2.setSex("公");
            
            Cat cat3 = new Cat();
            cat3.setAge(4);
            cat3.setName("咖啡猫3");
            cat3.setSex("母");
            
            List<Cat> list = Arrays.asList(cat1,cat2,cat3);
            
            // 序列化一个对象到文件中
            os.writeObject(list);
            
            // 释放流
            os.flush();
            os.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    
    @Test
    public void objectInputStream() { // 反序列化出来
        // java.io.NotSerializableException: java.lang.Object
        // 异常就是被序列化的对象没有实现Serializable接口
        try {
            // 创建一个对象流程
            ObjectInputStream os = new ObjectInputStream(new FileInputStream(new File("D:/a/b/c/d/objects.txt")));
            
            // 反序列化文件内容
            try {
                //System.out.println(os.readObject());
                Object obj = os.readObject();
                
                if (obj instanceof List) {
                    List<Cat> catList = (List<Cat>) obj;
                    for (Cat cat : catList) {
                        System.out.println(cat.getName());
                    }
                }
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }
            
            // 释放流
            os.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}