java学习笔记--IO流

第十二章大纲：
I/O input/output 输入/输出
一、创建文件，借助File类来实现
file.createNewFile() ：创建文件
file.exists() ：判断文件是否存在，如果存在，则返回true
delete() ：删除文件，如果删除成功，则返回true
deleteOnExit() ：程序退出的时候才删除文件

 1 import java.io.File;
 2 import java.io.IOException;
 3 
 4 public class FileDemo {
 5     
 6     public static void main(String[] args) throws IOException {
 7         File file = new File("D:\123.txt");
 8         //判断文件是否存在
 9         if(!file.exists()){
10             //文件不存在，创建该文件
11             file.createNewFile();
12         }
13         
14     }
15 }

二、创建文件夹
exists() ：判断文件夹是否存在，如果存在，则返回true
delete() ：删除文件夹，如果删除成功，则返回true
mkdir() ：创建文件夹
mkdirs() ：创建嵌套的文件夹

 1 import java.io.File;
 2 import java.io.IOException;
 3 
 4 public class FileDemo {
 5     
 6     public static void main(String[] args) throws IOException {
 7         File file = new File("D:\test");
 8         //判断文件是否存在
 9         if(!file.exists()){
10             //文件不存在，创建该文件
11             file.mkdir();
12         }
13         
14         //多个文件夹嵌套时，使用mkdirs()方法创建文件
15         File file2 = new File("D:\test2\demo");
16         //判断文件是否存在
17         if(!file2.exists()){
18             //文件不存在，创建该文件
19             file2.mkdirs();
20         }
21         
22     }
23 }

三、
输入还是输出参照物是内存。我们的程序是在内存运行的
输入：d:\720.txt--->内存
输出：内存---->f:\721.txt

字节流和字符流，都可以实现文本的输入输出，区别是读写单位（速度）不一样
字节流：每次读写一个字节 1Byte=8bit 2^8-1 可以表示255个字符
字符流：每次读写一个字符 1字符=2字节常见汉字5000多 2^16

节点流和过滤流都是对字节流和字符流做了封装，好处是读写速度更快。
1.字节流： FileInputStream 和 FileOutputStream
FileInputStream
read() ：每次都一个字节，返回值是int,如果读到头，返回值是-1 想要读完文本中的数据，要用循环
available() ：返回可读的字节数，返回值是int
close() ：关闭输入流，释放资源

FileOutputStream
write() ：向指定文件写数据
close() ：关闭输出流

把720.txt文本中的内容输入到721.txt文本中去

 1 import java.io.File;
 2 import java.io.FileInputStream;
 3 import java.io.FileNotFoundException;
 4 import java.io.FileOutputStream;
 5 import java.io.IOException;
 6 
 7 /**
 8  * 字节流演示
 9  * @author Administrator
10  *
11  */
12 public class FileInputDemo {
13 
14     public static void main(String[] args) throws IOException {
15         
16         //打开字节输入流
17         FileInputStream fis = new FileInputStream(new File("D:\720.txt"));
18         //打开字节输出流
19         FileOutputStream fos = new FileOutputStream(new File("D:\721.txt"));
20         //获取字节长度
21         int length = fis.available();
22         for(int i =0 ; i < length ; i++){
23             //把从720.txt读取的字节输出到721.txt中
24             fos.write(fis.read());
25         }
26         
27         //关闭输入输出流
28         fis.close();
29         fos.close();
30         
31     }
32     
33 }

2.字符流：FileReader FileWriter

FileReader
read() ：读参数可以是char数组，存放读到内存中的数据
close() ：关闭资源

FileWriter
write() ：写参数可以是char数组，也可以是String
close() ：关闭资源

 1 import java.io.File;
 2 import java.io.FileNotFoundException;
 3 import java.io.FileReader;
 4 import java.io.FileWriter;
 5 import java.io.IOException;
 6 
 7 public class FileReaderDemo {
 8 
 9     public static void main(String[] args) throws IOException {
10 
11         FileReader fr = new FileReader(new File("D:\720.txt"));
12         FileWriter fw = new FileWriter(new File("D:\721.txt"));
13         char[] ch = new char[1024];
14         int i=0;
15         String s="";
16         while((i=fr.read())!=-1){
17             //把int类型的 i ，强转为char类型
18             s=s+(char)i;
19         }
20         
21         //把取出的内容写入到721.txt中
22         fw.write(s);
23         fr.close();
24         fw.close();
25     }
26 
27 }

从流向分
输入流 FileInputStream FileReader
输出流 FileOutputStream FileWriter
从读写单位
字节流 FileInputStream FileOutputStream
字符流 FileReader FileWriter

补充：过滤流：给节点流做封装，提供缓冲区，读写速度会更快
BufferedReader
readLine() ：每次读取一行
BufferedWriter
write() ：写
newLine() ：换行

 1 import java.io.*;
 2 public class BufferedDemo {
 3 
 4     public static void main(String[] args) throws IOException {
 5         BufferedReader bfr = new BufferedReader(new FileReader(new File("D:\720.txt")));
 6         BufferedWriter bfw = new BufferedWriter(new FileWriter(new File("D:\721.txt")));
 7         //每次读取一行
 8         String str = bfr.readLine();
 9         String ss = str;
10         while(str!=null){
11             System.out.println(str);
12             str = bfr.readLine();
13             
14             //每拼接一次要换行，换行符也可以写成
15             //ss= ss+System.getProperty("line.separator")+str;
16             ss = ss + "
" + str;
17         }
18         bfw.write(ss);
19         bfr.close();
20         bfw.close();
21         
22     }
23     
24 }

补充：序列化(Serializable)和反序列化读写对象读对象就是反序列化写对象就是序列化
一个对象想要被序列化，必须实现一个接口：Serializable
ObjectOutputStream
writeObject(obj) ：把对象obj作为整体以二进制流的形式写到指定文本中

ObjectInputStream
readObject() ：把文本中的二进制对象读入内存

问：当我们要保存多个对象的时候怎么办？可以多次调用writeObject()实现写，但是读的时候就麻烦了，我们可以把对象放到一个数组中，对数组执行序列化和反序列化操作

 1 import java.io.Serializable;
 2 /**
 3  * 创建一个学生类，实现Serializable接口
 4  * @author Administrator
 5  *
 6  */
 7 public class Student implements Serializable{
 8 
 9     public String name;
10     public String sex;
11     
12 }

如果学生类没有实现Serializable接口，会报错java.io.NotSerializableException

对学生对象序列化后，会在磁盘中保存一个二进制文件

 1 import java.io.*;
 2 
 3 /**
 4  * 序列化类
 5  * @author Administrator
 6  *
 7  */
 8 public class XuLieDemo {
 9 
10     public static void main(String[] args) throws  IOException {
11         
12         ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(new File("D:\123.txt")));
13         //声明一个学生类型是数组，把实例化的学生对象存入数组中
14         Student[] stu = {new Student("张三","男"),new Student("丽丽","女")};
15         //对学生类型的数组序列化
16         oos.writeObject(stu);
17         oos.close();
18         
19     }
20     
21 }

反序列化操作

 1 import java.io.*;
 2 
 3 /**
 4  * 反序列化类
 5  * @author Administrator
 6  *
 7  */
 8 public class FanXuLieDemo {
 9 
10     public static void main(String[] args) throws IOException, ClassNotFoundException {
11 
12         ObjectInputStream ois = new ObjectInputStream(new FileInputStream(new File("D:\123.txt")));
13         Student[] stu = (Student[]) ois.readObject();
14         for (Student student : stu) {
15             System.out.println(student.name+"  "+student.sex);
16         }
17         ois.close();
18         
19     }
20 
21 }