IO流进阶2-向日葵屋

标准输入流 & 转换流 & 打印流

标准输入输出流

public static final InputStream in:标准输入流
public static final PrintStream out:标准输出流

转换流
OutputStreamWriter:将字节输出流转换为字符输出流

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.Writer;
public class OutputStreamWriterDemo { 
    public static void main(String[] args) throws IOException   {
        //method2();
        //创建输入流对象
        BufferedReader br = new BufferedReader(new FileReader("SystemInOutDemo.java"));
        //创建输出流对象
        //OutputStream os = System.out;
        //Writer w = new OutputStreamWriter(System.out);//多态，父类型引用指向子类对象
        //BufferedWriter bw = new BufferedWriter(w);
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
        //进行数据的读写
        String line;//用于存储读取到的数据
        while((line = br.readLine()) != null) {
            bw.write(line);
            bw.newLine();
        }
        //释放资源
        bw.close();
        br.close();
    }
    private static void method2() throws FileNotFoundException, IOException {
        //创建输入流对象
        BufferedReader br = new BufferedReader(new FileReader("SystemInOutDemo.java"));
        //创建输出流对象
        //OutputStream os = System.out;
        Writer w = new OutputStreamWriter(System.out);//多态，父类型引用指向子类对象
        //进行数据的读写
        String line;//用于存储读取到的数据
        while((line = br.readLine()) != null) {
            w.write(line);
            w.write("\r\n");
        }
        //释放资源
        w.close();
        br.close();
    }
    private static void method() throws FileNotFoundException, IOException {
        //创建输入流对象
        BufferedReader br = new BufferedReader(new FileReader("SystemInOutDemo.java"));
        //创建输出流对象
        OutputStream os = System.out;
        String line;//用于存储读取到的数据
        while((line = br.readLine()) != null) {
            os.write(line.getBytes());
            os.write("\r\n".getBytes());
        }
        //释放资源
        os.close();
        br.close();
    }
}

InputStreamReader:将字节输入流转换为字符输入流

import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.Reader;
public class InputStreamReaderDemo {
    public static void main(String[] args) throws IOException  {
        //创建输入流对象
        InputStream is = System.in;
        Reader r = new InputStreamReader(is);
        //创建输出流对象
        FileWriter fw = new FileWriter("a.txt");
        //读写数据
        char[] chs = new char[1024];
        int len;
        while((len = r.read(chs)) != -1) {
            fw.write(chs,0,len);
            fw.flush();
        }
        //释放资源
        fw.close();
        is.close();
    }
    private static void method() throws IOException {
        //创建输入流对象
        InputStream is = System.in;
        //创建输出流对象
        FileWriter fw = new FileWriter("a.txt");
        //读写数据
        byte[] bys = new byte[1024];
        int len;//用于存储读取到的字节个数
        while((len = is.read(bys)) != -1) {
            fw.write(new String(bys,0,len));
            fw.flush();
        }
        //释放资源
        fw.close();
        is.close();
    }
}

打印流

打印流添加输出数据的功能，使它们能够方便地打印各种数据值表示形式.
字符打印流 PrintWriter
void print(String str): 输出任意类型的数据，
void println(String str): 输出任意类型的数据，自动写入换行操作

import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.PrintWriter;
public class PrintWriterDemo { 
    public static void main(String[] args) throws IOException  {
        //创建打印流对象
        PrintWriter pw = new PrintWriter("b.txt");
        //写出数据
        pw.write("hello");
        pw.write("world");
        pw.write("java");
        //释放资源
        pw.close();
    }
}

利用打印流实现自动换行与自动更新

import java.io.FileNotFoundException;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
public class PrintWriterDemo2 { 
    public static void main(String[] args) throws IOException  {
        //method();
        //创建打印流对象
        //PrintWriter pw = new PrintWriter("d.txt");
        PrintWriter pw = new PrintWriter(new FileWriter("d.txt"),true);
        pw.println("hello");
        pw.println("world");
        pw.println("java");
        //释放资源
        //pw.close();
    }
    private static void method() throws FileNotFoundException {
        //创建打印流对象
        PrintWriter pw = new PrintWriter("c.txt");
        pw.print("hello");
        pw.println("world");
        pw.println("java");
        //释放资源
        pw.close();
    }
}

利用打印流将根目录下的SystemInOutDemo.java复制到d:\SystemInOutDemo.java下

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
public class PrintWriterDemo3 { 
    public static void main(String[] args) throws IOException  {
        //创建输入流对象
        BufferedReader br = new BufferedReader(new FileReader("SystemInOutDemo.java"));
        //创建打印流对象
        PrintWriter pw = new PrintWriter(new FileWriter("d:\\SystemInOutDemo.java"),true);
        String line;//用于存储读取到的每行数据
        while((line = br.readLine()) != null) {
            pw.println(line);
        }
        //释放资源
        pw.close();
        br.close();
    }
}

对象操作流

概述
用于从流中读取对象的
ObjectInputStream 称为反序列化流,利用输入流从文件中读取对象
ObjectOutputStream 称为序列化流,利用输出流向文件中写入对象
特点：用于操作对象。可以将对象写入到文件中，也可以从文件中读取对象。

利用序列化流读写对象

import java.io.Serializable;
public class Student implements Serializable { 
    String name;
    int age;
    public Student(String name,int age) {
        this.name = name;
        this.age = age;
    }
    @Override
    public String toString() {
        return "Student [name=" + name + ", age=" + age +"]";
    }
}
import java.io.EOFException;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
public class ObjectOutputStreamDemo { 
    public static void main(String[] args) throws IOException, ClassNotFoundException  {
        //method();
        //创建对象输入流的对象
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("a.txt"));
        try {
            while(true) {
                Object obj = ois.readObject();
                System.out.println(obj);
            }
        } catch(EOFException e) {
            System.out.println("读到了文件的末尾");
        }
        //释放资源
        ois.close();
    }
    private static void method() throws IOException, FileNotFoundException {
        //创建对象输出流的对象
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("a.txt"));
        //创建学生对象
        Student s = new Student("zhangsan",18);
        Student s2 = new Student("lisi",19);
        //写出学生对象
        oos.writeObject(s);
        oos.writeObject(s2);
        //释放资源
        oos.close();
    }
}

解决对象输入流读取对象出现异常的问题

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.ArrayList;
public class ObjectOutputStreamDemo3 { 
    public static void main(String[] args) throws IOException, ClassNotFoundException   {
        //method();
        //创建对象输入流的对象
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("b.txt"));
        //读取数据
        Object obj = ois.readObject(); 
        //向下转型，获取具体的子类对象
        ArrayList<Student> list = (ArrayList<Student>) obj;
        for (Student student : list) {
            System.out.println(student);
        }
        //释放资源
        ois.close();
    }
    private static void method() throws IOException, FileNotFoundException {
        //创建对象输出流的对象
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("b.txt"));
        //创建集合对象
        ArrayList<Student> list = new ArrayList<Student>();
        //添加学生对象
        list.add(new Student("wangwu",30));
        list.add(new Student("zhaoliu",28));
        //写出集合对象
        oos.writeObject(list);
        //释放资源
        oos.close();
    }
}

解决读写对象版本不一致问题

import java.io.Serializable;
public class Student implements Serializable { 
    private static final long serialVersionUID = 6361890890437825953L;
    String name;
    int age;
    String gender;
    public Student(String name,int age) {
        this.name = name;
        this.age = age;
    }
    @Override
    public String toString() {
        return "Student [name=" + name + ", age=" + age + ", gender=" + gender + "]";
    }
}
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
public class ObjectOutputStreamDemo4 { 
    public static void main(String[] args) throws IOException, ClassNotFoundException  {
        //method();
        method2();
    }
    //读取学生对象
    private static void method2() throws IOException, FileNotFoundException, ClassNotFoundException {
        //创建对象输入流的对象
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("c.txt"));
        //读取对象
        Object obj = ois.readObject();
        System.out.println(obj);
        //释放资源
        ois.close();
    }
    //写出学生对象
    private static void method() throws IOException, FileNotFoundException {
        //创建对象输出流的对象
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("c.txt"));
        //创建的学生对象
        Student s = new Student("qianqi",28);
        //写出学生对象
        oos.writeObject(s);
        //释放资源
        oos.close();
    }
}

Properties集合

Properties介绍

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

特点：
1、Hashtable的子类，map集合中的方法都可以用。
2、该集合没有泛型。键值都是字符串。
3、它是一个可以持久化的属性集。键值可以存储到集合中，也可以存储到持久化的设备(硬盘、U盘、光盘)上。键值的来源也可以是持久化的设备。
4、有和流技术相结合的方法。

这里写图片描述

利用Properties存储键值对

import java.util.Map;
import java.util.Properties;
import java.util.Set;
public class PropertiesDemo2 {
    public static void main(String[] args) {
        //创建属性列表对象
        Properties prop = new Properties();
        //添加映射关系
        prop.put("CZBK001", "zhangsan");
        prop.put("CZBK002", "lisi");
        prop.put("CZBK003", "wangwu");
        //遍历属性列表
        //获取所有的key，通过key获取value
        Set<Object> keys = prop.keySet();
        for (Object key : keys) {
            Object value = prop.get(key);
            System.out.println(key + "=" + value);
        }
        System.out.println("------------------");
        //获取所有的结婚证对象
        Set<Map.Entry<Object,Object>> entrys = prop.entrySet();
        for (Map.Entry<Object, Object> entry : entrys) {
            Object key = entry.getKey();
            Object value = entry.getValue();
            System.out.println(key + "=" + value);
        }
    }
}

Properties与流结合使用

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.Properties;
public class PropertiesDemo2 { 
    public static void main(String[] args) throws IOException{
        //method();
        //method2();
        //创建属性列表对象
        Properties prop = new Properties();
        //添加映射关系
        prop.setProperty("CZBK001", "zhangsan");
        prop.setProperty("CZBK002", "lisi");
        prop.setProperty("CZBK003", "wangwu");
        //创建输出流对象
        FileWriter fw = new FileWriter("e.txt");
        //void store(Writer writer, String comments) 
        prop.store(fw, "hello world");
        //释放资源
        fw.close();
    }
    private static void method2() throws FileNotFoundException, IOException {
        //创建属性列表对象
        Properties prop = new Properties();
        //创建一个输入流对象
        FileReader fr = new FileReader("d.txt");
        //void load(Reader reader) 
        prop.load(fr);
        //释放资源
        fr.close();
        System.out.println(prop);
    }
    private static void method() throws FileNotFoundException {
        //创建属性列表对象
        Properties prop = new Properties();
        //添加映射关系
        prop.setProperty("CZBK001", "zhangsan");
        prop.setProperty("CZBK002", "lisi");
        prop.setProperty("CZBK003", "wangwu");
        //创建打印流对象
        PrintWriter out = new PrintWriter("d.txt");
        //void list(PrintWriter out) 
        prop.list(out);
        //释放资源
        out.close();
    }
编码表
---
**编码表的概述**
编码表：把计算机底层的二进制数据转换成我们能看到的字符
    ASCII
        GB2312  --- GBK
        Unicode 所有的字符都占2个字节
        UTF-8   长度可变的码表
 ANSI：本地编码表 gbk
 Java中的字符串默认使用的ANSI（gbk）
  乱码：编码保持前后一致即可解决
**Java中字符串的编码**  
*常用方法*
构造方法（字节数组转字符串）：
String():初始化一个新创建的 String 对象，使其表示一个空字符序列
String(byte[] bytes) 使用平台的默认字符集解码指定的 byte 数组，构造一个新的 String
String(byte[] bytes, Charset charset) 通过使用指定的 charset 解码指定的 byte 数组，构造一个新的 String
成员方法（字符串转字节数组）
    getBytes() 使用平台的默认字符集将此 String 编码为 byte 序列，并将结果存储到一个新的 byte 数组中
    getBytes(Charset charset) 使用给定的 charset 将此 String 编码到 byte 序列，并将结果存储到新的 byte 数组