首页 > 编程语言 >java_day16_IO、序列化

java_day16_IO、序列化

时间：2024-10-18 21:48:49浏览次数：1  
标签：java String int write day16 new 序列化 public out

一、IO流

IO流划分

IO流【输入输出流】：
    按照流向划分：
        输入流：外部数据 -> java程序
        输出流：java程序 -> 外部数据


按照数据类型划分【根据使用记事本打开是否能够看懂来决定】
字节流【万能流】：
    字节输入流：
        InputStream【抽象类】
            - FileInputStream【实现子类】【普通字节输入流】
            - BufferedInputStream【字节缓冲输入流】

    字节输出流：
        OutputStream【抽象类】
            - FileOutputStream【实现子类】【普通字节输出流】
            - BufferedOutputStream【字节缓冲输出流】

字符流：
    字符输入流：
        Reader【抽象类】
            - InputStreamReader【具体实现子类】【普通字符输入流】
                - FileReader【继承自InputStreamReader】
            - BufferedReader 【字符缓冲输入流】

    字符输出流：
        Writer【抽象类】
            - OutputStreamWriter【具体实现子类】【普通字符输出流】
                - FileWriter【继承自OutputStreamWriter】
            - BufferedWriter【字符缓冲输出流】

一、字节流

1、字节输入流

普通字节输入流

字节流【万能流】：
字节输入流：
    InputStream（抽象类）
        - FileInputStream（实现子类）

    FileInputStream：
        构造方法：
            FileInputStream(File file)
            FileInputStream(String name)
        成员方法：
            public int read()
            public int read(byte[] b)

代码案例：

public class FileInputStreamDemo1 {
    public static void main(String[] args) throws Exception {
//        FileInputStream fis = new FileInputStream(new File("java/src/com/shujia/day16/a1.txt"));
        FileInputStream fis = new FileInputStream("java/src/com/shujia/day16/a1.txt");

        //public int read() 一次只读取一个字节
        // 如果没有读到数据，返回-1
//        System.out.print((char)fis.read());
//        System.out.print((char)fis.read());
//        System.out.print((char)fis.read());
//        System.out.print((char)fis.read());
//        System.out.print((char)fis.read());
//        System.out.print((char)fis.read());
//        System.out.print((char)fis.read());
//        int i = 0;
//        while ((i = fis.read()) != -1) {
//            System.out.print((char) i);
//        }

        //public int read(byte[] b) 一次读取一个字节数组
        //创建一个字节数组，用作接收读取到的字节
        byte[] bytes = new byte[7];
        int length = 0;
        while ((length = fis.read(bytes))!=-1){
            //读取到的字节在字节数组中
            //返回的是实际读取到的字节数
            //将字节数组转字符串
            String s = new String(bytes,0,length);
            System.out.print(s);
        }




        // 释放资源
        fis.close();
    }
}

字节缓冲输入流

InputStream:
    FileInputStream【普通的字节输入流】:
    BufferedInputStream【字节缓冲输入流】:

代码案例：

public class BufferedInputStreamDemo1 {
    public static void main(String[] args) throws Exception {
        //BufferedInputStream(InputStream in)
        //创建一个 BufferedInputStream并保存其参数，输入流 in ，供以后使用。
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("java/src/com/shujia/day16/a1.txt"));

        // 一次读一个字节
//        int i = 0;
//        while ((i=bis.read())!=-1){
//            System.out.print((char) i);
//        }

        // 一次都一个字节数组
        byte[] bytes = new byte[1024];
        int length = 0;
        while ((length = bis.read(bytes)) != -1) {
            String s = new String(bytes, 0, length);
            System.out.print(s);
        }


        //释放资源
        bis.close();
    }
}

2、字节输出流

普通字节输出流

字节流【万能流】：
    字节输出流：
       OutputStream（抽象类）
          - FileOutputStream（实现子类）

  FileOutputStream：
    构造方法：
        FileOutputStream(File file)
        FileOutputStream(String name)

代码案例：

public class FileOutputStreamDemo1 {
    public static void main(String[] args) throws Exception{
        // FileOutputStream(File file) 将目标文件封装成File对象
        // 若目标文件不存在，则会自动创建
//        FileOutputStream fos = new FileOutputStream(new File("java/src/com/shujia/day16/a1.txt"));

        //FileOutputStream(String name)
        FileOutputStream fos = new FileOutputStream("java/src/com/shujia/day16/a1.txt");


    }
}

public void write(int b)
public void write(byte[] b)
public void write(byte[] b,int off,int len)

代码案例：

public class FileOutputStreamDemo2 {
    public static void main(String[] args) throws Exception{
//        FileOutputStream fos = new FileOutputStream("java/src/com/shujia/day16/a1.txt");
        //public FileOutputStream(String name, boolean append)
        FileOutputStream fos = new FileOutputStream("java/src/com/shujia/day16/a1.txt", true);

        //public void write(int b) 写一个ASCII码值
//        fos.write(97);

        // public void write(byte[] b) 写一个字节数组到文件中
//        byte[] bytes = {97,98,99,100,101,102};
//        fos.write(bytes);


        //public void write(byte[] b,int index,int len)
//        fos.write(bytes,2,3);

        fos.write("\r\n".getBytes());
        fos.write("李刚真帅！".getBytes());

        //释放资源
        fos.close();
    }
}

字节缓冲输出流

OutputStream:
    FileOutputStream【普通的字节输出流】：
    BufferedOutputStream【字节缓冲输出流】：

代码案例：

public class FileOutputStreamDemo2 {
    public static void main(String[] args) throws Exception{
//        FileOutputStream fos = new FileOutputStream("java/src/com/shujia/day16/a1.txt");
        //public FileOutputStream(String name, boolean append)
        FileOutputStream fos = new FileOutputStream("java/src/com/shujia/day16/a1.txt", true);

        //public void write(int b) 写一个ASCII码值
//        fos.write(97);

        // public void write(byte[] b) 写一个字节数组到文件中
//        byte[] bytes = {97,98,99,100,101,102};
//        fos.write(bytes);


        //public void write(byte[] b,int index,int len)
//        fos.write(bytes,2,3);

        fos.write("\r\n".getBytes());
        fos.write("李刚真帅！".getBytes());

        //释放资源
        fos.close();
    }
}

二、字符流

1、字符输入流

普通字符输入流

字符流：
   字符输入流：
       Reader【抽象类】
           - InputStreamReader【具体实现子类】
               - FileReader【继承自InputStreamReader】

   InputStreamReader：
        构造方法：
            InputStreamReader(InputStream in) 创建一个使用默认字符集的InputStreamReader。
            InputStreamReader(InputStream in, String charsetName) 创建一个使用命名字符集的InputStreamReader。
        成员方法：
            public int read()
            public int read(char[] cbuf)

代码案例：

public class InputStreamReaderDemo1 {
    public static void main(String[] args) throws Exception {
//        InputStreamReader isr = new InputStreamReader(new FileInputStream("java/src/com/shujia/day16/a3.txt"));
        //InputStreamReader(InputStream in, String charsetName)
        InputStreamReader isr = new InputStreamReader(new FileInputStream("java/src/com/shujia/day16/a3.txt"), "GBK");


        // public int read() 一次都一个字符
//        System.out.print((char) isr.read());
//        System.out.print((char) isr.read());
//        int i = 0;
//        while ((i = isr.read()) != -1) {
//            System.out.print((char) i);
//        }

        //public int read(char[] cbuf) 一次读取一个字符数组
        char[] chars = new char[1024];
        int length = 0;
        while ((length= isr.read(chars))!=-1){
            String s = new String(chars, 0, length);
            System.out.print(s);
        }


        // 释放资源
        isr.close();
    }
}

用上面的InPutStreamReader创建字符输入流对象，还要传入一个字节输入流对象，挺麻烦的，java还有一个类描述字符输入流，FileReader，使用该类创建字符输入流对象只用传文件地址就行了
FileReader：

字符缓冲输入流

字符输出流：
    Writer【抽象类】
       - OutputStreamWriter【具体实现子类】
            - FileWriter【继承自OutputStreamWriter】
       - BufferedWriter【字符缓冲输出流】

    BufferedReader 【字符缓冲输入流】:
        构造方法：
            BufferedReader(Reader in) 创建使用默认大小的输入缓冲区的缓冲字符输入流。
        特殊功能：
            public String readLine() 一次读取文本文件内容的一行, 不会读取换行符

代码案例：

public class BufferedReaderDemo1 {
    public static void main(String[] args) throws Exception {
        //创建字符缓冲输入流对象
//        BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream("java/src/com/shujia/day16/b3.txt")));
        BufferedReader br = new BufferedReader(new FileReader("java/src/com/shujia/day16/b3.txt"));

        //一次读一个字符
//        int i = 0;
//        while ((i=br.read())!=-1){
//            System.out.print((char) i);
//        }

        //一次读一个字符数组
//        char[] chars = new char[1024];
//        int length = 0;
//        while ((length=br.read(chars))!=-1){
//            String s = new String(chars, 0, length);
//            System.out.print(s);
//        }

        //一次读取一行数据
//        System.out.println(br.readLine());
//        System.out.println(br.readLine());
//        System.out.println(br.readLine());
//        System.out.println(br.readLine());
        String line = null;
        while ((line = br.readLine()) != null) {
            System.out.println(line);
        }

        //释放资源
        br.close();
    }
}

2、字符输出流

普通字符输出流

字符输出流：
    Writer【抽象类】
        - OutputStreamWriter【具体实现子类】

OutputStreamWriter：
    构造方法：
        OutputStreamWriter(OutputStream out) 创建一个使用默认字符编码的OutputStreamWriter。
        OutputStreamWriter(OutputStream out, String charsetName) 创建一个使用命名字符集的OutputStreamWriter。
    成员方法：
        public void write(int c)
        public void write(char[] cbuf)
        public void write(char[] cbuf,int off,int len)
        public void write(String str)
        public void write(String str,int off,int len)

代码案例：


```plaintext
public class OutputStreamWriterDemo1 {
    public static void main(String[] args) throws Exception{
//        String s1 = "今天下午放假，不上课！";
////        byte[] bytes = s1.getBytes();
//        byte[] bytes = s1.getBytes("GBK");
//        System.out.println(Arrays.toString(bytes));
//
//        String s = new String(bytes,"GBK");
//        System.out.println(s);

        // 创建OutputStreamWriter(OutputStream out)对象
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("java/src/com/shujia/day16/a3.txt"),"GBK");

        // public void write(int c) 一次写一个字符
//        osw.write(97);
//        osw.flush();

        //public void write(char[] cbuf) 一次写一个字符数组
//        char[] chars = {'我','爱','数','加'};
//        osw.write(chars);

        //public void write(char[] cbuf,int off,int len) 一次写字符数组的一部分
//        osw.write(chars,1,3);
//        osw.flush();

        //public void write(String str) 直接写一个字符串
//        osw.write("李刚是32期最帅的男人！");
//        osw.flush();

        //public void write(String str,int off,int len) 写字符串的一部分
//        osw.write("李刚是32期最帅的男人！",6,2);

        osw.write("中国");
        osw.flush();


        //释放资源
        osw.close();

    }
}

用上面的OutStreamReader创建字符输入流对象，还要传入一个字节输出流对象，挺麻烦的，java还有一个类描述字符输出流，FileWriter，使用该类创建字符输出流对象只用传文件地址就行了
FileWriter：
代码案例：

public class FileWriterDemo1 {
    public static void main(String[] args) throws Exception{
        //创建字符输出流对象
//        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("java/src/com/shujia/day16/b3.txt"));
//        FileWriter fw = new FileWriter("java/src/com/shujia/day16/b2.txt");

        //创建字符输入流对象
//        InputStreamReader isr = new InputStreamReader(new FileInputStream("java/src/com/shujia/day16/b2.txt"));
        FileReader fr = new FileReader("java/src/com/shujia/day16/b2.txt");

        //一次读一个字符
//        int i = 0;
//        while ((i = fr.read())!=-1){
//            System.out.print((char) i);
//        }

        //一次读一个字符数组
        char[] chars = new char[1024];
        int length = 0;
        while ((length = fr.read(chars))!=-1){
            String s = new String(chars, 0, length);
            System.out.print(s);
        }


//        fw.write("今天的天气不错！");
//        fw.flush();

        fr.close();
//        fw.close();
    }
}

字符缓冲输出流

字符输出流：
    Writer【抽象类】
        - OutputStreamWriter【具体实现子类】
            - FileWriter【继承自OutputStreamWriter】
        - BufferedWriter【字符缓冲输出流】

  BufferedWriter【字符缓冲输出流】：
        构造方法：
            BufferedWriter(Writer out) 创建使用默认大小的输出缓冲区的缓冲字符输出流。
        特殊方法：
            newLine(); // 默认会自动根据当前的系统生成一个换行符

代码案例：

public class BufferedWriterDemo1 {
    public static void main(String[] args) throws Exception{
        //BufferedWriter(Writer out) 创建使用默认大小的输出缓冲区的缓冲字符输出流。
//        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("java/src/com/shujia/day16/b3.txt")));
        BufferedWriter bw = new BufferedWriter(new FileWriter("java/src/com/shujia/day16/b3.txt"));

        bw.write("落霞与孤鹜齐飞");
//        bw.write("\r\n"); // 这里的换行符需要根据将来运行的系统环境来设置
        bw.newLine(); // 默认会自动根据当前的系统生成一个换行符
        bw.write("秋水共长天一色");

        bw.flush();


        //释放资源
        bw.close();
    }
}

二、序列化

序列化：将对象转化成数据流一样在网络中传输
    对象输出流：ObjectOutputStream
    只有实现了Serializable接口的类的对象才可以进行序列化

反序列化：将网络中数据流还原成一个对象
    对象输入流：ObjectInputStream

 我们正常写一个对象之后，读取一个对象都是没有问题的。
 但是当我们修改了原来的类的时候，再次读取存储的对象就报错了
 java.io.InvalidClassException:
 com.shujia.day16.Teacher;
  local class incompatible:
    stream class desc serialVersionUID = -4530247781226673719,
    local class serialVersionUID = -4180828856871739850

 若不想让某一个成员序列化的话，只需要在该成员前面加上transient关键字

代码案例：

public class ObjectOutputStreamDemo1 {
    public static void main(String[] args) throws Exception{
//        write();

        read();
    }
    public static void read() throws Exception{
        //ObjectInputStream(InputStream in)
        //创建从指定的InputStream读取的ObjectInputStream
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("java/src/com/shujia/day16/obj.txt"));
        Object o = ois.readObject(); //Object o = new Teacher("小虎", 18)
        Teacher t1 = (Teacher)o;
        System.out.println(t1);


        ois.close();
    }

    public static void write() throws Exception{
        Teacher t1 = new Teacher("小虎", 18);
        //创建ObjectOutputStream对象
        //ObjectOutputStream(OutputStream out)
        //创建一个写入指定的OutputStream的ObjectOutputStream。
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("java/src/com/shujia/day16/obj.txt"));
        oos.writeObject(t1);
        oos.flush();

        //释放资源
        oos.close();
    }
}

三、总结

当一个文件打开能看懂，用字符缓冲流，看不懂用字节缓冲流

标签：java,String,int,write,day16,new,序列化,public,out
From： https://www.cnblogs.com/w-ll/p/18475119

相关文章

  • (附论文)JavaWeb基于ssm的高校毕业设计信息管理系统(054)
    获取源码请滑到最底部访问官网项目配套调试视频和相对应的软件安装包1、项目描述具体请看视频演示2、项目开发工具开发工具：Idea或Eclipse数据库：MysqlJar包仓库：Maven前端框架：Vue2后端框架：SSM3、项目图片4、演示视频(附论文)JavaWeb基于ssm的高校毕业设计信息管理......
  • 计算机毕业设计 | java swing 销售管理系统(附源码)
    1，概述1.1选题背景近几年来，传统商业与电商似乎是水火不容，大有不是你死便是我活的劲头。一直以来舆论都是一边倒的电商将迅速取代传统零售的论调，然而几年过去，电商的发展确实值得侧目，但传统商业虽然受到不小的影响，也依然顽强地挺立。事实上，就零售市场总规模而言，仍然是实体......
  • Java方法使用的细节
    在Java中，方法是一段可重用的逻辑代码块，用于执行特定的任务。以下是关于Java方法使用的一些细节：方法声明：方法应该先声明，再调用。方法的声明包括方法名、参数列表、返回类型和方法体。方法名应该以小写字母开头，并采用驼峰命名法。参数列表包括参数的类型和名称，多个参数之间用逗......
  • Java 初学 day13
    day13数据结构1、栈栈：入口和出口是一个反向，且取出的顺序是先进后出。数据进入栈中叫入栈也叫压栈，数据从栈中被取出叫出栈也叫弹栈栈数据结构的特点：先进后出场景：将A，B，C按顺序存入栈中并取出存储的顺序：ABC取出的顺序：CBA2、队列队列：入口和出口是反方向的，且取出的顺序是......
  • javascript-类型
    1.number使用64位浮点数表示范围+-1.797*10（308次方），+-5*10(-324次方），相当于C++的double整数-2（53次方）2(53次方）十六进制0x开头例0xff八进制0o开头0io377二进制0b开头使用e表示浮点数6.02e231.47e-322.数的计算，在math类中有很多方法。3.没有上溢，下溢。但有无限大无......
  • 基于Java+Springboot+Vue开发的鲜牛奶订购管理系统
    项目简介该项目是基于Java+Springboot+Vue开发的鲜牛奶订购管理系统（前后端分离），这是一项为大学生课程设计作业而开发的项目。该系统旨在帮助大学生学习并掌握Java编程技能，同时锻炼他们的项目设计与开发能力。通过学习基于Java的鲜牛奶订购管理系统项目，大学生可以在实践中学......
  • Java中的反射机制，如何应用反射？
    目录1.类比“万能钥匙”来理解反射机制2.反射机制的优点有哪些？3.代码示例4.扩展知识5.反射的性能考虑        Java的反射机制是指在运行时获取类的结构信息(如方法、字段、构造函数)，并操作对象的一种机制。反射机制提供了在运行时动态创建对象、调用方法、......
  • 【Java】多线程 Start（） 与 run（） （简洁实操）
    Java系列文章目录补充内容Windows通过SSH连接Linux第一章Linux基本命令的学习与Linux历史文章目录Java系列文章目录一、前言二、学习内容：三、问题描述start()方法run()方法四、解决方案：4.1重复调用.run()4.2重复调用start()4.3正常调用start()不会报出......
  • 学 Python 还是 Java 更好找工作？
    对于很多想进入编程领域的小伙伴来说，Python和Java这两门编程语言常常让人难以抉择。无论你是新手还是有经验的开发者，选择学习哪一门语言直接关系到未来的职业发展。那么，学Python还是Java更容易找到工作呢？近年来，随着AI、自动化、区块链等技术的崛起，Python的应用逐渐扩展到......
  • JavaScript从零学起 —— 数据类型（进阶篇3）
    说明：此文章用作个人学习记录，若有任何问题或建议欢迎大家在评论区讨论文章目录前言对象(Object)1.定义2.对象创建方式2.1使用对象字面量（ObjectLiteral）2.2使用Object()构造函数2.3使用自定义构造函数（ConstructorFunction）2.4工厂函数（FactoryFunction）2.5类（Cl......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99