Как преобразовать массив в HashMap с помощью Java 8 Stream

вы можете использовать

public static <K, V> Map<K, V> toMap(Object... entries) {
    if(entries.length % 2 == 1)
        throw new IllegalArgumentException("Invalid entries");
    return (Map<K, V>)IntStream.range(0, entries.length/2).map(i -> i*2)
        .collect(HashMap::new, (m,i)->m.put(entries[i], entries[i+1]), Map::putAll);
}

но это даст вам (основана) unchecked предупреждение. Ваш метод не может содержать обещание вернуть правильно набранный Map<K, V> для массива произвольных объектов и, что еще хуже, он не потерпит неудачу за исключением, но молча вернет несогласованную карту, если вы передадите объекты неправильного типа.

уборщик, обыкновенно используемый, решение

public static <K, V> Map<K, V> toMap(
                               Class<K> keyType, Class<V> valueType, Object... entries) {
    if(entries.length % 2 == 1)
        throw new IllegalArgumentException("Invalid entries");
    return IntStream.range(0, entries.length/2).map(i -> i*2)
        .collect(HashMap::new,
                 (m,i)->m.put(keyType.cast(entries[i]), valueType.cast(entries[i+1])),
                 Map::putAll);
}

это можно скомпилировать без предупреждения, так как правильность будет проверяться во время выполнения. Код вызова должен быть адаптирован:

Map<String, Integer> map1 = toMap(String.class, Integer.class, "k1", 1, "k2", 2);
Map<String, String> map2 = toMap(
                           String.class, String.class, "k1", "v1", "k2", "v2", "k3", "v3");

помимо необходимости указывать фактические типы как литералы классов, он имеет недостаток в том, что не поддерживает общие типы ключей или значений (поскольку они не могут быть выражены как Class) и все еще не имея безопасности во время компиляции, только проверка выполнения.

стоит глядя на Java 9. Там, вы сможете сделать:

Map<String, Integer> map1 = Map.of("k1", 1, "k2", 2);
Map<String, String>  map2 = Map.of("k1", "v1", "k2", "v2", "k3", "v3");

это создаст неизменяемые карта неопределенного типа, а не HashMap, но интересным моментом является API.

есть метод <K,V> Map.Entry<K,V> entry(K k, V v) который можно совместить с
<K,V> Map<K,V> ofEntries(Map.Entry<? extends K,? extends V>... entries) для создания карты переменной длины (varargs по-прежнему ограничены 255 параметрами).

вы можете реализовать аналогичную вещь:

public static <K,V> Map.Entry<K,V> entry(K k, V v) {
    return new AbstractMap.SimpleImmutableEntry<>(k, v);
}
public static <K,V> Map<K,V> ofEntries(Map.Entry<? extends K,? extends V>... entries) {
    return Arrays.stream(entries)
        .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
}

удобный метод(ы) of реализованы единственным способом, это можно сделать с помощью типа safety: as overloaded методы с различным количеством аргументов, например

public static <K,V> Map<K,V> of() {
    return new HashMap<>();// or Collections.emptyMap() to create immutable maps
}
static <K,V> Map<K,V> of(K k1, V v1) {
    return ofEntries(entry(k1, v1));
}
static <K,V> Map<K,V> of(K k1, V v1, K k2, V v2) {
    return ofEntries(entry(k1, v1), entry(k2, v2));
}
static <K,V> Map<K,V> of(K k1, V v1, K k2, V v2, K k3, V v3) {
    return ofEntries(entry(k1, v1), entry(k2, v2), entry(k3, v3));
}
static <K,V> Map<K,V> of(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4) {
    return ofEntries(entry(k1, v1), entry(k2, v2), entry(k3, v3), entry(k4, v4));
}   
static <K,V> Map<K,V> of(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5) {
    return ofEntries(entry(k1, v1), entry(k2, v2), entry(k3, v3), entry(k4, v4));
}   

(Java 9 делает разрез на десяти отображениях, если у вас есть больше, вы должны использовать ofEntries(entry(k1, v1), …) вариант).

если вы следуете этой схеме, вы должны сохранить свой toMap имя или использовать просто map, вместо того, чтобы звонить на "of", так как вы не пишете Map интерфейс.

эти перегрузки могут выглядеть не очень элегантно, но они решают все проблемы. Вы можете написать код, как в вашем вопрос, без указания Class объекты, но получить безопасность типа времени компиляции и даже отклонение попыток вызвать его с нечетным числом аргументов.

вы должны сделать разрез при определенном количестве параметров, но, как уже отмечалось, даже varargs не поддерживают неограниченные параметры. И ofEntries(entry(…), …) форма не так уж и плохо для больших карт.

сборщик Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue) возвращает неопределенный тип карты, который может быть даже неизменяемым (хотя это HashMapв текущей версии). Если вы хотите иметь гарантию, что HashMap экземпляр возвращается, вы должны использовать .