Map<String, List<String>> myMaps = new HashMap<String, List<String>>();
    for (DataObject item : myList) {
        if (!myMaps.containsKey(item.getKey())) {
            myMaps.put(item.getKey(), new ArrayList<String>());
        }
        myMaps.get(item.getKey()).add(item.getValue());
    }

I believe something like this should work:

Map<String,List<String>> map =
    userList.stream()
            .flatMap(user -> {
                Map<String,String> um = new HashMap<>();
                um.put("names",user.getName());
                um.put("age",user.getAge());
                um.put("org",user.getOrg());
                return um.entrySet().stream();
            }) // produces a Stream<Map.Entry<String,String>>
            .collect(Collectors.groupingBy(Map.Entry::getKey,
                                           Collectors.mapping(Map.Entry::getValue,
                                                              Collectors.toList())));

It converts each User to a Map<String,String> (containing the 3 required properties indexed by the required keys), and then groups the entries of all the user maps by their keys.

EDIT:

Here's another alternative that creates the Map.Entrys directly instead of creating the small HashMaps, so it should be more efficient:

Map<String,List<String>> map =
    userList.stream()
            .flatMap (user -> Stream.of (new SimpleEntry<>("names",user.getName()),
                                         new SimpleEntry<>("age",user.getAge()),
                                         new SimpleEntry<>("org",user.getOrg())))
            .collect(Collectors.groupingBy(Map.Entry::getKey,
                                           Collectors.mapping(Map.Entry::getValue,
                                                              Collectors.toList())));

You should declare your map as:

Map<String, List<? extends Object>> myVehicles = 
                                new HashMap<String, List<? extends Object>>();

Map<String, List<Object>> wouldn't work, because you can't add a List<Bikes> where a List<Object> is needed, because generic types are invariant. A List<Bikes> is not a subclass of List<Object>, however it can be captured by a List<? extends Object>.

List<Map<String, Object>> list = new ArrayList<Map<String, Object>>();
Map<String, Object> map = new HashMap<String, Object>();
map.put("foo", "bar");
list.add(map);

You can accomplish this using Java 8 streams.

public List<Object> fetchMultiFieldsList() {
    return multiFieldMap.entrySet().stream()
      .flatMap(e -> {
          String entityName = e.getKey();
          List<Object> ids = e.getValue();
          return ids.stream()
            .map(id -> queryService.query(entityName, queryService.property("id").eq(id)));
      }).collect(Collectors.toList());
}

I think the code itself is relatively self-explanatory. The important bit is the usage of flatMap instead of map for the first mapping operation so that the resulting streams are concatenated, ending up with a flat list of objects rather than a list of lists.

It is unfortunate that Java does not support destructuring assignment, which would allow the first lambda expression to be a single expression of the form (k, v) -> ..., but it does not, so I've left the statements in for clarity.

If you are willing to omit the inner declarations, the above code can be simplified further.

public List<Object> fetchMultiFieldsList() {
    return multiFieldMap.entrySet().stream()
      .flatMap(e -> e.getValue().stream()
          .map(id -> queryService.query(e.getKey(), queryService.property("id").eq(id)))
      ).collect(Collectors.toList());
}

Whichever one you prefer is a matter of personal preference. The former has more descriptive variable names, while the latter is simpler and more functional.

You are trying to place a string where a map expects a List.

Instead of:

patientMap.put("PATIENTLIST", patientList);
patientMap.put("LASTKEY", date);

Place:

patientMap.put(date, patientList);

With a map where date string is key and list of patient is value you can quickly get a list of patients for a given date.

If you want to use a map to hold a date and list of objects in string form, then you would have to convert back those strings back to their original date or list of patient objects.

If this is really what you want I suggest you look into java object serialization and deserialization.

Map<String, Object> map = new HashMap<String, Object>();
...
for (Map.Entry<String, Object> entry : map.entrySet()) {
    if (entry.getValue() instanceof String) {
        // Do something with entry.getKey() and entry.getValue()
    } else if (entry.getValue() instanceof Class) {
        // Do something else with entry.getKey() and entry.getValue()
    } else {
        throw new IllegalStateException("Expecting either String or Class as entry value");
    }
}

You can use groupingBy collector with mapping downstream as :

Map<String, List<Result>> map = data.stream()
        .collect(Collectors.groupingBy(a -> a.getSystemId() + ":" + a.getFileName()
                , Collectors.mapping(a -> new Result(a.getX(), a.getY()),
                        Collectors.toList())));

Always try to use interface reference in Collection, this adds more flexibility.
What is the problem with the below code?

List<Map<String,List<String>>> list = new ArrayList<Map<String,List<String>>>();//This is the final list you need
Map<String, List<String>> map1 = new HashMap<String, List<String>>();//This is one instance of the  map you want to store in the above list.
List<String> arraylist1 = new ArrayList<String>();
arraylist1.add("Text1");//And so on..
map1.put("key1",arraylist1);
//And so on...
list.add(map1);//In this way you can add.

You can easily do it like the above.

1. If the input data are provided as the mentioned JSON string, it would be better to implement a POJO and then deserialize that JSON as a list/array.

2. If the input data are provided as a map, a constructor/mapper method/builder should be implemented for Timezone class to convert the map entries:

Map<String,String> tz = Map.of(
    "America/New_York", "US Eastern Time",
    "America/Chicago", "US Central Time",
    "America/Denver", "US Mountain Time",
    "America/Los_Angeles", "US Pacific Time"
);    

List<Timezone> timezoneList = tz.entrySet()
    .stream()
    .map(e -> new Timezone(e.getKey(), e.getValue())) // constructor
//  .map(e -> new TimezoneBuilder().withName(e.getKey()).withLabel(e.getValue()).build()
    .collect(Collectors.toList());

Methods

The first thing that we can do is divide up the labor. Consider

void static main(String[] args) throws JsonProcessingException {
    Map<String, List<String>> properties = parseProperties(getPropertyValue());
    Map<String, Map<String, List<String>>> payload = buildPayload(properties);
    String json = new ObjectMapper().writeValueAsString(payload);
    System.out.println(json);
}

Now we have the heavy lifting in parseProperties and buildPayload.

I also hid the propertyValue in a method, but that was mostly to avoid obnoxious horizontal scrolling.

parseProperties

    String[] dayParts = propertyValue.split(",");

    for (String string : dayParts) {
      String[] array = string.split("  -  ");
      if (map.get(array[0]) == null) {
        List<String> list = new ArrayList<>();
        list.add(array[1]);
        map.put(array[0], list);
      } else {
        List<String> tempList = map.get(array[0]);
        tempList.add(array[1]);
        map.put(array[0], tempList);
      }
    }

Consider

    for (String string : propertyValue.split(",")) {
      String[] parts = string.split("  -  ");

      List<String> hours = map.get(parts[0]);
      if (hours == null) {
        hours = new ArrayList<>();
      }

      hours.add(parts[1]);
      map.put(parts[0], hours);
    }

We don't need a separate variable for the results of the comma split. We only use that for this loop, so we can do it directly.

We do need a separate variable for the parts of that string, as we use the parts separately. Also, we use one of them multiple times.

In both branches of the original if, we do two of the same commands. If we rewrite it this way, we can do those outside the if.

In the original if, we could have used contains, as we don't use the value otherwise. But this way, we save the result. If it is empty, we put an empty list there. Otherwise, we can just use the previous value.

buildPayload

    Map<String, Map<String, List<String>>> payload = new HashMap<>();
    Map<String, List<String>> hrs1 = new HashMap<>();
    hrs1.put("Hours", new ArrayList<String>());
    payload.put("Sunday", hrs1);
    payload.put("Monday", hrs1);
    payload.put("Tuesday", hrs1);
    payload.put("Wednesday", hrs1);
    payload.put("Thursday", hrs1);
    payload.put("Friday", hrs1);
    payload.put("Saturday", hrs1);
    for (Entry<String, List<String>> entry : map.entrySet()) {
      Map<String, List<String>> hrs = new HashMap<>();
      hrs.put("Hours", entry.getValue());
      if (payload.containsKey(entry.getKey())) {
        payload.put(entry.getKey(), hrs);
      }
    }

So you want to create a map with the seven days of the week. The same pattern can work here.

public static Map<String, List<String>> normalizeHours(Map<String, List<String>> hours) {
    if (hours == null) {
        hours = new HashMap<>();
        hours.put("Hours", new ArrayList<String>());
    }

    return hours;
}

And we'd use it like

    Map<String, Map<String, List<String>>> payload = new HashMap<>();
    payload.put("Sunday", normalizeHours(properties.get("Sunday")));
    payload.put("Monday", normalizeHours(properties.get("Monday")));
    payload.put("Tuesday", normalizeHours(properties.get("Tuesday")));
    payload.put("Wednesday", normalizeHours(properties.get("Wednesday")));
    payload.put("Thursday", normalizeHours(properties.get("Thursday")));
    payload.put("Friday", normalizeHours(properties.get("Friday")));
    payload.put("Saturday", normalizeHours(properties.get("Saturday")));

Instead of putting a dummy value into each day of the week and then replacing it, this puts the correct value in in the first place.

It's not shorter but is more reusable to have a container for the days of the week that you can use here.

    for (String dayOfTheWeek : dayNames) {
        payload.put(dayOfTheWeek, normalizeHours(properties.get(dayOfTheWeek)));
    }

It's not much longer even for this single problem. Once you have the container, it shortens the code.

It sounds like you're looking for something like this:

List<Map<String, Object>> list; // this is what you have already

for (Map<String, Object> map : list) {
    for (Map.Entry<String, Object> entry : map.entrySet()) {
        String key = entry.getKey();
        Object value = entry.getValue();
    }
}