Java常用类库（3）——IO流

1.本章内容：

1）对于计算机资源的读取和取出

2）对文件的增删改以及查找的操作

3）对文件字节上的进行读入或者写出

4）对文本文件进行字符上的读入或者写出

一:IO流中，File对象

1.File对象是文件和目录的抽象表示

2.File中常见的构造方法：

1）一参构造方法：File file = new File("文件目录名（如果该目录下没有该文件，就创建，否则返回false）");

 1 import java.io.File;
 2 import java.io.IOException;
 3 
 4 public class Test {
 5     public static void main(String[] args) throws IOException {
 6         //创建File对象
 7         File file = new File("D://Java");
 8         boolean newFile = file.createNewFile();
 9         System.out.println(newFile?"创建成功":"创建失败");
10     }
11 }

2）二参构造方法：File file = new File("文件夹名","文件名字")

 1 import java.io.File;
 2 import java.io.IOException;
 3 
 4 public class Test {
 5     public static void main(String[] args) throws IOException {
 6        File file = new File("D://java");
 7        //创建文件夹
 8        file.mkdir();
 9         //创建两参的构造方法
10        File a = new File(file,"javaee");
11         boolean newFile = a.createNewFile();
12         System.out.println(newFile);
13     }
14 }

3.File中常见的方法：

1）createNewFile();当文件不存在时，创建文件

2）delete();删除文件或者目录

3）exists();判断是否存在该文件或者目录

4）getAbsolutePath();获取文件或者目录的绝对地址

5）getName()；获取文件或者目录的名称

6）getParent();返回此路径的父类文件名称

7）length();返回路径代表的文件长度

8）list();返回一个字符串数组，表示抽象路径下的文件和目录的名称

listFiles();获取抽象路径名下的文件的名字

9）mikdir();创建文件夹

10）minkdirs();创建多级文件夹

11）renameTo();复制文件内容到另一个新创建的文件下面

1 import java.io.IOException;
2 
3 public class Test {
4     public static void main(String[] args) throws IOException {
5        File file = new File("D://java");
6        File file2 = new File("D://python");
7        file.renameTo(file2);
8     }
9 }

12）判断的方法：\

13)分隔符：pathSeparator表示分号，separator表示"\"，都是用来表示文件的分割的

4.遍历文件

 1 import java.io.File;
 2 import java.io.IOException;
 3 
 4 public class Test {
 5     public static void main(String[] args) throws IOException {
 6         //创建文件对象
 7         File file = new File("e://");
 8         //调用方法，获得该对象路径下的文件和目录的数组
 9         File[] files = file.listFiles();
10         listFile(files);
11 
12     }
13     public static void listFile(File [] file){
14         if(file!=null && file.length>0){
15             for(File files : file){
16                 if(files.isFile()) {
17                     if (files.getName().endsWith(".txt")) {
18                         if (files.length() > 200 * 1024 * 1024) {
19                             System.out.println("找到了文件" + files.getAbsolutePath());
20                         }
21                     }
22                 }else{
23                     File[] files1 = files.listFiles();
24                     listFile(files1);
25                 }
26             }
27         }
28     }
29 }

5.文件过滤器：

6.相对路径和绝对路径：

1）相对路径：在Java代码中，是相对于项目路径的路径，这是一个不完整的便捷路径

2）绝对路径：从盘符开始，是一个完整的路径

二：IO流:

1.IO流的概述：

1）可以将数据传送这种操作看作是数据流动，按照流动的方向分为数据流入（input）和数据流出（output)

2）java中IO流的操作实际上是对Java.io包下的类的使用,利用这些常用类对数据进行读取（input）和写出（output）

2.IO流的分类：

1）按照数据的流动方向：输入流（input）和输出流（output）

2）按照流动的数据类型来分：字符流和字节流

3）学习路径：（一下都是顶级的父类）

字节流：

—— 输入流：InputStream

—— 输出流：OutputStream

字符流：

——输入流：Reader

——输出流：Writer

4)一切对象皆字符：计算机中，一切的数据（视频，音频，文字等）都是以二进制来存储的，在数据传输时也是有二进制来存储的，后续学习的任何流都是通过二进制来传输的。

3.字节输出流：OutputSteam

1)将Java代码的文件写入内存中

2）字节输出流中常用的方法：

2.1）close()；关闭流

2.2）flush();刷新流（该父类的子类中，有些流具有缓冲的作用，要使用到刷新）

2.3）write(byte[]);一次写入一个字符

write(byte[] ,int begin,int len);写入一个字符数组的子数组

write（int a);写入一个int类型的数，该数不超过225，底层实际还是字符

3）常用的构造方法：

3.1）FileOutputSream(File file);创建文件输出流以写入由指定的 File对象表示的文件

3.2) FileOutputSream(File file,boolean append);

3.3) FileOutputStream(String name);创建文件输出流以写入具有指定名称的文件。

3.4) FileOutputStream(String name,boolean append);

是否有append的区别：当append为true时，表示重载对象时，文件追加在文件内，如果为false或者不写时，表示清空源文件，从新写入新的文件

4）代码演示

 1 import java.io.File;
 2 import java.io.FileOutputStream;
 3 import java.io.IOException;
 4 
 5 public class Test {
 6     public static void main(String[] args) throws IOException {
 7        //创建FileOutputStream对象
 8         FileOutputStream fos = new FileOutputStream("D://java");//如果没有该文件，就自动创建
 9         //写入一个字节字符
10         fos.write(65);
11         //关闭字节流
12         fos.close();
13         System.out.println("已经写出来了");
14 
15     }
16 }

 1 import java.io.File;
 2 import java.io.FileOutputStream;
 3 import java.io.IOException;
 4 
 5 public class Test {
 6     public static void main(String[] args) throws IOException {
 7        //创建FileOutputStream对象
 8         FileOutputStream fos = new FileOutputStream("D://java",true);//如果没有该文件，就自动创建
 9         //写入一组字符
10         byte [] bytes = {65,66,67,68,69};
11         fos.write(bytes);
12         //关闭字节流
13         fos.close();
14         System.out.println("已经写出来了");
15 
16     }
17 }

 1 import java.io.File;
 2 import java.io.FileOutputStream;
 3 import java.io.IOException;
 4 
 5 public class Test {
 6     public static void main(String[] args) throws IOException {
 7        //创建FileOutputStream对象
 8         FileOutputStream fos = new FileOutputStream("D://java",true);//如果没有该文件，就自动创建
 9         //写入一组字符
10         byte [] bytes ="ABCDEF".getBytes();//getBytes()该方法，将字符串转换为一个字节数组
11         fos.write(bytes,1,2);//从1下表开始，写两个长度
12         //关闭字节流
13         fos.close();
14         System.out.println("已经写出来了");
15 
16     }
17 }

4.字节输入流FileInoutStream

4.1）将文件中的东西写入Java代码中

4.2）FileInputOutput类中常用的方法：

1）close();关闭流

2）read(byte a);读入一个字节

3）read(byte [] a);读入一组字节数组

4.3)FileInputSream类中常见的构造方法

1)FileInputStream(File file);

2)FileInputStream(String name);

4.4）代码演示：

 1 import java.io.FileInputStream;
 2 import java.io.FileNotFoundException;
 3 import java.io.IOException;
 4 
 5 public class Test {
 6     public static void main(String[] args) throws IOException {
 7         //创建FileInoutStream对象
 8         FileInputStream fis = new FileInputStream("D://java");
 9         //创建一个字节数组
10         byte [] bytes = new byte[10];
11         //调用方法，采用一次读入一个字节数组的方式
12         int len = fis.read(bytes);
13         System.out.println(new String(bytes,0,len));
14         len = fis.read(bytes);
15         System.out.println(new String(bytes,0,len));
16         len = fis.read(bytes);
17         System.out.println(new String(bytes,0,len));
18         fis.close();
19     }
20 }

5.字符编码：

5.1）UTF-8:unicode编码，支持多个国家的编码

5.2）乱码的发生：输入端和输出端的编码不匹配

6.字符输出：

1）只能用来读写文字

2）常用的构造方法：

3）常用的方法：

4）代码：

 1 import java.io.FileWriter;
 2 import java.io.IOException;
 3 
 4 public class Test {
 5     public static void main(String[] args) throws IOException {
 6         FileWriter fw = new FileWriter("D://java",true);
 7         fw.append("锄禾日当午").append("汗滴禾下土").append("谁知盘中餐");
 8         fw.write("粒粒皆辛苦");
 9         fw.close();
10     }
11 }

七：字符读取：

1）常用的构造方法：同字符写入相同

3）字符的写入需要刷新：flush();

2）代码演示（一次读取一个字符）

 1 import java.io.FileReader;
 2 import java.io.IOException;
 3 
 4 public class Test {
 5     public static void main(String[] args) throws IOException {
 6         FileReader fr = new FileReader("D://java");
 7         while(true){
 8             int read = fr.read();
 9             if(read==-1){
10                 break;
11             }
               fr.flush();
               fr.close();
12             System.out.println((char)read);
13         }
14 
15     }
16 }

3）代码演示（一次读取一个字符数组）

 1 import java.io.FileReader;
 2 import java.io.IOException;
 3 
 4 public class Test {
 5     public static void main(String[] args) throws IOException {
 6         FileReader fr = new FileReader("D://java");
 7         //创建一个字符数组
 8         char [] chars = new char[100];
 9         int len = fr.read(chars);
10         String str = new String(chars,0,len);
11         System.out.println(str);
12     }
13 }

8.字节转换流（字节转换为字符）

8.1）字节输入流的转换：InputStreamReader();

8.1.1) 代码演示：

 1 import java.io.*;
 2 
 3 public class Test {
 4     public static void main(String[] args) throws IOException {
 5         //创建字节输入流
 6         FileInputStream fis = new FileInputStream("D://java");
 7         //创建转换流
 8         InputStreamReader isr = new InputStreamReader(fis,"UTF-8");
 9         while(true){
10             int read = isr.read();
11             if(read==-1){
12                 break;
13             }
14             System.out.println((char)read);
15         }
16     }
17 }

8.2）字节输出流转换：OutputStreamWriter;

8.2.1) 代码演示：

 1 import java.io.*;
 2 
 3 public class Test {
 4     public static void main(String[] args) throws IOException {
 5         //创建字节输出流对象
 6         FileOutputStream fos = new FileOutputStream("D://java");
 7         //创建字节转换流
 8         OutputStreamWriter osw = new OutputStreamWriter(fos);
 9         //写入数据
10         osw.write("床前明月光，地上鞋一堆");
11         osw.flush();
12         osw.close();
13     }
14 }

8.打印流：

 1 import java.io.*;
 2 
 3 public class Test {
 4     /**
 5      * 字符输出流（打印流）
 6      * @param args
 7      * @throws IOException
 8      */
 9     public static void main(String[] args) throws IOException {
10 //        //创建打印流对象
11 //        PrintStream ps = new PrintStream("D://java");
12 //        //写入数据
13 //        ps.println("唧唧复唧唧，木兰当户织");
14 //        ps.println("不闻机杼声，唯闻女叹息");
15 //        ps.println("问女何所思,问女何所忆");
16 
17 
18 //        //创建打印流对象
19 //        PrintWriter ps = new PrintWriter("D://java");
20 //        //写入数据
21 //        ps.println("唧唧复唧唧，木兰当户织");
22 //        ps.println("不闻机杼声，唯闻女叹息");
23 //        ps.println("问女何所思,问女何所忆");
24 
25         /**
26          * 在字节转换为字符的时候，建议采用一下方法，将字节流转换为打印流
27          */
28         //创建字节输出流
29         FileOutputStream fos = new FileOutputStream("D://java");
30         //创建打印流对象
31         PrintWriter pw = new PrintWriter(fos);
32         pw.println("唧唧复唧唧，木兰当户织");
33         pw.println("不闻机杼声，唯闻女叹息");
34         pw.println("问女何所思,问女何所忆");
35         pw.flush();
36         pw.close();
37     }
38 }

9.缓存读取流：

9.1）将字符输入流，转换为可以缓存，可以一次性读取一行的字符缓冲流

9.2）代码演示：

 1 import java.io.*;
 2 
 3 public class Test {
 4     /**
 5      * 字符输出流（打印流）
 6      * @param args
 7      * @throws IOException
 8      */
 9     public static void main(String[] args) throws IOException {
10         //创建字符输入流对象
11         FileReader fw = new FileReader("D://java");
12         //将字符输入流转换为字符缓冲流
13         BufferedReader br = new BufferedReader(fw);
14         String text = br.readLine();
15         System.out.println(text);
16     }
17 }

三：收集异常日志：

 1 import java.io.*;
 2 import java.text.SimpleDateFormat;
 3 import java.util.Date;
 4 
 5 public class Test {
 6     /**
 7      * 日志异常收集
 8      * @param args
 9      * @throws IOException
10      */
11     public static void main(String[] args) throws IOException {
12        try{
13            String s = null;
14            System.out.println(s.toString());
15        }catch (Exception e){
16            //创建写入流
17            PrintWriter fw = new PrintWriter("D://java");
18            //创建日期格式化对象
19            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm");
20            //创建当前日期对象
21            Date date = new Date();
22            fw.println(sdf.format(date));
23            e.printStackTrace(fw);
24            fw.close();
25        }
26     }
27 }

四：properties配置文件

1.properties既属于集合类的知识，又涉及到IO流

2.Properties为他的类，properties是他的文件

3.代码演示：将文件写入磁盘

 1 import java.io.FileWriter;
 2 import java.io.IOException;
 3 import java.util.Properties;
 4 
 5 public class Test {
 6     /**
 7      * Properties类和properties文件
 8      * 将文件写入磁盘
 9      * @param args
10      */
11     public static void main(String[] args) throws IOException {
12         //创建Properties类对象
13         Properties pro = new Properties();
14         //因为他底层使用Map集合，键值对的形式，调用方法，传入参数
15         pro.put("name","金苹果");
16         pro.put("info","讲诉了农夫种植金苹果的心酸过程");
17         //创建一个字符输入流，将该文件写入磁盘
18         FileWriter fw = new FileWriter("D://java.properties");
19         pro.store(fw,"图书存储");
20         fw.close();
21     }
22 }

4.代码演示：将文件内容从磁盘里面读出来

 1 import java.io.FileReader;
 2 import java.io.IOException;
 3 import java.util.Properties;
 4 
 5 public class Test {
 6     /**
 7      * Properties类和properties文件
 8      * 将文件写入磁盘
 9      * @param args
10      */
11     public static void main(String[] args) throws IOException {
12         //创建Properties类对象
13         Properties pro = new Properties();
14         //创建一个字符输出流
15         FileReader fr = new FileReader("D://java.properties");
16         //调用方法，将文件从磁盘中读取出来
17         pro.load(fr);
18         System.out.println(pro.get("name"));
19         System.out.println(pro.get("info"));
20         fr.close();
21     }
22 }

五：序列化和反序列化：

1.序列化是将Java编写的类存储到文件中，他是一些看不懂得东西，反序列化就是将文件里面的东西写到程序中来

2.序列化技术:

 1 import java.io.FileOutputStream;
 2 import java.io.ObjectOutputStream;
 3 import java.io.Serializable;
 4 
 5 public class Test {
 6     /**
 7      * 序列化技术，将类存储到文件中，以便永久保存
 8      * @param args
 9      */
10     public static void main(String[] args) throws Exception {
11         //创建图书对象
12         Book book = new Book("金苹果","讲诉了农夫种植苹果的心酸过程");
13         //创建序列化对象
14         ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("D://java01"));
15         oos.writeObject(book);
16         oos.close();
17     }
18     //implements Serializable 用于标记该类将要序列化
19     static class Book implements Serializable {
20         String name;
21         String info;
22         public Book(){};
23 
24         public Book(String name, String info) {
25             this.name = name;
26             this.info = info;
27         }
28 
29         @Override
30         public String toString() {
31             return "Book{" +
32                     "name='" + name + '\'' +
33                     ", info='" + info + '\'' +
34                     '}';
35         }
36     }
37 }

3.反序列化技术：

 1 import java.io.FileInputStream;
 2 import java.io.ObjectInputStream;
 3 import java.io.Serializable;
 4 
 5 public class Test {
 6     /**
 7      * 反序列化技术，文件中储存的类，写到程序中
 8      *
 9      * @param args
10      */
11     public static void main(String[] args) throws Exception {
12         //创建反序列化对象
13         ObjectInputStream obs = new ObjectInputStream(new FileInputStream("D://java01"));
14 //        Object o = obs.readObject();
15 //        System.out.println(o);
16         Book o = (Book)obs.readObject();
17         System.out.println(o);
18     }
19 
20     //implements Serializable 用于标记该类将要序列化
21     static class Book implements Serializable {
22         String name;
23         String info;
24 
25         public Book() {
26         }
27 
28         public Book(String name, String info) {
29             this.name = name;
30             this.info = info;
31         }
32 
33         @Override
34         public String toString() {
35             return "Book{" +
36                     "name='" + name + '\'' +
37                     ", info='" + info + '\'' +
38                     '}';
39         }
40     }
41 }

（如果反序列化中的类中有其他的引用数据类型，那么那个引用数据类型也要实现标记接口）

4.序列化和反序列化是用来数据传输或者本地存储的

六：try-with-resources:

1.简化了代码的异常处理，他是自动进行了close()操作

2.代码演示：

 1 import java.io.FileNotFoundException;
 2 import java.io.FileReader;
 3 import java.io.IOException;
 4 import java.io.PrintWriter;
 5 
 6 public class Test {
 7     /**
 8      *try-with-resource既是异常中的知识点，也是IO流中的知识点
 9      * @param args
10      */
11     public static void main(String [] args)throws FileNotFoundException{
12 //        //1.7版本：
13 //        try(FileReader fr = new FileReader("D://java01")) {
14 //            int num = fr.read();
15 //            System.out.println((char)num);
16 //
17 //        } catch (IOException e) {
18 //            e.printStackTrace();
19 //        }
20 
21         //1.9版本
22         FileReader fr = new FileReader("D://java01");
23         PrintWriter fw = new PrintWriter("D://java01");
24         try(fr;fw){
25             int c = fr.read();
26             System.out.println((char)c);
27 
28         }catch (IOException e){
29             e.printStackTrace();
30         }
31     }
32 }

3.使用try-with-resources的类必须实现Closeable()或者AutoCloseable()接口。

posted @ 2021-06-14 16:55 白杨树& 阅读(152) 评论(0) 编辑收藏举报

刷新页面返回顶部

白杨树&