zoukankan      html  css  js  c++  java
  • 文件操作,文件字节流,字符流操作,字节缓存流,字符缓存流

    文件操作
    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();
            }
        }
    }
  • 相关阅读:
    poj 1088 滑雪
    位运算与bitset
    hdu 4607 Park Visit
    树的直径
    codeforces 495D Sonya and Matrix
    German Collegiate Programming Contest 2015(第三场)
    BAPC 2014 Preliminary(第一场)
    Benelux Algorithm Programming Contest 2014 Final(第二场)
    E. Reachability from the Capital(tarjan+dfs)
    poj2104 K-th Number(划分树)
  • 原文地址:https://www.cnblogs.com/sunBinary/p/10507550.html
Copyright © 2011-2022 走看看