java-IO基本知识点
IO
本节内容在我们开发需求中十分常见，我个人认为理解java IO知识点的重中之重在于理解java.io包下每一种流之间存在的关系。下面我将关系图、基本操作放出（自己敲一遍，且找一下各类存在的关系有助于加深印象）。
一、字节流
1.关系图
2.使用代码
package com.example.io;
import org.junit.jupiter.api.Test;
import java.io.*;
/**
* @author lqh
* @date 2020/6/10
*/
public class ByteStreamTest {
/**
* IO(input/output)在计算机用语中时指输入输出，流是一种抽象的数据传输结构，
* 主要用于进行数据的传输，所以IO流就是指用流的形式来进行数据传输。
*
*流的概念：流就像是一个通道，将两个设备之前建立连接，然后数据在通道直接传输
*
* 流的分类
* 一、按操作数据的单位分：字节流和字符流
* 二、按数据流的流向分：输入流和输入流
* 四种常用流
* FileInputStream、FileOutputStream,FileReader,FileWriter
*
*/
@Test
public void testFileInputStream(){
/**
* FileInputStream，字节输入流
* 该流用于从文件读取数据，
* 常用API:
* public int read() throws IOException //到达文件末尾，则返回-1
* public int read(byte[] b) throws IOException
* public int read(byte[] b,int off,int len) throws IOException
*/
File file=new File("E:"+File.separator+"AioDir"+File.separator+"fileInput.txt");
InputStream f=null;
if(!file.getParentFile().exists()) {
file.getParentFile().mkdir();
}
try {
if(!file.exists()){
file.createNewFile();
}
f=new FileInputStream(file);
/* int n=0;
StringBuffer sBuffer=new StringBuffer();
while (n!=-1) //当n不等于-1,则代表未到末尾
{
n= f.read();//读取文件的一个字节(8个二进制位),并将其由二进制转成十进制的整数返回
char by=(char) n; //转成字符
sBuffer.append(by);
}
System.out.println(sBuffer);*/
byte[] b=new byte[2];
int len=0;
while ((len=f.read(b))!=-1) //当n不等于-1,则代表未到末尾
{
System.out.println(new String(b,0,len)); //读取后的字节数组内容
}
} catch (IOException e) {
e.printStackTrace();
}finally {
if(f!=null){
try {
f.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
@Test
public void testFileOutStream(){
/**
* FileOutputStream,字节输出流
* 该流用于向文件中写数据
* 如果该流打开文件进行输出时，目标文件不存在，那么该流就会创建文件
* 常用API：
* public void write(int b) throws IOException
* public void write(byte[] b) throws IOException {}
* public void write(byte[] b,int off,int len) throws IOException{}
* public void close() throws IOException{}
*/
File file=new File("E:"+File.separator+"AioDir"+File.separator+"fileOutput.txt");
OutputStream f=null;
try {
f=new FileOutputStream(file,true);
f.write("\n\rabc".getBytes());
} catch (IOException e) {
e.printStackTrace();
}finally {
if(f!=null){
try {
f.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
二、字符流
1.关系图（注：FileReader和FileWriter的父类）
2.使用代码
package com.example.io;
import org.junit.jupiter.api.Test;
import java.io.*;
/**
* @author lqh
* @date 2020/6/11
*/
public class CharacterStreamTest {
@Test
public void testFileReader(){
/**
* int read():每次读取一个字符，读到最后返回 -1
* int read(char[] buffer):将字符读进字符数组,返回结果为读取的字符数
* int read(char[] buffer,int off,int len):将读取的字符存储进字符数组 buffer，返回结果为读取的字符数，从索引 off 开始，长度为 len
*/
File file=new File("E:"+File.separator+"AioDir"+File.separator+"fileReader.txt");//文件编码：UTF-8
Reader fileReader=null;
//此处省略目录检查，假设文件存在
try {
fileReader=new FileReader(file);
int len=0;
/* while ((len=fileReader.read())!=-1){
System.out.println((char)len);
}*/
//int read(char[] buffer,int off,int len)
char[] buffer = new char[10]; //每次读取 10 个字符
while((len=fileReader.read(buffer,0,10))!=-1){
System.out.println(new String(buffer,0,len));
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}finally {
if(fileReader!=null){
try {
fileReader.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
@Test
public void TestFileWriter(){
File file=new File("E:"+File.separator+"AioDir"+File.separator+"fileWriter.txt");
/***
* void write(int c):向外写出一个字符
* void write(char[] buffer):向外写出多个字符 buffer
* void write(char[] buffer,int off,int len):把 buffer 数组中从索引 off 开始到 len个长度的数据写出去
* void write(String str):向外写出一个字符串
*/
Writer fileWriter=null;
try {
fileWriter=new FileWriter(file,true);
fileWriter.write("abc你好123");
fileWriter.write("abc你好".toCharArray());
} catch (IOException e) {
e.printStackTrace();
}finally {
if(fileWriter!=null){
try {
/**
* 此处如果注释flush和close，内容不能够写入
*/
fileWriter.flush();
fileWriter.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
三、转换流
1.关系图
2.使用代码
/**
* @author lqh
* @date 2020/6/11
*/
public class ConversionFlowTest {
/**
* OutputStreamWriter
* InputStreamReader
*/
@Test
public void testOutputStreamWriter(){
File file=new File("E:"+File.separator+"AioDir"+File.separator+"fileOutput.txt");
try {
OutputStream outputStream=new FileOutputStream(file); //字节流
Writer outputStreamWriter=new OutputStreamWriter(outputStream); //字节流转字符流
outputStreamWriter.write("www.baidu.com");
outputStreamWriter.write("\r\n你好");
outputStreamWriter.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
@Test
public void testInputStreamReader(){
File file=new File("E:"+File.separator+"AioDir"+File.separator+"fileInput.txt");
try {
InputStream inputStream=new FileInputStream(file); //字节流
Reader inputStreamReader=new InputStreamReader(inputStream); //字节流转字符流
int len=0;
char[] buffer = new char[10]; //每次读取 10 个字符
while((len= inputStreamReader.read(buffer,0,10))!=-1){
System.out.println(new String(buffer,0,len));
}
inputStreamReader.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
}
四、内存流（以字节内存流为例）
1.关系图
2.使用代码
/**
* @author lqh
* @date 2020/6/11
*/
public class MemoryStreamTest {
@Test
public void testByteArrayOutputStream() throws IOException{
/**
* 内存流：在内存中读写数据 （特点：数据在内存中处理比磁盘(硬盘)要更快一些，有时候可能需要临时在内存中保存并处理数据，内存流效率会更高）
* 好处及应用场景:
* 1.代码中需要交换的数据，读写的数据，仅仅是代码之间需要交换，就没必要内存 ==》 磁盘 磁盘 ==》内存 【仅仅可以在内存读写上提高了效率】
* 2.好处：提高了读写的效率，即数据处理的效率
* 3.安全性：线程安全
* ByteArrayInputStream ：包含一个内部缓冲区，该缓冲区包含从流中读取的字节。内部计数器跟踪 read 方法要提供的下一个字节。
* ByteArrayOutputStream ： 此类实现了一个输出流，其中的数据被写入一个 byte 数组。缓冲区会随着数据的不断写入而自动增长。可使用 toByteArray() 和 toString() 获取数据。
* CharArrayReader: 此类实现一个可用作字符输入流的字符缓冲区。
* CharArrayWriter：此类实现一个可用作 Writer 的字符缓冲区。缓冲区会随向流中写入数据而自动增长。可使用 toCharArray() 和 toString() 获取数据。
*
* 注意：void close()：关闭 内存流 无效。 之前的IO流都是跟磁盘文件建立了连接，需要关闭连接即关闭流！ 而关闭内存流跟连接无关
*/
//内存字节流
ByteArrayOutputStream baos = new ByteArrayOutputStream();//不需要路径，写入内存，跟磁盘无需关联
baos.write("ByteArrayOutputStream".getBytes());//将字符串变成字节数组，写入内存
baos.close();//此处关闭内存流无效 下面的数据也可写入
baos.write("\r\nhelloworld".getBytes());//注意：之前的IO流都是跟磁盘文件建立了连接，需要关闭连接即关闭流！ 而关闭内存流跟连接无关
byte[] byteArray = baos.toByteArray();//获取内存中存数据的数组
//使用内存输入流 读取获得内存中的保存数据的数组
ByteArrayInputStream bais = new ByteArrayInputStream(byteArray);//ByteArrayInputStream(byte[] buf):创建一个 ByteArrayInputStream，使用 buf 作为其缓冲区数组。
//读
int len;
byte[] b = new byte[1024];
while((len = bais.read(b)) != -1){
System.out.println(new String(b,0,len));
}
//内存字符流
CharArrayWriter caw = new CharArrayWriter();
caw.write("CharArrayWriter");
char[] ch = caw.toCharArray();
//使用内存输入流 读取获得内存中的保存数据的数组
CharArrayReader car = new CharArrayReader(ch);
//读
int len2;
char[] c = new char[10];
while((len2 = car.read(c)) != -1){
System.out.print(new String(c,0,len2));
}
}
}
五、打印流（以字节打印流为例）
1.关系图
2.使用代码
@Test
public void testStream() throws FileNotFoundException {
/**
* 提供了一系列重载的print()和println()方法，用于多种数据类型的输出。
* PrintStream和PrintWriter的输出不会抛出IOException异常。
* PrintStream和PrintWriter有自动flush功能。
* PrintStream 打印的所有字符都使用平台的默认字符编码转换为字节。 在需要写入字符而不是写入字节的情况下，应该使用 PrintWriter 类。
* System.out返回的是PrintStream的实例。
*
*/
File file=new File("E:"+File.separator+"AioDir"+File.separator+"printFile.txt");
PrintStream printStream=new PrintStream(file);
printStream.println(123);
printStream.println("你好");
printStream.println("1+1="+2);
printStream.printf("姓名：%s；年龄：%d；成绩：%f；性别：%c","tom",18,99.5f,'男') ;
printStream.close();
}
六、RandomAccessFile
1.关系图
2.使用代码
@Test
public void testRandomAccessFile(){
/**
* 优点：
* 1.既可以读也可以写
* 2.可以指定位置进行读写
* 构造器中定义的四种模式
* r 以只读的方式打开文本
* rw 读和写操作都是被允许的（文件不存在，自动创建）
* rws 相当于“rw”，要求对文件内容或元数据的每个更新都同步写入底层设备
* rwd 相当于“rw”，要求对文件内容的每个更新都同步写入底层设备
* 操作文件记录指针:
* long getFilePointer():返回文件记录指针的当前位置
* void seek(long pos) : 将文件记录指针定位到pos位置
*/
RandomAccessFile randomAccessFile=null;
try {
randomAccessFile=new RandomAccessFile("E:"+ File.separator+"AioDir"+File.separator+"randomAccessFile.txt","rw");
System.out.println(randomAccessFile.getFilePointer());
randomAccessFile.write("abcd123".getBytes());
System.out.println(randomAccessFile.getFilePointer());
randomAccessFile.seek(5);
System.out.println(randomAccessFile.readLine());
} catch (IOException e) {
e.printStackTrace();
}finally {
if(randomAccessFile!=null){
try {
randomAccessFile.close();
} catch (IOException e1) {
e1.printStackTrace();
}
}
}
}
七、缓冲流
1.关系图
2.使用代码
@Test
public void testCharBufferedStream(){
File file=new File("E:"+File.separator+"AioDir"+File.separator+"bufferedOutputFile.txt");
try {
FileOutputStream outputStream=new FileOutputStream(file);
BufferedOutputStream bufferedOutputStream=new BufferedOutputStream(outputStream);
bufferedOutputStream.write("abcdefg".getBytes());
bufferedOutputStream.close();
outputStream.close();
FileInputStream fileInputStream=new FileInputStream(file);
BufferedInputStream bufferedInputStream=new BufferedInputStream(fileInputStream);
byte[] b=new byte[1024];
int len=0;
while ((len=bufferedInputStream.read(b))!=-1){
System.out.println(new String(b,0,len));
}
bufferedInputStream.close();
fileInputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
@Test
public void testCharacterBufferStream(){
/**
* 使用字符缓存流可以边读边写
*/
File file=new File("E:"+File.separator+"AioDir"+File.separator+"bufferedCharacterFile.txt");
try {
FileReader reader=new FileReader(file);
BufferedReader bufferedReader=new BufferedReader(reader);
File file1=new File("E:"+File.separator+"AioDir"+File.separator+"writeBufferedCharacterFile.txt");
FileWriter writer=new FileWriter(file1);
BufferedWriter bufferedWriter=new BufferedWriter(writer);
String str="";
while ((str=bufferedReader.readLine())!=null){
System.out.println(str);
bufferedWriter.write(str);
bufferedWriter.newLine();
}
char[] c=new char[1024];
int len=0;
while ((len=bufferedReader.read(c))!=-1){
bufferedWriter.write(c,0,len);
}
bufferedWriter.flush();
bufferedWriter.close();
bufferedReader.close();
writer.close();
reader.close();
} catch (IOException e) {
e.printStackTrace();
}
}
八、对象流
1.关系图
2.使用代码
public class ObjectStream {
/**
* ObjectOutputStream:序列化
* ObjectInputStream:反序列化
*不能序列化Static和Transient修饰的成员变量
**/
public static void main(String[] args) {
/**
* ObjectOutputStream:序列化
* ObjectInputStream:反序列化
*不能序列化Static和Transient修饰的成员变量
* 要序列化的对象必须实现Serializable接口，并且尽量显示的声明serialVersionUID常量
*
**/
File file=new File("D:"+ File.separator+"TestIo"+File.separator+"demo.txt");
//序列化：将内存中对象或基本类型数据序列化到磁盘中
try {
FileOutputStream fileOutputStream=new FileOutputStream(file);
ObjectOutputStream oos=new ObjectOutputStream(fileOutputStream);
oos.writeObject(new String("1223"));
oos.flush();
oos.close();
} catch (IOException e) {
e.printStackTrace();
}
//反序列化：将磁盘中的可序列话文件反序列化到内存中
try {
FileInputStream fileInputStream=new FileInputStream(file);
ObjectInputStream ois=new ObjectInputStream(fileInputStream);
try {
Object object=ois.readObject();
System.out.println(object);
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
ois.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}