概述

计算机内存与硬盘之间时常有交互行为，由于参考对象是内存，所以我们把数据从硬盘到内存传输的行为称为输入，也叫写；相反地，数据从内存到硬盘传输的行为称为输出，也叫读。由于数据传输的动作是像流水一样，因此传输的数据也被称为流，于是就有了输入流和输出流的概念。
IO流有2种分类，按照流的方向可分为输入流和输出流；按读取数据的方式可分为字节流和字符流，其中字节流是万能的，能传输各种格式的数据，而字符流只能传输纯文本文件，即能用记事本打开的文件。
Java的IO流有4个抽象类，分别是InputStream-OutputStream、Reader-Writer，以Stream结尾的文件称为字节流文件，以Reader或Writer结尾的文件被称为字符流文件。值得注意的是，只有数据传输时内存和硬盘的通道才会被打开，所以数据传输完毕后所有流都有关闭流的动作，因此所有流都实现了Closeable接口。同时，当内存向硬盘传输数据完成以后，是需要刷新的，因为这个刷新的动作表示将管道中剩余未输出的数据强行清空，所以所有的输出流都会实现Flushable接口，如果没有实现此接口，则有可能数据在传输过程中会丢失。
image.png
注：①路径中，\和/是等效的 ②IDEA目录中，默认的路径是当前工程下的根目录
先以FileInputstream类为例，介绍以下几个方法：
image.png
image.png

字节流

  1. package IOStream;
  3. import java.io.FileInputStream;
  4. import java.io.FileNotFoundException;
  5. import java.io.IOException;
  7. public class FileInputStreamTest03 {
  8.     public static void main(String[] args) {
  9.         FileInputStream fis = null;
  10.         try {
  11.             //创建文件字节输出流对象
  12.             //此文件建在project的直接目录下
  13.             fis = new FileInputStream("mytest1.txt");
  14.             int readCount;
  15.             byte[] bytes = new byte[1024];
  16.             while ((readCount = fis.read(bytes))!= -1){
  17.                 System.out.println(readCount);//19
  18.                 //以byte[1024]大小的数组去读，然后数据留在了数组中，再将数组中的数据转成String类型
  19.                 //String类的构造方法，String(char[])，字符数组转成字符串
  20.                 System.out.println(new String(bytes,0,readCount));//heLLo,??   world...
  21.             }
  22.         } catch (FileNotFoundException e) {
  23.             e.printStackTrace();
  24.         } catch (IOException e) {
  25.             e.printStackTrace();
  26.         } finally {
  27.             //关闭流
  28.             if (fis != null) {
  29.                 try {
  30.                     fis.close();
  31.                 } catch (IOException e) {
  32.                     e.printStackTrace();
  33.                 }
  34.             }
  35.         }
  36.     }
  37. }
  40. FileInputStream类的其他2个方法：
  41. package IOStream;
  43. import java.io.File;
  44. import java.io.FileInputStream;
  45. import java.io.FileNotFoundException;
  46. import java.io.IOException;
  48. /**
  49.  * FileInputStream类的其他常用方法
  50.  * ①int available():其作用是避免了while()循环，不需要判断是不是读到头了。这个方法不适合大文件
  51.  * ②long skip(long n):跳过几个字节不读
  52.  */
  53. public class FileInputStream04 {
  54.     public static void main(String[] args) {
  55.         testAvailMethod();
  56.         testSkipMethod();
  57.     }
  59.     private static void testAvailMethod() {
  60.         FileInputStream fis = null;
  61.         try {
  62.             fis = new FileInputStream("mytest1.txt");
  63.             System.out.println("刚开始读的字节数：" + fis.available());  //刚开始读的字节数：14
  64.             int readCount = fis.read();
  65.             System.out.println("读完后的字节数：" + fis.available());   //读完后的字节数：13
  66.             System.out.println(new String(new byte[fis.available()]));  //
  67.         } catch (FileNotFoundException e) {
  68.             e.printStackTrace();
  69.         } catch (IOException e) {
  70.             e.printStackTrace();
  71.         } finally {
  72.             try {
  73.                 fis.close();
  74.             } catch (IOException e) {
  75.                 e.printStackTrace();
  76.             }
  77.         }
  78.     }
  80.     public static void testSkipMethod(){
  81.         FileInputStream fis = null;
  82.         File file = new File("mytest1.txt");
  83.         try {
  84.             fis = new FileInputStream(file);
  85.             fis.skip(3);
  86.             System.out.println(new String(new byte[fis.available() - 3]));//        
  88.         } catch (FileNotFoundException e) {
  89.             e.printStackTrace();
  90.         } catch (IOException e) {
  91.             e.printStackTrace();
  92.         } finally {
  93.             try {
  94.                 fis.close();
  95.             } catch (IOException e) {
  96.                 e.printStackTrace();
  97.             }
  98.         }
  99.     }
  100. }

FileOutputStream类用法类似，比如我们将刚才从文件读取的内容写到另外一个文件中：

  1. package IOStream;
  3. import java.io.File;
  4. import java.io.FileNotFoundException;
  5. import java.io.FileOutputStream;
  6. import java.io.IOException;
  8. public class FileOutputStreamTest01 {
  9.     public static void main(String[] args) {
  10.         FileOutputStream fos = null;
  11.         try {
  12.             //以追加方式写入，英文字符和汉字。
  13.             //注意：不追加的话每写一次就会清空之前的内容
  14.             fos = new FileOutputStream("myoutfile.txt",true);
  15.             byte[] bytes = {101,28,23,78,69};
  16.             fos.write(bytes,0,bytes.length);
  17.             String s = "今天天气不太好！！！";
  18.             byte[] bytes1 = s.getBytes();
  19.             fos.write(bytes1);  //文件内容：eNE今天天气不太好！！！eNE今天天气不太好！！！
  20.             fos.flush();
  21.         } catch (FileNotFoundException e) {
  22.             e.printStackTrace();
  23.         } catch (IOException e) {
  24.             e.printStackTrace();
  25.         }finally {
  26.             try {
  27.                 fos.close();
  28.             } catch (IOException e) {
  29.                 e.printStackTrace();
  30.             }
  31.         }
  32.     }
  33. }

字节流复制文件
文件复制：由于C、D盘并不能直接交互，需要以内存为中介进行操作，所有需要边读边写，具体代码如下：

  1. package IOStream;
  3. import java.io.FileInputStream;
  4. import java.io.FileNotFoundException;
  5. import java.io.FileOutputStream;
  6. import java.io.IOException;
  8. public class CopyFileTest {
  9.     public static void main(String[] args) {
  10.         FileInputStream fis = null;
  11.         FileOutputStream fos = null;
  12.         try {
  13.             fis = new FileInputStream("C:\\Users\\Simon\\Desktop\\List\\something convinient\\面试day726.md");
  14.             fos = new FileOutputStream("D:\\面试day726.md");
  15.             byte[] bytes = new byte[1024*1024];
  16.             int readCount = 0;
  17.             while ((readCount = fis.read(bytes,0,readCount))!= -1){
  18.                 fos.write(bytes,0,bytes.length);
  19.             }
  20.             fos.flush();
  21.         } catch (FileNotFoundException e) {
  22.             e.printStackTrace();
  23.         } catch (IOException e) {
  24.             e.printStackTrace();
  25.         }finally {
  26.             if (fis != null) {
  27.                 try {
  28.                     fis.close();
  29.                 } catch (IOException e) {
  30.                     e.printStackTrace();
  31.                 }
  32.             }
  33.             if (fos != null) {
  34.                 try {
  35.                     fos.close();
  36.                 } catch (IOException e) {
  37.                     e.printStackTrace();
  38.                 }
  39.             }
  40.         }
  41.     }
  42. }

字符流

  1. package IOStream;
  3. import java.io.FileNotFoundException;
  4. import java.io.FileReader;
  5. import java.io.IOException;
  7. public class FileReaderTest {
  8.     public static void main(String[] args) {
  9.         FileReader fr = null;
  10.         try {
  11.             fr = new FileReader("D:\\DataValue\\project\\MyData\\Data1\\src\\IOStream\\iotest1.txt");
  12.             char[] chars =new char[20];
  13.             int readCount = 0;
  14.             while ((readCount = fr.read(chars))!=-1){
  15.                 //hello,wo   rld
  16.                 //sdaj
  17.                 //kfsdghsdkbk我就偶返回数据拷贝
  18.                 //到方便快速
  19.                 //撒娇不看电视
  20.                 System.out.println(new String(chars, 0, readCount));
  21.             }
  22.         } catch (FileNotFoundException e) {
  23.             e.printStackTrace();
  24.         } catch (IOException e) {
  25.             e.printStackTrace();
  26.         } finally {
  27.             if (fr != null) {
  28.                 try {
  29.                     fr.close();
  30.                 } catch (IOException e) {
  31.                     e.printStackTrace();
  32.                 }
  33.             }
  34.         }
  35.     }
  36. }
  42. package IOStream;
  44. import java.io.FileWriter;
  45. import java.io.IOException;
  47. public class WriterTest {
  48.     public static void main(String[] args) {
  49.         FileWriter fw = null;
  50.         try {
  51.             fw = new FileWriter("D:\\Data\\temp.txt");
  52.             char[] c = {'我','是','人'};
  53.             fw.write(c);
  54.             fw.write(c,0,2);
  55.             fw.write("mytest.only you");//文件内容：我是人我是mytest.only you
  56.             fw.flush();
  57.         } catch (IOException e) {
  58.             e.printStackTrace();
  59.         }finally {
  60.             if (fw != null) {
  61.                 try {
  62.                     fw.close();
  63.                 } catch (IOException e) {
  64.                     e.printStackTrace();
  65.                 }
  66.             }
  67.         }
  68.     }
  69. }
  75. package IOStream;
  77. import java.io.FileNotFoundException;
  78. import java.io.FileReader;
  79. import java.io.FileWriter;
  80. import java.io.IOException;
  82. public class CopyFileTest2 {
  83.     public static void main(String[] args) {
  84.         FileReader in =null;
  85.         FileWriter out = null;
  86.         try {
  87.             in = new FileReader("D:\\DataValue\\project\\MyData\\Data1\\src\\IOStream\\iotest1.txt");
  88.             out = new FileWriter("D:\\DataValue\\project\\MyData\\Data1\\iotest1.txt");
  90.             //文件输出：
  91.             // hello,wo   rld
  92.             //sdajkfsdghsdkbk我就偶返回数据拷贝到方便快速
  93.             //撒娇不看电视
  95.             char[] chars = new char[1024*1024];
  96.             int readCount = 0;
  97.             while ((readCount=in.read(chars))!=-1){
  98.                 out.write(chars,0,readCount);
  99.             }
  101.             out.flush();
  102.         } catch (FileNotFoundException e) {
  103.             e.printStackTrace();
  104.         } catch (IOException e) {
  105.             e.printStackTrace();
  106.         } finally {
  107.             try {
  108.                 in.close();
  109.             } catch (IOException e) {
  110.                 e.printStackTrace();
  111.             }
  112.             try {
  113.                 out.close();
  114.             } catch (IOException e) {
  115.                 e.printStackTrace();
  116.             }
  117.         }
  118.     }
  119. }

缓冲流

  1. package IOStream;
  3. import java.io.BufferedReader;
  4. import java.io.FileReader;
  6. /**
  7.  *带缓冲区的字符流：
  8.  * ①由于带缓冲区，所以不需要再指定字节数组或者字符数组
  9.  * ②包装流、节点流
  10.  *本流优点是，一读就读一行
  11.  */
  12. public class BufferReaderTest{
  13.     public static void main(String[] args)  throws Exception{
  14.         FileReader reader = new FileReader("D:\\DataValue\\project\\MyData\\Data1\\iotest1.txt");
  15.         //这里，FileReader称为节点流，外部的BufferedReader称为包装流
  16.         //这里的参数要传一个Reader类的对象，但Reader类是抽象的，所以可以以FileReader传入
  17.         BufferedReader br = new BufferedReader(reader);
  18.         String s = null;
  19.         while ((s=br.readLine())!=null){
  20.             //这里并不自带换行符
  21.             System.out.println(s);
  22.             //读取文件内容如下：
  23.             // hello,wo   rld
  24.             //sdajkfsdghsdkbk我就偶返回数据拷贝到方便快速
  25.             //撒娇不看电视
  26.         }
  27.         //对于包装流来说，只需要关闭最外层流就行，里面的节点流会自动关闭。
  28.         br.close();
  29.     }
  30. }
  34. //注意：文件字符流可以直接作为参数传入给缓冲流，但是字节流不行，它还必须经过转换流转成字符流
  35. //作为参数传入，所以会经历2次转换。
  37. package IOStream;
  39. import java.io.BufferedWriter;
  40. import java.io.FileOutputStream;
  41. import java.io.FileWriter;
  42. import java.io.OutputStreamWriter;
  44. public class BufferWriterTest {
  45.     public static void main(String[] args) throws Exception{
  46.         BufferedWriter bw = new BufferedWriter(new FileWriter("tetsBufferWriterTest.txt",true));
  47.         BufferedWriter bw2 = new BufferedWriter(new OutputStreamWriter(new FileOutputStream
  48.                                                          ("testBufferWriterTest2.txt",true)));
  49.         bw.write("hello"+"\n");
  50.         bw.write(100);
  51.         bw.write("test0000001",0,3);
  52.         //文件内容如下：
  53.         // hello
  54.         //dteshello
  55.         //dtes
  57.         bw2.write("my test for the .java file");
  58.         //文件内容输出如下：
  59.         // my test for the .java file
  61.         bw.flush();
  62.         bw.close();
  64.         bw2.flush();
  65.         bw2.close();
  66.     }
  67. }

读入和写出：以字节流为节点流

  1. package sumup.iostream;
  3. import java.io.*;
  5. //以字节流作为缓冲流的节点流
  6. //运行成功
  7. public class IOStreamTest06 {
  8.     public static void main(String[] args) {
  9.         BufferedReader br = null;
  10.         BufferedWriter bw = null;
  11.         try {
  12.             br = new BufferedReader(new InputStreamReader(new FileInputStream("myfile5")));
  13.             String s = null;
  14.             while ((s = br.readLine())!=null){
  15.                 System.out.println(s);
  16.             }
  17.         } catch (FileNotFoundException e) {
  18.             e.printStackTrace();
  19.         } catch (IOException e) {
  20.             e.printStackTrace();
  21.         } finally {
  22.             if (br != null) {
  23.                 try {
  24.                     br.close();
  25.                 } catch (IOException e) {
  26.                     e.printStackTrace();
  27.                 }
  28.             }
  29.         }
  32.         try {
  33.             bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("myfile7",true)));
  34.             bw.write("m买买买");
  35.             char[] chars = {'z','o','o'};
  36.             bw.write(chars);
  37.             bw.flush();
  38.         } catch (FileNotFoundException e) {
  39.             e.printStackTrace();
  40.         } catch (IOException e) {
  41.             e.printStackTrace();
  42.         }finally {
  43.             try {
  44.                 bw.close();
  45.             } catch (IOException e) {
  46.                 e.printStackTrace();
  47.             }
  48.         }
  49.     }
  50. }

读入和写出：以字符流为节点流

  1. package sumup.iostream;
  3. import java.io.*;
  4. //运行成功
  5. //用缓冲流读入和写出一个java文件，先以字符流作为节点流
  6. public class IOStreamTest05 {
  7.     public static void main(String[] args) {
  8.         FileReader fr =null;
  9.         BufferedWriter bw = null;
  10.         try {
  11.             fr = new FileReader("printLog");
  12.             BufferedReader br = new BufferedReader(fr);
  13.             String s = null;
  14.             while ((s=br.readLine())!=null){
  15.                 System.out.println(s);
  16.             }
  17.         } catch (FileNotFoundException e) {
  18.             e.printStackTrace();
  19.         } catch (IOException e) {
  20.             e.printStackTrace();
  21.         } finally {
  22.             try {
  23.                 fr.close();
  24.             } catch (IOException e) {
  25.                 e.printStackTrace();
  26.             }
  27.         }
  30.         try {
  31.             FileWriter fw = new FileWriter("myfile5");
  32.             bw = new BufferedWriter(fw);
  33.             bw.write("这是一个秘密，请保密");
  34.             bw.flush();
  35.         } catch (IOException e) {
  36.             e.printStackTrace();
  37.         }finally {
  38.             if (fr != null) {
  39.                 try {
  40.                     bw.close();
  41.                 } catch (IOException e) {
  42.                     e.printStackTrace();
  43.                 }
  44.             }
  45.         }
  47.     }
  48. }

数据流

  1. package IOStream;
  3. import java.io.DataOutputStream;
  4. import java.io.FileOutputStream;
  6. public class DataOutputStreamTest {
  7.     public static void main(String[] args) throws Exception{
  8.         DataOutputStream dos = new DataOutputStream(new FileOutputStream("dataOutputStream.txt"));
  9.         //写数据
  10.         byte b = 100;
  11.         short s = 30;
  12.         float f = 3.0f;
  13.         double d = 3.0;
  14.         int i = 3;
  15.         char c ='c';
  17.         //写:把数据及其类型写入文件，但由于不是普通文件，所以打开乱码
  18.         dos.writeByte(b);
  19.         dos.writeChar(c);
  20.         dos.writeInt(i);
  21.         dos.writeFloat(f);
  23.         dos.flush();
  24.         dos.close();
  25.     }
  26. }
  30. package IOStream;
  32. import java.io.DataInputStream;
  33. import java.io.FileInputStream;
  35. /**
  36.  * 按什么规则写，就按什么规则读
  37.  */
  38. public class DataInputStreamTest {
  39.     public static void main(String[] args) throws Exception{
  40.         DataInputStream dis = new DataInputStream(new FileInputStream("dataOutputStream.txt"));
  41.         //开始读
  42.         byte b = dis.readByte();
  43.         char c = dis.readChar();
  44.         float f = dis.readFloat();
  45.         int i = dis.readInt();
  47.         //b:100    c:c    f:4.2E-45    i:1077936128
  48.         System.out.println("b:" + b + "\tc:" + c + "\tf:" + f + "\ti:" + i);
  50.         dis.close();
  51.     }
  52. }

标准打印流

  2. package IOStream;
  4. import java.io.FileOutputStream;
  5. import java.io.PrintStream;
  7. public class PrintStreamTest {
  8.     public static void main(String[] args) throws Exception{
  9.         PrintStream ps = System.out;
  10.         ps.println("zs");
  11.         ps.println("ls");
  12.         ps.println("ww");
  14.         //不再输出到控制台，而是输出到printLog文件中
  15.         PrintStream pl = new PrintStream(new FileOutputStream("printLog"));
  16.         System.setOut(pl);
  17.         System.out.println("hello,world");
  18.         System.out.println("hello,kitty");
  19.     }
  20. }
  29. //一个案例
  31. package IOStream;
  33. import java.io.FileOutputStream;
  34. import java.io.PrintStream;
  35. import java.text.SimpleDateFormat;
  36. import java.util.Date;
  38. public class Logger {
  39.     public static void log(String msg)throws Exception{
  40.         //指向一个日志文件
  41.         PrintStream out = new PrintStream(new FileOutputStream("loggerTest.txt", true));
  42.         //改变输出方向
  43.         System.setOut(out);
  44.         //日期当前时间
  45.         Date date = new Date();
  46.         SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss SSS");
  47.         String strTime = sdf.format(date);
  49.         System.out.println(strTime + ":" + msg);
  50.     }
  51. }
  54. package IOStream;
  56. public class LoggerTest {
  57.     public static void main(String[] args) {
  58.         try {
  59.             Logger.log("zs做了一道奥数题");
  60.             Logger.log("ls打了一桶水");
  61.             Logger.log("ww完了一把游戏");
  62.         } catch (Exception e) {
  63.             e.printStackTrace();
  64.         }
  65.     }
  66. }
  69. 新增文档内容：
  70. 2021/10/12 10:36:37 864:zs做了一道奥数题
  71. 2021/10/12 10:36:37 890:ls打了一桶水
  72. 2021/10/12 10:36:37 890:ww完了一把游戏

关于File类

  1. package IOStream;
  3. import java.io.File;
  4. import java.text.SimpleDateFormat;
  5. import java.util.Date;
  7. /**
  8.  * File的直接父类是Object，不属于四大家族，所以File类是不能完成文件读和写的
  9.  * File对象是文件和目录的路径名的抽象表示形式
  10.  * Fiel类的常用方法
  11.  */
  12. public class FileTest {
  13.     public static void main(String[] args) throws Exception{
  14.         File file = new File("D:/file");
  15.         System.out.println(file.exists());  //false
  16.         //以文件形式新建
  17. /*        if (!(file.exists())){
  18.             file.createNewFile();
  19.         }*/
  20.         //以目录形式新建，可创建多重目录--->mkdirs
  21.         if (!(file.exists())){
  22.             file.mkdir();
  23.         }
  24.         //获取父路径
  25.         System.out.println(file.getParent());   //D:\
  26.         //获取父路径的绝对路径
  27.         System.out.println(file.getParentFile().getAbsolutePath()); //D:\
  28.         //获取文件名
  29.         System.out.println(file.getName()); //file
  31.         System.out.println(file.isDirectory()); //ture
  32.         System.out.println(file.isFile());  //false
  34.         //获取对象的最后一次修改时间
  35.         long lm = file.lastModified();
  36.         Date date = new Date(lm);
  37.         SimpleDateFormat sdf = new SimpleDateFormat("yyyy - MM - dd  HH:mm:ss   SSS");
  38.         System.out.println(sdf.format(date));   //2021 - 10 - 12  10:54:31   487
  40.         //获取文件大小
  41.         System.out.println(file.length());  //0
  43.         //File中的listFiles方法
  44.         File[] files = file.listFiles();
  45.         for (File file1 : files) {
  46.             System.out.println(file1.getName());
  47.             //输出内容如下(是正确的)：
  48.             // 1
  49.             //2
  50.             //3.txt
  51.             //4.txt
  53.         }
  54.     }
  55. }

对象流-序列化和反序列化

  1. package IOStream.bean;
  3. import java.io.Serializable;
  5. //Serializable标志性接口
  6. public class Student implements Serializable {
  7.     private int no;
  8.     private String name;
  9.     //若  private transient String name;则最终输出：
  10.     //Student{no=1111, name='null'}
  12.     @Override
  13.     public String toString() {
  14.         return "Student{" +
  15.                 "no=" + no +
  16.                 ", name='" + name + '\'' +
  17.                 '}';
  18.     }
  20.     public int getNo() {
  21.         return no;
  22.     }
  24.     public void setNo(int no) {
  25.         this.no = no;
  26.     }
  28.     public String getName() {
  29.         return name;
  30.     }
  32.     public void setName(String name) {
  33.         this.name = name;
  34.     }
  36.     public Student(int no, String name) {
  37.         this.no = no;
  38.         this.name = name;
  39.     }
  41.     public Student() {
  42.     }
  43. }
  48. package IOStream;
  50. import IOStream.bean.Student;
  52. import java.io.FileOutputStream;
  53. import java.io.ObjectOutputStream;
  54. import java.io.Serializable;
  56. /**
  57.  * 对象的序列化和反序列化
  58.  * 参与对象序列化和反序列的对象，必须实现Serializable接口
  59.  * 仅有接口没有方法的称为标志性接口，作用是什么？
  60.  * JVM看到这个接口后，会为这个类自动生成一个序列化版本号
  61.  * 序列化版本号有什么用？每序列化一次就会生成一个序列化版本号，JVM怎么判断一个类有没有被改动？
  62.  *①全类名是否变化    ②若①相同，比较2个序列化版本号是否一样，一样则表示为同一个类
  63.  *
  64.  */
  65. public class ObjectOutputStreamTest {
  66.     public static void main(String[] args) throws Exception{
  67.         //创建java对象
  68.         Student s = new Student(1111, "zhangsan");
  69.         //序列化
  70.         ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("studentTest"));
  71.         //序列化对象
  72.         oos.writeObject(s);
  74.         oos.flush();
  75.         oos.close();
  77.     }
  78. }
  80. /**
  81. *注意：如果改动了代码，然后没有序列化，直接点了反序列化操作，会报以下异常：
  82. *Exception in thread "main" java.io.InvalidClassException: IOStream.bean.Student; local class incompatible: stream classdesc serialVersionUID = 9082654830569486289, local class serialVersionUID = 3103404913107206989
  83.     at java.io.ObjectStreamClass.initNonProxy(ObjectStreamClass.java:699)
  84.     at java.io.ObjectInputStream.readNonProxyDesc(ObjectInputStream.java:1885)
  85.     at java.io.ObjectInputStream.readClassDesc(ObjectInputStream.java:1751)
  86.     at java.io.ObjectInputStream.readOrdinaryObject(ObjectInputStream.java:2042)
  87.     at java.io.ObjectInputStream.readObject0(ObjectInputStream.java:1573)
  88.     at java.io.ObjectInputStream.readObject(ObjectInputStream.java:431)
  89.     at IOStream.ObjectInputStreamTest.main(ObjectInputStreamTest.java:9)
  91. Process finished with exit code 1
  93. */
  94. //自动生成序列化版本号有什么坏处？只要修改就必须重新编译。
  95. //所以凡是一个类实现了Serializable接口，建议给该类提供一个固定不变的序列化版本号
  96. //比如ArrayList的：private static final long serialVersionUID = 8683452581122892189L;
  100. package IOStream;
  102. import java.io.FileInputStream;
  103. import java.io.ObjectInputStream;
  105. public class ObjectInputStreamTest {
  106.     public static void main(String[] args) throws Exception{
  107.         ObjectInputStream ois = new ObjectInputStream(new FileInputStream("studentTest"));
  108.         Object o = ois.readObject();
  109.         System.out.println(o);    //Student{no=1111, name='zhangsan'}
  110.         ois.close();
  111.     }
  112. }

IO和Properties的联合使用

在idea写一个Properties文件，以key-value形式存储在硬盘中，我们创建一个userinfo.txt文件，内容写入：
username=admin
password=123
########################################这个＃号表示注释##########################

  1. package IOStream;
  3. import java.io.FileReader;
  4. import java.util.Properties;
  6. /**
  7.  * Properties是一个Map集合，key和value都是String类型
  8.  * 想将userinfo.txt文件中的数据加载到Properties对象中
  9.  *
  10.  * 这是一个非常好的设计理念：
  11.  * 以后经常改变的数据，可以单独写到一个文件中，使用程序动态读取，将来只需要修改文件的内容，
  12.  * java代码不需要改动，不需要重新编译，服务器也不需要重启
  13.  *
  14.  * 类似以上机制的这种文件称为配置文件，当配置文件的内容格式是：
  15.  * key1=value；
  16.  * key2=value；
  17.  * 时，我们把这种配置文件称为属性配置文件
  18.  *
  19.  * java规范中有要求：属性配置文件建议以.properties结尾，但这不是必须的。
  20.  * .properties是专门存放在属性配置文件内容的一个类
  21.  */
  22. public class IOPropertiesTest {
  23.     public static void main(String[] args) throws Exception{
  24.         //创建文件字符输入流对象
  25.         FileReader fr = new FileReader("D:\\IDEA_Data\\Data5\\test\\src\\userinfo.txt");
  26.         //创建Map对象
  27.         Properties properties = new Properties();
  28.         //Map的load方法，将字符流对象加载进来
  29.         properties.load(fr);
  30.         //读取
  31.         String username = properties.getProperty("username");
  32.         String password = properties.getProperty("password");
  33.         //username:admin,password:123
  34.         System.out.println("username:" + username + ",password:" + password);
  35.     }
  36. }