Java中的IO

水深无声 2023-10-12 18:34 2阅读 0赞

**目录**

一.IO中的File类

1.1File类的简介

1.2File 类中的常用方法

二.输入流与输出流

2.1输入与输出的概念

2.2输入流与输出流

三.字节流的输入与输出

四.字符流的输入与输出

五.节点流与处理流

六.打印流

七.对象输入输出流--对象序列化

--------------------

## 一.IO中的File类 ##

### 1.1File类的简介 ###

Java中的File类是用来操作文件和目录的类，它提供了一些方法来创建、删除、重命名、移动文件和目录等功能。

File类的常用方法：

1.  创建文件或目录：可以使用File类的构造方法创建一个文件或目录，也可以使用createNewFile()方法创建文件，使用mkdir()方法创建目录。
2.  删除文件或目录：可以使用delete()方法删除文件或目录。
3.  重命名文件或目录：可以使用renameTo()方法将文件或目录重命名。
4.  判断文件或目录是否存在：可以使用exists()方法判断文件或目录是否存在。
5.  获取文件或目录的属性：可以使用length()方法获取文件的大小，lastModified()方法获取文件最后修改时间，isDirectory()方法判断是否为目录，isFile()方法判断是否为文件等。
6.  列出目录下的文件和目录：可以使用list()方法列出目录下的文件和目录名，也可以使用listFiles()方法获取目录下的文件和目录对象。

File类可以实现对文件和目录的基本操作，但是它不能用来读写文件的内容。要读写文件内容，需要使用Java IO中的其他类，如FileInputStream、FileOutputStream、BufferedReader、BufferedWriter等。

### 1.2File 类中的常用方法 ###

1.  `exists()`：检查文件是否存在
2.  `getName()`：获取文件名
3.  `getPath()`：获取文件路径
4.  `length()`：获取文件长度（字节数）
5.  `delete()`：删除文件
6.  `renameTo(File dest)`：重命名文件或移动文件到指定路径
7.  `canRead()`：检查文件是否可读
8.  `canWrite()`：检查文件是否可写
9.  `isFile()`：检查文件是否为普通文件
10. `isDirectory()`：检查文件是否为目录
11. `lastModified()`：获取文件最后修改时间
12. `mkdir()`：创建目录
13. `mkdirs()`：创建多级目录
14. `list()`：获取目录下的所有文件和目录名
15. `listFiles()`：获取目录下的所有文件和目录对象

具体运用中如下所示：

public static void main(String[] args) {
            //File类在创建的时候有三种形式
            //1. File f1 = new File("D:/temp");
            /*2. File file = new File("D:");
                 File f1 = new File(file,"temp");
            */
            /*3.String s = "D:";
                File file = new File(s,"temp");
            */
            File f1 = new File("D:/temp/demo.txt");//常用的创建方式
            //File类中的常用方法
            System.out.println(f1.canRead());//判断文件是否可读
            System.out.println(f1.canWrite());//判断文件是否可写
            System.out.println(f1.canExecute());//判断文件是否可以执行
            System.out.println(f1.isFile());//判断是否是文件
            System.out.println(f1.isDirectory());//判断文件是否是目录
            System.out.println(f1.isAbsolute());//判断文件是否是绝对路径
            System.out.println(f1.isHidden());//判断是否为隐藏文件
            System.out.println(f1.length());//返回文件的字节长度
            System.out.println(f1.exists());//判断文件是否存在
            System.out.println(f1.getName());//获取文件名
            System.out.println(new Date(f1.lastModified()));//获取文件的创建时间
    
        }

运行结果如下所示：

![ad57392c716d4beab1b960644ce7bb1f.png][]

## 二.输入流与输出流 ##

### 2.1输入与输出的概念 ###

Java中输入与输出（Input/Output，简称I/O）是指程序与外部世界之间的数据传输。输入是指从外部世界（如键盘、文件、网络等）读取数据到程序中，输出是指将程序中的数据输出到外部世界（如屏幕、文件、网络等）。在Java中，I/O是通过流（Stream）来实现的，流是一个数据传输的通道，将数据从一个地方传输到另一个地方。Java中的I/O分为字节流和字符流两种，字节流处理的是字节数据，字符流处理的是字符数据。常用的I/O类包括FileInputStream，FileOutputStream、BufferedReader、BufferedWriter等。

![20151109175238446 (554×423)][20151109175238446 _554_423]

### 2.2输入流与输出流 ###

概念：

输入流和输出流是计算机科学中的概念，用于描述在程序中读取和写入数据的方式。

输入流（Input Stream）是从外部读取数据到程序中的流，它可以从文件、网络、键盘等输入设备中获取数据，然后传递给程序进行处理。在Java中，可以使用InputStream类及其子类来实现输入流操作。

输出流（Output Stream）是从程序中将数据输出到外部的流，它可以将程序中处理的数据输出到文件、网络、控制台等输出设备中。在Java中，可以使用OutputStream类及其子类来实现输出流操作。

输入流和输出流是程序中常用的数据操作方式，它们可以帮助程序读取和处理数据，同时也可以将程序处理的结果输出到外部设备中。

输入流与输出流常用的方法有：

以下是输入流和输出流的常用方法：

输入流常用方法：

1.  read()：从流中读取一个字节的数据。
2.  read(byte\[\] buffer)：从流中读取一定数量的字节数据，并将其存储到缓冲区中。
3.  skip(long n)：跳过 n 个字节的数据。
4.  available()：返回可以从流中读取的字节数。
5.  close()：关闭输入流。

输出流常用方法：

1.  write(int b)：将一个字节的数据写入输出流中。
2.  write(byte\[\] buffer)：将缓冲区中的数据写入输出流中。
3.  flush()：将缓冲区中的数据写入输出流中，并清空缓冲区。
4.  close()：关闭输出流。

输入流与输出流具体是如何调用：

public static void main(String[] args) throws IOException {
    
            //文件输入流----读取文件——>管道
            FileInputStream in  = new FileInputStream("D:/demo.txt");
            //文件输出流----管道———>书写文件
            FileOutputStream out = new FileOutputStream("D:/Demo/demo.txt");
            int b = 0;//每次传进去一个字节 一次读一个
            while((b=in.read())!=-1){
                out.write(b);//循环一次，往文件中写一个字节
            }
            in.close();//输入流结束
            out.close();//输出流结束
        }

使用byte数组提高传输效率：

public static void main(String[] args) throws IOException {
            FileInputStream in  =  new FileInputStream("D:/demo.txt");
            FileOutputStream out  =  new FileOutputStream("D:/Demo/a/demo.txt");
            //read（bb）一次只读指定数组长度的内容，读完返回的是-1
            byte [] bb = new byte[10];
            int num = 0;//记录实际装入数组中的元素的个数。
            while((num=in.read(bb))!=-1){
                out.write(bb,0,num);//一次写出一个byte数组个内容,但是从第0个开始写,写num个
            }
            in.close();
            out.close();
        }

使用byte数组，在读取和写入的时候，就可以一次性拿到byte数组定义的长度个字节，提高了效率。

## 三.字节流的输入与输出 ##

字节流是以字节为单位进行读写的流，Java中提供了两个基本的字节流类：InputStream和OutputStream。InputStream用于读取字节流数据，OutputStream用于写出字节流数据。

1.  InputStream

InputStream是所有输入流的基类，它提供了一些基本的方法来读取字节流数据。常用的方法有：

*  int read()：读取一个字节并返回该字节的值，如果已经到达流的末尾，则返回-1。
 *  int read(byte\[\] b)：从输入流中读取一定数量的字节并将其存储在缓冲区数组b中，返回实际读取的字节数，如果已经到达流的末尾，则返回-1。
 *  int read(byte\[\] b, int off, int len)：从输入流中读取最多len个字节并将其存储在缓冲区数组b中，从off位置开始存储，返回实际读取的字节数，如果已经到达流的末尾，则返回-1。
 *  void close()：关闭流并释放与之关联的所有系统资源。

1.  OutputStream

OutputStream是所有输出流的基类，它提供了一些基本的方法来写出字节流数据。常用的方法有：

*  void write(int b)：将一个字节写入输出流。
 *  void write(byte\[\] b)：将字节数组b中的所有字节写入输出流。
 *  void write(byte\[\] b, int off, int len)：将字节数组b中从off位置开始的长度为len的字节写入输出流。
 *  void flush()：刷新输出流并将所有缓冲的字节写入底层流。
 *  void close()：关闭流并释放与之关联的所有系统资源。

以上是字节流的基本操作，需要注意的是，读取和写出时都需要使用try-catch语句来处理可能出现的IOException异常。同时，在使用完流后，应该及时关闭流以释放系统资源。

具体的使用如下所示：

public static void main(String[] args) {
            FileInputStream in = null;//用于关闭文件调用
            FileOutputStream out = null;
            try {
                in = new FileInputStream("D:/temp");
                out = new FileOutputStream("D:/temp/a");
                int length = 0;
                byte [] b = new byte[1024*1024];
                while((length = in.read())!=-1){
                    out.write(b,0,length);
                }
            } catch (FileNotFoundException e) {
                System.out.println("系统找不到此文件。");
            }catch (IOException e){
                System.out.println("文件读写异常");
            }finally{
                try {
                    if(in != null){//当文件输入流为空时，也就没必要关闭此文件的调用
                        in.close();}
                    if(out != null){
                        out.close();}
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

如何将字符串写入到自己想保存的文件中呢？

有以下两种形式：

public static void main(String[] args) throws IOException {
            String sr = "你好";
            FileOutputStream out = new FileOutputStream("D:/temp/demo.txt");
            out.write(sr.getBytes());//将字符串转换为byte数组进行文件读写
            FileInputStream in = new FileInputStream("D:/temp/demo.txt");
            byte [] b = new byte[20];
            int length = in.read(b);//把内容读到byte数组中
            String sc = new String(b,0,length);//把数组转为字符串
            System.out.println(sc);
            /*FileOutputStream out = new FileOutputStream("D:/temp/demo.txt");
            DataOutputStream dout = new DataOutputStream(out);
            dout.writeUTF(sr);//直接写出一个字符串
            FileInputStream in = new FileInputStream("D:/temp/demo.txt");
            DataInputStream din = new DataInputStream(in);
            String m = din.readUTF();//直接可以读到一个字符串
            System.out.println(m);*/
        }

## 四.字符流的输入与输出 ##

字符流的输入输出是指以字符为单位进行输入输出操作的流。字符流可以用于读写文本文件、网络连接等。

Reader 的基本方法 读取一个字符并以整数的形式返回, 如果返回-1已到输入流的末尾。 int read() throws IOException 读取一系列字符并存储到一个数组buffer， 返回实际读取的字符数，如果读取前 已到输入流的末尾返回-1 int read( char\[\] cbuf) throws IOException 关闭void close() throws IOException

Writer 的基本方法 向输出流中写入一个字符数据,该字节数据为参数b的16位 void write(int c) throws IOException 一个字符类型的数组中的数据写入输出流 void write( char\[\] cbuf) throws IOException 将一个字符类型的数组中的从指定位置（off set）开始的 length个字符写入到 输出流 void write( char\[\] cbuf, int off set, int length) throws IOException 关闭void close() throws

字符流的输入可以通过以下步骤进行：

1.  创建一个字符输入流对象，如 FileReader 或 InputStreamReader。
2.  打开需要读取的文件或网络连接，如通过 FileInputStream 或 Socket.getInputStream() 获取输入流。
3.  通过字符输入流对象的 read() 方法读取字符或 readLine() 方法读取一行字符。
4.  关闭字符输入流对象和输入流。

字符流的输出可以通过以下步骤进行：

1.  创建一个字符输出流对象，如 FileWriter 或 OutputStreamWriter。
2.  打开需要写入的文件或网络连接，如通过 FileOutputStream 或 Socket.getOutputStream() 获取输出流。
3.  通过字符输出流对象的 write() 方法写入字符或 write() 方法写入字符串。
4.  刷新字符输出流对象的缓冲区并关闭字符输出流对象和输出流。

字符流的具体使用如下所示：

public static void main(String[] args) throws IOException {
            FileReader fr = new FileReader("D:/Demo/xx.txt");
            FileWriter fw = new FileWriter("D:/Demo/a/xx.txt");
            int c= 0;
            while ((c=fr.read())!=-1){
                fw.write(c);
            }
            fr.close();
            fw.close();
        }

使用数组一次写入多个字节：

public static void main(String[] args) throws IOException {
            FileReader fr = new FileReader("D:/Demo/.demo.txt");
            FileWriter fw = new FileWriter("D:/Demo/dd.txt");
            char [] chars = new char[100];
            int length = 0;
            while((length=fr.read(chars))!=-1){
                fw.write(chars,0,length);
            }
            fr.close();
            fw.close();
        }

## 五.节点流与处理流 ##

节点流常用的类有：

1.  FileInputStream/FileOutputStream：用于读写文件的字节流。
2.  FileReader/FileWriter：用于读写文件的字符流。
3.  ByteArrayInputStream/ByteArrayOutputStream：用于读写字节数组的流。
4.  DataInputStream/DataOutputStream：用于读写基本数据类型的流。
5.  ObjectInputStream/ObjectOutputStream：用于读写对象的流。
6.  RandomAccessFile：可以随机访问文件的流。

处理流常用的类有：

1.  BufferedInputStream/BufferedOutputStream：用于加速读写文件的字节流。
2.  BufferedReader/BufferedWriter：用于加速读写文件的字符流。
3.  DataInputStream/DataOutputStream：用于加速读写基本数据类型的流。
4.  ObjectInputStream/ObjectOutputStream：用于加速读写对象的流。
5.  PrintStream/PrintWriter：用于格式化输出的流。

具体使用：

JavaIO中的节点流和处理流是常用的输入输出流，其中节点流是直接与数据源或目标进行交互的流，而处理流则是对节点流进行包装，提供了更高级的功能。

以下是JavaIO中常用的节点流和处理流的类以及它们的使用方法：

1.  FileInputStream和FileOutputStream：用于读取和写入文件的节点流。

示例：

FileInputStream fis = new FileInputStream("input.txt");
    FileOutputStream fos = new FileOutputStream("output.txt");
    
    byte[] buffer = new byte[1024];
    int length;
    while ((length = fis.read(buffer)) > 0) {
        fos.write(buffer, 0, length);
    }
    
    fis.close();
    fos.close();

2.ByteArrayInputStream和ByteArrayOutputStream：用于读取和写入内存中的字节数组的节点流。

byte[] input = { 1, 2, 3, 4, 5 };
    ByteArrayInputStream bais = new ByteArrayInputStream(input);
    ByteArrayOutputStream baos = new ByteArrayOutputStream();
    
    byte[] buffer = new byte[1024];
    int length;
    while ((length = bais.read(buffer)) > 0) {
        baos.write(buffer, 0, length);
    }
    
    byte[] output = baos.toByteArray();
    
    bais.close();
    baos.close();

3.InputStreamReader和OutputStreamWriter：用于将字节流转换为字符流的处理流。

示例：

FileInputStream fis = new FileInputStream("input.txt");
    InputStreamReader isr = new InputStreamReader(fis, StandardCharsets.UTF_8);
    FileOutputStream fos = new FileOutputStream("output.txt");
    OutputStreamWriter osw = new OutputStreamWriter(fos, StandardCharsets.UTF_8);
    
    char[] buffer = new char[1024];
    int length;
    while ((length = isr.read(buffer)) > 0) {
        osw.write(buffer, 0, length);
    }
    
    isr.close();
    osw.close();

4.BufferedReader和BufferedWriter：用于提供缓冲区功能的处理流，提高读写效率。

示例：

FileReader fr = new FileReader("input.txt");
    BufferedReader br = new BufferedReader(fr);
    FileWriter fw = new FileWriter("output.txt");
    BufferedWriter bw = new BufferedWriter(fw);
    
    String line;
    while ((line = br.readLine()) != null) {
        bw.write(line);
        bw.newLine();
    }
    
    br.close();
    bw.close();

5.DataInputStream和DataOutputStream：用于读写基本数据类型的节点流。

FileOutputStream fos = new FileOutputStream("data.bin");
    DataOutputStream dos = new DataOutputStream(fos);
    
    dos.writeInt(123);
    dos.writeDouble(3.14);
    dos.writeUTF("Hello, world!");
    
    dos.close();
    
    FileInputStream fis = new FileInputStream("data.bin");
    DataInputStream dis = new DataInputStream(fis);
    
    int i = dis.readInt();
    double d = dis.readDouble();
    String s = dis.readUTF();
    
    dis.close();

## 六.打印流 ##

打印流(PrintStream/PrintWriter)是Java IO中的一种高级流，它可以将Java数据类型以可读性良好的方式打印到输出流中。打印流通常用于输出文本数据到控制台或文件中。

PrintStream和PrintWriter的使用方法类似，都是将数据写入到输出流中，不同的是PrintStream是字节流，而PrintWriter是字符流。PrintStream主要用于处理字节数据，而PrintWriter主要用于处理字符数据。

打印流的常用方法有：

*  print()：打印指定的数据。
 *  println()：打印指定的数据，并在结尾处添加一个换行符。
 *  printf()：使用指定的格式字符串打印指定的数据。
 *  format()：使用指定的格式字符串打印指定的数据。

使用打印流可以方便地输出数据，同时也可以指定输出的格式，使输出内容更加规范化

Java中的打印流(PrintStream)是一种方便的输出数据的方式，它提供了许多方法来输出各种类型的数据，包括整数、浮点数和字符串等。下面是使用PrintStream的一些基本步骤：

1.  创建一个PrintStream对象，可以指定要输出的目标，比如文件或控制台：

PrintStream ps = new PrintStream(new File("output.txt")); //将输出到文件 PrintStream ps = new PrintStream(System.out); //将输出到控制台

1.  使用PrintStream的各种方法输出数据：

ps.print("hello"); //输出字符串 ps.println(123); //输出整数，并在末尾换行 ps.printf("%.2f", 3.14159); //格式化输出浮点数 // ...还有很多其他方法，可以根据需要选择使用

1.  在程序结束时关闭PrintStream对象：

ps.close();

注意，PrintStream输出数据时不会抛出IOException异常，因此不需要在调用打印流的方法时捕获异常，但最终使用完毕后仍需关闭该对象。

## 七.对象输入输出流--对象序列化 ##

在Java中，对象序列化是指将Java对象转换为字节序列以便于存储或传输的过程。对象序列化需要使用到对象输入输出流(ObjectInputStream/ObjectOutputStream)。

对象序列化的使用步骤如下：

1.  创建一个FileOutputStream/ObjectOutputStream对象来写出对象到文件或网络中。

> `FileOutputStream fos = new FileOutputStream("data.ser");`
> 
> `ObjectOutputStream oos = new ObjectOutputStream(fos);`

2.通过对象输出流ObjectOutputStream将Java对象进行序列化：

> `Person person = new Person("Tom", 20);`
> 
> `oos.writeObject(person);`

此时，Person类必须实现Serializable接口，否则会抛出NotSerializableException异常。

3.关闭对象输出流ObjectOutputStream。

> `oos.close();`

4.创建一个FileInputStream/ObjectInputStream对象来读取序列化后的对象。

> `FileInputStream fis = new FileInputStream("data.ser");`
> 
> `ObjectInputStream ois = new ObjectInputStream(fis);`

5.通过对象输入流ObjectInputStream将Java对象进行反序列化：

> `Person person = (Person) ois.readObject();`

6.关闭对象输入流ObjectInputStream。

> `ois.close();`

注意：在对象序列化的过程中，序列化的字段可以限制只有被transient关键字修饰的字段才不会被序列化，而其他字段均会自动地保存。此外，在进行反序列化时，如果不存在该字段，则默认会赋予其所定义类型的初始值(如int类型就是0，String类型就是null)

[ad57392c716d4beab1b960644ce7bb1f.png]: https://img-blog.csdnimg.cn/ad57392c716d4beab1b960644ce7bb1f.png
[20151109175238446 _554_423]: https://img-blog.csdn.net/20151109175238446