字节流，字符流，序列化和反序列化

最新推荐文章于 2024-05-18 16:42:38 发布

꧁惜若༒奔已꧂

最新推荐文章于 2024-05-18 16:42:38 发布

阅读量120

点赞数

文章标签： java 缓存

惜若

本文链接：https://blog.csdn.net/qq_69581907/article/details/130212915

版权

字节流

可以操作所有的所有类型的文件

1.文件对象
    //创建文件对象
    File file = new File("文件的所在的路径");
    //如果文件的所在的路径不存在，则创建对应的文件夹，如果已存在，则无效果
    file.createNewFile();

2.字节输出对象(程序对文件进行输出)[直接对文件进行操作]
    //创建输出对象
    FileOutPutStream fops = new FileOutPutStream("文件所在的路径");
    //将字符串转换为字节存入到指定文件中
    String num = "中国";
    fops.write(num.getBytes());
    //关闭输出流
    fops.close();

3.字节输入流对象(程序读取指定文件的内容)[直接对文件进行操作]
    FileInputStream fis = new FileInputStream("文件指定路径");
    //计算读取的次数
    int count = 0;
    //存入每次读取的内容，每次读取10个字节
    byte[] b = new byte[10];
    //当每次读取的次数非等于-1时
    while ((count = s.read(l)) != -1){
        //将读取的内容转换为字符串，并输出
        System.out.println(new String(b,0,count));
    }
    //关闭输入流对象
    fis.close();

4.字节流输出对象加强版(程序对文件进行输出)[先将要操作的内容放到缓冲区，等所有操作执行完成，一并在放入缓存文件]
    //加强版的属于高层流，使用加强版的时候必须要有底层流
    //创建底层流输出对象
    FileOutPutStream fops = new FileOutPutStream("文件所在的路径");
    //创建高层流输出对象
    BufferedOutputStream bffops = new BufferedOutputStream(fops);
    //将字符串转换为字节存入到指定文件中
    String num = "中国";
    bffops.write(num.getBytes());
    //关闭输出流,先关闭高层流，在关闭底层流
    fops.close();

5.字节流输入对象加强版(从指定文件读取内容到程序中)[先将要操作的内容放到缓冲区，等所有操作执行完成，一并在放入]
    //加强版的属于高层流，使用加强版的时候必须要有底层流
    //创建底层流读取对象
    FileInPutStream fops = new FileInPutStream("文件所在的路径");
    //创建高层流读取对象
    BUfferedInputStream bis = new BUfferedInputStream(BUfferedInputStream);
    //计算读取的次数
    int count = 0;
    //存入每次读取的内容，每次读取10个字节
    byte[] b = new byte[10];
    //当每次读取的次数非等于-1时
    while ((count = bis.read(l)) != -1){
        //将读取的内容转换为字符串，并输出
        System.out.println(new String(b,0,count));
    }
    //关闭输出流,先关闭高层流，在关闭底层流
    bis.close();
    fops.close();

字符流

1.只能操作纯文本的文件

1.  //创建字符流输出对象
    FileWriter fw = new FileWriter("指定文件的路径");
    //直接将字符串写入到指定文件中，因为他是对字符操作，而不用转字节型
    String num = "张三";
    fw.writer(num);
    //关闭流
    fw.close();

2.  //构建输入(读取)对象
    FileReader fr = new FileReader("指定文件的路径");
    //定义变量保存数据
    int b ;
    //存入字符数据的数组，每次读取两个字符
    char[] c = new char[2];
    //循环读取
    while ((b=r.read(c)) != -1) {
        System.out.print(new String(c,0,b));
    }
    //关闭流
    r.close();

4.  //创建底层流
    FileWriter fw = new FileWriter("D:\\桌面\\新建文件夹\\zs.txt");
    //创建写入对象
    BufferedWriter bw = new BufferedWriter(fw);
    bw.write("张三是sb");
    //关闭流
    bw.close();
    fw.close();

5.  //创建底层流
    FileReader fr = new FileReader("D:\\桌面\\新建文件夹\\zs.txt");
    //创建高层流
    BufferedReader br = new BufferedReader(fr);
    String str = null;
    while ((str=br.readLine()) != null) {
        System.out.println(str);
    }

序列化和反序列化

Java序列化就是指把Java对象转换为字节序列的过程
Java反序列化就是指把字节序列恢复为Java对象的过程。

        要实现序列化时，对象一定要实现Serializable接口，否则不能序列化成功

1.序列化(将对象存入文件中)
        //创建map集合对象
        Map map = new HashMap();
        //创建多个学生对象
        Student zs = new Student(1,"张三",15);
        Student zl = new Student(2,"赵六",16);
        Student ww = new Student(3,"王五",17);
        //将学生对象存入集合中
        map.put(zs.getId(),zs);
        map.put(zl.getId(),zl);
        map.put(ww.getId(),ww);
        //创建底层流，指定路径
        FileOutputStream fio = new FileOutputStream("D:\\桌面\\新建文件夹\\zs.txt");
        //创建序列化对象
        ObjectOutputStream oop = new ObjectOutputStream(fio);
        //将集合存入到指定文件
        oop.writeObject(map);
        //关闭写流
        oop.close();
        fio.close();

2.反序列化(将存入文件中的对象读取出来)
        //创建读取底层流对象
        FileInputStream ism = new FileInputStream("D:\\桌面\\新建文件夹\\zs.txt");
        //创建反序列化对象
        ObjectInputStream ins = new ObjectInputStream(ism);
        //读取指定文件
        Map map1 = (Map)ins.readObject();
        //获取集合
        //System.out.println(map);
        for (Object i : map1.keySet()) {
            System.out.println("key:"+i+",value:"+map1.get(i));
        }
        //关闭流
        ins.close();
        ism.close();