Use a LinkedHashMap. Hash table and linked list implementation of the Map interface, with predictable iteration order. This implementation differs from HashMap in that it maintains a doubly-linked list running through all of its entries. This linked list defines the iteration ordering, which is normally the order in which keys were inserted into the map … Read more
You could do this element adding to 1. or last place: Adding to last place ► You just need to remove the previous entry from the map like this: map.remove(key); map.put(key,value); Adding to first place ► It’s a bit more complicated, you need to clone the map, clear it, put the 1. value to it, … Read more
You can use ObjectMapper.convertValue(), either value by value or even for the whole list. But you need to know the type to convert to: POJO pojo = mapper.convertValue(singleObject, POJO.class); // or: List<POJO> pojos = mapper.convertValue(listOfObjects, new TypeReference<List<POJO>>() { }); this is functionally same as if you did: byte[] json = mapper.writeValueAsBytes(singleObject); POJO pojo = mapper.readValue(json, … Read more
You can’t get the value of the Map based on index, Maps just don’t work that way. A workaround would be to create a new list from your values and get the value based on index. LinkedHashMap<String, List<String>> hMap; List<List<String>> l = new ArrayList<List<String>>(hMap.values()); l.get(0);
Just to clarify a bit for readers: LinkedHashMap only behaves that way when built with one particular constructor overload. Normally the elements are maintained in insert order. (This feels a little odd to me, but never mind.) I don’t believe there’s any such class in .NET. It wouldn’t be too hard to build one, using … Read more
The question requires a LinkedHashMap in reverse order, some answers suggesting using a TreeSet but this will reorder the map based upon the key. This solution allows the iteration over the original LinkedHashMap not the new ArrayList as has also been proposed: List<String> reverseOrderedKeys = new ArrayList<String>(linkedHashMap.keySet()); Collections.reverse(reverseOrderedKeys); for (String key : reverseOrderedKeys) { RecordItemElement … Read more
List<Map.Entry<String, Integer>> entries = new ArrayList<Map.Entry<String, Integer>>(map.entrySet()); Collections.sort(entries, new Comparator<Map.Entry<String, Integer>>() { public int compare(Map.Entry<String, Integer> a, Map.Entry<String, Integer> b){ return a.getValue().compareTo(b.getValue()); } }); Map<String, Integer> sortedMap = new LinkedHashMap<String, Integer>(); for (Map.Entry<String, Integer> entry : entries) { sortedMap.put(entry.getKey(), entry.getValue()); }
The semantics of LinkedHashMap are still those of a Map, rather than that of a LinkedList. It retains insertion order, yes, but that’s an implementation detail, rather than an aspect of its interface. The quickest way to get the “first” entry is still entrySet().iterator().next(). Getting the “last” entry is possible, but will entail iterating over … Read more
The Map interface provides three collection views, which allow a map’s contents to be viewed as a set of keys, collection of values, or set of key-value mappings. The order of a map is defined as the order in which the iterators on the map’s collection views return their elements. Some map implementations, like the … Read more