Java 输入输出流及文件读写详解

合集下载

字节流和字符流进行读写操作的一般步骤

字节流和字符流进行读写操作的一般步骤
字节流和字符流是 Java 中用于数据读写的两种基本流，它们有着不同的特点和应用场景。

在字节流中进行读写操作一般包括以下步骤:
1. 打开文件或输入输出流：使用相应的打开方法，如打开FileInputStream 或 FileOutputStream 对象，打开文件或输出流。

2. 读取数据：使用输入流的 read() 方法或 RandomAccessFile 类的 read() 方法读取数据，将其存储在字节数组或字符数组中。

3. 处理数据：对读取到的数据进行处理，如将其转换为字符串、打印到控制台等。

4. 关闭流：使用相应的关闭方法，如 FileInputStream.close() 或 FileOutputStream.close() 方法，关闭文件或输入输出流。

在字符流中进行读写操作一般也包括以下步骤:
1. 打开文件或输入输出流：与字节流相似，使用相应的打开方法打开文件或输入输出流。

2. 读取字符：使用输入流的 read() 方法或 RandomAccessFile 类的 read() 方法读取字符，将其存储在字符数组中。

3. 处理字符：对读取到的字符进行处理，如将其转换为字符串、打印到控制台等。

4. 关闭流：与字节流相似，使用相应的关闭方法，如FileInputStream.close() 或 FileOutputStream.close() 方法，关闭文件或输入输出流。

不过，在字符流中，读取的字符需要进行编码转换，以适应不同的字符编码方案。

例如，在读取文本文件时，需要将读取到的字符进行 UTF-8 编码转换，以确保读取的字符符合文本文件的格式。

Java的输入与输出流(实验报告)

成都大学实验报告实验项目名称Java的输入与输出流一、实验目的：1. 理解I/O流的概念，掌握其分类2. 掌握文本文件读写、二进制文件读写二、实验内容（包括源程序及相关说明）：1. 分别使用FileWriter 和BufferedWriter 往文件中写入10万个随机数，比较用时。

源代码如下：（1）import java.io.*;public class Ex1_1 {public static void main(String[] args) throws IOException{long t=System.currentTimeMillis();FileWriter fw =new FileWriter("d:\\Ex1.txt");for(int i=1;i<=100000;i++){fw.write((int)(Math.random()*10000)+" \n");}fw.close();t=System.currentTimeMillis()-t;System.out.println("The elapsed: "+t);}}（2）import java.io.*;public class Ex1_1 {public static void main(String[] args) throws IOException{long t=System.currentTimeMillis();BufferedWriter fw=new BufferedWriter(new FileWriter("d:\\Ex1.txt"));for(int i=1;i<=100000;i++){fw.write((int)(Math.random()*10000)+"\n");}fw.close();t=System.currentTimeMillis()-t;System.out.println("The elapsed: "+t);}}2. 生成一个html文件，使其能显示2的幂次(0~9)的表格如下：代码如下：import java.io.*;public class Ex1_1 {public static void main(String[] args) throws IOException{BufferedWriter bw=new BufferedWriter(new FileWriter("d:\\Ex2.html"));bw.write("<table border=1 align=center width=200 height=250>");bw.newLine();bw.write("<tr><td align=center>Power of 2<td align=center>Value</tr>");for(int i=0;i<=9;i++){bw.write("<tr><td align=center>"+i+"<td align=center>"+Math.pow(i, 2)+"</tr>");}bw.write("</table>");bw.newLine();bw.close();}}3. 在文本文件bigbook.txt中包含有很长篇幅的英语短文，编写程序要求统计文件的所有短文中包含英文字母“A”的个数，并显示统计的时间。

第7章 Java的输入输出流

第7章 Java的输入/输出流
String dirList[]=f1.list(m); for(int i=0;i<dirList.length;i++) Transcript.println(dirList[i]); } } public MyClass3(File f) { this.f=f; } public boolean accept(File dir, String name){ return name.startsWith("un"); } }
第7章 Java的输入/输出流
该程序的运行结果如图7.3所示。此程序中，我们为了说明路径分隔符的使用方法，实例化文件对象的时候给出了全路径，其实由于我们已经在Java系统中设置好了源路径，只要给出文件名就行了。表7.1中，list方法用于列出一个目录中所有的文件或与某个模式相匹配的文件。下面我们给出两个例子来讨论带参数或不带参数的list方法的使用。
返回指定格式的目录中的文件名返回当前目录中的所有文件名创建目录，成功返回真创建路径中所有目录，成功则返回真返回路径分隔符文件更名，成功返回真返回文件分隔符返回对象的字符串表示
第7章 Java的输入/输出流
下面我们给出几个File类的应用实例。通过例题的使用，希望读者对File类有更清楚的认识。例7.1 import java.io.*; public class MyClass1 { public static void main(String args[]){ Filef=new File("c:\\jbuilder3\\myprojects\\untitled5\\MyClass1.java"); if(!f.exists())

java 顺序读写文件的原理

java 顺序读写文件的原理Java顺序读写文件的原理顺序读写文件是一种常见的文件操作方式，特别是用于处理大型文件或者需要按照固定顺序访问文件内容的情况。

Java提供了多种API和技术来实现顺序读写文件，下面将介绍其原理。

1. 读取文件（顺序读取）：顺序读取文件主要通过FileInputStream类来实现。

以下是其原理：- 使用FileInputStream类的构造函数创建一个文件输入流对象，并指定要读取的文件路径。

- 创建一个字节数组或者字符数组作为缓冲区，用来存放从文件中读取的数据。

- 使用read方法从文件输入流中读取数据，并将数据存入缓冲区。

read方法会返回读取的字节数或者字符数，如果已经读取到文件末尾，则返回-1。

- 重复执行上述步骤，直到读取完整个文件内容。

2. 写入文件（顺序写入）：顺序写入文件主要通过FileOutputStream类来实现。

以下是其原理：- 使用FileOutputStream类的构造函数创建一个文件输出流对象，并指定要写入的文件路径。

- 创建一个字节数组或者字符数组作为缓冲区，用来存放待写入的数据。

- 使用write方法将缓冲区中的数据写入文件输出流。

write方法会将数据写入文件并返回写入的字节数或者字符数。

- 重复执行上述步骤，直到写入完所有数据。

- 使用close方法关闭文件输出流，确保所有数据都被写入文件。

需要注意的是，顺序读写文件时要合理设置缓冲区的大小。

缓冲区太小会导致频繁的IO操作，影响性能；缓冲区太大则会占用过多内存。

因此，根据实际情况调整缓冲区大小以达到最佳性能。

另外，为了保证顺序读写文件的稳定性和可靠性，建议在读写文件时使用try-catch-finally或者try-with-resources语句块，确保资源能够被正确释放。

总结：顺序读写文件是通过Java的FileInputStream和FileOutputStream类来实现的。

java输入输出流读取文件路径并保存到文本中

} catch (Exception e) {
e.printStackTrace();
}
try {
File file = new File("c:\\a.txt"); //创建一个file文件
FileWriter writer = new FileWriter(file);
File f = new File(strPath);
if (f.isDirectory()) {
File[] fList = f.listFiles();
for (int j = 0; j < fList.length; j++) {
if (fList[j].isDirectory()) { //判断是否为文件夹
fos.close();
}catch(FileNotFoundException e){
System.out.println("FileStreamsTest"+e);
}catch(IOException e)
writer.write(n); //把目录写到文件file中
writer.close();
}
catch (IOException ex) {
System.err.println(ex);
}
}
public static void main(String[] args) {
String strPath = "C:\\dev\\training"; //选择路径
System.out.println(strPath);
try {
getDir(strPath);

《java输入输出》课件

System.out.format
通过格式化字符串将数据输出到控制台。
String.format
将数据格式化字符串并返回格式化结果。
异常处理
1
try -catch语句
通过添加try-catch语句来处理异常。
2
fin ally 语句
无论是否发生异常，finally语句块中的代码都会执行。
3
自定义异常
开发自定义异常来处理特殊情况。
字符输入输出
字符读取
使用Reader类读取字符信息。
字符写入
使用Writer类向文件中写入字符信息，可支持中文。
二进制输入输出
1 输入
使用BufferedInputStream类从二进制文件中读取信息。
2 输出
使用BufferedOutputStream类将信息写入二进制文件中。
格式化输入输出
控制台输出
使用System.out.print来在控制台输出信息。
键盘输入
使用Scanner类从键盘获取用户输入的信息。
文件输入输出
1
文件读取
使用File类和Scanner类从文件中读取信息。
2
文件写入
使用FileWriter类和PrintWriter类信息写入文件中。
3
二进制文件读写
使用InputStream和OutputStream类读写二进制文件。
《java输入输出》PPT课件
本课程将教您如何处理各种输入输出并展示Java编程语言的强大功能。
输入输出概述
输入
从外部读取数据到计算机中，例如键盘输入。
处理
综合输入和输出，对外部数据做出处理。
输出
将数据从计算机输出到外部，例如屏幕输出。

java08(第8章输入输出流)

在java.io包中定义了很多这二个基本类具体实现包中定义了很多这二个基本类具体实现输入输出功能的子类，输入输出功能的子类，表8.1为部分常用字节输入为部分常用字节输入流类和字节输出流子类的功能。流类和字节输出流子类的功能。
表8.1
类名 FileInputStream 和 FileOutputStream ByteArrayInputStream和 ByteArrayOutputStream ObjectInputStream 和 ObjectOutputStream FilterInputStream 和 FilterOutputStream DataInputStream 和 DataOutputStream BufferedInputStream 和 BufferedOutputStream
【例8-1 】
1. /* 读取文件 */ 2. import java.io.FileInputStream; 3. import javax.swing.JOptionPane; 4. class Example8_1 5. { public static void main( String args[ ]) 6. { byte buffer[ ] = new byte[2056]; 7. String str; 8. try{ 9. File file=new File("d:/jtest/test.dat"); 10. FileInputStream fileInput = new FileInputStream(file); 11. int bytes = fileInput.read( buffer, 0, 2056 ); //读到的字节数读到的字节数 12. str = new String( buffer, 0, bytes ); 13. } 14. catch(Exception e) 15. { 16. str= e.toString(); 17. } 18. JOptionPane.showMessageDialog(null,str); 19. System.exit(0); //退出程序退出程序 20. } 21. }

Java中常用数据类型的输入输出详解

Java中常⽤数据类型的输⼊输出详解⽬录1、Char型1.1 输⼊格式：1.2 举例说明2、int型1.1 简单的int格式输⼊：1.2 举例说明2.1带空格的int格式输⼊：2.2 举例说明3.1 复杂int格式的输⼊3.2 举例说明3、double型1.1 double保留两位格式输出1.2 举例说明4、多次输⼊1.1 输⼊格式1.2 举例说明5、数组1.1 数组输⼊格式：2.1 数组转换成字符串6、字符串1.1 字符串转换成整型，浮点型（以整型为例）1.2 整型，浮点型转换成字符串2.1 字符串转换成字符数组2.2 字符数组转换成字符串3 举例说明7、写在最后C语⾔学习完转到Java后，第⼀个感觉就是Java的写法很复杂，同时，在常⽤的数据类型的输⼊输出上也没有C语⾔那么⽅便。

在C语⾔上⾯，⽤ scanf 函数可以很⽅便的输⼊⼤多数格式，在Java上却不⾏，Java当中没有类似于scanf的语句。

本⽂搭配本⼈的输⼊输出习惯及做题的记录，对这些不同类型的如整型的，是整型的但隔开参数的...做⼀个总结。

下⾯的说明中主类均为Main类，我们使⽤Scanner来进⾏输⼊。

每⼀种输⼊或输出可能有多种⽅法，本⼈只写了较为简单的写法。

1、Char型这⾥说的char型指的是只输⼊⼀个字符的情况。

1.1 输⼊格式：import java.io.IOException;//导⼊包public class Main {public static void main(String[] args) throws IOException {char ch = (char)System.in.read();//<1>System.out.println((int)ch);}}说明：需要搭配IOException异常来使⽤。

<1>中，System.in就是从标准输⼊流（最常见的是键盘）输⼊，rand()⽅法是从这个流⾥⾯读取输⼊的内容。

java

System.out.println("文件名： "+myFile.getName()); System.out.println("文件的相对路径:"+myFile.getPath()); System.out.println("文件绝对路径:"+myFile.getAbsolutePath()); System.out.println("上一级目录名:"+myFile.getParent());
（2）public File（String pathname， String name）；参数pathname指明新创建的文件对象所对应的文件所在的路径，可以是绝对路径或相对路径。参数name指明新创建的文件对象所对应文件的名称。将路径和名称分开可使具有相同路径的文件具有同一个路径字符串，而且方便管理。例如： File myFile=new File("c:\java", "test.txt");
System.out.println("文件长度:"+myFile.length()); System.out.println("是文件吗?"+myFile.isFile()); System.out.println("是目录吗?"+myFile.isDirectory()); System.out.println("是否可写?"+myFile.canWrite());
第9章 Java输入输出
9.1 Java输入输出概述
9.2 文件处理 9.3 目录管理

java中基本输入输出流的解释

java中基本输入输出流的解释1.网络程序的很大一部分是简单的输入输出，即从一个系统向另一个系统移动字节。

字节就是字节，在很大程度上，读服务器发送的数据与读取文件没什么不同；向客户传送数据与写入一个文件也没有什么区别。

Java中输入和输出组织不同于大多数其他语言。

它是建立在流(stream)上。

不同的基本流类(如java.io.FileInputStream和.TelnetOutputStream)用于读写特定的数据资源。

但是所有的基本输出流使用同一种基本方法读数据。

过滤器流可以连接到输入流或输出流。

它可以修改已经读出或写人的数据(例如，加密或压缩数据)，或者可以简单地提供附加方法将已经读出或写入的数据转化成其他格式。

最后Reader和Writer也可以链接到输入流和输出流，从而允许程序读出和写入文本(即字符)而不是字节。

如果使用正确，Reader和Writer能够处理多种类型的字符编码，包括SJIS和UTF-8等多字节字符集。

一、输出流java的基本输出流是 java.io.OutputStream.public abstract class OutputStreamn public abstract void write(int b) throws IOExceptionn public void write(byte[] data) throws IOExceptionn public void write(byte[] data,int offset,int length) throws IOExceptionn public void flush() throws IOExceptionn public void close() throws IOExceptionOutputStream的子类使用这些方法向指定媒体写入数据。

我始终相信，我们理解了为什么它们存在，就会更好地记住它们，好，现在开始说一下OutputStream类的方法的由来public abstract void write(int b) throws IOExceptionOutputStream的基本方法是write(int b)。

java 文件读写操作注意事项

java 文件读写操作注意事项在进行Java文件读写操作时，有几个注意事项需要注意：1. 文件路径，确保提供正确的文件路径。

可以使用绝对路径或相对路径。

如果使用相对路径，要确保当前工作目录正确。

2. 文件编码，要根据实际情况选择正确的文件编码。

常见的编码方式有UTF-8、GBK等。

在读取或写入文件时，要使用与文件编码相匹配的字符编码。

3. 文件打开和关闭，在读取或写入文件之前，要确保正确地打开文件，并在操作完成后关闭文件。

这可以使用Java的IO流来实现。

使用try-with-resources语句块可以确保文件在使用完毕后自动关闭。

4. 文件权限，在进行文件读写操作时，要确保当前用户对文件具有足够的权限。

否则，可能会抛出权限不足的异常。

5. 异常处理，在进行文件读写操作时，要对可能出现的异常进行适当的处理。

常见的异常包括文件不存在、文件无法读取或写入等。

可以使用try-catch语句块来捕获并处理这些异常。

6. 内存管理，在读取大型文件时，要注意内存的使用。

如果一次性读取整个文件可能导致内存溢出，可以考虑使用缓冲区进行分段读取。

7. 文件锁定，在多线程或多进程环境下，要注意文件的并发访问。

可以使用文件锁定机制确保同一时间只有一个线程或进程可以访问文件。

8. 缓冲区刷新，在写入文件时，要及时将缓冲区的内容刷新到磁盘上的文件中。

可以使用flush或close方法来实现。

9. 文件大小限制，在读取文件时，要注意文件的大小限制。

如果文件过大，可能会导致读取时间过长或内存溢出。

可以考虑使用分段读取或按需读取的方式。

10. 文件类型检查，在读取文件时，要确保文件的类型与预期一致，以避免解析错误或安全问题。

可以通过文件扩展名或内容检查来进行文件类型验证。

总之，在进行Java文件读写操作时，要注意路径、编码、权限、异常处理、内存管理、并发访问、缓冲区刷新、文件大小限制和文件类型检查等方面的注意事项，以确保操作的正确性和安全性。

Java 程序设计基础第10章 Java语言的输入输出与文件处理

注意：流中的方法都声明抛出异常，所以程序中调用流方法时必须处理异常，否则编译不能通过。
8
10.2.1 基本的输入输出流
OutputStream类常用的方法及功能见教材表 10.2。由于OutputStream是抽象类，所以程序中创建的输出流对象一般是OutputStream某个子类的对象，通过调用该对象继承的write() 方法就可以实现对相应外设的输出操作。
11
} 用FileInputStream 、 FileOutputStream来实现对二进制图像文件的复制。 //filename：App10_2.java 读写二进制文件 import java.io.*; public class App10_2 { public static void main(String[] args) throws IOException { FileInputStream fi=new FileInputStream("d:\\cgj\\风景.jpg"); FileOutputStream fo=new FileOutputStream("d:\\cgj\\风景1.jpg"); System.out.println("文件的大小="+fi.available()); byte[] b=new byte[fi.available()]; fi.read(b); fo.write(b); System.out.println("文件已被拷贝并被更名"); fi.close(); fo2.2 输入输出流的应用
文件输入（FileInputStream）输出流（FileOutputStream ）主要负责完成对本地磁盘文件的顺序输入与输出操作。 FileInputStream类的对象表示一个文件字节输入流，从中可读取一个字节或一批字节。 FileOutputStream类的对象表示一个字节文件输出流，可向流中写入一个字节或一批字节。在生成该类的对象时，若指定的文件不存在，则创建一个新的文件，若已存在，则清除原文件的内容。 FileInputStream类和FileOutputStream类的构造方法见教材表10.3和10.4。

Java输入输出流（一）——常用的输入输出流

Java输⼊输出流（⼀）——常⽤的输⼊输出流1.流的概念：在Java中，流是从源到⽬的地的字节的有序序列。

Java中有两种基本的流——输⼊流（InputStream）和输出流（OutputStream）。

根据流相对于程序的另⼀个端点的不同，分为节点流和过滤流。

（1）节点流：以特定源如磁盘⽂件、内存某区域或者线程之间的管道为端点的构造输⼊输出流，是⼀种基本的流。

（2）过滤流：以其他已经存在的流为端点构造的输⼊输出流。

根据流中的数据单位分为字节流和字符流。

（1）字节流：流中的数据是以8位字节为单位进⾏读写，以InputStream和OutputStream为基础类。

（2）字符流:流中的数据是以16为字符为单位进⾏读写，以Reader和Writer为基础类。

2.字节流InputStream和OutputStream是字节流的两个顶层⽗类，提供了输⼊流类和输出流类的通⽤API。

2.1 输⼊字节流InputStream基本⽅法：（1）基本读⽅法;: int read() int read（byte[] b） int read(byte[] b,int off,int len)(2) 关闭流：void close()(3) 返回输⼊流中还有多少可读字节 int available()(4) 跳过指定字节 long skip(long n)(5) 回读数据 boolean markSupported() void Mark(int readlimt) void reset()2.2 输出字符流OutputStream基本⽅法：（1）基本写⽅法：void write（int c） void write(byte[] b) void write(byte[] b,int off,int len)(2) 关闭流：void close()(3)q强制输出：void flush（）3.字符流：Reader和Writer是字符流的顶层⽗类，字符流能够处理Unicode字符集中的所有字符。

用java逐行读取和写入大文件的最快方法

在软件开发过程中，经常会遇到需要处理大文件的情况，而对于Java语言来说，如何高效地逐行读取和写入大文件是一个常见的问题。

本文将介绍使用Java语言逐行读取和写入大文件的最快方法，帮助开发人员更加高效地处理大文件。

一、使用BufferedReader和BufferedWriter进行逐行读取和写入BufferedReader和BufferedWriter是Java标准库中提供的用于缓冲输入和输出的类，它们可以显著提高文件读写的效率。

下面是使用BufferedReader和BufferedWriter进行逐行读取和写入的代码示例：```javapublic class FileUtil {public static void copyFile(String sourceFileName, String targetFileName) {try (BufferedReader br = new BufferedReader(new FileReader(sourceFileName));BufferedWriter bw = new BufferedWriter(new FileWriter(targetFileName))) {String line;while ((line = br.readLine()) != null) {bw.write(line);bw.newLine();}} catch (IOException e) {e.printStackTrace();}}}```在上面的代码中，我们使用了BufferedReader逐行读取文件，并使用BufferedWriter逐行写入文件，通过缓冲输入和输出来提高读写效率。

这种方法适用于处理中等大小的文件，但对于大文件来说，还有更加高效的方法可供选择。

二、使用RandomAccessFile进行逐行读取和写入RandomAccessFile是Java标准库中提供的用于随机访问文件的类，它可以在文件中进行任意位置的读写操作。

文件输入输出流

文件输入输出流文件输入输出流是在计算机中进行文件读写操作的一种机制。

通过文件输入输出流，我们可以从文件中读取数据或者将数据写入文件中。

在程序开辟中，文件输入输出流常用于读取配置文件、读取和写入日志文件、进行数据持久化等操作。

文件输入输出流的基本概念和使用方法如下：1. 文件输入流（FileInputStream）：用于从文件中读取数据。

- 创建文件输入流对象：可以使用FileInputStream类的构造方法来创建一个文件输入流对象。

需要提供文件路径作为参数。

- 读取数据：可以使用文件输入流对象的read()方法来读取数据。

read()方法会返回一个整数值，表示读取到的字节数据。

当读取到文件末尾时，read()方法会返回-1。

2. 文件输出流（FileOutputStream）：用于将数据写入文件中。

- 创建文件输出流对象：可以使用FileOutputStream类的构造方法来创建一个文件输出流对象。

需要提供文件路径作为参数。

如果文件不存在，会自动创建新文件；如果文件已存在，会清空文件内容。

- 写入数据：可以使用文件输出流对象的write()方法来写入数据。

write()方法接受一个字节数组作为参数，将字节数组中的数据写入文件中。

文件输入输出流的使用示例：```javaimport java.io.FileInputStream;import java.io.FileOutputStream;import java.io.IOException;public class FileIOExample {public static void main(String[] args) {// 文件输入流示例try {FileInputStream inputStream = new FileInputStream("input.txt");int data;while ((data = inputStream.read()) != -1) {System.out.print((char) data);}inputStream.close();} catch (IOException e) {e.printStackTrace();}// 文件输出流示例try {FileOutputStream outputStream = new FileOutputStream("output.txt"); String data = "Hello, World!";byte[] bytes = data.getBytes();outputStream.write(bytes);outputStream.close();} catch (IOException e) {e.printStackTrace();}}}```在上面的示例中，我们通过文件输入流读取了名为"input.txt"的文件中的数据，并使用文件输出流将字符串"Hello, World!"写入了名为"output.txt"的文件中。

java inputstream 和 outputstream使用方法

java inputstream 和 outputstream使用方法Java中的InputStream和OutputStream是用于处理字节流的抽象类。

它们是Java IO库中非常重要的部分，用于读取和写入数据。

InputStream的使用方法：1. 创建一个InputStream对象，可以通过继承InputStream类或实现InputStream接口来创建子类或实现类。

2. 使用read()方法读取数据，该方法会返回一个字节数组。

可以多次调用read()方法来读取多个字节，直到所有数据都被读取完毕。

3. 使用close()方法关闭InputStream对象，释放相关资源。

下面是一个简单的示例代码，演示如何使用InputStream读取文件中的数据：```javaimport ;import ;public class InputStreamExample {public static void main(String[] args) {try {FileInputStream fis = new FileInputStream(""); byte[] buffer = new byte[1024];int bytesRead = (buffer);while (bytesRead != -1) {// 处理读取到的数据(new String(buffer, 0, bytesRead));bytesRead = (buffer);}();} catch (IOException e) {();}}}```OutputStream的使用方法：1. 创建一个OutputStream对象，可以通过继承OutputStream类或实现OutputStream接口来创建子类或实现类。

2. 使用write()方法写入数据，该方法需要一个字节数组作为参数。

可以多次调用write()方法来写入多个字节，直到所有数据都被写入完毕。

Java使用FileInputStream流读取文件示例详解

Java使⽤FileInputStream流读取⽂件⽰例详解⼀、File流概念JAVA中针对⽂件的读写操作设置了⼀系列的流，其中主要有FileInputStream,FileOutputStream,FileReader,FileWriter四种最为常⽤的流⼆、FileInputStream1）FileInputStream概念FileInputStream流被称为⽂件字节输⼊流，意思指对⽂件数据以字节的形式进⾏读取操作如读取图⽚视频等2）构造⽅法2.1）通过打开与File类对象代表的实际⽂件的链接来创建FileInputStream流对象public FileInputStream(File file) throws FileNotFoundException{}若File类对象的所代表的⽂件不存在;不是⽂件是⽬录;或者其他原因不能打开的话，则会抛出FileNotFoundException/**** 运⾏会产⽣异常并被扑捉--因为不存在xxxxxxxx这样的⽂件*/public static void main(String[] args){File file=new File("xxxxxxxx"); //根据路径创建File类对象--这⾥路径即使错误也不会报错，因为只是产⽣File对象，还并未与计算机⽂件读写有关联try{FileInputStream fileInputStream=new FileInputStream(file);//与根据File类对象的所代表的实际⽂件建⽴链接创建fileInputStream对象}catch (FileNotFoundException e){System.out.println("⽂件不存在或者⽂件不可读或者⽂件是⽬录");}}2.2）通过指定的字符串参数来创建File类对象，⽽后再与File对象所代表的实际路径建⽴链接创建FileInputStream流对象public FileInputStream(String name) throws FileNotFoundException通过查看源码，发现该构造⽅法等于是在第⼀个构造⽅法的基础上进⾏延伸的，因此规则也和第⼀个构造⽅法⼀致public FileInputStream(String name) throws FileNotFoundException {this(name != null ? new File(name) : null);}2.3）该构造⽅法没有理解---查看api是指使⽤的fdObj⽂件描述符来作为参数，⽂件描述符是指与计算机系统中的⽂件的连接，前⾯两个⽅法的源码中最后都是利⽤⽂件描述符来建⽴连接的public FileInputStream(FileDescriptor fdObj)3）FileInputStream常⽤API3.1）从输⼊流中读取⼀个字节返回int型变量，若到达⽂件末尾，则返回-1public int read() throws IOException理解读取的字节为什么返回int型变量1、⽅法解释中的-1相当于是数据字典告诉调⽤者⽂件已到底，可以结束读取了，这⾥的-1是Int型2、那么当⽂件未到底时，我们读取的是字节，若返回byte类型，那么势必造成同⼀⽅法返回类型不同的情况这是不允许的3、我们读取的字节实际是由8位⼆进制组成，⼆进制⽂件不利于直观查看，可以转成常⽤的⼗进制进⾏展⽰，因此需要把读取的字节从⼆进制转成⼗进制整数，故返回int型4、因此结合以上3点，保证返回类型⼀致以及直观查看的情况，因此该⽅法虽然读取的是字节但返回int型read⽅法读取实例--最后输出内容和字符内容⼀致是123package com.test;import java.io.File;import java.io.FileInputStream;import java.io.FileNotFoundException;import java.io.IOException;public class FileStream{/*****/public static void main(String[] args){//建⽴⽂件对象File file=new File("C:\\Users\\Administrator\\Desktop\\1.txt");try{//建⽴链接FileInputStream fileInputStream=new FileInputStream(file);int n=0;StringBuffer sBuffer=new StringBuffer();while (n!=-1) //当n不等于-1,则代表未到末尾{n=fileInputStream.read();//读取⽂件的⼀个字节(8个⼆进制位),并将其由⼆进制转成⼗进制的整数返回char by=(char) n; //转成字符sBuffer.append(by);}System.out.println(sBuffer.toString());}catch (FileNotFoundException e){System.out.println("⽂件不存在或者⽂件不可读或者⽂件是⽬录");}catch (IOException e){System.out.println("读取过程存在异常");}}}3.2）从输⼊流中读取b.length个字节到字节数组中，返回读⼊缓冲区的总字节数，若到达⽂件末尾，则返回-1public int read(byte[] b) throws IOException1. 我们先设定⼀个缓冲区即字节数组⽤于存储从流中读取的字节数据，该数组的长度为N2. 那么就是从流中读取N个字节到字节数组中。