图片梳理
理解
对于文件流来说是io流的基础，牵扯到缓冲流，缓冲流是在内存中使用io流的各类操作，转换流顾名思义，是字节与字符流之间的转换 ，要先有字节流和字符流，对象流，最主要的是类的序列化与反序列化，相当于一个封装转化，随机存取流，也是在有字节流和字符流的基础上。
File类
- 能新建，删除，重命名文件和目录，但不能访问文件内容，访问文件内容要通过输入/输出流
图片梳理
File操作
package day12;
import java.io.File;
import java.io.IOException;
public class Test {
public static void main(String[] args) {
File f = new File("D:\test\abc\tt.txt");//这个时候对象f就是tt.txt文件
File f4 = new File("D:\test\abc");//这个目录
<!-- File f2 = new File("D:/test/abc/tt.txt");
File f3 = new File("D:" + File.separator + "test\abc\tt.txt");
File f1 = new File("D:\test","abc\tt.txt");//这个f1也是tt.txt文件，这种实验相对比较少 -->
//注意，在文件中是路径的分隔符，但是在java编程中一个的意思是转移符，在java中\或者/才是文件的分隔符
//也可以File.separator作为文件分隔符
System.out.println(f.getName());//获取文件名
System.out.println(f4.getName());//获取文当前的文件名称
File f5 = new File("src/day12/Test.java");//使用相对路径来创建file对象
System.out.println(f5.getPath());//获取文件或者文件夹的路径，就是new file时候写的路径
System.out.println(f5.getAbsolutePath());//获取当前文件的绝对路径
System.out.println(f5);
System.out.println(f5.getAbsoluteFile());//返回一个用当前的文件的绝对路径构建的file对象
System.out.println(f5.getParent());//返回当前文件或者文件夹的父级路径
f.renameTo(new File("D:\test\abc\tt1.txt"));//给文件或文件夹重命名
File f6 = new File("D:\test\abc1");
System.out.println(f6.exists());//判断文件或者文件夹是否存在
File f7 = new File("D:\test\abc\tt1.txt");
System.out.println(f7.canWrite());//判断文件是否可写
System.out.println(f7.canRead());//判断文件是否可读
System.out.println(f7.isFile());//判断当前的file对象是不是文件
System.out.println(f7.isDirectory());//判断当前的file对象是不是文件夹或者目录
System.out.println(f7.lastModified());//获取文件的最后修改时间，返回的是一个毫秒数
System.out.println(f7.length());//返回文件的长度，单位是字节数
File f8 = new File("D:\test\abc\tt2.txt");
System.out.println(f8.exists());//判断文件是否存在
if(!f8.exists()){
try {
f8.createNewFile();//创建新的文件
} catch (IOException e) {
e.printStackTrace();
}
}
<!-- f8.delete();//删除文件
File f9 = new File("D:\test\abc\cc");
File f9 = new File("D:\test\abc\cc\dd");
f9.mkdir();//创建单层目录，如果使用这一方法来创建多层目录，就得一层一层的执行mkdir()
File f10 = new File("D:\test\abc\a\b\c");
f10.mkdirs();//这个方法是直接用来创建多层目录 -->
File f11 = new File("D:\test");
String[] fl = f11.list();//返回的是当前文件夹的子集的名称，包括目录和文件
for(String s : fl){
System.out.println(s);
}
File[] fs = f11.listFiles();//返回的是当前文件夹的子集的file对象，包括目录和文件
for(File ff : fs){
System.out.println(ff);
}
}
递归遍历文件
public void test(File file){
if(file.isFile()){
System.out.println(file.getAbsolutePath() + " 是文件");
}else{
System.out.println(file.getAbsolutePath() + " 是文件夹");
//如果是文件夹，这个文件夹里就可能有子文件夹或者文件
File[] fs = file.listFiles();//获取当前文件夹下的子文件夹或者文件的file对象
if(fs != null && fs.length > 0){
for(File ff : fs){
test(ff);//递归
if(ff.isFile()){
System.out.println(ff.getAbsolutePath() + " 是文件");
}else{
System.out.println(ff.getAbsolutePath() + " 是文件夹");
File[] fs1 = ff.listFiles();
if(fs1 != null && fs1.length > 0){
for(File ff1 : fs1){
}
}
}
}
}
}
}
}
文件流:数据流的读写都是基于文件的操作
- 字节流非常通用，可以用来操作字符的文档，还可以操作然后的其他类型文件，都是使用二进制转换
FileInputStream：字节输入流
public static void testFileInputStream(){
try {
FileInputStream in = new FileInputStream("D:/test/abc/tt1.txt");
byte[] b = new byte[10];//设置一个byte数组接收读取的文件的内容
int len = 0;//设置一个读取数据的长度
//in.read(b);//in.read方法有一个返回值，返回值是读取的数据的长度，如果读取到最后一个数据，还会向后读一个，这个时候返回值就是-1
//也就意味着当in.read的返回值是-1的时候整个文件就读取完毕了
while((len = in.read(b)) != -1){
System.out.println(new String(b,0,len));
//new String(b,0,len),参数1是缓冲数据的数组，参数2是从数组的那个位置开始转化字符串，参数3是总共转化几个字节
}
in.close();//注意。流在使用完毕之后一段要关闭
} catch (Exception e) {
e.printStackTrace();
}
}
FileOutputStream：字节输出流
public static void testFileOutputStream(){
try {
FileOutputStream out = new FileOutputStream("D:/test/abc/tt4.txt");//指定行tt4输出数据
String str = "knsasjadkajsdkjsa";
out.write(str.getBytes());//把数据写到内存
out.flush();//把内存中的数据刷写到硬盘
out.close();//关闭流
} catch (Exception e) {
e.printStackTrace();
}
}
复制文件到指定位置
public static void copyFile(String inPath, String outPanth){
try {
FileInputStream in = new FileInputStream(inPath);//读取的源文件
FileOutputStream out = new FileOutputStream(outPanth);//复制到哪里
byte[] b = new byte[100];
int len = 0;
while((len = in.read(b)) != -1){
out.write(b, 0, len);//参数1是写的缓冲数组，参数2是从数组的那个位置开始，参数3是获取的数组的总长度
}
out.flush();//把写到内存的数据刷到硬盘
out.close();
in.close();
} catch (Exception e) {
e.printStackTrace();
}
}
FileReader：字符输入流
public static void testFileReader(String inPath){
try {
FileReader fr = new FileReader(inPath);//创建文件字符输入流的对象
char[] c = new char[10];//创建临时存数据的字符数组
int len = 0;//定义一个输入流的读取长度
while((len = fr.read(c)) != -1){
System.out.println(new String(c, 0, len));
}
fr.close();//关闭流
} catch (Exception e) {
e.printStackTrace();
}
}
FileWriter：字符输出流
public static void testFileWriter(String text,String outPath){
try {
FileWriter fw = new FileWriter(outPath);
fw.write(text);//写到内存中
fw.flush();//把内存的数据刷到硬盘
fw.close();//关闭流
} catch (Exception e) {
e.printStackTrace();
}
}
复制文件到指定位置(字符流只适合操作内容是字符文件)
public static void copyFile(String inPaht, String outPath){
try {
FileReader fr = new FileReader(inPaht);
FileWriter fw = new FileWriter(outPath);
char[] c = new char[100];
int len = 0;
while((len = fr.read(c)) != -1){//读取数据
fw.write(c,0,len);//写数据到内存
}
fw.flush();
fw.close();
fr.close();
} catch (Exception e) {
e.printStackTrace();
}
}
缓冲流:数据流的读写都是基于内存的操作
- 缓冲流要套接在相应的节点流之上，对读写的数据提供了缓冲的功能，提高了读写的效率，同时增加了一些新的方法，对于输出的缓冲流，写出的数据会先在内存中缓存，使用flush()将会使内存中的数据立刻写出
- 简单来说就是先把数据缓存到内存里，在内存中做io操作
BufferedInputStream：缓冲字节输入流
public static void testBufferedInputStream() throws Exception {
// 文件字节输入流对象
FileInputStream in = new FileInputStream("D:\testdemo\demo\src\day13\tt.txt");
// 把文件字节输入流放到缓冲字节输入流对象
BufferedInputStream br = new BufferedInputStream(in);
byte[] b = new byte[10];
int len = 0;
while ((len = br.read(b)) != -1) {
System.out.println(new String(b, 0, len));
}
// 关闭流的时候，本着一个最晚开的最早关，依次关
br.close();
in.close();
}
BufferedOutputStream：缓冲字节输入流
public static void testBufferedOutputStream() throws Exception {
// 创建字节输出流对象
FileOutputStream out = new FileOutputStream("D:\testdemo\demo\src\day13\tt1.txt");
// 把字节输出流对象放到缓冲字节输出流中
BufferedOutputStream bo = new BufferedOutputStream(out);
String s = "hello world";
bo.write(s.getBytes());// 写到内存中
bo.flush();// 刷到硬盘上
// 关闭流的时候，本着一个最晚开的最早关，依次关
bo.close();
out.close();
}
缓冲流实现文件的复制
public static void copyFile() throws Exception {
// 缓冲输入流
BufferedInputStream br = new BufferedInputStream(
new FileInputStream("D:\testdemo\demo\src\day13\tt1.txt"));
// 缓冲输出流
BufferedOutputStream bo = new BufferedOutputStream(
new FileOutputStream("D:\testdemo\demo\src\day13\tt2.txt"));
byte[] b = new byte[1024];
int len = 0;// 设置一个没出读取到的数据的长度，直到br.read方法执行到最后（比如说文件中只有hello
// world，执行到最后一个就读取d的后面，这个时候返回值就是-1）
while ((len = br.read(b)) != -1) {
bo.write(b, 0, len);// 写到内存
}
bo.flush();// 刷到硬盘
bo.close();
br.close();
}
BufferedReader：缓冲字符输入流
public static void testBufferedReader() throws Exception {
FileReader r = new FileReader("D:\testdemo\demo\src\day13\tt.txt");
BufferedReader br = new BufferedReader(r);
char[] c = new char[100];
int len = 0;
while ((len = br.read(c)) != -1) {// br.read(c)读到文件的最后一个字符的下一位，返回值就是-1
System.out.println(new String(c, 0, len));
}
br.close();
r.close();
}
BufferedWriter：缓冲字符输出流
public static void testBufferedWriter() throws Exception {
FileWriter fw = new FileWriter("D:\testdemo\demo\src\day13\tt3.txt");
BufferedWriter bw = new BufferedWriter(fw);
String s = "hello world!!!!";
bw.write(s);
bw.flush();
bw.close();
fw.close();
}
缓冲字符流复制文件
public static void copyFile() throws Exception {
BufferedReader br = new BufferedReader(new FileReader("D:\testdemo\demo\src\day13\tt3.txt"));
BufferedWriter bw = new BufferedWriter(new FileWriter("D:\testdemo\demo\src\day13\tt4.txt"));
char[] c = new char[100];
int len = 0;
while ((len = br.read(c)) != -1) {
bw.write(c, 0, len);
}
bw.flush();
bw.close();
br.close();
}
转换流
- 转换字节输入流为字符输入流 注意，在转换字符流的时候，设置的字符集编码要与读取的文件的数据的编码一致 不然就会出现乱码 InputStreamReader
- 所有的文件都是有编码格式，对于我们来说，TXT和java文件一般来讲有三种编码，ISO8859-1，西欧编码，是纯粹英文编码，不适应汉字，GBK和UTF-8，这两编码是适用于重要和英文，我们一般使用UTF-8编码
InputStreamReader：转换字节输入流为字符输入流
public static void testInputStreamReader() throws Exception {
FileInputStream fs = new FileInputStream("D:\testdemo\demo\src\day13\tt5.txt");
// 把字节流转换为字符流
InputStreamReader in = new InputStreamReader(fs, "GBK");// 参数1是字节流，参数2是编码
//InputStreamReader in = new InputStreamReader(fs,"UTF-8");//参数1是字节流，参数2是编码
char[] c = new char[100];
int len = 0;
while ((len = in.read(c)) != -1) {
System.out.println(new String(c, 0, len));
}
in.close();
fs.close();
}
OutputStreamReader：转换字节输出流为字符输出流
public static void testOutputStreamWriter() throws Exception {
FileOutputStream out = new FileOutputStream("D:\testdemo\demo\src\day13\tt6.txt");
//OutputStreamWriter os = new OutputStreamWriter(out, "UTF-8");
OutputStreamWriter os = new OutputStreamWriter(out, "GBK");
os.write("你好你好");
os.flush();
os.close();
out.close();
}
标准输入输出流
- System.in(默认输入键盘)：类型是InputStream
- System.out(默认输出显示器)：类型是PrintStream，是OutputStream的子类FilterOutputStream的子类
标准的输入流
public static void testSystemIn() throws Exception {
// 创建一个接收键盘输入数据的输入流
InputStreamReader is = new InputStreamReader(System.in);
// 把输入流放到缓冲流里
BufferedReader br = new BufferedReader(is);
String str = "";// 定义一个临时接收数据的字符串
while ((str = br.readLine()) != null) {
System.out.println(str);
}
br.close();
is.close();
}
把控制台输入的内容写到指定的TXT文件中，当接收到字符串over，就结束程序的运行
public static void write2TXT() throws Exception {
// 创建一个接收键盘输入数据的输入流
InputStreamReader is = new InputStreamReader(System.in);
// 把输入流放到缓冲流里
BufferedReader br = new BufferedReader(is);
BufferedWriter out = new BufferedWriter(new FileWriter("D:\testdemo\demo\src\day13\tt7.txt"));
String line = "";
while ((line = br.readLine()) != null) {
if (line.equals("over")) {
break;
}
// 读取的每一行都写到指定的TXT文件
out.write(line);
}
out.flush();
out.close();
br.close();
is.close();
}
打印流(了解)
PrintStream/PrintWriter:System.out.println等
数据流(了解)：专门用来做基本数据类型的读写的
DataInputStream：数据输出流
用数据输出流写到文件的中的基本数据类型的数据，是乱码的，不能直接辨认出来，需要数据输入流来读取 DataOutputStream
public static void testDataOutputStream() throws Exception {
DataOutputStream out = new DataOutputStream(new FileOutputStream("D:/testdemo/demo/src/day13/tt8.txt"));
//out.writeBoolean(true);
out.writeDouble(1.35d);
//out.writeInt(100);
out.flush();
out.close();
}
DataOutputStream：数据输入流
如果写的时候是writeDouble，读的时候就得是readDouble DataInputStream
public static void testDataInputStream() throws Exception {
DataInputStream in = new DataInputStream(new FileInputStream("D:/testdemo/demo/src/day13/tt8.txt"));
System.out.println(in.readDouble());
in.close();
}
对象流(序列化与反序列化):把一个对象转化为一个数据流进行读写
ObjectInputStream：对象的序列化
public static void testSerialize() throws Exception {
// 定义对象的输出流，把对象的序列化之后的流放到指定的文件中
ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("D:/testdemo/demo/src/day13/tt9.txt"));
Person p = new Person();
p.name = "zhangsan";
p.age = 11;
out.writeObject(p);
out.flush();// 刷写数据到硬盘
out.close();
}
ObjectOutputStream：对象的反序列化
public static void testDeserialize() throws Exception {
// 创建对象输入流对象，从指定的文件中把对象序列化后的流读取出来
ObjectInputStream in = new ObjectInputStream(new FileInputStream("D:/testdemo/demo/src/day13/tt9.txt"));
Object obj = in.readObject();
Person p = (Person) obj;
// 这个时候序列化与反序列化使用的类不是一个类分别是day13.Person和day13.test.Person
// 这个时候反序列化就有异常day13.Person cannot be cast to day13.test.Person
//day13.test.Person p = (day13.test.Person)obj;
System.out.println(p.name);
System.out.println(p.age);
in.close();
}
RandomAccessFile：随意存取文件流:插入位置，读取位置，存储位置随意
- RandomAccessFile的构造有两个参数，参数1是读写的文件的路径
- 参数2是指定 RandomAccessFile 的访问模式
- r: 以只读方式打开
- rw：打开以便读取和写入
- rwd:打开以便读取和写入；同步文件内容的更新
- rws:打开以便读取和写入；同步文件内容和元数据的更新
- 最常用是r和rw
随意读文件
public static void testRandomAccessFileRead() throws Exception {
RandomAccessFile ra = new RandomAccessFile("D:/testdemo/demo/src/day13/tt10.txt", "r");
//ra.seek(0);//设置读取文件内容的起始点
ra.seek(8);// 通过设置读取文件内容的起始点，来达到从文件的任意位置读取
byte[] b = new byte[1024];
int len = 0;
while ((len = ra.read(b)) != -1) {
System.out.println(new String(b, 0, len));
}
ra.close();
}
随意存文件
public static void testRandomAccessFileWrite() throws Exception {
RandomAccessFile ra = new RandomAccessFile("D:/testdemo/demo/src/day13/tt10.txt", "rw");
//ra.seek(0);//设置写的起始点，0代表从开头写
// 注意：如果是在文件开头或者中间的某个位置开始写的话，就会用写的内容覆盖掉等长度的原内容
ra.seek(ra.length());// 设置写的起始点,ra.length()代表从文件的最后结尾写，也就是文件的追加
ra.write("你好".getBytes());
ra.close();
}