IO流(一)

内容概要：

Java以流的形式处理所有输入和输出。流是随通信路径从源移动到目的地的字节序列。

内存与存储设备之间传输数据的通道

流的分类：

按方向

输入流：将存储空间中的内容读到内存中硬盘-->内存外部源-->程序

输出流：将内存中的内容写到存储设备中

按单位

字节流：以字节为单位，可以读写所有数据

字符流：以字符为单位，只能读写文本数据

按功能

节点流：具有实际传输数据的读写功能

过滤流：在节点流的基础之上增强功能

缓冲流

缓冲输入流

可以说没有定义缓冲流时，我在进行输入流时，就像拿着灌满水的水杯往缸里装水，定义缓冲区后，我就先将杯子里的水装进水桶里，待水桶装满，再将水桶中的水往缸里倒。

减少往缸里运水的次数，从而提高效率

import java.io.BufferedInputStream;

import java.io.FileInputStream;

import java.io.FileNotFoundException;

import java.io.IOException;

//BufferedInputStream

public class Demo03 {

    public static void main(String[] args) throws IOException {

        FileInputStream fis = new FileInputStream("d:\\1764\\aaa.txt");

        //BufferedInputStream bis = new BufferedInputStream(fis);

//定义缓冲区

        /*int data = 0;

        while ((data = bis.read()) != -1){

            System.out.print((char)data);

        }*/

        //自定义缓冲区

        byte[] buf = new byte[1024];

        int count = 0;

        while ((count = fis.read(buf)) != -1){

            System.out.println(new String(buf,0,count));

        }

        bis.close();//只需关闭缓冲输入流，输入流也会跟着关闭

    }

}

缓冲输出流

import java.io.BufferedOutputStream;

import java.io.FileNotFoundException;

import java.io.FileOutputStream;

import java.io.IOException;

//字节输出缓冲流

public class Demo04 {

    public static void main(String[] args) throws IOException {

        FileOutputStream fos = new FileOutputStream("d:\\1764\\aaa.txt");

        BufferedOutputStream bos = new BufferedOutputStream(fos);

        int count = 0;

        for (int i = 0; i < 10; i++) {

            bos.write("helloworld\n".getBytes());//写入缓冲区

            bos.flush();//刷新到硬盘，如果没有写，当断电时，会出现没有写到硬盘上的问题，导致数据丢失；在write中当缓冲区满时，会自动调用flushBuffer方法写出

        }

        bos.close();//关闭的时候内部也会调用flush方法

        System.out.println("打印结束");

    }

}

一什么叫序列化

通俗点讲：它是处理对象流的一种机制，即可以很方便的保存内存中java对象的状态，同时也为了方便传输。

二序列化有什么作用

1.方便传输，速度快，还很安全，被调用方序列化，调用方反序列化即可拿到传输前最原始的java对象，常用于不同进程之间的对象传输

2.方便存储，不管是存储成文件还是数据库，都行，存储为文件，下回要用可以直接反序列拿到对象

三怎么序列化和反序列化

实现序列化接口就行（里面什么方法都没有，不用管的，只是一个标记接口而已）Serializable；

至于他们的代码怎么写，网上例子很多，随便搜一下就行了


//ObjectOutputStream实现对象的序列化
  Student

//序列化类必须实现Serializable接口

//标志可以进行序列化

import java.io.*;

//序列化类必须实现Serializable接口

class Student implements Serializable {  //标志可以进行序列化

    private String name;

    private int age;

    public Student() {

    }

    public Student(String name, int age) {

        this.name = name;

        this.age = age;

    }

    public String getName() {

        return name;

    }

    public void setName(String name) {

        this.name = name;

    }

    public int getAge() {

        return age;

    }

    public void setAge(int age) {

        this.age = age;

    }

    @Override

    public String toString() {

        return "Student{" +

                "name='" + name + '\'' +

                ", age=" + age +

                '}';

    }

}

//ObjectOutputStream实现对象的序列化

public class Demo05 {

    public static void main(String[] args) throws IOException {

        //创建对象流

        FileOutputStream fos = new FileOutputStream("d:\\1764\\aaa.txt");

        ObjectOutputStream oos = new ObjectOutputStream(fos);

        //进行序列化(写入操作)

        Student s1 = new Student("张三",20);

        oos.writeObject(s1);

        oos.close();

        System.out.println("序列化完毕");

    }

}

//使用ObjectInputStream实现反序列化(读取重构成对象)

//使用ObjectInputStream实现反序列化(读取重构成对象)

import java.io.FileInputStream;

import java.io.IOException;

import java.io.ObjectInputStream;public class Demo06 {

    public static void main(String[] args) throws IOException, ClassNotFoundException {

        //创建对象流

        FileInputStream fis = new FileInputStream("d:\\1764\\aaa.txt");

        ObjectInputStream ois = new ObjectInputStream(fis);

        //读取文件(反序列化)

        Student s = (Student) ois.readObject();

        ois.close();

        System.out.println("执行完毕");

        System.out.println(s.toString());

    }

}

关于序列化类

import java.io.*;

import java.lang.reflect.Array;

import java.util.ArrayList;

import java.util.LinkedList;

//1.序列化类必须要实现Serializable接口

//2.序列化类中对象属性要求实现Serializable接口

//3.序列化版本号ID serialVersionUID,保证序列化的类和反序列化的类是同一个类

//4.使用transient(瞬间的) 修饰属性,这个属性不能序列化

//5.静态属性不能序列化

//6.序列化多个对象,可以借助集合实现

//ObjectOutputStream实现对象的序列化

public class Demo05 {

    public static void main(String[] args) throws IOException {

        //创建对象流

        FileOutputStream fos = new FileOutputStream("d:\\1764\\aaa.txt");

        ObjectOutputStream oos = new ObjectOutputStream(fos);

        //进行序列化(写入操作)

        Student s1 = new Student("张三",20);

        Student s2 = new Student("李四",18);

        ArrayList<Student> list = new ArrayList<>();

        list.add(s1);

        list.add(s2);

        oos.writeObject(list);

        oos.close();

        System.out.println("序列化完毕");

    }

}

then ObjectInputStream

//使用ObjectInputStream实现反序列化(读取重构成对象)

import java.io.FileInputStream;

import java.io.IOException;

import java.io.ObjectInputStream;

import java.io.Serializable;

import java.util.ArrayList;

public class Demo06 {

    public static void main(String[] args) throws IOException, ClassNotFoundException {

        //创建对象流

//        new String();//ctrl shift alt u

        FileInputStream fis = new FileInputStream("d:\\1764\\aaa.txt");

        ObjectInputStream ois = new ObjectInputStream(fis);

        //读取文件(反序列化)

//        Student s = (Student) ois.readObject();

//        Student s1 = (Student) ois.readObject();

        ArrayList<Student> list = (ArrayList<Student>) ois.readObject();

        ois.close();

        System.out.println("执行完毕");

        System.out.println(list.toString());

    }

}

巴特西

IO流(一)

最新文章

热门文章