只需要一篇文章带你学会IO---IO最详解

最新推荐文章于 2024-04-01 07:58:03 发布

UkeLiu

最新推荐文章于 2024-04-01 07:58:03 发布

阅读量2.5k

点赞数 4

分类专栏： javaSE 文章标签： java javase

本文链接：https://blog.csdn.net/weixin_50563955/article/details/110521845

版权

javaSE 专栏收录该内容

10 篇文章 0 订阅

订阅专栏

Java–IO最详细解析

IO简介
1 继承结构
in/out相对于程序而言的输入(读取)和输出(写出)的过程。

在Java中，根据处理的数据单位不同，分为字节流和字符流

java.io包：

File

字节流：针对二进制文件

InputStream

–FileInputStream

–BufferedInputStream

–ObjectInputStream

OutputStream

–FileOutputStream

–BufferedOutputStream

–ObjectOutputStream

字符流：针对文本文件。读写容易发生乱码现象，在读写时最好指定编码集为utf-8

Writer

–BufferedWriter

–OutputStreamWriter

Reader

–BufferedReader

–InputStreamReader

–PrintWriter/PrintStream

2 流的概念
数据的读写抽象成数据，在管道中流动。

Ø 流只能单方向流动

Ø 输入流用来读取in

Ø 输出流用来写出Out

Ø 数据只能从头到尾顺序的读写一次

3 File文件流
3.1 概述
封装一个磁盘路径字符串，对这个路径可以执行一次操作。

可以用来封装文件路径、文件夹路径、不存在的路径。

3.2 创建对象
File(String pathname)

      通过将给定路径名字符串转换为抽象路径名来创建一个新 File 实例。

3.3 常用方法
文件、文件夹属性

length()：文件的字节量

exists()：是否存在，存在返回true

isFile()：是否为文件，是文件返回true

isDirectory()：是否为文件夹，是文件夹返回true

getName()：获取文件/文件夹名

getParent()：获取父文件夹的路径

getAbsolutePath()：获取文件的完整路径

创建、删除

createNewFile()：新建文件，文件夹不存在会异常，文件已经存在返回false

mkdirs()：新建多层不存在的文件夹\a\b\c

mkdir()：新建单层不存在的文件夹\a

delete()：删除文件，删除空文件夹

文件夹列表

 list()：返回String[]，包含文件名

   listFiles()：返回File[]，包含文件对象

3.4 demo1：测试常用方法

import java.io.File;

import java.io.IOException;

import java.util.Arrays;

 

import org.junit.Test;

 

//测试文件类

public class Test1_File {

       //Junit单元测试方法：

       //@Test + public + void + 没有参数

       @Test

       public void show() throws IOException {

              //1，创建File对象，读取了指定位置的文件

              File f = new File("D:\\teach\\a");

             

              //文件夹列表list() listFiles()

              String[] names = f.list();

              System.out.println(Arrays.toString(names));

             

              File[] files = f.listFiles();//推荐，更常见

              System.out.println(Arrays.toString(files));

             

             

              //TODO常用方法

              System.out.println(f.createNewFile());//新建文件，文件夹不存在会异常，文件已经存在返回false

              System.out.println(f.mkdir());//新建单层不存在的文件夹

              System.out.println(f.mkdirs());//新建多层不存在的文件夹

              System.out.println(f.delete());//删除文件，删除空文件夹

             

              System.out.println();

             

              System.out.println(f.length());//文件的字节量

              System.out.println(f.exists());//是否存在，存在返回true

              System.out.println(f.isFile());//是否为文件，是文件返回true

              System.out.println(f.isDirectory());//是否为文件夹，是文件夹返回true

              System.out.println(f.getName());//获取文件/文件夹名

              System.out.println(f.getParent());//获取父文件夹的路径

              System.out.println(f.getAbsolutePath());//获取文件的完整路径

             

       }

}

3.5 demo2:递归求目录总大小

递归：不断的调用方法本身。
递归：统计文件大小，删除文件

需求
求目录的总大小：

1、把指定目录封装成File对象
2、把文件夹列表列出来
3、判断，如果是文件，直接把f.length()相加
4、判断，如果是文件夹，继续列表，继续判断，如果是文件相加，如果又是文件夹，继续列表，继续判断，如果是文件相加…
5、如果是文件夹，递归调用方法本身的业务逻辑

import java.io.File;
import org.junit.Test;

//递归求目录总大小

public class Test2_File2 {

       public static void main(String[] args) {

//           1、把指定目录封装成File对象

              File file = new File("D:\\teach\\a");

              int size =count(file);

              System.out.println(size);

       }

      

       private static int count(File file) {

//           2、把文件夹列表列出来

              File[] files = file.listFiles();

             

              //2.1 遍历数组里的每个资源

              int sum = 0;//记录文件的大小

              for (int i = 0; i < files.length; i++) {

//           3、判断，如果是文件，直接把f.length()相加

// files[i]表示每次遍历到的资源

                            if(files[i].isFile()) {

                                   sum += files[i].length();//求文件的和

                            }else if(files[i].isDirectory()){

//           4、判断，如果是文件夹，继续列表，继续判断，如果是文件相加，如果又是文件夹，继续列表，继续判断，如果是文件相加......

//           5、如果是文件夹，递归调用方法本身的业务逻辑

                                   sum += count(file[i]);//把当前遍历到的文件夹继续循环判断求和

                            }

              }

               return sum ;

       }
           
}

4 扩展1
4.1 常见字符编码表在这里插入图片描述
测试：

	@Test
    public void code() throws IOException {

       String s = "我爱你中国";

       System.out.println(s.getBytes("utf-8").length);//15--unicode/u8一个汉字3字节存储

       System.out.println(s.getBytes("gbk").length);//10--中文双字节

       System.out.println(s.getBytes("unicode").length);//12--双字节+2

       System.out.println(s.getBytes("iso-8859-1").length);//5--单字节

    }

4.2 JDK1.7新特性之IO关流
try( ){ }catch(){ }

private static void customBufferStreamCopy(File source, File target) {

    InputStream fis = null;

    OutputStream fos = null;

    try {

        fis = new FileInputStream(source);

        fos = new FileOutputStream(target);

 

        byte[] buf = new byte[8192];

 

        int i;

        while ((i = fis.read(buf)) != -1) {

            fos.write(buf, 0, i);

        }

    }

    catch (Exception e) {

        e.printStackTrace();

    } finally {

        close(fis);

        close(fos);

    }

}

 

private static void close(Closeable closable) {

    if (closable != null) {

        try {

            closable.close();

        } catch (IOException e) {

            e.printStackTrace();

        }

    }

}

上述代码对于异常处理十分复杂，
对于资源的关闭也很麻烦，那么可以和下面的进行对比：

private static void customBufferStreamCopy(File source, File target) {

    try (InputStream fis = new FileInputStream(source);

        OutputStream fos = new FileOutputStream(target)){
        byte[] buf = new byte[8192];
        int i;

        while ((i = fis.read(buf)) != -1) {

            fos.write(buf, 0, i);

        }

    }

    catch (Exception e) {

        e.printStackTrace();

    }

}

5.1 字节流读取

字节流是由字节组成的,字符流是由字符组成的.
Java里字符由两个字节组成.字节流是最基本的，所有的InputStream和OutputStream的子类都是，主要用在处理二进制数据。

流式传输主要指将整个音频和视频及三维媒体等多媒体文件经过特定的压缩方式解析成一个个压缩包，由视频服务器向用户计算机顺序或实时传送。在采用流式传输方式的系统中，用户不必像采用下载方式那样等到整个文件全部下载完毕，而是只需经过几秒或几十秒的启动延时即可在用户的计算机上利用解压设备对压缩的A/V、3D等多媒体文件解压后进行播放和观看。此时多媒体文件的剩余部分将在后台的服务器内继续下载。

5.1.1 InputStream抽象类
此抽象类是表示字节输入流的所有类的超类/抽象类。

常用方法：

abstract int read()

      从输入流中读取数据的下一个字节。

int read(byte[] b)

      从输入流中读取一定数量的字节，并将其存储在缓冲区数组 b 中。

int read(byte[] b, int off, int len)

      将输入流中最多 len 个数据字节读入 byte 数组。

void close()

      关闭此输入流并释放与该流关联的所有系统资源。

5.1.2 FileInputStream子类
直接插在文件上，直接读取文件数据。

创建对象

FileInputStream(File file)

      通过打开一个到实际文件的连接来创建一个 FileInputStream，该文件通过文件系统中的 File 对象 file 指定。

FileInputStream(String pathname)

      通过打开一个到实际文件的连接来创建一个 FileInputStream，该文件通过文件系统中的路径名 name 指定。

5.1.3 BufferedInputStream子类
BufferedInputStream 为另一个输入流添加一些功能，即缓冲输入以及支持 mark 和 reset 方法的能力。在创建 BufferedInputStream 时，会创建一个内部缓冲区数组(默认8M大小)。在读取或跳过流中的字节时，可根据需要从包含的输入流再次填充该内部缓冲区，一次填充多个字节。

创建对象

BufferedInputStream(InputStream in)

创建一个 BufferedInputStream 并保存其参数，即输入流 in，以便将来使用。

5.2 字节流写出
5.2.1 OutputStream抽象类
此抽象类是表示输出字节流的所有类的超类。输出流接受输出字节并将这些字节发送到某个接收器。

常用方法：

void close()

      关闭此输出流并释放与此流有关的所有系统资源。

void flush()

      刷新此输出流并强制写出所有缓冲的输出字节。

void write(byte[] b)

      将 b.length 个字节从指定的 byte 数组写入此输出流。

void write(byte[] b, int off, int len)

      将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此输出流。

abstract void write(int b)

      将指定的字节写入此输出流。

5.2.2 FileOutputStream子类
直接插在文件上，直接写出文件数据

创建对象：

FileOutputStream(String name)

      创建一个向具有指定名称的文件中写入数据的输出文件流。FileOutputStream(File file)

      创建一个向指定 File 对象表示的文件中写入数据的文件输出流。

FileOutputStream(File file, boolean append) –追加

      创建一个向指定 File 对象表示的文件中写入数据的文件输出流。

5.2.3 BufferedOutputStream子类
该类实现缓冲的输出流。通过设置这种输出流，应用程序就可以将各个字节写入底层输出流中，而不必针对每次字节写入调用底层系统。

创建对象

BufferedOutputStream(OutputStream out)

创建一个新的缓冲输出流，以将数据写入指定的底层输出流。

5.3 demo：字节流读写

import java.io.BufferedInputStream;

import java.io.BufferedReader;

import java.io.File;

import java.io.FileInputStream;

import java.io.InputStream;

import java.io.InputStreamReader;

 

public class tt {

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

       method1();//字节读取

       method2();//字节写出

    }

private static void method2() throws Exception {

              long s = System.currentTimeMillis();

              OutputStream out = new FileOutputStream(new File("D:\\teach\\a.txt"));

              for(int i = 48 ; i < 1000000; i++) {

                     out.write(i);

              }

              s = System.currentTimeMillis() - s;

              System.out.println(s + "--");//3484

             

              long ss = System.currentTimeMillis();

              OutputStream out2 = new BufferedOutputStream(new FileOutputStream(new File("D:\\teach\\a2.txt")));

              for(int i = 48 ; i < 1000000; i++) {

                     out2.write(i);

              }

              ss = System.currentTimeMillis() - ss;

              System.out.println(ss + "==");//54

             

              out.close();

              out2.close();

       }

 

    private static void method1() throws Exception {

       long s = System.currentTimeMillis();

       InputStream in = new FileInputStream("D:\\teach\\1.jpg");

       int b = 0;

       while ((b = in.read()) != -1) {

           // System.out.println(b);

       }

       s = System.currentTimeMillis() - s;

       System.out.println(s + "--");// 7515

 

       long ss = System.currentTimeMillis();

       InputStream in2 = new BufferedInputStream(new FileInputStream("D:\\teach\\1.jpg"));

       int b2 = 0;

       while ((b2 = in2.read()) != -1) {

           // System.out.println(b2);

       }

       ss = System.currentTimeMillis() - ss;

       System.out.println(ss + "==");// 32

      

       in.close();

       in2.close();

    }

}

5.4 字符流读取
常用于处理纯文本数据。

5.4.1 Reader抽象类
用于读取字符流的抽象类。

常用方法：

int read()

      读取单个字符。

int read(char[] cbuf)

      将字符读入数组。

abstract int read(char[] cbuf, int off, int len)

      将字符读入数组的某一部分。

int read(CharBuffer target)

      试图将字符读入指定的字符缓冲区。

abstract void close()

      关闭该流并释放与之关联的所有资源。

5.4.2 FileReader子类
用来读取字符文件的便捷类。此类的构造方法假定默认字符编码和默认字节缓冲区大小都是适当的。要自己指定这些值，可以先在 FileInputStream 上构造一个 InputStreamReader。

创建对象

FileReader(String fileName)

在给定从中读取数据的文件名的情况下创建一个新 FileReader。

FileReader(File file)

在给定从中读取数据的 File 的情况下创建一个新 FileReader。

5.4.3 InputStreamReader子类

InputStreamReader 是字节流通向字符流的桥梁：它使用指定的 charset
读取字节并将其解码为字符。它使用的字符集可以由名称指定或显式给定，或者可以接受平台默认的字符集。

创建对象

InputStreamReader(InputStream in, String charsetName)

      创建使用指定字符集的 InputStreamReader。

InputStreamReader(InputStream in)

      创建一个使用默认字符集的 InputStreamReader。

5.4.4 BufferedReader子类

从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取。

可以指定缓冲区的大小，或者可使用默认的大小。大多数情况下，默认值就足够大了。

创建对象

BufferedReader(Reader in)

      创建一个使用默认大小输入缓冲区的缓冲字符输入流。

5.5 字符流写出
5.5.1 Writer抽象类
写入字符流的抽象类。

常用方法：

void write(char[] cbuf)

      写入字符数组。

abstract void write(char[] cbuf, int off, int len)

      写入字符数组的某一部分。

void write(int c)

      写入单个字符。

void write(String str)

      写入字符串。

void write(String str, int off, int len)

      写入字符串的某一部分。

abstract void close()

      关闭此流，但要先刷新它。

5.5.2 FileWriter子类
用来写入字符文件的便捷类。此类的构造方法假定默认字符编码和默认字节缓冲区大小都是可接受的。要自己指定这些值，可以先在 FileOutputStream 上构造一个 OutputStreamWriter。

创建对象

FileWriter(String fileName)
根据给定的文件名构造一个 FileWriter 对象。

FileWriter(String fileName, boolean append)

根据给定的文件名以及指示是否附加写入数据的 boolean 值来构造 FileWriter 对象

。

5.5.3 OutputStreamWriter子类
OutputStreamWriter 是字符流通向字节流的桥梁：可使用指定的 charset 将要写入流中的字符编码成字节。它使用的字符集可以由名称指定或显式给定，否则将接受平台默认的字符集。

创建对象

OutputStreamWriter(OutputStream out, String charsetName)

      创建使用指定字符集的 OutputStreamWriter。

OutputStreamWriter(OutputStream out)

      创建使用默认字符编码的 OutputStreamWriter。

5.5.4 BufferedWriter子类
将文本写入字符输出流，缓冲各个字符，从而提供单个字符、数组和字符串的高效写入。可以指定缓冲区的大小，或者接受默认的大小。在大多数情况下，默认值就足够大了。

创建对象

BufferedWriter(Writer out)

      创建一个使用默认大小输出缓冲区的缓冲字符输出流。

5.6 demo：字符流读写
把数据写出到指定文件中。如果文件不存在会自动创建，文件夹不存在会报错。

import java.io.BufferedOutputStream;

import java.io.BufferedWriter;

import java.io.File;

import java.io.FileOutputStream;

import java.io.OutputStream;

import java.io.OutputStreamWriter;

import java.io.Writer;

 
public class rr {

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

//           method1();//字符读取

              method2();//字符写出

       }

       private static void method2() throws Exception {

              Writer out = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(new File("D:\\\\teach\\\\a.txt"))
                                                                                                                                                                                             , "utf-8"));

              long s = System.currentTimeMillis();

              for(int i = 48 ; i < 1000000; i++) {

                     out.write(i);

              }

              s = System.currentTimeMillis() - s;

              System.out.println(s + "--");//266             

              out.close();

       }
 
       private static void method1() throws Exception {

       //字符流读图片乱码

//     BufferedReader in = new BufferedReader(new InputStreamReader(new FileInputStream(new File("D:\\teach\\1.jpg"))));

       BufferedReader in = new BufferedReader(new InputStreamReader(new FileInputStream(new File("D:\\teach\\a\\1.txt"))));

//     System.out.println(in.readLine());

//     System.out.println(in.readLine());//null读到/n/r

      
       String line = "";

       while((line = in.readLine())!=null) {//一行一行读

           System.out.println(line);

       }

       in.close();

    }

}

5.7 扩展
5.7.1 序列化 / 反序列化

序列化
(Serialization)是将对象的状态信息转换为可以存储或传输的形式的过程。在序列化期间，对象将其当前状态写入到临时或持久性存储区。以后，可以通过从存储区中读取或反序列化对象的状态，重新创建该对象。

1、序列化：利用ObjectOutputStream，对象的信息，按固定格式转成一串字节值输出并持久保存到磁盘化。
2、反序列化：利用ObjectInputStream，读取磁盘中序列化数据，重新恢复对象。

注意：

1、需要序列化的文件必须实现Serializable接口以启用其序列化功能。 2、
每个被序列化的文件都有一个唯一id，如果没有添加编译器会根据类的定义信息计算产生一个版本号。

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.io.IOException;

import java.io.ObjectInputStream;

import java.io.ObjectOutputStream;

import java.io.Serializable;

 

public class Test5_Seri {

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

              //序列化：就是把java对象保存在磁盘中

           	ObjectOutputStream os =new ObjectOutputStream(new FileOutputStream(                                                     "D:\\teach\\a\\student.txt"));
             
              Student s = new Student("张三",20,"成都");

              os.writeObject(s);//序列化，把Student对象信息保存到指定文件中

               os.close();//关闭输出资源
            
              //反序列化：从磁盘读到程序里

              ObjectInputStream in =

                            new ObjectInputStream(

                                          new FileInputStream(
                                                        "D:\\teach\\a\\student.txt"));
             
              //反序列化，把文件里的数据读到程序中，封装成对象，默认是Object

              Object obj =in.readObject();

              System.out.println(obj);
             
       }

}


//1，如果想完成序列化，类必须实现Serializable接口

//只是用来做标记，需要序列化

class  Student implements Serializable{

       //创建对象用

       public Student(String name, int age, String addr) {

              this.name = name;

              this.age = age;

              this.addr = addr;

       }

       //一般序列化的都是属性

       String name = "张三";

       int age = 20;

       String addr = "成都";

       //为了看属性值

       @Override

       public String toString() {

              return "Student [name=" + name + ", age=" + age + ", addr=" + addr + "]";

       }

      

}

5.7.2 编码转换流
用来作为桥梁，把字节流转成字符流的桥梁。用来解决字符流读写乱码问题。

–工具类

OutputStreamWriter：是字节流通向字符流的桥梁

–OutputStreamWriter(OutputStream out, String charsetName)

–OutputStreamWriter(OutputStream out)

InputStreamReader：是字节流通向字符流的桥梁

–InputStreamReader(InputStream in)

–InputStreamReader(InputStream in, String charsetName)

–测试

import java.io.BufferedReader;

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.io.InputStreamReader;

import java.io.OutputStreamWriter;

 
//编码转换流的测试

public class Test5_Decode {

    public static void main(String[] args) {

//     method();//输出的转换流

       method2();//读取的转换流

    }

    private static void method2() {

       try {

           //1，创建转换对象

           //第二个参数可以设置编码表，解决乱码现象

           //文件保存时使用的是gbk编码，如果用utf-8就会乱码

//         BufferedReader in = new BufferedReader(

//                      new InputStreamReader(

//                      new FileInputStream("1.txt"),"utf-8"));//乱码

           BufferedReader in = new BufferedReader(

                  new InputStreamReader(

                         new FileInputStream("1.txt"),"gbk"));
         
           //2，读取一行数据

           String line = in.readLine();//子类BufferedReader的特有方法

           System.out.println(line);
          
           //3，释放资源
          
       }catch(Exception e) {

           e.printStackTrace();

       }
    }
    private static void method() {

       try {

           // 1,创建转换流输出对象，OutputStreamWriter是字节流通向字符流的桥梁

           //第二个参数可以设置编码表，解决乱码现象

           //写出去的文件如果使用了utf-8表，打开时，使用了默认的gbk编码表，就会出现乱码

//         OutputStreamWriter out = new OutputStreamWriter(new FileOutputStream("1.txt"), "utf-8");

           OutputStreamWriter out = new OutputStreamWriter(new FileOutputStream("1.txt"), "gbk");

 

           // 2,开始写出数据

           // 当数据的保存方式和打开方式，使用的不是一张表时，就会出现乱码！！

           out.write("大家好，我是渣渣辉");

 

           // TODO 3，释放资源

           out.flush();

 

       } catch (Exception e) {

           e.printStackTrace();

       }

    }

 

}

5.7.3 BIO、NIO、AIO的区别
阻塞IO

BIO 就是传统的 java.io
包，它是基于流模型实现的，交互的方式是同步、阻塞方式，也就是说在读入输入流或者输出流时，在读写动作完成之前，线程会一直阻塞在那里，它们之间的调用时可靠的线性顺序。它的优点就是代码比较简单、直观；缺点就是 IO 的效率和扩展性很低，容易成为应用性能瓶颈。

非阻塞IO

NIO 是 Java 1.4 引入的 java.nio 包，提供了 Channel、Selector、Buffer等新的抽象，可以构建多路复用的、同步非阻塞 IO 程序，同时提供了更接近操作系统底层高性能的数据操作方式。

异步IO

AIO 是 Java 1.7 之后引入的包，是 NIO 的升级版本，提供了异步非堵塞的 IO 操作方式，所以人们叫它：AIO（Asynchronous IO），异步 IO是基于事件和回调机制实现的，也就是应用操作之后会直接返回，不会堵塞在那里，当后台处理完成，操作系统会通知相应的线程进行后续的操作。但目前还不够成熟，应用不多。

UkeLiu

关注

4
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
只需要一篇文章带你学会IO---IO最详解

Java–IO最详细解析IO简介1 继承结构in/out相对于程序而言的输入(读取)和输出(写出)的过程。在Java中，根据处理的数据单位不同，分为字节流和字符流java.io包：File字节流：针对二进制文件InputStream–FileInputStream–BufferedInputStream–ObjectInputStreamOutputStream–FileOutputStream–BufferedOutputStream–ObjectOutputStr
复制链接

扫一扫