IO流(高级)

释放资源的标准代码

主要考虑的是在什么时候释放资源比较合适.而且在jdk1.7之前和之后是不同的.

package com.wzlove.demo;

import java.io.FileReader;

import java.io.FileWriter;

import java.io.IOException;

/**

 * 标准的IO格式处理

 *

 * @author WZLOVE

 * @create 2018-07-23 9:54

 */

public class StandardIO {

    // jdk7之前

    public static void main(String[] args) {

        // 初始赋值为null

        FileReader fr = null;

        FileWriter fw = null;

        try {

            // 创建字符流对象

            fr = new FileReader("student.txt");

            fw = new FileWriter("student.txt");

            // 操作资源(边读编写,耗资源,仅作为示例)

            int len;

            while((len = fr.read()) != -1){

                fw.write((char) len);

            }

        } catch (IOException e) {

            e.printStackTrace();

        } finally {

            try {

                // 判断输入流是否为null

                if(fr != null){

                    // 关闭资源

                    fr.close();

                }

            } catch (IOException e) {

                e.printStackTrace();

            } finally {

                try {

                    // 判断输入流是否为null

                    if(fw != null) {

                        // 关闭资源

                        fw.close();

                    }

                } catch (IOException e) {

                    e.printStackTrace();

                }

            }

        }

    }

    // jdk7之后

    /**

     * try(创建IO流对象的代码){

     *     其他代码

     * }catch(可能出现的异常){

     *      打印异常信息

     * }

     * 上面的代码会自动调用close方法(也就是IO流对象都实现了Closeable接口(Closeable实现了AutoCloseable接口),

     * 重写close方法).有兴趣的可以查看源码

     */

    public static void main(String[] args) {

        try (

                // 创建字符流对象

                FileReader fr = new FileReader("student.txt");

                FileWriter fw = new FileWriter("student.txt");

                ){

                // 操作资源(边读编写,耗资源,仅作为示例)

                int len;

                while((len = fr.read()) != -1){

                    fw.write((char) len);

                }

        } catch (IOException e) {

            e.printStackTrace();

        }

    }

}

Properties

是Map下的一个子类(意味着map有的它都有).该类的key和value的类型都是String类型,

开发中Properties使用会结合IO流对文件进行操作,

特殊的方法:

• String getProperties(String key): 根据键获取对应的值
• Object setProperties(String key,String value): 给集合中添加键值对映射关系,返回值是被替换的值.

将Properties对象中的数据进行持久化保存(写数据到文件中):

• void store(OutputStream out, String comments):使用字节流将Properties对象中的内容写入到指定文件,
  
  comments的意思是对文件的数据进行说明
• void store(Writer writer, String comments):使用字符流将Properties对象中的内容写入到指定文件,
  
  comments的意思是对文件的数据进行说明

从文件中获取数据到Properties集合中

• void load(InputStream inStream) : 将文件中的内容以字节流的方式写入到Properties的对象中.

• void load(Reader reader) : 将文件中的内容以字符流的方式写入到Properties的对象中.

  public static void main(String[] args) throws IOException {

        // 创建属性集对象
  
        Properties p = new Properties();
  
        // 添加数据
  
        /*p.put("001","迪丽热巴");
  
        p.put("002","郑爽");
  
        p.put("003","杨紫");*/
  
        // 调用方法,写入文件
  
        // p.store(new FileWriter("a.properties"),"测试文件");
  
        // p.store(new FileWriter("a.txt"),"测试文件");
  
        //p.store(new FileOutputStream("b.properties"),"测试文件");
  
        // 调用方法,读取文件
  
        /*p.load(new FileReader("a.properties"));
  
        // map的子类,遍历的方法和map一样
  
        Set<Map.Entry<Object, Object>> entries = p.entrySet();
  
        for (Map.Entry<Object, Object> entry : entries) {
  
            System.out.println(entry.getKey() + "=" + entry.getValue());
  
        }*/
  
        p.load(new FileInputStream("b.properties"));
  
        // map的子类,遍历的方法和map一样
  
        Set<Map.Entry<Object, Object>> entries = p.entrySet();
  
        Iterator<Map.Entry<Object, Object>> iterator = entries.iterator();
  
        while(iterator.hasNext()){
  
            Map.Entry<Object, Object> map = iterator.next();
  
            System.out.println(map.getKey() + "=" + map.getValue());
  
        }
  
    }
  

高效流

• 高效字节流:
  1. 高效字节输入流(BufferedInputStream)
  2. 高效字节输出流(BufferedOutStream)
• 高效字符流:
  1. 高效字符输入流(BufferedReader)
  2. 高效字符输出流(BufferedWriter)

高效字节流

构造方法:

• public BufferedInputStream(InputStream in) ：创建一个 新的缓冲输入流。
• public BufferedOutputStream(OutputStream out) ： 创建一个新的缓冲输出流。

常用方法:

方法与普通字节流的方法没有区别.下面用个例子测试一下两个的效率,文件大小是七十几兆

public static void main(String[] args) throws IOException {

    // bufferedCopy();

    byteCopy();

}

public static void bufferedCopy() throws IOException {

    long startTime = System.currentTimeMillis();

    BufferedInputStream bis = new BufferedInputStream(new FileInputStream("F:\\desktop\\Desktop\day09\\day09\\avi\\01-今日内容.itcast"));

    BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("abc.avi"));

    int len;

    while((len = bis.read()) != -1){

        bos.write(len);

    }

    bos.close();

    bis.close();

    System.out.println(System.currentTimeMillis() - startTime); // 3171

}

public static void byteCopy() throws IOException {

    long startTime = System.currentTimeMillis();

    FileInputStream fis = new FileInputStream("F:\\desktop\\Desktop\\day09\\day09\\avi\\01-今日内容.itcast");

    FileOutputStream fos = new FileOutputStream("bcd.avi");

    int len;

    while((len = fis.read()) != -1){

        fos.write(len);

    }

    fis.close();

    fos.close();

    System.out.println(System.currentTimeMillis() - startTime); // 297409

}

字符高效流

构造方法:

• public BufferedReader(Reader in) ：创建一个 新的缓冲输入流。
• public BufferedWriter(Writer out) ： 创建一个新的缓冲输出流。

常用方法(父类有的它都有):

• void newLine() : (高效输出字符流的方法)写出一个换行符,跨平台.

• String readLine() : 读取一行数据(结束标志为null)

  package com.wzlove.buffered;

  import java.io.*;
  
  import java.util.Scanner;

  /**

  • 测试高效字符流

  • @author WZLOVE

  • @create 2018-07-23 15:32
    
    */
    
    public class Demo1 {

    public static void main(String[] args) throws IOException {
    
    BufferedWriter bw = new BufferedWriter(new FileWriter("c.txt"));
    
    Scanner in = new Scanner(System.in);
    
    String str;
    
    while(true){
    
    System.out.println("请输入您想要的内容:");
    
    str = in.nextLine();
    
    if(str.equals("ends")){
    
    break;
    
    }
    
    bw.write(str);
    
    bw.newLine();
    
    }
    
    bw.flush();
    
    bw.close();

     System.out.println("您输入的内容是:");
    
     BufferedReader br = new BufferedReader(new FileReader("c.txt"));
    
     String str2;
    
     while((str2 = br.readLine()) != null){
    
         System.out.println(str2);
    
     }
    
     br.close();
    

    }
    
    }

转换流(字符流)

• InputStreamReader
  1. 构造方法
     1. InputStreamReader(InputStream in) : 创建一个使用默认字符集的字符流。
     2. InputStreamReader(InputStream in, String charsetName) : 创建一个指定字符集的字符流。
  2. 常用方法
     1. int read() 读一个字符
     2. void close() 关闭流并释放与之相关联的任何系统资源。
• OutputStreamWriter
  1. 构造方法
     1. OutputStreamWriter(OutputStream in) : 创建一个使用默认字符集的字符流。
     2. OutputStreamWriter(OutputStream in, String charsetName) : 创建一个指定字符集的字符流。
  2. 常用方法:
     1. void close() 关闭流，先刷新。
     2. void flush() 刷新流。
     3. void write(int c) 写一个字符
     4. void write(String str) 写一个字符串

什么时候使用?如果需要以指定的字符集进行数据的读写操作.

    package com.wzlove.demo1;

    import java.io.*;

    import java.util.Scanner;

    /**

     * 测试转换流

     * @author WZLOVE

     * @create 2018-07-23 18:20

     */

    public class Demo {

        public static void main(String[] args) throws IOException {

            // 创建高效输出流

            BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("d.txt"),"GBK"));

            // 写入数据

            Scanner in = new Scanner(System.in);

            while(true){

                System.out.println("请输出内容");

                String str = in.nextLine();

                if(str.equals("ends")){

                    break;

                }

                bw.write(str);

                bw.newLine();

            }

            in.close();

            // 关闭流

            bw.flush();

            bw.close();

            // 创建高效输入流

            BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream("d.txt"),"GBK"));

            String str;

            while((str = br.readLine()) != null){

                System.out.println(str);

            }

            br.close();

        }

    }

回忆学过的IO流:

字节:

    InputStream

        |-- FileInputStream : 输入字节流

        |-- FilterInputStream (不用管,没学)

            |-- BufferedInputStream : 高效缓冲输入字节流

		|-- ObjectInputStream : 对象输入字节流(反序列化流)

    OutputStream

        |-- FileOutputStream : 输出字符流

        |-- FilterOutputStream (不用管,没学)

            |-- BufferedOutputStream : 高效缓冲输出字节流

		|-- ObjectOutputStream : 对象输出字节流(序列化流)

		|-- PrintStream : 打印字节流

字符:

    Reader

        |-- BufferedReader : 高效缓冲字符输入流(读取字符串的时候使用,注意readLine读取一行数据,但不会读取换行符)

        |-- InputStreamReader : 转换流,将字节流转化为字符流

            |-- FileReader : 字符输入流

    Writer

        |-- BufferedWriter : 高效缓冲字符输出流(newLine方法是换行)

        |-- OutputStreamWriter : 转换流,将字符流转化为字节流

            |-- FileWriter : 字符输出流

		|-- PrintWriter : 打印字符流(方便使用,自动刷新和自动换行)

转换流的使用场景:

1. 读取数据需要指定字符编码集或者就是本身的意义,将字节流转化为字符流
2. 写出数据需要指定字符编码集
   
   注意字节流和字符流的使用场景
3. 对于文件的拷贝使用字节流
4. 文本文件的数据的读取的话,使用字符流
5. 文本文件的数据的写出的话,字符流和字节流都可以