目录
缓冲流
原理
缓冲流在输入输出时先将输入输出数据存储在缓冲区中，再将缓冲区的数据输入或输出文档。
字节缓冲输出流
BufferedOutputStream extends FileOutputStream:字节缓冲输出流
继承来的方法：
close()
write(byte[] b)
write(byte[] b,int off,int len)
write(int b)
构造方法：
BufferedOutputStream(OutputStream out):创建一个BufferedOutputStream对象
BufferedOutputStream(OutputStream out,int size):创建一个BufferedOutputStream对象，并且可用size指定缓冲区的大小
使用步骤：
1.创建FileOutputStream对象
2.创建BufferedOutPutStream对象，构造方法可以传递FileOutputStream对象
3.使用write方法，将数据写入缓冲区
4.使用flush将内部缓冲区的数据刷新到文件
5.释放资源
FileOutputStream fos=new FileOutputStream("day10\\a.txt");
BufferedOutputStream bos=new BufferedOutputStream(fos);
bos.write("我把数据写入到内存缓冲区中".getBytes());
bos.flush();
bos.close();字节缓冲输入流
BufferedInputStream extends FileInputStream
继承的成员方法：
read()
read(byte[] b)
close()
构造方法：
BufferedInputStream(InputStream in):创建一个BufferedInputStream对象
BufferedInputStream(InputStream in，int size):创建一个BufferedInputStream对象，可以自行规定缓冲区大小
使用步骤：
1.创建字节输入流FileInputStream对象
2.创建缓冲流对象，构造方法传入FileInputStream对象
3.使用read方法，读取文件
4.释放资源
//创建字节输入流
FileInputStream fis=new FileInputStream("day10\\a.txt");
//创建字节缓冲输入流
BufferedInputStream bis = new BufferedInputStream(fis);
//使用read方法读取字节
byte[] bytes=new byte[1024];
int len=0;
while((len=bis.read(bytes))!=-1)
{
System.out.print(new String(bytes,0,len));
}
bis.close();字符缓冲输入流
BufferedReader extends Reader
继承方法：
read() 读取单个字符
read(char[] cbuf) 读取字符数组
close() 释放资源
构造方法：
BufferedReader(Reader in):创建一个BufferedReader字符缓冲输入流
BuffererReader(Reader in,int size):创建一个使用指定大小的BufferedReader字符缓冲输入流
特有成员方法：
String readLine():读取一行文本行，返回字符串类型
使用步骤：
1.创建字符缓冲输入流
2.使用read/readLine()对对象进行输入
3.释放资源
//创建
BufferedReader br=new BufferedReader(new FileReader("day10\\c.txt"));
//读取
String line=br.readLine();
//System.out.println(line);
while((line=br.readLine())!=null){
System.out.println(line);
}
//释放资源
br.close();字符缓冲输出流
BufferedWriter extends Write:字符缓冲输出流
继承来的成员方法：
write(int c)
write(char[] cbuf)
write(char[] cbuf,int off,int len)
write(String str)
write(String str,int off,int len)
flush()
close()
构造方法：
BufferedWriter(Writer out) 创建一个字符输出流
BufferedWrite(Write out,int size) 创建一个指定缓冲区大小的字符输出流
特有成员方法：
newLine() 写入一个行分隔符，根据不同系统获得不同分隔符
使用步骤：
1.创建关键字符缓冲输出流
2.调用字符缓冲输出流中的write方法
3.调用flush方法，刷新内存
4.释放资源
BufferedWriter bw=new BufferedWriter(new FileWriter("day10\\c.txt"));
for(int i=0;i<10;i++)
{
bw.write("郝宜文");
bw.newLine();
}
bw.close();练习：
题目：将顺序打乱的诸葛亮出师表的内容进行排列
HashMap<String,String> map=new HashMap<>();
BufferedReader br=new BufferedReader(new FileReader("day10\\in.txt"));
BufferedWriter bw=new BufferedWriter(new FileWriter("day10\\out.txt"));
String line;
while((line=br.readLine())!=null)
{
String[] arr = line.split("\\.");
map.put(arr[0],arr[1]); //map集合会自动排序
}
//遍历
for (String key : map.keySet()) {
String value=map.get(key);
line=key+"."+value;
bw.write(line);
bw.newLine();
}
bw.close();
br.close();转换流
原理：
世界上存在大量的编码方式，不同编码方式的输入输出可能导致文件乱码，为解决这一问题引入转换流概念。
InputStreamReader类
InputStreamReader extends Writer :看不懂的-->看得懂的
继承父类的共性方法：
read() read(char[] cbuf) close
构造方法：
InputStreamReader(InputStream in) 读取文件中的字节
InputStreamReader(InputStream in,String charsetName) 读取文件中的字节，还有编码表的名称
使用步骤:
1.创建对象，构造方法中传入字节输入流和指定的编码名称
2.使用read方法，读取文件
3.使用完释放流
InputStreamReader isr = new InputStreamReader(new FileInputStream("day10\\GBK.txt"),"GBK");
int len=0;
while((len=isr.read())!=-1)
{
System.out.println((char)len);
}
isr.close();OutputStreamReader类
OutputStreamReader extends Writer :看的懂的-->看不懂的
继承父类的共性方法：
write（int c) write(char[] cbuf) write(char[] cbuf,int off,int len) write(String str)
构造方法：
OutputStreamReader(OutputStream in) 创建输出文件中的字节流
OutputStreamReader(OutputStream in,String charsetName) 输出文件中的字节流，还有指定编码表的名称
使用步骤：
1.创建OutputStream对象，构造方法传递字节输出流和指定编码
2.创建write方法，将字符转换为字节存储子啊缓冲区
3.使用flush刷新
4.释放资源
//创建对象
OutputStreamWriter osw=new OutputStreamWriter(new FileOutputStream("day10\\GBK.txt"),"GBK");
//使用writer方法
osw.write("你好");
osw.close();练习将GBK文本转换为utf-8
InputStreamReader isr=new InputStreamReader(new FileInputStream("day10\\我是GBK格式的文本.txt"),"gbk");
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("day10\\我是utf_8文件.txt"), "utf-8");
int len=0;
while((len=isr.read())!=-1){
osw.write(len);
}
osw.close();
isr.close();对象的序列化
概述：
Person类对象
序列化和反序列化时，会抛出没有序列化和反序列化异常
通过实现Serlizable接口实现序列化宫嗯那个，为实现此接口有无法进行序列化
public class Person implements Serializable{
private final long serialVersionUID =42L;
private String name;
private int age;
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public Person() {
}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
}对象的序列化
ObjectOutputStream:对象的序列化，将对象以序列化流的方式保存到文件中
构造方法：
ObjectOutStream(OutputStream out)创建对象
成员特有的方法：
writeObject(Object obj) 写对象、
使用方法：
1.创建对象ObjectOutputStream对象，构建字节输出流
2.使用writeObject()方法写对象
3.资源释放
ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream("day10\\person.txt"));
oos.writeObject(new Person("小美女",18));
oos.close();对象的反序列化
ObjectInputStream:对象的反序列化，将对象以流的方式读取出来
构造方法：
ObjecInStream(InputStream out)创建对象
成员特有的方法：
readObject(Object obj) 写对象、
使用方法：
1.创建对象ObjectInputStream对象，构建字节输出流
2.使用readObject()方法写对象
3.资源释放
4.使用读取对象
ObjectInputStream iis=new ObjectInputStream(new FileInputStream("day10\\person.txt"));
Object obj=iis.readObject();
iis.close();
System.out.println(obj.toString());
Person p=(Person)obj;
System.out.println(p.getName()+p.getAge());打印流
打印流的特点：
1.只负责数据的输出，不负责打印
2.PrintStream永远不会抛出IO异常
3.特有方法：print，printf
输出任意类型的值，一个不换行一个换行
PrintStream ps=new PrintStream("day10\\print.txt");
ps.write(97);
ps.print(97);
ps.print(97);
//释放资源
ps.close();改变输出语句目的地
使用setOut方法进行输出语句目的地的改变
System.out.println("我是在控制台输出");
PrintStream printStream=new PrintStream("day10\\目的地时打印流.txt");
System.setOut(printStream);
System.out.println("我在打印流的目的地输出");
printStream.close();
527
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
