Java转换流缓冲流流的操作规律和properties类整理

Posted 2021-11-21 mengmengi

     转换流

1.1                OutputStreamWriter类

OutputStreamWriter 是字符流通向字节流的桥梁：可使用指定的字符编码表，将要写入流中的字符编码成字节。它的作用的就是，将字符串按照指定的编码表转成字节，在使用字节流将这些字节写出去。

 

 

 

package com.oracle.reader;

 

public class Demo04 {

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

                   FileOutputStream fw=new FileOutputStream("E:\\\\test\\\\c.txt",true);

                   //给字符流添加指定码表的功能

                   OutputStreamWriter osw=new OutputStreamWriter(fw, "UTF-8");

                   osw.write("你好吗");

                   osw.close();

}

其实在OutputStreamWriter流中维护自己的缓冲区，当我们调用OutputStreamWriter对象的write方法时，会拿着字符到指定的码表中进行查询，把查到的字符编码值转成字节数存放到OutputStreamWriter缓冲区中。然后再调用刷新功能，或者关闭流，或者缓冲区存满后会把缓冲区中的字节数据使用字节流写到指定的文件中

 

1.2                InputStreamReader类

 

 

 

package com.oracle.reader;

 

import java.io.FileInputStream;

import java.io.FileNotFoundException;

import java.io.FileOutputStream;

import java.io.FileReader;

import java.io.FileWriter;

import java.io.IOException;

import java.io.InputStreamReader;

import java.io.OutputStreamWriter;

import java.io.UnsupportedEncodingException;

 

public class Demo04 {

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

       

        //读取文件的字节流对象

        FileInputStream fis=new FileInputStream("E:\\\\test\\\\c.txt");

        //创建转换流对象

        InputStreamReader isr=new InputStreamReader(fis, "UTF-8");

        //使用转换流去读字节流中的字节

        int len=0;

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

            System.out.print((char)len);

        }

        //释放资源

        isr.close();

       

   

       

    }

}

运行结果：

 

 

 

注意：在读取指定的编码的文件时，一定要指定编码格式，否则就会发生解码错误，而发生乱码现象。

 

 

1.3                转换流和子类区别

发现有如下继承关系：

OutputStreamWriter:

                   |--FileWriter:

InputStreamReader:

|--FileReader;

父类和子类的功能有什么区别呢？

OutputStreamWriter和InputStreamReader是字符和字节的桥梁：也可以称之为字符转换流。字符转换流原理：字节流+编码表。

FileWriter和FileReader：作为子类，仅作为操作字符文件的便捷类存在。当操作的字符文件，使用的是默认编码表时可以不用父类，而直接用子类就完成操作了，简化了代码。

InputStreamReader isr = new InputStreamReader(new FileInputStream("a.txt"));//默认字符集。

InputStreamReader isr = new InputStreamReader(new FileInputStream("a.txt"),"GBK");//指定GBK字符集。

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

这三句代码的功能是一样的，其中第三句最为便捷。

注意：一旦要指定其他编码时，绝对不能用子类，必须使用字符转换流。什么时候用子类呢？

条件：

1、操作的是文件。2、使用默认编码。

总结：

字节--->字符 ： 看不懂的--->看的懂的。  需要读。输入流。 InputStreamReader

字符--->字节 ： 看的懂的--->看不懂的。  需要写。输出流。 OutputStreamWriter

 

 

   缓冲流

缓冲流，根据流的分类分类字节缓冲流与字符缓冲流。

 

2.1                字节缓冲流

字节缓冲流根据流的方向，共有2个

写入数据到流中，字节缓冲输出流 BufferedOutputStream

读取流中的数据，字节缓冲输入流 BufferedInputStream

2.1.1            字节缓冲输出流BufferedOutputStream

构造方法

public BufferedOutputStream(OutputStream out)创建一个新的缓冲输出流，以将数据写入指定的底层输出流。

 

package com.oracle.huanchongliu;

 

import java.io.BufferedInputStream;

import java.io.BufferedOutputStream;

import java.io.FileInputStream;

import java.io.FileNotFoundException;

import java.io.FileOutputStream;

import java.io.IOException;

 

public class Demo01 {

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

        method1();

       

    }

    //缓冲字节流输出

    public static void method1() throws IOException{

        FileOutputStream fos=new FileOutputStream("E://test//a.txt");

        //续写

        //FileOutputStream fos=new FileOutputStream("E://test//a.txt",true);

        BufferedOutputStream bos=new BufferedOutputStream(fos);

        bos.write(100);

        bos.write("你好吗".getBytes());//字符数组

        //资源释放

        bos.close();

    }

   

}

 

运行结果：

 

 

 

 

 

2.1.2            字节缓冲输入流 BufferedInputStream

构造方法

public BufferedInputStream(InputStream in)

 

package com.oracle.huanchongliu;

 

import java.io.BufferedInputStream;

import java.io.BufferedOutputStream;

import java.io.FileInputStream;

import java.io.FileNotFoundException;

import java.io.FileOutputStream;

import java.io.IOException;

 

public class Demo01 {

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

        method2();

    }

   

    //缓冲字节输入流

    public static void method2() throws IOException{

        FileInputStream fis=new FileInputStream("E://test//a.txt");

        BufferedInputStream bis=new BufferedInputStream(fis);

        int line=0;

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

            System.out.print((char)line);

           

        }

        //释放资源

        bis.close();//中文用字符流读

    }

}

运行结果：

 

 

 

 

 

2.2                字符缓冲流

字符缓冲输入流 BufferedReader

字符缓冲输出流 BufferedWriter

2.2.1            字符缓冲输出流 BufferedWriter

package com.oracle.huanchongliu;

 

import java.io.BufferedWriter;

import java.io.FileNotFoundException;

import java.io.FileReader;

import java.io.FileWriter;

import java.io.IOException;

 

public class zifuhuanchongliu {

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

        method1();

    }

    //缓冲字符输出流

    //win 换行 \\r\\n

    //linux 换行 \\n

    public static void method1() throws IOException{

        FileWriter fw=new FileWriter("E://test/b.txt");

        BufferedWriter bw=new BufferedWriter(fw);

        //字符数组

        bw.write("你好吗".toCharArray());

        //刷新一下（可有可无，最好刷新）

        bw.flush();

        //换行

        bw.newLine();//可以实现平台无关性

        bw.write("我还好");

        bw.flush();

        bw.newLine();

        bw.write(100);

        //释放资源

        bw.close();

    }

} 

 

 

运行结果：

 

 

 

 

2.2.2            字符缓冲输入流 BufferedReader

方法

public String readLine() 读取一个文本行，包含该行内容的字符串，不包含任何行终止符，如果已到达流末尾，则返回 null

 

package com.oracle.huanchongliu;

 

import java.io.BufferedReader;

import java.io.BufferedWriter;

import java.io.FileNotFoundException;

import java.io.FileReader;

import java.io.FileWriter;

import java.io.IOException;

 

public class zifuhuanchongliu {

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

        method2();

    }

   

    //缓冲字符输入流

    public static void method2() throws IOException{

        //创建流对象

        FileReader fr=new FileReader("E://test//b.txt");

        BufferedReader br=new BufferedReader(fr);

        String line=null;

        int sum=0;//计数器

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

            sum++;

            System.out.println(sum+"    "+line);

           

        }

//释放资源

        br.close();

    }

}  

 

 

运行结果：

 

 

 

2.2.3            使用字符缓冲流完成文本文件的复制

 

package com.oracle.huanchongliu;

 

import java.io.BufferedReader;

import java.io.BufferedWriter;

import java.io.FileNotFoundException;

import java.io.FileReader;

import java.io.FileWriter;

import java.io.IOException;

 

public class zifuhuanchongliu {

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

                   method3();

         }

         //缓冲字符流的复制

         public static void method3() throws IOException{

                   //明确数据源

                   FileReader fr=new FileReader("E://test//a.txt");

                   BufferedReader br=new BufferedReader(fr);

                   //明确数据目的

                   FileWriter fw=new FileWriter("E://test//e//a.txt");

                   BufferedWriter bw=new BufferedWriter(fw);

                   //开始复制

                   String line=null;

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

                            bw.write(line);

                            bw.newLine();

                            bw.flush();

                           

                   }

                   //释放资源

                   br.close();

                   bw.close();

         }

}       

运行结果：

 

 

 

 

 

 

  流的操作规律

l  明确一：要操作的数据是数据源还是数据目的。

                   源：InputStream    Reader

                   目的：OutputStream Writer

先根据需求明确要读，还是要写。

 

l  明确二：要操作的数据是字节还是文本呢？

                   源：

                            字节：InputStream

                            文本：Reader

                   目的：

                            字节：OutputStream

                            文本：Writer

已经明确到了具体的体系上。

 

l  明确三：明确数据所在的具体设备。

                   源设备：

                            硬盘：文件  File开头。

                            内存：数组，字符串。

                            键盘：System.in;

                            网络：Socket

                   目的设备：

                            硬盘：文件  File开头。

                            内存：数组，字符串。

                            屏幕：System.out

                            网络：Socket

完全可以明确具体要使用哪个流对象。

 

l  明确四：是否需要额外功能呢？

                   额外功能：

                            转换吗？转换流。InputStreamReader OutputStreamWriter

                            高效吗？缓冲区对象。BufferedXXX

     InputStream

       FileInputStream

       BufferedInputStream

 

OuputStream

   FileOutputStream

   BufferedOuputStream

 

 

Writer

  OutputStreamWriter

     FileWriter

      BufferedWriter

 

Reader

  InputStreamReader

     FileReader

 BufferedReader

   Properties类

Properties 类表示了一个持久的属性集。Properties 可保存在流中或从流中加载。属性列表中每个键及其对应值都是一个字符串。

特点：

1、Hashtable的子类，map集合中的方法都可以用。

2、该集合没有泛型。键值都是字符串。

3、它是一个可以持久化的属性集。键值可以存储到集合中，也可以存储到持久化的设备(硬盘、U盘、光盘)上。键值的来源也可以是持久化的设备。

4、有和流技术相结合的方法。

 load(InputStream)  把指定流所对应的文件中的数据，读取出来，保存到Propertie集合中

 load(Reader) 

 store(OutputStream,commonts)把集合中的数据，保存到指定的流所对应的文件中，参数commonts代表对描述信息

 stroe(Writer,comments);

 

 

package com.oracle.Properties;

 

import java.util.Properties;

import java.util.Set;

 

public class Demo01 {

    public static void main(String[] args) {

        //创建集合对象

        Properties pro=new Properties();

        //赋值

        pro.setProperty("name", "张三");

        pro.setProperty("age", "123");

        //System.out.println(pro.getProperty("age"));//测试

        //遍历相当于map中的keyset

        Set<String> set=pro.stringPropertyNames();

        int num=0;

        for(String key: set){

            num++;

            //通过键找值

            System.out.println(num+"    "+key+" "+pro.getProperty(key));

        }

       

       

       

    }

}

 

运行结果：

 

 

 

 

4.1                将集合中内容存储到文件

package com.oracle.Properties;

 

import java.io.FileOutputStream;

import java.io.IOException;

import java.util.Properties;

 

public class Demo03 {

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

                   //创建Properties对象

                   Properties pro=new Properties();

                   //创建字节输出流对象

                   FileOutputStream fos=new FileOutputStream("E:\\\\test\\\\por2.properties");

                   //准备数据

                   pro.setProperty("name","lisi");

                   pro.setProperty("age","123");

                   pro.store(fos, "李四");

         }

}

运行结果：

 

 

 

4.2                读取文件中的数据，并保存到集合

需求：从属性集文件prop.properties 中取出数据，保存到集合中

分析：

1，创建集合

2，创建流对象

3,把流所对应文件中的数据 读取到集合中

load(InputStream)  把指定流所对应的文件中的数据，读取出来，保存到Propertie集合中

                   load(Reader) 

4,关闭流

5,显示集合中的数据

 

package com.oracle.Properties;

 

import java.io.FileInputStream;

import java.io.IOException;

import java.util.Properties;

 

public class Demo02 {

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

        //创建Properties对象

        Properties pro=new Properties();

        //获取输入流对象

        FileInputStream fis=new FileInputStream("E:\\\\test\\\\pro.properties");

        //从文件中读取简直对到集合中

        pro.load(fis);

        //释放资源

        System.out.println(pro);

       

    }

}

运行结果：

 

 

 

         注意：使用字符流FileReader就可以完成文件中的中文读取操作了