JAVA IO流

r我们对习IO流做一个简单的总结：

大致流程图如下

以上图片是我们这张知识的大致流程

接下来我们用代码演示其中的操作，我大致的将红色的给写一下，其他的大家在下面进行操作

InputStream的操作演示

public class InputStreamDemo2 {
    public static void main(String[] args) {
        InputStream inputStream = null;

        try {
            //创建对象
            inputStream = new FileInputStream("D:\\d1.txt");
            //传输数据
            int read = 0;
            //如果文件的数据未读取完毕，继续执行该循环
            while ((read = inputStream.read()) !=-1){
                //skip跳过并丢弃来自此输入流的 n字节数据
                //每个五个输出字母
               // inputStream.skip(5);
                System.out.println((char)read);
            }
//            int read = inputStream.read();
//            System.out.println((char) read);

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                inputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }
}

OutputStream的演示操作

public class OutputStreamDemo {
    public static void main(String[] args) {
        File file = new File("a2.txt");
        OutputStream outputStream = null;
        try {
            //创建对象
            outputStream = new FileOutputStream(file,true);
            //传输数据
            outputStream.write(98);
            outputStream.write("www.baidu.com百度".getBytes());
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            //关闭对象
            try {
                outputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }
}

为了节约时间，我将FileInputStream和FileOutputStream进行一起的操作

/**
 * @Auther:Yuhai
 * @Date:2022/4/6-04-06-8:53
 * @Description:IntelliJ IDEA
 * @version:1.0
 *
 * 训练要点
 * – 理解输入流和输出流类的概念。 – 使用FileInputStream实现读取文本文件。 – 使用FileOutputStream实现向文本文件中写数据
 * ▪ 需求说明
 * – 文件“我的青春谁做主.txt”位于D盘根目录下，要求将此文件的
 * 内容复制到
 * – C:\myFile\myPrime.txt中
 *
 *
 * 题意大致是一个复制功能
 *
 * 无非是对之前知识的一个总结
 * 四步骤：
 *      选择合适的流
 *      创建对象
 *      传输数据
 *      关闭流对象
 */
public class FileOutputStreamTest {
    public static void main(String[] args) throws IOException {
        //现将值为空
        FileInputStream fis = null;
        FileOutputStream fos = null;
        try {
            //创建字节输入流
            fis = new FileInputStream("D:\\我的青春谁做主.txt");

            //创建字节输出流
            fos = new FileOutputStream("d:\\io\\myPrime");

            //创建字节数据，方便存储
            byte [] b  = new byte[1024];
            int hasRead = 0;
            while ((hasRead = fis.read(b))>0){
                //每读取一次，即写入文件输入流，读了多少，就写多少
                //off是偏移值，即从这个地方开始
                fos.write(b,0,hasRead);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        fis.close();
        fos.close();
    }
}

printStream的操作演示

/**
 * @Auther:Yuhai
 * @Date:2022/4/12-04-12-8:32
 * @Description:IntelliJ IDEA
 * @version:1.0
 */
public class PrintStreamDemo {
    public static void main(String[] args) {

        try {
            PrintStream ps = new PrintStream(new FileOutputStream("a1.txt"));
            //看一下基本数据类型是否可以输出
            int i    =0;
            double f = 900.0;
            String str = "大家好，我是java小白";
            ps.print(i);
            ps .print(f);
            ps.print(str);
            ps.flush();

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }

    }
}

Reader的演示操作（读取的功能）

/**
 * @Auther:Yuhai
 * @Date:2022/4/4-04-04-9:12
 * @Description:IntelliJ IDEA
 * @version:1.0
 *
 * 做一下内容无非是一下四步骤
 *          选择合适的流
 *          创建对象
 *          传输数据
 *          关闭对象中的流
 *
 *
 *          显然，这个查询速度比较慢，
 */
public class ReaderDemo {
    public static void main(String[] args)  {
        Reader reader  = null;
        try {
            //创建对象
            reader = new FileReader("a2.txt");

            int read = 0;
            while ((read = reader.read())!=-1){
                System.out.println((char)read);
            }

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            //关闭流对象
            try {
                reader.close();
            } catch (IOException e) {
                e.printStackTrace();
            }

        }
    }
}

Wtiter的操作演示（写入的过程）

/**
 * @Auther:Yuhai
 * @Date:2022/4/12-04-12-8:48
 * @Description:IntelliJ IDEA
 * @version:1.0
 */
public class WriterDemo {
    public static void main(String[] args) {
        File file = new File("b5.txt");
        Writer writer = null;

        try {
            writer = new FileWriter(file,false);

            writer.write(100);
            writer.write("你好，世界");
            //append追加
            writer.append(",");
            writer.write( new char[]{'4','f','p'});
            writer.append('a').append('c').append('e');
            writer.flush();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                writer.close();
            } catch (IOException e) {
                e.printStackTrace();
            }

        }
    }
}

InputStreamReader和OutputStreamWriter的操作演示（这是处理流，也是字节流和字符流得桥梁）

/**
 * @Auther:Yuhai
 * @Date:2022/4/7-04-07-20:43
 * @Description:IntelliJ IDEA
 * @version:1.0
 *
 *
 * 处理流之二：
 *          转换流的使用，
 *          1.转换流：属于字符流
 *          InputStreamReader:将一个字节输入流转换为字符的输入流
 *          OutputStreamWriter: 将一个字符的输出流转换为字节的输出流
 *
 *          2.作用：提供字节流和字符流的转换
 *
 *          3.解码：字节、字节数组-----》字符数组、字符串
 *          编码：字符数组、字符串-----》字节、字节数组
 *
 *          4.字符集
 *          ASCII：美国标准信息交换码
 *          用一个字节的7位也可以表示
 *          IS08859-1:拉丁码，欧洲码表
 *          用一个字节的8位表示
 *          GB2312：中国的中文编码表。最多两个字节编码的所有字符
 *          GBK:中国的中文编码表的升级，融合了更多的中文文字符号，最多两个字节编码
 *          Unicode: 国际标准码，融合了目前人类使用的所有字符。为每一个字符的分配唯一的字符码，所有的文件
 *          UTF-8： 变长的编码方式，可用1-4个字节来表示一个字符
 */
public class InputStreamReaderTest {

    /*
    此时处理异常，任然使用try-catch -finally
     */
    @Test
    public void test1() throws IOException {
        FileInputStream fis = new FileInputStream("D:\\HelloWord.txt");
//InputStreamReader isr = new InputStreamReader(fis);//使用默认的字符集
        //参数二指明了字符集，具体使用那个字符集，取决于文件的字符集
        InputStreamReader isr = new InputStreamReader(fis,"Utf-8");

        char[] chars = new char[20];
        int len;
        while ((len = isr.read(chars))!=-1){
            String str = new String(chars,0,len);
            System.out.println(str);
        }
        isr.close();
    }
    /*
        综合的使用InputStreamReader和OutputStreamWrite
     */
    @Test

    public void  test2() throws Exception {
        //造文件，造流
        File file1 = new File("D:\\d1.txt");
        File file2 = new File("D:\\di.txt");

        FileInputStream fis = new FileInputStream(file1);
        FileOutputStream fos = new FileOutputStream(file2);

        InputStreamReader isr =new InputStreamReader(fis,"UTF-8");
        OutputStreamWriter osw = new OutputStreamWriter(fos,"gbk");

        //读写过程
        char [] chars = new char[20];
        int len;
        while ((len =isr.read(chars))!=-1){
            osw.write(chars,0,len);
        }
        //关闭流对象，资源
    }

}

BufferedReader的操作演示

/**
 * @Auther:Yuhai
 * @Date:2022/4/9-04-09-21:18
 * @Description:IntelliJ IDEA
 * @version:1.0
 *
 *  BufferedReader的用法有一个ReadLine()读取一行文字的操作
 *
 */
public class BufferedReaderDemo {
    public static void main(String[] args) {
        FileReader fileReader = null;
        BufferedReader reader=null;

        try {
            fileReader = new FileReader("D:\\hi.txt");
            reader = new BufferedReader(fileReader);

            String str = "";
            while ((str = reader.readLine())!=null){
                System.out.println(str);

            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                fileReader.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
               reader.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }
}

BufferedWriter的操作演示

/**
 * @Auther:Yuhai
 * @Date:2022/4/9-04-09-21:12
 * @Description:IntelliJ IDEA
 * @version:1.0
 *
 * 总结：
 *       bufferedWriter独有的方法换行newLine()
 */
public class BufferedWriteDemo {
    public static void main(String[] args) {
        FileWriter fileWriter = null;
        BufferedWriter bufferedWriter = null;

        try {
            fileWriter = new FileWriter("HelloWord.txt");
            bufferedWriter = new BufferedWriter(fileWriter);
            bufferedWriter.write(100);
            bufferedWriter.write("www.baidu.com百度");
            bufferedWriter.write("www.ailibab.com阿里巴巴".toCharArray());
            //写入一行
            bufferedWriter.newLine();
            bufferedWriter.write(97);
            bufferedWriter.flush();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                bufferedWriter.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                fileWriter.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

File的操作演示

/**
 * @Auther:Yuhai
 * @Date:2022/4/12-04-12-9:03
 * @Description:IntelliJ IDEA
 * @version:1.0
 */
public class FileWriterTest {
    public static void main(String[] args) {

        File file = new File("b2.txt");
        FileWriter fw = null;
        try {
            fw = new FileWriter(file);
        //创建字符缓冲区
            fw.write(100);//此时的100对应的是d
            fw.write("你好");
            //......
            fw.flush();
            fw.close();

        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

FileReader的演示

/**
 * @Auther:Yuhai
 * @Date:2022/3/31-03-31-17:55
 * @Description:IntelliJ IDEA
 * @version:1.0
 */
//使用FileReader读取文件
public class FileReaderTest {
    public static void main(String[] args) throws IOException {
        FileReader fis = null;
        try {
            //创建字节输入流
            fis = new FileReader("D:\\Program Files\\IDEA\\IntelliJ IDEA 2019.2.4\\build.txt");
            //创建一个长度为1024的竹简
            char[] b = new char[1024];
            //用于保存的实际字节数
            int hasRead = 0;
            //使用循环来重复取水的过程
            while ((hasRead = fis.read(b))>0){
                //取出竹简中的水滴（字节）,将数组转换成字符串进型输出
                System.out.println(new String(b,0,hasRead));
            }
        }catch (IIOException | FileNotFoundException e ){
            e.printStackTrace();

        } finally {
            fis.close();
        }
    }
}

总结: 学这么多IO流类，其实他们的内容比较复杂，但是形式比较统一，无非是读和写，都是从前面四个抽象基类演变过来的。在我们实际应用中，使用IO流的时候，应当选择适合自己的流来进行操作。