java学习笔记（16）：IO流

• IO是指Input和Output
• Input是读取文件中的数据（文件到程序）
• Output是往文件中写数据（程序到文件）

一、OutputStream字节输出流（抽象类/父类）

（1）特点：从java程序，写到文件，该流每次只操作文件中的一个字节。可以写任意文件（不是文件夹）

（2）字节输出流的方法（写入文件的方法）

write(int b)   				 //写入1个字节
write(byte[] b)      		 //写入字节数组
write(byte[] b,int m,int n)	 //写入字节数组，m表示开始写入的索引，n表示写几个
close()      				 //关闭流对象，并释放与此流相关的资源

（3）流对象的使用步骤
1.创建流子类的对象，绑定一个数据目的
2.调用流对象的方法write写
3.close释放资源

FileOutputStream类（继承OutputStream）

（1）子类中的构造方法作用：绑定输出的输出目的。（可以根据路径创建文件，如果文件已经村子，直接覆盖原文件。）

（2）流对象的方法write写数据

• 举例如下

import java.io.FileOutputStream;
import java.io.IOException;

public class Demo {
    public static void main(String[] args) throws IOException {
        System.out.println("-----写一个字节------");
        FileOutputStream fos = new FileOutputStream("f:\\a.txt");
        fos.write(97);
        fos.close();

        System.out.println("-----写字节数组------");
        FileOutputStream fos1 = new FileOutputStream("f:\\b.txt");
        byte[] bytes = {65,66,67,68};
        fos1.write(bytes);
        System.out.println("-----写字节数组的简便方式------");
        fos1.write("hello".getBytes());      //利用String类的getByetes方法直接得到字符串的字节
        fos1.close();

        System.out.println("-----写字节数组的一部分------");
        FileOutputStream fos2 = new FileOutputStream("f:\\c.txt");
        byte[] bytes1 = {65,66,67,68};
        fos2.write(bytes1,1,2);
        fos2.close();
    }
}

• 运行结果
  
  

注： 写一个字节写入的是97，但是文件中显示的是a（显示的是ASCII码）

（3）FileOutputStream文件的续写和换行问题
续写：FileOutputStream构造方法的第二个参数，加入true（如果不加入true，则每次写入时会将上一次程序运行写入的内容覆盖）
在文件中，写入换行，符号换行 \r\n （该换行符可以写在上一行的末尾，也可以写在下一行的开头）

• 举例如下

import java.io.FileOutputStream;
import java.io.IOException;

public class Demo {
    public static void main(String[] args) throws IOException {
        FileOutputStream fos = new FileOutputStream("f:\\a.txt",true);		
        fos.write("hello\r\n".getBytes());                                  
        fos.write("world".getBytes());
        fos.close();
    }
}

• 运行结果（程序运行了两次）
  

二、FileInputStream（继承IntputStream字节输出流）

（1）构造方法：为这个流对象绑定数据源

（2）输入流读取文件的步骤：
1.创建字节输入流的子类对象
2.调用读取方法read读取
3.关闭资源

注： read()方法执行一次，就会自动读取下一个字节，返回值是读取到的字节。当读取到文件的结尾时，返回值是-1。

（3）读取一个字节

• 错误代码（错误原因是在读一个字节调用了两次read方法）

 while(fis.read() != -1){
            int i = fis.read();
            System.out.print((char)i);
        }

• 正确代码

import java.io.FileInputStream;
import java.io.IOException;

public class Demo {
    public static void main(String[] args) throws IOException {
        FileInputStream fis = new FileInputStream("f:\\a.txt");
        int i;
        while((i = fis.read()) != -1){
            System.out.print((char)i);
        }
        fis.close();
    }
}

• 运行结果
  

（4）读取字节数组
读取方法 int read（byte[ ] b）读取字节数组
数组的作用：缓冲的作用，提高效率
read返回的int：表示读取到多少个有效的字节数

• 举例如下

import java.io.FileInputStream;
import java.io.IOException;

public class Demo {
    public static void main(String[] args) throws IOException {
        FileInputStream fis = new FileInputStream("f:\\a.txt");
        int i;
        byte[] b = new byte[2];           //一般数组的大小取1024
        while((i = fis.read(b)) != -1){
            System.out.print(new String(b,0,i));   //只读取有效字节（即不读取相同字节）
        }
        fis.close();
    }
}

• 运行结果
  

（5）文件的复制
将数据源c:\a.txt复制到d：\a.txt
字节输入流，绑定数据源
字节输出流，绑定数据目的

输入，读取1个字节
输出，写1个字节

• 举例如下

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class Demo {
    public static void main(String[] args) throws IOException {
        FileInputStream fis = null;
        FileOutputStream fos = null;
            fis = new FileInputStream("e:\\a.txt");
            fos = new FileOutputStream("f:\\a.txt");
            byte [] bytes = new byte[1024];
            int f = 0;
            while((f = fis.read(bytes)) != -1) {
                fos.write(bytes, 0, f);
            }
                fis.close();              //先开的后关的原则
                fos.close();
    }
}

注： 如果要数据目的中已有a.txt，则会将原来的文件覆盖；因为是按字节复制的，所以可以复制任何文件。

三、字符流输入输出

字符流输出

（1）java.io.Writer 所有字符输出流的父类（常用Writer类的子类对象FileWriter（只能写文本文件））

（2）写的方法write
write（int c） 写一个字符
write（char[] c） 写字符数组
write（char[] c,int a, int b） 写字符数组的一部分，开始索引，写几个
write（String s） 写入字符串

（3）注意事项

• 字符输出流写数据的时候，必须要运行刷新功能（flush()）
• 建议写一次，调用一次刷新功能，最后再关闭流

（4）举例如下

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

public class Demo {
    public static void main(String[] args) throws IOException {
        FileWriter fw = new FileWriter("f:\\a.txt");
        //写1个字符
        fw.write(100);
        fw.flush();
        //写1个字符数组
        char[] c = {'a','b','c','d'};
        fw.write(c);
        fw.flush();
        //写字符数组的一部分
        fw.write(c,2,2);
        fw.flush();
        //写1个字符串
        fw.write("hello");
        fw.flush();
        fw.close();
    }
}

• 运行结果
  

字符输入流读取文本文件

（1）java.io.Reader（所有字符输入流的超类） 只能读取文本文件（也是专门用于读文本文件）

（2）读取方法
int read（） 读取1个字符
int read（char[] c）读取字符数组
没有读取字符串的功能（因为不好界定文本中的字符串）

（03）举例如下

import java.io.FileReader;
import java.io.IOException;

public class Demo {
    public static void main(String[] args) throws IOException {
        FileReader fr = new FileReader("f:\\a.txt");
        int f = 0;
        //读取一个字符
        while((f=fr.read()) != -1){
            System.out.print((char)f);
        }
        //读取字符数组
        char[] c = new char[1024];
        while((f=fr.read(c)) != -1){
            System.out.print(new String(c,0,5));
        }
        fr.close();
    }
}

• 运行结果