need store object for 5 mins

[sudh ag]

i have a requirement in which i have to store key value pair.
the value should be expire after 5 mins so that if some get access using key than null returns
how we can achieve this requirement

[Jesper de Jong]

Store the key-value pair and schedule a task that triggers in 5 minutes which removes it again.

There are several ways to schedule a task to be executed in 5 minutes in Java. I would use a ScheduledExecutorService for this and a ConcurrentMap to store the keys and values.

import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class FiveMinuteMap<K, V> {
    private final static ScheduledExecutorService EXECUTOR_SERVICE = Executors.newSingleThreadScheduledExecutor();

    private final ConcurrentMap<K, V> map = new ConcurrentHashMap<K, V>();

    public void put(final K key, V value) {
        map.put(key, value);

        // Task to remove the key-value pair
        Runnable task = new Runnable() {
            @Override
            public void run() {
                map.remove(key);
            }
        };

        // Schedule the task to run in 5 minutes
        EXECUTOR_SERVICE.schedule(task, 5, TimeUnit.MINUTES);
    }

    public V get(K key) {
        return map.get(key);
    }
}

[Rob Spoor]

And if you want a full Map implementation, just have FiveMinuteMap delegate other calls to the backing map as well.
You need proper synchronization, which is what the ConcurrentHashMap will do for you. If you need a TreeMap as backing mechanism you need to take care of synchronization (also while iterating) yourself.

I'd make one improvement over that class though - make the interval instance fields. That allows you to use the same class for 10 minutes, 1 hour, etc:

import java.util.concurrent.ConcurrentHashMap;   
import java.util.concurrent.ConcurrentMap;   
import java.util.concurrent.Executors;   
import java.util.concurrent.ScheduledExecutorService;   
import java.util.concurrent.TimeUnit;   
   
public class TemporalMap<K, V> implements Map<K,V> {   
    private final static ScheduledExecutorService EXECUTOR_SERVICE = Executors.newSingleThreadScheduledExecutor();   
   
    private final ConcurrentMap<K, V> map = new ConcurrentHashMap<K, V>();   

    private final long delay;

    private final TimeUnit unit;

    public TemporalMap(long delay, TimeUnit unit)
    {
        // TODO: add checking if delay > 0, unit != null
        this.delay = delay;
        this.unit = unit;
    }
   
    public void put(final K key, V value) {   
        map.put(key, value);   
   
        // Task to remove the key-value pair   
        Runnable task = new Runnable() {   
            @Override   
            public void run() {   
                map.remove(key);   
            }   
        };   
   
        // Schedule the task to run after the delay
        EXECUTOR_SERVICE.schedule(task, delay, unit);   
    }   
   
    public V get(K key) {   
        return map.get(key);   
    }

    // implement other methods like get is implemented
    // implement putAll by:
    // a) iterating over the supplied map and calling put for each entry
    // b) call map.putAll, then schedule the required tasks in a loop
}

[Jesper de Jong]

Rob, notice that V get(K key) is not implementing the get method from interface Map - in that interface, the key is unfortunately of type Object (because of backward compatibility reasons with pre-generics Java). If you'd want to implement the Map interface, it would have to be:

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

[Rob Spoor]

You're right, I missed that.