Java IO流

一、IO简介

1 什么是IO

​ 对于任何程序设计语言而言，输入输出(Input/Output)系统都是非常核心的功能。

​ **输入(Input)**指的是：可以让程序从外部系统获得数据（核心含义是“读”，读取外部数据）。常见的应用：

​ 1、读取硬盘上的文件内容到程序。例如：播放器打开一个视频文件、word打开一个doc文件。

​ 2、读取网络上某个位置内容到程序。例如：浏览器中输入网址后，打开该网址对应的网页内容；下载网络上某个网址的文件。

​ 3、读取数据库系统的数据到程序。

​ 4、读取某些硬件系统数据到程序。例如：车载电脑读取雷达扫描信息到程序；温控系统等。

​ **输出(Output)**指的是：程序输出数据给外部系统从而可以操作外部系统（核心含义是“写”，将数据写出到外部系统）。常见的应用有：

​ 1、将数据写到硬盘中。例如：我们编辑完一个word文档后，将内容写到硬盘上进行保存。

​ 2、将数据写到数据库系统中。例如：我们注册一个网站会员，实际就是后台程序向数据库中写入一条记录。

​ 3、将数据写到某些硬件系统中。例如：导弹系统导航程序将新的路径输出到飞控子系统，飞控子系统根据数据修正飞行路径。

2 数据源

​ 数据源DataSource，提供数据的原始媒介。常见的数据源有：数据库、文件、其他程序、内存、网络连接、IO设备。

​ 数据源分为：源设备、目标设备。

​ 源设备：为程序提供数据，一般对应输入流。

​ 目标设备：程序数据的目的地，一般对应输出流。

3 流的概念

​ 流是一个抽象、动态的概念，是一连串连续动态的数据集合。

​ 对于输入流而言，数据源就像水箱，流(Stream)就像水管中流动着的水流，程序就是我们最终的用户。我们通过流（AStream）将数据源（Source）中的数据（information）输送到程（Program）中。

​ 对于输出流而言，目标数据源就是目的地（dest），我们通过流（AStream）将程序（Program）中的数据（information）输送到目的数据源（dest）中。

​ 输入/输出流的划分是相对程序而言的，并不是相对数据源。

4 Java中四大IO抽象类

​ InputStream/OutputStream和Reader/Writer类是所有IO流类的抽象父类。

InputStream

​ 此抽象类是表示字节输入流的所有类的父类。InputSteam是一个抽象类，它不可以实例化。数据的读取需要由它的子类来实现。根据节点的不同，它派生了不同的节点流子类。继承自InputSteam的流都是用于向程序中输入数据，且数据的单位为字节（8bit）。

常用方法：

​ intread()：读取一个字节的数据，并将字节的值作为int类型返回(0-255之间的一个值)。如果未读出字节则返回-1（返回值为-1表示读取结束）。

​ voidclose()：关闭输入流对象，释放相关系统资源。

OutputStream

​ 此抽象类是表示字节输出流的所有类的父类。输出流接收输出字节并将这些字节发送到某个目的地。

常用方法：

​ voidwrite(intn)：向目的地中写入一个字节。

​ voidclose()：关闭输出流对象，释放相关系统资源。

Reader

​ Reader用于读取的字符流抽象类，数据单位为字符。

常用方法：

​ intread():读取一个字符的数据，并将字符的值作为int类型返回(0-65535之间的一个值，即Unicode值)。如果未读出字符则返回-1（返回值为-1表示读取结束）。

​ voidclose()：关闭流对象，释放相关系统资源。

Writer

​ Writer用于输出的字符流抽象类，数据单位为字符。

常用方法：

​ voidwrite(intn)：向输出流中写入一个字符。

​ voidclose()：关闭输出流对象，释放相关系统资源。

5 Java中流的概念细分

按流的方向分类：

​ 输入流：数据流从数据源到程序（以InputStream、Reader结尾的流）。

​ 输出流：数据流从程序到目的地（以OutPutStream、Writer结尾的流）。

按处理的数据单元分类：

​ 字节流：以字节为单位获取数据，命名上以Stream结尾的流一般是字节流，如FileInputStream、FileOutputStream。（二进制文件、图片、影音）

​ 字符流：以字符为单位获取数据，命名上以Reader/Writer结尾的流一般是字符流，如FileReader、FileWriter。（文本）

按处理对象不同分类：

​ 节点流：可以直接从数据源或目的地读写数据，如FileInputStream、FileReader、DataInputStream等。

​ 处理流：不直接连接到数据源或目的地，是”处理流的流”。通过对其他流的处理提高程序的性能，如BufferedInputStream、BufferedReader等。处理流也叫包装流。

​ 节点流处于IO操作的第一线，所有操作必须通过它们进行；处理流可以对节点流进行包装，提高性能或提高程序的灵活性。

6 Java中IO流类的体系

1. InputStream/OutputStream

   ​ 字节流的抽象类。

2. Reader/Writer

   ​ 字符流的抽象类。

3. FileInputStream/FileOutputStream

   ​ 节点流：以字节为单位直接操作“文件”。

4. ByteArrayInputStream/ByteArrayOutputStream

   ​ 节点流：以字节为单位直接操作“字节数组对象”。

5. ObjectInputStream/ObjectOutputStream

   ​ 处理流：以字节为单位直接操作“对象”。

6. DataInputStream/DataOutputStream

   ​ 处理流：以字节为单位直接操作“基本数据类型与字符串类型”。

7. FileReader/FileWriter

   ​ 节点流：以字符为单位直接操作“文本文件”（注意：只能读写文本文件）。

8. BufferedReader/BufferedWriter

   ​ 处理流：将Reader/Writer对象进行包装，增加缓存功能，提高读写效率。

9. BufferedInputStream/BufferedOutputStream

   ​ 处理流：将InputStream/OutputStream对象进行包装，增加缓存功能，提高读写效率。

10. InputStreamReader/OutputStreamWriter

    ​ 处理流：将字节流对象转化成字符流对象。

11. PrintStream

    ​ 处理流：将OutputStream进行包装，可以方便地输出字符，更加灵活。

二、IO流入门案例

1 第一个简单的IO流程序

​ 当程序需要读取数据源的数据时，就会通过IO流对象开启一个通向数据源的流，通过这个IO流对象的相关方法可以顺序读取数据源中的数据。

输出D盘中的文件

FileInputStreamfis=null;
try{
//创建字节输入流对象
fis=newFileInputStream("d:/ab.txt");
ints1=fis.read();//打印输入字符a对应的ascii码值97
ints2=fis.read();//打印输入字符b对应的ascii码值98
ints3=fis.read();//打印输入字符c对应的ascii码值99
ints4=fis.read();//打印输入字符d对应的ascii码值100
ints5=fis.read();//由于文件内容已经读取完毕，则返回-1
System.out.println(s1);
System.out.println(s2);
System.out.println(s3);
System.out.println(s4);
System.out.println(s5);
}catch(Exceptione){
e.printStackTrace();
}finally{
if(fis!=null){
try{
fis.close();
}catch(Exceptione){
e.printStackTrace();
}
}
}

2 改造入门案例

FileInputStreamfis=null;
try{
//创建字节输入流对象
fis=newFileInputStream("d:/ab.txt");
StringBuildersb=newStringBuilder();
inttemp=0;
while((temp=fis.read())!=-1){
System.out.println(temp);
sb.append((char)temp);
}
System.out.println(sb.toString());
}catch(Exceptione){
e.printStackTrace();
}finally{
try{
if(fis!=null){
fis.close();
}
}catch(Exceptione){
e.printStackTrace();
}
}

三、File类的使用

1 File类简介

1.1 File类的作用

​ File类是Java提供的针对磁盘中的文件或目录转换对象的包装类。一个File对象而可以代表一个文件或目录，File对象可以实现获取文件和目录属性等功能，可以实现对文件和目录的创建，删除等功能。

1.2 File类操作目录与文件的常用方法

1.2.1 针对文件操作的方法

​ createNewFile()//创建新文件。

​ delete()//直接从磁盘上删除

​ exists()//查询磁盘中的文件是否存在

​ getAbsolutePath()//获取绝对路径

​ getPath()//获取相对路径

​ getName()//获取文件名相当于调用了一个toString方法。

​ isFile()//判断是否是文件

​ length()//查看文件中的字节数

​ isHidden()//测试文件是否被这个抽象路径名是一个隐藏文件。

1.2.2 针对目录操作的方法

​ exists()//查询目录是否存在

​ isDirectory()//判断当前路径是否为目录

​ mkdir()//创建目录

​ getParentFile()//获取当前目录的父级目录。

​ list()//返回一个字符串数组，包含目录中的文件和目录的路径名。

​ listFiles//返回一个File数组，表示用此抽象路径名表示的目录中的文件。

2 File类的基本使用

2.1 操作文件

//创建File对象
Filefile=newFile("d:/aa.txt");
System.out.println(file.createNewFile());
//System.out.println(file.delete());
System.out.println(file.exists());
System.out.println(file.getName());
System.out.println(file.isFile());
System.out.println(file.isHidden());

2.2 操作目录

//创建File对象
Filefile=newFile("d:/b/c");
//System.out.println(file.mkdir());
//System.out.println(file.mkdirs());
//System.out.println(file.exists());
//System.out.println(file.isDirectory());
//System.out.println(file.getParent());
//System.out.println(file.getParentFile().getName());
Filefile2=newFile("d:/");
String[]arr=file2.list();
for(Stringtemp:arr){
System.out.println(temp);
}
System.out.println("-----------------------");
File[]arr2=file2.listFiles();
for(Filetemp:arr2){
System.out.println(temp);
}

四、常用流对象

1 文件字节流

​ FileInputStream通过字节的方式读取文件，适合读取所有类型的文件（图像、视频、文本文件等）。Java也提供了FileReader专门读取文本文件。

​ FileOutputStream通过字节的方式写数据到文件中，适合所有类型的文件。Java也提供了FileWriter专门写入文本文件。

1.1 文件字节输入流

FileInputStreamfis=null;
try{
//创建文件字节输入流对象
fis=newFileInputStream("d:/落日.jpg");
inttemp=0;
while((temp=fis.read())!=-1){
System.out.println(temp);
}
}catch(Exceptione){
e.printStackTrace();
}finally{
try{
if(fis!=null){
fis.close();
}
}catch(Exceptione){
e.printStackTrace();
}
}

1.2 文件字节输出流

FileInputStreamfis=null;
FileOutputStreamfos=null;
try{
//创建文件字节输入流对象
fis=newFileInputStream("d:/落日.jpg");
//创建文件字节输出流对象
fos=newFileOutputStream("d:/dd.jpg");
inttemp=0;
while((temp=fis.read())!=-1){
fos.write(temp);
}
//将数据从内存中写入到磁盘中。
fos.flush();
}catch(Exceptione){
e.printStackTrace();
}finally{
try{
if(fis!=null){
fis.close();
}
if(fos!=null){
fos.close();
}
}catch(Exceptione){
e.printStackTrace();
}
}

1.3 通过缓冲区提高读写效率

1.3.1 方式一

​ 通过创建一个指定长度的字节数组作为缓冲区，以此来提高IO流的读写效率。该方式适用于读取较大图片时的缓冲区定义。注意：缓冲区的长度一定是2的整数幂。一般情况下1024长度较为合适。

FileInputStreamfis=null;
FileOutputStreamfos=null;
try{
//创建文件字节输入流对象
fis=newFileInputStream("d:/落日.jpg");
//创建文件字节输出流对象
fos=newFileOutputStream("d:/cc.jpg");
//创建一个缓冲区，提高读写效率
byte[]buff=newbyte[1024];
inttemp=0;
while((temp=fis.read(buff))!=-1){
fos.write(buff,0,temp);
}
//将数据从内存中写入到磁盘中。
fos.flush();
}catch(Exceptione){
e.printStackTrace();
}finally{
try{
if(fis!=null){
fis.close();
}
if(fos!=null){
fos.close();
}
}catch(Exceptione){
e.printStackTrace();
}
}

1.3.2 方式二

​ 通过创建一个字节数组作为缓冲区，数组长度是通过输入流对象的available()返回当前文件的预估长度来定义的。在读写文件时，是在一次读写操作中完成文件读写操作的。注意：如果文件过大，那么对内存的占用也是比较大的。所以大文件不建议使用该方法。

FileInputStreamfis=null;
FileOutputStreamfos=null;
try{
//创建文件字节输入流对象
fis=newFileInputStream("d:/落日.jpg");
//创建文件字节输出流对象
fos=newFileOutputStream("d:/dd.jpg");
//创建一个缓冲区，提高读写效率
byte[]buff=newbyte[fis.available()];
fis.read(buff);
//将数据从内存中写入到磁盘中。
fos.write(buff);
fos.flush();
}catch(Exceptione){
e.printStackTrace();
}finally{
try{
if(fis!=null){
fis.close();
}
if(fos!=null){
fos.close();
}
}catch(Exceptione){
e.printStackTrace();
}
}

1.4 通过字节缓冲流提高读写效率

​ Java缓冲流本身并不具有IO流的读取与写入功能，只是在别的流（节点流或其他处理流）上加上缓冲功能提高效率，就像是把别的流包装起来一样，因此缓冲流是一种处理流（包装流）。

​ 当对文件或者其他数据源进行频繁的读写操作时，效率比较低，这时如果使用缓冲流就能够更高效的读写信息。因为缓冲流是先将数据缓存起来，然后当缓存区存满后或者手动刷新时再一次性的读取到程序或写入目的地。

​ 因此，缓冲流还是很重要的，我们在IO操作时记得加上缓冲流来提升性能。BufferedInputStream和BufferedOutputStream这两个流是缓冲字节流，通过内部缓存数组来提高操作流的效率。

FileInputStreamfis=null;
FileOutputStreamfos=null;
BufferedInputStreambis=null;
BufferedOutputStreambos=null;
try{
fis=newFileInputStream("d:/落日.jpg");
bis=newBufferedInputStream(fis);
fos=newFileOutputStream("d:/ff.jpg");
bos=newBufferedOutputStream(fos);
//缓冲流中的byte数组长度默认是8192
inttemp=0;
while((temp=bis.read())!=-1){
bos.write(temp);
}
bos.flush();
}catch(Exceptione){
e.printStackTrace();
}finally{
try{
//注意：关闭流顺序："后开的先关闭"
if(bis!=null){
bis.close();
}
if(fis!=null){
fis.close();
}
if(bos!=null){
bos.close();
}
if(fos!=null){
fos.close();
}
}catch(Exceptione){
e.printStackTrace();
}
}

注意：关闭流顺序：“后开的先关闭”

1.5 定义文件拷贝工具类

copyFile("d:/落日.jpg","d:/abc.jpg");
}

/**
*文件拷贝方法
*/
publicstaticvoidcopyFile(Stringsrc,Stringdes){
FileInputStreamfis=null;
BufferedInputStreambis=null;
FileOutputStreamfos=null;
BufferedOutputStreambos=null;

try{
bis=newBufferedInputStream(newFileInputStream(src));
bos=newBufferedOutputStream(newFileOutputStream(des));
inttemp=0;
while((temp=bis.read())!=-1){
bos.write(temp);
}
bos.flush();
}catch(Exceptione){
e.printStackTrace();
}finally{
try{
if(bis!=null){
bis.close();
}
if(fis!=null){
fis.close();
}
if(bos!=null){
bos.close();
}
if(fos!=null){
fos.close();
}
}catch(Exceptione){
e.printStackTrace();
}
}
}

2 文件字符流

​ 如果我们处理的是文本文件，也可以使用文件字符流，它以字符为单位进行操作。

2.1 文件字符输入流

FileReaderfrd=null;
try{
//创建文件字符输入流对象
frd=newFileReader("d:/ab.txt");
inttemp=0;
while((temp=frd.read())!=-1){
System.out.println((char)temp);
}
}catch(Exceptione){
e.printStackTrace();
}finally{
try{
if(frd!=null){
frd.close();
}
}catch(Exceptione){
e.printStackTrace();
}
}

2.2 文件字符输出流

FileWriterfw=null;
FileWriterfw2=null;
try{
//创建字符输出流对象
fw=newFileWriter("d:/sxt.txt");
fw.write("你好尚学堂\r\n");
fw.write("你好Oldlu\r\n");
fw.flush();

fw2=newFileWriter("d:/sxt.txt",true);
fw2.write("何以解忧\r\n唯有尚学堂");
fw2.flush();
}catch(Exceptione){
e.printStackTrace();
}finally{
try{
if(fw!=null){
fw.close();
}
if(fw2!=null){
fw2.close();
}
}catch(Exceptione){
e.printStackTrace();
}
}

2.3 使用字符流实现文本文件的拷贝处理

FileReaderfr=null;
FileWriterfw=null;
try{
fr=newFileReader("d:/2.txt");
fw=newFileWriter("d:/3.txt");
char[]buffer=newchar[1024];
inttemp=0;
while((temp=fr.read(buffer))!=-1){
fw.write(buffer,0,temp);
}
fw.flush();
}catch(Exceptione){
e.printStackTrace();
}finally{
try{
if(fr!=null){
fr.close();
}
if(fw!=null){
fw.close();
}
}catch(Exceptione){
e.printStackTrace();
}
}

3 字符缓冲流

​ BufferedReader/BufferedWriter增加了缓存机制，大大提高了读写文本文件的效率。

3.1 字符输入缓冲流

​ BufferedReader是针对字符输入流的缓冲流对象，提供了更方便的按行读取的方法：readLine();在使用字符流读取文本文件时，我们可以使用该方法以行为单位进行读取。

FileReaderfr=null;
BufferedReaderbr=null;
try{
fr=newFileReader("d:/sxt.txt");
br=newBufferedReader(fr);
Stringtemp="";
while((temp=br.readLine())!=null){
System.out.println(temp);
}
}catch(Exceptione){
e.printStackTrace();
}finally{
try{
if(br!=null){
br.close();
}
if(fr!=null){
fr.close();
}
}catch(Exceptione){
e.printStackTrace();
}
}

3.2 字符输出缓冲流

FileWriterfw=null;
BufferedWriterbw=null;
try{
fw=newFileWriter("d:/sxt2.txt");
bw=newBufferedWriter(fw);
bw.write("你好尚学堂");
bw.write("你好Oldlu");
bw.newLine();
bw.write("何以解忧");
bw.newLine();
bw.write("唯有尚学堂");
bw.flush();
}catch(Exceptione){
e.printStackTrace();
}finally{
try{
if(bw!=null){
bw.close();
}
if(fw!=null){
fw.close();
}
}catch(Exceptione){
e.printStackTrace();
}
}

bw.newLine();换行处理

3.3 通过字符缓冲流实现文本文件的拷贝

copyFile("d:/2.txt","d:/22.txt");
}

/**
*基于字符流缓冲流实现文件拷贝
*/
publicstaticvoidcopyFile(Stringsrc,Stringdes){
BufferedReaderbr=null;
BufferedWriterbw=null;
try{
br=newBufferedReader(newFileReader(src));
bw=newBufferedWriter(newFileWriter(des));
Stringtemp="";
while((temp=br.readLine())!=null){
bw.write(temp);
bw.newLine();
}
bw.flush();
}catch(Exceptione){
e.printStackTrace();
}finally{
try{
if(br!=null){
br.close();
}
if(bw!=null){
bw.close();
}
}catch(Exceptione){
e.printStackTrace();
}
}

3.4 通过字符缓冲流为文件中的内容添加行号

BufferedReaderbr=null;
BufferedWriterbw=null;
try{
br=newBufferedReader(newFileReader("d:/sxt2.txt"));
bw=newBufferedWriter(newFileWriter("d:/sxt3.txt"));
Stringtemp="";
inti=1;
while((temp=br.readLine())!=null){
bw.write(i+","+temp);
bw.newLine();
i++;
}
bw.flush();
}catch(Exceptione){
e.printStackTrace();
}finally{
try{
if(br!=null){
br.close();
}
if(bw!=null){
bw.close();
}
}catch(Exceptione){
e.printStackTrace();
}
}

4 转换流

​ InputStreamReader/OutputStreamWriter用来实现将字节流转化成字符流。比如，如下场景：

​ System.in是字节流对象，代表键盘的输入，如果我们想按行接收用户的输入时，就必须用到缓冲字符流BufferedReader特有的方法readLine()，但是经过观察会发现在创建BufferedReader的构造方法的参数必须是一个Reader对象,这时候我们的转换流InputStreamReader就派上用场了。

​ 而System.out也是字节流对象，代表输出到显示器，按行读取用户的输入后，并且要将读取的一行字符串直接显示到控制台，就需要用到字符流的write(Stringstr)方法，所以我们要使用OutputStreamWriter将字节流转化为字符流。

4.1 通过转换流实现键盘输入屏幕输出

BufferedReader br = null;
BufferedWriter bw = null;
try {
    br = new BufferedReader(new InputStreamReader(System.in));
    bw = new BufferedWriter(new OutputStreamWriter(System.out));
    while (true) {
        bw.write("请输入：");
        bw.flush();
        String input = br.readLine();
        if ("exit".equals(input)) {
            break;
        }
        bw.write("你输入的是：" + input);
        bw.newLine();
        bw.flush();
    }
} catch (Exception e) {
    e.printStackTrace();
} finally {
    try {
        if (bw != null) {
            bw.close();
        }
        if (br != null) {
            br.close();
        }

    } catch (Exception e) {
        e.printStackTrace();
    }
}

4.2 通过字节流读取文本文件并添加行号

BufferedReader br = null;
BufferedWriter bw = null;
try {
    br = new BufferedReader(new InputStreamReader(new FileInputStream("d:/sxt.txt")));
    bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("d:/sxt3.txt")));
    String temp = "";
    int i = 1;
    while ((temp = br.readLine()) != null) {
        bw.write(i + "," + temp);
        bw.newLine();
        i++;
    }
    bw.flush();
} catch (Exception e) {
    e.printStackTrace();
} finally {
    try {
        if (br != null) {
            br.close();
        }
        if (bw != null) {
            bw.close();
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
}

5 字符输出流

​ 在Java的IO流中专门提供了用于字符输出的流对象PrintWriter。该对象具有自动行刷新缓冲字符输出流，特点是可以按行写出字符串，并且可通过println();方法实现自动换行。

BufferedReader br = null;
PrintWriter pw = null;
try {
    br = new BufferedReader(new InputStreamReader(new FileInputStream("d:/sxt.txt")));
    pw = new PrintWriter("d:/sxt4.txt");
    String temp = "";
    int i = 1;
    while ((temp = br.readLine()) != null) {
        pw.println(i + "," + temp);
        i++;
    }
} catch (Exception e) {
    e.printStackTrace();
} finally {
    try {
        if (br != null) {
            br.close();
        }
        if (pw != null) {
            pw.close();
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
}

6 字节数组流

​ ByteArrayInputStream和ByteArrayOutputStream经常用在需要流和数组之间转化的情况！

6.1 字节数组输入流

​ FileInputStream是把文件当做数据源。ByteArrayInputStream则是把内存中的”字节数组对象”当做数据源。

byte[] arr = "abcdefg".getBytes();
ByteArrayInputStream bis = null;
StringBuilder sb = new StringBuilder();
try {
    //该构造方法的参数是一个字节数组，这个字节数组就是数据源
    bis = new ByteArrayInputStream(arr);
    int temp = 0;
    while ((temp = bis.read()) != -1) {
        sb.append((char) temp);
    }
    System.out.println(sb.toString());
} finally {
    try {
        bis.close();
    } catch (Exception e) {
        e.printStackTrace();
    }
}

6.2 字节数组输出流

​ ByteArrayOutputStream流对象是将流中的数据写入到字节数组中。

ByteArrayOutputStream bos = null;
try {
    StringBuilder sb = new StringBuilder();
    bos = new ByteArrayOutputStream();
    bos.write('a');
    bos.write('b');
    bos.write('c');
    byte[] arr = bos.toByteArray();
    for (int i = 0; i < arr.length; i++) {
        sb.append((char) arr[i]);
    }
    System.out.println(sb.toString());
} finally {
    try {
        if (bos != null) {
            bos.close();
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
}

7 数据流

​ 数据流将“基本数据类型与字符串类型”作为数据源，从而允许程序以与机器无关的方式从底层输入输出流中操作Java基本数据类型与字符串类型。

​ DataInputStream和DataOutputStream提供了可以存取与机器无关的所有Java基础类型数据（如：int、double、String等）的方法。

7.1 数据输出流

DataOutputStream dos = null;
try {
    dos = new DataOutputStream(new BufferedOutputStream(new FileOutputStream("d:/data.txt")));
    dos.writeChar('a');
    dos.writeInt(10);
    dos.writeDouble(Math.random());
    dos.writeBoolean(true);
    dos.writeUTF("你好尚学堂");
    dos.flush();
} catch (Exception e) {
    e.printStackTrace();
} finally {
    try {
        if (dos != null) {
            dos.close();
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
}

7.2 数据输入流

DataInputStream dis = null;
try {
    dis = new DataInputStream(new BufferedInputStream(new FileInputStream("d:/data.txt")));
    //直接读取数据，注意：读取的顺序要与写入的顺序一致，否则不能正确读取数据。
    System.out.println("char: " + dis.readChar());
    System.out.println("int: " + dis.readInt());
    System.out.println("double: " + dis.readDouble());
    System.out.println("boolean: " + dis.readBoolean());
    System.out.println("String: " + dis.readUTF());
} catch (Exception e) {
    e.printStackTrace();
} finally {
    try {
        if (dis != null) {
            dis.close();
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
}

8 对象流

​ 对象的本质是用来组织和存储数据的，对象本身也是数据。那么，能不能将对象存储到硬盘上的文件中呢？能不能将对象通过网络传输到另一个电脑呢？我们可以通过序列化和反序列化来实现这些需求。

8.1 Java对象的序列化和反序列化

8.1.1 序列化和反序列化是什么

​ 当两个进程远程通信时，彼此可以发送各种类型的数据。无论是何种类型的数据，都会以二进制序列的形式在网络上传送。比如，我们可以通过http协议发送字符串信息；我们也可以在网络上直接发送Java对象。发送方需要把这个Java对象转换为字节序列，才能在网络上传送；接收方则需要把字节序列再恢复为Java对象才能正常读取。

​ 把Java对象转换为字节序列的过程称为对象的序列化。把字节序列恢复为Java对象的过程称为对象的反序列化。

​ 对象序列化的作用有如下两种：

​ **持久化：**把对象的字节序列永久地保存到硬盘上，通常存放在一个文件中。

​ **网络通信：**在网络上传送对象的字节序列。比如：服务器之间的数据通信、对象传递。

8.1.2 序列化涉及的类和接口

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

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

​ 只有实现了Serializable接口的类的对象才能被序列化。Serializable接口是一个空接口，只起到标记作用。

8.2 操作基本数据类型

​ 我们前边学到的数据流只能实现对基本数据类型和字符串类型的读写，并不能对Java对象进行读写操作（字符串除外），但是在对象流中除了能实现对基本数据类型进行读写操作以外，还可以对Java对象进行读写操作。

8.2.1 写出基本数据类型数据

ObjectOutputStream oos = null;
try {
    oos = new ObjectOutputStream(new BufferedOutputStream(new FileOutputStream("d:/sxt5.txt")));
    oos.writeInt(10);
    oos.writeDouble(Math.random());
    oos.writeChar('a');
    oos.writeBoolean(true);
    oos.writeUTF("你好Oldlu");
    oos.flush();
} catch (Exception e) {
    e.printStackTrace();
} finally {
    try {
        if (oos != null) {
            oos.close();
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
}

8.2.2 读取基本数据类型数据

ObjectInputStream ois = null;
try {
    ois = new ObjectInputStream(new BufferedInputStream(new FileInputStream("d:/sxt5.txt")));
    //必须要按照写入的顺序读取数据
    System.out.println("int: " + ois.readInt());
    System.out.println("double: " + ois.readDouble());
    System.out.println("char: " + ois.readChar());
    System.out.println("boolean: " + ois.readBoolean());
    System.out.println("String: " + ois.readUTF());
} catch (Exception e) {
    e.printStackTrace();
} finally {
    try {
        if (ois != null) {
            ois.close();
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
}

8.3 操作对象

8.3.1 将对象序列化到文件

​ ObjectOutputStream 可以将一个内存中的 Java 对象通过序列化的方式写入到磁盘的文件中。被序列化的对象必须要实现 Serializable 序列化接口，否则会抛出异常。

8.3.1.1 创建对象

public class Users implements Serializable {
    private int userid;
    private String username;
    private String userage;

    public Users(int userid, String username, String userage) {
        this.userid = userid;
        this.username = username;
        this.userage = userage;
    }

    public Users() {
    }

    public int getUserid() {
        return userid;
    }

    public void setUserid(int userid) {
        this.userid = userid;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getUserage() {
        return userage;
    }

    public void setUserage(String userage) {
        this.userage = userage;
    }
}

8.3.1.2 序列化对象

ObjectOutputStream oos = null;
try {
    oos = new ObjectOutputStream(new FileOutputStream("d:/sxt6.txt"));
    Users users = new Users(1, "Oldlu", "18");
    oos.writeObject(users);
    oos.flush();
} catch (Exception e) {
    e.printStackTrace();
} finally {
    try {
        if (oos != null) {
            oos.close();
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
}

8.3.2 将对象反序列化到内存中

ObjectInputStream ois = null;
try {
    ois = new ObjectInputStream(new FileInputStream("d:/sxt6.txt"));
    Users users = (Users) ois.readObject();
    System.out.println(users.getUserid() + "\t" + users.getUsername() + "\t" + users.getUserage());
} catch (Exception e) {
    e.printStackTrace();
} finally {
    try {
        if (ois != null) {
            ois.close();
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
}

9 随机访问流

​ RandomAccessFile可以实现两个作用：

​ 1.实现对一个文件做读和写的操作。

​ 2.可以访问文件的任意位置。不像其他流只能按照先后顺序读取。

​ 在开发某些客户端软件时，经常用到这个功能强大的可以”任意操作文件内容”的类。比如，软件的使用次数和使用日期，可以通过本类访问文件中保存次数和日期的地方进行比对和修改。Java很少开发客户端软件，所以在Java开发中这个类用的相对较少。

​ 学习这个流我们需掌握三个核心方法：

​ 1.RandomAccessFile(Stringname,Stringmode)name用来确定文件；mode取r(读)或rw(可读写)，通过mode可以确定流对文件的访问权限。

​ 2.seek(longa)用来定位流对象读写文件的位置，a确定读写位置距离文件开头的字节个数。

​ 3.getFilePointer()获得流的当前读写位置。

RandomAccessFile raf = null;
try {
    raf = new RandomAccessFile("d:/sxt7.txt", "rw");
    //将若干数据写入到文件中
    int[] arr = new int[]{10, 20, 30, 40, 50, 60, 70, 80, 90, 100};
    for (int i = 0; i < arr.length; i++) {
        raf.writeInt(arr[i]);
    }
    raf.seek(4);
    System.out.println(raf.readInt());

    //隔一个读一个数据
    for (int i = 0; i < 10; i += 2) {
        raf.seek(i * 4);
        System.out.print(raf.readInt() + "\t");
    }
    System.out.println();
    //在第8个字节位置插入一个新的数据45，替换之前的数据30
    raf.seek(8);
    raf.writeInt(45);
    for (int i = 0; i < 10; i += 2) {
        raf.seek(i * 4);
        System.out.print(raf.readInt() + "\t");
    }
} catch (Exception e) {
    e.printStackTrace();
} finally {
    try {
        if (raf != null) {
            raf.close();
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
}

10 File类在IO中的作用

​ 当以文件作为数据源或目标时，除了可以使用字符串作为文件以及位置的指定以外，我们也可以使用File类指定。

BufferedReader br = null;
BufferedWriter bw = null;
try {
    br = new BufferedReader(new FileReader(new File("d:/sxt.txt")));
    bw = new BufferedWriter(new FileWriter(new File("d:/sxt8.txt")));
    String temp = "";
    int i = 1;
    while ((temp = br.readLine()) != null) {
        bw.write(i + "," + temp);
        bw.newLine();
        i++;
    }
    bw.flush();
} catch (Exception e) {
    e.printStackTrace();
} finally {
    try {
        if (br != null) {
            br.close();
        }
        if (bw != null) {
            bw.close();
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
}

五、总结

按流的方向分类：

​ 输入流：数据源到程序(InputStream、Reader读进来)。

​ 输出流：程序到目的地(OutPutStream、Writer写出去)。

按流的处理数据单元分类：

​ 字节流：按照字节读取数据(InputStream、OutputStream)。

​ 字符流：按照字符读取数据(Reader、Writer)。

按流的功能分类：

​ 节点流：可以直接从数据源或目的地读写数据。

​ 处理流：不直接连接到数据源或目的地，是处理流的流。通过对其他流的处理提高程序的性能。

IO的四个基本抽象类：

​ InputStream、OutputStream、Reader、Writer

InputStream的实现类：

​ FileInputStream

​ ByteArrayInutStream

​ BufferedInputStream

​ DataInputStream

​ ObjectInputStream

OutputStream的实现类：

​ FileOutputStream

​ ByteArrayOutputStream

​ BufferedOutputStream

​ DataOutputStream

​ ObjectOutputStream

​ PrintStream

Reader的实现类：

​ FileReader

​ BufferedReader

​ InputStreamReader

Writer的实现类：

​ FileWriter

​ BufferedWriter

​ OutputStreamWriter

把Java对象转换为字节序列的过程称为对象的序列化。

br.readLine()) != null) {
bw.write(i + “,” + temp);
bw.newLine();
i++;
}
bw.flush();
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
if (br != null) {
br.close();
}
if (bw != null) {
bw.close();
}
} catch (Exception e) {
e.printStackTrace();
}
}

[外链图片转存中...(img-AlqLZkR2-1656766126377)]\28.jpg)

# 五、总结

按流的方向分类：

​	**输入流**：数据源到程序(InputStream、Reader读进来)。

​	**输出流**：程序到目的地(OutPutStream、Writer写出去)。

按流的处理数据单元分类：

​	**字节流**：按照字节读取数据(InputStream、OutputStream)。

​	**字符流**：按照字符读取数据(Reader、Writer)。

按流的功能分类：

​	**节点流**：可以直接从数据源或目的地读写数据。

​	**处理流**：不直接连接到数据源或目的地，是处理流的流。通过对其他流的处理提高程序的性能。

IO的四个基本抽象类：

​	**InputStream、OutputStream、Reader、Writer**

InputStream的实现类：

​	**FileInputStream**

​	**ByteArrayInutStream**

​	**BufferedInputStream**

​	**DataInputStream**

​	**ObjectInputStream**

OutputStream的实现类：

​	**FileOutputStream**

​	**ByteArrayOutputStream**

​	**BufferedOutputStream**

​	**DataOutputStream**

​	**ObjectOutputStream**

​	**PrintStream**

Reader的实现类：

​	**FileReader**

​	**BufferedReader**

​	**InputStreamReader**

Writer的实现类：

​	**FileWriter**

​	**BufferedWriter**

​	**OutputStreamWriter**

把Java对象转换为字节序列的过程称为对象的序列化。

把字节序列恢复为Java对象的过程称为对象的反序列化。