我有一个(可能很长)二进制文件列表,我想懒惰地阅读。将有太多文件加载到内存中。我目前正在使用FileChannel.map()
将其作为MappedByteBuffer阅读,但这可能并不是必需的。我希望方法readBinaryFiles(...)
能够返回Java 8 Stream,以便在访问文件时懒惰加载文件列表。
public List<FileDataMetaData> readBinaryFiles(
List<File> files,
int numDataPoints,
int dataPacketSize )
throws
IOException {
List<FileDataMetaData> fmdList = new ArrayList<FileDataMetaData>();
IOException lastException = null;
for (File f: files) {
try {
FileDataMetaData fmd = readRawFile(f, numDataPoints, dataPacketSize);
fmdList.add(fmd);
} catch (IOException e) {
logger.error("", e);
lastException = e;
}
}
if (null != lastException)
throw lastException;
return fmdList;
}
// The List<DataPacket> returned will be in the same order as in the file.
public FileDataMetaData readRawFile(File file, int numDataPoints, int dataPacketSize) throws IOException {
FileDataMetaData fmd;
FileChannel fileChannel = null;
try {
fileChannel = new RandomAccessFile(file, "r").getChannel();
long fileSz = fileChannel.size();
ByteBuffer bbRead = ByteBuffer.allocate((int) fileSz);
MappedByteBuffer buffer = fileChannel.map(FileChannel.MapMode.READ_ONLY, 0, fileSz);
buffer.get(bbRead.array());
List<DataPacket> dataPacketList = new ArrayList<DataPacket>();
while (bbRead.hasRemaining()) {
int channelId = bbRead.getInt();
long timestamp = bbRead.getLong();
int[] data = new int[numDataPoints];
for (int i=0; i<numDataPoints; i++)
data[i] = bbRead.getInt();
DataPacket dp = new DataPacket(channelId, timestamp, data);
dataPacketList.add(dp);
}
fmd = new FileDataMetaData(file.getCanonicalPath(), fileSz, dataPacketList);
} catch (IOException e) {
logger.error("", e);
throw e;
} finally {
if (null != fileChannel) {
try {
fileChannel.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
return fmd;
}
从fmdList.Stream()
返回readBinaryFiles(...)
无法完成此操作,因为文件内容已经被读入内存,但我无法做到。
将多个文件的内容作为Stream读取的其他方法依赖于使用Files.lines()
,但我需要读取二进制文件。
我可以在Scala或golang中这样做,如果这些语言比Java更能支持这个用例。
我很感激任何关于如何懒惰地读取多个二进制文件内容的指示。
答案 0 :(得分:1)
当您正在阅读整个文件以构建FileDataMetaData
的实例时,在文件中读取可能不会有懒惰。您需要对该类进行大量重构才能构建FileDataMetaData
的实例,而无需读取整个文件。
但是,在该代码中有几个要清理的东西,甚至特定于Java 7而不是Java 8,即你不再需要RandomAccessFile
绕道来打开一个频道而且{{3确保正确关闭。请进一步注意,使用内存映射毫无意义。在映射文件后将整个内容复制到堆ByteBuffer
中时,没有什么是懒惰的。与通道上的堆read
调用ByteBuffer
时发生的情况完全相同,除了JRE可以在read
情况下重用缓冲区。
为了允许系统管理页面,您必须从映射的字节缓冲区中读取。根据系统的不同,这可能不会比将小块重复读入堆字节缓冲区更好。
public FileDataMetaData readRawFile(
File file, int numDataPoints, int dataPacketSize) throws IOException {
try(FileChannel fileChannel=FileChannel.open(file.toPath(), StandardOpenOption.READ)) {
long fileSz = fileChannel.size();
MappedByteBuffer bbRead=fileChannel.map(FileChannel.MapMode.READ_ONLY, 0, fileSz);
List<DataPacket> dataPacketList = new ArrayList<>();
while(bbRead.hasRemaining()) {
int channelId = bbRead.getInt();
long timestamp = bbRead.getLong();
int[] data = new int[numDataPoints];
for (int i=0; i<numDataPoints; i++)
data[i] = bbRead.getInt();
dataPacketList.add(new DataPacket(channelId, timestamp, data));
}
return new FileDataMetaData(file.getCanonicalPath(), fileSz, dataPacketList);
} catch (IOException e) {
logger.error("", e);
throw e;
}
}
基于此方法构建流是直截了当的,只需要处理已检查的异常:
public Stream<FileDataMetaData> readBinaryFiles(
List<File> files, int numDataPoints, int dataPacketSize) throws IOException {
return files.stream().map(f -> {
try {
return readRawFile(f, numDataPoints, dataPacketSize);
} catch (IOException e) {
logger.error("", e);
throw new UncheckedIOException(e);
}
});
}
答案 1 :(得分:0)
我不知道这是多么高效,但您可以使用java.io.SequenceInputStream
包裹在DataInputStream
内。这将有效地将您的文件连接在一起。如果您从每个文件创建BufferedInputStream
,那么整个事情应该被正确缓冲。
答案 2 :(得分:0)
在VGR's comment的基础上,我认为他的基本解决方案是:
return files.stream().map(f -> readRawFile(f, numDataPoints, dataPacketSize))
是正确的,因为它将懒惰地处理文件(并且如果从map()操作的结果调用短路终端动作则停止。我还建议与利用的readRawFile的实现略有不同try with resources和InputStream,它不会将整个文件加载到内存中:
public FileDataMetaData readRawFile(File file, int numDataPoints, int dataPacketSize)
throws DataPacketReadException { // <- Custom unchecked exception, nested for class
FileDataMetadata results = null;
try (FileInputStream fileInput = new FileInputStream(file)) {
String filePath = file.getCanonicalPath();
long fileSize = fileInput.getChannel().size()
DataInputStream dataInput = new DataInputStream(new BufferedInputStream(fileInput);
results = new FileDataMetadata(
filePath,
fileSize,
dataPacketsFrom(dataInput, numDataPoints, dataPacketSize, filePath);
}
return results;
}
private List<DataPacket> dataPacketsFrom(DataInputStream dataInput, int numDataPoints, int dataPacketSize, String filePath)
throws DataPacketReadException {
List<DataPacket> packets = new
while (dataInput.available() > 0) {
try {
// Logic to assemble DataPacket
}
catch (EOFException e) {
throw new DataPacketReadException("Unexpected EOF on file: " + filePath, e);
}
catch (IOException e) {
throw new DataPacketReadException("Unexpected I/O exception on file: " + filePath, e);
}
}
return packets;
}
这应该减少代码量,并确保您的文件在出错时关闭。
答案 3 :(得分:0)
这应该足够了:
return files.stream().map(f -> readRawFile(f, numDataPoints, dataPacketSize));
...如果,也就是说,您愿意从readRawFile方法的签名中删除throws IOException
。您可以让该方法在内部捕获IOException并将其包装在UncheckedIOException中。 (延迟执行的问题是异常也需要延迟。)