- 第一章 文件的编码
package com.imooc.io; public class EncodeDemo { /** * @param args */ public static void main(String[] args) { // TODO Auto-generated method stub String s="欢迎你ABC"; byte[] byte1=s.getBytes(); for (byte b : byte1) { //把字节转换成16进制的方式显示 System.out.println(Integer.toHexString(b)); } } }
运行结果为:
package com.imooc.io; public class EncodeDemo { /** * @param args */ public static void main(String[] args) { // TODO Auto-generated method stub String s="欢迎你ABC"; byte[] byte1=s.getBytes(); for (byte b : byte1) { //把字节转换成16进制的方式显示 System.out.println(Integer.toHexString(b & 0xff)); } } }
运行结果为:
- 第二章 File类常用API介绍
java.io.File类用于表示文件(目录)
File类只用于表示文件(目录)的信息(名称,大小等),不能用于文件内容的访问
package com.imooc.io; import java.io.File; import java.io.IOException; public class FileDemo { /** * @param args */ public static void main(String[] args) { // TODO Auto-generated method stub //了解构造函数的情况,查帮助 File file=new File("E:\\javaio\\ime"); //System.out.println(file.exists()); if (!file.exists()) { file.mkdir();//file.mkdirs() }else{ file.delete(); } //是否是一个目录 如果是目录返回true,如果不是目录or目录不存在返回的是false System.out.println(file.isDirectory()); //是否是个文件 System.out.println(file.isFile()); //File file2=new File("e:\\javaio\\日记1.txt"); File file2=new File("e:\\javaio","日记1.txt"); if (file2.exists()) { try { file2.createNewFile(); } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } } else { file2.delete(); //常用的File对象的API System.out.println(file);//file.toString()的内容 System.out.println(file.getAbsolutePath()); System.out.println(file.getName()); System.out.println(file2.getName()); System.out.println(file.getParent()); System.out.println(file2.getParent()); System.out.println(file.getParentFile().getAbsolutePath()); } } }
运行结果为:
遍历目录
package com.imooc.io; import java.io.File; import java.io.IOException; public class FileUtils { //列出File的一些常用操作比如过滤,遍历等操作 /** * @param dir * @ throws IOException */ public static void listDirectory(File dir) throws IOException{ //exists()方法用于判断文件或目录是否存在 if (!dir.exists()) { throw new IllegalArgumentException("目录:"+dir+"不存在"); } //isDirectory()方法用于判断File类的对象是否是目录 if (!dir.isDirectory()) { throw new IllegalArgumentException(dir+"不是目录"); } //list()方法用于列出当前目录下的子目录和文件 /*String[] filenames=dir.list();//返回的字符串数组 直接子的名称,不包含子目录下的内容 for (String string : filenames) { System.out.println(string); }*/ //如果要遍历子目录下的内容就需要构造成File对象做递归操作,File提供了直接返回File对象的dir File[] files=dir.listFiles();//返回的是直接子目(文件)的抽象 /*for (File file : files) { System.out.println(file); }*/ if (files!=null && files.length>0) { for (File file : files) { if (file.isDirectory()) { //递归 listDirectory(file); }else{ System.out.println(file); } } } } }
package com.imooc.io; import java.io.File; import java.io.IOException; public class FileUtilTest1 { /** * @param args */ public static void main(String[] args) throws Exception{ // TODO Auto-generated method stub FileUtils.listDirectory(new File("E:\\example")); } }
- 第三章 RandomAccessFile类的使用
RandomAccessFile基本操作
- java.io.File类用于表示文件(目录)
- File类只用于表示文件(目录)的信息(名称,大小等),不能用于文件内容的访问RandomAccessFile java提供的对文件内容的访问,即可以读文件,也可以写文件
- RandeomAccessFile支持随机访问文件,可以访问文件的任意位置
- java文件模型
java文件模型 在硬盘上的文件是byte byte byte存储的,是数据的集合
5. 打开文件
(1)有两种模式“rw”(读写)“r”(只读)
(2) RandomAccessFile raf=new RandomAccessFile("file","rw");
(3)文件指针,打开文件时指针在开头pointer=0;
6.写方法
raf.write(int)--->只写一个字节(后8位),同时指针指向下一个位置,准备再次写入
7.读方法
int b=raf.read()--->读一个字节
8.文件读写完成以后一定要关闭(oracle官方说明)
package com.imooc.io; import java.io.File; import java.io.FileNotFoundException; import java.io.IOException; import java.io.RandomAccessFile; import java.util.Arrays; public class RafDemo { /** * @param args */ public static void main(String[] args) { File demo=new File("demo"); if (!demo.exists()) { demo.mkdir(); } File file=new File("raf.dat"); if (!demo.exists()) { try { file.createNewFile(); } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } } try { RandomAccessFile raf=new RandomAccessFile(file,"rw"); //指针的位置 System.out.println(raf.getFilePointer()); raf.write(‘A‘);//只写了一个字节 System.out.println(raf.getFilePointer()); raf.write(‘B‘); int i=0x7fffffff; //用write方法每次只能写一个字节,如果要把i写进去就得写4次 raf.write(i>>>24); raf.write(i>>>16); raf.write(i>>>8); raf.write(i); System.out.println(raf.getFilePointer()); //可以直接写一个int raf.writeInt(i); String s="中"; byte[] gbk=s.getBytes("gbk"); raf.write(gbk); System.out.println(raf.length()); //读文件,必须把指针移到头部 raf.seek(0); //一次性读取,把文件中的内容都读到字节数组中 byte[] buf=new byte[(int)raf.length()]; raf.read(buf); System.out.println(Arrays.toString(buf)); for (byte b : buf) { System.out.println(Integer.toHexString(b & 0xff)); } raf.close(); /*String s1=new String(buf,"gbk"); System.out.println(s1);*/ } catch (FileNotFoundException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } } }
运行结果:
- 第四章 字节流
字节流之文件输入流FileInputStream-1
IO流(输入流和输出流)
字节流 字符流
1.字节流
(1)InputStream、outputSream
InputStream抽象了应用程序读取数据的方式
outputStream抽象了应用程写出数据的方式
(2)EOF=End读到-1就读到结尾
(3)输入流基本方式
int b=in.read();读取一个字节无符号填充到int低八位,-1是EOF
in.read(byte[] buf)读取数据填充到字节数组buf
in.read(byte[] buf,int start,int size)读取数据到字节数组buf 从buf 的 start位置开始存放size长度的数据
(4)输出流基本方法
out.write(int b)写出一个byte到流,b的第八位
out.write(byte[] buf)将buf字节数组都写入到流
out.write(byte[] buf,int start,int size)//字节数组buf从start位置,开始写size长度的字节到流
(5)FileInputStream--->具体实现了在文件上读取数据
先计算机——文档(E)创建一个javaio文件夹——FileUtils.java文本文档
package com.imooc.io; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.IOException; public class IOUtil { /** * @param args */ /** * 读取指定文件内容,按照16进制输出到控制台 * 并且每输出10个byte换行 * @param fileName */ public static void printHex(String fileName){ try { //把文件作为字节流进行读操作 FileInputStream in=new FileInputStream(fileName); int b; int i=1; try { while ((b=in.read())!=-1) { if (b<=0xf) { //单位数前面补0 System.out.println("0"); } //将整型b转换为16进制表示的字符串 System.out.println(Integer.toHexString(b)); if (i++%10==0) { System.out.println(); } } in.close(); } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } } catch (FileNotFoundException e) { // TODO Auto-generated catch block e.printStackTrace(); } } }
package com.imooc.io; public class IOUtilTest1 { /** * @param args */ public static void main(String[] args) { try { IOUtil.printHex("e:\\javaio\\FileUtils.java"); } catch (Exception e) { // TODO Auto-generated catch block e.printStackTrace(); } } }
字节流之文件输入流FileInputStream-2
package com.imooc.io; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.IOException; import java.util.Iterator; public class IOUtil { /** * @param args */ /** * 读取指定文件内容,按照16进制输出到控制台 * 并且每输出10个byte换行 * @param fileName */ /* public static void printHex(String fileName){ try { //把文件作为字节流进行读操作 FileInputStream in=new FileInputStream(fileName); int b; int i=1; try { while ((b=in.read())!=-1) { if (b<=0xf) { //单位数前面补0 System.out.println("0"); } //将整型b转换为16进制表示的字符串 System.out.println(Integer.toHexString(b)); if (i++%10==0) { System.out.println(); } } in.close(); } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } } catch (FileNotFoundException e) { // TODO Auto-generated catch block e.printStackTrace(); } } */ public static void printHexByByteArray(String fileName){ try { FileInputStream in=new FileInputStream(fileName); byte[] buf=new byte[8*1024]; try { /** * @从in中批量读取字节,放入到buf这个字节数组中, * 从第0个位置开始放,最多放buf.length个 * 返回的是读到的字节的个数 */ /*int bytes=in.read(buf,0,buf.length);//一次性读完,说明字节数组足够大 int j=1; for (int i = 0; i < bytes; i++) { if (buf[i]<=0xf) { System.out.println("0"); } System.out.println(Integer.toString(buf[i])+" "); if (j++%10==0) { System.out.println(); } }*/ int bytes=0; int j=0; while ((bytes=in.read(buf,0,buf.length))!=-1) { for (int i = 0; i < buf.length; i++) { //byte类型8位,int类型32位,为了避免数据转换错误,通过&0xff将高24位清零 System.out.println(Integer.toHexString(buf[i] & 0xff)); if (j++%10==0) { System.out.println(); } } } } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } } catch (FileNotFoundException e) { // TODO Auto-generated catch block e.printStackTrace(); } } }
package com.imooc.io; public class IOUtilTest2 { /** * @param args */ public static void main(String[] args) { try { IOUtil.printHexByByteArray("e:\\javaio\\FileUtils.java"); } catch (Exception e) { // TODO Auto-generated catch block e.printStackTrace(); } } }
字节流之文件输出流FileOutputStream
FileOutputStream实现了向文件中写出byte数据的方法
package com.imooc.io; import java.io.File; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.IOException; import java.util.Iterator; public class IOUtil { public static void printHex(String fileName) { // TODO Auto-generated method stub try { FileInputStream in=new FileInputStream(fileName); byte[] buf=new byte[8*1024]; int bytes=0; int j=0; try { while ((bytes=in.read(buf,0,buf.length))!=-1) { for (int i = 0; i < buf.length; i++) { //byte类型8位,int类型32位,为了避免数据转换错误,通过&0xff将高24位清零 System.out.println(Integer.toHexString(buf[i] & 0xff)); if (j++%10==0) { System.out.println(); } } } in.close(); } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } } catch (FileNotFoundException e) { // TODO Auto-generated catch block e.printStackTrace(); } } public static void copyFile(File srcFile,File destFile)throws IOException{ if (!srcFile.exists()) { throw new IllegalArgumentException("文件:"+srcFile+"不存在"); } if (!srcFile.isFile()) { throw new IllegalArgumentException(srcFile+"不是文件"); } FileInputStream in=new FileInputStream(srcFile); FileOutputStream out=new FileOutputStream(destFile); byte[] buf=new byte[8*1024]; int b; while ((b=in.read(buf,0,buf.length))!=-1) { out.write(buf,0,b); out.flush();//最好加上 } in.close(); out.close(); } }
package com.imooc.io; import java.io.FileOutputStream; public class FileOutDemo1 { /** * @param args */ public static void main(String[] args) throws Exception{ //如果该文件不存在,则直接创建,如果存在,删除后创建 FileOutputStream out=new FileOutputStream("demo/out.dat"); out.write(‘A‘);//写出了‘A’的低八位 out.write(‘B‘);//写出了‘B’的低八位 int a=10;//write只能写八位,那么写一个int需要些4次每次8位 out.write(a>>>24); out.write(a>>>16); out.write(a>>>8); out.write(a); byte[] gbk="中国".getBytes("gbk"); out.write(gbk); out.close(); IOUtil.printHex("demo/out.dat"); } }
运行结果为:
package com.imooc.io; import java.io.File; import java.io.IOException; public class IOUtilTest3 { /** * @param args */ public static void main(String[] args) { try { IOUtil.copyFile(new File("e:\\javaio\\imooc.txt"),new File("e:\\javaio\\imooc1.txt")); } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } } }
运行结果为:
字节流之数据输入输出流
DataOutputStream/DataInputStream 对“流”功能的扩展,可以更加方面的读取int,long,字符等类型数据DataOutputStream
writeInt()/writeDouble()/writeUTF()
package com.imooc.io; import java.io.DataOutputStream; import java.io.FileOutputStream; public class DosDemo { /** * @param args */ public static void main(String[] args) throws Exception{ String file="demo/dos.dat"; DataOutputStream dos=new DataOutputStream(new FileOutputStream(file)); dos.writeInt(10); dos.writeInt(-10); dos.writeLong(10l); dos.writeDouble(10.5); //采用utf-8编码写出 dos.writeUTF("中国"); //采用 utf-16be编码写出 dos.writeChars("中国"); dos.close(); IOUtil.printHex(file); } }
运行结果为:
package com.imooc.io; import java.io.DataInput; import java.io.DataInputStream; import java.io.FileInputStream; import java.io.FileNotFoundException; public class DisDemo { /** * @param args * @throws Exception */ public static void main(String[] args) throws Exception { String file="demo/dos.dat"; IOUtil.printHex(file); DataInputStream dis=new DataInputStream(new FileInputStream(file)); int i=dis.readInt(); System.out.println(i); long l=dis.readLong(); System.out.println(l); double d=dis.readDouble(); System.out.println(d); String s=dis.readUTF(); System.out.println(s); dis.close(); } }
运行结果为:略
字节缓冲流
BufferedInputStream & BufferedOutputStream 这两个流类位IO提供了带缓冲区的操作,一般打开文件进行写入或读取操作时,都会加上缓冲,这种流模式提高了IO的性能
从应用程序中把输入放入文件,相当于将一缸水倒入到另一个缸中:
FileOutputStream---->write()方法相当于一滴一滴地把水“转移”过去
DataOutputStream--->writeXxx()方法会方便一些,相当于一瓢一瓢把水“转移”过去
BufferedOutputStream--->write方法更方便,相当于一瓢一瓢先放入桶中,再从桶中倒入到另一个缸中,性能提高了
package com.imooc.io; import java.io.BufferedInputStream; import java.io.BufferedOutputStream; import java.io.File; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.IOException; import java.util.Iterator; public class IOUtil { public static void printHex(String fileName) { // TODO Auto-generated method stub try { FileInputStream in=new FileInputStream(fileName); byte[] buf=new byte[8*1024]; int bytes=0; int j=0; try { while ((bytes=in.read(buf,0,buf.length))!=-1) { for (int i = 0; i < buf.length; i++) { //byte类型8位,int类型32位,为了避免数据转换错误,通过&0xff将高24位清零 System.out.println(Integer.toHexString(buf[i] & 0xff)); if (j++%10==0) { System.out.println(); } } } in.close(); } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } } catch (FileNotFoundException e) { // TODO Auto-generated catch block e.printStackTrace(); } } public static void copyFile(File srcFile,File destFile)throws IOException{ if (!srcFile.exists()) { throw new IllegalArgumentException("文件:"+srcFile+"不存在"); } if (!srcFile.isFile()) { throw new IllegalArgumentException(srcFile+"不是文件"); } FileInputStream in=new FileInputStream(srcFile); FileOutputStream out=new FileOutputStream(destFile); byte[] buf=new byte[8*1024]; int b; while ((b=in.read(buf,0,buf.length))!=-1) { out.write(buf,0,b); out.flush();//最好加上 } in.close(); out.close(); } /*进行文件的拷贝,利用带缓冲的字节流 * * * */ public static void copyFileByBuffer(File srcFile,File desFile) throws Exception{ if (!srcFile.exists()) { throw new IllegalArgumentException("文件"+srcFile+"不存在"); } if (!srcFile.exists()) { throw new IllegalArgumentException("不是文件"); } BufferedInputStream bis=new BufferedInputStream(new FileInputStream(srcFile)); BufferedOutputStream bos=new BufferedOutputStream(new FileOutputStream(desFile)); int c; while ((c=bis.read())!=1) { bos.write(c); bos.flush();//刷新缓冲区 } bis.close(); bos.close(); } }
package com.imooc.io; import java.io.File; import java.io.IOException; public class IOUtilTest4 { /** * @param args * @throws IOException */ public static void main(String[] args) throws IOException { IOUtil.copyFile(new File("E:\\javaio\\FileUtils.java"), new File("E:\\javaio\\aa.txt")); } }
package com.imooc.io; import java.io.File; import java.io.IOException; public class IOUtilTest4 { /** * @param args * @throws IOException */ public static void main(String[] args) throws IOException { IOUtil.copyFile(new File("E:\\javaio\\FileUtils.java"), new File("E:\\javaio\\aa.txt")); } }
运行结果为:
- 第五章 字符流
字节字符转换流
1.编码问题
2.认识文本和文本文件
Java的文本(char)是16位无符号整数,是字符的unicode编码(双字节编码)
文件是byte byte byte......的数据序列
文本文件是文本(char)序列按照某种编码方案(utf-8,utf-16be,gbk)序列化为byte的存储结果
3.字符流(Reader writer)--->操作的是文本文件
字符的处理,一次处理一个字符
字符的底层任然是基本的字节序列
字符流的基本实现
InputStreamReader 完成byte流解析为char流,按照编码解析
OutputStreamWriter 提供char流到byte流,按照编码处理
package com.imooc.io; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.InputStreamReader; public class Test11 { /** * @param args * @throws Exception */ public static void main(String[] args) throws Exception { FileInputStream in=new FileInputStream("e:\\javaio\\imooc.txt"); InputStreamReader isr=new InputStreamReader(in);//默认项目的编码 /*int c; while ((c=isr.read())!=-1) { System.out.println((char)c); }*/ char[] buffer=new char[8*1024]; int c; //批量读取,放入buffer这个字符数组,从第0个位置开始放置,最多放buffer.length个 //放回的是读到的字符的个数 while ((c=isr.read(buffer,0,buffer.length))!=-1) { String s=new String(buffer,0,c); System.out.println(s); } } }
运行结果:
提醒:imooc.txt必须是 utf-8 不然复制出来的文本文档会出现乱码
package com.imooc.io; import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.InputStreamReader; import java.io.OutputStreamWriter; public class IsrAndOswDemo { /** * @param args */ public static void main(String[] args) throws Exception{ FileInputStream in=new FileInputStream("e:\\javaio\\imooc.txt"); InputStreamReader isr=new InputStreamReader(in,"utf-8");//默认项目的编码 FileOutputStream out=new FileOutputStream("e:\\javaio\\imoocutf81.txt"); OutputStreamWriter osw=new OutputStreamWriter(out,"utf-8"); /*int c; while ((c=isr.read())!=-1) { System.out.println((char)c); }*/ char[] buffer=new char[8*1024]; int c; //批量读取,放入buffer这个字符数组,从第0个位置开始放置,最多放buffer.length个 //放回的是读到的字符的个数 while ((c=isr.read(buffer,0,buffer.length))!=-1) { String s=new String(buffer,0,c); System.out.println(s); osw.write(buffer,0,c); osw.flush(); } isr.close(); osw.close(); } }
运行结果:
字符流之文件读写流
FileReader/FileWriter读写文本文件
package com.imooc.io; import java.io.FileNotFoundException; import java.io.FileReader; import java.io.FileWriter; public class FrAndFwDemo { /** * @param args * @throws FileNotFoundException */ public static void main(String[] args) throws Exception { // TODO Auto-generated method stub FileReader fr=new FileReader("e:\\javaio\\imooc.txt"); FileWriter fw=new FileWriter("e:\\javaio\\imooc2.txt",true);//文件追加内容 char[] buffer=new char[2056]; int c; while ((c=fr.read(buffer,0,buffer.length))!=-1) { fw.write(buffer,0,c); fw.flush(); } fr.close(); fw.close(); } }
运行结果: 复制前的文本文件
复制后的文本文件
字符流的过滤器
字符流的过滤器 bufferedReader --->readLine一次读一行
bufferedWriter/PrintWriter--->写一行
package com.imooc.io; import java.io.BufferedReader; import java.io.BufferedWriter; import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.IOException; import java.io.InputStream; import java.io.InputStreamReader; import java.io.OutputStreamWriter; import java.io.PrintWriter; public class BrAndBwOrPwDemo { public static void main(String[] args) throws Exception{ //对文件进行读写操作 BufferedReader bReader=new BufferedReader( new InputStreamReader( new FileInputStream( "e:\\javaio\\imooc.txt"))); BufferedWriter bufferedWriter=new BufferedWriter( new OutputStreamWriter( new FileOutputStream("e:\\javaio\\imooc3.txt"))); PrintWriter printWriter=new PrintWriter("e:\\javaio\\imooc4.txt"); String line; while ((line=bReader.readLine())!=null) { /*System.out.println(line);//一次读一行,并不能识别换行 bufferedWriter.write(line);//换行操作 //单独写出换行操作 bufferedWriter.flush();*/ printWriter.print(line); printWriter.flush(); } bReader.close(); //bufferedWriter.close(); printWriter.close(); } }
运行结果为:
- 第六章 对象的序列化和反序列化
序列化基本操作
1.对象的序列化,反序列化
(1)对象序列化,就是将Object转换成byte序列,反之叫对象的反序列化
(2)序列化流(ObjectOutputStream),是过滤流----writeObject
反序列化流(ObjectInputStream)----readObject
(3)序列化接口(Serializable)
对象必须实现实例化接口,才能进行序列化,否则将出现异常
这个接口,没有任何方法,只是一个标准
定义Student类:
package com.imooc.io; import java.io.Serializable; public class Student implements Serializable{ private String stuno; private String stuname; private int stuage; public Student(String stuno, String stuname, int stuage) { super(); this.stuno = stuno; this.stuname = stuname; this.stuage = stuage; } public String getStuno() { return stuno; } public void setStuno(String stuno) { this.stuno = stuno; } public String getStuname() { return stuname; } public void setStuname(String stuname) { this.stuname = stuname; } public int getStuage() { return stuage; } public void setStuage(int stuage) { this.stuage = stuage; } @Override public String toString() { return "Student [stuno=" + stuno + ", stuname=" + stuname + ", stuage=" + stuage + "]"; } }
测试:
package com.imooc.io; import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.ObjectInputStream; import java.io.ObjectOutputStream; public class ObjectSeriaDemo1 { public static void main(String[] args) throws Exception { //对象的序列化 ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream("e:\\javaio\\imooc.txt")); Student student=new Student("10001", "小明", 21); oos.writeObject(student); oos.flush(); oos.close(); } }
运行结果为:
package com.imooc.io; import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.ObjectInputStream; import java.io.ObjectOutputStream; public class ObjectSeriaDemo1 { public static void main(String[] args) throws Exception { //对象的序列化 /*ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream("e:\\javaio\\imooc.txt")); Student student=new Student("10001", "小明", 21); oos.writeObject(student); oos.flush(); oos.close();*/ ObjectInputStream ois=new ObjectInputStream(new FileInputStream("e:\\javaio\\imooc.txt")); Student student=(Student) ois.readObject(); System.out.println(student); } }
运行结果为:
transient及ArrayList源码分析
transient关键字
private void writeObject(java.io.ObjectOutputStream s) throws java.io.IOException
private void readObject(java.io.ObjectInputStream s) throws java.io.IOException, ClassNotFoundException
分析ArrayList源码中序列化和反序列化的问题
package com.imooc.io; import java.io.Serializable; import java.util.jar.JarException; public class Student implements Serializable{ private String stuno; private String stuname; private transient int stuage;//该元素不会进行jvm默认的序列化,也可以自己完成这个元素的序列化 public Student(String stuno, String stuname, int stuage) { super(); this.stuno = stuno; this.stuname = stuname; this.stuage = stuage; } public String getStuno() { return stuno; } public void setStuno(String stuno) { this.stuno = stuno; } public String getStuname() { return stuname; } public void setStuname(String stuname) { this.stuname = stuname; } public int getStuage() { return stuage; } public void setStuage(int stuage) { this.stuage = stuage; } @Override public String toString() { return "Student [stuno=" + stuno + ", stuname=" + stuname + ", stuage=" + stuage + "]"; } private void writeObject(java.io.ObjectOutputStream s) throws java.io.IOException{ s.defaultWriteObject();//把jvm能默认序列化的元素进行序列化操作 s.writeInt(stuage);//自己完成stuage的序列化 } private void readObject(java.io.ObjectInputStream s) throws java.io.IOException, ClassNotFoundException{ s.defaultReadObject();//把jvm能默认反序列化的元素进行反序列化操作 this.stuage=s.readInt(); } }
package com.imooc.io; import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.ObjectInputStream; import java.io.ObjectOutputStream; public class ObjectSeriaDemo1 { public static void main(String[] args) throws Exception { //对象的序列化 /*ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream("e:\\javaio\\imooc.txt")); Student student=new Student("10001", "小明", 21); oos.writeObject(student); oos.flush(); oos.close();*/ ObjectInputStream ois=new ObjectInputStream(new FileInputStream("e:\\javaio\\imooc.txt")); Student student=(Student) ois.readObject(); System.out.println(student); } }
序列化运行结果为:
反序列化运行结果为:
序列化中子父类构造数问题
序列化中子类和父类构造函数的调用问题
package com.imooc.io; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.IOException; import java.io.ObjectInputStream; import java.io.ObjectOutputStream; import java.io.Serializable; public class ObjectSeriaDemo2 { public static void main(String[] args) throws Exception { ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream("e:\\javaio\\imooc.txt")); Foo2 foo2=new Foo2(); oos.writeObject(foo2); oos.flush(); oos.close(); } } /*一个类实现了序列化接口,那么其子类都可以进行序列化*/ class Foo implements Serializable{ public Foo(){ System.out.println("foo........"); } } class Foo1 extends Foo{ public Foo1(){ System.out.println("foo1........"); } } class Foo2 extends Foo1{ public Foo2(){ System.out.println("foo2........"); } }
运行结果为:
package com.imooc.io; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.IOException; import java.io.ObjectInputStream; import java.io.ObjectOutputStream; import java.io.Serializable; public class ObjectSeriaDemo2 { public static void main(String[] args) throws Exception { /*ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream("e:\\javaio\\imooc.txt")); Foo2 foo2=new Foo2(); oos.writeObject(foo2); oos.flush(); oos.close();*/ //反序列化是否递归调用父类的构造函数 ObjectInputStream ois=new ObjectInputStream(new FileInputStream("e:\\javaio\\imooc.txt")); Foo2 foo2=(Foo2) ois.readObject(); System.out.println(foo2); ois.close(); } } /*一个类实现了序列化接口,那么其子类都可以进行序列化*/ class Foo implements Serializable{ public Foo(){ System.out.println("foo........"); } } class Foo1 extends Foo{ public Foo1(){ System.out.println("foo1........"); } } class Foo2 extends Foo1{ public Foo2(){ System.out.println("foo2........"); } }
运行结果为:
package com.imooc.io; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.IOException; import java.io.ObjectInputStream; import java.io.ObjectOutputStream; import java.io.Serializable; public class ObjectSeriaDemo2 { public static void main(String[] args) throws Exception { /*ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream("e:\\javaio\\imooc.txt")); Foo2 foo2=new Foo2(); oos.writeObject(foo2); oos.flush(); oos.close();*/ //反序列化是否递归调用父类的构造函数 /*ObjectInputStream ois=new ObjectInputStream(new FileInputStream("e:\\javaio\\imooc.txt")); Foo2 foo2=(Foo2) ois.readObject(); System.out.println(foo2); ois.close();*/ ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream("e:\\javaio\\imooc.txt")); Bar2 bar2=new Bar2(); oos.writeObject(bar2); oos.flush(); oos.close(); } } class Bar { public Bar() { System.out.println("bar"); } } class Bar1 extends Bar implements Serializable{ public Bar1(){ System.out.println("bar1........."); } } class Bar2 extends Bar1{ public Bar2(){ System.out.println("bar2........."); } } /*一个类实现了序列化接口,那么其子类都可以进行序列化*/ /*class Foo implements Serializable{ public Foo(){ System.out.println("foo........"); } } class Foo1 extends Foo{ public Foo1(){ System.out.println("foo1........"); } } class Foo2 extends Foo1{ public Foo2(){ System.out.println("foo2........"); } }*/
运行结果为:
package com.imooc.io; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.IOException; import java.io.ObjectInputStream; import java.io.ObjectOutputStream; import java.io.Serializable; public class ObjectSeriaDemo2 { public static void main(String[] args) throws Exception { /*ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream("e:\\javaio\\imooc.txt")); Foo2 foo2=new Foo2(); oos.writeObject(foo2); oos.flush(); oos.close();*/ //反序列化是否递归调用父类的构造函数 /*ObjectInputStream ois=new ObjectInputStream(new FileInputStream("e:\\javaio\\imooc.txt")); Foo2 foo2=(Foo2) ois.readObject(); System.out.println(foo2); ois.close();*/ /*ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream("e:\\javaio\\imooc.txt")); Bar2 bar2=new Bar2(); oos.writeObject(bar2); oos.flush(); oos.close();*/ ObjectInputStream ois=new ObjectInputStream(new FileInputStream("e:\\javaio\\imooc.txt")); Bar2 bar2=(Bar2) ois.readObject(); System.out.println(bar2); ois.close(); } } /*对子类对象进行反序列化操作时, *如果其父类没有实现序列化接口 *那么其父类的构造函数会被调用 */ class Bar { public Bar() { System.out.println("bar"); } } class Bar1 extends Bar implements Serializable{ public Bar1(){ System.out.println("bar1........."); } } class Bar2 extends Bar1{ public Bar2(){ System.out.println("bar2........."); } } /*一个类实现了序列化接口,那么其子类都可以进行序列化*/ /*class Foo implements Serializable{ public Foo(){ System.out.println("foo........"); } } class Foo1 extends Foo{ public Foo1(){ System.out.println("foo1........"); } } class Foo2 extends Foo1{ public Foo2(){ System.out.println("foo2........"); } }*/
运行结果为: