How to reuse code in multiple enum names?

I have below Enum from which I am calling appropriate execute method basis on what type of enum (eventType) is passed.

public enum EventType {

  EventA {
    @Override
    public Map<String, Map<String, String>> execute(String eventMapHolder) {
      final Map<String, String> holder = parseStringToMap(eventMapHolder);
      if (holder.isEmpty() || Strings.isNullOrEmpty(holder.get("m_itemId"))) {
        return ImmutableMap.of();
      }
      String itemId = holder.get("m_itemId");
      Map<String, String> clientInfoHolder = getClientInfo(itemId);
      holder.putAll(clientInfoHolder);
      return ImmutableMap.<String, Map<String, String>>builder().put(EventA.name(), holder)
          .build();
    }
  },
  EventB {
    @Override
    public Map<String, Map<String, String>> execute(String eventMapHolder) {
      final Map<String, String> holder = parseStringToMap(eventMapHolder);
      if (holder.isEmpty() || Strings.isNullOrEmpty(holder.get("m_itemId"))) {
        return ImmutableMap.of();
      }
      return ImmutableMap.<String, Map<String, String>>builder().put(EventB.name(), holder)
          .build();
    }
  },
  EventC {
    @Override
    public Map<String, Map<String, String>> execute(String eventMapHolder) {
      final Map<String, String> holder = parseStringToMap(eventMapHolder);
      if (holder.isEmpty() || Strings.isNullOrEmpty(holder.get("m_itemId"))) {
        return ImmutableMap.of();
      }
      String itemId = holder.get("m_itemId");
      Map<String, String> clientInfoHolder = getClientInfo(itemId);
      holder.putAll(clientInfoHolder);
      return ImmutableMap.<String, Map<String, String>>builder().put(EventC.name(), holder)
          .build();
    }
  };

  public abstract Map<String, Map<String, String>> execute(String eventMapHolder);

  public Map<String, String> parseStringToMap(String eventMapHolder) {
    // parse eventMapHolder String to Map
  }

  public Map<String, String> getClientInfo(final String clientId) {
    // code to populate the map and return it
  }
}

For example: If I get "EventA", then I am calling it's execute method. Similarly if I get "EventB" then I am callings it's execute method and so on.

String eventType = String.valueOf(payload.get("eventType"));
String eventMapHolder = String.valueOf(payload.get("eventMapHolder"));
Map<String, Map<String, String>> processedMap = EventType.valueOf(eventType).execute(eventMapHolder);

In general I will have more event types (around 10-12) in the same enum class and mostly they will do same operation as EventA, EventB and EventC.

Question:

Now as you can see, code in execute method of EventA and EventC are identically similar but the only difference is what I put as "key" (event name) in the returned immutable map. Is there any way to remove that duplicated code but still achieve the same functionality in the enum.

For example, something on this ground. By writing multiple enums side by side separated by comma (if the execute method functionality is same). I know this doesn't work because I have a abstract method which I need to implement it everywhere but is it still possible by making some changes or any other better way?

public enum EventType {

  EventA,
  EventC {
    @Override
    public Map<String, Map<String, String>> execute(String eventMapHolder) {
        // same code which is there in execute method for EventA and EventC
    }
  },
  EventB {
    @Override
    public Map<String, Map<String, String>> execute(String eventMapHolder) {
        // same code which is there in execute method of EventB
    }
  };

  // other methods which are there already
}

I know one way is to make a method with all the common things and call those method by passing appropriate Event type enum name. Is there any other way apart from that by using enum features or any other changes?

If there is any other better way or any other design pattern to do this then I am open for suggestions as welll which can help me remove duplicated code.

Idea is - basis on what type of event is passed, I want to call its execute method and avoid duplication if possible.