JavaSE FileInputStream（文件字节输入流）

最新推荐文章于 2024-08-14 11:38:52 发布
最新推荐文章于 2024-08-14 11:38:52 发布
阅读量250 收藏
点赞数
分类专栏： JavaSE 文章标签： java 编程语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/LvJzzZ/article/details/108326293
版权

Java自我学习路线

FileInputStream（文件字节输入流）

一、java.io.FileInputStream

  • 文件字节输入流，任何类型的文件都可以采用这个流来读
  • 以字节的方式，完成输入的操作，完成读的操作（硬盘—> 内存）
  • 读取数据的原理（硬盘—>内存）
    Java程序–>JVM（Java虚拟机）–>OS(操作系统)–>OS调用读取数据的方法–>读取文件
  • 字节输入流的使用步骤
  1. 创建一个FileInputStream对象，构造方法中绑定要读取的数据源
  2. 调用FileInputStream对象中的方法read，读取文件
  3. 释放资源（流使用会占用一定的内存，使用完毕后要把内存清空，提高程序的效率）

1. 测试用例初步（开发不用）

  • 在D:\Test下创建temp文件，文件内容：abcdef
  • 读取字节：read方法，每次可以读取一个字节的数据，提升为int类型，读取到文件末尾，返回-1
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class FileInputStreamTest {
	public static void main(String[] args) {
		FileInputStream fis = null;
		try {
			// 创建文件字节输入流对象
			// 文件路径：D:\Test\temp （自动把\编程\\，因为java中\表示转义）
			// FileInputStream fis = new FileInputStream("D:\\Test\\temp");
			// 写成/也可以
			fis = new FileInputStream("D:/Test/temp"); // 编译时异常

			// 开始读（如果已达到文件末尾，则返回-1）
			int readData = fis.read(); // 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();
				}
			}
		}
	}
}
  • 对以上程序进行改进，采用循环的方式
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class FileInputStreamTest {
	public static void main(String[] args) {
		/**
		 * 在D:\Test下创建temp文件，文件内容：abcdef
		 * 此程序和以上程序一次读取一个字节byte，这样内存和硬盘交互太频繁，基本上时间/资源都耗费在交互上面了
		 */
		FileInputStream fis = null;
        try {
            fis = new FileInputStream("D:\\Test\\temp");

            /*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); // 97 98 99 100 101 102
            }

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fis != null) {
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
	}
}
  • 以上两个程序一次读取一个字节byte，这样内存和硬盘交互太频繁，基本上时间/资源都耗费在交互上面了
  • 对以上两个程序进行改进，一次读取多个字节

2. 测试用例改进

  • 使用字节数组读取int read(byte[] bytes)，一次最多读取 bytes.length 个字节，即往byte[]数组当中读，减少硬盘和内存的交互，提高程序的执行效率，读取到末尾时，返回-1
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class FileInputStreamTest {
	public static void main(String[] args) {
		/**
		 * 在D:\Test下创建temp文件，文件内容：abcdef
		 * 使用int read(byte[] bytes)
		 */
		FileInputStream fis = null;
		try {
			fis = new FileInputStream("D:\\Test\\temp");

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

			readCount = fis.read(bytes); // 第二次只能读取到2个字节
			System.out.println(readCount); // 2，即第二次读到了2个字节
			// 将字节数组全部转换成字符串
			// System.out.println(new String(bytes)); // efcd
			// 不应该全部都转换，应该是读取了多少个字节，转换多少个
			System.out.println(new String(bytes, 0, readCount)); // ef

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

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

3. 测试用例最终（掌握）

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

public class FileInputStreamTest {
	public static void main(String[] args) {
		FileInputStream fis = null;
		try {
			fis = new FileInputStream("D:\\Test\\temp");
			// 准备一个byte数组
			byte[] bytes = new byte[4];

			/*while(true) {
        	int readCount = fis.read(bytes);
        	if(readCount == -1) {
        		break;
        	}
        	// 把byte数组转换成字符串，读到多少个转换多少个
            System.out.print(new String(bytes, 0, readCount));
        }*/
			
			int readCount = 0;
			while ((readCount = fis.read(bytes)) != -1) {
				System.out.print(new String(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();
				}
			}
		}
	}
}

二、FileInputStream类的其它常用方法

1. int available()

  • 返回流当中剩余的没有读到的字节数量
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class FileInputStreamTest {
	public static void main(String[] args) {
		/**
		 * int available()：返回流当中剩余的没有读到的字节数量
		 */
		FileInputStream fis = null;
		try {
			fis = new FileInputStream("D:/Test/temp");
			System.out.println("总字节数量：" + fis.available()); // 6
			// 读1个字节
			 int readByte = fis.read();
			 System.out.println("剩下多少个字节没有读：" + fis.available()); // 5
			 byte[] bytes = new byte[fis.available()]; // 这种方式不太适合太大的文件，因为byte[]数组不能太大
			// 不需要循环了，直接读一次就行了
			 int readCount = fis.read(bytes); // 6
			 System.out.println(new String(bytes)); // bcdef

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

2. long skip(long n)

  • 跳过几个字节不读
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class FileInputStreamTest {
	public static void main(String[] args) {
		/**
		 * long skip(long n)：跳过几个字节不读
		 */
		FileInputStream fis = null;
		try {
			fis = new FileInputStream("D:/Test/temp");
			// skip()方法跳过几个字节不读取
			fis.skip(4);
			System.out.println(fis.read()); // 101
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			if (fis != null) {
				try {
					fis.close();
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		}
	}
}
Jayco江柯
关注
专栏目录
Java IO流之FileInputStream
饶玉龙的博客
05-29 279
目录介绍代码 介绍 FileInputStream继承自抽象类 InputStream A FileInputStream从文件系统中的文件获取输入字节。 什么文件可用取决于主机环境。 FileInputStream用于读取诸如图像数据的原始字节流。 要阅读字符串，请考虑使用FileReader 。 读取方式：如果达到文件的末尾， 返回 -1 代码 public static void readFile01() { String filePath = "d:/a.txt";
java fileinputstream转换字节流_关于FileInputStream文件字节输入流的使用
weixin_39818727的博客
02-27 1175
关于FileInputStream文件字节输入流：FileInputStream，称为文件字节输入流，属于万能流，一次读一个字节byte，什么文件都能读。也称为Read(读)，从硬盘 到 内存输入文件数据。测试代码：import java.io.*;public class Test02 {public static void main(String[] args) {// 创建文件字节输入流对象...
Java IO: FileInputStream
weixin_33769207的博客
03-26 105
原文链接作者:JakobJenkov译者:李璟(jlee381344197@gmail.com) FileInputStream可以以字节流的形式读取文件内容。FileInputStream是InputStream的子类，这意味着你可以把FileInputStream当做InputStream使用(FileInputStream与InputStream的行为类似)。 这是一个F...
JAVA中的FileInputStream
最新发布
qa3629723的博客
08-14 796
Java中的FileInputStream类是Java IO包中的一个重要类，它用于从文件系统中的文件获取输入字节流。以下是关于FileInputStream类的详细介绍、代码例子及中文注释。一、FileInputStream类概述。使用场景：当需要读取本地文件系统中的文件时，可以使用FileInputStream类。作用：FileInputStream类用于读取文件中的数据，它继承自InputStream类。以上代码演示了如何使用FileInputStream类读取文件内容。
java_io.FileInputStream
伤心书生的专栏
10-26 845
没有展示没有炫耀 只是为单纯的飞蛾扑火 希望能被你所用 package com.java_io.FileInputStream; import java.io.BufferedWriter; import java.io.FileWriter; public class Test { public static void main(String[] args) throws Exce
java.io.FileInputStream
TRasdzz的博客
10-08 1355
java.io.FileInputStream 文件字节输入流，万能的，任何类型的文件都可以采用这个流来读。 字节的方式，完成输入的操作，完成读的操作（硬盘—>内存） 常用的方法 int read() FileInputStream fis = null; try { //创建文件字节输入流对象 //以下都是采用了：绝对路径 //文件路径：E:\学习\Java\代码相关\基础语法\s
关于FileInputStream文件字节输入流的使用
pipizhen_的博客
07-21 1234
关于FileInputStream字节输入流： FileInputStream，称为字节输入流，属于万能流，一次读一个字节byte，什么文件都能读。 也称为Read（读），从硬盘 到 内存输入数据。 测试代码： import java.io.*; public class Test02 { public static void main(String[] args) { // 创建字节输入流对象 FileInputStream fis = null;
关于FileInputStream（万能文件字节输入流）
heliuerya的博客
12-23 755
关于FileInputStream（万能文件字节输入流）
JavaSE之IO流中的字节输出流（OutputStream）、字节输入流（InputSream）和字符输入流（Reader）、字符输出流（Writer）
Meteorazj的博客
03-16 1984
字节输出流和字节输入流均位于java.io包下，且均为抽象类，两者都有诸多子类，FileOutputStream和FileInputStream是两者各自的子类之一，分别为文件字节输出流和文件字节输入流 一、字节输出流（OutputStream） 该类中的一些方法如下： FileOutputStream类有多个构造方法： 1.FileOutputStream(String name); 创建一个向具有指定名称的文件中写入数据的输出文件流，String name：文件的路径 2.File...
Java字节流输入流FileInputStream的简单使用
I want to fly higher
02-12 975
官网API: https://docs.oracle.com/javase/8/docs/api/java/io/FileInputStream.html public static void main(String[] args) throws IOException { getConstructor(); //getLoanShift(); //getLoanShiftThr...
Java使用FileInputStream流读取文件示例详解
08-18
主要介绍了Java使用FileInputStream流读取文件示例详解，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
javaIO FileInputStream
小蓝的博客
05-06 3792
JavaIO流分为输入流、输出流.也可以分为：字节流、字符流FileInputStream 实现了在文件上的读取数据操作IO流分类：1如果是按照数据的流向划分：(1) 输入流(2) 输出流2 如果按照处理的单位划分：(1) 字节流: 字节流读取得都是文件中二进制数据，读取到二进制数据不会经过任何的处理。(2) 字符流： 字符流读取的数据是以字符为单位的 。字符流也是读取文件中的二进制数据，不过会把...
java io -- FileInputStream
zhao123h的专栏
10-15 3430
接上篇文章java io -- InputStream，本文将剖析InputStream中最常用的一个子类FileInputStream FileInputStream是对一个文件抽象而成的数据流，我们这里先展示一下这个类的结构。 图1 FileInputStream类 可以看到，这个结构和InputStream大致一致，不过多了一些特性。 首先这个类的构造函数，可以通
JAVAio流之FileInputStream
2301_76716766的博客
05-22 164
在每次调用read时候指针都会移动一次，这就会导致数据丢失！InputStream,即从文件中读取数据。
JAVA-IO流-FileInputStream
人生若只如初见的博客
03-24 318
//每次读取一个字节 try { //文件输入流的对象一旦生成，那么这个流就是打开的。 FileInputStream fis = new FileInputStream("1.txt"); //每次只能读取一个字节 也有一个类似游标的东西。 //如果read 方法返回的是-1 表明该流读到末尾了。 byte temp[] = new byte[4]; ...
Java IO流（2.4）——FileInputStream
m0_57497737的博客
07-12 166
FileInputStream中read(byte[] b)方法的使用 文章目录FileInputStream中read(byte[] b)方法的使用代码展示1.框架2.被读取文件展示3.read(byte[] b)方法的使用4.简化版 代码展示 1.框架 框架很注重要，一定要会搭 package IO; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.IOException;
Java中的IO流（ FileInputStream）
张子又
12-26 282
InputStream:字节输入流（抽象类） FileInputStream：文件字节输入流 public static void main(String[] args) throws IOException { //1:创建字节输入流 File file = new File("工程天下.txt"); System.out.println(file.length()); Fil...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Jayco江柯

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值