JavaSE学习笔记21：IO流（二）

IO流（二）

缓冲流（了解）

BufferedReader

package se4.io;

import java.io.BufferedReader;
import java.io.FileReader;
/**
 * BUfferedReader：
 *  带有缓冲区的字符输入流
 *  使用这个流的时候不需要自定义char数组，或者说不需要自定义byte数组。自带缓冲。
 */
public class BufferedReaderTest01 {
    public static void main(String[] args) throws Exception {
        FileReader reader = new FileReader("E:\\学习资料\\老杜Java系列\\File\\tempfile.txt");
        //当一个流的构造方法中需要一个流的时候，这个被传进来的流叫做：节点流
        //外部负责包装的这个流，叫做：包装流，还有一个名字叫做：处理流
        //像当前这个程序来说：FileReader就是一个节点流。BufferedReader就是包装流/处理流
        BufferedReader br = new BufferedReader(reader);
        /*
        //读一行
        String firstLine = br.readLine();
        System.out.println(firstLine);

        String secondLine = br.readLine();
        System.out.println(secondLine);

        String line3 = br.readLine();
        System.out.println(line3);
        */

        String s = null;
        while ((s = br.readLine()) != null){
            System.out.println(s);
        }
        /**
         * 输出内容：
         * public class Test01 {
         *     public static void main(String[] args) {
         *         System.out.println("Hello World!");
         *     }
         * }
         * 注：tempfile.txt文件的内容就是以上的内容
         */

        //关闭流
        //对于包装流来说，只需要关闭最外层流就行，里面的节点流会自动关闭（可以看源代码）
        br.close();
    }
}

转换流（了解）

InputStreamReader

package se4.io;

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.InputStreamReader;
/**
 * 转换流：InputStreamReader
 */
public class BufferedReaderTest02 {
    public static void main(String[] args) throws Exception {
        //字节流
        //FileInputStream in = new FileInputStream("E:\\学习资料\\老杜Java系列\\File\\tempfile.txt");
        //通过转换流转换(InputStreamReader将字节流转换成字符流)
        //in是节点流。reader是包装流。
        //InputStreamReader reader = new InputStreamReader(in);
        //这个构造方法只能传一个字符流，不能传字节流。
        //reader是节点流。br是包装流。
        //BufferedReader br = new BufferedReader(reader);

        //合并（极致套娃~）
        BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream("E:\\学习资料\\老杜Java系列\\File\\tempfile.txt")));

        String line = null;
        while ((line = br.readLine()) != null){
            System.out.println(line);
        }
        /**
         * 输出结果：
         * public class Test01 {
         *     public static void main(String[] args) {
         *         System.out.println("Hello World!");
         *     }
         * }
         */
        //关闭最外层
        br.close();
    }
}

OutputStreamWriter

package se4.io;

import java.io.BufferedWriter;
import java.io.FileOutputStream;
import java.io.OutputStreamWriter;
/**
 * BufferedWriter:带有缓冲的字符输出流
 */
public class BufferedWriterTest {
    public static void main(String[] args) throws Exception {
        //带有缓冲区的字符输出流
        //BufferedWriter out = new BufferedWriter(new FileWriter("E:\\学习资料\\老杜Java系列\\File\\myfile.txt"));
        BufferedWriter out = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("E:\\学习资料\\老杜Java系列\\File\\myfile.txt",true)));
        //开始写
        out.write("hello world!");
        out.write("\n");
        out.write("hello kitty!");
        //刷新
        out.flush();
        //关闭最外层
        out.close();
    }
}

数据流（了解）

DataOutputStream

package se4.io;

import java.io.DataOutputStream;
import java.io.FileOutputStream;
/**
 * java.io.DataOutputStream：数据专属的流
 * 这个流可以将数据连同数据的类型一并写入文件
 * 注意：这个文件不是普通文本文档（这个文件使用记事本打不开）
 */
public class DataOutputStreamTest {
    public static void main(String[] args) throws Exception {
        //创建数据专属的字节输出流
        DataOutputStream dos = new DataOutputStream(new FileOutputStream("E:\\学习资料\\老杜Java系列\\File\\data"));
        //写数据
        byte b = 100;
        short s = 200;
        int i = 300;
        long l = 400L;
        float f = 3.0F;
        double d = 3.14;
        boolean sex = false;
        char c = 'a';
        //写
        dos.writeByte(b);
        dos.writeShort(s);
        dos.writeInt(i);
        dos.writeLong(l);
        dos.writeFloat(f);
        dos.writeDouble(d);
        dos.writeBoolean(sex);
        dos.writeChar(c);
        //刷新
        dos.flush();
        //关闭
        dos.close();
        /**
         * 记事本打开如下：
         * d ?  
,      
怈@  @ 窺雲  a
         */
    }
}

DataInputStream

package se4.io;

import java.io.DataInputStream;
import java.io.FileInputStream;
/**
 * DataInputStream：数据字节输入流
 * DataOutputStream写的文件，只能使用DataInputStream去读，并且读的时候需要提前知道写入的顺序
 * 读的顺序需要和写的顺序一样，才可以正常取出数据
 */
public class DataInputStreamTest {
    public static void main(String[] args) throws Exception {
        DataInputStream dis = new DataInputStream(new FileInputStream("E:\\学习资料\\老杜Java系列\\File\\data"));
        //开始读
        byte b = dis.readByte();
        short s = dis.readShort();
        int i = dis.readInt();
        long l = dis.readLong();
        float f = dis.readFloat();
        double d = dis.readDouble();
        boolean sex = dis.readBoolean();
        char c = dis.readChar();

        System.out.println(b);
        System.out.println(s);
        System.out.println(i + 1000);
        System.out.println(l);
        System.out.println(f);
        System.out.println(d);
        System.out.println(sex);
        System.out.println(c);
        //关闭
        dis.close();
        /**
         * 输出结果：
         * 100
         * 200
         * 1300
         * 400
         * 3.0
         * 3.14
         * false
         * a
         */
    }
}

标准输出流

PrintStream

package se4.io;

import java.io.FileOutputStream;
import java.io.PrintStream;
/**
 * java.io.PrintStream：标准的字节输出流，默认输出到控制台
 */
public class PrintStreamTest {
    public static void main(String[] args) throws Exception {
        //联合起来写
        System.out.println("hello world!");
        //分开写
        PrintStream ps = System.out;
        ps.println("hello 张三");
        ps.println("hello 李四");
        ps.println("hello 王五");
        //标准输出流不需要手动close()关闭

        //可以改变标准输出流的输出方向吗？可以！
        /**
         * 这些是之前System类使用过的方法和属性
         * System.gc();
         * System.currentTimeMillis();
         * System.exit();
         * System.arraycopy();
         */
        //标准输出流不再指向控制台，指向log文件
        PrintStream printStream = new PrintStream(new FileOutputStream("E:\\学习资料\\老杜Java系列\\File\\log.txt"));
        //修改输出方向，将输出方向修改到log文件
        System.setOut(printStream);
        //再输出
        System.out.println("琴女");
        System.out.println("琴女36D");
        System.out.println("最爱琴女E");
        /**
         * hello world!
         * hello 张三
         * hello 李四
         * hello 王五
         * 依然会在控制台上输出，但下面的内容会不会输出到控制台上，而是输出到log.txt文件中了
         * 琴女
         * 琴女36D
         * 最爱琴女E
         */
    }
}

日志工具例子

package se4.io;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.PrintStream;
import java.text.SimpleDateFormat;
import java.util.Date;

/*
日志工具
 */
public class Logger {
    /*
    记录日志的方法
     */
    public static void log(String msg){
        try {
            //指向一个日志文件
            PrintStream out = new PrintStream(new FileOutputStream("E:\\学习资料\\老杜Java系列\\File\\logFile.txt",true));
            //改变输出方向
            System.setOut(out);
            //日期当前时间
            Date nowTime = new Date();
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SS");
            String strTime = sdf.format(nowTime);
            System.out.println(strTime + ": 发生了" + msg);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
    }
}

package se4.io;

public class LongTest {
    public static void main(String[] args) {
        //测试工具类是否好用
        Logger.log("调用了System类的gc()方法，建议启动垃圾回收器");
        Logger.log("调用了UserService的doSome()方法");
        Logger.log("用户尝试进行登录，验证失败");
        Logger.log("我非常喜欢这个记录日志的工具哦~");
        /**
         * 打开logFile.txt文件，内容如下：
         * 2020-11-13 16:01:21 64: 发生了调用了System类的gc()方法，建议启动垃圾回收器
         * 2020-11-13 16:01:21 98: 发生了调用了UserService的doSome()方法
         * 2020-11-13 16:01:21 99: 发生了用户尝试进行登录，验证失败
         * 2020-11-13 16:01:21 99: 发生了我非常喜欢这个记录日志的工具哦~
         */
    }
}

File类

File：

1. File类和四大家族没有关系，所有File类不能完成文件的读和写

2. FIle对象代表什么？
   文件和目录路径名的抽象表现形式
   E:\学习资料\老杜Java系列\File 这是一个File对象
   E:\学习资料\老杜Java系列\File\log.txt 也是一个File对象
   一个File对象有可能对应的是目录，也有可能是文件
   File只是一个路径名的抽象表现形式

3. 需要掌握File类中常用的方法

File类常用方法

package se4.file;

import java.io.File;

public class FileTest01 {
    public static void main(String[] args) throws Exception {
        //创建一个File对象
        File f1 = new File("E:\\学习资料\\老杜Java系列\\File\\file");
        //判断是否存在
        System.out.println(f1.exists());//不存在输出false，存在输出true

        //如果E:\学习资料\老杜Java系列\File\file不存在，则以文件的形式创建出来
        if (!f1.exists()){
            //以文件的形式新建
            f1.createNewFile();
        }

        File f2 = new File("E:\\学习资料\\老杜Java系列\\File\\Music");
        //如果E:\学习资料\老杜Java系列\File\Music不存在，则以目录的形式创建出来
        if (!f2.exists()){
            //以目录的形式新建
            f2.mkdirs();
        }

        //可以创建多重目录吗？可以！
        File f3 = new File("E:\\学习资料\\老杜Java系列\\File\\a\\b\\c\\d\\e\\f");
        if (!f3.exists()){
            //以多重目录的形式创建
            f3.mkdirs();
        }

        File f4 = new File("E:\\学习资料\\老杜Java系列\\File\\temp.txt");
        //获取文件的父路径
        String parentPath = f4.getParent();
        System.out.println(parentPath);//E:\学习资料\老杜Java系列\File
        //另一种方法，结果一样
        File parentFile = f4.getParentFile();
        System.out.println(parentFile);//E:\学习资料\老杜Java系列\File

        //获取文件的绝对路径
        File f5 = new File("copy.txt");
        System.out.println("相对路径：" + f5.getPath());//相对路径：copy.txt
        System.out.println("绝对路径：" + f5.getAbsolutePath());//绝对路径：E:\学习资料\老杜Java系列\Code\copy.txt
    }
}

package se4.file;

import java.io.File;
import java.text.SimpleDateFormat;
import java.util.Date;

/*
File类的常用方法
 */
public class FileTest02 {
    public static void main(String[] args) {
        File f1 = new File("E:\\学习资料\\老杜Java系列\\File\\个人博客地址.txt");
        //获取文件名
        System.out.println("文件名：" + f1.getName());//文件名：个人博客地址.txt

        //判断是否是一个目录
        System.out.println(f1.isDirectory());//false
        //判断是否是一个文件
        System.out.println(f1.isFile());//true

        //获取文件最后一次修改时间
        long haomiao = f1.lastModified();//这个毫秒是从1970年到现在的总毫秒数
        //将总毫秒数转换成日期
        Date time = new Date(haomiao);
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS");
        String strTime = sdf.format(time);
        System.out.println(strTime);//2020-11-13 14:29:56 694

        //获取文件大小
        System.out.println(f1.length());//85字节
    }
}

package se4.file;

import java.io.File;
/*
File中的ListFiles()方法
 */
public class FileTest03 {
    public static void main(String[] args) {
        //File[] listFiles()
        //获取当前目录下所有的子文件
        File f = new File("E:\\学习资料\\老杜Java系列\\File");
        File[] files = f.listFiles();
        //foreach
        for (File file : files){
            System.out.println(file.getAbsolutePath());//绝对路径
            //System.out.println(file.getName());文件名
        }
        /**
         * 输出结果：
         * E:\学习资料\老杜Java系列\File\a
         * E:\学习资料\老杜Java系列\File\data
         * E:\学习资料\老杜Java系列\File\file
         * E:\学习资料\老杜Java系列\File\log.txt
         * E:\学习资料\老杜Java系列\File\logFile.txt
         * E:\学习资料\老杜Java系列\File\Music
         * E:\学习资料\老杜Java系列\File\myfile.txt
         * E:\学习资料\老杜Java系列\File\myfile2.txt
         * E:\学习资料\老杜Java系列\File\temp.txt
         * E:\学习资料\老杜Java系列\File\tempfile.txt
         * E:\学习资料\老杜Java系列\File\个人博客地址.txt
         */
    }
}

目录拷贝例子

package se4.file;

import java.io.*;
/*
拷贝目录
 */
public class CopyAll {
    public static void main(String[] args) {
        //拷贝源
        File srcFile = new File("D:\\Python file");
        //拷贝目标
        File destFile = new File("E:\\学习资料\\老杜Java系列\\File");
        //调用方法拷贝
        copyDir(srcFile,destFile);
    }
    /**
     * 拷贝目录
     * @param srcFile 拷贝源
     * @param destFile 拷贝目标
     */
    private static void copyDir(File srcFile,File  destFile){
        if (srcFile.isFile()){
            //srcFile如果是一个文件的话，递归结束
            //是文件的时候需要拷贝
            FileInputStream in = null;
            FileOutputStream out = null;
            try {
                //读这个文件
                //D:\Python file\Hello World.py
                in = new FileInputStream(srcFile);
                //写到这个文件中
                //E:\学习资料\老杜Java系列\File\Python file\Hello World.py
                String path = (destFile.getAbsolutePath().endsWith("\\") ? destFile.getAbsolutePath()
                        : destFile.getAbsolutePath() + "\\") + srcFile.getAbsolutePath().substring(3);
                out = new FileOutputStream(path);
                //一边读一边写
                byte[] bytes = new byte[1024 * 1024];//一次复制1MB
                int readCount = 0;
                while ((readCount = in.read()) != -1){
                    out.write(bytes,0,readCount);
                }
                //刷新
                out.flush();
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                if (out != null) {
                    try {
                        out.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                if (in != null) {
                    try {
                        in.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
            return;
        }
        //获取源下面的子目录
        File[] files = srcFile.listFiles();
        for (File file : files){
            //获取所有文件的绝对路径（包括目录和文件）
            //System.out.println(file.getAbsolutePath());
            if (file.isDirectory()){
                //新建对应的目录
                //System.out.println(file.getAbsolutePath());
                //D:\Python file\1  源目录
                //E:\学习资料\老杜Java系列\File\Python file\1   目标目录
                String srcDir = file.getAbsolutePath();
                //System.out.println(srcDir.substring(3));//Python file\1
                String destDir = (destFile.getAbsolutePath().endsWith("\\") ? destFile.getAbsolutePath()
                        : destFile.getAbsolutePath() + "\\") + srcDir.substring(3);
                File newFile = new File(destDir);
                if (!newFile.exists()){
                    newFile.mkdirs();
                }
            }
            //递归调用
            copyDir(file,destFile);
        }
    }
}