主要内容
- File类的使用
- 字节流
- 字符流
- 对象的序列化和反序列化
输出流：
将数据写入到输出设备当中
输入流 ：
从输入设备当中读取数据，将数据读取到程序当中
File类
什么是文件？
文件可认为是相关记录或放在一起的数据的集合
在java中，使用java,io.File类对文件进行操作。
File相关方法：
创建目录、创建文件的简单使用
package com.demo.day10.file;
import java.io.File;
import java.io.IOException;
public class FileDemo {
public static void main(String[] args) {
// 创建File对象
//File file=new File("/Users/mac/Documents/java/demo/aa.txt");
//File file=new File("/Users/mac/Documents/java","demo/aa.txt");
File file=new File("/Users/mac/Documents/java");
File file1=new File(file,"demo/aa.txt");
//判断是文件还是目录
System.out.println("是否是目录"+file1.isDirectory());
System.out.println("是否是文件"+file1.isFile());
//创建目录
//File file2=new File("/Users/mac/Documents/java","demo2");
File file2=new File("/Users/mac/Documents/java","demo3/demo3_3");
if(!file2.exists()) {//判断demo2是否存在
//file2.mkdir();//创建demo2目录
file2.mkdirs();//创建多级目录, demo3/demo3_3
}
//创建文件
File file3=new File("/Users/mac/Documents/java","demo2/bb.txt");
if(!file3.exists()) {
try {
file3.createNewFile();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}字节流
- 字节输入流InputStream
- 字节输出流OutpunStream
FileInputStream
- 从系统中的某个文件中获得输入字符
- 用于读取诸如图像数据之类的原始字节流
常用方法：
| 方法名 | 描述 |
| public int read() | 从输入流中读取一个数据字节 |
| public int read(byte[] b) | 从输入流中将最大b.length个字节的数据读入一个byte数组中 |
| public int read(byte[] b，int off,int len) | 从输入流中将最大len个字节的数据读入byte数组中 |
| public void close() | 关闭此文件输入流并释放与此流有关的额所以系统资源 |
如果返回值为-1.则表示已经到达文件的末尾。
常用方法使用案例：
package com.demo.day10.file;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
/*
* aa.txt
* 里面的内容是 Hello,World!
*/
public class FileInputStreamDemo {
public static void main(String[] args) {
// 创建一个FileInputStream的对象
try {
FileInputStream fis=new FileInputStream("/Users/mac/Documents/java/demo/aa.txt");//绝对路径
// int n=fis.read();//读取aa.txt文件的一个字节的数据
// System.out.println((char)n);//输出H
int n;
//循环读取文件的数据
while((n=fis.read())!=-1) {//当读取返回值是-1说明是到末尾了
System.out.print((char)n);//输出H
}
fis.close();//关闭输入流
System.out.println("\n=====下面是read(b,off,len)的使用====");
FileInputStream fis2=new FileInputStream("/Users/mac/Documents/java/demo/aa.txt");//绝对路径
byte[] b=new byte[100];
//fis2.read(b);
fis2.read(b, 0, 5);//偏移量，从第0个开始读，长度为5
System.out.println(new String (b));//将字节数组转字符串对象输出
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}输出结果：
Hello,World!
=====下面是read(b,off,len)的使用====
Hello
FileOutputStream
文件输出流
常用方法：
| 方法名 | 描述 |
| public int write() | 从输入流中读取一个数据字节 |
| public int write(byte[] b) | 从输入流中将最大b.length个字节的数据读入一个byte数组中 |
| public int write(byte[] b，int off,int len) | 从输入流中将最大len个字节的数据读入byte数组中 |
| public void close() | 关闭此文件输入流并释放与此流有关的额所以系统资源 |
字符的添加、图片拷贝简单实现：
package com.demo.day10.file;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
public class FileOutputStreamDemo {
public static void main(String[] args) {
//创建一个FileOutputStream对象
try {
//文件输出流
FileOutputStream fos=new FileOutputStream("/Users/mac/Documents/java/demo/aa.txt");
//文件输入流
FileInputStream fis=new FileInputStream("/Users/mac/Documents/java/demo/aa.txt");
//照片拷贝
//文件输出流
FileOutputStream fos1=new FileOutputStream("/Users/mac/Documents/java/demo/pigcopy.jpg");
//文件输入流
FileInputStream fis1=new FileInputStream("/Users/mac/Documents/java/demo/pig.jpg");
try {
//文字读写
fos.write(50);
fos.write('a');
int n;
while((n=fis.read())!=-1) {
System.out.print((char)n);
}
// System.out.println(fis.read());
// System.out.println((char)fis.read());
fos.close();
fis.close();
//图片拷贝 是个读写过程
byte[] b=new byte[1024];
int n1;
while((n1=fis1.read(b))!=-1)//从11.jpg中读取数据放到数组b中
{
fos1.write(b,0,n1);
}
fos1.close();
fis1.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
字节缓冲流
- 缓冲输入流BufferedInputStream
- 缓冲输出流BufferedOuputStream
为什么要用缓冲流
- 文件读写，从硬盘中读取数据，读写速度较慢
- 缓冲流是从内存中读取数据 ，可以提供读写速度。
- 与文件输入输出流进行结合使用
- 其过程就是：在文件读写的基础上再嫁接一个缓冲流，执行缓冲读写后，数据会放到一个指定大小的缓冲区内。如果缓冲区满了，则自动写到文档里面显示；如果没满，要调用flush()方法：刷新释放缓冲区的资源。
package com.demo.day10.file;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
public class BufferedDemo {
public static void main(String[] args) {
try {
// 创建FilesInputStream的对象 输入流
FileInputStream fis=new FileInputStream("/Users/mac/Documents/java/demo/aa.txt");
// 创建FilesOutputStream的对象 输出流
FileOutputStream fos=new FileOutputStream("/Users/mac/Documents/java/demo/aa.txt");
// 创建BufferedInputStream的对象 输入流
BufferedInputStream bis=new BufferedInputStream(fis);
// 创建BufferedInputStream的对象 输出流
BufferedOutputStream bos=new BufferedOutputStream(fos);
try {
//输出流写操作 //写入数据到目标
bos.write('a');
bos.write(50);
bos.flush();//刷新释放缓冲区资源，如果缓冲器没满则释放
bos.close();
long startTime=System.currentTimeMillis();//获取系统时间
//输入流读操作：从输入设备中读取数据
System.out.println((char)bis.read());
System.out.println(bis.read());
bis.close();
long endTime=System.currentTimeMillis();
System.out.println(endTime-startTime);
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}输出：
a
50
1
字符字节转换流
用于处理字节流和字符流直接的转换
- InputStreamReader
- OutputStreamReader
字符流缓冲区
- BufferReader
- BufferWriter
package com.demo.day10.file;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
public class InputStreamReaderDemp {
public static void main(String[] args) {
// 创建一个FileInputStream的对象
try {
//字节输入流
FileInputStream fis=new FileInputStream("/Users/mac/Documents/java/demo/abc.txt");
InputStreamReader isr=new InputStreamReader(fis);
BufferedReader br=new BufferedReader(isr);//字符读缓冲输入流
FileOutputStream fos=new FileOutputStream("/Users/mac/Documents/java/demo/abc_copy.txt");
OutputStreamWriter osr=new OutputStreamWriter(fos);
BufferedWriter bw=new BufferedWriter(osr);//字符读缓冲输出流
char[] b=new char[10];
int n=0;
// while((n=isr.read(b))!=-1) {
// System.out.print((char)n);
// }
//方法二
// while((n=isr.read(b))!=-1) {
// String s=new String(b,0,n);
// System.out.print(s);
// }
//写入到新的文件当中
while((n=isr.read(b))!=-1) {
osr.write(b,0,n);
osr.flush();
}
fis.close();
fos.close();
isr.close();
osr.close();
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
对象序列化与反序列化
- 序列化：把java对象转换为字节序列的过程
- 反序列化：吧字节序列恢复为java对象的过程
对象输入流ObjectInputStream
对象输出流ObjectOut'putStream
步骤：
- -创建一个类，继承Serializable接口
- -创建对象
- -将对象写入文件
- -从文件读取对象信息
Goods.java
package com.demo.day10.file;
import java.io.Serializable;
/*
* 分析商品信息类
* 属性：
* -商品编号:id
* -商品名称:name
* -商品价格：price
* 方法：
* -构造方法
* -获取和设置属性值的方法
* -其他方法
*/
public class Goods implements Serializable{
private String goodsId;
private String goodsName;
private double goodsPrice;
public Goods(String goodsId,String goodsName,double goodsPrice) {
this.setGoodsId(goodsId);
this.setGoodsName(goodsName);
this.setGoodsPrice(goodsPrice);
}
public String getGoodsId() {
return goodsId;
}
public void setGoodsId(String goodsId) {
this.goodsId = goodsId;
}
public String getGoodsName() {
return goodsName;
}
public void setGoodsName(String goodsName) {
this.goodsName = goodsName;
}
public double getGoodsPrice() {
return goodsPrice;
}
public void setGoodsPrice(double goodsPrice) {
this.goodsPrice = goodsPrice;
}
//toString方法
public String toString() {
String str="商品编号:"+goodsId+" "+"商品名称:"+goodsName+" "+"商品价格:"+goodsPrice;
return str;
}
public static void main(String[] args) {
// TODO Auto-generated method stub
}
}GoodTest.java
package com.demo.day10.file;
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 GoodsTest {
public static void main(String[] args) {
Goods goods1=new Goods("s001","电脑",3000);
try {
//创建一个goods.txt文件
File file= new File("/Users/mac/Documents/java/demo/goods.txt");
if(!file.exists()) {//如果goods.txt不存在
try {
file.createNewFile();//创建这个文件
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
// 创建一个字符输出流对象写入数据
FileOutputStream fos=new FileOutputStream(file);
// 创建一个字符输入流对象读取数据
FileInputStream fis=new FileInputStream(file);
try {
ObjectOutputStream oos=new ObjectOutputStream(fos);
ObjectInputStream ois=new ObjectInputStream(fis);
oos.writeObject(goods1);
Goods goods2=(Goods)ois.readObject();
System.out.println(goods2);
oos.flush();
oos.close();
ois.close();
fis.close();
fos.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}