java输入流输出流--样例

最新推荐文章于 2023-07-26 10:53:22 发布
最新推荐文章于 2023-07-26 10:53:22 发布
阅读量182 收藏
点赞数
分类专栏： 后端 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/go_____________ahead/article/details/105640926
版权
本文深入讲解Java中的IO流操作，包括字节流、字符流、缓存流等基本概念及其实现方法，如FileInputStream、FileOutputStream、FileReader、FileWriter、BufferedInputStream、BufferedOutputStream、BufferedReader和BufferedWriter的使用。
摘要由CSDN通过智能技术生成

一、低级流

1.字节输入流 FileInputStream

  1.每次读入一个

//每次读取一个
    public void inptutStream(String path) {
        //文件
    File file = new File ( path );
    //字节型输入流
    FileInputStream fis = null;
    {
        try {
            fis = new FileInputStream ( file );
            //每次读取一个
            int i=fis.read ();
            while (i != -1) {
                //转为字符型
                System.out.print( (char)i );
                //再次读取一个字符
                i=fis.read ();
            }
        } catch (IOException e) {
            e.printStackTrace ();
        }finally {
            try {
                //关闭输入流
                fis.close ();
            } catch (IOException e) {
                e.printStackTrace ();
            }
        }
    }
}

2.每次读入在byte数组中

 public void inptutStream2(String path) {
        //文件
        File file = new File ( path );
        //字节型输入流
        FileInputStream fis = null;
        {
            try {
                fis = new FileInputStream ( file );
                //每次读取10个字节放在数组中
                byte bytes[] = new byte[10];
                //返回每次读取多少个数据
                int code= fis.read (bytes);
                while (code!=-1) {

                    //防止最后一次读数据出现脏数据
                    String value=new String ( bytes,0,code );
                    System.out.print( value);
                   code= fis.read (bytes);
                }
            } catch (IOException e) {
                e.printStackTrace ();
            }finally {
                try {
                    fis.close ();
                } catch (IOException e) {
                    e.printStackTrace ();
                }
            }
        }
    }

2.字节输出流FileOutPutDemo

public void FileOutPutDemo(String path){
    //写入文件
    File file=new File ( path );
    //输出流
    FileOutputStream fos=null;
    try {
        //append"已追加的方式传参，不加是以覆盖的方式
        fos =new FileOutputStream ( file,true );
        //写入字符串
        String value ="\r写入文件";
        byte bytes[]=value.getBytes ();
        //字节写入文件
        fos.write (bytes);
        //刷新
        fos.flush ();
    } catch (FileNotFoundException e) {
        e.printStackTrace ();
    } catch (IOException e) {
        e.printStackTrace ();
    }finally {
        try {
            //关闭输入流
            fos.close ();
        } catch (IOException e) {
            e.printStackTrace ();
        }
    }
}

3.使用字节流复制一个文件

public void inputOutput(String path, File file) {

        //创建输入流
        FileInputStream fis = null;
        //复制文件路径
        System.out.println ( path + "copy_" + file.getName () );
        File newFile = new File ( path + "\\copy_" + file.getName () );
        //创建输出流
        FileOutputStream fos = null;
        try {
            fis = new FileInputStream ( file );
            fos = new FileOutputStream ( newFile, true );

            //读取数据
            byte[] bytes = new byte[1024];
            int code = fis.read ( bytes );
            int i = 1;
            while (code != -1) {
                //将输入写入
                fos.write ( bytes, 0, code );
                //刷新
                fos.flush ();
                //再次读取数据
                code = fis.read ( bytes );
            }


        } catch (FileNotFoundException e) {
            e.printStackTrace ();
        } catch (IOException e) {
            e.printStackTrace ();
        } finally {
            //关闭流
            try {
                fis.close ();
            } catch (IOException e) {
                e.printStackTrace ();
            }
            try {
                fos.close ();
            } catch (IOException e) {
                e.printStackTrace ();
            }
        }


    }

4.字符型输入流FileReader

 1.每次读取一个字符

    /**
     *
     * @param path 文件路径，文件名
     * @param fileName
     */
    public void fileReaderDemo(String path,String fileName){

        File file=new File ( path+fileName );
        //创建输入流
        FileReader fr=null;
        try {
             fr=new FileReader ( file );
             //返回每个字符的值
             int value=fr.read ();
             while (value!=-1){
                 //控制台打印
                 System.out.print ( (char) value );
                 //在从读取
                 value=fr.read ();
             }
        } catch (FileNotFoundException e) {
            e.printStackTrace ();
        } catch (IOException e) {
            e.printStackTrace ();
        }finally {
            //关闭流
            try {
                fr.close ();
            } catch (IOException e) {
                e.printStackTrace ();
            }
        }

    }

2.读取字符数组中

    /**
     *
     * @param path 文件路径，文件名
     * @param fileName
     */
    public void fileReaderDemo1(String path,String fileName){
        File file=new File ( path+fileName );
        //输入流
        FileReader fr=null;
        try {
            fr=new FileReader ( file );
            //用来存放读取文件的数据
            char value []=new char[1024];
            //返回读取多少个字符，没有读取到返回-1
            int code=fr.read (value);
            while (code!=-1){
                //控制台输出
                System.out.print ( value );
                //再次读取
                code=fr.read ();
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace ();
        } catch (IOException e) {
            e.printStackTrace ();
        }finally {
            //关闭流
            try {
                fr.close ();
            } catch (IOException e) {
                e.printStackTrace ();
            }
        }

    }

5.字符输出流 FileWriteDemo

    public void FileWriteDemo(String path, String fileName) {
        //数据写入的文件
        File file = new File ( path + fileName );
        //创建输出流
        FileWriter fw = null;
        try {
            fw = new FileWriter ( file );
            //将字符输入
            String value = "可以看到类中的代码比较乱";
            fw.write ( value );
            fw.flush ();

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

6.字符型输入流与输出流配合复制文本型文件

    /**
     * @param path     文件路径，文件名
     * @param fileName
     */
    public void ReaderWriteDemo(String path, String fileName) {
        //创建输入流与输出流
        FileReader fr = null;
        FileWriter fw = null;
        //复制的新文件
        File newFile = new File ( path + "new_" + fileName );
         //将一次读取数据放在数组中
        char values[] = new char[1024];
        try {
            //输入流与输出流
            fr = new FileReader ( path + fileName );
            fw = new FileWriter ( newFile );
            //返回一次读取多少个字符，没有读取返回-1
            int code = fr.read ( values );
            while (code != -1) {
                fw.write ( values, 0, code );
                //刷新
                fw.flush ();
                //再次读取
                code = fr.read ( values );
            }


        } catch (FileNotFoundException e) {
            e.printStackTrace ();
        } catch (IOException e) {
            e.printStackTrace ();
        } finally {
            //关闭流
            try {
                fr.close ();
            } catch (IOException e) {
                e.printStackTrace ();
            }
            try {
                fw.close ();
            } catch (IOException e) {
                e.printStackTrace ();
            }
        }
    }

二、缓存流

1. a.字节输入流

    public void bufferFileInputDemo(String path, String fileName) {
        //读取文件内容
        File file = new File ( path + fileName );
      //创建一个字节输入流
        FileInputStream fis = null;
        //创建一个字节缓存流
        BufferedInputStream bfis=null;
        try {
            //实例化
            fis = new FileInputStream ( file );
             bfis = new BufferedInputStream ( fis );
            //每次获取一个字节
            int value = bfis.read ();
            while (value != -1) {
                //打印
                System.out.print ( (char) value );
                value = bfis.read ();
            }


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

    b将读取数据放入数组中

    public void bufferFileInputDemo1(String path, String fileName) {
        //创建一个文件对象
        File file = new File ( path + fileName );
       //创建一个字节输入流
        FileInputStream fis = null;
        //创建一个缓存流
        BufferedInputStream bfis=null;
        try {
            //实例化
             fis = new FileInputStream ( file );
             bfis = new BufferedInputStream ( fis );
             //存放数据的数组
             byte bytes[]=new byte[1024];
             //判断是否读取几个字节
            int code = bfis.read (bytes);
            while (code != -1) {
                //将内容打印
                String value =new String ( bytes );
                System.out.print ( value );
                //继续读取
                code = bfis.read ();
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace ();
        } catch (IOException e) {
            e.printStackTrace ();
        } finally {
            //关闭流
            try {
                fis.close ();
            } catch (IOException e) {
                e.printStackTrace ();
            }
        }
    }

2.字节输出流

    public void bufferOutputDemo(String path, String filename) {
        //将数据存入文件中
        File file = new File ( path + filename );
        //创建输出流
        FileOutputStream fos = null;
        //创建缓存
        BufferedOutputStream bops = null;
        try {
            //实例化
            fos = new FileOutputStream ( file );
            bops = new BufferedOutputStream ( fos );
            //模拟数据
            String value = "qwerdf";
            //将数据写入文件中
            bops.write ( value.getBytes () );
            //刷新
            bops.flush ();


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

3.字符输入流

a.每次读取一个字符

  public void bufferDemo(String path, String filaname) {
        //读取数据文件
        File file = new File ( path + filaname );
        //创建一个字符型输入流
        FileReader fr = null;
        //创建一个缓存流
        BufferedReader br = null;
        try {
            //实例化
            fr = new FileReader ( file );
            br = new BufferedReader ( fr );
            //读取一个字符
            int value = br.read ();
            while (value != -1) {
             //控制台打印
                System.out.print ( (char) value );
                value = br.read ();
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace ();
        } catch (IOException e) {
            e.printStackTrace ();
        } finally {
            //关闭流
            try {
                br.close ();
            } catch (IOException e) {
                e.printStackTrace ();
            }
        }
    }

b。一次读取一个数组的数据

public void bufferDemo1(String path, String filaname) {
        //读取数据文件
        File file = new File ( path + filaname );
        //创建一个字符型输入流
        FileReader fr = null;
        //创建一个缓存流
        BufferedReader br = null;
        //存放放读取数据
        char values[] = new char[1024];
        try {
            //示例化
            fr = new FileReader ( file );
            br = new BufferedReader ( fr );
            //每次读取一个数组的数据
            int code = br.read ( values );
            while (code != -1) {
               //将数据控制台打印
                System.out.print ( (char) code );
                //继续读取
                code = br.read ();
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace ();
        } catch (IOException e) {
            e.printStackTrace ();
        } finally {
            //关闭流
            try {
                br.close ();
            } catch (IOException e) {
                e.printStackTrace ();
            }
        }
    }

c.每次读取一行数据

 public void bufferDemo2(String path, String filaname) {
        //读取数据文件
        File file = new File ( path + filaname );
        //创建一个字符型输入流
        FileReader fr = null;
        //创建一个缓存流
        BufferedReader br = null;
        try {
            //示例化
            fr = new FileReader ( file );
            br = new BufferedReader ( fr );
            //每次读取一行数据
            String value = br.readLine ();
            while (value != null) {
              //将数据打印
                System.out.println ( value );
                //继续读取数据
                value = br.readLine ();
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace ();
        } catch (IOException e) {
            e.printStackTrace ();
        } finally {
            //关闭流
            try {
                br.close ();
            } catch (IOException e) {
                e.printStackTrace ();
            }
        }
    }

4.字符输出流

    public void bufferdWrite(String path, String filename) {
        //写入目标文件
        File file = new File ( path + filename );
        //创建字符输出流
        FileWriter fw = null;
        //创建缓存流
        BufferedWriter bw = null;

        try {
            //实例化
            fw = new FileWriter ( file );
            bw = new BufferedWriter ( fw );
            //模拟数据
            String value = "我是钢铁侠";
            //数据写入文件
            bw.write ( value );
            //刷新
            bw.flush ();

        } catch (IOException e) {
            e.printStackTrace ();
        } finally {
            
            //关闭流
            try {
                bw.close ();
            } catch (IOException e) {
                e.printStackTrace ();
            }
        }
    }

 

go_____________ahead
关注
专栏目录
输入入门（编程入门题-C/C++&Java&Python实现）
一键难忘的博客
12-12 1675
输入入门（编程入门题-C/C++&Java&Python实现） 输出格式练习。 输入 输入数据有多组。 每组一行，为两个整数A，B。 输入以0 0结束。 输出 输出A+B的值，每组数据之间保留一个空行。 解决这个问题的思路与之前的类似，需要注意的是在每组输出之后加上一个空行。以下是解题思路： 1. **读取输入：** 使用循环结构（例如while循环）读取多组输入数据。每组数据包含两个整数A和B，输入以0 0结束。 2. **处理每组测试数据：** 在循环中，读取每组测试数据，并进行如下判断：
java输出输入的日期_Java编写的日历，输入年月，输出这个月的日期与星期
weixin_33212915的博客
02-16 1520
import java.util.Scanner;public class rili {public static void main(String[] args) {for (int g = 0; g < 100; g++) {Scanner in = new Scanner(System.in);System.out.println("\n请输入年份：");int year = in.n...
输入/输出流
qq_45838321的博客
06-19 1900
一.流的概念 1.输入/输出是一种基本的数据传递操作，它可以理解为字符序列在计算机 内存与外设之间的流动。 2.数据从一个对象到另一个对象的流动抽象为流，实现设备之间交换信息的类称为流类。 3.按面向对象方法组织的多个流类及其类层次集合构成了I/O流类库，简称为流库。 流库中的每一个流类都定义了一种设备之间的信息交换方式，按信息流 动方向的不同，可以分为输入/输出流。 与输入设备（如键盘）相联系的流称为输入流。 与输出设备（如屏幕）相联系的流称为输出流。 与输入输出设备相联系的流称为输入输出流。 二.流的种
Java输入输出流
weixin_30794491的博客
04-01 4873
1.什么是IO Java中I/O操作主要是指使用Java进行输入，输出操作.Java所有的I/O机制都是基于数据流进行输入输出，这些数据流表示了字符或者字节数据的流动序列。Java的I/O流提供了读写数据的标准方法。任何Java中表示数据源的对象都会提供以数据流的方式读写它的数据的方法。 Java.io是大多数面...
[转]Java输入输出流的使用详细介绍
weixin_34117211的博客
10-13 232
出处：http://www.jb51.net/article/36138.htm 1.什么是IO Java中I/O操作主要是指使用Java进行输入，输出操作.Java所有的I/O机制都是基于数据流进行输入输出，这些数据流表示了字符或者字节数据的流动序列。Java的I/O流提供了读写数据的标准方法。任何Java中表示数据源的对象都会提供以数据流的方式读写它的数据的方法。 ...
java中输出流OutputStream类应用实例
iteye_12813的博客
02-04 233
OutputStream类 该类是字节输出流的抽象类，定义了输出流的各种操作方法。这些方法的说明如表1所示。 下面通过实例介绍如何使用OutputStream类向控制台输出字符串信息。步骤如下。 （1）创建OutputStreamWriteStr类，在类中创建OutputStream类的实例对象out，并为其赋值为System类的out属性，该属性是控制台的输出流，再定义一个字节数组，该数组...
对输入流和输出流的一个例子辨析
谶生的博客
06-06 383
这里和我们一般编程中的输入输出流的使用不太一样，所以可能会导致误解。 这里首先初始化了一个输出流：注意到这里的使用： dos是baos的装饰器，内部实现是委派baos 往dos里面写一个随机数和一个true，由于dos是baos的装饰器，实际上数据写进了baos（注意到这个“写入流中”的操作） 起一个读入器bais，用途是读baos的内容（已经用一个Byte数组存起来了，bais是读这个byte数组的输入流） 起一个dis包装bais，读dis实质上就是读bais 从dis里面读出浮点数和布尔量。 （关.
java 输出流转换成输入流_在JAVA中如何将输出流转为输入流的类的实现
weixin_30847063的博客
02-13 4177
问题背景在实际应用中，我们会碰的一个功能的输出的字节流，是另一个功能输入字节流的情况。一般情况下，我们可以使用ByteArrayOutputStream和ByteArrayInputStream实现相应的功能。来看下面的测试代码：import java.io.ByteArrayInputStream;import java.io.ByteArrayOutputStream;import java....
【java】文件输出流 与 文件输入流 实例
intsum的博客
03-31 1611
IO流按数据流向分为 输入流（读数据）与 输出流（写数据） 按数据类型分为 字节流 与 字符流 以文件输出流为参考，了解输出流的应用（write数据的三种方式），【输入流则是read数据的三种方式】，了解字节流的特性及操作 FileOutputStream用于将数据写入Fille 以下是FileOutputStream的构造方法与写入 package IO; import java.io.FileOutputStream; import java.io.IO...
一文搞定Java IO流，输入流、输出流、字符流、缓冲流，附详细代码示例
最新发布
m0_71777195的博客
07-26 819
很多朋友问我，如何才能学好IO流，对各种流的概念，云里雾里的，不求甚解。用到的时候，现百度，功能虽然实现了，但是为什么用这个？不知道。更别说效率问题了~下次再遇到，再百度，“良性循环”。今天，我就用一天的时间，整理一下关于Java I/O流的知识点，分享给大家。每一种IO流，都配有示例代码，大家可以跟着敲一遍，找找感觉~
java输入流输出流
5431的专栏
10-25 783
java把不同来源和目标的数据称为抽象为数据流。在java中输入输出的功能很强大，提供了很庞大的类库，涉及到的领域很广：包括标准的输入输出、文件的操作、网络上的数据流、字符串流、对象流、zip文件流等。因为有如此多的类库，所以java的输入输出流的代码并不整洁。java流的分类 按流向分类： 输入流和输出流 按数据传输单位分类： 字节流和字符流 按功能分类： 节点流：用于直接操作
输入输出流
m0_52653999的博客
04-30 1720
程序在运行期间，可能需要从外部的存储媒介或其他程序中读入所需的数据，这就需要使用输入流。输入流的指向称为它的源，程序通过输入流读取源中的数据。另一方面，程序处理数据后，可能需要将处理的结果写入到永久的存储媒介中或传送给其他的应用程序，这就需要用输出流。输出流的指向称为它的目的地，虽然I/O流经常与磁盘文件存取有关，但是源和目的地也可以是键盘、内存或显示器窗口。 java.io包（I/O流库）提供大量的流类，所有输入流都是抽象类InputStream（字节输入流）或抽象类Reader（字符输入流）的子类，而所
Java输入、输出流
Haleyce的博客
01-04 1996
一、文件字节输入流 1. 构造方法 FileInputStream(String name); FileInputStream(File file); 参数name和file指定的文件称为输入流的源。 FileInputStream输入流打开一个到达文件的通道，当创建输入流时，可能会抛出IOException（IO异常）。 //使用构造函数 //FileInputStream(String name); try { FileInputStream input = new FileInputStre
Java之输入流和输出流
ldcaws的专栏
05-24 160
在 Java 中操作文件的方法本质上只有两种：字符流和字节流； 字节流分为输入字节流InputStream、输出字节流OutputStream； 字符流分为输入字符流Redaer、输出字符流Writer； 写入文件的方法主要使用输出字符流 Writer 和输出字节流 OutputStream 的子类； 输出字符流Writer经常使用的类为：FileWriter、BufferedWriter、PrintWriter； 实例： public class WriteExample { pub
输入流和输出流
weixin_43931125的博客
10-12 723
输入流和输出流 分为字节流，字符流 字节流：操作的数据单元是8位的字节，InputStream,OutputStream作为基类。 字符流:操作的数据单元是字符，以Writer,Reader作为基类。 处理文本文件用字符流。 IO流中的三类数据源 基于磁盘文件:FileInputStream, FileOutputStream, FileReader, FileWriter。 基于内存: ByteArrayInputStream, ByteArrayOutputStream。字节数组都是在内存中产生的。 基
输入流和输出流理解
热门推荐
Sanders_xu的博客
08-09 1万+
对于这个问题，你首先要知道“流”的概念，流就像水一样，源源不断的传送，它是一种数据传输的模式。根据数据流方向的不同，可分为输入流和输出流。 输入流就是把数据（键盘输入、鼠标、扫描仪等等外设设备）读入到内存（程序）中，输出流就是把内存（程序）中的数据输出到外设或其他地方，从文件角度简单总结就是，输入流就是读数据，输出流就是写数据。在这个过程中，始终把内存作为参考点。 在JAVA语言中，定义了专门...
Java输入输出示例教程压缩包
Java I/O（输入/输出）是Java编程中处理数据输入和输出的重要机制。Java I/O流库用于从数据源读取数据或者向数据目的地写入数据。数据源可以是文件、控制台输入或网络连接等，数据目的地同理。Java I/O涉及字节流和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值