IO流进阶2

灰太狼 2022-06-11 08:10 250阅读 0赞

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

**标准输入输出流**

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、有和流技术相结合的方法。

![这里写图片描述][SouthEast]

**利用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 数组

[SouthEast]: /images/20220611/1ca110281f7646e69f853708f9e35af4.png