一、File类
1.1 概述
java.io.File
类是文件和目录路径名的抽象表示,主要用于文件和目录的创建、查找和删除等操作。
抽像:
1.2 构造方法
-
public File(String pathname)
:通过将给定的路径名字符串转换为抽象路径名来创建新的 File 实例。 -
public File(String parent, String child)
:从父路径名字符串和子路径名字符串创建新的 File实例。 -
public File(File parent, String child)
:从父抽象路径名和子路径名字符串创建新的 File实例。 -
public File(URI uri)
:通过给定的 file:URI 转换为抽象路径名来创建新的 File 实例。 - 构造举例,代码如下:
// 文件路径名
String pathname1 = "/Users/abc/a.txt";
File file1 = new File(pathname1);
// 文件路径名
String pathname2 = "/Users/abc/b.txt";
File file2 = new File(pathname2);
// 通过父路径和子路径字符串
String parent = "/Users/abc";
String child1 = "c.txt";
File file3 = new File(parent, child1);
// 通过父级File对象和子路径字符串
File parentDir = new File("/Users/abc");
String child2 = "d.txt";
File file4 = new File(parentDir, child2);
提示:
- 1.一个File对象代表硬盘中实际存在的一个文件或目录。
- 无论该路径下是否存在文件或者目录,都不影响File对象的创建。
- 3.关于路径的书写问题,这取决于你的系统,分为windows、linux和mac os版本。你可以通过File的静态成员变量来查看自己系统的分隔符。例如:
File.pathSeparator
表示与系统相关的路径分隔符字符。
File.separator
表示与系统相关的默认名称 - 分隔符字符
对应到windows系统,pathSeparator为":",separator为:"\"。所以windows系统的文件路径可以用这样表示:"D:\abc\a.txt"。
1.3 常用方法
获取功能的方法
-
public String getAbsolutePath()
:返回此File的绝对路径名字符串。 -
public String getPath()
:将此File转换为路径名字符串。 -
public String getName()
:返回由此File表示的文件或目录的名称。 -
public long length()
:返回由此File表示的文件的长度。
方法演示,代码如下:
// 文件路径名
String pathname = "/Users/abc/a.txt";
File file = new File(pathname);
System.out.println("文件绝对路径:"+file.getAbsolutePath());
System.out.println("文件构造路径:"+file.getPath());
System.out.println("文件名称:"+file.getName());
System.out.println("文件长度"+file.length()+"字节");
System.out.println("-----------------------------");
// 目录路径名
String pathname2="/Users/abc";
File file2=new File(pathname2);
System.out.println("目录绝对路径:"+file2.getAbsolutePath());
System.out.println("目录构造路径:"+file2.getPath());
System.out.println("目录名称:"+file2.getName());
System.out.println("目录长度"+file2.length()+"字节");
输出结果:
文件绝对路径:/Users/abc/a.txt
文件构造路径:/Users/abc/a.txt
文件名称:a.txt
文件长度100字节
-----------------------------
目录绝对路径:/Users/abc
目录构造路径:/Users/abc
目录名称:abc
目录长度608字节
判断功能的方法
-
public boolean exists()
:此File表示的文件或目录是否实际存在。 -
public boolean isDirectory()
:此File表示的是否为目录。 -
public boolean isFile()
:此File表示的是否为文件。
方法演示,代码如下:
File f = new File("/Users/abc/a.txt");
File f2 = new File("/Users/abc");
// 判断是否存在
System.out.println("/Users/abc/a.txt 是否存在:"+f.exists());
System.out.println("/Users/abc 是否存在:"+f2.exists());
// 判断是文件还是目录
System.out.println("/Users/liudonghui/abc 文件?:"+f2.isFile());
System.out.println("/Users/abc 目录?:"+f2.isDirectory());
输出结果:
/Users/abc/a.txt 是否存在:true
/Users/abc 是否存在:true
/Users/abc 文件?:false
/Users/abc 目录?:true
创建删除功能的方法
-
public boolean createNewFile()
:当且仅当具有该名称的文件尚不存在时,创建一个新的空文件。 -
public boolean delete()
:删除由此File表示的文件或目录。 -
public boolean mkdir()
:创建由此File表示的目录。 -
public boolean mkdirs()
:创建由此File表示的目录,包括任何必需但不存在的父目录。
方法演示,代码如下:
// 文件的创建
File f = new File("aaa.txt");
System.out.println("是否存在:"+f.exists());// false
System.out.println("是否创建:"+f.createNewFile()); // true
System.out.println("是否存在:"+f.exists()); // true
// 目录的创建
File f2= new File("newDir");
System.out.println("是否存在:"+f2.exists());// false
System.out.println("是否创建:"+f2.mkdir()); // true
System.out.println("是否存在:"+f2.exists());// true
// 创建多级目录
File f3= new File("newDira\\newDirb");
System.out.println(f3.mkdir());// false
File f4= new File("newDira\\newDirb");
System.out.println(f4.mkdirs());// true
// 文件的删除
System.out.println(f.delete());// true
// 目录的删除
System.out.println(f2.delete());// true
System.out.println(f4.delete());// false
说明:delete方法,如果此File表示的是目录,则此目录必须为空才能删除。
1.4 目录的遍历
-
public String[] list()
:返回一个String数组,表示该File目录中的所有子文件或目录。 -
public File[] listFiles()
:返回一个File数组,表示该File目录中的所有子文件或目录。
例子:递归打印多级目录
代码如下:
public class RecursionDemo {
public static void main(String[] args) {
File dir=new File("/Users/abc");
getDirAndFiles(dir);
}
private static void getDirAndFiles(File dir) {
File[] files = dir.listFiles();
for (File file:files) {
if (file.isFile()){
System.out.println("文件名:"+file.getAbsolutePath());
}else{
System.out.println("目录:"+file.getAbsolutePath());
getDirAndFiles(file);
}
}
}
}
二、字节流和字符流
2.1 什么是IO
I:Input即输入。
O:Output即输出。
这里的输入输出以内存为基准,即流向内存的是输入流,流出内存的是输出流。
java中的I/O操作主要是指使用java.io
包下的内容,进行输入输出操作。
2.2 IO的分类
根据数据的流向分为:输入流和输出流。
- 输入流:把数据从其他设备读到内存中的流。
- 输出流:把数据从内存中写到其他设备上的流。
根据数据的类型分为:字节流和字符流。
- 字节流:以字节为单位,读写数据的流。
- 字符流:以字符为单位,读写数据的流。
javaIO中有40多个类,但他们之间关系精密,都是从下面四个抽象基类派生出来的。
javaIO的顶级父类们.png按照操作方式分类结构图:
按照操作对象分类结构图:
摘自 JavaGuide v2.0突击版 p50
2.3 字节流
首先要明白对于一切文件数据(文本、图片、视频等)在存储时,都是以二进制数字的形式保存,都一个一个的字节,那么传输时一样如此。所以,字节流可以传输任意文件数据。在操作流的时候,我们要时刻明确,无论使用什么样的流对象,底层传输的始终为二进制数据。
2.3.1 字节输出流【OutputStream】
java.io.OutputStream
抽象类是表示字节输出流的所有类的超类,将指定的字节信息写出到目的地。它定义了字节输出流的基本共性方法。
-
public void close()
:关闭此输出流并释放与此流相关联的任何系统资源。 -
public void flush()
:刷新此输出流并强制任何缓冲的输出字节被写出。 -
public void write(byte[] b)
:将 b.length 字节从指定的字节数组写入此输出流。 -
public void write(byte[] b, int off, int len)
:从指定的字节数组写入 len字节,从偏移量 off开始输 出到此输出流。 -
public abstract void write(int b)
:将指定的字节写入此输出流。
FileOutputStream类
FileOutputStream是OutputStream最常用的一个子类。
java.io.FileOutputStream
类是文件输出流,用于将数据写出到文件。
构造方法:
-
public FileOutputStream(File file)
:创建文件输出流以写入指定的File对象表示的文件。 -
public FileOutputStream(String name)
:创建文件输出流以指定的名称写入文件。
当你创建一个流对象时,必须传入一个文件路径。该路径下,如果没有这个文件,会创建该文件。如果有这个文 件,会清空这个文件的数据。
其他常用方法:
-
public void write(int b)
:每次写出一个字节数据,代码使用案例:
public class FOSWrite {
public static void main(String[] args) throws IOException {
// 使用文件名称创建流对象
FileOutputStream fos = new FileOutputStream("fos.txt");
// 写出数据
fos.write(97);
// 写出第1个字节
fos.write(98);
// 写出第2个字节
fos.write(99);
// 写出第3个字节
// 关闭资源
fos.close();
}
}
输出结果:
abc
-
public void write(byte[] b)
:将 b.length个字节从指定的字节数组写入此文件输出流。代码演示:
public class FOSWrite {
public static void main(String[] args) throws IOException {
// 使用文件名称创建流对象
FileOutputStream fos = new FileOutputStream("fos.txt");
// 字符串转换为字节数组
byte[] b = "你好".getBytes();
// 写出字节数组数据
fos.write(b);
// 关闭资源
fos.close();
}
}
输出结果:你好
-
public void write(byte[] b,int off,int len)
:将 len 字节从位于偏移量 off 的指定字节数组写入此文件输出流。代码演示:
public class FOSWrite {
public static void main(String[] args) throws IOException {
// 使用文件名称创建流对象
FileOutputStream fos = new FileOutputStream("fos.txt");
// 字符串转换为字节数组
byte[] b = "abcde".getBytes();
// 写出从索引2开始,2个字节。索引2是c,两个字节,也就是cd。
fos.write(b,2,2);
// 关闭资源
fos.close();
}
}
输出结果: cd
数据追加写
上面的方法,每次创建输出流,都会情况目标文件中的数据。下面介绍能够保留目标文件中的数据,并能继续添加新数据的方法。
public FileOutputStream(File file, boolean append)
public FileOutputStream(String name, boolean append)
只有在这两个构造方法中传入一个boolean类型的参数值,其中true
表示追加数据,false
表示清空原有数据。其余实现步骤与上面一样。
写出换行
代码演示:
public class FOSWrite {
public static void main(String[] args) throws IOException {
// 使用文件名称创建流对象
FileOutputStream fos = new FileOutputStream("fos.txt");
// 定义字节数组
byte[] words = {97,98,99,100,101};
// 遍历数组
for (int i = 0; i < words.length; i++) {
// 写出一个字节
fos.write(words[i]);
// 写出一个换行, 换行符号转成数组写出
fos.write("\r".getBytes());
}
// 关闭资源
fos.close();
}
}
输出结果:
a
b
c
d
e
提示:
- Windows系统里,换行符是\r\n;
- Linux系统里,换行符是\n;
- Mac系统里,是\r或\n;
2.3.2 字节输入流【InputStream】
java.io.InputStream
抽象类是表示字节输入流的所有类的超类,可以读取字节信息到内存中。它定义了字节输入流的基本共性功能方法。
-
public void close()
:关闭此输入流并释放与此流相关联的任何系统资源。 -
public abstract int read()
:从输入流读取数据的下一个字节。 -
public int read(byte[] b)
:从此输入流中读取一些字节数,并将它们存储到字节数组b中。
FileInputStream类
java.io.FileInputStream
类是文件输入流,从文件中读取字节。
构造方法:
-
FileInputStream(File file)
:通过打开与实际文件的连接来创建一个 FileInputStream ,该文件由文件系统中的 File 对象 file 命名。 -
FileInputStream(String name)
:通过打开与实际文件的连接来创建一个 FileInputStream ,该文件由文件系统中的路径名 name 命名。
当你创建一个文件输入流对象是,必须传入一个文件路径。该路径下,如果没有该文件,会抛出FileNotFoundException
常用方法
-
public int read()
:每次可以读取一个字节的数据,并将其提升为int类型,若读取到文件末尾,则返回 -1 ,代码使用演示:
public class FISRead {
public static void main(String[] args) throws IOException{
// 使用文件名称创建流对象
FileInputStream fis = new FileInputStream("read.txt");
// 定义变量,保存数据
int b;
// 循环读取
while((b=fis.read())!=-1){
System.out.println((char)b);
}
// 关闭资源
/fis.close();
}
}
输出结果:
a
b
c
d
e
-1
-
public int read(byte[] b)
:每次读取 b 的长度个字节到数组中,返回读取到的有效字节个数,读 取到末尾时,返回 -1 ,代码使用演示:
public class FISRead {
public static void main(String[] args) throws IOException{
// 使用文件名称创建流对象.
FileInputStream fis = new FileInputStream("read.txt");// 文件中为abcde
// 定义变量,作为有效个数
int len ;
// 定义字节数组,作为装字节数据的容器
byte[] b = new byte[2];
// 循环读取
while (( len= fis.read(b))!=‐1) {
// 每次读取后,把数组变成字符串打印
System.out.println(new String(b));
}
// 关闭资源
fis.close();
}
}
输出结果:
ab
cd
ed
这段代码有个问题,最后一个数据ed是错误的,这是由最后一次读取时,只读取了一个字节e,数组中,上次读取的数据没有被完全替换。所以我们应该通过len,获取有效的字节,代码改进如下:
public class FISRead {
public static void main(String[] args) throws IOException{
// 使用文件名称创建流对象.
FileInputStream fis = new FileInputStream("read.txt");// 文件中为abcde
// 定义变量,作为有效个数
int len ;
// 定义字节数组,作为装字节数据的容器
byte[] b = new byte[2];
// 循环读取
while (( len= fis.read(b))!=‐1) {
// 每次读取后,把数组变成字符串打印
System.out.println(new String(b,0,len));
}
// 关闭资源
fis.close();
}
}
输出结果:
ab
cd
e
使用数组读取可以每次读取多个字节,这减少了io的操作次数,提高了读写的效率,所以要常用数组读取。
2.4 字符流
当使用字节流读取文本文件时,可能会有一个小问题。就是遇到中文字符时,可能不会显示完整的字符,那是因为 一个中文字符可能占用多个字节存储。所以Java提供一些字符流类,以字符为单位读写数据,专门用于处理文本文件。
2.4.1 字符输入流【Reader】
java.io.Reader
抽象类是表示用于读取字符流的所有类的超类,可以读取字符信息到内存中。它定义了字符输入 流的基本共性功能方法。
-
public void close()
:关闭此流并释放与此流相关联的任何系统资源。 -
public int read()
:从输入流读取一个字符。 -
public int read(char[] cbuf)
:从输入流中读取一些字符,并将它们存储到字符数组 cbuf 中 。
FileReader类
java.io.FileReader`类是读取字符文件的便利类。构造时使用系统默认的字符编码和默认字节缓冲区。
构造方法
-
FileReader(File file)
: 创建一个新的 FileReader ,给定要读取的File对象。 -
FileReader(String fileName)
:创建一个新的 FileReader ,给定要读取的文件的名称。
类似于FileInputStream,当你要创建一个流对象是,必须传入一个文件路径。
其他方法
-
public int read()
:每次读取一个字符的数据,并将其提示为int类型,读取到文件末尾,返回-1。
public class FRRead {
public static void main(String[] args) throws IOException {
// 使用文件名称创建流对象
FileReader fr = new FileReader("read.txt");
// 定义变量,保存数据
int b;
// 循环读取
while ((b = fr.read())!=‐1) {
System.out.println((char)b);
}
// 关闭资源
fr.close();
}
}
输出结果:
你
好
啊
-
public int read(char[] chuf)
:每次读取b的长度个字符到数组中,返回读取到的有效字符个数, 读取到末尾时,返回 -1 ,代码使用演示:
public class FRRead {
public static void main(String[] args) throws IOException {
// 使用文件名称创建流对象
FileReader fr = new FileReader("read.txt");
// 定义变量,保存有效字符个数
int len;
// 定义字符数组,作为装字符数据的容器
char[] cbuf=new char[2];
// 循环读取
while ((len = fr.read(cbuf))!=‐1) {
System.out.println(new String(cbuf,0,len));
}
// 关闭资源
fr.close();
}
}
输出结果:
你好
啊
2.4.2 字符输出流【Writer】
java.io.Writer
抽象类是表示用于写出字符流的所有类的超类,将指定的字符信息写出到目的在,它定义了字节输出流的基本共性功能方法。
-
void write(int c)
: 写入单个字符。 -
void write(char[] cbuf)
: 写入字符数组。 -
abstract void write(char[] cbuf, int off, int len)
: 写入字符数组的某一部分,off数组的开始索引,len 写的字符个数。 -
void write(String str)
: 写入字符串。 -
void write(String str, int off, int len)
:写入字符串的某一部分,off字符串的开始索引,len写的字符个 数。 -
void flush()
: 刷新该流的缓冲。 -
void close()
: 关闭此流,但要先刷新它。
FileWriter类
java.io.FileWriter
类是写出字符到文件的便利类,构造时使用系统默认的字符编码和默认字节缓冲区。
构造方法
-
FileWriter(File file)
: 创建一个新的 FileWriter,给定要读取的File对象。 -
FileWriter(String fileName)
: 创建一个新的 FileWriter,给定要读取的文件的名称。
当你创建一个流对象时,必须传入一个文件路径,类似于FileOutputStream。
其他方法
-
public void write(int b)
:每次写出一个字符数据。
若为调用close方法,数据只是保存到了缓冲区,并没写到文件中。
关闭和刷新
因为内置缓冲区的原因,如果不关闭输出流,无法写出字符到文件中。但是关闭的流对象,是无法继续写出数据 的。如果我们既想写出数据,又想继续使用流,就需要 flush
方法了。
-
flush()
:刷新缓冲区,流对象可以继续使用。 -
close()
:先刷新缓冲区,然后通知系统释放资源。流对象不可以再被使用了。 -
public void write(char[] cbuf)
和public void write(char[] cbuf,int off,int len)
,每次可以写出字符数组中的数据,用法类似FileOutputStream,代码使用演示:
public class FWWrite {
public static void main(String[] args) throws IOException {
// 使用文件名称创建流对象
FileWriter fw = new FileWriter("fw.txt");
// 字符串转换为字节数组
char[] chars = "你好啊".toCharArray();
// 写出字符数组
fw.write(chars);// 你好啊
// 写出从索引1开始,2个字节。索引1是'好',两个字节,也就是'好啊'。
fw.write(b,1,2); // 好啊
// 关闭资源
fos.close();
}
}
-
public void write(String str)
和public void write(String str,int off,int len)
,每次可以写出字符串中的数据,更为方便。
续写和换行:类似于FileOutputStream。
三、缓冲流、转换流和序列化流
3.1 缓冲流
缓冲流是对前面讲的4个基本的Filexxx流的增强,所以也是4个流,安装数据类型分类:
-
字节缓冲流:
BufferedInputStream
,BufferedOutputStream
。 -
字符缓冲流:
BufferedReader
,BufferedWriter
缓冲流的基本原理,是在创建流对象时,会创建一个内置的默认大小的缓冲区数组,通过缓冲区读写,减少系统 IO 次数,从而提高读写的效率。
3.1.1 字节缓冲流
构造方法
-
public BufferedInputStream(InputStream in)
:创建一个新的缓冲输入流。 -
public BufferedOutputStream(OutputStream out)
:创建一个新的缓冲输出流。
构造举例,代码如下:
// 创建字节缓冲输入流
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("bis.txt"));
// 创建字节缓冲输出流
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("bos.txt"));
3.1.2 字符缓冲流
构造方法
-
pubic BufferedReader(Reader in)
:创建一个新的缓冲输入流。 -
public BufferedWriter(Writer out)
:创建一个新的缓冲输出流。
构造方法举例:
// 创建字符缓冲输入流
BufferedReader br = new BufferedReader(new FileReader("br.txt"));
// 创建字符缓冲输出流
BufferedWriter bw = new BufferedWriter(new FileWriter("bw.txt"));
缓冲流的读写方法和基本流是一致的,只不过缓冲流大大提高了读写效率。
特有方法
字符缓冲流的基本方法与普通字符流调用方式一致,不再阐述,我们来看它们具备的特有方法。
- BufferedReader:
public String readLine()
:读一行文字。 - BufferedWriter:
pubic void newLine()
:写一行文字,分隔符由系统属性定义。
readLine
方法演示,代码如下:
public class BufferedReaderDemo {
public static void main(String[] args) throws IOException {
// 创建流对象
BufferedReader br = new BufferedReader(new FileReader("in.txt"));
// 定义字符串,保存读取的一行文字
String line = null;
// 循环读取,读取到最后返回null
while ((line = br.readLine())!=null) {
System.out.print(line);
System.out.println("‐‐‐‐‐‐");
}
// 释放资源
br.close();
}
}
newLine
方法演示,代码如下:
public class BufferedWriterDemo throws IOException {
public static void main(String[] args) throws IOException {
// 创建流对象
BufferedWriter bw = new BufferedWriter(new FileWriter("out.txt"));
// 写出数据
bw.write("你好");
// 写出换行
bw.newLine();
bw.write("啊");
// 释放资源
bw.close();
}
}
输出结果:
你好
啊
缓冲流的原理
3.2 转换流
编码引出的问题
在IDEA中,使用 FileReader 读取项目中的文本文件。由于IDEA的设置,都是默认的 UTF-8 编码,所以没有任何 问题。但是,当读取Windows系统中创建的文本文件时,由于Windows系统的默认是GBK编码,就会出现乱码。
**想要在IDEA中读取GBK编码的文件,就必须使用转换流了。
3.2.1 InputStreamReader类
转换流java.io.InputStreamReader
,是Reader的子类,是从字节流到字符流的桥梁。它读取字节,并使用指定 的字符集将其解码为字符。它的字符集可以由名称指定,也可以接受平台的默认字符集。
构造方法
-
InputStreamReader(InputStream in)
:创建一个使用默认字符集的字符流。 -
InputStreamReader(InputStream in, String charsetName)
:创建一个指定字符集的字符流。
构造举例,代码如下:
InputStreamReader isr = new InputStreamReader(new FileInputStream("in.txt"));
InputStreamReader isr2 = new InputStreamReader(new FileInputStream("in.txt") , "GBK");
3.2.2 OutputStreamWriter类
转换流java.io.OutputStreamWriter
,是Writer的子类,是从字符流到字节流的桥梁。使用指定的字符集将字符 编码为字节。它的字符集可以由名称指定,也可以接受平台的默认字符集。
构造方法
-
OutputStreamWriter(OutputStream in)
:创建一个使用默认字符集的字符流。 -
OutputStreamWriter(OutputStream in, String charsetName)
:创建一个指定字符集的字符流。
构造举例,代码如下:
OutputStreamWriter isr = new OutputStreamWriter(new FileOutputStream("out.txt"));
OutputStreamWriter isr2 = new OutputStreamWriter(new FileOutputStream("out.txt") , "GBK");
转换流理解图解
转换流是字节与字符间的桥梁!
3.3 序列化
Java 提供了一种对象序列化的机制。用一个字节序列可以表示一个对象,该字节序列包含该对象的数据、 对象的类型和对象中存储的属性等信息。字节序列写出到文件之后,相当于文件中持久保存了一个对象的信息。
反之,该字节序列还可以从文件中读取回来,重构对象,对它进行反序列化。对象的数据、对象的类型和对象中存储的数据信息,都可以用来在内存中创建对象。看图理解序列化:
3.3.1 ObjectOutputStream类
java.io.ObjectOutputStream
类,将java对象的原始数据类型写出到文件,实现对象的持久存储。
构造方法
-
public ObjectOutputStream(OutputStream out)
:创建一个指定OutputStream的ObjectOutputStream。
构造举例,代码如下:
FileOutputStream fileOut = new FileOutputStream("employee.txt");
ObjectOutputStream out = new ObjectOutputStream(fileOut);
序列化操作
1.一个对象要想序列化,必须满足两个条件:
- 该类必须实现
java.io.Serializable
接口,Serializable 是一个标记接口,不实现此接口的类将不会使任 何状态序列化或反序列化,会抛出 NotSerializableException 。 - 该类的所有属性必须是可序列化的。如果有一个属性不需要可序列化的,则该属性必须注明是瞬态的,使用
transient
关键字修饰。
public class Person implements Serializable {
private static final long serialVersionUID=1l;
private String name;
public Integer age;
// private static Integer age;
// private transient Integer age;
public Person(String name, Integer age) {
this.name = name;
this.age = age;
}
......
}
-
public final void writeObject (Object obj)
:将指定的对象写出。
public class Demo01ObjectOutputStream {
public static void main(String[] args) throws IOException {
ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream("/Users/abc/person.txt"));
oos.writeObject(new Person("小美人",18));
oos.close();
}
}
被注明为static和transient的属性不会被序列化。
3.3.2 ObjectInputStream类
ObjectInputStream反序列化流,将之前使用ObjectOutputStream序列化的原始数据恢复为对象。
构造方法
-
public ObjectInputStream(InputStream in)
:创建一个指定InputStream的ObjectInputStream。
反序列化方法
-
public final Object readObject()
:读取一个对象。
public class Demo02ObjectInputStream {
public static void main(String[] args) throws IOException, ClassNotFoundException {
ObjectInputStream ois=new ObjectInputStream(new FileInputStream("/Users/abc/person.txt"));
Object o = ois.readObject();
ois.close();
System.out.println(o);
}
}
对于JVM可以反序列化对象,它必须是能够找到class文件的类。如果找不到该类的class文件,则抛出一个ClassNotFoundException异常。
另外,当JVM反序列化对象时,能找到class文件,但是class文件在序列化对象之后发生了修改,那么反序列化操 作也会失败,抛出一个InvalidClassException异常。发生这个异常的原因如下:
- 该类的序列版本号与从流中读取的类描述符的版本号不匹配
- 该类包含未知数据类型
- 该类没有可访问的无参数构造方法
Serializable 接口给需要序列化的类,提供了一个序列版本号。serialVersionUID 该版本号的目的在于验证序 列化的对象和对应类是否版本匹配。
// 加入序列版本号
private static final long serialVersionUID = 1L;
3.4 打印流
平时我们在控制台打印输出,是调用 print
方法和 println
方法完成的,这两个方法都来自于java.io.PrintStream
类,该类能够方便地打印各种数据类型的值,是一种便捷的输出方式。
3.4.1 PrintStream类【字节打印流】
构造方法
-
public PrintStream(String fileName)
:使用指定的文件名创建一个新的打印流。
System.out
就是PrintStream
类型的,只不过它的流向是系统规定的,打印在控制台上。不过,既然是流对象, 我们就可以改变它的流向。
public class PrintDemo {
public static void main(String[] args) throws IOException {
// 调用系统的打印流,控制台直接输出97
System.out.println(97);
// 创建打印流,指定文件的名称
PrintStream ps = new PrintStream("ps.txt");
// 设置系统的打印流流向,输出到ps.txt
System.setOut(ps);
// 调用系统的打印流,ps.txt中输出97
System.out.println(97);
}
}
3.4.2 PrintWriter类【字符打印流】
构造方法
-
PrintWriter(File file)
:使用指定的文件创建一个新的PrintWriter。 -
PrintWriter(String fileName)
:使用指定的文件名创建一个新的PrintWriter。
网友评论