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
* 已经明确到了具体的体系上。
* B: 转换流子类父类的区别
* a: 继承关系
OutputStreamWriter:
|--FileWriter:
InputStreamReader:
|--FileReader;
* b: 区别
* OutputStreamWriter和InputStreamReader是字符和字节的桥梁：也可以称之为字符转换流。字符转换流原理：字节流+编码表。
* FileWriter和FileReader：作为子类，仅作为操作字符文件的便捷类存在。
当操作的字符文件，使用的是默认编码表时可以不用父类，而直接用子类就完成操作了，简化了代码。
C.代码示例
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
import java.io.*;
import java.util.Date;
import java.util.Properties;
@RunWith(SpringRunner.class)
@SpringBootTest
public class IOTest {
/*
*public BufferedWriter(FileWriter fw) :参数就是一个普通的FileWriter对象；
*
*/
String src = "srctest.txt";
String desc = "desc.txt";
/*
* 字节流writer
* */
@Test
public void TestBufferedWriter() throws Exception {
FileWriter fileWriter = new FileWriter(desc);
BufferedWriter bufferedWriter = new BufferedWriter(fileWriter);
bufferedWriter.write("你好");
bufferedWriter.newLine();
bufferedWriter.flush();
bufferedWriter.close();
}
/*
* 字节流reader
*
* */
/*
* 使用缓冲区流对象,复制文本文件
* 数据源 BufferedReader+FileReader 读取
* 数据目的 BufferedWriter+FileWriter 写入
* 读取文本行, 读一行,写一行,写换行
*/
@Test
public void TestBufferedReader() throws Exception {
BufferedReader bufferedReader = new BufferedReader(new FileReader(src));
BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(desc));
String line = null;
String str = "";
while ((line = bufferedReader.readLine()) != null) {
bufferedWriter.write(line);
//存到str一份
str += line;
bufferedWriter.newLine();
bufferedWriter.flush();
}
System.out.println(str);
bufferedReader.close();
bufferedWriter.close();
}
/*
* Properties集合的方法load
*
* */
@Test
public void propertiesLoadTest() throws Exception {
Properties properties = new Properties();
properties.load(new FileReader(src));
String property = properties.getProperty("driver");
System.out.println(property);
}
/*
* 转换流对象OutputStreamWriter写文本
* 采用UTF-8编码表写入
*/
@Test
public void outPutStreamWriterTest() throws Exception {
FileOutputStream fileOutputStream = new FileOutputStream(desc);
OutputStreamWriter outputStreamWriter = new OutputStreamWriter(fileOutputStream, "utf-8");
outputStreamWriter.write("halo");
outputStreamWriter.close();
}
/*
* 转换流,InputSteamReader读取文本
*采用UTF-8编码表,读取文件utf
*
* */
@Test
public void inputStreamReaderTest() throws Exception {
FileInputStream fileInputStream = new FileInputStream(src);
InputStreamReader inputStreamReader = new InputStreamReader(fileInputStream, "UTF-8");
int read = inputStreamReader.read();
System.out.println(read);
inputStreamReader.close();
}
/*
* 字节流缓冲区流读写字节数组
* 实现文件复制
*
* */
@Test
public void bufferedOutputStreamTest() throws Exception {
BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(new FileOutputStream(desc));
BufferedInputStream bufferedInputStream = new BufferedInputStream(new FileInputStream(src));
Integer len = 0;
byte[] bytes = new byte[2048];
Long start = System.currentTimeMillis();
while ((len = bufferedInputStream.read(bytes)) != -1) {
bufferedOutputStream.write(bytes, 0, len);
bufferedOutputStream.flush();
}
bufferedInputStream.close();
bufferedInputStream.close();
Long end = System.currentTimeMillis();
Long total = end - start;
System.out.println("total:" + total);
}
}