数据流
DataOutputStream
package com.bjpowernode.javase.io;
import java.io.DataOutputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
/*
java.io.DataOutputStream:数据专属的流。
这个流可以将数据连同数据的类型一并写入文件。
注意:这个文件不是普通文本文档。(这个文件使用记事本打不开。)
*/
public class DataOutputStreamTest {
public static void main(String[] args) throws Exception {
// 创建数据专属的字节输出流
DataOutputStream dos = new DataOutputStream(new FileOutputStream("data"));
// 写数据
byte b = 100;
short s = 200;
int i = 300;
long l = 400L;
float f = 3.0F;
double d = 3.14;
boolean sex = false;
char c = 'a';
// 写
dos.writeByte(b); // 把数据以及数据的类型一并写入文件当中
dos.writeShort(s);
dos.writeInt(i);
dos.writeLong(l);
dos.writeFloat(f);
dos.writeDouble(d);
dos.writeBoolean(sex);
dos.writeChar(c);
// 刷新
dos.flush();
// 关闭最外层流
dos.close();
}
}
DataInputStream
package com.bjpowernode.javase.io;
import java.io.DataInputStream;
import java.io.FileInputStream;
/*
DataInputStream:数据字节输入流。
DataOutputStream写的文件,只能使用DataInputStream去读。并且读的时候你需要提前知道写入的顺序。
读的顺序需要和写的顺序一致。才可以正常取出数据。
中国电信开发项目:
话务员,每天打电话
*/
public class DataInputStreamTest {
public static void main(String[] args) throws Exception{
DataInputStream dis = new DataInputStream(new FileInputStream("data"));
// 开始读
byte b = dis.readByte();
short s = dis.readShort();
int i = dis.readInt();
long l = dis.readLong();
float f = dis.readFloat();
double d = dis.readDouble();
Boolean sex = dis.readBoolean();
char c = dis.readChar();
System.out.println(b);
System.out.println(s);
System.out.println(i + 1000);
System.out.println(l);
System.out.println(f);
System.out.println(d);
System.out.println(sex);
System.out.println(c);
dis.close();
}
}
标准输出流
PrintStream
package com.bjpowernode.javase.io;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.PrintStream;
/*
java.io.PrintStream:标准的字节输出流。默认输出到控制台。
*/
public class PrintStreamTest {
public static void main(String[] args) throws Exception {
// 联合起来写
System.out.println("Hello World!");
// 分开写
PrintStream ps = System.out;
ps.println("hello zhangsan");
ps.println("hello lisi");
ps.println("hello wangwu");
// 标准输出流不需要手动close()关闭。
// 可以改变标准输出流的输出方向吗?可以
/*
// 这些是之前System类使用过的方法和属性
System.gc();
System.currentTimeMillis();
PrintStream ps2 = System.out;
System.exit(0);
System.arraycopy();
*/
// 标准输出流不再指向控制台,指向"log"文件。
PrintStream printStream = new PrintStream(new FileOutputStream("log"));
// 修改输出方向,将输出方向修改到"log"文件
System.setOut(printStream);
// 再输出
System.out.println("hello world");
System.out.println("hello kitty");
System.out.println("hello zhangsan");
}
}
日志文件
- 日志工具方法
package com.bjpowernode.javase.io;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.PrintStream;
import java.text.SimpleDateFormat;
import java.util.Date;
/*
日志工具
*/
public class Logger {
public static void log(String msg) {
/*
* 记录日志的方法
* */
try {
// 指向一个日志文件
PrintStream out = new PrintStream(new FileOutputStream("log.txt", true));
// 改变输出方向
System.setOut(out);
// 日期当前时间
Date nowTime = new Date();
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS");
String strTime = sdf.format(nowTime);
System.out.println(strTime + ": " + msg);
} catch (FileNotFoundException e) {
e.printStackTrace();
}
}
}
- 调用日志工具
package com.bjpowernode.javase.io;
public class LogTest {
public static void main(String[] args) {
// 测试工具类是否好用
Logger.log("调用了System类的gc()方法,建议启动垃圾回收");
Logger.log("用户尝试登录,验证失败!");
}
}
java.io.File类
package com.bjpowernode.javase.io;
import java.io.File;
/*
File
1、File类和四大家族没有关系,所以File类不能完成文件的读和写。
2、File对象代表什么?
文件和目录路径名的抽象表示形式。
C:\Drivers 这是一个File对象。
C:\Drivers\Lan\Realtek\Readme.txt 也是File对象。
一个File对象有可能对应的是目录,也可能是文件。
File只是一个路径名的抽象表示形式。
3、需要掌握File类中的常用方法。
*/
public class FileTest01 {
public static void main(String[] args) throws Exception{
// 创建一个File对象
File f1 = new File("D:\\Java\\Pros\\IdeaPros\\advanced_21\\file");
// 判断是否存在!
System.out.println(f1.exists()); // false
/*// 如果file不存在,则以文件的形式创建出来
if(!f1.exists()){
// 以文件形式新建
f1.createNewFile();
}*/
/*// 如果file不存在,则以目录的形式创建出来
if(!f1.exists()){
// 以目录形式新建
f1.mkdir();
}*/
/*// 可以创建多重目录吗?可以
File f2 = new File("D:\\Java\\Pros\\IdeaPros\\advanced_21\\A\\B\\C\\D");
if(!f2.exists()){
// 以多重目录的形式新建
f2.mkdirs();
}*/
File f3 = new File("D:\\Java\\Pros\\IdeaPros\\advanced_21\\什么是IO.png");
// 获取文件的父路径
String parentPath = f3.getParent();
System.out.println(parentPath); // D:\Java\Pros\IdeaPros\advanced_21
File parentFile = f3.getParentFile();
System.out.println("绝对路径: " + parentFile.getAbsolutePath()); // 绝对路径: D:\Java\Pros\IdeaPros\advanced_21
File f4 = new File("什么是IO.png");
System.out.println("绝对路径: " + f4.getAbsolutePath()); // 绝对路径: D:\Java\Pros\IdeaPros\advanced_21\什么是IO.png
}
}
package com.bjpowernode.javase.io;
import java.io.File;
import java.text.SimpleDateFormat;
import java.util.Date;
/*
File类的常用方法:
*/
public class FileTest02 {
public static void main(String[] args) {
File f1 = new File("D:\\Java\\Pros\\IdeaPros\\advanced_21\\文件的复制原理.png");
// 获取文件名
System.out.println("文件名: " + f1.getName());
// 判断是否是一个目录?判断是否是一个文件?
System.out.println(f1.isDirectory()); // false
System.out.println(f1.isFile()); // true
// 获取文件的最后一次修改时间
long haoMiao = f1.lastModified(); // 这个毫秒数是从1970年到现在的总毫秒数
// 将总毫秒数转换成日期
Date time = new Date(haoMiao);
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS");
String strTime = sdf.format(time);
System.out.println(strTime);
// 获取文件大小
System.out.println(f1.length()); // 95184字节
}
}
package com.bjpowernode.javase.io;
import java.io.File;
/*
File中的listFiles方法。
*/
public class FileTest03 {
public static void main(String[] args) {
// File[] listFiles()
// 获取当前目录下所有的子文件。
File f = new File("D:\\Java\\Pros\\IdeaPros");
File[] files = f.listFiles();
// foreach
for(File file : files){
// System.out.println(file.getAbsolutePath());
System.out.println(file.getName());
}
}
}
目录拷贝
package com.bjpowernode.javase.io;
import java.io.*;
/*
拷贝目录
*/
public class CopyAll {
public static void main(String[] args) {
// 拷贝源
File srcFile = new File("D:\\研究生专业课\\综合英语");
// 拷贝目标
File destFile = new File("D:\\Java\\Pros\\IdeaPros\\advanced_21");
// 调用方法拷贝
copyDir(srcFile, destFile);
}
/**
* 拷贝目录
* @param srcFile 拷贝源
* @param destFile 拷贝目标
*/
private static void copyDir(File srcFile, File destFile) {
if(srcFile.isFile()){
// srcFile如果是一个文件的话,递归结束。
// 是文件的时候需要拷贝。
// ........一边读,一边写
FileInputStream in = null;
FileOutputStream out = null;
try {
// 读这个文件
// D:\研究生专业课\综合英语\录频\PPT展示\1.mp4
in = new FileInputStream(srcFile);
// 写到这个文件中
// D:\Java\Pros\IdeaPros\advanced_21\研究生专业课\综合英语\录频\PPT展示\1.mp4
String path = (destFile.getAbsolutePath().endsWith("\\") ? destFile.getAbsolutePath() : destFile.getAbsolutePath() + "\\") + srcFile.getAbsolutePath().substring(3);
out = new FileOutputStream(path);
// 一边读一边写
byte[] bytes = new byte[1024 * 1024]; // 一次复制1MB
int readCount = 0;
while((readCount = in.read(bytes)) != -1){
out.write(bytes, 0, readCount);
}
out.flush();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally{
if(in != null){
try {
in.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if(out != null){
try {
out.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
return;
}
// 获取源下面的子目录
File[] files = srcFile.listFiles();
for(File file : files){
// 获取所有文件的(包括文件和目录)绝对路径
//System.out.println(file.getAbsolutePath());
if(file.isDirectory()){
// 新建对应的目录
//System.out.println(file.getAbsolutePath());
// D:\研究生专业课\综合英语\录频 源目录
// D:\Java\Pros\IdeaPros\advanced_21\研究生专业课\综合英语\录频 目标目录
String srcDir = file.getAbsolutePath();
//System.out.println(srcDir.substring(3));
String destDir = (destFile.getAbsolutePath().endsWith("\\") ? destFile.getAbsolutePath() : destFile.getAbsolutePath() + "\\") + srcDir.substring(3);
//System.out.println(destDir);
File newFile = new File(destDir);
if(!newFile.exists()){
// 以多重目录形式
newFile.mkdirs();
}
}
// 递归调用
copyDir(file, destFile);
}
}
}
序列化和反序列化
原理
## 序列化的实现
package com.bjpowernode.javase.bean;
import java.io.Serializable;
public class Student implements Serializable {
// Java虚拟机看到Serialzable接口之后,会自动生成一个序列化版本号
// 这里没有手动写出来,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 + '\'' +
'}';
}
}
package com.bjpowernode.javase.io;
import com.bjpowernode.javase.bean.Student;
import java.io.FileOutputStream;
import java.io.ObjectOutputStream;
import java.rmi.server.ExportException;
/*
1、java.io.NotSerializableException:
Student这个类不支持序列化,需要实现接口Serializable。
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(111, "zhangsan");
// 序列化
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("students"));
// 序列化对象
oos.writeObject(s);
// 刷新
oos.flush();
// 关闭
oos.close();
}
}
反序列化的实现
package com.bjpowernode.javase.io;
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("students"));
// 开始反序列化,读
Object obj = ois.readObject();
// 反序列化回来是一个学生对象,所以会调用学生对象的toString方法。
System.out.println(obj);
ois.close();
}
}
序列化多个对象
package com.bjpowernode.javase.bean;
import java.io.Serializable;
public class User implements Serializable {
private int no;
private String name;
public User() {
}
public User(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 "User{" +
"no=" + no +
", name='" + name + '\'' +
'}';
}
}
package com.bjpowernode.javase.io;
import com.bjpowernode.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, "wangwu"));
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("users"));
// 序列化集合,这个集合对象当中放了许多其他对象、
oos.writeObject(userList);
oos.flush();
oos.close();
}
}
package com.bjpowernode.javase.io;
import com.bjpowernode.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("users"));
/*Object obj = ois.readObject();
System.out.println(obj instanceof List); // true*/
List<User> userList = (List<User>)ois.readObject();
for(User user : userList){
System.out.println(user);
}
ois.close();
}
}
transient关键字
package com.bjpowernode.javase.bean;
import java.io.Serializable;
public class User implements Serializable {
private int no;
// transient关键字表示游离的,不参与序列化。
private transient String name; // name不参与序列化操作!
public User() {
}
public User(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 "User{" +
"no=" + no +
", name='" + name + '\'' +
'}';
}
}
关于序列化版本号
package com.bjpowernode.javase.bean;
import java.io.Serializable;
public class Student implements Serializable {
// Java虚拟机看到Serialzable接口之后,会自动生成一个序列化版本号
// 这里没有手动写出来,java虚拟机会默认提供这个序列化版本号。
// 建议将序列化版本号手动的写出来。不建议自动生成
private static final long serialVersionUID = 1L; // java虚拟机识别一个类的时候先通过类名,如果类名一致,会通过序列化版本号识别。
private int no;
private String name;
// 过来很久,Student这个类源代码改动了。
// 源代码改动之后,需要重新编译,编译之后生成了全新的字节码文件。
// 并且class文件再次运行的时候,java虚拟机生成的序列化版本号也会发生相应的改变。
private int age;
//private String addr;
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 + '\'' +
", age=" + age +
'}';
}
}
package com.bjpowernode.javase.io;
import com.bjpowernode.javase.bean.Student;
import java.io.FileOutputStream;
import java.io.ObjectOutputStream;
import java.rmi.server.ExportException;
/*
1、java.io.NotSerializableException:
Student这个类不支持序列化,需要实现接口Serializable。
2、参与序列化和反序列化的对象,必须实现Serializable接口。
3、注意:通过源代码发现,Serializable接口只是一个标志接口:
public interface Serializable{
}
这个接口当中什么代码都没有。
那么它起到什么作用呢?
起到标识的作用,标志的作用,java虚拟机看到这个类实现了这个接口,可能会对这个类进行特殊待遇。
Serializable这个标志接口是给java虚拟机参考的,java虚拟机看到这个接口之后,会为该类自动生成
一个序列化版本号。
4、序列化版本号有什么用呢?
java.io.InvalidClassException:
com.bjpowernode.javase.bean.Student;
local class incompatible:
stream classdesc serialVersionUID = -2490588915011604657, (十年后)
local class serialVersionUID = -1642973173358893535 (十年前)
java语言中是采用什么机制来区分类的?
第一:首先通过类名进行比对,如果类名不一样,肯定不是同一个类。
第二:如果类名一样,再怎么进行类的区别呢?靠序列化版本号进行区分。
小明编写了一个类:com.bjpowernode.javase.bean.Student implements Serializable
小亮编写了一个类:com.bjpowernode.javase.bean.Student implements Serializable
不同的人编写了同一个类,但“这两个类确实不是同一个类”。这个时候序列化版本就起上作用了。
对于java虚拟机来说,java虚拟机是可以区分这两个类的,因为这两个类都实现了Serializable接口,
都有默认的序列化版本号,他们的序列化版本号不一样。所以区分开了。(这是自动生成序列化版本号的好处)
请思考?
这种自动生成序列化版本号的缺陷?
这种自动生成的序列化版本号缺点是:一旦代码确定之后,不能进行后续的修改,
因为只要修改,必然会重新编译,此时会生成全新的序列化版本号,这个时候java
虚拟机会认为这是一个全新的类。(这样就不好了!)
最终的结论:
凡是一个类实现了Serializable接口,建议给该类提供一个固定不变的序列化版本号。
这样,以后这个类即使代码修改了,但是版本号不变,java虚拟机会认为这是同一个类。
*/
public class ObjectOutputStreamTest01 {
public static void main(String[] args) throws Exception {
// 创建java对象
Student s = new Student(111, "zhangsan");
// 序列化
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("students"));
// 序列化对象
oos.writeObject(s);
// 刷新
oos.flush();
// 关闭
oos.close();
}
}
package com.bjpowernode.javase.io;
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("students"));
// 开始反序列化,读
Object obj = ois.readObject();
// 反序列化回来是一个学生对象,所以会调用学生对象的toString方法。
System.out.println(obj);
ois.close();
}
}
IDEA自动生成序列化版本号
- 光标移动到类名上,快捷键:Alt + Enter
package com.bjpowernode.javase.bean;
import java.io.Serializable;
public class Student implements Serializable {
// IDEA自动生成序列化 : ALT + Enter
private static final long serialVersionUID = 9119334117414507990L;
// Java虚拟机看到Serialzable接口之后,会自动生成一个序列化版本号
// 这里没有手动写出来,java虚拟机会默认提供这个序列化版本号。
// 建议将序列化版本号手动的写出来。不建议自动生成
//private static final long serialVersionUID = 1L; // java虚拟机识别一个类的时候先通过类名,如果类名一致,会通过序列化版本号识别。
private int no;
private String name;
// 过来很久,Student这个类源代码改动了。
// 源代码改动之后,需要重新编译,编译之后生成了全新的字节码文件。
// 并且class文件再次运行的时候,java虚拟机生成的序列化版本号也会发生相应的改变。
private int age;
//private String addr;
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 + '\'' +
", age=" + age +
'}';
}
}
IO和Properties联合使用
- IO流:文件的读和写。
- Properties:是一个Map集合,key和value都是String类型。
# 此文件名为:userinfo.properties
username=root
############在属性配置文件中井号是注释#################
#属性配置文件的key重复的话,value会自动覆盖!
#password=123
password=111
# 最好不要有空格
data = 100
# 不建议使用:
usernamex:admin
package com.bjpowernode.javase.io;
import java.io.FileInputStream;
import java.io.FileReader;
import java.util.Properties;
/*
IO + Properties的联合应用。
非常好的一个设计理念:
以后经常改变的数据,可以单独地写到一个文件中,使用程序动态读取。
将来只需要修改这个文件的内容,java代码不需要改动,不需要重新
编译,服务器不需要重启。就可以拿到动态的信息。
类似于以上机制的这种文件被称为配置文件。
并且当配置文件中的内容格式是:
key=value
key=value
的时候,我们把这种配置文件叫做属性配置文件。
java规范中有要求:属性配置文件建议以.properties结尾,但这不是必须的。
这种以.properties结尾的文件在java中被称为:属性配置文件。
其中Properties是专门存放属性配置文件内容的一个类。
*/
public class IoPropertiesTest01 {
public static void main(String[] args) throws Exception{
/*
Properties是一个Map集合,key和value都是String类型。
想将userinfo文件中的数据加载到Properties对象当中。
*/
// 新建一个输入流对象 读 从硬盘到内存
FileReader reader = new FileReader("io/userinfo.properties");
// 新建一个Map集合
Properties pro = new Properties();
// 调用Properties对象的load方法将文件中的数据加载到Map集合中。
pro.load(reader); // 文件中的数据顺着管道加载到Map集合当中,其中等号=左边做key,右边做value。
// 通过key来获取value呢?
String username = pro.getProperty("username");
System.out.println(username);
String password = pro.getProperty("password");
System.out.println(password);
String data = pro.getProperty("data");
System.out.println(data);
String usernamex = pro.getProperty("usernamex");
System.out.println(usernamex);
}
}