一、FileInputStream

1.可将读取的数据以byte数组的形式保存

  1. package javase.day31.io;
  3. import java.io.FileInputStream;
  4. import java.io.FileNotFoundException;
  5. import java.io.IOException;
  7. public class FileInputStreamTest04 {
  8.     public static void main(String[] args) {
  9.         FileInputStream fis = null;
  11.         try {
  12.             fis = new FileInputStream("io/src/tram");
  13.             //准备一个byte数组
  14.             byte [] bytes = new byte[4];
  15.             /*
  16.             while (true){
  17.                 int readCount = fis.read(bytes);
  18.                 if (readCount == -1){
  19.                     break;
  20.                 }
  21.                 System.out.println(new String(bytes,0,readCount));
  23.             }
  24.              */
  25.             //好方法
  26.             int readCount = 0;
  27.             while ((readCount = fis.read(bytes))!=-1){
  28.                 System.out.println(new String(bytes,0,readCount));
  29.             }
  31.         } catch (FileNotFoundException e) {
  32.             e.printStackTrace();
  33.         } catch (IOException e) {
  34.             e.printStackTrace();
  35.         } finally {
  36.             try {
  37.                 fis.close();
  38.             } catch (IOException e) {
  39.                 e.printStackTrace();
  40.             }
  41.         }
  42.     }
  43. }

2.返回剩余没读到的字节数量

int available()
image.png

3.跳过几个字节不读取

image.png

二、FileOutputStream

  1. package javase.day31.io;
  3. import java.io.FileNotFoundException;
  4. import java.io.FileOutputStream;
  5. import java.io.IOException;
  7. public class FileOutputStreamTest01 {
  8.     public static void main(String[] args) {
  9.         FileOutputStream fos = null;
  11.         try {
  12.             fos = new FileOutputStream("myfile",true);//加true加在原文件后面，不会清空
  13.             byte[] bytes = {97,98,99,100,101};
  14.             fos.write(bytes);
  16.             //字符串
  17.             String s ="我是在你的";
  18.             //将字符串转换为byte数组
  19.             byte[] bs = s.getBytes();
  21.             fos.write(bs);
  23.             //写完后一定要刷新
  24.             fos.flush();
  25.         } catch (FileNotFoundException e) {
  26.             e.printStackTrace();
  27.         } catch (IOException e) {
  28.             e.printStackTrace();
  29.         } finally {
  30.             if (fos != null){
  31.                 try {
  32.                     fos.close();
  33.                 } catch (IOException e) {
  34.                     e.printStackTrace();
  35.                 }
  36.             }
  37.         }
  38.     }
  39. }

三、复制文件（FileInputStream+FileOutputStream）

  1. package javase.day31.io;
  3. import java.io.FileInputStream;
  4. import java.io.FileNotFoundException;
  5. import java.io.FileOutputStream;
  6. import java.io.IOException;
  8. public class Copy01 {
  9.     public static void main(String[] args) {
  10.         FileInputStream fis = null;
  11.         FileOutputStream fos = null;
  12.         try {
  13.             fis = new FileInputStream("myfile");
  14.             fos = new FileOutputStream("copymyfile");
  16.             byte [] bytes = new byte[1024];
  17.             int readCount=0;
  18.             while ((readCount = fis.read(bytes)) != -1){
  19.                 fos.write(bytes,0,readCount);
  20.             }
  21.             //刷新
  22.             fos.flush();
  23.         } catch (FileNotFoundException e) {
  24.             e.printStackTrace();
  25.         } catch (IOException e) {
  26.             e.printStackTrace();
  27.         } finally {
  28.             if (fis !=null){
  29.                 try {
  30.                     fis.close();
  31.                 } catch (IOException e) {
  32.                     e.printStackTrace();
  33.                 }
  34.             }
  35.             if (fos !=null){
  36.                 try {
  37.                     fos.close();
  38.                 } catch (IOException e) {
  39.                     e.printStackTrace();
  40.                 }
  41.             }
  42.         }
  43.     }
  44. }

四、FileReader

  1. package javase.day31.io;
  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 reader = null;
  11.         try {
  12.             reader = new FileReader("io/src/readerfile");
  13.             //开始读
  14.             char[] chars = new char[4];//一次4个字符
  15.             int readCount = 0;
  16.             while ((readCount = reader.read(chars))!=-1){
  18.                 System.out.println(new String(chars,0,readCount));
  19.             }
  21.         } catch (FileNotFoundException e) {
  22.             e.printStackTrace();
  23.         } catch (IOException e) {
  24.             e.printStackTrace();
  25.         } finally {
  26.             if (reader !=null){
  27.                 try {
  28.                     reader.close();
  29.                 } catch (IOException e) {
  30.                     e.printStackTrace();
  31.                 }
  32.             }
  33.         }
  34.     }
  35. }

五、FileWriter

  • 文件字符输出流（只能输出普通文本）
  • 可以直接写入字符串 ```java package javase.day31.io;

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

/**

  • 文件字符输出流。只能输出普通文本 */ public class FileWriterTest01 { public static void main(String[] args) {

    1.  FileWriter out = null;
    3.  try {
    4.      out = new FileWriter("writerfile");
    6.      //开始写
    7.      char[] chars = {'我','是','中','国','人'};
    8.      out.write(chars);
    9.      out.write(chars,2,3);
    11.      out.write("我是java工程师");
    12.      //刷新
    13.      out.flush();
    14.  } catch (IOException e) {
    15.      e.printStackTrace();
    16.  }finally {
    17.      if (out !=null){
    18.          try {
    19.              out.close();
    20.          } catch (IOException e) {
    21.              e.printStackTrace();
    22.          }
    23.      }
    24.  }

    } }

  2. <a name="k11B4"></a>
  3. # 六、复制2（FileReader+FileWrite）
  4. ```java
  5. package javase.day31.io;
  7. import java.io.FileNotFoundException;
  8. import java.io.FileReader;
  9. import java.io.FileWriter;
  10. import java.io.IOException;
  12. public class Copy02 {
  13.     public static void main(String[] args) {
  14.         FileReader in =null;
  15.         FileWriter out = null;
  17.         try {
  18.             in=new FileReader("writerfile");
  20.             out=new FileWriter("copymyfile2");
  22.             char[] chars = new char[1024 * 1024];
  23.             int readCount = 0;
  24.             while ((readCount = in.read(chars))!= -1){
  25.                 out.write(chars,0,readCount);
  26.             }
  27.             //刷新
  28.             out.flush();
  29.         } catch (FileNotFoundException e) {
  30.             e.printStackTrace();
  31.         } catch (IOException e) {
  32.             e.printStackTrace();
  33.         }finally {
  34.             try {
  35.                 in.close();
  36.             } catch (IOException e) {
  37.                 e.printStackTrace();
  38.             }
  39.             try {
  40.                 out.flush();
  41.             } catch (IOException e) {
  42.                 e.printStackTrace();
  43.             }
  44.         }
  45.     }
  46. }

七、BufferedReader

  1. package javase.day31.io;
  3. import java.io.BufferedReader;
  4. import java.io.FileNotFoundException;
  5. import java.io.FileReader;
  6. import java.io.IOException;
  8. public class BufferedReaderTest01 {
  9.     public static void main(String[] args)  {
  10.         FileReader reader = null;
  11.         BufferedReader br = null;
  12.         try {
  13.             reader = new FileReader("io/src/javase/day31/io/le.java");
  14.              br = new BufferedReader(reader);
  16.              String s = null;
  17.              //br.readline()方法获取一个文本行，但不带换行符
  18.              while ((s = br.readLine())!= null){
  19.                  System.out.println(s);
  20.              }
  21.         } catch (FileNotFoundException e) {
  22.             e.printStackTrace();
  23.         } catch (IOException e) {
  24.             e.printStackTrace();
  25.         } finally {
  26.             try {
  27.                 //对于包装流来说，只需要关闭最外层流就行，里面的节点流会自动关闭（看源代码）
  28.                 br.close();
  29.             } catch (IOException e) {
  30.                 e.printStackTrace();
  31.             }
  32.         }
  37.     }
  38. }

八、BufferedWriter

  1. package javase.day31.io;
  3. import java.io.*;
  5. public class BufferedWriterTest {
  6.     public static void main(String[] args) {
  7.         BufferedWriter out = null;
  8.         try {
  9.             //out = new BufferedWriter(new FileWriter("BufferedWriterCopy"));
  10.             out = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("BufferedWriterCopy02",true)));
  11.         } catch (IOException e) {
  12.             e.printStackTrace();
  13.         }finally {
  14.             try {
  15.                 if (out !=null){
  17.                     out.close();
  18.                 }
  19.             } catch (IOException e) {
  20.                 e.printStackTrace();
  21.             }
  22.         }
  23.     }
  24. }

九、DataOutputStream

  1. package javase.day31.io;
  3. import java.io.DataOutputStream;
  4. import java.io.FileNotFoundException;
  5. import java.io.FileOutputStream;
  6. import java.io.IOException;
  8. public class DataOutputStreamTest {
  9.     public static void main(String[] args) {
  10.         DataOutputStream dos= null;
  11.         try {
  12.             //创建数据专属的字节输出流
  13.             dos = new DataOutputStream(new FileOutputStream("data"));
  14.             //写数据
  16.             byte b =100;
  17.             short s =200;
  18.             int i =300;
  19.             long l = 400;
  20.             float f =3.0f;
  21.             double d =3.14;
  22.             boolean sex =false;
  23.             char c= 'a';
  24.             //写
  25.             dos.writeByte(b);
  26.             dos.writeShort(s);
  27.             dos.writeInt(i);
  28.             dos.writeLong(l);
  29.             dos.writeFloat(f);
  30.             dos.writeDouble(d);
  31.             dos.writeBoolean(sex);
  32.             dos.writeChar(c);
  34.             //刷新
  35.             dos.flush();
  36.         } catch (FileNotFoundException e) {
  37.             e.printStackTrace();
  38.         } catch (IOException e) {
  39.             e.printStackTrace();
  40.         } finally {
  41.             if (dos !=null){
  42.                 try {
  43.                     dos.close();
  44.                 } catch (IOException e) {
  45.                     e.printStackTrace();
  46.                 }
  47.             }
  48.         }
  49.     }
  50. }

十、DataInputStream

  1. package javase.day31.io;
  3. import java.io.DataInputStream;
  4. import java.io.FileInputStream;
  5. import java.io.FileNotFoundException;
  6. import java.io.IOException;
  8. /*
  9. DataInputStream:数据字节输入流
  10. DataOutputStream:写的文件，只能用DataInputStream去读。并且读的时候你需要提前知道写入的顺序
  11. 读的顺序需要和写的顺序一致。才可以正常取出数据
  12.  */
  13. public class DataInputStreamTest {
  14.     public static void main(String[] args) {
  15.         DataInputStream dis =null;
  17.         try {
  18.             dis = new DataInputStream(new FileInputStream("data"));
  19.         } catch (FileNotFoundException e) {
  20.             e.printStackTrace();
  21.         }finally {
  22.             if (dis !=null){
  23.                 try {
  24.                     dis.close();
  25.                 } catch (IOException e) {
  26.                     e.printStackTrace();
  27.                 }
  28.             }
  29.         }
  30.     }
  31. }

十一、PrintStream（标准输出流）

可以改变输出方向吗？可以。

  1. package javase.day31.io;
  3. import java.io.FileNotFoundException;
  4. import java.io.FileOutputStream;
  5. import java.io.PrintStream;
  7. public class PrintStreamTest {
  8.     public static void main(String[] args) throws FileNotFoundException {
  9.         System.out.println("hello world!");
  11.         PrintStream ps = System.out;
  12.         ps.println("zhangsan");
  14.         //标准输出流不需要手动close（）关闭
  16.         //之前System类使用的方法和属性
  17. //        System.gc();
  18. //        System.currentTimeMillis();
  19. //        PrintStream ps2 = System.out;
  20. //        System.exit(0);
  21. //        System.arraycopy(...)
  22.         //标准输出流不再指向控制台，指向“log”文件
  23.         PrintStream printStream = new PrintStream(new FileOutputStream("log"));
  24.         //修改输出方向，将输出方向修改到“log”文件
  25.         System.setOut(printStream);
  26.         //再输出
  27.         System.out.println("hello world");
  28.         System.out.println("hello litty");
  30.     }
  31. }

十二、序列化和反序列化（两个流）

1.ObjectOutputStream和ObjectInputStream

  1. package bean;
  3. import java.io.Serializable;
  5. public class Student implements Serializable {
  6.     private int no;
  7.     private String name;
  9.     public Student(){
  11.     }
  13.     public Student(int no, String name) {
  14.         this.no = no;
  15.         this.name = name;
  16.     }
  18.     public int getNo() {
  19.         return no;
  20.     }
  22.     public void setNo(int no) {
  23.         this.no = no;
  24.     }
  26.     public String getName() {
  27.         return name;
  28.     }
  30.     public void setName(String name) {
  31.         this.name = name;
  32.     }
  34.     @Override
  35.     public String toString() {
  36.         return "Student{" +
  37.                 "no=" + no +
  38.                 ", name='" + name + '\'' +
  39.                 '}';
  40.     }
  41. }
  1. package bean;
  3. import java.io.FileOutputStream;
  4. import java.io.ObjectOutputStream;
  5. /*
  6. 1.Student对象不支持序列化
  7. 2.参与序列化和反序列化的对象，必须实现Serializable接口。
  8. 3.注意：通过源代码发现，这个接口只是一个标志性接口：标识的作用，虚拟机看到这个类实现了这个接口，可能会对这个类特殊待遇
  9.  */
  10. public class ObjectOutputStreamTest01 {
  11.     public static void main(String[] args) throws Exception {
  12.         Student s = new Student(111,"zhangsan");
  14.         //序列化
  15.         ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("students"));
  16.         //序列化对象
  17.         oos.writeObject(s);
  19.         //刷新
  20.         oos.flush();
  21.         oos.close();
  22.     }
  23. }
  1. package bean;
  3. import java.io.*;
  5. public class ObjectInputStreamTest01 {
  6.     public static void main(String[] args) throws IOException, ClassNotFoundException {
  7.         ObjectInputStream ois = new ObjectInputStream(new FileInputStream("students"));
  9.         Object obj = ois.readObject();
  10.         System.out.println(obj);
  11.         ois.close();
  12.     }
  13. }

2.重点：

  1.     参与序列化的类型必须实现java.io.Serializable接口。<br />        **并且建议**将序列化版本号手动的写出来。<br />            private static final long serialVersionUID = 1L;

3.一次序列化多个对象

  1. transient(修饰的属性不参与序列化)

image.png

  1. user ```java package bean;

import java.io.Serializable;

public class User implements Serializable { private int no; //transient 游离的 不参与序列化操作 private transient String name;

  1. public User() {
  2. }
  4. public User(int no, String name) {
  5.     this.no = no;
  6.     this.name = name;
  7. }
  9. public int getNo() {
  10.     return no;
  11. }
  13. public void setNo(int no) {
  14.     this.no = no;
  15. }
  17. public String getName() {
  18.     return name;
  19. }
  22. public void setName(String name) {
  23.     this.name = name;
  24. }
  26. @Override
  27. public String toString() {
  28.     return "User{" +
  29.             "no=" + no +
  30.             ", name='" + name + '\'' +
  31.             '}';
  32. }

}

  2. 将多个序列化对象放到集合中，
  3. ```java
  4. package bean;
  6. import java.io.FileNotFoundException;
  7. import java.io.FileOutputStream;
  8. import java.io.IOException;
  9. import java.io.ObjectOutputStream;
  10. import java.util.ArrayList;
  11. import java.util.List;
  13. public class ObjectOutputStreamTest02 {
  14.     public static void main(String[] args) throws IOException {
  15.         List<User> userList = new ArrayList<>();
  16.         userList.add(new User(111,"zhangsan"));
  17.         userList.add(new User(122,"lucy"));
  18.         userList.add(new User(133,"jack"));
  20.         ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("users"));
  21.         //序列化对象
  22.         oos.writeObject(userList);
  24.         oos.flush();
  25.         oos.close();
  26.     }
  27. }
  1. package bean;
  3. import java.io.FileInputStream;
  4. import java.io.ObjectInputStream;
  5. import java.util.LinkedList;
  6. import java.util.List;
  8. public class ObjectInputStreamTest02 {
  9.     public static void main(String[] args) throws Exception{
  10.         ObjectInputStream ois = new ObjectInputStream(new FileInputStream("users"));
  12. //        Object obj = ois.readObject();
  13. //        System.out.println(obj instanceof List);
  14.         List<User> userList = (List<User>) ois.readObject();
  15.         for (User user : userList){
  16.             System.out.println(user);
  17.         }
  19.         ois.close();
  20.     }
  21. }

4.序列化版本号

image.png