java 一个数据文件，文件大小超过程序可用运行内存,输出id最小的128 个记录，按照id非降序排列

程序输入:
一个数据文件，文件大小超过程序可用运行内存。
文件内容为单一结构数据的数组:
class Record
{
int id;
byte gender;
short depart;
int age;
};
程序输出:
id最小的128 个记录，按照id非降序排列

注1: 结构体在文件中的存储方式可以自己假定，可以二进制也可以文本
注2:下面列出了几个函数原型供选择，使用其他语言可以自定义函数和结构体

java :
List foo(File file)
C/C++:
int foo(const char *fileName, Record *list) // 返回记录个数，list空间足够大
C#:
List foo(string fileName)

package cn.xmg.thread;

import net.sf.json.JSONObject;
import java.io.*;
import java.util.*;

/**
 * @author 作者 : xmg
 * @version 创建时间：2020年12月23日 下午12:17:25
 *
 *          程序输入: 一个数据文件，文件大小超过程序可用运行内存。 文件内容为单一结构数据的数组: class Record {    int id;
 *          byte gender; 
 *          short depart; 
 *          int age; 
 * }; 
 * 程序输出: id最小的128 个记录，按照id非降序排列
 * 
 * 
 *          内存用的 -Xms10m -Xmx10m
 */
public class MinRecords {

	/** 最大数目 */
	private static final int MAX_NUM = 128;

	/**
	 * 生成测试数据
	 * 
	 * @throws IOException
	 */
	static void createData(File file) throws IOException {
		if (!file.exists()) {
			file.getParentFile().mkdir();
			file.createNewFile();
		}
		FileWriter os = new FileWriter(file, true);
		BufferedWriter oos = new BufferedWriter(os);
		int i = 0;
		while (i < 1000000) {
			Random rand = new Random();
			Record r1 = new Record(rand.nextInt(1000000), (byte) 1, (short) 1, rand.nextInt(1000));
			oos.write(r1.toJson() + "\n");
			i++;
		}
		oos.close();
	}

	/**
	 * json字符串转为Record
	 * 
	 * @param str
	 * @return
	 */
	public static Record toObject(String str) {
		JSONObject fromObject = JSONObject.fromObject(str);
		Record record = new Record();
		record.setId((int) (fromObject.get("id")));
		record.setAge((int) (fromObject.get("age")));
		record.setGender(Byte.valueOf(fromObject.get("gender").toString()));
		record.setDepart(Short.valueOf(fromObject.get("depart").toString()));
		return record;
	}

	/**
	 * 获得按照id非降序排列的记录
	 * 
	 * @param file
	 * @return
	 * @throws IOException
	 */
	public static List<Record> foo(File file) throws IOException {
		BufferedReader reader = new BufferedReader(new FileReader(file));
		String str = null;
		// 使用优先队列创建最大堆
		PriorityQueue<Record> queue = new PriorityQueue<Record>(MAX_NUM);
		while ((str = reader.readLine()) != null) {
			Record record = toObject(str);
			if (queue.size() < MAX_NUM) {
				queue.offer(record);
			} else if (queue.peek().getId() > record.getId()) {
				queue.poll();
				queue.offer(record);
			}
		}
		List<Record> records = new ArrayList<>();
		for (int i = 0; i < MAX_NUM; i++) {
			records.add(queue.poll());
		}
		return records;
	}

	public static void main(String[] args) {
		try {
			File file = new File("D:/test.txt");
			List<Record> records = foo(file);
			for (Record r : records) {
				System.out.println(r.getId());
			}
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	static class Record implements Comparable<Record> {
		int id;
		byte gender;
		short depart;
		int age;

		Record() {

		}

		Record(int id, byte gender, short depart, int age) {
			this.id = id;
			this.gender = gender;
			this.depart = depart;
			this.age = age;
		}

		public int getId() {
			return id;
		}

		public void setId(int id) {
			this.id = id;
		}

		public byte getGender() {
			return gender;
		}

		public void setGender(byte gender) {
			this.gender = gender;
		}

		public short getDepart() {
			return depart;
		}

		public void setDepart(short depart) {
			this.depart = depart;
		}

		public int getAge() {
			return age;
		}

		public void setAge(int age) {
			this.age = age;
		}

		public String toJson() {
			JSONObject obj = new JSONObject();
			obj.put("id", id);
			obj.put("gender", gender);
			obj.put("depart", depart);
			obj.put("age", age);
			return obj.toString();
		}

		@Override
		public int compareTo(Record o) {
			return this.id - o.getId();
		}
	}
}