关联容器map设计

import java.util.*;
public class Main{
    public static void main(String[] args){
        Scanner in = new Scanner(System.in);
        int n = Integer.parseInt(in.nextLine());
        int curSize = 0;
        LinkedHashMap<String, Long> map = new LinkedHashMap<>();
        while(in.hasNext()){
            String curInput = in.nextLine();
            String[] stringArray = curInput.split(" ");
            String curKey = stringArray[0];
            long curValue = Long.parseLong(stringArray[1]);
            if(map.containsKey(curKey)){
                if(map.get(curKey) < curValue){
                    map.remove(curKey);
                    map.put(curKey, curValue);
                }
            }else{
                if(curSize < n){
                    curSize++;
                }else{
                    for(String s : map.keySet()){
                        System.out.println(s+" "+map.get(s));
                        map.remove(s);
                        break;
                    }
                }
                map.put(curKey, curValue);
            }
        }
    }
}

import java.util.*;

/**
 * LRU 算法 LinkHashMap 或者 hashMap + Queue
 */

public class Main {

     public static void main(String[] args) {


        Scanner sc = new Scanner(System.in);
        int N = sc.nextInt();
        sc.nextLine();

        //记录数据
        LinkedHashMap<String , Long> LRUhashMap = new LinkedHashMap<>();

        while (sc.hasNext()){

            //输入k - v
            String[] insert = sc.nextLine().split(" ");
            String key = insert[0];
            String value = insert[1];

            if(LRUhashMap.containsKey(key)){
                if(LRUhashMap.get(key)-Long.valueOf(value) < 0){
                    LRUhashMap.remove(key);
                    LRUhashMap.put(key,Long.valueOf(value));
                }
            }else{
                if(LRUhashMap.size() < N){ //空间剩余
                    LRUhashMap.put(key,Long.valueOf(value));
                }else if(LRUhashMap.size() == N){ //空间不足
                    for(String s : LRUhashMap.keySet()){
                        System.out.println(s + " " + LRUhashMap.get(s));
                        LRUhashMap.remove(s);
                        LRUhashMap.put(key,Long.valueOf(value));
                        break;
                    }
                }
            }
        }
    }
}

	

import java.util.*;
public class Main{
    /*
     LRU 实现
     容量不足则将最少使用的剔除掉
    */
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        int capa = sc.nextInt();
        DList lru = new DList(capa);
        while(sc.hasNext()){
            String key = sc.next();
            long val = sc.nextLong();
            lru.put(key, val);
        }
    }
}
class DList{
    int count;
    int capa;
    Map<String, Node> map;
    Node head;
    Node tail;
    public DList(int capa){
        map = new HashMap<>();
        count = 0;
        this.capa = capa;
        head = new Node("", -1);
        tail = new Node("", -1);
        head.next = tail;
        tail.pre = head;
    }

    public void put(String key, long val){
        Node node = map.get(key);
        if(node == null){
            node = new Node(key, val);
            map.put(key, node);
            Node reNode = addNewNode(node);
            if(reNode != null){
                map.remove(reNode.key);
                System.out.println(reNode.key + " " + reNode.val);
            }
            return;
        }
        if(node.val < val){
            node.val = val;
            moveToHead(node);
        }
    }

    public Node addNewNode(Node node){
        moveToHead(node);
        if(count == capa){
            return removeTail();
        }
        count++;
        return null;
    }

    public void moveToHead(Node node){
        if(node.pre != null){
            node.pre.next = node.next;
            node.next.pre = node.pre;
        }
        node.next = head.next;
        node.pre = head;
        head.next.pre = node;
        head.next = node;
    }

    private Node removeTail(){
        if(count == 0){
            return null;
        }
        Node temp = tail.pre;
        temp.pre.next = tail;
        tail.pre = temp.pre;
        temp.pre = null;
        temp.next = null;
        return temp;
    }
}
class Node{
    String key;
    long val;
    Node pre;
    Node next;
    public Node(String key, long val){
        this.key = key;
        this.val = val;
    }
}

import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        LRUMap<String, Long> map = new LRUMap<>(n, 0.75f, true);
        while (sc.hasNext()) {
            String key = sc.next();
            long value = sc.nextLong();
            if (map.containsKey(key)) {
                if (value > map.get(key)) {
                    map.put(key, value);
                }
            } else {
                map.put(key, value);
            }
        }
    }
}


class LRUMap<String, Long> extends LinkedHashMap<String, Long> {
    int max;

    public LRUMap(int initialCapacity, float loadFactor, boolean accessOrder) {
        super(initialCapacity, loadFactor, accessOrder);
        max = initialCapacity;
    }

    protected boolean removeEldestEntry(Map.Entry<String, Long> eldest) {
        if (size() > max) {
            System.out.println(eldest.getKey() + " " + eldest.getValue());
        }
        return size() > max;
    }
}