两个上亿行的大文件取交集

最新推荐文章于 2024-07-25 08:48:59 发布
最新推荐文章于 2024-07-25 08:48:59 发布
阅读量1.6k 收藏 2
点赞数
分类专栏： java知识 文章标签： 排序 大文件 上亿 java
前两天看到一哥们百度面试归来后发的帖子，并分享了其百度面试题，其中有一个题大意如下：
现有两个上亿行的文件，每一行都只有一个数字，求这两个文件的交集。

我的思路如下：首先是分别对这两个文件排序，然后，再同时遍历这两个文件。求出交集即可。
下面我对大文件的排序进行了简单的实现。
基本思路如下，首先对大文件进行拆分，一亿行的大文件可以拆分成10个小文件，并分别对这10个小文件进行排序，之后对这10个有序的小文件进行遍历，比较，再合并成一个大文件即可完成排序。
里面文件的路径为D://bigfile

代码如下。
main函数在bigFile中。 

package com.fly.lee.bigfile;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class BigFile {
	private List<String> subFileNameList = new ArrayList<String>();
	private String bigFilePath = "D:/bigfile/";

	private String bigFileName = "Source1.txt";
	private FileGenerator fGenerator = new FileGenerator();

	private static final int theMaxNumber = 10000000;
	private List<Integer> theContentWritingToSubFile = new ArrayList<Integer>(theMaxNumber);

	public void sortTheBigfile(String destination){
		splitTheBigFile();
		SourceFolder sFolder = new SourceFolder();
		sFolder.setFilenameList(subFileNameList);
		sFolder.setDestination(destination);
		try {
			sFolder.compareFiles();
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		removeTheSubFiles();
	}

	public void setBigFilePath(String bigFilePath) {
		this.bigFilePath = bigFilePath;
	}

	public void setBigFileName(String bigFileName) {
		this.bigFileName = bigFileName;
	}

	private void removeTheSubFiles() {
		for(String fileName:subFileNameList){
			File file = new File(fileName);
			if(file.exists()&&file.canWrite()){
				System.out.println(fileName+":"+file.delete());;
			}
		}
	}

	public void splitTheBigFile(){
		System.out.println("begin to spliting the big files...");
		int counter = 0;
		File file = new File(bigFilePath+bigFileName);
        BufferedReader reader = null;
        FileReader fReader;
        int fileFlag = 1;
        try {
        	fReader = new FileReader(file);
            reader = new BufferedReader(fReader);
            String tempString = null;
            while ((tempString = reader.readLine()) != null) {
            	if(tempString.trim().equals("")){
            		break;
            	}
            	int tempInt = Integer.valueOf(tempString);
            	theContentWritingToSubFile.add(tempInt);
            	if(isTheListFull(counter)){
            		handleTheFullList(fileFlag);
            		theContentWritingToSubFile.clear();
            		fileFlag ++;
            	}
            }
            handleTheFullList(fileFlag);
            fReader.close();
            reader.close();
            System.out.println("finishing the spliting work.");
        }catch(Exception e){
        	e.printStackTrace();
        }
	}

	private void handleTheFullList(int fileFlag) throws Exception {
		System.out.println("handle the full list...");
		String tempFilePath = bigFilePath + fileFlag + ".txt";
		writeTheContentToSubFile(tempFilePath);
		subFileNameList.add(tempFilePath);
		theContentWritingToSubFile.clear();
		System.out.println("the full list is clear now...");
	}

	private void writeTheContentToSubFile(String tempFilePath) throws Exception {
		System.out.println("begin to write the content to sub file...");
		System.out.println("sub file path:"+tempFilePath);
		Collections.sort(theContentWritingToSubFile);
		fGenerator.setFileName(tempFilePath);
		fGenerator.setTheListNeedToWriteTofile(theContentWritingToSubFile);
		fGenerator.writeToFileFromTheList(true);
		System.out.println("finishing this loop of writing the content to sub file...");
	}

	private boolean isTheListFull(int counter) {
		return theContentWritingToSubFile.size() >= theMaxNumber; 
	}

	public static void main(String[] args) {
		BigFile bf = new BigFile();
		bf.setBigFileName("Source1.txt");
		bf.sortTheBigfile("D:/bigfile/Source1_sorted.txt");
	}
}


SourceFolder.java: 主要负责对文件夹下拆分后的小文件进行比较并合并成一个新的有序文件。 

package com.fly.lee.bigfile;

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class SourceFolder {
	private List<String> filenameList;
	private Map<Integer, Integer> numberCache;
	private List<BufferedReader> bufferedReaderList;
	private int endFlagNumber = 0;
	private List<Integer> contentListWritingToFile;
	private FileGenerator fileGenerator; 
	private String destination = "D:/bigfile/AllSource.txt";


	public SourceFolder() {
		contentListWritingToFile = new ArrayList<Integer>();
		filenameList = new ArrayList<String>();
		bufferedReaderList = new ArrayList<BufferedReader>();
		fileGenerator = new FileGenerator();
	}

	public void setDestination(String destination) {
		this.destination = destination;
	}
	public void addFile(String filename) {
		this.filenameList.add(filename);
	}
	public void setFilenameList(List<String> filenameList) {
		this.filenameList = filenameList;
	}

	public void compareFiles() throws Exception {
		System.out.println("filenameList:"+filenameList);
		initTheBufferedReaderList();
		initTheNumberCache();
		while(!isAllFilesFinishTheComparing()){
			int theIndexOfReaderNeedingToMove = findTheLastIndexOfTheMinNumber();
			addTheNumberToFile(theIndexOfReaderNeedingToMove);
			updateNumberCache(theIndexOfReaderNeedingToMove);
		}
		addTheLastListToFile();
		closeAllIOStreams();
	}

	private void closeAllIOStreams() throws IOException {

		for(BufferedReader bReader:bufferedReaderList){
			if(bReader != null){
				bReader.close();
			}
		}

	}

	private int findTheLastIndexOfTheMinNumber() {
		int theIndexOfTheMinNumber = 0;
		int mixNumber = getTheFirstNumberFromTheCache();
		for (int index = 0; index < numberCache.size(); index++) {
			if(numberCache.get(index) == null){
				continue;
			}
			int theNumberWillBeCompared = numberCache.get(index);
			if (mixNumber >= theNumberWillBeCompared) {
				mixNumber = theNumberWillBeCompared;
				theIndexOfTheMinNumber = index;
			}
		}
		return theIndexOfTheMinNumber;
	}

	private int getTheFirstNumberFromTheCache() {
		for (int index = 0; index < numberCache.size(); index++) {
			if(numberCache.get(index) == null){
				continue;
			}
			return numberCache.get(index);
		}
		return 0;
	}

	private void addTheNumberToFile(int theIndexOfReaderNeedingToMove) throws Exception {
		contentListWritingToFile.add(numberCache.get(theIndexOfReaderNeedingToMove));
		if(contentListWritingToFile.size() == 1000000){
			fileGenerator.setTheListNeedToWriteTofile(contentListWritingToFile);
			fileGenerator.setFileName(destination);
			fileGenerator.writeToFileFromTheList( false);
			contentListWritingToFile.clear();
		}
	}

	private void updateNumberCache(int index) throws Exception {
		BufferedReader bufferedReader = bufferedReaderList.get(index);
		String tempString = null;
		if ((tempString = bufferedReader.readLine()) != null) {
			if (!"".equals(tempString.trim())) {
				int tempInt = Integer.valueOf(tempString);
				numberCache.put(index, tempInt);
			}
		} else {
			numberCache.put(index, null);
			endFlagNumber ++;
		}
	}

	private void addTheLastListToFile() throws Exception {
		fileGenerator.setTheListNeedToWriteTofile(contentListWritingToFile);
		fileGenerator.setFileName(destination);
		fileGenerator.writeToFileFromTheList(false);
	}



	private void initTheBufferedReaderList() throws FileNotFoundException {
		System.out.println("begin to initial the buffered reader...");
		for (String filename : filenameList) {
			BufferedReader bufferedReader = new BufferedReader(new FileReader(
					filename));
			bufferedReaderList.add(bufferedReader);
		}
		System.out.println("finish initialing the buffered reader...");
	}

	private void initTheNumberCache() throws Exception {
		System.out.println("begin to initial the number cache...");
		numberCache = new HashMap<Integer, Integer>(filenameList.size());
		for (int index = 0; index < filenameList.size(); index++) {
			updateNumberCache(index);
		}
		System.out.println("finish initialing the number cache...");
	}

	private boolean isAllFilesFinishTheComparing() {

		return endFlagNumber == filenameList.size();
	}
}

FileGenerator.java主要是负责将生成好的链表写入到一指定的文件中，可以选择是覆盖文件或者是在文件后添加。里面也有生成上亿行文件的方法(测试时可以事先用此方法生成大文件。 : ) ). 

package com.fly.lee.bigfile;

import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

public class FileGenerator {
	private int wholeLineNumber = 100000000;

	private List<Integer> theListNeedToWriteTofile;
	private String fileName;
	private FileWriter fWriter = null;

	//	public void write
	public static void main(String[] args) {
		String fileName = "D:/bigfile/Source_yiwan.txt";
		FileGenerator fileGenerator = new FileGenerator();
		fileGenerator.setFileName(fileName);
		try {
			fileGenerator.createRandomFile();
			fileGenerator.closeFileWriter();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	public void setFileName(String fileName) {
		this.fileName = fileName;
	}

	public void setWholeLineNumber(int wholeLineNumber) {
		this.wholeLineNumber = wholeLineNumber;
	}

	public void setTheListNeedToWriteTofile(List<Integer> theListNeedToWriteTofile) {
		this.theListNeedToWriteTofile = theListNeedToWriteTofile;
	}
	public void createRandomFile() throws Exception {
		int listSize = 10000000;
		theListNeedToWriteTofile = new ArrayList<Integer>(listSize);
		for(int i = 0; i < wholeLineNumber; i ++){
			int tempRandomInt = (int)(Math.random()*100000000);
			theListNeedToWriteTofile.add(tempRandomInt);
			if(theListNeedToWriteTofile.size()==listSize){
				System.out.println("begin to write to the file...");
				writeToFileFromTheList(false);
				theListNeedToWriteTofile.clear();
				System.out.println("finish this loop...");
			}
		}
		writeToFileFromTheList(false);
}

	public void writeToFileFromTheList(boolean isNeedToCreateNewFile) throws Exception {
		System.out.println("write the content to file...");
		try {
			if(isNeedToCreateNewFile){
				createNewFile(fileName);
			}
			StringBuilder contentWritingToFile = new StringBuilder();
			int cycleLineNumber = 1000000;
			int counter = 0;
			fWriter = new FileWriter(fileName,true);
			for(int index = 0; index < theListNeedToWriteTofile.size(); index ++){
				int tempRandomInt = theListNeedToWriteTofile.get(index);
				contentWritingToFile.append(tempRandomInt+"\n");
				if(counter == cycleLineNumber){
					fWriter.append(contentWritingToFile.toString());
					counter = 0;
					contentWritingToFile = new StringBuilder();
				}
			}
//			while(theListNeedToWriteTofile.size() != 0){
//				int tempRandomInt = theListNeedToWriteTofile.remove(0);
//				contentWritingToFile.append(tempRandomInt+"\n");
//				if(counter == cycleLineNumber){
//					fWriter.append(contentWritingToFile.toString());
//					counter = 0;
//					contentWritingToFile = new StringBuilder();
//				}
//			}
			fWriter.append(contentWritingToFile.toString());
			System.out.println("done..........");
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} finally{
			closeFileWriter();
		}
	}

	private void closeFileWriter() throws IOException{
		if(fWriter != null){
			fWriter.close();
		}
	}
	private void createNewFile(String fileName) throws IOException {
		File file = new File(fileName);
		if(file.delete()){
			file.createNewFile();
		}
	}
}

至此，完成了大文件的排序。至于下一步就是对着两个有序的大文件进行遍历比较了，
1.两个索引分别指向两个大文件的第一行。
2.如果两个索引所指的数据一样，记录当前数据到新的文件，并将两个指针分别下移一位。
如果二者不相等，则将数据较小的指针下移一位。
3.判断是否到其中一个文件的结尾，如果是，结束比较，否则重复步骤2。
这样就可以取出二者的交集，代码到此结束。
「已注销」
关注
专栏目录
linux两个文件取交集、并集、差集
Kenina_Xie的博客
10-29 2398
如何得到两个文件的交集、并集和差集？ 交集：两个文件中都出现的行 并集：两个文件中的所有行加起来，去掉重复 差集：在一个文件中存在，而在另一个文件中不存在。 比如以下两个文件： a.txt aaa bbb ccc 111 222 b.txt ccc ddd eee 111 333 结果： a.txt和b.txt的交集： ccc 111 a.txt和b.txt的并集： 111 222 333 aaa bbb ccc ddd eee a.txt中存在b.txt中不存在： 222 aaa bbb b.txt中存在
Python脚本002：取两个文件数据的交集
qq_41876456的博客
07-31 816
背景：需要标注夜间行人检测的数据集（原图15w张.jpg） 1.老师提供了10w张.txt标注数据（已经检测好的） 2.我这边对数据集做了一个筛选，将光照强度高的剔除，留下夜间10w.jpg 3.现在需要取1和2的数据的交集，分别存在JEPGImage文件夹和Annotations文件夹中 #author：XuLiu #time：2021-07-29 #fuction：we select 10w pictures,then we should pipei 15w txtfiles #input:10w .
2个特别大的文件A和文件B，求交集
何超杰的博客
07-17 972
2个特别大的文件A和文件B，求交集 文件中存放的是url，2个文件都无法直接读到内存。 思路 hash+分片 1.将文件A中的hash(url)%100，生成100个小文件。 2.文件B中也hash(url)%100，生成100个小文件。 3.然后将A子文件001和B子文件001求交集，放入一个结果文件即可。 ...
两个超大文件求交集
qq_40813329的博客
11-25 963
题目背景 给定a、b两个文件，各存放50亿个url，每个url各占64字节，内存限制是4G，让你找出a、b文件共同的url 主体思路 分治+hash 实现步骤 遍历文件A，对每个url使用hash(url) % 1000，根据所得的取值将url存储到1000个小文件中（a1,a2,…,a1000）（根据内存大小设定hash函数） 遍历文件B，使用同样的hash函数将B中的url存储到1000个小文件中（b1,b2,…,b1000）（这样相同的url就会被映射到下标相同的小文件中） 求每对小文件中相同的ur
两个大文件求交集
二进制的博客
07-06 4207
前段时间有人问我，给你两个文件，每个文件每行都是字符串，如何找出两个文件中行相同的字符串。当时提供了两个思想，但是对方不满意。 假设文件为a，b 1.直接遍历法。一般人第一时间都是想遍历吧。读取每一行a，在b中遍历，这样时间复杂度为O（n^2），显然一般人都不能接受这个时间复杂度。 2.利用哈希思想。先把a文件hash，在遍历b文件，去判断是否存在。时间复杂度降低为O（n） ，但是空间复杂度...
用java实现在 对两个文件数据取交集、并集、差集
m0_63064861的博客
05-10 560
【代码】用java实现在 对两个文件数据取交集、并集、差集。
读取两个文件，并求其交集，输出交集量比较大的（百度语音算法一面、二面）
weixin_41888257的博客
08-11 1237
1. 题目描述 示例： file1.txt a b file2.txt a b c 读出两个文件，得到 list1 = ['a', 'b'] list2 = ['a', 'b', 'c'] 最终输出 {'a': 2} 2. 解题思路 & 代码 def inter(list1, list2): dict1 = {} for item in list1: if item not in dict1: dict1[item] = 1
利用vbs代码提取两个txt文件的交集
04-22
有2个txt文件：qq1.txt和qq2.txt，现用vbs代码实现：提取两者的交集保存为qq3.txt
Python实现求两个csv文件交集的方法
01-21
本文实例讲述了Python实现求两个csv文件交集的方法。分享给大家供大家参考，具体如下： #!/usr/bin/env python rd3 = open('data_17_17_2.csv') base = open('data_17_17_3.csv') wr3 = open('delNoBuyed3...
布隆过滤器（Bloom Filter）（给两个文件，分别有100亿个字符串，我们只要1g的内存，如何找到两个文件的交集？分别给出精确算法和近似算法？）
zhao_miao的博客
09-15 2044
  给两个文件，分别有100亿个字符串，我们只要1g的内存，如何找到两个文件的交集？分别给出精确算法和近似算法？ 精确算法：   我们可以创建1000个文件，运用哈希函数先将文件1的字符串保存在对应的文件中，之后再文件2中取元素，通过哈希函数计算出哈希地址，去对应的文件里面找是否有与之相同的字符串。 近似算法：   我们可以使用位图的方法，通过一个函数将一个元素映射成一个位矩阵中的一个点，这样...
【海量数据问题】两个超大文件求交集
alicelmx的博客
04-19 7482
分治法解决大数据问题
面试--超大文件取交集
wmq534的专栏
08-20 3440
如果仅仅只是要取两个文件中都存在的数字，而不用管这个数字在两个文件中出现的次数的话，用BitSet就行了。 这个昨天有人讨论过，说给40亿个整数排序。 用数组显然是不行的，太大了，一个整形使用4Byte，1亿个int就会花400M左右的内存，10亿就是4G内存。 因为int的最大数是2^32 - 1 == 约43亿，用一个二进制的下标来表示一个int值，大概需要43亿个bit位，
大厂面试官问我：两个1亿行的文件怎么求交集？【后端八股文十五：场景题合集】
最新发布
qq_33445788的博客
07-25 1938
任务分批： 将任务分成多个批次，每次从任务列表中取出一部分任务交给线程池处理。这样可以避免一次性将大量任务提交给线程池，减少系统资源竞争。 线程池大小调优： 根据系统资源和任务的性质，合理设置线程池的大小。如果任务是 CPU 密集型的，可以设置较少的线程数；如果任务是 I/O 密集型的，可以适当增加线程数。避免线程数过多导致上下文切换频繁，影响性能。
数据量比较大的两个集合，求交集和差集
STRANGE-P 的博客
09-23 3448
数据量比较大的两个集合求交集1、使用 retainAll 函数2、使用 LinkedList + 迭代器 1、使用 retainAll 函数   import java.util.*; /** * 求交集 1 */ public class ListIntersection1 { public static void main(String[] args) { List<String> listA = new ArrayList<String
多个文件求交集并生成矩阵
浮生终有醒
12-17 1037
博主觉得写得还是有点复杂，求再简单一些的方法！ #!perl use warnings; use strict; my %hash; my %samp; foreach my $f(@ARGV) { my $id = $f; open FF, $f or die $!; while() { chomp; my @tmp = split; $hash{$tmp[0]} =
面试经典题型--海量数据处理
EQUINOX1的博客
08-22 195
海量数据处理是指基于海量数据的存储和处理，正因为数据量太大，所以导致要么无法在短时间内迅速处理，要么无法一次性装入内存。
linux得到两个文件的交集、并集
weixin_49621901的博客
04-21 740
1、 两个文件的交集、并集（每个文件中不得有重复 也可以是多个文件）(2)、取出两个文件的交集（只留下同时存在于两个文件中的文件）(1)、取出两个文件的并集（重复的行只保留一份）(1)、 一个文件在上，一个文件在下。(2)、 一个文件在左，一个文件在右。(3)、 删除交集，留下其他的行。(1)、 重复的多行记为一行。(2)、 重复的行全部去掉。3、一个文件去掉重复的行。
对比两个txt大文件，写出差异值
weixin_40403318的博客
11-14 1503
该程序能对比两个大txt文件，已测两个400M文件对比，结果在三分钟内执行完毕，需在Linux下执行，Windows下容易出现内存不足。 package test; import java.io.*; import java.util.ArrayList; import java.util.HashMap; import java.util.List; import java.util.Map; ...
十万以上数据的两个集合进行交集，差集运算，ArrayList为什么特别慢？HashSet为什么效率如此高？
真相不难
06-11 4242
1
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值