目录
分类
字节流
InputStream
OutputStream
文件拷贝
字符流
FileReader
FileWriter
处理流
BufferedReader
BufferedWriter
文本拷贝
流是从起源到接受的有序数据，通过流的方式允许程序使用相同的方式来访问不同的输入/输出源。
分类
按数据单位分：字节流(二进制文件) 字符流(文本文件）
按数据流向分：输入流 输出流
按流的角色分：节点流 处理流
IO流的40多个类都是由这四个抽象基类派生的
字节流
InputStream
常用子类：
- FileInputStream 文件输入流
- BufferedInputStream 缓冲字节输入流
- ObjectInputStream 对象字节输入流
import java.io.FileInputStream;
public class FileInputStream_ {
public static void main(String[] args) {
readFile01();
System.out.println();
readFile02();
}
public static void readFile01(){
String path="D:\\javacode\\IO\\src\\test.txt";
int read;
FileInputStream fis=null;
try {
fis=new FileInputStream(path);
while((read=fis.read())!=-1)//读取一个字节的数据，读到末尾返回-1
{
System.out.print((char)read);//一个一个读
}
} catch (Exception e) {
e.printStackTrace();
}finally {
try {
fis.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
public static void readFile02(){
String path="D:\\javacode\\IO\\src\\test.txt";
byte[] buf=new byte[8];
FileInputStream fis=null;
int len;
try {
fis=new FileInputStream(path);
while((len=fis.read(buf))!=-1)//读取一个字节的数据，读到末尾返回-1
{
System.out.print((new String(buf,0,len)));//一次最多读入buf.length字节的数据，存入字节数组buf
}
} catch (Exception e) {
e.printStackTrace();
}finally {
try {
fis.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
}OutputStream
子类：FileOutputStream
import java.io.FileOutputStream;
public class FileOutputStream_ {
public static void main(String[] args) {
writeFile01();
}
public static void writeFile01(){
String path="D:\\javacode\\IO\\src\\test.txt";
FileOutputStream fos=null;
try {
//fos=new FileOutputStream(path);//覆写
fos=new FileOutputStream(path,true);//加true,追加文本
fos.write('6');
fos.write("helloworld".getBytes());//获取str对应的字节数组
} catch (Exception e) {
e.printStackTrace();
}finally {
try {
fos.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
}#字节流中文会乱码，这是因为只能存一个字节一个字节输出
文件拷贝
import java.io.FileInputStream;
import java.io.FileOutputStream;
public class FileCopy {
public static void main(String[] args) {
//文件拷贝
FileInputStream fileInputStream=null;//输入流
FileOutputStream fileOutputStream=null;//输出流
//源文件和目标文件
String srcpath="C:\\Users\\Elysia\\Pictures\\Saved Pictures\\illust_86465238_20210124_003335.jpg";
String destpath="D:\\javacode\\IO\\src\\pic.jpg";
try {
fileOutputStream=new FileOutputStream(destpath,true);
fileInputStream=new FileInputStream(srcpath);
byte[] buf=new byte[1024];
int len;
while((len=fileInputStream.read(buf))!=-1){
fileOutputStream.write(buf,0,len);
}
} catch (Exception e) {
e.printStackTrace();
}finally {
try {
fileOutputStream.close();
fileInputStream.close();
}catch (Exception e){
e.printStackTrace();
}
}
}
}
字符流
FileReader
import java.io.FileReader;
public class FileReader_ {
public static void main(String[] args) {
FileReader fileReader=null;
String path="D:\\javacode\\IO\\src\\test.txt";
try {
fileReader=new FileReader(path);
char[] buf=new char[8];//用char接收
int len;
while((len=fileReader.read(buf))!=-1){
System.out.print(new String(buf,0,len));
}
// int read;//单个读取
// while((read= fileReader.read())!=-1){
// System.out.print((char)read);
// }
} catch (Exception e) {
e.printStackTrace();
}finally {
try {
fileReader.close();//关闭文件
}catch (Exception e){
e.printStackTrace();
}
}
}
}FileWriter
import java.io.FileWriter;
public class FileWriter_ {
public static void main(String[] args) {
FileWriter fileWriter=null;
String path="D:\\javacode\\IO\\src\\test.txt";
try{
fileWriter=new FileWriter(path,true);//加true表示追加
fileWriter.write("\n成功写入");
}catch (Exception e){
e.printStackTrace();
}finally {
try{
fileWriter.close();//必须 一定 关闭流，才能真正的写入
}catch (Exception e){
e.printStackTrace();
}
}
}
}必须 一定 关闭/flush流，才能真正的写入
处理流
将“流”包装，在其之上为程序提供更强大的读写功能
节点流的数据源是特定的，而处理流则利用了向上转型，可以封装多种“流”，减小了节点流之间的差异。
优势：
- 使用处理流进行 读写操作更简单
- 处理流增加了缓冲，提高效率
#在关闭包装流的时候，会自动关闭里面封装的字节流
BufferedReader
从字符输入流读取文本，缓冲字符，以提供字符，数组和行的高效读取。
import java.io.BufferedReader;
import java.io.FileReader;
public class BufferedReader_ {
public static void main(String[] args) throws Exception{
String path="D:\\javacode\\IO\\src\\test.txt";
BufferedReader bufferedReader=new BufferedReader(new FileReader(path));
String line;//按行读取，效率高
while((line=bufferedReader.readLine())!=null){
System.out.println(line);//读取一行
}
bufferedReader.close();//只需要关闭包装流
}
}BufferedWriter
文本写入字符输出流，缓冲字符，以提供单个字符，数组和字符串的高效写入。
import java.io.BufferedWriter;
import java.io.FileWriter;
public class BufferedWriter_ {
public static void main(String[] args) throws Exception{
String path="D:\\javacode\\IO\\src\\test.txt";
BufferedWriter bufferedWriter=new BufferedWriter(new FileWriter(path,true));
bufferedWriter.newLine();//插入一个换行
bufferedWriter.write("成功写入");
bufferedWriter.close();
}
}文本拷贝
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
public class TxtCopy {
public static void main(String[] args) throws Exception{
String dest="D:\\javacode\\IO\\src\\dest.txt";
String src="D:\\javacode\\IO\\src\\test.txt";
BufferedReader bufferedReader=new BufferedReader(new FileReader(src));
BufferedWriter bufferedWriter=new BufferedWriter(new FileWriter(dest));
String line;
while((line=bufferedReader.readLine())!=null){
bufferedWriter.write(line);//末尾没有换行符
bufferedWriter.newLine();//每读取一行，插入换行符
}
bufferedWriter.close();
bufferedReader.close();
}
}
