实例一个巨大但有限容量的map，当元素数量达到上限后，新加入的对象映射关系将替换最近不常用的对象映

射关系。

1. import java.util.HashMap;
   
2. import java.util.Map;
   
3. import java.util.Set;
   
4. 
   
5. public class MainClass {
   
6.         public static void main(String[] args) {
   
7.                 MyMap myMap = new MyMap(3);// 定义上限为3
   
8.                 for (int i = 10, j = 100; i < 20; i++, j++) {
   
9.                         myMap.put(i, j);// 放入键值对
   
10.                         myMap.get(10);// 使用键为10的键值对
    
11.                         myMap.get(11);// 使用键为11的键值对
    
12.                         myMap.get(15);// 使用键为15的键值对
    
13.                 }
    
14.         }
    
15. }
    
16. 
    
17. class MyMap {
    
18.         private Map map = null;
    
19.         private int toplimit;// 上限
    
20. 
    
21.         public MyMap(int toplimit) {
    
22.                 this.toplimit = toplimit;
    
23.                 map = new HashMap();// map指向一个HashMap对象
    
24.         }
    
25. 
    
26.         public void put(Object key, Object value) {
    
27.                 Set<Key> set = map.keySet();// map中的所有键放入一个set中
    
28.                 System.out.println("放入");
    
29.                 if (map.size() == toplimit) {// 达到上限
    
30.                         System.out.println("Map对象的容量已达到上限");
    
31. 
    
32.                         if (!set.contains(key)) {// 如果这个键是新放入的则执行下面的代码
    
33.                                 int minAccessTimes = ((Key) set.toArray()[0]).accessTimes;
    
34.                                 for (Object k : set) {
    
35.                                         if (minAccessTimes > ((Key) k).accessTimes) {
    
36.                                                 minAccessTimes = ((Key) k).accessTimes;// 取出访问量最少的次数
    
37.                                         }
    
38.                                 }
    
39.                                 for (Key k : set) {
    
40.                                         if (minAccessTimes == k.accessTimes) {// 前面找出的最少 的次数来找到对应的键
    
41.                                                 map.remove(k);// 移出这个键值对
    
42.                                                 break;
    
43.                                         }
    
44.                                 }
    
45.                         }
    
46.                 }
    
47.                 map.put(new Key(key), value);// 放入新的键值对
    
48.                 for (Key k : set) {
    
49.                         System.out.println(k.key + "," + map.get(k).toString() + ","
    
50.                                         + k.accessTimes);
    
51.                 }
    
52.         }
    
53. 
    
54.         public Object get(Object key) {
    
55.                 System.out.println("使用");
    
56.                 Set<Key> set = map.keySet();
    
57.                 Object value = null;
    
58.                 for (Key k : set) {
    
59.                         if (k.key.equals(key)) {
    
60.                                 ++k.accessTimes;// 每使用一次访问量加1
    
61.                                 value = map.get(key);
    
62.                         }
    
63.                 }
    
64.                 for (Key k : set) {
    
65.                         System.out.println(k.key + "," + map.get(k).toString() + ","
    
66.                                         + k.accessTimes);
    
67.                 }
    
68.                 return value;
    
69.         }
    
70. 
    
71.         class Key {
    
72.                 private int accessTimes = 0;// 存放这个键值对的访问量
    
73.                 private Object key = null;// 存放原始的键
    
74. 
    
75.                 public Key(Object key) {
    
76.                         this.key = key;
    
77.                 }
    
78.         }
    
79. }

复制代码

看看吧，个人觉得功能算是实现了

呵呵……有意思，我试试看