Java-IO流

最新推荐文章于 2024-08-13 07:30:00 发布
最新推荐文章于 2024-08-13 07:30:00 发布
阅读量134 收藏
点赞数 1
原文链接：https://blog.csdn.net/zhaoyanjun6/article/details/54292148
版权

IO流

版权声明：本文为CSDN博主「赵彦军」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/zhaoyanjun6/article/details/54292148

————————————————
版权声明：本文为CSDN博主「陆勤」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/wangloveall/article/details/7992448

IO流体系

这里写图片描述
在这里插入图片描述

流的概念和作用

流是一组有顺序的，有起点和终点的字节集合，是对数据传输的总称或抽象。即数据在两设备间的传输称为流，流的本质是数据传输，根据数据传输特性将流抽象为各种类，方便更直观的进行数据操作。

IO流的分类

  • 根据处理数据类型的不同分为：字符流和字节流

  • 根据数据流向不同分为：输入流和输出流

字符流和字节流

字符流的由来： 因为数据编码的不同，而有了对字符进行高效操作的流对象。本质其实就是基于字节流读取时，去查了指定的码表。 字节流和字符流的区别：

  • 读写单位不同：字节流以字节（8bit）为单位，字符流以字符为单位，根据码表映射字符，一次可能读多个字节。

  • 处理对象不同：字节流能处理所有类型的数据（如图片、avi等），而字符流只能处理字符类型的数据。

  • 字节流：一次读入或读出是8位二进制。

  • 字符流：一次读入或读出是16位二进制。

设备上的数据无论是图片或者视频，文字，它们都以二进制存储的。二进制的最终都是以一个8位为数据单元进行体现，所以计算机中的最小数据单元就是字节。意味着，字节流可以处理设备上的所有数据，所以字节流一样可以处理字符数据。

结论：只要是处理纯文本数据，就优先考虑使用字符流。 除此之外都使用字节流。

输入流和输出流

输入流只能进行读操作，输出流只能进行写操作，程序中需要根据待传输数据的不同特性而使用不同的流。

输入字节流 InputStream

  • InputStream 是所有的输入字节流的父类，它是一个抽象类。

  • ByteArrayInputStream、StringBufferInputStream、FileInputStream 是三种基本的介质流，它们分别从Byte 数组、StringBuffer、和本地文件中读取数据。

  • PipedInputStream 是从与其它线程共用的管道中读取数据，与Piped 相关的知识后续单独介绍。

  • ObjectInputStream 和所有FilterInputStream 的子类都是装饰流（装饰器模式的主角）。

输出字节流 OutputStream

  • OutputStream 是所有的输出字节流的父类，它是一个抽象类。

  • ByteArrayOutputStream、FileOutputStream 是两种基本的介质流，它们分别向Byte 数组、和本地文件中写入数据。

  • PipedOutputStream 是向与其它线程共用的管道中写入数据。

  • ObjectOutputStream 和所有FilterOutputStream 的子类都是装饰流。

总结：

  • 输入流：InputStream或者Reader：从文件中读到程序中；
  • 输出流：OutputStream或者Writer：从程序中输出到文件中；

节点流

节点流：直接与数据源相连，读入或读出。
直接使用节点流，读写不方便，为了更快的读写文件，才有了处理流。

这里写图片描述

常用的节点流

  • 父类 ：InputStream 、OutputStream、 Reader、 Writer
  • 文件 ：FileInputStream 、 FileOutputStrean 、FileReader 、FileWriter 文件进行处理的节点流
  • 数组 ：ByteArrayInputStream、 ByteArrayOutputStream、 CharArrayReader 、CharArrayWriter 对数组进行处理的节点流（对应的不再是文件，而是内存中的一个数组）
  • 字符串 ：StringReader、 StringWriter 对字符串进行处理的节点流
  • 管道 ：PipedInputStream 、PipedOutputStream 、PipedReader 、PipedWriter 对管道进行处理的节点流

字节流与字符流代码演示

字节流
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
/*
1.如果是文本文件使用字符流，如果是非文本文件则应该使用字节流
2.如果仅对于一个文件进行复制，并不读取到内存中进行显示，则可以使用字节流进行复制
 */

public class FileInputAndOutput {
    public static void main(String[] args) {
        FileInputStream fis = null;
        FileOutputStream fos = null;
        try {
            //1.创建File类的对象，指明读入和写出的文件
            File srcFile = new File("图片.jpg");
            File destFile = new File("图片2.jpg");

            //2.创建输入输出流对象
            fis = new FileInputStream(srcFile);
            fos = new FileOutputStream(destFile);

            //3.数据的读入和写出
            byte[] buffer = new byte[5];
            int len;
            while((len = fis.read(buffer)) != -1){
                fos.write(buffer,0,len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //4.流资源的关闭
            if (fos != null){
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

            if(fis != null){
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}
字符流
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class FileReaderAndWriter {

    public static void main(String[] args){
        FileReader fr = null;
        FileWriter fw = null;
        try {
            //1.创建File类的对象，指明读入和写出的文件
            File readerFile = new File("text1.txt");
            File WriteFile = new File("text2.txt");

            //2.创建输入输出流对象
            fr = new FileReader(readerFile);
            fw = new FileWriter(WriteFile);

            //3.数据的读入和写出
            char[] chars = new char[5];
            int len;
            while((len=fr.read(chars)) != -1){
                fw.write(chars,0,len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //4.流资源的关闭
            if(fw != null){
                try {
                    fw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

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

处理流

处理流和节点流一块使用，在节点流的基础上，再套接一层，套接在节点流上的就是处理流。如BufferedReader.处理流的构造方法总是要带一个其他的流对象做参数。一个流对象经过其他流的多次包装，称为流的链接。

这里写图片描述

常用的处理流

  • 缓冲流：BufferedInputStrean 、BufferedOutputStream、 BufferedReader、 BufferedWriter 增加缓冲功能，避免频繁读写硬盘。

  • 转换流：InputStreamReader 、OutputStreamReader实现字节流和字符流之间的转换。

  • 数据流： DataInputStream 、DataOutputStream 等-提供将基础数据类型写入到文件中，或者读取出来。

  • 对象流：ObjectInputStream、ObjectOutputStream对象流可以将一个对象写出，或者读取一个对象到程序中，也就是执行了序列化和反序列化的操作。

缓冲流

import java.io.*;

public class BufferedText {
    public static void main(String[] args) {
        BufferedInputStream bis = null;
        BufferedOutputStream bos = null;
        try {
            //1.创建File类的对象，指明输入输出的文件
            File srcFile = new File("图片.jpg");
            File destFile = new File("图片3.jpg");

            //2.创建输入输出流对象
            //1.先创建节点流
            FileInputStream fis = new FileInputStream(srcFile);
            FileOutputStream fos = new FileOutputStream(destFile);
            //2.在创建处理流
            bis = new BufferedInputStream(fis);
            bos = new BufferedOutputStream(fos);

            //3.读入和写出文件
            byte[] buffer = new byte[10];
            int len;
            while ((len = bis.read(buffer)) != -1){
                bos.write(buffer,0,len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //4.流的关闭
            //说明：关闭外层流的同时，内层流会自动的进行关闭。内层流的关闭我们可以省略
            try {
                if (bos != null)
                    bos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }

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

import java.io.*;

public class BufferedText3 {
    public static void main(String[] args) {
        BufferedReader br = null;
        BufferedWriter bw = null;
        try {
            //创建文件和相应的流
            br = new BufferedReader(new FileReader(new File("text1.txt")));
            bw = new BufferedWriter(new FileWriter(new File("text3.txt")));

            //读写操作
            //方式一:
//            char[] chars = new char[5];
//            int len;
//            while((len=br.read(chars)) != -1){
//                bw.write(chars,0,len);
//            }

            //方式二：
            String data;
            while ((data = br.readLine()) != null){
                //方法一：
//                bw.write(data+"\n");  //data中不包含换行符
                //方法二：
                bw.write(data);  //data中不包含换行符
                bw.newLine();

            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //关闭资源
            if (bw != null){
                try {
                    bw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

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

转换流

InputStreamReader 、OutputStreamWriter 要InputStream或OutputStream作为参数，实现从字节流到字符流的转换。

在这里插入图片描述

1. 转换流属于字符流

InputStreamReader ：将一个字节的输入流转换为字符的输出流

OutputStreamWriter ：将一个字符的输出流转换为字节的输出流

2. 作用

​ 提供字节流与字符流之间的转换

3.解码与编码

​ 解码：字节，字节数组 —》字符数组，字符串

​ 编码：字符数组，字符串—》字节，字节数组

import java.io.*;

public class TransitionTest {
    public static void main(String[] args) {
        InputStreamReader isr = null;
        OutputStreamWriter osr = null;
        try {
            //1.//创建文件和相应的流
            File file1 = new File("背影.txt");
            File file2 = new File("背影2.txt");

            FileInputStream fis = new FileInputStream(file1);
            FileOutputStream fos = new FileOutputStream(file2);

            isr = new InputStreamReader(fis,"utf-8");
            osr = new OutputStreamWriter(fos,"gbk");

            //2.文件的读入和写出
            char[] buffer = new char[20];
            int len;
            while ((len = isr.read(buffer)) != -1){
                osr.write(buffer,0,len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //3.关闭资源
            try {
                if (osr != null)
                    osr.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if (isr != null)
                    isr.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

序列化（对象流的使用）

  • 序列化的概念：Java序列化是指把Java对象转换为字节序列的过程；而Java反序列化是指把字节序列恢复为Java对象的过程。

  • 为什么需要序列化与反序列化

    我们知道，当两个进程进行远程通信时，可以相互发送各种类型的数据，包括文本、图片、音频、视频等，而这些数据都会以二进制序列的形式在网络上传送。那么当两个Java进程进行通信时，能否实现进程间的对象传送呢？答案是可以的。如何做到呢？这就需要Java序列化与反序列化了。换句话说，一方面，发送方需要把这个Java对象转换为字节序列，然后在网络上传送；另一方面，接收方需要从字节序列中恢复出Java对象。

  • 如何实现Java序列化与反序列化

    • JDK类库中序列化API

      • java.io.ObjectOutputStream：表示对象输出流

      • 它的writeObject(Object obj)方法可以对参数指定的obj对象进行序列化，把得到的字节序列写到一个目标输出流中。

      • java.io.ObjectInputStream：表示对象输入流

      • 它的readObject()方法源输入流中读取字节序列，再把它们反序列化成为一个对象，并将其返回。

    • 实现序列化的要求

      只有实现了Serializable或Externalizable接口的类的对象才能被序列化，否则抛出异常。

    • 实现Java对象序列化与反序列化的方法

      假定一个Student类，它的对象需要序列化，可以有如下三种方法：

      方法一：若Student类仅仅实现了Serializable接口，则可以按照以下方式进行序列化和反序列化
      ObjectOutputStream采用默认的序列化方式，对Student对象的非transient的实例变量进行序列化。
      ObjcetInputStream采用默认的反序列化方式，对对Student对象的非transient的实例变量进行反序列化。

      方法二：若Student类仅仅实现了Serializable接口，并且还定义了readObject(ObjectInputStream in)和writeObject(ObjectOutputSteam out)，则采用以下方式进行序列化与反序列化。
      ObjectOutputStream调用Student对象的writeObject(ObjectOutputStream out)的方法进行序列化。
      ObjectInputStream会调用Student对象的readObject(ObjectInputStream in)的方法进行反序列化。

      方法三：若Student类实现了Externalnalizable接口，且Student类必须实现readExternal(ObjectInput in)和writeExternal(ObjectOutput out)方法，则按照以下方式进行序列化与反序列化。
      ​ ObjectOutputStream调用Student对象的writeExternal(ObjectOutput out))的方法进行序列化。
      ​ ObjectInputStream会调用Student对象的readExternal(ObjectInput in)的方法进行反序列化。

  • 关于 serialVersionUID 的描述

    ​ 序列化运行时使用一个称为 serialVersionUID 的版本号与每个可序列化类相关联，该序列号在反序列化过程中用于验证序列化对象的发送者和接收者是否为该对象加载了与序列化兼容的类。如果接收者加载的该对象的类的 serialVersionUID 与对应的发送者的类的版本号不同，则反序列化将会导致 InvalidClassException。可序列化类可以通过声明名为 “serialVersionUID” 的字段（该字段必须是静态 (static)、最终 (final) 的 long 型字段）显式声明其自己的 serialVersionUID：

    ​ 如果可序列化类未显式声明 serialVersionUID，则序列化运行时将基于该类的各个方面计算该类的默认 serialVersionUID 值，如“Java™ 对象序列化规范”中所述。不过，强烈建议 所有可序列化类都显式声明 serialVersionUID 值，原因是计算默认的 serialVersionUID 对类的详细信息具有较高的敏感性，根据编译器实现的不同可能千差万别，这样在反序列化过程中可能会导致意外的 InvalidClassException。因此，为保证 serialVersionUID 值跨不同 java 编译器实现的一致性，序列化类必须声明一个明确的 serialVersionUID 值。还强烈建议使用 private 修饰符显示声明 serialVersionUID（如果可能），原因是这种声明仅应用于直接声明类 – serialVersionUID 字段作为继承成员没有用处。数组类不能声明一个明确的 serialVersionUID，因此它们总是具有默认的计算值，但是数组类没有匹配 serialVersionUID 值的要求。

import java.io.*;

public class ObjectTest {

    //序列化
    public static void main(String[] args) {
        ObjectOutputStream oos = null;
        try {
            oos = new ObjectOutputStream(new FileOutputStream("object.dat"));

            oos.writeObject(new String("Java学习"));    //String类实现了Serializable接口，定义了 	                                                                       serialVersionUID
            oos.flush();   //刷新操作
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(oos != null){
                try {
                    oos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;

public class ObjectTest2 {
    //反序列化
    public static void main(String[] args) {
        ObjectInputStream ois = null;
        try {
            ois = new ObjectInputStream(new FileInputStream("object.dat"));

            Object o = ois.readObject();
            String str = (String)o;
            System.out.println(str);
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } finally {
            if (ois != null){
                try {
                    ois.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

    }
}

字符编码

  • 编码表的由来

    计算机只能识别二进制数据，早期由来是电信号。为了方便应用计算机，让它可以识别各个国家的文字。就将各个国家的文字用数字来表示，并一一对应，形成一张表。这就是编码表。

  • 常见的编码表

    • ASCII:美国标准信息交换码。.

      用一个字节的7位可以表示。

    • ISO8859-1:拉丁码表。欧洲码表

      用一个字节的8位表示。

    • GB2312:中国的中文编码表。最多两个字节编码所有字符

    • GBK:中国的中文编码表升级，融合了更多的中文文字符号。最多两个字节编码

    • Unicode: 国际标准码，融合了目前人类使用的所有字符。为每个字符分配唯一的字符码。所有的文字都用两个字节来表示。

    • UTF-8: 变长的编码方式，可用1-4个字节来表示一个字符。

在这里插入图片描述
在这里插入图片描述

辛夷陵
关注
Java-Io流，练习
07-06
Java的IO流是Java编程语言中的重要组成部分，它主要用于数据的输入和输出操作。在Java中，IO流被设计为处理任何类型的数据，包括字符、字节甚至对象。本练习旨在帮助初学者理解和掌握Java IO流的基础知识。 一、IO...
java-io流-文件流
08-05
Java IO流-文件流 Java IO流是Java语言中用于输入/输出操作的基本组件，它提供了多种方式来读取和写入数据，包括文件、网络、内存等。IO流体系可以分为两大类：字节流和字符流。 字节流 字节流是最基本的IO流，...
Java IO _字节流与字符流
韩世雷 程序员专栏
08-23 1336
1.掌握流的概念 2.掌握字节流与字符流的作用 3.掌握文件的标准操作步骤 4.掌握字节与字符操作的区别 1、流的概念 程序中的输入输出都是以流的形式保存的，流中保存的实际上全都是字节文件。 2、字节流与字符流 内容操作就四个类：OutputStream、InputStream、writer、Rader 使用 File 类操作的时候一定要有路
java io流
weixin_41729259的博客
03-30 135
参考1 参考2 JAVA基础知识之IO——Java IO体系及常用类 Java IO体系 个人觉得可以用“字节流操作类和字符流操作类组成了Java IO体系”来高度概括Java IO体系。 借用几张网络图片来说明(图片来自 http://blog.csdn.net/zhangerqing/article/details/8466532 ) 基于字节的IO操作 基于字符的IO操作 从上图...
java——IO流
最新发布
Good_Starry的博客
08-13 958
java——IO流：文件；常用文件操作；io流的分类；节点流和处理流；对象流；转换流；打印流；Properties
java io流
Noreaday的博客
03-13 184
如：生活中图片、影视等都是以字节存在的。字节流可以读取任何类文件（可以读取字符流可以读取的任何文件，反之不行）java  io流类有很多，类以inputstream或outputstream结尾的是字节流；以reader、writer结尾的是字符流。...
java IO流
怀念过去
07-21 295
JavaIO流的分类： 字节流、字符流 输入流 输出流 节点流 处理流 Tables 字节流 字符流 输入流 InputStream Reader 输出流 Outputstream WriterInputStream中的方法:  read() 读取一个字节  read（byte[] buffer）读取一个字节数组
Java-IO流/Stream流总结
07-12
Java的IO流与Stream流是Java程序中处理输入输出的核心技术。IO流主要分为字节流和字符流，这两种流分别处理二进制数据（如图片、音频等）和文本数据（如ASCII、UTF-8编码的文本）。下面将详细阐述这两个流的分类、...
java-io流学习总结.doc
11-24
Java IO 流学习总结的主要内容是对 Java 语言中 IO 流的机制和应用进行了详细的介绍，包括流的基本概念、字节流和字符流的区别、IO 体系的基本结构、FileReader 和 FileWriter 的使用、IO 流的应用等等。
Java-IO流.pdf
02-28
Java的IO流是Java平台核心特性之一，用于处理程序中的数据输入和输出。在Java中，流被定义为一组有序的数据序列，可以是字节流或字符流。字节流处理的数据最小单位是字节，而字符流处理的是Unicode字符。 Java I/O...
[Java]Day9:IO流 字节流 字符流 Properties集合
DhzWorld的博客
09-03 163
File类 File类 文件和目录路径名的抽象表示 文件和目录是可以通过File封装成对象的 对于File而言,其封装的并不是一个真正存在的文件,仅仅是一个路径名而已,它可以是存在的,也可以是不存在的,将来是要通过具体的操作把这个路径的内容转换为具体存在的 File类构造方法 方法名 说明 File(String pathname) 通过将给定的路径名字符串转换为抽象路径名来创建新的 File实例 File(String parent, String child) 从父
JAVA IO流
weixin_61611746的博客
06-24 587
IO，即in和out，也就是输入和输出，指应用程序和外部设备之间的数据传递，常见的外部设备包括文件、管道、网络连接。流（Stream），是一个抽象的概念，是指一连串的数据（字符或字节），是以先进先出的方式发送信息的通道。关于流的特性有下面几点：1.先进先出：最先写入输出流的数据最先被输入流读取到。2.顺序存取：可以一个接一个地往流中写入一串字节，读出时也将按写入顺序读取一串字节，不能随机访问中间的数据。（RandomAccessFile除外）
java高级特性 - io流
05-24
Java中的IO流指的是输入输出流，是用于读写数据的机制。在Java中，IO流分为两种：字节流和字符流。字节流以字节为单位进行操作，而字符流以字符为单位进行操作。 Java中提供了丰富的IO流类，包括File、InputStream...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值