Java_对象流

Posted 2021-09-15 小企鹅推雪球!

文章目录

• Java_对象流_ObjectInputStream和OjbectOutputSteam
• • Java_对象序列化的特点
  • Java_对序列化进行一致性验证
  • Java_使用Serializeable接口实现序列化
  • Java_Java NIO 概述
  • Java_NIO.2中Path、Paths、Files类的使用
  • Java_NIO.2中Path常用方法
  • Java_NIO.2中Files 类

Java_对象流_ObjectInputStream和OjbectOutputSteam

1. ObjectInputStream和OjbectOutputSteam用于存储和读取基本数据类型数据或对象的处理流。
2. ObjectInputStream和OjbectOutputSteam的强大之处就是可以把Java中的对象写入到数据源中，也能把对象从数据源中还原回来。
3. 序列化：用ObjectOutputStream类保存基本类型数据或对象的机制
4. 反序列化：用ObjectInputStream类读取基本类型数据或对象的机制
5. ObjectOutputStream和ObjectInputStream不能序列化static和transient修饰的成员变量

Java_对象序列化的特点

1. 对象序列化机制允许把内存中的Java对象转换成平台无关的二进制流，从而允许把这种二进制流持久地保存在磁盘上，或通过网络将这种二进制流传输到另一个网络节点。
2. 当其它程序获取进行过对象序列化的二进制流，就可以恢复成原来的Java对象
3. 序列化的好处在于可将任何实现了Serializable接口的对象转化为字节数据，使其在保存和传输时可被还原
4. 序列化是 RMI（Remote Method Invoke – 远程方法调用）过程的参数和返回值都必须实现的机制，而RMI 是 JavaEE的基础。因此序列化机制是JavaEE 平台的基础
5. 如果需要让某个对象支持序列化机制，则必须让对象所属的类及其属性是可序列化的，
6. 类必须实现Serializable或Externalizable接口才能序列化或反序列化。否则，会抛出NotSerializableException异常:
7. 凡是实现Serializable接口的类都有一个表示序列化版本标识符的静态变量：private static final long serialVersionUID;``serialVersionUID用来表明类的不同版本间的兼容性,如果类没有显示定义这个静态常量，它的值是Java运行时环境根据类的内部细节自动生成的。
8. 若类的实例变量做了修改，serialVersionUID可能发生变化。所以显式声明。

Java_对序列化进行一致性验证

1. Java的序列化机制是通过在运行时判断类的serialVersionUID来验证版本一致性的。
2. 在进行反序列化时，JVM会把传来的字节流中的serialVersionUID与本地相应实体类的serialVersionUID进行比较，如果相同就认为是一致的，可以进行反序列化，否则就会出现序列化版本不一致的异常。(InvalidCastException)

Java_使用Serializeable接口实现序列化

1. Serializable接口是一个标记接口。
2. 如果我们想要一个Person类的对象被序列化，我们需要声明Person类如下：

public class Person   implements Serializable  {
    
}

3. Java负责处理向流读取或写入Serializable对象的细节,只需要将对象写入流或读取流写入到流中的方法
4. 实现Externalizable接口能够更好的控制从流中读取和写入对象,Externalizable接口继承Serializable接口,

Externalizable 接口的声明如下:

public interface  Externalizable extends Serializable  {
    void  readExternal(ObjectInput in)  throws   IOException,  ClassNotFoundException;
    void  writeExternal(ObjectOutput out) throws   IOException;
}

1. 当从流中读取一个对象时,Java调用readExternal()方法,向流中写入对象时,使用writeExternal()方法

实现可序列化接口的Person类

package com.company;

import java.io.*;

// 实现可序列化的 person 类
public class Java_47 {
    // private static final long serialVersionUID;
    static class Person implements Serializable {
        long serialVersionUID;
        private String name = "Unknown";
        private String gender = "Unknown";
        private double height = Double.NaN;

        public Person(String name, String gender, double height) {
            this.name = name;
            this.gender = gender;
            this.height = height;
        }

        @Override
        public String toString() {
            return "Name: " + this.name + ", Gender:   " + this.gender + ",  Height: " + this.height;
        }
    }

    public static void main(String[] args) {
            Person p1 = new Person("John", "Male", 1.7);
            Person p2 = new Person("Wally", "Male", 1.7);
            Person p3 = new Person("Katrina", "Female", 1.4);

//          创建保存对象序列化的文件
            File fileObject = new File("H:/IDE_Java_Work/src/com/person.ser");

//          创建ObjectOutputStream类的对象，并将对象保存到person.ser文件。
            try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(fileObject))) {
//              使用 writeObject()方法通过将对象引用作为参数传递来序列化对象
//                `ObjectOutputStream 对象的 writeObject(对象) `方法输出可序列化对象
                oos.writeObject(p1);
                oos.writeObject(p2);
                oos.writeObject(p3);


                // Display the serialized objects on the standard output
                System.out.println(p1);
                System.out.println(p2);
                System.out.println(p3);
//              注意写出一次，操作`flush()`一次
                oos.flush();
                oos.close();


            } catch (IOException e) {
//                关闭对象输入流
                e.printStackTrace();
            }

            System.out.println("写入完成,反序列化开始");
//   	  创建ObjectInputStream类的对象，并从person.ser文件读取对象
//        File ReadfileObject = new File("H:/IDE_Java_Work/src/com/person.ser");
        try(ObjectInputStream ois = new ObjectInputStream(new FileInputStream(fileObject))){
//         使用ObjectInputStream类的readObject()方法来反序列化对象。(即读取文件)
            Person p4 = (Person) ois.readObject();
            Person p5 = (Person) ois.readObject();
            Person p6 = (Person) ois.readObject();


            System.out.println(p4);
            System.out.println(p5);
            System.out.println(p6);

            ois.close();
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

反序列化

1. 创建一个 ObjectInputStream
2. 调用 readObject() 方法读取流中的对象
3. 强调：如果某个类的属性不是基本数据类型或String 类型，而是另一个引用类型，那么这个引用类型必须是可序列化的，否则拥有该类型的File的类也不能序列化

//序列化：将对象写入到磁盘或者进行网络传输。
//要求对象必须实现序列化

ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(“data.txt"));
Person p = new Person("韩梅梅", 18, "中华大街", new Pet());
oos.writeObject(p);
oos.flush();
oos.close();

//反序列化：将磁盘中的对象数据源读出。

ObjectInputStream ois = new ObjectInputStream(new FileInputStream(“data.txt"));
Person p1 = (Person)ois.readObject();
System.out.println(p1.toString());
ois.close();

Java_Java NIO 概述

1. Java NIO (New IO，Non-Blocking IO)是一套新的IO API，可以替代标准的Java IO API。NIO与原来的IO有同样的作用和目的，但是使用的方式完全不同，NIO支持面向缓冲区的(IO是面向流的)、基于通道的IO操作。NIO将以更加高效的方式进行文件的读写操作。
2. Java API中提供了两套NIO，一套是针对标准输入输出NIO，另一套就是网络编程NIO

Java_NIO.2中Path、Paths、Files类的使用

1. 早期的Java只提供了一个File类来访问文件系统，但File类的功能比较有限，所提供的方法性能也不高。而且，大多数方法在出错时仅返回失败，并不会提供异常信息。
2. NIO. 2为了弥补这种不足，引入了Path接口，代表一个平台无关的平台路径，描述了目录结构中文件的位置。Path可以看成是File类的升级版本，实际引用的资源也可以不存在。

在以前IO操作都是这样写的:
import java.io.File;
File file = new File("index.html");

但在Java7 中，我们可以这样写：
import java.nio.file.Path; 
import java.nio.file.Paths; 
Path path = Paths.get("index.html");

3. NIO.2在java.nio.file包下还提供了Files、Paths工具类，Files包含了大量静态的工具方法来操作文件；Paths则包含了两个返回Path的静态工厂方法。
4. Paths 类提供的静态 get()方法用来获取Path对象：
5. static Path get(String first, String … more): 用于将多个字符串串连成路径
6. static Path get(URI uri): 返回指定uri对应的Path路径

Java_NIO.2中Path常用方法

1. String toString() ： 返回调用 Path 对象的字符串表示形式
2. boolean startsWith(String path): 判断是否以 path 路径开始
3. boolean endsWith(String path) : 判断是否以 path 路径结束
4. boolean isAbsolute() : 判断是否是绝对路径
5. Path getParent()：返回Path对象包含整个路径，不包含 Path 对象指定的文件路径
6. Path getRoot()：返回调用 Path 对象的根路径
7. Path getFileName() : 返回与调用 Path 对象关联的文件名
8. int getNameCount() : 返回Path 根目录后面元素的数量
9. Path getName(int idx) : 返回指定索引位置 idx 的路径名称
10. Path toAbsolutePath(): 作为绝对路径返回调用 Path 对象
11. Path resolve(Path p):合并两个路径，返回合并后的路径对应的Path对象
12. File toFile(): 将Path转化为File类的对象

Java_NIO.2中Files 类

1. java.nio.file.Files 用于操作文件或目录的工具类。

Files常用方法：

1. Path copy(Path src, Path dest, CopyOption … how): 文件的复制
2. Path createDirectory(Path path, FileAttribute<?> … attr) : 创建一个目录
3. Path createFile(Path path, FileAttribute<?> … arr): 创建一个文件
4. void delete(Path path) : 删除一个文件/目录，如果不存在，执行报错
5. void deleteIfExists(Path path) : Path对应的文件/目录如果存在，执行删除
6. Path move(Path src, Path dest, CopyOption…how): 将 src 移动到 dest 位置
7. long size(Path path) : 返回 path 指定文件的大小

Files常用方法：用于判断

1. boolean exists(Path path, LinkOption … opts): 判断文件是否存在
2. boolean isDirectory(Path path, LinkOption … opts) : 判断是否是目录
3. boolean isRegularFile(Path path, LinkOption … opts) : 判断是否是文件
4. boolean isHidden(Path path) : 判断是否是隐藏文件
5. boolean isReadable(Path path) : 判断文件是否可读
6. boolean isWritable(Path path) : 判断文件是否可写
7. boolean notExists(Path path, LinkOption … opts) : 判断文件是否不存在

Files常用方法：用于操作内容

1. SeekableByteChannel newByteChannel(Path path, OpenOption…how): 获取与指定文件的连接，how 指定打开方式。
2. DirectoryStream<Path> newDirectoryStream(Path path) : 打开 path 指定的目录
3. InputStream newInputStream(Path path, OpenOption…how):获取 InputStream 对象
4. OutputStream newOutputStream(Path path, OpenOption…how) : 获取 OutputStream 对象