• Java之文件流(26个Demo)

    Java文件流主要包括字节流和字符流，字符流本质上就是字节流+编码表，下面通过26个案例介绍了字符流和字节流对文件的操作，包括创建文件路径，文件的读取和写入，文件判断，文件删除，遍历文件，文件复制，文件的编码与解码，文件异常处理以及对象序列化和反序列化等。

    目录

    1-File类的三个构造方法

    2-File类的创建功能

    3-File类判断和获取功能

    4-File类删除功能

    5-简单递归

    6-遍历目录打印绝对路径

    7-字节流写数据的三种方式

    8-字节流读数据的方式

    9-字节流复制文本文件

    10-字节流读数据(一次读一组)

    11-字节流复制图片

    12-字节缓冲流读取数据

    13-初识编码与解码

    14-字符流的编码与解码

    15-字符流写数据的5种方式

    16-字符流读数据的2种方式

    17-字符流复制文件

    18-字符缓冲流复制文件

    19-使用字符缓冲流特有功能复制文件

    20-集合数据传入文件

    21-文件数据读入集合

    22-复制单级文件夹(目录含文件，不含目录)

    23-复制多级文件夹(目录中包含目录和文件)

    24-复制文件的异常处理(try---catch代替throws)

    25-对象序列化流与对象反序列化流

    26-序列化中的serialVersionUID和transient

    1-File类的三个构造方法

    1. import java.io.File;
    2.  
    3. public class FileDemo01 {
    4.     public static void main(String[] args) {
    5.         //File封装路径
    6.         //创建File实例的三种方法
    7.         File file = new File("src\\com\\learn\\java.txt") ;
    8.         System.out.println(file);
    9.  
    10.         File file1 = new File("src\\com\\learn","java.txt") ;
    11.         System.out.println(file1);
    12.  
    13.         File file2 = new File("src\\com\\learn") ;
    14.         File file3 = new File(file2,"java.txt") ;
    15.         System.out.println(file3);
    16.     }
    17. }

    2-File类的创建功能

    1. import java.io.File;
    2. import java.io.IOException;
    3.  
    4. public class FileDemo02 {
    5.     public static void main(String[] args) throws IOException {
    6.         //在目录下创建java.txt文件
    7.         File file = new File("New\\src\\com\\learn\\java.txt") ;
    8.         System.out.println(file.createNewFile());
    9.         System.out.println("------------------");
    10.  
    11.         //在目录下创建目录study
    12.         File file1 = new File("New\\src\\com\\learn\\study") ;
    13.         System.out.println(file1.mkdir());
    14.         System.out.println("------------------");
    15.  
    16.         //在目录下创建多级目录study1\Java
    17.         File file2 = new File("New\\src\\com\\learn\\study1\\Java");
    18.         System.out.println(file2.mkdirs());
    19.         System.out.println("------------------");
    20.         
    21.     }
    22. }

    3-File类判断和获取功能

    1. import java.io.File;
    2. import java.io.IOException;
    3.  
    4. public class FileDemo03 {
    5.     public static void main(String[] args) throws IOException {
    6.         File file = new File("New\\src\\com\\learn\\java.txt");
    7.         file.createNewFile() ;
    8.  
    9.         System.out.println(file.isFile()); //是否是文件
    10.         System.out.println(file.isDirectory()); //是否是目录
    11.         System.out.println(file.exists()); //是否存在
    12.  
    13.         System.out.println(file.getAbsolutePath()); //绝对路径
    14.         System.out.println(file.getPath()); //抽象的路径
    15.         System.out.println(file.getName()); //最后的文件或者目录名
    16.  
    17.         //返回文件和目录或者目录的字符串
    18.         File file1 = new File("New\\src") ;
    19.         String [] files = file1.list() ;
    20.         for(String s : files){
    21.             System.out.println(s);
    22.         }
    23.  
    24.  
    25.         //返回文件和目录的File对象
    26.         File [] files1 = file1.listFiles() ;
    27.         for(File file2 : files1){
    28.             System.out.println(file2);
    29.         }
    30.  
    31.     }
    32. }

    4-File类删除功能

    1.  
    2. import java.io.File;
    3. import java.io.IOException;
    4.  
    5. public class FileDemo04 {
    6.     public static void main(String[] args) throws IOException {
    7.         //创建java.txt文件并删除
    8.         File file = new File("New\\src\\com\\learn\\java.txt") ;
    9.         file.createNewFile() ;
    10.         file.delete() ;
    11. //        System.out.println("------------");
    12.  
    13.         //创建study目录并删除
    14.         File file1 = new File("New\\src\\com\\learn\\study") ;
    15.         file1.mkdir() ;
    16.         file1.delete() ;
    17. //        System.out.println("-------------");
    18.  
    19.         //先创建目录,再创建文件,然后先删除文件,后删除目录
    20.         File file2 = new File("New\\src\\com\\learn\\study") ;
    21.         file2.mkdir() ;
    22.         File file3 = new File("New\\src\\com\\learn\\study","java.txt") ;
    23.         file3.createNewFile() ;
    24.         file3.delete() ;
    25.         file2.delete() ;
    26.  
    27.     }
    28. }

    5-简单递归

    1. import java.util.Scanner;
    2.  
    3. public class FileDemo05 {
    4.     public static void main(String[] args) {
    5.         //递归求阶乘
    6.         Scanner input = new Scanner(System.in) ;
    7.         long n = input.nextLong() ;
    8.         System.out.println(f(n));
    9.     }
    10.     public static long f(long n){
    11.       return n==1 ? 1 : n * f(n-1) ;
    12.     }
    13. }

    6-遍历目录打印绝对路径

    1.  
    2. import java.io.File;
    3.  
    4. public class FileDemo06 {
    5.     public static void main(String[] args) {
    6.         //遍历文件，输出绝对路径
    7.         File file = new File("New\\src") ;
    8.         findPath(file) ;
    9.     }
    10.  
    11.     private static void findPath(File file) {
    12.         if(file != null) {
    13.             for (File file1 : file.listFiles()) {
    14.                 if (file1.isDirectory()) {
    15.                     findPath(file1); //是目录，递归调用
    16.                 } else {
    17.                     //不是目录,打印绝对路径
    18.                     System.out.println(file1.getAbsolutePath());
    19.                 }
    20.             }
    21.         }
    22.     }
    23. }

    7-字节流写数据的三种方式

    1. import java.io.FileOutputStream;
    2. import java.io.IOException;
    3.  
    4. public class FileDemo07 {
    5.     public static void main(String[] args) throws IOException {
    6.         //true表示追加,如果没有true就默认为覆盖
    7.         FileOutputStream fos = new FileOutputStream("New\\src\\com\\learn\\java.txt",true) ;
    8.         fos.write(97); //写单个
    9.         fos.write("\r\n".getBytes());
    10.         fos.write("abcde\r\n".getBytes()); //写一组
    11.         fos.write("xyzw\r\n".getBytes(),1,3); //写指定长度
    12.         fos.close();
    13.  
    14.     }
    15. }

    8-字节流读数据的方式

    1.  
    2. import java.io.FileInputStream;
    3. import java.io.IOException;
    4.  
    5. public class FileDemo08 {
    6.     public static void main(String[] args) throws IOException {
    7.         FileInputStream fis = new FileInputStream("New\\src\\com\\learn\\java.txt") ;
    8.         //读取一次数据
    9.         int by = fis.read() ;
    10.         System.out.println(by);
    11.         System.out.println((char)by);
    12.  
    13.         //读取所有数据
    14.         while((by=fis.read()) != -1){
    15.             System.out.print((char)by);
    16.         }
    17.  
    18.         fis.close();
    19.     }
    20. }

    9-字节流复制文本文件

    1. import java.io.FileInputStream;
    2. import java.io.FileOutputStream;
    3. import java.io.IOException;
    4.  
    5. public class FileDemo09 {
    6.     public static void main(String[] args) throws IOException {
    7.         //字节流依次读取文件内容并写入新文件
    8.         FileInputStream fis = new FileInputStream("New\\src\\com\\learn\\java.txt") ;
    9.         FileOutputStream fos = new FileOutputStream("New\\src\\com\\learn\\python.txt") ;
    10.  
    11.         int by ;
    12.         while((by=fis.read()) != -1){
    13.             fos.write((char)by);
    14.         }
    15.         fis.close();
    16.         fos.close();
    17.     }
    18. }

    10-字节流读数据(一次读一组)

    1.  
    2. import java.io.FileInputStream;
    3. import java.io.IOException;
    4.  
    5. public class FileDemo10 {
    6.     public static void main(String[] args) throws IOException {
    7.         FileInputStream fis = new FileInputStream("New\\src\\com\\learn\\java.txt") ;
    8.         byte [] bytes = new byte[1024] ;
    9.         int len ;
    10.         while((len=fis.read(bytes)) != -1){
    11.             System.out.println(new String(bytes,0,len));
    12.         }
    13.         fis.close();
    14.  
    15.     }
    16. }

    11-字节流复制图片

    1. import java.io.FileInputStream;
    2. import java.io.FileOutputStream;
    3. import java.io.IOException;
    4.  
    5. public class FileDemo11 {
    6.     public static void main(String[] args) throws IOException {
    7.         //字节流复制图片
    8.         FileInputStream fis = new FileInputStream("New\\src\\com\\learn\\x.jpg") ;
    9.         FileOutputStream fos = new FileOutputStream("New\\src\\com\\my\\x.jpg") ;
    10.  
    11.         byte [] bytes = new byte[1024] ;
    12.         int len ;
    13.         while((len=fis.read(bytes)) != -1){
    14.             fos.write(bytes,0,len);
    15.         }
    16.         fis.close();
    17.         fos.close();
    18.     }
    19. }

    12-字节缓冲流读取数据

    1. import java.io.BufferedInputStream;
    2. import java.io.FileInputStream;
    3. import java.io.IOException;
    4.  
    5. public class FileDemo12 {
    6.     public static void main(String[] args) throws IOException {
    7.         //字节缓冲流
    8.         BufferedInputStream bis = new BufferedInputStream(new FileInputStream("New\\src\\com\\learn\\java.txt")) ;
    9.         byte [] bytes = new byte[1024] ;
    10.         int len ;
    11.         while((len=bis.read(bytes)) != -1){
    12.             System.out.println(new String(bytes,0,len));
    13.         }
    14.     }
    15. }

    13-初识编码与解码

    1. import java.io.UnsupportedEncodingException;
    2. import java.util.Arrays;
    3.  
    4. public class FileDemo13 {
    5.     public static void main(String[] args) throws UnsupportedEncodingException {
    6.         String s = "中国" ;
    7.         //编码
    8.         byte [] bytes = s.getBytes("GBK") ;
    9.         byte [] bytes1 = s.getBytes("UTF-8") ;
    10.         System.out.println(Arrays.toString(bytes));
    11.         System.out.println(Arrays.toString(bytes1));
    12.  
    13.         //解码
    14.         String s1 = new String(bytes,"GBK") ;
    15.         String s2 = new String(bytes1, "UTF-8") ;
    16.         System.out.println(s1);
    17.         System.out.println(s2);
    18.  
    19.     }
    20. }

    14-字符流的编码与解码

    1.  
    2. import java.io.*;
    3.  
    4. public class FileDemo14 {
    5.     public static void main(String[] args) throws IOException {
    6.         //以GBK编码字符流写入
    7.         OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("New\\src\\com\\learn\\java.txt"),"GBK") ;
    8.         osw.write("中国");
    9.         osw.close();
    10.         //以GBK编码字符流读取
    11.         InputStreamReader osr = new InputStreamReader(new FileInputStream("New\\src\\com\\learn\\java.txt"),"GBK") ;
    12.         int len ;
    13.         while((len=osr.read()) != -1){
    14.             System.out.print((char) len);
    15.         }
    16.  
    17.     }
    18. }

    15-字符流写数据的5种方式

    1. import java.io.FileOutputStream;
    2. import java.io.IOException;
    3. import java.io.OutputStreamWriter;
    4.  
    5. public class FileDemo15 {
    6.     public static void main(String[] args) throws IOException {
    7.         //字符流写数据的5种方式
    8.         OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("New\\src\\com\\learn\\java.txt")) ;
    9.         //写单个字符
    10. //        osw.write("a");
    11. //        osw.flush();
    12. //        osw.close();
    13.         //写字符数组
    14. //        char [] chars = {'a','b','c','e','d'} ;
    15. //        osw.write(chars);
    16. //        osw.flush();
    17. //        osw.close();
    18.         //写字符数组的一部分
    19. //        char [] chars1 = {'a','c','d','b'} ;
    20. //        osw.write(chars1,1,2);
    21. //        osw.flush();
    22. //        osw.close();
    23.         //写字符串
    24. //        osw.write("abcdefg");
    25. //        osw.flush();
    26. //        osw.close();
    27.         //写字符串的一部分
    28.         osw.write("abcdefg",1,4);
    29.         osw.flush();
    30.         osw.close();
    31.         
    32.     }
    33. }

    16-字符流读数据的2种方式

    1. import java.io.FileInputStream;
    2. import java.io.IOException;
    3. import java.io.InputStreamReader;
    4.  
    5. public class FileDemo16 {
    6.     public static void main(String[] args) throws IOException {
    7.         InputStreamReader isr = new InputStreamReader(new FileInputStream("New\\src\\com\\learn\\java.txt")) ;
    8.         //一次读取一个字符
    9.         int len ;
    10.         while((len=isr.read()) != -1){
    11.             System.out.print((char)len);
    12.         }
    13.         //一次读取一组字符
    14.         char [] bytes = new char[1024] ;
    15.         int by ;
    16.         while((by=isr.read(bytes)) != -1){
    17.             System.out.println(new String(bytes,0,by));
    18.         }
    19.  
    20.         isr.close();
    21.     }
    22. }

    17-字符流复制文件

    1. import java.io.*;
    2.  
    3. public class FileDemo17 {
    4.     public static void main(String[] args) throws IOException {
    5.         InputStreamReader isr = new InputStreamReader(new FileInputStream("New\\src\\com\\learn\\java.txt")) ;
    6.         OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("New\\src\\com\\my\\copy.txt")) ;
    7. //
    8. //        //方法1：单个字符依次读写
    9. //        int len ;
    10. //        while ((len=isr.read()) != -1){
    11. //            osw.write(len);
    12. //        }
    13. //        osw.close();
    14.         //方法2：一组字符的读写
    15.         int len ;
    16.         char [] chars = new char[1024] ;
    17.         while ((len = isr.read(chars)) != -1){
    18.             osw.write(chars,0,len);
    19.         }
    20.         osw.close();
    21.         isr.close();
    22.     }
    23. }
    1. import java.io.FileReader;
    2. import java.io.FileWriter;
    3. import java.io.IOException;
    4.  
    5. public class FileDemo18 {
    6.     public static void main(String[] args) throws IOException {
    7.         FileReader fr = new FileReader("New\\src\\com\\learn\\java.txt") ;
    8.         FileWriter fw = new FileWriter("New\\src\\com\\my\\copy.txt") ;
    9.  
    10.         //一次读写一个字符
    11. //        int len ;
    12. //        while((len=fr.read()) !=-1){
    13. //            fw.write(len);
    14. //        }
    15. //        fw.close();
    16.  
    17.         //一次写一组数据
    18.         int len ;
    19.         char [] chars = new char[1024] ;
    20.         while((len=fr.read(chars)) != -1){
    21.             fw.write(chars,0,len);
    22.         }
    23.         fr.close();
    24.         fw.close();
    25.     }
    26. }

    18-字符缓冲流复制文件

    1. import java.io.*;
    2.  
    3. public class FileDemo19 {
    4.     public static void main(String[] args) throws IOException {
    5.         BufferedReader br = new BufferedReader(new FileReader("New\\src\\com\\learn\\java.txt")) ;
    6.         BufferedWriter bw = new BufferedWriter(new FileWriter("New\\src\\com\\my\\copy.txt")) ;
    7.  
    8.         //一次读写一个字符
    9. //        int len ;
    10.         while((len=br.read()) != -1){
    11.             bw.write(len);
    12.         }
    13.         br.close();
    14.         bw.close();
    15.         //一次写一组字符
    16.         int len ;
    17.         char [] chars = new char[1024] ;
    18.         while((len=br.read(chars)) != -1){
    19.             bw.write(chars,0,len);
    20.         }
    21.         bw.close();
    22.         br.close();
    23.     }
    24. }

    19-使用字符缓冲流特有功能复制文件

    1. import java.io.*;
    2.  
    3. public class FileDemo20 {
    4.     public static void main(String[] args) throws IOException {
    5.         BufferedReader br = new BufferedReader(new FileReader("New\\src\\com\\learn\\java.txt")) ;
    6.         BufferedWriter bw = new BufferedWriter(new FileWriter("New\\src\\com\\my\\copy.txt")) ;
    7.  
    8.         String line ;
    9.         while ((line=br.readLine()) != null){
    10.             bw.write(line);
    11.             bw.newLine();
    12.             bw.flush();
    13.         }
    14.         bw.close();
    15.         br.close();
    16.  
    17.     }
    18. }

    20-集合数据传入文件

    1. import java.io.BufferedWriter;
    2. import java.io.FileWriter;
    3. import java.io.IOException;
    4. import java.util.ArrayList;
    5.  
    6. public class FileDemo21 {
    7.     public static void main(String[] args) throws IOException {
    8.         ArrayList arrayList = new ArrayList<>() ;
    9.         arrayList.add("Java") ;
    10.         arrayList.add("python");
    11.         arrayList.add("c");
    12.  
    13.         BufferedWriter bw = new BufferedWriter(new FileWriter("New\\src\\com\\learn\\java.txt"));
    14.         for(String s : arrayList){
    15.             bw.write(s);
    16.             bw.newLine();
    17.             bw.flush();
    18.         }
    19.         bw.close();
    20.  
    21.     }
    22. }

    21-文件数据读入集合

    1. import java.io.BufferedReader;
    2. import java.io.FileReader;
    3. import java.io.IOException;
    4. import java.util.ArrayList;
    5.  
    6. public class FileDemo22 {
    7.     public static void main(String[] args) throws IOException {
    8.         BufferedReader br = new BufferedReader(new FileReader("New\\src\\com\\learn\\java.txt")) ;
    9.         ArrayList arrayList = new ArrayList<>() ;
    10.         String line ;
    11.         while((line = br.readLine()) != null){
    12.             arrayList.add(line);
    13.         }
    14.  
    15.         for(String str : arrayList){
    16.             System.out.println(str);
    17.         }
    18.     }
    19. }

    22-复制单级文件夹(目录含文件，不含目录)

    1.  
    2. import java.io.*;
    3.  
    4. public class FileDemo23 {
    5.     /**
    6.      * 有2个问题需要注意
    7.      * 第一，该方法只能复制单级文件，即目录里不能含有目录，只能含有文件
    8.      * 第二，对于源路径和目标路径一定要具体到文件名，否则会拒绝访问
    9.      * @param args
    10.      * @throws IOException
    11.      */
    12.     public static void main(String[] args) throws IOException {
    13.         File srcFile = new File("D:\\files") ;
    14.         File destFile = new File("New\\src\\com\\my\\",srcFile.getName()) ;
    15.  
    16.         if(!destFile.exists()){
    17.             destFile.mkdir() ;
    18.         }
    19.  
    20.         for(File files : srcFile.listFiles()){
    21.             String name = files.getName() ;
    22.             File newFile = new File(destFile,name) ;
    23.             copyFiles(files,newFile) ;
    24.         }
    25.     }
    26.  
    27.     private static void copyFiles(File srcFile, File newFile) throws IOException {
    28.         BufferedInputStream bis = new BufferedInputStream(new FileInputStream(srcFile)) ;
    29.         BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(newFile)) ;
    30.  
    31.         byte [] bytes = new byte[1024] ;
    32.         int len ;
    33.         while((len=bis.read(bytes)) != -1){
    34.             bos.write(bytes,0,len);
    35.         }
    36.         bis.close();
    37.         bos.close();
    38.  
    39.     }
    40. }

    23-复制多级文件夹(目录中包含目录和文件)

    1. import java.io.*;
    2.  
    3. public class FileDemo24 {
    4.     public static void main(String[] args) throws IOException {
    5.         File srcFile = new File("D:\\file") ;
    6.         File destFile = new File("New\\src\\com\\my") ;
    7.         copyFolder(srcFile,destFile) ;
    8.     }
    9.  
    10.     private static void copyFolder(File srcFile, File destFile) throws IOException {
    11.         //从源目录复制到目标目录
    12.         if(srcFile.isDirectory()){
    13.             File newFile = new File(destFile,srcFile.getName()) ;
    14.             if(!newFile.exists()){
    15.                 newFile.mkdir() ;
    16.             }
    17.             for(File file : srcFile.listFiles()){
    18.                 copyFolder(file,newFile);
    19.             }
    20.  
    21.         }else{ //是文件，直接复制
    22.             File newFile = new File(destFile,srcFile.getName()) ;
    23.             copyFile1(srcFile,newFile);
    24.         }
    25.     }
    26.  
    27.     private static void copyFile1(File srcFile, File newFile) throws IOException {
    28.         BufferedInputStream bis = new BufferedInputStream(new FileInputStream(srcFile)) ;
    29.         BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(newFile)) ;
    30.         int len ;
    31.         byte [] bytes = new byte[1024] ;
    32.         while((len=bis.read(bytes)) != -1){
    33.             bos.write(bytes,0,len);
    34.         }
    35.         bis.close();
    36.         bos.close();
    37.  
    38.     }
    39. }

    24-复制文件的异常处理(try---catch代替throws)

    1. import java.io.FileReader;
    2. import java.io.FileWriter;
    3. import java.io.IOException;
    4.  
    5. public class FileDemo25 {
    6.     public static void main(String[] args) {
    7.         method1() ;
    8.         method2() ;
    9.     }
    10.  
    11.     //方法1：直接进行try-catch处理异常
    12.     private static void method1() {
    13.         FileReader fr = null;
    14.         FileWriter fw = null;
    15.         try {
    16.              fr = new FileReader("New\\src\\com\\learn\\java.txt");
    17.              fw = new FileWriter("New\\src\\com\\my\\copy1.txt");
    18.             int len ;
    19.             char [] chars = new char[1024] ;
    20.             while((len=fr.read(chars)) != -1){
    21.                 fw.write(chars,0,len);
    22.             }
    23.         }catch (IOException e){
    24.             e.printStackTrace();
    25.         }finally {
    26.             try {
    27.                 if (fr != null) {
    28.                     fr.close();
    29.                 }
    30.             }catch (IOException e){
    31.                e.printStackTrace();
    32.             }
    33.             try {
    34.                 if (fw != null) {
    35.                     fw.close();
    36.                 }
    37.             }catch (IOException e){
    38.                 e.printStackTrace();
    39.             }
    40.         }
    41.     }
    42.  
    43.     //改进版本的异常处理
    44.     private static void method2() {
    45.         try(
    46.         FileReader fr = new FileReader("New\\src\\com\\learn\\java.txt");
    47.         FileWriter fw = new FileWriter("New\\src\\com\\my\\copy2.txt");) {
    48.             int len ;
    49.             char [] chars = new char[1024] ;
    50.             while((len=fr.read(chars)) != -1){
    51.                 fw.write(chars,0,len);
    52.             }
    53.  
    54.         }catch (IOException e){
    55.             e.printStackTrace();
    56.         }
    57.     }
    58. }

    25-对象序列化流与对象反序列化流

    1. import java.io.Serializable;
    2.  
    3. public class Student implements Serializable {
    4.     private String name ;
    5.     private int age ;
    6.  
    7.     public Student() {
    8.     }
    9.  
    10.     public Student(String name, int age) {
    11.         this.name = name;
    12.         this.age = age;
    13.     }
    14.  
    15.     public String getName() {
    16.         return name;
    17.     }
    18.  
    19.     public void setName(String name) {
    20.         this.name = name;
    21.     }
    22.  
    23.     public int getAge() {
    24.         return age;
    25.     }
    26.  
    27.     public void setAge(int age) {
    28.         this.age = age;
    29.     }
    30. }
    1. import java.io.*;
    2.  
    3. public class FileDemo26 {
    4.     public static void main(String[] args) throws IOException, ClassNotFoundException {
    5.         //对象序列化流
    6.         ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("New\\src\\com\\my\\c.txt")) ;
    7.         Student student = new Student("张三", 18) ;
    8.         oos.writeObject(student);
    9.         oos.close();
    10.  
    11.         //对象反序列化流
    12.         ObjectInputStream ois = new ObjectInputStream(new FileInputStream("New\\src\\com\\my\\c.txt")) ;
    13.         Object object = ois.readObject() ;
    14.         Student student1 = (Student) object ;
    15.  
    16.         System.out.println(student1.getName() + "," + student1.getAge());
    17.     }
    18. }

    26-序列化中的serialVersionUID和transient

    1. import java.io.Serializable;
    2.  
    3. public class Student implements Serializable {
    4.     //加入序列化后修改类文件,会报错，需要加一个版本号
    5.     private static final long serialVersionUID = 42L ;
    6.     private transient String name ; //给变量加transient关键字,可以不被序列化
    7.     private int age ;
    8.  
    9.     public Student() {
    10.     }
    11.  
    12.     public Student(String name, int age) {
    13.         this.name = name;
    14.         this.age = age;
    15.     }
    16.  
    17.     public String getName() {
    18.         return name;
    19.     }
    20.  
    21.     public void setName(String name) {
    22.         this.name = name;
    23.     }
    24.  
    25.     public int getAge() {
    26.         return age;
    27.     }
    28.  
    29.     public void setAge(int age) {
    30.         this.age = age;
    31.     }
    32.  
    33.     @Override
    34.     public String toString() {
    35.         return "Student{" +
    36.                 "name='" + name + '\'' +
    37.                 ", age=" + age +
    38.                 '}';
    39.     }
    40. }
    1. import java.io.*;
    2.  
    3. public class FileDemo26 {
    4.     public static void main(String[] args) throws IOException, ClassNotFoundException {
    5.         //对象序列化流
    6.         ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("New\\src\\com\\my\\c.txt")) ;
    7.         Student student = new Student("张三", 18) ;
    8.         oos.writeObject(student);
    9.         oos.close();
    10.  
    11.         //对象反序列化流
    12.         ObjectInputStream ois = new ObjectInputStream(new FileInputStream("New\\src\\com\\my\\c.txt")) ;
    13.         Object object = ois.readObject() ;
    14.         Student student1 = (Student) object ;
    15.  
    16.         System.out.println(student1.getName() + "," + student1.getAge());
    17.     }
    18. }
  • 相关阅读:
    RabbitMQ系列【2】核心概念
    【入门篇】UML-FlowChat流程图
    全志A33使用主线U-Boot
    基于SpringBoot招聘管理系统设计和实现(源码+LW+调试文档+讲解等)
    计算机二级WPS 选择题（模拟和解析十三）
    JavaWeb文件上传/下载（Servlet）
    【网络篇】如何给虚拟机添加网卡，设置固定ip
    【Spark】计算LSH引入新jar包-LinkedInAttic ScANNS
    PBR系列-物理材质（上）
    02_SpringSecurity学习之多种配置共存
  • 原文地址：https://blog.csdn.net/nuist_NJUPT/article/details/126184758