即使在java代码终止后，我们也能在内存中保留HashMap的值吗？

一个特定的HashMap包含三个Java代码（b.Java、c.Java和d.Java）将使用的信息。a、 java是另一个将变量放入HashMap的代码。现在，我想让这三个java代码使用HashMap。因为在a.java终止后，HashMap丢失了，所以我无法这样做。我不想使用文件写入和读取来使系统更快。使用Java实现它的方法是什么？

如果它在3个不同的JVM中运行，那么您不能在其他程序中使用它。

---

您应该将数据持久化到数据库或写入文件

如果还没有，请尝试使用属性文件或SQLite数据库来存储这些值，并确保读/写操作将成为瓶颈，然后再花时间优化性能

如果您已经在那里，那么当Java进程结束时，所有分配的内存都会被释放，这一点很重要。所以，如果您想将其保留在内存中，那么必须有一个相关的进程。您有很多选择，其中有两个是运行memcache/redis进程，或者运行每个代码所连接的ehcache/hazelcast进程。我假设您正在寻找比运行数据库来承载此信息更轻的东西

使用memcache或redis，您可以编写密钥-值对，并使用网络协议读取它们。 使用ehcache/hazelcast，您可以编写和读取分布式映射，而库负责在进程间获取信息

---

最终的结果是一样的：一个独立于现有代码的进程，用于保持驻留在内存中的值，以便瞬态代码访问。这样做的一个附带好处是，您的代码不需要在同一台机器上运行，这是一个限制，如果它们都在同一个VM中，或者它们使用一个文件来持久化数据（除非该文件在网络共享上！）

如果您用另一个Java程序一个接一个地启动不同的Java程序，这应该不会是一个问题。只需在executor类中初始化HashMap，并在其他程序中将其设置为静态变量

public class A{
    public static HashMap<String,String> hashMap;     
    public static void main(String[] args) {}
} 
[class B, class C]

public class ProgrammRunner{
    public static void main(String[] args) {
        HashMap<String,String> hashMap = new HashMap<>();
        A.hashMap = hashMap;
        A.main(new String[]{});
        B.hashMap = hashMap;
        B.main(new String[]{});
        [...]
    }
}

公共A类{
公共静态HashMap HashMap；
公共静态void main（字符串[]args）{}
} 
[乙类、丙类]
公共类程序运行器{
公共静态void main（字符串[]args）{
HashMap HashMap=新的HashMap（）；
A.hashMap=hashMap；
main（新字符串[]{}）；
B.hashMap=hashMap；
B.main（新字符串[]{}）；
[...]
}
}

一个简单的解决方案应该是在文件系统中序列化映射（如果您不想使用缓存库或数据库，则映射不应包含非基本数据类型，如果您是类的作者，则可能需要编写代码；如果是第三方API接口，则可能需要编写代码。）

您可以轻松测试这一点：

将读取标志设置为false；它会将地图序列化到指定位置

将读取标志设置为真；它将读取以前序列化的映射

在您的程序中，您可以使用这些read（）和write（）方法

public class PersistHashMap {
    public static void main(String[] args) {

        boolean read = false;
        if (read == false) {
            write();
        } else {
            Map<Integer, String> map = read();
            for (Entry<Integer, String> entry : map.entrySet()) {
                System.out.println("key:" + entry.getKey() + "----- value:" + entry.getValue());
            }
        }

    }

    @SuppressWarnings("unchecked")
    public static Map<Integer, String> read() {
        Map<Integer, String> hmap = new HashMap<Integer, String>();

        try (FileInputStream fis = new FileInputStream("D:\\hashmap.ser")) {

            try (ObjectInputStream ois = new ObjectInputStream(fis)) {

                hmap=(HashMap<Integer,String>)ois.readObject();

            } catch (Exception e) {
                e.printStackTrace();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }

        return hmap;
    }

    public static void write() {
        Map<Integer, String> hmap = new HashMap<Integer, String>();
        // Adding elements to HashMap
        hmap.put(1, "1");
        hmap.put(2, "2");
        hmap.put(3, "3");
        hmap.put(4, "4");
        hmap.put(5, "5");

        try (FileOutputStream fos = new FileOutputStream("D:\\hashmap.ser")) {

            try (ObjectOutputStream oos = new ObjectOutputStream(fos)) {
                oos.writeObject(hmap);
            }

        } catch (Exception e) {
            e.printStackTrace();
        }
    }

}

公共类PersistHashMap{
公共静态void main（字符串[]args）{
布尔读取=假；
如果（读==假）{
write（）；
}否则{
Map=read（）；
for（条目：map.entrySet（））{
System.out.println（“key:+entry.getKey（）+”----value:+entry.getValue（））；
}
}
}
@抑制警告（“未选中”）
公共静态映射读取（）{
Map hmap=newhashmap（）；
try（FileInputStream fis=newfileinputstream（“D:\\hashmap.ser”））{
try（ObjectInputStream ois=新ObjectInputStream（fis））{
hmap=（HashMap）ois.readObject（）；
}捕获（例外e）{
e、 printStackTrace（）；
}
}捕获（例外e）{
e、 printStackTrace（）；
}
返回hmap；
}
公共静态void write（）{
Map hmap=newhashmap（）；
//向HashMap添加元素
hmap.put（1，“1”）；
hmap.put（2，“2”）；
hmap.put（3，“3”）；
hmap.put（4，“4”）；
hmap.put（5，“5”）；
尝试（FileOutputStream fos=newfileoutputstream（“D:\\hashmap.ser”））{
try（ObjectOutputStream oos=新的ObjectOutputStream（fos））{
oos.writeObject（hmap）；
}
}捕获（例外e）{
e、 printStackTrace（）；
}
}
}

不清楚“java代码终止后”是什么意思

如果在同一线程中连续运行B、C和D。创建一个HashMap并将其传递给B、C和D

---

如果B、C和D是3个单独执行的Java应用程序。您可以使用内存数据库，如HSQLDB。或者更好，考虑将B、C和D迁移到一个java应用程序中。

它们都在同一个JVM实例中运行吗？或者它们是独立运行的？它们是同时运行的吗？它们是连续运行的，一个接一个。我只想让Hasmap在内存中保持活动状态，以便更快地使用。好的，按顺序。在同一个JVM实例中？如果它是同一个实例，最简单的方法就是使它

静态
。远程方法调用，有人吗？