java IO流
流是一组有序的数据序列，根据操作的类型，可以分为输入流和输出流。
根据处理数据类型的不同，流又可分为字节流和字符流。相关类位于java.io包中，以下是相关类
1、文件输入\输出流
字节流：FileInputStream和FileOutputStream
FileInputStream和FileOutputStream分别继承自InputStream和OutputStream
/** * 写入文件 */ public static void testFileOutputStream(){ try { File file=new File("D:\\test.txt"); if(!file.exists()){ file.createNewFile(); } FileOutputStream fileOutputStream=new FileOutputStream(file); String str="this is the content"; byte[] b=str.getBytes(); fileOutputStream.write(b); fileOutputStream.close(); } catch (IOException e) { e.printStackTrace(); } } /** * 读文件 */ public static void testFileInputStream(){ try { File file=new File("D:\\test.txt"); if(!file.exists()){ file.createNewFile(); } FileInputStream fileInputStream=new FileInputStream(file); byte[] b=new byte[1024]; System.out.println("b before:"+new String(b)); int len=fileInputStream.read(b);//Reads up to b.length bytes of data from this input stream into an array of bytes. System.out.println("b after:"+new String(b,0,len)); fileInputStream.close(); } catch (IOException e) { e.printStackTrace(); } }
输出：
b before: b after:this is the content
可见，FileInputStream的read(byte[] b)方法是从流中读取b中（Reads up to b.length bytes of data from this input stream into an array of bytes. ）
字符流：FileReader和FileWriter
FileReader和FileWriter分别继承自Reader和Writer
/** * 写入文件 */ public static void testFileWriter(){ try { File file=new File("D:\\test.txt"); if(!file.exists()){ file.createNewFile(); } FileWriter fileWriter=new FileWriter(file); String str="this is the content2"; fileWriter.write(str); fileWriter.close(); } catch (IOException e) { e.printStackTrace(); } } /** * 读文件 */ public static void testFileReader(){ try { File file=new File("D:\\test.txt"); if(!file.exists()){ file.createNewFile(); } FileReader fileReader=new FileReader(file); char[] cbuf=new char[1024]; System.out.println("cbuf before:"+new String(cbuf)); int len=fileReader.read(cbuf);//Attempts to read characters into the specified character buffer. System.out.println("cbuf after:"+new String(cbuf,0,len)); fileReader.close(); } catch (IOException e) { e.printStackTrace(); } }
输出：
cbuf before: cbuf after:this is the content2
FileReader的read(char[] cbuf)方法，是将流的内容读取到cbuf中
2、带缓存的输入/输出流
缓存是I/O的一种性能优化，缓存流为I/O流增加了内存缓存区。有了缓存区，使得在流上执行skip()、mark()和reset()方法成为可能。
字节流：BufferedInputStream和BufferedOutputStream
BufferedInputStream对所有InputStream类进行带缓存区的包装以达到性能的优化。BufferedInputStream有两个构造方法：
(1) BufferedInputStream(InputStream in)
(2) BufferedInputStream(InputStream in,int size)
第一个构造方法创建了一个带有32字节的缓存流；第二个构造方法size参数指定了创建的缓存区的大小。
BufferedInputStream读取文件的流程如下：
BufferedOutputStream与BufferedInputStream类似，也有两个构造方法，
(1) BufferedOutputStream(OutputStream out)
(2) BufferedOutputStream(OutputStream out,int size)
第一个构造方法创建了一个带有32字节的缓存流；第二个构造方法size参数指定了创建的缓存区的大小。
BufferedOutputStream的flush()方法强制将缓存区的数据输出完。
以下是代码：/* * 写入文件
*/ public static void testBufferedOutputStream(){ try { File file=new File("D:\\test.txt"); if(!file.exists()){ file.createNewFile(); } FileOutputStream fileOutputStream=new FileOutputStream(file); BufferedOutputStream bufferedOutputStream=new BufferedOutputStream(fileOutputStream); String str="this is the content3"; byte[] b=str.getBytes(); bufferedOutputStream.write(b);
bufferedOutputStream.flush();
BufferedOutputStream.close();
fileOutputStream.close();
} catch (IOException e) {
e.printStackTrace(); }
}
/** * 读文件 */
public static void testBufferedInputStream(){
try {
File file=new File("D:\\test.txt");
if(!file.exists()){ file.createNewFile();
}
FileInputStream fileInputStream=new FileInputStream(file);
BufferedInputStream BufferedInputStream=new BufferedInputStream(fileInputStream);
byte[] b=new byte[1024]; System.out.println("b before:"+new String(b));
int len=BufferedInputStream.read(b);//Reads up to byte.length bytes of data from this input stream into an array of bytes.
System.out.println("b after:"+new String(b,0,len));
BufferedInputStream.close(); fileInputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
字符流：BufferedReader和BufferedWriter
BufferedReader和BufferedWriter分别继承自Reader和Writer，具有内部缓存的机制，并可以以行为单位进行输入输出。下图是读取的过程
以下是代码示例：
/** * 写文件 */ public static void testBufferedWriter(){ try { File file=new File("D:\\test.txt"); if(!file.exists()){ file.createNewFile(); } FileOutputStream fileOutputStream=new FileOutputStream(file); OutputStreamWriter outputStreamWriter=new OutputStreamWriter(fileOutputStream); BufferedWriter bufferedWriter=new BufferedWriter(outputStreamWriter); String str="this is the content5\n thissssss"; bufferedWriter.write(str);
bufferedWriter.flush();
bufferedWriter.close(); outputStreamWriter.close(); fileOutputStream.close(); } catch (IOException e) { e.printStackTrace(); } } /** * 读文件 */ public static void testBufferedReader(){ try { File file=new File("D:\\test.txt"); if(!file.exists()){ file.createNewFile(); } FileInputStream fileInputStream=new FileInputStream(file); InputStreamReader inputStreamReader=new InputStreamReader(fileInputStream); BufferedReader bufferedReader=new BufferedReader(inputStreamReader); String str=bufferedReader.readLine(); System.out.println(str); int i=bufferedReader.read(); System.out.println(i); bufferedReader.close(); inputStreamReader.close(); fileInputStream.close(); } catch (IOException e) { e.printStackTrace(); } }
输出结果：
this is the content5 32
flush()函数
flush这个操作的作用是将缓存中的输出流（字节流，字符流等）强制输出。输出流在进行输出时，比如像某个文件中写入内容，其实是先将输出流写入到缓冲区，当缓冲区写满后才将缓冲区的内容输出到文件中。但是当主机完成输出流的输出后，有可能缓冲区这个时候还没有被填满，这样的话，就会一直等待主机发送内容，这时候，就可以使用flush将缓冲区的内容强制输出到文件中，清空缓冲区。 所以，一般在关闭输出流之前，要先调用flush方法强制缓冲区中的内容输出，并清空缓冲区。
