流

  1. 流具有方向，且只能但方向，只能从头到尾的顺序读写一次
  2. 根据程序的思路来考虑问题：
    数据读取到程序中in（输入流）
    数据写入到文件中out（输出流）
  3. 流操作的前提是必须建立”管道”——-获取流对象
  4. 流的分类：字节输入流、字节输出流、字符输入流、字符输出流

IO流的继承结构

在java中,根据处理的数据单位不同,可以把流分为字节流和字符流
字节流 : 针对二进制文件
字符流 : 针对文本文件,读写容易出现乱码的现象,在读写时,最好指定编码集为UTF-8

字节流:针对二进制文件

以File为前缀的，是可以插在文件上，直接对文件进行操作的流
以Buffered为前缀的，是插在其他流上，对其他流做加强操作的缓冲或高效流。

InputStream抽象父类，字节输入流

FileInputStream操作文件的字节输入流，可以传文件或路径，普通子类

BufferedInputStream—缓冲或高效字节输入流，需要传InputStream，普通子类

ObjectInputStream

OutputStream抽象父类，字节输出流

FileOutputStream，普通子类，可直接操作文件
BufferedOutputStream，普通子类，插在其他流上，给其他流做加强的缓冲或高效流
ObjectOutputStream

字符流:针对文本文件

Reader抽象父类，字符输入流

FileReader，普通子类
BufferedReader，普通子类
InputStreamReader

Writer抽象父类，字符输出流
FileWriter，普通子类
BufferedWriter，普通子类
OutputStreamWriter
PrintWriter

file文件类

概述

封装一个磁盘路径字符串,对这个路径可以执行一次操作
使用面向对象的方法可以将文件路径、文件夹路径、不存在的路径封装为file对象，file对象可以参与相关的流操作。

创建对象的方式

File(String pathname)通过将给定路径名字符串转换为抽象路径名来创建一个新的File实例
new File(“d:/abc/a.txt”);
new File(“d:/abc”,”a.txt”);

常用方法

image.png

示例代码

  1. package cn.tedu.file;
  3. import java.io.File;
  4. import java.io.IOException;
  5. import java.util.Arrays;
  7. /**
  8.  * 用于测试文件类常用方法
  9.  */
  11. public class TestFile {
  12.     public static void main(String[] args) {
  13.         File file = new File("F:\\ready\\1.txt");
  15.         //测试常用方法
  16.         System.out.println(file.length());//查看指定文件字节大小
  17.         System.out.println(file.exists());//查看指定文件是否存在
  18.         System.out.println(file.isFile());//判断指定File是否为文件
  19.         System.out.println(file.isDirectory());//判断指定File是否为文件夹
  20.         System.out.println(file.getName());//获取指定File文件名
  21.         System.out.println(file.getParentFile());//获取指定File的父级路径
  22.         System.out.println(file.getAbsoluteFile());//获取指定File的绝对路径
  24.         //创建
  25.         file = new File("F:\\ready\\2.txt");
  26.         try {
  27.             System.out.println(file.createNewFile());
  28.         } catch (IOException e) {
  29.             e.printStackTrace();
  30.         }
  31.         file = new File("F:\\ready\\a");
  32.         System.out.println(file.mkdir());//创建单层文件夹
  33.         file = new File("F:\\ready\\a\\b\\c");
  34.         System.out.println(file.mkdirs());
  36.         //删除
  37.         System.out.println(file.delete());//只有c被删除，只可以删除空文件夹或文件
  38.         file = new File("F:\\ready\\2.txt");
  39.         System.out.println(file.delete());
  41.         //文件列表
  42.         file = new File("F:\\ready");
  43.         String[] listName = file.list();
  44.         System.out.println(Arrays.toString(listName));
  46.         File[] fs = file.listFiles();
  47.         System.out.println(Arrays.toString(fs));
  48.         System.out.println(fs[0].length());
  49.     }
  50. }

字节流

字节输入流

InputStream抽象父类，不可实例化

常用方法：

abstract int read() 使用方法：对象名.read() 从输入流中读取数据的下一个字节
int read(byte[] b) 使用方法：对象名.read() 从输入流中读取一定数量的字节，并将其存储在缓冲区数组 b 中
int read(byte[] b, int off, int len) 使用方法：对象名.read() 将输入流中最多 len 个数据字节读入 byte 数组,off表示存时的偏移量
void close()使用方法：对象名.close() 关闭此输入流并释放与该流关联的所有系统资源

FileInputStream

文件的字节输入流，参数可以使用文件或路径

创建对象方式：

InputStream in = new FileInputStream("G:\\ready\\1.txt");

可以直接传文件到对象，通过打开一个到实际文件的连接来创建一个 FileInputStream，该文件通过文件系统中的 File 对象 file 指定FileInputStream(String pathname)—传路径
通过打开一个到实际文件的连接来创建一个 FileInputStream，该文件通过文件系统中的路径名 name 指定

BufferedInputStream

BufferedInputStream 为另一个输入流添加一些功能，即缓冲输入以及支持 mark 和 reset 方法的能力。在创建 BufferedInputStream 时，会创建一个内部缓冲区数组(默认8k大小)。在读取或跳过流中的字节时，可根据需要从包含的输入流再次填充该内部缓冲区，一次填充多个字节。

创建对象方式

BufferedInputStream in = new BufferedInputStream(new FileInputStream("G:\\ready\\1.txt"));

需要使用InputStream作为参数

示例代码

  1. package cn.tedu.file;
  3. import java.io.*;
  5. /**
  6.  * 测试字节流读取
  7.  */
  9. public class TestIn {
  10.     public static void main(String[] args) {
  11.         method();//普通字节流读取
  12.         method1();//高校字节流读取
  13.     }
  15.     private static void method() {
  16.         //创建字节输入流对象用于读取
  17.         /*
  18.         InputStream in = new InputStream();
  19.         抽象类，不能创建对象需要创建FIS对象
  20.         IO操作可能会出现异常，需要try-catch
  21.          */
  22.         InputStream in = null;
  23.         try {
  24.             //InputStream in = new FileInputStream(new File("F:\\ready\\1.txt"));
  25.             in = new FileInputStream("F:\\ready\\1.txt");
  26.             /*
  27.             read()一次读取一个字符，若果没有数据，返回-1
  28.              */
  29. //            System.out.println(in.read());//97----a
  30. //            System.out.println(in.read());//98----b
  31. //            System.out.println(in.read());//99----c
  32. //            System.out.println(in.read());//-1
  33.             //循环读取文件中所有内容
  34.             int b;
  35.             while ((b = in.read()) != -1){
  36.                 System.out.println(b);
  37.             }
  38.             //会跳着读取数据，漏掉数据
  39. //            while (in.read() != -1){
  40. //                System.out.println(in.read());
  41. //            }
  43.             /*
  44.             关闭流资源
  45.             in.close();
  46.              */
  47.         } catch (Exception e) {
  48.             e.printStackTrace();//打印错误信息
  49.         }finally {
  50.             /*
  51.             finally代码块是try-catch结构中一定会被执行到的部分
  52.             常用于关流操作，防止因发生异常没有争取关流，不能写在try{}中
  53.              */
  54.             try {
  55.                 in.close();
  56.             } catch (IOException e) {
  57.                 e.printStackTrace();
  58.             }
  59.         }
  60.     }
  62.     private static void method1() {
  63.         BufferedInputStream in1 = null;
  64.         try {
  65.             in1 = new BufferedInputStream(new FileInputStream("F:\\ready\\1.txt"));
  66.             int b;
  67.             while ((b = in1.read()) !=-1){
  68.                 System.out.println(b);
  69.             }
  70.         } catch (Exception e) {
  71.             e.printStackTrace();
  72.         }finally {
  73.             try {
  74.                 in1.close();
  75.             } catch (IOException e) {
  76.                 e.printStackTrace();
  77.             }
  78.         }
  79.     }
  81. }

字节输出流

OutputStream抽象类,表示输出字节流的所有类的超类.输出流接受输出字节并将这些字节发送到某个接收器.

常用方法

Void close(), 使用方法：对象名.close()关闭此输出流并释放与此流相关的所有系统资源
Void flush() ,使用方法：对象名.flush()刷新此输出流并强制写出所有缓冲的输出字节,防止数据遗漏
Void write(byte[ ] b),使用方法：对象名.write() 将b.length个字节从指定的byte数组写入此输出流
Void write(byte[ ] b,int off ,int len),使用方法：对象名.write() 将指定byte数组中从偏移量off开始的len个字节写入输出流
Abstract void write(int b) ,使用方法：对象名.write()将指定的字节写入此输出流

FileOutputStream

直接在文件中插入数据

创建对象方式

  1. OutputStream out = null;
  2. out = new FileOutputStream("F:\\ready\\1.txt",true);

构造方法(创建对象):
FileOutputStream(String name)
创建一个向具有指定名称的文件中写入数据的文件输出流
FileOutStream(File file)
创建一个向指定File对象表示的文件中写入数据的文件输出流
FileOutStream(File file,boolean append)—如果第二个参数为true,表示追加,不覆盖
创建一个向指定File对象表示的文件中写入数据的文件输出流,后面的参数是指是否覆盖原文件内容

BufferedOutputstream

实现缓冲的输出流,通过设置这种输出流,应用程序就可以将各个字节写入底层输出流中,而不必每次针对字节写出调用底层系统

创建对象方式

OutputStream out = null;

out = new BufferedOutputStream(new FileOutputStream("F:\\ready\\1.txt",true));

构造方法(创建对象):
BufferedOutputStream(OutputStream out)
创建一个新的缓冲输出流,用以将数据写入指定的底层输出流

示例代码

  1. package cn.tedu.file;
  3. import java.io.*;
  5. /**
  6.  * 字节输出流
  7.  */
  9. public class TestOut {
  10.     public static void main(String[] args) {
  11.         //method();//普通字节输出流
  12.         method1();//高效字节输出流
  13.     }
  15.     private static void method() {
  16.         OutputStream out = null;
  17.         try {
  18.             /*
  19.             out = new FileOutputStream(new File("F:\\ready\\1.txt"));
  20.             可以使用两个参数的构造方法，来控制输出的数据是覆盖还是追加
  21.             默认方式为覆盖
  22.             追加需要设置第二个参数为true
  23.              */
  24.             out = new FileOutputStream("F:\\ready\\1.txt",true);
  25.             out.write(97);//对应ASCII码表中的a
  26.             out.write(97);//对应ASCII码表中的a
  27.             out.write(97);//对应ASCII码表中的a
  28.         } catch (Exception e) {
  29.             e.printStackTrace();
  30.         } finally {
  31.             try {
  32.                 out.close();
  33.             } catch (IOException e) {
  34.                 e.printStackTrace();
  35.             }
  36.         }
  37.     }
  39.     private static void method1() {
  40.         OutputStream out = null;
  41.         try {
  42.             /*
  43.             out = new FileOutputStream(new File("F:\\ready\\1.txt"));
  44.             可以使用两个参数的构造方法，来控制输出的数据是覆盖还是追加
  45.             默认方式为覆盖
  46.             追加需要设置第二个参数为true
  47.              */
  48.             //out = new FileOutputStream("F:\\ready\\1.txt",true);
  49.             out = new BufferedOutputStream(new FileOutputStream("F:\\ready\\1.txt",true));
  50.             out.write(11111);//对应ASCII码表中的a
  51.             out.write(11110);//对应ASCII码表中的a
  52.             out.write(11112);//对应ASCII码表中的a
  53.         } catch (Exception e) {
  54.             e.printStackTrace();
  55.         } finally {
  56.             try {
  57.                 out.close();
  58.             } catch (IOException e) {
  59.                 e.printStackTrace();
  60.             }
  61.         }
  62.     }
  63. }

字符流

字符输入流

Reader抽象类,用于读取字符流的抽象类。

常用方法

int read() 使用方式：对象名.read()读取单个字符
int read(char[] cbuf) 使用方式：对象名.read()将字符读入数组
abstract int read(char[] cbuf, int off, int len) 使用方式：对象名.read()将字符读入数组的某一部分
int read(CharBuffer target) 使用方式：对象名.read()试图将字符读入指定的字符缓冲区
abstract void close()使用方式：对象名.close() 关闭该流并释放与之关联的所有资源

FileReader子类

用来读取字符文件的便捷类。此类的构造方法假定默认字符编码和默认字节缓冲区大小都是适当的。要自己指定这些值，可以先在 FileInputStream 上构造一个 InputStreamReader。

创建对象方式

Reader in = null;

in = new FileReader("F:\\ready\\1.txt");

FileReader(String fileName) 在给定从中读取数据的文件名的情况下创建一个新 FileReader
FileReader(File file) 在给定从中读取数据的 File 的情况下创建一个新 FileReader

BufferedReader

从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取。
可以指定缓冲区的大小，或者可使用默认的大小。大多数情况下，默认值就足够大了。

创建对象方式

Reader in = null;
in = new BufferedReader(new FileReader("F:\\ready\\1.txt"));
in = new BufferedReader(new FileReader(new File("F:\\ready\\1.txt")));
BufferedReader(Reader in) 创建一个使用默认大小输入缓冲区的缓冲字符输入流

字符输出流

Writer 抽象类

常用方法

Abstract void close()，使用方式：对象名.close() 关闭此流,但要先刷新它
Void write(char[ ] cbuf)， 使用方式：对象名.write()写入字符数组
Void write(int c) ， 使用方式：对象名.write()写入单个字符
Void write(String str) ， 使用方式：对象名.write()写入字符串
Void write(String str,int off,int len) ， 使用方式：对象名.write()写入字符串的某一部分
Abstract void write(char[] cbuf,int off,int len)， 使用方式：对象名.write()写入字符数组的某一部分

FileWriter 子类

用来写入字符文件的便捷类,此类的构造方法假定默认字符编码和默认字节缓冲区大小都是可接受的.如果需要自己自定义这些值,可以先在FileOutputStream上构造一个OutputStreamWriter.

创建对象方式

Writer out = null;

out = new FileWriter("F:\\ready\\1.txt",true);

构造方法(创建对象):
FileWriter(String filename)
根据给定的文件名构造一个FileWriter对象
FileWriter(String filename,boolean append)
根据给定的文件名以及指示是否附加写入数据的boolean值来构造FileWriter

BufferedWriter子类

将文本写入字符输出流,缓冲各个字符,从而提供单个字符,数组和字符串的高效写入.可以指定缓冲区的大小,或者接受默认的大小,在大多数情况下,默认值就足够大了

创建对象方式

Writer out = null;
out = new BufferedWriter(new FileWriter("F:\\ready\\1.txt",true));

构造方法(创建对象):
BufferedWriter(Writer out)
创建一个使用默认大小输出缓冲区的缓冲字符输出流

示例代码

  1. package cn.tedu.file;
  3. import java.io.*;
  5. public class TestIn2 {
  6.     public static void main(String[] args) {
  7.         //method();
  8.         method1();
  9.     }
  11.     private static void method() {
  12.         /*
  13.         Reader in = new Reader();
  14.         Reader为字符输入流的抽象父类，不可实例化
  15.          */
  16.         Reader in = null;
  17.         try {
  18.             in = new FileReader("F:\\ready\\1.txt");
  19.             int b;
  20.             while ((b = in.read()) != -1){
  21.                 System.out.println(b);
  22.             }
  23.         } catch (Exception e) {
  24.             e.printStackTrace();
  25.         } finally {
  26.             try {
  27.                 in.close();
  28.             } catch (IOException e) {
  29.                 e.printStackTrace();
  30.             }
  31.         }
  32.     }
  34.     private static void method1() {
  35.         Reader in = null;
  36.         try {
  37.             in = new BufferedReader(new FileReader("F:\\ready\\1.txt"));
  38.             in = new BufferedReader(new FileReader(new File("F:\\ready\\1.txt")));
  39.             int b;
  40.             while ((b = in.read()) != -1){
  41.                 System.out.println(b);
  42.             }
  43.         } catch (Exception e) {
  44.             e.printStackTrace();
  45.         } finally {
  46.             try {
  47.                 in.close();
  48.             } catch (IOException e) {
  49.                 e.printStackTrace();
  50.             }
  51.         }
  52.     }
  53. }

字符输出流

示例代码

  1. package cn.tedu.file;
  3. import java.io.*;
  5. /**
  6.  * 字符输出流
  7.  */
  9. public class TestOut2 {
  10.     public static void main(String[] args) {
  11.         //method();//用于测试普通字符输出流
  12.         method1();//用于测试高效字符输出流
  13.     }
  15.     private static void method() {
  16.         Writer out = null;
  17.         try {
  18.             //out = new FileWriter(new File("F:\\ready\\1.txt"));
  19.             out = new FileWriter("F:\\ready\\1.txt",true);
  20.             out.write(222);
  21.             out.write(298);
  22.             out.write(256);
  23.         } catch (Exception e) {
  24.             e.printStackTrace();
  25.         } finally {
  26.             try {
  27.                 out.close();
  28.             } catch (IOException e) {
  29.                 e.printStackTrace();
  30.             }
  31.         }
  32.     }
  34.     private static void method1() {
  35.         Writer out = null;
  36.         try {
  37.             //out = new BufferedWriter(new FileWriter(new File("F:\\ready\\1.txt")));
  38.             out = new BufferedWriter(new FileWriter("F:\\ready\\1.txt",true));
  39.             out.write(222);
  40.             out.write(298);
  41.             out.write(256);
  42.             out.flush();//防止数据遗漏
  43.         } catch (Exception e) {
  44.             e.printStackTrace();
  45.         } finally {
  46.             try {
  47.                 out.close();
  48.             } catch (IOException e) {
  49.                 e.printStackTrace();
  50.             }
  51.         }
  52.     }
  53. }