java将文件反序列化_十五、Java中的16个流、序列化和反序列化、File类

FileInputStream

FileOutputStream

FileReader

FileWriter

BufferedInputStream

BufferedOutputStream

BufferReader

BufferWriter

InputStreamReader

OutputStreamWriter

PrintStream

PrintWriter

DateInputStream

DateOutputStream这两个流比较专业，他们有点特殊，特殊在可以直接将byte类型写进去，不是写进去一个字符串，而是带着格式写进去的，将来你读的时候就带着格式出来了。

ObjectOutputStream

ObjectInputStream

1、字节流和字符流、输入流和输出流

1)字节流和字符流：文件通常是由一连串的字节或字符构成，组成文件的字节序列称为字节流，组成文件的字符序列称为字符流；

2)输入流和输出流： java中根据流的方向可以分为输入流和输出流，输入流是将文件或是其他输入设备的数据加载到内存的过程:输出流恰恰相反，是将内存中的数据保存到文件或是其他输出设备。文件由字字符或字节组成，那么将文件加载到内存或再将文件输出到文件，需要有输入和输出流的支持。

2、流分为四大家族：(InputStream，OutputStream，Reader、Writer)

虚线表示：实现       实线表示：继承

1)InputStream、OutputStream分别表示字节输入流和输出流

2)Reader和Writer：分别表示字符输入流和输出流

|FileInputStream|：

用于读取诸如图像数据之类的原始字节流，要读取字符流，建议何使用FileReader

|一次读取一个字节|

import java.io.FileInputStream;

import java.io.FileNotFoundException;

import java.io.IOException;

public class FileInputStreamTest02 {

public static void main(String[] args) {

/*文件里面有数据，我们通过流去访问这个文件，这个文件在硬盘上存储

*那我们这个流去频繁的访问这个硬盘，对于硬盘有伤害，升级上述循环里面，读取一次返回一个针。

*可以通过一次读取多个来减少对硬盘的伤害

*/

String filePath="src/数据类型和封装性和String类/zhangjunbo.txt";

FileInputStream fis=null;

try {

fis=new FileInputStream(filePath);

int temp=0;

try {

while((temp=fis.read()) !=-1){

System.out.println(temp);

}

} catch (IOException e) {

e.printStackTrace();

}

} catch (FileNotFoundException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}finally{

try {

fis.close();

} catch (IOException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

}

}

}

|一次读取多个字节|

读取之前先在内存中准备一个byte类型的数组，每次读取多个字节存储到byte数组中

即一次读取多个字节，而不是单字节读取。提高了效率，并且这个byte[] 就相当于我们内存中的缓存。

文件中内容为：abcdefg

import java.io.FileInputStream;

import java.io.FileNotFoundException;

import java.io.IOException;

public class FileInputStreamTest03 {

public static void main(String[] args) throws Exception {

String filePath="src/数据类型和封装性和String类/zhangjunbo.txt";

FileInputStream fis=new FileInputStream(filePath);

byte[] bytes=new byte[3];

fis.read(bytes);//其返回的是：往bytes数组中写入的字节的数量大小

System.out.println(new String(bytes));//abc

//通过使用平台的默认字符集解码指定的 byte 数组，构造一个新的 String

fis.read(bytes);

System.out.println(new String(bytes));//def

fis.read(bytes);

System.out.println(new String(bytes));//gef

//第三次read()方法的时候只读取了g，用g把d给覆盖掉了，但是后面的fg依然在，所以低三次读取的是

fis.close();

}

}

|一次读取多个字节并通过循环进行输出显示|

import java.io.FileInputStream;

import java.io.FileNotFoundException;

public class FileInputStreamTest04 {

public static void main(String[] args) throws Exception {

String filePath="src/数据类型和封装性和String类/zhangjunbo.txt";

FileInputStream fis=new FileInputStream(filePath);

System.out.println(fis.available());//返回流程剩余的估计字节数

byte[] bytes=new byte[100];

while(fis.read(bytes)!=-1){

System.out.println(fis.available());

fis.skip(10);//跳过n个字节数不读取

System.out.println(new String(bytes));

}

}

}

|FileOutputStream|

--将字符串写入到指定的文件夹中

import java.io.FileNotFoundException;

import java.io.FileOutputStream;

import java.io.IOException;

public class FileOutputStreamTest01 {

public static void main(String[] args) throws FileNotFoundException {

String path="src/数据类型和封装性和String类/练习.txt";

FileOutputStream fos=new FileOutputStream(path);

//getBytes()使用平台的默认字符集将此 String 编码为 byte 序列，并将结果存储到一个新的 byte 数组中

String message="你就是个大坏蛋";

byte[] bytes=message.getBytes();

try {

//fos.write(bytes);将byte数组全部写入

//将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此文件输出流

fos.write(bytes, 0, 2);

} catch (IOException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}finally{

if(fos!=null){

try {

fos.close();

} catch (IOException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

}

}

}

}

-- 一边读一边写

import java.io.FileInputStream;

import java.io.FileOutputStream;

public class FileOutputStreamTest02 {

public static void main(String[] args) throws Exception{

String filePath="src/数据类型和封装性和String类/zhangjunbo.txt";

FileInputStream fis=new FileInputStream(filePath);

String path="src/数据类型和封装性和String类/练习.txt";

FileOutputStream fos=new FileOutputStream(path);

byte[] bytes=new byte[1];//要是读取的是汉子，那么会出现乱码，因为汉子是两个字节，而每次读取的是一个字节。写入的也是一个字节

fis.read(bytes);

while(fis.read(bytes)!=-1){

fos.write(bytes);

}

}

}

|FileWriter|字符输入和输出流

输出

import java.io.FileWriter;

import java.io.IOException;

public class FileWriterTest01 {

public static void main(String[] args) throws IOException {

String path="D:/eclipse_project/javaPractise/src/数据类型和封装性和String类/练习.txt";

FileWriter fwFileWriter=new FileWriter(path);

String contextString="你就是个十足的傻子";

fwFileWriter.write(contextString);

char[] chares={'而','我','是','聪','人',','};

fwFileWriter.write(chares, 0, 6);

fwFileWriter.flush();

fwFileWriter.close();

}

}

边输入边输出

import java.io.FileNotFoundException;

import java.io.FileReader;

import java.io.FileWriter;

public class FileWriterTest02 {

public static void main(String[] args) throws Exception {

String filePath="src/数据类型和封装性和String类/zhangjunbo.txt";

FileReader fReader=new FileReader(filePath);

String path="D:/eclipse_project/javaPractise/src/数据类型和封装性和String类/练习.txt";

FileWriter fWrite=new FileWriter(path);

char[] chars=new char[3];

while(fReader.read(chars)!=-1){

fWrite.write(chars);

}

fReader.close();

fWrite.flush();

fWrite.close();

}

}

|用户接受键盘的输入方法一：Scanner|

import java.util.Scanner;

public class ScannerTest01 {

public static void main(String[] args) {

Scanner scanner=new Scanner(System.in);

String string=scanner.next();

System.out.println(string);

}

}

|用户接受键盘的输入方法二：BufferedReader|

import java.io.BufferedReader;

import java.io.InputStreamReader;

public class BufferedReaderTest02 {

public static void main(String[] args) throws Exception {

//BufferedReader构造方法中参数时一个Reader

//而System.in 返回的是一个InputStream

//InputStreamReader() 将输入流转化为Reader

BufferedReader br=new BufferedReader(new InputStreamReader(System.in));

String context=br.readLine();

System.out.println(context);

}

}

|用BufferedReader和BufferedWriter一边读一边写|

import java.io.BufferedReader;

import java.io.BufferedWriter;

import java.io.FileReader;

import java.io.FileWriter;

import java.io.IOException;

public class BufferedWriterTest02 {

public static void main(String[] args) throws IOException{

String filePath="src/数据类型和封装性和String类/zhangjunbo.txt";

String pathString="D:/eclipse_project/javaPractise/src/数据类型和封装性和String类/练习.txt";

BufferedReader bReader=new BufferedReader(new FileReader(filePath));;

BufferedWriter bWriter=new BufferedWriter(new FileWriter(pathString));

String temp=null;

while((temp=bReader.readLine()) != null){

bWriter.write(temp);

bWriter.newLine();

}

bWriter.flush();

bReader.close();

bWriter.close();

}

}

|DataInputStream和DataOutPutStream用法|

import java.io.DataOutputStream;

import java.io.FileNotFoundException;

import java.io.FileOutputStream;

import java.io.IOException;

public class DataOutputStreamTest {

public static void main(String[] args) throws FileNotFoundException,IOException {

String pathString="D:/eclipse_project/javaPractise/src/数据类型和封装性和String类/练习.txt";

DataOutputStream dos=new DataOutputStream(new FileOutputStream(pathString));

int a=100;

byte b=10;

double d=10.0;

boolean flag=false;

long l=1000L;

char c='中';

short s=11;

dos.write(a);

dos.write(b);

dos.writeDouble(d);

dos.writeBoolean(flag);

dos.writeLong(l);

dos.writeChar(c);

dos.writeShort(s);

dos.flush();

dos.close();

//上述的代码执行完以后会往练习.txt文件中插入一个二进制文件

}

}

import java.io.DataInputStream;

import java.io.FileInputStream;

import java.io.FileNotFoundException;

import java.io.IOException;

public class DataInputStreamTest01 {

public static void main(String[] args) throws FileNotFoundException,IOException {

String pathString="D:/eclipse_project/javaPractise/src/数据类型和封装性和String类/练习.txt";

DataInputStream dis=new DataInputStream(new FileInputStream(pathString));

//如下为读取二进制文件：

int i=dis.read();

byte b=dis.readByte();

double d=dis.readDouble();

boolean bo=dis.readBoolean();

long l=dis.readLong();

short s=dis.readShort();

System.out.println(b);

System.out.println(i);

System.out.println(d);

System.out.println(bo);

System.out.println(l);

System.out.println(s);

}

}

|PrintStream和PrintWrite|

import java.io.FileNotFoundException;

import java.io.FileOutputStream;

import java.io.PrintStream;

import java.text.SimpleDateFormat;

import java.util.Date;

public class PrintStreamTest01 {

public static void main(String[] args) throws FileNotFoundException {

PrintStream ps=System.out;

ps.println("java");//默认是输出到控制台的

String path="D:/eclipse_project/javaPractise/src/数据类型和封装性和String类/练习3.txt";

System.setOut(new PrintStream(new FileOutputStream(path)));

System.out.println("haha");//此时就不会在控制台输出了，而会输出到  练习3.txt  文件中

SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS");

m1();

System.out.println("m1方法执行的时间是"+sdf.format(new Date()));

}

public static void m1(){

System.out.println("m1方法执行");

}

}

|ObjectOutputStream和ObjectInputStream|序列化和反序列化

1)序列化：对象从内存到硬盘的这个过程叫做序列化；

2)反序列化：对象从硬盘到内存的这个过程叫做反序列化；

备注：比如说一个内存或者说是java虚拟机，在堆里面有java对象，堆里面的java对象计算机一关这个对象就没有了。我们为了保障这个对象的状态，直接把这个对象存到硬盘上面，硬盘上面有一个文件我们可以考虑将对象直接放入到文件中去。这个过程叫做序列化。

3)编译：把java文件变成class文件的过程叫做编译的过程；

4)反编译：把class文件变成java文件的过程叫做反编译的过程，反编译生成的class文件和原来java文件和源文件肯定是有一定的区别；

3、File类

File类： 是文件和目录路径名的抽象表示形式，与流无关，不能通过该类完成文件的读和写。

D:\zhangsan\File     　　　　　　此种的File表示目录

D:\zhangsan\File\Test01.java    此种的File是一个文件

|创建目录和文件|

import java.io.File;

import java.io.IOException;

public class FileTest01 {

public static void main(String[] args) throws IOException {

File file=new File("D:/eclipse_project/javaPractise/src/数据类型和封装性和String类/lianda");

System.out.println(file.exists());

if(!file.exists()){

file.mkdir();//创建目录

file.createNewFile();//创建文件

}

}

}

|是目录还是文件以及文件的遍历|

import java.io.File;

import java.text.SimpleDateFormat;

import java.util.Date;

public class FileTest02 {

public static void main(String[] args) {

File file=new File("D:/eclipse_project/javaPractise/src/数据类型和封装性和String类/lianda");

//获取绝对路径

String path=file.getAbsolutePath();

System.out.println(path);

//获取父路径

System.out.println(file.getParent());

//判断是否是目录

boolean b=file.isDirectory();

System.out.println(b);

//判断是否是文件

boolean b2=file.isFile();

System.out.println(b2);

//文件最后一次被修改的时间

Date date=new Date(file.lastModified());

SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:SS sss");

System.out.println(sdf.format(date));

//列出子文件：

File file2=new File("D:/eclipse_project/javaPractise/src/数据类型和封装性和String类");

File[] files=file2.listFiles();

for(File f:files){

System.out.println(f.getAbsolutePath());

//如何只输出后缀是.java的文件名呢？

if(f.getAbsolutePath().endsWith(".java")){

System.out.println(f.getAbsolutePath());

}

}

}

}

|查找某个目录下面的所有子文件|

import java.io.File;

public class FileTest03 {

public static void main(String[] args) {

File file=new File("D:/eclipse_project/javaPractise/src");

method(file);

}

public static void method(File f){

if(f.isFile()){

return;

}

File[] fs=f.listFiles();

for(File subf:fs){

System.out.println(subf.getAbsolutePath());

method(subf);

}

}

}