16.IO流（字节流，字符流，数据流、对象流）
I/O框架
1. IO框架介绍
I：input
O：output
流：
按数据流向划分：输入流、输出流
按处理单元划分：字节流，字符流
2. File类
2.1 File类构造方法
File类提供了用于操作文件和获取文件信息的一系列方法
1.File类的构造方法：
File(String pathname) :
File(File parent, String child): 根据父类路径名与子类路径名字字符串创建新的file实例(便于先处理父类路径)；
File(String parent, String child): 与上式类似
2.2 File类常用方法(增删改查)
1.创建：
createNewFile()
mkdir() 创建文件夹
mkdirs() 创建多级文件夹，用\\或/隔开
renameTo(File dest) 重命名文件或文件夹，如果目标文件与源文件是在同一个路径下，那么renameTo的作用是重命名，如果目标文件与源文件不是在同一个路径下，那么renameTo的作用就是剪切，而且还不能操作文件夹。
注：
separatorChar：目录分隔符
separator包含一个separatorChar，字符串形式。
均是静态，File类直接调用
new File("C:" + File.separator + "a.txt");
2.删除：
delete() 删除文件或一个空文件夹(非空不能删)，有返回值
deleteOnExit() 保证程序异常时创建的临时文件也可以被删除,无返回值，一般用于删除临时文件
3.判断
exists()
isFile()
isDirectory()
isAbsolute() 测试此抽象路径名是否为绝对路径名。
4.获取
getName()
getPath()
getAbsolutePath()
length()
lastModified() 获取最后一次被修改的时间(毫秒值)。
/**
* File类 提供了文件和目录相关的操作的方法
* 位于java.io包
* @author asus
*
*/
public class TestFile {
public static void main(String[] args) {
File file = new File("A");
file.mkdir(); // 创建一个文件夹
File files = new File("B/C/D");
files.mkdirs();
file.delete();
files.delete(); // B 文件夹中有内容 不能删除
File file1 = new File("a.txt"); // 相对路径 相对于我们当前操作的目录而言的路径
File file2 = new File("C:\\Users\\WHD\\Desktop\\test.txt"); // 绝对路径 具体的路径
try {
file1.createNewFile(); // 返回值 true表示创建成功 false表示创建失败
file2.createNewFile();
} catch (IOException e) {
e.printStackTrace();
}
System.out.println("a.txt文件是否存在" + file1.exists());
System.out.println("a.txt文件的相对路径" + file1.getPath());
System.out.println("a.txt文件的绝对路径" + file1.getAbsolutePath());
System.out.println("a.txt文件的大小" + file1.length());
System.out.println("a.txt文件的名称" + file1.getName());
System.out.println("a.txt是否是一个文件" + file1.isFile());
System.out.println("a.txt是否是一个文件夹" + file1.isDirectory());
System.out.println("是否删除成功" + file1.delete());
}
}3.字节流
3.1 FileInputStream
父类abstract InputStream
子类FileInputStream：基于字节的文件输入流
int read()：每次读取一个字节，返回值是读取的内容的ascii码
int read(byte[] datas)： 可以读取指定数组长度的内容，返回值是每次读取的长度，读取的内容存放在数组中，可以使用String类构造方法来封装为字符串 new String(byte[], int offset, int length);
int available(): 可读取的剩余字节数，即容量
/**
* 字节输入流
* read() 每次读取一个字节
* read(byte[] datas) 读取一个byte数组 返回值是读取的长度
* @author asus
*
*/
public class TestFileInputStream3 {
public static void main(String[] args) throws IOException {
File file = new File("a.txt");
file.createNewFile();
FileInputStream fis = new FileInputStream(file);
System.out.println(fis.available());
// byte [] datas = new byte[100];
byte [] datas = new byte[fis.available()];
int dataCount = -1;
while((dataCount = fis.read(datas)) != -1){
// System.out.println(dataCount);
System.out.println(new String(datas, 0, dataCount));
}
}
}3.2 FileOutputStream
父类 abstract OutputStream
void write()：每次写入一个字节
void write(byte[] datas)：写入一个byte数组，可以使用String类的getBytes()方法将字符串转换为byte数组
支持的参数为byte数组和int
flush() ：将内容从缓存中刷新到文件中。close会自动调用。字节流中不是必须的，但字符流必须刷新
close()：关闭资源
/**
* 字节输出流
* @author asus
*
*/
public class TestFileOutPutStream2 {
public static void main(String[] args) {
FileOutputStream fos = null;
try {
fos = new FileOutputStream("c.txt", true);
String str = "床前明月光，疑是地上霜，举头望明月，低头思故乡";
byte [] datas = str.getBytes();
fos.write(97);
fos.write(datas);
fos.flush(); // 将缓存中的内容刷新到文件
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}finally {
if(fos != null) {
try {
fos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}4.字符流
字符流若未关闭资源，必须手动调用flush，否则不会写出资源
4.1输入字符流(3种，含缓冲流Bufferedxxx)
父类：abstract Reader
1.子类FileReader：基于字符的文件输入流
int read()：每次读取一个字符
int read(char[] datas)：每次读取char数组长度的内容，返回值是读取的长度，读取的内容存放在数组中。(若要直接打印，可能出现字节增大，但也可以通过设置数组长度为available避免)，最好的方式是new一个新的String来输出。
2.子类：BufferedReader：基于字符的输入缓冲流
在以上方法的基础上还有：
readLine() ：每次读取一行
close()：关闭资源
3.子类： inputStreamReader：可以指定编码格式的字符输入流
（字节流到字符流的桥梁，BufferedReader创建时需要Reader，InputStreamReader即是Reader的子类，可传它，且InputStreamReader创建时可传字节流） 多态
/**
* 字符读取流 一次读取一个字符 也可以读取一个字符数组
* 字符是16位 unicode编码
* 字节 8位 byte ascii
* @author asus
*/
public class TestFileReader2 {
public static void main(String[] args) {
FileReader fReader = null;
try {
fReader = new FileReader("c.txt");
char [] datas = new char[100];
int dataCount = -1;
while((dataCount = fReader.read(datas)) != -1){
//System.out.println(dataCount);
//System.out.println(datas);//若字符长度设为available即，剩余字节数，可正常打印，
//否则可能打印多余的内容。即最后一次未读满，倒数第二次读的部分内容仍被输出
System.out.println(new String(datas,0,dataCount));
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}finally{
if(fReader != null){
try {
fReader.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}/**
* 带有缓冲流的字符读取流
* 可以读取一个字符 也可以一次读取一行
* readLine()
* @author asus
*
*/
public class TestBufferedReader2 {
public static void main(String[] args) {
FileReader fr = null;
BufferedReader bReader = null;
try {
fr = new FileReader("c.txt");
bReader = new BufferedReader(fr);
int data = -1;
while((data = bReader.read()) != -1){
System.out.println((char)data);
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}finally {
if(bReader != null){
try {
bReader.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if(fr != null){
try {
fr.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
/**
* 乱码出现的原因：
* 编码的方式和解码的方式不一致
* 解决方式：
* 1.统一编码
* 2.可以将出现乱码的内容打散(iso-8859-1) 按照我们自己的编码方式组合
* 常见的编码格式：
* GBK 国标扩展板 简体和繁体
* GB2312 国标版本 只支持简体
* ISO-8859-1 最原始的编码方式 通常用于解决乱码
* UTF-8 unicode万国码 包含世界大多数国家的语言编码
* ANSI 不具体指定某一种编码 因为在不同的操作系统上 表示对应的编码 比如 win10中文版 GBK
* @author asus
*/
public class TestInputStreamReader {
public static void main(String[] args) {
FileInputStream fis = null;
try {
fis = new FileInputStream("testCode.txt");
InputStreamReader isr = new InputStreamReader(fis,"GBK");
char []datas = new char[100];
int dataCount = -1;
while((dataCount = isr.read(datas)) != -1) {
System.out.println(new String(datas,0,dataCount));
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}finally {
// 关闭资源
}
}
}4.2输出字符流(3种，含缓冲流Bufferedxxx)
父类：abstract writer
1.子类：FileWriter
new实例时末尾添加true，表示在文本末尾追加内容
writer() : 每次写入一个字符
write(char [] datas):每次写入一个char数组
write(String str)：每次写入一个字符串
2.子类:BufferedWriter
write()：每次写入一个字符
write(char[] datas)：每次写入一个char数组
write(String str) 每次写入一个字符串，也可设置起始位置
newLine()：换行
3.子类：OutputStreamWriter 可指定编码的字符输出流
（字节流到字符流的桥梁，BufferedWriter创建时需要Writer，OutputStreamWriter即是Writer的子类，可传它，且OutputStreamWriter创建时可传字节流）
write():每次写入一个字符
write(char [] datas):每次写入一个char数组
write(String str)：每次写入一个字符串，也可设置起始位置
/**
* 字符缓冲流写入流
* 可以写入一个字符 或者字符串
* 还可以换行
* newLine()
* @author asus
*
*/
public class TestBufferedWritet {
public static void main(String[] args) {
FileWriter fWriter = null;
BufferedWriter bWriter = null;
try {
fWriter = new FileWriter("e.txt",true);
bWriter = new BufferedWriter(fWriter);
bWriter.write("hello word1");
bWriter.newLine();
bWriter.write("hello world2");
bWriter.flush();//与字节流不同。。。不刷新或关闭资源不显示
} catch (IOException e) {
e.printStackTrace();
}finally {
if(bWriter !=null){
try {
bWriter.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if(fWriter != null){
try {
fWriter.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}/**
* @author asus
*/
public class TestFileWriter {
public static void main(String[] args) {
FileWriter fWriter =null;
try {
fWriter = new FileWriter("d.txt", true);
fWriter.write("hello word2\n");
// 将缓存中的内容刷新到文件
fWriter.flush();//与字节流不同，若为关闭资源，必须刷新内容，否则不显示
} catch (IOException e) {
e.printStackTrace();
}finally{
/*if(fWriter != null){
try {
fWriter.close();
} catch (IOException e) {
e.printStackTrace();
}
}*/
}
}
}public class TestOutputStreamWriter {
public static void main(String[] args) {
FileOutputStream fos;
try {
fos = new FileOutputStream("f.txt");
OutputStreamWriter osw = new OutputStreamWriter(fos);
osw.write("hello world");
osw.flush();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}5.数据流(二进制，依赖并属于字节流)
数据流属于字节流，用于读取二进制文件，比如图片、音频、视频等。。。。。
DataInputStream：基于字节的二进制文件输入流,读入只有byte存
DataOutputStream：基于字节的二进制文件输出流，输出有byte数组，或字符串，或字符多种形式
/**
* DataInputStream 负责读取二进制文件
* DataOutPutStream 负责写入二进制文件
* @author asus
*/
public class TestDataStream {
public static void main(String[] args) {
FileInputStream fis = null;
FileOutputStream fos = null;
DataInputStream dis = null;
DataOutputStream dos = null;
try {
fis = new FileInputStream("D:\\图片.png");
dis = new DataInputStream(fis);
fos = new FileOutputStream("copy2.png");
dos = new DataOutputStream(fos);
byte [] datas = new byte[fis.available()];
int dataCount = -1;
while((dataCount = dis.read(datas)) != -1){
//dos.write(datas, 0, dataCount);
dos.write(datas);
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}finally {
//关闭资源
}
}6.对象流(依赖并属于字节流)
对象流属于字节流，用于输入对象和输出对象
ObjectOutputStream-序列化：将对象以二进制的形式存储在文件中 readObject()
ObjectInputStream-反序列化：将保存有对象的二进制文件读取出来转换为对象 writeObject
序列化要求：被序列化的对象必须实现Serializable接口，此接口是空接口，相当于一个标识，实现此接口的类才可以序列化
/**
* ObjectInputStream 对象输入流
* ObjectOutputStream 对象输出流
* 序列化：将对象写入到文件中
* 反序列化：将存有对象的文件读取出来生成对象
* @author asus
*
*/
public class TestObjectStream {
public static void main(String[] args) {
FileOutputStream fos = null;
ObjectOutputStream oos = null;
FileInputStream fis = null;
ObjectInputStream ois = null;
try {
fos = new FileOutputStream("stu.txt");
oos = new ObjectOutputStream(fos);
Student stu1 = new Student("赵四", 20);
Student stu2 = new Student("广坤", 21);
Student stu3 = new Student("大拿", 22);
oos.writeObject(stu1);
oos.writeObject(stu2);
oos.writeObject(stu3);
fis = new FileInputStream("stu.txt");
ois = new ObjectInputStream(fis);
while(fis.available() > 0){
Object obj = ois.readObject();
if(obj instanceof Student){
Student stuRead = (Student) obj;
System.out.println(stuRead);
}
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}finally{
//关闭资源
}
}/**
* Serializeable 空接口 相当于一个标识 标识此接口的类才能被序列化化
* @author asus
*/
public class Student implements Serializable{
private String name;
private int age;
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 Student(String name, int age) {
super();
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "Student [name=" + name + ", age=" + age + "]";
}
}每日问题
1.判断是否是文件
2.判断是否是目录
3.判断是否存在
4.删除文件的方法
5.文件的相对路径
6.文件的绝对路径
7.FileInputStream是什么流？
8.字节写入流是哪个对象？
9.字节流写入的方法是什么，支持参数是什么？
10.FileInputStream如何使每次读取两个字节
11.读取图片应该使用什么对象？
12.BufferedReader独有的读取文件的方法是什么
13.什么是序列化，什么是反序列化，序列化的对象有什么要求
14.实现序列化的步骤是什么
15.写入对象使用哪个对象的哪个方法
16.读取一个对象是什么方法
解答：
1.判断是否是文件 isFile();
2.判断是否是目录 isDirectory();
3.判断是否存在 exists()
4.删除文件的方法 delete();
5.文件的相对路径 getPath();
6.文件的绝对路径 getAbsolutePath();
7.FileInputStream是什么流？ 字节读取流
8.字节写入流是哪个对象？ FileOutputStream
9.字节流写入的方法是什么，支持参数是什么？
write(); byte数组 int num 显示对应的ascii
10.FileInputStream如何使每次读取两个字节
byte [] datas = new byte[2]; read(byte[] datas); 返回值是每次读取的长度，内容存放在datas数组中
11.读取图片应该使用什么对象？ DataInputStream
12.BufferedReader独有的读取文件的方法是什么 readLine();
13.什么是序列化，什么是反序列化，序列化的对象有什么要求
将对象以二进制的形式存储在 文件中 将存储有对象的二进制文件读取出来转化为对象 实现Serializable
14.实现序列化的步骤是什么
先实现Serializable接口，然后使用ObjectOutputStream写入对象，再使用 ObjectInputStream读取对象 15.写入对象使用哪个对象的哪个方法 使用ObjectOutputStream写入对象，writeObject()
16.读取一个对象是什么方法 readObject();
上一篇： Mybatis入门学习笔记1
下一篇： 反射-通过反射来调用方法