Java—字符流、内存流、对象操作流、打印流与Properties

Java—字符流、内存流、对象操作流、打印流与Properties

1、FileReader，FileWriter

和字节流类似，字符流也有四步基本步骤：选择管道→创建管道→读写操作→关闭管道。
字符流就是按字符为处理单位的数据流，就是可以直接读写字符的io流。
  字符流读取字符，就要先读取到字节数据，然后转为字符。如果要写出字符，需要把字符  
转为字节再写出。

对于FileReader，FileWriter与BufferedReader、BufferedWriter的代码展示。

package com.hwadee;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class TestIO1 {

    public static void main(String[] args) throws IOException {
//      test1();
//      test2();
//      test3();
//      test4();
//      test5();
//      test6();
//      test7();
//      test8();
//      test9();
        test10();
    }
    public static void test1() throws IOException {
        FileReader fr=new FileReader("D:\\qqq.txt");
        int ch=0;
        while((ch=fr.read())!=-1) {
            System.out.print((char)ch);
        }
        fr.close();
    }
    public static void test2() throws IOException {
        FileReader fr=new FileReader("D:\\hhhh.txt");
        char[] c=new char[1024*1];
        int len=0;
        while((len=fr.read(c))!=-1) {
            String s=new String(c, 0, len);
            System.out.println(s);
        }
        fr.close();
    }
    public static void test3() throws IOException {
        FileWriter fw=new FileWriter("D:\\xxx.txt");
        String s="成都竟然下雪了，五年一见";
        char[] charArray = s.toCharArray();
        fw.write(charArray);
        fw.close();
    }
    public static void test4() throws IOException {
        FileReader fr=new FileReader("D:\\xxx.txt");
        FileWriter fw=new FileWriter("D:\\copyxxx.txt");
        int len=0;
        char[] c=new char[1024*1];
        while((len=fr.read(c))!=-1) {
            fw.write(c, 0, len);
        }
        fr.close();
        fw.close();
    }
    public static void test5() throws IOException {
        BufferedWriter bw=new BufferedWriter(new FileWriter("D:\\xxx.txt",true));
        bw.write("，错错错，是我的错");
        bw.close();
    }
    public static void test6() throws IOException {
        BufferedReader br=new BufferedReader(new FileReader("D:\\xxx.txt"));
        char[] c=new char[1024*1];
        int len=0;
        while((len=br.read(c))!=-1) {
            String s=new String(c, 0, len);
            System.out.println(s);
        }
        br.close();
    }
    public static void test7() throws IOException {
        BufferedReader br=new BufferedReader(new FileReader("D:\\xxx.txt"));
        BufferedWriter bw=new BufferedWriter(new FileWriter("D:\\copyxxx1.txt"));
        char[] c=new char[1024*1];
        int len=0;
        while((len=br.read(c))!=-1) {
            bw.write(c, 0, len);
        }
        br.close();
        bw.close();
    }
    public static void test8() throws IOException {
        BufferedWriter bw=new BufferedWriter(new FileWriter("D:\\诗经.txt"));
        bw.write("床前明月光");
        bw.newLine();          //newline  换行
        bw.write("疑是地上霜");
        bw.newLine();
        bw.write("举头望明月");
        bw.newLine();
        bw.write("低头思故乡");
        bw.close();
    }
    public static void test9() throws IOException {
        BufferedReader br=new BufferedReader(new FileReader("D:\\诗经.txt"));
        BufferedWriter bw=new BufferedWriter(new FileWriter("D:\\copy诗经.txt"));
        String len=null;
        while((len=br.readLine())!=null) {        //readline 每次读取一行
            bw.write(len);
            bw.newLine();
        }
        br.close();
        bw.close();
    }
    public static void test10() throws IOException {
        BufferedReader br=new BufferedReader(new FileReader("D:\\诗经.txt"));
        String len=null;
        while((len=br.readLine())!=null) {
            System.out.println(len);
        }
        br.close();
    }

}

2、内存流与Properties入门

    ByteArrayOutputStream输出流可以向内存中写数据，把内存当做一个缓冲区，写出  
 之后可以一次性获取出所有数据。在制作聊天软件时能用到，将输入的字符先存到内存中，  
 然后把所有的字符一次性发送出去。
    Properties类表示了一个持久的属性集。Properties可保存在流中或者从流中加  
 载。属性列表中每个键及其对应值都是一个字符串。
    一个属性列表可包含另一个属性列表作为它的“默认值”；如果未能在原有的属性列表中  
 搜索到属性键，则搜索第二个属性列表。
 Properties类的特点是:
    (1)该集合中的键和值都是字符串类型。
    (2)集合中的数据可以保存到流中或者从流中获取数据。
    (3)通常该集合用于操作以键值对形式存在的配置文件。

package com.hwadee;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Enumeration;
import java.util.Properties;

public class TestIO2 {

    public static void main(String[] args) throws IOException {
//      test1();
//      test2();
        test3();
    }
    /**
     * 一些数据会在内存中打转的时候 采用ByteArrayOutputStream和ByteArrayInputStream
     * 
     * 这两个流需要close么？不需要。因为本身是一个空的方法
     * 
     * @throws IOException
     */
    public static void test1() throws IOException {
        ByteArrayOutputStream bos=new ByteArrayOutputStream();
        bos.write("美滋滋呀不错".getBytes());
        byte[] byteArray = bos.toByteArray();
        ByteArrayInputStream bis=new ByteArrayInputStream(byteArray);
        byte[] bs=new byte[1024*1];
        int ch=0;
        while((ch=bis.read(bs))!=-1) {
            String string=new String(bs, 0, ch);
            System.out.print(string);
        }
        bis.close();
        bos.close();

    }
    /**
     * 配置文件
     * 属性文件
     * Properties入门
     */
    public static void test2() throws IOException {
        Properties p=new Properties();
        p.setProperty("country", "China");
        p.setProperty("动画片", "秦时明月");
        p.setProperty("作家", "鲁迅");

        FileWriter fw=new FileWriter("D:\\测试.txt");

        p.store(fw, "This is information");

        fw.close();
    }
    public static void test3() {
        Properties p=new Properties();
        p.setProperty("country", "China");
        p.setProperty("动画片", "秦时明月");
        p.setProperty("作家", "鲁迅");
        String person = p.getProperty("作家");
        System.out.println(person);

        Enumeration<String> propertyNames=(Enumeration<String>)p.propertyNames();
        while(propertyNames.hasMoreElements()) {
            String nextElement = propertyNames.nextElement();
            System.out.println(nextElement);
        }


    }
}

3、对象操作流

该流可以将一个对象写出，或者读取一个对象到程序中。也就是执行了序列化和反序列化的操作。

    package com.hwadee;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
//序列化，创造的文本文件只有自己能看懂
import java.io.Serializable;

public class TestIO3 {

    public static void main(String[] args) throws Exception {
        test1();
        test2();
    }
    public static void test1() throws IOException {
        Person p1=new Person("张三", 19);
        Person p2=new Person("李四", 20);
        FileOutputStream fos=new FileOutputStream("D:\\text.txt");
        ObjectOutputStream oos=new ObjectOutputStream(fos);
        oos.writeObject(p1);
        oos.writeObject(p2);
        oos.close();
    }
    public static void test2() throws Exception {
        ObjectInputStream ois=new ObjectInputStream(new FileInputStream("D:\\text.txt"));
        Person r1 = (Person)ois.readObject();
        Person r2 = (Person)ois.readObject();
        System.out.println(r1);
        System.out.println(r2);
        ois.close();
    }

}
class Person implements Serializable{

    private static final long serialVersionUID = 5980018261970480755L;

    String name;
    int age;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public Person(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    @Override
    public String toString() {
        return "Person [name=" + name + ", age=" + age + "]";
    }

}