Java - 文件和IO流

文件：File类

Java就提供了一个File类，以抽象的方式代表文件名和目录路径名。该类主要用于文件和目录的创建、文件的查找和文件的删除等。是我们后面学习IO流的基础和前提

File对象代表磁盘中实际存在的文件和目录，我们可以通过递归算法知道磁盘中某一个目录下嵌套了多少文件。

递归算法（英语：recursion algorithm）：程序调用自身的编程技巧称为递归（ recursion）。递归做为一种算法在程序设计语言中广泛应用在计算机科学中，指一种通过重复将问题分解为同类的子问题而解决问题的方法。递归式方法可以被用于解决很多的计算机科学问题，因此它是计算机科学中十分重要的一个概念。绝大多数编程语言支持函数的自调用，在这些语言中函数可以通过调用自身来进行递归。计算理论可以证明递归的作用可以完全取代循环，因此在很多函数编程语言（如Scheme）中习惯用递归来实现循环。

递归算法解决问题的特点：

1）递归就是方法里调用自身。

2）在使用递增归策略时，必须有一个明确的递归结束条件，称为递归出口。

3）递归算法解题通常显得很简洁，但递归算法解题的运行效率较低。

package com.liudm.demo13;

import java.io.File;
import java.io.IOException;
import java.net.PasswordAuthentication;

public class FileDemo {
	public static void main(String[] args) throws IOException {
		File file = new File("D:\\bxk");   //两个“\”：第一个“\”是用来转义第二个“\”
		System.out.println(file.exists());   //判断文件是否存在
		System.out.println(file.isFile());   //判断是否是一个文件
		System.out.println(file.isDirectory());  //判断是否是一个文件夹
		System.out.println(file.getAbsolutePath());  //返回file文件的绝对路径
		System.out.println(file.getPath());  //返回相对路径
		
		File [] files = file.listFiles();
		for (int i = 0; i < files.length; i++) {
			System.out.println(files[i]);  //列举该目录下这一级的所有文件/文件夹
		}

		if (file.createNewFile()) {
			System.out.println("文件创建成功");  //到D盘查看，aa.txt已创建
		}
		
		if (file.mkdir()) {   //只创建自己
			System.out.println("文件夹创建成功");
		}
		
		File file1 = new File("D:\\bxk1\\bkx2\\bxk3");
		if (file1.mkdirs()) {   //创建目录，包括父目录
			System.out.println("子文件夹创建成功");
		}
		
		//delete()：只能删除空文件夹，即该文件夹中不能有内容
		file.delete();
		file1.delete();   //只删除了最下层子文件夹
	}
}

 

package com.liudm.demo13;

import java.io.File;

public class FileDemo1 {
	
	//递归，列举该目录下包括子目录下的所有文件
	public static  void  listFile(File file){
		//File file=new File(pathName);
		if(file.exists()){
			if(file.isDirectory()){
				File  [] files=file.listFiles();
				for (int i = 0; i < files.length; i++) {
					listFile(files[i]);
//					System.out.println(files[i]);
				}
			}else{
				System.out.println(file.getPath());  //打印名字
			}
		}else{
			System.out.println("该目录不存在");
		}
	}
	public static void main(String[] args) {
		
		listFile(new File("D:\\7-Zip"));
		
//		File file = new File("D:\\soft");
//		File  [] files=file.listFiles();
//		for (int i = 0; i < files.length; i++) {
//			System.out.println(files[i]);
//		}
	}
}

 实验：编写代码实现遍历本地目录（自己定义一个存在的目录）下的所有文件，并打印文件的名字在控制台

1. 打开终端切换目录到/data/目录下,创建文件夹file

2.进入file目录，使用wget命令，下载实验需要的数据

3、解压所需要的数据     

unzip data.zip

package com.liudm.test7;

import java.io.File;

public class FileTest {
	public static void main(String[] args) {
		File file = new File("/data/java3/file");
		FileTest ft = new FileTest();
		ft.GetFileName(file);
	}

	private void GetFileName(File file) {
		// TODO Auto-generated method stub
		if (file.isDirectory()) {
			File [] fs = file.listFiles();
			for (int i = 0; i < fs.length; i++) {
				GetFileName(fs[i]);
			}
		} else {
			System.out.println(file.getName());
		}
	}
}

---

流：主要应用场景是上传下载

字符流操作文件：

java中的流是指一连串流动的字符,是以先进先出方式发送信息的通道

流架构：

流分类：

• 按照流向区分：输入流和输出流（输入输出流是相对于计算机内存来说的）
• 按照内存单元划分：字节流和字符流

字符流：处理包含大量中文的文本文件

• 字符输入流：Reader（父）---》FileReader（低级流）-->BufferedReader（高级流）
• 字符输出流：Writer（父）---》FileWriter（低级流）-->BufferedWriter（高级流）

低级流：也称节点流，节点流类型常见的有：对文件操作的字符流有FileReader/FileWriter，字节流有FileInputStream/FileOutputStream

高级流：也称缓冲流，缓冲流要“套接”在相应的节点流之上，对读写的数据提供了缓冲的功能，提高了读写效率，同时增加了一些新的方法，常用缓冲流有BufferedReader、BufferedWriter

注意：

1.只需要 关闭高级流即可：关高级流，其实就是关低级流，关流的时候，自动刷新缓冲区

 bw.flush();

2.高级流构造器中传入低级流构，体现了 装饰者 模式，让高级流功能更加强大

FileWriter fw = new FileWriter("F:/fw.txt");// 低级流

BufferedWriter bw = new BufferedWriter(fw);  //高级流，有缓冲

3.输出流向外写数据的时候，如果目标地址不存在，自动创建

字节流：字节流是 8 位通用字节流，常用来处理图片、视频、文件

字节输入流：InputStream（父）---》FileInputStream（子）：常用方法：read() 、read(byte[])

字节输出流：OutputStream(父)----》FileOutputStream（子）：常用方法：write(int byte) 、 write(byte[])

注意：

1.输出流向外写数据的时候，如果目标地址不存在，自动创建

2.不管是字节输入流还是字节输出流，在读写数据完成之后，一定要手动关闭流资源，一般在finally代码中完成，垃圾回收机制不会自动回收物理资源

3.在用流操作文件的时候，有很多异常需要处理

package com.liudm.demo13;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class ByteInDemo {
	public static void main(String[] args) {
		//字节输入流：一个字节一个字节地读，读中文汉字会乱码，一个中文？字节
		//将D:\\FileDemo.java → JVM：内存 → 读进来
		File file = new File("D:\\FileDemo.java");
		FileInputStream in = null;
		try {
			in = new FileInputStream(file);
			int data = 0;
			
			//读取文件内容：方法一
			while ((data = in.read()) != -1) {   //  ==-1：读到最后一个字符
				//System.out.print(data);  //ASCII码
				System.out.print((char)data);   //强制转换
			}
			
			//读取文件内容：方法二
			byte [] bs = new byte[in.available()];  //bs数组长度为：这个文件内容的大小，用available()获取
			data = in.read(bs);
			System.out.println(new String(bs));
		} catch (FileNotFoundException e) {
			// TODO: handle exception
			e.printStackTrace();
		} catch (IOException e) {
			// TODO: handle exception
			e.printStackTrace();
		} finally {
			//流：物力资源，一定要手动关闭
			if (in != null) {
				
			}
		}
	}
}

package com.liudm.demo13;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class ByteInDemo1 {
	public static void main(String[] args) throws IOException {
		//字节输出流
		//往外写文件的时候，如果不存在，则创建
		//如果存在不会追加，直接覆盖
		FileOutputStream out = null;
		try {
			out = new FileOutputStream(new File("D:/bxk.txt"));
			out.write(98);
			out.write(97);
			out.write(96);
			System.out.println("写入成功。。");
		} catch (FileNotFoundException e) {
			// TODO: handle exception
			e.printStackTrace();
		} catch (IOException e) {
			// TODO: handle exception
			e.printStackTrace();
		} finally {
			if (out != null) {
				out.close();
			}
		}
	}
}

 

package com.liudm.demo13;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

public class CharDemo {
	//字符流，基类：Reader，Writer
	//字节流，基类：InPutStream，OutPutStream
	public static void main(String[] args) {
		//在外面声明，里面赋值
		FileReader fr = null;
		BufferedReader br = null;
		try {
			//模式：装饰者模式
			
			fr = new FileReader(new File ("D:\\FileDemo.java"));  //低级流
			br = new BufferedReader(fr);  //高级流：缓冲区，效率高
			
			String line = null;
			br.readLine();  //一行一行地读
			while ((line = br.readLine()) != null) {
				System.out.println(line);
			}
			
			int data = 0;  //fr.read()
			while ((data = fr.read()) != -1) {
				System.out.println((char)data);
			}
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} finally {
			if (br != null) {
				try {
					br.close();  //关闭高级流，低级流就不用关闭了
				} catch (Exception e2) {
					// TODO: handle exception
				}
			}
		}
	}
}

package com.liudm.demo13;

import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;

public class CharDemo1 {
	//字符输出流
	public static void main(String[] args) {
		FileWriter fw = null;
		BufferedWriter br = null;
		try {
			fw = new FileWriter(new File("D:\\study.txt"),true);  //在低级流后面加true，表示追加
			br = new BufferedWriter(fw);
			
			char [] c = {'A','B','C','D'};
			br.write("张三");
			br.write(98);
			br.write(c);
			
			br.flush();
			//刷新缓冲区，当没有关流的时候需要读流时，需要刷新缓冲区先读出来
			//读流自动刷新缓冲区
			
		} catch (IOException e) {
			// TODO: handle exception
			e.printStackTrace();
		} catch (Exception e) {
			// TODO: handle exception
			e.printStackTrace();
		} finally {
			if (br != null) {
				try {
					br.close();  //关流的时候会自动刷新缓冲区
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		}
	}
}

 

package com.liudm.demo13;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class CopyDemo {
	public static void main(String[] args) throws IOException {
		CopyDemo.copy("D:\\FileDemo.java","C:\\FileDemo.java");
	}
	
	//图片，视频等，都用字节流
	public static void copy(String start,String end) throws FileNotFoundException{
		FileInputStream in = new FileInputStream(new File(start));
		FileOutputStream out = new FileOutputStream(new File(end));
		
		int data = 0;
		try {
			while ((data = in.read()) != -1) {
				//System.out.println((char)data);
				out.write(data);
			}
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}

实验1：利用字符流完成文件的读写操作

package com.liudm.test1;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

import com.liudm.test1.FileTest;

public class FileTest {
	public static void main(String[] args) throws IOException {
		FileTest.WritrDoc("/data/liudm.txt");
	}
	
	public static void WritrDoc (String file1) throws IOException{
		FileWriter fw = null;
		BufferedWriter bw = null;
		try {
			fw = new FileWriter(new File(file1));
			bw = new BufferedWriter(fw);
			bw.write("写入＋＋＋＋");
			bw.write("追加＋＋＋＋");
		} catch (IOException e) {
			// TODO: handle exception
			e.printStackTrace();
		} finally {
			if (bw != null) {
				bw.close();
			}
		}
	}
	
	public static void ReadDoc (String file1) throws FileNotFoundException {
		FileReader fr = null;
		BufferedReader br = null;
		try {
			fr = new FileReader(new File(file1));
			br = new BufferedReader(fr);
			int data = 0;
			while ((data = br.read()) != -1) {
				System.out.println((char)data);
			}
		} catch (IOException e) {
			// TODO: handle exception
			e.printStackTrace();
		} finally {
			if (br != null) {
				try {
					br.close();   //关闭高级流的时候---》默认关闭的就是低级流
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		}
	}
}

读文件：在该类中，定义一个方法，用来实现文件的读取，并打印在控制台输出。

首先声明一个字节流BufferedReader，构造一个BufferedReader对象，构造器中传入FileReader对象，因为FileReader是字符流，所以其构造器中需传入file对象，最终获得BufferedReader对象，使用read方法返回读取的字符，当文件读到末尾的时候返回-1.所以借助whille循环，不断的读取文件中的内容，最后打印输出。

注意：在编写代码的时候，只要记住两个类：FileReader、BufferedReader和read方法，在写代码时，根据提示传入所需要的内容即可。

public static void ReadFileByZifu(String address){  
    FileReader fr=null;//低级流  
    BufferedReader br=null;//高级流：缓冲  
    try {  
        fr=new FileReader(new File(address));//FileReader是字符流  
                br=new BufferedReader(fr);//BufferedReader是字符高级流，有缓冲区  
                int data=0;  
                while((data=br.read())!=-1){  
                    System.out.print((char)data);  
                }  
            } catch (FileNotFoundException e) {  
                // TODO Auto-generated catch block  
                e.printStackTrace();  
            } catch (IOException e) {  
                // TODO Auto-generated catch block  
                e.printStackTrace();  
            }finally{  
                try {  
                    br.close();//关闭高级流的时候---》默认关闭的就是低级流  
                } catch (IOException e) {  
                    // TODO Auto-generated catch block  
                    e.printStackTrace();  
                }  
            }  
        }

在读文件的时候，也可以把br.read换成br.readLine方法，这样表示读取一行数据：

String data=null;  
                while((data=br.readLine())!=null){  
                    System.out.println(data);  
                }

写文件：写文件用字符输出流来实现，使用FileWrite、BufferedWriter类和write方法，和字符输入流是一样的。在使用高级流读写文件的时候，一定要注意刷新高级流的缓冲区，即调用flush方法，流关闭的时候，默认刷新缓冲区。

package my.iodemo1;  
import java.io.BufferedReader;  
import java.io.BufferedWriter;  
import java.io.File;  
import java.io.FileNotFoundException;  
import java.io.FileReader;  
import java.io.FileWriter;  
import java.io.IOException;  
    public class ZiFu {  
        public static void main(String[] args) {  
            //ZiFu.ReadFileByZifu("/data/FileDemo.java");  
            ZiFu.WriteFileByZiFu("/data/outzifu.txt");  
  
        }  
  
        public static void WriteFileByZiFu(String address){  
            FileWriter fw=null;  
            BufferedWriter bw=null;  
            try {  
                fw=new FileWriter(new File(address));  
                bw=new BufferedWriter(fw);  
                bw.write("大家一定要认真学习。。");  
                //bw.flush();//刷新缓冲区  
  
            } catch (IOException e) {  
                // TODO Auto-generated catch block  
                e.printStackTrace();  
            }finally{  
                try {  
                    bw.close();//关闭流资源之前 ，先刷新缓冲区  
                } catch (IOException e) {  
                    // TODO Auto-generated catch block  
                    e.printStackTrace();  
                }  
            }  
        }  
  
  
        public static void ReadFileByZifu(String address){  
            FileReader fr=null;//低级流  
            BufferedReader br=null;//高级流：缓冲  
             try {  
                fr=new FileReader(new File(address));//FileReader是字符流  
                br=new BufferedReader(fr);//BufferedReader是字符高级流，有缓冲区  
                int data=0;  
                while((data=br.read())!=-1){  
                    System.out.print((char)data);  
                }  
               // String data=null;  
               //while((data=br.readLine())!=null){  
                //  System.out.println(data);  
                //}  
            } catch (FileNotFoundException e) {  
                // TODO Auto-generated catch block  
                e.printStackTrace();  
            } catch (IOException e) {  
                // TODO Auto-generated catch block  
                e.printStackTrace();  
            }finally{  
                try {  
                    br.close();//关闭高级流的时候---》默认关闭的就是低级流  
                } catch (IOException e) {  
                    // TODO Auto-generated catch block  
                    e.printStackTrace();  
                }  
            }  
        }  
} 

实验2：利用字节流完成文件的读写操作

读文件：在该类中，定义一个方法，用来实现文件的读取，并打印在控制台输出。首先声明一个字节流FileInputStream，构造一个FileInputStream对象，构造器中传入file文件，获得字节输入流FileInputStream对象，因为流是携带信息的通道，使用read方法返回读取的字节，当文件督导末尾的时候返回-1.所以借助whille循环，不断的读取文件中的字节内容，最后打印输出。

package my.iodemo1;  
import java.io.File;  
import java.io.FileInputStream;  
import java.io.FileNotFoundException;  
import java.io.IOException;  
public class ZiJie {  
    public static void main(String[] args) {  
        ZiJie.ReadFile("/data/FileDemo.java");  
    }  
  
    public static void ReadFile(String address){  
        File file=new File(address);  
        FileInputStream in=null;  
        //流来读  
        try {  
            in=new FileInputStream(file);//把信息放在流中  
            byte [] bs=new byte[in.available()]; //信息总共的字节大小  
            int data=0; //in.read()读到的其实就是字符对应的AS码值  
            while((data=in.read(bs))!=-1){// -1表示文件读到末尾了  
               System.out.print(new String(bs));  
            }  
        } catch (FileNotFoundException e) {  
            // TODO Auto-generated catch block  
            e.printStackTrace();  
        } catch (IOException e) {  
            // TODO Auto-generated catch block  
            e.printStackTrace();  
        }finally{  
            try {  
                in.close();  
            } catch (IOException e) {  
                // TODO Auto-generated catch block  
                e.printStackTrace();  
            }  
        }  
    }  
  
    public static  void ReadFile2(String address){  
        File file=new File(address);  
        FileInputStream in=null;  
        //流来读  
        try {  
            in=new FileInputStream(file);//把信息放在流中  
            int data=0; //in.read()读到的其实就是字符对应的AS码值  
            while((data=in.read())!=-1){// -1表示文件读到末尾了  
               System.out.print((char)data);  
            }  
        } catch (FileNotFoundException e) {  
            // TODO Auto-generated catch block  
            e.printStackTrace();  
        } catch (IOException e) {  
            // TODO Auto-generated catch block  
            e.printStackTrace();  
        }finally{  
            try {  
                in.close();  
            } catch (IOException e) {  
                // TODO Auto-generated catch block  
                e.printStackTrace();  
            }  
        }  
    }  
} 

写文件：同理，使用FileOutPutStream类中的write方法写内容，定义WriteFile方法，在FileOutputStream构造器中传入file对象，new出FileOutputStream对象，调用他的write方法写入字节数据，当然也可以借助字节数组完成数据的写入。

public static void WriteFile(String address){  
        FileOutputStream  out=null;  
        try {  
            out=new FileOutputStream(new File(address));  
            out.write(97);  //97  -->a  //98  -->b  
            out.write(98);  
  
            byte []bs=new byte[10];//借助字节数组  
            bs[0]='A';  
            bs[1]='A';  
            bs[2]='A';  
            bs[3]='A';  
            out.write(bs);  
        } catch (FileNotFoundException e) {  
            // TODO Auto-generated catch block  
            e.printStackTrace();  
        } catch (IOException e) {  
            // TODO Auto-generated catch block  
            e.printStackTrace();  
        }finally{  
            try {  
                out.close();  
            } catch (IOException e) {  
                // TODO Auto-generated catch block  
                e.printStackTrace();  
            }  
        }  
    } 

 在main方法中调用：

public static void main(String[] args) {  
    ZiJie.WriteFile("/data/out.txt");  
  
}

package com.liudm.demo2;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class FileTest {
	public static void main(String[] args) throws IOException {
		FileTest.WriteDoc("/data/liudmm.txt");
		FileTest.ReadDoc("/data/liudmm.txt");
	}
	
	public static void WriteDoc(String f) throws IOException {
		FileOutputStream out = null;
		try {
			out = new FileOutputStream(f);
			out.write(65);
			out.write(115);
			out.write(104);
			out.write(32);
			out.write(105);
			out.write(115);
			out.write(32);
			
			byte [] bs = new byte [20];
			bs[0] = 't';
			bs[1] = 'h';
			bs[2] = 'e';
			bs[3] = ' ';
			bs[4] = 'p';
			bs[5] = 'u';
			bs[6] = 'r';
			bs[7] = 'e';
			bs[8] = 's';
			bs[9] = 't';
			out.write(bs);
			
		} catch (FileNotFoundException e) {
			// TODO: handle exception
			e.printStackTrace();
		} catch (IOException e) {
			// TODO: handle exception
			e.printStackTrace();
		} finally {
			if (out != null) {
				out.close();
			}
		}
	}
	
	public static void ReadDoc(String f) throws IOException {
		FileInputStream in = null;
        //流来读
		try {
			in = new FileInputStream(f);   //把信息放在流中
			int data = 0;   //in.read()读到的其实就是字符对应的AS码值
			while ((data = in.read()) != -1) {   // -1表示文件读到末尾了
				System.out.println((char)data);
			}
		} catch (FileNotFoundException e) {
			// TODO: handle exception
			e.printStackTrace();
		} catch (IOException e) {
			// TODO: handle exception
			e.printStackTrace();
		} catch (Exception e) {
			// TODO: handle exception
			e.printStackTrace();
		} finally {
			if (in != null) {
				in.close();
			}
		}
	}
}

练习1：编码实现从C盘拷贝一张图片到D盘

package com.liudm.demo13;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class Test1 {
	public static void main(String[] args) throws IOException {
		Test1.copy("C:\\subwaymap.jpg","D:\\subwaymap.jpg");
	}

	private static void copy(String start, String end) throws IOException {
		// TODO Auto-generated method stub
		FileInputStream in = new FileInputStream(new File(start));
		FileOutputStream out = new FileOutputStream(new File(end));
		int data = 0;
		try {
			while ((data = in.read()) != -1) {
				out.write(data);
			}
		} catch (Exception e) {
			// TODO: handle exception
		} finally {
			if (out != null) {
				out.close();
			}
		}
	}
}

     

练习2：编码实现将一个包含大量中文的文件从C盘copy到D盘

package com.liudm.demo13;

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class Test2 {
	public static void main(String[] args) throws IOException {
		FileReader fr = null;
		FileWriter fw = null;
		try {
			fr = new FileReader("C:\\IO流.txt");  //该含有大量中文字符的文件已存在
			fw = new FileWriter("D:\\IO流.txt");
			int data =0;
			while((data = fr.read()) != -1){
				fw.write(data);
			}
		} catch (FileNotFoundException e) {
			// TODO: handle exception
			e.printStackTrace();
		} catch (IOException e) {
			// TODO: handle exception
			e.printStackTrace();
		} catch (Exception e) {
			// TODO: handle exception
			e.printStackTrace();
		} finally {
			if (fw != null) {
				fw.close();
			}
		}
	}
}

序列化和反序列化

概念：序列化就是一种用来处理对象流的机制，所谓对象流也就是将对象的内容进行流化,将数据分解成字节流以便存储在文件中或在网络上传输。可以对流化后的对象进行读写操作，也可将流化后的对象传输于网络之间。序列化是为了解决在对对象流进行读写操作时所引发的问题。

分类：序列化分为两大部分：序列化和反序列化。

• 序列化：将数据分解成字节流，以便存储在文件中或在网络上传输。即：序列化是将对象的状态存储到特定存储介质中的过程，由ObjectOutputStream类的writeObject实现
• 反序列化：打开字节流并重构对象。即：反序列化则是从特定存储介质中的数据重新构建对象的过程 ，由ObjectInputStream类的readObject()方法实现

步骤：序列化的实现步骤：

1.将需要被序列化的类实现Serializable接口，该接口没有需要实现的方法，implements Serializable只是为了标注该对象是可被序列化的，生成一个 serialVersionUID = -3780517487765653944L;

2.然后使用一个输出流(如：FileOutputStream)来构造一个ObjectOutputStream(对象流)对象

3.接着，使用ObjectOutputStream对象的writeObject(Object obj)方法就可以将参数为obj的对象写出(即保存其状态)，要恢复的话则用输入流

4.关闭流资源

注意：

1.static属性不会被序列化出去：--》static属于类的，不属于对象

2.如果一个对象的某个属性不想被序列化出去，那么该属性可以用transient修饰

3.序列化不可追加

4.如果某个类能够被序列化，其子类也可以被序列化

实验1：编写代码实现，将老师对象（stu("张老师",23)）序列化到本地文件teachers.txt中，再反序列化回来将其信息打印在控制台。

让Teacher类实现Serializable接口，生成serialVersionUID，表明teacher对象可以被序列化出去并唯一标识该类，并封装Teacher类：

package my.seriobject;  
import java.io.Serializable;  
public class Teacher  implements Serializable{  
    private static final long serialVersionUID = 1L;  
    private String name;  
    private int age;  
    private  transient String course;  
  
    public Teacher() {  
        // TODO Auto-generated constructor stub  
    }  
    public Teacher(String name, int age, String course) {  
        super();  
        this.name = name;  
        this.age = age;  
        this.course = course;  
    }  
  
    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 getCourse() {  
        return course;  
    }  
    public void setCourse(String course) {  
        this.course = course;  
    }  
    public static long getSerialversionuid() {  
        return serialVersionUID;  
    }  
}  

在SeriObject类中定义序列化的方法，实现序列化的类是ObjectOutputStream，该类构造器中需传入一个输出流，所以我们构建一个字节输出流FileOutputStream对象传入其构造器中，然后调用ObjectOutputStream的writeObject方法将对象持久化保存在本地文件中。

在处理异常的时候，大家注意：如果代码爆红线，鼠标放在上面时，弹出这种界面，说明我们要处理异常，可以点击：Add throws declaration，声明异常；Surround with try/catch,捕获异常。在开发中一般使用try-catch捕获异常。在main方法中调用该序列化方法。因为是将对象转换成流的形式保存起来，所以使用cat命令查看的时候，是乱码的。编写反序列代码，定义一个方法，将我们序列化出去的对象反序列化回来并将信息打印在控制台。

package my.seriobject;  
import java.io.File;  
import java.io.FileInputStream;  
import java.io.FileNotFoundException;  
import java.io.FileOutputStream;  
import java.io.IOException;  
import java.io.ObjectInputStream;  
import java.io.ObjectOutputStream;  
  
  
public class SeriObject {  
    public static void main(String[] args) throws IOException, ClassNotFoundException {  
        SeriObject.seriz("/data/teachers.txt");  
        SeriObject.fseriz("/data/teachers.txt");  
    }  
  
    //反序列化对象回来  
    public static void fseriz(String address) throws FileNotFoundException, IOException, ClassNotFoundException{  
        ObjectInputStream in=new ObjectInputStream(new FileInputStream(address));  
        Teacher stu=  (Teacher) in.readObject();  
        System.out.println(stu.getName()+"   "+stu.getAge()+"  "+stu.getCourse());  
        in.close();  
    }  
    //序列化对象出去  
    public static void seriz(String address){  
        File file=new File(address);  
        FileOutputStream fo = null;  
        ObjectOutputStream obj=null;  
        try {  
            fo = new FileOutputStream(file);  
            obj=new ObjectOutputStream(fo);  
            Teacher s1=new Teacher("张老师",12,"java");  
            obj.writeObject(s1);//把对象写到本地：序列化  
        } catch (FileNotFoundException e) {  
            // TODO Auto-generated catch block  
            e.printStackTrace();  
        } catch (IOException e) {  
            // TODO Auto-generated catch block  
            e.printStackTrace();  
        }finally{  
            try {  
                fo.close();  
            } catch (IOException e) {  
                // TODO Auto-generated catch block  
                e.printStackTrace();  
            }  
            try {  
                obj.close();  
            } catch (IOException e) {  
                // TODO Auto-generated catch block  
                e.printStackTrace();  
            }  
        }  
    }  
} 

在控制台查看读取到的信息内容：

发现tea.getCourse()返回null，说明Teacher类中被关键字transient修饰的属性没有被序列化出去。