打开一个文本文件,另存为:

Ansi就是系统默认编码(就是gbk)

建一个编码是utf-8的txt文件,

例:

import java.io.FileWriter;
import java.io.IOException;
public class Demo01 {
public static void main(String[] args) throws IOException {
//确定目的地
FileWriter fw=new FileWriter("E:\\zyx\\java\\utf-8.txt",true);
//写入目的地
fw.write("你好");
//释放资源
fw.close();
}
}

所以字符流无法实现utf-8编码格式文件的读和写。

如果需要指定编码和缓冲区大小时,可以在字节流的基础上,构造一个InputStreamReader或者OutputStreamWriter。

1 OutputStreamWriter类

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

1.1继承体系

1.2原理

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

1.3构造方法

只支持utf-8和gbk这两个码表

OutputStreamWriter是一个字符流,所以字符流的方法都能用

例:

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
public class Demo02 {
public static void main(String[] args) throws IOException {
//指定目的地
FileOutputStream fos=new FileOutputStream("E:\\zyx\\java\\utf-8.txt",true); //续写
//创建转换流
OutputStreamWriter osw=new OutputStreamWriter(fos,"utf-8");
//写入
osw.write("你好你好");
//刷新数据
osw.flush();
//释放资源:(new了谁关谁,先开的先关)
osw.close();
fos.close();
}
}

注意:释放资源时,new了谁关谁,先开的后关

gbk例子:

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
public class Demo03 {
public static void main(String[] args) throws IOException {
//指定目的地
FileOutputStream fos=new FileOutputStream("E:\\zyx\\java\\gbk.txt",true); //续写
//创建转换流
OutputStreamWriter osw=new OutputStreamWriter(fos,"gbk");
//写入
osw.write("你好,java");
//osw.flush();
//释放资源
osw.close();
fos.close();
}
}

 

注意:gbk和utf-8不区分大小写,可以写成GBK

2 InputStreamReader类

utf-8是三个字节代表一个汉字,直接用Filereader不能读

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

2.1继承体系

2.2构造方法

例:

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
public class Demo04 {
public static void main(String[] args) throws IOException {
//获取数据源
FileInputStream fis=new FileInputStream("E:\\zyx\\java\\utf-8.txt");
//创建转换流
InputStreamReader isr=new InputStreamReader(fis,"utf-8");
//开始读取
int len=0;
while((len=isr.read())!=-1){
System.out.print((char)len);
}
//释放资源
isr.close();
fis.close();
}
}

改成gbk是这样:

用字符数组读gbk的文件

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
public class Demo05 {
public static void main(String[] args) throws IOException {
FileInputStream fis=new FileInputStream("E:\\zyx\\java\\gbk.txt");
InputStreamReader isr=new InputStreamReader(fis);
char[] ch=new char[24];
int len=0;
while((len=isr.read(ch))!=-1){
System.out.print(new String(ch,0,len));
}
isr.close();
fis.close();
}
}

3 转换流和子类区别

发现有如下继承关系:

OutputStreamWriter:

|--FileWriter:

InputStreamReader:

|--FileReader;

父类和子类的功能的区别:

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

2)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");

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

3)一旦要指定其他编码时,绝对不能用子类,必须使用字符转换流。

4)用子类的条件:

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

总结:

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

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

4缓冲流

读取数据量大的文件时,读取的速度会很慢,很影响程序的效率。

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

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

4.1字节缓冲流

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

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

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

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

缓冲区就是一个容器

4.1.1构造方法

例:

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException; public class Demo06 {
public static void main(String[] args) throws IOException {
method02();
} //字节输出缓冲流
public static void method01() throws IOException{
//明确目的地
FileOutputStream fos=new FileOutputStream("E:\\zyx\\java\\demo.txt");
//加缓冲流
BufferedOutputStream bos=new BufferedOutputStream(fos);
bos.write(100);
bos.close();
//fos.close(); //可以不加,bos会自动关上fos
} //字节输入缓冲流
public static void method02() throws IOException{
//明确数据源
FileInputStream fis=new FileInputStream("E:\\zyx\\java\\demo.txt");
//加缓冲流
BufferedInputStream bis=new BufferedInputStream(fis);
int len=0;
while((len=bis.read())!=-1){
System.out.println((char)len);
}
bis.close();
}
}

4.1.2复制比较示例

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.IOException; public class Demo07 {
public static void main(String[] args) throws IOException {
copy02();
} //单个字节文件复制
public static void copy01() throws IOException{
//明确数据源
FileInputStream fis=new FileInputStream("E:\\zyx\\java\\tomcat.zip");
//明确目的地
FileOutputStream fos=new FileOutputStream("E:\\zyx\\java\\a\\tomcat.zip");
//开始复制
long time1=System.currentTimeMillis();
int len=0;
while((len=fis.read())!=-1){
fos.write(len);
}
long time2=System.currentTimeMillis();
System.out.println(time2-time1);
fis.close();
fos.close();
} //单个字节,字节缓冲流复制
public static void copy02() throws IOException{
//明确数据源
FileInputStream fis=new FileInputStream("E:\\zyx\\java\\tomcat.zip");
BufferedInputStream bis=new BufferedInputStream(fis);
//明确目的地
FileOutputStream fos=new FileOutputStream("E:\\zyx\\java\\a\\tomcat.zip");
BufferedOutputStream bos=new BufferedOutputStream(fos);
//开始复制
long time1=System.currentTimeMillis();
int len=0;
while((len=bis.read())!=-1){
bos.write(len);
}
long time2=System.currentTimeMillis();
System.out.println(time2-time1);
bis.close();
bos.close();
//System.out.println(system.in);
}
}

copy01()结果:

copy02()结果:

4.1.3用字节数组方式复制的比较

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException; public class CopyTest {
public static void main(String[] args) throws IOException {
copy01();
} //普通流复制
public static void copy01() throws IOException{
//指定数据源
FileInputStream fis=new FileInputStream("E:\\zyx\\java\\eclipse.zip");
//指定目的地
FileOutputStream fos=new FileOutputStream("E:\\zyx\\java\\e\\eclipse.zip");
//复制
long start=System.currentTimeMillis();
int len=0;
byte[] bys=new byte[1024];
while((len=fis.read(bys))!=-1){
fos.write(bys);
}
long end=System.currentTimeMillis();
System.out.println(end-start);
fis.close();
fos.close();
} //缓冲流复制
public static void copy02() throws IOException{
//指定数据源
FileInputStream fis=new FileInputStream("E:\\zyx\\java\\eclipse.zip");
BufferedInputStream bis=new BufferedInputStream(fis);
//指定目的地
FileOutputStream fos=new FileOutputStream("E:\\zyx\\java\\f\\eclipse.zip");
BufferedOutputStream bos=new BufferedOutputStream(fos);
long start=System.currentTimeMillis();
int len=0;
byte[] bys=new byte[1024];
while((len=bis.read(bys))!=-1){
bos.write(bys);
}
long end=System.currentTimeMillis();
System.out.println(end-start);
bis.close();
bos.close();
}
}

结果比较:

5字符缓冲流

字符缓冲输入流 BufferedReader

字符缓冲输出流 BufferedWriter

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

5.1 BufferedWriter

\r\n换行:

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException; public class Test {
public static void main(String[] args) throws IOException {
//明确日的地
FileWriter fw=new FileWriter("E:\\zyx\\java\\demo01.txt");
//添加缓冲流
BufferedWriter bw=new BufferedWriter(fw); //会自动关闭fw
//写入文件
bw.write("你好\r\n");
bw.flush();
fw.write("java\r\n");
bw.flush();
bw.write("中国\r\n");
bw.close(); //会自动关闭fw
}
}

newLine() 方法:

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException; public class Test {
public static void main(String[] args) throws IOException {
//明确日的地
FileWriter fw=new FileWriter("E:\\zyx\\java\\demo01.txt");
//添加缓冲流
BufferedWriter bw=new BufferedWriter(fw); //会自动关闭fw
//写入文件
bw.write("你好");
bw.newLine();
bw.flush();
fw.write("java");
bw.newLine();
bw.flush();
bw.write("中国");
bw.newLine();
bw.close(); //会自动关闭fw
}
}

Tips:

\r\n是windows的换行

Linux是\n

5.2字符缓冲输入流 BufferedReader

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

例:

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException; public class Test {
public static void main(String[] args) throws IOException {
// 明确数据源
FileReader fr = new FileReader("E:\\zyx\\java\\demo01.txt");
// 添加缓冲流
BufferedReader br = new BufferedReader(fr);
// 读取
String line = "";
int lineNum = 0; // 加个行号
while ((line = br.readLine()) != null) {
lineNum++;
System.out.println(lineNum + " " + line);
}
fr.close();
}
}

Tips:

readLine()不会把换行符读出来

可以手动加一个行号

5.3复制文本文件比较

6流的操作规律

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

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

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

源:InputStream    Reader

目的:OutputStream Writer

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

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

源:

字节:InputStream

文本:Reader

目的:

字节:OutputStream

文本:Writer

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

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

源设备:

硬盘:文件  File开头。

内存:数组,字符串。

键盘:System.in;

网络:Socket

目的设备:

硬盘:文件  File开头。

内存:数组,字符串。

屏幕:System.out

网络:Socket

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

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

额外功能:

转换吗?转换流。InputStreamReader OutputStreamWriter

高效吗?缓冲区对象。BufferedXXX

InputStream

FileInputStream

BufferedInputStream

OuputStream

FileOutputStream

BufferedOuputStream

Writer

OutputStreamWriter

FileWriter

BufferedWriter

Reader

InputStreamReader

FileReader

BufferedReader

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

  1. Java IO流之【缓冲流和文件流复制文件对比】

    与文件流相比,缓冲流复制文件更快 代码: package Homework; import java.io.BufferedOutputStream; import java.io.File; imp ...

  2. File类与常用IO流第八章——缓冲流

    第八章.缓冲流 缓冲流概述 缓冲流,也叫高效流,是对4个基本的FileXxx流的增强.按照数据类型分为4类:   输入缓冲流 输出缓冲流 字节缓冲流 BufferedInputStream Buffe ...

  3. 01 语言基础+高级:1-8 File类与IO流_day10【缓冲流、转换流、序列化流】

    day10[缓冲流.转换流.序列化流] 主要内容 缓冲流 转换流 序列化流 打印流 教学目标 能够使用字节缓冲流读取数据到程序 能够使用字节缓冲流写出数据到文件 能够明确字符缓冲流的作用和基本用法 能 ...

  4. Java—转换流、字符缓冲流

    转换流 OutputStreamWriter 是字符流通向字节流的桥梁:可使用指定的字符编码表,将要写入流中的字符编码成字节.它的作用的就是,将字符串按照指定的编码表转成字节,在使用字节流将这些字节写 ...

  5. Java IO流之字符缓冲流

    字符流: 1.加入字符缓存流,增强读取功能(readLine) 2.更高效的读取数据 BufferedReader 从字符输入流读取文本,缓冲各个字符,从而实现字符.数组和行的高效读取. FileRe ...

  6. java IO流之三 使用缓冲流来读写文件

    原文:http://blog.csdn.net/haluoluo211/article/details/52183219 一.通过BufferedReader和BufferedWriter来读写文件 ...

  7. 10.4 缓冲流 BufferedReader & BufferedWriter & 缓冲流特殊功能readLine

    缓冲流和正常流的使用大致相同,缓冲流效率更高. package day10_io_fileWrite_Read.buffer_stream; import java.io.*; /* * Buffer ...

  8. 使用文件流与使用缓冲流完成文件的复制操作性能对比,文件流 FileInputStream FileOutputStream 缓冲流: BufferedInputStream BufferedOutputStream

    package seday06; import java.io.FileInputStream;import java.io.FileOutputStream;import java.io.IOExc ...

  9. Java字节缓冲流和字符缓冲流学习

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

  10. IO流(File类--递归--过滤器--IO字节流--IO字符流--Properties集合--缓冲流--转换流--序列化流--打印流)

    一.File类 1.1概述 java.io.File 类是文件和目录路径名的抽象表示,主要用于文件和目录的创建.查找和删除等操作. 1.1.1相对路径与绝对路径 相对路径从盘符开始的路径,这是一个完整 ...

随机推荐

  1. Oracle表空间维护总结

    1. 概念:表空间:最大的逻辑存储文件,与物理上的一个或多个数据文件对应,每个数据库至少拥有一个表空间,表空间的大小等于构成表空间的所有数据文件的大小总和,用于存储用户在数据库中存储的所有内容. 2. ...

  2. BZOJ2028:[SHOI2009]会场预约(平衡树版)

    浅谈\(splay\):https://www.cnblogs.com/AKMer/p/9979592.html 浅谈\(fhq\)_\(treap\):https://www.cnblogs.com ...

  3. webAPP meta 标签大全

    1.先说说mate标签里的viewport: viewport即可视区域,对于桌面浏览器而言,viewport指的就是除去所有工具栏.状态栏.滚动条等等之后用于看网页的区域.对于传统WEB页面来说,9 ...

  4. 《Java多线程编程核心技术》读后感(八)

    不使用等待/通知机制实现线程间通信 使用sleep()结合while(true)死循环来实现多个线程间通信 package Third; import java.util.ArrayList; imp ...

  5. OpenCPN介绍及编译

    OpenCPN介绍及编译 OpenCPN是一个航海应用软件系统,采用wxWidgets界面框架,支持OpenGL,可以跨平台运行在Windows , Linux , Mac电脑上. OpenCPN是一 ...

  6. HDU-6395 多校7 Sequence(除法分块+矩阵快速幂)

    Sequence Time Limit: 4000/2000 MS (Java/Others)    Memory Limit: 262144/262144 K (Java/Others)Total ...

  7. pure css做的手机页面

    <!doctype html> <html> <head> <meta http-equiv="Content-type" content ...

  8. 钉钉/支付宝小程序和微信小程序的区别及转换方案

    最近接到一个工作任务,是把钉钉小程序转微信小程序... 对,居然还有这种操作,之前只听过微信小程序转支付宝小程序的,钉钉转微信是什么鬼

  9. Java 普通方法和构造方法的区别

    构造方法: ①方法名和 类名相同 ②在方法名的前面没有返回值类型的声明 ③在方法中不能使用return语句返回一个值 ④在创建对象时,要调用new,如:book b1=new book(); ⑤当没有 ...

  10. solidity 学习笔记(3) 函数修饰符/继承

    修饰符: 函数修饰符有 constant  view pure 其中 constant和view的功能是一样的  不会消耗gas 也就是说不会做任何存储   constant在5.0以后的版本中被废弃 ...