IO流（上）

已于 2025-02-13 17:57:42 修改
阅读量422 收藏 8
点赞数 3
分类专栏： Java 文章标签： 开发语言 java
于 2025-02-13 17:09:19 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/2401_88153531/article/details/145616408
版权

目录

1.IO概述

1.1流的分类

2.字符流

2.1输出流

2.2输入流Reader

2.3BufferedReader高效缓存字符输入流

2.4BufferedWriter高效缓存字符输出流

1.IO概述

IO（Input/Output）:输入和输出，指的是某个设备或环境进行数据的输入或者输出。例如：键盘的输入，再比如显示器就是输出设备，输出图像。

对于java来说输入输出问题，java将它抽象成流对象来解决。

以游戏程序为中心读取文件就是输入，写入文件是输出。

1.1流的分类

IO流在java中从输入输出角度分类：

        1.输入流

        2.输出流

IO流在java中从数据的角度来分类：

        1.字符流

        文本，我们能读的懂的都可以认为是字符流。比如：文章，java文件等等

        2.字节流

        二进制的数据，这种数据一般用文本打开我们读不懂。比如，图片文件，mp3文件，等等。

2.字符流

        文本，我们能读的懂的都可以认为是字符流。比如：文章，java文件等等

字符流

        输出流

         

        输入流 

        

字符流的类的命名的规则：

        如果是输出流就以Writer结尾

        如果是输入流就以Reader结尾

2.1输出流

使用字符流向一个文件输入helloworld。

分析：

步骤：     

  •         1.创建文件
  •         2.创建输出流对象
  •         3.把流指向指定的文件
  •         4.释放资源

public class IOTest {

    public static void main(String[] args) {

        //创建一个文件
        File file = new File("test.txt");
        Writer writer = null;

        try {
            //IO流是需要关闭的，如果不这样设计就会不能关闭资源
            writer = new FileWriter(file);
            writer.write("HelloWorld");


        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            //判断writer不是空防止空指针异常
            if(writer != null) {
                try {
                    //关闭流
                    writer.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

 文件的追加

public class IOTest4 {

    public static void main(String[] args) {


        Writer writer = null;

        try {
            //IO流是需要关闭的，如果不这样设计就会不能关闭资源
            //writer = new FileWriter("test1.txt", true);
            writer = new FileWriter(new File("test1.txt"), true);
            writer.write("liangliang");

        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            //判断writer不是空防止空指针异常
            if(writer != null) {
                try {
                    //在关闭前会做flush的事情
                    writer.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

换行：

输出换行

        把文本写入文件中\n代表换行

        问题是不同的环境下换行的方式也不一样

        Windows: \r\n

        Linux:\n

        Mac:\r

public class IOTest5 {

    public static void main(String[] args) {

        //创建一个文件
        File file = new File("test.txt");
        Writer writer = null;
        try {
            //IO流是需要关闭的，如果不这样设计就会不能关闭资源
            writer = new FileWriter(file);
            for (int i = 0; i < 100; i++) {
                writer.write("HelloWorld\r\n");
                //每次写入10个helloworld的时候做一次flush
                if(i % 10 == 0){
                    writer.flush();
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            //判断writer不是空防止空指针异常
            if(writer != null) {
                try {
                    //在关闭前会做flush的事情
                    writer.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

Writer的五种写入的方法

public class IOTest6 {
    public static void main(String[] args) {
        //创建一个文件
        File file = new File("test.txt");
        Writer writer = null;
        try {
            writer = new FileWriter(file);
            //定义一个数组
            char[] c = {'a','b','p','b','p'};
            /*writer.write(c);

            //把数组中的一部分写入文件
            writer.write(c, 2, 2);

            writer.write(97);
            */

            writer.write("helloworld", 2, 2);

        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if(writer != null) {
                try {
                    writer.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

2.2输入流Reader

package cn.tedu.demo1;

import java.io.*;
import java.util.Arrays;

public class ReaderDemo {

    public static void main(String[] args) {

        File file = new File("c.txt");
        //输入流的超类    从文件读
        Reader reader = null;

        try {
            //创建出入流对象FileReader
            reader = new FileReader(file);
            //读取数据, 读取的字符被转换成了ascii  单个字符读取
            int c = reader.read();
            System.out.println((char)c);
             c = reader.read();
            System.out.println((char)c);
            //如果读取到的是-1后面就没有字符了
            c = reader.read();

            /*
            //读取数据, 读取的字符被转换成了ascii
            int c = -1;
            //单个字符的读取性能低
            while((c = reader.read()) != -1){
                System.out.print((char)c);
            }*/

            /*
            //定义一个数组   字符 char
            char[] cs = new char[5];
            //向字符数组中填数据
            int len = reader.read(cs);
            System.out.println("读取的长度："+len+"    读取的内容："+ Arrays.toString(cs));

            //本次读取的字符的长度，如果要是文件中没有数据了，读取到的是-1
            len = reader.read(cs);
            System.out.println("第二次读取的长度："+len+"    读取的内容："+ Arrays.toString(cs));

            len = reader.read(cs);
            System.out.println("第三次读取的长度："+len+"    读取的内容："+ Arrays.toString(cs));*/
            
            /*            
            //定义一个数组
            char[] cs = new char[5];
            //向字符数组中填数据
            int len = -1;
            while((len = reader.read(cs)) != -1){
                //把字符数组变成字符串
                String str = new String(cs, 0, len );
                System.out.print(str);
            }*/
            
            /*
            //定义一个数组
            char[] cs = new char[5];

            int read = reader.read(cs, 2, 3);
            System.out.println(Arrays.toString(cs));*/

            System.out.println(c);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //关闭资源
            if(reader != null){
                try {
                    reader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

        }
    }
}

2.3BufferedReader高效缓存字符输入流

package cn.tedu.buffer;

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

public class BufferReaderDemo {

    public static void main(String[] args) {

        BufferedReader reader = null;

        try {
            //创建一个高效缓存字符输入流对象
            reader = new BufferedReader(new FileReader("CopyDemo1.java"));
            String line = null;
            while((line = reader.readLine()) != null){
                //打印一行
                System.out.println(line);
            }

        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            //关闭外层的对象的时候，内存的资源会自动的背关闭
            if(reader != null){
                try {
                    reader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

        }

    }
}

2.4BufferedWriter高效缓存字符输出流

package cn.tedu.buffer;

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;

public class BufferWriterDemo {

    public static void main(String[] args) {
        //创建高效缓冲字符输出流
        BufferedWriter writer = null;

        try {
            writer = new BufferedWriter(new FileWriter("IOTest.java"));
            //写一行数据
            writer.write("helloworld");
            //换行
            writer.newLine();
            writer.write("helloworld");
            writer.flush();

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

            //资源关闭
            if(writer != null){
                try {
                    writer.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

    }
}

BufferedInputStream高效缓存字节输入流

BufferedOutputStream高效缓存字节输出流

InputStream字节输入流

OutputStream字节输出流

与字符的操作基本一样，字符能做的字节都可以

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值