Java LinkedHashMap removeEldestEntry()用法及代码示例

使用Java中的java.util.LinkedHashMap.removeEldestEntry()方法来跟踪Map是否从Map中删除了最老的条目。因此,每次将新元素添加到LinkedHashMap时,最旧的条目都会从Map中删除。通常在使用put()和putall()方法将元素添加到Map中之后调用此方法。

此方法允许Map按照其返回值的指示修改自身。尽管允许该方法直接修改Map,但如果这样做,它必须返回false,这表明该Map不应尝试任何进一步的修改而导致歧义的事实。未指定从此方法修改映射后返回true的效果。

当映射表表示一个高速缓存时,此函数非常有用,在该高速缓存表中,它允许映射表通过依次删除陈旧条目来减少内存消耗。
用法:

private boolean removeEldestEntry(Map.Entry eldest)

参数:该方法接受一个最老的参数,该参数表示映射中最近插入的条目。如果映射具有访问顺序,则最旧引用最近访问最少的条目,如果此方法返回true,则将其删除。如果在put或putAll调用之前映射为空,则这将是刚刚插入的条目;换句话说,如果Map包含单个条目,则最旧的条目也是最新的条目。

返回值:如果将最旧的条目从映射中删除,则映射返回true;如果不删除或保留该条目,则返回false。

下面的程序用于说明java.util.LinkedHashMap.removeEldestEntry()方法的用法:

// Java program to illustrate removeEldestEntry() 
import java.util.*; 
  
public class Linked_Hash_Map_Demo { 
  
    // Refers to the max size of the map following which 
    // the removal takes place of the eldest entry 
    private static final int MAX = 6; 
  
    public static void main(String[] args) 
    { 
  
        // Creating the linked hashmap and implementing 
        // removeEldestEntry() to MAX size 
        LinkedHashMap<Integer, String> li_hash_map =  
        new LinkedHashMap<Integer, String>() { 
            protected boolean removeEldestEntry(Map.Entry<Integer, String> eldest) 
            { 
                return size() > MAX; 
            } 
        }; 
        // Adding elements using put() 
        li_hash_map.put(0, "Welcome"); 
        li_hash_map.put(1, "To"); 
        li_hash_map.put(2, "The"); 
        li_hash_map.put(3, "World"); 
        li_hash_map.put(4, "Of"); 
        li_hash_map.put(5, "geeks"); 
  
        System.out.println("" + li_hash_map); 
  
        // Adding more elements 
        li_hash_map.put(6, "GeeksforGeeks"); 
  
        // Displying the map after adding one more element 
        System.out.println("" + li_hash_map); 
  
        // Adding more elements 
        li_hash_map.put(7, "Hello"); 
  
        // Displying the map after adding one more element 
        System.out.println("" + li_hash_map); 
    } 
}

输出:

{0=Welcome, 1=To, 2=The, 3=World, 4=Of, 5=geeks}
{1=To, 2=The, 3=World, 4=Of, 5=geeks, 6=GeeksforGeeks}
{2=The, 3=World, 4=Of, 5=geeks, 6=GeeksforGeeks, 7=Hello}

参考: https://docs.oracle.com/javase/8/docs/api/java/util/LinkedHashMap.html#removeEldestEntry-java.util.Map.Entry-

  • 4
    点赞
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
### 回答1: LRU算法(Least Recently Used)可以使用Java集合框架中的LinkedHashMap来实现,LinkedHashMap提供了一种按访问顺序排序的功能,具体实现示例如下:import java.util.*;public class LRUCache { // 容量 private int capacity; // 使用LinkedHashMap保存缓存的内容 private LinkedHashMap<Integer, Integer> cache; // 构造函数 public LRUCache(int capacity) { this.capacity = capacity; cache = new LinkedHashMap<Integer, Integer>(capacity, 0.75f, true){ // 重写removeEldestEntry方法 @Override protected boolean removeEldestEntry(Map.Entry<Integer, Integer> eldest) { return size() > capacity; } }; } // 根据key获取缓存内容 public int get(int key) { Integer value = cache.get(key); if (value == null) { return -1; } else { return value; } } // 存入key-value public void put(int key, int value) { cache.put(key, value); } } ### 回答2: LRU算法(Least Recently Used,最近最少使用)是一种用于缓存替换策略的算法,它保留最近使用的数据,并淘汰最久未使用的数据。以下是使用Java实现LRU算法的详细代码: ```java import java.util.HashMap; class Node { int key; int value; Node prev; Node next; public Node(int key, int value) { this.key = key; this.value = value; } } class LRUCache { private int capacity; private HashMap<Integer, Node> map; private Node head; private Node tail; public LRUCache(int capacity) { this.capacity = capacity; this.map = new HashMap<>(); this.head = new Node(0, 0); this.tail = new Node(0, 0); head.next = tail; tail.prev = head; } public int get(int key) { if (map.containsKey(key)) { Node node = map.get(key); remove(node); addToHead(node); return node.value; } return -1; } public void put(int key, int value) { if (map.containsKey(key)) { Node node = map.get(key); node.value = value; remove(node); addToHead(node); } else { if (map.size() == capacity) { map.remove(tail.prev.key); remove(tail.prev); } Node newNode = new Node(key, value); map.put(key, newNode); addToHead(newNode); } } private void addToHead(Node node) { node.next = head.next; node.next.prev = node; node.prev = head; head.next = node; } private void remove(Node node) { node.prev.next = node.next; node.next.prev = node.prev; } } ``` 本实现使用HashMap来存储缓存数据,HashMap的键为键值,值为对应的Node节点。 LRUCache类有一个构造函数用于初始化缓存容量。get方法用于获取缓存中的值,它首先判断缓存是否包含该键值,如果包含,则将对应的节点移至链表头部并返回对应的值;如果不包含则返回-1。put方法用于存储缓存数据,如果缓存中已存在该键值,则更新对应的值并将对应的节点移至链表头部;如果缓存大小已达到容量上限,则删除最久未使用的节点,并将新节点添加至链表头部。addToHead和remove方法用于调整链表节点的位置,将最近使用的节点移至链表头部,最久未使用的节点移至链表尾部。 以上就是使用Java实现LRU算法的详细代码。 ### 回答3: LRU(最近最少使用)算法是一种缓存淘汰策略,它根据缓存中数据的访问时间来进行淘汰。当缓存已满时,会淘汰掉最近最少使用的数据。下面是使用Java实现LRU算法的详细代码: ```java import java.util.HashMap; public class LRUCache { private int capacity; private HashMap<Integer, Node> cache; private Node head; private Node tail; public LRUCache(int capacity) { this.capacity = capacity; cache = new HashMap<>(); head = new Node(-1, -1); tail = new Node(-1, -1); head.next = tail; tail.prev = head; } public int get(int key) { if (cache.containsKey(key)) { Node node = cache.get(key); // 将访问的节点移到链表头部 removeNode(node); addToHead(node); return node.value; } return -1; } public void put(int key, int value) { if (cache.containsKey(key)) { Node node = cache.get(key); node.value = value; // 将访问的节点移到链表头部 removeNode(node); addToHead(node); } else { if (cache.size() == capacity) { // 移除最近最少使用的节点 cache.remove(tail.prev.key); removeNode(tail.prev); } Node newNode = new Node(key, value); cache.put(key, newNode); addToHead(newNode); } } private void removeNode(Node node) { node.prev.next = node.next; node.next.prev = node.prev; } private void addToHead(Node node) { node.next = head.next; node.prev = head; head.next.prev = node; head.next = node; } private class Node { private int key; private int value; private Node prev; private Node next; public Node(int key, int value) { this.key = key; this.value = value; } } } ``` 以上代码实现了一个LRUCache类,里面包含了LRU算法的核心逻辑。LRUCache类有一个构造函数用于初始化缓存容量,get()方法用于获取缓存中的数据,put()方法用于往缓存中添加数据。算法通过双向链表和哈希表实现,双向链表中的节点按照访问顺序从头到尾依次排列,哈希表用于加快查找节点的速度。当缓存已满时,淘汰最近最少使用的节点,即双向链表的尾节点。对于get操作和put操作,都会将访问的节点移到链表头部,保证头部节点是最近访问的节点。这样即可以实现LRU算法的缓存淘汰策略。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值