2017 - 10 -27 IO流 字符流 字符缓冲流

1 转换流
由于字节流操作中文不是特别方便，所以，java就提供了转换流
字符流=字节流+编码表

2 编码表
编码表：由现实世界的字符和对应的数值组成的一张表
ASCII码表:最高位位符号位，其余为数值位
      'a'  97
      'A'  65
      '0'  48

ASCII：美国标准信息交换码。
用一个字节的7位可以表示。
ISO8859-1：拉丁码表。欧洲码表，用一个字节的8位表示。
GB2312：中国的中文编码表。
GBK：中国的中文编码表升级，融合了更多的中文文字符号。
GB18030：GBK的取代版本
BIG-5码 ：通行于台湾、香港地区的一个繁体字编码方案，俗称“大五码”。
Unicode：国际标准码，融合了多种文字。
所有文字都用两个字节来表示,Java语言使用的就是unicode
UTF-8：最多用三个字节来表示一个字符。(国际化)
UTF-8不同，它定义了一种“区间规则”，这种规则可以和ASCII编码保持最大程度的兼容：它将Unicode编码为00000000-0000007F的字符，用单个字节来表示 它将Unicode编码为00000080-000007FF的字符用两个字节表示? 它将Unicode编码为00000800-0000FFFF的字符用3字节表示?

3 String类中的编码和解码问题
String(byte[] bytes,String charsetName):通过制定的字符串解码字节数组
byte[] getBytes(String charsetName):使用制定的字符集合把字符串编码为字节数组

编码：把看得懂的编程看不懂的
String -- byte[]
解码：把看不懂的编程看的懂得
byte[] -- String

String s = "你好";

//String -- byte[]
byte[] bys = s.getBytes();//{-60,-29,-70,-61}
//byte[] bys = s.getBytes("GBK");//{-60,-29,-70,-61}
byte[] bys = s.getBytes("UTF-8");//{-28,-67,-96,-27,-91,-67}
System.out.println(Arrays.toString(bys));//{-60,-29,-70,-61}

//byte[] -- String
//String ss = new String(bys);//你好
//String ss = new String(bys,"GBK");//你好
//String ss = new String(bys,"UTF-8");//???
System.out.println(ss);

4 转换流
(1)
OutputStreamWriter(OutputStream out):根据默认编码把字节流的数据转换为字符流
OutputStreamWriter(OutputStream out,String charsetName):根据制定该编码把字节流数据转换为字符流
把字节流转换为字符流
字符流=字节流+编码表
//创建对象
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("osw.txt"));//指定默认GBK
//写数据
osw.write("中国");
//释放资源
osw.close();

(2)
InputStreamWriter(InputStream is):用默认的编码读取数据
InputStreamWriter(InputStream is,String charsetName):用指定的编码读取数据
//创建对象
InputStreamWriter isr = new InputStreamReader(new FileInputStream("osw.txt"));
//读取数据
//一次读取一个字符
int ch = 0;
while((ch = isr.read())!=-1){
    System.out.print((char) ch);
}
//释放资源
isr.close();

5 字符流
(1) 5种写数据的方式
OutputStreamWriter
public void write(int c):写一个字符
public void write(char[] cbuf)：写一个字符数组
public void write(char[] cbuf,int off,int len)：写一个字符数组的一部分
public void write(String str)：写一个字符串
public void write(String str,int off,int len)：写一个字符串的一部分
------------------------------------
面试题：close()和flush()的区别？
A:close()关闭流对象，但是先刷新一次缓冲区，关闭之后，该对象不可以继续再使用了。
B:flush()s仅仅刷新缓冲区，刷新之后，该对象还可以继续使用
------------------------------------
//创建对象
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("osw2.txt"));
//写数据
//public void write(int c):写一个字符
//osw.write('a');
//osw.write(97);
//为什么数据没有进去呢？
//原因是：字符=2字节
//文件中数据存储的基本单位是字节
//void flush()

//public void write(char[] cbuf):是一个字符数组
char[] chs = {'a','b','c','d','e'};
osw.write(chs);

//public void write(char[] cbuf,int off,int len)：写一个字符数组的一部分
osw.write(chs,1,3);

//public void write(String str)：写一个字符串
osw.write("喵喵喵")

//public void write(String str,int off,int len)：写一个字符串的一部分
osw.write("喵喵喵",2,3)

//刷新缓冲区
osw.flush();

//释放资源
osw.close(); //close的作用是先刷新再释放

(2) 两种读数据的方式
InputStreamWriter
int read():一次读取一个字符
int read(char[] chs):一次读取一个字符数组
--------------------------------------------
//创建对象
InputStreamWriter isr = new InputStreamWriter(new FileInputStream("StringDemo.java"));
//一次读取一个字符
//int ch = 0;
//while((ch = isr.read())!=-1){
//  System.out.print((char)ch);
//}

//一次读取一个字符数组
char[] chs = new char[1024];
int len =0;
while((len=isr.read(chs))!=-1){
   System.out.print(new String(chs,0,len));
}

6 字符流赋值文本
数据源：
      a.txt -- 读取数据 -- 字符转换流 -- InputStreamReader
目的地：
      b.txt -- 写出数据 -- 字符转换流 -- OutputStreamWriter

(1) 复制
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
public class CopyFileDemo {
public static void main(String[] args) throws IOException {
// 封装数据源
InputStreamReader isr = new InputStreamReader(new FileInputStream(
"a.txt"));
// 封装目的地
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(
"b.txt"));

// 读写数据
// 方式1
// int ch = 0;
// while ((ch = isr.read()) != -1) {
// osw.write(ch);
// }

// 方式2
char[] chs = new char[1024];
int len = 0;
while ((len = isr.read(chs)) != -1) {
osw.write(chs, 0, len);
// osw.flush();
}

// 释放资源
osw.close();
isr.close();
}
}

(2) 简化版
由于我们常见的操作都是使用本地默认编码，所以，不用指定编码。
而转换流的名称有点长，所以，java就提供了其子类供我们使用、
OutputStreamWriter = FileOutputStream + 编码表(GBK)
FileWriter = FileOutputStream + 编码表(GBK)
InputStreamReader = FileInputStream + 编码表(GBK)
FileReader = FileInputStream + 编码表(GBK)
------------------------------------------------
需求：把当前项目目录下的a.txt内容复制到当前项目目录下的b.txt中
a.txt -- 读取数据 -- 字符转换流 -- InputStreamReader -- FileReader
b.txt -- 写出数据 -- 字符转换流 -- OutputStreamWriter -- FileWriter
// 封装数据源
FileReader fr = new FileReader("a.txt");
// 封装目的地
FileWriter fw = new FileWriter("b.txt");

// 一次一个字符
// int ch = 0;
// while ((ch = fr.read()) != -1) {
// fw.write(ch);
// }

// 一次一个字符数组
char[] chs = new char[1024];
int len = 0;
while ((len = fr.read(chs)) != -1) {
fw.write(chs, 0, len);
fw.flush();
}

// 释放资源
fw.close();
fr.close();

7 字符缓冲流
BufferredReader:字符缓冲输入流
BufferredWriter:字符缓冲输出流
BufferedReader 字符缓冲输入流
从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取。 
可以指定缓冲区的大小，或者可使用默认的大小。大多数情况下，默认值就足够大了。 
// 创建字符缓冲输入流对象
BufferedReader br = new BufferedReader(new FileReader("bw.txt"));

// 方式1
// int ch = 0;
// while ((ch = br.read()) != -1) {
// System.out.print((char) ch);
// }

// 方式2
char[] chs = new char[1024];
int len = 0;
while ((len = br.read(chs)) != -1) {
System.out.print(new String(chs, 0, len));
}

// 释放资源
br.close();
-------------------------------------------
BufferedWriter:字符缓冲输出流
将文本写入字符输出流，缓冲各个字符，从而提供单个字符、数组和字符串的高效写入。 
可以指定缓冲区的大小，或者接受默认的大小。在大多数情况下，默认值就足够大了。 
// BufferedWriter(Writer out)
// BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(
// new FileOutputStream("bw.txt")));
BufferedWriter bw = new BufferedWriter(new FileWriter("bw.txt"));
bw.write("hello");
bw.write("world");
bw.write("java");
bw.flush();
bw.close();
}

8 字符缓冲流的特殊方法
BufferedReader
 public void newLine():根据系统来决定换行符
BufferedWrite
 public String readLine():一次读取一行数据
 包含该行内容的字符串，不包含任何终止符，如果已达到末尾，则返回null

   //创建字符流缓冲输出对象
   BufferedWriter bw = new BufferedWriter(new FileWriter("bw.txt"));
   //换行
   for(int x = ;x<0;x++){
        bw.write("hello"+x);
      //bw.write("\r\n");
        bw.newLine();
   }
   bw.close();

   //创建字符流缓冲输入对象
   BufferedReader br = new BufferedReader(new FileReader("bw.txt"));
   //public String readLine():一次读取一行数据
   //String line =br.readLine();
   //System.out.println(line);
   //line = br.readLine();
   //System.out.println(line);
    
   //最终版代码
     String line =null;
     while((line=br.readLine())!=-1){
           System.out.println(line);
     }
   //释放资源
     br.close();

9 IO流小结

10 字符流五种复制文本方式
String srcString = "c:\\a.txt";
String destString = "d:\\b.txt";
// method1(srcString, destString);
// method2(srcString, destString);
// method3(srcString, destString);
// method4(srcString, destString);
method5(srcString, destString);
}

     ***推荐使用// 字符缓冲流一次读写一行数据
private static void method5(String srcString, String destString)
throws IOException {
BufferedReader br = new BufferedReader(new FileReader(srcString));
BufferedWriter bw = new BufferedWriter(new FileWriter(destString));
String line = null;
while ((line = br.readLine()) != null) {
bw.write(line);
bw.newLine();
bw.flush();
}
bw.close();
br.close();
}

// 字符缓冲流一次读写一个字符数组
private static void method4(String srcString, String destString)
throws IOException {
BufferedReader br = new BufferedReader(new FileReader(srcString));
BufferedWriter bw = new BufferedWriter(new FileWriter(destString));
char[] chs = new char[1024];
int len = 0;
while ((len = br.read(chs)) != -1) {
bw.write(chs, 0, len);
}
bw.close();
br.close();
}

// 字符缓冲流一次读写一个字符
private static void method3(String srcString, String destString)
throws IOException {
BufferedReader br = new BufferedReader(new FileReader(srcString));
BufferedWriter bw = new BufferedWriter(new FileWriter(destString));
int ch = 0;
while ((ch = br.read()) != -1) {
bw.write(ch);
}
bw.close();
br.close();
}


// 基本字符流一次读写一个字符数组
private static void method2(String srcString, String destString)
throws IOException {
FileReader fr = new FileReader(srcString);
FileWriter fw = new FileWriter(destString);
char[] chs = new char[1024];
int len = 0;
while ((len = fr.read(chs)) != -1) {
fw.write(chs, 0, len);
}
fw.close();
fr.close();
}

// 基本字符流一次读写一个字符
private static void method1(String srcString, String destString)
throws IOException {
FileReader fr = new FileReader(srcString);
FileWriter fw = new FileWriter(destString);
int ch = 0;
while ((ch = fr.read()) != -1) {
fw.write(ch);
}
fw.close();
fr.close();
}
}

11 复制图片的四种方式
复制数据，如果我们知道用记事本打开并能够读懂，就用字符流，否则用字节流。
所以复制图片用字节流。
而字节流有4种方式，所以做这个题目我们有4种方式。推荐掌握第4种。
// 使用File对象做为参数
File srcFile = new File("c:\\a.jpg");
File destFile = new File("d:\\b.jpg");
// method1(srcFile, destFile);
// method2(srcFile, destFile);
// method3(srcFile, destFile);
method4(srcFile, destFile);
}

     ***推荐使用// 字节缓冲流一次读写一个字节数组
private static void method4(File srcFile, File destFile) throws IOException {
BufferedInputStream bis = new BufferedInputStream(new FileInputStream(
srcFile));
BufferedOutputStream bos = new BufferedOutputStream(
new FileOutputStream(destFile));
byte[] bys = new byte[1024];
int len = 0;
while ((len = bis.read(bys)) != -1) {
bos.write(bys, 0, len);
}
bos.close();
bis.close();
}

// 字节缓冲流一次读写一个字节
private static void method3(File srcFile, File destFile) throws IOException {
BufferedInputStream bis = new BufferedInputStream(new FileInputStream(
srcFile));
BufferedOutputStream bos = new BufferedOutputStream(
new FileOutputStream(destFile));
int by = 0;
while ((by = bis.read()) != -1) {
bos.write(by);
}
bos.close();
bis.close();
}

// 基本字节流一次读写一个字节数组
private static void method2(File srcFile, File destFile) throws IOException {
FileInputStream fis = new FileInputStream(srcFile);
FileOutputStream fos = new FileOutputStream(destFile);
byte[] bys = new byte[1024];
int len = 0;
while ((len = fis.read(bys)) != -1) {
fos.write(bys, 0, len);
}
fos.close();
fis.close();
}

// 基本字节流一次读写一个字节
private static void method1(File srcFile, File destFile) throws IOException {
FileInputStream fis = new FileInputStream(srcFile);
FileOutputStream fos = new FileOutputStream(destFile);
int by = 0;
while ((by = fis.read()) != -1) {
fos.write(by);
}
fos.close();
fis.close();
}
}

12 集合---文本文件
(1)把集合中的数据存储到文本文件
    // 封装数据与(创建集合对象)
ArrayList<String> array = new ArrayList<String>();
array.add("hello");
array.add("world");
array.add("java");
// 封装目的地
BufferedWriter bw = new BufferedWriter(new FileWriter("a.txt"));
// 遍历集合
for (String s : array) {
// 写数据
bw.write(s);
bw.newLine();
bw.flush();
}
// 释放资源
bw.close();
(2)从文本文件读取数据到集合中
// 封装数据源
BufferedReader br = new BufferedReader(new FileReader("b.txt"));
// 封装目的地(创建集合对象)
ArrayList<String> array = new ArrayList<String>();
// 读取数据存储到集合中
String line = null;
while ((line = br.readLine()) != null) {
array.add(line);
}
// 释放资源
br.close();
// 遍历集合
for (String s : array) {
System.out.println(s);
      }