There isn't a factory method like LinkedHashMap::of indeed, and a Map does not have an order per-se, so the only way I see it is to build a LinkedHashMap if you really needed one.

Btw from the JEP itself:

Static factory methods on concrete collection classes (e.g., ArrayList, HashSet) have been removed from this proposal ...

There is another wrinkle, which is that static methods on classes are inherited by subclasses. Suppose a static factory method HashMap.of() were to be added. Since LinkedHashMap is a subclass of HashMap, it would be possible for application code to call LinkedHashMap.of(). This would end up calling HashMap.of(), not at all what one would expect!

Point here is that static methods are inherited, but not overridable, thus if such a method would have been added to HashMap it could have not been overridden in LinkedHashMap.

If you can use guava, you could use ImmutableMap that is documented as:

An immutable, hash-based Map with reliable user-specified iteration order...

As documented on the Java apidoc of Map (emphasis mine):

Unmodifiable Maps

The Map.of, Map.ofEntries, and Map.copyOf static factory methods provide a convenient way to create unmodifiable maps. The Map instances created by these methods have the following characteristics:

• ...
• The iteration order of mappings is unspecified and is subject to change.
• ...

Unfortunately, there is no equivalent convenience method in the Java API that creates a LinkedHashMap. If you want a consistent iteration order, then you will need to manually create a LinkedHashMap and populate it (and - if needed - wrap it using Collections.unmodifiableMap).

Consider creating your own convenience method that does the equivalent of Map.of but with a consistent iteration order (or find an existing library that already provides this).

Because there seems to be no method that is doing what you want in the JDK you have to implement it by yourself or use a existing library. Creating such helper method isn't that hard:

public static <K, V> LinkedHashMap<K, V> of(Collection<Entry<? extends K, ? extends V>> entries) {
  final LinkedHashMap<K, V> map = new LinkedHashMap<>();
  entries.forEach(entry -> map.put(entry.getKey(), entry.getValue()));
  return map;
}

And then you could use it like this:

of(List.of(Map.entry("Hello", "World"), Map.entry("Goodnight", "Moon")));

This solution has the advantage over the Map.of in the JDK that the key value pairs are provided as entry pairs and not just as lose pairs by parameter index.

You can also use vavr.io in the following way:

Map<String, String> mapPreservingInsertionOrder = io.vavr.collection.LinkedHashMap.of("key1", "val1", "key2", "val2").toJavaMap();