Java IO详解
Posted 午觉千万别睡过
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Java IO详解相关的知识，希望对你有一定的参考价值。
什么是I/O流?
I:Input O:Output
通过IO可以完成硬盘文件的读和写。
IO流又叫输入输出流 ，输入和输出均是以内存作为参照物。
I/O流的分类?
1.按照流的方向进行分类:
以内存作为参照物，往内存中去，叫做输入，或者叫做读。从内存中出来，叫做输出，或者叫做写。
2.按照读取数据方式不同进行分类:
- 按照字节的方式读取数据，一次读取1个字节byte,等同于一次读取8个二进制位。这种流是万能的，什么类型的文件都可以读取。包括:文本文件，图片，声音文件，视频文件。
example:假设文件file1.txt,采用字节流的话是这样读的:
a中国bo张三fe：
第一次读: 一个字节,正好读"a"。
第二次读:一个字节,正好读到"中"字符的一半。
第三次读: 一个字节,正好读到"中字符的另外一半。 - 按照字符的方式读取数据, 一次读取一个字符，这种流是为了方便读取普通文本文件而存在的，这种流不能读取:图片、声音、视频等文件。只能读取纯文本文件，连word文件都无法读取。
example:假设文件file1.txt,采用字符流的话是这样读的:
a中国bo张三fe：
第一次读:'a’字符('a’字符在windows系统中占用1个字节。)
第二次读:'中’字符('中’字符在windows系统中占用2个字节。)
综上所述:流的分类
输入流、输出流、字节流、字符流
Java IO流这块有四大家族(首领):(均是抽象类)
java.io.InputStream 字节输入流
java.io.OutputStream 字节输出流
java.io.Reader 字符输入流
java.io.Writer 字符输出流
所有的流都实现了:java.io.Colseable接口，都是可关闭的，都有close()方法. 流毕竟是一个管道，这个是内存和硬盘之间的通道，养成一个好习惯，用完流将其关闭。
所有的输出流都实现了:
java.io.Flushable接口，都是可刷新的，都有flush()方法。养成一个好习惯，输出流在最终输出之后，一定要记得flush()刷新一下。这个刷新表示将通道/管道当中剩余未输出的数据强行输出完(清空管道!)刷新的作用就是清空管道。如果没有flush()可能会导致数据丢失.
注意:在java中只要"类名"以Stream结尾的都是字节流。以"Reader/Writer"结尾的都是字符流 。
Java.io 包下需要掌握的流有16个:
文件专属
java.io.FileinputStream (用得最多)
java.io.FileOutputStream (用得最多)
java.io.FileReader
java.io.FileWriter
转换流:(将字节流转换成字符流)
java.io.InputStreamReader
java.io.outputStreamWriter
缓冲流专属:
java.io.BufferedReader
java.io.BufferedWriter
java.io.BufferedInputStream
java.io.BufferedOutputStream
数据流专属:
java.io.DataInpoutStream
java.io.DataOutputStream
标准输出流:
java.io.PrintWriter
java.io.PrintStream
对象专属流:（掌握）
java.io.ObjectInputStream
java.io.ObjectOutputStream
FileInputStream
IDEA的默认路径是整个工程下的包
- 文件字节输入流，万能的，任何类型的文件都可以采用这个流来读
- 字节的方式，完成输入的操作，完成读的操作(硬盘 —> 内存)
example1:
FileInputStream fis = new FileInputStream("D:\\\\Desktop\\\\temp.txt");
// 开始读
int read = fis.read(); // read是读到的字节大小
int read1 = fis.read(); // read1是读到的字节大小
// 如果读不到数据 则返回负一
System.out.println(read);
System.out.println(read1);
fis.close();
note:
- idea会自动把\\编程\\，因为java中****表示转义,故路径处采用的是\\
- 读到文件末尾时read()方法会返回-1
example2: 对example1进行改进，采用循环的方式!
FileInputStream fis = null;
// 指向一个文件
fis = new FileInputStream("D:\\\\Desktop\\\\temp.txt");
while(true)
int read = fis.read();
if(read==-1) // 读到末尾的时候返回值为-1
break;
System.out.println(read);
if(fis != null)
fis.close();
该程序的缺点:一次读取一个字节byte，这样内存和硬盘交互太频繁，基本时间/资源都耗费在交互上面了，能不能一次性读取多个字节呢?
example3:
* int read(byte[] b)
* 一次最多读取b.length个字节
* 减少硬盘和内存的交互，提高程序的执行效率
* 往byte[]数组当中读
FileInputStream fis = null; // 创建一个流
// IDEA默认的当前路径在哪里?
// 工程Project的根就是IDEA的默认当前路径。
fis = new FileInputStream("tempfile");
// 开始读 采用byte数组 一次读取多个字节。最多读取数组.length个字节.
byte[] bytes = new byte[4]; // 准备一个4长度的byte数组，一次最多读取4个字节
// 返回读到的字节数量（不是字节本身）(把数据读取到了byte数组当中)
int readCount = fis.read(bytes); // 4
//System.out.println(new String(bytes)); // 将字节数组全部转换成字符串
// 不应该全部转换，应该是读取了多少字节，转换多少个
System.out.println(new String(bytes,0,readCount));
System.out.println(readCount);
readCount = fis.read(bytes); // 2
System.out.println(new String(bytes,0,readCount));
System.out.println(readCount);
readCount = fis.read(bytes); // -1 （一个字节都没有读到）
System.out.println(new String(bytes,0,readCount));
System.out.println(readCount);
当read方法中的参数为byte[]数组时，该方法的返回值为byte[]数组在文件中读取的字节数量，而此时的byte[]数组中的内容为在目标文件中所读取的内容。
example4: 建议使用这种方式读取
FileInputStream fis = null;
fis = new FileInputStream("tempfile");
// 准备一个byte数组
byte[] bytes = new byte[4];
int readCount;
while((readCount = fis.read(bytes))!=-1)
// 把byte数组转换成字符串，读到多少个转换多少个
System.out.print(new String(bytes,0,readCount));
if(fis!=null)
fis.close();
补充：FileInputStream类的其它方法:
* int available(); // 返回流当中的剩余的没有读到的字节数量
* long skip(long n); // 跳过几个字节不读
FileInputStream fis = null;
fis = new FileInputStream("tempfile");
System.out.println("总字节数量:"+fis.available());
fis.skip(3);
System.out.println(fis.read());
FIleOutputStream
文件字节输出流，负责写，从内存到硬盘
example:
FileOutputStream fos = null;
// myfile文件不存在的时候会自动新建！
// fos = new FileOutputStream("myfile");
// 不清空原文件的方式写入 则选择以追加的方式写入 不会清空原文件内容
fos = new FileOutputStream("myfile1",true); // true表示追加
// 开始写
byte[] bytes = 97,98,99,100;
// 将byte数组全部写出
fos.write(bytes); // abcd
// 将byte数组的一部分写出
fos.write(bytes,0,2); //ab
// 以上两种方式都是将原文件清空之后再写入的(谨慎使用)
// 写完之后，一定要刷新
String s = "我是一个中国人,我骄傲";
// 将字符串转换为byte数组
byte[] bytes1 = s.getBytes();
fos.write(bytes1);
fos.flush();
*** note :
以不清空原文件的方式写入。选择以追加的方式写入，需要在创建流对象的时候引入参数true*表示以追加的方式写入硬盘。
文件的复制
原理图如下:
文件的拷贝，是先从硬盘中读取到文件里面，再通过内存写入硬盘从而完成文件的复制。使用FileInputStream + FileOutputStream 完成文件的拷贝拷贝的过程应该一边读，一边写。使用以上字节流拷贝文件的时候，文件的类型随意，万能的，什么样的文件都能拷贝。
example1:使用FileInputStream + FileOutputStream 进行拷贝
FileInputStream fis = null;
FileOutputStream fos = null;
// 创建一个输入流对象
fis = new FileInputStream("myfile");
// 创建一个输出流对象
fos = new FileOutputStream("myfile2");
// 最核心的: 一边读，一边写(1024个字节是1kb)
byte[] bytes = new byte[1024 * 1024]; // 一次拷贝1M
int readCounts = 0;
while((readCounts = fis.read(bytes)) != -1)
fos.write(bytes,0,readCounts);
// 刷新，输出流最后要刷新
fos.flush();
fis.close();
fos.close();
example2:使用FIleReader + FileWriter进行拷贝(只能拷贝普通文件)
FileReader fileReader = null;
FileWriter fileWriter = null;
// 创建一个输入流
fileReader = new FileReader("myfile");
// 创建一个输出流(没有文件会先自己创建)
fileWriter = new FileWriter("myfile00");
char[] chars = new char[1024*1024];
int readCounts = 0;
while((readCounts = fileReader.read(chars))!=-1)
fileWriter.write(chars,0,readCounts);
fileWriter.flush();
fileReader.close();
fileWriter.close();
FIleReader
文件字符输入流。只能读取普通文本
example:
FileReader reader = null;
// 创建文件字符输入流
reader = new FileReader("tempfile");
// 开始读
char[] chars = new char[10];
int readCounts = 0;
while((readCounts = reader.read(chars)) != -1)
System.out.print(new String(chars,0,readCounts));
reader.close();
因为是字符输入流，故此处创建的是char[]数组而不是byte[]数组
FileWriterTest
文件字符输出流，写。只能输出普通文本
example:
FileWriter out = null;
// 初始化一个文件字符输出流对象
out = new FileWriter("file"); // 不想清空 一直累加的话 可以在此处加true
// 开始写
char[] chars = '我','是','中','国','人';
// 刷新
out.write(chars);
out.write(chars,0,2);
out.write("我是一名java工程师!");
out.flush();
note: FileReader和FileWriter操作普通文本挺在行，但是操作其它非普通文本文件不在行(word不是普通文本，普通文本也与文件后缀名无关)
BufferedReader
带有缓冲区的字符输入流，使用这个流的时候不需要自定义char数组，或者说不需要自定义byte数组，自带缓冲。
example1：
FileReader fileReader = new FileReader("myfile");
// 当一个流的构造方法中需要一个流的时候,这个被传进来的流叫做: 节点流.
// 外部负责包装的这个流,叫做:包装流，还有一个名字叫做 : 处理流
// 像当前这个程序来说: FileReader就是一个节点流。BufferedReader就是包装流/处理流。
BufferedReader bufferedReader = new BufferedReader(fileReader);
// // 读第一行
// String s = bufferedReader.readLine();
// System.out.println("第一行: "+s);
//
// // 读第二行
// String s1 = bufferedReader.readLine();
// System.out.println("第二行:"+s1);
// 循环读出来 这种方式 读到末尾返回值为null
// readLine() 方法读取一个文本行，但不带换行符。
String s ;
while((s = bufferedReader.readLine())!=null)
System.out.println(s);
// 关闭流
// 对于包装流来说，只需要关闭最外层流就行，里面的节点流会自动关闭！
bufferedReader.close();
节点流:当一个流的构造方法中需要一个流的时候,这个被传进来的流叫做
包装流:外部负责包装的这个流，又叫处理流
example2:
BufferedReader br = new BufferedReader(new InputStreamReader((new FileInputStream("myfile"))));
String line = null;
while((line=br.readLine())!= null) // 一行一行的读 没有读到null就代表读到了
System.out.println(line);
BufferedWriter
带有缓冲区的字符输出流
BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("copy1",true)));
bw.write("hello world");
bw.write("\\n");
bw.write("i love you");
// 刷新(输出流好习惯)
bw.flush();
// 关闭最外层
bw.close();
DataOutputStream
这个流可以将数据连同数据的类型一并写入文件，但是这个文件不是普通文本文档。
// 创建数据专属的字节输出流
DataOutputStream dos = new DataOutputStream(new FileOutputStream("data"));
// 写数据
byte b =100;
short s =200;
int i =300;
long l = 400L;
float f =3.0f;
double d = 3.14;
boolean sex = false;
char c = 'a';
// 写
dos.writeByte(b);
dos.writeShort(s);
dos.writeInt(i);
dos.writeFloat(f);
dos.writeBoolean(sex);
dos.writeDouble(d);
dos.flush();
dos.close();
DataInputStream
数据字节写入流，DataOutputStream写的文件，只能使用DataInputStream去读，并且读的时候需要提前知道写入的顺序。读的顺序和写的顺序一致，才可以正确取出数据。
example:
DataInputStream dis = new DataInputStream(new FileInputStream("data"));
// 开始读
Byte b = dis.readByte();
Short s = dis.readShort();
int i = dis.readInt();
Float f = dis.readFloat();
Boolean sex = dis.readBoolean();
Double d = dis.readDouble();
System.out.println(b);
System.out.println(s);
System.out.println(i);
System.out.println(f);
System.out.println(sex);
System.out.println(d);
PrintStream
标准字节的输出流，默认输出到控制台，也就是我们常用的System.out.println()方法
example1:
// 联合起来写
System.out.println("hello world");
// 分开写
PrintStream out = System.out;
out.println("hello zhangsan");
out.println("hello lisi");
out.println("hello wangwu");
example2: 日志框架的实现原理:
PrintStream log = new PrintStream(new FileOutputStream("log"));
// 修改输出方向，将输出方向修改到"log"文件。
System.setOut(log);
// 再输出
System.out.println("hello jingjing");
System.out.println("hello xiangzheng");
System.out.println("hello gege");
setOut方法改变输出流的方向
example3:日志框架的实现原理:
public class LogUtil
/**
* 自己实现 记录日志的方法
* @param msg
*/
public static void log(String msg)
try
// 指向一个日志文件
PrintStream ps = new PrintStream(new FileOutputStream("log.txt",true));
// 改变流的输出方向
System.setOut(ps);
// 获取系统当前时间
Java IO详解（四)------字符流
1.字符输出流：Writer
FileWriter 是Writer的子类，以FileWriter 为例把字符串写入到文件
package stream;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;
/***
* @ClassName: FileWriter
* @Description: TODO
* @Auther: chujiu
* @Date: 2020/6/9
* @version : V1.0
*/
public class FileWriterDemo {
public static void main(String[] args) throws IOException {
//1、创建源
File srcFile = new File("G:" + File.separator + "javabased" + File.separator + "JavaTest" + File.separator + "java.txt");
//2、创建字符输出流对象
Writer out = new FileWriter(srcFile);
//3、具体的 IO 操作
/***
* void write(int c):向外写出一个字符
* void write(char[] buffer):向外写出多个字符 buffer
* void write(char[] buffer,int off,int len):把 buffer 数组中从索引 off 开始到 len个长度的数据写出去
* void write(String str):向外写出一个字符串
*/
//void write(int c):向外写出一个字符
out.write(65);//将 A 写入 java.txt 文件中
//void write(char[] buffer):向外写出多个字符 buffer
out.write("Aa帅锅".toCharArray());//将 Aa帅锅 写入 java.txt 文件中
//void write(char[] buffer,int off,int len)
out.write("Aa帅锅".toCharArray(), 0, 2);//将 Aa 写入java.txt文件中
//void write(String str):向外写出一个字符串
out.write("Aa帅锅");//将 Aa帅锅 写入 java.txt 文件中
//4、关闭流资源
/***
* 注意如果这里有一个 缓冲的概念，如果写入文件的数据没有达到缓冲的数组长度，那么数据是不会写入到文件中的
* 解决办法：手动刷新缓冲区 flush()
* 或者直接调用 close() 方法，这个方法会默认刷新缓冲区
*/
out.flush();
out.close();
}
}
2.字符输入流：Reader
FileReader 是Reader子类，以FileReader 为例进行文件读取
package stream;
import java.io.*;
/***
* @ClassName: FileReaderDemo
* @Description: TODO
* @Auther: chujiu
* @Date: 2020/6/9
* @version : V1.0
*/
public class FileReaderDemo {
public static void main(String[] args) throws IOException {
//1、创建源
File srcFile = new File("G:" + File.separator + "javabased" + File.separator + "JavaTest" + File.separator + "java.txt");
//2、创建字符输出流对象
Reader in = new FileReader(srcFile);
//3、具体的 IO 操作
/***
* int read():每次读取一个字符，读到最后返回 -1
* int read(char[] buffer):将字符读进字符数组,返回结果为读取的字符数
* int read(char[] buffer,int off,int len):将读取的字符存储进字符数组 buffer，返回结果为读取的字符数，从索引 off 开始，长度为 len
*
*/
//int read():每次读取一个字符，读到最后返回 -1
int len = -1;//定义当前读取字符的数量
while ((len = in.read()) != -1) {
//打印 a.txt 文件中所有内容
System.out.print((char) len);
}
//int read(char[] buffer):将字符读进字符数组
char[] buffer = new char[10]; //每次读取 10 个字符
while ((len = in.read(buffer)) != -1) {
System.out.println(new String(buffer, 0, len));
}
//int read(char[] buffer,int off,int len)
while ((len = in.read(buffer, 0, 10)) != -1) {
System.out.println(new String(buffer, 0, len));
}
//4、关闭流资源
in.close();
}
}
3.用字符流完成文件的复制
package stream;
import java.io.*;
/***
* @ClassName: FileCopying
* @Description: TODO
* @Auther: chujiu
* @Date: 2020/6/9
* @version : V1.0
*/
public class FileCopying {
public static void main(String[] args) throws IOException {
/**
* 将 a.txt 文件 复制到 b.txt 中
*/
//1、创建源和目标
File srcFile = new File("G:" + File.separator + "javabased" + File.separator + "JavaTest" + File.separator + "a.txt");
File descFile = new File("G:" + File.separator + "javabased" + File.separator + "JavaTest" + File.separator + "b.txt");
//2、创建字符输入输出流对象
Reader in = new FileReader(srcFile);
Writer out = new FileWriter(descFile);
//3、读取和写入操作
char[] buffer = new char[10];//创建一个容量为 10 的字符数组，存储已经读取的数据
int len = -1;//表示已经读取了多少个字节，如果是 -1，表示已经读取到文件的末尾
while((len=in.read(buffer))!=-1){
out.write(buffer, 0, len);
}
//4、关闭流资源
out.close();
in.close();
}
}
以上是关于Java IO详解的主要内容，如果未能解决你的问题，请参考以下文章