IO流
java的io是实现输入和输出的基础,可以方便的实现数据的输入和输出操作。在java中抽象表述为流( stream)
IO流的分类
1.按照流的流向分,可以分为输入流和输岀流
输入流:只能从中读取数据,而不能向其写入数据
输出流:只能向其写入数据,而不能向其读取数据
2.按照操作单元划分,可以划分为字节流和字符流
字节流和字符流的用法几乎完成全一样,区别在于字节流和字符流所操作的数据单元不同,一个字符等于两个字节
字节流主要是由InputStream和OutputStream作为基类,而字符流则主要有 Reader和Writer作为基类
3.按照流的角色划分为节点流和处理流
可以从/向—个特定的io设备(如磁盘,网络)读/写数据的流,称为节点流 节点流也被称为低级流
处理流则是用于对一个已存在的流进行连接和封装,通过封装后的流来实现数据的读/写功能 处理流也被称为髙级流
了解数据源
IO流分类表
Java中四大io抽象类
InputStream
常用方法
read() 返回值 int类型 （0-255之间的一个值） 如果未读出字节则返回-1，表示读取结束 读取一个字节的数据
close() 无返回值 关闭输入流对象，释放相关资源
OutputStream
常用方法
write（int n） 无返回值 向目的地写入一个字节
close（） 无返回值 关闭输出流对象，释放相关资源
Reader
常用方法
read() 返回值 int类型 （0-65535之间的一个Unicode值） 如果未读出字节则返回-1，表示读取结束 读取一个字符的数据
close() 无返回值 关闭输入流对象，释放相关资源
Writer
常用方法
write(int n) 无返回值 写入一个字符的数据
close() 无返回值 关闭输出流对象，释放相关资源
小总结
动手写第一个io程序
package com.vis_yang.io;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
/**
* @author Vis.Yang
* @project_name study io
* @date 2021/5/10 11:06
*/
public class Demo {
public static void main(String[] args) throws IOException {
//为什么定义在外面（全局变量），方便最后关闭流对象，防止资源的浪费
FileInputStream fis = null;
try {
/*
* 创建字节输入流对象
* FileInputStream fis=new FileInputStream("C:/Users/ASUS/Desktop/a.txt");
*/
fis = new FileInputStream("C:/Users/ASUS/Desktop/a.txt");
//read()方法 读取文件里的第一个字符，会把这个字符基于字节的形式读取出来，将字节转换成一个十进制的整数返回，即返回这个整数相应的ASCII码
int read = fis.read();
System.out.println(read);
//得到类容 (char) read ASCII码转成文字
System.out.println((char) read);
//read()方法 并不是一次性读出所有的字符，想要一次性全部读出需要使用循环
// int i;
// while(( i=fis.read())!=-1){
// System.out.print((char) i);
// }
} catch (FileNotFoundException e) {
e.printStackTrace();
System.out.println("找不到此文件");
} finally {
if (fis != null) {
fis.close();
}
}
}
} 
ASCII相关
不同的字符所占的字节是不同的
ASCII码：
一个英文字母（不分大小写）占一个字节的空间，一个中文汉字占两个字节的空间。一个二进制数字序列，在计算机中作为一个数字单元，一般为8位二进制数，换算为十进制。最小值0，最大值255。如一个ASCII码就是一个字节。
UTF-8编码：
一个英文字符等于一个字节，一个中文（含繁体）等于三个字节
Unicode编码：
一个英文等于两个字节，一个中文（含繁体）等于两个字节
File类简介
针对文件操作的方法
敲代码
createNewFile() 返回布尔值 成功：true 失败：false
exists() 返回值 boolean 判断文件是否存在
delete () 返回值 boolean 删除文件
一起上
字节数获取
针对目录操作的方法
mkdir() 返回值 boolean 创建目录成功返回true 失败则是false 创建一个单级目录 | mkdirs() 同理 创建一个多级目录
😇
一起上
常用流对象
文件字节流
文件字节输入流
FileInputStream
写代码
文件字节输出流
FileOutPutStream
通过缓冲区提高读写效率 不再是一个字节一个一字节读写，而是一个缓冲区一个缓冲区的读写了
通过创建一个指定长度的字节数组（byte[ ]）作为缓冲区,以此来提高io流的读写效率。该方式适用于读取较大图片时的缓冲区定义。注意:缓冲区的长度一定是2的整数幂,一般情况下1024长度较为合适。
写代码
缓冲区长度固定 1024字节 如操作的文件过大则建议采用此方法,节省内存 比拟：一袋一袋拿 利用缓冲区方法，读写流都必须传入缓冲参数，此外缓冲区长度固定的写出流还要而外指定长度
读取速度加快
预估缓冲区长度 操作大文件不建议 ,内存占用很大 比拟:一次性拿走 利用缓冲区方法，读写流都需要要传入定义好的缓冲区参数
通过字节缓冲流提高读写效率
字节输入缓冲流
BufferedInputStream
字节输出缓冲流
BufferedOutStream
写一个文件拷贝工具类
package com.vis_yang.io;
import java.io.*;
/**
* @author Vis.Yang
* @project_name 定义文件拷贝类
* @date 2021/5/10 22:09
*/
public class FileCopyTools {
public static void main(String[] args) throws IOException {
//桌面的power.png 复制到 E盘
copyFile("C:\\Users\\ASUS\\Desktop\\power.png","E:\\power.png");
}
//可以操作多种文件
public static void copyFile(String src, String des) throws IOException {
//1.定义字节流和缓冲流
FileInputStream fis = null;
FileOutputStream fos = null;
BufferedInputStream bis = null;
BufferedOutputStream bos = null;
//实例化字节流和缓冲流
try {
fis = new FileInputStream(src);
fos = new FileOutputStream(des);
bis = new BufferedInputStream(fis);
bos = new BufferedOutputStream(fos);
int i=0;
while ((i=bis.read())!=-1){
bos.write(i);
}
bos.flush();
} catch (FileNotFoundException e) {
e.printStackTrace();
}finally {
//关闭资源
if (bos!=null){
bos.close();
}
if (bis!=null){
bis.close();
}
if (fis!=null){
fis.close();
} if (fos!=null){
fos.close();
}
}
}
}
文件字符流
文件字符输入流
FileReader
文件字符输出流
FileWriter
换行？就这样😁
多个字符输出流同时操作同一个文件
实现追加
使用字符流实现文本文件拷贝
敲代码
全局代码
package com.vis_yang.io;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
/**
* @author Vis.Yang
* @project_name TxtFileCopyTools
* @date 2021/5/11 13:59
*/
public class TxtFileCopyTools {
public static void main(String[] args) {
copyTxtFile();
}
/**
* @MethodName:copyTxtFile
* @Description:只能操作文本文件
* @Author: Vis.Yang
* @Date: 2021/5/11 14:08
* @return: void
*/
public static void copyTxtFile() {
FileReader fr = null;
FileWriter fw = null;
try {
//从a.txt里读取
fr = new FileReader("C:\\Users\\ASUS\\Desktop\\a.txt");
//写入c.txt
fw = new FileWriter("C:\\Users\\ASUS\\Desktop\\c.txt");
//读取方式
int i = 0;
while ((i = fr.read()) != -1) {
fw.write(i);
}
fw.flush();
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
if (fr != null) {
fr.close();
}
if (fw != null) {
fw.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
通过缓冲区提高读写效率 不再是一个字符一个一字符读写，而是一个缓冲区一个缓冲区的读写了
通过创建一个指定长度的字符数组（char[ ]）作为缓冲区,以此来提高io流的读写效率。该方式适用于读取较大图片时的缓冲区定义。注意:缓冲区的长度一定是2的整数幂,一般情况下1024长度较为合适。
长度固定 利用缓冲区方法，读写流都必须传入缓冲区参数 并且写出流有长度
全局代码
package com.vis_yang.io;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
/**
* @author Vis.Yang
* @project_name TxtFileCopyTools
* @date 2021/5/11 13:59
*/
public class TxtFileCopyTools {
public static void main(String[] args) {
copyTxtFile();
}
/**
* @MethodName:copyTxtFile
* @Description:只能操作文本文件
* @Author: Vis.Yang
* @Date: 2021/5/11 14:08
* @return: void
*/
public static void copyTxtFile() {
FileReader fr = null;
FileWriter fw = null;
try {
//从a.txt里读取
fr = new FileReader("C:\\Users\\ASUS\\Desktop\\a.txt");
//写入c.txt
fw = new FileWriter("C:\\Users\\ASUS\\Desktop\\c.txt");
//读取方式 改进：加入字符数组作为缓冲区，加快读写速度
//定义一个char[]字符数组作为缓冲区 类似一个装米的包(字符数据)的包
char [] buffer=new char[1024];
//利用缓冲区方法，读写流都必须传入缓冲区参数 并且写出流有长度
int i = 0;
while ((i = fr.read(buffer)) != -1) {
/*
*缓冲区用法 write(buffer,0,i) 长度：起始位置从0开始到i=fr.read(buffer) 比拟：若包未装满返回-1，数据读取结束 写入也随即停止
*相当于一次拿一整个的buffer缓冲区里存的数据写入磁盘 类似一堆大米(字符数据)，原来一粒粒(字符)拿，现在一包一包拿
*/
fw.write(buffer,0,i);
}
fw.flush();
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
if (fr != null) {
fr.close();
}
if (fw != null) {
fw.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
字符流没有预估长度的缓冲区的方法
字符缓冲流
字符输入缓冲流
BufferedReader
字符输出缓冲流
BufferedWriter
全局代码
package com.vis_yang.io;
import java.io.*;
/**
* @author Vis.Yang
* @project_name 学习字符输入输出缓冲流，提高文本文件读取效率
* @date 2021/5/11 15:35
*/
public class BufferedReaderTest {
public static void main(String[] args) {
//定义变量
FileReader fr = null;
FileWriter fw = null;
BufferedReader br = null;
BufferedWriter bw = null;
//实例化
try {
fr = new FileReader("C:\\Users\\ASUS\\Desktop\\a.txt");
fw = new FileWriter("C:\\Users\\ASUS\\Desktop\\c.txt");
br = new BufferedReader(fr);
bw = new BufferedWriter(fw);
/*加入缓冲流后，直接操作缓冲流即可
*学习一下readline()这个按行读取的方法
* 每次读取一行，效率更高
*/
String str = "";
while ((str = br.readLine()) != null) {
bw.write(str+"\r\n");
}
/*
每次读取一个字符，相对readline()要慢
bw = new BufferedWriter(fw);
加入缓冲流后，直接操作缓冲流即可
int i = 0;
while ((i = br.read()) != -1) {
bw.write(i);
}
*/
//刷新
bw.flush();
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
if (br != null) {
br.close();
}
if (bw != null) {
bw.close();
}
if (fw != null) {
fw.close();
}
if (fr != null) {
fr.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
换行改进
package com.vis_yang.io;
import java.io.*;
/**
* @author Vis.Yang
* @project_name 学习字符输入输出缓冲流，提高文本文件读取效率
* @date 2021/5/11 15:35
*/
public class BufferedReaderTest {
public static void main(String[] args) {
//定义变量
FileReader fr = null;
FileWriter fw = null;
BufferedReader br = null;
BufferedWriter bw = null;
//实例化
try {
fr = new FileReader("C:\\Users\\ASUS\\Desktop\\a.txt");
fw = new FileWriter("C:\\Users\\ASUS\\Desktop\\c.txt");
br = new BufferedReader(fr);
bw = new BufferedWriter(fw);
/*加入缓冲流后，直接操作缓冲流即可
*学习一下readline()这个按行读取的方法
* 每次读取一行，效率更高
*/
String str = "";
while ((str = br.readLine()) != null) {
//bw.write(str+"\r\n"); 其实这样也挺快
bw.write(str);
//new line()方法换行:代替\r\n
bw.newLine();
}
/*
每次读取一个字符，相对readline()要慢
bw = new BufferedWriter(fw);
加入缓冲流后，直接操作缓冲流即可
int i = 0;
while ((i = br.read()) != -1) {
bw.write(i);
}
*/
//刷新
bw.flush();
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
if (br != null) {
br.close();
}
if (bw != null) {
bw.close();
}
if (fw != null) {
fw.close();
}
if (fr != null) {
fr.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
通过字符缓冲流为文件中的内容添加行号
JAVA 中int类型转String类型的通常方法,有三种：
1、Integer.toString(int i)
2、String.valueOf(int i)
3、i + " " i 为 int类型 先将int型的i转为string接上后面的字符串
三种方法效率排序为：
Integer.toString(int i) > String.valueOf(int i) > i+" "
全局代码
package com.vis_yang.io;
import java.io.*;
/**
* @author Vis.Yang
* @project_name 通过字符缓冲流实现为文件中的内容添加行号
* @date 2021/5/11 15:35
*/
public class BufferedReaderTest {
public static void main(String[] args) {
//定义变量
FileReader fr = null;
FileWriter fw = null;
BufferedReader br = null;
BufferedWriter bw = null;
//实例化
try {
fr = new FileReader("C:\\Users\\ASUS\\Desktop\\a.txt");
fw = new FileWriter("C:\\Users\\ASUS\\Desktop\\c.txt");
br = new BufferedReader(fr);
bw = new BufferedWriter(fw);
/*加入缓冲流后，直接操作缓冲流即可
*学习一下readline()这个按行读取的方法
* 每次读取一行，效率更高
*/
int i=1;
String str = "";
while ((str = br.readLine()) != null) {
//bw.write(str+"\r\n"); 其实这样也挺快
//添加功能：每行加行号
bw.write(i+"."+str);
//new line()方法换行:代替\r\n
bw.newLine();
i++;
}
/*
每次读取一个字符，相对readline()要慢
bw = new BufferedWriter(fw);
加入缓冲流后，直接操作缓冲流即可
int i = 0;
while ((i = br.read()) != -1) {
bw.write(i);
}
*/
//刷新
bw.flush();
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
if (br != null) {
br.close();
}
if (bw != null) {
bw.close();
}
if (fw != null) {
fw.close();
}
if (fr != null) {
fr.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
缓冲流
功能：将字节流转换成字符流
通过转换流实现键盘输入屏幕输出
InputStream is=System.in "标准"字节输入流对象 OutputStream os=System.out "标准"字节输出流对象 
采用转换流
全局代码
package com.vis_yang.io;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
/**
* @author Vis.Yang
* @project_name 学习转换流
* @date 2021/5/11 17:19
*/
public class ConvertString {
public static void main(String[] args) throws IOException {
InputStream is = null;
BufferedReader br = null;
InputStreamReader isr = null;
try {
//"标准"字节输入流对象 System.in
is = System.in;
// 使用 InputStreamReader（is）转换流把字节流 is= System.in 转换成字符流
isr = new InputStreamReader(is);
//字符流才可以添加到字符缓冲流
br = new BufferedReader(isr);
//这样一波三折后就可以使用BufferedReader字节缓冲流的readLine()方法了
String input = br.readLine();
System.out.println(input);
} finally {
try {
br.close();
isr.close();
is.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
全局代码
package com.vis_yang.io;
import java.io.*;
/**
* @author Vis.Yang
* @project_name 学习转换流
* @date 2021/5/11 17:19
*/
public class ConvertString {
public static void main(String[] args) throws IOException {
InputStream is = null;
OutputStream os = null;
BufferedReader br = null;
BufferedWriter bw = null;
InputStreamReader isr = null;
OutputStreamWriter osw = null;
try {
//"标准"字节输入流对象 System.in
is = System.in;
// 使用 InputStreamReader（is）转换流把字节流 is= System.in 转换成字符流
isr = new InputStreamReader(is);
//字符流才可以添加到字符缓冲流
br = new BufferedReader(isr);
//"标准"字节输出流对象 System.out
os = System.out;
// 使用 OutputStreamWriter(os) 转换流把字节流 os=System.out 转换成字符流
osw = new OutputStreamWriter(os);
//字符流才可以添加到字符缓冲流
bw = new BufferedWriter(osw);
//这样一波三折后就可以使用BufferedReader字节缓冲流的readLine()方法了
String input = br.readLine();
// System.out.println(input);
bw.write(input);
bw.flush();
} finally {
try {
bw.close();
osw.close();
os.close();
br.close();
isr.close();
is.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
键盘输入屏幕输出
package com.vis_yang.io;
import java.io.*;
/**
* @author Vis.Yang
* @project_name 学习转换流
* @date 2021/5/11 17:19
*/
public class ConvertString {
public static void main(String[] args) throws IOException {
InputStream is = null;
OutputStream os = null;
BufferedReader br = null;
BufferedWriter bw = null;
InputStreamReader isr = null;
OutputStreamWriter osw = null;
try {
//"标准"字节输入流对象 System.in
is = System.in;
// 使用 InputStreamReader（is）转换流把字节流 is= System.in 转换成字符流
isr = new InputStreamReader(is);
//字符流才可以添加到字符缓冲流
br = new BufferedReader(isr);
//"标准"字节输出流对象 System.out
os = System.out;
// 使用 OutputStreamWriter(os) 转换流把字节流 os=System.out 转换成字符流
osw = new OutputStreamWriter(os);
//字符流才可以添加到字符缓冲流
bw = new BufferedWriter(osw);
//这样一波三折后就可以使用BufferedReader字节缓冲流的readLine()方法按行读取了
//这样一波三折后就可以使用BufferedWriter字节缓冲流的newLine()方法换行了
while (true){
String input = br.readLine();
if (input.equals("exit")){
break;
}
bw.write("你输入的是:"+input); //另起一行输出
bw.newLine();
bw.flush();
}
} finally {
try {
bw.close();
osw.close();
os.close();
br.close();
isr.close();
is.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
全局代码
package com.vis_yang.demos;
import java.io.*;
/**
* @author Vis.Yang
* @project_name 通过转换流实现键盘输入屏幕输出
* @date 2021/5/11 19:01
*/
public class NewTab {
public static void main(String[] args) {
BufferedReader br = null;
BufferedWriter bw = null;
try {
br=new BufferedReader(new InputStreamReader(System.in));
bw=new BufferedWriter(new OutputStreamWriter(System.out));
while (true){
String input = br.readLine();
if (input.equals("exit")){
break;
}
bw.write("你输入的是:"+input);
//另起一行输出
bw.newLine();
bw.flush();
}
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
bw.close();
br.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
通过字节流读取文本文件并添加行号 肯定要转换流对象
全局代码
读到键盘中
package com.vis_yang.io;
import java.io.*;
/**
* @author Vis.Yang
* @project_name 通过字节流读取文本文件并添加行号
* @date 2021/5/11 19:18
*/
public class NewConvertString {
public static void main(String[] args) throws IOException {
//肯定要转换流对象
BufferedReader br=null;
BufferedWriter bw=null;
try {
br=new BufferedReader(new InputStreamReader(new FileInputStream("C:\\Users\\ASUS\\Desktop\\a.txt")));
bw=new BufferedWriter(new OutputStreamWriter(System.out));
String str="";
int i=1;
while (true){
str = br.readLine();
if (str==null){
break;
}
bw.write(i+"."+str);
bw.newLine();
i++;
bw.flush();
}
} catch (FileNotFoundException e) {
e.printStackTrace();
}finally {
try {
br.close();
bw.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
读到文本文件里
全局代码
package com.vis_yang.io;
import java.io.*;
/**
* @author Vis.Yang
* @project_name 通过字节流读取文本文件并添加行号
* @date 2021/5/11 19:18
*/
public class NewConvertString {
public static void main(String[] args) throws IOException {
//肯定要转换流对象
BufferedReader br=null;
BufferedWriter bw=null;
try {
br=new BufferedReader(new InputStreamReader(new FileInputStream("C:\\Users\\ASUS\\Desktop\\a.txt")));
bw=new BufferedWriter(new OutputStreamWriter(new FileOutputStream("C:\\Users\\ASUS\\Desktop\\b.txt")));
String str="";
int i=1;
//readLine()每次只读一行，循环才会流动，就像游标卡尺上的游标
while ((str = br.readLine())!=null){
bw.write(i+"."+str);
//代替换行符
bw.newLine();
i++;
}
bw.flush();
} catch (FileNotFoundException e) {
e.printStackTrace();
}finally {
try {
br.close();
bw.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
字符输出流
有它自己的输出方法，同时不需要刷新 ，println（）方法自带换行功能
字节数组流
字节数组输入流
ByteArrayInputStream
全局代码
package com.vis_yang.io;
import java.io.ByteArrayInputStream;
import java.io.IOException;
/**
* @author Vis.Yang
* @project_name 学习字节数组输入流 ByteArrayInputStream
* @date 2021/5/11 20:51
*/
public class ByteArrayInputStreamTest {
public static void main(String[] args) {
//创建字节数组 "HelloWorld".getBytes() 字符串.getBytes()可以形成一个字节数组
byte [] byteArray="HelloWorld".getBytes();
ByteArrayInputStream bais=null;
StringBuilder sb=new StringBuilder();
try {
//该构造方法的参数是一个字节数组，这个字节数组就是数据源，需要读取哪个字节数组就把哪个数组传给他即可
bais= new ByteArrayInputStream(byteArray);
int i=0;
while((i=bais.read())!=-1){
//append(Char c):字符串连接
sb.append((char) i);
}
System.out.println(sb);
}finally {
try {
bais.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
字节数组输出流
ByteArrayOutputStream
全局代码
package com.vis_yang.io;
import java.io.ByteArrayOutputStream;
/**
* @author Vis.Yang
* @project_name 学习字节数组输出流 ByteArrayOutputStream
* @date 2021/5/12 9:28
*/
public class ByteArrayOutputStreamTest {
public static void main(String[] args) {
ByteArrayOutputStream baos=null;
try{
baos=new ByteArrayOutputStream();
baos.write('a');
baos.write('c');
baos.write('b');
byte [] byteArray= baos.toByteArray();
for (int i = 0; i < byteArray.length; i++) {
System.out.print((char) byteArray[i]);
}
}finally {
try {
if (baos!=null){
baos.close();
}
}catch (Exception e){
e.printStackTrace();
}
}
}
}
数据流
数据输出字节流
DataOutputStream
全局代码
package com.vis_yang.io;
import java.io.BufferedOutputStream;
import java.io.DataOutputStream;
import java.io.FileOutputStream;
/**
* @author Vis.Yang
* @project_name 学习数据输出流 DataOutputStream
* @date 2021/5/12 12:32
*/
public class DataOutputStreamTest {
public static void main(String[] args) {
DataOutputStream dos = null;
try {
//DataOutputStream是一个处理流，这里套了个字节缓冲流，里面套了个文件字节流，用于操作文件
dos = new DataOutputStream(new BufferedOutputStream(new FileOutputStream("C:\\Users\\ASUS\\Desktop\\data.txt")));
//写入单个字节数据
dos.writeByte('哈');
//写入多个字节数
dos.writeBytes("哈喽呀");
//写入单个字符数据
dos.writeChar(1);
dos.writeChar('1');
dos.writeChar('嘿');
//写入多个字符数据
dos.writeChars("你好呀");
//写入int类型的数据
dos.writeInt(1);
//写入double类型的数据
dos.writeDouble(2.0);
//写入float类型的数据
dos.writeFloat(1.9f);
//写入boolean类型的数据
dos.writeBoolean(true);
//writeUTF("hello 世界") 写入字符串类型的数据
dos.writeUTF("hello 世界");
//刷新
dos.flush();
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
if (dos != null) {
dos.close();
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
}
数据输入流
DataInputStream
全局代码
package com.vis_yang.io;
import java.io.BufferedOutputStream;
import java.io.DataOutputStream;
import java.io.FileOutputStream;
/**
* @author Vis.Yang
* @project_name 学习数据输出流 DataOutputStream
* @date 2021/5/12 12:32
*/
public class DataOutputStreamTest {
public static void main(String[] args) {
DataOutputStream dos = null;
try {
//DataOutputStream是一个处理流，这里套了个字节缓冲流，里面套了个文件字节流，用于操作文件
dos = new DataOutputStream(new BufferedOutputStream(new FileOutputStream("C:\\Users\\ASUS\\Desktop\\data.txt")));
//写入单个字节数据
dos.writeByte('哈');
//写入单个字符数据
dos.writeChar('1');
dos.writeChar('嘿');
//写入int类型的数据
dos.writeInt(1);
//写入double类型的数据
dos.writeDouble(2.0);
//写入float类型的数据
dos.writeFloat(1.9f);
//写入boolean类型的数据
dos.writeBoolean(true);
//writeUTF("hello 世界") 写入字符串类型的数据
dos.writeUTF("hello 世界");
//刷新
dos.flush();
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
if (dos != null) {
dos.close();
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
} package com.vis_yang.io;
import java.io.BufferedInputStream;
import java.io.DataInputStream;
import java.io.FileInputStream;
import java.io.IOException;
/**
* @author Vis.Yang
* @project_name 学习数据输入流 DataInputStream
* @date 2021/5/12 12:31
*/
public class DataInputStreamTest {
public static void main(String[] args) {
DataInputStream dis=null;
try {
dis=new DataInputStream(new BufferedInputStream(new FileInputStream("C:\\Users\\ASUS\\Desktop\\data.txt")));
//注意：读取与写顺序和次数必须一致
System.out.println(dis.readByte());
System.out.println(dis.readChar());
System.out.println(dis.readChar());
System.out.println(dis.readInt());
System.out.println(dis.readDouble());
System.out.println(dis.readFloat());
System.out.println(dis.readBoolean());
System.out.println(dis.readUTF());
} catch (Exception e) {
e.printStackTrace();
} finally {
if (dis!=null){
try {
dis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
对象流
额外功能：可以对Java对象进行读写操作
对象输出流
操作数据
ObjectOutputStream
package com.vis_yang.io;
import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
/**
* @author Vis.Yang
* @project_name 学习对象流
* @date 2021/5/12 14:23
*/
public class ObjectOutputStreamBasicTypeTest {
public static void main(String[] args) {
ObjectOutputStream oos = null;
try {
//ObjectOutputStream处理流
oos = new ObjectOutputStream(new BufferedOutputStream(new FileOutputStream("C:\\Users\\ASUS\\Desktop\\ObjectData.txt")));
oos.writeInt(10);
oos.writeDouble(Math.random());
oos.writeChar('a');
oos.writeBoolean(true);
oos.writeUTF("hello world");
oos.flush();
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
if (oos != null) {
oos.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
对象输入流
操作数据
ObjectInputStream
package com.vis_yang.io;
import java.io.*;
/**
* @author Vis.Yang
* @project_name
* @date 2021/5/12 14:37
*/
public class ObjectInputStreamBasicTypeTest {
public static void main(String[] args) {
ObjectInputStream ois = null;
try {
//ObjectInputStream也是处理流
ois = new ObjectInputStream(new BufferedInputStream(new FileInputStream("C:\\Users\\ASUS\\Desktop\\ObjectData.txt")));
//同理写和读顺序必须一致
System.out.println(ois.readInt());
System.out.println(ois.readDouble());
System.out.println(ois.readChar());
System.out.println(ois.readBoolean());
System.out.println(ois.readUTF());
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
if (ois != null) {
ois.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
输出效果图
操作对象
将对象序列化到文件
需要注意的地方
将文件里的对象序列化文件反序列化到内存
具体代码
package com.vis_yang.io;
import java.io.*;
/**
* @author Vis.Yang
* @project_name 学习反序列化
* @date 2021/5/12 15:40
*/
public class ObjectInputStreamObjectTypeAntiSerializeTest {
public static void main(String[] args) {
ObjectInputStream ois = null;
try {
//实例化一个对象输入流
ois = new ObjectInputStream(new FileInputStream("C:\\Users\\ASUS\\Desktop\\serialize"));
//ois.readObject()得到的对象类型不是User 所以这里要强制类型转换
User user = (User) ois.readObject();
System.out.println("该用户的id:"+user.getUserId()+"该用户的name:"+user.getUserName()+"该用户的Age:"+user.getUserAge());
} catch (IOException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
} finally {
try {
if (ois != null) {
ois.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
随机访问流
RandomAccessFile
独立于Java.io包外
掌握三个核心方法：
全局代码
package com.vis_yang.io;
import java.io.IOException;
import java.io.RandomAccessFile;
/**
* @author Vis.Yang
* @project_name 学习随机访问流 RandomAccessFile
* @date 2021/5/12 16:13
*/
public class RandomAccessFileTest {
public static void main(String[] args) throws IOException {
RandomAccessFile raf = null;
//mode:"rw" 可读可写 "r"只可读 "w"只可写
raf = new RandomAccessFile("C:\\Users\\ASUS\\Desktop\\student.txt", "rw");
//将若干数据写入到文件 10,20,30,90每个都占4个字节
int[] intArray = new int[]{10, 20, 30, 90};
for (int i = 0; i < intArray.length; i++) {
raf.writeInt(intArray[i]);
}
//传入的是字节数 10,20,30,90每个都占4个字节 10-->0~3 20-->4~7 30-->8~11 90-->12~15
raf.seek(4);
//传入的是字节数是4，打印的是20
System.out.println(raf.readInt());
//getFilePointer() 查看指针位置
long filePointer = raf.getFilePointer();
System.out.println(filePointer);
//循环输出到控制台
for (int i = 0; i < 4; i++) {
raf.seek(i * 4);
System.out.print(raf.readInt() + "\t");
}
//利用raf.seek()替换数据 将30换成40
raf.seek(8);
raf.writeInt(40);
//更改后
System.out.println();
for (int i = 0; i < 4; i++) {
raf.seek(i * 4);
System.out.print(raf.readInt() + "\t");
}
}
}
结果：
"C:\Program Files\Java\jdk-11.0.6\bin\java.exe"
20
8
10 20 30 90
10 20 40 90
Process finished with exit code 0
File类在IO中的作用
全局代码
package com.vis_yang.io;
import java.io.*;
/**
* @author Vis.Yang
* @project_name 学习File类在IO中的作用
* @date 2021/5/12 17:18
*/
public class FileInIoTest {
public static void main(String[] args) {
//字符输入缓冲流 BufferedReader 字符输出缓冲流 BufferedWriter
BufferedReader br = null;
BufferedWriter bw = null;
//File类用于存放地址信息
try {
//字符输入流 FileReader 字符输出流 FileWriter
//从IoTest.txt里读写到Io.txt
br = new BufferedReader(new FileReader(new File("C:\\Users\\ASUS\\Desktop\\IoTest.txt")));
bw = new BufferedWriter(new FileWriter(new File("C:\\Users\\ASUS\\Desktop\\Io.txt")));
String s = "";
int i=1;
while ((s = br.readLine()) != null) {
bw.write(i+"."+s);
bw.newLine();
i++;
}
bw.flush();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
}
Apache IO包
下载地址：
导入jar
开始使用吧
先学习一些常用方法
FileUtils的
FileUtils.readFileToString(file, "utf-8") 将文件内容作为字符串返回
FileUtils.copyDirectory（） FileFilter:过滤器接口 
IoUtils的
IOUtils.toString(new FileInputStream("C:\\Users\\ASUS\\Desktop\\a.txt"), "utf-8") 将输入流或数组中的内容转化为字符串 utf-8 :指定编码格式
京公网安备 11010502036488号