javase-io-210509-01

最新推荐文章于 2024-08-19 17:55:12 发布

原创最新推荐文章于 2024-08-19 17:55:12 发布 · 180 阅读

0 ·

CC 4.0 BY-SA版权

白光一

文章标签：

#java #javase #流处理

javase 专栏收录该内容

29 篇文章

订阅专栏

本文详细介绍了 Java 中的 IO 流操作，包括字符流 FileReader 和 FileWriter 的使用方法，以及如何利用 BufferedReader 和 BufferedWriter 进行高效的读写操作。此外，还介绍了 DataInputStream 和 DataOutputStream 如何实现不同类型的数据读写。

javase-io-210509-01

FileReader
FileWriter
拷贝
BufferedReader
InputStreamReader
BufferedWriter
DataOutputStream
DataInputStream
PrintStream

FileReader

文件字符输入流，只能读取普通文本

读取文本内容，比较方便，快捷

Demo01

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

public class Demo01 {
    public static void main(String[] args) {
        FileReader reader = null;

        try {
            // 创建文件字符输入流
            reader = new FileReader("file");

            // 读
            // 一次读取四个字符
//            char[] chars = new char[4];
//            int readCount = 0;
//            while ((readCount = reader.read(chars)) != -1){
//                System.out.println(new String(chars,0,readCount));
//            }

            // 也可以这样读
            char[] chars = new char[4];
//            int readCount = reader.read(chars);
//            /*
//                按照字符的方式读取，第一次读取a,第二次读取b,第三次读取c,第四次读取d
//             */
//            for (char c : chars){
//                System.out.println(c);
//            }
            int readCount = 0;
            while ((readCount = reader.read(chars)) != -1){
                for (char c : chars){
                    System.out.println(c);
                }
            }


        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (reader != null) {
                try {
                    reader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

FileWriter

文件字符输出流，写，内存------->硬盘

只能输出普通文本

Demo01.java

import java.io.FileWriter;
import java.io.IOException;

public class Demo01 {
    public static void main(String[] args) {
        FileWriter writer = null;

        try {
            // 创建输出流对象
            /*
                writer = new FileWriter("myfile");
                    会清空内容，在写入

                writer = new FileWriter("myfile",true);
                    在原来的内容上追加，不会清空
             */
            writer = new FileWriter("myfile",true);

            // 写
            char[] chars = {'白','光','一'};
            writer.write(chars);
            writer.write("\n");
            writer.write("你好");

            // 刷新，，，不要忘了
            writer.flush();

        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (writer != null) {
                try {
                    writer.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

拷贝

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

public class CopyFile {
    public static void main(String[] args) {
        FileReader reader = null;
        FileWriter writer = null;

        try {
            // 创建输出流，输入流
            reader = new FileReader("file");
            writer = new FileWriter("copyfile");

            char[] chars = new char[4];
            int readCount = 0;

            while ((readCount = reader.read(chars)) != -1){
                writer.write(chars,0,readCount);
            }

            // !!!!! 不要忘记刷新  !!!!!
            writer.flush();

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (writer != null) {
                try {
                    writer.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (reader != null) {
                try {
                    reader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

    }
}

BufferedReader

带有缓冲区的字符输入流

使用这个流，不需要自定义char数组，或者说不需要自定义byte数组，自带缓冲区

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

public class Demo01 {
    public static void main(String[] args) {
        FileReader reader = null;
        BufferedReader br = null;
        try {
            /*
                对于当前程序
                    BufferedReader  包装流 / 处理流
                    FileReader      节点流
             */
            // 创建包装流
            reader = new FileReader("file01");
            br = new BufferedReader(reader);

//            // 读取第一行
//            String firstLine = br.readLine();
//            System.out.println(firstLine);
//            // 读取第二行
//            String secondLine = br.readLine();
//            System.out.println(secondLine);

            // readLine()方法读取一行文本，，但是不带换行符
            String s = null;
            while ((s = br.readLine()) != null){
                System.out.println(s);
            }

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {

            // 只需要关闭包装流即可
            if (br != null) {
                try {
                    br.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

InputStreamReader

import java.io.*;

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

        // 创建一个字节流
        FileInputStream fis = new FileInputStream("file01");

        /*
            通过  InputStreamReader  转换流 ，，将字节流转换为字符流
            fis是节点流
            reader是包装流
         */
        InputStreamReader reader = new InputStreamReader(fis);


        /*
            这个 BufferedReader 构造方法，只能传字符流，不能传字节流
            reader是节点流
            br是包装流
         */
        
        // 也可以写一行
        BufferedReader br01 = new BufferedReader(new InputStreamReader(new FileInputStream("file01")));
        
        // 也可以分开写
        BufferedReader br = new BufferedReader(reader);
        String line = null;
        while ((line = br.readLine()) != null){
            System.out.println(line);
        }

        // 关闭最外层流
        br.close();
    }
}

BufferedWriter

带有缓冲区的字符输出流

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;

public class Demo02 {
    public static void main(String[] args) throws IOException {
//        // 追加
//        BufferedWriter out = new BufferedWriter(new FileWriter("file02",true));
        BufferedWriter out = new BufferedWriter(new FileWriter("file02"));
        out.write("hello");
        out.write("\n");
        out.write("bgy");

        // 刷新
        out.flush();

        // 关闭最外层流
        out.close();
    }
}

DataOutputStream

数据专属流

这个流可以将数据连同数据类型一并写入文件

普通文件文档，这个文件不是普通文档，这个文档使用记事本打不开

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

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

        // 创建数据专属字节输出流
        DataOutputStream dos = new DataOutputStream(new FileOutputStream("data"));

        // 写
        byte b = 111;
        short s = 222;
        int i = 333;
        long l = 444L;
        float f = 5.5F;
        double d = 6.66;
        char c = 'a';

        // 把数据以及数据类型一并写入文件中
        dos.writeByte(b);
        dos.writeShort(s);
        dos.writeInt(i);
        dos.writeLong(l);
        dos.writeFloat(f);
        dos.writeDouble(d);
        dos.writeChar(c);

        // 刷新
        dos.flush();

        // 关闭流
        dos.close();
    }
}

DataInputStream

/*
    DataOutputStream 写的文件，只能使用 DataInputStream去读，并且读的时候你需要提前知道写入的顺序
    读的顺序和写的顺序一样，才能取出数据
    例如Demo1 ；
        dos.writeByte(b);
        dos.writeShort(s);
        dos.writeInt(i);
        dos.writeLong(l);
        dos.writeFloat(f);
        dos.writeDouble(d);
        dos.writeChar(c);
   这样写，读的时候也必须这样来读
 */

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

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

        // 创建输入流
        DataInputStream dis = new DataInputStream(new FileInputStream("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();
        char c = dis.readChar();

        System.out.println(b);
        System.out.println(s);
        System.out.println(i);
        System.out.println(l);
        System.out.println(f);
        System.out.println(d);
        System.out.println(c);

        // 关闭流
        dis.close();
    }
}

PrintStream

标准的字节输出流，默认输出到控制台

java.io.PrintStream

Demo01.java

package com.bgy06;

/*
        标准输出流不需要关闭
        可以改变输出方向，，比如指向一个文件
 */
import java.io.*;
public class Demo01 {
    public static void main(String[] args) throws FileNotFoundException {

        System.out.println("hello,bgy");

        PrintStream ps = System.out;
        ps.println("hello,bgy01");
        ps.println("hello,bgy02");
        ps.println("hello,bgy03");

//        标准输出流不需要关闭

        // 可以改变输出方向，，比如指向一个文件
        PrintStream printStream = new PrintStream(new FileOutputStream("log"));
        // 修改输出方向，将输出方向修改到‘log’文件
        System.setOut(printStream);
        // 输出
        System.out.println("001");
        System.out.println("002");
        System.out.println("003");
    }
}

Logger.java

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

public class Logger {
    /*
        记录日志
     */

    public static void log(String msg) {
        try {
            // 指向一个日志文件
            PrintStream ps = new PrintStream(new FileOutputStream("log.txt",true));
            // 改变输出方向
            System.setOut(ps);
            // 当前日期
            Date nowTime = new Date();
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS");
            String strTime = sdf.format(nowTime);

            System.out.println(strTime+":"+msg);

            ps.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
    }
}

TestLogger.java

public class TestLogger {
    public static void main(String[] args) {
        Logger.log("用户尝试进行登录，登录失败");
        Logger.log("用户恶意评论");
    }
}