java文件的读写操作(字节流)

java的IO

java文件的读写操作(字节流)

上篇博文提到了File类和流的概念，这篇博文将详细介绍具体的使用:

InputStream和FileInputStream

InputStream和FileInputStream的常用方法

• InputStream类的常用方法

  int read()从输入流一个字节一个字节的读，返回的是该字节的整数表示形式，如果读到了输入流的末尾，返回-1

  int read(byte[] b)从输入流读取若干的字节，将这些字节保存到数组b中，返回的是读取到的字节数，如果读到了输入流的末尾，返回-1

  int read(byte[]b ,int off,int len)从输入流读取若干字节，把这些字节保存在数组b中。off指的是字节数组中开始保存数据的起始下标，len指的是读取的字节数目，返回的是实际读取到的字节数，如果读到了输入流的末尾，返回-1

  void close():关闭输入流

  int available():可以从输入流中读取的字节数目

InputStream是作为抽象基类，创建对象的话是需要它的子类FileInputStream。

• 子类FileInputStream常用的构造方法

  FileInputStream(File file)

  FileInputStream(String pathname)

示例

前提是:当前项目中创建一个test.txt文件，从中写入一串文字，保存退出.

package Test;
//1.引入相关的流

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

//通过字节输入流完成对文件的读操作
public class FileInputStreamDemoTest {
    public static void main(String[] args) {
        FileInputStream fis = null;

        try {
            //2.创建FileInputStream对象
            fis = new FileInputStream("E:\\file\\code\\java\\day01\\src\\Test\\test.txt");
            //3.借助FileInputStream对象的read()方法读取文件
            /*
            System.out.println("\n可以读取到的字节数:" + fis.available());
            int data;读取到的每个字节的整数表示形式
            while ((data = fis.read()) != -1) {
                System.out.print((char) data);
            }
            System.out.println("\n可以读取到的字节数:" + fis.available());
            */
            //3.借助FileInputStream对象的read(byte[])方法读取文件
            byte[] b = new byte[1024];
            int data;//读取到的字节数
            while ((data = fis.read(b)) != -1) {
                //字节读取到了字节数组b中，需要循环输出
                for (int i = 0; i < data; i++) {
                    System.out.print((char) b[i]);
                }
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //4.关闭输入流
            try {
                fis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

OuputStream和FileOuputStream

OutputStream和FileOutputStream的常用方法

• OutputStream的常用方法

  void write(int c)往输出流中写入一个一个的字节

  void write(byte[] buf)往输出流中写入一个字节数组

  void write(byte[] b,int off,int len):往输出流中写入一个字节数组，off代表开始从字节数组的off位置开始往外写，len代表往外写len长度的字节

  void close():关闭输出流

  void flush():强制把缓冲区的数据写到输出流中

  OutputStream是一个抽象基类，要创建对象需要它的子类FileOutputStream。

• 子类FileOutputStream的常用构造方法

  FileOutputStream(File file)

  FileOutputStream(String pathname)

  FileOutputStream(String pathname,bool append)

前两种构造方法在向文件中写数据时将覆盖文件中的原有的内容
创建FileOutputStream示例时，如果相应的文件并不存在，则会自动创建空的文件

示例

package Test;
//1.引入资源

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

//借助字节输出流完成对文件的写入操作
public class FileOutputStreamDemoTest {
    public static void main(String[] args) {
        FileOutputStream fos = null;
        try {
            //2.创建字节输出流对象(FileOutputStream)
            fos = new FileOutputStream("E:\\file\\code\\java\\day01\\src\\Test\\test.txt");
            //fos = new FileOutputStream("E:\\file\\code\\java\\day01\\src\\Test\\test.txt",true);代表的是文件不会进行覆盖，而是追加
            //3.调用字节输出流对象(FileOutputStream)的write()方法写入文件
            String info = "hello first file";
            //将写入的字符串打散为一个字节数组
            byte[] infos = info.getBytes();
            fos.write(infos, 0, infos.length);
            System.out.println("test文件已经被更新!");
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //4.关闭输出流
            try {
                fos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

实现文件的复制

将E:\file\mysoft\deveco-studio\DevEco Studio 2.1.0.501\NOTICE.txt文本文件复制到E:\file\code\java\day01\src\Test\NOTICE.txt，其实复制就是先读取文本文件，读取到文本文件后再到指定的位置创建一个文本文件，之后写入文本文件

package Test;

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

//借助字节输入输出流综合使用，实现文件的复制(读 写)
//E:\file\mysoft\deveco-studio\DevEco Studio 2.1.0.501\NOTICE.txt-->E:\file\code\java\day01\src\Test\NOTICE.txt
public class InAndOutStreamDemoTest {
    public static void main(String[] args) {
        FileInputStream fis = null;//输入流 读
        FileOutputStream fos = null;//输出流 写
        try {
            fis = new FileInputStream("E:\\file\\mysoft\\deveco-studio\\DevEco Studio 2.1.0.501\\NOTICE.txt");
            fos = new FileOutputStream("E:\\file\\code\\java\\day01\\src\\Test\\NOTICE.txt");
            byte[] words = new byte[1024];
            int len = -1;
            //文件的内容读取出来存放到了字节数组words中
            while ((len = fis.read(words)) != -1) {
                //将字节数组words写出到输出流fos中
                fos.write(words, 0, len);
            }
            System.out.println("文件复制完毕");
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                fos.close();
                fis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

java文件的读写操作(字符流)