javaSE--5 IO流

最新推荐文章于 2021-11-17 17:54:57 发布

╰ー幸运儿

最新推荐文章于 2021-11-17 17:54:57 发布

阅读量154

点赞数

分类专栏： java基础+javaSE

本文链接：https://blog.csdn.net/weixin_44116098/article/details/112221473

版权

java基础+javaSE 专栏收录该内容

12 篇文章 0 订阅

订阅专栏

一、什么是IO？

I：Input O：Output

通过IO可以完成硬盘文件的读和写

在这里插入图片描述

二、IO流的分类

有多种分类方式：

1.按照流的方向进行分类：

以内存为参照物，往内存中去，叫输入input（读）

从内存中出来，叫输出output（写）

2.按照读取数据方式不同进行分类：

①有的流是按照字节方式读取数据，一次读取一个字节byte，相当于一次读取8个二进制位

这种流是万能流，什么类型的文件都可以读取，包括：文本文件、图片、声音文件、视频文件等

②有的流是按照字符方式读取数据，一次读取一个字符，这种流是为了方便读取普通文本文件而存在，只能读取纯文本文件，连word文件都无法读取（word文档不是普通文本）

综上：流的分类：

输入流、输出流

字节流、字符流

三、java中流的主要研究方向

java中的IO流已经写好了，需要掌握java中提供了哪些流，每个流的特点是什么，每个流对象上的常用方法有哪些？

java所有的流都在java.io.*下

主要研究：

怎么new流对象

调用流对象的哪个方法是读，哪个方法是写

四、java中IO流的四大家族

java.io.InputStream 字节输入流

java.io.outputStream 字节输出流

java.io.Reader 字符输入流

java.io.Writer 字符输出流

注意：在java中只要“类名”以Stream结尾的都是字节流，以“Reader/Writer”结尾的都是字符流

特点：

都是抽象类

所有的流都实现了：

java.io.Closeable接口，都是可关闭的，都有close（）方法

流毕竟是一个管道，是内存和硬盘之间的通道，用完之后一定要关闭，不然会耗费很多资源

所有的输出流都实现了：

java.io.Flushable接口，都是可刷新的，都有flush方法

输出流在最终输出后，一定要flush（）刷新，刷新表示将通道/管道中剩余为输出的数据强行输出完（刷新的作用：清空管道）

注意：如果没有flush()可能会导致丢失数据

java.io包下需要掌握的流（16个）：

文件专属：

java.io.FileInputStream（掌握）

java.io.FileOutputStream（掌握）

java.io.FileReader

java.io.FileWriter

转换流：（将字节流转换成字符流）

java.io.InputStreamReader

java.io.OutputStreamWriter

缓冲流专属：

java.io.BufferedReader

java.io.BufferedWriter

java.io.BufferedInputStream

java.io.BufferedOutputStream

数据流专属：

java.io.DataInputStream

java.DataOutputStream

标准输出流：

java.io.PrintWriter

java.io.PrintStream（掌握）

对象专属流：

java.io.ObjectInputStream（掌握）

java.io.ObjectOutStream（掌握）

1.FileInputStream（重点掌握）

①字节的方式完成输入的操作：从硬盘到内存

//以下均采用了绝对路径的方式
//FileInputStream fis = new FileInputStream("F:\\java\\code\\tmp");
FileInputStream fis = new FileInputStream("F:/java/code/tmp");

IDEA默认的当前路径是工程Project的根

掌握：

/*
int read(byte[] b)
    一次最多读取b.length个字节
    减少硬盘和内存的交互，提高程序的执行效率
    在byte[]数组中读
 */
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class FileInputStreamTest04 {
    public static void main(String[] args) {
        FileInputStream fis = null;
        try {
            fis = new FileInputStream("IO/src/tmpfile");

            //准备byte数组
            byte[] bytes = new byte[4];
            /*while(true){
               int readCount = fis.read(bytes);
               if (readCount == -1){
                   break;
               }
               //把字符数组转成字符串
                System.out.print(new String(bytes,0,readCount));
            }*/

            int readCount = 0;
            while((readCount = fis.read(bytes)) != -1){
                System.out.print(new String(bytes,0,readCount));
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if (fis != null) {
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

available方法：返回流中剩余的没有读到的字节数量

int available();

 fis = new FileInputStream("IO/src/tmpfile");

            System.out.println("总字节数量：" + fis.available());
            //读1个字节
            //int readByte = fis.read();
            //还剩下可以读的字节数量：5
            //System.out.println("剩下多少个字节没有读：" + fis.available());
            //这个方法有什么作用？
            byte[] bytes = new byte[fis.available()];//这种方式不适合太大的文件，因为byte[]数组不能太大
            //不需要循环，直接读一次即可
            int readCount = fis.read(bytes);
            System.out.println(new String(bytes));

跳跃skip：跳过几个字节不读取

long skip(long n);

2.FileOutputStream输出流（重点掌握）

//以追加的方式在文件末尾写入，不会清空原文件内容
 fos = new FileOutputStream("myfile",true);

FileOutputStream fos = null;
        try {
            //fos = new FileOutputStream("myfile");

            //以追加的方式在文件末尾写入，不会清空原文件内容
            fos = new FileOutputStream("myfile",true);
            //开始写
            byte[] bytes = {97,98,99,100};
            //将byte数组全部写出
            fos.write(bytes);//abcd
            //将byte数组的一部分写出
            fos.write(bytes,0,2);//再写出ab

            //写完之后，最后一定要刷新

            fos.flush();

3.文件复制

使用FileInputStream+FileOutputStream完成文件的拷贝

拷贝的过程应该是一边读，一边写

使用以上的字节流拷贝文件时，文件类型随意，万能的，什么样的文件都可拷贝

try {
            //创建一个输入流对象
            fis = new FileInputStream("");
            //创建一个输出流对象
            fos = new FileOutputStream("");

            //最核心的：一边读，一边写
            byte[] bytes = new byte[1024*1024];
            int readCount = 0;
            while((readCount = fis.read(bytes)) != -1){
                fos.write(bytes,0,readCount);
            }
            
            //刷新
            fos.flush();

4.FileReader

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

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

char数组

FileReader reader = null;
        try {
            reader = new FileReader("myfile");
            //开始读
            char[] chars = new char[4];//一次读取4个字符
            int readCount = 0;
            while ((readCount = reader.read(chars)) != -1){
                System.out.print(new String(chars,0,readCount));
            }

遍历：

//准备一个char数组
char[] chars = new char[4];
//往char数组中读
reader.read(chars);//按照字符的方式读取
for (char c:chars){
	System.out.println(c);
}

5.FileWriter

文件字符输出流，写

只能输出普通文本

 //创建文件字符输出流对象
            out = new FileWriter("file");
            //开始写
            char[] chars = {'我','是','中','国','人'};
            out.write(chars);
            out.write(chars,2,3);

            //刷新
            out.flush();

FileReader in = null;
        FileWriter out = null;
        try {
            //读
            in = new FileReader("file");

            //写
            out = new FileWriter("file1");
            //边读边写
            char[] chars = new char[1024*512];//1MB
            int readCount = 0;
            while ((readCount = in.read(chars)) != -1){
                out.write(chars,0,readCount);
            }

            //刷新
            out.flush();

6.BufferedReader

带有缓冲区的字符输入流

不需要指定byte或char数组，自带缓冲

//当一个流的构造方法中需要一个流时，这个被传进来的流叫做：节点流
        //外部负责包装的这个流，叫做：包装流，还有一个名字叫做：处理流
        //像当前程序来说，FileReader是节点流，BufferedReader是包装流/处理流

        FileReader reader = new FileReader("file");
        BufferedReader br = new BufferedReader(reader);

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

        String s = null;
        while((s = br.readLine()) != null){
            System.out.println(s);
        }

        //关闭流
        br.close();

节点流和包装流

public static void main (String[] args) throws Exception {

        //字节流
        FileInputStream in = new FileInputStream("file");
        //通过转换流转换(将字节流转换成字符流)
        //in是节点流，reader是包装流
        InputStreamReader reader = new InputStreamReader(in);

        //这个构造方法只能传一个字符流，不能传字节流
        //reader是节点流，br是包装流
        BufferedReader br = new BufferedReader(reader);

        String line = null;
        while((line = br.readLine()) != null){
            System.out.println(line);
        }

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

7.BufferedWriter

带有缓冲的字符输出流

OutputStreamWriter：转换流

public static void main(String[] args) throws Exception{
        //带有缓冲区的字符输出流
        //BufferedWriter out = new BufferedWriter(new FileWriter("copy"));
        BufferedWriter out = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("copy",true)));//true表示追加

        out.write("hello world");
        out.write("\n");
        out.write("hello ketty");
        //刷新
        out.flush();
        //关闭
        out.close();
    }

8.数据流（了解）

可以将数据连同数据的类型一并写入文件

注意：这个文件不是普通文本文档（这个文件使用记事本打不开）

DataOutputStream写的文件，只能使用DataInputStream去读，且读的时候需要提前知道写入的顺序
读的顺序需要和写的顺序一致，才能正常取出数据

DataOutputStream：

public static void main(String[] args) throws Exception{
        DataOutputStream dos = new DataOutputStream(new FileOutputStream("data"));
        //写数据
        byte b = 100;
        short s = 200;
        int i = 300;
        long l = 400L;
        float f = 3.0F;
        boolean sex = false;
        char c = 'a';
        //写
        dos.writeByte(b);
        dos.writeShort(s);
        dos.writeInt(i);
        dos.writeLong(l);
        dos.writeFloat(f);
        dos.writeBoolean(sex);
        dos.writeChar(c);

        //刷新
        dos.flush();
        //关闭
        dos.close();
    }

DataInputStream：

public static void main(String[] args) throws Exception{
        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();
        boolean sex = dis.readBoolean();
        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(sex);
        System.out.println(c);
        System.out.println(b);
        dis.close();
    }

9.标准输出流

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

//联合起来写
        System.out.println("hello world!");

        //分开写
        PrintStream ps = System.out;
        ps.println("hello zhangsan");
        ps.println("hello lisi");
        ps.println("hello wangwu");

        //标准输出流不需要手动close（）关闭
        //可以改变标准输出流的输出方向吗？可以
        //标准输出流不再指向控制台，指向log文件
        PrintStream printStream = new PrintStream(new FileOutputStream("log"));
        //修改输出方向，将输出方向修改到log文件
        System.setOut(printStream);

        //再输出
        System.out.println("hello world");
        System.out.println("hello kitty");
        System.out.println("hello zhangsan");

/*
日志工具
 */
public class Logger {
    public static void log(String msg) {
        /*
        记录日志的方法
         */
        try {
            //标准输出流指向一个日志文件
            PrintStream out = new PrintStream(new FileOutputStream("log.txt",true));
            //改变输出方向
            System.setOut(out);
            //日期当前时间
            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);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
    }
}

public class LogTest {
    public static void main(String[] args) {
        //测试工具类
        Logger.log("调用了System类的gc()方法，建议启动垃圾回收");
        Logger.log("调用了UserService的doSome()方法");
        Logger.log("用户尝试进行登录，验证失败");
    }
}

五、File类

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

2.File对象代表什么？

文件和目录路径名的抽象表示形式

C:/Drivers 这是一个File对象

一个File对象有可能对应的是目录，也有可能是文件

File只是一个路径名的抽象表示形式

3.需要掌握File类中常用的方法
在这里插入图片描述

获得文件的大小
System.out.println(f1.length());

listFiles方法
在这里插入图片描述

六、目录拷贝

在这里插入图片描述

步骤：

拷贝源、拷贝目标

七、对象流中的序列化和反序列化

序列化：Serialize java对象存储到文件中，将java对象的状态保存下来的过程

反序列化：DeSerialize 将硬盘上的数据重新恢复到内存当中去，恢复成java对象
在这里插入图片描述

1.序列化

//序列化
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("students"));
//序列化对象
oos.writeObject(s);
//刷新
oos.flush();
//关闭
oos.close();

注意：

1.java.io.NotSerializableException：Student对象不支持序列化

2.参与序列化和反序列化的对象，必须实现Serializable接口

3.通过源代码发现，Serialzable接口只是一个标志接口：

public interface Serializable{}

这个接口中没有任何代码，

起到标识的作用，标志的作用，java虚拟机看到这个类实现了这个接口，可能会对这个类进行特殊待遇
在这里插入图片描述

2.反序列化

ObjectInputStream ois = new ObjectInputStream(new FileInputSream("students"));
//开始反序列化，读
Object obj = ois.readObject();
//反序列化回来时一个学生对象，所以会调用学生对象的toString方法
System.out.println(obj);
ois.close();

一次可以序列化多个对象吗？可以，可以得到对象放到集合中，序列化集合

提示：

参与序列化的ArrayList集合以及集合中的元素User都需要实现java.io.Serializable接口

序列化多个对象
在这里插入图片描述

3.transient关键字

此关键字修饰的是不参与序列化操作的

4.关于序列化版本号

八、IO和Properties联合使用

IO流：文件的读和写

Properties：是一个Map集合，key和value都是String类型
在这里插入图片描述
IO+Properties的联合应用：

非常好的一个设计理念：

以后经常改变的数据，可以单独写到一个文件中，使用程序动态读取

将来只需要修改这个文件的内容，java代码不需要改动，不需要重新编译，服务器也不需要重启，就可以拿到动态的信息

类似于以上机制的这种文件被称为配置文件，且当配置文件中的内容格式是：

key1 = value，key2 = value 的时候，我们把这种配置文件叫做属性配置文件

java规范中要求：属性配置文件建议以.properties结尾，但这不是必须的

这种以.properties结尾的文件在java中被称为：属性配置文件

其中Properties是专门存放属性配置文件内容的一个类

╰ー幸运儿

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
javaSE--5 IO流

一、什么是IO？ I：Input O：Output 通过IO可以完成硬盘文件的读和写二、IO流的分类有多种分类方式：1.按照流的方向进行分类：以内存为参照物，往内存中去，叫输入input（读）从内存中出来，叫输出output（写）2.按照读取数据方式不同进行分类： ①有的流是按照字节方式读取数据，一次读取一个字节byte，相当于一次读取8个二进制位这种流是万能流，什么类型的文件都可以读取，包括：文本文件、图片、声音文件、视频文件等 ②有的流是按照字
复制链接

扫一扫