【JavaSE笔记】IO(四)字符流

本期知识点：

字符流

1.概述

字节流操作中文数据不是特别的方便，所以就出现了转换流。转换流的作用就是把字节流转换字符流来使用。

2.转换流其实是一个字符流

字符流 = 字节流 + 编码表
编码表
a.就是由字符和对应的数值组成的一张表
b.常见的编码表

ASCII

ISO-8859-1

GB2312

GBK

GB18030

UTF-8

c.字符串中的编码问题

编码

String -- byte[]

解码

byte[] -- String

3.引出：

字节流一次读取一个字节数组有问题:出现中文乱码
那么利用字符流进行操作

4.回顾String类的方法：

public byte[] getBytes(Charset charset)throws UnsupportedEncodingException   将String类型转换成字节数组:编码

public String(byte[] bytes,String charsetName)   将byle类型的数组转换成String类型:解码

5.IO流中的编码问题

a.OutputStreamWriter

OutputStreamWriter(OutputStream os):默认编码，GBK

OutputStreamWriter(OutputStream os,String charsetName):指定编码。

b.InputStreamReader

InputStreamReader(InputStream is):默认编码，GBK

InputStreamReader(InputStream is,String charsetName):指定编码

c.编码问题其实很简单

编码只要一致即可

6.字符流体系：

字符流

Reader

|--InputStreamReader

|--FileReader

|--BufferedReader

Writer

|--OutputStreamWriter

|--FileWriter

|--BufferedWriter

7.字符输入流:

a.概述：

读数据: Reader:抽象类------->InputStreamReader--->FileReader

public InputStreamReader(InputStream in):默认的编码格式

public InputStreamReader(InputStream in,String charsetName):指定的编码格式

字符输入流(转换流) = 字节输入流 + 编码表

b.字符输入流(字符转换输入流)常用的方法:

public int read():读取单个字符

public int read(char[] cbuf, int offset,int length):读取字符数组(读取的是实际长度)

a.

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStreamReader;

public class 字符输入流 {
	public static void main(String[] args) throws IOException {
		//创建字符输入流对象
		InputStreamReader i = new InputStreamReader
				(new FileInputStream("字符输入流例子.txt"));
		//读数据
		//一次读取一个字符
		int x = 0 ;
		while((x=i.read())!=-1){
			System.out.print((char)x);
		}
		//关闭资源
		i.close();
	}
}

b.

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;

public class 字符输入流2 {
	public static void main(String[] args) throws IOException {
		InputStreamReader isr = new InputStreamReader
				(new FileInputStream("字符输入流例子.txt"));
		//一次读取一个字符数组
		char []a = new char[1024];
		int len =0;
		while((len=isr.read(a))!=-1){
			System.out.println(new String(a,0,len));
		}
		isr.close();
	}
}

8.字符输出流

a.字符转换输出流常用方法

i.写数据：

public void write(int c):写单个字符

public void write(char[] cbuf):写一个字符数组

public abstract void write(char[] cbuf, int off,int len):字符数组的一部分

public void write(String str):写字符串

public void write(String str, int off,int len):写一部分字符串

ii.刷新

flush():刷新该流的缓冲

b.(面试题)close()方法和flush()方法的区别?

close():关闭跟该流相关的资源,并且关闭之前,一定要刷新,防止出现没有写进去的情况,关闭之后不能在写数据了!

flush():刷新缓冲的流,刷新之后,还可以给文件中写数据

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.UnsupportedEncodingException;

public class 字符输出流 {
	public static void main(String[] args) throws IOException{
		fun1();
		fun2();
	}

	public static void fun2() throws IOException {
		OutputStreamWriter o = new OutputStreamWriter
				(new FileOutputStream("字符输出流例子2.txt"));
		o.write("农夫山泉\t有点甜\r农夫山泉\n有点\r\n甜");
		o.close();
	}

	public static void fun1() throws IOException {
		OutputStreamWriter o = new OutputStreamWriter
				(new FileOutputStream("字符输出流例子1.txt"),"utf-8");
		o.write("农夫山泉有点甜\r\n农夫山泉有点甜");
		o.close();
	}
}

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;

public class 字符输出流2 {
	public static void main(String[] args) throws IOException {
		OutputStreamWriter osw = new OutputStreamWriter
				(new FileOutputStream("字符输出流例子3.txt"));
		//开始写数据:写单个字符:
//		public void write(int c):写单个字符
		osw.write('a');
//		osw.write(97);
		
		//public void write(char[] cbuf):写一个字符数组
//		char[] ch = {'a','b','c','d','e'} ;
//		osw.write(ch);
		
		//public void write(String str):写字符串
		osw.write("I want something just like this");
		
		//public void write(String str, int off,int len):写一部分字符串
		osw.write("HelloWorld", 2, 5);
		
		
		//刷新该流的缓冲
		osw.flush();
		//public abstract void write(char[] cbuf,  int off,int len):字符数组的一部分
//		osw.write(ch, 2, 3);
		
		//关闭资源
		osw.close(); 
		//java.io.IOException: Stream closed
//		osw.write(ch, 2, 3);
	
	}
}

9.优化的转换流的方式

OutputStreamWriter(new FileOutputStream("文件抽象表现形式")):默认编码

FileWriter + 默认的编码格式

InputStreamReader(new FileInputStream("路径名...")):默认编码

FileReader + 默认编码格式

类 FileReader(java.io)

public class FileReader extends InputStreamReader

用来读取字符文件的便捷类。此类的构造方法假定默认字符编码和默认字节缓冲区大小都是适当的。要自己指定这些值，可以先在 FileInputStream 上构造一个 InputStreamReader。

常用方法：

public FileReader(String fileName) 在给定从中读取数据的文件名的情况下创建一个新 FileReader。

10.字符缓冲流里面有特殊的功能(重点)

a.引出：

字符流为了提高高效的读写操作,所有也引出了,字符缓冲流

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

b.字符缓冲输出流：

public BufferedWriter(Writer out)   创建字符缓冲输出流的对象 默认的缓冲区就足够大了,所以不用指定缓冲区大小

c.字符缓冲输入流：

public BufferedReader(Reader in)   创建一个使用默认大小输入缓冲区的缓冲字符输入流。

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

d.字符缓冲输出流里面的特殊方法

public void newLine() throws IOException：写入一个行的分隔符号

e.字符缓冲输入流里面的特殊方法

public String readLine() throws IOException：一次读取一行

包含该行内容的字符串，不包含任何终止符，如果已到达流末尾，则返回null。

b.

import java.io.BufferedWriter;
import java.io.FileOutputStream;
import java.io.FileWriter;
import java.io.IOException;

public class BufferedWriterDemo {
	public static void main(String[] args) throws IOException {
		//创建字符缓冲输出流对象
		BufferedWriter bw = new BufferedWriter(new FileWriter("字符缓冲输出流.txt"));
		//写数据
		bw.write("Hello");
		bw.write("World");
		bw.flush();
		
		bw.close();
	}
}

c.

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

public class BufferedReadDemo {
	public static void main(String[] args) throws IOException {
		BufferedReader br =new BufferedReader(new FileReader("字符缓冲输入流.txt"));
		//读取数据
		//一次读取一个字符
//		int x = 0 ;
//		while((x=br.read())!=-1){
//			System.out.print((char)x);
//		}
//		
		//一次读取一个字符数组
		char[]a = new char[1024];
		int len = 0 ;
		while((len=br.read(a))!=-1){
			System.out.println(new String(a,0,len));
		}
	}
}

d.e.

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

/*字符缓冲输出流的特殊方法
	public void newLine()throws IOException :写入一个行的分隔符号!
字符缓冲输入流的特殊方法:
	public String readLine() throws IOExce
*/
public class BufferedDemo特殊方法 {
	public static void main(String[] args) throws IOException {
		Write();
		Read();
	}

	public static void Read() throws IOException {
		BufferedReader br = new BufferedReader(new FileReader("字符缓冲输入流.txt"));
		String line = null;
		while((line=br.readLine())!=null){
			System.out.println(line);
		}
		
		br.close();
	}

	public static void Write() throws IOException {
		BufferedWriter bw = new BufferedWriter(new FileWriter("字符缓冲输出流BufferedDemo.txt"));
		
		for (int i = 0; i < 10; i++) {
			bw.write("HelloWorld");
			bw.newLine();
			bw.flush();
		}
		bw.close();
	}
}

11.复制文本文件的读写操作

a.字符流一次读取一行进行读写操作

b.字符流一次读取一个字符数组进行读写操作

a.

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

//	//一次读取一行
public class CopyFileDemo02 {
	public static void main(String[] args) throws IOException {
		//创建字符缓冲输入流对象
		BufferedReader br = new BufferedReader
				(new FileReader("a.txt"));
		//创建字符缓冲输出流对象
		BufferedWriter bw = new BufferedWriter
				(new FileWriter("b.txt"));
		//一次读取一行
		String line = null;
		while((line=br.readLine())!=null){
			//读第一行 写一行
			bw.write(line);
			//换行
			bw.newLine();
			//刷新
			bw.flush();
		}
		bw.close();
		br.close();
	}
}

b.

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

一次读取一个字符数组
public class CopyFileDemo01 {
	public static void main(String[] args) throws IOException {
		//创建字符缓冲输入流对象
		BufferedReader br = new BufferedReader
				(new FileReader("a.txt"));
		//创建字符缓冲输出流对象
		BufferedWriter bw = new BufferedWriter
				(new FileWriter("b.txt"));
		//一次读取一个字符数组
		char []a = new char[1024];
		int len=0;
		while((len=br.read(a))!=-1){
			bw.write(a,0,len);
			bw.flush();
		}
		br.close();
		bw.close();
	}
}

IO流总结：

IO流

|--字节流

|--字节输入流

InputStream

int read():一次读取一个字节

int read(byte[] bys):一次读取一个字节数组

|--FileInputStream

|--BufferedInputStream

|--字节输出流

OutputStream

void write(int by):一次写一个字节

void write(byte[] bys,int index,int len):一次写一个字节数组的一部分

|--FileOutputStream

|--BufferedOutputStream

|--字符流

|--字符输入流

Reader

int read():一次读取一个字符

int read(char[] chs):一次读取一个字符数组

|--InputStreamReader

|--FileReader

|--BufferedReader

String readLine():一次读取一个字符串

|--字符输出流

Writer

void write(int ch):一次写一个字符

void write(char[] chs,int index,int len):一次写一个字符数组的一部分

|--OutputStreamWriter

|--FileWriter

|--BufferedWriter

void newLine():写一个换行符

void write(String line):一次写一个字符串