Java IO(一)

最新推荐文章于 2023-04-06 17:13:19 发布
最新推荐文章于 2023-04-06 17:13:19 发布
阅读量1.7k 收藏 7
点赞数
分类专栏： java学习笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lym152898/article/details/56013835
版权

一、流的概念

流（Ｓｔｒｅａｍ）的概念源自ＵＮＩＸ中管道的概念，管道是一条不间断的字节流，用来实现程序或进程之间的通信。一个流必有源端和目的端（可以是内存、磁盘文件等。）流的源端和目的端可以简单的看成字节的生产者和消费者。

二、流的分类

根据 读写位置 流分为：

  1. 结点流 ：接从指定的位置（如磁盘文件或内存区域）读或写
  2. 过滤器 ：输入流往往是以其它输入流作为它的输入源，经过过滤或处理后再以新的输入流的形式提供给用户，输出流的原理也类似。

根据 流的方向 分为：

  1. 输入流 ：用户可以从输入流中读取信息　，但是不能往里写信息。
  2. 输出流 ：用户可以往里写信息，但是不能从中读出信息。

根据 操作对象的类型是字符还是字节 分为两类：

  1. 字节流
  2. 字符流

Ｊａｖａ ＩＯ流的继承结构图如下:
这里写图片描述

三、常用流的详解

文件操作类：File

在讲解流之前，先讲解一下之后和流操作紧密相关的文件操作类 File类
File类是一个与文件本身操作相关的类——文件的创建、删除、重命名、取得文件大小和修改日期等。

File类中常用的构造方法和操作方法
No.方法类型描述
1public File(String pathName)构造给定一个要操作文件的完整路径
2public boolean exists()普通判定给定路径是否存在
3public File getParentFile()普通找到一个指定路径的父路径
4public boolean mkdirs()普通创建指定目录
5public boolean createNewFile()普通创建文件
6public boolean delete()普通删除文件
7public boolean isDirectory()普通判断给定路径是否是文件夹
8public boolean isFile()普通判断给定路径是否是文件
9public boolean isHidden()普通判断是否隐藏
10public boolean renameTo(File dest)普通为文件重命名
11public long lastModified()普通文件的最后一次修改时间
12public long length()普通取得文件的大小
13public String getName()普通取得文件名称
14public [] File listFiles()普通将目录中的文件以File对象数组的方式返回
代码示例
import java.util.Date;
import java.text.SimpleDateFormat;
import java.io.File;
public class TestDemo{
    public static void main(String [] args)throws Exception{
        File file = new File("/home/linyimin/DaSi/java/demo.txt");
        // 如果文件存在，获取并输出文件信息
        if(file.exists()){
            getInfo(file);
        }
        // 如果不存在，先判断文件的父路径是否存在，不存在先创建目录在创建文件，否则直接创建文件
        else if(file.getParentFile().exists()){
            // 创建文件
            file.createNewFile();
            // 获取文件信息
            getInfo(file);
        }
        else{
            // 创建目录
            file.getParentFile().mkdirs();
            // 创建文件
            file.createNewFile();
            // 获取文件信息
            getInfo(file);
        } 
        // 为文件重命名，并取得重命名后的文件信息
        File f = new File("/home/linyimin/DaSi/java/TestDemo.txt");
        file.renameTo(f);
        File newFile = new File("/home/linyimin/DaSi/java/TestDemo.txt");
        System.out.println("崇重命名之后的文件信息：");
        getInfo(newFile);
        // 删除文件
        newFile.delete();
    }

    /*
     * 获取文件的各种信息
     * @param file 目标操作文件
    **/
    public static void getInfo(File file){
        // 判断指定路径是否是目录
        System.out.println(file.getName() + (file.isDirectory()?"是一个目录":"不是一个目录"));
        // 判断是否是文件
        System.out.println(file.getName() + (file.isFile()?"是一个文件":"不是一个文件"));
        // 判断是否为隐藏文件
        System.out.println(file.getName() + (file.isHidden()?"是隐藏文件":"不是隐藏文件"));
        // 获取文件的最后修改时间
        long temp = file.lastModified();
        // 将long型数据转换称Date型数据
        Date date = new Date(temp);
        // 将Date型数据转换称时间字符串
        String str = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss").format(date);
        System.out.println(str);
        // 输出文件大小
        System.out.println(file.getName() + ":" + file.length() + "B");
    }
}

字节流

  • 所有的 字节输入流都直接或间接继承自InputStream抽象类 ，输入流作为数据的来源，我们可以通过输入流的read方法读取字节数据；

  • 所有的 输出流都直接或间接继承自OutputStream抽象类 ，输出流接收数据，可以通过write方法写入字节数据。

对于InputStream、OutputStream类而言，本身定义的是一个抽象类（abstract class），按照抽象类的使用原则来讲，需要定义抽象类的子类，根据功能的不同，使用不同的子类完成。 按照面向对象的开发原则，子类要为抽象类进行对象的实例化，而后调用的方法以父类中定义的方法为主，方法的具体实现由实例化这个父类的子类完成的。所以对于子类用户最关心的是构造方法 下面主要讲解几种常用的IO操作和其对应定义的子类。

文件操作:FileInputStream & FileOutputStream
  • 程序通过 FileInputStream能够将文件作为数据源，读取文件中的流 ，通过File对象或文件路径等初始化，在其构造函数中，如果传入的File对象（或与其相对应的文件路径所表示的File对象）不存在或是一个目录而不是文件或者由于其他原因无法打开读取数据，都会导致在初始化阶段导致抛出FileNotFoundException异常；
  • 程序可以通过 FileOutputStream向文件中写入数据 ，也需要通过File对象或文件路径对其初始化，如同FileInputStream ，如果传入的File对象（或与其相对应的文件路径所表示的File对象）是一个目录而不是文件或者由于其他原因无法创建该文件写入数据，都会导致在初始化阶段抛出FileNotFoundException异常

文件操作流的常用方法

类名称No.方法名称类型描述
FileInputStream 1public FileInputStream(File file) 构造 实例化FileInputStream，用于从指定文件中读取数据
FileInputStream 2public FileInputStream(Stirng name) 构造 实例化FileInputStream，用于从指定文件路径中读取数据
InputStream3public void close()普通关闭输入流
InputStream4public int read()普通从指定输入流中读取一个字节数据
InputStream5public int read(byte [] data)普通从指定流中读取多个字节
InputStream6public int read(byte [] data, int off, int len)普通从指定流中读取指定多个字节
FileOutputStream 7public FileOutputStream(File file) 构造方法 实例化FileOuputStream,用于新建数据
FileOutputStream 8public FileOutputStream(File file,boolean append) 构造方法 实例化FileOutputStream，用于追加数据
OutputStream9public void close()普通关闭输出流
OutputStream10public abstract void write(int b)普通向文件输出单个字节
OutputStream11public void write(byte [] b)普通向文件输出一组字节数据
OutputStream12public void write(byte [] b, int off, int len)普通向文件输出部分字节数据
代码示例
import java.io.File;
import java.io.OutputStream;
import java.io.InputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
public class TestDemo{
    public static void main(String [] args)throws Exception{
        // 指定操作文件
        File fileOut = new File("/home/linyimin/DaSi/java/OutputStream.txt");
        File fileIn = new File("/home/linyimin/DaSi/java/InputStream.txt");
        // 实例化FileOutputStream，向文件添加数据
        OutputStream out = new FileOutputStream(fileOut);
        // 实例化FileInputStream，从文件中读取数据
        InputStream in = new FileInputStream(fileIn);
        String str = "Hello World.";
        // 将字符串转换称字节数组
        byte [] data = str.getBytes();
        // 向文件中写如数据
        out.write(data);
        // 从文件中读取数据并输出
        int len = 0;
        byte [] temp = new byte[1024];
        while(len != -1){
            len = in.read(temp);
            if(len != -1){
                System.out.println(new String(temp, 0, len));   
            }
        }
        // 关闭输出流
        out.close();
        // 关闭输入流
        in.close();
    }
}

在以上的例子中，通过FileInputStream的read()方法从/home/linyimin/DaSi/java/InputStream.txt文件中读取信息，通过FileOutputStream的write()方法向/home/linyimin/DaSi/java/InputStream.txt文件写入“Hello World.”。在此操作中如果InputStream.txt已经存在，会先清空内容在写入信息，如果不存在，会自动创建InputStream.txt文件后在写入数据。如果希望在已存在的文件之后添加数据，应使用public FileOutputStream(fileOut,true)构造方法进行实例化对象，表示向已有文件中追加写入数据而不是覆盖已有数据。

内存操作:ByteArrayInputStream & ByteArrayOutputStream

在某个操作需要发生IO操作，但又不希望有一些临时文件产生，可以使用内存操作流完成，即以内存为操作的终端，以发生IO操作关系。用于以IO流的方式来完成对字节数组内容的读写，来支持类似内存虚拟文件或者内存映射文件的读写。

  • ByteArrayInputStream:字节数组输入流，继承自InputStream,它会在内存中创建一个字节数组缓冲区，实例化后的字节数组会保存在此缓冲区中。也就是 使用一个字节数组当中所有的数据作为数据源，程序可以像输入流方式一样读取字节，可以看作一个虚拟文件，用文件的方式读取里面的数据 。
  • ByteArrayOutputStream:字节数组输出流，继承自OutputStream，是与ByteArrayInputStream相对应的输出流。此类实现一个字节输出流，数据被写入一个byte字节数组。缓冲区会随着数据的不断写入而自动增长。

内存操作类的常用方法

类名称No.方法类型描述
ByteArrayInputStream 1public ByteArrayInputStream(byte [] buf) 构造 将字节流转换称输入流
ByteArrayInputStream 2public int read()普通从输入流中读取一个字节数据
ByteArrayInputStream 3public int read(byte [] data)普通从指定流中读取多个字节
ByteArrayInputStream 4public int read(byte [] data, int off, int len)普通从指定流中读取指定多个字节
ByteArrayOutputStream 5public ByteArrayOutputStream() 构造 创建一个32个字节
ByteArrayOutputStream 6public ByteArrayOutputStream(int size) 构造 根据参数指定大小创建缓冲区
ByteArrayOutputStream 7public void write(int b)普通往输出流中写入一个字节数据
ByteArrayOutputStream 8public void write(byte [] b)普通往输出流中写入一个字节数组数据
ByteArrayOutputStream 9public void write(byte [] b, int off, int len)普通往输出流中写入指定多个字节数据
ByteArrayOutputStream 10public String toString()普通使用默认编码将缓冲区数据编码成字符串并返回
ByteArrayOutputStream 11public byte [] toByteArray()普通将缓冲区数据通过字节数组返回
代码示例
import java.io.InputStream;
import java.io.OutputStream;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
public class TestDemo{
    public static void main(String [] args)throws Exception{
        String str = "abcdefghijklmnopqrstuvwsyz";
        // 将字符串转换成字节数组
        byte [] data = str.getBytes();
        // 将字节数组转换成输入流，即将数据输出到内存
        InputStream in = new ByteArrayInputStream(data);
        // 字节输出流的实例化，即从内存读取数据
        OutputStream out = new ByteArrayOutputStream();
        // 从ByteArrayInputStream中读取多个字节数据
        byte [] b = new byte[1024];
        int len = in.read(b);
        System.out.println(new String(b, 0, len));
        // 重置标志位置，从第一个字节开始读取字节数据
        in.reset();
        // 从ByteArrayInputStream中一个字节接一个字节读取数据
        int temp = in.read();
        while(temp != -1){
            // 往输出流写入从输入流中读取的数据，并把数据变为大写
            out.write(Character.toUpperCase(temp));
            System.out.print((char)temp + " ");
            temp = in.read();
        }
        System.out.println();
        // 从输出流中获取数据，并转换成字符数据
        System.out.println(out.toString());
    }
}

程序运行结果:
abcdefghijklmnopqrstuvwsyz
a b c d e f g h i j k l m n o p q r s t u v w s y z
ABCDEFGHIJKLMNOPQRSTUVWSYZ

在上面的例子中，我们通过字符串获取字节数组将其作为ByteArrayInputStream的数据流来源，然后通过读取ByteArrayInputStream的数据，将读到的数据写入到ByteArrayOutputStream中。

键盘操作:System.in

System.in是System类中的一个InputStream类型的常量，用于系统输入。系统输入针对标准的输入设备——键盘，也就是俗称的键盘输入数据，由于System.in是InputStream类型数据，所以接收的数据是字节型。通过调用read()函数完成键盘输入数据操作。

代码示例
import java.io.IOException;
import java.io.InputStream;

public class TestDemo{
    public static void main(String [] args) throws IOException{
        InputStream in = System.in;
        byte [] data = new byte[1024];
        // 从键盘输入多个数据，以回车键结束输入
        System.out.println("输入多个字节数据：");
        int len = in.read(data);
        System.out.println(new String(data, 0, len));
        System.out.println("一个字节接一个字节输入数据：");
        int temp = in.read();
        while(temp != -1){
            // 键入回车键，则退出输出
            if(temp == '\n'){
                break;
            }
            // 将输入的字母变为大写字母
            System.out.print((char)Character.toUpperCase(temp) + " ");
            // 从键盘输入一个字节数据
            temp = in.read();
        }
    }
}

程序运行结果:
输入多个字节数据：
Hello 中国
Hello 中国

一个字节接一个字节输入数据：
Hello 中国
H E L L O Ä ¸ ­ Å › ½

在上面的例子中，可以发现从键盘输入数据时，既可以多个字节数据同时输入，也可以一个接一个字节输入，但应注意的是， 在单个字节输入时，中文输出会发生乱码 ,一般在进行中文操作时，应使用字符流完成。

缓冲区操作:BufferedInputStream & BufferedOutputStream

  • BufferedInputStream是缓冲输入流，继承于FilterInputStream。作用是为其它输入流提供缓冲功能。BufferedInputStream会将输入流数据分批读取，每次读取一部分数据到缓冲中，操作完缓冲中的数据之后，在从输入流中读取下一部分的数据。即BufferedInputStream内部有一个字节数组缓冲区，每次执行read操作的时候就从这buf中读取数据，从buf中读取数据没有多大的开销。如果buf中已经没有了要读取的数据，那么就去执行其内部绑定的InputStream的read方法，而且是一次性读取很大一块数据，以便填充满buf缓冲区。于我们在执行BufferedInputStream的read操作的时候，很多时候都是从缓冲区中读取的数据，这样就大大减少了实际执行其指定的InputStream的read操作的次数，也就提高了读取的效率。

  • BufferedOutputStream是输出缓冲流，与BufferedInputStream相对，继承于FilterOutputStream。作用是为输出流提供缓冲功能。BufferedOutputStream内部有一个字节缓冲区buf，在执行write操作时，将要写入的数据先一起缓存在一起，将其存入字节缓冲区buf中，当buf被填充完毕的时候会调用BufferedOutputStream的flushBuffer方法，该方法会通过调用其绑定的OutputStream的write方法将buf中的数据进行实际的写入操作并将buf的指向归零（可以看做是将buf中的数据清空）。如果想让缓存区buf中的数据理解真的被写入OutputStream中，可以调用flush方法，flush方法内部会调用flushBuffer方法。由于buf的存在，会大大减少实际执行OutputStream的write操作的次数，优化了写的效率。

缓冲操作的常用方法

类名称No.方法类型描述
BufferedInputStream 1public BufferedInputStream(InputStream in) 构造 实例化BufferedInputStream，使用默认缓冲区大小
BufferedInputStream 2public BufferedInputStream(InputStream in, int size) 构造 实例化BufferedInputStream，指定缓冲区大小
BufferedInputStream 3public int read()普通从输入流中读取一个字节数据
BufferedInputStream 4public int read(byte [] data)普通从指定流中读取多个字节
BufferedInputStream 5public int read(byte [] data, int off, int len)普通从指定流中读取指定多个字节
BufferedOutputStream 6public BufferedOutputStream(OutputStream out) 构造 实例化BufferedOutputStream，使用默认缓冲区大小
BufferedOutputStream 7public BufferedOutputStream(OutputStream out, int size) 构造 实例化BufferedOutputStream，指定缓冲区大小
BufferedOutputStream 8public void write(int b)普通向输出缓冲区写入一个字节数据
BufferedOutputStream 9public void write(byte [] data)普通向输出缓冲区写入多个字节数据
BufferedOutputStream 10public void write(byte [] data, int off, int len)普通向输出缓冲取写入指定多个字节
BufferedOutputStream 11public void flush()普通清空缓冲区，缓存区buf中的数据理解真的被写入OutputStream中

代码示例

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class TestDemo{
    public static void main(String [] args) throws IOException{
        File fio = new File(File.separator + "home" + File.separator + "linyimin" + File.separator + "DaSi" +
                            File.separator + "java" + File.separator + "InputStream.txt");
        File fout = new File(File.separator + "home" + File.separator + "linyimin" + File.separator + "DaSi" +
                        File.separator + "java" + File.separator + "OutputStream.txt");
        // InputStream.txt不存在则创建文件
        if(!fio.exists()){
            fio.createNewFile();
        }
        // OutputStream.txt不存在则创建文件
        if(!fout.exists()){
            fout.createNewFile();
        }
        // 实例化BufferedInputStream
        BufferedInputStream ibuf = new BufferedInputStream(new FileInputStream(fio));
        // 实例化BufferedOutputStream
        BufferedOutputStream  obuf = new BufferedOutputStream(new FileOutputStream(fout));
        byte [] data = new byte[1024];
        // 从BufferedInputStream中多个字节数据
        int len = ibuf.read(data);
        while(len != -1){
            // 向BufferedOutputStream中写入多个数据
            obuf.write(data, 0, len);
            // 继续从BufferedInputStream中读取多个字节数据
            len = ibuf.read(data);
        }
        // 清空输出缓存区
        obuf.flush();
        // 关闭输出输入流
        ibuf.close();
        obuf.close();
    }
}

　程序运行结果:
程序运行前：OutputStream.txt文件不存在，InputStream.txt文件的内容为：
Hello World.
1234567890
程序运行后：OutputStream.txt文件的内容为：
Hello World.
1234567890

在上面的例子中，实现了将InputStream.txt拷贝到OutputStream.txt。其实不通过BufferedInputStream 和 BufferedOutputStream也可以完成这样的工作，使用这个两个类的好处是提升了文件拷贝的效率。下面进行验证：

  • 直接使用InputStream和OutputStream完成大文件赋值

代码

import java.io.File;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.math.BigDecimal;
public class TestDemo{
    public static void main(String [] args) throws IOException{
        File fio = new File("/home/linyimin/Downloads/linux_11gR2_database_2of2.zip");
        File fout = new File("/home/linyimin/Downloads/linux_11gR2_database_2of2-copy.zip");
        InputStream in = null;
        OutputStream out = null;
        // 创建文件
        try{
            fout.createNewFile();
            in = new FileInputStream(fio);
            out = new FileOutputStream(fout);
        }
        catch(Exception e){
            e.printStackTrace();
        }
        // 获取复制文件大小,并转换成单位M，保留两位小数
        double length = new BigDecimal(fio.length() / 1024.0 / 1024).divide(new BigDecimal(1), 2, BigDecimal.ROUND_HALF_UP).doubleValue();
        // 文件复制开始时间
        long start = System.currentTimeMillis();
        // 从输入流中读取多个字节数据
        byte [] data = new byte[1024];
        int len = in.read(data);
        while(len != -1){
            // 将从输入流中读出的数据写入输出流中
            out.write(data);
            // 继续从输入流中读取数据
            len = in.read(data);
        }
        // 文件复制结束时间
        long end = System.currentTimeMillis();
        // 将文件复制时间转换成秒并保留三位小数
        double time = new BigDecimal((end - start) / 1000.0).divide(new BigDecimal(1), 3, BigDecimal.ROUND_HALF_UP).doubleValue();
        System.out.println("复制大小为:" + length + "M的文件共花费时间：" + time + "s");

    }
}

程序运行结果:

复制大小为:949.25M的文件共花费时间：49.048s

  • 使用缓冲区完成大文件的复制

代码

import java.io.File;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.math.BigDecimal;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
public class TestDemo{
    public static void main(String [] args) throws IOException{
        File fio = new File("/home/linyimin/Downloads/linux_11gR2_database_2of2.zip");
        File fout = new File("/home/linyimin/Downloads/linux_11gR2_database_2of2-copy.zip");
        InputStream in = null;
        OutputStream out = null;
        // 创建文件
        try{
            fout.createNewFile();
            in = new BufferedInputStream(new FileInputStream(fio));
            out = new BufferedOutputStream(new FileOutputStream(fout));
        }
        catch(Exception e){
            e.printStackTrace();
        }
        // 获取复制文件大小,并转换成单位M，保留两位小数
        double length = new BigDecimal(fio.length() / 1024.0 / 1024).divide(new BigDecimal(1), 2, BigDecimal.ROUND_HALF_UP).doubleValue();
        // 文件复制开始时间
        long start = System.currentTimeMillis();
        // 从输入流中读取多个字节数据
        byte [] data = new byte[1024];
        int len = in.read(data);
        while(len != -1){
            // 将从输入流中读出的数据写入输出流中
            out.write(data);
            // 继续从输入流中读取数据
            len = in.read(data);
        }
        // 文件复制结束时间
        long end = System.currentTimeMillis();
        // 将文件复制时间转换成秒并保留三位小数
        double time = new BigDecimal((end - start) / 1000.0).divide(new BigDecimal(1), 3, BigDecimal.ROUND_HALF_UP).doubleValue();
        System.out.println("复制大小为:" + length + "M的文件共花费时间：" + time + "s");

    }
}

程序运行结果:

复制大小为:949.25M的文件共花费时间：32.93s

比较以上两个程序的执行结果，使用缓冲区操作的效率确实要提高不少。

管道流操作:PipeInputStream & PipeOutputStream

管道流操作主要用于两个线程之间进行管道通信。PipedInputStream和PipedOutputStream一般是结合使用的，一般在一个线程中执行PipedOutputStream 的write操作，而在另一个线程中执行PipedInputStream的read操作。单独使用PipedInputStream或单独使用PipedOutputStream时没有任何意义的，必须将二者通过connect方法（或在构造函数中传入对应的流）进行连接绑定，如果单独使用其中的某一个类，就会触发IOException: PipeNotConnected.

代码示例

import java.io.IOException;
import java.io.PipedInputStream;
import java.io.PipedOutputStream;
public class TestDemo{
    public static void main(String [] args)throws Exception{
        // 实例化PipedOutputStream
        final PipedOutputStream out = new PipedOutputStream();
        final PipedInputStream in = new PipedInputStream(out);
        // 使用匿名内部类实现线程t1
        Thread t1 = new Thread(new Runnable(){
            @Override
            public void run(){
                try {
                    out.write("Hello Pipe.".getBytes());
                } 
                catch (IOException e) {
                    e.printStackTrace();
                }
            }
        });
        // 使用匿名内部类实现线程t2
        Thread t2 = new Thread(new Runnable(){
            @Override
            public void run(){
            int len = 0;
            try {
                // 从线程t1中的输出流中读取数据
                while((len = in.read()) != -1){
                    System.out.print((char)len + " ");
                }
            } 
            catch (IOException e) {
            }
            System.out.println();
            }
            });
        // 启动线程 
        t1.start();
        t2.start();
    }
}

程序运行结果
H e l l o P i p e .

在上面的程序中，我们创建了两个线程，并通过构造方法将PipedInputStream流和PipedOutputStream绑定。线程t1在运行时往输出流中写入字节数据，而线程t2在运行时阻塞式的执行read操作，等待获取数据，并输出。

对象序列化和反序列化操作:ObjectInputStream & ObjectOutputStream
  • 对象序列化指的是将在内存中保存的对象数据（主要指的是一个对象里面所包含的属性内容）进行二进制传输的一种操作．
  • 反序列化：将已经被序列化的数据反序列化为对象．

注： 要实现序列化，对象所在类必须实现java.io.Serializable接口.Serializable接口没有方法，属于一种标识接口，表示一种一种能力．

如果一个类已经实现了序列化接口，那么此类的对象就可以经过二进制数据流进行传输，但是还需要对象输出流ObjectOutputStream和对象输入流ObjectInputStream完成对象的输入和输出．

  • ObjectOutputStream具有一系列writeXXX方法，在其构造函数中可以传入一个OutputStream，可以方便的向指定的输出流中写入基本类型数据以及String，比如writeBoolean、writeChar、writeInt、writeLong、writeFloat、writeDouble、writeCharts、writeUTF等，除此之外，ObjectOutputStream还具有writeObject方法。在执行writeObject操作时将对象进行序列化成流，并将其写入指定的输出流中。
  • ObjectInputStream与ObjectOutputStream相对应，ObjectInputStream有与OutputStream中的writeXXX系列方法完全对应的readXXX系列方法，专门用于读取OutputStream通过writeXXX写入的数据。

ObjectOutputStream和ObjectInputStream常用方法

类名称No.方法类型描述
ObjectOutputStream 1public ObjectOutputStream(OutputStream out) 构造 实例化指定输出流的对象
ObjectOutputStream 2public void writeObject(Object obj)普通向指定输流写入数据
ObjectInputStream ３public ObjectInputStream(InputStream in) 构造 实例化指定输入流的对象
ObjectInputStreaｍ ４public void readObject(Object obj)普通从指定输入流读出数据

代码示例－序列化

import java.io.File;
import java.io.Serializable;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;

// 定义可以被序列化的类
class Person implements Serializable{
    private String name;
    private int age;

    public Person(String name, int age){
        this.name = name;
        this.age =  age;
    }
}
public class TestDemo{
    public static void main(String [] args) throws FileNotFoundException, IOException{
        // 实例化序列化对象
        Person per = new Person("张三", 20);
        File file = new File("/home/linyimin/DaSi/java/serializable.txt");
        // 实例化ObjectOutputStream对象
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(file));
        // 序列化对象
        oos.writeObject(per);
        // 关闭输出流
        oos.close();

    }
}

程序运行结果:
文件serializable.txtx中的内容：
\AC\ED\00sr\00Person:H3\BC\B0\FC\00I\00ageL\00namet\00Ljava/lang/String;xp\00\00\00t\00张三

本程序使用ObjectOutputStream将一个已经实例化的对象序列化到文件中．

代码示例－反序列化

import java.io.File;
import java.io.Serializable;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.ObjectInputStream;

//定义可以被序列化的类
class Person implements Serializable{
    private String name;
    private int age;
    public Person(String name, int age){
        this.name = name;
        this.age = age;
    }
    @Override
    public String toString(){
        return "姓名：" + this.name + "   年龄：" + this.age;
    }
}
public class TestDemo{
    public static void main(String [] args) throws FileNotFoundException, IOException, ClassNotFoundException{
        // 实例化ObjectInputStream对象
        File fio = new File("/home/linyimin/DaSi/java/serializable.txt");
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream(fio));
        //　实现反序列化
        Person per = (Person) ois.readObject();
        ois.close();
        System.out.println(per);
    }
}

程序运行结果:

姓名：张三 年龄：20

本程序通过ObjectInputStream类将之前已经被序列化的数据反序列化为对象．

字符流

字符流和字节流十分相似，主要区别在于：

  • 字节流是针对字节的操作，而字符流是针对字符的操作
  • 字节流在进行IO操作时，直接针对的是操作的数据终端（如文件），而字符流是针对缓存区（可以理解为内存）的操作，然后由缓冲区操作终端（如文件）

下面主要介绍字符流较于字节流的区别之处：

使用Writer类进行输出的最大方便之处在于：可以直接输出字符串数据，而不像OutputStream类一样需要调用getBytes()函数将字符串转换成字节数组．

代码示例

import java.io.File;
import java.io.Writer;
import java.io.FileWriter;
public class TestDemo{
    public static void main(String [] args)throws Exception{
        File file = new File("/home/linyimin/DaSi/java/out.txt");
        //　如果文件不不存在，创建文件
        if(!file.exists()){
            file.createNewFile();
        }
        // 实例化FileWriter对象
        Writer out = new FileWriter(file);
        String str = "Hello World.";
        // 直接向文件中输出字符串
        out.write(str);
        // 需要关闭输出流，数据才会从缓存区写到文件中
        out.close();

    }
}

程序运行结果

创建out.txt文件，并写入”Hello World.＂

本程序通过FileWriter完成直接将字符串写入指定文件中．

转换流

所谓转换流指的是字节流向字符流转换的操作流．由InputStreamReader和OutputStreamWriter两个类完成．

  • InputStreamReader继承自Reader: InputStream –> Reader(使用构造方法完成）
  • OutputStreamWriter继承自Writer:OutputStream –> Writer（使用构造方法完成）

代码示例

import java.io.File;
import java.io.Writer;
import java.io.OutputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
public class TestDemo{
    public static void main(String [] args) throws IOException{
        File file = new File("/home/linyimin/DaSi/java/out.txt");
        // 实例化字节输出流
        OutputStream out = new FileOutputStream(file);
        // 将字节输出流转换成字符输出流
        Writer wout = new OutputStreamWriter(out);
        String str = "使用OutputStreamWriter完成输出流转换操作";
        // 直接向文件输出字符串
        try {
            wout.write(str);
        } catch (IOException e) {
            e.printStackTrace();
        }
        // 关闭输出流，完成IO操作
        wout.close();
    }
}

程序运行结果

向文件out.txt中输出字符串＂使用OutputStreamWriter完成输出流转换操作＂

注: 处理各种数据都可以通过字节流完成，而在处理中文时使用字符流会更好

lym152898
关注
  • 0
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
java 读取文件名称及内容
09-14 384
java 读取文件名称及内容
JavaIO总结
05-08
有关Java输入输出流的总结有关Java输入输出流的总结有关Java输入输出流的总结
关于BufferedInputStream的read(byte b[], int off, int len)方法读取文件部分出现的问题
一个沉迷Java，无法自拔的Coder
04-06 658
使用BufferedInputStream的read方法需要注意的一些问题
BufferedInputStream读取文本文件
Tomorrow never comes
09-27 1914
import java.io.BufferedInputStream; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.IOException; public class GetClassTest { /** * 从文件中读取文本 */ publ
BufferedInputStream读取文件
u012322628的博客
11-19 2342
FileInputStream fileInputStream = null; try{ fileInputStream = new FileInputStream(mTempFile); bufferedInputStream = new BufferedInputStream(fileInputStream); byte[] buffer = new byte[2048]; int size = 0; DataProcessor tempDataPro...
3种Java从文件路径中获取文件名的方法
fofu33的专栏
06-11 4217
package test;      import java.io.File;      public class FileName {          /**       * @param args       */       public static void main(String[] args) {   //      举例：           String
java IO流精讲
01-29
IO 简介，只看这篇，IO全部搞定，对于初学者来说，不可多得
JAVA IO-NIO 详解
最新发布
04-24
在Java中，IO（输入/输出）是程序与外部世界进行交互的重要桥梁，而NIO（非阻塞IO）则是Java IO的一个重要扩展，它提供了更为高效、灵活的数据处理方式。 传统的Java IO是阻塞式的，即当程序进行读写操作时，如果...
javaIO流javaIO流javaIO流
07-02
javaIO流javaIO流
java IO流详细笔记
07-12
Java IO流详解
JAVA程序怎么看文件名,Java根据文件名称，判断下载类型
weixin_36274103的博客
03-10 356
根据文件后缀名获取对应的MIME类型的两种常见方式如下：JMimeMagic该方式是通过检测magic headers来判断文件或者流的mime类型的java工具包。该插件在持续更新中，因此推荐使用。a. 加入依赖net.sf.jmimemagicjmimemagic0.1.5复制代码b. 示例代码public static void main(String[] args) throws Magi...
Java下载文件获取真实文件名
leeldy的专栏
07-24 2905
[code="java"] String imgurl = "文件地址"; URL url = new URL(imgurl); HttpURLConnection conn = (HttpURLConnection) url.openConnection(); conn.connect(); //获取文件名和扩展名 //先连接一次，解决跳转下载 ...
JAVA函数笔记
The_RedMaple的博客
06-08 220
JAVA常见类 Object类 protected Object clone() //对象克隆 int hashCode() //获取对象哈希值 boolean equals(Object obj) //判断两个对象是否相等 {return (this == obj);} 默认比较的是两个对象的内存地址，不够用，需要重写 重写的equals函数里的参数还是要是Object obj,否则不是重写，而是重载 String toString() //将对象转换成字...
java io 基础
07-28
Java IO（Input/Output）是Java编程语言中用于处理输入和输出的基础库。它提供了一种方便的方式来读取和写入数据，从而与外部世界进行交互。 Java IO库包含多个类和接口，用于在不同的场景下处理输入和输出。这些类和接口可以分为字节流（Byte Stream）和字符流（Character Stream）两种类型。 字节流主要用于处理二进制数据，而字符流则用于处理文本数据。 常用的字节流类有： - InputStream和OutputStream：用于读取和写入字节数据。 - FileInputStream和FileOutputStream：用于读取和写入文件。 - BufferedInputStream和BufferedOutputStream：提供了缓冲功能，以提高读写的效率。 常用的字符流类有： - Reader和Writer：用于读取和写入字符数据。 - FileReader和FileWriter：用于读取和写入文本文件。 - BufferedReader和BufferedWriter：提供了缓冲功能，以提高读写的效率。 除了字节流和字符流之外，Java IO还提供了一些其他的类和接口，用于处理特定类型的输入和输出。例如： - DataInputStream和DataOutputStream：用于读写基本数据类型及字符串。 - ObjectInputStream和ObjectOutputStream：用于读写Java对象。 - PrintWriter：用于格式化输出。 在使用Java IO时，通常需要使用try-catch语句来捕获可能抛出的异常，例如IOException。 总结起来，Java IO是Java编程语言中用于处理输入和输出的基础库，提供了字节流和字符流两种类型的处理方式，并且还包含其他一些类和接口，用于处理特定类型的输入和输出。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值