首页 > 代码库 > 文件传输基础——Java IO流
文件传输基础——Java IO流
- 第一章 文件的编码
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........");
}
}*/
运行结果为：
文件传输基础——Java IO流
声明：以上内容来自用户投稿及互联网公开渠道收集整理发布，本网站不拥有所有权，未作人工编辑处理，也不承担相关法律责任，若内容有误或涉及侵权可进行投诉： 投诉/举报 工作人员会在5个工作日内联系你，一经查实，本站将立刻删除涉嫌侵权内容。