黑马程序员—IO概述

——Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ——-
IO概述
IO流用来处理设备之间的数据传输。
Java对数据的操作是通过流的方式。
Java用于操作流的对象都在IO包中。

IO分类：

流按操作数据分为两种：字节流与字符流。
注意：其实计算机里的所有数据都是以字节的形式体现的,计算机可以直接识别字节。但是作为人类的程序员更擅长操作字符，所以后期产生了字符流 。

流按流向分为：输入流(input)，输出流(output)。
相对路径与绝对路径：
绝对路径：从盘符开始指定的物理路径。是真正文件在硬盘上的位置。
相对路径：相对于某个指定位置的路径。
如c:/a/b/c.txt文件。
相对于c:的路径为a/b/c.txt
c.txt相对于c:/a/b的路径为直接的c .txt
代码中Windows中路径分隔可使用/或者\。

InputStream:此抽象类是表示字节输入流的所有类的超类。

FileInputStream: InputStream的子类 从文件系统中的某个文件中获得输入字节。

构造：
public FileInputStream(String name) throws FileNotFoundException 通过文件字符串的名称，从一个文件中读
public FileInputStream(File file) throws FileNotFoundException 通过文件对象，从一个文件中读

普通方法：
public int read() throws IOException 一次读取一个字节 返回为读取到的那个字节 如果读取到文件末位，返回-1
public int read(byte[] b)throws IOException 一次读取一个字节组
byte[] b:最终读取到的内容存放的
返回值：本次读到的字节个数
代码实例

public class Demo02_InputStream {    public static void main(String[] args) throws IOException {        //创建流对象        FileInputStream fis = new FileInputStream("a.txt");        //读入或者写出        /*         *         一次读取一个字节        //System.out.println(fis.read());        //定义变量，用于临时存储读取到的字节//      int b;//      //      while((b=fis.read())!=-1) {//          System.out.println((char)b);//      } *          */        //定义变量，用于临时存储读取到的字节        byte[] bytes = new byte[3];        //定义变量，记录本次读取到的字节个数，用于判断循环是否结束        int len;        while((len=fis.read(bytes))!=-1) {            System.out.println("本次读取到"+len+"个字节");            System.out.println("本次读取到的内容是："+Arrays.toString(bytes));            String s = new String(bytes,0,len);            System.out.println(s);        }        //关闭流        fis.close();    }}

代码实例 把一个文件复制到另一个文件中去

public class Demo03_copyFile {    public static void main(String[] args) throws IOException {        method();        method2();    }    //一次复制一个字节数组    public static void method2() throws IOException{        //本次采取一次一个字节数组的方式        //创建流对象        FileInputStream fis = new FileInputStream("a.txt");        FileOutputStream fos = new FileOutputStream("b.txt");        //先读         //定义变量，用于临时存储读到的字节        byte[] bytes = new byte[3];        //定义变量，用于临时存储本次读取到的字节个数        int len;        while((len=fis.read(bytes))!=-1) {            //后写            fos.write(bytes,0,len);        }        //关闭流        fos.close();        fis.close();    }    //一次复制一个字节    public static void method() throws IOException{        //本次采取一次一个字节的方式        //创建流对象        FileInputStream fis = new FileInputStream("a.txt");        FileOutputStream fos = new FileOutputStream("b.txt");        //先读         //定义变量，用于临时存储读到的字节        int b;        while((b=fis.read())!=-1) {            //后写            fos.write(b);        }        //关闭流        fos.close();        fis.close();    }}

OutputStream:此抽象类是表示输出字节流的所有类的超类。
FileOutputStream: OutputStream的子类 文件输出流是用于将数据写入 File的输出流。

构造：
public FileOutputStream(String name) throws FileNotFoundException 通过文件字符串的名称，写出到一个文件中
public FileOutputStream(File file)throws FileNotFoundException 通过文件对象，写出到一个文件中

普通方法：
public void write(int b) throws IOException 一次输出一个字节
public void write(byte[] b) throws IOException 一次输出一个字节数组
public void write(byte[] b, int off,int len) throws IOException 一次输出一个字节数组的一部分

public void close() throws IOException 关闭流
代码实例

public class Demo01_OutputStream {    public static void main(String[] args) throws IOException {        //创建流对象        FileOutputStream fos = null;            fos = new FileOutputStream("a.txt");//      File file = new File("a.txt");//      FileOutputStream fos2 = new FileOutputStream(file);        //写出或读取数据        fos.write(97);        String s = "i love java";        byte[] bytes = s.getBytes();        System.out.println(Arrays.toString(bytes));        fos.write(bytes);        fos.write(bytes,2,2);        fos.close();    }}

BufferedOutputStream: 高效字节输出流 缓冲字节输出流
BufferedInputStream: 高效字节输入流 缓冲字节输入流

public void flush() throws IOException 刷新缓冲区
使用带缓冲区的流是写出到缓冲区中，如果想写到文件中，需要将缓冲区的内容刷新到文件中
close方法在真正关闭之前，先刷新缓冲区

构造方法：
public BufferedOutputStream(OutputStream out)
public BufferedInputStream(InputStream in)

高效流的构造方法，不直接关联文件，而是使用了对应的普通流对象
代码实例

public class Demo02_Buffer {    public static void main(String[] args) throws IOException {        //高效输出流        //创建流对象        OutputStream os = new FileOutputStream("a/a.txt");        BufferedOutputStream bos = new BufferedOutputStream(os);        //写出//      os.write('a');        bos.write("我虔诚地热爱着java".getBytes());//      bos.flush();        //关闭流        bos.close();        //高效输入流        InputStream is = new FileInputStream("a/a.txt");        BufferedInputStream bis = new BufferedInputStream(is);//      //一次一个字节//      int b;//      while((b=bis.read())!=-1) {//          System.out.println((char)b);//      }        //一次一个字节数组        byte[] bytes = new byte[1024];        int len;        while((len=bis.read(bytes))!=-1) {            System.out.println(new String(bytes,0,len));        }        bis.close();    }}

Writer:字符输出流根类

FileWriter：用来写入字符文件的便捷类。

普通方法：
public void write(int c) throws IOException 一次写出一个字符
public void write(char[] cbuf) throws IOException 一次写出一个字符数组
public void write(char[] cbuf，int index，int len) throws IOException 一次写出一个字符数组的一部分

    public void write(String str) throws IOException  一次写出一个字符串

代码实例

public class Demo03_Writer {    public static void main(String[] args) throws IOException {        //创建流对象        FileWriter fw = new FileWriter("c.txt");        //写出数据        fw.write('中');        fw.write('a');        fw.write(97);        char[] chars = new char[]{'a','b','c'};        fw.write(chars);        fw.write(chars, 0, 2);        fw.write("我爱Java");//      fw.flush();        //关闭流        fw.close();    }}

Reader:字符输入流根类

FileReader：用来读入字符文件的便捷类。

普通方法：
public int read() throws IOException 一次读取一个字符
public int read(char[] cbuf) throws IOException 一次读取一个字符数组
代码实例

public class Demo04_Reader {    public static void main(String[] args) throws IOException {        //创建IO流对象        FileReader fr = new FileReader("c.txt");        //读取//      //一次读取一个字符//      int c;//      while((c=fr.read())!=-1) {//          System.out.println((char)c);//      }        //一次读取一个字符数组        char[] chars = new char[1024];        int len;        while((len=fr.read(chars))!=-1) {            System.out.println(chars);            System.out.println(new String(chars, 0, len));        }        //关闭流        fr.close();    }}

转换流
InputStreamReader isr = new InputStreamReader(System.in);
InputStreamReader isr = new InputStreamReader(new FileInputStream(…));

OutputStreamWriter osw = new OutputStreamWriter(System.out);
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(…));