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 : 高效緩沖輸入字節流
    OutputStream
        |-- FileOutputStream : 輸出字符流
        |-- FilterOutputStream (不用管,沒學)
            |-- BufferedOutputStream : 高效緩沖輸出字節流
字符:      
    Reader
        |-- BufferedReader : 高效緩沖字符輸入流
        |-- InputStreamReader : 轉換流,從字節流到字符流的橋
            |-- FileReader : 字符輸入流
    Writer
        |-- BufferedWriter : 高效緩沖字符輸出流
        |-- OutputStreamWriter : 轉換流,是字符的橋梁流以字節流
            |-- FileWriter : 字符輸出流

Java之高級IO,Properties