IO流
1、主要内容
- java.io.File类的使用:计算机操作系统的文件和文件夹
- IO原理及流的分类
- 文件流:数据流的读写都是基于文件的操作
- FileInputStream
- FileOutputStream
- FileReader
- FileWriter
- 缓冲流:数据流的读写都是基于内存的操作
- BufferedInputStream
- BufferedOutputStream
- BufferdReader
- BufferedWriter
- 转换流
- InputStreamReader/OutputStreamWriter
- 标准输入/输出流
- 对象流:将对象转换为一个数据流进行读写 —涉及序列化、反序列化
- ObjectInputStream/ObjectOutputStream
- 随机存取文件流:例如一个TXT文件,其中有100行数据,可以直接读取第50行数据,也可以在第89行插入数据
- RandomAccessFile
2、File类
- java.io.File类:文件和目录路径名的抽像表示形式,与平台无关
- File能新建、删除、重命名文件和目录,但File不能访问文件内容本身。如果需要访问文件内容本身,则需要使用输入/输出流
- File对象可以作为参数传递给流的构造函数
- File类的常见构造方法:
- public File(String pathname)
- public File(String parent,String child)
import java.io.File;
public class Test8 {
public static void main(String[] args) {
File file = new File("/Volumes/磁盘/intellij idea file/db_books.sql");//第一种构造方法常用
//对象file就是db_books.sql文件
File file1 = new File("/Volumes/磁盘/intellij idea file","db_books.sql");//第二种构造方法不常用
//注意,\在文件中是路径的分隔符,但是在java中一个\的意思是转义符,在java中\\或者/才是文件定位分隔符
//File.separator作为文件分隔符
//File file2 = new File("/Volumes" + File.separator + "磁盘/intellij idea file/db_books.sql");
System.out.println(file.getName());//获取文件名或者是最终目录名
File file2 = new File("src/Test8");//相对路径
System.out.println(file.getPath());//获取文件或者文件目录的路径,也就是new File时的路径
System.out.println(file.getAbsolutePath());//获取当前文件的绝对路径
System.out.println(file2);
System.out.println(file2.getAbsoluteFile());//返回一个用当前的文件的绝对路径构建的file对象
System.out.println(file.getParent());//返回当前文件或者目录的父级目录
//file.renameTo(new File("/Volumes/磁盘/intellij idea file/book.sql"));//给file对象对应的文件重命名
//文件检测判断方法 返回的都是Boolean类型
System.out.println(file.exists());//判断文件或者文件夹是否存在
System.out.println(file.canWrite());//判断文件是否可写
System.out.println(file.canRead());//判断文件是否可读
System.out.println(file.isFile());//判断当前的file对象是不是文件
System.out.println(file.isDirectory());//判断当前的file对象是不是文件夹
System.out.println(file.lastModified());//获取文件的最后修改方法,返回的是一个毫秒数
System.out.println(file.length());//返回文件的长度,单位是字节数
}
//对于文件的创建删除操作
File file3 = new File("/Volumes/磁盘/intellij idea file/db_books.txt");
if (!(file3.exists())) { //判断文件是否存在
try {
file3.createNewFile(); //创建文件
} catch (IOException e) {
e.printStackTrace();
}
}
//file3.delete();//删除文件
//对文件夹进行创建删除操作
File file4 = new File("/Volumes/磁盘/intellij idea file/学习视我为快乐");
if (!(file4.exists())) { //判断文件夹是否存在
file4.mkdir(); //创建单层文件夹
//file4.mkdirs();//创建多层目录
}
//file4.delete();//删除目录
File file5 = new File("/Volumes/磁盘/intellij idea file");
String[] list = file5.list();//返回的是当前文件夹的子集的名称,包括目录和文件
for (String s : list) {
System.out.println(s);
}
File[] files = file5.listFiles();//返回的是当前文件夹的子集的file对象,包括目录和文件
for (File file6 : files) {
System.out.println(file6);
}
}
3、IO流和IO流的体系
IO流体系
4、文件字节流
文件字节输入流: FileInputStream 将文件从硬盘读取到内存,文件输入流表示输入到程序内存
import java.io.FileInputStream;
public class Test9 {
public static void main(String[] args) {
try {
FileInputStream in = new FileInputStream("/Volumes/磁盘/intellij idea file/db_books.txt");
byte[] bytes = new byte[10];//设置一个byte字节数组接收读取文件的内容
int len = 0;//设置一个读取数据的长度
//in.read(bytes);方法会有一个返回值,返回值是读取的数据的长度,如果读取到最后一个数据,还会向后读一个,若为空,返回-1
//in.read的返回值是-1的时候代表整个文件就读取完毕
while ((len = in.read(bytes)) != -1) {
System.out.println(new String(bytes, 0, len));
}
in.close();//注意:流使用完需要关闭
} catch (Exception e) {
e.printStackTrace();
}
}
}
文件字节输出流: FileOutputStream 将内存中的数据输出到硬盘,文件输出流表示输出到文件
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
public class Test10 {
public static void main(String[] args) throws FileNotFoundException {
try{
FileOutputStream out = new FileOutputStream("/Volumes/磁盘/intellij idea file/db_books.txt");
String f = "fsfsd";
out.write(f.getBytes());//将数据写到内存,同时会将文件清空再写入
out.flush();//把内存中的数据刷写到硬盘
out.close();//关闭流
} catch (IOException e) {
e.printStackTrace();
}
}
}
5、文件字符流
文件字符输入流: FileReader 与字节输入流没有很大的区别,传输单位变成了字符,适合字符文件的输入
import java.io.FileReader;
public class Test9 {
public static void main(String[] args) {
try {
FileReader in = new FileReader("/Volumes/磁盘/intellij idea file/db_books.txt");
char[] c = new char[10];//设置一个char字符数组接收读取文件的内容
int len = 0;//设置一个读取数据的长度
//in.read(c);方法会有一个返回值,返回值是读取的数据的长度,如果读取到最后一个数据,还会向后读一个,若为空,返回-1
//in.read的返回值是-1的时候代表整个文件就读取完毕
while ((len = in.read(c)) != -1) {
System.out.println(new String(c, 0, len));
}
in.close();//注意:流使用完需要关闭
} catch (Exception e) {
e.printStackTrace();
}
}
}
文件字符输出流: FileWriter 与字节输出流没有很大的区别,传输单位变成了字符,适合字符文件的输出
import java.io.FileNotFoundException;
import java.io.FileWriter;
import java.io.IOException;
public class Test10 {
public static void main(String[] args) throws FileNotFoundException {
try{
FileWriter out = new FileWriter("/Volumes/磁盘/intellij idea file/db_books.txt");
String f = "fsfsdsfd";
out.write(f);//将数据写到内存
out.flush();//把内存中的数据刷写到硬盘
out.close();//关闭流
} catch (IOException e) {
e.printStackTrace();
}
}
}
6、处理流之缓冲流
- 为了提高数据读写的速度,Java AP提供了带缓冲功能的流类,在使用这些流类时,会创建一个内部缓冲区,缓冲流就是先把数据缓存在内存,在内存中区做IO流操作,基于内存的IO流操作更快
- 根据数据操作单位可以把缓冲流分为
- 缓冲流BufferedInputStream和BufferedOutputStream对应文件流 FileInputStream和FileOutputStream
- 缓冲流BufferedReader和BufferedWriter对应文件流FileReader和FileWriter
缓冲流BufferedInputStream:
import java.io.BufferedInputStream;
import java.io.FileInputStream;
public class Test11 {
public static void main(String[] args) {
try {
//创建一个文件字节输入流对象
FileInputStream file = new FileInputStream("/Volumes/磁盘/intellij idea file/db_books.txt");
//创建一个缓冲字节输入流对象
BufferedInputStream br = new BufferedInputStream(file);
int len = 0;//接收字节长度
byte[] buffer = new byte[10];//创建接收字节流数组
while ((len = br.read(buffer)) != -1) {
System.out.println(new String(buffer, 0, len));
}
//关闭的时候,最晚开启的最先关
br.close();
file.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
缓冲BufferedOutputStream:
import com.sun.org.apache.xml.internal.utils.StringToStringTable;
import java.io.BufferedOutputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
public class Test12 {
public static void main(String[] args) {
//创建一个文件输出流对象
try {
//创建一个文件字节输出流对象
FileOutputStream out = new FileOutputStream("/Volumes/磁盘/intellij idea file/db_books.txt");
//创建一个缓冲字节输出流对象
BufferedOutputStream br = new BufferedOutputStream(out);
String s = "1111";
br.write(s.getBytes());//写入数据到程序内存
br.flush();//内存中的数据刷新到硬盘
//关闭流
br.close();
out.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
缓冲字符输入流BufferedReader:
import java.io.BufferedInputStream;
import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.FileReader;
public class Test11 {
public static void main(String[] args) {
try {
//创建一个文件字符输入流对象
FileReader file = new FileReader("/Volumes/磁盘/intellij idea file/db_books.txt");
//创建一个缓冲字符输入流对象
BufferedReader br = new BufferedReader(file);
int len = 0;//接收字节长度
char[] buffer = new char[10];//创建接收字节流数组
while ((len = br.read(buffer)) != -1) {
System.out.println(new String(buffer, 0, len));
}
//关闭的时候,最晚开启的最先关
br.close();
file.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
缓冲字符输出流BufferedWrite:
import java.io.*;
public class Test12 {
public static void main(String[] args) {
try {
//创建一个文件字符输出流对象
FileWriter out = new FileWriter("/Volumes/磁盘/intellij idea file/db_books.txt");
//创建一个缓冲字符输出流对象
BufferedWriter bo = new BufferedWriter(out);
String s = "1111641151";
bo.write(s);//写入数据到程序内存
bo.flush();//内存中的数据刷新到硬盘
//关闭流
bo.close();
out.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
7、处理流之转换流
-
所有的文件都有编码格式,如常见的TXT和Java文件一般有三种
- ISO8859-1,西欧编码,是纯英文编码,不适应汉字
- GBK和UTF-8,这两种编码是适合中文和英文的
- 我们一般使用UTF-8
-
转换流提供了在字节流和字符流之间的转换
- 两个转换流InputStreamReader和OutputStreamWriter
- 当字节流中数据为字符时,将字节流转换为字符流效率更高
输入流InputStreamReader: 在转换字符流的时候,设置的字符集编码要与读取的文件的数据编码一致,也可以用来接收键盘的输入
import java.io.FileInputStream;
import java.io.FileReader;
import java.io.InputStreamReader;
public class Test9 {
public static void main(String[] args) {
try {
//文件输入字节流对象
FileInputStream in = new FileInputStream("/Volumes/磁盘/intellij idea file/db_books.txt");
InputStreamReader in1 = new InputStreamReader(in, "GBK");//参数1是字节流,参数二是编码
char[] c = new char[10];//设置一个char字符数组接收读取文件的内容
int len = 0;//设置一个读取数据的长度
while ((len = in1.read(c)) != -1) {
System.out.println(new String(c, 0, len));
}
in1.close();
in.close();
//注意:流使用完需要关闭
} catch (Exception e) {
e.printStackTrace();
}
}
}
输入流OutputStreamWriter:
import java.io.*;
public class Test10 {
public static void main(String[] args) throws FileNotFoundException {
try{
//创建文件字节流输出对象
FileOutputStream out = new FileOutputStream("/Volumes/磁盘/intellij idea file/db_books.txt");
//将字节流装化为字符流
OutputStreamWriter out1 = new OutputStreamWriter(out, "GBK");
String f = "66666666666";
out1.write(f);//将数据写到内存
out1.flush();//把内存中的数据刷写到硬盘
out1.close();
out.close();
//关闭流
} catch (IOException e) {
e.printStackTrace();
}
}
}
8、处理流之对象流
-
ObjectInputStream和ObjectOutputStream
-
用于存储和读取对象的处理流。
-
序列化:用ObjectOutputStream类将一个java对象输出到IO流
-
反序列化:用ObjectInputStream类从IO流中恢复该java对象
-
序列化和反序列化针对的是对象的属性,不包括类的属性
-
ObjectInputStream和ObjectOutputStream不能序列化static和transient修饰的成员变量
-
对象的序列化和反序列化使用的类要严格一致,包名,类名,类结构等等都要一致
-
如果需要某个对象支持序列化机制,则必须实现以下两个接口之一
- Serializable
- Externalizable
序列化ObjectOutputStream:
import java.io.*;
public class Test13 {
public static void main(String[] args) {
try {
//定义对象的输出流,把对象的序列化之后的流放在指定文件中
ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("/Volumes/磁盘/intellij idea file/db_books.txt"));
Person s = new Person(22, "李某");
out.writeObject(s);
out.flush();//刷写数据到硬盘
out.close();//关闭流
} catch (Exception e) {
e.printStackTrace();
}
}
}
反序列化ObjectInputStream:
import java.io.FileInputStream;
import java.io.ObjectInputStream;
public class Test14 {
public static void main(String[] args) {
try {
//创建对象输入流对象,从指定的文件中吧对象序列化后的流读取出来
ObjectInputStream in = new ObjectInputStream(new FileInputStream("/Volumes/磁盘/intellij idea file/db_books.txt"));
Object object = in.readObject();//方法返回Object对象
Person p = (Person) object;
System.out.println(p.getAge());
System.out.println(p.getName());
in.close();//关闭流
} catch (Exception e) {
e.printStackTrace();
}
}
}
9、随机存取类
-
RandomAccessFile类支持“随机访问”的方式,程序可直接跳到文件的任意位置读取和写入文件
-
RandomAccessFile的构造有两个参数,参数1是读写文件的路径,参数2是指定RandomAccessFile的访问模式
- r:以只读方式打开
- rw:打开以便读取和写入
- rwd:打开以便读取和写入;同步文件内容的更新
- rws:打开以便读取和写入;同步文件内容和元数据的更新
-
如果是在文件的开头或者中间的某个位置开始写的话,就会用写的内容覆盖掉等长度的内容
import java.io.RandomAccessFile;
public class Test15 {
public static void main(String[] args) {
try {
RandomAccessFile rw = new RandomAccessFile("/Volumes/磁盘/intellij idea file/db_books.txt", "rw");
//随机读取文件操作
rw.seek(0);//从开头读写数据,里面的表示第几个字符
int len = 0;
byte[] buffer = new byte[1024];
while ((len = rw.read(buffer)) != -1) {
System.out.println(new String(buffer,0,len));
}
//随机写入文件的操作
rw.seek(rw.length());//结尾追加文件
String s = "666666";
rw.write(s.getBytes());
rw.close();//关闭流
} catch (Exception e) {
e.printStackTrace();
}
}
}
本次学习视频来自b站Java学习
点击跳转学习视频