Java-IO-Java字节流

鹿鹿熊

已于 2022-03-16 00:34:19 修改

阅读量417

点赞数

分类专栏： Mac开发Java IO流文章标签： java 开发语言

于 2022-03-15 00:00:08 首次发布

本文链接：https://blog.csdn.net/axegrgv/article/details/123491827

版权

Mac开发Java 同时被 2 个专栏收录

29 篇文章 0 订阅

订阅专栏

IO流

4 篇文章 0 订阅

订阅专栏

本文详细介绍了Java中的字节流，包括字节输出流FileOutputStream的构造方法和常用操作，如创建文件、写入字节、数组和指定长度数据，以及数据追加功能。同时涵盖了字节输入流FileInputStream的基础用法，如读取字节和数组。实例展示了如何复制文件和图片的字节流操作。

摘要由CSDN通过智能技术生成

Java字节流

字节：计算机中所有文件数据在存储时，都是以二进制的形式保存，都是一个一个的字节组成，在传输亦是如此。所以字节流可以传输任意文件。

字节输出流OutputStream

构造方法：

FileOutputStream(File file) 
	创建文件输出流以写入由指定的 File对象表示的文件。

FileOutputStream(File file, boolean append) 
创建文件输出流以写入由指定的 File对象表示的文件。 

FileOutputStream(String name) ——name:相对路径：文件名/绝对路径：从盘符开始
创建文件输出流以指定的名称写入文件。  

FileOutputStream(String name, boolean append) 
创建文件输出流以指定的名称写入文件。

方法摘要：

void close()
	关闭此输出流并释放与此流相关联的任何系统资源。  
	
void flush() 
	刷新此输出流并强制任何缓冲的输出字节被写出。  
	
void write(byte[] b)
	将 b.length字节从指定的字节数组写入此输出流。  
	
void write(byte[] b, int off, int len) 
	从指定的字节数组写入 len个字节，从偏移 off开始输出到此输出流。
  
abstract void write(int b) 
	将指定的字节写入此输出流。  
	
java.io .FileOutputStream
	 文件字节输出流：写数据到文件中

注意：
1.流使用完毕后一定要释放(关闭)调用close方法

2.flush():强制写入到内存中,如果flush()方法体里面没有具体实现，可以不使用

3.在创建一个流对象时，必须传入一个文件路径。该路径下，如果没有这个文件，会创造该文件。如果有，则会清空这个文件。

public class FileOutputStreamConstructor throws IOException {
    public static void main(String[] args) {
   	 	// 使用File对象创建流对象
        File file = new File("a.txt");
        FileOutputStream fos = new FileOutputStream(file);
      
        // 使用文件名称创建流对象
        FileOutputStream fos = new FileOutputStream("b.txt");
    }
}

写出字节数据

写出字节：用write(int b)方法

public class FileOutputStreamTest01 {
    public static void main(String[] args) throws IOException{
        /*创建对象*/
        FileOutputStream fos = new FileOutputStream("a.txt");
        /*写文件到数据*/
        fos.write(97);//当打开a.txt会去匹配Ascii码表，其它数值，会去匹配GBK中文编码表
        /*字节流刷新可以不调用*/
        //fos.flush();
        /*释放流不用占用内存空间*/
        fos.close();
    }
}
输出结果：a

写出字节数组：用write(byte[] b)方法，每次可一写出数组中的数据。

public class work1 {
    public static void main(String[] args) throws IOException {
      //创建流对象
        FileOutputStream fos = new FileOutputStream("b.txt");
      //字符串转换为字节数组
        byte[] a = "欧der欧der欧der".getBytes();
      //写出字节数组
        fos. write(a);
      //关闭资源
        fos.close();
    }
}

**写出指定长度数组：**void write(byte[] b, int off, int len) 每次写出从off索引开始 len个字节。

package sample.Day17.Work;

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

public class work1 {
    public static void main(String[] args) throws IOException {
        FileOutputStream fos = new FileOutputStream("b.txt");
      // 字符串转换为字节数组
        byte[] a = "abcdr".getBytes();
        fos. write(a,0,3);
      // 写出从索引0开始，3个字节。索引0是a，两个字节，也就是abc。
        fos.close();
    }
}
输出结果：abc

数据追加续写

public FileOutputStream(File file, boolean append)：创建文件输出流以写入由指定的 File对象表示的文件。

public FileOutputStream(String name, boolean append)：创建文件输出流以指定的名称写入文件。

这两个构造方法，参数中都需要传入一个boolean类型的值，true 表示追加数据，false 表示清空原有数据。这样创建的输出流对象，就可以指定是否追加续写了。

public static void main(String[] args) throws IOException {
        FileOutputStream fos = new FileOutputStream("c.txt",true);
        for (int i=0;i<10;i++){
            fos.write("刚果金".getBytes());
        }
        fos.close();
    }
//在文件中写入十遍“刚果金”
刚果金刚果金刚果金刚果金刚果金刚果金刚果金刚果金刚果金刚果金

写出换行

换行：
windows:\r\n
Linux：\n或\r
Mac:\r或\n

public static void main(String[] args) throws IOException {
        FileOutputStream fos = new FileOutputStream("c.txt",true);
        for (int i=0;i<10;i++){
            fos.write("刚果金".getBytes());
          	fos.write("\r".getBytes())
              /*windows:\r\n Linux：\n或\r Mac:\r或\n*/
        }
        fos.close();
    }

字节输入流InputStream

构造方法

FileInputStream(File file)
	通过打开与实际文件的连接创建一个 FileInputStream ，该文件由文件系统中的 File对象 file命名。
	
	FileInputStream(String name)
	通过打开与实际文件的连接来创建一个 FileInputStream ，该文件由文件系统中的路径名 name命名。

方法摘要

java.io InputStream:
* abstract int read()
从输入流读取数据的下一个字节。

int read(byte[] b)
从输入流读取一些字节数，并将它们存储到缓冲区 b 。

int read(byte[] b, int off, int len)
从输入流读取最多 len字节的数据到一个字节数组。

void close()
关闭此输入流并释放与流相关联的任何系统资源。

int available()
返回从该输入流中可以读取（或跳过）的字节数的估计值，而不会被下一次调用此输入流的方法阻塞。

long skip(long n)
跳过并丢弃来自此输入流的 n字节数据。

在创建一个流对象时，必须传入一个存在的文件路径。若文件不存在会抛出FileNotFoundException异常。

public class FileInputStreamConstructor throws IOException{
    public static void main(String[] args) {
   	 	// 使用File对象创建流对象
        File file = new File("a.txt");
        FileInputStream fos = new FileInputStream(file);
      
        // 使用文件名称创建流对象
        FileInputStream fos = new FileInputStream("b.txt");
    }
}

读取字节数组

读取字节：read方法，每次可以读取一个字节的数据，提升为int类型，读取到文件末尾，返回-1。

public static void main(String[] args) throws IOException {
        // 创见对象
        FileInputStream fis = new FileInputStream("b.txt");
        //读取数据，返回一个字节
        int len = fis.read();
        System.out.println(len);
        len = fis.read();
        System.out.println(len);
        len = fis.read();
        System.out.println(len);
        len = fis.read();
        System.out.println(len);
        len = fis.read();
        System.out.println(len);
        len = fis.read();
        System.out.println(len);
        len = fis.read();
        System.out.println(len);
        //释放流
        fis.close();

可用循环改进读取方式：

public static void main(String[] args) throws IOException {
        // 创见对象
        FileInputStream fis = new FileInputStream("b.txt");
        /*
		 * 用循环语句改造以上代码
          */
        int len =0;
        while (len!=-1){
          len = fis.read();
          System.out.println(len);
        }
        //释放流
        fis.close();
    }

**使用字节数组读取：**read(byte[] b)，每次读取b的长度个字节到数组中，返回读取到的有效字节个数，读取到末尾时，返回-1

 public static void main(String[] args) throws IOException {
        FileInputStream fis = new FileInputStream("/Users/agionlost/IdeaProjects/untitled2/src/sample/Day17/b.txt");

        byte[] bytes = new byte[2];//存储每次读取到的多个字节
        int len=0;//记录读取到的有效字节的数量

        while ((len = fis.read(bytes))!=-1){
            //构造方法：String(byte[] bytes, int offset, int length)
            System.out.println(new String(b);
        }
        // 关闭资源
        fis.close();
    }
}

输出结果：
ab
cd
ed

错误数据d，是由于最后一次读取时，只读取一个字节e，数组中，上次读取的数据没有被完全替换，所以要通过len ，获取有效的字节，代码使用演示：

public static void main(String[] args) throws IOException {
        FileInputStream fis = new FileInputStream("/Users/agionlost/IdeaProjects/untitled2/src/sample/Day17/b.txt");

        byte[] bytes = new byte[1024];//存储每次读取到的多个字节
        int len=0;//记录读取到的有效字节的数量

        while ((len = fis.read(bytes))!=-1){
            //构造方法：String(byte[] bytes, int offset, int length)
            System.out.println(new String(bytes,0,len));
        }
       // 关闭资源
        fis.close();
    }
}

输出结果：
ab
cd
e

图片复制

将已有文件中的图片或视频复制到另一个文件中。

package sample.Day17;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
/*
 * 图片的复制粘贴：文件字节输入/输出流——一边读一边写
 * 1.创建文件字节输入流对象，读取d:\\1.jpg
 * 2.创建文件字节输出流对象，写入e:\\1.jpg
 *
 * 注意：字节流适合读取二进制文件-图片，音频，视频
 */
public class FileCopy01 {
    public static void main(String[] args) throws IOException {
        FileInputStream fis = new FileInputStream("/Desktop/图片/video_1800042325.mp4");
        FileOutputStream fos = new FileOutputStream("/sample/Day17/video_1800048072.mp4");
        byte[] bytes = new byte[1024];
        int len = 0;
        while ((len = fis.read(bytes))!=-1){
            fos.write(bytes,0,len);
        }
        fis.close();
        fos.close();
    }
}