5、IO流

一、File类

1、概述

用于封装一个路径，这个路径可以是绝对路径，也可以是相对路径。File 类的路径可以指向一个文件，也可以指向一个文件夹。

2、构造方法

a: File(String pathname):根据指定的路径创建File对象。
b: File(String parent, String child):根据指定的父文件夹和子文件或者文件夹创建File对象
c: File(File parent, String child):根据指定的父文件夹对象和子文件或者文件夹创建File对象

          // 方式1
          File file = new File("d:\\a.txt");
          File file2 = new File("d:\\aaa");

          // 方式2
          File file3 = new File("d:\\", "a.txt");
          File file4 = new File("d:\\", "aaa");

          // 方式3
          File file5 = new File("d:\\");
          File file6 = new File(file5, "a.txt");
          File file7 = new File(file5, "aaa");
     }
}

3、File类的常用方法

• 创建功能：
  创建文件：public boolean createNewFile( )
  如果指定的文件不存在，就创建。如果存在，就不创建。
  创建文件夹：public boolean mkdir( )
  创建指定的目录，如果存在，就不创建。
  public boolean mkdirs( )
  创建指定的目录,如果存储，就不创建。这个时候，如果父目录不存在，它也会自动创建。

• 删除功能：
  public boolean delete():既可以删除文件，也可以删除文件夹。取决于你使用的对象。
  注意：
  a:如果你删除的目录下还有内容，那么，必须先把所有内容删除完毕后，在删除目录。
  b:java语言的删除不走回收站。
  c: 判断功能：

  • boolean exists():判断file对象是否存在
  • boolean isFile():判断file对象是否是文件
  • boolean isDirectory():判断file对象是否是文件夹
  • boolean isAbsolute():判断file对象是否是绝对路径
  • boolean canRead():判断file对象是否可读
  • boolean canWrite():判断file对象是否可写
  • boolean isHidden():判断file对象是否隐藏

  d: 获取功能：

  • String getAbsolutePath():绝对路径
  • String getPath():相对路径
  • String getName():文件名称
  • long length():文件大小，单位是字节
  • long lastModified():上次修改时间的毫秒值。

  注：毫秒----》时间

 Date d = new Date(file.lastModified());
         SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
         System.out.println(sdf.format(d));

e：获取功能：

• public static File[] listRoots():列出可用的系统文件根目录
• public String[ ] list( ):返回的是指定目录下所有文件或者文件夹的名称数组
• public File[ ] listFiles( ):返回的是指定目录下所有文件或者文件夹对象数组

列题：

* 获取指定目录下指定后缀的文件名称：
* A:先获取指定目录下所有文件或者文件夹的File数组,然后再遍历的时候进行判断。满足条件的就输出该File的名称。
* B:直接获取指定目录下满足条件的String(File)数组。然后遍历数组即可。
*
* 文件名称过滤器：FilenameFilter
*           public String[] list(FilenameFilter filter)
*/
public class FileDemo {
     public static void main(String[] args) {
          // 封装目录
          File file = new File("F:\\03.06\\day01");

          // 获取满足条件的数组//以内部类形式
          String[] strArray = file.list(new FilenameFilter() {
               @Override
               public boolean accept(File dir, String name) {
                    // 判断是否是文件，是否是以.mp4结尾
                    // System.out.println(dir + "---" + name);
                    File file = new File(dir, name); // d:\我的文档
                    boolean flag = file.isFile();
                    boolean flag2 = name.endsWith(".java");
                    return flag && flag2;
               }
          });

          // 遍历字符串数组
          for (String str : strArray) {
               System.out.println(str);
          }
     }
}

二、IO流分类：

• 字节流
  字节输出流（OutputStream） 字节写入数据。
  字节输入流（InputStream） 字节写入数据

• 字符流
  字符输出流（Writer） 字符流写入数据
  字符输入流（Reader）字符流读取数据

• 创建字符输出流
  FileWriter fw =new FileWriter( "d.txt");
  创建字符输出流对象做了什么？
  a 调用了系统功能创建了文件
  b 创建了fw对象
  c 把fw对象指向了对应的文件
  注意:FileWriter fw = new FileWriter("a.txt");这一步创建构造方法时，如果这个文件不存在会自动创建。（要跟file类的构造方法区分开）

• FileWriter写入数据的几个小问题
  a：为什么FileWriter没有参数构造方法？
  因为FileWriter是输出流写入数据，既然是写入数据要明确数据要写到那里
  b：flush（）和close（）的区别？
  flush（）只刷新缓冲区，流对象还可以继续使用
  close（）是先刷新缓冲区，再关闭流对象，流对象不可以使用。

• FileWriter的换行和追加写入
  a：写入数据的方式5种

  • write（int ch）；//写入一个字符数据
  • write（char [ ] chs, int index, int length）;//写入一个字符数组的一部分
  • write（char[ ] chs）;写入一个字符数组的数据
  • write（String str， int index ，int length）；//写入一个字符串的一部分
  • write( String str ); //写入一个字符串

  b：不同的操作系统，所对应的换行符；
  windows：\r\n
  linux: \n
  mac: \r
  c: 数据每次都把以前的给覆盖了，如果想要追加，怎么办?
  使用FileWriter的带两个参数的构造
  实列： FileWriter fw =new FileWriter（"d.txt",true）；

• FileWriter写入数据加入异常处理
  标准代码：

     实际开发中的代码写法：
     FileWriter  fw =null；
     try{
          fw=new FileWriter(d.txt);
          fw.write("hello");
          fw.flush;
     }catch( IOException e){
          e.printStackTrace( );
     }finally{
         try{ fw.close( );
     }catch（IOException e）{
          e.printStackTrace( );
     }
     }
     }

• FileWriter读取数据的方式
  a:字符输入流读取数据步骤：

  • 创建字符输入流对象
  • 调用读取方法
  • 释放资源

  b: FileReader类下方法，public int read( );读取单个字符返回int
  如果能读取到数据，它就会把这个数据的值拿到编码表中去找对应的值，并把只返回，如果读取不到数据那么他就会返回-1.
  返回值类型 int；

• 复制文本文件
  思路：
  1、创建字符输入流对象，并且指向到要读取的文件。读取文件FileReader
  2、创建字符输出流对象，并且指向到你要把数据写入的位置，并且改名copy.java。写入文件FileWriter
  3、注意：用IO流完成复制文件的操作后要把输入流和输出流对象都关闭

• FileReader读取数据的方式
  public int read( char[ ] cbuf );//每次读取数组（字符数组的长度一般定义为1024的整数倍）

1、字节流

• 字节输出流OutputStream子类FileOutputStream写入数据
  字节输出流操作步骤
  a：创建字节输出流对象
  b：调用写数据的方法
  c：释放资源
  注意: 字节流是不能直接写字符串

• 字符输出流写数据的方式五种
  每次写入一个字符 write( int i );
  每次写入一个字符数组 write( char [ ] ch);
  每次写入一个字符数组的一部分 write( char[ ] ch,int off ,int len)
  每次写入一个字符串write( string[ ] str)
  每次写入一个字符串的一部分(string[ ] str,int off,int len)

• 字节输出流写数据的方式三种
  每次写入一个字节write(int i)
  每次写入一个字节数组write( byte[] by)
  每次写入一个字节数组的一部分( byte[ ] byte,int off, int len)

二、字节输入流InputStream的子类FileInputStream读取数据

• 字节输入流操作步骤：
  a：创建字节输入流对象
  b：调用读取数据的方法
  c：释放资源
  注：如果读汉字就用字符流,如果读非文本文件就用字节流.

三、字节流复制文本文件

数据源： FileInputStream
目的地： FileOutputStream

四、分别使用字节流和字符流复制图片

代码示例：

private static void method2() throws IOException {
// 用字节流来做
// 封装数据源和目的地
FileInputStream fis = new FileInputStream("aaa.jpg");
FileOutputStream fos = new FileOutputStream("E:\\tupian.jpg");
byte[] bytes = new byte[1024 * 5];
// 读取图片，
int len = 0;
while ((len = fis.read(bytes)) != -1) {
     fos.write(bytes, 0, len);
}
}

五、缓冲流

• BufferedWriter写入数据
  构造方法
  BufferedWriter( Writer out )为什么传递的是Writer呢？
  因为 BufferedWriter 这种流被称为缓冲流,它只提供缓冲功能
  真正的读写还得靠别人,所以这里我们把 FileWriter 作为参数传递进来
  基本流：能够直接读写的流
  高级流: 站在基本流的基础上,提供一些特殊的功能(缓冲流,处理流)

• BufferedReader读取数据

// 创建字符缓冲流对象
BufferedReader br = new BufferedReader(new FileReader("c.txt"));
// 第二种方式取值，按照给定的数组长度取
char[] chs = new char[1024];
int len = 0;
while ((len = br.read(chs)) != -1) {
     System.out.println(new String(chs, 0, len));
}

六、复制MP3加入异常处理的标准代码

• 把复制文件的标准代码全部放到 try里面
• 把释放资源的两个close 放到finally当中
• 步骤2会找不到对象,然后把声明两个输入输出流放在try外面并赋值为null
• 在finally里分别对两个close try..catch ()
• 在finally里对两个close的对象进行不为null判断.

代码：

//使用子符缓冲父子文件
public class io {
     public static void main(String[] args) {
           BufferedReader br = null;
           BufferedWriter bw = null;
            try {
                 br = new BufferedReader( new FileReader("d.txt" ));
                 bw = new BufferedWriter( new FileWriter("c.txt" ));

                 char[] chs = new char[1024];
                 int len = 0;
                 while (( len = br.read( chs)) != -1) {
                      bw.write( chs, 0, len);
                      bw.flush();
                }

           } catch (IOException e) {
             
                 e.printStackTrace();
           } finally {
                 try {
                      bw.close();
                } catch (IOException e) {
                   
                      e.printStackTrace();
                }
                 try {
                      br.close();
                } catch (IOException e) {
                    
                      e.printStackTrace();
                }
           }

     }

七、字符缓冲流的特殊功能

• BufferedWriter ：
• public void newLine();//根据操作平台自动匹配合适的换行符
• BufferedReader ：
• public String readLine();//一次读取一行数据(如果读不到则返回null,这个可以用作判断条件)
  注意:只有字符高效流才有这两个方法, 字节高效流是没有

八、复制目录

• （先改名在复制）
  思路：
  a：封装数据源。
  b：从数据源中找到其所有的后缀名为.java的文件对象。
  c：封装目的地文件。判断目的地文件是否存在。如果不存在，就创建该文件。
  d：遍历B的File[]数组，获取到每个对象后，将每个对象的后缀名改成.jad，在C目录下
  创建相应的文件。
  e：分别创建高效输入，输出流对象。对B中的内容进行读取，复写到D下。

• （先复制再改名）
  思路：
  a：封装数据源。
  b：从数据源中找到其所有的后缀名为.java的文件对象。
  c：封装目的地文件。判断目的地文件是否存在。如果不存在，就创建该文件。
  d：遍历B的File[]数组，获取到每个对象后，在C目录下创建相应的文件。
  e：分别创建高效输入，输出流对象。对B中的内容进行读取，复写到D下。
  f：对C下的文件，进行修改文件后缀名操作。（使用file类下的renameTo（File file）方法）

九、标准的输入输出流

• System类下的--System.in 标准的输入流(它还是一个字节输入流对象)
• System类下的--System.out 标准的输出流(它还是一个字节输出流对象)
  理解:public static final InputStream in=System.in
  其实就是一个类中的属性,数据类型是 InputStream 常量名叫 in

十、转换流InputStreamReader的使用

• 什么时候用到这个转换流呢？
  当字节流想要使用字符高效流的特殊功能时可以考虑使用转换流
• 转换流OutputStreamWriter的使用
  注意：对二进制文件进行操作不能用转换流(转换流本质就是字符流)
  如果是字符流:BufferedReader BufferedWriter
  如果是字节流:BufferedInputStream BufferedOutputStream

十一、打印流概述

• PrintStream:字节打印流

• PrintWriter：字符打印流

• 打印流特点：
  a:可以写入任意数据类型
  b:可以自动刷新,只有在使用println()printf()format()这三个方法时；
  c:可以直接对文件进行写入

• 如何判断一个流可以直接对文件进行写入?
  看构造方法,如果参数位置同时传递String和File类型的数据,
  那么它就可以直接对文件进行写入
  注意：打印流只有写数据没有读数据

• 打印流的自动刷新和换行
  PrintWriter写任意类型数据
  想要自动刷新和换行用 println() 前提是必须先启动刷新
  注意print()方法是不会自动刷新的
  想要启动自动刷新用
  PrintWriter(Writer out, boolean autoFlush)
  带两个参数的构造

• 通过打印流改进复制文本文件FileNotFoundException: test

• 常见问题：
  a:读数据的时候如果给定的是一个文件夹的话会报一个
  异常FileNotFoundException: test(拒绝访问)
  b:写数据的时候如果给定的字符串没有写后缀名的话
  系统会自动创建一个无类型的文件,但是这个文件可以通过记事本打开.

十二、序列化流概述和简单使用 Serializable

• 序列化：
  把对象按照流一样的方式进行传输或者储存

• 反序列化：
  把网络中或者文件中的流数据还原成对象

• 什么时候使用：
  当想把对象通过流传输的时候

• 当你需要序列化对象的时候需要告诉虚拟机这个对象要被序列化那么怎么告诉呢？
  类通过实现 Serializable 接口去实现

• 小知识：以后如果发现一个接口中没有任何的方法
  那么不要奇怪,看一下接口的描述,这个接口一定是有特殊意义的

三、Properties类概述

• Properties 的理解：
  它是处理属性文件(Map体系下的集合)
  它可以保存在流中或从流中加载

• 注意：在使用Properties 这个类的时候不能加泛型
  因为Properties这个集合中只能存储字符串类型

四、Properties的特殊功能使用

• public Object setProperty(String key,String value)
  向集合中添加元素,如果元素锁所对应的键存在的话则替换其值
  返回的是被替换的值

• public String getProperty(String key)
  根据键获取值,如果该键在集合中不存在则返回null

• public String getProperty(String key,String defaultValue)
  根据键获取值,如果该键在集合中不存在则返回给定的值(也就是defaultValue)

• public Set<String> stringPropertyNames()
  获取键的集合

• public static Properties getProperties():
  获取操作系统属性 (它的返回值类型是一个Properties)

• public void list(PrintWriter out)
  把集合中的数据按照键值对儿的形式存储到文本文件中.

• public void load(Reader reader)
  把文本文件中的数据加载到集合中.
  注意事项：这个文本文件必须是键值对形式

• public void store(Writer writer,String comments)
  把集合中的数据加载到文本文件中