1 文件
1.1 文件的定义
文件是保存数据的地方(相关记录或放在一起的数据的集合)
1.2 文件流
文件在程序中以流的形式来操作
1.3 常用的文件操作
方法名称 | 说明 |
---|---|
boolean exists( ) | 判断文件或目录是否存在 |
boolean isFile( ) | 判断是否是文件 |
boolean isDirectory( ) | 判断是否是目录 |
String getPath( ) | 返回此对象表示的文件的相对路径名 |
String getAbsolutePath( ) | 返回此对象表示的文件的绝对路径名 |
String getName( ) | 返回此对象表示的文件或目录的名称 |
boolean delete( ) | 删除此对象指定的文件或目录 |
boolean createNewFile( ) | 创建名称的空文件,不创建文件夹 |
long length() | 返回文件的长度,单位为字节**,** 如果文件不存在,则返回 0L |
package cn.bdqn.demo01;
import java.io.File;
import java.io.IOException;
public class FileDemo01 {
public static void main(String[] args) {
// 获取一个File类对象, 这个对象指向计算机F盘中的demo.txt文件
File file1 = new File("F:\\demo.txt");
File file2 = new File("F:/test");
//boolean exists():判断File类对象指向的文件或者目录是否存在,如果存在返回true,否则返回false
System.out.println(file1.exists());
System.out.println(file2.exists());
//boolean isFile():判断File类对象指向的是不是一个文件,如果是返回true,否则返回false
System.out.println(file1.isFile());
System.out.println(file2.isFile());
//boolean isDirectory():判断FIle类对象指向的是不是一个目录,如果是返回true,否则返回false
System.out.println(file1.isDirectory());
System.out.println(file2.isDirectory());
File file3 = new File("F:/a.txt");
File file4 = new File("F:/a/b/c/d.txt");
//boolean createNewFile():创建名称的空文件,不创建文件夹,也就是说File类指向的文件,其所在的文件夹应该存在
// file3.createNewFile();
// file4.createNewFile();
System.out.println("文件创建成功");
//String getPath():返回此对象表示的文件的相对路径名
//String getAbsolutePath():返回此对象表示的文件的绝对路径名
//String getName():返回此对象表示的文件或目录的名称
System.out.println(file1.getPath());//F:\demo.txt
System.out.println(file1.getAbsolutePath());//F:\demo.txt
System.out.println(file1.getName());//demo.txt
File file5 = new File("qqqq.txt");
try {
file5.createNewFile();
System.out.println("file5创建成功");
} catch (IOException e) {
e.printStackTrace();
}
System.out.println(file5.getPath());//qqqq.txt
System.out.println(file5.getAbsolutePath());//E:\MyEclipseWorkspaces02\Day026输入输出流\qqqq.txt
//boolean delete():删除File类对象指向的文件或目录
// file1.delete();
file2.delete();
//long length():返回File类对象指向的文件的长度,单位为字节,如果文件不存在,返回0L
System.out.println(file1.length());//0
File file6 = new File("F:/a");
File file7 = new File("F:/aa/bb/cc/dd");
//mkdir():创建此抽象路径名指定的目录。
file6.mkdir();
// file7.mkdir();
//mkdirs():创建此抽象路径名指定的目录,包括所有必需但不存在的父目录。
file7.mkdirs();
}
}
1.3.1 创建文件对象相关构造器和方法
File file = new File( String pathname );
方式1:new File(String pathname) 根据路径构建一个File对象(最常用)
方式2:new File(File parent,String child) 根据父目录文件+子路径构建
方式 3 new File(String parent,String child) //根据父目录+子路径构建
应用案例:在e盘中创建new1.txt、new2.txt、new3.txt
package cn.bdqn.demo01;
import org.junit.Test;
import java.io.File;
import java.io.IOException;
//创建文件
public class FileCreate {
public static void main(String[] args) {
}
//方式1:new File(String pathname) 根据路径构建一个File对象
@Test
public void create01()
{
String filePath="e:\\news1.txt";
File file =new File(filePath);//此时文件还在内存里面
try {
file.createNewFile();//通过调用此方法吧文件存入硬盘
System.out.println("文件创建成功");
} catch (IOException e) {
e.printStackTrace();
}
}
//方式2:new File(File parent,String child) 根据父目录文件+子路径构建
//e:\\new2.txt
@Test
public void create02() {
File parentFile = new File("e:\\");
String fileName = "news2.txt";
//这里的 file 对象, 在 java 程序中, 只是一个对象
//只有执行了 createNewFile 方法, 才会真正的, 在磁盘创建该文件
File file = new File(parentFile, fileName);
try {
file.createNewFile();
System.out.println("创建成功~");
} catch (IOException e) {
e.printStackTrace();
}
}
//方式 3 new File(String parent,String child) //根据父目录+子路径构建
@Test
public void create03() {
String parentPath = "e:\\";
String fileName = "news4.txt";
File file = new File(parentPath, fileName);
try {
file.createNewFile();
System.out.println("创建成功~");
} catch (IOException e) {
e.printStackTrace();
}
}
}
1.3.2 获取文件相关信息
getName、 getAbsolutePath、 getParent、 length、 exists、 isFile、 isDirectory
package cn.bdqn.demo01;
import org.junit.Test;
import java.io.File;
public class FileInformation {
public static void main(String[] args) {
}
//获取文件的信息
@Test
public void info()
{
//先创建文件对象
File file = new File("e:\\news1.txt");
//调用相应的方法, 得到对应信息
System.out.println("文件名字=" + file.getName());
System.out.println("文件绝对路径=" + file.getAbsolutePath());
System.out.println("文件父级目录=" + file.getParent());
System.out.println("文件大小(字节)=" + file.length());
System.out.println("文件是否存在=" + file.exists());//T
System.out.println("是不是一个文件=" + file.isFile());//T
System.out.println("是不是一个目录=" + file.isDirectory());//F
}
}
1.3.3 目录操作和文件删除
package cn.bdqn.demo01;
import org.junit.Test;
import java.io.File;
public class Director_ {
public static void main(String[] args) {
}
@Test
//判断 e:\\news1.txt 是否存在。如果存在就删除
public void m1()
{
String filePath="e:\\news1.txt";
File file = new File(filePath);
if(file.exists())
{
if(file.delete())
{
System.out.println(filePath+"删除成功");
}else
{
System.out.println(filePath+"删除失败");
}
}else{
System.out.println("文件不存在");
}
}
@Test
//判断 e:\\demo02 是否存在。如果存在就删除
//这里我们需要体会到,在java中,目录也被当做文件
public void m2()
{
String filePath="e:\\demo02";
File file = new File(filePath);
if(file.exists())
{
if(file.delete())
{
System.out.println(filePath+"删除成功");
}else
{
System.out.println(filePath+"删除失败");
}
}else{
System.out.println("该目录不存在");
}
}
@Test
//判断e:\\demo\\a\\b\\c目录是否存在,若存在则提示存在,不存在则创建
public void m3()
{
String dircetoryPath="e:\\demo\\a\\b\\c";
File file = new File(dircetoryPath);
if(file.exists())
{
System.out.println("该目录存在");
}else{
if(file.mkdirs())//创建一级目录使用mkdir(),多级使用mkdirs()
{
System.out.println(dircetoryPath+"目录创建成功");
}else
{
System.out.println("创建失败");
}
}
}
}
2 IO流原理及流的分类
2.1 java IO流的原理:
1 I\O是Input和Output的缩写,IO技术是非常实用得技术,用于处理数据传输,如读写文件、网络通讯等
2、Java程序中,对于数据的输入输出操作以“流(stream)”的方式进行
3、java.io包下。提供了各种流的接口,用以获取不同种类的数据,并通过方法输入和输出数据
2.2 流的分类:
字节流是 8 位通用字节流,字符流是 16 位 Unicode 字符流
部分常用类关系图:
2.2.1 字节流(重点)
(1)FileInputStream
-
InputStream类常用方法
int read( ) int read(byte[] b) int read(byte[] b,int off,int len) void close( ) int available():可以从输入流中读取的字节数目
-
子类FileInputStream常用的构造方法
FileInputStream(File file) FileInputStream(String name)
实例:int read( )和 int read(byte[] b)
package cn.bdqn.demo01; import java.io.File; import java.io.FileInputStream; import java.io.IOException; public class FileInputStreamDemo01 { public static void main(String[] args) throws IOException { //创建File类对象 File file = new File("F:/a.txt"); //创建FileInputStream类对象 FileInputStream fis = new FileInputStream(file); //读取数据 int num; while((num=fis.read())!=-1){ System.out.print((char)num); } System.out.println("数据读取完毕"); //数据读取完毕之后,关闭流 fis.close(); }
package cn.bdqn.demo01;
import java.io.FileInputStream;
import java.io.IOException;
public class FileInputStreamDemo02 {
public static void main(String[] args) throws IOException {
//创建FileInputStream类对象
FileInputStream fis = new FileInputStream("F:/a.txt");
//读取数据
byte[] bytes = new byte[1024];
//从流中读取数据,将读取的数据存储在你声明的数组中,该方法返回的结果表示从流中读取到的字节数目
int num =fis.read(bytes);
System.out.println(num);
//遍历数组,获取读取到的数据
for (int i = 0; i < num; i++) {
System.out.print((char)bytes[i]);
}
//关闭流
fis.close();
}
}
(2)FileOutputStream
- OutputStream类常用方法
void write(int c)
void write(byte[] buf)
void write(byte[] b,int off,int len)
void close()
void flush()://强制把缓冲区的数据写到输出流中
- 子类FileOutputStream常用的构造方法
FileOutputStream (File file)
FileOutputStream(String name)
FileOutputStream(String name,boolean append)
注意: 1.前两种构造方法在向文件写数据时将覆盖文件中原有的内容
2.创建FileOutputStream实例时,如果相应的文件并不存在,则会自动创建一个空的文件
package cn.bdqn.demo02;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
public class FileOutputStreamDemo01 {
public static void main(String[] args) {
//创建File类对象
File file= new File("F:/a.txt");
//创建FileOutputStream类对象
FileOutputStream fos = null;
try {
//构造方法FileOutputStream(File file)和FileOutputStream(String path):通过这两个构造方法创建的输出流对象在对外进行数据输出的时候,会覆盖文件中原来的数据
// FileOutputStream fos = new FileOutputStream(file);
//FileOutputStream(File file,boolean append)和FileOutputStream(String path,boolean append):使用这两个构造方法创建输出流对象的时候,将第二个参数赋值为true,则在对外进行输出数据的时候,不会覆盖文件中原来的数据
fos = new FileOutputStream(file,true);
//调用写的方法,将数据写入到文件中
fos.write(65);
System.out.println("数据写入完毕");
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}finally{
//关闭流
try {
if(fos!=null){
fos.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
package cn.bdqn.demo02;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
public class FileOutputStreamDemo02 {
public static void main(String[] args) {
//创建FileOutputStream类对象
FileOutputStream fos = null;
try {
fos = new FileOutputStream("F:/a.txt", true);
//准备数据
String strs = "qwertyuiop";
//将字符串strs转换成字节数组
byte[] bytes =strs.getBytes();
//开始写数据
fos.write(bytes);
System.out.println("文件写入完毕");
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}finally{
try {
fos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
2.2.2 字符流
(1)Reader类
Reader类常用的方法:
int read( )
int read(char[] c)
read(char[] c,int off,int len)
void close( )
1 InputStreamReader类
子类InputStreamReader常用的构造方法
InputStreamReader(InputStream in)
InputStreamReader(InputStream in,String charsetName)
package cn.bdqn.demo04;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
public class InputStreamReaderDemo01 {
public static void main(String[] args) {
// 创建File类对象
File file = new File("F:/a.txt");
// 创建InputStream类的引用(InputStream是一个抽象类,无法实例化,可以创建其子类对象)
InputStream is = null;
// 创建InputStreamReader类对象
InputStreamReader isr = null;
try {
//向上转型:父类引用指向子类的实例
is = new FileInputStream(file);
// 创建InputStreamReader类对象
isr = new InputStreamReader(is);//需要传入一个InputStream类对象
// 读取数据
int num;
while ((num = isr.read()) != -1) {
System.out.print((char)num);
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}finally{
try {
isr.close();//后开先关
is.close();//先开后关
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
package cn.bdqn.demo04;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
public class InputStreamReaderDemo02 {
public static void main(String[] args) {
//获取本地平台的编码格式
System.out.println(System.getProperty("file.encoding")); //GBK
// 创建File类对象
File file = new File("F:/a.txt");
// 创建InputStream类的引用(InputStream是一个抽象类,无法实例化,可以创建其子类对象)
InputStream is = null;
// 创建InputStreamReader类对象
InputStreamReader isr = null;
try {
//向上转型:父类引用指向子类的实例
is = new FileInputStream(file);
// 创建InputStreamReader类对象
//InputStreamReader(InputStream is):按照平台默认编码格式读取文件
// isr = new InputStreamReader(is);
//InputStreamReader(InputStream is, String charsetName):按照指定编码格式读取文件
isr = new InputStreamReader(is, "UTF-8");
char[] chs = new char[1024];
// 读取数据
int num =isr.read(chs);
System.out.println(num);
for (int i = 0; i < num; i++) {
System.out.print(chs[i]);
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally{
try {
isr.close();
is.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
2 FileReader类:
FileReader类是InputStreamReader的子类
FileReader(File file)
FileReader(String name)
该类只能按照本地平台的字符编码来读取数据,用户不能指定其他的字符编码类型
System.out.println(System.getProperty("file.encoding")); //获得本地平台的字符编码类型
package cn.bdqn.demo05;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
public class FileReaderDemo01 {
public static void main(String[] args) {
//创建FileReader类对象,FileReader类对象只能按照本地平台的编码格式读取文件,如果文件编码和本地平台编码格式不一样,会出先乱码的现象
FileReader fr =null;
try {
fr =new FileReader("F:/a.txt");
char[] chs = new char[1024];
//读取数据
int num =fr.read(chs);
for (int i = 0; i < num; i++) {
System.out.print(chs[i]);
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
3 BufferedReader类
提高字符流读取文本文件的效率
-
BufferedReader类是Reader类的子类
-
BufferedReader类带有缓冲区
-
按行读取内容的readLine()方法
BufferedReader常用的构造方法
BufferedReader(Reader in)
子类BufferedReader特有的方法
readLine()
package cn.bdqn.demo06;
import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.Reader;
public class BufferedReaderDemo01 {
public static void main(String[] args) {
//创建InputStream类对象,但是InputStream类是一个抽象类,不能创建对象,可以将其引用指向子类
InputStream is = null;
//创建Reader类对象,但是Reader类是一个抽象类,不能创建对象,可以将其引用指向子类(包含孙子类)的实例
Reader reader =null;
//创建BufferedReader类对象
BufferedReader br =null;
try {
is = new FileInputStream("F:/demo.txt");
reader = new InputStreamReader(is);
br = new BufferedReader(reader);
//读取文件
// String str = br.readLine();
// System.out.println(str);
// String str2 = br.readLine();
// System.out.println(str2);
String str;
while((str=br.readLine())!=null){
System.out.println(str);
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}finally{
try {
br.close();
reader.close();
is.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
(2)Writer类
Writer类常用方法
write(String str)
write(String str,int off,int len)
void close()
void flush()
1 OutputStreamWriter类
子类OutputStreamWriter常用的构造方法
OutputStreamWriter(OutputStream out)
OutputStreamWriter(OutputStream out,String charsetName)
package cn.bdqn.demo07;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
public class OutputStreamWriterDemo01 {
public static void main(String[] args) {
// 创建OutputStream类对象,该类是一个抽象类,不能直接创建对象,可以创建一个引用指向其子类对象
OutputStream os = null;
// 创建OutputStreamWriter类对象
OutputStreamWriter osw = null;
try {
os = new FileOutputStream("F:/demo.txt", true);
osw = new OutputStreamWriter(os);
osw.write("asdfghjkl");
System.out.println("数据写入完毕");
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} finally {
try {
osw.close();
os.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
2 FileWriter类
FileWriter类是OutputStreamWriter的子类
FileWriter (File file)
FileWriter (String name)
该类只能按照本地平台的字符编码来写数据,用户不能指定其他的字符编码类型
package cn.bdqn.demo08;
import java.io.FileWriter;
import java.io.IOException;
public class FileWriterDemo01 {
public static void main(String[] args) {
//创建FileWriter类对象
FileWriter fw = null;
try {
fw = new FileWriter("F:/demo.txt", false);
fw.write("hello java");
System.out.println("文件写入完毕");
} catch (IOException e) {
e.printStackTrace();
}finally{
try {
fw.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
3 BufferedWriter类
提高字符流写文本文件的效率?
使用FileWriter类与BufferedWriter类
//BufferedWriter类是Writer类的子类
//BufferedWriter类带有缓冲区
BufferedWriter常用的构造方法
BufferedWriter(Writer out)
package cn.bdqn.demo08;
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;
public class BufferedWriterDemo01 {
public static void main(String[] args) {
//创建Writer类对象,但是Writer类是一个抽象类,不能直接创建对象,但是可以创建引用指向其子类对象
Writer writer = null;
//创建BufferedWriter类对象
BufferedWriter bw =null;
try {
writer = new FileWriter("F:/demo.txt", true);
bw = new BufferedWriter(writer);
//先向文件中插入一个换行
bw.newLine();
bw.write("hello html");
bw.newLine();
bw.write("hello css");
System.out.println("数据写入完毕");
} catch (IOException e) {
e.printStackTrace();
}finally{
try {
bw.close();
writer.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
2.2.3 读写二进制文件
DataInputStream类
FileInputStream的子类
与FileInputStream类结合使用读取二进制文件
DataOutputStream类
FileOutputStream的子类
与FileOutputStream类结合使用写二进制文件
package cn.bdqn.demo01;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
public class DataInputStreamAndDataOutputStreamDemo01 {
public static void main(String[] args) {
//创建InputStream类对象,但是InputStream类是一个抽象类,不能直接创建对象,可以创建引用指向其子类
InputStream is = null;
//创建DataInputStream类对象
DataInputStream dis =null;
//创建OutputStream类对象,但是OutputStream类是一个抽象类,不能直接创建对象,可以创建其引用指向其子类
OutputStream os = null;
//创建DataOutputStream类对象
DataOutputStream dos = null;
try {
is = new FileInputStream("F:/car.jpg");
dis = new DataInputStream(is);
os = new FileOutputStream("F:/runCar.jpg");
dos = new DataOutputStream(os);
int num ;
while((num=dis.read())!=-1){
dos.write(num);
}
System.out.println("图片复制完毕");
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}finally{
try {
dos.close();
os.close();
dis.close();
is.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
2.2.4 序列化和反序列化
序列化是将对象的状态写入到特定的流中的过程(把对象以留的方式写进文件中保存,也叫对象的序列化)
对象中包含的不仅仅是字符,使用字节流 ObjectOutputStream对象的序列化流
package cn.bdqn.demo02; import java.io.Serializable; public class Student implements Serializable { private String name; private int age; private double score; public Student() { super();// 调用其父类Object里的无参构造 } public Student(String name, int age, double score) { super();// 调用其父类Object里的无参构造 this.name = name; this.age = age; this.score = score; } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } public double getScore() { return score; } public void setScore(double score) { this.score = score; } @Override public String toString() { return "Student [name=" + name + ", age=" + age + ", score=" + score + "]"; } }
package cn.bdqn.demo02;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
public class ObjectOutputStreamDemo01 {
public static void main(String[] args) {
//创建一个Student类对象
Student stu = new Student("张三", 22, 99.5);
//创建OutputStream类对象,但是OutputStream类是一个抽象,不能直接创建对象,可以创建其引用指向其子类对象
OutputStream os = null;
//创建ObjectOutputStream类对象
ObjectOutputStream oos = null;
try {
//os指向的文件如果不存在,系统会自动创建这个文件
os = new FileOutputStream("F:/student.txt");
oos = new ObjectOutputStream(os);
//将stu对象通过oos流对象输出去
oos.writeObject(stu);
System.out.println("对象存储完毕");
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}finally{
try {
oos.close();
os.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
package cn.bdqn.demo02;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
public class ObjectOutputStreamDemo02 {
public static void main(String[] args) {
//创建3个Student类对象
Student stu1 = new Student("张三", 22, 95.5);
Student stu2 = new Student("李四", 23, 92.5);
Student stu3 = new Student("如花", 18, 100);
//将3个对象放入数组中
Student[] students = {stu1,stu2,stu3};
OutputStream os = null;
ObjectOutputStream oos =null;
try {
os = new FileOutputStream("F:/students.txt");
oos = new ObjectOutputStream(os);
oos.writeObject(students);
System.out.println("对象存储完毕");
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}finally{
try {
oos.close();
os.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
反序列化则是从特定的流中获取数据重新构建对象的过程 (把文件中保存的对象以留的方式读取出来,叫做读对象,也叫对象的反序列化)
读取的文件保存的都是字节,使用字节流,ObjectInputStream对象的反序列化流
package cn.bdqn.demo02;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectInputStream;
public class ObjectInputStreamDemo01 {
public static void main(String[] args) {
//创建InputStream类对象,但是InputStream类是一个抽象类,不能直接创建其对象,只能创建其引用指向其子类对象
InputStream is = null;
//创建ObjectInputStream类对象
ObjectInputStream ois =null;
try {
is = new FileInputStream("F:/student.txt");
ois = new ObjectInputStream(is);
//从文件中读取对象
Object object=ois.readObject();
//将读取的对象通过向下转型为其真是类型
Student stu = (Student)object;
System.out.println(stu);
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}finally{
try {
ois.close();
is.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
package cn.bdqn.demo02;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectInputStream;
public class ObjectInputStreamDemo02 {
public static void main(String[] args) {
InputStream is = null;
ObjectInputStream ois =null;
try {
is = new FileInputStream("F:/students.txt");
ois = new ObjectInputStream(is);
Object object =ois.readObject();
Student[] stus = (Student[])object;
for (Student student : stus) {
System.out.println(student);
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}finally{
try {
ois.close();
is.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
transient:
修饰属性后,该属性不会被序列化,或者说被transient修饰的属性在反序列化时,得到的属性值都是默认值
package cn.bdqn.demo02;
import java.io.Serializable;
public class GirlFriend implements Serializable {
private String name;
private int age;
// transient:修饰属性后,该属性不会被序列化,或者说被transient修饰的属性在反序列化时,得到的属性值都是默认自
private transient String gender;
public GirlFriend() {
super();
}
public GirlFriend(String name, int age, String gender) {
super();
this.name = name;
this.age = age;
this.gender = gender;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getGender() {
return gender;
}
public void setGender(String gender) {
this.gender = gender;
}
@Override
public String toString() {
return "GirlFriend [name=" + name + ", age=" + age + ", gender="
+ gender + "]";
}
}
package cn.bdqn.demo02;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
public class ObjectOutputStreamDemo03 {
public static void main(String[] args) {
//创建GirlFriend类对象
GirlFriend gf = new GirlFriend("如花", 19, "女");
ObjectOutputStream oos= null;
try {
oos= new ObjectOutputStream(new FileOutputStream("F:/grilFriend.txt"));
oos.writeObject(gf);
System.out.println("对象存储完毕");
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}finally{
try {
oos.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
package cn.bdqn.demo02;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.ObjectInputStream;
public class ObjectInputStreamDemo03 {
public static void main(String[] args) {
ObjectInputStream ois =null;
try {
ois = new ObjectInputStream(new FileInputStream("F:/grilFriend.txt"));
GirlFriend gf =(GirlFriend)ois.readObject();
System.out.println(gf);
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}finally{
try {
ois.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}