How to best convert Map<String,Foo> to Map<MyEnum,Foo> in a wrapper

Question

Update, adding the question from the comments:

what's the best way to get the Map into Map where Foo is an Enum. it just seems awfully complicated when, conceptually, not a complex idea.

This code functions, it's part of a simple MUD client. The basic idea is that Monitor holds data (hit points, etc) which will be displayed to the user during game play, perhaps in a secondary JPanel; something along those lines. The possible values for this report are in the Attribs as an Enum.

Before going too far down that path, when I look at the Monitor class and what it takes to create a single instance it seems more than a little verbose.

If I move convertToEnumEntry out of Monitor then the class won't work. So, the class can't get smaller, I don't think. Is there a pattern I could use (or use better)?

Everything in this class rests on the assumption that if convertToEnumEntry returns a null reference to a Map.Entry to then get the one, specific String which doesn't fit in Attribs:

enemy = stringEntry.getKey();

Unlike the other keys, the enemy can be any String. The other keys are limited to the Enum values of Attribs (attributes).

public class Monitor {

    private static Logger log = Logger.getLogger(Monitor.class.getName());
    private Map<Attribs, Ratio> mapOfAttributes = new HashMap<>();
    private String enemy = null;

    private Monitor() {
    }

    public Monitor(Map<String, Ratio> mapStringToRatio) {
        init(mapStringToRatio);
    }

    private void init(Map<String, Ratio> mapStringToRatio) {
        SimpleEntry<Attribs, Ratio> attribsEntry = null;
        for (Entry<String, Ratio> stringEntry : mapStringToRatio.entrySet()) {
            attribsEntry = null;
            attribsEntry = convertToEnumEntry(stringEntry);
            if (attribsEntry != null) {
                mapOfAttributes.put(attribsEntry.getKey(), attribsEntry.getValue());
            } else {
                enemy = stringEntry.getKey();     //assumes key is enemy value
                mapOfAttributes.put(Attribs.ENEMY, stringEntry.getValue());
            }
        }
    }

    private SimpleEntry<Attribs, Ratio> convertToEnumEntry(Entry<String, Ratio> stringEntry) {
        Ratio ratio = stringEntry.getValue();
        SimpleEntry<Attribs, Ratio> attribEntry = null;
        for (Attribs attribute : Attribs.values()) {
            if (stringEntry.getKey().equalsIgnoreCase(attribute.name())) {
                attribEntry = new HashMap.SimpleEntry<>(attribute, ratio);
            }
        }
        return attribEntry;
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append("\nfighting\t\t" + enemy + "\n");
        for (Map.Entry<Attribs, Ratio> e : mapOfAttributes.entrySet()) {
            sb.append("\n");
            sb.append(e.getKey().name());
            sb.append("\t");
            sb.append(e.getValue().toString());
        }
        sb.append("\n");
        return sb.toString();
    }
}

It's tempting to either cram everything into either one class to parse and build the Map, or put everything into Monitor. Currently, RegexMapBuilder is a sort of middle ground, because it does most of the hard work, but doesn't quite build a complete Monitor on its own:

public class RegexMapBuilder {

    public static Map<String, Ratio> stringToRatiosMap(String input) {
        Map<String, Ratio> mapOfStringsToRatios = new HashMap<>();
        Map<String, String> strings = stringMap(input);
        Pattern fraction = Pattern.compile("(\\d+)/(\\d+)");
        Pattern wholeNumber = Pattern.compile("(\\d+)");
        Pattern percent = Pattern.compile("(\\d+)%");
        Matcher matcher;
        int numerator, denominator;
        Ratio ratio = null;             //need numerator and denominator values
        for (Entry<String, String> e : strings.entrySet()) {
            matcher = wholeNumber.matcher(e.getValue());
            while (matcher.find()) {
                numerator = Integer.parseInt(matcher.group(1));
                denominator = 1;
                ratio = new Ratio(numerator, denominator);
            }
            matcher = fraction.matcher(e.getValue());
            while (matcher.find()) {
                numerator = Integer.parseInt(matcher.group(1));
                denominator = Integer.parseInt(matcher.group(2));
                ratio = new Ratio(numerator, denominator);
            }
            matcher = percent.matcher(e.getValue());
            while (matcher.find()) {
                numerator = Integer.parseInt(matcher.group(1));
                denominator = 100;
                ratio = new Ratio(numerator, denominator);
            }
            mapOfStringsToRatios.put(e.getKey(), ratio);
        }
        return mapOfStringsToRatios;
    }

    private static Map<String, String> stringMap(String input) {
        Map<String, String> strings = new HashMap<>();
        Pattern pattern = Pattern.compile("(\\w+): +(\\S+)");
        Matcher matcher = pattern.matcher(input);
        while (matcher.find()) {
            strings.put(matcher.group(1), matcher.group(2));
        }
        return strings;
    }
}

For brevity, I omitted the Enum, but Attribs is just a list of a few attributes which this report prints. The only tricky part is that there's one value which isn't really an Enum type.

Answer 1

I think java.util.EnumMap may be what you're looking for. You can use Enum#valueOf to look up the enum value from the given String, like Sam Yonnou mentioned.