1. File类

File类

2. IO流

• IO流介绍
  • IO：输入/输出(Input/Output)
  • 流：是一种抽象概念,是对数据传输的总称.也就是说数据在设备间的传输称为流,流的本质是数据传输
  • io流就是以流的方式进行输入输出
• IO流的分类
  • 按照数据的流向
    • 输入流：读数据，从存储设备到内存
    • 输出流：写数据，从内存到存储设备
  • 按照数据类型来分
    • 字节流:是以字节为处理单位的数据流
      • 字节输入流
      • 字节输出流
    • 字符流：是以字符为处理单位的数据流
      • 字符输入流
      • 字符输出流
  • 所有字节流的父类 =》 InputStream，OutputStream
  • 所有字符流的父类 =》 Ready，Write
  • 按功能
    • 节点流：指的就是可以独立来创建对象的流
    • 过滤流：在节点流的基础上增强功能
• IO流的使用场景
  • 如果操作的是纯文本文件,优先使用字符流
  • 如果操作的是图片、视频、音频等二进制文件,优先使用字节流
  • 如果不确定文件类型,优先使用字节流.字节流是万能的流

3. 字节流

是以字节为处理单位的数据流

字节流抽象基类

• InputStream：这个抽象类是表示字节输入流的所有类的超类
• OutputStream：这个抽象类是表示字节输出流的所有类的超类
• 子类名特点：子类名称都是以其父类名作为子类名的后缀

3.1 字节输出流

• 方法

方法	解释
FileOutputStream(String name)	创建文件输出流以指定的名称写入文件
public FileOutputStream(String name,boolean append)	创建文件输出流以指定的名称写入文件。如果第二个参数为true ，则字节将写入文件的末尾而不是开头
void write(int b)	将指定的字节写入此文件输出流 一次写一个字节数据
void write(byte[] b)	将 b.length字节从指定的字节数组写入此文件输出流 一次写一个字节数组数据
void write(byte[] b, int off, int len)	将 len字节从指定的字节数组开始，从偏移量off开始写入此文件输出流 一次写一个字节数组的部分数据

• 使用字节输出流写数据的步骤

  • 创建字节输出流对象(调用系统功能创建了文件,创建字节输出流对象,让字节输出流对象指向文件)
  • 调用字节输出流对象的写数据方法
  • 释放资源(关闭此文件输出流并释放与此流相关联的任何系统资源)

• 示例代码

  package m08.d06.demo;import java.io.FileNotFoundException;
  import java.io.FileOutputStream;
  import java.io.IOException;public class TestFileOutputStream {public static void main(String[] args) throws IOException {//1,创建文件输出流对象/*注意点:1.如果文件不存在,会帮我们创建,但是文件夹不会创建2.如果文件存在,会把文件清空*///FileOutputStream(File file)：创建文件输出流以写入由指定的 File对象表示的文件// FileOutputStream fos = new FileOutputStream(new File("myByteStream\\fos.txt"));//FileOutputStream(String name)：创建文件输出流以指定的名称写入文件，第二个参数为是否追加插入FileOutputStream fos = new FileOutputStream("D:\\qianfeng\\student_code\\lianxi\\src\\m08\\d06\\demo\\demo2.txt");// 2，写入数据//2.1     //void write(int b)：将指定的字节写入此文件输出流fos.write(97);fos.write(98);fos.write(99);//2.1   void write(byte[] b)：将 b.length字节从指定的字节数组写入此文件输出流String str = "你还记得吗，呢到晚霞";byte[] strBytes = str.getBytes();byte[] bytes = {97, 98, 99};fos.write(strBytes);fos.write(bytes);// 2.3 void write(byte[] b, int off, int len)：fos.write(bytes, 1, 2);//  3，释放资源;fos.close();//  打印如下，这里我用空格分开//abc   你还记得吗，呢到晚霞  abc bc}}

3.2 字节流异常处理方法

• 异常处理格式

  • try-catch-finally

    try{可能出现异常的代码;
    }catch(异常类名 变量名){异常的处理代码;
    }finally{执行所有清除操作;
    }
    

  • finally特点

    • 被finally控制的语句一定会执行，除非JVM退出

• 示例代码

  public class FileOutputStreamDemo04 {public static void main(String[] args) {//加入finally来实现释放资源FileOutputStream fos = null;try {fos = new FileOutputStream("myByteStream\\fos.txt");fos.write("hello".getBytes());} catch (IOException e) {e.printStackTrace();} finally {if(fos != null) {try {fos.close();} catch (IOException e) {e.printStackTrace();}}}}
  }
  

3.3 字节输入流

• 方法

方法	说明
FileInputStream(String name)：	通过打开与实际文件的连接来创建一个FileInputStream,该文件由文件系统中的路径名name命名
public int read(byte[] b)：	从此输入流中将最多 b.length 个字节的数据读入一个 byte 数组中。
public int read()	从此输入流中读取一个数据字节。如果没有输入可用，则此方法将阻塞。

• 字节输入流读取数据的步骤
  • 创建字节输入流对象
  • 调用字节输入流对象的读数据方法
  • 释放资源

• 示例代码

  public class FileInputStreamDemo01 {public static void main(String[] args) throws IOException {//创建字节输入流对象//FileInputStream(String name)FileInputStream fis = new FileInputStream("myByteStream\\fos.txt");int by;/*fis.read()：读数据by=fis.read()：把读取到的数据赋值给byby != -1：判断读取到的数据是否是-1*/while ((by=fis.read())!=-1) {System.out.print((char)by);}//释放资源fis.close();}
  }
  

3.5 字节缓冲流

• 构造方法：

  方法名	说明
  BufferedOutputStream(OutputStream out)	该类实现缓冲输出流.通过设置这样的输出流,应用程序可以向底层输出流写入字节,而不必为写入的每个字节导致底层系统的调用
  BufferedInputStream(InputStream in)	创建BufferedInputStream将创建一个内部缓冲区数组.当从流中读取或跳过字节时,内部缓冲区将根据需要从所包含的输入流中重新填充,一次很多字节

• 示例代码

package m08.d9;import java.io.*;public class BufferStreamDemo {public static void main(String[] args) throws IOException, IOException {//字节缓冲输出流：BufferedOutputStream(OutputStream out)BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("D:\\qianfeng\\student_code\\lianxi\\src\\m08\\d9\\bos.txt"));//写数据bos.write("hello\r\n".getBytes());bos.write("world\r\n".getBytes());//释放资源bos.close();//字节缓冲输入流：BufferedInputStream(InputStream in)BufferedInputStream bis = new BufferedInputStream(new FileInputStream("D:\\qianfeng\\student_code\\lianxi\\src\\m08\\d9\\bos.txt"));//一次读取一个字节数据
//        int by;
//        while ((by=bis.read())!=-1) {//            System.out.print((char)by);
//        }//一次读取一个字节数组数据byte[] bys = new byte[1024];int len;while ((len = bis.read(bys)) != -1) {System.out.print(new String(bys, 0, len));}//释放资源bis.close();}
}

4,字符流

4.1为什么会出现字符流

• 字符流的介绍

  由于字节流操作中文不是特别的方便，所以Java就提供字符流

  字符流 = 字节流 + 编码表

• 中文的字节存储方式

  用字节流复制文本文件时，文本文件也会有中文，但是没有问题，原因是最终底层操作会自动进行字节拼接成中文，如何识别是中文的呢？

  汉字在存储的时候，无论选择哪种编码存储，第一个字节都是负数

4.2编码表【理解】

• 什么是字符集

  是一个系统支持的所有字符的集合，包括各国家文字、标点符号、图形符号、数字等

  计算机要准确的存储和识别各种字符集符号，就需要进行字符编码，一套字符集必然至少有一套字符编码。常见字符集有ASCII字符集、GBXXX字符集、Unicode字符集等

• 常见的字符集

  • ASCII字符集：

    lASCII：是基于拉丁字母的一套电脑编码系统，用于显示现代英语，主要包括控制字符(回车键、退格、换行键等)和可显示字符(英文大小写字符、阿拉伯数字和西文符号)

    基本的ASCII字符集，使用7位表示一个字符，共128字符。ASCII的扩展字符集使用8位表示一个字符，共256字符，方便支持欧洲常用字符。是一个系统支持的所有字符的集合，包括各国家文字、标点符号、图形符号、数字等

  • GBXXX字符集：

    GBK：最常用的中文码表。是在GB2312标准基础上的扩展规范，使用了双字节编码方案，共收录了21003个汉字，完全兼容GB2312标准，同时支持繁体汉字以及日韩汉字等,占用两个字节

  • Unicode字符集：

    编码规则：

    128个US-ASCII字符，只需一个字节编码

    拉丁文等字符，需要二个字节编码

    大部分常用字（含中文），使用三个字节编码

    其他、极少使用的Unicode辅助字符，使用四字节编码

• 发展历程

  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cxgRYTZv-1628606447530)(md_img/IO流/image-20210807101428911.png)]

• 汉字存储和过程解析

  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-QpG9P9Dt-1628606447533)(md_img/IO流/image-20210807101507852.png)]

4.3字符串中的编码解码问题

• 相关方法

  方法名	说明
  byte[] getBytes()	使用平台的默认字符集将该 String编码为一系列字节
  byte[] getBytes(String charsetName)	使用指定的字符集将该 String编码为一系列字节
  String(byte[] bytes)	使用平台的默认字符集解码指定的字节数组来创建字符串
  String(byte[] bytes, String charsetName)	通过指定的字符集解码指定的字节数组来创建字符串

• 代码演示

  package m08.d07;import java.io.UnsupportedEncodingException;
  import java.util.Arrays;public class TestBian {public static void main(String[] args) throws UnsupportedEncodingException {String str = "你好世界";//    byte[] getBytes()使用平台的默认字符集将该 String编码为一系列字节byte[] bytes1 = str.getBytes();//    byte[] getBytes(String charsetName)使用指定的字符集将该  String编码为一系列字节byte[] bytes2 = str.getBytes("UTF-8");byte[] bytes3 = str.getBytes("GBK");System.out.println(Arrays.toString(bytes1)); // [-60, -29, -70, -61, -54, -64, -67, -25]System.out.println(Arrays.toString(bytes2)); // [-28, -67, -96, -27, -91, -67, -28, -72, -106, -25, -107, -116]System.out.println(Arrays.toString(bytes3)); // [-60, -29, -70, -61, -54, -64, -67, -25]// 由此可见，java默认编码为gbkbyte[] strBytes1 = {-60, -29, -70, -61, -54, -64, -67, -25};byte[] strBytes2 = {-28, -67, -96, -27, -91, -67, -28, -72, -106, -25, -107, -116};//    String(byte[] bytes)使用平台的默认字符集解码指定的字节数组来创建字符串String s1 = new String(strBytes1);String s2 = new String(strBytes2,"UTF-8");System.out.println(s1); // 你好世界System.out.println(s2); // 你好世界//    String(byte[] bytes, String charsetName)通过指定的字符集解码指定的字节数组来创建字符串}
  }

4.4字符流写数据

• 介绍

  Writer: 用于写入字符流的抽象父类

  FileWriter: 用于写入字符流的常用子类

• 构造方法

  方法名	说明
  FileWriter(File file)	根据给定的 File 对象构造一个 FileWriter 对象
  FileWriter(File file, boolean append)	根据给定的 File 对象构造一个 FileWriter 对象
  FileWriter(String fileName)	根据给定的文件名构造一个 FileWriter 对象
  FileWriter(String fileName, boolean append)	根据给定的文件名以及指示是否附加写入数据的 boolean 值来构造 FileWriter 对象

• 成员方法

  方法名	说明
  void write(int c)	写一个字符
  void write(char[] cbuf)	写入一个字符数组
  void write(char[] cbuf, int off, int len)	写入字符数组的一部分
  void write(String str)	写一个字符串
  void write(String str, int off, int len)	写一个字符串的一部分

• 刷新和关闭的方法

  方法名	说明
  flush()	刷新流，之后还可以继续写数据
  close()	关闭流，释放资源，但是在关闭之前会先刷新流。一旦关闭，就不能再写数据

• 代码演示

  package m08.d07;import java.io.File;
  import java.io.FileWriter;
  import java.io.IOException;public class TestFileWrite {public static void main(String[] args) throws IOException {// 创建对象// 方式1//FileWriter fw = new FileWriter(new File("D:\\qianfeng\\student_code\\lianxi\\src\\m08\\d07\\demo.txt"));// 方式2FileWriter fw = new FileWriter("D:\\qianfeng\\student_code\\lianxi\\src\\m08\\d07\\demo.txt");//void   write(int c)写一个字符fw.write(97);fw.write('a');//void   write(char[] cbuf)写入一个字符数组char[] b = {98,99,100,101};fw.write(b);//void write(char[] cbuf, int off, int len)写入字符数组的一部分fw.write(b,0,2);//void write(String str)写一个字符串fw.write("我爱你，中国");//void write(String str, int off, int len)写一个字符串的一部分fw.write("我爱你，中国",0,3);// 结果如下，我这里用空格分开每个打印的部分//a     a       bcde        bc      我爱你，中国      我爱你fw.flush(); //刷新流，之后还可以继续写数据fw.write("我们结婚吧");      //a     a       bcde        bc      我爱你，中国      我爱你 我们结婚吧fw.close();}}

4.5字符流读数据

• 介绍

  Reader: 用于读取字符流的抽象父类

  FileReader: 用于读取字符流的常用子类

• 构造方法

  方法名	说明
  FileReader(File file)	在给定从中读取数据的 File 的情况下创建一个新 FileReader
  FileReader(String fileName)	在给定从中读取数据的文件名的情况下创建一个新 FileReader

• 成员方法

  方法名	说明
  int read()	一次读一个字符数据
  int read(char[] cbuf)	一次读一个字符数组数据

• 代码演示

  public class InputStreamReaderDemo {public static void main(String[] args) throws IOException {FileReader fr = new FileReader("myCharStream\\b.txt");//int read()：一次读一个字符数据
  //        int ch;
  //        while ((ch=fr.read())!=-1) {//            System.out.print((char)ch);
  //        }//int read(char[] cbuf)：一次读一个字符数组数据char[] chs = new char[1024];int len;while ((len = fr.read(chs)) != -1) {System.out.print(new String(chs, 0, len));}//释放资源fr.close();}
  }
  

4.6字符流用户注册案例

• 案例需求

  将键盘录入的用户名和密码保存到本地实现永久化存储

• 实现步骤

  • 获取用户输入的用户名和密码
  • 将用户输入的用户名和密码写入到本地文件中
  • 关流,释放资源

• 代码实现

  public class CharStreamDemo8 {public static void main(String[] args) throws IOException {//需求: 将键盘录入的用户名和密码保存到本地实现永久化存储//要求：用户名独占一行，密码独占一行//分析：//1，实现键盘录入，把用户名和密码录入进来Scanner sc = new Scanner(System.in);System.out.println("请录入用户名");String username = sc.next();System.out.println("请录入密码");String password = sc.next();//2.分别把用户名和密码写到本地文件。FileWriter fw = new FileWriter("charstream\\a.txt");//将用户名和密码写到文件中fw.write(username);//表示写出一个回车换行符 windows \r\n  MacOS \r  Linux \nfw.write("\r\n");fw.write(password);//刷新流fw.flush();//3.关流,释放资源fw.close();}
  }
  

4.7字符缓冲流

• 字符缓冲流介绍

  • BufferedWriter：将文本写入字符输出流，缓冲字符，以提供单个字符，数组和字符串的高效写入，可以指定缓冲区大小，或者可以接受默认大小。默认值足够大，可用于大多数用途

  • BufferedReader：从字符输入流读取文本，缓冲字符，以提供字符，数组和行的高效读取，可以指定缓冲区大小，或者可以使用默认大小。 默认值足够大，可用于大多数用途

• 构造方法

  方法名	说明
  BufferedWriter(Writer out)	创建字符缓冲输出流对象
  BufferedReader(Reader in)	创建字符缓冲输入流对象

• 代码演示

  public class BufferedStreamDemo01 {public static void main(String[] args) throws IOException {//BufferedWriter(Writer out)BufferedWriter bw = new BufferedWriter(new                                                            FileWriter("myCharStream\\bw.txt"));bw.write("hello\r\n");bw.write("world\r\n");bw.close();//BufferedReader(Reader in)BufferedReader br = new BufferedReader(new                                                           FileReader("myCharStream\\bw.txt"));//一次读取一个字符数据
  //        int ch;
  //        while ((ch=br.read())!=-1) {//            System.out.print((char)ch);
  //        }//一次读取一个字符数组数据char[] chs = new char[1024];int len;while ((len=br.read(chs))!=-1) {System.out.print(new String(chs,0,len));}br.close();}
  }
  

4.8字符缓冲流特有功能【应用】

• 方法介绍

  BufferedWriter：

  方法名	说明
  void newLine()	写一行行分隔符，行分隔符字符串由系统属性定义

  BufferedReader:

  方法名	说明
  String readLine()	读一行文字。 结果包含行的内容的字符串，不包括任何行终止字符如果流的结尾已经到达，则为null

• 代码演示

  public class BufferedStreamDemo02 {public static void main(String[] args) throws IOException {//创建字符缓冲输出流BufferedWriter bw = new BufferedWriter(new                                                          FileWriter("myCharStream\\bw.txt"));//写数据for (int i = 0; i < 10; i++) {bw.write("hello" + i);//bw.write("\r\n");bw.newLine();bw.flush();}//释放资源bw.close();//创建字符缓冲输入流BufferedReader br = new BufferedReader(new                                                          FileReader("myCharStream\\bw.txt"));String line;while ((line=br.readLine())!=null) {System.out.println(line);}br.close();}
  }
  

4.9字符缓冲流操作文件中数据排序案例【应用】

• 案例需求

  使用字符缓冲流读取文件中的数据，排序后再次写到本地文件

• 实现步骤

  • 将文件中的数据读取到程序中
  • 对读取到的数据进行处理
  • 将处理后的数据添加到集合中
  • 对集合中的数据进行排序
  • 将排序后的集合中的数据写入到文件中

• 代码实现

  public class CharStreamDemo14 {public static void main(String[] args) throws IOException {//需求：读取文件中的数据，排序后再次写到本地文件//分析：//1.要把文件中的数据读取进来。BufferedReader br = new BufferedReader(new FileReader("charstream\\sort.txt"));//输出流一定不能写在这里，因为会清空文件中的内容//BufferedWriter bw = new BufferedWriter(new FileWriter("charstream\\sort.txt"));String line = br.readLine();System.out.println("读取到的数据为" + line);br.close();//2.按照空格进行切割String[] split = line.split(" ");//9 1 2 5 3 10 4 6 7 8//3.把字符串类型的数组变成int类型int [] arr = new int[split.length];//遍历split数组，可以进行类型转换。for (int i = 0; i < split.length; i++) {String smallStr = split[i];//类型转换int number = Integer.parseInt(smallStr);//把转换后的结果存入到arr中arr[i] = number;}//4.排序Arrays.sort(arr);System.out.println(Arrays.toString(arr));//5.把排序之后结果写回到本地 1 2 3 4...BufferedWriter bw = new BufferedWriter(new FileWriter("charstream\\sort.txt"));//写出for (int i = 0; i < arr.length; i++) {bw.write(arr[i] + " ");bw.flush();}//释放资源bw.close();}
  }
  

4.10IO流小结【理解】

• IO流小结

  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-LZwNWMbB-1628606447536)(md_img/IO流/01_IO流小结.png)]

5.转换流

5.1字符流中和编码解码问题相关的两个类

• InputStreamReader：是从字节流到字符流的桥梁,父类是Reader

  ​ 它读取字节，并使用指定的编码将其解码为字符

  ​ 它使用的字符集可以由名称指定，也可以被明确指定，或者可以接受平台的默认字符集

• OutputStreamWriter：是从字符流到字节流的桥梁,父类是Writer

  ​ 是从字符流到字节流的桥梁，使用指定的编码将写入的字符编码为字节

  ​ 它使用的字符集可以由名称指定，也可以被明确指定，或者可以接受平台的默认字符集

5.2转换流读写数据

• 构造方法

  方法名	说明
  InputStreamReader(InputStream in)	使用默认字符编码创建InputStreamReader对象
  InputStreamReader(InputStream in,String chatset)	使用指定的字符编码创建InputStreamReader对象
  OutputStreamWriter(OutputStream out)	使用默认字符编码创建OutputStreamWriter对象
  OutputStreamWriter(OutputStream out,String charset)	使用指定的字符编码创建OutputStreamWriter对象

• 代码演示

  public class ConversionStreamDemo {public static void main(String[] args) throws IOException {//OutputStreamWriter osw = new OutputStreamWriter(new    FileOutputStream("myCharStream\\osw.txt"));OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("lianxi\\src\\io\\osw.txt"), "GBK");osw.write("你好世界");osw.close();//InputStreamReader isr = new InputStreamReader(new  FileInputStream("myCharStream\\osw.txt"));// 第一种方式读取InputStreamReader isr = new InputStreamReader(new FileInputStream("lianxi\\src\\io\\osw.txt"), "GBK");//一次读取一个字符数据int ch;while ((ch = isr.read()) != -1) {System.out.print((char) ch);}isr.close();}}
  

6.对象操作流

6.1对象序列化流

• 对象序列化介绍

  • 对象序列化：就是将对象保存到磁盘中，或者在网络中传输对象
  • 这种机制就是使用一个字节序列表示一个对象，该字节序列包含：对象的类型、对象的数据和对象中存储的属性等信息
  • 字节序列写到文件之后，相当于文件中持久保存了一个对象的信息
  • 反之，该字节序列还可以从文件中读取回来，重构对象，对它进行反序列化

• 对象序列化流： ObjectOutputStream

  • 将Java对象的原始数据类型和图形写入OutputStream。 可以使用ObjectInputStream读取（重构）对象。 可以通过使用流的文件来实现对象的持久存储。 如果流是网络套接字流，则可以在另一个主机上或另一个进程中重构对象

• 构造方法

  方法名	说明
  ObjectOutputStream(OutputStream out)	创建一个写入指定的OutputStream的ObjectOutputStream

• 序列化对象的方法

  方法名	说明
  void writeObject(Object obj)	将指定的对象写入ObjectOutputStream

• 示例代码

  学生类

  public 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;}@Overridepublic String toString() {return "Student{" +"name='" + name + '\'' +", age=" + age +'}';}
  }

  测试类

  public class ObjectOutputStreamDemo {public static void main(String[] args) throws IOException {//ObjectOutputStream(OutputStream out)：创建一个写入指定的OutputStream的ObjectOutputStreamObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("myOtherStream\\oos.txt"));//创建对象Student s = new Student("佟丽娅",30);//void writeObject(Object obj)：将指定的对象写入ObjectOutputStreamoos.writeObject(s);//释放资源oos.close();}
  }

• 注意事项

  • 一个对象要想被序列化，该对象所属的类必须必须实现Serializable 接口
  • Serializable是一个标记接口，实现该接口，不需要重写任何方法

6.2对象反序列化流

• 对象反序列化流： ObjectInputStream

  • ObjectInputStream反序列化先前使用ObjectOutputStream编写的原始数据和对象

• 构造方法

  方法名	说明
  ObjectInputStream(InputStream in)	创建从指定的InputStream读取的ObjectInputStream

• 反序列化对象的方法

  方法名	说明
  Object readObject()	从ObjectInputStream读取一个对象

• 示例代码

  public class ObjectInputStreamDemo {public static void main(String[] args) throws IOException, ClassNotFoundException {//ObjectInputStream(InputStream in)：创建从指定的InputStream读取的ObjectInputStreamObjectInputStream ois = new ObjectInputStream(new FileInputStream("myOtherStream\\oos.txt"));//Object readObject()：从ObjectInputStream读取一个对象Object obj = ois.readObject();Student s = (Student) obj;System.out.println(s.getName() + "," + s.getAge());ois.close();}
  }

6.3 serialVersionUID&transient

• serialVersionUID

  • 用对象序列化流序列化了一个对象后，假如我们修改了对象所属的类文件，读取数据会不会出问题呢？
    • 会出问题，会抛出InvalidClassException异常
  • 如果出问题了，如何解决呢？
    • 重新序列化
    • 给对象所属的类加一个serialVersionUID
      • private static final long serialVersionUID = 42L;

• transient

  • 如果一个对象中的某个成员变量的值不想被序列化，又该如何实现呢？
    • 给该成员变量加transient关键字修饰，该关键字标记的成员变量不参与序列化过程

• 示例代码

  学生类

  public class Student implements Serializable {private static final long serialVersionUID = 42L;private String name;
  //    private int age;private transient 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 +
  //                '}';
  //    }
  }

  测试类

  public class ObjectStreamDemo {public static void main(String[] args) throws IOException, ClassNotFoundException {//        write();read();}//反序列化private static void read() throws IOException, ClassNotFoundException {ObjectInputStream ois = new ObjectInputStream(new FileInputStream("myOtherStream\\oos.txt"));Object obj = ois.readObject();Student s = (Student) obj;System.out.println(s.getName() + "," + s.getAge());ois.close();}//序列化private static void write() throws IOException {ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("myOtherStream\\oos.txt"));Student s = new Student("佟丽娅", 30);oos.writeObject(s);oos.close();}
  }

3.4对象操作流练习

• 案例需求

  创建多个学生类对象写到文件中,再次读取到内存中

• 实现步骤

  • 创建序列化流对象
  • 创建多个学生对象
  • 将学生对象添加到集合中
  • 将集合对象序列化到文件中
  • 创建反序列化流对象
  • 将文件中的对象数据,读取到内存中

• 代码实现

  学生类

  public class Student implements Serializable{private static final long serialVersionUID = 2L;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;}
  }

  测试类

  public class Demo03 {/***  read():*      读取到文件末尾返回值是 -1*  readLine():*      读取到文件的末尾返回值 null*  readObject():*      读取到文件的末尾 直接抛出异常*  如果要序列化的对象有多个,不建议直接将多个对象序列化到文件中,因为反序列化时容易出异常*      建议: 将要序列化的多个对象存储到集合中,然后将集合序列化到文件中*/public static void main(String[] args) throws Exception {/*// 序列化//1.创建序列化流对象ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("myCode\\oos.txt"));ArrayList<Student> arrayList = new ArrayList<>();//2.创建多个学生对象Student s = new Student("佟丽娅",30);Student s01 = new Student("佟丽娅",30);//3.将学生对象添加到集合中arrayList.add(s);arrayList.add(s01);//4.将集合对象序列化到文件中oos.writeObject(arrayList);oos.close();*/// 反序列化//5.创建反序列化流对象ObjectInputStream ois = new ObjectInputStream(new FileInputStream("myCode\\oos.txt"));//6.将文件中的对象数据,读取到内存中Object obj = ois.readObject();ArrayList<Student> arrayList = (ArrayList<Student>)obj;ois.close();for (Student s : arrayList) {System.out.println(s.getName() + "," + s.getAge());}}
  }

7.Properties集合

7.1Properties作为Map集合的使用【应用】

• Properties介绍

  • 是一个Map体系的集合类
  • Properties可以保存到流中或从流中加载
  • 属性列表中的每个键及其对应的值都是一个字符串

• Properties基本使用

  public class PropertiesDemo01 {public static void main(String[] args) {//创建集合对象
  //        Properties<String,String> prop = new Properties<String,String>(); //错误Properties prop = new Properties();//存储元素prop.put("itheima001", "佟丽娅");prop.put("itheima002", "赵丽颖");prop.put("itheima003", "刘诗诗");//遍历集合Set<Object> keySet = prop.keySet();for (Object key : keySet) {Object value = prop.get(key);System.out.println(key + "," + value);}}
  }

7.2Properties作为Map集合的特有方法【应用】

• 特有方法

  方法名	说明
  Object setProperty(String key, String value)	设置集合的键和值，都是String类型，底层调用 Hashtable方法 put
  String getProperty(String key)	使用此属性列表中指定的键搜索属性
  Set stringPropertyNames()	从该属性列表中返回一个不可修改的键集，其中键及其对应的值是字符串

• 示例代码

  public class PropertiesDemo02 {public static void main(String[] args) {//创建集合对象Properties prop = new Properties();//Object setProperty(String key, String value)：设置集合的键和值，都是String类型prop.setProperty("itheima001", "佟丽娅");prop.setProperty("itheima002", "赵丽颖");prop.setProperty("itheima003", "刘诗诗");//String getProperty(String key)：使用此属性列表中指定的键搜索属性
  //        System.out.println(prop.getProperty("itheima001"));
  //        System.out.println(prop.getProperty("itheima0011"));//        System.out.println(prop);//Set<String> stringPropertyNames()：从该属性列表中返回一个不可修改的键集，其中键及其对应的值是字符串Set<String> names = prop.stringPropertyNames();for (String key : names) {//            System.out.println(key);String value = prop.getProperty(key);System.out.println(key + "," + value);}}
  }

7.3Properties和IO流相结合的方法【应用】

• 和IO流结合的方法

  方法名	说明
  void load(Reader reader)	从输入字符流读取属性列表（键和元素对）
  void store(Writer writer, String comments)	将此属性列表（键和元素对）写入此 Properties表中，以适合使用 load(Reader)方法的格式写入输出字符流

• 示例代码

  public class PropertiesDemo03 {public static void main(String[] args) throws IOException {//把集合中的数据保存到文件
  //        myStore();//把文件中的数据加载到集合myLoad();}private static void myLoad() throws IOException {Properties prop = new Properties();//void load(Reader reader)：FileReader fr = new FileReader("myOtherStream\\fw.txt");prop.load(fr);fr.close();System.out.println(prop);}private static void myStore() throws IOException {Properties prop = new Properties();prop.setProperty("itheima001","佟丽娅");prop.setProperty("itheima002","赵丽颖");prop.setProperty("itheima003","刘诗诗");//void store(Writer writer, String comments)：FileWriter fw = new FileWriter("myOtherStream\\fw.txt");prop.store(fw,null);fw.close();}
  }

7.4Properties集合练习【应用】

• 案例需求

  在Properties文件中手动写上姓名和年龄,读取到集合中,将该数据封装成学生对象,写到本地文件

• 实现步骤

  • 创建Properties集合,将本地文件中的数据加载到集合中
  • 获取集合中的键值对数据,封装到学生对象中
  • 创建序列化流对象,将学生对象序列化到本地文件中

• 代码实现

  学生类

  public class Student implements Serializable {private static final long serialVersionUID = 1L;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;}@Overridepublic String toString() {return "Student{" +"name='" + name + '\'' +", age=" + age +'}';}
  }

  测试类

  public class Test {public static void main(String[] args) throws IOException {//1.创建Properties集合,将本地文件中的数据加载到集合中Properties prop = new Properties();FileReader fr = new FileReader("prop.properties");prop.load(fr);fr.close();//2.获取集合中的键值对数据,封装到学生对象中String name = prop.getProperty("name");int age = Integer.parseInt(prop.getProperty("age"));Student s = new Student(name,age);//3.创建序列化流对象,将学生对象序列化到本地文件中ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("a.txt"));oos.writeObject(s);oos.close();}
  }

总结

IO流我们学到什么呢，最基本的大纲如下
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-X1xDcxiZ-1628606447542)(md_img/IO流/66aa4c1bc3c4475ca7a7798324b14b98.png)]
除此之外，还有一个与IO流相关的集合体系，因为严格来时属于集合，所以整理到下面，这个图需要随时更新

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vHs8PRsi-1628606447544)(md_img/IO流/image-20210810221148781.png)]

‘

javaIO流-IO基础知识指南相关推荐

1. WinCE流驱动基础知识小结

   WinCE流驱动基础知识小结 1.基础知识: 1)系统调用是操作系统内核和应用程序之间的接口,设备驱动程序是操作系统内核和机器硬件之间的接口.设备驱动程序为应用程序屏蔽了硬件细节,在应用程序看来硬件只 ...

2. mysql 网络io_分布式 | DBLE 网络模块源码解析（一）：网络 IO 基础知识

   作者:路路 热爱技术.乐于分享的技术人,目前主要从事数据库相关技术的研究. 本文来源:原创投稿 *爱可生开源社区出品,原创内容未经授权不得随意使用,转载请联系小编并注明来源. 前言 对于计算机学科来说 ...

3. 【Java】JavaIO(一)、基础知识

   一.常用概念介绍 Java的IO,实现输入输出的基础,可以方便的实现数据的输入输出 二.流的分类 1. 按照流向来分: a). 输入流:向应用程序输 b). 输出流:从应用程序中输出 输入输出流是站在 ...

4. java io基础知识（四）

   一.File文件类 1.1.常用方法 1.路径问题 绝对路径:该文件在硬盘上的完整路径.绝对路径一般都是以盘符开头的. 相对路径:相对路径就是资源文件相对于当前程序所在的路径. ".&quo ...

5. feed流和瀑布流_基础知识讲解：什么是feed流？(图文)

   feed是将用户主动订阅的若干消息源组合在一起形成内容聚合器,帮助用户持续地获取最新的订阅源内容.feed流即持续更新并呈现给用户内容的信息流. 最近常听朋友说中了抖音的毒,一有时间就刷抖音,根本停不 ...

6. feed流和瀑布流_基础知识讲解：什么是feed流？

   feed是将用户主动订阅的若干消息源组合在一起形成内容聚合器,帮助用户持续地获取最新的订阅源内容.feed流即持续更新并呈现给用户内容的信息流. 最近常听朋友说中了抖音的毒,一有时间就刷抖音,根本停不 ...

7. linux命令基础知识 管道流,linux基础知识-I/O重定向,管道(示例代码)

   系统设定 默认输出设备:标准输出,STDOUT, 1 默认输入设备:标准输入, STDIN, 0 标准错误输出:STDERR, 2 标准输入:键盘 标准输出和错误输出:显示器 I/O重定向: Linu ...

8. 测试显卡位宽软件,科普：显卡位宽基础知识指南

   显卡位宽准确是指显存的位宽,目前大部分用户购买显卡时都比较重视显存的大小,但是却将显存位宽的重要性给忽略了.显卡位宽的扩大是需要硬件的扩容的,就像是扩马路占用地皮一样,所以成本比提高显存要高多了,所以 ...

9. netty系列之IO基础

   建议阅读文件io和网络io了解IO基础知识 和rocketMq-broker篇之消息存储IO了解零拷贝知识 socket状态 1.SOCKET状态介绍 1.客户端独有的:(1)SYN_SENT (2) ...

10. java不死神兔总数_Java基础知识强化之IO流笔记13：递归之不死神兔问题（斐波那契数列）...

    1.这个问题是如下的: 有一对兔子,从出生后第3个月起,每个月都生一对兔子,小兔子长到第3个月又生一对兔子,加入兔子都不死,问第20个月兔子的对数? 分析:我们找规律 兔子对数 第1个月:   1 第 ...

最新文章

1. Andriod --- JetPack (三)：ViewModel 的诞生
2. PL/0语言编译程序分析
3. vb.net2019- 机器学习ml.net情绪分析(1)
4. 长度最小的子数组--滑动窗口
5. php如何识别快手广告预览,快手广告如何进行精准投放？快手官方广告位有哪些...
6. 构建机器学习系统步骤
7. Windows上的Java线程CPU分析
8. 完美解决IE6中fixed抖动问题的方法
9. 从Android界面开发谈起
10. 生产环境nginx平滑升级
11. [转载] 说说 Python 字典结构的 get() 方法
12. linux内核之进程调度
13. 解决body设置height:100%无效问题
14. linux修改域名命令是,Linux系统脚本命令修改动态域名解析记录
15. “霜降”，“农历”，“二十四节气”，英语怎么说？
16. 记录微信小程序createIntersectionObserver()方法的使用
17. Python数据分析与可视化概述
18. Linux kfifo 源码分析
19. S3C2440时钟和电源管理：空闲模式:电源管理模块断开CPU时钟FCLK，而只给外设提供时钟，CPU不耗时钟，故而减少功耗，任何中断请求都可将CPU从空闲模式唤醒。
20. 基于centos 安装配置环境

热门文章

1. bzoj 3676: [Apio2014]回文串
2. oc基础－OC基础-类的使用
3. 什么是MySQL视图
4. Android 4.1初识--7月13号
5. python stdout stderr 一起输出_关于python：您可以愚弄isatty并分别记录stdout和stderr吗？...
6. 拓端tecdat|R语言中的block Gibbs吉布斯采样贝叶斯多元线性回归
7. 深度学习-扩展数据集
8. 修改默认启动操作系统
9. php upload 缓存_thinkphp Upload上传文件在客户端生成的临时文件$_FILES['file']['tmp_name']...
10. java aes输出长度_关于Java下的AES加密明文长度的问题