[FIXED] More succinct way of creating a constant String map in Java

Issue

Good day all,
Considering the following code example:

import java.util.HashMap;
import java.util.Map;

    public class StaticPractice {
    
        private final Map<String, String> mapperMap;
    
        public StaticPractice(){
            mapperMap = new HashMap<String, String>(); 
            mapperMap.put("Foo1", "Bar1");
            mapperMap.put("Foo2", "Bar1");
            mapperMap.put("Foo3", "Bar2");
            mapperMap.put("Foo3", "Bar3");
            //...
            mapperMap.put("MoreFoo", "BarAgain");
        }
     
        public void doSomething(){
            //use mapperMap    
       }
    }

I am looking for a more succinct way of creating a Map data structure that has a whole lot of constant Strings mapping to a whole lot of other constant Strings. In use, the example is far from "clean" or elegant, and is very verbose (there are alot of predefined constant mappings).

The goal of the class is to map objects referenced by these predefined constant Strings. It is commonplace in my particular code convention to use private static final String for all String constant, this example as well breaks that convention.

Would greatly appreciate any input, the wealth of knowledge from SO contributors always humbles me.
Much thanks.

Edit: Requirement specifies no external files.

Solution

One approach would be to create a builder class that generates the map. This has the advantage that you can optimize for concise syntax. You can also do things like making the generated map immutable -- useful if you want to use it as a publically accessible constant.

In your example, I notice that you have more than one key mapping to the same value. So, it would be more concise to have a method that takes a value followed by a list of keys. You can also make it more concise by having the builder return itself so that you can "chain" method calls:

class Builder<K,V> {
   final Map<K,V> map = new HashMap<K,V>();

   Builder add(V value, K... keys) {
      for(K key : keys) {
         map.put(key, value);
      }
      return this;
   }

   Map<K,V> build() {
      return Collections.unmodifiableMap(new HashMap<K,V>(map));
   }
}

// Usage:
mapperMap = new Builder<String,String>()
   .add("Bar1", "Foo1", "Foo2")
   .add("Bar2", "Foo3")
   ...
   .build();

Alternately you might take a look at the Guava ImmutableMap class, which has a builder using the chaining syntax, though it doesn't have a way to map multiple keys to a single value in one call.

Answered By - Russell Zahniser
Answer Checked By - Katrina (JavaFixing Volunteer)