写一段Java代码实现简单的缓存

public class Cache {
private Map<Object, Object> map;

public Cache() {
map = new HashMap<Object, Object>();
}

public void put(Object key, Object value) {
map.put(key, value);
}

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

相关问题

写一段Java代码实现高性能的缓存

public class HighPerformanceCache {
private Map<String, Object> cacheMap = new HashMap<>(); public Object get(String key) {
return cacheMap.get(key);
} public void put(String key, Object value) {
cacheMap.put(key, value);
}
}

写一段Java代码实现byte[]数据的缓存，要求高性能，线程安全

### 回答1：

public class ByteCache {
private ConcurrentHashMap<String, byte[]> cacheMap = new ConcurrentHashMap<>(); public void put(String key, byte[] data) {
if (key != null && data != null) {
cacheMap.put(key, data);
}
} public byte[] get(String key) {
if (key != null) {
return cacheMap.get(key);
}
return null;
}
}

### 回答2：
要实现byte[]数据的高性能、线程安全的缓存，可以使用ConcurrentHashMap和ReadWriteLock来进行实现。具体的Java代码如下所示：

import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class ByteArrayCache {
    private ConcurrentHashMap<String, byte[]> cache;
    private ReadWriteLock lock;

    public ByteArrayCache() {
        cache = new ConcurrentHashMap<>();
        lock = new ReentrantReadWriteLock();
    }

    public void put(String key, byte[] value) {
        lock.writeLock().lock();
        try {
            cache.put(key, value);
        } finally {
            lock.writeLock().unlock();
        }
    }

    public byte[] get(String key) {
        lock.readLock().lock();
        try {
            return cache.get(key);
        } finally {
            lock.readLock().unlock();
        }
    }

    public boolean containsKey(String key) {
        lock.readLock().lock();
        try {
            return cache.containsKey(key);
        } finally {
            lock.readLock().unlock();
        }
    }

    public void remove(String key) {
        lock.writeLock().lock();
        try {
            cache.remove(key);
        } finally {
            lock.writeLock().unlock();
        }
    }

    public int size() {
        lock.readLock().lock();
        try {
            return cache.size();
        } finally {
            lock.readLock().unlock();
        }
    }
}

上述代码中，使用ConcurrentHashMap作为缓存数据的容器，它是线程安全的HashMap实现类。并通过ReadWriteLock来保证在读取和写入缓存时的线程安全。具体来说，当需要写入缓存时，获取写锁(lock.writeLock())并在操作完成后释放写锁；当需要读取缓存时，获取读锁(lock.readLock())并在操作完成后释放读锁。这种读写锁的机制可以使得多个线程可以同时读取缓存，从而提高性能。

使用上述代码可以实现一个高性能、线程安全的byte[]数据缓存，可以通过put方法将数据存入缓存，通过get方法获取缓存中的数据，并提供了其他常见的缓存操作方法，例如删除缓存(remove)和获取缓存大小(size)等。

### 回答3：
下面是一个使用Java实现高性能、线程安全的byte[]数据缓存的示例代码：

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

public class ByteCache {
    private static Map<String, byte[]> cache = new ConcurrentHashMap<>();

    public static void put(String key, byte[] value) {
        cache.put(key, value);
    }

    public static byte[] get(String key) {
        return cache.get(key);
    }

    public static void remove(String key) {
        cache.remove(key);
    }

    public static void clear() {
        cache.clear();
    }

    public static boolean containsKey(String key) {
        return cache.containsKey(key);
    }
}

在这个示例代码中，使用`ConcurrentHashMap`来存储缓存的数据。它是线程安全的哈希表实现，并发访问时可以提供良好的性能。

你可以使用`put`方法将byte[]数据添加到缓存中，使用`get`方法从缓存中获取指定key对应的数据。`remove`方法用于从缓存中删除指定key的数据。`clear`方法用于清空缓存中的所有数据。`containsKey`方法用于检查缓存是否包含指定的key。

注意，示例代码中的`cache`对象是静态的，这样你就可以在不同的类和线程中使用`ByteCache`类来操作同一个缓存。如果你需要多个独立的缓存，你可以将`cache`对象改为实例变量。

希望这个示例代码能够帮助你实现一个高性能、线程安全的byte[]数据缓存。