01转换流概述

* A: 转换流概述
* a: 转换流概述
* OutputStreamWriter 是字符流通向字节流的桥梁:可使用指定的字符编码表,将要写入流中的字符编码成字节
* 将字符串按照指定的编码表转成字节,在使用字节流将这些字节写出去 

02转换流_字符转字节的过程

* A: 转换流_字符转字节的过程
* a.图解
* 详见day24_source/转换流.JPG图片

03OutputStreamWriter写文本文件

* A: OutputStreamWriter写文本文件
* a: OutputStreamWriter
* java.io.OutputStreamWriter 继承Writer类
* 就是一个字符输出流,写文本文件
* write()字符,字符数组,字符串
* 字符通向字节的桥梁,将字符流转字节流
* OutputStreamWriter 使用方式
* 构造方法:
* OutputStreamWriter(OuputStream out)接收所有的字节输出流
* 字节输出流: FileOutputStream
* OutputStreamWriter(OutputStream out, String charsetName)
* String charsetName 传递编码表名字 GBK UTF-8
* OutputStreamWriter 有个子类, FileWriter
* b: 案例代码 public class OutputStreamWriterDemo {
public static void main(String[] args)throws IOException {
// writeGBK();
writeUTF();
}
/*
* 转换流对象OutputStreamWriter写文本
* 采用UTF-8编码表写入
*/
public static void writeUTF()throws IOException{
//创建字节输出流,绑定文件
FileOutputStream fos = new FileOutputStream("c:\\utf.txt");
//创建转换流对象,构造方法保证字节输出流,并指定编码表是UTF-8
OutputStreamWriter osw = new OutputStreamWriter(fos,"UTF-8");
osw.write("你好");
osw.close();
} /*
* 转换流对象 OutputStreamWriter写文本
* 文本采用GBK的形式写入
*/
public static void writeGBK()throws IOException{
//创建字节输出流,绑定数据文件
FileOutputStream fos = new FileOutputStream("c:\\gbk.txt");
//创建转换流对象,构造方法,绑定字节输出流,使用GBK编码表
OutputStreamWriter osw = new OutputStreamWriter(fos);
//转换流写数据
osw.write("你好"); osw.close();
}
}

04转换流_字节转字符流过程

* A: 转换流_字节转字符流过程
* a: InputStreamReader
* java.io.InputStreamReader 继承 Reader
* 字符输入流,读取文本文件
* 字节流向字符的敲了,将字节流转字符流
* 读取的方法:
* read() 读取1个字符,读取字符数组
* 技巧
* OuputStreamWriter写了文件
* InputStreamReader读取文件
* OutputStreamWriter(OutputStream out)所有字节输出流
* InputStreamReader(InputStream in) 接收所有的字节输入流
* 可以传递的字节输入流: FileInputStream
* InputStreamReader(InputStream in,String charsetName) 传递编码表的名字
* b: 图解
* 详见day24_source/转换流.JPG图片

05InputSteamReader读取文本文件

* A: InputSteamReader读取文本文件
* a: 案例代码
public class InputStreamReaderDemo {
public static void main(String[] args) throws IOException {
// readGBK();
readUTF();
}
/*
* 转换流,InputSteamReader读取文本
* 采用UTF-8编码表,读取文件utf
*/
public static void readUTF()throws IOException{
//创建自己输入流,传递文本文件
FileInputStream fis = new FileInputStream("c:\\utf.txt");
//创建转换流对象,构造方法中,包装字节输入流,同时写编码表名
InputStreamReader isr = new InputStreamReader(fis,"UTF-8");
char[] ch = new char[1024];
int len = isr.read(ch);
System.out.println(new String(ch,0,len));
isr.close();
}
/*
* 转换流,InputSteamReader读取文本
* 采用系统默认编码表,读取GBK文件
*/
public static void readGBK()throws IOException{
//创建自己输入流,传递文本文件
FileInputStream fis = new FileInputStream("c:\\gbk.txt");
//创建转换流对象,构造方法,包装字节输入流
InputStreamReader isr = new InputStreamReader(fis);
char[] ch = new char[1024];
int len = isr.read(ch);
System.out.println(new String(ch,0,len)); isr.close();
}
}

06转换流子类父类的区别

* A: 转换流子类父类的区别
* a: 继承关系
OutputStreamWriter:
|--FileWriter:
InputStreamReader:
|--FileReader;
* b: 区别
* 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");

07缓冲流概述

* A: 缓冲流概述
* a: 概述
* 可提高IO流的读写速度
* 分为字节缓冲流与字符缓冲流

08字节输出流缓冲流BufferedOutputStream

* A: 字节输出流缓冲流BufferedOutputStream
* a: BufferedOutputStream
* 字节输出流的缓冲流
* java.io.BufferedOuputStream 作用: 提高原有输出流的写入效率
* BufferedOuputStream 继承 OutputStream
* 方法,写入 write 字节,字节数组
* 构造方法:
* BufferedOuputStream(OuputStream out)
* 可以传递任意的字节输出流, 传递的是哪个字节流,就对哪个字节流提高效率 * b: 案例代码
public class BufferedOutputStreamDemo {
public static void main(String[] args)throws IOException {
//创建字节输出流,绑定文件
//FileOutputStream fos = new FileOutputStream("c:\\buffer.txt");
//创建字节输出流缓冲流的对象,构造方法中,传递字节输出流
BufferedOutputStream bos = new
BufferedOutputStream(new FileOutputStream("c:\\buffer.txt")); bos.write(55); byte[] bytes = "HelloWorld".getBytes(); bos.write(bytes); bos.write(bytes, 3, 2); bos.close();
}
}

09字节输入流缓冲流BufferedInputStream

* A: 字节输入流缓冲流BufferedInputStream
* a: BufferedInputStream
* 字节输入流的缓冲流
* 继承InputStream,标准的字节输入流
* 读取方法 read() 单个字节,字节数组
* 构造方法:
* BufferedInputStream(InputStream in)
* 可以传递任意的字节输入流,传递是谁,就提高谁的效率
* 可以传递的字节输入流 FileInputStream
* b: 案例代码
public class BufferedInputStreamDemo {
public static void main(String[] args) throws IOException{
//创建字节输入流的缓冲流对象,构造方法中包装字节输入流,包装文件
BufferedInputStream bis = new
BufferedInputStream(new FileInputStream("c:\\buffer.txt"));
byte[] bytes = new byte[10];
int len = 0 ;
while((len = bis.read(bytes))!=-1){
System.out.print(new String(bytes,0,len));
}
bis.close();
}
}

10四种文件复制方式的效率比较

* A:四种文件复制方式的效率比较
* a: 四中复制方式
* 字节流读写单个字节 125250 毫秒
* 字节流读写字节数组 193 毫秒 OK
* 字节流缓冲区流读写单个字节 1210 毫秒
* 字节流缓冲区流读写字节数组 73 毫秒 OK * b: 案例代码 public class Copy {
public static void main(String[] args)throws IOException {
long s = System.currentTimeMillis();
copy_4(new File("c:\\q.exe"), new File("d:\\q.exe"));
long e = System.currentTimeMillis();
System.out.println(e-s);
}
/*
* 方法,实现文件复制
* 4. 字节流缓冲区流读写字节数组
*/
public static void copy_4(File src,File desc)throws IOException{
BufferedInputStream bis = new BufferedInputStream(new FileInputStream(src));
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(desc));
int len = 0 ;
byte[] bytes = new byte[1024];
while((len = bis.read(bytes))!=-1){
bos.write(bytes,0,len);
}
bos.close();
bis.close();
}
/*
* 方法,实现文件复制
* 3. 字节流缓冲区流读写单个字节
*/
public static void copy_3(File src,File desc)throws IOException{
BufferedInputStream bis = new BufferedInputStream(new FileInputStream(src));
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(desc));
int len = 0 ;
while((len = bis.read())!=-1){
bos.write(len);
}
bos.close();
bis.close();
} /*
* 方法,实现文件复制
* 2. 字节流读写字节数组
*/
public static void copy_2(File src,File desc)throws IOException{
FileInputStream fis = new FileInputStream(src);
FileOutputStream fos = new FileOutputStream(desc);
int len = 0 ;
byte[] bytes = new byte[1024];
while((len = fis.read(bytes))!=-1){
fos.write(bytes,0,len);
}
fos.close();
fis.close();
} /*
* 方法,实现文件复制
* 1. 字节流读写单个字节
*/
public static void copy_1(File src,File desc)throws IOException{
FileInputStream fis = new FileInputStream(src);
FileOutputStream fos = new FileOutputStream(desc);
int len = 0 ;
while((len = fis.read())!=-1){
fos.write(len);
}
fos.close();
fis.close();
}
}

11字符输出流缓冲流BufferedWriter

* A: 字符输出流缓冲流BufferedWriter
* a: BufferedWriter
* 字符输出流缓冲区流
* java.io.BufferedWriter 继承 Writer
* 写入方法 write () 单个字符,字符数组,字符串 * 构造方法:
* BufferedWriter(Writer w)传递任意字符输出流
* 传递谁,就高效谁
* 能传递的字符输出流 FileWriter, OutputStreamWriter
* b: 案例代码
public class BufferedWrierDemo {
public static void main(String[] args) throws IOException{
//创建字符输出流,封装文件
FileWriter fw = new FileWriter("c:\\buffer.txt");
BufferedWriter bfw = new BufferedWriter(fw); bfw.write(100);
bfw.flush();
bfw.write("你好".toCharArray());
bfw.flush(); bfw.write("你好"); bfw.flush(); bfw.write("我好好"); bfw.flush();

bfw.write("大家都好");
bfw.flush(); bfw.close(); }

12字符输出流缓冲流BufferedWriter特有方法newLine

* A: 字符输出流缓冲流BufferedWriter特有方法newLine
* a: 方法介绍
* void newLine() 写换行 * newLine()文本中换行, \r\n也是文本换行
* 方法具有平台无关性
* Windows \r\n
* Linux \n * newLine()运行结果,和操作系统是相互关系
* JVM: 安装的是Windows版本,newLine()写的就是\r\n
* 安装的是Linux版本,newLine()写的就是\n
/*
* 将数据源 c:\\a.txt
* 复制到 d:\\a.txt 数据目的
* 字节输入流,绑定数据源
* 字节输出流,绑定数据目的
*
* 输入,读取1个字节
* 输出,写1个字节
*/
* b: 案例代码
public class BufferedWrierDemo {
public static void main(String[] args) throws IOException{
//创建字符输出流,封装文件
FileWriter fw = new FileWriter("c:\\buffer.txt");
BufferedWriter bfw = new BufferedWriter(fw); bfw.write(100);
bfw.flush();
bfw.write("你好".toCharArray());
bfw.flush(); bfw.write("你好");
bfw.newLine();
bfw.flush(); bfw.write("我好好");
bfw.newLine();
bfw.flush();

bfw.write("大家都好");
bfw.flush(); bfw.close(); }
}

13字符输入流缓冲流BufferedReader

* A: 字符输入流缓冲流BufferedReader
* a: 概述
* 从字符输入流中读取文本,缓冲各个字符,从而实现字符、数组和行的高效读取
* public String readLine() 读取一个文本行,包含该行内容的字符串,不包含任何行终止符,如果已到达流末尾,则返回 null

14字符输入流缓冲流BufferedReader读取文本行

* A: 字符输入流缓冲流BufferedReader读取文本行
* a: BufferedReader
* 字符输入流缓冲流
* java.io.BufferedReader 继承 Reader
* 读取功能 read() 单个字符,字符数组
* 构造方法:
* BufferedReader(Reader r)
* 可以任意的字符输入流
FileReader InputStreamReader
* BufferedReader自己的功能
* String readLine() 读取文本行 \r\n
* 方法读取到流末尾,返回null
* b: 小特点
* 获取内容的方法一般都有返回值
* int 没有返回的都是负数
* 引用类型 找不到返回null
* boolean 找不到返回false * c: 案例代码
public class BufferedReaderDemo {
public static void main(String[] args) throws IOException {
int lineNumber = 0;
//创建字符输入流缓冲流对象,构造方法传递字符输入流,包装数据源文件
BufferedReader bfr = new BufferedReader(new FileReader("c:\\a.txt"));
//调用缓冲流的方法 readLine()读取文本行
//循环读取文本行, 结束条件 readLine()返回null
String line = null;
while((line = bfr.readLine())!=null){
lineNumber++;
System.out.println(lineNumber+" "+line);
}
bfr.close();
}
}

/*
* String line = bfr.readLine();
System.out.println(line); line = bfr.readLine();
System.out.println(line); line = bfr.readLine();
System.out.println(line); line = bfr.readLine();
System.out.println(line); line = bfr.readLine();
System.out.println(line);
*/

15字符流缓冲区流复制文本文件

* A: 字符流缓冲区流复制文本文件
* a: 案例代码
/*
* 使用缓冲区流对象,复制文本文件
* 数据源 BufferedReader+FileReader 读取
* 数据目的 BufferedWriter+FileWriter 写入
* 读取文本行, 读一行,写一行,写换行
*/
public class Copy_1 {
public static void main(String[] args) throws IOException{
BufferedReader bfr = new BufferedReader(new FileReader("c:\\w.log"));
BufferedWriter bfw = new BufferedWriter(new FileWriter("d:\\w.log"));
//读取文本行, 读一行,写一行,写换行
String line = null;
while((line = bfr.readLine())!=null){
bfw.write(line);
bfw.newLine();
bfw.flush();
}
bfw.close();
bfr.close();
}
}

16IO流对象的操作规律

* A: IO流对象的操作规律
* a: 明确一:要操作的数据是数据源还是数据目的。
* 源:InputStream Reader
* 目的:OutputStream Writer
* 先根据需求明确要读,还是要写。

* b: 明确二:要操作的数据是字节还是文本呢?
* 源:
* 字节:InputStream
* 文本:Reader
* 目的:
* 字节:OutputStream
* 文本:Writer
* c: 明确三:明确数据所在的具体设备。
* 源设备:
* 硬盘:文件 File开头。
* 内存:数组,字符串。
* 键盘:System.in;
* 网络:Socket
* 目的设备:
* 硬盘:文件 File开头。
* 内存:数组,字符串。
* 屏幕:System.out
* 网络:Socket
* 完全可以明确具体要使用哪个流对象。
* d: 明确四:是否需要额外功能呢?
* 额外功能:
* 转换吗?转换流。InputStreamReader OutputStreamWriter
* 高效吗?缓冲区对象。BufferedXXX
* 已经明确到了具体的体系上。

24_java之转换流和缓冲流的更多相关文章

  1. Java转换流、缓冲流、流操作规律整理

    转换流 1.1                OutputStreamWriter类 OutputStreamWriter 是字符流通向字节流的桥梁:可使用指定的字符编码表,将要写入流中的字符编码成字 ...

  2. IO流----转换流、缓冲流

    打开一个文本文件,另存为: Ansi就是系统默认编码(就是gbk) 建一个编码是utf-8的txt文件, 例: import java.io.FileWriter; import java.io.IO ...

  3. IO(转换流、缓冲流)

    第1章 转换流 在学习字符流(FileReader.FileWriter)的时候,其中说如果需要指定编码和缓冲区大小时,可以在字节流的基础上,构造一个InputStreamReader或者Output ...

  4. Java_转换流和缓冲流

    今日内容介绍 转换流 缓冲流 1 转换流 在学习字符流(FileReader.FileWriter)的时候,其中说如果需要指定编码和缓冲区大小时,可以在字节流的基础上,构造一个InputStreamR ...

  5. java基础(24):转换流、缓冲流

    1. 转换流 在学习字符流(FileReader.FileWriter)的时候,其中说如果需要指定编码和缓冲区大小时,可以在字节流的基础上,构造一个InputStreamReader或者OutputS ...

  6. java:IO流(处理流(缓冲流,转换流,数据流),对象的序列化,Properties)

    字节缓冲流:(BufferedInputStream,BufferedOutStream) *按照流的功能来分:节点流和处理流 *节点流可以直接操作数据源: *InputStream *--FileI ...

  7. IO—》转换流和缓冲流

    转换流 摘要: InputStreamReader和OutputStreamWriter他们分别是FileReader和FileWriter的父类 当只是单纯的读写文件而不改变文件的编码格式时,就分别 ...

  8. java的 IO流之缓冲流(转载)

    java缓冲流本身不具IO功能,只是在别的流上加上缓冲提高效率,像是为别的流装上一种包装.当对文件或其他目标频繁读写或操作效率低,效能差.这时使用缓冲流能够更高效的读写信息.因为缓冲流先将数据缓存起来 ...

  9. IO流之缓冲流

    缓冲流 Java中提高了一套缓冲流,它的存在,可提高IO流的读写速度 缓冲流,根据流的分类字节缓冲流与字符缓冲流. 字节缓冲流 字节缓冲流根据流的方向,共有2个 l  写入数据到流中,字节缓冲输出流 ...

  10. java - >IO流_缓冲流(高效流)

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

随机推荐

  1. IAuthenticationManager.SignOut 退不了

      AuthenticationManager.SignOut(); 这个退不了,然后就加上   AuthenticationManager.SignOut( DefaultAuthenticatio ...

  2. iOS内存管理(objective-c)

    移动app开发中,由于移动设备内存的限制,内存管理是一个非常重要的话题.objective-c的内存管理,不仅是面试当中老生常谈的一个必问话题,也是日常项目开发中,特别需要重视的环节.对于笔者这种以j ...

  3. CF1109A Sasha and a Bit of Relax

    CF1109A Sasha and a Bit of Relax 用 \(xorsum[l,r]\) 表示 \(a[l] \oplus a[l+1] \oplus a[l+2]... a[r-1] \ ...

  4. Jquery 点击父类全选子类 , 子类选父类

    <p> <label style="font-size:18px;font-weight: bold;" class="checkboxs"& ...

  5. 《DSP using MATLAB》示例Example 8.11

    %% ------------------------------------------------------------------------ %% Output Info about thi ...

  6. 接口测试基础——第7篇 Python中_、__、__func__之间的区别

    今天的东西很少,主要是给自己做个笔记,顺便帮大家普及一下Python中的边角知识: 1.if __name__ == "__main__"是什么意思 答:一个.py文件,如果是自身 ...

  7. parceljs 基本使用———又一个前端构建工具

    备注:      又一个新的前端构建工具 1. 安装 yarn global add parcel-bundler 2. 初始化项目 yarn init -y 3. 基本代码 a. 创建 index. ...

  8. C/C++中一些不太注意到的小知识点--[锦集]

    C/C++中一些不太注意到的小知识点--[锦集] C/C++小知识点--[锦集] "="和"<=" 的优先级 1.( (file_got_len = re ...

  9. jieba分词初学

    昨天,做的那个数据分析报告用到了jieba分词.但是只是借用了别人的部分代码.具体函数代表什么还不太明白.今天去官网研究了下..... jieba官网简介 "结巴"中文分词:做最好 ...

  10. Centos6.5 恢复误删的系统面板

    在CentOS6.5下往面板上拖应用程序时,手贱了,点了"Delete This Panel".结果就悲剧了~面板不见了! 从网上搜了一下解决方法,列举一下. 1.新建面板 如果下 ...