Java之高级IO,Properties

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. 文本文件的数据的写出的话,字符流和字节流都可以