一、缓冲流

1、概述

  • 比普通流更强大的IO流,可以增加读写的效率
  • 组成
    • 缓冲输入流:BufferedInputStream、BufferedReader
    • 缓冲输出流:BufferedOutputStream、BufferedWriter

1、字节缓冲输出流(构造传递具体输出流)

  • BufferedOutputStream
public class Demo01BufferOutputStream {
public static void main(String[] args) throws IOException {
//1.创建FileOutputStream对象,构造方法中绑定输出的目的地
FileOutputStream fos=new FileOutputStream("src\\com\\liujinhui\\Day1107BufferStream\\a.txt");
//2.创建BufferedOutputStream对象,构造方法中传递FileOutputStream对象,提高FileOutputStream对象效率
BufferedOutputStream bos=new BufferedOutputStream(fos);
//3.使用BufferedOutputStream对象中的方法write,把数据写入到内部缓冲区中
bos.write("我把数据写入到内部缓冲区中".getBytes());
bos.flush();
bos.close();
}
}

2、字节缓冲输入流

  • BufferedInputStream
public class Demo02BufferedInputStream {
public static void main(String[] args) throws IOException {
//1.创建FileInputStream对象,构造方法中绑定要读取的数据源
FileInputStream fis=new FileInputStream("src\\com\\liujinhui\\Day1107BufferStream\\a.txt");
//2.创建BufferedInputStream对象,构造方法中传递FileInputStream对象,提高FileInputStream对象的读取效率
BufferedInputStream bis=new BufferedInputStream(fis);
//3.使用BufferedInputStream对象中的read方法,读取文件
//int read()从输入流中读取数据的下一个字节
/*int len=0;//记录每次读取到的字节
while((len=bis.read())!=-1){
System.out.println(len);
}*/
//int read(byte[] b)
byte[] bytes=new byte[1024];//数组长度表示一次能读取的最大字节数
int len=0;//每次读取的有效字节个数
while((len=bis.read(bytes))!=-1){
System.out.println(new String(bytes,0,len));
}
bis.close();
}
}
  • 效率测试

    • 缓冲流+数组>缓冲流+单字节>普通流+数组>普通流+单字节

4、字符缓冲输出流

  • BufferedWriter
public class Demo04BufferedWriter {
public static void main(String[] args) throws IOException {
//1.创建字符缓冲输出流对象,构造方法中传递字符输出流
BufferedWriter bw=new BufferedWriter(new FileWriter("src\\com\\liujinhui\\Day1107BufferStream\\d.txt"));
//2.调用字符缓冲输出流中的方法write,把数据写入到内存缓冲区中
for (int i=0;i<10;i++){
bw.write("传智播客");
bw.newLine();
bw.write("\n\r");
//sout调用的方法就是newLine
}
//3.调用字符缓冲输出流中的方法flush,把内存缓冲区的数据刷新到文件中
bw.flush();
//4.释放资源
bw.close(); }
}

5、字符缓冲输入流

  • BufferedReader
public class Demo05BufferedReader {
public static void main(String[] args) throws IOException {
//1.创建字符缓冲输入流对象BufferedReader,构造方法中传递字符输入流
BufferedReader br=new BufferedReader(new FileReader("src\\com\\liujinhui\\Day1107BufferStream\\d.txt"));
//2.使用字符输入流对象中的方法read和readLine读取文本
String line;
while((line=br.readLine())!=null){
System.out.println(line);
}
//3.释放资源
br.close();
}
}

6、练习:对文本的内容进行排序

  • HashMap会自动按照键的顺序进行排序
public class Demo06TestSort {
public static void main(String[] args) throws IOException {
//1.创建一个HashMap集合对象,可以存储每行文本的学号,value存储每行的文本
HashMap<String,String> map=new HashMap<>();//【HashMap输入数据后会自动排序】
//2.创建字符缓冲输入流对象,构造方法中绑定字符输入流
BufferedReader br=new BufferedReader(new FileReader("src\\com\\liujinhui\\Day1107BufferStream\\in.txt"));
//3.创建字符缓冲输出流对象,构造方法中绑定字符输出流
BufferedWriter bw=new BufferedWriter(new FileWriter("src\\com\\liujinhui\\Day1107BufferStream\\out.txt"));
//4.使用字符缓冲输入流中的方法readline,逐行读取文本
String line;
while((line=br.readLine())!=null){
//5.对读取到的文本进行切割,获取行中的序号和文本内容
String[] arr=line.split("\\.");//转义字符
//6.将切割好的序号和文本中的内容存储到HashMap集合中(key是有序的,会自动排序)
map.put(arr[0],arr[1]);
}
//7.遍历HashMap集合,获取每一个键值对
for (String key:map.keySet()){
String value = map.get(key);
//8.将每一个键值对,转换为一个文本行
line= key +"."+ value;
//9.将拼接好的文本,使用字符缓冲输出流中的方法write,写入到文件中
bw.write(line);
bw.newLine();//写的时候不会把换行符写进去
}
//10.释放资源
bw.close();
br.close();
}
}

二、转换流

1、字符编码和字符集

  • 字符编码

    • 编码:字符按规则存储为二进制数
    • 解码:将二进制数按规则解析显示
  • 编码表:文字与二进制的对应规则
  • 字符集Charset(编码表)
    • ASCII
    • GBK字符集:双字节编码
    • Unicode字符集(UTF-8等):中文3个字节编码

2、编解码引出的问题

  • IDEA默认以UTF-8编码,而windows默认为GBK编码
  • 转换流的原理
    • 包括转换输入流InputStreamReader和转换输出流OutputStreamWriter

    • 字符输入流FileReader先通过FileInputStream读入默认编码的二进制码,再通过字符输入流FileReader查询默认编码表,将其解码为对应的字符,放至内存
    • 字符输出流FileWriter先通过FileOutputStream查询默认码表,将字符转换为二进制编码字节,再通过字符输出流FileWriter将其解码为对应的字符,存入硬盘
    • 转换输入流InputStreamReader先通过FileInputStream读入默认编码的二进制码,再通过转换流InputStreamReader按指定的编码表解码为对应的字符,放至内存
    • 转换输出流OutputStreamWriter先通过FileOutputStream查询指定的编码表,将字符编码为对应的二进制字节,在通过字符输出流FileWriter将其解码为对应的字符,存入硬盘

3、OutputStreamWriter

  • 是Writer的子类
    /*
使用转换流OutputStreamWriter写UTF-8格式的文件
* */
private static void write_utf_8() throws IOException {
//1、创建一个OutputStreamWriter对象,构造方法中传递字节输出流和指定的编码表名【默认是UTF-8格式编码】6字节
OutputStreamWriter osw =new OutputStreamWriter(new FileOutputStream("src\\com\\liujinhui\\Day1107BufferStream\\utf_8.txt"),"utf-8");
//2、使用OutputStreamWriter对象中的方法write,将字符转换为字节存储缓冲区中【编码】
osw.write("你好");
//3、使用OutputStreamWriter对象中的方法flush,把内存缓冲区中的字节刷新到文件中(使用字节流写字节的过程)
osw.flush();
//4、释放资源
osw.close();
}

4、InputStreamReader

  • 是Reader的子类
    /*
使用InputStreamReader读取UTF-8格式的文件
* */
private static void read_utf_8() throws IOException {
//1、创建InputStreamReader对象,构造方法中传递字节输入流和指定的字节编码表名称,默认就是UTF-8,可以不指定
InputStreamReader isr =new InputStreamReader(new FileInputStream("src\\com\\liujinhui\\Day1107BufferStream\\utf_8.txt"),"utf-8");
//2、使用InputStreamReader对象中的方法read读取文件
int len=0;
while((len=isr.read())!=-1){
System.out.print((char)len);
}
//3、释放资源
isr.close();
}

5、练习:转换文件编码(GBK转UTF-8)

public class Demo10Practice {
public static void main(String[] args) throws IOException {
//1.创建InputStreamReader对象,构造方法中传递字节输入流和指定的编码表名称GBK
InputStreamReader isr =new InputStreamReader(new FileInputStream("src\\com\\liujinhui\\Day1107BufferStream\\gbk.txt"),"gbk");
//2.创建OutputStreamWriter对象,构造方法中传递字节输出流和指定的编码表名称UTF-8
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("src\\com\\liujinhui\\Day1107BufferStream\\utf8.txt"),"utf-8");
//3.使用InputStreamReader对象中的方法read读取文件
int len=0;
while((len=isr.read())!=-1){
//4.使用OutputStreamWriter对象中的方法write,把读取的数据写入到文件中
osw.write(len);
}
//5.释放资源
osw.close();
isr.close();
}
}

三、序列化

1、概述

  • 序列化:将对象写入到硬盘,以流的方式,名称为ObjectOutputStream.writeObject()

  • 反序列化:从硬盘中读取对象,流名称为ObjectInputStream.readObject(),返回给Object类型对象

2、序列化流ObjectOutputStream

public class Demo11ObjectOutputStream {
public static void main(String[] args) throws IOException {
//1.创建一个ObjectOutputStream对象,构造方法中传递字节输出流
ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream("src\\com\\liujinhui\\Day1107BufferStream\\person.txt"));
//2.调用ObjectOutputStream对象中的方法writeObject(),把对象写入到文件中
oos.writeObject(new Person("小美女",18));
//抛出NotSerializableException异常/未被序列化异常
/*
* java.io.NotSerializableException 当实例需要具有序列化接口时,抛出此异常。序列化运行时或实例的类会抛出此异常。
* Serializable为序列化接口,类通过实现 java.io.Serializable 接口以启用其序列化功能。未实现此接口的类将无法使其任何状态序列化或反序列化。
* */
//3.释放资源
oos.close();
}
}

3、反序列化流ObjectInputStream

public class Demo12ObjectInputStream {
public static void main(String[] args) throws IOException ,ClassNotFoundException {
//1、创建一个ObjectInputStream对象,构造方法中传递字节输入流
ObjectInputStream ois =new ObjectInputStream(new FileInputStream("src\\com\\liujinhui\\Day1107BufferStream\\person.txt"));
//2、使用ObjectInputStream对象中的方法readObject,读取保存对象的文件
Person p = (Person)ois.readObject();//不转型也可以
//readObject方法声明抛出了ClassNotFoundException(.class文件找不到异常)
//当不存在对象的class文件时,抛出此异常
//反序列化的前提:
//1.类必须事先Serializable接口
//2.必须存在类对应的class 文件
//3、释放资源
ois.close();
//4、使用读取出来的对象
System.out.println(p);
}
}

4、瞬态关键字

  • transient关键字修饰的成员变量,不能被序列化。序列化再反序列化后输出的是默认值0
  • static优先于非静态,被static修饰的成员变量不能被序列化,能序列化的都是对象

5、InvalidClassException

  • 原因:序列化后,class文件发生了修改,反序列化就会失败
  • 解决方式:显式声明serialVersionUID字段
public class Person implements Serializable {
private static final long serialVersionUID = 1L;
public String name;
// private int age;
private transient int age;
public Person() {
}
public Person(String name, int age) {
this.name = name;
this.age = age;
}

6、练习:序列化集合

public class Demo13SeriSet {
public static void main(String[] args) throws IOException, ClassNotFoundException {
//1、定义一个存储Person对象的ArrayList集合
ArrayList<Person> list=new ArrayList<>();
//2、在ArrayList集合中存储Person对象
list.add(new Person("张三",13));
list.add(new Person("李四",14));
list.add(new Person("王五",15));
//3、创建一个序列化流ObjectOutputStream对象
ObjectOutputStream oos =new ObjectOutputStream(new FileOutputStream("src\\com\\liujinhui\\Day1107BufferStream\\person.txt"));
//4、使用ObjectOutputStream对象中的方法writeObject,对集合进行序列化
oos.writeObject(list);
//5、创建一个反序列化ObjectInputStream对象
ObjectInputStream ois =new ObjectInputStream(new FileInputStream("src\\com\\liujinhui\\Day1107BufferStream\\person.txt"));
//6、使用ObjectInputStream对象中的方法readObject读取文件中保存的集合
Object o = ois.readObject();
//7、把Object类型的集合转换为ArrayList类型
ArrayList<Person> list2=(ArrayList<Person>)o;
//8、遍历ArrayList集合
for (Person p : list2) {
System.out.println(p);
}
//9、释放资源
ois.close();
oos.close();
}
}

四、打印流

1、默认打印到文件

public class Demo14PrintStream {
public static void main(String[] args) throws FileNotFoundException {
System.out.println("helloWorld");
//out就是一个打印流printStream
//print和println是打印流的方法
//创建打印流PrintStream对象,构造方法中绑定要输出的目的地
PrintStream ps=new PrintStream("c:\\a.txt");
//如果使用继承自父类的write方法写数据,查看数据的时候会查询编码表 97-->a
ps.write(97);
ps.println(97);
ps.println(8.8);
ps.println("aaa");
ps.println(true);
ps.println(2L);
//释放资源
ps.close();
}
}

2、改变输出流的目的地(打印到文件)

  • System.setOut(PrintStream)改变输出语句的目的地,重新分配标准输出流
public class Demo15PrintStream {
public static void main(String[] args) throws FileNotFoundException {
System.out.println("我在控制台输出");
PrintStream ps =new PrintStream("C:\\a.txt");
System.setOut(ps);
System.out.println("我在打印流的目的地中输出");
ps.close();
}
}

【Java SE进阶】Day10 缓冲流、转换流、序列化流 、打印流的更多相关文章

  1. Java自学第10期——File类与IO流(输入输出流、处理流、转换流、缓冲流、Properties集合、打印流)

    1.IO简介 IO(输入输出)通过java.io包下的类和接口来支持,包下包括输入.输出两种IO流,每种输入输出流又可分为字符流和字节流两大类. 2.File类 File类是io包下与平台无关的文件和 ...

  2. Java基础---IO(二)--File类、Properties类、打印流、序列流(合并流)

    第一讲     File类 一.概述 1.File类:文件和目录路径名的抽象表现形式 2.特点: 1)用来将文件或文件夹封装成对象 2)方便于对文件与文件夹的属性信息进行操作 3)File类的实例是不 ...

  3. Java基础---Java---IO流-----对象的序列化、管道流、RandomAccessFile、数据类型的流对象DataStream、ByteArrayStream

    ObjectInputStream 对以前使用 ObjectOutputStream 写入的基本数据和对象进行反序列化. ObjectOutputStream 和 ObjectInputStream ...

  4. JAVA基础学习day22--IO流四-对象序列化、管道流、RandomAccessFile、DataStream、ByteArrayStream、转换流的字符编码

    一.对象序列化 1.1.对象序列化 被操作的对象需要实现Serializable接口 1.2.对象序列化流ObjectOutputStream与ObjectInputStream ObjectInpu ...

  5. Java SE学习之printf 日期转换符

    本文是学习网络上的文章时的总结,感谢大家无私的分享. System.out.printf()方法能够对日期做处理输出. 相应列表 转换符 类型 举例 c 完整的日期和时间 Mon Feb 09 18: ...

  6. Java——IO流 对象的序列化和反序列化流ObjectOutputStream和ObjectInputStream

    对象的输入输出流 : 主要的作用是用于写入对象信息与读取对象信息. 对象信息一旦写到文件上那么对象的信息就可以做到持久化了 对象的输出流: ObjectOutputStream 对象的输入流:  Ob ...

  7. JAVA 打印流与转换流

    转换流主要有两个 InputStreamReader 和 OutputStreamWriter 1. InputStreamReader 主要是将字节流输入流转换成字符输入流 2. OutputStr ...

  8. Java API —— IO流(数据操作流 & 内存操作流 & 打印流 & 标准输入输出流 & 随机访问流 & 合并流 & 序列化流 & Properties & NIO)

    1.操作基本数据类型的流     1) 操作基本数据类型 · DataInputStream:数据输入流允许应用程序以与机器无关方式从底层输入流中读取基本 Java 数据类型.应用程序可以使用数据输出 ...

  9. 6.5(java学习笔记)其他流(字节数组流,数据流,对象流,打印流)

    一.字节数组流 之前使用输入输出流的操作的对象是文件,而这里字节数组流操作的对象是内存,内存可以看做是一个字节数组. 使用字节数组流读写就可以看做是从内存A到内存B的读写,对象时内存即字节数组. 1. ...

  10. java 打印流(PrintStream)

    打印流(PrintStream):打印流可以打印任意类型的数据,而且打印流在打印数据之前会将数据转为字符串在进行打印 PrintStream可以接受文件和其他字节输出流,所以打印流是对普通字节输出流的 ...

随机推荐

  1. k8s中安装rabbitmq集群

    官方文档地址:https://www.rabbitmq.com/kubernetes/operator/quickstart-operator.html 要求 1.k8s版本要1.18及其以上 2.能 ...

  2. 05_Java基础知识

    Java基础知识 一. Java的语言特点 面向对象(贴近人类思维模式,模拟现实世界,解决现实问题) 简单性(自动内存管理机制,不易造成内存溢出:简化流程处理.语义清晰) 跨平台(操作系统.服务器.数 ...

  3. 不可错过的效能利器「GitHub 热点速览 v.22.39」

    如果你是一名前端工程师且维护着多个网站,不妨试试本周榜上有名的 HTML-first 的 Qwik,提升网站访问速度只用一招.除了提升网站加载速度的 Qwik,本周周榜上榜的 Whisper 也是一个 ...

  4. C++自学笔记 初始化列表 Initializer list

    初始化p A(){ p = 0;cout<<"A::A()"<<endl;} 初始化列表 Initializer list A():p(0){ cout&l ...

  5. C#-10 事件

    一 发布者和订阅者 很多时候都有这种需求,当一个特定的程序事件发生时,程序的其他部分可以得到该事件已经发生的通知. 发布者/订阅者模式可以满足这种需求. 发布者:发布某个事件的类或结构,其他类可以在该 ...

  6. virtualbox的Linux虚拟磁盘大小调整及注意事项

    virtualBox 调整磁盘分区 起因 起初安装centos6.3 时,没有修改默认的硬盘空间.只有8G,导致后面安装完zookeeper,jdk之后,在安装mysql发现磁盘空间不足 扩容步骤 1 ...

  7. vue2使用组件进行父子互相传值的sync语法糖方法和原生方法

    原生方法:(事件名可以不在props通道里) 子类通过props通道绑定父类里data里的jjjjjj(@:fefefeff='jjjjjjjjjjjjj') 父组件通过监听fefeff事件来把子类传 ...

  8. jquery+bootstrap学习笔记

    最近小颖接了个私活,客户要求用jquery和bootstrap来实现业务需求,小颖总结了下在写的过程中的一下坑,来记录一下 1.动态加载html文件 switch (_domName) { case ...

  9. SQL生成脚本

    右键要生成脚本的数据库 选择task 选择Generate script 选择需要生成脚本的table.view.procedure

  10. 如何检查“lateinit”变量是否已初始化?

    kotlin中经常会使用延迟初始化,如果要校验lateinit var 变量是否初始化.可以使用属性引用上的.isInitialized. 原文中是这样描述的:To check whether a l ...