1.字符输出流
字符输出流---Writer类---抽象类---不能new---子类
1.1 FileWriter类
（1）构造方法：
FileWriter(File file)
FileWriter(File file, boolean append)
FileWriter(String fileName)
FileWriter(String fileName, boolean append)给一个String对象构造一个是否允许追加FileWriter对象。例：
import java.io.File;
import java.io.FileWriter;
import java.io.Writer;
public class FileWriteTest1 {
public static void main(String[] args) throws Exception {
//FileWriter(File file) 给一个File对象构造一个FileWriter对象
String pathname1="E:"+File.separator+"mytest"+File.separator+"test1.txt";
File file1=new File(pathname1);
FileWriter filewriter1=new FileWriter(file1);
Writer filewriter11=new FileWriter(file1);//或者上转型
//FileWriter(File file, boolean append) 给一个File对象构造一个是否允许追加FileWriter对象。
String pathname2="E:"+File.separator+"mytest"+File.separator+"test1.txt";
File file2=new File(pathname2);
FileWriter filewriter2=new FileWriter(file2,true);
Writer filewriter22=new FileWriter(file2,true);//或者上转型
//FileWriter(String fileName) 给一个String对象构造一个FileWriter对象
String pathname3="E:"+File.separator+"mytest"+File.separator+"test1.txt";
FileWriter filewriter3=new FileWriter(pathname3);
Writer filewriter33=new FileWriter(pathname3);//或者上转型
//FileWriter(String fileName, boolean append)给一个String对象构造一个是否允许追加FileWriter对象
String pathname4="E:"+File.separator+"mytest"+File.separator+"test1.txt";
FileWriter filewriter4=new FileWriter(pathname4,true);
Writer filewriter44=new FileWriter(pathname4,true);//或者上转型
}
}（2）实例方法：
void write(char[] cbuf) 写入一个字符数组。
void write(char[] cbuf, int off, int len) 写入字符数组的一部分。
void write(int c) 写一个字符
void write(String str) 写一个字符串
void write(String str, int off, int len) 写一个字符串的一部分。
void close() 关闭流，先刷新。
void flush() 刷新流。例：
import java.io.File;
import java.io.FileWriter;
import java.io.Writer;
public class FileWriteTest2 {
public static void main(String[] args) throws Exception {
//FileWriter(File file) 给一个File对象构造一个FileWriter对象
String pathname1="E:"+File.separator+"test"+File.separator+"test1.txt";
File file1=new File(pathname1);
FileWriter filewriter1=new FileWriter(file1);
//void write(char[] cbuf) 写入一个字符数组。
/*
* String info="hello,world";
char ch1[]=info.toCharArray();
filewriter1.write(ch1);
filewriter1.flush();
filewriter1.close();
*/
//void write(char[] cbuf, int off, int len) 写入字符数组的一部分。
/*
String info="hello,world";
char ch1[]=info.toCharArray();
filewriter1.write(ch1, 2, 8);//llo,wor
filewriter1.flush();
filewriter1.close();
*/
//void write(String str) 写一个字符串
String info="hello,world";
filewriter1.write(info);
//void write(String str, int off, int len) 写一个字符串的一部分。
filewriter1.write(info, 0, 4);
//void write(int c) 写一个字符
filewriter1.write(97); //a
//写出hello，world
char ch[]=info.toCharArray();
for(char c:ch){
filewriter1.write(c);
}
filewriter1.flush();
filewriter1.close();
}
}1.2 BufferedWriter类
（1）构造方法：
BufferedWriter(Writer out)通过字符输出流的对象创建BufferedWriter
（2）实例方法：
void write(char[] cbuf, int off, int len) 写入字符数组的一部分。
void write(int c) 写一个字符
void write(String s, int off, int len) 写一个字符串的一部分。
void close() 关闭流，先刷新。
void flush() 刷新流。多一个
void newLine() 写一行行分隔符，跳转到下一行。
例：
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
public class BufferedWriterTest {
public static void main(String[] args) throws Exception{
//BufferedWriter(Writer out)通过字符输出流的对象创建BufferedWriter
String pathname1="E:"+File.separator+"test"+File.separator+"test2.txt";
File file1=new File(pathname1);
FileWriter fileWriter = new FileWriter(file1,true);
BufferedWriter buffeinput=new BufferedWriter(fileWriter);
/*
* 和FileWriter都一样
//void write(char[] cbuf, int off, int len) 写入字符数组的一部分。
//void write(int c) 写一个字符
//void write(String s) 写一个字符串
//void write(String s, int off, int len) 写一个字符串的一部分。
//void close() 关闭流，先刷新。
//void flush() 刷新流。
*/
//void newLine() 写一行行分隔符，跳转到下一行。
String str1="hello,zhangsan";
buffeinput.write(str1);
buffeinput.newLine();
String str2="hello,lisi ";
buffeinput.write(str2);
buffeinput.flush();
buffeinput.close();
}
}1.3 OutputStreamWriter类
（1）构造方法：
OutputStreamWriter(OutputStream out)将字节输出流转换成字符输出流
例：
import java.io.File;
import java.io.FileOutputStream;
import java.io.OutputStreamWriter;
public class OutputStreamWriterTest {
public static void main(String[] args) throws Exception {
//之前我们需要向文件写出一个字符串数据，使用字节输出流，需要将字符串数据转换成字节数组
/*
String pathname1="E:"+File.separator+"test"+File.separator+"test3.txt";
File file1=new File(pathname1);
FileOutputStream fileOutputStream = new FileOutputStream (file1);
String info="hello,world";
fileOutputStream.write(info.getBytes());
fileOutputStream.close();
*/
//将字节输出流转换成字符输出流，好一次性直接写出字符串
String pathname1="E:"+File.separator+"test"+File.separator+"test3.txt";
File file1=new File(pathname1);
FileOutputStream fileOutputStream = new FileOutputStream (file1);
OutputStreamWriter out=new OutputStreamWriter(fileOutputStream);
String info="hello,world";
out.write(info);
out.close();
fileOutputStream.close();
}
}2.字符输入流
字符输入流---Reader类---抽象类---不能new---子类
2.1 FlieReader类
（1）构造方法：
FileReader(File file) 给一个File对象构造一个FileReader对象。
FileReader(String fileName)
（2）实例方法：
int read() 读一个字符。返回值是读取的真实字符数据的整数值，如果已经达到流的末尾，则为-1
int read(char[] cbuf) 将字符读入数组。返回总字符数，如果到达文件末尾返回-1
void close()
例：
import java.io.File;
import java.io.FileReader;
public class FileReaderTest {
public static void main(String[] args) throws Exception {
//构造方法
//FileReader(File file) 给一个File对象构造一个FileReader对象。
String pathname1="E:"+File.separator+"test"+File.separator+"test1.txt";
File file1=new File(pathname1);
FileReader fileReader1 = new FileReader(file1);
//FileReader(String fileName) 给一个String对象构造一个FileReader对象。
FileReader fileReader2 = new FileReader(pathname1);
//实例方法
//int read() 读一个字符。返回值是读取的真实字符数据的整数值，如果已经达到流的末尾，则为-1
//int readnumber=fileReader1.read();
//System.out.println((char)readnumber);
//循环读出所有的
/*
int num=0;//定义保存数据的变量
char ch2[]=new char[(int) file1.length()];
int index=0;
while((num=fileReader1.read())!=-1){
ch2[index]=(char)num;
index++;
}
String str=new String(ch2);
System.out.println(str);
*/
//int read(char[] cbuf) 将字符读入数组。返回总字符数，如果到达文件末尾返回-1
char ch3[]=new char[(int)file1.length()];
int len=fileReader1.read(ch3);
String str1=new String(ch3,0,len);
System.out.println(str1);
//void close() 关闭流并释放与之相关联的任何系统资源。
fileReader1.close();
}
}2.2 BufferedReader类
（1）构造方法：
BufferedReader(Reader in)通过字符输入流对象创建一个BufferedReader
（2）实例方法：
int read()
nt read(char[] cbuf)
void close() 关闭流并释放与之相关联的任何系统资源。
String readLine() 读一行文字。例：
import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.Reader;
public class BufferedReaderTest {
public static void main(String[] args) throws Exception{
//BufferedReader(Reader in)通过字符输入流对象创建一个BufferedReader
String pathname1="E:"+File.separator+"test"+File.separator+"test2.txt";
File file1=new File(pathname1);
Reader reader=new FileReader(file1);
BufferedReader bufferedReader = new BufferedReader(reader);
//int read() 读一个字符。返回值是读取的真实字符数据的整数值，如果已经达到流的末尾，则为-1。
//int read = bufferedReader.read();
//System.out.println((char)read);
//读全部遍历
/*
int num=0;
int index=0;
char ch1[]=new char[(int)file1.length()];
while((num=bufferedReader.read())!=-1){
ch1[index]=(char)num;
index++;
}
String str1=new String(ch1);
System.out.println(str1);
*/
//int read(char[] cbuf) 将字符读入数组。返回总字符数，如果到达文件末尾返回-1
//String readLine() 读一行文字。
//这个就更快
String info=null;
while((info=bufferedReader.readLine())!=null){
System.out.println(info);
}
//void close() 关闭流并释放与之相关联的任何系统资源。
bufferedReader.close();
reader.close();
}
}2.3 InputStreamReader类【字节输入流转成字符输入流】
BufferedReader 类中的readLine()方法和 Scanner类中的nextLine()方法都可以读一行数据，不同的是readLine()从文件中读取取，nextLine()从键盘输入中读取。
那我们能不能通过BufferedReader读取键盘输入的数据？？？？？Scanner的nextLine()方法为什么可以读取键盘输入？？？？因为Scanner对象在创建的时候使用了System.in,System.in默认就是键盘输入。
所以只要在创建BufferedReader对象的时候，使用System.in就可以完成键盘输入。System.in是InputStream类型字节输入流，而BufferedReader(Reader in)参数是Reader字符输入流。
解决问题的关键就是将InputStream类型字节输入流转换成Reader字符输入流。InputStreamReader类解决此问题。
构造方法：
InputStreamReader(InputStream in)字节输入流转成字符输入流。
例：
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class InputStreamReaderTest {
//字节输入流转成字符输入流
public static void main(String[] args) throws Exception {
InputStreamReader inputStreamReader = new InputStreamReader(System.in);
BufferedReader bufferedReader = new BufferedReader(inputStreamReader);
System.out.println("请输入姓名：");
String name=bufferedReader.readLine();//键盘输入
System.out.println("name==="+name);
bufferedReader.close();
inputStreamReader.close();
}
}3.补充字节流----序列化和反序列化
3.1 序列化定义
我们做操作的java对象可能需要在多台计算机之间传递。
序列化------将一个java对象转换成二进制流数据过程。
3.2 如何实现序列化
序列化接口【Serializable】。
public interface Serializable
特殊----该接口中一个方法都没有。
类的序列化由实现java.io.Serializable接口的类启用。
不实现此接口的类将不会使任何状态序列化或反序列化。
可序列化类的所有子类型都是可序列化的。
（2）通过java提供的ObjectOutputStream类的writeObject(Object obj)。
构造方法：
ObjectOutputStream(OutputStream out) 创建一个写入指定的OutputStream的ObjectOutputStream。
实例方法：
void writeObject(Object obj) 将指定的对象写入ObjectOutputStream。
例：
import java.io.Serializable;
public class Student implements Serializable {
public void getStudent(){
System.out.println("Student类的实例方法");
}
}
import java.io.File;
import java.io.FileOutputStream;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
public class ObjectOutputStreamTest {
public static void main(String[] args) throws Exception{
//ObjectOutputStream(OutputStream out) 创建一个写入指定的OutputStream的ObjectOutputStream。
String pathname1="E:"+File.separator+"test"+File.separator+"Student.txt";
File file1=new File(pathname1);
OutputStream outputStream = new FileOutputStream(file1);
ObjectOutputStream objectOutputStream = new ObjectOutputStream(outputStream);
//void writeObject(Object obj) 将指定的对象写入ObjectOutputStream。
Student student=new Student();
objectOutputStream.writeObject(student);
objectOutputStream.close();
outputStream.close();
}
}3.3 反序列化
当计算机a收到计算机b传过来的对象，计算机a现在需要拿这个对象的话，需要反序列化回去。
反序列化---将2进制流数据转换成java对象的过程。
ObjectInputStream类的Object readObject()方法读取对象。
构造方法：
ObjectInputStream(InputStream in) 创建从指定的InputStream读取的ObjectInputStream。
实例方法：
Object readObject() 从ObjectInputStream读取一个对象。
例：
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;
import java.io.ObjectInputStream;
public class ObjectInputStreamTest {
public static void main(String[] args) throws Exception{
// ObjectInputStream(InputStream in) 创建从指定的InputStream读取的ObjectInputStream。
String pathname1="E:"+File.separator+"test"+File.separator+"Student.txt";
File file1=new File(pathname1);
InputStream in=new FileInputStream(file1);
ObjectInputStream in1=new ObjectInputStream(in);
// Object readObject() 从ObjectInputStream读取一个对象。
Object readObject = in1.readObject();
Student student=(Student)readObject;
in1.close();
in.close();
//如果现在可以调用student里面的实例方法，证明反序列化成功
student.getStudent();//Student类的实例方法
}
}4.输入输出流思维导图
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
