FileInputStream与FileOutputStream

最新推荐文章于 2024-05-30 14:22:30 发布
最新推荐文章于 2024-05-30 14:22:30 发布
阅读量748 收藏 3
点赞数 3
分类专栏： 大白Java成长日记（Java基础） 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq2632246528/article/details/114602119
版权

文章目录

1、FileInputStream

java.io.FileInputStream:
1、文件字节流，万能的，任何类型的文件都可以采用这个流来读。
2、字节的方式，完成输入的操作，完成读的操作（硬盘–>内存）

1.1 int read() ：从此输入流中读取一个数据字节

示例代码1：

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

public class FileInputStreamtest1 {
    public static void main(String[] args) {
        FileInputStream fis = null;
        try {
            //创建文件字节输入流对象
            fis = new FileInputStream("C:\\Users\\Administrator\\Desktop\\temp.txt");

            //开始读
            int readData = fis.read();//这个方法的返回值是：读取到的“字节”方法本身
            System.out.println(readData);//97

            readData = fis.read();
            System.out.println(readData);//98

            readData = fis.read();
            System.out.println(readData);//99

            readData = fis.read();
            System.out.println(readData);//100

            readData = fis.read();
            System.out.println(readData);//101

            readData = fis.read();
            System.out.println(readData);//102

            //已经读到文件的末尾了，在读的时候读取不到任何数据，返回-1
            readData = fis.read();
            System.out.println(readData);// -1

            readData = fis.read();
            System.out.println(readData);//-1


        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //在finally语句块当中确保流一定关闭
            if (fis != null) {
                //关闭流的前提是：流不是空。流是null的时候没必要关闭。
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

    }
}

temp文件：
在这里插入图片描述

运行结果：
在这里插入图片描述

演示：
在这里插入图片描述
对上一个程序进行改进（使用while循环输出字节）：

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

public class FileInuputStreamtest2 {
    public static void main(String[] args) {
        FileInputStream fis = null;
        try {
            fis = new FileInputStream("C:\\Users\\Administrator\\Desktop\\temp.txt");

            while (true){
                int readData = fis.read();
                if (readData == -1){
                    break;
                }
                System.out.println(readData);
            }
            
			//改造while循环
            int readData = 0 ;
            while ((readData =fis.read())!= -1){
                System.out.println(readData);
            }

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //在finally语句块当中确保流一定关闭
            if (fis != null) {
                //关闭流的前提是：流不是空。流是null的时候没必要关闭。
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

    }
}

运行结果：
在这里插入图片描述

1.2 int read(byte[] b)一次最多读取b.length个字节

减少硬盘和内存的交互，提高程序的执行效率。
往byte[] 数组当中读
在这里插入图片描述
在这里插入图片描述

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

public class FileInputStreamtest3 {
    public static void main(String[] args) {
        FileInputStream fis = null;
        try {
            //相对路径的话呢？相对路径一定是从当前所在的位置作为起点开始找！
            //在IDEA中默认的当前路径是哪里？ 工程Project的根就是IDEA的默认当前路径
            fis = new FileInputStream("temp");

            //开始读，采用byte数组，一次读取多个字节。最多读取：数组.length 个字节
            byte[] bytes = new byte[4];//准备一个4个长度的byte数组，一次最多读取4个字节。
            //这个方法的返回值是：读取到的字节数量(不是字节本身)
            int readCount = fis.read(bytes);
            System.out.println(readCount);
            //将字节数组全部转化为字符串
            System.out.println(new String(bytes));
            //不应该全部都转换，应该是读取了多少字节，转换多少个
            System.out.println(new String(bytes,0,readCount));

            readCount = fis.read(bytes);//第二次只能读取到2个字节
            System.out.println(readCount);//2
            System.out.println(new String(bytes));
            System.out.println(new String(bytes,0,readCount));

            readCount = fis.read(bytes);//第三次1个字节都没有读取到返回-1
            System.out.println(readCount);//-1
            System.out.println(new String(bytes));

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

运行结果：
在这里插入图片描述
改进后（while循环）：

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

public class FileIuputStreamtest4 {
    public static void main(String[] args) {
        FileInputStream fis = null;
        try {
            fis = new FileInputStream("temp");
            byte[] bytes = new byte[4];
            while(true){
                int readCount = fis.read(bytes);
                if (readCount == -1){
                    break;
                }
                System.out.print(new String(bytes,0, readCount));
            }
或
			/*
			int readCount1 = 0;
            while ((readCount1 = fis.read(bytes))!= -1){
                System.out.print(new String(bytes,0,readCount1));
            }
            */

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

        }
    }
}

运行结果：
在这里插入图片描述

1.3int available() :返回流当中剩余的没有读到的字节数量

在上述代码的前提下进行修改：

            fis = new FileInputStream("temp");
            System.out.println("总字节数量" + fis.available());
            //读取1个字节
            int readByte = fis.read();

            System.out.println("剩下多少字节没有读：" + fis.available());

运行结果：
在这里插入图片描述
也可采用以下方法输出文件（不适合太大的文件，因为byte[]数组不能太大大）

            byte[] bytes = new byte[fis.available()];
            System.out.println(fis.read(bytes));
            System.out.println(new String(bytes));

运行结果：
在这里插入图片描述

1.4 long skip(long n ):跳过几个字节不读

修改以上代码：

		fis.skip(3);
        System.out.println(fis.read());//不跳过应该是97,现在是100

运行结果：
在这里插入图片描述

2、FileOutputStream

文件字节输出流，负责写。

从内存到硬盘。

2.1 输入字节到文件

这种方式将字节输出到文件中（但是谨慎使用，这种方式会将原文件清空，然后重新写入）：

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

public class FileOutputStreamtest1 {
    public static void main(String[] args) {
        FileOutputStream fos = null;
        try {
            //myfile文件不存在的时候会自动新建
            fos = new FileOutputStream("myfile");
            //开始写
            byte[] bytes = {97,98,99,100,101,102};
            //将byte数组全部写出！
            fos.write(bytes);
            //将byte数组的一部分写出
            fos.write(bytes,0,2);
            //写完之后，一定要刷新
            fos.flush();

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

运行结果：
在这里插入图片描述

以追加的方式在文件末尾写入。不会清空原文件内容：
只需在后面加true，即可拼接

fos = new FileOutputStream("myfile",true);

运行结果：
在这里插入图片描述

2.2 输入字符串到文件

			String s = "我是任义";
            byte[] bs = s.getBytes();
            fos.write(bs);

输出结果：
在这里插入图片描述

3、使用FileInputStream+FileOutputStream完成文件拷贝

拷贝的过程是一边读一边写。
使用以上的字节流拷贝文件的时候，文件类型随意，万能的。什么样的文件都能拷贝
在这里插入图片描述

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

public class Copy01 {
    public static void main(String[] args) {
        FileInputStream fis = null;
        FileOutputStream fos = null;
        try {
            //创建一个输入流
            fis = new FileInputStream("C:\\Users\\Administrator\\Desktop\\简历.txt");
            //创建一个输出流
            fos = new FileOutputStream("D:\\简历.txt");

            //最核心的：一边读，一边写
            byte[] bytes = new byte[1024*1024];//1MB(一次最多拷贝1MB)
            int readCount = 0;
            while ((readCount = fis.read(bytes))!= -1){
                fos.write(bytes,0,readCount);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }catch (IOException e){
            e.printStackTrace();
        }finally {
            if (fis != null){
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            if (fos !=null){
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            }
        }
    }
}

在这里插入图片描述

在这里插入图片描述

夢想家吖
关注
  • 3
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
FileInputStream和FileOutputStream应用
xinfeng777的博客
03-26 422
* 1.流的分类 * 按流向分：输入流(InputStream,Reader作为基类)和输出流(OutputStream,Write作为基类) * 按处理数据的单元划分：字节流(InputStream,OutputStream)和字符流(Reader,Write) * 按角色划分：节点流(直接作用于文件的)  处理流 * 2.IO体系 * 抽象基类
java FileInputStream与FileOutputStream
u010903286的博客
11-14 152
FileInputStream和FileOutputStream的参数不能是一个已经存在的目录名称。 输入输出都是相对于应用程序而言的。所以应该创建一个输入类读取A文件中的内容，然后创建一个输出类 写入B文件。 程序去读取A中的内容，然后输出到B文件。 import java.io.*; public class FileStreamTest {     public st...
FileInputStream和FileOutputStream
weixin_75202470的博客
06-29 3992
和是 Java I/O中用于处理文件输入和输出的流类。它们是字节流，用于读取和写入字节数据。：用于从文件中读取字节数据。它继承自类。通过创建对象，可以打开一个文件，并从该文件中读取数据。可以使用read()方法逐个字节地读取数据，也可以使用方法一次读取多个字节到字节数组中。读取完成后，应该调用close()方法关闭流。：用于向文件中写入字节数据。它继承自类。通过创建对象，可以打开一个文件，并向该文件中写入数据。可以使用write(int)方法逐个字节地写入数据，也可以使用方法一次写入多个字节。
FileInputStream 和 FileOutputStream
qq_51328499的博客
11-21 6912
1、什么是流 流是一连串流动的字符, 是一组有序的数据序列，是以先进先出方式发送信息的通道，将数据从一个地方带到另一个地方，在 java 中所有数据都是使用流读写的。同时可以通过流进行文件的读写操作。 2、流的分类 按照流向，可以分为输入流和输出流两大类 简单来说，可以理解为将磁盘中的数据读入到内存中即为输入流；相反，将内存中的数据存入磁盘中即为输出流 按处理数据的单元，可以将流分为字节流和字符流两大类 字节流是...
总结 File 类的用法和 InputStream, OutputStream 的用法
最新发布
2301_79547900的博客
05-30 1025
如何使用这两个方法呢：1.填写字符串表示的文件路径（绝对/相对路径均可）2.填写File对象这先是打开文件，如果没有出现异常打开成功，接下来就是读取文件内容版本一，一次write一个字节，参数是int类型版本二，一次write若干个字节，会把参数数组中的所有字节写入文件中。版本三，一次write若干个字节，把数组offset下标开始，连续写len个字节。这样打开之后，就会清空文件夹，要不想清空，就要以追加写的方式打开，也就是增加一句true。
操作系统——File类和InputStream，OutputStream类详解
xh1605004242的博客
04-15 5004
File类和InputStream, OutputStream类
二、文件输入输出流FileInputStream/FileOutputStream解析与使用
猿小许的博客
08-31 6764
一、阻塞式IO模型     Java IO是Java自带的 API，用于读取和写入数据（输入和输出）。大多数应用程序需要处理一些输入并根据该输入产生一些输出。例如，从文件或通过网络读取数据，然后通过网络写入文件或写回响应。    Java IO API 位于 Java IO 包 ( java.io) 中。如果您查看包中的 Java IO 类，那么java.io大量的选择可能会令人困惑。所有这些课程的目的是什么？对于给定的任务，您应该选择哪一个？你如
Java中的FileInputStream 和 FileOutputStream 介绍_动力节点Java学院整理
08-30
Java中的`FileInputStream`和`FileOutputStream`是用于处理文件输入和输出操作的基本类，它们分别继承自`InputStream`和`OutputStream`。这两个类在Java I/O系统中扮演着核心角色，提供了对文件进行字节级读写操作的...
FileInputStream 和 FileOutputStream 介绍_动力节点Java学院整理
10-24
FileInputStream 是文件输入流，它继承于InputStream。 通常，我们使用FileInputStream从某个文件中获得输入字节。 FileOutputStream 是文件输出流，它继承于OutputStream。 通常，我们使用FileOutputStream 将数据...
FileStreamReadWrite FileInputStream FileOutputStream 简单示例
02-26
File read write FileInputStream FileOutputStream 简单示例
FileInputStream和FileoutputStream的使用语法和实例
02-13
FileInputStream和FileoutputStream的使用语法和实例
【IT十八掌徐培成】Java基础第13天-04.字节流-FileInputStream-FileOutputStream.zip
08-07
本课程由IT十八掌徐培成讲解，重点介绍了Java基础中的字节流操作，特别是`FileInputStream`和`FileOutputStream`这两个核心类的使用。 `FileInputStream`和`FileOutputStream`是Java.io包下的核心类，它们分别代表...
文件输入(FileInputStream)、输出(FileOutputStream)流操作
热门推荐
一恍过去
02-13 1万+
文件输入(FileInputStream)、输出(OutputStream)流操作
JavaSE -- FileOutputStream 和 FileInputStream
weixin_37963567的博客
07-30 356
1、FileOutputStream :文件字节输出流 java.io.FileOutputStream extends OutputStream java.io.OutputStream:字节输出流，是一个抽象类，是所有字节输出流的超类。 构造方法的作用： （1）创建一个 FileOutputStream 对象； （2）根据构造方法中的文件或文件路径，创建一个空文件； （3）将创建好的 FileOutputStream 对象指向创建好的文件。 文件字节流的使用步骤： ...
FileInputStream 和FileOutputStream的概述，看完秒懂，内布操作
虚空掠夺者~
08-27 731
底层的最原本的文件字节流的操作：InputStream outputStream 1 .InputStream 和 OutputStream两个字节流都是抽象类，不能进行实例化操作，使用它的子类进行文件按的操作 2. 字节输出流：从内存中按字节流的形式写出到硬盘等存储介质上——FileInputStream 1. 字节输出流和字符输出流是不一样的，字节输出流底层是没有自带的缓冲取得， 2. 如果使用构造方法中中append参数，不指定默认位false那么每次写出的内容将会崔原来的内容进行全面
java之IO流(一) -- FileOutputStream+FileInputStream
weixin_50533562的博客
04-22 1155
java中IO流之FileInputStream和FileOutputStream
【Java】FileInputStream和FileOutputStream基本使用
兮动人
04-02 1273
FileInputStream和FileOutputStream基本使用
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值