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 : 打印字符流(方便使用,自动刷新和自动换行)

转换流的使用场景:

读取数据需要指定字符编码集或者就是本身的意义,将字节流转化为字符流

写出数据需要指定字符编码集
注意字节流和字符流的使用场景

对于文件的拷贝使用字节流

文本文件的数据的读取的话,使用字符流

文本文件的数据的写出的话,字符流和字节流都可以

posted @ 2018-07-24 18:01 庄子游世阅读(335) 评论(0) 收藏举报

刷新页面返回顶部

我想回家