逸学java【初级菜鸟篇】10.I/O（输入/输出）

程序员逸尘

已于 2024-02-08 14:52:13 修改

阅读量1k

点赞数 17

分类专栏：逸学JAVA java 基础文章标签： java 开发语言

于 2023-11-25 09:43:41 首次发布

本文链接：https://blog.csdn.net/m0_59337285/article/details/134574425

版权

java 同时被 3 个专栏收录

22 篇文章 1 订阅

订阅专栏

逸学JAVA

21 篇文章 0 订阅

订阅专栏

基础

13 篇文章 0 订阅

订阅专栏

hi，我是逸尘，一起学java吧

目标（任务驱动）

1.请重点的掌握I/O。

场景：最近你在企业也想搞一个短视频又想搞一个存储的云盘，你一听回想到自己对于这些存储的基础还不是很清楚，于是回家开始了复习基础。

我们前面学习了变量，数组，集合，但是我们发现那些都是暂时存在的，一旦关闭电脑或者程序，那么就会空空如也。那么我们想要不丢失文件，永久的存储程序创建的数据，就需要保存到磁盘中，也就是内存数据存储到磁盘文件中，我们也称之为持久化。我们可以使用java的I/O技术将数据保存到文本，二进制文件，甚至是zip压缩包中，达到永久保存。

流

流是一组有序的数据序列（我们之前的Stream是处理流，不是这个流。）

可以理解为在计算机中两个不同位置之间建立的一个通道·，该通道用于传输数据。

输入输出流

我们根据流操作的正反方向划分，我们可以分为输入和输出流两种。

如果我们想对象序列化，程序内容对象到磁盘等外部，我们是输出流，正向的。

ps;我们以程序为根本（锚点）外部为目标判断方向，所以是输出

反而言之就是输入流，反向的。

虽然说I/O流通常是与磁盘文件存取有关，但是也可以是鼠标键盘内存或者显示器为目的地/源。

字符字节流

我们在最开始的章节学习了，计算机底层存储只能是二进制的，字节（Byte）是二进制数据的单位，一个字节存储8位无符号数，我们也学习了字符集，在不同的编码方式下，一个字符占的字节可能不一样，以UTF-8的编码来看，中文一般占三个字节。

我们根据数据单位规格来区分又可以分为字符流和字节流。

总结

那么根据这些划分的不同，我们可以整理一下IO流体系

I/O流体系

我们的字节流可以做一切的文本数据拷贝，但是不适合读文本内容，涉及到处理字符文本我们优先考虑字符流（英文一个字节还好说，但是中文不是，那么就适合直接使用字符为单位处理）。

一些方法

读的API

写的API

File类

我们介绍了，I/O流，我们发现需要获取文件，文件夹在磁盘的定位，用来获取或者删除，或者其他操作信息。在java中，我们有File类定义了一些用来操作文件的方法。

它有三种常用的构造方法

相对路径和绝对路径

绝对路径：以windows操作系统为例，包括盘符在内的文件或文件目录的完整路径，固定的位置。

或者可以右键鼠标的属性找到

相对路径：相对于某一个文件目录来讲的相对的位置，它是依靠一个文件作为一个定位。
在idea中，如果使用单元测试方法：相对于当前的module来讲
如果使用main()方法：相对于当前的project来讲

创建一个文件

package com.yd.yc;

import java.io.File;

public class FileOne {
    public static void main(String[] args) {
        //注意绝对路径名前要用\\ 而不是\
        // "/" 分隔符，"\" 转义字符
//        File file = new File("D:\\aaa.txt");
        File file = new File("D:/aaa.txt");
        //相对路径请按照自己项目
//        File file = new File("src\\com\\yd\\yc\\8888.txt");
        if (file.exists()){
            file.delete();
            System.out.println("文件删除");
        }else{
            try {
                file.createNewFile();
                System.out.println("文件已创建");
            }catch (Exception e){
                e.printStackTrace();
            }

        }



    }
}

有的朋友相对路径不正确，看看自己的运行工作目录

需要注意一下的是在运行配置地址

工作目录要注意一下

常见的其他File的一些API

需要注意一下

还有一个

public file[] listfiles()

获取当前目录下所有的"一级文件对象"到一个文件对象数组中去返回

package com.yd.yc;

import java.io.File;

public class FileTwo {
    public static void main(String[] args) {
        File file = new File("src\\com\\yd\\yc");
        File fileOne = new File("src\\com\\yd\\yc\\www");
        if (file.exists()){
            //创建一个一级文件夹
            fileOne.mkdir();
            String name = file.getName();//获取文件名称
            file.length();//获取文件长度
            file.isHidden();//是否是隐藏文件
            file.lastModified();//最后修改文件的时间
            File[] files = file.listFiles();//获取文件目录西安
            for (File o:  files){
                System.out.println(o.getName());
            }
            System.out.println("文件夹名称 "+name);
        }else{
            System.out.println("文件不存在");
        }

    }
}

输入输出字节流

回到我们的I/O流，我们在字节流中有两个实现类FileInputStream和FileOutPutStream接下来我们要介绍一下这两个类

FileInputStream和FileOutPutStream

这两个类分别提供了操作磁盘文件的读和写的能力（相对简单的读文件可以使用FileInputStream）

示例一读写操作

package com.yd.yc;

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

public class IoOne {
    public static void main(String[] args) {
        File file = new File("src\\com\\yd\\yc\\8888.txt");
        try {
            //写
            //创建一个字节输出流
            FileOutputStream out = new FileOutputStream(file);
            //字节  内存对象数据
            //String的getBytes()方法是得到一个操作系统默认的编码格式的字节数组。
            byte[] buy="家人们谁懂呀，我真的要无语死了".getBytes();
            //FileOutputStream的写方法
            out.write(buy);
            //关闭字节流
            out.close();

            //读
            //创建一个字节输入流
            FileInputStream in = new FileInputStream(file);
            //缓存字节数组,如果不够中文是三个字节，4个字节会乱码一个
            byte[] buffer=new byte[4];
            //FileInputStream的写方法
            int read = in.read(buffer);
            System.out.println(new String(buffer,0,read));
            
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

示例二拷贝资源

/**
 * 拷贝资源
 */

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

public class CopyDemo {
    public static void main(String[] args) {
        //创建一个字节输入流管道(接入原视频)
        try {
            FileInputStream is = new FileInputStream("C:\\迅雷云盘\\b站\\666.flv");
        //接通目标(复制)
            FileOutputStream os = new FileOutputStream("one/src/new.flv");
        //定义一个字节数组转移数据
            byte[] buffer=new byte[1024];
            int len;//记录读取字节数
            while ((len=is.read(buffer))!=-1){
                os.write(buffer,0,len);
            }
            System.out.println("复制完毕");
            os.close();
            is.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

输入输出字符流

FileReader和FileWriter

字符流中有Reader抽象类是输入流处理字符的简化，Writer也是输出流的字符简化，他们对应的两个实现类FileReader和FileWriter，接下来我们要介绍一下这两个类

字符流读取文本特别是中文不会出现乱码的情况，但是性能比较慢

package com.yd.yc;

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

public class IoTwo {
    public static void main(String[] args) throws IOException {
        //写出，程序输出流,创建一个字符输出流的管道
        FileWriter fileWriterOne = new FileWriter("src\\com\\yd\\yc\\8888.txt");
        //源数据
        String word="大江东去浪淘尽";
        fileWriterOne.write(word);
        fileWriterOne.close();

        //读，程序输入流
        FileReader fileReaderOne = new FileReader("src\\com\\yd\\yc\\8888.txt");
        //缓存字符数组
        char[] buffer = new char[1024];
        int len;
        //读入（放入）缓存数组中,      如果读完就返回-1，没读完继续
        //buffer中可能就有[大江东去浪淘尽]
        while ((len=fileReaderOne.read(buffer))!=-1){
            String s = new String(buffer, 0, len);
            System.out.println(s);

        }
        fileReaderOne.close();
    }
}

总结一下

高级流

在之前我们所学的是基础流，我们接下来学习高级流，需要注意的是高级流是要包装低级流的

缓冲流

我们之前学习的流都是属于基础流，性能其实不是最好的，缓冲流读写数据的性能会更好一些。
缓冲流也称为高效流或者高级流。之前学习的字节流可以称为原始流。缓冲流自带缓冲区，以提高原始字节流，字符流读写数据的性能。

字节缓冲流性能优化原理：
字节缓冲输入流自带了8kb缓冲池，以后我们直接从缓冲池读取数据，所以性能较好。
字节缓冲输出流自带了8kb缓冲池，数据就直接写入到缓冲池中去，写数据性能极高了。

package com.yd.yc;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;

public class IoSix {
    public static void main(String[] args) throws Exception {
        File file = new File("src\\com\\yd\\yc\\8888.txt");
        //低级流
        FileReader fileReader = new FileReader(file);
        //包装低级流
        BufferedReader bufferedReader = new BufferedReader(fileReader);
        String len;
       //readLine读取一行数据，一行无了就返回null
        while ((len=bufferedReader.readLine())!=null){
            System.out.println(len);
        }
        bufferedReader.close();
    }
}

对象序列化与反序列化

那么学习流的其他内容，我们先谈谈序列化

序列化不一定要持久化，但是序列化为持久化做了格式的处理

与之相反还有反序列化，我们将磁盘中的对象数据恢复到内存对象中。

对象字节输出流objectoutputstram，在实现序列化对象的要求是对象必须实现序列化接口，

implements Serializable

对象反序列化用到了对象字节输入流objectlnputstram 类方法是 public object readobject()

package com.yd.yc;

import java.io.*;

public class IoFive {
    public static void main(String[] args) throws Exception {
        Employee employee = new Employee("小尘", 40, 1111, "男", "环卫工");
        File file = new File("src\\com\\yd\\yc\\999.txt");
        //字节输出流，管道
        FileOutputStream fileOutputStream = new FileOutputStream(file);
        //对象序列化，管道包装成高级流,高级输出流
        ObjectOutputStream objectOutputStream = new ObjectOutputStream(fileOutputStream);
        //调用序列化方法
        objectOutputStream.writeObject(employee);
        //释放资源
        objectOutputStream.close();
        System.out.println("序列化完成");

        //低级流 输入流 对程序输入
        FileInputStream inputStream = new FileInputStream(file);
        //变成高级流
        ObjectInputStream objectInputStream = new ObjectInputStream(inputStream);
        //方法读
        Object o = objectInputStream.readObject();
        System.out.println(o);

    }
}

打印流

打印流一般是指：printstream,printWrite两个类，该对象具有特有的方法，print println可以打印任何数据类型的数据。

特有的printf方法可以保持任意类型的数据表现形式的原样性，将数据输出到目的地（而Out

putStream父类中的write是将数据的字节写出去）

可以实现打印什么数据就是什么数据。

什么时候用？当需要保证数据表现的原样性时，就可以使用打印流的打印方法来完成，保证（表现形式）原样性的原理：其实就是将数据变成字符串，再进行写入操作。

package com.yd.yc;

import java.io.FileNotFoundException;
import java.io.PrintWriter;

public class IoSeven {
    public static void main(String[] args) throws FileNotFoundException {
        //1.创建打印流
        PrintWriter pw=new PrintWriter("src\\com\\yd\\yc\\8888.txt");
        //2.打印
        pw.println(97);
        pw.println(true);
        pw.println(3.14);
        pw.println('a');
        pw.flush();
        //3.关闭
        pw.close();
        System.out.println("打印完毕");

    }

}

转换流

如果我们的代码和文件编码不一致，字符流读取会乱码，这个时候需要我们的转换流。

我们先获取原有的字节流，使用转化流且参数可以指定编码，这样就不会乱码了。

package com.yd.yc;

import java.io.*;

public class IoSeven {
    public static void main(String[] args) throws Exception {
        //1.创建字节输出流
        OutputStream ot = new FileOutputStream("src\\com\\yd\\yc\\8888.txt");
        //2.转换流
        OutputStreamWriter ott = new OutputStreamWriter(ot,"UTF-8");
        //3.再用缓冲流包装一下
        BufferedWriter otts = new BufferedWriter(ott);

        otts.write("我爱我的祖国");
        otts.close();
    }

}

数据输入/输出流

DataInputStream类与DataOutputStream类允许程序以机器无关的方式从底层输入输出流中读取基本的java数据类型。（读取一个数据不必关心是那种字节）

或者说

DataOutputStream数据输出流允许应用程序将基本Java数据类型写到基础输出流中,

而DataInputStream数据输入流允许应用程序以机器无关的方式从底层输入流中读取基本的Java类型.

构造函数如下

DataInputStream(InputStream in):使用基础的inputstream对象创建一个DataInputStream对象

DataOutputStream（outputStream out）：创建一个新的数据输出流，将数据写入指定基础输出流。

DataOutputStream类提供将字符串，double，int，bolean数据写入文件的方法。

对字符串有三种处理,writeBytes(String s) writeChars(String s) writeUTF(String s)

java的字符是unicoede编码，是双字节的，writeByte是只将字符中每个字符的低字节内容写入目标，writeChars是将字符每一个字符的两个字节写入，writeUTF是将字符串按照utf编码以后字节长度写入。

DataInputStream类只提供readUTF方法返回字符串，当然也只用writeUTF方法将目标设备写入字符串的长度，才可以精准的读回字符串。

public class DataOutAndInStreamDemo {
  public static void main(String[] args) throws IOException {
    DataOutputStream dos = new DataOutputStream(new FileOutputStream("D:\\java.txt"));
    dos.writeUTF("α");
    dos.writeInt(1234567);
    dos.writeBoolean(true);
    dos.writeShort((short)123);
    dos.writeLong((long)456);
    dos.writeDouble(99.98);
    DataInputStream dis = new DataInputStream(new FileInputStream("D:\\java.txt"));
    System.out.println(dis.readUTF());
    System.out.println(dis.readInt());
    System.out.println(dis.readBoolean());
    System.out.println(dis.readShort());
    System.out.println(dis.readLong());
    System.out.println(dis.readDouble());
    dis.close();
    dos.close();
  }
}