IO框架

1. File类

File类有用于操作文件以及查看文件属性的方法

  1. package com.qfedu.test1;
  3. import java.io.File;
  4. import java.io.IOException;
  6. /**
  7.  *     File类 文件操作类 可以查看文件的属性  和 创建文件等
  8.  * @author WHD
  9.  *
  10.  */
  11. public class TestFile {
  12.     public static void main(String[] args) throws IOException {
  14.         File file2 = new File("C:\\Users\\WHD\\Desktop\\a.txt");
  15.         System.out.println(file2.createNewFile());
  18.         File file1 = new File("a.txt");
  19.         System.out.println(file1.createNewFile());
  20.         System.out.println("是否是一个文件" + file1.isFile());
  21.         System.out.println("是否是一个文件夹" + file1.isDirectory());
  22.         System.out.println("相对路径" + file1.getPath());
  23.         System.out.println("绝对路径" + file1.getAbsolutePath());
  24.         System.out.println("文件名称" + file1.getName());
  25.         System.out.println("文件大小" + file1.length());
  26.         System.out.println("文件是否存在" + file1.exists());
  27.         System.out.println("文件删除是否成功" + file1.delete());
  29.         File file3 = new File("A");
  30.         file3.mkdir();// make directory 
  33.         File file4 = new File("B/C/D");
  34.         file4.mkdirs();
  36.         file3.delete();
  37.         file4.delete();        
  38.     }
  39. }

2. 字节流(读取)

2.1 InputStream

字节读取流父类 抽象类

2.2 FileInputStream

InputStream字节读取流父类 FileInputStream 子类 read() 每次读取一个字节 返回值为读取的内容 read(byte [] data) 返回值为读取的个数 读取到的内容存在数组中 close() 关闭资源

  1. package com.qfedu.test2;
  3. import java.io.FileInputStream;
  4. import java.io.FileNotFoundException;
  5. import java.io.IOException;
  7. /**
  8.  *     InputStream字节读取流父类
  9.  *     FileInputStream 子类
  10.  *     read()  每次读取一个字节 返回值为读取的内容
  11.  *     read(byte [] data)  返回值为读取的个数 读取到的内容存在数组中
  12.  *     close()  关闭资源
  13.  * @author WHD
  14.  *
  15.  */
  16. public class TestFileInputStream1 {
  17.     public static void main(String[] args) {
  18.         try {
  19.             FileInputStream fis = new FileInputStream("A.txt");
  20.             int data = fis.read();
  21.             System.out.println("第一次读取" + (char)data);
  23.             int readData = -1;
  24.             while((readData = fis.read()) != -1) {
  25.                 System.out.println((char)readData);
  26.             }
  27.         } catch (FileNotFoundException e) {
  28.             e.printStackTrace();
  29.         } catch (IOException e) {
  30.             e.printStackTrace();
  31.         }
  32.     }
  33. }

3.字节流(写入)

3.1 OutputStream

字节写入流父类 抽象类

3.2 FileOutputStream

OutputStream FileOutputStream write(int data); 写一个字节 write(byte [] data); 写一个字节数组 close()

  1. package com.qfedu.test4;
  3. import java.io.FileNotFoundException;
  4. import java.io.FileOutputStream;
  5. import java.io.IOException;
  7. /**
  8.  *     OutputStream
  9.  *     FileOutputStream
  10.  *     write(int data); 写一个字节
  11.  *     write(byte [] data);    写一个字节数组
  12.  *     close()
  13.  * @author WHD
  14.  *
  15.  */
  16. public class TestFileOutputStream {
  17.     public static void main(String[] args) {
  18.         FileOutputStream fos = null;
  19.         try {
  20.             fos = new FileOutputStream("B.txt");
  21.             fos.write(97);
  22.         } catch (FileNotFoundException e) {
  23.             e.printStackTrace();
  24.         } catch (IOException e) {
  25.             e.printStackTrace();
  26.         }finally {
  27.             try {
  28.                 if(fos != null) {
  29.                     fos.close();
  30.                 }
  31.             } catch (IOException e) {
  32.                 e.printStackTrace();
  33.             }
  34.         }
  35.     }
  36. }

4. 字符流(读取)

4.1 Reader

字符读取流父类 抽象类

4.1.1 InputStreamReader

可以指定读取编码格式的字符读取类 read() 每次读取一个字符

  1. package com.qfedu.test5;
  3. import java.io.FileInputStream;
  4. import java.io.FileNotFoundException;
  5. import java.io.IOException;
  6. import java.io.InputStreamReader;
  8. /**
  9.  *     Reader 字符流读取父类 抽象类
  10.  *     InputStreamReader 子类
  11.  *     read() 每次读取一个字符 
  12.  * @author WHD
  13.  *
  14.  */
  15. public class TestInputStreamReader {
  16.     public static void main(String[] args) {
  17.         FileInputStream fis = null;
  18.         InputStreamReader isr = null;
  19.         try {
  20.             fis = new FileInputStream("A.txt");
  21.             isr = new InputStreamReader(fis);
  22.             int data = -1;
  23.             while((data = isr.read())!= -1) {
  24.                 System.out.println((char)data);
  25.             }
  26.         } catch (FileNotFoundException e) {
  27.             e.printStackTrace();
  28.         } catch (IOException e) {
  29.             e.printStackTrace();
  30.         }finally {
  31.             try {
  32.                 if(fis != null) {
  33.                     fis.close();
  34.                 } 
  36.                 if(isr != null) {
  37.                     isr.close();
  38.                 }
  40.             }catch (IOException e) {
  41.                     e.printStackTrace();
  42.                 }
  43.             }
  44.         }
  45. }

4.1.1.1 FileReader

只能按照本地默认的编码格式读取文件 字符流

  1. package com.qfedu.test6;
  3. import java.io.FileNotFoundException;
  4. import java.io.FileReader;
  5. import java.io.IOException;
  7. /**
  8.  *     Reader
  9.  *     InputStreamReader
  10.  *     FileReader 
  11.  * @author WHD
  12.  *
  13.  */
  14. public class TestFileReader {
  15.     public static void main(String[] args) {
  16.         try {
  17.             FileReader fr = new FileReader("A.txt");
  18.             int data = -1;
  19.             while(( data = fr.read()) != -1) {
  20.                 System.out.println((char)data);
  21.             }
  23.         } catch (FileNotFoundException e) {
  24.             e.printStackTrace();
  25.         } catch (IOException e) {
  26.             e.printStackTrace();
  27.         }finally {
  28.             // 关闭资源
  29.         }
  30.     }
  31. }

4.1.2 BufferedReader

独有的方法 readLine() 读取一行

  1. package com.qfedu.test7;
  3. import java.io.BufferedReader;
  4. import java.io.FileInputStream;
  5. import java.io.IOException;
  6. import java.io.InputStreamReader;
  8. /**
  9.  *     Reader
  10.  *     BufferedReader
  11.  * 
  12.  *     readLine()  读取一行
  13.  * @author WHD
  14.  *
  15.  */
  16. public class TestBufferedReader1 {
  17.     public static void main(String[] args) throws IOException {
  18.         FileInputStream fis = new FileInputStream("A.txt");
  19.         InputStreamReader isr = new InputStreamReader(fis);
  20.         BufferedReader br = new BufferedReader(isr);
  21.         String line = null;
  22.         while((line = br.readLine()) != null) {
  23.             System.out.println(line);
  24.         }
  25.         // 关闭资源
  26.     }
  27. }

5. 字符流(写入)

5.1 Writer

字符写入流父类 抽象类

5.1.1 OutputStreamWriter

write(String str) 可以直接写入字符串 可以指定写入的编码格式

  1. package com.qfedu.test8;
  3. import java.io.IOException;
  4. import java.io.FileOutputStream;
  5. import java.io.OutputStreamWriter;
  7. /**
  8.  *     Writer
  9.  *     OutputStreamWriter
  10.  * @author WHD
  11.  *
  12.  */
  13. public class TestOutputStreamWriter1 {
  14.     public static void main(String[] args) throws IOException {
  15.         OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("D.txt",true),"utf-8");
  16.         osw.write("hello world世界你好");
  17.         osw.close();
  18.     }
  19. }

5.1.1.1 FileWriter

只能按照本地的默认的编码格式写入文件

  1. package com.qfedu.test8;
  3. import java.io.FileWriter;
  4. import java.io.IOException;
  6. /**
  7.  *     Writer
  8.  *     OutputStreamWriter
  9.  *     FileWriter
  10.  * @author WHD
  11.  *
  12.  */
  13. public class TestFileWriter1 {
  14.     public static void main(String[] args) {
  15.         FileWriter fw;
  16.         try {
  17.             fw = new FileWriter("E.txt");
  18.             fw.write("abcdefg");
  19.             fw.flush(); // 刷新 表示将内容从内存刷新到硬盘
  20.         } catch (IOException e) {
  21.             e.printStackTrace();
  22.         }finally {
  23.             // 关闭资源
  24.         }
  25.     }
  26. }

5.1.2 BufferedWriter

独有的newLine() 换行的方法

  1. package com.qfedu.test8;
  3. import java.io.BufferedWriter;
  4. import java.io.FileNotFoundException;
  5. import java.io.FileOutputStream;
  6. import java.io.IOException;
  7. import java.io.OutputStreamWriter;
  9. /**
  10.  *     Writer
  11.  *     BufferedWriter
  12.  * @author WHD
  13.  *
  14.  */
  15. public class TestBufferedWriter1 {
  16.     public static void main(String[] args) throws IOException {
  17.         BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("F.txt")));
  18.         bw.write("abcd\n");
  19.         bw.write("efgh");
  20.         bw.newLine();
  21.         bw.write("hello world");
  22.         bw.flush();
  23.     }
  24. }

6. 数据流

用于读写二进制文件 DataInputStream读取二进制文件 DataOutputStream写入二进制文件

  1. package com.qfedu.test9;
  3. import java.io.DataInputStream;
  4. import java.io.DataOutputStream;
  5. import java.io.FileInputStream;
  6. import java.io.FileOutputStream;
  7. import java.io.IOException;
  9. /**
  10.  *     DataInputStream读取二进制文件
  11.  *     DataOutputStream写入二进制文件
  12.  *     
  13.  * @author WHD
  14.  *
  15.  */
  16. public class TestDataStream {
  17.     public static void main(String[] args) throws IOException {
  18.         FileInputStream fis = new FileInputStream("C:\\Users\\WHD\\Desktop\\zs1.jpg");
  19.         DataInputStream dis = new DataInputStream(fis);
  20.         byte data [] = new byte[fis.available()];
  21.         dis.read(data);
  22. //        System.out.println(new String(data,0,data.length));
  24.         DataOutputStream dos = new DataOutputStream(new FileOutputStream("copyzs.jpg"));
  25.         dos.write(data);
  26.         fis.close();
  27.         dis.close();
  28.         dos.close();
  29.     }
  30. }

7. 序列化

序列化：将对象写入到二进制文件中 反序列化：将存有对象的二进制文件读取为对象 要求：被序列化的对象所属类必须实现Serializable接口 此接口是空接口 相当于一个标识 被transient修饰的属性不能被序列化

  1. package com.qfedu.test9;
  3. import java.io.Serializable;
  5. public class Student implements Serializable{
  8.     private static final long serialVersionUID = -4543464400965999994L;
  9.     private String name;
  10.     private int age;
  11.     private transient String address;
  13.     public String getAddress() {
  14.         return address;
  15.     }
  16.     public void setAddress(String address) {
  17.         this.address = address;
  18.     }
  19.     public String getName() {
  20.         return name;
  21.     }
  22.     public void setName(String name) {
  23.         this.name = name;
  24.     }
  25.     public int getAge() {
  26.         return age;
  27.     }
  28.     public void setAge(int age) {
  29.         this.age = age;
  30.     }
  31.     public Student() {
  32.     }
  33.     public Student(String name, int age) {
  34.         this.name = name;
  35.         this.age = age;
  36.     }
  41.     public Student(String name, int age, String address) {
  42.         this.name = name;
  43.         this.age = age;
  44.         this.address = address;
  45.     }
  46.     @Override
  47.     public String toString() {
  48.         return "Student [name=" + name + ", age=" + age + ", address=" + address + "]";
  49.     }
  53. }
  1. package com.qfedu.test9;
  3. import java.io.DataInputStream;
  4. import java.io.DataOutputStream;
  5. import java.io.FileInputStream;
  6. import java.io.FileOutputStream;
  7. import java.io.IOException;
  9. /**
  10.  *     DataInputStream读取二进制文件
  11.  *     DataOutputStream写入二进制文件
  12.  *     
  13.  * @author WHD
  14.  *
  15.  */
  16. public class TestDataStream {
  17.     public static void main(String[] args) throws IOException {
  18.         FileInputStream fis = new FileInputStream("C:\\Users\\WHD\\Desktop\\zs1.jpg");
  19.         DataInputStream dis = new DataInputStream(fis);
  20.         byte data [] = new byte[fis.available()];
  21.         dis.read(data);
  22. //        System.out.println(new String(data,0,data.length));
  24.         DataOutputStream dos = new DataOutputStream(new FileOutputStream("copyzs.jpg"));
  25.         dos.write(data);
  26.         fis.close();
  27.         dis.close();
  28.         dos.close();
  29.     }
  30. }