BCSP-玄子JAVA开发之面向对 象编程CH09_ Java IO流笔记

已于 2023-02-18 22:50:45 修改
阅读量451 收藏 2
点赞数 1
分类专栏： # JAVASE + JAVAOOP 文章标签： java jvm 开发语言
于 2023-02-18 22:49:27 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_62283694/article/details/129105821
版权

BCSP-玄子JAVA开发之面向对 象编程CH09_ Java IO流笔记

9.1 File 类

是java.io包下代表操作与平台无关的文件和目录的类，实现对文件或目录的新建、删除、重命名等操作

File file = new File( String pathname );
// 创建File类对象时，必须设置文件路径
// pathname 文件路径

绝对路径：以根目录开头的完整路径

相对路径：相对于当前目录文件的路径

.表示当前目录

..表示上级目录

Windows文件路径名中，分隔符可以使用正斜杠/，也可以使用反斜杠\。但必须写成\\，其中第一个\表示转义符

9.1.1 File类的常用方法

方法名描述
boolean createNewFile()创建新文件
boolean delete()删除文件
boolean exists()判断文件是否存在
Boolean isFile()判断是否是文件
boolean isDirectory()判断是否是目录
long length()返回文件长度，单位为字节 若文件不存在，则返回0L
String getPath()返回此对象文件名所对应的路径
String getAbsolutePath()返回此对象表示的文件的绝对路径名

在实际开发中，如需完成对File类的更多操作，可随时查阅API帮助文档

package CH09_IO.IO;

import java.io.File;
import java.io.IOException;

public class MyIO {
    public static void main(String[] args) {
        File file = new File("XuanZi.txt");
        if (file.exists()) {
            if (file.isFile()) {
                System.out.println("文件名：" + file.getName() + ",文件长度：" + file.length() + "字节。");
                System.out.println("文件路径是：" + file.getPath());
                System.out.println("文件绝对路径是：" + file.getAbsolutePath());
            }
            if (file.isDirectory()) {
                System.out.println("此文件是目录");
            }
        } else {
            System.out.println("此文件不存在！");
        }
    }

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-CUMkpVnq-1676731747226)(./assets/image-20230216232759203.png)]

package CH09_IO.IO;

import java.io.File;
import java.io.IOException;

public class MyFile {
    public static void main(String[] args) {
        File file = new File("resources/XuanZi.txt");
        // 指定文件路径
        File dirs = file.getParentFile();
        // 获取上级文件路径
        if (!dirs.exists()) {
            // 判断上级文件夹是否存在
            dirs.mkdirs();
            // 创建上级文件夹
        }
        try {
            file.createNewFile();
            // 创建文件
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}

public void deleteFile(File file) {
    if (file.exists()) {
        file.delete();
         //删除文件
        System.out.println("文件删除成功！");
    }
}

9.2 IO 流概述

IO流是指一连串流动的字符，以先进先出方式发送信息的通道

  • I：input，指读入操作

  • O：output，指写出操作

Java把所有流类型都封装到java.io包中，以实现输入/输出操作

9.2.1 Java 流的分类

  • 按流向划分：输入流和输出流

  • 按处理单元划分：字节流和字符流

  • 按流的角色划分：节点流和处理流

9.2.2 按流向划分：输入流和输出流

输入流

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6mJVxBR7-1676731747229)(./assets/image-20230217004345541.png)]

只能从中读取数据，而不能写入数据的流，实现程序从数据源中读数据

输出流

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-juimZCrw-1676731747229)(./assets/image-20230217004349220.png)]

只能向其写入数据，而不能从中读数据的流，实现程序向目标数据源中写数据

  • 输入流主要由InputStream和Reader作为基类

  • 输出流则主要由OutputStream和Writer作为基类

  • 都是抽象类，无法直接实例化对象

按照流的流向进行分类时，输入流完成数据读入操作，输出流完成数据写出操作，这里的出和入一定是从程序运行所在内存的角度来论述

9.2.3 按处理单元划分：字节流和字符流

字节流

  • 以8位字节为操作数据单元的流，可操作二进制数据

  • 可细分为字节输入流、字节输出流

字符流

  • 以16位字符为操作数据单元的流，可操作文本数据

  • 可细分为字符输入流、字符输出流

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qHAThTWu-1676731747229)(./assets/image-20230217004450803.png)]

区别

  • 操作的数据单元不同

  • 使用方法几乎相同

9.2.4 按流的角色划分：节点流和处理流

节点流（包装流）

  • 可以直接向一个特定的存储介质（如磁盘、文件）读写数据的流

  • 使用节点流进行读写数据操作时，程序直接连接到数据源

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tsvE7GEr-1676731747230)(./assets/image-20230216234219675.png)]

处理流

  • 对已存在的流进行连接和封装，通过封装后的流实现数据读写操作的流

  • 使用处理流进行读写操作时，程序并不会直接连接到实际的数据源

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-oPg7ppGq-1676731747230)(./assets/image-20230216234211113.png)]

使用处理流包装节点流，通过处理流执行输入和输出功能，让节点流与文件或磁盘等存储设置交互，可隐藏底层节点流的差异

9.3 字节流

具有输入和输出操作

主要操作byte类型数据

基类

  • 字节输出流类： OutputStream

  • 字节输入流类：InputStream

9.3.1 字节输出流的基类：OutputStream

是抽象类，必须使用该类的子类进行实例化对象

常用方法

方法描述
void close()关闭输出流
void flush()刷新缓冲区
void write(byte[] b)将每个byte数组写入数据流
void write(byte[] b,int off,int len)将每一个指定范围的byte数组写入数据流
void write(int b)将一个字节数据写入数据流

如果需要操作文件，则使用FileOutputStream实例化

9.3.2 字节输出流FileOutputStream类

使用OutputStream类的FileOutputStream子类向文本文件写入数据

常用构造方法

方法描述
FileOutputStream( File file)创建向指定File对象写数据的文件输出流 file：指定目标文件的对象
FileOutputStream( String name)创建向指定路径的文件写数据的文件输出流 name：指定目标文件的路径字符串
FileOutputStream( String name, boolean append)创建一个向指定路径的文件写入数据的文件输出流 name：指定目标文件的路径字符串 append：表示是否在文件末尾追加数据。如果为true，则表示可以在文件末尾追加数据

9.3.3 创建文件输出流对象的常用方式

//方式一：使用File对象构造对象
File file = new File("D:\\mydoc\\test.txt");
OutputStream fos = new FileOutputStream(file);
//方式二：使用文件路径构造对象
OutputStream fos = new FileOutputStream("D:\\doc\\test.txt");
//方式三：使用文件路径构造对象，且可向文件末尾追加数据
OutputStream fos = new FileOutputStream("D:\\doc\\test.txt"，true);

使用FileOutputStream类的构造方法创建对象时

如果相应的文件不存在，就会自动新建一个文件

如果参数file或name表示的文件路径是一个目录，则会抛出FileNotFoundException异常

9.3.4实现步骤

  1. 导入相关的类
  2. 构造文件输出流FileOutputStream对象
  3. 把数据写入文本文件
  4. 关闭文件输出流对象
package CH09_IO.IO;

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;

public class MyFileOutputStream {
    public static void main(String[] args) throws IOException {
        OutputStream fos = new FileOutputStream("resources/XuanZi.txt", true);
        //准备一个字符串
        String str = "I love Java!";
        //将字符串转换为byte数组
        byte[] words = str.getBytes();
        fos.write(words, 0, words.length);
        System.out.println("文件已写入成功！");
        if (fos != null) {
            fos.close();
        }
    }
}

创建输出流对象、执行写操作、关闭输出流时都可能会有IOException异常发生

因此，除处理FileNotFoundException异常外，还需处理IOException异常

9.3.5 字节输入流的基类：InputStream

从文件中读数据，与OutputStream一样，也是抽象类

常用方法

方法描述
int read()读取一个字节数据
int read(byte[] b)将数据读取到字节数组中
int read(byte[] b,int off,int len)从输入流中读取最多len长度的字节，保存到字节数组中，保存的位置从off开始
void close()关闭输入流
int available()返回输入流读取的字节数

9.3.6 字节输入流 FileInputStream 类

使用InputStream类的FileInputStream子类实现文本文件内容的读取

常用构造方法

方法描述
FileInputStream(File file)用于创建从指定File对象读取数据的文件输入流 file：指定目标文件数据源对象
FileInputStream( String name)用于创建从指定路径的文件读取数据的文件输入流 name：指定目标文件数据源路径字符串

9.3.7 创建文件输入流对象的常用方式

//方式一：使用File对象构造对象
File file = new File("D:\\doc\\test.txt");
InputStream fis = new FileInputStream(file);
//方式二：使用文件路径构造对象
InputStream fis = new FileInputStream("D:\\doc\\test.txt");

从文件读取到计算机内存中的过程

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-PGHmuMLw-1676731747230)(./assets/image-20230217005442035.png)]

read()方法

  • 每次读取一个字节（0~255的整数）

  • 每次读取多个字节

读取文件中全部数据

while( (data=fis.read()) != -1 ) {
    // 判断是否到文件尾
      System.out.print( (char)  data);
    // 强制类型转换
}

按字节读取并显示数据时需进行强制类型转换

使用read()读取文件中的数据时，当返回结果为-1时，即输入流已经读到末尾

在创建输入流对象、读取数据、关闭流时必须进行异常处理

9.3.8 实现步骤

  1. 构造文件输入流FileInputStream对象
  2. 读取文本文件中数据
  3. 关闭文件输入流对象
package CH09_IO.IO;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;

public class MyFileInputStream {
    public static void main(String[] args) throws IOException {
        File file = new File("resources/XuanZi.txt");
        FileInputStream fis = new FileInputStream(file);
        System.out.println("可读取的字节数：" + fis.available());
        System.out.println("----------");
        byte[] bytes = new byte[1024];
        int len = 0;
        while ((len = fis.read(bytes)) != -1) {
            String s = new String(bytes, 0, len);
            System.out.println(s);
        }
        fis.close();
    }
}

文本文件保存时，采用GBK编码方式，每个中文占2个字节

read()方法一次读取1个字节（半个中文字符）

当数组长度不足时，可能导致中文乱码

9.4 字符流

一个字符占用内存的两个字节

  • 当输入和输出是文本文件时，尽量使用字符流

  • 使用Reader类和Writer类操作字符

基类

  • 字符输出流类： Writer

  • 字符输入流类：Reader

使用字符流读写文本更合适

9.4.1 字符输出流的基类：Writer

抽象类

常用方法

方法描述
void write(String str)将str字符串中包含的字符输出到输出流中
void write(String str, int off, int len)将字符串中从off位置开始，长度为len的字符输出到输出流中
void close()关闭输出流
void flush()刷新输出流

9.4.2 字符输出流FileWriter类

  1. 导入相关的类
  2. 创建FileWriter对象
  3. 使用write()方法向文本文件写数据
  4. 清空流
  5. 关闭流
package CH09_IO.IO;

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

public class MyFileWrite {
    public static void main(String[] args) throws IOException {
        File file = new File("resources/XuanZi.txt");
        FileWriter fw = new FileWriter(file,true);
        fw.write("我能写字符串了");
        fw.flush();
        // 刷新
        fw.close();
    }
}

9.4.3 字符输入流基类：Reader

是抽象类

常用方法

方法描述
int read()从输入流中读取单个字符，返回所读取的字符数据
int read(char[] c)从输入流中最多读取c.length个字符数据，并将其存储在字符数组c中，返回实际读取的字符数
int read(char[] c, int off, int len)从输入流中最多读取len个字符的数据，并将其存储在字符数组c中 存入数组c中时，并不是从数组起点开始，而是从off位置开始，返回实际读取的字符数

9.4.4 字符输入流FileReader类

  1. 导入相关的类
  2. 创建FileReader对象
  3. 循环使用read()方法读取文件中数据
  4. 关闭流
package CH09_IO.IO;

import java.io.File;
import java.io.FileReader;
import java.io.IOException;

public class MyFileReader {
    public static void main(String[] args) throws IOException {
        File file = new File("resources/XuanZi.txt");
        FileReader fr = new FileReader(file);
        System.out.println("-----------");
        char[] c = new char[1024];
        int len = 0;
        while ((len = fr.read(c)) != -1) {
            String str = new String(c, 0, len);
            System.out.println(str);
        }
        fr.close();
    }
}

9.5 缓冲流

java.io包提供了缓冲流，高读写文件数据的执行效率

Java缓冲流自身并不具有IO功能，只是在别的流上增加缓冲，以提高程序性能

分类

  • 字节缓冲流

  • 字符缓冲流

  • BufferedWriter类

  • BufferedReader类

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-VUyMqVoE-1676731747231)(./assets/image-20230218193712672.png)]

9.5.1 BufferedWriter类

是Writer类的子类，带有缓冲区

默认情况下，只有缓冲区满的时候，才会把缓冲区的数据真正写到目的地，能减少物理写数据的次数，提高输入/输出操作的执行效率

常用的构造方法

方法描述
BufferedWriter(Writer out)创建一个缓冲字符输出流

使用FileWriter类与BufferedWriter类，可提高字符流写文本文件的效率

9.5.2 实现步骤

  1. 导入相关的类
  2. 构造FileWriter对象和BufferedWriter对象
  3. 调用write()方法写数据
  4. 清空、关闭流对象
package CH09_IO.IO;

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

public class MyBufferedWriter {
    public static void main(String[] args) throws IOException {
        File file = new File("resources/XuanZi.txt");
        FileWriter fw = new FileWriter(file, true);
        BufferedWriter bw = new BufferedWriter(fw);
        bw.write("玄子啊啊啊");
        bw.flush();
        bw.close();
    }
}

9.5.3 BufferedReader类

Reader类的子类

带有缓冲区，提高文件读取的效率

  • 把一批数据读到缓冲区

  • 从缓冲区内获取数据

常用构造方法

方法描述
BufferedReader(Reader in)创建一个缓冲字符输入流

readLine()方法

  • 按行读取文件中数据

9.5.4 实现步骤

  1. 导入相关的类
  2. 构造FileReader对象和BufferedReader对象
  3. 调用readLine()方法读取数据
  4. 清空、关闭流对象
package CH09_IO.IO;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;

public class MyBufferedReader {
    public static void main(String[] args) throws IOException {
        File file = new File("resources/XuanZi.txt");
        FileReader fr = new FileReader(file);
        BufferedReader br = new BufferedReader(fr);
//        br.readLine();
        String str = "";
        while ((str = br.readLine()) != null) {
            System.out.println(str);
        }
        br.close();
    }
}

9.6 数据操作流

对二进制文件读写操作

DataOutputStream类

  • OutputStream类的子类

  • 与FileOutputStream类结合使用写二进制文件

使用DataOutputStream类写二进制文件的实现步骤与FileOutputStream类写文本文件相似

DataInputStream类

  • InputStream类的子类

  • 与FileInputStream类结合使用读取二进制文件

使用DataInputStream类读取二进制文件的实现步骤与FileInputStream类读取文本文件相似

9.6.1DataOutputStream类

按照与平台无关的方式向流中写入基本数据类型的数据，如int、float、long、double和boolean等

使用writeUTF()方法能写入采用utf-8字符编码的字符串

FileOutputStream out1 = new FileOutputStream("D:\\doc\\test.txt");		
BufferedOutputStream out2 = new BufferedOutputStream(out1);
DataOutputStream out = new DataOutputStream(out2);
out.writeByte(1);
out.writeLong(2);
out.writeChar('c');
out.writeUTF("hello");

9.6.2 DataInputStream类

按照与平台无关的方式从流中读取基本数据类型的数据，如int、float、long、double和boolean等

使用readUTF( )方法能读取采用utf-8字符编码的字符串

FileInputStream in1 = new  FileInputStream("D:\\doc\\test.txt");		
BufferedInputStream in2 = new BufferedInputStream(in1);
DataInputStream in = new DataInputStream(in2);
System.out.println(in.readByte());
System.out.println(in.readLong());
System.out.println(in.readChar());
System.out.println(in.readUTF());

9.6.3 实现步骤

写二进制文件

  1. 导入相关的类
  2. 构造数据输出流对象
  3. 调用write()方法写二进制文件
  4. 关闭数据输出流

读二进制文件

  1. 导入相关的类
  2. 构造数据输入流对象
  3. 调用read ()方法读取二进制文件
  4. 关闭数据输入流
package CH09_IO.IO;

import java.io.*;

public class MyData {
    public static void main(String[] args) throws IOException {
        DataOutputStream dos = null;
        DataInputStream dis = null;
        FileInputStream fis = null;
        FileOutputStream fos = null;

        try {
            //创建输入流文件
            fis = new FileInputStream("D:\\doc\\User.class");
            dis = new DataInputStream(fis);
            //创建输出流文件
            fos = new FileOutputStream("D:\\doc\\newUser.class");
            dos = new DataOutputStream(fos);
            int temp;
            while (((temp = dis.read()) != -1)) {
                fos.write(temp);
            }
        } catch (Exception ex) {
            ex.printStackTrace();
        } finally {
            //省略异常处理代码
            dis.close();
            fis.close();
            fos.close();
            dos.close();
        }
    }
}

9.7 序列化与反序列化

为每个对象属性一一编写读写代码，过程很繁琐且非常容易出错

使用序列化和反序列化，方便数据传输和存储

  • 序列化是将对象的状态存储到特定的存储介质中的过程

  • 反序列化是将特定的存储介质中数据重新构建对象的过程

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-MJUqg3Lo-1676731747231)(./assets/image-20230218194926286.png)]

对象输出流（ ObjectOutputStream ）：实现序列化

对象输入流（ ObjectInputStream）：实现反序列化

9.7.1 使用ObjectOutputStream类实现序列化

序列化的对象所属类须为可序列化的类

一个类实现java.io.Serializable接口，该类的对象是可序列化的

public interface Serializable{}

JDK1.8类库中，有些类实现了java.io.Serializable接口

  • 如：String类、包装类和日期时间类等

常用方法

方法描述类型
ObjectOutputStream(OutputStream out)创建对象输出流对象构造方法
final void writeObject(Object obj)将指定对象写入流实例方法

创建一个Person类，并标记该类的对象是可序列化的

import java.io.Serializable;
public class Person implements Serializable {
    private String name;
    private int age;
    private String sex;
    public void print() {
        System.out.println("姓名："+this.name+",年龄："+this.age+",性别："+this.sex+"。");
    }
}

9.7.2 解决序列化和反序列化的版本不一致问题

引入serialVersionUID常量

  • serialVersionUID常量为long类型

  • JVM在编译时自动生成serialVersionUID常量，也可显式定义

在Person类中显式定义serialVersionUID常量

import java.io.Serializable;
public class Person implements Serializable {
     private static final long serialVersionUID=1L;
    // 序列化和反序列化时serialVersionUID常量值需一致
    private String name;
    private int age;
    private String sex;
    public void print() {
        System.out.println("姓名："+this.name+",年龄："+this.age+",性别："+this.sex+"。");
    }
}

9.7.3 实现步骤

  1. 导入相关的类
  2. 创建可序列化的类，要求实现Serializable接口
  3. 创建对象输出流（ObjectOutputStream）
  4. 输出可序列化对象
  5. 关闭对象输出流
    ObjectOutputStream oos = null;
    try {
        oos = new ObjectOutputStream(new FileOutputStream("D:\\doc\\persons.bat"));
        // 创建流
        Person person = new Person("杰米", 25, "男");
        Person person2 = new Person("Lisa", 30, "女");
        ArrayList<Person> list = new ArrayList<Person>();
        list.add(person);
        list.add(person2);
        oos.writeObject(list);
        // 集合对象序列化
        System.out.println("序列化成功！");
    }catch(IOException ex){
        ex.printStackTrace();
    }finally {
        if(oos!=null){
            try{
                oos.close();
            }catch(IOException ex){
                ex.printStackTrace();
            }
        }
    }

9.7.4 使用ObjectInputStream类实现反序列化

使用对象输出流ObjectInputStream可以还原序列化的对象

常用方法

方法描述类型
ObjectInputStream(InputStream in)创建对象输入流对象构造方法
final Object readObject()从指定位置读取对象实例方法

final Object readObject()返回一个Object类型的对象，如果确定该Object对象的真实类型，则可以将该对象强制转换成其真实类型

9.7.5 实现步骤

  1. 导入相关的类
  2. 创建一个对象输入流（ObjectInputStream）
  3. 输出反序列化后对象信息
  4. 关闭对象输入流
    ObjectInputStream ois = null;
    try {
        ois = new ObjectInputStream(new FileInputStream("D:\\doc\\persons.bat"));
        ArrayList<Person> list = (ArrayList<Person>)ois.readObject();
        // 反序列化，进行强制类型转换
        for(Person person:list) {
            person.print();
        }
        //输出转换反序列化后的对象信息
    }catch(ClassNotFoundException ex) {
        ex.printStackTrace();
    } catch(FileNotFoundException ex) {
        ex.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        try {
            if (ois != null)
                ois.close();
        }catch (IOException ex) {
            ex.printStackTrace();
        }
    }

反序列化时，readObject()方法返回的是Object对象需强制类型转换为Person对象

如果使用序列化方式向文件中写入多个对象，那么反序列化恢复对象时，也是按照写入的顺序读取

如果一个可序列化的类有多个父类（包括直接或间接父类），则这些父类要么是可序列化的，要么有无参数的构造；否则，将会抛出异常

9.7.6 限制序列化

出于安全考虑，对于一些比较敏感的信息（如用户密码），应限制被序列化

使用transient关键字修改不需要序列化的对象属性

希望Person类对象中的年龄信息不被序列化

import java.io.Serializable;
public class Person implements Serializable {
    private String name;
    private transient int age;
    // 被限制序列化
    private String sex;
    public void print() {
        System.out.println("姓名："+this.name+",年龄："+this.age+",性别："+this.sex+"。");
    }
}

9.8 IO 总结

9.8.1 Java常用IO流

分类字节输出流字节输入流字符输出流字符输入流
基类OutputStreamInputStreamWriterReader
文件流FileOutputSteamFileInputStreamFileWriterFileReader
缓冲流BufferedOutputStreamBufferedInputStreamBufferedWriterBufferedReader
对象流ObjectOutputStreamObjectInputStream--
数据操作流DataOutputStreamDataInputStream--

  • 所有的基类都是抽象类，无法直接创建实例，需要借助其实现类

  • 所有输出流实现写数据，所有输入流实现读数据

  • 输入和输出是相对程序而言

  • 所有的文件流直接与存储介质关联，需指定物理节点

在操作文本文件时，应使用字符流

字节流可以处理二进制数据，它的功能比字符流更强大

如果是二进制文本，应考虑使用字节流

BCSP-玄子JAVA开发之面向对 象编程CH09_ Java IO流笔记 2.18

玄子Share
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
面向对象程序设计实践（Java）作业3
qq_60437248的博客
06-04 415
北京邮电大学BUPT2023春季《面向对象程序设计实践（Java）课》OJ作业3
java学习第二十九天
qq_54364082的博客
06-19 2298
2020080605004大数据2005 黄满 编写程序，计算并输出所有的水仙花数。水仙花数是这样的三位数，它的各位数字的立方和等于这个三位数本身，例如371=33+73+13，371就是一个水仙花数。 package hm; public class Shuixianhua { public static void main(String[] args) { int a = 0; int b = 0; int c = 0; for (int i = 100; i <
java.io.serializable_java.io.Serializable类解读
weixin_39665762的博客
02-18 472
预备知识单词发音英 [sɪərɪəlaɪ'zəbl]美 [sɪərɪrlaɪ'zəbl]什么叫序列化在java中Serializable接口类的定义如下：package java.io;public interface Serializable {}特性讲解实现(implement)了java.io.serializable接口的类可以被序列化。没有实现这个接口的类将不能序列化和反序列化。该接口没...
Java基础篇---练习：类的设计
满天星的博客
05-28 3282
练习：类的设计 练习一 （类与测试类分开写） 练习1：创建一个Person类，其定义如下： 要求：（1）创建Person类的对象，设置该 对象的name、age和sex属性； 调用study（）方法，输出字符串"studying"；调用showAge（）方法显示age值；调用addAge()方法给对象的age属性值增加2岁 （2）创建第二个对象，执行上述操作，体会同一个类的不同对象之间的关系 新建一个workbook包 创建一个Person类 //练习：类的设计 package wor
java定义一个Person类
qq_56435059的博客
09-12 7419
定义一个Person类，其包含：name、address、e_mail三个成员变量；一个显示“this is in class Person”字符串的show（）方法； 要求根据此类定义一个子类Employee，该子类包含：workingage（工龄）和salary（工资）两个成员变量，定义一个覆盖父类的show（）方法显示类名和人名；还定义一个员工的加薪方式addSal：若工龄小于1年，加当前工资的10%；若工龄大于1年，可以指定加薪的数目，但此数目不可大于该员工工资的20%（即最多加20%）。完成此父子
北京市bcsp-x样题
05-25
这是第一届bcsp 这是样题 文件列表 BCSP-X2024第一轮报名通知.pdf BCSP-X活动方案.pdf 活动范围.zip 样例题目.zip 希望可以帮助到大家 更多报名内容请关注 文件内报名通知 登陆网站后报名
BCSP-X 2024年活动文件，包含活动范围和模拟题
05-01
《BCSP-X 2024年活动文件详解——挖掘信息学能力测评的深度与广度》 BCSP-X，全称北京市中小学信息学能力测评，是一项旨在提升北京市中小学生信息科学素养的重要活动。该活动每年举办一次，为学生提供了一个展示、...
BCSP-X活动方案.pdf
最新发布
07-13
形成 “数字教育+科技创新”的新质生产力，推进北京高水平人才高地建设工作，北京青少年科技教育协会拟组织 BCSP-X 活动，面向北京市中小学生进行信息学能力测评，旨在进行信息学人才的早发现、早培养。 活动内容 ...
hci_bcsp.rar_CSR hci_HCI_csr 驱动_hci_bcsp2
09-19
本压缩包文件"hci_bcsp.rar_CSR hci_HCI_csr 驱动_hci_bcsp2"包含了CSR蓝牙HCI层的驱动源码，这对于我们理解蓝牙驱动工作原理以及定制或优化蓝牙功能具有重要意义。 驱动程序是操作系统与硬件设备之间的桥梁，它...
hci_bcsp.rar_BCSP_hci uart driver
09-21
标题中的“hci_bcsp.rar_BCSP_hci uart driver”表明这是一个关于蓝牙HCI（Host Controller Interface）UART驱动程序的资源包，主要关注BCSP（Bluetooth Control and Signaling Protocol）协议。在蓝牙技术中，HCI是...
Java对象的序列化和反序列化
weixin_34356138的博客
03-27 89
2019独角兽企业重金招聘Python工程师标准>>> ...
Java多种方式自定义序列化
Genge
06-14 3773
我们知道，通过实现java.io.Serializable接口可以使得该类的实例能够被序列化。例如如下的Person类， import java.io.Serializable; public class Person implements Serializable { private String name; private int age; public P
java序列化与反序列化
qq_45939159的博客
02-17 183
java序列化与反序列化 一、序列化和反序列化的概念 　　把对象转换为字节序列的过程称为对象的序列化。 　　把字节序列恢复为对象的过程称为对象的反序列化。 　　对象的序列化主要有两种用途： 　　1） 把对象的字节序列永久地保存到硬盘上，通常存放在一个文件中； 　　2） 在网络上传送对象的字节序列。 　　在很多应用中，需要对某些对象进行序列化，让它们离开内存空间，入住物理硬盘，以便长期保存。比如最常见的是Web服务器中的Session对象，当有 10万用户并发访问，就有可能出现10万个Session对象
Java基础学习总结——Java对象的序列化和反序列化
weixin_33698823的博客
06-09 394
一、序列化和反序列化的概念 　　把对象转换为字节序列的过程称为对象的序列化。　　把字节序列恢复为对象的过程称为对象的反序列化。　　对象的序列化主要有两种用途：　　1） 把对象的字节序列永久地保存到硬盘上，通常存放在一个文件中；　　2） 在网络上传送对象的字节序列。 　　在很多应用中，需要对某些对象进行序列化，让它们离开内存空间，入住物理硬盘，以便长期保存。比如最常见的是Web服务器中的Sess...
Java IO操作——对象序列化（Serializable接口、ObjectOutputStream、以及与Externalizable接口的用法和区别）...
iteye_18817的博客
08-11 279
学习目标 掌握对象序列化的作用。 掌握Serializable接口的作用。 可以使用ObjectOutputStream进行对象的序列化操作。 可以使用ObjectInputStream进行对象的反序列化操作。 掌握Externalizable接口的作用及与Serializable接口的实现区别。 掌握transient关键字的作用。 可以序列化一组对象。 对象序列化 对象序列化，就是把一个对象变...
java.io：接口 Serializable——类通过实现 java.io.Serializable 接口以启用其序列化功能
null
09-09 2519
什么是java序列化，如何实现java序列化？ 序列化就是一种用来处理对象流的机制，所谓对象流也就是将对象的内容进行流化。可以对流化后的对象进行读写操作，也可将流化后的对象传输于网络之间。序列化是为了解决在对对象流进行读写操作时所引发的问题。 ----------------------------------------------------------------...
Java IO(二)
梵高话葵
05-31 135
对象操作：Serializable 序列化就是将一个对象转换成字节序列，方便存储和传输。 序列化：ObjectOutputStream.writeObject() 反序列化：ObjectInputStream.readObject() 不会对静态变量进行序列化，因为序列化只是保存对象的状态，静态变量属于类的状态。 对class文件进行修改后若直接进行反序列化会报错，因为UID会被重新赋值 解决办法 在class文件中定义一个UID 这样保证永远不变 网络操作：Socket 新的输入/输出：NIO
Java面试题及答案整理与下载（2021最新版）
zuoan1993的博客
02-16 974
Java面试题及答案整理 一、Java 基础# 1. JDK 和 JRE 有什么区别？# JDK：Java Development Kit 的简称，java 开发工具包，提供了 java 的开发环境和运行环境。 JRE：Java Runtime Environment 的简称，java 运行环境，为 java 的运行提供了所需环境。 具体来说 JDK 其实包含了 JRE，同时还包含了编译 java 源码的编译器 javac，还包含了很多 java 程序调试和分析的工具。简单来说：如果你需要运行 ja
java基础---->Serializable的使用
07-06 215
Serializable序列化的简要说明 一、 持久化的简单介绍： 　　“持久化”意味着对象的“生存时间”并不取决于程序是否正在执行——它存在或“生存”于程序的每一次调用之间。通过序列化一个对象，将其写入磁盘，以后在程序再次调用时重新恢复那个对象，就能圆满实现一种“持久”效果。 二、 语言里增加了对象序列化的概念后，可提供对两种主要特性的支持： 远程方法调用（RMI）使...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值