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修饰的属性没有被序列化出去。

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值