Java IO流操作(FileInputStream、ByteArrayInputStream、ObjectInputStream)

一、介绍

        java 的IO流操作主要分为字节流和字符流，每个流都会有输入和输出两种类型的流。所有的字节流类都继承自InputStream 和 OutputStream 这两个抽象类，而所有的字符流类是都继承自Reader 和 Writer 这两个抽象类。字节流的处理单位是字节，通常用来处理二进制文件，如音乐、图片文件等。而字符流的处理单位是字符，通常来处理文本。对流进行操作之后，都要记得关闭它。BufferInputStream和BufferOutputStream是字节缓冲流，BufferReader和BufferWriter是字符缓冲流。缓冲流的读写速度比正常的来的快

二、FileInputStream字节流

1、介绍。

        FileInputStream是Java语言中抽象类InputStream用来具体实现类的创建对象。FileInputStream可以从文件系统中的某个文件中获得输入字节，获取的文件可用性取决于主机环境。FileInputStream的构造方法需要指定文件的来源，通过打开一个到实际文件的连接来创建一个FileInputStream，该文件通过文件系统中的 File 对象 file 指定。

2、代码。

private static final String Pre_Path = "G:\\项目测试\\io流文件测试\\";

public static void main(String[] args) {
    fileInputTest(); //文件的复制(字节流)
}

//文件的复制(字节流)
private static void fileInputTest() {
    InputStream inputStream = null;//输入流
    OutputStream outputStream = null;//输出流
    try {
        inputStream = new FileInputStream(Pre_Path + "fileStream\\01.jpg");
        outputStream = new FileOutputStream(Pre_Path + "fileStream\\02.jpg");
        //从输入流读取0 到 255数量的字节,并写入输出流中
        int readByte;
        while ((readByte = inputStream.read()) != -1) {
            outputStream.write(readByte);
        }
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        try {
            if (inputStream != null) {
                inputStream.close();
            }
            if (outputStream != null) {
                outputStream.close();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

3、测试文件：

4、结果。

三、ByteArrayInputStream字节流

1、介绍。

        字节数组输入流在内存中创建一个字节数组缓冲区，从输入流读取的数据保存在该字节数组缓冲区中。

2、代码。

    private static final String Pre_Path = "G:\\项目测试\\io流文件测试\\";

    public static void main(String[] args) {
        byteArrayStreamTest();//将小写字符串转为大写字符串
    }

    //将小写字符串转为大写字符串
    private static void byteArrayStreamTest() {
        //将字符串转为字节数组
        String lowerStr = "qwer";
        System.out.println("小写字符串：" + lowerStr);
        byte[] lowerByteArray = lowerStr.getBytes();
        System.out.println("小写字符串的字节数组：" + Arrays.toString(lowerByteArray));
        //
        ByteArrayInputStream inputStream = null;//输入流
        ByteArrayOutputStream outputStream = null;//输出流
        try {
            inputStream = new ByteArrayInputStream(lowerByteArray);
            outputStream = new ByteArrayOutputStream();
            int readByte;
            while ((readByte = inputStream.read()) != -1) {
                int upperChar = Character.toUpperCase((char) readByte);
                outputStream.write(upperChar);
            }
            //将字节数组转为字符串
            byte[] upperByteArray = outputStream.toByteArray();
            System.out.println("大写字符串的字节数组：" + Arrays.toString(upperByteArray));
            String upperStr = new String(upperByteArray);
            System.out.println("大写字符串：" + upperStr);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (inputStream != null) {
                    inputStream.close();
                }
                if (outputStream != null) {
                    outputStream.close();
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

3、结果。

四、ObjectInputStream字节流。

1、介绍。

        将对象的原始数据序列化，ObjectOutputStream将序列化的数据反序列化。当分别使用FileInputStream和FileOutStream做为输入和输出流ObjectInputStream和ObjectOutputStream是可以提供持久化的应用程序。ObjectInputStream 用于恢复先前序列化的对象，其它的用途包括主机之间使用socket流传递对象、远程系统调用。

2、代码（对象一定要继承Serializable接口）。

    private static final String Pre_Path = "G:\\项目测试\\io流文件测试\\";

    public static void main(String[] args) {
        objectStreamTest();//序列化对象到文件中，并从文件中得到反序列对象
    }

    //序列化对象到文件中，并从文件中得到反序列对象
    private static void objectStreamTest() {
        //初始化对象
        User user = new User();
        user.setUsername("admin");
        user.setPassword("123456");
        System.out.println("要序列化到文件中的对象：" + user);
        //
        ObjectInputStream inputStream = null;//输入流
        ObjectOutputStream outputStream = null;//输出流
        try {
            //将对象序列化到文件中
            outputStream = new ObjectOutputStream(new FileOutputStream(Pre_Path + "objectStream\\user.txt"));
            outputStream.writeObject(user);
            //从文件中得到反序列化对象
            inputStream = new ObjectInputStream(new FileInputStream(Pre_Path + "objectStream\\user.txt"));
            User userFromFile = (User) inputStream.readObject();
            System.out.println("从文件中反序列化的对象：" + userFromFile);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (inputStream != null) {
                    inputStream.close();
                }
                if (outputStream != null) {
                    outputStream.close();
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

public class User implements Serializable {
    private String username;
    private String password;

    public User() {
    }

    public User(String username, String password) {
        this.username = username;
        this.password = password;
    }

    public String getUsername() {
        return username;
    }

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

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    @Override
    public String toString() {
        return "User{" +
                "username='" + username + '\'' +
                ", password='" + password + '\'' +
                '}';
    }
}

3、结果。