java中利用IO流实现简单的图书管理系统（利用数组和IO实现）
这个案例，主要对数组及IO流进行总结！
利用IO流实现简单的图书管理系统，在控制台上打印！
功能：1，查看所有书籍
& 2，添加书籍
3，删除书籍
4，修改书籍
package com.baojian.bookS
import java.io.BufferedR
import java.io.FileNotFoundE
import java.io.FileOutputS
import java.io.FileR
import java.io.IOE
import java.util.S
* 实体类，主要利用数组，和IO流，对两个知识点进行加强
public class Book {
private String authorN
// 价格
// 书的数量
// 用于从控制台输入内容
Scanner scan = new Scanner(System.in);
// 确定库存数为20
final static int SIZE = 20;
// 创建一个长度为20的数组，用于存放书籍
Book[] books = new Book[SIZE];
// 存放当前图书数量
static int count = 0;
public Book() {
public Book(int id,String name, String authorName, double price, int num) {
this.name =
this.authorName = authorN
this.price =
this.num =
public int getId() {
public void setId(int id) {
public double getPrice() {
public void setPrice(double price) {
this.price =
public String getName() {
public void setName(String name) {
this.name =
public String getAuthorName() {
return authorN
public void setAuthorName(String authorName) {
this.authorName = authorN
public int getNum() {
public void setNum(int num) {
this.num =
//查看图书列表
public void list() throws IOException{
// 从文件中读出数据
books = Service.readData();
// 如果count为0，说明系统里面还没有书籍
if(count == 0 ){
System.out.println(&图书管理系统中还没有输入书籍，快去添加吧！&);
// 如果有书籍则遍历书籍
System.out.println(&图书编号\t\t& + &书名\t\t& + &作者\t\t& + &价格\t\t& + &数量\t\t&);
for (int i = 0; i & i++)
System.out.print(books[i].getId() + &\t\t&);
System.out.print(books[i].getName() + &\t\t&);
System.out.print(books[i].getAuthorName() + &\t\t&);
System.out.print(books[i].getPrice() + &\t\t&);
System.out.println(books[i].getNum() + &\t\t&);
// 确保书的种类不能多于20种
//count++;
//添加图书
public void add() throws IOException {
System.out.println(&----------------------------&);
if (count & SIZE)
// System.out.println(&请输入图书编号：&);
System.out.println(&请输入图书名称：&);
String name = scan.next();
System.out.println(&请输入作者：&);
String authorName = scan.next();
System.out.println(&请输入单价：&);
double price = scan.nextDouble();
System.out.println(&请输入图书数量：&);
int num = scan.nextInt();
Book book = new Book(id,name,authorName,price,num);
books[count] =
// 保存已经添加的书籍到文本文档中
Service.saveBook(books[count]);
count++;
System.out.println(&添加成功！&);
System.out.println(&书库已满！&);
//删除图书
public void delete() throws IOException{
System.out.println(&----------------------------&);
System.out.println(&请输入要删除书籍的id：&);
int id = scan.nextInt();
for(int i = i & count - 1 ; i++){
//用for循环的形式实现对数组的删除
books[i+1].setId(i);
books[i]=books[i+1];
System.out.println(&删除成功！&);
// 重写写到文件里面
Service service = new Service();
service.saveBook(books);
//修改图书
public void update() throws IOException{
System.out.println(&----------------------------&);
System.out.println(&请输入需要修改的图书编号：&);
int id = scan.nextInt();
System.out.println(&请输入图书名称：&);
String name = scan.next();
System.out.println(&请输入作者：&);
String authorName = scan.next();
System.out.println(&请输入单价：&);
double price = scan.nextDouble();
System.out.println(&请输入图书数量：&);
int num = scan.nextInt();
Book book = new Book(id,name, authorName, price, num);
// 修改该书籍的数据
books[id] =
Service.saveBook(books);
System.out.println(&修改成功！&);
package com.baojian.bookS
import java.io.BufferedR
import java.io.FileNotFoundE
import java.io.FileOutputS
import java.io.FileR
import java.io.IOE
* 用于向读取和写入数据
public class Service {
private static final int SIZE = 20;
// 此方法用于从文本文件中读出数据，封装成book对象，存到books中
public static Book[] readData() throws IOException {
// 创建一个Book类型的数组，用于存放读取出来的数据封装成的Book对象
Book[] readBooks = new Book[SIZE];
// 创建一个字符串用于存放读取出来的数据
String data = &&;
// 创建一个字符缓冲输入流对象
BufferedReader br = new BufferedReader(new FileReader(&c:\\bookData.txt&));
// 用于控制存放数组的下标
int id = 0;
// 每次度一行，如果有内容继续读取
while ((data = br.readLine()) != null) {
String[] dataArr = data.split(&:&);
// 创建Book对象
Book book = new Book();
// 第一个字符串用于设置id
//System.out.println(Integer.parseInt(dataArr[0].trim()));
book.setId(id);
// 第二个字符串用于设置name
book.setName(dataArr[1]);
// 第三个字符串用于设置author
book.setAuthorName(dataArr[2]);
// 第四个字符串用于设置价格
book.setPrice(Double.parseDouble(dataArr[3]));
// 第五个字符串用于设置存量
book.setNum(Integer.parseInt(dataArr[4]));
// 给数组中的元素赋值
readBooks[id] =
id++;
// 确定数据个数，就是书籍的种类
Book.count =
br.close();
// 返回读取到的数据
return readB
// 将新添加的书籍保存到文本文档中
public static void saveBook(Book book) throws IOException {
// 创建字符输入缓冲流对象
// BufferedWriter bw = new BufferedWriter(new FileWriter(&c:\\bookData.txt&,true));
// FileWriter fw = new FileWriter(&c:\\bookData.txt&,true);
FileOutputStream fos = new FileOutputStream(&c:\\bookData.txt&,true);
// 将book中的数据拼接成字符串
StringBuffer data = new StringBuffer();
// 获取书籍的id值
data.append( &\r\n& + book.getId() + &:&);
// 获取书名
data.append(book.getName() + &:&);
// 获取作者名
data.append(book.getAuthorName() + &:&);
// 获取价格
data.append(book.getPrice() + &:&);
// 获取库存数
data.append(book.getNum() + &&);
// 创建数据字符串
String dataStr = data.toString();
byte[] buf = dataStr.getBytes();
// 控制写入数据的长度
int len = buf.
fos.write(buf, 0, len);
fos.close();
// System.out.println(&写入成功！&);
// 重写saveBook方法用于删除和更新后向文件写数据
public static void saveBook(Book[] books) throws IOException{
// 创建字符输入缓冲流对象
// BufferedWriter bw = new BufferedWriter(new FileWriter(&c:\\bookData.txt&,true));
// FileWriter fw = new FileWriter(&c:\\bookData.txt&,true);
FileOutputStream fos = new FileOutputStream(&c:\\bookData.txt&);
// 存放数据
StringBuffer data = new StringBuffer();
//String data = &&;
for(int i = 0;i & Book.i++){
if(i == 0){
data.append(books[i].getId() + &:&);
// 获取书名
data.append(books[i].getName() + &:&);
// 获取作者名
data.append(books[i].getAuthorName() + &:&);
// 获取价格
data.append(books[i].getPrice() + &:&);
// 获取库存数
data.append(books[i].getNum() + &&);
data.append( &\r\n& + books[i].getId() + &:&);
// 获取书名
data.append(books[i].getName() + &:&);
// 获取作者名
data.append(books[i].getAuthorName() + &:&);
// 获取价格
data.append(books[i].getPrice() + &:&);
// 获取库存数
data.append(books[i].getNum() + &&);
// 创建数据字符串
String dataStr = data.toString();
byte[] buf = dataStr.getBytes();
// 控制写入数据的长度
int len = buf.
fos.write(buf, 0, len);
fos.close();
package com.baojian.bookS
import java.util.S
* 管理员实体类
public class User {
private String userN
public String getUserName() {
return userN
public void setUserName(String userName) {
this.userName = userN
public String getPassword() {
public void setPassword(String password) {
this.password =
//登录方法
public void login (){
Scanner sc = new Scanner(System.in);
while(true){
User user = new User();
System.out.println(&请输入用户名：&);
// 从控制台上输入用户名
user.setUserName(sc.nextLine());
System.out.println(&请输入密码：&);
// 从控制台上输入密码
user.setPassword(sc.nextLine());
if(user.getUserName().equals(&张三&) && user.getPassword().equals(&123&)){
System.out.println(&登陆成功！欢迎【& + user.getUserName() + &】使用阅山管理系统&);
System.out.println(&登录失败！请重新登录：&);
package com.baojian.bookS
import java.io.FileNotFoundE
import java.io.IOE
import java.util.S
* 测试类，用于测试功能
public class Test {
public static void main(String[] args) throws IOException {
@SuppressWarnings(&resource&)
Scanner sc = new Scanner(System.in);
User user = new User();
Book book = new Book();
//进行登录
user.login();
while(true){
System.out.println(&请输入数字进行操作：1.查看图书列表 2.添加图书 3.删除图书 4.修改图书
5.退出本系统&);
int num = sc.nextInt();
switch(num){
// 查看图书列表
book.list();
book.add();
System.out.println(&----------------------------&);
book.list();
book.delete();
System.out.println(&----------------------------&);
book.list();
book.update();
System.out.println(&已退出系统！&);
System.out.println(&您输入的数字不符合要求！&);
文本写入格式为：
完成案例测试效果：
没有更多推荐了，
加入CSDN，享受更精准的内容推荐，与500万程序员共同成长！Java IO流学习总结一：输入输出流
转载请标明出处：
Java流类图结构：
流的概念和作用
流是一组有顺序的，有起点和终点的字节集合，是对数据传输的总称或抽象。即数据在两设备间的传输称为流，流的本质是数据传输，根据数据传输特性将流抽象为各种类，方便更直观的进行数据操作。
IO流的分类
根据处理数据类型的不同分为：字符流和字节流
根据数据流向不同分为：输入流和输出流
字符流和字节流
字符流的由来： 因为数据编码的不同，而有了对字符进行高效操作的流对象。本质其实就是基于字节流读取时，去查了指定的码表。 字节流和字符流的区别：
读写单位不同：字节流以字节（8bit）为单位，字符流以字符为单位，根据码表映射字符，一次可能读多个字节。
处理对象不同：字节流能处理所有类型的数据（如图片、avi等），而字符流只能处理字符类型的数据。
字节流：一次读入或读出是8位二进制。
字符流：一次读入或读出是16位二进制。
设备上的数据无论是图片或者视频，文字，它们都以二进制存储的。二进制的最终都是以一个8位为数据单元进行体现，所以计算机中的最小数据单元就是字节。意味着，字节流可以处理设备上的所有数据，所以字节流一样可以处理字符数据。
结论：只要是处理纯文本数据，就优先考虑使用字符流。 除此之外都使用字节流。
输入流和输出流
输入流只能进行读操作，输出流只能进行写操作，程序中需要根据待传输数据的不同特性而使用不同的流。
输入字节流 InputStream
InputStream 是所有的输入字节流的父类，它是一个抽象类。
ByteArrayInputStream、StringBufferInputStream、FileInputStream 是三种基本的介质流，它们分别从Byte 数组、StringBuffer、和本地文件中读取数据。
PipedInputStream 是从与其它线程共用的管道中读取数据，与Piped 相关的知识后续单独介绍。
ObjectInputStream 和所有FilterInputStream 的子类都是装饰流（装饰器模式的主角）。
输出字节流 OutputStream
OutputStream 是所有的输出字节流的父类，它是一个抽象类。
ByteArrayOutputStream、FileOutputStream 是两种基本的介质流，它们分别向Byte 数组、和本地文件中写入数据。
PipedOutputStream 是向与其它线程共用的管道中写入数据。
ObjectOutputStream 和所有FilterOutputStream 的子类都是装饰流。
输入流：InputStream或者Reader：从文件中读到程序中；
输出流：OutputStream或者Writer：从程序中输出到文件中；
节点流：直接与数据源相连，读入或读出。
直接使用节点流，读写不方便，为了更快的读写文件，才有了处理流。
常用的节点流
父　类 ：InputStream 、OutputStream、 Reader、 Writer
文　件 ：FileInputStream 、 FileOutputStrean 、FileReader 、FileWriter 文件进行处理的节点流
数　组 ：ByteArrayInputStream、 ByteArrayOutputStream、 CharArrayReader 、CharArrayWriter 对数组进行处理的节点流（对应的不再是文件，而是内存中的一个数组）
字符串 ：StringReader、 StringWriter 对字符串进行处理的节点流
管　道 ：PipedInputStream 、PipedOutputStream 、PipedReader 、PipedWriter 对管道进行处理的节点流
处理流和节点流一块使用，在节点流的基础上，再套接一层，套接在节点流上的就是处理流。如BufferedReader.处理流的构造方法总是要带一个其他的流对象做参数。一个流对象经过其他流的多次包装，称为流的链接。
常用的处理流
缓冲流：BufferedInputStrean 、BufferedOutputStream、 BufferedReader、 BufferedWriter 增加缓冲功能，避免频繁读写硬盘。
转换流：InputStreamReader 、OutputStreamReader实现字节流和字符流之间的转换。
数据流： DataInputStream 、DataOutputStream 等-提供将基础数据类型写入到文件中，或者读取出来。
InputStreamReader 、OutputStreamWriter 要InputStream或OutputStream作为参数，实现从字节流到字符流的转换。
InputStreamReader(InputStream);
//通过构造函数初始化，使用的是本系统默认的编码表GBK。
InputStreamWriter(InputStream,String charSet);
//通过该构造函数初始化，可以指定编码表。
OutputStreamWriter(OutputStream);
//通过该构造函数初始化，使用的是本系统默认的编码表GBK。
OutputStreamwriter(OutputStream,String charSet);
//通过该构造函数初始化，可以指定编码表。
FileInputStream类的使用：读取文件内容
package com.
import java.io.FileInputS
import java.io.FileNotFoundE
import java.io.IOE
public class A1 {
public static void main(String[] args) {
A1 a1 = new A1();
//电脑d盘中的abc.txt 文档
String filePath = "D:/abc.txt" ;
String reslut = a1.readFile( filePath ) ;
System.out.println( reslut );
* 读取指定文件的内容
* @param filePath ： 文件的路径
返回的结果
public String readFile( String filePath ){
FileInputStream fis=
String result = "" ;
// 根据path路径实例化一个输入流的对象
= new FileInputStream( filePath );
//2. 返回这个输入流中可以被读的剩下的bytes字节的估计值；
int size =
fis.available() ;
//3. 根据输入流中的字节数创建byte数组；
byte[] array = new byte[size];
//4.把数据读取到数组中；
fis.read( array ) ;
//5.根据获取到的Byte数组新建一个字符串，然后输出；
result = new String(array);
} catch (FileNotFoundException e) {
e.printStackTrace();
}catch (IOException e) {
e.printStackTrace();
if ( fis != null) {
fis.close();
} catch (IOException e) {
e.printStackTrace();
FileOutputStream 类的使用：将内容写入文件
package com.
import java.io.FileNotFoundE
import java.io.FileOutputS
import java.io.IOE
public class A2 {
public static void main(String[] args) {
A2 a2 = new A2();
//电脑d盘中的abc.txt 文档
String filePath = "D:/abc.txt" ;
//要写入的内容
String content = "今天是,天气很好" ;
a2.writeFile( filePath , content
* 根据文件路径创建输出流
* @param filePath ： 文件的路径
* @param content : 需要写入的内容
public void writeFile( String filePath , String content ){
FileOutputStream fos =
//1、根据文件路径创建输出流
= new FileOutputStream( filePath );
//2、把string转换为byte数组；
byte[] array = content.getBytes() ;
//3、把byte数组输出；
fos.write( array );
} catch (FileNotFoundException e) {
e.printStackTrace();
}catch (IOException e) {
e.printStackTrace();
if ( fos != null) {
fos.close();
} catch (IOException e) {
e.printStackTrace();
在实际的项目中，所有的IO操作都应该放到子线程中操作，避免堵住主线程。
FileInputStream在读取文件内容的时候，我们传入文件的路径（"D:/abc.txt"）, 如果这个路径下的文件不存在，那么在执行readFile()方法时会报FileNotFoundException异常。
FileOutputStream在写入文件的时候，我们传入文件的路径（"D:/abc.txt"）, 如果这个路径下的文件不存在，那么在执行writeFile()方法时, 会默认给我们创建一个新的文件。还有重要的一点，不会报异常。
综合练习，实现复制文件，从D盘复制到E盘
package com.
import java.io.FileInputS
import java.io.FileNotFoundE
import java.io.FileOutputS
import java.io.IOE
public class A3 {
public static void main(String[] args) {
A3 a2 = new A3();
//电脑d盘中的cat.png 图片的路径
String filePath1 = "D:/cat.png" ;
//电脑e盘中的cat.png 图片的路径
String filePath2 = "E:/cat.png" ;
//复制文件
a2.copyFile( filePath1 , filePath2 );
* 文件复制
* @param filePath_old : 需要复制文件的路径
* @param filePath_new : 复制文件存放的路径
public void copyFile( String filePath_old
, String filePath_new){
FileInputStream fis=
FileOutputStream fout =
// 根据path路径实例化一个输入流的对象
= new FileInputStream( filePath_old );
//2. 返回这个输入流中可以被读的剩下的bytes字节的估计值；
int size =
fis.available() ;
//3. 根据输入流中的字节数创建byte数组；
byte[] array = new byte[size];
//4.把数据读取到数组中；
fis.read( array ) ;
//5、根据文件路径创建输出流
fout = new FileOutputStream( filePath_new ) ;
//5、把byte数组输出；
fout.write( array );
} catch (FileNotFoundException e) {
e.printStackTrace();
}catch (IOException e) {
e.printStackTrace();
if ( fis != null) {
fis.close();
} catch (IOException e) {
e.printStackTrace();
if ( fout != null ) {
fout.close();
} catch (IOException e) {
e.printStackTrace();
阅读(...) 评论()java的IO流怎么发送json? 请具体分步哦，打好了有悬赏。_百度知道
java的IO流怎么发送json? 请具体分步哦，打好了有悬赏。
我有更好的答案
首先封装的数据，MAP/String/XML等等格式。举个例子String putData = &这是我要发送的数据&;JSONObject json= new JSONObject();json.put(&datas&,putData);PrintWriter out = response.getWriter();out.println(json.toString());
请问，json.fromobject 在这可以用吗
可以啊，但是你前台请求要定义好数据格式，dataType：&json&,
采纳率：89%
为您推荐：
其他类似问题
换一换
回答问题，赢新手礼包
个人、企业类
违法有害信息,请在下方选择后提交
色情、暴力
我们会通过消息、邮箱等方式尽快将举报结果通知您。网上得来终觉浅，绝知此事要躬行。
Java 常用IO流操作详解
IO流大家肯定不陌生，简单整理了一下常用IO流基本用法，其他的IO流还有很多以后有时间在整理。
1.基本概念
IO：Java对数据的操作是通过流的方式，IO流用来处理设备之间的数据传输，上传文件和下载文件，Java用于操作流的对象都在IO包中。
2.IO流的分类
图示：（主要IO流）
（1）.字节流基类
1）.InputStream
InputStream：字节输入流基类，抽象类是表示字节输入流的所有类的超类。
常用方法：
// 从输入流中读取数据的下一个字节
abstract int read()
// 从输入流中读取一定数量的字节，并将其存储在缓冲区数组 b中
int read(byte[] b)
// 将输入流中最多 len 个数据字节读入 byte 数组
int read(byte[] b, int off, int len)
// 跳过和丢弃此输入流中数据的 n个字节
long skip(long n)
// 关闭此输入流并释放与该流关联的所有系统资源
void close()
2）.OutputStream
OutputStream：字节输出流基类，抽象类是表示输出字节流的所有类的超类。
常用方法：
// 将 b.length 个字节从指定的 byte 数组写入此输出流
void write(byte[] b)
// 将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此输出流
void write(byte[] b, int off, int len)
// 将指定的字节写入此输出流
abstract void write(int b)
// 关闭此输出流并释放与此流有关的所有系统资源
void close()
// 刷新此输出流并强制写出所有缓冲的输出字节
void flush()
（2）.字节文件操作流
1）.FileInputStream
FileInputStream：字节文件输入流，从文件系统中的某个文件中获得输入字节，用于读取诸如图像数据之类的原始字节流。
构造方法：
// 通过打开一个到实际文件的连接来创建一个FileInputStream，该文件通过文件系统中的File对象file指定
FileInputStream(File file)
// 通过打开一个到实际文件的连接来创建一个FileInputStream，该文件通过文件系统中的路径name指定
FileInputStream(String name)
常用方法：覆盖和重写了父类的的常用方法。
InputStream inputStream = new FileInputStream(new File("f://hello//test.txt"));
int i = 0;
while ((i = inputStream.read()) != -1) {
System.out.print((char) i + " ");
inputStream.close();
InputStream inputStream2 = new FileInputStream("f://hello/test.txt");
byte[] b = new byte[2];
int i2 = 0;
while ((i2 = inputStream2.read(b)) != -1) {
System.out.print(new String(b, 0, i2) + " ");
inputStream2.close();
注： 一次读取一个字节数组，提高了操作效率,IO流使用完毕一定要关闭。
2）.FileOutputStream
FileOutputStream：字节文件输出流是用于将数据写入到File，从程序中写入到其他位置。
构造方法：
// 创建一个向指定File对象表示的文件中写入数据的文件输出流
FileOutputStream(File file)
// 创建一个向指定File对象表示的文件中写入数据的文件输出流
FileOutputStream(File file, boolean append)
// 创建一个向具有指定名称的文件中写入数据的输出文件流
FileOutputStream(String name)
// 创建一个向具有指定name的文件中写入数据的输出文件流
FileOutputStream(String name, boolean append)
常用方法：覆盖和重写了父类的的常用方法。
OutputStream outputStream = new FileOutputStream(new File("test.txt"));
outputStream.write("ABCD".getBytes());
outputStream.close();
OutputStream outputStream2 = new FileOutputStream("test.txt", true);
outputStream2.write("\r\n".getBytes());
outputStream2.write("hello".getBytes());
outputStream2.close();
注；输出的目的地文件不存在，则会自动创建，不指定盘符的话，默认创建在项目目录下;输出换行符时一定要写\r\n不能只写\n,因为不同文本编辑器对换行符的识别存在差异性。
（3）.字节缓冲流（高效流）
1）.BufferedInputStream
BufferedInputStream：字节缓冲输入流，提高了读取效率。
构造方法：
// 创建一个 BufferedInputStream并保存其参数，即输入流in，以便将来使用。
BufferedInputStream(InputStream in)
// 创建具有指定缓冲区大小的 BufferedInputStream并保存其参数，即输入流in以便将来使用
BufferedInputStream(InputStream in, int size)
InputStream in = new FileInputStream("test.txt");
BufferedInputStream bis = new BufferedInputStream(in);
byte[] bs = new byte[20];
int len = 0;
while ((len = bis.read(bs)) != -1) {
System.out.print(new String(bs, 0, len));
bis.close();
2）.BufferedOutputStream
BufferedOutputStream：字节缓冲输出流，提高了写出效率。
构造方法：
// 创建一个新的缓冲输出流，以将数据写入指定的底层输出流
BufferedOutputStream(OutputStream out)
// 创建一个新的缓冲输出流，以将具有指定缓冲区大小的数据写入指定的底层输出流
BufferedOutputStream(OutputStream out, int size)
常用方法：
// 将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此缓冲的输出流
void write(byte[] b, int off, int len)
// 将指定的字节写入此缓冲的输出流
void write(int b)
// 刷新此缓冲的输出流
void flush()
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("test.txt", true));
bos.write("\r\n".getBytes());
bos.write("Hello Android".getBytes());
bos.flush();
bos.close();
（1）.字符流基类
1）.Reader
Reader:读取字符流的抽象类.
常用方法：
// 读取单个字符
int read()
// 将字符读入数组
int read(char[] cbuf)
// 将字符读入数组的某一部分
abstract int read(char[] cbuf, int off, int len)
// 跳过字符
long skip(long n)
// 关闭该流并释放与之关联的所有资源
abstract void close()
2）.Writer
Writer:写入字符流的抽象类.
常用方法：
// 写入字符数组
void write(char[] cbuf)
// 写入字符数组的某一部分
abstract void write(char[] cbuf, int off, int len)
// 写入单个字符
void write(int c)
// 写入字符串
void write(String str)
// 写入字符串的某一部分
void write(String str, int off, int len)
// 将指定字符添加到此 writer
Writer append(char c)
// 将指定字符序列添加到此 writer
Writer append(CharSequence csq)
// 将指定字符序列的子序列添加到此 writer.Appendable
Writer append(CharSequence csq, int start, int end)
// 关闭此流，但要先刷新它
abstract void close()
// 刷新该流的缓冲
abstract void flush()
（2）.字符转换流
1）.InputStreamReader
InputStreamReader：字节流转字符流，它使用的字符集可以由名称指定或显式给定，否则将接受平台默认的字符集。
构造方法：
// 创建一个使用默认字符集的 InputStreamReader
InputStreamReader(InputStream in)
// 创建使用给定字符集的 InputStreamReader
InputStreamReader(InputStream in, Charset cs)
// 创建使用给定字符集解码器的 InputStreamReader
InputStreamReader(InputStream in, CharsetDecoder dec)
// 创建使用指定字符集的 InputStreamReader
InputStreamReader(InputStream in, String charsetName)
特有方法：
//返回此流使用的字符编码的名称
String getEncoding()
InputStreamReader reader = new InputStreamReader(new FileInputStream("test.txt"));
while ((len = reader.read()) != -1) {
System.out.print((char) len);
reader.close();
InputStreamReader reader = new InputStreamReader(new FileInputStream("test.txt"),"utf-8");
while ((len = reader.read()) != -1) {
System.out.print((char) len);
reader.close();
注：Eclipse默认使用GBK编码,test.txt文件所以是GBK编码，当指定utf-8编码时所以会乱码。
2）.OutputStreamWriter
OutputStreamWriter：字节流转字符流。
构造方法：
// 创建使用默认字符编码的 OutputStreamWriter
OutputStreamWriter(OutputStream out)
// 创建使用给定字符集的 OutputStreamWriter
OutputStreamWriter(OutputStream out, Charset cs)
// 创建使用给定字符集编码器的 OutputStreamWriter
OutputStreamWriter(OutputStream out, CharsetEncoder enc)
// 创建使用指定字符集的 OutputStreamWriter
OutputStreamWriter(OutputStream out, String charsetName)
特有方法：
//返回此流使用的字符编码的名称
String getEncoding()
（3）.字符缓冲流（高效流）
1）.BufferedReader
BufferedReader：字符缓冲流，从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取。
构造方法：
// 创建一个使用默认大小输入缓冲区的缓冲字符输入流
BufferedReader(Reader in)
// 创建一个使用指定大小输入缓冲区的缓冲字符输入流
BufferedReader(Reader in, int sz)
特有方法：
// 读取一个文本行
String readLine()
BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream("test.txt")));
String str;
while ((str = reader.readLine()) != null) {
System.out.println(str);
reader.close();
2）.BufferedWriter
BufferedWriter：字符缓冲流，将文本写入字符输出流，缓冲各个字符，从而提供单个字符、数组和字符串的高效写入。
构造方法：
// 创建一个使用默认大小输出缓冲区的缓冲字符输出流
BufferedWriter(Writer out)
// 创建一个使用给定大小输出缓冲区的新缓冲字符输出流
BufferedWriter(Writer out, int sz)
特有方法：
// 写入一个行分隔符
void newLine()
（4）.FileReader、FileWriter
FileReader：InputStreamReader类的直接子类，用来读取字符文件的便捷类，使用默认字符编码。
FileWriter：OutputStreamWriter类的直接子类，用来写入字符文件的便捷类，使用默认字符编码。
5.高效流效率比对
读取f盘下的一个视频文件到项目中：文件大小29.5 MB
读取方式一：
FileInputStream inputStream = new FileInputStream("f://滑板//HEEL_FLIP.mp4");
FileOutputStream outputStream = new FileOutputStream("HEEL_FLIP.mp4");
long begin = System.currentTimeMillis();
while ((len = inputStream.read()) != -1) {
outputStream.write(len);
System.out.println(System.currentTimeMillis() - begin);
inputStream.close();
outputStream.close();
读取方式二：
FileInputStream inputStream = new FileInputStream("f://滑板//HEEL_FLIP.mp4");
FileOutputStream outputStream = new FileOutputStream("HEEL_FLIP.mp4");
byte[] bs = new byte[1024];
long begin = System.currentTimeMillis();
while ((len = inputStream.read(bs)) != -1) {
outputStream.write(bs, 0, len);
System.out.println(System.currentTimeMillis() - begin);
inputStream.close();
outputStream.close();
读取方式三：
FileInputStream inputStream = new FileInputStream("f://滑板//HEEL_FLIP.mp4");
BufferedInputStream bis = new BufferedInputStream(inputStream);
FileOutputStream outputStream = new FileOutputStream("HEEL_FLIP.mp4");
BufferedOutputStream bos = new BufferedOutputStream(outputStream);
byte[] bs = new byte[1024];
long begin = System.currentTimeMillis();
while ((len = bis.read(bs)) != -1) {
bos.write(bs, 0, len);
System.out.println(System.currentTimeMillis() - begin);
bis.close();
bos.close();
注：由此可以看出高效缓冲流读写速度是非常快的，建议使用。
更多方法查看API
没有更多推荐了，
加入CSDN，享受更精准的内容推荐，与500万程序员共同成长！