Storing static data locally

I currently have 200 rows of key -> value, values, where one key has two values. Even though I'm only using the first value.

I'm wondering about ways to handle this, whether using a json file to store all this data and converting it to a map<String, List<String>> or if I could create an enum class to store all this?

I'm just not sure how to solve this

Assuming the data needs to persist.

MapDB comes in handy for requirements like this in java. This can be used to store any serializable type.

Map can be directly stored in a file and retrieved.
It has embedded support for transactions.

import org.mapdb.DB;
import org.mapdb.DBMaker;

private DB mapDb;
    private ConcurrentMap<String, LinkedHashSet> translationMap;

    @PostConstruct
    private void init() {
        log.info("Map db Start initiated...");

        mapDb = DBMaker
                .fileDB(new File(nosqlDbPath))
                .fileMmapEnable()
                .transactionEnable()
                .make();

        translationMap = (ConcurrentMap<String, LinkedHashSet>) mapDb.hashMap("map").createOrOpen();
        log.info("Map db Start completed.");
    }


    @PreDestroy
    private void close() {
        log.info("Map db shutdown initiated...");
        mapDb.commit();
        mapDb.close();
        log.info("Map db shutdown complete.");

    }

translationMap would hold all the data on startup.

Don't forget to add the MapDB jars

since its just 200 entries, you have a lot of options.

1. Just store it in a Hashmap.

Pros:

• Simplest as it can get. O(1) look up

Cons:

• If you have multiple threads mutating this, you are asking for trouble

• Order will not be preserved

• No provision to TTL

2. Store It in LinkedHashMap

Same as Hashmap except Order will be preserved

3. Store it in ConcurrentHashmap

Same as Hashmap except this one can be used even if multiple threads tries to mutate it

4. Store it in CaffeineCache

You can set TTL

5. Store it in EHCache

You can set TTL. Provision to store in OffHeap Primary Memory. Provision to overflow to Disk

All the aforementioned approaches are leveraging primary memory. It will give you the highest performance for Reads. This goes without saying, it's all ephemeral, as soon as you switch off the machine it will vanish. On the other hand, during runtime, if you want to mutate it and persist the mutations across restarts, you might need to look into more persistent storages.

Since it's a key-value look-up, you can use a static block or @PostConstruct annotated methods or Constructer to populate it when the app starts. Or if you are in spring-boot land, you could leverage @Configuration annotated class and @Value annotated Map<String,Object> member variable in conjunction with a property/yaml file where you have all the data and get it injected

Regarding 2 values

If you are sure, you will ever be getting only 2 values, I would change it as typed class, for example

class Values {
    Value left;
    Value right;
}

rather than a List<Value>, After all its a Strongly typed language program