Java的三种输入输出流FileOutputStream、FileInputStream； FileWrite、FileReader；OutputStreamWrit、InputStreamRead

package com.suyun.svop.admin;

import java.io.File;
import java.io.FileInputStream;
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.util.ArrayList;
import java.util.List;

/**
 * Description：
 *
 * @Author： leo.xiong
 * @CreateDate： 2020/07/20 19:44
 * @Email： leo.xiong@suyun360.com
 * @Since：
 */
public class InputStreamOrOutputStream {
    private static int[] initialArray = new int[50];


    /**
     * 在一个数组长度为50的int行数组，随机获取一个数， 获取之后，就把这个数字赋值为-1
     *  
     *
     * @return 一个长度为7的listint数组
     */
    public static List<Integer> resultIntArray() {
        List<Integer> list = new ArrayList<Integer>();
        while (true) {
            int random = (int) (Math.random() * 50);
            if (initialArray[random] != -1) {
                list.add(initialArray[random]);
                initialArray[random] = -1;
            }
            if (list.size() == 7) {
                break;
            }
        }
        return list;
    }


    /**
     * list转换为文件
     *  
     *
     * @param list
     * @return
     */
    public static String listToString(List<Integer> list) {
        StringBuffer sb = new StringBuffer();
        for (int i = 0; i < list.size(); i++) {
            sb.append(list.get(i) + " ");
        }
        return sb.toString();
    }


    /**
     * 读出文件也就是把控制台的文件写出到文本文件中，对象是控制台 FileOutputStream接口 OutputStream
     *  
     *
     * @param text
     * @return int 字节流
     */
    public static int fileOutputStreamFile(String text, String path) {
        File file = new File(path);
        try {
            if (!file.exists()) {
                file.createNewFile();
            }
            FileOutputStream out = new FileOutputStream(file);
            out.write(text.getBytes());
            out.close();
        } catch (IOException e) {
            e.printStackTrace();
            return 0;
        }
        return 1;
    }


    /**
     * 读入文件也就是把文本文件的信息写入到控制台，对象是控制台 FileInputStream接口InputStream
     *  
     *
     * @param path
     * @return int 字节流
     */
    public static int fileInputStreamFile(String path) {
        File file = new File(path);
        if (!file.exists()) {
            return -1;
        }
        try {
            FileInputStream in = new FileInputStream(file);
            byte[] inbytes = new byte[1024];
            int buffRead = 0;
            while ((buffRead = in.read(inbytes)) != -1) {
/**
 * 每次把读取文件的大小为1024byte，存入缓冲流中，在真正的读取是读取这个缓冲流，也就是这个数组，读取的长度为0，
 * 到实际复制的长度buffRead ，因为最后的长度基本上不太可能是准确的1024byte，往往会小于1024byte，
 * 所以不能直接读取1024byte数组 ，而要用buffRead
 */
                System.out.println(new String(inbytes, 0, buffRead));
            }
            in.close();
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
        return 1;
    }


    /**
     * 读出文件也就是把控制台的文件写出到文本文件中，对象是控制台 FileWriter接口Writer
     *  
     *
     * @param text
     * @return int 字符流
     */
    public static int fileWriterFile(String text, String path) {
        File file = new File(path);
        try {
            if (!file.exists()) {
                file.createNewFile();
            }
            FileWriter out = new FileWriter(file);
            out.write(text);
            out.close();
        } catch (IOException e) {
            e.printStackTrace();
            return 0;
        }
        return 1;
    }


    /**
     * 读入文件也就是把文本文件的信息写入到控制台，对象是控制台 FileReader接口 Reader
     *  
     *
     * @param path
     * @return int 字符流
     */
    public static int fileReaderFile(String path) {
        File file = new File(path);
        if (!file.exists()) {
            return -1;
        }
        try {
            FileReader in = new FileReader(file);
            char[] inbytes = new char[1024];
            int buffRead = 0;
            while ((buffRead = in.read(inbytes)) != -1) {
/**
 * 原理如上，但此处需要char[]数组
 */
                System.out.println(new String(inbytes, 0, buffRead));
            }
            in.close();
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
        return 1;
    }


    /**
     * 读出文件也就是把控制台的文件写出到文本文件中，对象是控制台 OutputStreamWrite接口Writer
     *  
     *
     * @param text
     * @return int 字符流
     */
    public static int outputStreamWriteFile(String text, String path) {
        File file = new File(path);
        try {
            if (!file.exists()) {
                file.createNewFile();
            }
/**
 * 将字节流转换为字符流
 */
            OutputStreamWriter out = new OutputStreamWriter(
                    new FileOutputStream(file));
            out.write(text);
            out.close();
        } catch (IOException e) {
            e.printStackTrace();
            return 0;
        }
        return 1;
    }


    /**
     * 读入文件也就是把文本文件的信息写入到控制台，对象是控制台 InputStreamReader接口Reader
     *  
     *
     * @param path
     * @return int 字节流通向字符流的桥梁，中间
     */
    public static int inputStreamReaderFile(String path) {
        File file = new File(path);
        if (!file.exists()) {
            return -1;
        }
        try {
/**
 * 将字节流转换为字符流
 */
            InputStreamReader in = new InputStreamReader(new FileInputStream(
                    file));
            char[] inbytes = new char[1024];
            int buffRead = 0;
            while ((buffRead = in.read(inbytes)) != -1) {
/**
 * 原理如上，但此处需要char[]数组
 */
                System.out.println(new String(inbytes, 0, buffRead));
            }
            in.close();
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
        return 1;
    }


    public static void main(String[] args) {
        String path = "F:/STS/输出.txt";
        for (int i = 0; i < 50; i++) {
            initialArray[i] = i;
        }
        String text = "";
        for (int i = 0; i < 7; i++) {
            text = text + listToString(resultIntArray());
        }
/**
 * 三种输出流根据需要用哪种，对象为控制台
 */
        fileOutputStreamFile(text, path);
        fileWriterFile(text, path);
        outputStreamWriteFile(text, path);
        for (int i = 0; i < initialArray.length; i++) {
            if (initialArray[i] != -1) {
                System.out.println(initialArray[i]);// 没有写入文本的数据
            }
        }
/**
 * 三种输入流根据需要用哪种，对象为控制台
 */
        fileInputStreamFile(path);
        System.out.println();
        fileReaderFile(path);
        System.out.println();
        inputStreamReaderFile(path);
    }


}