1、IO
1.1、什么是IO
I: Input
O: Output
通过IO可以完成硬盘文件的读和写。
输入与输出都是相对于内存而言的,即从内存中出去叫做写,读入内存叫做读。
1.2、IO流的分类
有多种分类方式:
一种方式是按照流的方向进行分类:
以内存作为参照物,往内存中去,叫做输入(Input),或者叫做读(Read)。
往内存中出来,叫做输出(Output),或者叫做写(Write)。
另一种方式是按照读取数据的方式不同进行分类:
有的流是按照字节的方式读取数据,一次读取1个字节byte,等同于一次8个二进制位。这种流是万能的,什么类型的文件度能够读取,包括:文本文件、图片、声音文件、视频文件等等。
假设文件file1.txt,采用字节流的方式读取:
file1.txt中的内容有:a中国bc张三fe
第一次读:一个字节,正好读到 'a'
第二次读:一个字节,正好读到 '中' 字符的一半
第三次读:一个字节,正好读到 '中' 字符的另外一半
有的流是按照字符的方式读取数据的,一次读取一个字符,这种流是为了方便读取普通文本文件而存在的,这种流不能读取包括:图片、声音、视频等文件,只能读取纯文本文件,连word文件都无法读取。
假设文件file1.txt,才有字节流的方式读取:
file1.txt中的内容有:a中国bc张三fe
第一次读:'a' 字符('a'字符在Windows系统中占用1个字节)
第二次读:'中' 字符('中'字符在Windows系统中占用2个字节)
综上所述,流的分类:
输入流、输出流、字节流、字符流。
java中所有的流都是在:java.io.* 下,java中主要研究:怎么new流对象,调用刘对象的那个方法是读,那个方法是写。
1.3、IO四大家族
四大家族的首领:
java.io.InputStream 字节输入流
java.io.OutputSteam 字节输出流
java.io.Reader 字符输入流
java.io.Writer 字符输出流
四大家族的首领都是“抽象类”(abstract class)
所有的流都实现了:
java.io.Closeable接口,都是可关闭的,都有close()方法。流毕竟是一个管道,这个是内存和硬盘之间的通道,用完之后一定要关闭,不然会耗费(占用)很多资源。养成好习惯,用完流一定要关闭。
所有的输出流都实现了:
java.io.Flushable接口,都是可刷新的,都有flush()方法,养成一个好习惯,输出流在最终输出之后,一定要记得flush()刷新一下,这个刷新表示将“通道/管道”中剩余未输出的数据强行输出完(清空管道),刷新的作用就是清空管道。
注意:如果不使用flush()可能会导致丢失数据。
注意:在Java中只要“类名”以Stream结尾的都是字节流,以“Reader”或“Writer”结尾的都是字符流。
1.4、需要掌握的16个流
文件专属:
java.io.FileInputStream (掌握)
java.io.FileOutputStream(掌握)
java.io.FileReader
java.io.FileWriter
转换专属(将字节流转换成字符流):
java.io.InputStreamReader
java.io.OutputStreamWriter
缓冲流专属:
java.io.BufferReader
java.io.BufferWriter
java.io.BufferInputStream
java.io.BufferOutputStream
数据流专属:
java.io.DataInputStream
java.io.DataOutputStream
标准输出流
java.io.PrintWriter
java.io.PrintStream(掌握)
对象专属流:
java.io.ObjectInputStream(掌握)
java.io.ObjectOutputStream(掌握)
2、FileInputStream
2.1、使用read()方法读取
package javase.i0;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
/*
java.io.FileInputStream:
1、文件字节输入流,是万能的,任何类型的文件都可以采用这个流来读取。
2、字节的方式,完成输入的操作,即完成读的操作(硬盘-->内存)
分析以下程序的缺点:
一次读取一个字节byte,这样内存和硬盘交互的太频繁,基本上时间/资源都耗费在交互上面。能不能一次读取多个字节?可以。
*/
public class FileInputStreamTest01 {
public static void main(String[] args) {
// 创建文件字节流对象
// 以下都是采用的绝对路径的方式
// 文件路径:F:\Java_Project\bigDate\lesson\javase-io\src\file\1.txt,在Java中\表示转义,idea工具会自动将\变成\\
// 当然下面的\\以可以写成/
FileInputStream fileInputStream = null;
try {
// 文件1.txt中的内容为:abc
fileInputStream = new FileInputStream("F:\\Java_Project\\bigDate\\lesson\\javase-io\\src\\file\\1.txt");
/*
// 开始往fileInputStream流中读取数据,读取文件的指针一开始并不是指向文件内容的第一个字符,而是在第一个字符之前。
// 调用一次read()方法,读取文件的指针向后移动移动一位。
// 这一的read()方法返回字符本身的ASCII值。
int readData = fileInputStream.read();
System.out.println(readData); // 97
// 逐一读取下一位
readData = fileInputStream.read();
System.out.println(readData); // 98
readData = fileInputStream.read();
System.out.println(readData); // 99
// 当读取文件的指针已经移动到文件的末尾而读取不到数据时,read()方法返回-1
readData = fileInputStream.read();
System.out.println(readData); // -1
*/
// 下面使用while循环来进行读取
int filePointer = 0;
while ((filePointer = fileInputStream.read()) != -1){ // 循环中的表达式只能是true或者false
System.out.println(filePointer);
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
// 在finally语句中执行流的关闭,确保一定能够关闭。
if (fileInputStream != null) { // 避免空指针异常
// 关闭流的前提是:流不为空!流是null的时候没必要关闭!
try {
fileInputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
2.2、使用byte[]
// 2.txt 文件内容为:abcdef
fis = new FileInputStream("F:\\Java_Project\\bigDate\\lesson\\javase-io\\src\\file\\2.txt");
byte[] bytes = new byte[4]; // 准备一个4字节的byte数组,一次最多读取4个字节。
// 这个方法的返回值是:读取到的字节数量(不是字节本身)。
int readCount = fis.read(bytes); // 第一次读到4个字节
System.out.println(readCount); // 4
// 将字节数组全部转换为字符串
// System.out.println(new String(bytes)); // abcd
// 上面的这行代码有不足之处,不应该全部都转换,应该是读取了多少个字节,才转换多少个字节。
System.out.println(new String(bytes, 0, readCount));
// 第二次读取到两个字节
readCount = fis.read(bytes);
System.out.println(readCount); // 2
// 将字节数组全部转换成字符串
// 这里为什么会输出efcd?
// 原因是:第一次从文件中读取到abcd放入了byte数组中,但是第二次读取的时候只从文件中读取出了ef,这时的ef会覆盖byte数组中
// 原本已经存在的abcd中的ab,而cd没有被覆盖
// System.out.println(new String(bytes)); // efcd
// 不应该全部转换,应该是读取了多少个字节,转换多少个。
System.out.println(new String(bytes, 0, readCount)); // ef
// 如果1个字节都没有读取到,则返回-1
readCount = fis.read(bytes);
System.out.println(readCount); // -1
2.3、最终版
package javase.i0;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
/*
FileInputStream的最终版本,需要掌握
3.txt文件内容:
public class HelloWorld{
public static void main(String[] args){
System.out.println("hello world!");
}
}
*/
public class FileInputStreamTest03 {
public static void main(String[] args) {
FileInputStream fis = null;
try {
// idea的当前目录是“当前的工程目录”。
fis = new FileInputStream("javase-io/src/file/3.txt");
// 准备byte数组
byte[] bytes = new byte[4];
int readCount = 0;
// 使用while循环进行遍历
while ((readCount = fis.read(bytes)) != -1){
System.out.print(new String(bytes, 0 , readCount));
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
if (fis != null) {
try {
fis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
2.4、补充
package javase.i0;
import java.lang.String;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
/*
FileInputStream类中的其他常用方法:
int available() :返回流当中剩余的没有读到的字节数量
long skip(long n) : 跳过几个字节不读
*/
public class FileInputStreamTest04 {
public static void main(String[] args) {
FileInputStream fis = null;
try {
// 2.txt : abcdef
fis = new FileInputStream("javase-io/src/file/2.txt");
/*
System.out.println("总字节数量 : " + fis.available()); // 6
// 读1个字节
int readByte = fis.read();
// 还剩下可以读取的字节数量为:5
System.out.println("还剩下多少个字节没有读取: " + fis.available()); // 5
// 这个available()方法有什么用?
byte[] bytes = new byte[fis.available()]; // 注意:这种方法不适合太大的文件,因为byte数组不能太大。
// 不需要循环了,直接一次性全部读取
int read = fis.read(bytes); // 6
System.out.println(new String(bytes)); // abcdef
*/
// skip()方法跳过几个字节不读取,这个方法也可能以后会用到!
fis.skip(3); // 跳过前三个字节开始读取
System.out.println(fis.read()); // 100(d)
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
if (fis != null) {
try {
fis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
3、FileOutputStream
3.1、写入文件基础操作
package javase.i0.FileOutPutStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
public class FileOutputStreamTest01 {
public static void main(String[] args) {
FileOutputStream fio = null;
try {
// myfile.txt文件不存在的时候会自动新建。
// 这种方式谨慎使用,这种方式会先将原来文件中的内容清空,然后重新写入。
// fio = new FileOutputStream("javase-io/src/file/myfile.txt");
// 以追加的方式在文件末尾写入,不会清空原有文件内容。
fio = new FileOutputStream("javase-io/src/file/myfile.txt", true);
// 创建byte数组
byte[] bytes = {97, 98, 99, 100}; // abcd
// 将byte数组全部写出!
fio.write(bytes); // abcd
// 将byte数组的一部分写出
fio.write(bytes, 0, 2); // ab
String str = "我是一个中国人,我非常的骄傲!";
// 将字符串转换成byte数组
byte[] strBytes = str.getBytes();
fio.write(strBytes);
// 写完之后一定要“刷新”
fio.flush();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally{
if (fio != null) {
try {
fio.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
3.2、文件复制
package javase.i0;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
/*
使用FileInputStream + FileOutputStream完成文件的拷贝。拷贝的过程应该是一边读、一边写。
使用以上的字节流拷贝文件的时候,文件的类型随意,没有限制。什么样的文件都能够进行拷贝。
*/
public class FileCopy01 {
public static void main(String[] args) {
// 创建文件字节输入流对象
FileInputStream fis = null;
// 创建文件字节输出流对象
FileOutputStream fos = null;
try {
// 创建文件输入流对象
fis = new FileInputStream("C:\\Users\\friendship\\ez_php.mp4");
// 创建文件输出流对象
fos = new FileOutputStream("C:\\Users\\friendship\\Desktop\\FileCopyTest01.mp4");
// 创建byte数组,一次读取:1MB
byte[] bytes = new byte[1024 * 1024];
int readCount = 0;
while ((readCount = fis.read(bytes)) != -1){
fos.write(bytes, 0 , readCount);
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
// 这里最好分开进行关闭,以避免一个流关闭出现问题而影响另外一个流的关闭。
if (fis != null) {
try {
fis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (fos != null) {
try {
fos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
4、FileReader
package javase.i0;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
/*
FileReader : 读取纯文本文件。
*/
public class FileReaderTest01 {
public static void main(String[] args) {
FileReader reader = null;
try {
// 创建文件字符输入流对象
reader = new FileReader("javase-io/src/file/2.txt");
// 使用char数组保留读取的结果
char[] chars = new char[4]; // 一次读取4个字符
int readCount = 0;
while ((readCount = reader.read(chars)) != -1){
System.out.print(new String(chars, 0 ,readCount));
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
if (reader != null) {
try {
reader.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
5、FileWriter
package javase.i0;
import java.io.FileWriter;
import java.io.IOException;
/*
FileWriter:
文件字符输出流,只能输出普通文本。
*/
public class FileWriterTest01 {
public static void main(String[] args) {
FileWriter fw = null;
try {
// 创建文件字符输出流对象
// 使用这种方式创建写入文件:
// 1.如果指定的文件不存在,则自动新建文件并写入相关的数据。
// 2.如果文件已经存在,则会先将原来文件的内容清空再写入相应的数据。
// 3.这种方法应该谨慎使用。
// fw = new FileWriter("javase-io/src/file/fw_test.txt");
// 以追加的形式写入文件信息:
// 1.如果文件不存在则创建文件。
// 2.如果文件已经存在则在文件的末尾添加信息。
fw = new FileWriter("javase-io/src/file/fw_test.txt",true);
// 创建数据
char[] chars = {'我','是','中','国','人'};
// 使用char数组提供数据
fw.write(chars);
// 写入一个换行符
fw.write("\n");
// 直接写入字符串
fw.write("我爱我的祖国!");
//刷新
fw.flush();
} catch (IOException e) {
e.printStackTrace();
} finally {
if (fw != null) {
try {
fw.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
5.1、文本文件的复制
package javase.i0;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
// 使用FileReader和FileWriter对文件进行copy,这两个类只能对普通的文本文件进行编辑。
// 能使用记事本打开编辑的都是普通的“文本文件”。
public class FileCopy02RW {
public static void main(String[] args) {
FileReader fileReader = null;
FileWriter fileWriter = null;
try {
fileReader = new FileReader("javase-io/src/file/myfile.txt");
fileWriter = new FileWriter("javase-io/src/file/myfile_copy02.txt");
char[] chars = new char[4]; // 每次读取4个字符
int readCount = 0;
while ((readCount = fileReader.read(chars))!= -1){
fileWriter.write(chars, 0, readCount);
}
// 刷新
fileWriter.flush();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
if (fileReader != null) {
try {
fileReader.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (fileWriter != null) {
try {
fileWriter.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
6、缓冲字符流
6.1、BufferedReader
package javase.i0;
import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
/*
BufferedReader:
带有缓冲的字符输入流,使用这个流的时候不需要自定义char数组,或者说不需要自定义byte数组,自带缓冲。
*/
public class BufferedReaderTest01 {
public static void main(String[] args) {
BufferedReader br = null;
try {
FileReader reader = new FileReader("javase-io/src/javase/i0/FileCopy01.java");
// 当一个流的构造方法中需要一个另一个流的时候,这个被传进来的流叫做“节点流”。
// 外部负责包装的这个流,叫做:包装流或处理流。
// 像当前这个程序来说:FileReader就是一个节点流,BufferedReader就是一个包装流。
br = new BufferedReader(reader);
/*
// 读一行
String Line = br.readLine();
System.out.println(Line);
// 读取第二行
Line = br.readLine();
System.out.println(Line);
*/
// 使用循环来进行读取,br.readLine()方法读取的内容不包含“换行符”。
String str = null;
while ((str = br.readLine())!=null){
System.out.println(str); //
}
} catch (Exception e) {
e.printStackTrace();
} finally {
// 关闭流
// 对于包装流来说,只需要关闭最外层流,里面的节点流会自动关闭(参考源代码)。
if (br != null) {
try {
br.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
6.2、流的转换
package javase.i0;
import java.io.*;
/*
InputStreamReader:字节流->字符流
*/
public class BufferedReaderTest02 {
public static void main(String[] args) {
BufferedReader br = null;
try {
// 字节流
FileInputStream in = new FileInputStream("javase-io/src/javase/i0/FileCopy01.java");
// 通过转换流转换(InputStreamReader将字节流转换为字符流)
// in是节点流,reader是包装流
InputStreamReader reader = new InputStreamReader(in);
// 这个构造方法只能传递一个字符流,不能传递字节流
// 在这里reader是节点流,br是包装流
br = new BufferedReader(reader);
String line = null;
while ((line = br.readLine())!=null){
System.out.println(line);
}
} catch (Exception e) {
e.printStackTrace();
} finally {
if (br != null) {
try {
br.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
7、数据流(了解)
7.1、DataOutputStream
package javase.i0;
import java.io.DataOutputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
/*
java.io.DataOutputStream : 数据专属流
这个流可以将数据连同数据类型一并写入文件。注意:这个文件不是普通的文本文件(记事本无法打开)。
*/
public class DataOutputStreamTest01 {
public static void main(String[] args) {
// 创建数据专属的字节输出流
DataOutputStream dataOutputStream = null;
try {
// 创建数据专属的字节输出流
dataOutputStream = new DataOutputStream(new FileOutputStream("javase-io/src/file/data"));
// 数据
byte b = 100;
short s = 200;
int i = 300;
long l = 500L;
float f = 3.0F;
double d = 3.14;
boolean sex = false;
char c = 'a';
// 写数据
// 把数据已经数据的类型一并写入到文件当中。
dataOutputStream.writeByte(b);
dataOutputStream.writeShort(s);
dataOutputStream.writeInt(i);
dataOutputStream.writeLong(l);
dataOutputStream.writeFloat(f);
dataOutputStream.writeDouble(d);
dataOutputStream.writeBoolean(sex);
dataOutputStream.writeChar(c);
// 刷新
dataOutputStream.flush();
} catch (Exception e) {
e.printStackTrace();
} finally {
if (dataOutputStream != null) {
try {
dataOutputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
7.2、DataInputStream
package javase.i0;
import java.io.DataInputStream;
import java.io.FileInputStream;
import java.io.IOException;
/*
DataInputStream:数据字节输入流
DataOutputStream写的文件,只能使用 DataInputStream来读取,并且读的时候还需要知道写入数据的顺序。
读和写的顺序一致时,才可以正常取出数据。
*/
public class DataInputStreamTest01 {
public static void main(String[] args) {
DataInputStream dataInputStream = null;
try {
dataInputStream = new DataInputStream(new FileInputStream("javase-io/src/file/data"));
// 开始读取数据
byte b = dataInputStream.readByte();
short s = dataInputStream.readShort();
long l = dataInputStream.readLong();
int i = dataInputStream.readInt();
float v = dataInputStream.readFloat();
double v1 = dataInputStream.readDouble();
boolean b1 = dataInputStream.readBoolean();
char c = dataInputStream.readChar();
// 打印数据
System.out.println(b);
System.out.println(s);
System.out.println(l);
System.out.println(i + 1000); // int类型支持数值的四则运算 1300
System.out.println(v);
System.out.println(v1);
System.out.println(b1);
System.out.println(c);
} catch (Exception e) {
e.printStackTrace();
} finally {
if (dataInputStream != null) {
try {
dataInputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
8、标准输出流
8.1、PrintStream
package javase.i0;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.PrintStream;
/*
java.io.PrintStream:标准的字节输出流,默认输出到控制台。
默认的标准数据流不用显示的手动close();
*/
public class PrintStreamTest01 {
public static void main(String[] args) {
// 联合起来写
System.out.println("hello world"); // hello world
// 分开写
PrintStream printStream = System.out;
printStream.println("我爱Java!"); // 我爱Java!
try {
// 设置标准输出流的输出方向,这里设置为输出到“指定的文件中”。通常日志就是使用这种原理。see LoggerUtil.java
System.setOut(new PrintStream(new FileOutputStream("javase-io/src/file/javaPrintLog.txt", true)));
System.out.println("printStream-filename");
} catch (FileNotFoundException e) {
e.printStackTrace();
}
// 测试LoggerUtil日志类
LoggerUtil.log("用户“我爱你Java”登录成功登录系统!");
}
}
LoggerUtil.java
package javase.i0;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.PrintStream;
import java.text.SimpleDateFormat;
import java.util.Date;
public class LoggerUtil {
public static void log(String msg){
try {
// 设置标准流的输出方向
System.setOut(new PrintStream(new FileOutputStream("javase-io/src/file/selfDefineLog.txt", true)));
// 获取标准数据流对象
PrintStream printStream = System.out;
// 获取系统当前时间
Date date = new Date();
// 格式化时间格式 yyyy-MM-dd HH:mm:ss SSS
// yyyy-MM-dd HH:mm:ss
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS");
// 将日志信息输入到相应的文件中
printStream.println(sdf.format(date) + " : " + msg);
} catch (FileNotFoundException e) {
e.printStackTrace();
}
}
}
9、File类
package javase.i0.File;
import java.io.File;
import java.text.SimpleDateFormat;
import java.util.Date;
/*
File:
1、File类和流四大家族没有关系,所有File不能完成文件的读和写。
2、File对象代表什么?
文件和目录路径名的抽象表示形式。
C:\Drivers 这是一个File对象
C:\ftlog.log 这也是File对象
一个File对象有可能对应的是目录,也有可能是文件,File只是一个路径名的抽象表示形式。
3、需要掌握File类中的常用方法(这个程序中出现的每个方法都要练)。
String getName() 获取文件名
boolean isDirectory() 是否是一个目录
boolean isFile() 是否是一个文件
long lastModified() 获取文件最后修改的总毫秒数
File[] listFiles() 获取当前目录下所有的子文件
……
*/
public class FileTest01 {
public static void main(String[] args) {
// 创建一个File对象
File f1 = new File("D:\\file");
// 判断指定的File对象是否存在,即这里表示的是D:\有没有file这个文件或者目录
System.out.println(f1.exists());
// 如果D:\file不存在,则以文件的形式创建出来
/*
if (!f1.exists()){
try {
f1.createNewFile();
} catch (IOException e) {
e.printStackTrace();
}
}
*/
// 如果D:\file不存在,则以目录的形式创建出来
/*
if (!f1.exists()){
f1.mkdir();
}
*/
// 创建多重目录 - mkdirs()
/*
File f2 = new File("D:\\a\\b\\cc");
if (!f2.exists()){
System.out.println(f2.mkdirs());
}
*/
/*
File f3 = new File("D:\\赛题征集\\ez_web\\exp.py");
// 获取文件的父路径(方法一)
String parentPath = f3.getParent();
System.out.println(parentPath); // D:\赛题征集\ez_web\
// 方法二
File parentFile = f3.getParentFile();
System.out.println("获取绝对路径: " + parentFile.getAbsolutePath()); // D:\赛题征集\ez_web\ 即父文件的绝对路径。
// 获取文件的绝对路径
File f4 = new File("javase-io/src/file/2.txt");
System.out.println(f4.getAbsolutePath()); // F:\Java_Project\bigDate\lesson\javase-io\src\file\2.txt
*/
// 获取文件最后一次修改的时间
File f5 = new File("D:\\赛题征集\\ez_web\\Writeup.md");
long l = f5.lastModified(); // 这个毫秒数是从1970年到现在的总的毫秒数
// 将总毫秒数转换成日期
Date date = new Date(l);
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH-mm-ss SSS");
System.out.println(sdf.format(date)); // 2021-10-11 17-06-15 361
// 获取文件大小
System.out.println(f5.length()); // 2339 字节
// 获取当前目录下所有的子文件
File f6 = new File("D:\\赛题征集\\ez_web");
File[] files = f6.listFiles();
assert files != null;
for (File file : files) {
// 只获取文件名
System.out.println(file.getName());
}
}
}
9.1、目录拷贝
package javase.i0.File;
import java.io.*;
// 目录的拷贝
public class DirCopy {
public static void main(String[] args) {
// 拷贝源
File srcFile = new File("C:\\Users\\friendship\\Desktop\\common");
// 拷贝目标
File destFile = new File("D:\\");
// 调用方法进行拷贝
copyDir(srcFile, destFile);
}
/**
* Java实现目录的拷贝
* @param srcFile 拷贝源
* @param destFile 拷贝目标地址
*/
private static void copyDir(File srcFile, File destFile) {
if (srcFile.isFile()){
// srcFile如果是一个文件,递归结束
// srcFile是文件的时候进行拷贝,一边读、一边写
FileInputStream fileInputStream = null;
FileOutputStream fileOutputStream = null;
try {
// 读取目标文件
fileInputStream = new FileInputStream(srcFile);
// 写入对应的文件中
String path = (destFile.getAbsolutePath().endsWith("\\") ? destFile.getAbsolutePath() :
destFile.getAbsolutePath() + "\\") + srcFile.getAbsolutePath().substring(3);
fileOutputStream = new FileOutputStream(path);
// 一边读取、一边写入。每次copy 1MB
byte[] bytes = new byte[1024 * 1024];
int readCount = 0;
while ((readCount = fileInputStream.read(bytes)) != -1){
fileOutputStream.write(bytes, 0 , readCount);
}
// 刷新
fileOutputStream.flush();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
if (fileInputStream != null) {
try {
fileInputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (fileOutputStream != null) {
try {
fileOutputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
// 如果是文件,写入完成之后直接结束。
return;
}
// 获取所有的子目录
File[] files = srcFile.listFiles();
if (files != null){
for (File file : files) {
// 获取所有文件的(包括目录和文件)绝对路径
// System.out.println(file.getAbsolutePath());
if (file.isDirectory()){
// 新建对应的目录
String srcDir = file.getAbsolutePath().substring(3);
String destDir = (destFile.getAbsolutePath().endsWith("\\") ? destFile.getAbsolutePath() :
destFile.getAbsolutePath() + "\\") + srcDir;
File newFile = new File(destDir);
if (!newFile.exists()){
newFile.mkdirs();
}
}
// 递归调用
copyDir(file, destFile);
}
}
}
}
10、对象流
10.1、序列化与反序列化
序列化:Serialize
在进行对象的序列化时,如果一个类的某个属性被transient关键字所修饰时,表示这个关键字不参与序列化。
反序列化:Deserialize
10.2、序列化
Student.java
package javase.Bean;
import java.io.Serializable;
public class Student implements Serializable {
// Java虚拟机看到Serializable接口之后,会自动生成一个序列化版本号。
// 这里没有手动写出来,Java虚拟机会默认提供这个反序列化版本号。
private int no;
private String name;
public Student() {
}
public Student(int no, String name) {
this.no = no;
this.name = name;
}
public int getNo() {
return no;
}
public void setNo(int no) {
this.no = no;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "Student{" +
"no=" + no +
", name='" + name + '\'' +
'}';
}
}
ObjectOutputStreamTest01.java
package javase.i0.Serialize;
import javase.Bean.Student;
import java.io.FileOutputStream;
import java.io.ObjectOutputStream;
/*
1、java.io.NotSerializableException:
Student对象不支持序列化
2、参与序列化和反序列化的对象,必须实现Serializable接口。
3、注意:通过源代码发现,Serializable接口只是一个标志接口:
public interface Serializable {}
这个接口当中什么代码都没有,那么有什么用呢?
起到标识、标志的作用,Java虚拟机看到这个类实现这个接口后,可能会对这个类进行特殊待遇。
Serializable这个标志接口是给Java虚拟机参考的,Java虚拟机看到这个接口之后,会为该类自动生成一个序列化版本号。
4、序列化版本号有什么用?
*/
public class ObjectOutputStreamTest01 {
public static void main(String[] args) throws Exception {
// 创建Java对象
Student s = new Student(1, "zhangsan");
// 序列化
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("javase-io/src/file/students"));
// 序列化对象
oos.writeObject(s);
// 刷新
oos.flush();
// 关闭
oos.close();
}
}
10.3、反序列化
package javase.i0.Serialize;
import java.io.FileInputStream;
import java.io.ObjectInputStream;
/*
反序列化对象
*/
public class ObjectInputStreamTest01 {
public static void main(String[] args) throws Exception {
// 创建反序列化对象
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("javase-io/src/file/students"));
// 这里的使用readObject()读取文件中的内容,开始反序列化。
Object students = ois.readObject();
// 反序列化回来的是一个学生对象。所有会默认调用Students类中的toString()方法。
System.out.println(students);
// 关闭
ois.close();
}
}
10.4、补充
package javase.i0.Serialize;
import javase.Bean.User;
import java.io.FileOutputStream;
import java.io.ObjectOutputStream;
import java.util.ArrayList;
import java.util.List;
/*
一次序列化多个对象呢?
可以,将对象放到集合当中,序列化集合。
提示:参与序列化的ArrayList集合以及集合中的元素User都需要实现java.io.Serializable接口。
*/
public class ObjectOutputStreamTest02 {
public static void main(String[] args) throws Exception {
List<User> userList = new ArrayList<>();
userList.add(new User(1, "zhangsan"));
userList.add(new User(2, "lisi"));
userList.add(new User(3, "wangliu"));
// 开始序列化一个List集合
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("javase-io/src/file/userList"));
// 写入List集合中的对象
oos.writeObject(userList);
// 刷新
oos.flush();
// 关闭
oos.close();
}
}
package javase.i0.Serialize;
import javase.Bean.User;
import java.io.FileInputStream;
import java.io.ObjectInputStream;
import java.util.List;
/*
反序列化集合。
*/
public class ObjectInputStreamTest02 {
public static void main(String[] args) throws Exception {
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("javase-io/src/file/userList"));
Object obj = ois.readObject();
// System.out.println(obj instanceof List); // true
List<User> userList = (List<User>) obj;
for (User user : userList) {
// 输出:
/*
User{no=1, username='zhangsan'}
User{no=2, username='lisi'}
User{no=3, username='wangliu'}
*/
System.out.println(user); // 输出引用的时候会自动调用引用的toString()方法。
}
//关闭
ois.close();
}
}
transient关键字;
public class User implements Serializable {
private int no;
// username使用transient关键字修饰,表示在序列化User类的时候,username不参加序列化。
private transient String username;
public User(){}
public User(int no, String username) {
this.no = no;
this.username = username;
}
}
10.5、序列化版本号
Student.java
package javase.Bean;
import java.io.Serializable;
public class Student implements Serializable {
// Java虚拟机看到Serializable接口之后,会自动生成一个序列化版本号。
// 这里没有手动写出来,Java虚拟机会默认提供这个反序列化版本号。
// 建议将序列化版本号手动的写出来,不建议自动生成。
// private static final long serialVersionUID = 1L; // java虚拟机识别一个类的时候先通过类名,如果不能区分;在通过序列化版本号。
private static final long serialVersionUID = 5506495958222352416L; // idea自动生成。
private int no;
private String name;
// 过了很久,Student这个类源代码改动了,源代码改动之后,需要重新编译,编译之后生成了全新的直接码文件。
// 并且class文件再次运行的时候,java虚拟机生成的序列化版本号也会发生相应的改变。
// private int age;
public Student() {
}
public Student(int no, String name) {
this.no = no;
this.name = name;
}
public int getNo() {
return no;
}
public void setNo(int no) {
this.no = no;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "Student{" +
"no=" + no +
", name='" + name + '\'' +
'}';
}
}
ObjectOutputStreamTest01.java
package javase.i0.Serialize;
import javase.Bean.Student;
import java.io.FileOutputStream;
import java.io.ObjectOutputStream;
/*
1、java.io.NotSerializableException:
Student对象不支持序列化
2、参与序列化和反序列化的对象,必须实现Serializable接口。
3、注意:通过源代码发现,Serializable接口只是一个标志接口:
public interface Serializable {}
这个接口当中什么代码都没有,那么有什么用呢?
起到标识、标志的作用,Java虚拟机看到这个类实现这个接口后,可能会对这个类进行特殊待遇。
Serializable这个标志接口是给Java虚拟机参考的,Java虚拟机看到这个接口之后,会为该类自动生成一个序列化版本号。
4、序列化版本号有什么用?
javase.Bean.Student;
local class incompatible:
stream classdesc serialVersionUID = 478455862847212921(十年前)
local class serialVersionUID = 5506495958222352416(十年后)
Java语言中是采用什么机制来区分类的?
第一:首先通过类名进行对比,如果类名不一样,肯定不是同一个类。
第二:如果类名一样,再怎么进行区分?靠的就是序列化版本号进行区分。
张三编写了一个类:com.zh0u.bean.Student implements Serializable
李四编写了一个类:com.zh0u.bean.Student implements Serializable
不同的人编写了同一个类,但“这两个类确实不是同一个类”。这个时候序列化版本号就起上作用了,对于Java虚拟机来说,它是可以区分开
这两个类的,因为这两个类都实现了Serializable接口,都有默认的序列化版本号,他们序列化版本号不一样。所以区分开了。(这是自动生成序列化版本的好处)
请思考:
这种自动生成序列化版本号有什么缺陷?
这种自动生成序列化版本号缺点是:一旦代码确定之后,不能进行后续的修改,因为只要修改,必然后重新编译,此时会生成全新的
的序列化版本号,这个时候Java虚拟机会自认为这是一个全新的类。(这样就不好了!)
重点结论:
凡是一个实现了Serializable接口,建议给该类提供一个补丁不变的序列化版本号。这样,以后这个类即使代码被修改了,但是版本号不变,
Java虚拟机认为是同一个类。
*/
public class ObjectOutputStreamTest01 {
public static void main(String[] args) throws Exception {
// 创建Java对象
Student s = new Student(1, "zhangsan");
// 序列化
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("javase-io/src/file/students"));
// 序列化对象
oos.writeObject(s);
// 刷新
oos.flush();
// 关闭
oos.close();
}
}
ObjectInputStreamTest01.java
package javase.i0.Serialize;
import java.io.FileInputStream;
import java.io.ObjectInputStream;
/*
反序列化对象
*/
public class ObjectInputStreamTest01 {
public static void main(String[] args) throws Exception {
// 创建反序列化对象
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("javase-io/src/file/students"));
// 这里的使用readObject()读取文件中的内容,开始反序列化。
Object students = ois.readObject();
// 反序列化回来的是一个学生对象。所有会默认调用Students类中的toString()方法。
System.out.println(students);
// 关闭
ois.close();
}
}
idea自动生成serilizable版本号,
10.6、IO与Properties
userInfo.properties
# 建议key和value之间使用=进行连接
# 不建议使用“:”好的方式进行区分,如:username:zh0u_admin不建议使用
username=zh0u_admin
password=_zh0u_123
package javase.i0;
import java.io.FileReader;
import java.util.Properties;
/*
IO+Properties的联合使用:
非常好的一个设计理念:
以后经常改变的数据,可以单独写到一个文件中,使用程序动态读取。
将来只需要修改这个文件的内容,Java代码不需要改动,不需要重新
编译,服务器也不需要重启。就可以动态的拿到信息。
类似于以上机制的这种文件被称为配置文件。
并且当配置文件中的内容格式是:
key1=value1 # 这里的key和value之间最好不要有空格。
key2=value2
的时候,我们把这种配置文件叫做“属性属性配置文件”。
Java规范中有要求:属性配置文件建议以.properties结尾,但这不是必须的。
这种以.properties结尾的文件在Java中被称为:属性配置文件。
其中Properties对象是专门存放属性配置文件内容的一个类。在属性配置文件中,#表示注释。
如果属性配置文件中的key部分出现重复时,这个时候的value会自动覆盖。
*/
public class IoPropertiesTest01 {
public static void main(String[] args) throws Exception{
// Properties是一个Map集合,key和value都是String类型。
// 将javase-io/src/file/userInfo文件中的数据加载到Properties对象当中。
// 新建一个输入流对象
FileReader fileReader = new FileReader("javase-io/src/file/userInfo.properties");
// 新建一个Map集合
Properties properties = new Properties();
// 调用Properties对象的load方法将文件中的数据加载到Map集合中。
properties.load(fileReader); // 文件中的数据顺着管道加载到Map集合中,其中等号左边做key,右边做value。
// 通过key来获取value
String username = properties.getProperty("username");
String password = properties.getProperty("password");
System.out.println(username + " : " + password);
}
}
10.6、IO与Properties
userInfo.properties
# 建议key和value之间使用=进行连接
# 不建议使用“:”好的方式进行区分,如:username:zh0u_admin不建议使用
username=zh0u_admin
password=_zh0u_123
package javase.i0;
import java.io.FileReader;
import java.util.Properties;
/*
IO+Properties的联合使用:
非常好的一个设计理念:
以后经常改变的数据,可以单独写到一个文件中,使用程序动态读取。
将来只需要修改这个文件的内容,Java代码不需要改动,不需要重新
编译,服务器也不需要重启。就可以动态的拿到信息。
类似于以上机制的这种文件被称为配置文件。
并且当配置文件中的内容格式是:
key1=value1 # 这里的key和value之间最好不要有空格。
key2=value2
的时候,我们把这种配置文件叫做“属性属性配置文件”。
Java规范中有要求:属性配置文件建议以.properties结尾,但这不是必须的。
这种以.properties结尾的文件在Java中被称为:属性配置文件。
其中Properties对象是专门存放属性配置文件内容的一个类。在属性配置文件中,#表示注释。
如果属性配置文件中的key部分出现重复时,这个时候的value会自动覆盖。
*/
public class IoPropertiesTest01 {
public static void main(String[] args) throws Exception{
// Properties是一个Map集合,key和value都是String类型。
// 将javase-io/src/file/userInfo文件中的数据加载到Properties对象当中。
// 新建一个输入流对象
FileReader fileReader = new FileReader("javase-io/src/file/userInfo.properties");
// 新建一个Map集合
Properties properties = new Properties();
// 调用Properties对象的load方法将文件中的数据加载到Map集合中。
properties.load(fileReader); // 文件中的数据顺着管道加载到Map集合中,其中等号左边做key,右边做value。
// 通过key来获取value
String username = properties.getProperty("username");
String password = properties.getProperty("password");
System.out.println(username + " : " + password);
}
}