linkedhashmap – Tarik Billa

Jackson JSON + Java Generics get LinkedHashMap

December 16, 2023 by Tarik

The following works and as per StaxMan’s advice no longer uses the deprecated static collectionType() method. public class SoApp { /** * @param args * @throws Exception */ public static void main(String[] args) throws Exception { System.out.println(“Hello World!”); String s = “[{\”user\”:\”TestCity\”,\”role\”:\”TestCountry\”},{\”user\”:\”TestCity\”,\”role\”:\”TestCountry\”}]”; StringReader sr = new StringReader(“{\”user\”:\”TestCity\”,\”role\”:\”TestCountry\”}”); //UserRole user = mapper.readValue(sr, UserRole.class); mapJsonToObjectList(s,UserRole.class); } protected … Read more

Use LinkedHashMap to implement LRU cache

November 27, 2023 by Tarik

As pointed out by Jeffrey, you are using accessOrder. When you created the LinkedHashMap, the third parameter specify how the order is changed. “true for access-order, false for insertion-order” For more detailed implementation of LRU, you can look at this http://www.programcreek.com/2013/03/leetcode-lru-cache-java/

Collect stream of EntrySet to LinkedHashMap

September 26, 2023 by Tarik

You can do this with Stream: Map<String, Object> result = resources.entrySet() .stream() .filter(e -> keys.contains(e.getKey())) .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, (x, y) -> y, LinkedHashMap::new)); The part (x, y) -> y is because of mergeFunction when find duplicate keys, it returns value of second key which found. the forth part is mapFactory which a supplier providing a new … Read more

HashMap vs LinkedHashMap performance in iteration over values()

September 5, 2023 by Tarik

I think the LinkedHashMap has to be faster in traversal due to a superior nextEntry implementation in its Iterator Here is why : Let us go step by step from the values implementation. The HashMap implementation of values is this : public Collection<V> values() { Collection<V> vs = values; return (vs != null ? vs … Read more

java collections – keyset() vs entrySet() in map

August 23, 2023 by Tarik

Every call to the Iterator.next() moves the iterator to the next element. If you want to use the current element in more than one statement or expression, you have to store it in a local variable. Or even better, why don’t you simply use a for-each loop? for (String key : map.keySet()) { System.out.println(key + … Read more

How is the internal implementation of LinkedHashMap different from HashMap implementation?

August 3, 2023 by Tarik

HashMap does not maintain insertion order, hence it does not maintain any doubly linked list. Most salient feature of LinkedHashMap is that it maintains insertion order of key-value pairs. LinkedHashMap uses doubly Linked List for doing so. Entry of LinkedHashMap looks like this- static class Entry<K, V> { K key; V value; Entry<K,V> next; Entry<K,V> … Read more

How to get position of key/value in LinkedHashMap using its key

August 1, 2023 by Tarik

HashMap implementations in general are un-ordered for Iteration. LinkedHashMap is predictablely ordered for Iteration ( insertion order ) but does not expose the List interface and a LinkedList ( which is what mirrors the key set insertion order ) does not track index position itself either, it is very in-efficient to find the index as … Read more

Iterating through a LinkedHashMap in reverse order

July 20, 2023 by Tarik

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

How to iterate through LinkedHashMap with lists as values

July 11, 2023 by Tarik

for (Map.Entry<String, ArrayList<String>> entry : test1.entrySet()) { String key = entry.getKey(); ArrayList<String> value = entry.getValue(); // now work with key and value… } By the way, you should really declare your variables as the interface type instead, such as Map<String, List<String>>.

Does Java’s LinkedHashMap maintain the order of keys? [duplicate]

June 6, 2023 by Tarik

Yes. See: LinkedHashMap: This linked list defines the iteration ordering, which is normally the order in which keys were inserted into the map (insertion-order). and from the HashMap#keySet documentation: The set [returned] is backed by the map, so changes to the map are reflected in the set, and vice-versa.