java实验：使用适当的I/O流类，将电商平台中书籍信息和用户信息分别用文件进行存储

最新推荐文章于 2023-06-16 10:25:52 发布

陆云池

最新推荐文章于 2023-06-16 10:25:52 发布

阅读量766

点赞数 2

文章标签：开发语言 java ide idea

本文链接：https://blog.csdn.net/m0_72471315/article/details/128152130

版权

文章目录

前言

好像很久没写点东西了（

感觉io流还是有点麻烦的，不过似乎有一套固定的操作，顺着操作下来也八九不离十了

一、实验内容

（1）完成书籍信息的添加、查询功能（操作文件实现）；

（2）完成用户信息的注册，登录功能（操作文件实现）；

二、实验思路

用File类操作文件，将数据储存到文件中

当我们创建对象时，只要需要，对象就会一直存在，但在程序终止的时候，无论如何它都不会继续存在。这么做有一定的意义，但是如果对象能够在程序不运行的情况下仍能存在并保存其信息，这样，在下次运行程序时，该对象将被重建并且拥有的信息与在程序上次运行时它所拥有的信息相同。为达到这目的，通常的做法可以写入文件或数据库，这样有其优点，但缺乏了某些便利性，在Java中，通过序列化技术，可以将对象声明为“持久性”的，为我们处理所有细节，显得十分方便。

Java的对象序列化将那些实现了 Serializable 接口的对象转换成一个字节序列，并能够在以后将这个字节序列完全恢复为原来的对象，这一过程甚至可以通过网络进行，也意味着能自动弥补不同操作系统之间的差异，运行在 Windows 系统的计算机上创建一个对象并序列化，通过网络将其发送给一台运行 Unix 系统的计算机，不必担心数据在不同机器上表示不同从而在那里重新组装。

三、实验代码

如下：


//所有的代码都在一个chapter10包里，后续导包的时候要注意这一点

import java.io.Serializable;

public class User implements Serializable {//代表这个类是可序列化的
    private String id;
    private String name;
    private String password;
    private char sex;
    private String city;
    private String role;
    public User() {
        super();
    }
    public User(String id, String name, String password, char sex, String city) {
        super();
        this.id = id;
        this.name = name;
        this.password = password;
        this.sex = sex;
        this.city = city;
    }
    public User(String id, String name, String password, char sex, String city, String role) {
        super();
        this.id = id;
        this.name = name;
        this.password = password;
        this.sex = sex;
        this.city = city;
        this.role = role;
    }
    public String getId() {
        return id;
    }
    public void setId(String id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getPassword() {
        return password;
    }
    public void setPassword(String password) {
        this.password = password;
    }
    public char getSex() {
        return sex;
    }
    public void setSex(char sex) {
        this.sex = sex;
    }
    public String getCity() {
        return city;
    }
    public void setCity(String city) {
        this.city = city;
    }
    public String getRole() {
        return role;
    }
    public void setRole(String role) {
        this.role = role;
    }
    @Override
    public String toString() {
        return "用户标号：" + id + ", 用户名" + name + ",密码：" + password + ", 性别：" + sex + ", 城市：" + city;
    }
}




import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;

import chapter10.User;

//将一个用户信息写入到user.txt文件进行持久化储存
//第一个版本：使用字节流将User类保存至文本
public class TestByteStream {
    public static void main(String[] args) throws IOException {
        //准备要写入的数据
        User u1 = new User("u004", "孙乔", "111", '女', "太原");
        User u2 = new User("u005", "孙小乔", "222", '女', "太原");
        User u3 = new User("u006", "孙大乔", "333", '女', "太原");
        //1、创建文件对象
        File file = new File("D:\\idea\\code\\chapter10\\src\\chapter10\\User1");
        //2、创建字节输入流对象
        OutputStream os = new FileOutputStream(file );
        //3、调用写入的方法
        os.write(u1.toString().getBytes());
        os.write("\r\n".getBytes());
        os.write(u2.toString().getBytes());
        os.write("\r\n".getBytes());
        os.write(u3.toString().getBytes());
        os.write("\r\n".getBytes());
        //4、关闭流
        os.close();
        //要求将文件的数据读取出来，在控制台打印输出

        //1、创建字节输出流对象
        InputStream is = new FileInputStream(file);
        //2、调用读的方法
        byte[] b = new byte[300];
        is.read(b);
        System.out.println(new String(b));
        //3、关闭流
        is.close();
    }

}




import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;

//第三个版本，使用缓冲流将User类保存至文本
public class TestBufferedStream {

    public static void main(String[] args) throws IOException {
        //准备要写的内容
        User u1=new User("u001","张尺寸","001",'男',"百京");
        User u2=new User("u010","张尺寸","001",'男',"百京");
        User u3=new User("u011","张尺寸","001",'男',"百京");
        //创建文件对象
        File file = new File("D:\\idea\\code\\chapter10\\src\\chapter10\\User2");

        //创建字符输出流对象（造细管）
        FileWriter fw=new FileWriter(file);
        //创建缓冲输出流对象（造粗管）
        BufferedWriter bw=new BufferedWriter(fw);
        //调用写方法，将用户信息写入文件
        bw.write(u1.toString());
        bw.newLine();
        bw.write(u2.toString());
        bw.newLine();
        bw.write(u3.toString());
        bw.newLine();
        //关闭流
        bw.close();
        fw.close();
    }
}


//在下面两个版本中，处理后的数据不是文数据

import java.io.*;
import java.util.Arrays;

import chapter10.User;

//第四个版本：使用对象流将User类保存至文本
public class TestObjectStream {

    public static void main(String[] args) throws IOException, ClassNotFoundException {
        // TODO Auto-generated method stub
        //准备数据
        User u1 = new User("u001", "王雅", "000", '女', "运城");
        User u2 = new User("u002", "李亚淇", "111", '女', "临汾");
        User u3 = new User("u003", "豆豆", "222", '女', "大同");
        //创建文件对象
        File file = new File("D:\\idea\\code\\chapter10\\src\\chapter10\\user3");
        //创建字节输出流对象（细管）
        OutputStream os = new FileOutputStream(file);
        //创建对象输出流对象（粗管）
        ObjectOutputStream oos = new ObjectOutputStream(os);
        //调用写的方法
        oos.writeObject(u1);
        oos.writeObject(u2);
        oos.writeObject(u3);
        //对Java对象进行序列化处理，处理后的数据不是文本数据，所以把数据保存到文本文档中后打开是乱码
        //关闭流
        oos.close();
        os.close();

        //读文件
        InputStream is = new FileInputStream(file);
        ObjectInputStream ois = new ObjectInputStream(is);
        u1 =(User)ois.readObject();
        u2 =(User)ois.readObject();
        u3 =(User)ois.readObject();
        System.out.println(u1);
        System.out.println(u2);
        System.out.println(u3);
        ois.close();
        is.close();
    }

}




import java.io.*;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

import chapter10.User;

//第五个版本：结合集合框架使用对象流将User类保存至文本
//1、需要把若干用户对象，保存到集合中
//2、把集合序列化
//3、反序列化读取时，只需要读取一次，转换为集合类型
//4、遍历集合，打印输出所有用户信息
public class TestObjectStreamUsingCollection {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        User u1 = new User("u001", "王雅", "000", '女', "运城");
        User u2 = new User("u002", "李亚淇", "111", '女', "临汾");
        User u3 = new User("u003", "豆豆", "222", '女', "大同");
        Set<User> users = new HashSet<User>();
        users.add(u1);
        users.add(u2);
        users.add(u3);
        File file = new File("D:\\idea\\code\\chapter10\\src\\chapter10\\user4");
        OutputStream os = new FileOutputStream(file);
        ObjectOutputStream oos = new ObjectOutputStream(os);
        oos.writeObject(users);
        oos.close();
        os.close();

        InputStream is = new FileInputStream(file);
        ObjectInputStream ois = new ObjectInputStream(is);
        HashSet<User> hs = (HashSet<User>)ois.readObject();
        Iterator it = hs.iterator();
        while(it.hasNext()) {
            System.out.println(it.next());
        }
        ois.close();
        is.close();
    }

}



import java.io.File;
public class TestFileDemo {
    public static void main(String[] args) {
        //构造方法
        //第一种构造方法:根据字符串形成的路径获取File对象  File(String path);
        File f1 = new File("D:\\javacode\\1.txt");  //将文件包装成file对象
        File f2 = new File("D:\\javacode");  //将文件夹包装成file对象
        //第二种构造方法：根据字符串形式的父目录及子目录创建file对象
        File f3 = new File("D:\\idea\\chapter10\\src\\chapter10", "luyunchi.txt");
        //第三种构造方法：根据父目录对象以及字符串形式的子目录来获取File对象
        File f4 = new File("D:\\javacode");
        File f5 = new File(f4, "filedemo.txt");
        System.out.println(f1.exists());
        System.out.println(f3.exists());
        System.out.println(f5.isFile());
    }

}