Java 如何使用HashMap模拟缓存

我想计算给定字符串中的唯一字符，并使用集合缓存它们，这样，如果该字符串已经存在，它就不会再次计算。为此，我使用了

HashMap

，将字符串作为键，并将其计数为值。我已经编写了以下代码，但它不会在映射中添加这些键值对。如何解决这个问题

class UniqueCharacters {

    public int uniqueCharacters(String s)
    {
        List<Character> list=new ArrayList<Character>();
        for(int i=0; i<s.length();i++)
        {
            if(!(list.contains(s.charAt(i))))
            {
                list.add(s.charAt(i));
            }
        }
        for(Character c:list)
        {
            System.out.println(c);
        }
        int count=list.size();
        maintainCache(s, count);

        System.out.println(count);
        return count;
    }

    public void maintainCache(String s, int count)
    {
        Map<String,Integer> map=new HashMap<String,Integer>();
        for(Map.Entry<String, Integer> entry: map.entrySet())
        {
            if(entry.getKey().equals(s))
            {
                System.out.println(entry.getKey()+" "+entry.getValue());
                System.out.println("String was already there");
            }
            else
            {
                map.put(s, count);
                System.out.println("String added to the cache");
            }
        }
    }
}

public class UniqueCharactersTest {

    public static void main(String[] args) {
        UniqueCharacters u=new UniqueCharacters();
        u.uniqueCharacters("hello");
    }
}

类唯一字符{
公共整数唯一字符（字符串s）
{
列表=新的ArrayList（）；
对于（int i=0；i每次调用时，
maintainCache
都会创建一个新的局部变量
map
。如果希望该映射在调用之间保留其值，则应将其从方法中提取出来，并将其保留为成员。
每次调用时，
maintainCache
都会创建一个新的局部变量
map
nt映射要在调用之间保留其值，应将其从方法中提取并保留为成员。
问题是每次调用maintainCache时都会新创建HashMap。请将该映射作为UniqueCharacters类的属性，而不是方法maintainCache下的局部变量。
问题是HashMap是每次调用maintainCache时新创建的映射。请将映射作为UniqueCharacters类的属性，而不是maintainCache方法下的局部变量；
import java.util.HashMap;
import java.util.Map;

public class StringCacheTest {

    public static void main(String[] args) {
        StringCache cache = new StringCache();

        System.out.println("Unique characters : " + cache.getUniqueCharactersCount("test"));
        System.out.println("Unique characters : " + cache.getUniqueCharactersCount("test2"));
        System.out.println("Unique characters : " + cache.getUniqueCharactersCount("test"));
    }

}

class StringCache {

    private Map<String, Long> cache;

    public StringCache(){
        this.cache = new HashMap<>();
    }

    public Long getUniqueCharactersCount(String string){
        if(string == null){
            throw new RuntimeException("Null string");
        }
        if(cache.containsKey(string)){
            System.out.println("String " + string + " found in cache");
            return cache.get(string);
        } else {
            System.out.println("String " + string + " not found in cache");
            long uniqueCharactersCount = string
                    .chars()
                    .distinct()
                    .count();
            cache.put(string, uniqueCharactersCount);
            return uniqueCharactersCount;
        }
    }

}

导入java.util.Map；
公共类StringCacheTest{
公共静态void main（字符串[]args）{
StringCache缓存=新建StringCache（）；
System.out.println（“唯一字符：+cache.getUniqueCharactersCount（“测试”））；
System.out.println（“唯一字符：+cache.getUniqueCharactersCount（“test2”））；
System.out.println（“唯一字符：+cache.getUniqueCharactersCount（“测试”））；
}
}
类StringCache{
私有地图缓存；
公共字符串缓存（）{
this.cache=new HashMap（）；
}
公共长GetUniqueCharacterScont（字符串）{
if（字符串==null）{
抛出新的RuntimeException（“空字符串”）；
}
if（cache.containsKey（字符串））{
System.out.println（“在缓存中找到字符串”+String+）；
返回cache.get（字符串）；
}否则{
System.out.println（“字符串”+String+“未在缓存中找到”）；
长uniqueCharactersCount=字符串
.chars（）
.distinct（）
.count（）；
cache.put（字符串，uniqueCharactersCount）；
返回唯一字符；
}
}
}

导入java.util.HashMap；
导入java.util.Map；
公共类StringCacheTest{
公共静态void main（字符串[]args）{
StringCache缓存=新建StringCache（）；
System.out.println（“唯一字符：+cache.getUniqueCharactersCount（“测试”））；
System.out.println（“唯一字符：+cache.getUniqueCharactersCount（“test2”））；
System.out.println（“唯一字符：+cache.getUniqueCharactersCount（“测试”））；
}
}
类StringCache{
私有地图缓存；
公共字符串缓存（）{
this.cache=new HashMap（）；
}
公共长GetUniqueCharacterScont（字符串）{
if（字符串==null）{
抛出新的RuntimeException（“空字符串”）；
}
if（cache.containsKey（字符串））{
System.out.println（“在缓存中找到字符串”+String+）；
返回cache.get（字符串）；
}否则{
System.out.println（“字符串”+String+“未在缓存中找到”）；
长uniqueCharactersCount=字符串
.chars（）
.distinct（）
.count（）；
cache.put（字符串，uniqueCharactersCount）；
返回唯一字符；
}
}
}

请参见

map.get（..）

声明

map

全局使用map或hasMap不仅仅是模拟缓存。它是缓存。请参见

map.get（..）

声明

map

globally使用map或hasMap不仅仅是模拟缓存。它是一个缓存。它仍然不起作用，您能否建议是否有其他错误仍然不起作用，您能否建议是否有其他错误