黑马程序员——JAVA基础------IO流（四）----字节字符转换流和缓冲流
——Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ——
一、字节字符转换流
输入/输出流体系中还提供了两个转换流，这两个转换流用于实现将字节流转换成字符流，其中InputStreamReader将字节输入流转换成字符输入流，OutputStreamWriter将字节输出流转换成字符输出流。
OutputStreamWriter:
public class OutputStreamWriter extends WriterOutputStreamWriter 是字符流通向字节流的桥梁；可使用指定的charset 将要写流中的字符编码成字节。它使用的字符集可以由名称指定或显式给定，否则将接收平台默认的字符集。
InputStreamReader:
public class InputStreamReader extends ReaderInputStreamReader是字节流通向字符流的桥梁；它使用指定的charset 读取字节并将其解码为字符。它使用的字符集可以由名称指定或显式给定，或者可以接收平台默认的字符集。
代码演示：
package com.joe.io;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.Reader;
import java.io.Writer;
/**
* 转换流是增强流的功能，使输入输出更加便捷
* 代码思路：1、创建流对象 2、创建转换流 3、按照输入输出流的思路继续往下走
*
* @author joe
*
*/
public class OutputStreamWriterDemo {
public static void main(String[] args) {
// writer();
reader();
}
/**
* 使用转换流，把字符流转换成字节流输出 OutputStreamWriter
*/
public static void writer() {
// 构造一个字节输出流
OutputStream out = null;
Writer writer = null;
try {
out = new FileOutputStream("d:\\3.txt");
String info = "学JAVA,要耐心，要坚持！";
// 通过字节输出流构造一个字符输出流
writer = new OutputStreamWriter(out);
writer.write(info);// 输出
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
// 关闭流
if (writer != null)
try {
writer.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
if (out != null)
try {
out.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
/**
* 使用转换流，把字节流转换成字符流
*/
public static void reader() {
InputStream in = null;
Reader reader = null;
try {
// 构造字节输入流
in = new FileInputStream("d:\\3.txt");
// 通过字节输入流构造一个字符输入流
reader = new InputStreamReader(in);
// 创建一个字符数组用来定义一次读取数据的长度
char[] cs = new char[50];
int len = 0;
StringBuilder sb = new StringBuilder();
// 当没有数据时，返回-1
while ((len = reader.read(cs)) != -1) {
sb.append(new String(cs, 0, len));
}
System.out.println(sb);
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
// 关闭流
if (reader != null)
try {
reader.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
if (in != null)
try {
in.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}二、缓冲流
字节字符流对文件或其他目标频繁的读写操作，因此效率低，性能差。因此，JAVA还提供了一个提高效率的方法——缓冲流。
使用缓冲流的好处是，能够更高效的读写信息，原理是将数据先缓冲起来，然后一起写入或者读取出来。
Java 提供了两种字节缓冲流 BufferInputStream 和BufferOutputStream ；两种字符缓冲流 BufferReader 和 BufferWriter .
BufferedInputStream：
public class BufferedInputStream extends FilterInputStreamBufferInputStream 为另一个输入流添加一些功能，在创建BufferInputStream时，会创建一个内部缓冲区数组，用于缓冲数据。
BufferedOutputStream：
public class BufferedOutputStream extends FilterOutputStream类实现缓冲的输出流。通过设置这种输出流，应用程序就可以将各个字节写入底层输出流中，而不必针对每次字节写入调用底层系统。
代码演示：
package com.joe.io;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.Reader;
/**
* 缓冲流是增强流的功能 提高效率和性能
* 代码思路：1、创建流对象 2、创建缓冲流 3、按照输入输出流的思路往下走
*
*
* @author joe
*
*/
public class BufferedStreamDemo {
public static void main(String[] args) {
// input();
write();
}
/**
* 使用字节缓冲流写入数据
*/
public static void write() {
OutputStream out = null;
BufferedOutputStream bos = null;
try {
out = new FileOutputStream("d:\\4.txt");
// 根据字节输出流构造一个字节缓冲流
bos = new BufferedOutputStream(out);
String info = "学JAVA，要坚持，要有耐心！";
bos.write(info.getBytes());
bos.flush();// 刷新缓冲区
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
/**
* 使用字节缓冲流进行读取操作
*/
public static void input() {
InputStream in = null;
BufferedInputStream bis = null;
Reader r = null;
try {
in = new FileInputStream("d:\\别让大学上了你.txt");
// 根据字节输入流构造一个字节缓冲流
bis = new BufferedInputStream(in);
r = new InputStreamReader(bis);
char[] cs = new char[512];
int len = -1;
StringBuilder sb = new StringBuilder();
while ((len = r.read(cs)) != -1) {
sb.append(new String(cs, 0, len));
}
System.out.println(sb);
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
if (r != null)
try {
r.close();
} catch (IOException e) {
e.printStackTrace();
}
if (bis != null)
try {
bis.close();
} catch (IOException e) {
e.printStackTrace();
}
if (in != null)
try {
in.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}BufferedReader :
public class BufferedReader extends Reader从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取。可指定缓冲区的大小，也可使用默认大小。大多数情况下，默认值就足够大了。
BufferedWriter
public class BufferedWriter extends Writer将文本写入字符输出流，缓冲各个字符，从而提供单个字符、数组和字符串的高效写入。可指定缓冲区的大小，也可接受默认大小。在大多数情况下，默认值就足够大了。
代码演示：
package com.joe.io;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Reader;
import java.io.Writer;
/**
* 字符缓冲流
*
* @author lamp
*
*/
public class BufferedCharStreamDemo {
public static void main(String[] args) {
write();
System.out.println("success!");
reader();
}
/**
* 使用缓冲流实现读取操作
*/
public static void reader() {
Reader r = null;
BufferedReader br = null;
try {
r = new FileReader("d:\\3.txt");
// 根据字符输入流构造一个字符缓中流
br = new BufferedReader(r);
char[] cs = new char[512];
int len = -1;
StringBuilder sb = new StringBuilder();
while ((len = br.read(cs)) != -1) {
sb.append(new String(cs, 0, len));
}
System.out.println(sb);
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
if (br != null)
try {
br.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
if (r != null)
try {
r.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
/**
* 使用缓冲流实现写入操作
*/
public static void write() {
Writer w = null;
BufferedWriter bw = null;
try {
w = new FileWriter("d:\\5.txt");
// 根据字符输出流构造一个字符缓冲流
bw = new BufferedWriter(w);
bw.write("小白，怎么了，这是，被驴踢了吧");
bw.flush();// 刷新
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
if (bw != null)
try {
bw.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
if (w != null)
try {
w.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}