文件字节输入流

FileInputStream

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

调用read（）时，指针移动，并且返回指向的字节本身

调用read（byte）时，返回读取进的字节数量

已经读到文件的末尾了，再读的时候读取不到任何数据，返回-1

普通代码：

FileInputStream fis = null;
try {
    //创建文件字节输入流对象
    //文件路径D:\temp\test.txt   IDEA会自动把单斜杠变成\\  因为java中\表示转义
    //文件路径也可以写成 D:/temp/test.txt   绝对路径
   fis = new FileInputStream("D:\\temp\\test.txt");
   //开始读
    int readdata = fis.read();//这个方法的返回值是：读取到的字节本身
    System.out.println(readdata);//97 a
    int readdata2 = fis.read();//
    System.out.println(readdata2);//98 b
    int readdata3 = fis.read();
    System.out.println(readdata3);//99  c
    int readdata4 = fis.read();
    System.out.println(readdata4);//100 d
    int readdata5 = fis.read();
    System.out.println(readdata5);//-1
    // 已经读到文件的末尾了，再读的时候读取不到任何数据，返回-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();
        }
    }
}

利用循环方式

int readdata = 0;
while ((readdata = fis.read())!=-1){
    System.out.println(readdata);
}

缺点

一次读取一个字节byte，这样内存和硬盘交互太频繁，时间和资源都浪费在交互上面了，能不能一次读取多个字节呢。可以

相对路径

IDEA默认的当前路径在哪里？

工程project的根就是IDEA的默认当前路径

一次读取多个字节

int read(byte[]b) 返回值是本次read读了多少个字节

一次最多读取b.length个字节，减少内存和硬盘的交互，提高程序的执行效率

往byte[]数组当中读。

数组转字符串 new String(bytes)

不应该全部都转换,应该是读取了多少个字节，转多少个

所以应该调用的是String类中的另一个构造方法

String(byte[]bytes,int offset,int length)

String(bytes,0,readcount)

 //文件内容为abcdef
    fis = new FileInputStream("testfile.txt");
    //开始读，采用byte数组，一次读取多个字节，最多读取 数组.length个字节
byte[]bytes = new byte[4];//准备一个4个长度的byte数组。一次最多读取四个字节
    int readcount = fis.read(bytes);//此方法的返回值是读取到的字节数量，不是字节本身
    System.out.println(readcount);//第一次读到了四个字节  4
    System.out.println(new String(bytes,0,readcount));//abcd

    readcount = fis.read(bytes);
    System.out.println(readcount);//第二次只能读取两个字节  2
    System.out.println(new String(bytes,0,readcount));//efcd   ef覆盖了ab

    readcount = fis.read(bytes);
    System.out.println(readcount);//一个字节都没读到  -1

利用循环方式一次读取多个字节

fis = new FileInputStream("testfile.txt");
byte[] bytes = new byte[4];
int readcount;
while ((readcount = fis.read(bytes))!=-1){
    System.out.print(new String(bytes,0,readcount));
}

最终代码：

package com.iostream.fileinputstream;

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

public class Demo5 {
    public static void main(String[] args) {
        FileInputStream fis =null;
        try {
            fis = new FileInputStream("testfile.txt");
            byte[] bytes = new byte[4];
            int readcount;
            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的其他常用方法

int available（）

返回流中剩余的没有读到的字节数量

• byte[]bytes = new byte[fis.available()];不用循环

不适合太大的文件，因为byte数组不能太大

fis = new FileInputStream("testfile.txt");
System.out.println("字节总数量为："+fis.available());
byte[]bytes = new byte[fis.available()];
int readcount = 0;
readcount = fis.read(bytes);
System.out.print(new String(bytes));

long skip（long n）

跳过几个字节不读取

fis.skip(3)