以前写的一个简单的顺序敏感的HashMap

HashMap 是无序的.
这段代码是我写的一个可以间接实现有序 HashMap的代码.
写的不好 见笑了
顺便问一下,网上现在有没有更好 更高效的类似的代码?

package com.wzj;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;

/**
 * @author fins  build 2006-07-18
 *	顺序敏感的HashMap
 *	get(int idx)/remove(int idx) 为按加入hashMap的顺序号(index) 来取得/删除 数据
 */
public class IndexHashMap extends HashMap  {

	private static final long serialVersionUID = 1L;

	private List list=new ArrayList();
	

	public Object put(Object key, Object value) {
		if (!containsKey(key)){
			list.add(key);
		}
		return super.put(key, value);
	}

	
	public Object get(int idx){
		return super.get(getKey(idx));
	}
	public int getIndex(Object key){
		return list.indexOf(key);
	}
	public Object getKey(int idx){
		if (idx>=list.size()) return null;
		return list.get(idx);
	}
	
	public void remove(int idx){
		Object key=getKey(idx);
		removeFromList(getIndex(key));
		super.remove(key);
	}
	
	public Object remove(Object key) {
		removeFromList(getIndex(key));
		return super.remove(key);
	}
	
	public void clear() {
		this.list = new ArrayList();
		super.clear();
	}
	private void removeFromList(int idx){
		if (idx<list.size() && idx>=0) {
			list.remove(idx);
		}
	}


}

TreeMap class implements SortedMap interface.

这个我知道 但是用法和我写的这个不太一样
你仔细看看
TreeMap和我需要的效果不一样

从treeMap里 不能随机取数据
只有在遍历的时候才能按顺序取

例如 我想取 treemap里 第5个加入的数据

hehe, API说明不详，有些误导。

实现上提出一个小建议。
可以不用继承，用包含。使用proxy pattern。
这样就可以对任意 Map 进行截获处理，而不只是 HashMap。

先来一个通用的ProxyMap。如果不需要重用，这个类可以不用写。主要为了展示Proxy，delegate。

public class ProxyMap {
	protected Map map;

	public ProxyMap(Map map) {
		super();
		this.map = map;
	}

	public Map getMap() {
		return map;
	}

	public void clear() {
		map.clear();
	}

	public boolean containsKey(Object key) {
		return map.containsKey(key);
	}

	public boolean containsValue(Object value) {
		return map.containsValue(value);
	}

	public Set entrySet() {
		return map.entrySet();
	}

	public boolean equals(Object o) {
		return map.equals(o);
	}

	public Object get(Object key) {
		return map.get(key);
	}

	public int hashCode() {
		return map.hashCode();
	}

	public boolean isEmpty() {
		return map.isEmpty();
	}

	public Set keySet() {
		return map.keySet();
	}

	public Object put(Object arg0, Object arg1) {
		return map.put(arg0, arg1);
	}

	public void putAll(Map arg0) {
		map.putAll(arg0);
	}

	public Object remove(Object key) {
		return map.remove(key);
	}

	public int size() {
		return map.size();
	}

	public Collection values() {
		return map.values();
	}
}

--------------------------------

IndexMap 继承 ProxyMap。
如果没有ProxyMap这个类，那么就不用继承。
需要自己实现所有Map的delegate方法。

IndexMap的代码几乎和 fins 给出的一样（就是copy过来的）。
只是可以截获所有的Map。而不只是HashMap。

import java.util.ArrayList;
import java.util.List;
import java.util.Map;

public class IndexMap extends ProxyMap{

	public IndexMap(Map map) {
		super(map);
	}
	
	 private List list = new ArrayList();

	 public Object put(Object key, Object value) {
	 if (!containsKey(key)){
	 list.add(key);
	 }
	 return super.put(key, value);
	 }

	 public Object get(int idx){
	 return super.get(getKey(idx));
	 }
	 public int getIndex(Object key){
	 return list.indexOf(key);
	 }
	 public Object getKey(int idx){
	 if (idx>=list.size()) return null;
	 return list.get(idx);
	 }
	 public void remove(int idx){
	 Object key=getKey(idx);
	 removeFromList(getIndex(key));
	 super.remove(key);
	 }
	 public Object remove(Object key) {
	 removeFromList(getIndex(key));
	 return super.remove(key);
	 }
	 public void clear() {
	 this.list = new ArrayList();
	 super.clear();
	 }
	 private void removeFromList(int idx){
	 if (idx<list.size() && idx>=0) {
	 list.remove(idx);
	 }
	 }
}

哈哈 我咋就没想到呢
高手!谢谢 buaawhl
学习!

晕, 没用过 java.util.LinkedHashMap ?

楼上的 看完帖子再发言啊

LinkedHashMap 也是不能随机存取的啊