一个简单的笨重Map，内存中保存一些对象，其他的保存到硬盘。

今天观看论坛，发现有些初学者，总是将大量的数据存入HashMap中，造成内存溢出。

问题的关键是，造成溢出以后，不去改进算法，而是机械的调节JVM的最大内存容量，这并不能从根本上解决问题。

除了B+Tree等较好的算法以外，我想来想去，还有一个相对简单点的实现方案，就是效率硬盘没有索引，效率相对较低。

代码如下：

import java.io.EOFException;
import java.io.File;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.util.HashSet;
import java.util.LinkedHashMap;

public class HeavyMap extends LinkedHashMap<String, Integer> {
	private static final long serialVersionUID = -858815745597381386L;
	public static final int DEFAULT_CAPACITY = 2000;
	public static final String File_Prefix = "heavy_map";
	public static final String File_Suffix = "bin";
	private int capacity;// 内存对象容量
	private RandomAccessFile switchFile;// 数据交换文件
	private HashSet<Integer> virtualCache = new HashSet<Integer>();

	public HeavyMap() throws IOException {
		this(DEFAULT_CAPACITY);
	}

	public HeavyMap(int capacity) throws IOException {
		this(capacity, File.createTempFile(File_Prefix, File_Suffix));
	}

	public HeavyMap(int capacity, File switchFile) throws IOException {
		super(16, 0.75f, true);
		this.capacity = capacity;
		if (switchFile.isDirectory()) {
			switchFile = File.createTempFile(File_Prefix, File_Suffix,
					switchFile);
		}
		this.switchFile = new RandomAccessFile(switchFile, "rw");
	}

	@Override
	public Integer put(String key, Integer value) {
		virtualCache.add(key.hashCode());
		return super.put(key, value);
	}

	@Override
	protected boolean removeEldestEntry(
			java.util.Map.Entry<String, Integer> eldest) {
		if (size() >= capacity) {
			updateEntry(eldest);
			return true;
		}
		return false;
	}

	@Override
	public Integer get(Object key) {
		Integer value = super.get(key);
		if (value == null && virtualCache.contains(key.hashCode())) {
			Integer v = findValue((String) key);
			if (v != null) {
				put((String) key, v);
			}
		}
		return value;
	}

	private Integer findValue(Object key) {
		synchronized (switchFile) {
			try {
				switchFile.seek(0L);
				long length = switchFile.length();
				while (switchFile.getFilePointer() < length) {
					int hash = switchFile.readInt();
					int len = switchFile.readInt();
					if (hash == key.hashCode()) {
						byte[] data = new byte[len - 4];
						if (switchFile.read(data) < 0) {
							throw new EOFException();
						}
						int valueNumber = switchFile.readInt();
						String keyString = new String(data, "UTF-8");
						if (keyString.equals(key)) {
							return valueNumber;
						}
					} else {
						switchFile.skipBytes(len);
					}
				}
			} catch (EOFException e) {
				return null;
			} catch (IOException e) {
				throw new IllegalStateException("读取交换区数据时产生异常", e);
			}
		}
		return null;
	}

	private void updateEntry(java.util.Map.Entry<String, Integer> e) {
		synchronized (switchFile) {
			try {
				switchFile.seek(0L);
				long length = switchFile.length();
				while (switchFile.getFilePointer() < length) {
					int hash = switchFile.readInt();
					int len = switchFile.readInt();
					if (hash == e.getKey().hashCode()) {
						byte[] data = new byte[len - 4];
						if (switchFile.read(data) < 0) {
							throw new EOFException();
						}
						int valueNumber = switchFile.readInt();
						String keyString = new String(data, "UTF-8");
						if (keyString.equals(e.getKey())
								&& valueNumber != e.getValue()) {
							switchFile.seek(switchFile.getFilePointer() - 4);
							switchFile.writeInt(e.getValue());
						}
					} else {
						switchFile.skipBytes(len);
					}
				}
			} catch (IOException ex) {
				throw new IllegalStateException("读取交换区数据时产生异常", ex);
			}
		}
	}

	@Override
	public void clear() {
		super.clear();
		virtualCache.clear();
	}
	
	@Override
	protected void finalize() throws Throwable {
		super.finalize();
		switchFile.close();
	}
}