第1章 转换流

在学习字符流(FileReader、FileWriter)的时候,其中说如果需要指定编码和缓冲区大小时,可以在字节流的基础上,构造一个InputStreamReader或者OutputStreamWriter,这又是什么意思呢?

1.1 OutputStreamWriter类

查阅OutputStreamWriter的API介绍,OutputStreamWriter 是字符流通向字节流的桥梁:可使用指定的字符编码表,将要写入流中的字符编码成字节。它的作用的就是,将字符串按照指定的编码表转成字节,在使用字节流将这些字节写出去。

l 代码演示:

public static void writeCN() throws Exception {

//创建与文件关联的字节输出流对象

FileOutputStream fos = new FileOutputStream("c:\\cn8.txt");

//创建可以把字符转成字节的转换流对象,并指定编码

OutputStreamWriter osw = new OutputStreamWriter(fos,"utf-8");

//调用转换流,把文字写出去,其实是写到转换流的缓冲区中

osw.write("你好");//写入缓冲区。

osw.close();

}

OutputStreamWriter流对象,它到底如何把字符转成字节输出的呢?

其实在OutputStreamWriter流中维护自己的缓冲区,当我们调用OutputStreamWriter对象的write方法时,会拿着字符到指定的码表中进行查询,把查到的字符编码值转成字节数存放到OutputStreamWriter缓冲区中。然后再调用刷新功能,或者关闭流,或者缓冲区存满后会把缓冲区中的字节数据使用字节流写到指定的文件中。

1.2 InputStreamReader类

查阅InputStreamReader的API介绍,InputStreamReader 是字节流通向字符流的桥梁:它使用指定的字符编码表读取字节并将其解码为字符。它使用的字符集可以由名称指定或显式给定,或者可以接受平台默认的字符集。

l 代码演示

public class InputStreamReaderDemo {

public static void main(String[] args) throws IOException {

//演示字节转字符流的转换流

readCN();

}

public static void readCN() throws IOException{

//创建读取文件的字节流对象

InputStream in = new FileInputStream("c:\\cn8.txt");

//创建转换流对象

//InputStreamReader isr = new InputStreamReader(in);这样创建对象,会用本地默认码表读取,将会发生错误解码的错误

InputStreamReader isr = new InputStreamReader(in,"utf-8");

//使用转换流去读字节流中的字节

int ch = 0;

while((ch = isr.read())!=-1){

System.out.println((char)ch);

}

//关闭流

isr.close();

}

}

注意:在读取指定的编码的文件时,一定要指定编码格式,否则就会发生解码错误,而发生乱码现象。

1.3 转换流和子类区别

发现有如下继承关系:

OutputStreamWriter:

|--FileWriter:

InputStreamReader:

|--FileReader;

父类和子类的功能有什么区别呢?

OutputStreamWriter和InputStreamReader是字符和字节的桥梁:也可以称之为字符转换流。字符转换流原理:字节流+编码表。

FileWriter和FileReader:作为子类,仅作为操作字符文件的便捷类存在。当操作的字符文件,使用的是默认编码表时可以不用父类,而直接用子类就完成操作了,简化了代码。

InputStreamReader isr = new InputStreamReader(new FileInputStream("a.txt"));//默认字符集。

InputStreamReader isr = new InputStreamReader(new FileInputStream("a.txt"),"GBK");//指定GBK字符集。

FileReader fr = new FileReader("a.txt");

这三句代码的功能是一样的,其中第三句最为便捷。

注意:一旦要指定其他编码时,绝对不能用子类,必须使用字符转换流。什么时候用子类呢?

条件:

1、操作的是文件。2、使用默认编码。

总结:

字节--->字符 : 看不懂的--->看的懂的。  需要读。输入流。 InputStreamReader

字符--->字节 : 看的懂的--->看不懂的。  需要写。输出流。 OutputStreamWriter

第2章 缓冲流

在我们学习字节流与字符流的时候,大家都进行过读取文件中数据的操作,读取数据量大的文件时,读取的速度会很慢,很影响我们程序的效率,那么,我想提高速度,怎么办?

Java中提高了一套缓冲流,它的存在,可提高IO流的读写速度

缓冲流,根据流的分类分类字节缓冲流与字符缓冲流。

2.1 字节缓冲流

字节缓冲流根据流的方向,共有2个

l 写入数据到流中,字节缓冲输出流 BufferedOutputStream

l 读取流中的数据,字节缓冲输入流 BufferedInputStream

它们的内部都包含了一个缓冲区,通过缓冲区读写,就可以提高了IO流的读写速度

2.1.1 字节缓冲输出流BufferedOutputStream

通过字节缓冲流,进行文件的读写操作 写数据到文件的操作

l 构造方法

public BufferedOutputStream(OutputStream out)创建一个新的缓冲输出流,以将数据写入指定的底层输出流。

public class BufferedOutputStreamDemo01 {

public static void main(String[] args) throws IOException {

//写数据到文件的方法

write();

}

/*

* 写数据到文件的方法

* 1,创建流

* 2,写数据

* 3,关闭流

*/

private static void write() throws IOException {

//创建基本的字节输出流

FileOutputStream fileOut = new FileOutputStream("abc.txt");

//使用高效的流,把基本的流进行封装,实现速度的提升

BufferedOutputStream out = new BufferedOutputStream(fileOut);

//2,写数据

out.write("hello".getBytes());

//3,关闭流

out.close();

}

}

2.1.2 字节缓冲输入流 BufferedInputStream

刚刚我们学习了输出流实现了向文件中写数据的操作,那么,现在我们完成读取文件中数据的操作

l 构造方法

public BufferedInputStream(InputStream in)

/*

* 从文件中读取数据

* 1,创建缓冲流对象

* 2,读数据,打印

* 3,关闭

*/

private static void read() throws IOException {

//1,创建缓冲流对象

FileInputStream fileIn = new FileInputStream("abc.txt");

//把基本的流包装成高效的流

BufferedInputStream in = new BufferedInputStream(fileIn);

//2,读数据

int ch = -1;

while ( (ch = in.read()) != -1 ) {

//打印

System.out.print((char)ch);

}

//3,关闭

in.close();

}

2.1.3 使用基本的流与高效的流完成复制文件

我们一直在说,高效的流速度快并高效,怎么体现呢?需要通过一个复制文件耗时的比较过程,来体验一下高效流带来的快感。

/*

* 需求:将d:\\test.avi文件进行复制

* 采用4种方式复制

* 方式1: 采用基本的流,一次一个字节的方式复制 共耗时 224613毫秒

* 方式2: 采用基本的流,一个多个字节的方式赋值 共耗时     327毫秒

* 方式3: 采用高效的流,一次一个字节的方式复制 共耗时    2047毫秒

* 方式4: 采用高效的流,一个多个字节的方式赋值 共耗时      96毫秒

*

* 数据源: d:\\test.avi

* 目的地1: d:\\copy1.avi

* 目的地2: d:\\copy2.avi

* 目的地3: d:\\copy3.avi

* 目的地4: d:\\copy4.avi

*

* 实现的步骤:

* 1,指定数据源

* 2,指定目的地

* 3,读数据

* 4,写数据

* 5,关闭流

*

*/

public class CopyAVI {

public static void main(String[] args) throws IOException {

//开始计时

long start = System.currentTimeMillis();

//方式1: 采用基本的流,一次一个字节的方式复制

//method1("d:\\test.avi", "d:\\copy1.avi");

//方式2: 采用基本的流,一个多个字节的方式赋值

//method2("d:\\test.avi", "d:\\copy2.avi");

//方式3: 采用高效的流,一次一个字节的方式复制

//method3("d:\\test.avi", "d:\\copy3.avi");

//方式4: 采用高效的流,一个多个字节的方式赋值

method4("d:\\test.avi", "d:\\copy4.avi");

//结束计时

long end = System.currentTimeMillis();

//打印耗时多少毫秒

System.out.println("共耗时 " +(end - start)+ "毫秒");

}

//方式4: 采用高效的流,一个多个字节的方式赋值

private static void method4(String src, String dest) throws IOException {

//1,指定数据源

BufferedInputStream in = new BufferedInputStream(new FileInputStream(src));

//2,指定目的地

BufferedOutputStream out = new BufferedOutputStream(new FileOutputStream(dest));

//3,读数据

byte[] buffer = new byte[1024];

int len = -1;

while ( (len = in.read(buffer)) != -1) {

//4,写数据

out.write(buffer, 0, len);

}

//5,关闭流

in.close();

out.close();

}

//方式3: 采用高效的流,一次一个字节的方式复制

private static void method3(String src, String dest) throws IOException {

//1,指定数据源

BufferedInputStream in = new BufferedInputStream(new FileInputStream(src));

//2,指定目的地

BufferedOutputStream out = new BufferedOutputStream(new FileOutputStream(dest));

//3,读数据

int ch = -1;

while ((ch=in.read()) != -1) {

//4,写数据

out.write(ch);

}

//5,关闭流

in.close();

out.close();

}

//方式2: 采用基本的流,一个多个字节的方式赋值

private static void method2(String src, String dest) throws IOException {

//1,指定数据源

FileInputStream in = new FileInputStream(src);

//2,指定目的地

FileOutputStream out = new FileOutputStream(dest);

//3,读数据

byte[] buffer = new byte[1024];

int len = -1;

while ( (len=in.read(buffer)) != -1) {

//4,写数据

out.write(buffer, 0, len);

}

//5,关闭流

in.close();

out.close();

}

//方式1: 采用基本的流,一次一个字节的方式复制

private static void method1(String src, String dest) throws IOException {

//1,指定数据源

FileInputStream in = new FileInputStream(src);

//2,指定目的地

FileOutputStream out = new FileOutputStream(dest);

//3,读数据

int ch = -1;

while (( ch=in.read()) != -1) {

//4,写数据

out.write(ch);

}

//5,关闭流

in.close();

out.close();

}

}

2.2 字符缓冲流

l 字符缓冲输入流 BufferedReader

l 字符缓冲输出流 BufferedWriter

完成文本数据的高效的写入与读取的操作

2.2.1 字符缓冲输出流 BufferedWriter

将文本写入字符输出流,缓冲各个字符,从而提供单个字符、数组和字符串的高效写入。

l 方法:

void newLine() 根据当前的系统,写入一个换行符

/*

* BufferedWriter 字符缓冲输出流

* 方法

* public void newLine()写入一个行分隔符

*

* 需求: 通过缓冲输出流写入数据到文件

* 分析:

* 1,创建流对象

* 2,写数据

* 3,关闭流

*

*/

public class BufferedWriterDemo {

public static void main(String[] args) throws IOException {

//创建流

//基本字符输出流

FileWriter fileOut = new FileWriter("file.txt");

//把基本的流进行包装

BufferedWriter out = new BufferedWriter(fileOut);

//2,写数据

for (int i=0; i<5; i++) {

out.write("hello");

out.newLine();

}

//3,关闭流

out.close();

}

}

2.2.2 字符缓冲输入流 BufferedReader

从字符输入流中读取文本,缓冲各个字符,从而实现字符、数组和行的高效读取。

l 方法

public String readLine() 读取一个文本行,包含该行内容的字符串,不包含任何行终止符,如果已到达流末尾,则返回 null

/*

* BufferedReader 字符缓冲输入流

*

* 方法:

* String readLine()

* 需求:从文件中读取数据,并显示数据

*/

public class BufferedReaderDemo {

public static void main(String[] args) throws IOException {

//1,创建流

BufferedReader in = new BufferedReader(new FileReader("file.txt"));

//2,读数据

//一次一个字符

//一次一个字符数组

//一次读取文本中一行的字符串内容

String line = null;

while( (line = in.readLine()) != null ){

System.out.println(line);

}

//3,关闭流

in.close();

}

}

2.2.3 使用字符缓冲流完成文本文件的复制

刚刚我们学习完了缓冲流,现在我们就使用字符缓冲流的特有功能,完成文本文件的复制

/*

* 采用高效的字符缓冲流,完成文本文件的赋值

*

* 数据源: file.txt

* 目的地: copyFile.txt

*

* 分析:

* 1,指定数据源, 是数据源中读数据,采用输入流

* 2,指定目的地,是把数据写入目的地,采用输出流

* 3,读数据

* 4,写数据

* 5,关闭流

*/

public class CopyTextFile {

public static void main(String[] args) throws IOException {

//1,指定数据源, 是数据源中读数据,采用输入流

BufferedReader in = new BufferedReader(new FileReader("file.txt"));

//2,指定目的地,是把数据写入目的地,采用输出流

BufferedWriter out = new BufferedWriter(new FileWriter("copyFile.txt"));

//3,读数据

String line = null;

while ( (line = in.readLine()) != null ) {

//4,写数据

out.write(line);

//写入换行符号

out.newLine();

}

//5,关闭流

out.close();

in.close();

}

}

第3章 流的操作规律

IO流中对象很多,解决问题(处理设备上的数据时)到底该用哪个对象呢?  

把IO流进行了规律的总结(四个明确):

l 明确一:要操作的数据是数据源还是数据目的。

源:InputStream    Reader

目的:OutputStream Writer

先根据需求明确要读,还是要写。

l 明确二:要操作的数据是字节还是文本呢?

源:

字节:InputStream

文本:Reader

目的:

字节:OutputStream

文本:Writer

已经明确到了具体的体系上。

l 明确三:明确数据所在的具体设备。

源设备:

硬盘:文件  File开头。

内存:数组,字符串。

键盘:System.in;

网络:Socket

目的设备:

硬盘:文件  File开头。

内存:数组,字符串。

屏幕:System.out

网络:Socket

完全可以明确具体要使用哪个流对象。

l 明确四:是否需要额外功能呢?

额外功能:

转换吗?转换流。InputStreamReader OutputStreamWriter

高效吗?缓冲区对象。BufferedXXX

InputStream

FileInputStream

BufferedInputStream

OuputStream

FileOutputStream

BufferedOuputStream

Writer

OutputStreamWriter

FileWriter

BufferedWriter

Reader

InputStreamReader

FileReader

BufferedReader

第4章 总结

4.1 知识点总结

l 字节流

l 字节输入流 InputStream

l FileInputStream 操作文件的字节输入流

l BufferedInputStream高效的字节输入流

l 字节输出流 OutputStream

l FileOutputStream 操作文件的字节输出流

l BufferedOutputStream 高效的字节输出流

l 字符流

l 字符输入流 Reader

l FileReader 操作文件的字符输入流

l BufferedReader 高效的字符输入流

l InputStreamReader 输入操作的转换流(把字节流封装成字符流)

l 字符输出流 Writer

l FileWriter 操作文件的字符输出流

l BufferedWriter 高效的字符输出流

l OutputStreamWriter 输出操作的转换流(把字节流封装成字符流)

l 方法:

l 读数据方法:

l read() 一次读一个字节或字符的方法

l read(byte[]  char[]) 一次读一个数组数据的方法

l readLine() 一次读一行字符串的方法(BufferedReader类特有方法)

l readObject() 从流中读取对象(ObjectInputStream特有方法)

l 写数据方法:

l write(int) 一次写一个字节或字符到文件中

l write(byte[] char[]) 一次写一个数组数据到文件中

l write(String) 一次写一个字符串内容到文件中

l writeObject(Object ) 写对象到流中(ObjectOutputStream类特有方法)

l newLine() 写一个换行符号(BufferedWriter类特有方法)

l 向文件中写入数据的过程

1,创建输出流对象

2,写数据到文件

3,关闭输出流

l 从文件中读数据的过程

1, 创建输入流对象

2, 从文件中读数据

3, 关闭输入流

l 文件复制的过程

1, 创建输入流(数据源)

2, 创建输出流(目的地)

3, 从输入流中读数据

4, 通过输出流,把数据写入目的地

5, 关闭流

IO(转换流、缓冲流)的更多相关文章

  1. Java基础知识强化之IO流笔记41:字符流缓冲流之复制文本文件案例02(使用 [ newLine() / readLine() ] )(重要)

    1. 使用字符流缓冲流的特殊功能 [ newLine() / readLine() ] 需求:把当前项目目录下的a.txt内容复制到当前项目目录下的b.txt中  数据源: a.txt -- 读取数据 ...

  2. Java基础知识强化之IO流笔记39:字符流缓冲流之复制文本文件案例01

    1. 字符流缓冲流之复制文本文件案例 需求:把当前项目目录下的a.txt内容复制到当前项目目录下的b.txt中 数据源: a.txt -- 读取数据 -- 字符转换流 -- InputStreamRe ...

  3. IO流(字节流,字符流,缓冲流)

    一:IO流的分类(组织架构) 根据处理数据类型的不同分为:字节流和字符流 根据数据流向不同分为:输入流和输出流   这么庞大的体系里面,常用的就那么几个,我们把它们抽取出来,如下图:   二:字符字节 ...

  4. Java基础知识强化之IO流笔记40:字符流缓冲流之特殊功能 [ newLine() / readLine() ]

    1. 字符缓冲流的特殊方法 BufferedWriter: public void newLine():根据系统来决定换行符 BufferedReader: public String readLin ...

  5. Java基础知识强化之IO流笔记38:字符流缓冲流之BufferedWriter / BufferedReader使用

    1. 字符流缓冲流: 字符流为了高效读写,也提供了对应的字符缓冲流. BufferedWriter:字符缓冲输出流 BufferedReader:字符缓冲输入流 2. BufferedWriter使用 ...

  6. -1-4 java io java流 常用流 分类 File类 文件 字节流 字符流 缓冲流 内存操作流 合并序列流

      File类 •文件和目录路径名的抽象表示形式 构造方法 •public File(String pathname) •public File(String parent,Stringchild) ...

  7. Java基础IO类之缓冲流

    首先要明确一个概念: 对文件或其他目标频繁的读写操作,效率低,性能差. 使用缓冲流的好处是:能够高效的读写信息,原理是先将数据先缓冲起来,然后一起写入或者读取出来. 对于字节: BufferedInp ...

  8. IO Streams:缓冲流

    我们迄今为止看到的大多数示例都使用无缓冲的I / O.这意味着每个读或写请求都由底层操作系统直接处理.这使程序效率变得很低,因为每个这样的请求经常触发磁盘访问,网络活动或一些相对昂贵的其他操作. 为了 ...

  9. java 文件字节和字符流 缓冲流

    流的原理 1) 在 Java 程序中,对于数据的输入/输出操作以“流”(stream) 方式进行:2) J2SDK 提供了各种各样的“流”类,用以获取不同种类的数据:程序中通过标准的方法输入或输出数据 ...

  10. IO之BufferedStream缓冲流举例

    import java.io.*; public class TestBufferStream1 { public static void main(String[] args) { try { Fi ...

随机推荐

  1. CRC16算法之一:CRC16-CCITT-FALSE算法的java实现

    CRC16算法系列文章: CRC16算法之一:CRC16-CCITT-FALSE算法的java实现 CRC16算法之二:CRC16-CCITT-XMODEM算法的java实现 CRC16算法之三:CR ...

  2. 【247】◀▶IEW-Unit12

    Unit 12 Leisure Activities 1.Model1对应图片分析 2.Model1范文分析 The pie chart shows the six sporting activiti ...

  3. ZOJ 1586 QS Network Kruskal求最小生成树

    QS Network Sunny Cup 2003 - Preliminary Round April 20th, 12:00 - 17:00 Problem E: QS Network In the ...

  4. 黑科技抢先尝(续) - Windows terminal中WSL Linux 终端的极简美化指南

    目录 修改默认源,为apt-get安装提速 安装python 和 python pip 安装 zsh 安装powerline-font中的特定字体 安装powerline-shell 修改~目录下的配 ...

  5. 将Angular6自己定义的模块发布成npm包

    创建自己的模块组件 1. ng new 一个工程 2. ng g m 创建模块 例如我这里的modules文件下创建header模块 3. ng g c modules/head 创建一个hear组件 ...

  6. poj3225(线段树区间更新&hash)

    题目链接: http://poj.org/problem?id=3225 题意: 初始给一个全局为 0~65536 的区间  s, 然后不断地对区间 s 进行 并, 交, 差, 相对差等运算, 输出最 ...

  7. Manacher(hdu3068最长回文)

    浅谈manacher算法 manacher算法是我在网上无意中找到的,主要是用来求某个字符串的最长回文子串. 不过网上的版本还不太成熟,我就修改了下. 不要被manacher这个名字吓倒了,其实man ...

  8. 关于Struts漏洞工具的使用

    最新struts-scan资源: https://www.cesafe.com/3486.html 一,将资源下载后,放入liunx系统中,并且需要具备python2的操作环境 二,打开终端使用如下命 ...

  9. 人民网慕课联手FISCO BCOS开源社区上线“区块链学院”

    FISCO BCOS是完全开源的联盟区块链底层技术平台,由金融区块链合作联盟(深圳)(简称金链盟)成立开源工作组通力打造.开源工作组成员包括博彦科技.华为.深证通.神州数码.四方精创.腾讯.微众银行. ...

  10. link-1-STL 标准模板库

    STL(Standard Template Library,标准模版库)是C++语⾔言标准中的重要组成部分.STL以模板类和模版函数的形式为程序员提供了了各种数据结构和算法的实现,程序员吐过能够充分的 ...