2019-05-31 Java学习日记之IO(其他流)&Properties

序列流：

package com.otherio;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.SequenceInputStream;

public class Demo1 {
    public static void main(String[] args) throws IOException {
//        demo1();
        FileInputStream fis1 = new FileInputStream("a.txt");
        FileInputStream fis2 = new FileInputStream("b.txt");
        SequenceInputStream sis = new SequenceInputStream(fis1,fis2);
        FileOutputStream fos = new FileOutputStream("c.txt");
        
        int b;
        while((b = sis.read()) != -1){
            fos.write(b);
        }
        
        sis.close();            //sis在关闭的时候，会将构造方法中传入的流对象也都关闭
        fos.close();
    }

    public static void demo1() throws FileNotFoundException, IOException {
        FileInputStream fis1 = new FileInputStream("a.txt");        //创建字节输入流关联a.txt
        FileOutputStream fos1 = new FileOutputStream("c.txt");        //创建字节输出流关联c.txt
        
        int b1;
        while((b1 = fis1.read()) != -1){                            //不断的在a.txt上读取字节
            fos1.write(b1);                                            //将读到的字节写到c.txt上
        }
        fis1.close();                                                 //关闭字节输入流
        
        FileInputStream fis2 = new FileInputStream("b.txt");
        int b2;
        while((b2 = fis2.read()) != -1){
            fos1.write(b2);
        }
        
        fis2.close();
        fos1.close();
    }
}

内存输出流：

1、什么是内存输出流

该输出流可以向内存中写数据，把内存当作一个一个缓冲区，写出之后可以一次性获取出所有数据

2、使用方式

创建对象：new ByteArrayOutputStream（）

写出数据：writer（int），writer（byte[ ]）

获取数据：toByteArray（）

package com.otherio;

import java.io.ByteArrayOutputStream;
import java.io.FileInputStream;
import java.io.IOException;

public class Demo2 {
    /**
     * 内存输出流
     * 
     * FileInputStream读取中文的时候出现了乱码
     * 
     * 解决方案：
     * 1、字符流读取
     * 2、ByteArrayOutputStream
     */
    public static void main(String[] args) throws IOException {
         FileInputStream fis = new FileInputStream("e.txt");
         ByteArrayOutputStream baos = new ByteArrayOutputStream();            //在内存中创建了可以增长的内存数组
         
         int b;
         while((b = fis.read()) != -1){
             baos.write(b);                                                 //将读取到的数据逐个写到内存中
         }
         
         //byte[] arr = baos.toByteArray();                                    //将缓冲区的数据全部获取出来，并赋值给arr数组
         //System.out.println(new String(arr));                                 
         
         System.out.println(baos.toString());                                //将缓冲区的内容转换为字符串，在输出语句中可以省略调用toString方法        
         fis.close();
    }

}

内存输出流之黑马面试题：

定义一个文件输入流,调用read(byte[] b)方法,将a.txt文件中的内容打印出来(byte数组大小限制为5)

package com.otherio;

import java.io.ByteArrayOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class Test1 {
    /**
     * 需求：定义一个文件输入流,调用read(byte[] b)方法,将a.txt文件中的内容打印出来(byte数组大小限制为5)
     * 
     * 分析：
     * 1、read（byte[] b）是字节输入流的方法，创建FileInputStream，关联a.txt
     * 2、创建内存输出流，将读到的数据写到内存输出流中
     * 3、创建字节数组，长度为5
     * 4、将内存输出流的数据全部转换为字符串打印
     * 5、关闭输入流
     * @throws IOException 
     * 
     */
    public static void main(String[] args) throws IOException {
        //1、read（byte[] b）是字节输入流的方法，创建FileInputStream，关联a.txt
        FileInputStream fis = new FileInputStream("a.txt");
        //2、创建内存输出流，将读到的数据写到内存输出流中
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        //3、创建字节数组，长度为5
        byte[] arr = new byte[5];
        int len;
        
        while((len = fis.read(arr)) != -1) {
            baos.write(arr,0,len);
        }
        //4、将内存输出流的数据全部转换为字符串打印
        System.out.println(baos);            //即使没有调用，底层也会默认帮我们调用toString方法
        //5、关闭输入流
        fis.close();
    }

}

打印流的概述和特点：

1、什么是打印流

该流可以很方便的将对象的toString()结果输出, 并且自动加上换行, 而且可以使用自动刷出的模式

System.out就是一个PrintStream, 其默认向控制台输出信息

2、使用方式

打印: print(), println()
自动刷出: PrintWriter(OutputStream out, boolean autoFlush, String encoding)

打印流只操作数据目的

package com.otherio;

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.PrintStream;
import java.io.PrintWriter;

public class Demo3 {
    /**
     * @throws IOException 
     * PrintStream和PrintWriter分别是打印字节流和字符流
     * 只操作数据目的的
     */
    public static void main(String[] args) throws IOException {
//        demo1();
        PrintWriter pw = new PrintWriter(new FileOutputStream("f.txt"),true);
        //pw.println(97);                         //自动刷出功能只针对的是println方法
        //pw.write(97);
        pw.print(97);
        pw.println(97);
        pw.close();
        
    }

    public static void demo1() {
        System.out.println("aaa");
        PrintStream ps = System.out;            //获取标注输出流
        ps.println(97);                         //底层通过Integer.toString（）将97转换成字符串并打印
        ps.write(97);                             //查找码表，找到对应的a并打印
        
        Person p1 = new Person("张三",23);        
        ps.println(p1);                         //默认调用p1的toString方法
        
        Person p2 = null;                        //打印引用数据类型，如果是null，就打印null，如果不是null就打印对象的toString方法
        ps.println(p2);
        ps.close();
    }
}

标准输入输出流概述和输出语句：

1、什么是标准输入输出流

System.in是InputStream, 标准输入流, 默认可以从键盘输入读取字节数据

System.out是PrintStream, 标准输出流, 默认可以向Console中输出字符和字节数据

2、修改标准输入输出流

修改输入流: System.setIn(InputStream)

修改输出流: System.setOut(PrintStream)

package com.otherio;

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintStream;

public class Demo4 {

    public static void main(String[] args) throws IOException {
//        demo1();
        System.setIn(new FileInputStream("a.txt"));                    //改变标准输入流
        System.setOut(new PrintStream("b.txt"));                    //改变标准输出流
        
        InputStream  is = System.in;                                //获取标准的键盘输入流，默认指向键盘，改变后指向文件
        PrintStream ps = System.out;                                //获取标准输出流，默认指向的是控制台，改变后就指向文件
        
        int b;
        while((b = is.read()) != -1){
            ps.write(b);
        }
        //System.out.println();                                        //也是一个输出流，不用关，因为没有和硬盘上的文件产生关联的管道            
        is.close();
        ps.close();
    }

    public static void demo1() throws IOException {
        InputStream is = System.in;
        int x = is.read();
        System.out.println(x);
        
        is.close();
        
        InputStream is2 = System.in;
        int y = is2.read();
        System.out.println(y);
    }

}