java io教学文件_java学习笔记--IO流

第十二章大纲：

I/O input/output 输入/输出

一、创建文件，借助File类来实现

file.createNewFile() ： 创建文件

file.exists() ： 判断文件是否存在，如果存在，则返回true

delete() ： 删除文件，如果删除成功，则返回true

deleteOnExit() ： 程序退出的时候才删除文件

1 importjava.io.File;2 importjava.io.IOException;3

4 public classFileDemo {5

6 public static void main(String[] args) throwsIOException {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 importjava.io.File;2 importjava.io.IOException;3

4 public classFileDemo {5

6 public static void main(String[] args) throwsIOException {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 importjava.io.File;2 importjava.io.FileInputStream;3 importjava.io.FileNotFoundException;4 importjava.io.FileOutputStream;5 importjava.io.IOException;6

7 /**

8 * 字节流演示9 *@authorAdministrator10 *11 */

12 public classFileInputDemo {13

14 public static void main(String[] args) throwsIOException {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 importjava.io.File;2 importjava.io.FileNotFoundException;3 importjava.io.FileReader;4 importjava.io.FileWriter;5 importjava.io.IOException;6

7 public classFileReaderDemo {8

9 public static void main(String[] args) throwsIOException {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 classBufferedDemo {3

4 public static void main(String[] args) throwsIOException {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 + "\r\n" +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 importjava.io.Serializable;2 /**

3 * 创建一个学生类，实现Serializable接口4 *@authorAdministrator5 *6 */

7 public class Student implementsSerializable{8

9 publicString name;10 publicString sex;11

12 }

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

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

1 import java.io.*;2

3 /**

4 * 序列化类5 *@authorAdministrator6 *7 */

8 public classXuLieDemo {9

10 public static void main(String[] args) throwsIOException {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 *@authorAdministrator6 *7 */

8 public classFanXuLieDemo {9

10 public static void main(String[] args) throwsIOException, 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 }