Java-IO流之字节输入流详解

于 2025-06-03 18:23:11 发布
阅读量1.3k 收藏 14
点赞数 37
CC 4.0 BY-SA版权
分类专栏： JavaSE 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/aa_hdkf_vg/article/details/148407226

Java-IO流之字节输入流详解

Java编码中处理二进制数据是一项常见的任务，而字节输入流(Byte Input Stream)则是Java IO体系中用于读取二进制数据的核心组件。本文我将深入探讨Java中字节输入流的相关知识，从基础概念到高级应用，并结合实例代码，带你全面掌握这一重要技术。

一、Java IO体系与字节输入流概述

1.1 Java IO体系结构

Java IO(Input/Output)体系基于数据流的概念，提供了一套丰富的类和接口，用于处理各种输入输出操作。根据数据处理方式的不同，Java IO可分为：

  • 字节流(Byte Stream)：以字节为单位处理数据，适用于二进制文件、网络数据流等。
  • 字符流(Character Stream)：以字符为单位处理数据，适用于文本文件等。

1.2 字节输入流的核心类层次

字节输入流的顶层接口是java.io.InputStream，所有字节输入流类都继承自该接口。主要的实现类包括：

  • FileInputStream：用于从文件读取数据
  • ByteArrayInputStream：用于从内存中的字节数组读取数据
  • PipedInputStream：用于线程间通信的管道输入流
  • FilterInputStream：装饰器基类，用于增强其他输入流的功能
    • BufferedInputStream：提供缓冲功能，提高读取效率
    • DataInputStream：提供读取基本数据类型的功能
    • CheckedInputStream：提供校验功能，用于验证数据完整性

1.3 字节输入流的基本工作模式

字节输入流的基本工作模式是：

  1. 创建输入流对象，连接数据源（文件、网络等）
  2. 调用读取方法从流中读取数据
  3. 处理读取到的数据
  4. 关闭流，释放系统资源

二、InputStream类的核心方法

2.1 int read()

  • 功能：从输入流读取一个字节的数据，返回值为0-255的整数。如果到达流的末尾，返回-1。
  • 示例：
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;

public class ReadExample {
    public static void main(String[] args) {
        try (InputStream inputStream = new FileInputStream("test.txt")) {
            int data;
            while ((data = inputStream.read()) != -1) {
                System.out.print((char) data);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

2.2 int read(byte[] b)

  • 功能：从输入流读取最多b.length个字节的数据到字节数组中，返回实际读取的字节数。如果到达流的末尾，返回-1。
  • 示例：
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;

public class ReadByteArrayExample {
    public static void main(String[] args) {
        try (InputStream inputStream = new FileInputStream("test.txt")) {
            byte[] buffer = new byte[1024];
            int bytesRead;
            while ((bytesRead = inputStream.read(buffer)) != -1) {
                System.out.write(buffer, 0, bytesRead);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

2.3 int read(byte[] b, int off, int len)

  • 功能：从输入流读取最多len个字节的数据到字节数组b中，从索引off开始存储，返回实际读取的字节数。如果到达流的末尾，返回-1。
  • 示例：
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;

public class ReadByteArrayOffsetExample {
    public static void main(String[] args) {
        try (InputStream inputStream = new FileInputStream("test.txt")) {
            byte[] buffer = new byte[1024];
            int offset = 0;
            int bytesRead;
            while ((bytesRead = inputStream.read(buffer, offset, buffer.length - offset)) != -1) {
                offset += bytesRead;
                // 处理读取的数据
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

2.4 long skip(long n)

  • 功能：跳过并丢弃输入流中的n个字节数据，返回实际跳过的字节数。

2.5 int available()

  • 功能：返回可以从输入流中读取而不会被阻塞的估计字节数。

2.6 void close()

  • 功能：关闭输入流并释放相关的系统资源。

三、常用字节输入流实现类

3.1 FileInputStream

FileInputStream用于从文件系统中的文件读取数据，是最常用的字节输入流之一。

示例：读取文件内容

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

public class FileInputStreamExample {
    public static void main(String[] args) {
        try (FileInputStream fis = new FileInputStream("test.txt")) {
            byte[] buffer = new byte[1024];
            int bytesRead;
            while ((bytesRead = fis.read(buffer)) != -1) {
                String content = new String(buffer, 0, bytesRead);
                System.out.print(content);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

3.2 ByteArrayInputStream

ByteArrayInputStream用于从内存中的字节数组读取数据，适合处理临时数据。

示例：从字节数组读取数据

import java.io.ByteArrayInputStream;
import java.io.IOException;

public class ByteArrayInputStreamExample {
    public static void main(String[] args) {
        byte[] data = {65, 66, 67, 68, 69}; // ASCII码对应A,B,C,D,E
        
        try (ByteArrayInputStream bais = new ByteArrayInputStream(data)) {
            int byteValue;
            while ((byteValue = bais.read()) != -1) {
                System.out.print((char) byteValue + " ");
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

3.3 BufferedInputStream

BufferedInputStream为输入流提供缓冲功能，通过减少直接与数据源的交互次数，提高读取效率。

示例：使用BufferedInputStream读取文件

import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.IOException;

public class BufferedInputStreamExample {
    public static void main(String[] args) {
        try (BufferedInputStream bis = new BufferedInputStream(new FileInputStream("test.txt"))) {
            byte[] buffer = new byte[1024];
            int bytesRead;
            while ((bytesRead = bis.read(buffer)) != -1) {
                System.out.write(buffer, 0, bytesRead);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

3.4 DataInputStream

DataInputStream允许应用程序以与机器无关的方式从底层输入流读取基本Java数据类型。

示例：读取二进制数据

import java.io.DataInputStream;
import java.io.FileInputStream;
import java.io.IOException;

public class DataInputStreamExample {
    public static void main(String[] args) {
        try (DataInputStream dis = new DataInputStream(new FileInputStream("data.bin"))) {
            int intValue = dis.readInt();
            double doubleValue = dis.readDouble();
            boolean booleanValue = dis.readBoolean();
            
            System.out.println("整数: " + intValue);
            System.out.println("双精度数: " + doubleValue);
            System.out.println("布尔值: " + booleanValue);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

四、字节输入流的高级应用

4.1 实现文件复制功能

import java.io.*;

public class FileCopyExample {
    public static void main(String[] args) {
        try (InputStream in = new FileInputStream("source.txt");
             OutputStream out = new FileOutputStream("target.txt")) {
            
            byte[] buffer = new byte[4096];
            int bytesRead;
            while ((bytesRead = in.read(buffer)) != -1) {
                out.write(buffer, 0, bytesRead);
            }
            
            System.out.println("文件复制成功");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

4.2 实现图片加密/解密功能

import java.io.*;

public class ImageEncryptDecrypt {
    private static final byte KEY = 0x55; // 加密密钥
    
    public static void main(String[] args) {
        try {
            // 加密图片
            encryptImage("input.jpg", "encrypted.jpg");
            System.out.println("图片加密完成");
            
            // 解密图片
            decryptImage("encrypted.jpg", "decrypted.jpg");
            System.out.println("图片解密完成");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    
    public static void encryptImage(String inputFile, String outputFile) throws IOException {
        try (InputStream in = new FileInputStream(inputFile);
             OutputStream out = new FileOutputStream(outputFile)) {
            
            int byteValue;
            while ((byteValue = in.read()) != -1) {
                out.write(byteValue ^ KEY); // 异或加密
            }
        }
    }
    
    public static void decryptImage(String inputFile, String outputFile) throws IOException {
        // 解密与加密使用相同的算法
        encryptImage(inputFile, outputFile);
    }
}

4.3 使用CheckedInputStream验证数据完整性

import java.io.*;
import java.util.zip.Adler32;
import java.util.zip.CheckedInputStream;

public class CheckedInputStreamExample {
    public static void main(String[] args) {
        try (CheckedInputStream cis = new CheckedInputStream(
                new FileInputStream("data.txt"), new Adler32())) {
            
            byte[] buffer = new byte[1024];
            while (cis.read(buffer) != -1) {
                // 读取数据但不处理，只是为了计算校验和
            }
            
            long checksum = cis.getChecksum().getValue();
            System.out.println("数据校验和: " + checksum);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

五、字节输入流的最佳实践

5.1 使用try-with-resources自动关闭流

Java 7引入的try-with-resources语句可以自动关闭实现了AutoCloseable接口的资源，避免资源泄漏。

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;

public class TryWithResourcesExample {
    public static void main(String[] args) {
        // try-with-resources语句会自动关闭流
        try (InputStream inputStream = new FileInputStream("test.txt")) {
            int data;
            while ((data = inputStream.read()) != -1) {
                System.out.print((char) data);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

5.2 选择合适的缓冲区大小

使用缓冲区可以显著提高IO性能，但缓冲区大小需要根据具体情况选择。一般来说，4KB-8KB的缓冲区大小比较合适。

import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;

public class BufferSizeExample {
    public static void main(String[] args) {
        try (InputStream inputStream = new BufferedInputStream(
                new FileInputStream("large_file.txt"), 8192)) {
            // 使用8KB的缓冲区
            byte[] buffer = new byte[8192];
            int bytesRead;
            while ((bytesRead = inputStream.read(buffer)) != -1) {
                // 处理数据
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

5.3 处理大文件时的性能优化

对于非常大的文件，应避免一次性读取整个文件到内存中，而是采用分块读取的方式。

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;

public class LargeFileProcessing {
    public static void main(String[] args) {
        try (InputStream inputStream = new FileInputStream("large_file.txt")) {
            byte[] buffer = new byte[1024 * 1024]; // 1MB缓冲区
            int bytesRead;
            while ((bytesRead = inputStream.read(buffer)) != -1) {
                // 处理每一块数据
                processChunk(buffer, bytesRead);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    
    private static void processChunk(byte[] buffer, int length) {
        // 处理数据块的逻辑
    }
}

六、常见问题与解决方案

6.1 中文乱码问题

字节输入流按字节读取数据，如果直接将字节转换为字符串而不指定字符编码，可能会导致中文乱码。

错误示例：

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

public class CharsetIssueExample {
    public static void main(String[] args) {
        try (FileInputStream fis = new FileInputStream("chinese.txt")) {
            byte[] buffer = new byte[1024];
            int bytesRead = fis.read(buffer);
            String content = new String(buffer, 0, bytesRead); // 未指定字符编码
            System.out.println(content); // 可能显示乱码
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

正确示例：

import java.io.*;

public class CharsetCorrectExample {
    public static void main(String[] args) {
        try (InputStreamReader isr = new InputStreamReader(
                new FileInputStream("chinese.txt"), "UTF-8")) {
            
            BufferedReader reader = new BufferedReader(isr);
            String line;
            while ((line = reader.readLine()) != -1) {
                System.out.println(line); // 正确显示中文
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

6.2 流关闭失败问题

如果流没有正确关闭，可能会导致资源泄漏。使用try-with-resources可以有效解决这个问题。

6.3 性能瓶颈问题

  • 避免频繁调用read()方法，尽量使用带缓冲区的read(byte[] b)方法。
  • 对于大文件读取，使用BufferedInputStream提高性能。

若这篇内容帮到你，动动手指支持下！关注不迷路，干货持续输出！
ヾ(´∀ ˋ)ﾉヾ(´∀ ˋ)ﾉヾ(´∀ ˋ)ﾉヾ(´∀ ˋ)ﾉヾ(´∀ ˋ)ﾉ

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值