Java IO流操作(InputStream、OutputStream)

版权声明:本文为博主原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接和本声明。
本文链接: https://blog.csdn.net/qq_36511401/article/details/102711786

一、介绍

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

二、FileInputStream字节流

1、介绍。

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

2、代码。

public static void main(String[] args){
    fileInputStreamTest();//文件的复制}

//文件的复制
private static void fileInputStreamTest(){
    InputStream inputStream = null;
    OutputStream outputStream = null;
    try {
        inputStream = new FileInputStream("G:\\项目测试\\io流文件测试\\fileInputStream\\01.jpg");//输入流
        outputStream = new FileOutputStream("G:\\项目测试\\io流文件测试\\fileInputStream\\02.jpg");//输出流
        //从输入流读取0 到 255数量的字节,并写入输出流中
        int i;
        while ((i = inputStream.read()) != -1) {
            outputStream.write(i);
        }
    } 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、代码。

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

    //将小写字符串转为大写字符串
    private static void byteArrayInputStreamTest() {
        //将字符串转为字节数组
        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 i;
            while ((i = inputStream.read()) != -1) {
                int upperChar = Character.toUpperCase((char) i);
                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接口)。

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

    //序列化对象到文件中,并从文件中得到反序列对象
    private static void objectOutputStreamTest() {
        //初始化对象
        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("G:\\项目测试\\io流文件测试\\objectInputStream\\user.txt"));
            outputStream.writeObject(user);
            //从文件中得到反序列化对象
            inputStream = new ObjectInputStream(new FileInputStream("G:\\项目测试\\io流文件测试\\objectInputStream\\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、结果。

猜你喜欢

转载自blog.csdn.net/qq_36511401/article/details/102711786