java I/O流

文件对象File（java.io.File）

1.File是谁？

File对象是文件和文件目录路径的抽象表示形式，与平台无关，它能新建、删除、重命名文件和目录，但 File 不能访问文件内容本身，访问文件本身需要流（Steam,Reader...）来执行

2.File的对象在我们电脑中一定存在吗？

这个答案是不确定的，File创建出来的对象可以不存在，也可以存在，但如果要用File对象来表示一个真实存在的文件或者文件夹，就必须保证文件存在！

3.File类的常用构造器方法

public File(String filePath);
public File(String parent,String child);//以parent为父路径， child为子路径创建File对象。

4.File类中的常用方法

//获取
public String getAbsolutePath();//获取绝对路径
public String getName();//获取文件名称
public String getParent();//获取上一级目录路径
public String[] list();//获取所有子代文件或文件夹名称
public File[] listFiles();//获取所有子代文件或文件夹的File对象

//判断
public boolean isDirectory();//判断是否是文件目录
public boolean isFile();//判断是否是文件
public boolean exists();//判断是否存在

//创建
public boolean createNewFile();//创建文件。 若文件存在， 则不创建， 返回false
public boolean mkdir();//创建文件目录。 如果此文件目录存在， 就不创建了。如果此文件目录的上层目录不存在， 也不创建。
public boolean mkdirs();//创建文件目录。 如果上层文件目录不存在， 一并创建

了解了File之后，我们走向流

I/O流

1.什么是I/O流，拿来干嘛的？

I/O是Input/Output的缩写， I/O技术是非常实用的技术， 用于处理设备之间的数据传输。 如读/写文件，网络通讯等

2.什么是输入，什么又是输出

首先，这两个概念都是针对程序来说的，将数据读到程序类=输入(input),将数据从程序写到文件或数据库=输出(output)

3.流的分类

按操作数据单位分： 字节流(8 bit)，字符流(16 bit)
按数据流的流向分： 输入流，输出流
按流的角色分： 节点流，处理流

4.流的抽象基类

(抽象基类)	字节流	字符流
输入流	InputStream	Reader
输出流	OutputStream	Writer

助记：人类阅读(read)看到的是文字、字符等等，所以字符流就是：Reader和Writer，因此剩下的那个就是字节流

5.i/o流体系

6.流中的常用方法：

InputStream 和 Reader 是所有输入流的基类

//InputStream（典型实现： FileInputStream）
int read();//从输入流中读取数据的下一个字节。 
//返回 0 到 255 范围内的 int 字节值。 
//如果因为已经到达流末尾而没有可用的字节， 则返回值 -1。
int read(byte[] b);//从此输入流中将最多 b.length 个字节的数据读入一个 byte数组中。 
//如果因为已经到达流末尾而没有可用的字节， 则返回值 -1。否则以整数形式返回实际读取的字节数。
int read(byte[] b, int off, int len);//将输入流中最多 len 个数据字节读入byte 数组.
//尝试读取 len 个字节， 但读取的字节也可能小于该值。 
//以整数形式返回实际读取的字节数。 如果因为流位于文件末尾而没有可用的字节， 则返回值 -1。

//Reader（典型实现： FileReader）
int read();//读取单个字符。 作为整数读取的字符， 范围在 0 到 65535 之间(0x00-0xffff)（2个字节的Unicode码),
//如果已到达流的末尾， 则返回 -1
int read(char [] c);//将字符读入数组。 如果已到达流的末尾， 则返回 -1。 否返回本次读取的字符数
int read(char [] c, int off, int len);//将字符读入数组的某一部分。 存到数组cbuf中， 
//从off处开始存储， 最多读len个字符。 如果已到达流的末尾， 则返回 -1。 否则返回本次读取的字符数
void close();

OutputStream & Writer

void write(int b/int c);
void write(byte[] b/char[] cbuf);
void write(byte[] b/char[] buff, int off, int len);
void flush();//刷新该流的缓冲， 则立即将它们写入预期目标
void close(); //需要先刷新，再关闭此流

7.文件流使用步骤

写入：
1.建立一个流对象，将已存在的一个文件加载进流。

FileReader fr = new FileReader(new File(“Test.txt”));

2.创建一个临时存放数据的数组。

char[] ch = new char[1024];

3.调用流对象的读取方法将流中的数据读入到数组中。

fr.read(ch);

4. 关闭资源。

fr.close();

输出：
1.创建流对象，建立数据存放文件

FileWriter fw = new FileWriter(new File(“Test.txt”));

2.调用流对象的写入方法，将数据写入流

fw.write(“ssssss”);

3.调用flush()清除缓存

fw.flush();

4.关闭流资源，并将流中的数据清空到文件中。

fw.close();

案例：

读取

FileReader fr = null;
try {
  fr = new FileReader(new File("c:\\test.txt"));
  //读取是必须保证文件存在，否则FileNotFoundException
  char[] buf = new char[1024];
  int len;
  while ((len = fr.read(buf)) != -1) {
    System.out.print(new String(buf, 0, len));
  }
} catch (IOException e) {
  System.out.println("read-Exception :" + e.getMessage());
} finally {
  if (fr != null) {
    try {
      fr.close();
    } catch (IOException e) {
      System.out.println("close-Exception :" + e.getMessage());
    }
  }
}

输出

FileWriter fw = null;
try {
  fw = new FileWriter(new File("Test.txt"));
  //如果文件已存在，则覆盖，不想覆盖则用FileWriter(file,true);
  //节点流：FileOutputStream(file,true);
  fw.write("ssssss");
} catch (IOException e) {
  e.printStackTrace();
} finally {
  if (fw != null)
    try {
      fw.close();
    } catch (IOException e) {
      e.printStackTrace();
    }
}

缓冲流

为什么要用缓冲流

因为缓冲流的读写速度更快

使用案例：

BufferedReader br = null;
BufferedWriter bw = null;
try {
  // 创建缓冲流对象：它是处理流，是对节点流的包装
  br = new BufferedReader(new FileReader("d:\\IOTest\\source.txt"));
  bw = new BufferedWriter(new FileWriter("d:\\IOTest\\dest.txt"));
  String str;
  while ((str = br.readLine()) != null) { // 一次读取字符文本文件的一行字符
    bw.write(str); // 一次写入一行字符串
    bw.newLine(); // 写入行分隔符
  }
  bw.flush(); // 刷新缓冲区
} catch (IOException e) {
   e.printStackTrace();
} finally {
  // 关闭IO流对象
  try {
    if (bw != null) {
      bw.close(); // 关闭过滤流时,会自动关闭它所包装的底层节点流
    }
  } catch (IOException e) {
     e.printStackTrace();
  }
  try {
     if (br != null) {
        br.close();
     }
  } catch (IOException e) {
    e.printStackTrace();
  }
}

转换流

InputStreamReader：将InputStream转换为Reader
OutputStreamWriter：将Writer转换为OutputStream
InputStreamReader的构造方法：

public InputStreamReader(InputStream in)；
public InputSreamReader(InputStream in,String charsetName)；

OutputStreamWriter的构造方法：

public OutputStreamWriter(OutputStream out)；
public OutputSreamWriter(OutputStream out,String charsetName);

使用案例：

public void testMyInput() throws Exception {
  FileInputStream fis = new FileInputStream("dbcp.txt");
  FileOutputStream fos = new FileOutputStream("dbcp5.txt");
  InputStreamReader isr = new InputStreamReader(fis, "GBK");
  OutputStreamWriter osw = new OutputStreamWriter(fos, "GBK");
  BufferedReader br = new BufferedReader(isr);
  BufferedWriter bw = new BufferedWriter(osw);
  String str = null;
  while ((str = br.readLine()) != null) {
    bw.write(str);
    bw.newLine();
    bw.flush();
  }
  bw.close();
  br.close();
}

此节到此结束，下节整理对象流