简单了解java中的File类

1、File类

1.1、概述

File对象就表示一个路径，可以是文件路径也可以是文件夹路径，这个路径可以 是存在的，也可以是不存在的。

1.2、常见的构造方法

方法名称	说明
public File（String pathname）	根据文件路径创建文件对象
public File（String parent, String child）	根据父路径名字符串和子路径名字符串创建文件对象
public File（File parent, String child）	根据父路径对应文件对象和子路径名字字符串创建文件对象

示例：

public class Test {public static void main(String[] args) {//根据文件路径创建文件对象String url1 = "D:\\实习\\笔记\\Java\\md\\File类\\md\\File.md";File file1 = new File(url1);System.out.println(file1);//根据父路径名字符串和子路径名字符串创建文件对象String parent = "D:\\实习\\笔记\\Java\\md\\File类\\md";//父级路径String child = "File.md";//子级路径File file2 = new File(parent, child);System.out.println(file2);//根据父路径对应文件对象和子路径名字字符串创建文件对象File par = new File("D:\\实习\\笔记\\Java\\md\\File类\\md");File file3 = new File(par, child);System.out.println(file3);}
}

补充：

• 绝对路径：带盘符
• 相对路径：不带盘符，默认到当前项目找

1.3、File中常见的成员方法

1.3.1、判断、获取

成员方法名称	说明
public boolean isDrectory（）	判断此路径名表示的File是否为文件夹
public boolean isFile（）	判断此路径名表示的File是否为文件
public boolean exists（）	判断此路径名表示的File是否存在
public long length（）	返回文件的大小（字节数量）
public String getAbsolutePath（）	返回文件的绝对路径
public String getPath（）	返回定义文件时使用的路径
public String getName（）	返回文件的名称（带后缀）
public long lastModified（）	返回文件最后修改的时间（毫秒值）

判断示例：

public class Test1 {public static void main(String[] args) {//对一个文件路径进行判断String url1 = "D:\\实习\\笔记\\Java\\md\\File类\\md\\File.md";File file1 = new File(url1);System.out.println(file1.isDirectory());System.out.println(file1.isFile());System.out.println(file1.exists());System.out.println("----------------------------------");//对一个文件夹进行判断String url2 = "D:\\实习\\笔记\\Java\\md\\File类\\md";File file2 = new File(url2);System.out.println(file2.isDirectory());System.out.println(file2.isFile());System.out.println(file2.exists());System.out.println("----------------------------------");//对一个不存在的文件进行判断String url3 = "D:\\实习\\笔记\\Java\\md\\File类\\md\\file.txt";File file3 = new File(url3);System.out.println(file3.isDirectory());System.out.println(file3.isFile());System.out.println(file3.exists());}
}

结果展示：

false
true
true
----------------------------------
true
false
true
----------------------------------
false
false
false

获取示例：

public class Test2 {public static String url = "D:\\实习\\笔记\\Java\\md\\File类\\md\\File.md";public static void main(String[] args) {File file = new File(url);//获取一个文件大小System.out.println("文件的大小为" + file.length() + "个字节");//获取一个文件的绝对路径System.out.println("文件的绝对路径是：" + file.getAbsoluteFile());//获取一个文件的定义时的路径System.out.println("定义文件时的路径是：" + file.getPath());//返回一个文件的名字System.out.println("文件的名字是：" + file.getName());//返回一个文件最后修改的时间DateFormat dateFormat = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");String date = dateFormat.format(new Date(file.lastModified()));System.out.println("最后一次修改文件是在：" + date);}
}

结果展示：

文件的大小为4318个字节
文件的绝对路径是：D:\实习\笔记\Java\md\File类\md\File.md
定义文件时的路径是：D:\实习\笔记\Java\md\File类\md\File.md
文件的名字是：File.md
最后一次修改文件是在：2024年06月13日 09:30:05

1.3.2、创建和删除

成员方法名称	说明
public boolean createNewFile（）	创建一个新的文件夹
public boolean mkdir（）	创建单级文件夹
public boolean mkdirs（）	创建多级文件夹
public boolean delete（）	删除文件、空文件夹

注意：delete方法默认只能删除文件和空文件夹，delete方法直接删除不走回收站

创建和删除示例：

public class Test {public static void main(String[] args) throws IOException {//创建一个新的文件//如果当前路径表示的文件是不存在的，则创建成功，方法返回true//如果当前路径表示的文件是存在的，则创建失败，方法返回false//如果父级路径不存在，那么方法会发生异常IOException//createNewFile方法创建的一定是文件，如果路径中不含后缀名，则创建一个没有后缀的文件
//        File file1 = new File("D:\\实习\\笔记\\Java\\md\\File类\\md\\demo.txt");
//        System.out.println(file1.createNewFile());//创建一个单级文件夹//Windows中路径是唯一的，如果当前路径已经存在，则创建失败，返回false//mkdir只能创建单级文件夹
//        File file2 = new File("D:\\实习\\testDir\\aaa");
//        System.out.println(file2.mkdir());//创建一个多级文件夹
//        File file3 = new File("D:\\实习\\testDir\\aaa\\bbb\\ccc");
//        System.out.println(file3.mkdirs());//删除文件，文件夹//如果删除的是文件，直接删除，不走回收站//如果删除的是空文件夹，直接删除，不走回收站//如果删除的是由内容的文件夹，则删除失败File file4 = new File("D:\\实习\\testDir");System.out.println(file4.delete());}
}

1.3.3、获取并遍历

最常用：

成员方法名称	说明
public File[] listFiles（）	获取当前路径下所有内容

注意：

• 当调用者File表示的路径不存在时，返回null
• 当调用者File表示的路径是文件时，返回null
• 当调用者File表示的路径是一个需要权限才能访问的文件夹时，返回null
• 当调用者File表示的路径是一个空文件夹时，返回一个长度为零的数组
• 当调用者File表示的路径是一个有隐藏文件的文件夹时，将里面的文件文件夹的路径放在File数组中返回，包含隐藏文件
• 当调用者File表示的路径是一个由内容的文件夹时，将里面所有的文件和文件夹的路径放到File数组中返回

其他获取并遍历的方法：

方法名称	说明
public static File[] listRoots（）	列出可用的文件系统根
public String[] list（）	获取当前路径下所有内容
public String[] list（FilenameFilter filter）	利用文件名过滤器获取当前路径下所有内容
public File[] listFiles （FileFilter filter）	利用文件名过滤器获取当前路径下所有内容
public File[] listFiles（FilenameFilter filter）	利用文件名过滤器获取当前路径下所有内容

2、IO流

2.1、概述

IO流用于读写文件中的数据，是存储和读取数据的解决方案

2.2、IO流的分类

2.2.1、流的方向

• 输入流（InputStream读入）
• 输出流（OutputStream写出）

2.2.2、操作文件的类型

• 字节流（操作所有类型的文件）
• 字符流（操作纯文本文件）

不要用字节流去读取中文，会乱码！！！

2.3、FileOutputStream

2.3.1、概念

操作本地文件的字节输出流，可以把程序中的数据写到本地文件中。

2.3.2、书写步骤

• 创建字节输出流对象

  注意：

  参数是字符串表示的路径或者是File对象都是可以的

  如果文件不存在会创建一个新的文件，但是要保证父级路径是存在的

  如果文件已经存在则会清空文件

• 写数据

  注意：

  write方法的参数是整数，但实际上写到本地文件中是整数在ASCII上对应的字符

• 释放资源

  注意：

  每次使用完都要记得释放资源

简单示例：

public class OutputStreamDmeo {public static void main(String[] args) throws IOException {//创建对象FileOutputStream fos = new FileOutputStream("D:\\Application\\IDEA\\code\\javaThread\\demo.txt");//写出数据fos.write(99);//释放资源fos.close();}
}

2.3.3、FileOutputStream写数据的三种方式

方法名称	说明
void write（int b）	一次写一个字节数据
void write（byte）	一次写一个字节数组数据
void write（byte[] b, int off, int len）	一次写一个字节数组的部分数据

代码示例：

public class OutputStreamDemo1 {public static void main(String[] args) throws IOException {//创建对象FileOutputStream fos = new FileOutputStream("D:\\Application\\IDEA\\code\\javaThread\\demo.txt");//写出数据byte[] b = {97, 98, 99, 100, 101};fos.write(b);//一次写一个字节数组数据
//        fos.write(b, 0, 2);//一次写一个字节数组的数据的一部分//释放资源fos.close();}
}

2.3.3、换行续写

代码示例：

/*** FileOutputStream演示换行续写** 换行写：* 再次写出一个换行就可以啦* windows：/r/n* linux：/n* mac：/r* 细节：* 在windows操作系统中，java对回车做了优化，虽然完整的是/r/n，但是我们写一* 个/r或者/n都是可以的，因为java在底层会自动补全* * 续写：* FileOutputStream中第二个参数为续写开关* 第二个参数默认为false（不续写）* 第二个参数改为true（续写）*/
public class ByteStreamDemo1 {public static void main(String[] args) throws IOException {//创建对象FileOutputStream fos = new FileOutputStream("demo.txt", true);//写出第一行数据String str1 = "Hello ";byte[] arr1 = str1.getBytes();fos.write(arr1);//换行String str2 = "\r\n";byte[] arr2 = str2.getBytes();fos.write(arr2);//写出第二行数据String str3 = "World!";byte[] arr3 = str3.getBytes();fos.write(arr3);//释放资源fos.close();}
}

2.4、FileInputStream

2.4.1、概念

操作本地文件的字节输入流，可以把本地文件中的数据读取出来

2.4.2、书写步骤

• 创建字节输入流对象

  注意：

  如果文件不存在，程序直接报错

• 读取数据

  注意：

  一次读一个字节，读出来的是数据在ASCII上对应的数字

  读到了文件末尾，read方法返回-1

• 释放资源

  注意：

  每次使用完都需要释放资源

简单示例：

/*** FileInputStream演示*/
public class FileInputStreamDemo1 {public static void main(String[] args) throws IOException {//创建对象FileInputStream fileIn = new FileInputStream("D:\\Application\\IDEA\\code\\javaThread\\demo.txt");//读取数据int read1 = fileIn.read();System.out.println((char)read1);int read2 = fileIn.read();System.out.println((char)read2);//释放资源fileIn.close();}
}

2.4.3、循环读取

在2.4.2中的代码示例当中我们读取文件中的数据是一个一个读取的，并且每次读取输出都写了两行代码，如果文件中的数据很多时，我们的代码就会十分冗余，因此我们可以通过循环读取来减轻代码冗余度。

代码示例：

/*** FileInputStream循环读取演示*/
public class FileInputStreamDmeo2 {public static void main(String[] args) throws IOException {//创建对象FileInputStream fis = new FileInputStream("D:\\Application\\IDEA\\code\\javaThread\\demo.txt");//循环读取数据int read;while((read = fis.read()) != -1){System.out.println(((char)read));}//释放资源fis.close();}

此时有人可能会想，我们的while循环是不是还有其他更简便的写法呢，上面代码中的read变量是不是可以省略，把while循环这样写

while(fis.read() != -1){System.out.println((char)fis.read());
}

可是当我们运行时发现这样写之后我们读取出来的数据会出现缺失，这是为什么呢？原因很简单，当我们调用read方法读取数据时，每读取一次数据指针就向后移动一次，也就是我们每调用一次read方法，指针就向后走一位。

2.5、拷贝文件

再次熟悉FileInputStream和FileOutputStream的使用

代码示例：

/*** 文件拷贝演示（边读边写）** 选择一个较小的文件进行拷贝，此时我们还没有学习到大文件* 传输，如果文件过大，会浪费时间*/
public class FileCopyDemo {public static void main(String[] args) throws IOException {//创建对象FileInputStream fis = new FileInputStream("D:\\图片音乐视频\\视频\\demo\\es安装.mp4");FileOutputStream fos = new FileOutputStream("D:\\实习\\笔记\\Java\\md\\File类\\imgs\\demo.mp4");//边读边写int read;while((read = fis.read()) != -1){fos.write(read);}System.out.println("拷贝成功~");//释放资源//先创建的对象后关闭，后创建的对象先关闭fos.close();fis.close();}
}

在我们传输一个小文件时，上述的代码运行时间我们还是可以接受的，但是当我们传输一个大文件时，我们会疯掉的，因为它实在是太慢了，那么有没有什么方法来解决这个问题呢？当然有，我们每次可以读取多个字节，这样我们拷贝文件的时间将会大大缩减。

2.5.1、FileInputStream一次读取多个字节

方法名称	说明
public int read（byte [] buffer）	一次读取一个字节数组数据，每次读取尽可能把数组装满，返回一次读取多少个数据

注意：虽然数组越大，传输的速度会越快，但是我们也不能把读取数组创建的太惊人，因为我们也要为电脑内存考虑一下，一般我们所开设的数组内存大小一般是1024的整数倍。

那么上述拷贝文件我们就可以这样做啦：

/*** 拷贝文件速度优化版*/public class FileCopyDemo2 {public static void main(String[] args) throws IOException {long time1 = new Date().getTime();//创建对象FileInputStream fis = new FileInputStream("D:\\图片音乐视频\\视频\\demo\\es安装.mp4");FileOutputStream fos = new FileOutputStream("D:\\实习\\笔记\\Java\\md\\File类\\imgs\\demo.mp4");//拷贝文件int len;byte[] bytes = new byte[1024 * 1024 * 5];while((len = fis.read(bytes)) != -1){fos.write(bytes, 0, len);}long time2 = new Date().getTime();System.out.println("传输成功~共用时：" +(time2 - time1) + "ms");//释放资源fos.close();fis.close();}
}

此时我们发现这拷贝速度块啦很多很多~~

补充一下，上述代码中的异常我们都是直接抛出的，但是在我们实际开发中一般是将其进行捕获处理的捕获（若要了解异常方面知识，可以参考我之前的笔记简单了解java中的异常）,所以我们来修改一下上面的代码把。

/*** 使用try  catch对代码中的异常进行处理*/public class FileCopyDemo3 {public static void main(String[] args) {long time1 = System.currentTimeMillis();FileInputStream fis = null;FileOutputStream fos = null;try {//创建对象fis = new FileInputStream("D:\\图片音乐视频\\视频\\demo\\es安装.mp4");fos = new FileOutputStream("D:\\实习\\笔记\\Java\\md\\File类\\imgs\\demo.mp4");//拷贝文件int len;byte[] bytes = new byte[1024 * 1024 * 5];while((len = fis.read(bytes)) != -1){fos.write(bytes, 0, len);}} catch (IOException e) {throw new RuntimeException(e);} finally {}long time2 = System.currentTimeMillis();System.out.println("传输成功~共用时：" +(time2 - time1) + "ms");//释放资源(当不为空时才释放资源)if(fos != null){try {fos.close();} catch (IOException e) {throw new RuntimeException(e);}}if(fis != null){try {fis.close();} catch (IOException e) {throw new RuntimeException(e);}}}
}

2.6、字符流

2.6.1、概述

字符流的底层其实就是字节流（字符流 = 字节流 + 字符集）

特点：

输入流：一次读一个字节，遇到中文时，一次读多个字节

输出流：底层会把数据按照指定的编码方式进行编码，编程字节再写到文件中

使用场景：对于纯文本文件进行读写操作

2.6.2、FileReader

• 创建字符输入流对象

构造方法	说明
public FileReader**（File file）**	创建字符输入流关联本地文件
public FileReader**（String pathname）**	创建字符输入流关联本地文件

注意：如果文件不存在直接报错

• 读取数据

成员方法	说明
public int read（）	读取数据，读到末尾返回-1
public int read（char[], buffer）	读取多个数据，读到末尾返回-1

• 释放资源

成员方法	说明
public int close（）	释放资源/关流

代码示例（空参read）：

/*** FileReader读取数据(空参read)演示*/
public class FileReaderDemo1 {public static void main(String[] args) throws IOException {//创建对象FileReader fr = new FileReader("D:\\Application\\IDEA\\code\\javaThread\\demo.txt");//读取数据int reade;while((reade = fr.read()) != -1){System.out.print((char) reade);}//释放资源fr.close();}
}

/*** FileReader读取数据(有参read)演示*/
public class FileReaderDemo2 {public static void main(String[] args) throws IOException {//创建对象FileReader fr = new FileReader("D:\\Application\\IDEA\\code\\javaThread\\demo.txt");//读取数据char[] chars = new char[1024];int len;while((len = fr.read(chars)) != -1){System.out.print(new String(chars, 0, len));}//释放资源fr.close();}
}

2.6.3、FileWriter

• 构造方法

构造方法	说明
public FileWriter（File file）	创建字符输出流关联本地文件
public FileWriter（String pathname）	创建字符输出流关联本地文件
public FileWriter（File file, boolean append）	创建字符输出流关联本地文件、续写
public FileWriter（String pathname, boolean append）	创建字符输出流关联本地文件、续写

• 成员方法

成员方法	说明
void write （int c）	写出一个字符
void write （String str）	写出一个字符串
void write （String str, int off, int len）	写出一个字符串的一部分
void write （char[] cbuf）	写出一个字符数组
void write （char[] cbuf, int off, int len）	写出一个字符数组的一部分

代码示例：

/*** FileWriter写出数据演示*/
public class FileWriterDemo1 {public static void main(String[] args) throws IOException {//创建对象FileWriter fw = new FileWriter("D:\\Application\\IDEA\\code\\javaThread\\demo.txt");//写出数据String str = "大家好！\r\n我叫糖锅~\r\n希望大家能够喜欢我~~";fw.write(str);//关闭资源fw.close();}
}

2.7、字节流和字符流使用场景

字节流：拷贝任意类型的文件

字符流：读取纯文本文件中的数据，往纯文本文件中写出数据

案例1：拷贝文件夹

/*** 拷贝一个文件夹，考虑子文件夹* 拷贝的文件夹：D:\实习\笔记\Java\md\线程* 拷贝到：D:\实习\FileCopyDemo*/
public class FileCopyDemo4 {//创建数据源对象static File sta = new File("D:\\实习\\笔记\\Java\\md\\线程");//创建拷贝目的地文件对象static File en = new File("D:\\实习\\FileCopyDemo");//调用copyFiles(File sta, File en)方法进行文件夹拷贝public static void main(String[] args) throws IOException {copyFiles(sta, en);System.out.println("拷贝完成~");}//copyFiles方法内部逻辑public static void copyFiles(File sta, File en) throws IOException {//如果en路径表示的文件夹不存在，则创建en.mkdirs();//获取sta路径下的所有内容File[] files = sta.listFiles();//for循环遍历文件内容for (File file : files) {//判断内容数组中内容是文件夹还是文件，如果是文件则拷贝，反之则递归if(file.isFile()){//创建字节输入&出流对象FileInputStream fis = new FileInputStream(file);FileOutputStream fos = new FileOutputStream(new File(en, file.getName()));//拷贝数据int len;byte[] bytes = new byte[1024 * 1024];while((len = fis.read(bytes)) != -1){fos.write(bytes, 0, len);}//释放资源fos.close();fis.close();}else{//是文件夹递归copyFiles(file, new File(en, file.getName()));}}}
}

案例2：文件加密

/*** 为了保证文件的安全性，就需要对原始文件进行加密存储，在使用的时候再对其进行解密处理* 加密原理：* 对原始文件中内一个字节数据进行更改，然后将更改后的数据存储到新的文件中* 解密原理：* 读取加密文件，按照加密的规则反向操作，变成原始文件*/
public class FileEncAndDecDemo {public static void main(String[] args) throws IOException {enc();dec();}public static void enc() throws IOException {//创建对象关联原始的文件FileInputStream fis = new FileInputStream("D:\\图片音乐视频\\图片\\PS素材\\素材3.png");//创建对象关联加密文件FileOutputStream enc = new FileOutputStream("D:\\实习\\FileCopyDemo\\imgs\\加密文件.png");//进行加密int len;byte[] bytes = new byte[1024];while((len = fis.read(bytes)) != -1){for(int i = 0; i < len; i++){bytes[i] = (byte) (bytes[i] ^ 10);}enc.write(bytes, 0, len);}//释放资源enc.close();fis.close();System.out.println("加密成功");}public static void dec() throws IOException {//创建对象关联加密原始文件FileInputStream fis = new FileInputStream("D:\\实习\\FileCopyDemo\\imgs\\加密文件.png");//创建对象关联解密文件FileOutputStream dec = new FileOutputStream("D:\\实习\\FileCopyDemo\\imgs\\解密文件.png");//进行解密int len;byte[] bytes = new byte[1024];while((len = fis.read(bytes)) != -1){for(int i = 0; i < len; i++){bytes[i] = (byte) (bytes[i] ^ 10);}dec.write(bytes, 0, len);}//释放资源dec.close();fis.close();System.out.println("解密成功");}
}

案例3：修改文件中的数据

/***文本文件中有一下数据；9-12-3-0-5-4*将文件中的数据进行排序：0-3-4-5-9-12*/
public class FileUpdateDemo {public static void main(String[] args) throws IOException {//读取数据FileReader fr = new FileReader("D:\\实习\\FileCopyDemo\\demo.txt");StringBuffer sb = new StringBuffer();int len;char[] chars = new char[1024];while((len = fr.read(chars)) != -1){sb.append(chars, 0, len);}//关闭资源fr.close();//System.out.println(sb);//获取文本中的字符串String text = sb.toString();//切割String[] str = text.split("-");//排序List<Integer> list = new ArrayList<>();for (String s : str) {list.add(Integer.parseInt(s));}Collections.sort(list);//System.out.println(list);//写出数据FileWriter fw = new FileWriter("D:\\实习\\FileCopyDemo\\res.txt");for (int i = 0; i < list.size(); i++) {if(i != list.size() - 1){fw.write(list.get(i) + "-");}else{fw.write(list.get(i) + "");}}//关闭资源fw.close();}
}

3、缓冲流

3.1、字节缓冲流

方法名称	说明
public BufferedInputStream（InputStream is）	把基本流包装成高级流，提高读取数据的性能
public BufferedOutputStream（OutputStream os）	把基本流包装成高级流，提高写出数据的性能

代码示例：

/*** 用缓冲流实现数据拷贝*/
public class FileBufferedDemo {public static void main(String[] args) throws IOException {//创建对象BufferedInputStream bis = new BufferedInputStream(new FileInputStream("D:\\实习\\FileCopyDemo\\demo.txt"));BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("D:\\实习\\FileCopyDemo\\res.txt"));//拷贝数据int read;while ((read = bis.read()) != -1) {bos.write(read);}//释放资源bos.close();bis.close();}
}

3.2、字符缓冲流

方法名称	说明
public BufferedReader（Reader r）	把基本流换成高级流
public BufferedWriter（Writer r）	把基本流换成高级流

特有方法：

方法名称	说明
public String readLine（）	读取一行数据，如果没有数据可读，返回null，字符缓冲输入流特有
public void newLine（）	跨平台的换行，字符缓冲输出流特有

代码示例：

/*** BufferedReader示例*/
public class FileBufferedDemo1 {public static void main(String[] args) throws IOException {//创建对象BufferedReader br = new BufferedReader(new FileReader("D:\\实习\\FileCopyDemo\\demo.txt"));//读取数据String line;while((line = br.readLine()) != null){System.out.println(line);}//关闭资源br.close();}
}/*** BufferedWriter演示*/
public class FielBufferedWriterDemo1 {public static void main(String[] args) throws IOException {//创建对象BufferedWriter bw = new BufferedWriter(new FileWriter("D:\\实习\\FileCopyDemo\\res.txt"));//写出数据bw.write("hello,我是糖锅~");bw.newLine();bw.write("希望大家会喜欢我");//释放资源bw.close();}
}

4、转换流

4.1、概述

是字符流和字节流之间的桥梁

示例1：利用转换流按照指定字符编码读取文件内容

//该读取方式作为了解OutputStreamWriter类似
public class InputStreamReaderDemo1 {public static void main(String[] args) throws IOException {/*文件地址：D:\实习\FileCopyDemo\gbkdemo.txt*///创建对象InputStreamReader isr = new InputStreamReader(new FileInputStream("D:\\实习\\FileCopyDemo\\gbkdemo.txt"), "GBK");//进行数据读取int len;char[] chars = new char[1024 * 8];while((len = isr.read(chars)) != -1){System.out.println(new String(chars, 0, len));}//释放资源r.close();}
}

5、序列化流（对象操作输出流）

5.1、可以把java中的对象写到本地文件中

• 构造方法

构造方法	说明
public ObjectOutputStream（OutputStream out）	把基本流包装成高级流

• 成员方法

成员方法	说明
public final void writeObject（Object obj）	把对象序列化写出到文件中去

使用对象输出流将对象保存到文件中时会出现：NotSerializableException异常

解决方案是：让javabean实现Serializable接口，Serializable接口 里面是没有抽象方法的，它是一个标记型接口，一旦实现这个接口，那么表示当前的Student类可以被序列化

示例：ObjectOutputStream

public class ObjectOutputStreamDemo1 {public static void main(String[] args) throws IOException {//创建对象Person person = new Person("糖锅", 21);//创建序列化对象ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("D:\\实习\\FileCopyDemo\\demo.txt"));//写出数据oos.writeObject(person);//释放资源oos.close();}
}

如果一个对象中每个成员变量的值不想被序列化，给该成员加上transient关键字修饰，该关键字标记的成员变量不参与序列化过程。

6、反序列化流

6.1、概述

可以把序列化到本地中的文件中的对象，读取到程序中来

• 构造方法

构造方法	说明
public ObjectInputStream（InputStream in）	把基本流包装成高级流

• 成员方法

成员方法	说明
public Object readObject（）	把序列化到本地文件中的对象，读取到程序中

示例：

public class ObjectInputStreamDemo1 {public static void main(String[] args) throws IOException, ClassNotFoundException {//创建反序列化流对象ObjectInputStream ois = new ObjectInputStream(new FileInputStream("D:\\实习\\FileCopyDemo\\demo.txt"));//读取数据Object res = ois.readObject();System.out.println(res);//释放资源ois.close();}
}

7、打印流

打印流一般是指：PrintStream、PrintWriter两个类

特点：

打印流只操作文件目的地，不操作数据源

特有的方法可以实现，数据的原样输出、自动刷新、自动换行

• 字节打印流

构造方法	说明
public PrintStream（OutputStream/File/String）	关联字节输出流/文件/文件路径
public PrintStream（String fileName, Charset charset）	指定字符编码
public PrintStream（OutputStream out, boolean auroFlush）	自动刷新
public PrintStream（OutputStream out, boolean auroFlush, String encoding）	指定字符编码且自动刷新

• 字符打印流

构造方法	说明
public PrintWriter（Write/File/String）	关联字节输出流/文件/文件路径
public PrintWriter（String fileName, Charset charset）	指定字符编码
public PrintWriter（Write w, boolean autoFlush）	自动刷新
public PrintWriter（OutputStream out, boolean autoFlush, Charset charset）	指定字符编码且自动刷新

• 字节打印流/字符打印流成员方法

成员方法	说明
public void write（int b）	将指定的字符输出
public void println（Xxx xx）	打印任意数据，自动刷新，自动换行
public void print（Xxx xx）	打印任意数据不换行
public void printf（String format, Object…args）	带有占位符的打印语句，不换行