IO加强
1字符流
字符流只能读入文本，操作的是char，一个char等于二个bytes。
字符流有二个父类
1)重点为前二个子类
Reader（字符输入流）分为以下子类
*** BufferedReader*:基于缓冲区的读者**
*** InputStreamReader：在字节流和字符流之间做转换的流。*
子类有一个FileReader，是一个基于磁盘文件的字符输入
CharArrayReader：字符数组读者
PipedReader：管道读者
StringReader .. FilterReader ..
Writer（字符输出流）分为一下子类：
*** BufferedWriter***
*** OutputStreamWriter***
子类：FileWriter
PrintWriter：打印写者并提供换行。
CharArrayWriter
PipedWriter
FilterWriter .. StringWriter..
字符流的作用：与字节流相比效率更高，因为一个字符=二个字节，但局限性，应用不广。
1.1FileWriter
是一个基于字符的文件输出流，用于在磁盘中对文本文件做写操作。
构造方法和FileInputStream无大差别。
FileWriter（String name）
FileWriter（File file）
FileWriter（String name，boolean append）
FileWriter（File file，boolean append）
下面这个成员方法：Writer（int c）指传入一个ASCII码，传入文件变为ASCII码对应的字符。
场景：将字符写入磁盘
package com.hujesse.IO;
import java.io.FileWriter;
public class FileWriterTest1 {
public static void main(String[] args) {
try(
FileWriter fw=new FileWriter("b.txt")
){
char [] data = {'h','e','l','l','0'};
// 将字符数组写入
fw.write(data);
//写入部分字符
fw.writer(data,0,5);
//写入单个字符
fw.writer(100);
//写入字符串
fw.writer("Hujesse4");
//写入部分字符串
fw.writer("Hujesse4",0,5);
}catch(Exception e){
e.printStackTrace(); }
}
}
1.2FileReader
基于字符的文件输入流，用来读取磁盘文件的数据。
// FileReader 的源码
public FileReader(String fileName) throws FileNotFoundException {
super(new FileInputStream(fileName));
}
// FileInputStream的源码
public FileInputStream(String name) throws FileNotFoundException {
this(name != null ? new File(name) : null);
}
//说明了字符流是基于字节流的
场景：创建FileReader对象读取数据
package com.hujesse.IO;
import java.io.FileReader;
import java.util.Arrays;
public class FileWriterTest1 {
public static void main(String[] args) {
try(
FileReader fw=new FileReader("b.txt")
){
// d定义一个字符数组，一次从磁盘读取多个
char [] data = new char[32];
fw.read(data);
System.out.println(Arrays.toString(data));
}catch(Exception e){
e.printStackTrace(); } }}
1.3文本文件的拷贝
package com.hujesse.IO;
import java.io.FileReader;
import java.io.FileWriter;
public class FileWriterTest1 {
public static void main(String[] args) {
try(
FileReader fr=new FileReader("b.txt");
FileWriter fw=new FileWriter("b_copy.txt");
){
char []buffer = new char[32];
int len;
while ((len=fr.read(buffer))!=-1){
fw.write(buffer,0,len);
}
}catch(Exception e){
e.printStackTrace(); } }}
2缓冲流
2.1相关概念
流的分类
流的流向：输入流和输出流
按照数据类型：字节流和字符流
按照功能：基础流和装饰流（处理流）
什么是基础流：FileInputStream和FileOutputStream之间操作磁盘的。
什么是装饰流：对基础流做了一个包装，例如FileReader对FileInputStream做了一个装饰，在创建FileReader同时创建了FileInputStream
2.2带有缓冲区的装饰流（基于字节）
带有缓冲区的好处（由来..whatever）：内存读取数据快，磁盘读取数据慢，需要一个缓冲区来匹配速度
基于字节的装饰流：
BufferedInputStream & BufferedOutputStream
2.2.1BufferedInputStream
1)**BufferedInputStream 在基础流之上多了一个基于字节数组的缓冲区，默认大小为8192bytes。
2)缓冲输入流相对于普通输入流的优势是，它提供了一个缓冲数组，每次调用read方法的时候，它首先尝试从缓冲区里读取数据，若读取失败（缓冲区无可读数据），则选择从物理数据源（譬如文件）读取新数据（这里会尝试尽可能读取多的字节）放入到缓冲区中，最后再将缓冲区中的内容部分或全部返回给用户.由于从缓冲区里读取数据远比直接从物理数据源（譬如文件）读取速度快。
3) 里面有二个属性，pos（position）和count，当pos==count，说明读取完毕了
场景：使用缓冲输入流读取磁盘数据并打印
package com.hujesse.IO;
import java.io.BufferedInputStream;
import java.io.FileInputStream;
public class BufferedInputTest {
public static void main(String[] args) {
try(
BufferedInputStream bu = new BufferedInputStream(new FileInputStream("a.txt"));
){
//每次读取1024个字节
byte[] data = new byte[1024];
int len = 0;
// 理解String StringBuffer StringBuilder的区别；capacity容积
StringBuilder sb = new StringBuilder(500);
while ((len=bu.read(data))!=-1){
//将字节数组转换为字符串
String str = new String(data,0,len);
//将字符串追加到StringBuilder
sb.append(str);
}
System.out.println(sb.toString());
}catch (Exception e){
e.printStackTrace(); } }}
2.2.2BufferedOutputStream
BufferedOutputStream是一个缓冲输出流，内部也有一个缓冲区，在写数据的时候，会将数据写入缓冲区直到写满，再讲缓冲区的数据一次性写入磁盘。
场景：使用字节缓冲流拷贝图片
package com.hujesse.IO;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
public class BufferedOutPutTest {
public static void main(String[] args) {
try (
BufferedOutputStream os = new BufferedOutputStream(new FileOutputStream("BufferCopy.jpg"));
BufferedInputStream in = new BufferedInputStream(new FileInputStream("D:\timg.jpg"));
) {
byte[] data = new byte[1024];
int len = 0;
while ((len = in.read(data)) != -1) {
os.write(data, 0, len);
}
} catch (Exception e) {
e.printStackTrace();
} }}
// 和FileInputStream操作真没什么区别
唯一需要注意的是BufferOutputStream(OutputStream out)需要传入对象，子类也可以。
2.3带有缓冲区的装饰流（基于字符）
他们内部也有一个缓冲区，这个缓冲区是一个char[],默认长度为8192
2.3.1BufferedReader
构造方法：BufferedReader（Reader）：创建一个基于字符的缓冲流，参数是一个Reader的子类，例如：FileReader。
它除了支持read（）的方法外还支持
readLine():读取缓冲区里的一行数据，读到 就会结束。
2.3.2 BufferedWriter
构造方法：BufferWriter（Writer）：创建一个基于字符的缓冲流，参数是一个Writer的子类，例如：FileWriter。
还支持newLine（）：写入 换行
场景：使用字符缓冲流进行文件的copy&paste
package com.hujesse.IO;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
// bufferReader BUfferedWriter进行copy& paste
public class BufferRead {
public static void main(String[] args) {
try(
BufferedReader bf = new BufferedReader(new FileReader("D:\bia.txt"));
BufferedWriter bw = new BufferedWriter(new FileWriter("copyChar.txt"));
){
// 用一个String类型接受数据
String line = null;
while ((line=bf.readLine())!=null){
bw.write(line);
//换行
bw.newLine();
}
}catch (Exception e){
e.printStackTrace(); } }}
3内存流(重点)
特征：数据的读和写都在内存中完成，可以将数据写入内存中，也可以从内存中读取数据。
3.1 ByteArrayOutputStream
基于字节的内存输出流，它是一个基础流，主要用于将程序中的数据转换为字节数组，然后写入流中。
构造方法如下：
ByteArrayOutputStream（）无参构造方法，用来创建字节数组输出流对象。
ByteArrayOutputStream（int size）同上，不过参数size是字节数组的长度。
场景：定义一个变量，将其转换为字节数组，然后将其写入到ByteArrayOutputStream流里面
package com.hujesse.IO;
import java.io.ByteArrayOutputStream;
public class ByteArrayOutStream {
public static void main(String[] args) {
try (
ByteArrayOutputStream bo = new ByteArrayOutputStream();
) {
String str = "helloIO";
bo.write(str.getBytes());
//bo.flush(); JVM自动帮我门做了这种事
} catch (Exception e) {
e.printStackTrace(); } }}
3.2 ByteArrayInputStream
是一个字节数组输入流，也是一个基础流，主要用于将内存的数据读取到程序中。
场景：定义一个变量，将其转换为字节数组，然后将其写入到ByteArrayInputStream流,最后调取类的方法读取数据
package com.hujesse.IO;
import java.io.ByteArrayInputStream;
public class ArrayInputStreamTest {
public static void main(String[] args) {
try(
ByteArrayInputStream bi = new ByteArrayInputStream("test".getBytes());
){
int data = bi.read();
System.out.println((char)data);
}catch(Exception e){
e.printStackTrace();
} }}
// FileInputStream(String name)读取磁盘里面的数据
//ByteArrayInputStream(byte[])读取内存中的数据
综合案例：将百度服务器的logo下载到本地磁盘
package com.hujesse.IO;
/**
* 场景：从百度服务器下载资源
* 创建URL对象，指定百度服务器的地址
* 打开URL链接
* 读取百度服务器数据，将读取的数据存储到内存流
* 创建FileInputStream，将内存流数据写到本地磁盘
*/
import java.io.*;
import java.net.URL;
public class ArrayInputStreamTest {
public static void main(String[] args) throws Exception{
URL url = new URL("https://www.baidu.com/img/PCtm_d9c8750bed0b3c7d089fa7d55720d6cf.png");
try(
//url.openStream()相当于在浏览器输入服务器地址，然后回车
InputStream in = url.openStream();
ByteArrayOutputStream bo = new ByteArrayOutputStream();
){
// 使用输入流读取百度服务器图片，将读取的数据放进内存流
byte[] bufffer = new byte[1024];
int len = 0;
while ((len=in.read(bufffer))!=-1){
bo.write(bufffer,0,len); }
bo.flush();
// 获取内存流里面的字节数
try(
FileOutputStream fo = new FileOutputStream(new File("Logo.png"));
){
//bo.toByteArray()将内存流里面的数据转换为字节数组
byte [] data2 = bo.toByteArray();
fo.write(data2);
}catch(Exception e
){
e.printStackTrace();
}
}catch (Exception e){
e.printStackTrace(); } }}
//最主要的是内存流有个方法 byteArrayOutputStream.toByteArray()
//可以将内存流里面的的数据全部转换为字节数组
4对象输入和输出流
4.1 ObjectInputStream
是一个基于字节的对象输入流，同时也是一个装饰流，主要用于读取内存中的对象
构造方法：ObjectInputStream（InputStream）
1)工作中可以使用对象输入和输出流来完成对象的克隆
2)什么叫对象的克隆？在原始对象的基础上繁殖新对象，新对象数据和原对象一模一样
4.2 ObjectOutputStream
是一个基于字节的对象输出流，同时也是一个装饰流，主要用于读取内存中的对象
构造方法：ObjectOutputStream（outputStream）
场景：对象的克隆
package com.hujesse.IO;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
public class ObjectInPutStreamCLONE {
public static void main(String[] args) {
Student hujesse4 = new Student(20, "hujesse4");
try (
//创建原始输出流对象，将字节数组输出流注入到对象输出流里面
ByteArrayOutputStream bo= new ByteArrayOutputStream();
ObjectOutputStream op = new ObjectOutputStream(bo);
) {
//将对象写入内存
op.writeObject(hujesse4);
try(
// 注意把输出流的内容转换为对象数组传给输入流.bo.toByteArray()存储了原始数据
ByteArrayInputStream bi = new ByteArrayInputStream(bo.toByteArray());
ObjectInputStream ob = new ObjectInputStream(bi);
){
Object stuClone = ob.readObject();
System.out.println(stuClone);
}catch (Exception e){
System.out.println("clone Object failed");
e.printStackTrace();
}
} catch (Exception e) {
System.out.println("clone Object failed");
e.printStackTrace(); } }}
package com.hujesse.IO;
import java.io.Serializable;
//参与clone的对象必须继承implements Serializable接口，否则抛出异常
public class Student implements Serializable {
private int age;
private String name;
/* getters and setters */
小改进，写成一个静态方法
public static Object ObejctClone (Object obj)throws Exception{
try (
ByteArrayOutputStream bo = new ByteArrayOutputStream();
ObjectOutputStream oo = new ObjectOutputStream(bo);
) {
oo.writeObject(obj);
try (
ByteArrayInputStream bi = new ByteArrayInputStream(bo.toByteArray());
ObjectInputStream oi = new ObjectInputStream(bi);
){
return oi.readObject();
} } }
5转换流
5.1 InputStreamReader
它是一个连接字节流和字符流之间的桥梁，也是一个输入流
// 为什么需要转换流 ---
为了解决设备之间编码方式不统一的问题
场景：将D盘目录下的一个文本文件拷贝，可它使用的是GBK编码，但IDEA使用的是UTF-8编码，拷贝会出现乱码。
什么时候用呢：即源头编码和目标编码不一致时，使用转换流（指定编码格式）即解决乱码
但是工作中一般定义有缓冲区的转换流
new BufferedReader(new InputStreamReader(new FileInputStream("D:\bia.txt"),"GBK"))
new BufferedWriter(new InputStreamWriter(new FileOutputStream("copy.txt"),"GBK"))
场景：使用带有缓冲区的读者写者配合转换流进行文件的复制粘贴
package com.hujesse.IO;
import java.io.*;
public class InputStreamReaderTES {
public static void main(String[] args) {
try(
BufferedReader bf=new BufferedReader(new InputStreamReader(new FileInputStream("D:\bia.txt"),"UTF-8"));
BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("copy.txt"),"UTF-8"));
){
String line = null;
while((line=bf.readLine())!=null){
bw.write(line);
bw.newLine();
}
}catch(Exception e){
e.printStackTrace(); } }}
5.2 OutputStreamWriter
它是一个连接字节流和字符流之间的桥梁，也是一个输出流
见上个场景
6读写基本数据类型
6.1 DataInputStream
构造函数DataInputStream(InputStream )
还提供了一些读写的方法
readint()读整数
readFloat()读单精度浮点小数
readDouble()读双精度浮点小数
readBoolean()读取Boolean
readChar()读字符
readUTF()读字符串
6.2 DataOutputStream
构造函数DataOutputStream(OutputStream)
还提供了一些写的方法
writeInt(int);写入整数
writeFloat（Float）：写入单精度浮点数
场景：定义一个Student数组，使用DataOutputStream将数据写入磁盘，然后用DataInoutStream读写出来并打印；
package com.hujesse.IO;
import java.io.*;
public class DataInOutputStreamTest {
private static Student[] students = {
new Student(20,"hujesse"),
new Student(13,"cousin")};
public static void main(String[] args)
{
try(
DataOutputStream dot = new DataOutputStream(new FileOutputStream(new File("student")))
){
for(Student stu:students){
dot.writeInt(stu.getAge());
dot.writeUTF(stu.getName());
}
try(
DataInputStream dit = new DataInputStream(new FileInputStream("student"));
){
for(int i =0;i<students.length;i++){
int age = dit.readInt();
String name = dit.readUTF();
System.out.println(age);
System.out.println(name);
}
}catch (Exception e){e.printStackTrace();
}
}catch (Exception e){e.printStackTrace();
} }}
7打印流(了解)
PrintWriter：就是BufferedWriter + 换行
PrintWriter时一个字符流同时也是一个装饰流提供了换行的功能；
方法为：pw.println(args);
小知识
1)boolean不是布尔类型，而是logic（逻辑）类型