JAVA核心编程之文件的输入输出流

最新推荐文章于 2024-06-13 13:32:01 发布

bug_writer01

最新推荐文章于 2024-06-13 13:32:01 发布

阅读量784

点赞数 2

文章标签： java jvm 开发语言

本文链接：https://blog.csdn.net/Code_0001/article/details/126430512

版权

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();
			}
		}

	}

}