java操作大文件3种方法对比

最新推荐文章于 2024-06-26 15:05:35 发布
最新推荐文章于 2024-06-26 15:05:35 发布
阅读量674 收藏 5
点赞数
文章标签： java mybatis jvm
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/z_917924497/article/details/127021791
版权 
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.nio.MappedByteBuffer;
import java.nio.channels.FileChannel;
import java.util.Comparator;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.Collectors;
 
public class CountWordsOfArticle {
	public void countWordsOfArticle(String fileName, int arraySize) throws IOException {
		File file = new File(fileName);
		if (!file.exists()) {
			System.out.println("该文件不存在");
			return;
		}
		MappedBiggerFileReader reader = new MappedBiggerFileReader(fileName, arraySize);
		while (reader.read() != -1) {
			wordCount(reader);
		}
	}
 
	private static void wordCount(MappedBiggerFileReader reader) throws IOException {
		Map<String, Integer> map = new ConcurrentHashMap<>();
		BufferedReader in = new BufferedReader(new InputStreamReader(reader));
		StringBuffer buffer = new StringBuffer();
		String line = " ";
		while ((line = in.readLine()) != null) {
			buffer.append(line);
		}
		String request = buffer.toString();
 
		Pattern p = Pattern.compile("[, . ; ! ? ]");
		Matcher m = p.matcher(request);
		String[] strs = p.split(request);
		for (int i = 0; i < strs.length; i++) {
			if (map.containsKey(strs[i].toLowerCase())) {
				map.put(strs[i].toLowerCase(), map.get(strs[i].toLowerCase()) + 1);
			} else {
				map.put(strs[i].toLowerCase(), 1);
			}
		}
		List<Map.Entry<String, Integer>> result = map.entrySet().stream()
				.sorted(new Comparator<Map.Entry<String, Integer>>() {
					@Override
					public int compare(Map.Entry<String, Integer> o1, Map.Entry<String, Integer> o2) {
						return o2.getValue().compareTo(o1.getValue());
					}
				}).collect(Collectors.toList());
		result.forEach(item -> {
			System.out.println(item.getKey() + " " + item.getValue());
		});
	}
 
	public class MappedBiggerFileReader extends InputStream{
		private MappedByteBuffer[] mappedBufArray;
		private int count = 0;
		private int number;
		private FileInputStream fileIn;
		private long fileLength;
		private int arraySize;
		private byte[] array;
 
		public MappedBiggerFileReader(String fileName, int arraySize) throws IOException {
			this.fileIn = new FileInputStream(fileName);
			FileChannel fileChannel = fileIn.getChannel();
			this.fileLength = fileChannel.size();
			this.number = (int) Math.ceil((double) fileLength / (double) Integer.MAX_VALUE);
			this.mappedBufArray = new MappedByteBuffer[number];// 内存文件映射数组
			long preLength = 0;
			long regionSize = (long) Integer.MAX_VALUE;// 映射区域的大小
			for (int i = 0; i < number; i++) {// 将文件的连续区域映射到内存文件映射数组中
				if (fileLength - preLength < (long) Integer.MAX_VALUE) {
					regionSize = fileLength - preLength;// 最后一片区域的大小
				}
				mappedBufArray[i] = fileChannel.map(FileChannel.MapMode.READ_ONLY, preLength, regionSize);
				preLength += regionSize;// 下一片区域的开始
			}
			this.arraySize = arraySize;
		}
 
		public int read() throws IOException {
			if (count >= number) {
				return -1;
			}
			int limit = mappedBufArray[count].limit();
			int position = mappedBufArray[count].position();
			if (limit - position > arraySize) {
				array = new byte[arraySize];
				mappedBufArray[count].get(array);
				return arraySize;
			} else {// 本内存文件映射最后一次读取数据
				array = new byte[limit - position];
				mappedBufArray[count].get(array);
				if (count < number) {
					count++;// 转换到下一个内存文件映射
				}
				return limit - position;
			}
		}
 
		public void close() throws IOException {
			fileIn.close();
			array = null;
		}
 
		public byte[] getArray() {
			return array;
		}
 
		public long getFileLength() {
			return fileLength;
		}
	}
}




1.文件字节流----测试代码如下：


import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.IOException;
 
public class StreamFileReader {
	private BufferedInputStream fileIn;
    private long fileLength;
    private int arraySize;
    private byte[] array;
 
	public StreamFileReader(String fileName, int arraySize) throws IOException {
        this.fileIn = new BufferedInputStream(new FileInputStream(fileName), arraySize);
        this.fileLength = fileIn.available();
        this.arraySize = arraySize;
    }
 
    public int read() throws IOException {
        byte[] tmpArray = new byte[arraySize];
        int bytes = fileIn.read(tmpArray);// 暂存到字节数组中
        if (bytes != -1) {
            array = new byte[bytes];// 字节数组长度为已读取长度
            System.arraycopy(tmpArray, 0, array, 0, bytes);// 复制已读取数据
            return bytes;
        }
        return -1;
    }
 
    public void close() throws IOException {
        fileIn.close();
        array = null;
    }
 
    public byte[] getArray() {
        return array;
    }
 
    public long getFileLength() {
        return fileLength;
    }
 
    public static void main(String[] args) throws IOException {
        StreamFileReader reader = new StreamFileReader("/home/zfh/movie.mkv", 65536);
        long start = System.nanoTime();
        while (reader.read() != -1) ;
        long end = System.nanoTime();
        reader.close();
        System.out.println("StreamFileReader: " + (end - start));
    }
}

2.文件通道----测试代码如下：
import java.io.FileInputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
 
public class ChannelFileReader {
	private FileInputStream fileIn;
    private ByteBuffer byteBuf;
    private long fileLength;
    private int arraySize;
    private byte[] array;
 
    public ChannelFileReader(String fileName, int arraySize) throws IOException {
        this.fileIn = new FileInputStream(fileName);
        this.fileLength = fileIn.getChannel().size();
        this.arraySize = arraySize;
        this.byteBuf = ByteBuffer.allocate(arraySize);
    }
 
    public int read() throws IOException {
        FileChannel fileChannel = fileIn.getChannel();
        int bytes = fileChannel.read(byteBuf);// 读取到ByteBuffer中
        if (bytes != -1) {
            array = new byte[bytes];// 字节数组长度为已读取长度
            byteBuf.flip();
            byteBuf.get(array);// 从ByteBuffer中得到字节数组
            byteBuf.clear();
            return bytes;
        }
        return -1;
    }
 
    public void close() throws IOException {
        fileIn.close();
        array = null;
    }
 
    public byte[] getArray() {
        return array;
    }
 
    public long getFileLength() {
        return fileLength;
    }
 
    public static void main(String[] args) throws IOException {
        ChannelFileReader reader = new ChannelFileReader("/home/zfh/movie.mkv", 65536);
        long start = System.nanoTime();
        while (reader.read() != -1) ;
        long end = System.nanoTime();
        reader.close();
        System.out.println("ChannelFileReader: " + (end - start));
    }
}

3.内存文件映射----测试代码如下：

import java.io.FileInputStream;
import java.io.IOException;
import java.nio.MappedByteBuffer;
import java.nio.channels.FileChannel;
 
public class MappedBiggerFileReader {
    private MappedByteBuffer[] mappedBufArray;
    private int count = 0;
    private int number;
    private FileInputStream fileIn;
    private long fileLength;
    private int arraySize;
    private byte[] array;
 
    public MappedBiggerFileReader(String fileName, int arraySize) throws IOException {
        this.fileIn = new FileInputStream(fileName);
        FileChannel fileChannel = fileIn.getChannel();
        this.fileLength = fileChannel.size();
        this.number = (int) Math.ceil((double) fileLength / (double) Integer.MAX_VALUE);
        this.mappedBufArray = new MappedByteBuffer[number];// 内存文件映射数组
        long preLength = 0;
        long regionSize = (long) Integer.MAX_VALUE;// 映射区域的大小
        for (int i = 0; i < number; i++) {// 将文件的连续区域映射到内存文件映射数组中
            if (fileLength - preLength < (long) Integer.MAX_VALUE) {
                regionSize = fileLength - preLength;// 最后一片区域的大小
            }
            mappedBufArray[i] = fileChannel.map(FileChannel.MapMode.READ_ONLY, preLength, regionSize);
            preLength += regionSize;// 下一片区域的开始
        }
        this.arraySize = arraySize;
    }
 
    public int read() throws IOException {
        if (count >= number) {
            return -1;
        }
        int limit = mappedBufArray[count].limit();
        int position = mappedBufArray[count].position();
        if (limit - position > arraySize) {
            array = new byte[arraySize];
            mappedBufArray[count].get(array);
            return arraySize;
        } else {// 本内存文件映射最后一次读取数据
            array = new byte[limit - position];
            mappedBufArray[count].get(array);
            if (count < number) {
                count++;// 转换到下一个内存文件映射
            }
            return limit - position;
        }
    }
 
    public void close() throws IOException {
        fileIn.close();
        array = null;
    }
 
    public byte[] getArray() {
        return array;
    }
 
    public long getFileLength() {
        return fileLength;
    }
 
    public static void main(String[] args) throws IOException {
        MappedBiggerFileReader reader = new MappedBiggerFileReader("/home/zfh/movie.mkv", 65536);
        long start = System.nanoTime();
        while (reader.read() != -1) ;
        long end = System.nanoTime();
        reader.close();
        System.out.println("MappedBiggerFileReader: " + (end - start));
    }
}

运行结果比较 

用上面三种方法读取1GB文件，运行结果如下

StreamFileReader:  11494900386
ChannelFileReader: 11329346316
MappedFileReader:  11169097480


读取10GB文件，运行结果如下

StreamFileReader:       194579779394
ChannelFileReader:      190430242497
MappedBiggerFileReader: 186923035795

原文链接：https://blog.csdn.net/xiaofeng10330111/article/details/87958174

春白里巴
关注
  • 0
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
Java使用BIO和NIO进行文件操作对比代码示例
08-19
主要介绍了Java使用BIO和NIO进行文件操作对比代码示例,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
java利用缓冲区及流式对大文件进行高效读写
book_dw5189的博客
06-23 7482
java利用缓冲区及流式对大文件进行高效读写
如何在Java中优雅地处理大文件？
最新发布
微赚开发者技术分享博客
06-26 462
在Java中优雅地处理大文件，需要合理选择文件读取和写入的方法，利用缓冲流、NIO、流式处理等技术，并注意内存管理和性能优化。希望通过本文的介绍，您能够在处理大文件时更加高效和稳定。
java 处理大文件
qq_38345598的博客
07-02 5210
前几天在开发过程中遇到一个需求: 读取一个大约5G的csv文件内容，将其转化为对象然后存储到redis中, 想着直接开大内存直接load 进入到内存中就行了，结果可想而知,5G的文件 ，Xmx 开到10G都没有解决，直接out of Memory 异常 这种处理大文件很容易造成 内存不够的问题 这种 500M的文件，堆内存一般会占用2.5G ，那么如果你去读一个5G的文件，那么内存直接起飞,所以这种不建议使用 这种因为是有按照一行行读取到内存当中, 所以耗时肯定增
Java大数据文件处理方法
沛哥儿的专栏
05-29 2349
Java大数据文件处理是一种Java编写的数据处理技术，它能够处理大型数据文件和数据流。这种技术的主要作用是对大量数据进行分析、处理和存储。随着数字化和数据化的越来越普及，Java大数据文件处理成为了一种非常重要的技术，被广泛应用于互联网和金融行业。
【开发随记】JAVA超大文件的读取和写入实现(附demo)
AkimotoKaito的博客
12-19 4000
因近期工作需要对超大单文本文件进行读取和写入，经过简单研究分别写了读取类和写入类供项目使用。现在简单整理出来分享。核心思想就是通过MappedByteBuffer进行读取和写入。
Java中处理千万级数据的最佳实践：性能优化指南
weixin_51151534的博客
10-04 2090
根据应用程序的特性，有时自定义数据结构可以提供更好的性能。例如，如果您需要高效存储大量的布尔值数据，可以考虑使用位集合（BitSet），它可以显著减小内存消耗。// 设置某些位为true bitSet . set(1);// 检查位的状态 boolean isSet = bitSet . get(100);// 返回true boolean isNotSet = bitSet . get(500);// 返回false } }// 设置某些位为true bitSet . set(1)
Java文件、文件夹权限修改的两种方法
08-25
Java文件、文件夹权限修改的两种方法 在Java中，文件和文件夹权限的修改是非常重要的，特别是在Linux和Unix系统下。今天，我们将介绍两种修改文件和文件夹权限的方法，即使用File类和NIO方式。 使用File类 File类...
java多线程URL方式下载单个大文件
09-25
在Java编程中，多线程下载大文件是一种常见的优化策略，尤其对于网络资源如文件或图片的下载。这种策略能够利用多核处理器的优势，通过并发处理来提高下载速度。本篇将详细介绍如何使用Java实现基于URL的单个大文件...
java实现大文件分割与合并的实例代码
09-05
在Java编程中，处理大文件是一项常见的挑战，尤其是在内存有限的情况下。本文将通过一个实例代码讲解如何使用Java来实现大文件的分割与合并。这个实例主要用于处理大量数据，例如进行大数据排序，它包括四个主要步骤...
java高效文件流读写操作详解
08-25
下面是几种常见的文件流读写操作方法的性能比较： * DataInputStream+FileInputStream：这种方法的性能较差，因为DataInputStream需要将字节流转换为数据流，这增加了额外的计算开销。 * DataInputStream+...
如何使用 Java 高效读取大文件
盲目的拾荒者的博客
09-24 8546
文章目录1.介绍2.读在内存中3.通过文件流读取4.使用 Apache Commons IO 进行流传输 1.介绍 如何以高效的方式从 Java 大文件中读取所有行。 2.读在内存中 准备 准备1G作用的数据 @Test public void test0() throws IOException { final String json = "[{\"id\":\"380001671739949056\",\"type\":\"3\",\"work_no\":\"chn001
java如何处理大文件
m0_46552684的博客
05-15 674
Java中处理大文件时，通常需要采取一些特定的策略来避免内存溢出或性能问题。方法的返回值来确保没有读取到文件末尾。在写入时，我们确保只写入实际读取的字节数，而不是整个缓冲区的大小。在这个示例中，我们使用了1KB的缓冲区来逐块读取和写入文件。注意，在读取时，我们检查。
java 文本处理_java处理大文本方案
weixin_36473057的博客
02-12 1186
java处理大文件，一般用BufferedReader,BufferedInputStream这类带缓冲的Io类，不过如果文件超大的话，更快的方式是采用MappedByteBuffer。MappedByteBuffer是java nio引入的文件内存映射方案，读写性能极高。NIO最主要的就是实现了对异步操作的支持。其中一种通过把一个套接字通道(SocketChannel)注册到一个选择器(Sele...
超大大文件替换与对比问题
weixin_42108319的博客
04-29 681
工作中发现本地服务器和云服务生成的成果文件大小不同，两个文件都在11G以上，且有随机码，比较十分困难 为此需要做两件事情： 1.替换随机码 引文使用的是windows环境，自然想使用powershell去处理，但大文件替换，吃内存十分严重。卡死 Get-ChildItem C:\share\67 | ForEach-Object -Process{ if($_ -is [System.I...
java 8 stream流之大数据篇
spring_root的博客
07-05 273
如果你会任意一门语言的stream流，没道理不会大数据开发。俗话说男追女隔座山，女追男隔层纱。如果说零基础学大数据，感觉前面是一座山，那么只要你会java或者任意一门语言的stream流，那大数据就只隔了一层纱。本文以java stream流计算为例，讲解一些基础的spark操作。另一个流行的大数据框架flink同理。
Java8 Stream 数据流，大数据量下的性能效率
虫二的专栏~~在路上~~~
09-13 540
Java8 Stream的操作
java大文件上传/下载解决方案整理
weixin_43852079的博客
06-11 3270
分片上传，就是将所要上传的文件，按照一定的大小，将整个文件分隔成多个数据块（我们称之为Part）来进行分别上传，上传完之后再由服务端对所有上传的文件进行汇总整合成原始的文件。断点续传是在下载/上传时，将下载/上传任务（一个文件或一个压缩包）人为的划分为几个部分，每一个部分采用一个线程进行上传/下载,如果碰到网络故障，可以从已经上传/下载的部分开始继续上传/下载未完成的部分，而没有必要从头开始上传/下载。通俗的说，你把要上传的东西上传，服务器会先做MD5校验，如果服务。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值