generated from mingliqiye/lib-tem
minglipro
09792e2c3b
All checks were successful
Gitea Actions Build / Build (push) Successful in 53s
15986 lines
263 KiB
Java
15986 lines
263 KiB
Java
/*
|
||
* Copyright 2025 mingliqiye
|
||
*
|
||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||
* you may not use this file except in compliance with the License.
|
||
* You may obtain a copy of the License at
|
||
*
|
||
* http://www.apache.org/licenses/LICENSE-2.0
|
||
*
|
||
* Unless required by applicable law or agreed to in writing, software
|
||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||
* See the License for the specific language governing permissions and
|
||
* limitations under the License.
|
||
*
|
||
* ProjectName mingli-utils
|
||
* ModuleName mingli-utils.main
|
||
* CurrentFile Maps.java
|
||
* LastUpdate 2025-09-09 08:37:33
|
||
* UpdateUser MingLiPro
|
||
*/
|
||
|
||
package com.mingliqiye.utils.collection;
|
||
|
||
import java.util.*;
|
||
import java.util.concurrent.ConcurrentHashMap;
|
||
import lombok.var;
|
||
|
||
/**
|
||
* Maps工具类提供了一系列创建Map实现的便捷方法。
|
||
*
|
||
* @author MingLiPro
|
||
*/
|
||
public class Maps {
|
||
|
||
/**
|
||
* 创建一个空的HashMap实例。
|
||
*
|
||
* @param <K> Map键的类型
|
||
* @param <V> Map值的类型
|
||
* @return 新创建的空HashMap实例
|
||
*/
|
||
public static <K, V> Map<K, V> newHashMap() {
|
||
return new HashMap<>();
|
||
}
|
||
|
||
/**
|
||
* 创建一个指定初始容量的空HashMap实例。
|
||
*
|
||
* @param size 初始容量大小
|
||
* @param <K> Map键的类型
|
||
* @param <V> Map值的类型
|
||
* @return 指定初始容量的空HashMap实例
|
||
*/
|
||
public static <K, V> Map<K, V> newHashMap(int size) {
|
||
return new HashMap<>(size);
|
||
}
|
||
|
||
/**
|
||
* 根据已有Map创建一个新的HashMap实例。
|
||
*
|
||
* @param map 要复制的Map
|
||
* @param <K> Map键的类型
|
||
* @param <V> Map值的类型
|
||
* @return 包含原Map所有元素的新HashMap实例
|
||
*/
|
||
public static <K, V> Map<K, V> newHashMap(Map<K, V> map) {
|
||
Map<K, V> newMap = newHashMap();
|
||
newMap.putAll(map);
|
||
return newMap;
|
||
}
|
||
|
||
/**
|
||
* 创建一个空的LinkedHashMap实例。
|
||
*
|
||
* @param <K> Map键的类型
|
||
* @param <V> Map值的类型
|
||
* @return 新创建的空LinkedHashMap实例
|
||
*/
|
||
public static <K, V> Map<K, V> newLinkedHashMap() {
|
||
return new LinkedHashMap<>();
|
||
}
|
||
|
||
/**
|
||
* 创建一个指定初始容量的空LinkedHashMap实例。
|
||
*
|
||
* @param size 初始容量大小
|
||
* @param <K> Map键的类型
|
||
* @param <V> Map值的类型
|
||
* @return 指定初始容量的空LinkedHashMap实例
|
||
*/
|
||
public static <K, V> Map<K, V> newLinkedHashMap(int size) {
|
||
return new LinkedHashMap<>(size);
|
||
}
|
||
|
||
/**
|
||
* 根据已有Map创建一个新的LinkedHashMap实例。
|
||
*
|
||
* @param map 要复制的Map
|
||
* @param <K> Map键的类型
|
||
* @param <V> Map值的类型
|
||
* @return 包含原Map所有元素的新LinkedHashMap实例
|
||
*/
|
||
public static <K, V> Map<K, V> newLinkedHashMap(Map<K, V> map) {
|
||
Map<K, V> newMap = newLinkedHashMap();
|
||
newMap.putAll(map);
|
||
return newMap;
|
||
}
|
||
|
||
/**
|
||
* 创建一个空的TreeMap实例。
|
||
*
|
||
* @param <K> Map键的类型，必须实现Comparable接口
|
||
* @param <V> Map值的类型
|
||
* @return 新创建的空TreeMap实例
|
||
*/
|
||
public static <K extends Comparable<K>, V> Map<K, V> newTreeMap() {
|
||
return new TreeMap<>();
|
||
}
|
||
|
||
/**
|
||
* 根据已有Map创建一个新的TreeMap实例。
|
||
*
|
||
* @param map 要复制的Map
|
||
* @param <K> Map键的类型，必须实现Comparable接口
|
||
* @param <V> Map值的类型
|
||
* @return 包含原Map所有元素的新TreeMap实例
|
||
*/
|
||
public static <K extends Comparable<K>, V> Map<K, V> newTreeMap(
|
||
Map<K, V> map
|
||
) {
|
||
Map<K, V> newMap = newTreeMap();
|
||
newMap.putAll(map);
|
||
return newMap;
|
||
}
|
||
|
||
/**
|
||
* 创建一个空的Hashtable实例。
|
||
*
|
||
* @param <K> Map键的类型
|
||
* @param <V> Map值的类型
|
||
* @return 新创建的空Hashtable实例
|
||
*/
|
||
public static <K, V> Map<K, V> newHashtable() {
|
||
return new Hashtable<>();
|
||
}
|
||
|
||
/**
|
||
* 创建一个指定初始容量的空Hashtable实例。
|
||
*
|
||
* @param size 初始容量大小
|
||
* @param <K> Map键的类型
|
||
* @param <V> Map值的类型
|
||
* @return 指定初始容量的空Hashtable实例
|
||
*/
|
||
public static <K, V> Map<K, V> newHashtable(int size) {
|
||
return new Hashtable<>(size);
|
||
}
|
||
|
||
/**
|
||
* 根据已有Map创建一个新的Hashtable实例。
|
||
*
|
||
* @param map 要复制的Map
|
||
* @param <K> Map键的类型
|
||
* @param <V> Map值的类型
|
||
* @return 包含原Map所有元素的新Hashtable实例
|
||
*/
|
||
public static <K, V> Map<K, V> newHashtable(Map<K, V> map) {
|
||
Map<K, V> newMap = newHashtable();
|
||
newMap.putAll(map);
|
||
return newMap;
|
||
}
|
||
|
||
/**
|
||
* 创建一个空的ConcurrentHashMap实例。
|
||
*
|
||
* @param <K> Map键的类型
|
||
* @param <V> Map值的类型
|
||
* @return 新创建的空ConcurrentHashMap实例
|
||
*/
|
||
public static <K, V> Map<K, V> newConcurrentHashMap() {
|
||
return new ConcurrentHashMap<>();
|
||
}
|
||
|
||
/**
|
||
* 创建一个指定初始容量的空ConcurrentHashMap实例。
|
||
*
|
||
* @param size 初始容量大小
|
||
* @param <K> Map键的类型
|
||
* @param <V> Map值的类型
|
||
* @return 指定初始容量的空ConcurrentHashMap实例
|
||
*/
|
||
public static <K, V> Map<K, V> newConcurrentHashMap(int size) {
|
||
return new ConcurrentHashMap<>(size);
|
||
}
|
||
|
||
/**
|
||
* 根据已有Map创建一个新的ConcurrentHashMap实例。
|
||
*
|
||
* @param map 要复制的Map
|
||
* @param <K> Map键的类型
|
||
* @param <V> Map值的类型
|
||
* @return 包含原Map所有元素的新ConcurrentHashMap实例
|
||
*/
|
||
public static <K, V> Map<K, V> newConcurrentHashMap(Map<K, V> map) {
|
||
Map<K, V> newMap = newConcurrentHashMap();
|
||
newMap.putAll(map);
|
||
return newMap;
|
||
}
|
||
|
||
/**
|
||
* 创建一个包含单个键值对的HashMap实例。
|
||
*
|
||
* @param key 键
|
||
* @param value 值
|
||
* @param <K> 键的类型
|
||
* @param <V> 值的类型
|
||
* @return 包含指定键值对的HashMap实例
|
||
*/
|
||
public static <K, V> Map<K, V> of(K key, V value) {
|
||
var map = new HashMap<K, V>(5);
|
||
map.put(key, value);
|
||
return map;
|
||
}
|
||
|
||
public static <K, V> Map<K, V> of(K key, V value, K key2, V value2) {
|
||
var map = new HashMap<K, V>(6);
|
||
map.put(key, value);
|
||
map.put(key2, value2);
|
||
return map;
|
||
}
|
||
|
||
public static <K, V> Map<K, V> of(
|
||
K key,
|
||
V value,
|
||
K key2,
|
||
V value2,
|
||
K key3,
|
||
V value3
|
||
) {
|
||
var map = new HashMap<K, V>(7);
|
||
map.put(key, value);
|
||
map.put(key2, value2);
|
||
map.put(key3, value3);
|
||
return map;
|
||
}
|
||
|
||
public static <K, V> Map<K, V> of(
|
||
K key,
|
||
V value,
|
||
K key2,
|
||
V value2,
|
||
K key3,
|
||
V value3,
|
||
K key4,
|
||
V value4
|
||
) {
|
||
var map = new HashMap<K, V>(8);
|
||
map.put(key, value);
|
||
map.put(key2, value2);
|
||
map.put(key3, value3);
|
||
map.put(key4, value4);
|
||
return map;
|
||
}
|
||
|
||
public static <K, V> Map<K, V> of(
|
||
K key,
|
||
V value,
|
||
K key2,
|
||
V value2,
|
||
K key3,
|
||
V value3,
|
||
K key4,
|
||
V value4,
|
||
K key5,
|
||
V value5
|
||
) {
|
||
var map = new HashMap<K, V>(9);
|
||
map.put(key, value);
|
||
map.put(key2, value2);
|
||
map.put(key3, value3);
|
||
map.put(key4, value4);
|
||
map.put(key5, value5);
|
||
return map;
|
||
}
|
||
|
||
public static <K, V> Map<K, V> of(
|
||
K key,
|
||
V value,
|
||
K key2,
|
||
V value2,
|
||
K key3,
|
||
V value3,
|
||
K key4,
|
||
V value4,
|
||
K key5,
|
||
V value5,
|
||
K key6,
|
||
V value6
|
||
) {
|
||
var map = new HashMap<K, V>(10);
|
||
map.put(key, value);
|
||
map.put(key2, value2);
|
||
map.put(key3, value3);
|
||
map.put(key4, value4);
|
||
map.put(key5, value5);
|
||
map.put(key6, value6);
|
||
return map;
|
||
}
|
||
|
||
public static <K, V> Map<K, V> of(
|
||
K key,
|
||
V value,
|
||
K key2,
|
||
V value2,
|
||
K key3,
|
||
V value3,
|
||
K key4,
|
||
V value4,
|
||
K key5,
|
||
V value5,
|
||
K key6,
|
||
V value6,
|
||
K key7,
|
||
V value7
|
||
) {
|
||
var map = new HashMap<K, V>(11);
|
||
map.put(key, value);
|
||
map.put(key2, value2);
|
||
map.put(key3, value3);
|
||
map.put(key4, value4);
|
||
map.put(key5, value5);
|
||
map.put(key6, value6);
|
||
map.put(key7, value7);
|
||
return map;
|
||
}
|
||
|
||
public static <K, V> Map<K, V> of(
|
||
K key,
|
||
V value,
|
||
K key2,
|
||
V value2,
|
||
K key3,
|
||
V value3,
|
||
K key4,
|
||
V value4,
|
||
K key5,
|
||
V value5,
|
||
K key6,
|
||
V value6,
|
||
K key7,
|
||
V value7,
|
||
K key8,
|
||
V value8
|
||
) {
|
||
var map = new HashMap<K, V>(12);
|
||
map.put(key, value);
|
||
map.put(key2, value2);
|
||
map.put(key3, value3);
|
||
map.put(key4, value4);
|
||
map.put(key5, value5);
|
||
map.put(key6, value6);
|
||
map.put(key7, value7);
|
||
map.put(key8, value8);
|
||
return map;
|
||
}
|
||
|
||
public static <K, V> Map<K, V> of(
|
||
K key,
|
||
V value,
|
||
K key2,
|
||
V value2,
|
||
K key3,
|
||
V value3,
|
||
K key4,
|
||
V value4,
|
||
K key5,
|
||
V value5,
|
||
K key6,
|
||
V value6,
|
||
K key7,
|
||
V value7,
|
||
K key8,
|
||
V value8,
|
||
K key9,
|
||
V value9
|
||
) {
|
||
var map = new HashMap<K, V>(13);
|
||
map.put(key, value);
|
||
map.put(key2, value2);
|
||
map.put(key3, value3);
|
||
map.put(key4, value4);
|
||
map.put(key5, value5);
|
||
map.put(key6, value6);
|
||
map.put(key7, value7);
|
||
map.put(key8, value8);
|
||
map.put(key9, value9);
|
||
return map;
|
||
}
|
||
|
||
public static <K, V> Map<K, V> of(
|
||
K key,
|
||
V value,
|
||
K key2,
|
||
V value2,
|
||
K key3,
|
||
V value3,
|
||
K key4,
|
||
V value4,
|
||
K key5,
|
||
V value5,
|
||
K key6,
|
||
V value6,
|
||
K key7,
|
||
V value7,
|
||
K key8,
|
||
V value8,
|
||
K key9,
|
||
V value9,
|
||
K key10,
|
||
V value10
|
||
) {
|
||
var map = new HashMap<K, V>(14);
|
||
map.put(key, value);
|
||
map.put(key2, value2);
|
||
map.put(key3, value3);
|
||
map.put(key4, value4);
|
||
map.put(key5, value5);
|
||
map.put(key6, value6);
|
||
map.put(key7, value7);
|
||
map.put(key8, value8);
|
||
map.put(key9, value9);
|
||
map.put(key10, value10);
|
||
return map;
|
||
}
|
||
|
||
public static <K, V> Map<K, V> of(
|
||
K key,
|
||
V value,
|
||
K key2,
|
||
V value2,
|
||
K key3,
|
||
V value3,
|
||
K key4,
|
||
V value4,
|
||
K key5,
|
||
V value5,
|
||
K key6,
|
||
V value6,
|
||
K key7,
|
||
V value7,
|
||
K key8,
|
||
V value8,
|
||
K key9,
|
||
V value9,
|
||
K key10,
|
||
V value10,
|
||
K key11,
|
||
V value11
|
||
) {
|
||
var map = new HashMap<K, V>(15);
|
||
map.put(key, value);
|
||
map.put(key2, value2);
|
||
map.put(key3, value3);
|
||
map.put(key4, value4);
|
||
map.put(key5, value5);
|
||
map.put(key6, value6);
|
||
map.put(key7, value7);
|
||
map.put(key8, value8);
|
||
map.put(key9, value9);
|
||
map.put(key10, value10);
|
||
map.put(key11, value11);
|
||
return map;
|
||
}
|
||
|
||
public static <K, V> Map<K, V> of(
|
||
K key,
|
||
V value,
|
||
K key2,
|
||
V value2,
|
||
K key3,
|
||
V value3,
|
||
K key4,
|
||
V value4,
|
||
K key5,
|
||
V value5,
|
||
K key6,
|
||
V value6,
|
||
K key7,
|
||
V value7,
|
||
K key8,
|
||
V value8,
|
||
K key9,
|
||
V value9,
|
||
K key10,
|
||
V value10,
|
||
K key11,
|
||
V value11,
|
||
K key12,
|
||
V value12
|
||
) {
|
||
var map = new HashMap<K, V>(16);
|
||
map.put(key, value);
|
||
map.put(key2, value2);
|
||
map.put(key3, value3);
|
||
map.put(key4, value4);
|
||
map.put(key5, value5);
|
||
map.put(key6, value6);
|
||
map.put(key7, value7);
|
||
map.put(key8, value8);
|
||
map.put(key9, value9);
|
||
map.put(key10, value10);
|
||
map.put(key11, value11);
|
||
map.put(key12, value12);
|
||
return map;
|
||
}
|
||
|
||
public static <K, V> Map<K, V> of(
|
||
K key,
|
||
V value,
|
||
K key2,
|
||
V value2,
|
||
K key3,
|
||
V value3,
|
||
K key4,
|
||
V value4,
|
||
K key5,
|
||
V value5,
|
||
K key6,
|
||
V value6,
|
||
K key7,
|
||
V value7,
|
||
K key8,
|
||
V value8,
|
||
K key9,
|
||
V value9,
|
||
K key10,
|
||
V value10,
|
||
K key11,
|
||
V value11,
|
||
K key12,
|
||
V value12,
|
||
K key13,
|
||
V value13
|
||
) {
|
||
var map = new HashMap<K, V>(17);
|
||
map.put(key, value);
|
||
map.put(key2, value2);
|
||
map.put(key3, value3);
|
||
map.put(key4, value4);
|
||
map.put(key5, value5);
|
||
map.put(key6, value6);
|
||
map.put(key7, value7);
|
||
map.put(key8, value8);
|
||
map.put(key9, value9);
|
||
map.put(key10, value10);
|
||
map.put(key11, value11);
|
||
map.put(key12, value12);
|
||
map.put(key13, value13);
|
||
return map;
|
||
}
|
||
|
||
public static <K, V> Map<K, V> of(
|
||
K key,
|
||
V value,
|
||
K key2,
|
||
V value2,
|
||
K key3,
|
||
V value3,
|
||
K key4,
|
||
V value4,
|
||
K key5,
|
||
V value5,
|
||
K key6,
|
||
V value6,
|
||
K key7,
|
||
V value7,
|
||
K key8,
|
||
V value8,
|
||
K key9,
|
||
V value9,
|
||
K key10,
|
||
V value10,
|
||
K key11,
|
||
V value11,
|
||
K key12,
|
||
V value12,
|
||
K key13,
|
||
V value13,
|
||
K key14,
|
||
V value14
|
||
) {
|
||
var map = new HashMap<K, V>(18);
|
||
map.put(key, value);
|
||
map.put(key2, value2);
|
||
map.put(key3, value3);
|
||
map.put(key4, value4);
|
||
map.put(key5, value5);
|
||
map.put(key6, value6);
|
||
map.put(key7, value7);
|
||
map.put(key8, value8);
|
||
map.put(key9, value9);
|
||
map.put(key10, value10);
|
||
map.put(key11, value11);
|
||
map.put(key12, value12);
|
||
map.put(key13, value13);
|
||
map.put(key14, value14);
|
||
return map;
|
||
}
|
||
|
||
public static <K, V> Map<K, V> of(
|
||
K key,
|
||
V value,
|
||
K key2,
|
||
V value2,
|
||
K key3,
|
||
V value3,
|
||
K key4,
|
||
V value4,
|
||
K key5,
|
||
V value5,
|
||
K key6,
|
||
V value6,
|
||
K key7,
|
||
V value7,
|
||
K key8,
|
||
V value8,
|
||
K key9,
|
||
V value9,
|
||
K key10,
|
||
V value10,
|
||
K key11,
|
||
V value11,
|
||
K key12,
|
||
V value12,
|
||
K key13,
|
||
V value13,
|
||
K key14,
|
||
V value14,
|
||
K key15,
|
||
V value15
|
||
) {
|
||
var map = new HashMap<K, V>(19);
|
||
map.put(key, value);
|
||
map.put(key2, value2);
|
||
map.put(key3, value3);
|
||
map.put(key4, value4);
|
||
map.put(key5, value5);
|
||
map.put(key6, value6);
|
||
map.put(key7, value7);
|
||
map.put(key8, value8);
|
||
map.put(key9, value9);
|
||
map.put(key10, value10);
|
||
map.put(key11, value11);
|
||
map.put(key12, value12);
|
||
map.put(key13, value13);
|
||
map.put(key14, value14);
|
||
map.put(key15, value15);
|
||
return map;
|
||
}
|
||
|
||
public static <K, V> Map<K, V> of(
|
||
K key,
|
||
V value,
|
||
K key2,
|
||
V value2,
|
||
K key3,
|
||
V value3,
|
||
K key4,
|
||
V value4,
|
||
K key5,
|
||
V value5,
|
||
K key6,
|
||
V value6,
|
||
K key7,
|
||
V value7,
|
||
K key8,
|
||
V value8,
|
||
K key9,
|
||
V value9,
|
||
K key10,
|
||
V value10,
|
||
K key11,
|
||
V value11,
|
||
K key12,
|
||
V value12,
|
||
K key13,
|
||
V value13,
|
||
K key14,
|
||
V value14,
|
||
K key15,
|
||
V value15,
|
||
K key16,
|
||
V value16
|
||
) {
|
||
var map = new HashMap<K, V>(20);
|
||
map.put(key, value);
|
||
map.put(key2, value2);
|
||
map.put(key3, value3);
|
||
map.put(key4, value4);
|
||
map.put(key5, value5);
|
||
map.put(key6, value6);
|
||
map.put(key7, value7);
|
||
map.put(key8, value8);
|
||
map.put(key9, value9);
|
||
map.put(key10, value10);
|
||
map.put(key11, value11);
|
||
map.put(key12, value12);
|
||
map.put(key13, value13);
|
||
map.put(key14, value14);
|
||
map.put(key15, value15);
|
||
map.put(key16, value16);
|
||
return map;
|
||
}
|
||
|
||
public static <K, V> Map<K, V> of(
|
||
K key,
|
||
V value,
|
||
K key2,
|
||
V value2,
|
||
K key3,
|
||
V value3,
|
||
K key4,
|
||
V value4,
|
||
K key5,
|
||
V value5,
|
||
K key6,
|
||
V value6,
|
||
K key7,
|
||
V value7,
|
||
K key8,
|
||
V value8,
|
||
K key9,
|
||
V value9,
|
||
K key10,
|
||
V value10,
|
||
K key11,
|
||
V value11,
|
||
K key12,
|
||
V value12,
|
||
K key13,
|
||
V value13,
|
||
K key14,
|
||
V value14,
|
||
K key15,
|
||
V value15,
|
||
K key16,
|
||
V value16,
|
||
K key17,
|
||
V value17
|
||
) {
|
||
var map = new HashMap<K, V>(21);
|
||
map.put(key, value);
|
||
map.put(key2, value2);
|
||
map.put(key3, value3);
|
||
map.put(key4, value4);
|
||
map.put(key5, value5);
|
||
map.put(key6, value6);
|
||
map.put(key7, value7);
|
||
map.put(key8, value8);
|
||
map.put(key9, value9);
|
||
map.put(key10, value10);
|
||
map.put(key11, value11);
|
||
map.put(key12, value12);
|
||
map.put(key13, value13);
|
||
map.put(key14, value14);
|
||
map.put(key15, value15);
|
||
map.put(key16, value16);
|
||
map.put(key17, value17);
|
||
return map;
|
||
}
|
||
|
||
public static <K, V> Map<K, V> of(
|
||
K key,
|
||
V value,
|
||
K key2,
|
||
V value2,
|
||
K key3,
|
||
V value3,
|
||
K key4,
|
||
V value4,
|
||
K key5,
|
||
V value5,
|
||
K key6,
|
||
V value6,
|
||
K key7,
|
||
V value7,
|
||
K key8,
|
||
V value8,
|
||
K key9,
|
||
V value9,
|
||
K key10,
|
||
V value10,
|
||
K key11,
|
||
V value11,
|
||
K key12,
|
||
V value12,
|
||
K key13,
|
||
V value13,
|
||
K key14,
|
||
V value14,
|
||
K key15,
|
||
V value15,
|
||
K key16,
|
||
V value16,
|
||
K key17,
|
||
V value17,
|
||
K key18,
|
||
V value18
|
||
) {
|
||
var map = new HashMap<K, V>(22);
|
||
map.put(key, value);
|
||
map.put(key2, value2);
|
||
map.put(key3, value3);
|
||
map.put(key4, value4);
|
||
map.put(key5, value5);
|
||
map.put(key6, value6);
|
||
map.put(key7, value7);
|
||
map.put(key8, value8);
|
||
map.put(key9, value9);
|
||
map.put(key10, value10);
|
||
map.put(key11, value11);
|
||
map.put(key12, value12);
|
||
map.put(key13, value13);
|
||
map.put(key14, value14);
|
||
map.put(key15, value15);
|
||
map.put(key16, value16);
|
||
map.put(key17, value17);
|
||
map.put(key18, value18);
|
||
return map;
|
||
}
|
||
|
||
public static <K, V> Map<K, V> of(
|
||
K key,
|
||
V value,
|
||
K key2,
|
||
V value2,
|
||
K key3,
|
||
V value3,
|
||
K key4,
|
||
V value4,
|
||
K key5,
|
||
V value5,
|
||
K key6,
|
||
V value6,
|
||
K key7,
|
||
V value7,
|
||
K key8,
|
||
V value8,
|
||
K key9,
|
||
V value9,
|
||
K key10,
|
||
V value10,
|
||
K key11,
|
||
V value11,
|
||
K key12,
|
||
V value12,
|
||
K key13,
|
||
V value13,
|
||
K key14,
|
||
V value14,
|
||
K key15,
|
||
V value15,
|
||
K key16,
|
||
V value16,
|
||
K key17,
|
||
V value17,
|
||
K key18,
|
||
V value18,
|
||
K key19,
|
||
V value19
|
||
) {
|
||
var map = new HashMap<K, V>(23);
|
||
map.put(key, value);
|
||
map.put(key2, value2);
|
||
map.put(key3, value3);
|
||
map.put(key4, value4);
|
||
map.put(key5, value5);
|
||
map.put(key6, value6);
|
||
map.put(key7, value7);
|
||
map.put(key8, value8);
|
||
map.put(key9, value9);
|
||
map.put(key10, value10);
|
||
map.put(key11, value11);
|
||
map.put(key12, value12);
|
||
map.put(key13, value13);
|
||
map.put(key14, value14);
|
||
map.put(key15, value15);
|
||
map.put(key16, value16);
|
||
map.put(key17, value17);
|
||
map.put(key18, value18);
|
||
map.put(key19, value19);
|
||
return map;
|
||
}
|
||
|
||
public static <K, V> Map<K, V> of(
|
||
K key,
|
||
V value,
|
||
K key2,
|
||
V value2,
|
||
K key3,
|
||
V value3,
|
||
K key4,
|
||
V value4,
|
||
K key5,
|
||
V value5,
|
||
K key6,
|
||
V value6,
|
||
K key7,
|
||
V value7,
|
||
K key8,
|
||
V value8,
|
||
K key9,
|
||
V value9,
|
||
K key10,
|
||
V value10,
|
||
K key11,
|
||
V value11,
|
||
K key12,
|
||
V value12,
|
||
K key13,
|
||
V value13,
|
||
K key14,
|
||
V value14,
|
||
K key15,
|
||
V value15,
|
||
K key16,
|
||
V value16,
|
||
K key17,
|
||
V value17,
|
||
K key18,
|
||
V value18,
|
||
K key19,
|
||
V value19,
|
||
K key20,
|
||
V value20
|
||
) {
|
||
var map = new HashMap<K, V>(24);
|
||
map.put(key, value);
|
||
map.put(key2, value2);
|
||
map.put(key3, value3);
|
||
map.put(key4, value4);
|
||
map.put(key5, value5);
|
||
map.put(key6, value6);
|
||
map.put(key7, value7);
|
||
map.put(key8, value8);
|
||
map.put(key9, value9);
|
||
map.put(key10, value10);
|
||
map.put(key11, value11);
|
||
map.put(key12, value12);
|
||
map.put(key13, value13);
|
||
map.put(key14, value14);
|
||
map.put(key15, value15);
|
||
map.put(key16, value16);
|
||
map.put(key17, value17);
|
||
map.put(key18, value18);
|
||
map.put(key19, value19);
|
||
map.put(key20, value20);
|
||
return map;
|
||
}
|
||
|
||
public static <K, V> Map<K, V> of(
|
||
K key,
|
||
V value,
|
||
K key2,
|
||
V value2,
|
||
K key3,
|
||
V value3,
|
||
K key4,
|
||
V value4,
|
||
K key5,
|
||
V value5,
|
||
K key6,
|
||
V value6,
|
||
K key7,
|
||
V value7,
|
||
K key8,
|
||
V value8,
|
||
K key9,
|
||
V value9,
|
||
K key10,
|
||
V value10,
|
||
K key11,
|
||
V value11,
|
||
K key12,
|
||
V value12,
|
||
K key13,
|
||
V value13,
|
||
K key14,
|
||
V value14,
|
||
K key15,
|
||
V value15,
|
||
K key16,
|
||
V value16,
|
||
K key17,
|
||
V value17,
|
||
K key18,
|
||
V value18,
|
||
K key19,
|
||
V value19,
|
||
K key20,
|
||
V value20,
|
||
K key21,
|
||
V value21
|
||
) {
|
||
var map = new HashMap<K, V>(25);
|
||
map.put(key, value);
|
||
map.put(key2, value2);
|
||
map.put(key3, value3);
|
||
map.put(key4, value4);
|
||
map.put(key5, value5);
|
||
map.put(key6, value6);
|
||
map.put(key7, value7);
|
||
map.put(key8, value8);
|
||
map.put(key9, value9);
|
||
map.put(key10, value10);
|
||
map.put(key11, value11);
|
||
map.put(key12, value12);
|
||
map.put(key13, value13);
|
||
map.put(key14, value14);
|
||
map.put(key15, value15);
|
||
map.put(key16, value16);
|
||
map.put(key17, value17);
|
||
map.put(key18, value18);
|
||
map.put(key19, value19);
|
||
map.put(key20, value20);
|
||
map.put(key21, value21);
|
||
return map;
|
||
}
|
||
|
||
public static <K, V> Map<K, V> of(
|
||
K key,
|
||
V value,
|
||
K key2,
|
||
V value2,
|
||
K key3,
|
||
V value3,
|
||
K key4,
|
||
V value4,
|
||
K key5,
|
||
V value5,
|
||
K key6,
|
||
V value6,
|
||
K key7,
|
||
V value7,
|
||
K key8,
|
||
V value8,
|
||
K key9,
|
||
V value9,
|
||
K key10,
|
||
V value10,
|
||
K key11,
|
||
V value11,
|
||
K key12,
|
||
V value12,
|
||
K key13,
|
||
V value13,
|
||
K key14,
|
||
V value14,
|
||
K key15,
|
||
V value15,
|
||
K key16,
|
||
V value16,
|
||
K key17,
|
||
V value17,
|
||
K key18,
|
||
V value18,
|
||
K key19,
|
||
V value19,
|
||
K key20,
|
||
V value20,
|
||
K key21,
|
||
V value21,
|
||
K key22,
|
||
V value22
|
||
) {
|
||
var map = new HashMap<K, V>(26);
|
||
map.put(key, value);
|
||
map.put(key2, value2);
|
||
map.put(key3, value3);
|
||
map.put(key4, value4);
|
||
map.put(key5, value5);
|
||
map.put(key6, value6);
|
||
map.put(key7, value7);
|
||
map.put(key8, value8);
|
||
map.put(key9, value9);
|
||
map.put(key10, value10);
|
||
map.put(key11, value11);
|
||
map.put(key12, value12);
|
||
map.put(key13, value13);
|
||
map.put(key14, value14);
|
||
map.put(key15, value15);
|
||
map.put(key16, value16);
|
||
map.put(key17, value17);
|
||
map.put(key18, value18);
|
||
map.put(key19, value19);
|
||
map.put(key20, value20);
|
||
map.put(key21, value21);
|
||
map.put(key22, value22);
|
||
return map;
|
||
}
|
||
|
||
public static <K, V> Map<K, V> of(
|
||
K key,
|
||
V value,
|
||
K key2,
|
||
V value2,
|
||
K key3,
|
||
V value3,
|
||
K key4,
|
||
V value4,
|
||
K key5,
|
||
V value5,
|
||
K key6,
|
||
V value6,
|
||
K key7,
|
||
V value7,
|
||
K key8,
|
||
V value8,
|
||
K key9,
|
||
V value9,
|
||
K key10,
|
||
V value10,
|
||
K key11,
|
||
V value11,
|
||
K key12,
|
||
V value12,
|
||
K key13,
|
||
V value13,
|
||
K key14,
|
||
V value14,
|
||
K key15,
|
||
V value15,
|
||
K key16,
|
||
V value16,
|
||
K key17,
|
||
V value17,
|
||
K key18,
|
||
V value18,
|
||
K key19,
|
||
V value19,
|
||
K key20,
|
||
V value20,
|
||
K key21,
|
||
V value21,
|
||
K key22,
|
||
V value22,
|
||
K key23,
|
||
V value23
|
||
) {
|
||
var map = new HashMap<K, V>(27);
|
||
map.put(key, value);
|
||
map.put(key2, value2);
|
||
map.put(key3, value3);
|
||
map.put(key4, value4);
|
||
map.put(key5, value5);
|
||
map.put(key6, value6);
|
||
map.put(key7, value7);
|
||
map.put(key8, value8);
|
||
map.put(key9, value9);
|
||
map.put(key10, value10);
|
||
map.put(key11, value11);
|
||
map.put(key12, value12);
|
||
map.put(key13, value13);
|
||
map.put(key14, value14);
|
||
map.put(key15, value15);
|
||
map.put(key16, value16);
|
||
map.put(key17, value17);
|
||
map.put(key18, value18);
|
||
map.put(key19, value19);
|
||
map.put(key20, value20);
|
||
map.put(key21, value21);
|
||
map.put(key22, value22);
|
||
map.put(key23, value23);
|
||
return map;
|
||
}
|
||
|
||
public static <K, V> Map<K, V> of(
|
||
K key,
|
||
V value,
|
||
K key2,
|
||
V value2,
|
||
K key3,
|
||
V value3,
|
||
K key4,
|
||
V value4,
|
||
K key5,
|
||
V value5,
|
||
K key6,
|
||
V value6,
|
||
K key7,
|
||
V value7,
|
||
K key8,
|
||
V value8,
|
||
K key9,
|
||
V value9,
|
||
K key10,
|
||
V value10,
|
||
K key11,
|
||
V value11,
|
||
K key12,
|
||
V value12,
|
||
K key13,
|
||
V value13,
|
||
K key14,
|
||
V value14,
|
||
K key15,
|
||
V value15,
|
||
K key16,
|
||
V value16,
|
||
K key17,
|
||
V value17,
|
||
K key18,
|
||
V value18,
|
||
K key19,
|
||
V value19,
|
||
K key20,
|
||
V value20,
|
||
K key21,
|
||
V value21,
|
||
K key22,
|
||
V value22,
|
||
K key23,
|
||
V value23,
|
||
K key24,
|
||
V value24
|
||
) {
|
||
var map = new HashMap<K, V>(28);
|
||
map.put(key, value);
|
||
map.put(key2, value2);
|
||
map.put(key3, value3);
|
||
map.put(key4, value4);
|
||
map.put(key5, value5);
|
||
map.put(key6, value6);
|
||
map.put(key7, value7);
|
||
map.put(key8, value8);
|
||
map.put(key9, value9);
|
||
map.put(key10, value10);
|
||
map.put(key11, value11);
|
||
map.put(key12, value12);
|
||
map.put(key13, value13);
|
||
map.put(key14, value14);
|
||
map.put(key15, value15);
|
||
map.put(key16, value16);
|
||
map.put(key17, value17);
|
||
map.put(key18, value18);
|
||
map.put(key19, value19);
|
||
map.put(key20, value20);
|
||
map.put(key21, value21);
|
||
map.put(key22, value22);
|
||
map.put(key23, value23);
|
||
map.put(key24, value24);
|
||
return map;
|
||
}
|
||
|
||
public static <K, V> Map<K, V> of(
|
||
K key,
|
||
V value,
|
||
K key2,
|
||
V value2,
|
||
K key3,
|
||
V value3,
|
||
K key4,
|
||
V value4,
|
||
K key5,
|
||
V value5,
|
||
K key6,
|
||
V value6,
|
||
K key7,
|
||
V value7,
|
||
K key8,
|
||
V value8,
|
||
K key9,
|
||
V value9,
|
||
K key10,
|
||
V value10,
|
||
K key11,
|
||
V value11,
|
||
K key12,
|
||
V value12,
|
||
K key13,
|
||
V value13,
|
||
K key14,
|
||
V value14,
|
||
K key15,
|
||
V value15,
|
||
K key16,
|
||
V value16,
|
||
K key17,
|
||
V value17,
|
||
K key18,
|
||
V value18,
|
||
K key19,
|
||
V value19,
|
||
K key20,
|
||
V value20,
|
||
K key21,
|
||
V value21,
|
||
K key22,
|
||
V value22,
|
||
K key23,
|
||
V value23,
|
||
K key24,
|
||
V value24,
|
||
K key25,
|
||
V value25
|
||
) {
|
||
var map = new HashMap<K, V>(29);
|
||
map.put(key, value);
|
||
map.put(key2, value2);
|
||
map.put(key3, value3);
|
||
map.put(key4, value4);
|
||
map.put(key5, value5);
|
||
map.put(key6, value6);
|
||
map.put(key7, value7);
|
||
map.put(key8, value8);
|
||
map.put(key9, value9);
|
||
map.put(key10, value10);
|
||
map.put(key11, value11);
|
||
map.put(key12, value12);
|
||
map.put(key13, value13);
|
||
map.put(key14, value14);
|
||
map.put(key15, value15);
|
||
map.put(key16, value16);
|
||
map.put(key17, value17);
|
||
map.put(key18, value18);
|
||
map.put(key19, value19);
|
||
map.put(key20, value20);
|
||
map.put(key21, value21);
|
||
map.put(key22, value22);
|
||
map.put(key23, value23);
|
||
map.put(key24, value24);
|
||
map.put(key25, value25);
|
||
return map;
|
||
}
|
||
|
||
public static <K, V> Map<K, V> of(
|
||
K key,
|
||
V value,
|
||
K key2,
|
||
V value2,
|
||
K key3,
|
||
V value3,
|
||
K key4,
|
||
V value4,
|
||
K key5,
|
||
V value5,
|
||
K key6,
|
||
V value6,
|
||
K key7,
|
||
V value7,
|
||
K key8,
|
||
V value8,
|
||
K key9,
|
||
V value9,
|
||
K key10,
|
||
V value10,
|
||
K key11,
|
||
V value11,
|
||
K key12,
|
||
V value12,
|
||
K key13,
|
||
V value13,
|
||
K key14,
|
||
V value14,
|
||
K key15,
|
||
V value15,
|
||
K key16,
|
||
V value16,
|
||
K key17,
|
||
V value17,
|
||
K key18,
|
||
V value18,
|
||
K key19,
|
||
V value19,
|
||
K key20,
|
||
V value20,
|
||
K key21,
|
||
V value21,
|
||
K key22,
|
||
V value22,
|
||
K key23,
|
||
V value23,
|
||
K key24,
|
||
V value24,
|
||
K key25,
|
||
V value25,
|
||
K key26,
|
||
V value26
|
||
) {
|
||
var map = new HashMap<K, V>(30);
|
||
map.put(key, value);
|
||
map.put(key2, value2);
|
||
map.put(key3, value3);
|
||
map.put(key4, value4);
|
||
map.put(key5, value5);
|
||
map.put(key6, value6);
|
||
map.put(key7, value7);
|
||
map.put(key8, value8);
|
||
map.put(key9, value9);
|
||
map.put(key10, value10);
|
||
map.put(key11, value11);
|
||
map.put(key12, value12);
|
||
map.put(key13, value13);
|
||
map.put(key14, value14);
|
||
map.put(key15, value15);
|
||
map.put(key16, value16);
|
||
map.put(key17, value17);
|
||
map.put(key18, value18);
|
||
map.put(key19, value19);
|
||
map.put(key20, value20);
|
||
map.put(key21, value21);
|
||
map.put(key22, value22);
|
||
map.put(key23, value23);
|
||
map.put(key24, value24);
|
||
map.put(key25, value25);
|
||
map.put(key26, value26);
|
||
return map;
|
||
}
|
||
|
||
public static <K, V> Map<K, V> of(
|
||
K key,
|
||
V value,
|
||
K key2,
|
||
V value2,
|
||
K key3,
|
||
V value3,
|
||
K key4,
|
||
V value4,
|
||
K key5,
|
||
V value5,
|
||
K key6,
|
||
V value6,
|
||
K key7,
|
||
V value7,
|
||
K key8,
|
||
V value8,
|
||
K key9,
|
||
V value9,
|
||
K key10,
|
||
V value10,
|
||
K key11,
|
||
V value11,
|
||
K key12,
|
||
V value12,
|
||
K key13,
|
||
V value13,
|
||
K key14,
|
||
V value14,
|
||
K key15,
|
||
V value15,
|
||
K key16,
|
||
V value16,
|
||
K key17,
|
||
V value17,
|
||
K key18,
|
||
V value18,
|
||
K key19,
|
||
V value19,
|
||
K key20,
|
||
V value20,
|
||
K key21,
|
||
V value21,
|
||
K key22,
|
||
V value22,
|
||
K key23,
|
||
V value23,
|
||
K key24,
|
||
V value24,
|
||
K key25,
|
||
V value25,
|
||
K key26,
|
||
V value26,
|
||
K key27,
|
||
V value27
|
||
) {
|
||
var map = new HashMap<K, V>(31);
|
||
map.put(key, value);
|
||
map.put(key2, value2);
|
||
map.put(key3, value3);
|
||
map.put(key4, value4);
|
||
map.put(key5, value5);
|
||
map.put(key6, value6);
|
||
map.put(key7, value7);
|
||
map.put(key8, value8);
|
||
map.put(key9, value9);
|
||
map.put(key10, value10);
|
||
map.put(key11, value11);
|
||
map.put(key12, value12);
|
||
map.put(key13, value13);
|
||
map.put(key14, value14);
|
||
map.put(key15, value15);
|
||
map.put(key16, value16);
|
||
map.put(key17, value17);
|
||
map.put(key18, value18);
|
||
map.put(key19, value19);
|
||
map.put(key20, value20);
|
||
map.put(key21, value21);
|
||
map.put(key22, value22);
|
||
map.put(key23, value23);
|
||
map.put(key24, value24);
|
||
map.put(key25, value25);
|
||
map.put(key26, value26);
|
||
map.put(key27, value27);
|
||
return map;
|
||
}
|
||
|
||
public static <K, V> Map<K, V> of(
|
||
K key,
|
||
V value,
|
||
K key2,
|
||
V value2,
|
||
K key3,
|
||
V value3,
|
||
K key4,
|
||
V value4,
|
||
K key5,
|
||
V value5,
|
||
K key6,
|
||
V value6,
|
||
K key7,
|
||
V value7,
|
||
K key8,
|
||
V value8,
|
||
K key9,
|
||
V value9,
|
||
K key10,
|
||
V value10,
|
||
K key11,
|
||
V value11,
|
||
K key12,
|
||
V value12,
|
||
K key13,
|
||
V value13,
|
||
K key14,
|
||
V value14,
|
||
K key15,
|
||
V value15,
|
||
K key16,
|
||
V value16,
|
||
K key17,
|
||
V value17,
|
||
K key18,
|
||
V value18,
|
||
K key19,
|
||
V value19,
|
||
K key20,
|
||
V value20,
|
||
K key21,
|
||
V value21,
|
||
K key22,
|
||
V value22,
|
||
K key23,
|
||
V value23,
|
||
K key24,
|
||
V value24,
|
||
K key25,
|
||
V value25,
|
||
K key26,
|
||
V value26,
|
||
K key27,
|
||
V value27,
|
||
K key28,
|
||
V value28
|
||
) {
|
||
var map = new HashMap<K, V>(32);
|
||
map.put(key, value);
|
||
map.put(key2, value2);
|
||
map.put(key3, value3);
|
||
map.put(key4, value4);
|
||
map.put(key5, value5);
|
||
map.put(key6, value6);
|
||
map.put(key7, value7);
|
||
map.put(key8, value8);
|
||
map.put(key9, value9);
|
||
map.put(key10, value10);
|
||
map.put(key11, value11);
|
||
map.put(key12, value12);
|
||
map.put(key13, value13);
|
||
map.put(key14, value14);
|
||
map.put(key15, value15);
|
||
map.put(key16, value16);
|
||
map.put(key17, value17);
|
||
map.put(key18, value18);
|
||
map.put(key19, value19);
|
||
map.put(key20, value20);
|
||
map.put(key21, value21);
|
||
map.put(key22, value22);
|
||
map.put(key23, value23);
|
||
map.put(key24, value24);
|
||
map.put(key25, value25);
|
||
map.put(key26, value26);
|
||
map.put(key27, value27);
|
||
map.put(key28, value28);
|
||
return map;
|
||
}
|
||
|
||
public static <K, V> Map<K, V> of(
|
||
K key,
|
||
V value,
|
||
K key2,
|
||
V value2,
|
||
K key3,
|
||
V value3,
|
||
K key4,
|
||
V value4,
|
||
K key5,
|
||
V value5,
|
||
K key6,
|
||
V value6,
|
||
K key7,
|
||
V value7,
|
||
K key8,
|
||
V value8,
|
||
K key9,
|
||
V value9,
|
||
K key10,
|
||
V value10,
|
||
K key11,
|
||
V value11,
|
||
K key12,
|
||
V value12,
|
||
K key13,
|
||
V value13,
|
||
K key14,
|
||
V value14,
|
||
K key15,
|
||
V value15,
|
||
K key16,
|
||
V value16,
|
||
K key17,
|
||
V value17,
|
||
K key18,
|
||
V value18,
|
||
K key19,
|
||
V value19,
|
||
K key20,
|
||
V value20,
|
||
K key21,
|
||
V value21,
|
||
K key22,
|
||
V value22,
|
||
K key23,
|
||
V value23,
|
||
K key24,
|
||
V value24,
|
||
K key25,
|
||
V value25,
|
||
K key26,
|
||
V value26,
|
||
K key27,
|
||
V value27,
|
||
K key28,
|
||
V value28,
|
||
K key29,
|
||
V value29
|
||
) {
|
||
var map = new HashMap<K, V>(33);
|
||
map.put(key, value);
|
||
map.put(key2, value2);
|
||
map.put(key3, value3);
|
||
map.put(key4, value4);
|
||
map.put(key5, value5);
|
||
map.put(key6, value6);
|
||
map.put(key7, value7);
|
||
map.put(key8, value8);
|
||
map.put(key9, value9);
|
||
map.put(key10, value10);
|
||
map.put(key11, value11);
|
||
map.put(key12, value12);
|
||
map.put(key13, value13);
|
||
map.put(key14, value14);
|
||
map.put(key15, value15);
|
||
map.put(key16, value16);
|
||
map.put(key17, value17);
|
||
map.put(key18, value18);
|
||
map.put(key19, value19);
|
||
map.put(key20, value20);
|
||
map.put(key21, value21);
|
||
map.put(key22, value22);
|
||
map.put(key23, value23);
|
||
map.put(key24, value24);
|
||
map.put(key25, value25);
|
||
map.put(key26, value26);
|
||
map.put(key27, value27);
|
||
map.put(key28, value28);
|
||
map.put(key29, value29);
|
||
return map;
|
||
}
|
||
|
||
public static <K, V> Map<K, V> of(
|
||
K key,
|
||
V value,
|
||
K key2,
|
||
V value2,
|
||
K key3,
|
||
V value3,
|
||
K key4,
|
||
V value4,
|
||
K key5,
|
||
V value5,
|
||
K key6,
|
||
V value6,
|
||
K key7,
|
||
V value7,
|
||
K key8,
|
||
V value8,
|
||
K key9,
|
||
V value9,
|
||
K key10,
|
||
V value10,
|
||
K key11,
|
||
V value11,
|
||
K key12,
|
||
V value12,
|
||
K key13,
|
||
V value13,
|
||
K key14,
|
||
V value14,
|
||
K key15,
|
||
V value15,
|
||
K key16,
|
||
V value16,
|
||
K key17,
|
||
V value17,
|
||
K key18,
|
||
V value18,
|
||
K key19,
|
||
V value19,
|
||
K key20,
|
||
V value20,
|
||
K key21,
|
||
V value21,
|
||
K key22,
|
||
V value22,
|
||
K key23,
|
||
V value23,
|
||
K key24,
|
||
V value24,
|
||
K key25,
|
||
V value25,
|
||
K key26,
|
||
V value26,
|
||
K key27,
|
||
V value27,
|
||
K key28,
|
||
V value28,
|
||
K key29,
|
||
V value29,
|
||
K key30,
|
||
V value30
|
||
) {
|
||
var map = new HashMap<K, V>(34);
|
||
map.put(key, value);
|
||
map.put(key2, value2);
|
||
map.put(key3, value3);
|
||
map.put(key4, value4);
|
||
map.put(key5, value5);
|
||
map.put(key6, value6);
|
||
map.put(key7, value7);
|
||
map.put(key8, value8);
|
||
map.put(key9, value9);
|
||
map.put(key10, value10);
|
||
map.put(key11, value11);
|
||
map.put(key12, value12);
|
||
map.put(key13, value13);
|
||
map.put(key14, value14);
|
||
map.put(key15, value15);
|
||
map.put(key16, value16);
|
||
map.put(key17, value17);
|
||
map.put(key18, value18);
|
||
map.put(key19, value19);
|
||
map.put(key20, value20);
|
||
map.put(key21, value21);
|
||
map.put(key22, value22);
|
||
map.put(key23, value23);
|
||
map.put(key24, value24);
|
||
map.put(key25, value25);
|
||
map.put(key26, value26);
|
||
map.put(key27, value27);
|
||
map.put(key28, value28);
|
||
map.put(key29, value29);
|
||
map.put(key30, value30);
|
||
return map;
|
||
}
|
||
|
||
public static <K, V> Map<K, V> of(
|
||
K key,
|
||
V value,
|
||
K key2,
|
||
V value2,
|
||
K key3,
|
||
V value3,
|
||
K key4,
|
||
V value4,
|
||
K key5,
|
||
V value5,
|
||
K key6,
|
||
V value6,
|
||
K key7,
|
||
V value7,
|
||
K key8,
|
||
V value8,
|
||
K key9,
|
||
V value9,
|
||
K key10,
|
||
V value10,
|
||
K key11,
|
||
V value11,
|
||
K key12,
|
||
V value12,
|
||
K key13,
|
||
V value13,
|
||
K key14,
|
||
V value14,
|
||
K key15,
|
||
V value15,
|
||
K key16,
|
||
V value16,
|
||
K key17,
|
||
V value17,
|
||
K key18,
|
||
V value18,
|
||
K key19,
|
||
V value19,
|
||
K key20,
|
||
V value20,
|
||
K key21,
|
||
V value21,
|
||
K key22,
|
||
V value22,
|
||
K key23,
|
||
V value23,
|
||
K key24,
|
||
V value24,
|
||
K key25,
|
||
V value25,
|
||
K key26,
|
||
V value26,
|
||
K key27,
|
||
V value27,
|
||
K key28,
|
||
V value28,
|
||
K key29,
|
||
V value29,
|
||
K key30,
|
||
V value30,
|
||
K key31,
|
||
V value31
|
||
) {
|
||
var map = new HashMap<K, V>(35);
|
||
map.put(key, value);
|
||
map.put(key2, value2);
|
||
map.put(key3, value3);
|
||
map.put(key4, value4);
|
||
map.put(key5, value5);
|
||
map.put(key6, value6);
|
||
map.put(key7, value7);
|
||
map.put(key8, value8);
|
||
map.put(key9, value9);
|
||
map.put(key10, value10);
|
||
map.put(key11, value11);
|
||
map.put(key12, value12);
|
||
map.put(key13, value13);
|
||
map.put(key14, value14);
|
||
map.put(key15, value15);
|
||
map.put(key16, value16);
|
||
map.put(key17, value17);
|
||
map.put(key18, value18);
|
||
map.put(key19, value19);
|
||
map.put(key20, value20);
|
||
map.put(key21, value21);
|
||
map.put(key22, value22);
|
||
map.put(key23, value23);
|
||
map.put(key24, value24);
|
||
map.put(key25, value25);
|
||
map.put(key26, value26);
|
||
map.put(key27, value27);
|
||
map.put(key28, value28);
|
||
map.put(key29, value29);
|
||
map.put(key30, value30);
|
||
map.put(key31, value31);
|
||
return map;
|
||
}
|
||
|
||
public static <K, V> Map<K, V> of(
|
||
K key,
|
||
V value,
|
||
K key2,
|
||
V value2,
|
||
K key3,
|
||
V value3,
|
||
K key4,
|
||
V value4,
|
||
K key5,
|
||
V value5,
|
||
K key6,
|
||
V value6,
|
||
K key7,
|
||
V value7,
|
||
K key8,
|
||
V value8,
|
||
K key9,
|
||
V value9,
|
||
K key10,
|
||
V value10,
|
||
K key11,
|
||
V value11,
|
||
K key12,
|
||
V value12,
|
||
K key13,
|
||
V value13,
|
||
K key14,
|
||
V value14,
|
||
K key15,
|
||
V value15,
|
||
K key16,
|
||
V value16,
|
||
K key17,
|
||
V value17,
|
||
K key18,
|
||
V value18,
|
||
K key19,
|
||
V value19,
|
||
K key20,
|
||
V value20,
|
||
K key21,
|
||
V value21,
|
||
K key22,
|
||
V value22,
|
||
K key23,
|
||
V value23,
|
||
K key24,
|
||
V value24,
|
||
K key25,
|
||
V value25,
|
||
K key26,
|
||
V value26,
|
||
K key27,
|
||
V value27,
|
||
K key28,
|
||
V value28,
|
||
K key29,
|
||
V value29,
|
||
K key30,
|
||
V value30,
|
||
K key31,
|
||
V value31,
|
||
K key32,
|
||
V value32
|
||
) {
|
||
var map = new HashMap<K, V>(36);
|
||
map.put(key, value);
|
||
map.put(key2, value2);
|
||
map.put(key3, value3);
|
||
map.put(key4, value4);
|
||
map.put(key5, value5);
|
||
map.put(key6, value6);
|
||
map.put(key7, value7);
|
||
map.put(key8, value8);
|
||
map.put(key9, value9);
|
||
map.put(key10, value10);
|
||
map.put(key11, value11);
|
||
map.put(key12, value12);
|
||
map.put(key13, value13);
|
||
map.put(key14, value14);
|
||
map.put(key15, value15);
|
||
map.put(key16, value16);
|
||
map.put(key17, value17);
|
||
map.put(key18, value18);
|
||
map.put(key19, value19);
|
||
map.put(key20, value20);
|
||
map.put(key21, value21);
|
||
map.put(key22, value22);
|
||
map.put(key23, value23);
|
||
map.put(key24, value24);
|
||
map.put(key25, value25);
|
||
map.put(key26, value26);
|
||
map.put(key27, value27);
|
||
map.put(key28, value28);
|
||
map.put(key29, value29);
|
||
map.put(key30, value30);
|
||
map.put(key31, value31);
|
||
map.put(key32, value32);
|
||
return map;
|
||
}
|
||
|
||
public static <K, V> Map<K, V> of(
|
||
K key,
|
||
V value,
|
||
K key2,
|
||
V value2,
|
||
K key3,
|
||
V value3,
|
||
K key4,
|
||
V value4,
|
||
K key5,
|
||
V value5,
|
||
K key6,
|
||
V value6,
|
||
K key7,
|
||
V value7,
|
||
K key8,
|
||
V value8,
|
||
K key9,
|
||
V value9,
|
||
K key10,
|
||
V value10,
|
||
K key11,
|
||
V value11,
|
||
K key12,
|
||
V value12,
|
||
K key13,
|
||
V value13,
|
||
K key14,
|
||
V value14,
|
||
K key15,
|
||
V value15,
|
||
K key16,
|
||
V value16,
|
||
K key17,
|
||
V value17,
|
||
K key18,
|
||
V value18,
|
||
K key19,
|
||
V value19,
|
||
K key20,
|
||
V value20,
|
||
K key21,
|
||
V value21,
|
||
K key22,
|
||
V value22,
|
||
K key23,
|
||
V value23,
|
||
K key24,
|
||
V value24,
|
||
K key25,
|
||
V value25,
|
||
K key26,
|
||
V value26,
|
||
K key27,
|
||
V value27,
|
||
K key28,
|
||
V value28,
|
||
K key29,
|
||
V value29,
|
||
K key30,
|
||
V value30,
|
||
K key31,
|
||
V value31,
|
||
K key32,
|
||
V value32,
|
||
K key33,
|
||
V value33
|
||
) {
|
||
var map = new HashMap<K, V>(37);
|
||
map.put(key, value);
|
||
map.put(key2, value2);
|
||
map.put(key3, value3);
|
||
map.put(key4, value4);
|
||
map.put(key5, value5);
|
||
map.put(key6, value6);
|
||
map.put(key7, value7);
|
||
map.put(key8, value8);
|
||
map.put(key9, value9);
|
||
map.put(key10, value10);
|
||
map.put(key11, value11);
|
||
map.put(key12, value12);
|
||
map.put(key13, value13);
|
||
map.put(key14, value14);
|
||
map.put(key15, value15);
|
||
map.put(key16, value16);
|
||
map.put(key17, value17);
|
||
map.put(key18, value18);
|
||
map.put(key19, value19);
|
||
map.put(key20, value20);
|
||
map.put(key21, value21);
|
||
map.put(key22, value22);
|
||
map.put(key23, value23);
|
||
map.put(key24, value24);
|
||
map.put(key25, value25);
|
||
map.put(key26, value26);
|
||
map.put(key27, value27);
|
||
map.put(key28, value28);
|
||
map.put(key29, value29);
|
||
map.put(key30, value30);
|
||
map.put(key31, value31);
|
||
map.put(key32, value32);
|
||
map.put(key33, value33);
|
||
return map;
|
||
}
|
||
|
||
public static <K, V> Map<K, V> of(
|
||
K key,
|
||
V value,
|
||
K key2,
|
||
V value2,
|
||
K key3,
|
||
V value3,
|
||
K key4,
|
||
V value4,
|
||
K key5,
|
||
V value5,
|
||
K key6,
|
||
V value6,
|
||
K key7,
|
||
V value7,
|
||
K key8,
|
||
V value8,
|
||
K key9,
|
||
V value9,
|
||
K key10,
|
||
V value10,
|
||
K key11,
|
||
V value11,
|
||
K key12,
|
||
V value12,
|
||
K key13,
|
||
V value13,
|
||
K key14,
|
||
V value14,
|
||
K key15,
|
||
V value15,
|
||
K key16,
|
||
V value16,
|
||
K key17,
|
||
V value17,
|
||
K key18,
|
||
V value18,
|
||
K key19,
|
||
V value19,
|
||
K key20,
|
||
V value20,
|
||
K key21,
|
||
V value21,
|
||
K key22,
|
||
V value22,
|
||
K key23,
|
||
V value23,
|
||
K key24,
|
||
V value24,
|
||
K key25,
|
||
V value25,
|
||
K key26,
|
||
V value26,
|
||
K key27,
|
||
V value27,
|
||
K key28,
|
||
V value28,
|
||
K key29,
|
||
V value29,
|
||
K key30,
|
||
V value30,
|
||
K key31,
|
||
V value31,
|
||
K key32,
|
||
V value32,
|
||
K key33,
|
||
V value33,
|
||
K key34,
|
||
V value34
|
||
) {
|
||
var map = new HashMap<K, V>(38);
|
||
map.put(key, value);
|
||
map.put(key2, value2);
|
||
map.put(key3, value3);
|
||
map.put(key4, value4);
|
||
map.put(key5, value5);
|
||
map.put(key6, value6);
|
||
map.put(key7, value7);
|
||
map.put(key8, value8);
|
||
map.put(key9, value9);
|
||
map.put(key10, value10);
|
||
map.put(key11, value11);
|
||
map.put(key12, value12);
|
||
map.put(key13, value13);
|
||
map.put(key14, value14);
|
||
map.put(key15, value15);
|
||
map.put(key16, value16);
|
||
map.put(key17, value17);
|
||
map.put(key18, value18);
|
||
map.put(key19, value19);
|
||
map.put(key20, value20);
|
||
map.put(key21, value21);
|
||
map.put(key22, value22);
|
||
map.put(key23, value23);
|
||
map.put(key24, value24);
|
||
map.put(key25, value25);
|
||
map.put(key26, value26);
|
||
map.put(key27, value27);
|
||
map.put(key28, value28);
|
||
map.put(key29, value29);
|
||
map.put(key30, value30);
|
||
map.put(key31, value31);
|
||
map.put(key32, value32);
|
||
map.put(key33, value33);
|
||
map.put(key34, value34);
|
||
return map;
|
||
}
|
||
|
||
public static <K, V> Map<K, V> of(
|
||
K key,
|
||
V value,
|
||
K key2,
|
||
V value2,
|
||
K key3,
|
||
V value3,
|
||
K key4,
|
||
V value4,
|
||
K key5,
|
||
V value5,
|
||
K key6,
|
||
V value6,
|
||
K key7,
|
||
V value7,
|
||
K key8,
|
||
V value8,
|
||
K key9,
|
||
V value9,
|
||
K key10,
|
||
V value10,
|
||
K key11,
|
||
V value11,
|
||
K key12,
|
||
V value12,
|
||
K key13,
|
||
V value13,
|
||
K key14,
|
||
V value14,
|
||
K key15,
|
||
V value15,
|
||
K key16,
|
||
V value16,
|
||
K key17,
|
||
V value17,
|
||
K key18,
|
||
V value18,
|
||
K key19,
|
||
V value19,
|
||
K key20,
|
||
V value20,
|
||
K key21,
|
||
V value21,
|
||
K key22,
|
||
V value22,
|
||
K key23,
|
||
V value23,
|
||
K key24,
|
||
V value24,
|
||
K key25,
|
||
V value25,
|
||
K key26,
|
||
V value26,
|
||
K key27,
|
||
V value27,
|
||
K key28,
|
||
V value28,
|
||
K key29,
|
||
V value29,
|
||
K key30,
|
||
V value30,
|
||
K key31,
|
||
V value31,
|
||
K key32,
|
||
V value32,
|
||
K key33,
|
||
V value33,
|
||
K key34,
|
||
V value34,
|
||
K key35,
|
||
V value35
|
||
) {
|
||
var map = new HashMap<K, V>(39);
|
||
map.put(key, value);
|
||
map.put(key2, value2);
|
||
map.put(key3, value3);
|
||
map.put(key4, value4);
|
||
map.put(key5, value5);
|
||
map.put(key6, value6);
|
||
map.put(key7, value7);
|
||
map.put(key8, value8);
|
||
map.put(key9, value9);
|
||
map.put(key10, value10);
|
||
map.put(key11, value11);
|
||
map.put(key12, value12);
|
||
map.put(key13, value13);
|
||
map.put(key14, value14);
|
||
map.put(key15, value15);
|
||
map.put(key16, value16);
|
||
map.put(key17, value17);
|
||
map.put(key18, value18);
|
||
map.put(key19, value19);
|
||
map.put(key20, value20);
|
||
map.put(key21, value21);
|
||
map.put(key22, value22);
|
||
map.put(key23, value23);
|
||
map.put(key24, value24);
|
||
map.put(key25, value25);
|
||
map.put(key26, value26);
|
||
map.put(key27, value27);
|
||
map.put(key28, value28);
|
||
map.put(key29, value29);
|
||
map.put(key30, value30);
|
||
map.put(key31, value31);
|
||
map.put(key32, value32);
|
||
map.put(key33, value33);
|
||
map.put(key34, value34);
|
||
map.put(key35, value35);
|
||
return map;
|
||
}
|
||
|
||
public static <K, V> Map<K, V> of(
|
||
K key,
|
||
V value,
|
||
K key2,
|
||
V value2,
|
||
K key3,
|
||
V value3,
|
||
K key4,
|
||
V value4,
|
||
K key5,
|
||
V value5,
|
||
K key6,
|
||
V value6,
|
||
K key7,
|
||
V value7,
|
||
K key8,
|
||
V value8,
|
||
K key9,
|
||
V value9,
|
||
K key10,
|
||
V value10,
|
||
K key11,
|
||
V value11,
|
||
K key12,
|
||
V value12,
|
||
K key13,
|
||
V value13,
|
||
K key14,
|
||
V value14,
|
||
K key15,
|
||
V value15,
|
||
K key16,
|
||
V value16,
|
||
K key17,
|
||
V value17,
|
||
K key18,
|
||
V value18,
|
||
K key19,
|
||
V value19,
|
||
K key20,
|
||
V value20,
|
||
K key21,
|
||
V value21,
|
||
K key22,
|
||
V value22,
|
||
K key23,
|
||
V value23,
|
||
K key24,
|
||
V value24,
|
||
K key25,
|
||
V value25,
|
||
K key26,
|
||
V value26,
|
||
K key27,
|
||
V value27,
|
||
K key28,
|
||
V value28,
|
||
K key29,
|
||
V value29,
|
||
K key30,
|
||
V value30,
|
||
K key31,
|
||
V value31,
|
||
K key32,
|
||
V value32,
|
||
K key33,
|
||
V value33,
|
||
K key34,
|
||
V value34,
|
||
K key35,
|
||
V value35,
|
||
K key36,
|
||
V value36
|
||
) {
|
||
var map = new HashMap<K, V>(40);
|
||
map.put(key, value);
|
||
map.put(key2, value2);
|
||
map.put(key3, value3);
|
||
map.put(key4, value4);
|
||
map.put(key5, value5);
|
||
map.put(key6, value6);
|
||
map.put(key7, value7);
|
||
map.put(key8, value8);
|
||
map.put(key9, value9);
|
||
map.put(key10, value10);
|
||
map.put(key11, value11);
|
||
map.put(key12, value12);
|
||
map.put(key13, value13);
|
||
map.put(key14, value14);
|
||
map.put(key15, value15);
|
||
map.put(key16, value16);
|
||
map.put(key17, value17);
|
||
map.put(key18, value18);
|
||
map.put(key19, value19);
|
||
map.put(key20, value20);
|
||
map.put(key21, value21);
|
||
map.put(key22, value22);
|
||
map.put(key23, value23);
|
||
map.put(key24, value24);
|
||
map.put(key25, value25);
|
||
map.put(key26, value26);
|
||
map.put(key27, value27);
|
||
map.put(key28, value28);
|
||
map.put(key29, value29);
|
||
map.put(key30, value30);
|
||
map.put(key31, value31);
|
||
map.put(key32, value32);
|
||
map.put(key33, value33);
|
||
map.put(key34, value34);
|
||
map.put(key35, value35);
|
||
map.put(key36, value36);
|
||
return map;
|
||
}
|
||
|
||
public static <K, V> Map<K, V> of(
|
||
K key,
|
||
V value,
|
||
K key2,
|
||
V value2,
|
||
K key3,
|
||
V value3,
|
||
K key4,
|
||
V value4,
|
||
K key5,
|
||
V value5,
|
||
K key6,
|
||
V value6,
|
||
K key7,
|
||
V value7,
|
||
K key8,
|
||
V value8,
|
||
K key9,
|
||
V value9,
|
||
K key10,
|
||
V value10,
|
||
K key11,
|
||
V value11,
|
||
K key12,
|
||
V value12,
|
||
K key13,
|
||
V value13,
|
||
K key14,
|
||
V value14,
|
||
K key15,
|
||
V value15,
|
||
K key16,
|
||
V value16,
|
||
K key17,
|
||
V value17,
|
||
K key18,
|
||
V value18,
|
||
K key19,
|
||
V value19,
|
||
K key20,
|
||
V value20,
|
||
K key21,
|
||
V value21,
|
||
K key22,
|
||
V value22,
|
||
K key23,
|
||
V value23,
|
||
K key24,
|
||
V value24,
|
||
K key25,
|
||
V value25,
|
||
K key26,
|
||
V value26,
|
||
K key27,
|
||
V value27,
|
||
K key28,
|
||
V value28,
|
||
K key29,
|
||
V value29,
|
||
K key30,
|
||
V value30,
|
||
K key31,
|
||
V value31,
|
||
K key32,
|
||
V value32,
|
||
K key33,
|
||
V value33,
|
||
K key34,
|
||
V value34,
|
||
K key35,
|
||
V value35,
|
||
K key36,
|
||
V value36,
|
||
K key37,
|
||
V value37
|
||
) {
|
||
var map = new HashMap<K, V>(41);
|
||
map.put(key, value);
|
||
map.put(key2, value2);
|
||
map.put(key3, value3);
|
||
map.put(key4, value4);
|
||
map.put(key5, value5);
|
||
map.put(key6, value6);
|
||
map.put(key7, value7);
|
||
map.put(key8, value8);
|
||
map.put(key9, value9);
|
||
map.put(key10, value10);
|
||
map.put(key11, value11);
|
||
map.put(key12, value12);
|
||
map.put(key13, value13);
|
||
map.put(key14, value14);
|
||
map.put(key15, value15);
|
||
map.put(key16, value16);
|
||
map.put(key17, value17);
|
||
map.put(key18, value18);
|
||
map.put(key19, value19);
|
||
map.put(key20, value20);
|
||
map.put(key21, value21);
|
||
map.put(key22, value22);
|
||
map.put(key23, value23);
|
||
map.put(key24, value24);
|
||
map.put(key25, value25);
|
||
map.put(key26, value26);
|
||
map.put(key27, value27);
|
||
map.put(key28, value28);
|
||
map.put(key29, value29);
|
||
map.put(key30, value30);
|
||
map.put(key31, value31);
|
||
map.put(key32, value32);
|
||
map.put(key33, value33);
|
||
map.put(key34, value34);
|
||
map.put(key35, value35);
|
||
map.put(key36, value36);
|
||
map.put(key37, value37);
|
||
return map;
|
||
}
|
||
|
||
public static <K, V> Map<K, V> of(
|
||
K key,
|
||
V value,
|
||
K key2,
|
||
V value2,
|
||
K key3,
|
||
V value3,
|
||
K key4,
|
||
V value4,
|
||
K key5,
|
||
V value5,
|
||
K key6,
|
||
V value6,
|
||
K key7,
|
||
V value7,
|
||
K key8,
|
||
V value8,
|
||
K key9,
|
||
V value9,
|
||
K key10,
|
||
V value10,
|
||
K key11,
|
||
V value11,
|
||
K key12,
|
||
V value12,
|
||
K key13,
|
||
V value13,
|
||
K key14,
|
||
V value14,
|
||
K key15,
|
||
V value15,
|
||
K key16,
|
||
V value16,
|
||
K key17,
|
||
V value17,
|
||
K key18,
|
||
V value18,
|
||
K key19,
|
||
V value19,
|
||
K key20,
|
||
V value20,
|
||
K key21,
|
||
V value21,
|
||
K key22,
|
||
V value22,
|
||
K key23,
|
||
V value23,
|
||
K key24,
|
||
V value24,
|
||
K key25,
|
||
V value25,
|
||
K key26,
|
||
V value26,
|
||
K key27,
|
||
V value27,
|
||
K key28,
|
||
V value28,
|
||
K key29,
|
||
V value29,
|
||
K key30,
|
||
V value30,
|
||
K key31,
|
||
V value31,
|
||
K key32,
|
||
V value32,
|
||
K key33,
|
||
V value33,
|
||
K key34,
|
||
V value34,
|
||
K key35,
|
||
V value35,
|
||
K key36,
|
||
V value36,
|
||
K key37,
|
||
V value37,
|
||
K key38,
|
||
V value38
|
||
) {
|
||
var map = new HashMap<K, V>(42);
|
||
map.put(key, value);
|
||
map.put(key2, value2);
|
||
map.put(key3, value3);
|
||
map.put(key4, value4);
|
||
map.put(key5, value5);
|
||
map.put(key6, value6);
|
||
map.put(key7, value7);
|
||
map.put(key8, value8);
|
||
map.put(key9, value9);
|
||
map.put(key10, value10);
|
||
map.put(key11, value11);
|
||
map.put(key12, value12);
|
||
map.put(key13, value13);
|
||
map.put(key14, value14);
|
||
map.put(key15, value15);
|
||
map.put(key16, value16);
|
||
map.put(key17, value17);
|
||
map.put(key18, value18);
|
||
map.put(key19, value19);
|
||
map.put(key20, value20);
|
||
map.put(key21, value21);
|
||
map.put(key22, value22);
|
||
map.put(key23, value23);
|
||
map.put(key24, value24);
|
||
map.put(key25, value25);
|
||
map.put(key26, value26);
|
||
map.put(key27, value27);
|
||
map.put(key28, value28);
|
||
map.put(key29, value29);
|
||
map.put(key30, value30);
|
||
map.put(key31, value31);
|
||
map.put(key32, value32);
|
||
map.put(key33, value33);
|
||
map.put(key34, value34);
|
||
map.put(key35, value35);
|
||
map.put(key36, value36);
|
||
map.put(key37, value37);
|
||
map.put(key38, value38);
|
||
return map;
|
||
}
|
||
|
||
public static <K, V> Map<K, V> of(
|
||
K key,
|
||
V value,
|
||
K key2,
|
||
V value2,
|
||
K key3,
|
||
V value3,
|
||
K key4,
|
||
V value4,
|
||
K key5,
|
||
V value5,
|
||
K key6,
|
||
V value6,
|
||
K key7,
|
||
V value7,
|
||
K key8,
|
||
V value8,
|
||
K key9,
|
||
V value9,
|
||
K key10,
|
||
V value10,
|
||
K key11,
|
||
V value11,
|
||
K key12,
|
||
V value12,
|
||
K key13,
|
||
V value13,
|
||
K key14,
|
||
V value14,
|
||
K key15,
|
||
V value15,
|
||
K key16,
|
||
V value16,
|
||
K key17,
|
||
V value17,
|
||
K key18,
|
||
V value18,
|
||
K key19,
|
||
V value19,
|
||
K key20,
|
||
V value20,
|
||
K key21,
|
||
V value21,
|
||
K key22,
|
||
V value22,
|
||
K key23,
|
||
V value23,
|
||
K key24,
|
||
V value24,
|
||
K key25,
|
||
V value25,
|
||
K key26,
|
||
V value26,
|
||
K key27,
|
||
V value27,
|
||
K key28,
|
||
V value28,
|
||
K key29,
|
||
V value29,
|
||
K key30,
|
||
V value30,
|
||
K key31,
|
||
V value31,
|
||
K key32,
|
||
V value32,
|
||
K key33,
|
||
V value33,
|
||
K key34,
|
||
V value34,
|
||
K key35,
|
||
V value35,
|
||
K key36,
|
||
V value36,
|
||
K key37,
|
||
V value37,
|
||
K key38,
|
||
V value38,
|
||
K key39,
|
||
V value39
|
||
) {
|
||
var map = new HashMap<K, V>(43);
|
||
map.put(key, value);
|
||
map.put(key2, value2);
|
||
map.put(key3, value3);
|
||
map.put(key4, value4);
|
||
map.put(key5, value5);
|
||
map.put(key6, value6);
|
||
map.put(key7, value7);
|
||
map.put(key8, value8);
|
||
map.put(key9, value9);
|
||
map.put(key10, value10);
|
||
map.put(key11, value11);
|
||
map.put(key12, value12);
|
||
map.put(key13, value13);
|
||
map.put(key14, value14);
|
||
map.put(key15, value15);
|
||
map.put(key16, value16);
|
||
map.put(key17, value17);
|
||
map.put(key18, value18);
|
||
map.put(key19, value19);
|
||
map.put(key20, value20);
|
||
map.put(key21, value21);
|
||
map.put(key22, value22);
|
||
map.put(key23, value23);
|
||
map.put(key24, value24);
|
||
map.put(key25, value25);
|
||
map.put(key26, value26);
|
||
map.put(key27, value27);
|
||
map.put(key28, value28);
|
||
map.put(key29, value29);
|
||
map.put(key30, value30);
|
||
map.put(key31, value31);
|
||
map.put(key32, value32);
|
||
map.put(key33, value33);
|
||
map.put(key34, value34);
|
||
map.put(key35, value35);
|
||
map.put(key36, value36);
|
||
map.put(key37, value37);
|
||
map.put(key38, value38);
|
||
map.put(key39, value39);
|
||
return map;
|
||
}
|
||
|
||
public static <K, V> Map<K, V> of(
|
||
K key,
|
||
V value,
|
||
K key2,
|
||
V value2,
|
||
K key3,
|
||
V value3,
|
||
K key4,
|
||
V value4,
|
||
K key5,
|
||
V value5,
|
||
K key6,
|
||
V value6,
|
||
K key7,
|
||
V value7,
|
||
K key8,
|
||
V value8,
|
||
K key9,
|
||
V value9,
|
||
K key10,
|
||
V value10,
|
||
K key11,
|
||
V value11,
|
||
K key12,
|
||
V value12,
|
||
K key13,
|
||
V value13,
|
||
K key14,
|
||
V value14,
|
||
K key15,
|
||
V value15,
|
||
K key16,
|
||
V value16,
|
||
K key17,
|
||
V value17,
|
||
K key18,
|
||
V value18,
|
||
K key19,
|
||
V value19,
|
||
K key20,
|
||
V value20,
|
||
K key21,
|
||
V value21,
|
||
K key22,
|
||
V value22,
|
||
K key23,
|
||
V value23,
|
||
K key24,
|
||
V value24,
|
||
K key25,
|
||
V value25,
|
||
K key26,
|
||
V value26,
|
||
K key27,
|
||
V value27,
|
||
K key28,
|
||
V value28,
|
||
K key29,
|
||
V value29,
|
||
K key30,
|
||
V value30,
|
||
K key31,
|
||
V value31,
|
||
K key32,
|
||
V value32,
|
||
K key33,
|
||
V value33,
|
||
K key34,
|
||
V value34,
|
||
K key35,
|
||
V value35,
|
||
K key36,
|
||
V value36,
|
||
K key37,
|
||
V value37,
|
||
K key38,
|
||
V value38,
|
||
K key39,
|
||
V value39,
|
||
K key40,
|
||
V value40
|
||
) {
|
||
var map = new HashMap<K, V>(44);
|
||
map.put(key, value);
|
||
map.put(key2, value2);
|
||
map.put(key3, value3);
|
||
map.put(key4, value4);
|
||
map.put(key5, value5);
|
||
map.put(key6, value6);
|
||
map.put(key7, value7);
|
||
map.put(key8, value8);
|
||
map.put(key9, value9);
|
||
map.put(key10, value10);
|
||
map.put(key11, value11);
|
||
map.put(key12, value12);
|
||
map.put(key13, value13);
|
||
map.put(key14, value14);
|
||
map.put(key15, value15);
|
||
map.put(key16, value16);
|
||
map.put(key17, value17);
|
||
map.put(key18, value18);
|
||
map.put(key19, value19);
|
||
map.put(key20, value20);
|
||
map.put(key21, value21);
|
||
map.put(key22, value22);
|
||
map.put(key23, value23);
|
||
map.put(key24, value24);
|
||
map.put(key25, value25);
|
||
map.put(key26, value26);
|
||
map.put(key27, value27);
|
||
map.put(key28, value28);
|
||
map.put(key29, value29);
|
||
map.put(key30, value30);
|
||
map.put(key31, value31);
|
||
map.put(key32, value32);
|
||
map.put(key33, value33);
|
||
map.put(key34, value34);
|
||
map.put(key35, value35);
|
||
map.put(key36, value36);
|
||
map.put(key37, value37);
|
||
map.put(key38, value38);
|
||
map.put(key39, value39);
|
||
map.put(key40, value40);
|
||
return map;
|
||
}
|
||
|
||
public static <K, V> Map<K, V> of(
|
||
K key,
|
||
V value,
|
||
K key2,
|
||
V value2,
|
||
K key3,
|
||
V value3,
|
||
K key4,
|
||
V value4,
|
||
K key5,
|
||
V value5,
|
||
K key6,
|
||
V value6,
|
||
K key7,
|
||
V value7,
|
||
K key8,
|
||
V value8,
|
||
K key9,
|
||
V value9,
|
||
K key10,
|
||
V value10,
|
||
K key11,
|
||
V value11,
|
||
K key12,
|
||
V value12,
|
||
K key13,
|
||
V value13,
|
||
K key14,
|
||
V value14,
|
||
K key15,
|
||
V value15,
|
||
K key16,
|
||
V value16,
|
||
K key17,
|
||
V value17,
|
||
K key18,
|
||
V value18,
|
||
K key19,
|
||
V value19,
|
||
K key20,
|
||
V value20,
|
||
K key21,
|
||
V value21,
|
||
K key22,
|
||
V value22,
|
||
K key23,
|
||
V value23,
|
||
K key24,
|
||
V value24,
|
||
K key25,
|
||
V value25,
|
||
K key26,
|
||
V value26,
|
||
K key27,
|
||
V value27,
|
||
K key28,
|
||
V value28,
|
||
K key29,
|
||
V value29,
|
||
K key30,
|
||
V value30,
|
||
K key31,
|
||
V value31,
|
||
K key32,
|
||
V value32,
|
||
K key33,
|
||
V value33,
|
||
K key34,
|
||
V value34,
|
||
K key35,
|
||
V value35,
|
||
K key36,
|
||
V value36,
|
||
K key37,
|
||
V value37,
|
||
K key38,
|
||
V value38,
|
||
K key39,
|
||
V value39,
|
||
K key40,
|
||
V value40,
|
||
K key41,
|
||
V value41
|
||
) {
|
||
var map = new HashMap<K, V>(45);
|
||
map.put(key, value);
|
||
map.put(key2, value2);
|
||
map.put(key3, value3);
|
||
map.put(key4, value4);
|
||
map.put(key5, value5);
|
||
map.put(key6, value6);
|
||
map.put(key7, value7);
|
||
map.put(key8, value8);
|
||
map.put(key9, value9);
|
||
map.put(key10, value10);
|
||
map.put(key11, value11);
|
||
map.put(key12, value12);
|
||
map.put(key13, value13);
|
||
map.put(key14, value14);
|
||
map.put(key15, value15);
|
||
map.put(key16, value16);
|
||
map.put(key17, value17);
|
||
map.put(key18, value18);
|
||
map.put(key19, value19);
|
||
map.put(key20, value20);
|
||
map.put(key21, value21);
|
||
map.put(key22, value22);
|
||
map.put(key23, value23);
|
||
map.put(key24, value24);
|
||
map.put(key25, value25);
|
||
map.put(key26, value26);
|
||
map.put(key27, value27);
|
||
map.put(key28, value28);
|
||
map.put(key29, value29);
|
||
map.put(key30, value30);
|
||
map.put(key31, value31);
|
||
map.put(key32, value32);
|
||
map.put(key33, value33);
|
||
map.put(key34, value34);
|
||
map.put(key35, value35);
|
||
map.put(key36, value36);
|
||
map.put(key37, value37);
|
||
map.put(key38, value38);
|
||
map.put(key39, value39);
|
||
map.put(key40, value40);
|
||
map.put(key41, value41);
|
||
return map;
|
||
}
|
||
|
||
public static <K, V> Map<K, V> of(
|
||
K key,
|
||
V value,
|
||
K key2,
|
||
V value2,
|
||
K key3,
|
||
V value3,
|
||
K key4,
|
||
V value4,
|
||
K key5,
|
||
V value5,
|
||
K key6,
|
||
V value6,
|
||
K key7,
|
||
V value7,
|
||
K key8,
|
||
V value8,
|
||
K key9,
|
||
V value9,
|
||
K key10,
|
||
V value10,
|
||
K key11,
|
||
V value11,
|
||
K key12,
|
||
V value12,
|
||
K key13,
|
||
V value13,
|
||
K key14,
|
||
V value14,
|
||
K key15,
|
||
V value15,
|
||
K key16,
|
||
V value16,
|
||
K key17,
|
||
V value17,
|
||
K key18,
|
||
V value18,
|
||
K key19,
|
||
V value19,
|
||
K key20,
|
||
V value20,
|
||
K key21,
|
||
V value21,
|
||
K key22,
|
||
V value22,
|
||
K key23,
|
||
V value23,
|
||
K key24,
|
||
V value24,
|
||
K key25,
|
||
V value25,
|
||
K key26,
|
||
V value26,
|
||
K key27,
|
||
V value27,
|
||
K key28,
|
||
V value28,
|
||
K key29,
|
||
V value29,
|
||
K key30,
|
||
V value30,
|
||
K key31,
|
||
V value31,
|
||
K key32,
|
||
V value32,
|
||
K key33,
|
||
V value33,
|
||
K key34,
|
||
V value34,
|
||
K key35,
|
||
V value35,
|
||
K key36,
|
||
V value36,
|
||
K key37,
|
||
V value37,
|
||
K key38,
|
||
V value38,
|
||
K key39,
|
||
V value39,
|
||
K key40,
|
||
V value40,
|
||
K key41,
|
||
V value41,
|
||
K key42,
|
||
V value42
|
||
) {
|
||
var map = new HashMap<K, V>(46);
|
||
map.put(key, value);
|
||
map.put(key2, value2);
|
||
map.put(key3, value3);
|
||
map.put(key4, value4);
|
||
map.put(key5, value5);
|
||
map.put(key6, value6);
|
||
map.put(key7, value7);
|
||
map.put(key8, value8);
|
||
map.put(key9, value9);
|
||
map.put(key10, value10);
|
||
map.put(key11, value11);
|
||
map.put(key12, value12);
|
||
map.put(key13, value13);
|
||
map.put(key14, value14);
|
||
map.put(key15, value15);
|
||
map.put(key16, value16);
|
||
map.put(key17, value17);
|
||
map.put(key18, value18);
|
||
map.put(key19, value19);
|
||
map.put(key20, value20);
|
||
map.put(key21, value21);
|
||
map.put(key22, value22);
|
||
map.put(key23, value23);
|
||
map.put(key24, value24);
|
||
map.put(key25, value25);
|
||
map.put(key26, value26);
|
||
map.put(key27, value27);
|
||
map.put(key28, value28);
|
||
map.put(key29, value29);
|
||
map.put(key30, value30);
|
||
map.put(key31, value31);
|
||
map.put(key32, value32);
|
||
map.put(key33, value33);
|
||
map.put(key34, value34);
|
||
map.put(key35, value35);
|
||
map.put(key36, value36);
|
||
map.put(key37, value37);
|
||
map.put(key38, value38);
|
||
map.put(key39, value39);
|
||
map.put(key40, value40);
|
||
map.put(key41, value41);
|
||
map.put(key42, value42);
|
||
return map;
|
||
}
|
||
|
||
public static <K, V> Map<K, V> of(
|
||
K key,
|
||
V value,
|
||
K key2,
|
||
V value2,
|
||
K key3,
|
||
V value3,
|
||
K key4,
|
||
V value4,
|
||
K key5,
|
||
V value5,
|
||
K key6,
|
||
V value6,
|
||
K key7,
|
||
V value7,
|
||
K key8,
|
||
V value8,
|
||
K key9,
|
||
V value9,
|
||
K key10,
|
||
V value10,
|
||
K key11,
|
||
V value11,
|
||
K key12,
|
||
V value12,
|
||
K key13,
|
||
V value13,
|
||
K key14,
|
||
V value14,
|
||
K key15,
|
||
V value15,
|
||
K key16,
|
||
V value16,
|
||
K key17,
|
||
V value17,
|
||
K key18,
|
||
V value18,
|
||
K key19,
|
||
V value19,
|
||
K key20,
|
||
V value20,
|
||
K key21,
|
||
V value21,
|
||
K key22,
|
||
V value22,
|
||
K key23,
|
||
V value23,
|
||
K key24,
|
||
V value24,
|
||
K key25,
|
||
V value25,
|
||
K key26,
|
||
V value26,
|
||
K key27,
|
||
V value27,
|
||
K key28,
|
||
V value28,
|
||
K key29,
|
||
V value29,
|
||
K key30,
|
||
V value30,
|
||
K key31,
|
||
V value31,
|
||
K key32,
|
||
V value32,
|
||
K key33,
|
||
V value33,
|
||
K key34,
|
||
V value34,
|
||
K key35,
|
||
V value35,
|
||
K key36,
|
||
V value36,
|
||
K key37,
|
||
V value37,
|
||
K key38,
|
||
V value38,
|
||
K key39,
|
||
V value39,
|
||
K key40,
|
||
V value40,
|
||
K key41,
|
||
V value41,
|
||
K key42,
|
||
V value42,
|
||
K key43,
|
||
V value43
|
||
) {
|
||
var map = new HashMap<K, V>(47);
|
||
map.put(key, value);
|
||
map.put(key2, value2);
|
||
map.put(key3, value3);
|
||
map.put(key4, value4);
|
||
map.put(key5, value5);
|
||
map.put(key6, value6);
|
||
map.put(key7, value7);
|
||
map.put(key8, value8);
|
||
map.put(key9, value9);
|
||
map.put(key10, value10);
|
||
map.put(key11, value11);
|
||
map.put(key12, value12);
|
||
map.put(key13, value13);
|
||
map.put(key14, value14);
|
||
map.put(key15, value15);
|
||
map.put(key16, value16);
|
||
map.put(key17, value17);
|
||
map.put(key18, value18);
|
||
map.put(key19, value19);
|
||
map.put(key20, value20);
|
||
map.put(key21, value21);
|
||
map.put(key22, value22);
|
||
map.put(key23, value23);
|
||
map.put(key24, value24);
|
||
map.put(key25, value25);
|
||
map.put(key26, value26);
|
||
map.put(key27, value27);
|
||
map.put(key28, value28);
|
||
map.put(key29, value29);
|
||
map.put(key30, value30);
|
||
map.put(key31, value31);
|
||
map.put(key32, value32);
|
||
map.put(key33, value33);
|
||
map.put(key34, value34);
|
||
map.put(key35, value35);
|
||
map.put(key36, value36);
|
||
map.put(key37, value37);
|
||
map.put(key38, value38);
|
||
map.put(key39, value39);
|
||
map.put(key40, value40);
|
||
map.put(key41, value41);
|
||
map.put(key42, value42);
|
||
map.put(key43, value43);
|
||
return map;
|
||
}
|
||
|
||
public static <K, V> Map<K, V> of(
|
||
K key,
|
||
V value,
|
||
K key2,
|
||
V value2,
|
||
K key3,
|
||
V value3,
|
||
K key4,
|
||
V value4,
|
||
K key5,
|
||
V value5,
|
||
K key6,
|
||
V value6,
|
||
K key7,
|
||
V value7,
|
||
K key8,
|
||
V value8,
|
||
K key9,
|
||
V value9,
|
||
K key10,
|
||
V value10,
|
||
K key11,
|
||
V value11,
|
||
K key12,
|
||
V value12,
|
||
K key13,
|
||
V value13,
|
||
K key14,
|
||
V value14,
|
||
K key15,
|
||
V value15,
|
||
K key16,
|
||
V value16,
|
||
K key17,
|
||
V value17,
|
||
K key18,
|
||
V value18,
|
||
K key19,
|
||
V value19,
|
||
K key20,
|
||
V value20,
|
||
K key21,
|
||
V value21,
|
||
K key22,
|
||
V value22,
|
||
K key23,
|
||
V value23,
|
||
K key24,
|
||
V value24,
|
||
K key25,
|
||
V value25,
|
||
K key26,
|
||
V value26,
|
||
K key27,
|
||
V value27,
|
||
K key28,
|
||
V value28,
|
||
K key29,
|
||
V value29,
|
||
K key30,
|
||
V value30,
|
||
K key31,
|
||
V value31,
|
||
K key32,
|
||
V value32,
|
||
K key33,
|
||
V value33,
|
||
K key34,
|
||
V value34,
|
||
K key35,
|
||
V value35,
|
||
K key36,
|
||
V value36,
|
||
K key37,
|
||
V value37,
|
||
K key38,
|
||
V value38,
|
||
K key39,
|
||
V value39,
|
||
K key40,
|
||
V value40,
|
||
K key41,
|
||
V value41,
|
||
K key42,
|
||
V value42,
|
||
K key43,
|
||
V value43,
|
||
K key44,
|
||
V value44
|
||
) {
|
||
var map = new HashMap<K, V>(48);
|
||
map.put(key, value);
|
||
map.put(key2, value2);
|
||
map.put(key3, value3);
|
||
map.put(key4, value4);
|
||
map.put(key5, value5);
|
||
map.put(key6, value6);
|
||
map.put(key7, value7);
|
||
map.put(key8, value8);
|
||
map.put(key9, value9);
|
||
map.put(key10, value10);
|
||
map.put(key11, value11);
|
||
map.put(key12, value12);
|
||
map.put(key13, value13);
|
||
map.put(key14, value14);
|
||
map.put(key15, value15);
|
||
map.put(key16, value16);
|
||
map.put(key17, value17);
|
||
map.put(key18, value18);
|
||
map.put(key19, value19);
|
||
map.put(key20, value20);
|
||
map.put(key21, value21);
|
||
map.put(key22, value22);
|
||
map.put(key23, value23);
|
||
map.put(key24, value24);
|
||
map.put(key25, value25);
|
||
map.put(key26, value26);
|
||
map.put(key27, value27);
|
||
map.put(key28, value28);
|
||
map.put(key29, value29);
|
||
map.put(key30, value30);
|
||
map.put(key31, value31);
|
||
map.put(key32, value32);
|
||
map.put(key33, value33);
|
||
map.put(key34, value34);
|
||
map.put(key35, value35);
|
||
map.put(key36, value36);
|
||
map.put(key37, value37);
|
||
map.put(key38, value38);
|
||
map.put(key39, value39);
|
||
map.put(key40, value40);
|
||
map.put(key41, value41);
|
||
map.put(key42, value42);
|
||
map.put(key43, value43);
|
||
map.put(key44, value44);
|
||
return map;
|
||
}
|
||
|
||
public static <K, V> Map<K, V> of(
|
||
K key,
|
||
V value,
|
||
K key2,
|
||
V value2,
|
||
K key3,
|
||
V value3,
|
||
K key4,
|
||
V value4,
|
||
K key5,
|
||
V value5,
|
||
K key6,
|
||
V value6,
|
||
K key7,
|
||
V value7,
|
||
K key8,
|
||
V value8,
|
||
K key9,
|
||
V value9,
|
||
K key10,
|
||
V value10,
|
||
K key11,
|
||
V value11,
|
||
K key12,
|
||
V value12,
|
||
K key13,
|
||
V value13,
|
||
K key14,
|
||
V value14,
|
||
K key15,
|
||
V value15,
|
||
K key16,
|
||
V value16,
|
||
K key17,
|
||
V value17,
|
||
K key18,
|
||
V value18,
|
||
K key19,
|
||
V value19,
|
||
K key20,
|
||
V value20,
|
||
K key21,
|
||
V value21,
|
||
K key22,
|
||
V value22,
|
||
K key23,
|
||
V value23,
|
||
K key24,
|
||
V value24,
|
||
K key25,
|
||
V value25,
|
||
K key26,
|
||
V value26,
|
||
K key27,
|
||
V value27,
|
||
K key28,
|
||
V value28,
|
||
K key29,
|
||
V value29,
|
||
K key30,
|
||
V value30,
|
||
K key31,
|
||
V value31,
|
||
K key32,
|
||
V value32,
|
||
K key33,
|
||
V value33,
|
||
K key34,
|
||
V value34,
|
||
K key35,
|
||
V value35,
|
||
K key36,
|
||
V value36,
|
||
K key37,
|
||
V value37,
|
||
K key38,
|
||
V value38,
|
||
K key39,
|
||
V value39,
|
||
K key40,
|
||
V value40,
|
||
K key41,
|
||
V value41,
|
||
K key42,
|
||
V value42,
|
||
K key43,
|
||
V value43,
|
||
K key44,
|
||
V value44,
|
||
K key45,
|
||
V value45
|
||
) {
|
||
var map = new HashMap<K, V>(49);
|
||
map.put(key, value);
|
||
map.put(key2, value2);
|
||
map.put(key3, value3);
|
||
map.put(key4, value4);
|
||
map.put(key5, value5);
|
||
map.put(key6, value6);
|
||
map.put(key7, value7);
|
||
map.put(key8, value8);
|
||
map.put(key9, value9);
|
||
map.put(key10, value10);
|
||
map.put(key11, value11);
|
||
map.put(key12, value12);
|
||
map.put(key13, value13);
|
||
map.put(key14, value14);
|
||
map.put(key15, value15);
|
||
map.put(key16, value16);
|
||
map.put(key17, value17);
|
||
map.put(key18, value18);
|
||
map.put(key19, value19);
|
||
map.put(key20, value20);
|
||
map.put(key21, value21);
|
||
map.put(key22, value22);
|
||
map.put(key23, value23);
|
||
map.put(key24, value24);
|
||
map.put(key25, value25);
|
||
map.put(key26, value26);
|
||
map.put(key27, value27);
|
||
map.put(key28, value28);
|
||
map.put(key29, value29);
|
||
map.put(key30, value30);
|
||
map.put(key31, value31);
|
||
map.put(key32, value32);
|
||
map.put(key33, value33);
|
||
map.put(key34, value34);
|
||
map.put(key35, value35);
|
||
map.put(key36, value36);
|
||
map.put(key37, value37);
|
||
map.put(key38, value38);
|
||
map.put(key39, value39);
|
||
map.put(key40, value40);
|
||
map.put(key41, value41);
|
||
map.put(key42, value42);
|
||
map.put(key43, value43);
|
||
map.put(key44, value44);
|
||
map.put(key45, value45);
|
||
return map;
|
||
}
|
||
|
||
public static <K, V> Map<K, V> of(
|
||
K key,
|
||
V value,
|
||
K key2,
|
||
V value2,
|
||
K key3,
|
||
V value3,
|
||
K key4,
|
||
V value4,
|
||
K key5,
|
||
V value5,
|
||
K key6,
|
||
V value6,
|
||
K key7,
|
||
V value7,
|
||
K key8,
|
||
V value8,
|
||
K key9,
|
||
V value9,
|
||
K key10,
|
||
V value10,
|
||
K key11,
|
||
V value11,
|
||
K key12,
|
||
V value12,
|
||
K key13,
|
||
V value13,
|
||
K key14,
|
||
V value14,
|
||
K key15,
|
||
V value15,
|
||
K key16,
|
||
V value16,
|
||
K key17,
|
||
V value17,
|
||
K key18,
|
||
V value18,
|
||
K key19,
|
||
V value19,
|
||
K key20,
|
||
V value20,
|
||
K key21,
|
||
V value21,
|
||
K key22,
|
||
V value22,
|
||
K key23,
|
||
V value23,
|
||
K key24,
|
||
V value24,
|
||
K key25,
|
||
V value25,
|
||
K key26,
|
||
V value26,
|
||
K key27,
|
||
V value27,
|
||
K key28,
|
||
V value28,
|
||
K key29,
|
||
V value29,
|
||
K key30,
|
||
V value30,
|
||
K key31,
|
||
V value31,
|
||
K key32,
|
||
V value32,
|
||
K key33,
|
||
V value33,
|
||
K key34,
|
||
V value34,
|
||
K key35,
|
||
V value35,
|
||
K key36,
|
||
V value36,
|
||
K key37,
|
||
V value37,
|
||
K key38,
|
||
V value38,
|
||
K key39,
|
||
V value39,
|
||
K key40,
|
||
V value40,
|
||
K key41,
|
||
V value41,
|
||
K key42,
|
||
V value42,
|
||
K key43,
|
||
V value43,
|
||
K key44,
|
||
V value44,
|
||
K key45,
|
||
V value45,
|
||
K key46,
|
||
V value46
|
||
) {
|
||
var map = new HashMap<K, V>(50);
|
||
map.put(key, value);
|
||
map.put(key2, value2);
|
||
map.put(key3, value3);
|
||
map.put(key4, value4);
|
||
map.put(key5, value5);
|
||
map.put(key6, value6);
|
||
map.put(key7, value7);
|
||
map.put(key8, value8);
|
||
map.put(key9, value9);
|
||
map.put(key10, value10);
|
||
map.put(key11, value11);
|
||
map.put(key12, value12);
|
||
map.put(key13, value13);
|
||
map.put(key14, value14);
|
||
map.put(key15, value15);
|
||
map.put(key16, value16);
|
||
map.put(key17, value17);
|
||
map.put(key18, value18);
|
||
map.put(key19, value19);
|
||
map.put(key20, value20);
|
||
map.put(key21, value21);
|
||
map.put(key22, value22);
|
||
map.put(key23, value23);
|
||
map.put(key24, value24);
|
||
map.put(key25, value25);
|
||
map.put(key26, value26);
|
||
map.put(key27, value27);
|
||
map.put(key28, value28);
|
||
map.put(key29, value29);
|
||
map.put(key30, value30);
|
||
map.put(key31, value31);
|
||
map.put(key32, value32);
|
||
map.put(key33, value33);
|
||
map.put(key34, value34);
|
||
map.put(key35, value35);
|
||
map.put(key36, value36);
|
||
map.put(key37, value37);
|
||
map.put(key38, value38);
|
||
map.put(key39, value39);
|
||
map.put(key40, value40);
|
||
map.put(key41, value41);
|
||
map.put(key42, value42);
|
||
map.put(key43, value43);
|
||
map.put(key44, value44);
|
||
map.put(key45, value45);
|
||
map.put(key46, value46);
|
||
return map;
|
||
}
|
||
|
||
public static <K, V> Map<K, V> of(
|
||
K key,
|
||
V value,
|
||
K key2,
|
||
V value2,
|
||
K key3,
|
||
V value3,
|
||
K key4,
|
||
V value4,
|
||
K key5,
|
||
V value5,
|
||
K key6,
|
||
V value6,
|
||
K key7,
|
||
V value7,
|
||
K key8,
|
||
V value8,
|
||
K key9,
|
||
V value9,
|
||
K key10,
|
||
V value10,
|
||
K key11,
|
||
V value11,
|
||
K key12,
|
||
V value12,
|
||
K key13,
|
||
V value13,
|
||
K key14,
|
||
V value14,
|
||
K key15,
|
||
V value15,
|
||
K key16,
|
||
V value16,
|
||
K key17,
|
||
V value17,
|
||
K key18,
|
||
V value18,
|
||
K key19,
|
||
V value19,
|
||
K key20,
|
||
V value20,
|
||
K key21,
|
||
V value21,
|
||
K key22,
|
||
V value22,
|
||
K key23,
|
||
V value23,
|
||
K key24,
|
||
V value24,
|
||
K key25,
|
||
V value25,
|
||
K key26,
|
||
V value26,
|
||
K key27,
|
||
V value27,
|
||
K key28,
|
||
V value28,
|
||
K key29,
|
||
V value29,
|
||
K key30,
|
||
V value30,
|
||
K key31,
|
||
V value31,
|
||
K key32,
|
||
V value32,
|
||
K key33,
|
||
V value33,
|
||
K key34,
|
||
V value34,
|
||
K key35,
|
||
V value35,
|
||
K key36,
|
||
V value36,
|
||
K key37,
|
||
V value37,
|
||
K key38,
|
||
V value38,
|
||
K key39,
|
||
V value39,
|
||
K key40,
|
||
V value40,
|
||
K key41,
|
||
V value41,
|
||
K key42,
|
||
V value42,
|
||
K key43,
|
||
V value43,
|
||
K key44,
|
||
V value44,
|
||
K key45,
|
||
V value45,
|
||
K key46,
|
||
V value46,
|
||
K key47,
|
||
V value47
|
||
) {
|
||
var map = new HashMap<K, V>(51);
|
||
map.put(key, value);
|
||
map.put(key2, value2);
|
||
map.put(key3, value3);
|
||
map.put(key4, value4);
|
||
map.put(key5, value5);
|
||
map.put(key6, value6);
|
||
map.put(key7, value7);
|
||
map.put(key8, value8);
|
||
map.put(key9, value9);
|
||
map.put(key10, value10);
|
||
map.put(key11, value11);
|
||
map.put(key12, value12);
|
||
map.put(key13, value13);
|
||
map.put(key14, value14);
|
||
map.put(key15, value15);
|
||
map.put(key16, value16);
|
||
map.put(key17, value17);
|
||
map.put(key18, value18);
|
||
map.put(key19, value19);
|
||
map.put(key20, value20);
|
||
map.put(key21, value21);
|
||
map.put(key22, value22);
|
||
map.put(key23, value23);
|
||
map.put(key24, value24);
|
||
map.put(key25, value25);
|
||
map.put(key26, value26);
|
||
map.put(key27, value27);
|
||
map.put(key28, value28);
|
||
map.put(key29, value29);
|
||
map.put(key30, value30);
|
||
map.put(key31, value31);
|
||
map.put(key32, value32);
|
||
map.put(key33, value33);
|
||
map.put(key34, value34);
|
||
map.put(key35, value35);
|
||
map.put(key36, value36);
|
||
map.put(key37, value37);
|
||
map.put(key38, value38);
|
||
map.put(key39, value39);
|
||
map.put(key40, value40);
|
||
map.put(key41, value41);
|
||
map.put(key42, value42);
|
||
map.put(key43, value43);
|
||
map.put(key44, value44);
|
||
map.put(key45, value45);
|
||
map.put(key46, value46);
|
||
map.put(key47, value47);
|
||
return map;
|
||
}
|
||
|
||
public static <K, V> Map<K, V> of(
|
||
K key,
|
||
V value,
|
||
K key2,
|
||
V value2,
|
||
K key3,
|
||
V value3,
|
||
K key4,
|
||
V value4,
|
||
K key5,
|
||
V value5,
|
||
K key6,
|
||
V value6,
|
||
K key7,
|
||
V value7,
|
||
K key8,
|
||
V value8,
|
||
K key9,
|
||
V value9,
|
||
K key10,
|
||
V value10,
|
||
K key11,
|
||
V value11,
|
||
K key12,
|
||
V value12,
|
||
K key13,
|
||
V value13,
|
||
K key14,
|
||
V value14,
|
||
K key15,
|
||
V value15,
|
||
K key16,
|
||
V value16,
|
||
K key17,
|
||
V value17,
|
||
K key18,
|
||
V value18,
|
||
K key19,
|
||
V value19,
|
||
K key20,
|
||
V value20,
|
||
K key21,
|
||
V value21,
|
||
K key22,
|
||
V value22,
|
||
K key23,
|
||
V value23,
|
||
K key24,
|
||
V value24,
|
||
K key25,
|
||
V value25,
|
||
K key26,
|
||
V value26,
|
||
K key27,
|
||
V value27,
|
||
K key28,
|
||
V value28,
|
||
K key29,
|
||
V value29,
|
||
K key30,
|
||
V value30,
|
||
K key31,
|
||
V value31,
|
||
K key32,
|
||
V value32,
|
||
K key33,
|
||
V value33,
|
||
K key34,
|
||
V value34,
|
||
K key35,
|
||
V value35,
|
||
K key36,
|
||
V value36,
|
||
K key37,
|
||
V value37,
|
||
K key38,
|
||
V value38,
|
||
K key39,
|
||
V value39,
|
||
K key40,
|
||
V value40,
|
||
K key41,
|
||
V value41,
|
||
K key42,
|
||
V value42,
|
||
K key43,
|
||
V value43,
|
||
K key44,
|
||
V value44,
|
||
K key45,
|
||
V value45,
|
||
K key46,
|
||
V value46,
|
||
K key47,
|
||
V value47,
|
||
K key48,
|
||
V value48
|
||
) {
|
||
var map = new HashMap<K, V>(52);
|
||
map.put(key, value);
|
||
map.put(key2, value2);
|
||
map.put(key3, value3);
|
||
map.put(key4, value4);
|
||
map.put(key5, value5);
|
||
map.put(key6, value6);
|
||
map.put(key7, value7);
|
||
map.put(key8, value8);
|
||
map.put(key9, value9);
|
||
map.put(key10, value10);
|
||
map.put(key11, value11);
|
||
map.put(key12, value12);
|
||
map.put(key13, value13);
|
||
map.put(key14, value14);
|
||
map.put(key15, value15);
|
||
map.put(key16, value16);
|
||
map.put(key17, value17);
|
||
map.put(key18, value18);
|
||
map.put(key19, value19);
|
||
map.put(key20, value20);
|
||
map.put(key21, value21);
|
||
map.put(key22, value22);
|
||
map.put(key23, value23);
|
||
map.put(key24, value24);
|
||
map.put(key25, value25);
|
||
map.put(key26, value26);
|
||
map.put(key27, value27);
|
||
map.put(key28, value28);
|
||
map.put(key29, value29);
|
||
map.put(key30, value30);
|
||
map.put(key31, value31);
|
||
map.put(key32, value32);
|
||
map.put(key33, value33);
|
||
map.put(key34, value34);
|
||
map.put(key35, value35);
|
||
map.put(key36, value36);
|
||
map.put(key37, value37);
|
||
map.put(key38, value38);
|
||
map.put(key39, value39);
|
||
map.put(key40, value40);
|
||
map.put(key41, value41);
|
||
map.put(key42, value42);
|
||
map.put(key43, value43);
|
||
map.put(key44, value44);
|
||
map.put(key45, value45);
|
||
map.put(key46, value46);
|
||
map.put(key47, value47);
|
||
map.put(key48, value48);
|
||
return map;
|
||
}
|
||
|
||
public static <K, V> Map<K, V> of(
|
||
K key,
|
||
V value,
|
||
K key2,
|
||
V value2,
|
||
K key3,
|
||
V value3,
|
||
K key4,
|
||
V value4,
|
||
K key5,
|
||
V value5,
|
||
K key6,
|
||
V value6,
|
||
K key7,
|
||
V value7,
|
||
K key8,
|
||
V value8,
|
||
K key9,
|
||
V value9,
|
||
K key10,
|
||
V value10,
|
||
K key11,
|
||
V value11,
|
||
K key12,
|
||
V value12,
|
||
K key13,
|
||
V value13,
|
||
K key14,
|
||
V value14,
|
||
K key15,
|
||
V value15,
|
||
K key16,
|
||
V value16,
|
||
K key17,
|
||
V value17,
|
||
K key18,
|
||
V value18,
|
||
K key19,
|
||
V value19,
|
||
K key20,
|
||
V value20,
|
||
K key21,
|
||
V value21,
|
||
K key22,
|
||
V value22,
|
||
K key23,
|
||
V value23,
|
||
K key24,
|
||
V value24,
|
||
K key25,
|
||
V value25,
|
||
K key26,
|
||
V value26,
|
||
K key27,
|
||
V value27,
|
||
K key28,
|
||
V value28,
|
||
K key29,
|
||
V value29,
|
||
K key30,
|
||
V value30,
|
||
K key31,
|
||
V value31,
|
||
K key32,
|
||
V value32,
|
||
K key33,
|
||
V value33,
|
||
K key34,
|
||
V value34,
|
||
K key35,
|
||
V value35,
|
||
K key36,
|
||
V value36,
|
||
K key37,
|
||
V value37,
|
||
K key38,
|
||
V value38,
|
||
K key39,
|
||
V value39,
|
||
K key40,
|
||
V value40,
|
||
K key41,
|
||
V value41,
|
||
K key42,
|
||
V value42,
|
||
K key43,
|
||
V value43,
|
||
K key44,
|
||
V value44,
|
||
K key45,
|
||
V value45,
|
||
K key46,
|
||
V value46,
|
||
K key47,
|
||
V value47,
|
||
K key48,
|
||
V value48,
|
||
K key49,
|
||
V value49
|
||
) {
|
||
var map = new HashMap<K, V>(53);
|
||
map.put(key, value);
|
||
map.put(key2, value2);
|
||
map.put(key3, value3);
|
||
map.put(key4, value4);
|
||
map.put(key5, value5);
|
||
map.put(key6, value6);
|
||
map.put(key7, value7);
|
||
map.put(key8, value8);
|
||
map.put(key9, value9);
|
||
map.put(key10, value10);
|
||
map.put(key11, value11);
|
||
map.put(key12, value12);
|
||
map.put(key13, value13);
|
||
map.put(key14, value14);
|
||
map.put(key15, value15);
|
||
map.put(key16, value16);
|
||
map.put(key17, value17);
|
||
map.put(key18, value18);
|
||
map.put(key19, value19);
|
||
map.put(key20, value20);
|
||
map.put(key21, value21);
|
||
map.put(key22, value22);
|
||
map.put(key23, value23);
|
||
map.put(key24, value24);
|
||
map.put(key25, value25);
|
||
map.put(key26, value26);
|
||
map.put(key27, value27);
|
||
map.put(key28, value28);
|
||
map.put(key29, value29);
|
||
map.put(key30, value30);
|
||
map.put(key31, value31);
|
||
map.put(key32, value32);
|
||
map.put(key33, value33);
|
||
map.put(key34, value34);
|
||
map.put(key35, value35);
|
||
map.put(key36, value36);
|
||
map.put(key37, value37);
|
||
map.put(key38, value38);
|
||
map.put(key39, value39);
|
||
map.put(key40, value40);
|
||
map.put(key41, value41);
|
||
map.put(key42, value42);
|
||
map.put(key43, value43);
|
||
map.put(key44, value44);
|
||
map.put(key45, value45);
|
||
map.put(key46, value46);
|
||
map.put(key47, value47);
|
||
map.put(key48, value48);
|
||
map.put(key49, value49);
|
||
return map;
|
||
}
|
||
|
||
public static <K, V> Map<K, V> of(
|
||
K key,
|
||
V value,
|
||
K key2,
|
||
V value2,
|
||
K key3,
|
||
V value3,
|
||
K key4,
|
||
V value4,
|
||
K key5,
|
||
V value5,
|
||
K key6,
|
||
V value6,
|
||
K key7,
|
||
V value7,
|
||
K key8,
|
||
V value8,
|
||
K key9,
|
||
V value9,
|
||
K key10,
|
||
V value10,
|
||
K key11,
|
||
V value11,
|
||
K key12,
|
||
V value12,
|
||
K key13,
|
||
V value13,
|
||
K key14,
|
||
V value14,
|
||
K key15,
|
||
V value15,
|
||
K key16,
|
||
V value16,
|
||
K key17,
|
||
V value17,
|
||
K key18,
|
||
V value18,
|
||
K key19,
|
||
V value19,
|
||
K key20,
|
||
V value20,
|
||
K key21,
|
||
V value21,
|
||
K key22,
|
||
V value22,
|
||
K key23,
|
||
V value23,
|
||
K key24,
|
||
V value24,
|
||
K key25,
|
||
V value25,
|
||
K key26,
|
||
V value26,
|
||
K key27,
|
||
V value27,
|
||
K key28,
|
||
V value28,
|
||
K key29,
|
||
V value29,
|
||
K key30,
|
||
V value30,
|
||
K key31,
|
||
V value31,
|
||
K key32,
|
||
V value32,
|
||
K key33,
|
||
V value33,
|
||
K key34,
|
||
V value34,
|
||
K key35,
|
||
V value35,
|
||
K key36,
|
||
V value36,
|
||
K key37,
|
||
V value37,
|
||
K key38,
|
||
V value38,
|
||
K key39,
|
||
V value39,
|
||
K key40,
|
||
V value40,
|
||
K key41,
|
||
V value41,
|
||
K key42,
|
||
V value42,
|
||
K key43,
|
||
V value43,
|
||
K key44,
|
||
V value44,
|
||
K key45,
|
||
V value45,
|
||
K key46,
|
||
V value46,
|
||
K key47,
|
||
V value47,
|
||
K key48,
|
||
V value48,
|
||
K key49,
|
||
V value49,
|
||
K key50,
|
||
V value50
|
||
) {
|
||
var map = new HashMap<K, V>(54);
|
||
map.put(key, value);
|
||
map.put(key2, value2);
|
||
map.put(key3, value3);
|
||
map.put(key4, value4);
|
||
map.put(key5, value5);
|
||
map.put(key6, value6);
|
||
map.put(key7, value7);
|
||
map.put(key8, value8);
|
||
map.put(key9, value9);
|
||
map.put(key10, value10);
|
||
map.put(key11, value11);
|
||
map.put(key12, value12);
|
||
map.put(key13, value13);
|
||
map.put(key14, value14);
|
||
map.put(key15, value15);
|
||
map.put(key16, value16);
|
||
map.put(key17, value17);
|
||
map.put(key18, value18);
|
||
map.put(key19, value19);
|
||
map.put(key20, value20);
|
||
map.put(key21, value21);
|
||
map.put(key22, value22);
|
||
map.put(key23, value23);
|
||
map.put(key24, value24);
|
||
map.put(key25, value25);
|
||
map.put(key26, value26);
|
||
map.put(key27, value27);
|
||
map.put(key28, value28);
|
||
map.put(key29, value29);
|
||
map.put(key30, value30);
|
||
map.put(key31, value31);
|
||
map.put(key32, value32);
|
||
map.put(key33, value33);
|
||
map.put(key34, value34);
|
||
map.put(key35, value35);
|
||
map.put(key36, value36);
|
||
map.put(key37, value37);
|
||
map.put(key38, value38);
|
||
map.put(key39, value39);
|
||
map.put(key40, value40);
|
||
map.put(key41, value41);
|
||
map.put(key42, value42);
|
||
map.put(key43, value43);
|
||
map.put(key44, value44);
|
||
map.put(key45, value45);
|
||
map.put(key46, value46);
|
||
map.put(key47, value47);
|
||
map.put(key48, value48);
|
||
map.put(key49, value49);
|
||
map.put(key50, value50);
|
||
return map;
|
||
}
|
||
|
||
public static <K, V> Map<K, V> of(
|
||
K key,
|
||
V value,
|
||
K key2,
|
||
V value2,
|
||
K key3,
|
||
V value3,
|
||
K key4,
|
||
V value4,
|
||
K key5,
|
||
V value5,
|
||
K key6,
|
||
V value6,
|
||
K key7,
|
||
V value7,
|
||
K key8,
|
||
V value8,
|
||
K key9,
|
||
V value9,
|
||
K key10,
|
||
V value10,
|
||
K key11,
|
||
V value11,
|
||
K key12,
|
||
V value12,
|
||
K key13,
|
||
V value13,
|
||
K key14,
|
||
V value14,
|
||
K key15,
|
||
V value15,
|
||
K key16,
|
||
V value16,
|
||
K key17,
|
||
V value17,
|
||
K key18,
|
||
V value18,
|
||
K key19,
|
||
V value19,
|
||
K key20,
|
||
V value20,
|
||
K key21,
|
||
V value21,
|
||
K key22,
|
||
V value22,
|
||
K key23,
|
||
V value23,
|
||
K key24,
|
||
V value24,
|
||
K key25,
|
||
V value25,
|
||
K key26,
|
||
V value26,
|
||
K key27,
|
||
V value27,
|
||
K key28,
|
||
V value28,
|
||
K key29,
|
||
V value29,
|
||
K key30,
|
||
V value30,
|
||
K key31,
|
||
V value31,
|
||
K key32,
|
||
V value32,
|
||
K key33,
|
||
V value33,
|
||
K key34,
|
||
V value34,
|
||
K key35,
|
||
V value35,
|
||
K key36,
|
||
V value36,
|
||
K key37,
|
||
V value37,
|
||
K key38,
|
||
V value38,
|
||
K key39,
|
||
V value39,
|
||
K key40,
|
||
V value40,
|
||
K key41,
|
||
V value41,
|
||
K key42,
|
||
V value42,
|
||
K key43,
|
||
V value43,
|
||
K key44,
|
||
V value44,
|
||
K key45,
|
||
V value45,
|
||
K key46,
|
||
V value46,
|
||
K key47,
|
||
V value47,
|
||
K key48,
|
||
V value48,
|
||
K key49,
|
||
V value49,
|
||
K key50,
|
||
V value50,
|
||
K key51,
|
||
V value51
|
||
) {
|
||
var map = new HashMap<K, V>(55);
|
||
map.put(key, value);
|
||
map.put(key2, value2);
|
||
map.put(key3, value3);
|
||
map.put(key4, value4);
|
||
map.put(key5, value5);
|
||
map.put(key6, value6);
|
||
map.put(key7, value7);
|
||
map.put(key8, value8);
|
||
map.put(key9, value9);
|
||
map.put(key10, value10);
|
||
map.put(key11, value11);
|
||
map.put(key12, value12);
|
||
map.put(key13, value13);
|
||
map.put(key14, value14);
|
||
map.put(key15, value15);
|
||
map.put(key16, value16);
|
||
map.put(key17, value17);
|
||
map.put(key18, value18);
|
||
map.put(key19, value19);
|
||
map.put(key20, value20);
|
||
map.put(key21, value21);
|
||
map.put(key22, value22);
|
||
map.put(key23, value23);
|
||
map.put(key24, value24);
|
||
map.put(key25, value25);
|
||
map.put(key26, value26);
|
||
map.put(key27, value27);
|
||
map.put(key28, value28);
|
||
map.put(key29, value29);
|
||
map.put(key30, value30);
|
||
map.put(key31, value31);
|
||
map.put(key32, value32);
|
||
map.put(key33, value33);
|
||
map.put(key34, value34);
|
||
map.put(key35, value35);
|
||
map.put(key36, value36);
|
||
map.put(key37, value37);
|
||
map.put(key38, value38);
|
||
map.put(key39, value39);
|
||
map.put(key40, value40);
|
||
map.put(key41, value41);
|
||
map.put(key42, value42);
|
||
map.put(key43, value43);
|
||
map.put(key44, value44);
|
||
map.put(key45, value45);
|
||
map.put(key46, value46);
|
||
map.put(key47, value47);
|
||
map.put(key48, value48);
|
||
map.put(key49, value49);
|
||
map.put(key50, value50);
|
||
map.put(key51, value51);
|
||
return map;
|
||
}
|
||
|
||
public static <K, V> Map<K, V> of(
|
||
K key,
|
||
V value,
|
||
K key2,
|
||
V value2,
|
||
K key3,
|
||
V value3,
|
||
K key4,
|
||
V value4,
|
||
K key5,
|
||
V value5,
|
||
K key6,
|
||
V value6,
|
||
K key7,
|
||
V value7,
|
||
K key8,
|
||
V value8,
|
||
K key9,
|
||
V value9,
|
||
K key10,
|
||
V value10,
|
||
K key11,
|
||
V value11,
|
||
K key12,
|
||
V value12,
|
||
K key13,
|
||
V value13,
|
||
K key14,
|
||
V value14,
|
||
K key15,
|
||
V value15,
|
||
K key16,
|
||
V value16,
|
||
K key17,
|
||
V value17,
|
||
K key18,
|
||
V value18,
|
||
K key19,
|
||
V value19,
|
||
K key20,
|
||
V value20,
|
||
K key21,
|
||
V value21,
|
||
K key22,
|
||
V value22,
|
||
K key23,
|
||
V value23,
|
||
K key24,
|
||
V value24,
|
||
K key25,
|
||
V value25,
|
||
K key26,
|
||
V value26,
|
||
K key27,
|
||
V value27,
|
||
K key28,
|
||
V value28,
|
||
K key29,
|
||
V value29,
|
||
K key30,
|
||
V value30,
|
||
K key31,
|
||
V value31,
|
||
K key32,
|
||
V value32,
|
||
K key33,
|
||
V value33,
|
||
K key34,
|
||
V value34,
|
||
K key35,
|
||
V value35,
|
||
K key36,
|
||
V value36,
|
||
K key37,
|
||
V value37,
|
||
K key38,
|
||
V value38,
|
||
K key39,
|
||
V value39,
|
||
K key40,
|
||
V value40,
|
||
K key41,
|
||
V value41,
|
||
K key42,
|
||
V value42,
|
||
K key43,
|
||
V value43,
|
||
K key44,
|
||
V value44,
|
||
K key45,
|
||
V value45,
|
||
K key46,
|
||
V value46,
|
||
K key47,
|
||
V value47,
|
||
K key48,
|
||
V value48,
|
||
K key49,
|
||
V value49,
|
||
K key50,
|
||
V value50,
|
||
K key51,
|
||
V value51,
|
||
K key52,
|
||
V value52
|
||
) {
|
||
var map = new HashMap<K, V>(56);
|
||
map.put(key, value);
|
||
map.put(key2, value2);
|
||
map.put(key3, value3);
|
||
map.put(key4, value4);
|
||
map.put(key5, value5);
|
||
map.put(key6, value6);
|
||
map.put(key7, value7);
|
||
map.put(key8, value8);
|
||
map.put(key9, value9);
|
||
map.put(key10, value10);
|
||
map.put(key11, value11);
|
||
map.put(key12, value12);
|
||
map.put(key13, value13);
|
||
map.put(key14, value14);
|
||
map.put(key15, value15);
|
||
map.put(key16, value16);
|
||
map.put(key17, value17);
|
||
map.put(key18, value18);
|
||
map.put(key19, value19);
|
||
map.put(key20, value20);
|
||
map.put(key21, value21);
|
||
map.put(key22, value22);
|
||
map.put(key23, value23);
|
||
map.put(key24, value24);
|
||
map.put(key25, value25);
|
||
map.put(key26, value26);
|
||
map.put(key27, value27);
|
||
map.put(key28, value28);
|
||
map.put(key29, value29);
|
||
map.put(key30, value30);
|
||
map.put(key31, value31);
|
||
map.put(key32, value32);
|
||
map.put(key33, value33);
|
||
map.put(key34, value34);
|
||
map.put(key35, value35);
|
||
map.put(key36, value36);
|
||
map.put(key37, value37);
|
||
map.put(key38, value38);
|
||
map.put(key39, value39);
|
||
map.put(key40, value40);
|
||
map.put(key41, value41);
|
||
map.put(key42, value42);
|
||
map.put(key43, value43);
|
||
map.put(key44, value44);
|
||
map.put(key45, value45);
|
||
map.put(key46, value46);
|
||
map.put(key47, value47);
|
||
map.put(key48, value48);
|
||
map.put(key49, value49);
|
||
map.put(key50, value50);
|
||
map.put(key51, value51);
|
||
map.put(key52, value52);
|
||
return map;
|
||
}
|
||
|
||
public static <K, V> Map<K, V> of(
|
||
K key,
|
||
V value,
|
||
K key2,
|
||
V value2,
|
||
K key3,
|
||
V value3,
|
||
K key4,
|
||
V value4,
|
||
K key5,
|
||
V value5,
|
||
K key6,
|
||
V value6,
|
||
K key7,
|
||
V value7,
|
||
K key8,
|
||
V value8,
|
||
K key9,
|
||
V value9,
|
||
K key10,
|
||
V value10,
|
||
K key11,
|
||
V value11,
|
||
K key12,
|
||
V value12,
|
||
K key13,
|
||
V value13,
|
||
K key14,
|
||
V value14,
|
||
K key15,
|
||
V value15,
|
||
K key16,
|
||
V value16,
|
||
K key17,
|
||
V value17,
|
||
K key18,
|
||
V value18,
|
||
K key19,
|
||
V value19,
|
||
K key20,
|
||
V value20,
|
||
K key21,
|
||
V value21,
|
||
K key22,
|
||
V value22,
|
||
K key23,
|
||
V value23,
|
||
K key24,
|
||
V value24,
|
||
K key25,
|
||
V value25,
|
||
K key26,
|
||
V value26,
|
||
K key27,
|
||
V value27,
|
||
K key28,
|
||
V value28,
|
||
K key29,
|
||
V value29,
|
||
K key30,
|
||
V value30,
|
||
K key31,
|
||
V value31,
|
||
K key32,
|
||
V value32,
|
||
K key33,
|
||
V value33,
|
||
K key34,
|
||
V value34,
|
||
K key35,
|
||
V value35,
|
||
K key36,
|
||
V value36,
|
||
K key37,
|
||
V value37,
|
||
K key38,
|
||
V value38,
|
||
K key39,
|
||
V value39,
|
||
K key40,
|
||
V value40,
|
||
K key41,
|
||
V value41,
|
||
K key42,
|
||
V value42,
|
||
K key43,
|
||
V value43,
|
||
K key44,
|
||
V value44,
|
||
K key45,
|
||
V value45,
|
||
K key46,
|
||
V value46,
|
||
K key47,
|
||
V value47,
|
||
K key48,
|
||
V value48,
|
||
K key49,
|
||
V value49,
|
||
K key50,
|
||
V value50,
|
||
K key51,
|
||
V value51,
|
||
K key52,
|
||
V value52,
|
||
K key53,
|
||
V value53
|
||
) {
|
||
var map = new HashMap<K, V>(57);
|
||
map.put(key, value);
|
||
map.put(key2, value2);
|
||
map.put(key3, value3);
|
||
map.put(key4, value4);
|
||
map.put(key5, value5);
|
||
map.put(key6, value6);
|
||
map.put(key7, value7);
|
||
map.put(key8, value8);
|
||
map.put(key9, value9);
|
||
map.put(key10, value10);
|
||
map.put(key11, value11);
|
||
map.put(key12, value12);
|
||
map.put(key13, value13);
|
||
map.put(key14, value14);
|
||
map.put(key15, value15);
|
||
map.put(key16, value16);
|
||
map.put(key17, value17);
|
||
map.put(key18, value18);
|
||
map.put(key19, value19);
|
||
map.put(key20, value20);
|
||
map.put(key21, value21);
|
||
map.put(key22, value22);
|
||
map.put(key23, value23);
|
||
map.put(key24, value24);
|
||
map.put(key25, value25);
|
||
map.put(key26, value26);
|
||
map.put(key27, value27);
|
||
map.put(key28, value28);
|
||
map.put(key29, value29);
|
||
map.put(key30, value30);
|
||
map.put(key31, value31);
|
||
map.put(key32, value32);
|
||
map.put(key33, value33);
|
||
map.put(key34, value34);
|
||
map.put(key35, value35);
|
||
map.put(key36, value36);
|
||
map.put(key37, value37);
|
||
map.put(key38, value38);
|
||
map.put(key39, value39);
|
||
map.put(key40, value40);
|
||
map.put(key41, value41);
|
||
map.put(key42, value42);
|
||
map.put(key43, value43);
|
||
map.put(key44, value44);
|
||
map.put(key45, value45);
|
||
map.put(key46, value46);
|
||
map.put(key47, value47);
|
||
map.put(key48, value48);
|
||
map.put(key49, value49);
|
||
map.put(key50, value50);
|
||
map.put(key51, value51);
|
||
map.put(key52, value52);
|
||
map.put(key53, value53);
|
||
return map;
|
||
}
|
||
|
||
public static <K, V> Map<K, V> of(
|
||
K key,
|
||
V value,
|
||
K key2,
|
||
V value2,
|
||
K key3,
|
||
V value3,
|
||
K key4,
|
||
V value4,
|
||
K key5,
|
||
V value5,
|
||
K key6,
|
||
V value6,
|
||
K key7,
|
||
V value7,
|
||
K key8,
|
||
V value8,
|
||
K key9,
|
||
V value9,
|
||
K key10,
|
||
V value10,
|
||
K key11,
|
||
V value11,
|
||
K key12,
|
||
V value12,
|
||
K key13,
|
||
V value13,
|
||
K key14,
|
||
V value14,
|
||
K key15,
|
||
V value15,
|
||
K key16,
|
||
V value16,
|
||
K key17,
|
||
V value17,
|
||
K key18,
|
||
V value18,
|
||
K key19,
|
||
V value19,
|
||
K key20,
|
||
V value20,
|
||
K key21,
|
||
V value21,
|
||
K key22,
|
||
V value22,
|
||
K key23,
|
||
V value23,
|
||
K key24,
|
||
V value24,
|
||
K key25,
|
||
V value25,
|
||
K key26,
|
||
V value26,
|
||
K key27,
|
||
V value27,
|
||
K key28,
|
||
V value28,
|
||
K key29,
|
||
V value29,
|
||
K key30,
|
||
V value30,
|
||
K key31,
|
||
V value31,
|
||
K key32,
|
||
V value32,
|
||
K key33,
|
||
V value33,
|
||
K key34,
|
||
V value34,
|
||
K key35,
|
||
V value35,
|
||
K key36,
|
||
V value36,
|
||
K key37,
|
||
V value37,
|
||
K key38,
|
||
V value38,
|
||
K key39,
|
||
V value39,
|
||
K key40,
|
||
V value40,
|
||
K key41,
|
||
V value41,
|
||
K key42,
|
||
V value42,
|
||
K key43,
|
||
V value43,
|
||
K key44,
|
||
V value44,
|
||
K key45,
|
||
V value45,
|
||
K key46,
|
||
V value46,
|
||
K key47,
|
||
V value47,
|
||
K key48,
|
||
V value48,
|
||
K key49,
|
||
V value49,
|
||
K key50,
|
||
V value50,
|
||
K key51,
|
||
V value51,
|
||
K key52,
|
||
V value52,
|
||
K key53,
|
||
V value53,
|
||
K key54,
|
||
V value54
|
||
) {
|
||
var map = new HashMap<K, V>(58);
|
||
map.put(key, value);
|
||
map.put(key2, value2);
|
||
map.put(key3, value3);
|
||
map.put(key4, value4);
|
||
map.put(key5, value5);
|
||
map.put(key6, value6);
|
||
map.put(key7, value7);
|
||
map.put(key8, value8);
|
||
map.put(key9, value9);
|
||
map.put(key10, value10);
|
||
map.put(key11, value11);
|
||
map.put(key12, value12);
|
||
map.put(key13, value13);
|
||
map.put(key14, value14);
|
||
map.put(key15, value15);
|
||
map.put(key16, value16);
|
||
map.put(key17, value17);
|
||
map.put(key18, value18);
|
||
map.put(key19, value19);
|
||
map.put(key20, value20);
|
||
map.put(key21, value21);
|
||
map.put(key22, value22);
|
||
map.put(key23, value23);
|
||
map.put(key24, value24);
|
||
map.put(key25, value25);
|
||
map.put(key26, value26);
|
||
map.put(key27, value27);
|
||
map.put(key28, value28);
|
||
map.put(key29, value29);
|
||
map.put(key30, value30);
|
||
map.put(key31, value31);
|
||
map.put(key32, value32);
|
||
map.put(key33, value33);
|
||
map.put(key34, value34);
|
||
map.put(key35, value35);
|
||
map.put(key36, value36);
|
||
map.put(key37, value37);
|
||
map.put(key38, value38);
|
||
map.put(key39, value39);
|
||
map.put(key40, value40);
|
||
map.put(key41, value41);
|
||
map.put(key42, value42);
|
||
map.put(key43, value43);
|
||
map.put(key44, value44);
|
||
map.put(key45, value45);
|
||
map.put(key46, value46);
|
||
map.put(key47, value47);
|
||
map.put(key48, value48);
|
||
map.put(key49, value49);
|
||
map.put(key50, value50);
|
||
map.put(key51, value51);
|
||
map.put(key52, value52);
|
||
map.put(key53, value53);
|
||
map.put(key54, value54);
|
||
return map;
|
||
}
|
||
|
||
public static <K, V> Map<K, V> of(
|
||
K key,
|
||
V value,
|
||
K key2,
|
||
V value2,
|
||
K key3,
|
||
V value3,
|
||
K key4,
|
||
V value4,
|
||
K key5,
|
||
V value5,
|
||
K key6,
|
||
V value6,
|
||
K key7,
|
||
V value7,
|
||
K key8,
|
||
V value8,
|
||
K key9,
|
||
V value9,
|
||
K key10,
|
||
V value10,
|
||
K key11,
|
||
V value11,
|
||
K key12,
|
||
V value12,
|
||
K key13,
|
||
V value13,
|
||
K key14,
|
||
V value14,
|
||
K key15,
|
||
V value15,
|
||
K key16,
|
||
V value16,
|
||
K key17,
|
||
V value17,
|
||
K key18,
|
||
V value18,
|
||
K key19,
|
||
V value19,
|
||
K key20,
|
||
V value20,
|
||
K key21,
|
||
V value21,
|
||
K key22,
|
||
V value22,
|
||
K key23,
|
||
V value23,
|
||
K key24,
|
||
V value24,
|
||
K key25,
|
||
V value25,
|
||
K key26,
|
||
V value26,
|
||
K key27,
|
||
V value27,
|
||
K key28,
|
||
V value28,
|
||
K key29,
|
||
V value29,
|
||
K key30,
|
||
V value30,
|
||
K key31,
|
||
V value31,
|
||
K key32,
|
||
V value32,
|
||
K key33,
|
||
V value33,
|
||
K key34,
|
||
V value34,
|
||
K key35,
|
||
V value35,
|
||
K key36,
|
||
V value36,
|
||
K key37,
|
||
V value37,
|
||
K key38,
|
||
V value38,
|
||
K key39,
|
||
V value39,
|
||
K key40,
|
||
V value40,
|
||
K key41,
|
||
V value41,
|
||
K key42,
|
||
V value42,
|
||
K key43,
|
||
V value43,
|
||
K key44,
|
||
V value44,
|
||
K key45,
|
||
V value45,
|
||
K key46,
|
||
V value46,
|
||
K key47,
|
||
V value47,
|
||
K key48,
|
||
V value48,
|
||
K key49,
|
||
V value49,
|
||
K key50,
|
||
V value50,
|
||
K key51,
|
||
V value51,
|
||
K key52,
|
||
V value52,
|
||
K key53,
|
||
V value53,
|
||
K key54,
|
||
V value54,
|
||
K key55,
|
||
V value55
|
||
) {
|
||
var map = new HashMap<K, V>(59);
|
||
map.put(key, value);
|
||
map.put(key2, value2);
|
||
map.put(key3, value3);
|
||
map.put(key4, value4);
|
||
map.put(key5, value5);
|
||
map.put(key6, value6);
|
||
map.put(key7, value7);
|
||
map.put(key8, value8);
|
||
map.put(key9, value9);
|
||
map.put(key10, value10);
|
||
map.put(key11, value11);
|
||
map.put(key12, value12);
|
||
map.put(key13, value13);
|
||
map.put(key14, value14);
|
||
map.put(key15, value15);
|
||
map.put(key16, value16);
|
||
map.put(key17, value17);
|
||
map.put(key18, value18);
|
||
map.put(key19, value19);
|
||
map.put(key20, value20);
|
||
map.put(key21, value21);
|
||
map.put(key22, value22);
|
||
map.put(key23, value23);
|
||
map.put(key24, value24);
|
||
map.put(key25, value25);
|
||
map.put(key26, value26);
|
||
map.put(key27, value27);
|
||
map.put(key28, value28);
|
||
map.put(key29, value29);
|
||
map.put(key30, value30);
|
||
map.put(key31, value31);
|
||
map.put(key32, value32);
|
||
map.put(key33, value33);
|
||
map.put(key34, value34);
|
||
map.put(key35, value35);
|
||
map.put(key36, value36);
|
||
map.put(key37, value37);
|
||
map.put(key38, value38);
|
||
map.put(key39, value39);
|
||
map.put(key40, value40);
|
||
map.put(key41, value41);
|
||
map.put(key42, value42);
|
||
map.put(key43, value43);
|
||
map.put(key44, value44);
|
||
map.put(key45, value45);
|
||
map.put(key46, value46);
|
||
map.put(key47, value47);
|
||
map.put(key48, value48);
|
||
map.put(key49, value49);
|
||
map.put(key50, value50);
|
||
map.put(key51, value51);
|
||
map.put(key52, value52);
|
||
map.put(key53, value53);
|
||
map.put(key54, value54);
|
||
map.put(key55, value55);
|
||
return map;
|
||
}
|
||
|
||
public static <K, V> Map<K, V> of(
|
||
K key,
|
||
V value,
|
||
K key2,
|
||
V value2,
|
||
K key3,
|
||
V value3,
|
||
K key4,
|
||
V value4,
|
||
K key5,
|
||
V value5,
|
||
K key6,
|
||
V value6,
|
||
K key7,
|
||
V value7,
|
||
K key8,
|
||
V value8,
|
||
K key9,
|
||
V value9,
|
||
K key10,
|
||
V value10,
|
||
K key11,
|
||
V value11,
|
||
K key12,
|
||
V value12,
|
||
K key13,
|
||
V value13,
|
||
K key14,
|
||
V value14,
|
||
K key15,
|
||
V value15,
|
||
K key16,
|
||
V value16,
|
||
K key17,
|
||
V value17,
|
||
K key18,
|
||
V value18,
|
||
K key19,
|
||
V value19,
|
||
K key20,
|
||
V value20,
|
||
K key21,
|
||
V value21,
|
||
K key22,
|
||
V value22,
|
||
K key23,
|
||
V value23,
|
||
K key24,
|
||
V value24,
|
||
K key25,
|
||
V value25,
|
||
K key26,
|
||
V value26,
|
||
K key27,
|
||
V value27,
|
||
K key28,
|
||
V value28,
|
||
K key29,
|
||
V value29,
|
||
K key30,
|
||
V value30,
|
||
K key31,
|
||
V value31,
|
||
K key32,
|
||
V value32,
|
||
K key33,
|
||
V value33,
|
||
K key34,
|
||
V value34,
|
||
K key35,
|
||
V value35,
|
||
K key36,
|
||
V value36,
|
||
K key37,
|
||
V value37,
|
||
K key38,
|
||
V value38,
|
||
K key39,
|
||
V value39,
|
||
K key40,
|
||
V value40,
|
||
K key41,
|
||
V value41,
|
||
K key42,
|
||
V value42,
|
||
K key43,
|
||
V value43,
|
||
K key44,
|
||
V value44,
|
||
K key45,
|
||
V value45,
|
||
K key46,
|
||
V value46,
|
||
K key47,
|
||
V value47,
|
||
K key48,
|
||
V value48,
|
||
K key49,
|
||
V value49,
|
||
K key50,
|
||
V value50,
|
||
K key51,
|
||
V value51,
|
||
K key52,
|
||
V value52,
|
||
K key53,
|
||
V value53,
|
||
K key54,
|
||
V value54,
|
||
K key55,
|
||
V value55,
|
||
K key56,
|
||
V value56
|
||
) {
|
||
var map = new HashMap<K, V>(60);
|
||
map.put(key, value);
|
||
map.put(key2, value2);
|
||
map.put(key3, value3);
|
||
map.put(key4, value4);
|
||
map.put(key5, value5);
|
||
map.put(key6, value6);
|
||
map.put(key7, value7);
|
||
map.put(key8, value8);
|
||
map.put(key9, value9);
|
||
map.put(key10, value10);
|
||
map.put(key11, value11);
|
||
map.put(key12, value12);
|
||
map.put(key13, value13);
|
||
map.put(key14, value14);
|
||
map.put(key15, value15);
|
||
map.put(key16, value16);
|
||
map.put(key17, value17);
|
||
map.put(key18, value18);
|
||
map.put(key19, value19);
|
||
map.put(key20, value20);
|
||
map.put(key21, value21);
|
||
map.put(key22, value22);
|
||
map.put(key23, value23);
|
||
map.put(key24, value24);
|
||
map.put(key25, value25);
|
||
map.put(key26, value26);
|
||
map.put(key27, value27);
|
||
map.put(key28, value28);
|
||
map.put(key29, value29);
|
||
map.put(key30, value30);
|
||
map.put(key31, value31);
|
||
map.put(key32, value32);
|
||
map.put(key33, value33);
|
||
map.put(key34, value34);
|
||
map.put(key35, value35);
|
||
map.put(key36, value36);
|
||
map.put(key37, value37);
|
||
map.put(key38, value38);
|
||
map.put(key39, value39);
|
||
map.put(key40, value40);
|
||
map.put(key41, value41);
|
||
map.put(key42, value42);
|
||
map.put(key43, value43);
|
||
map.put(key44, value44);
|
||
map.put(key45, value45);
|
||
map.put(key46, value46);
|
||
map.put(key47, value47);
|
||
map.put(key48, value48);
|
||
map.put(key49, value49);
|
||
map.put(key50, value50);
|
||
map.put(key51, value51);
|
||
map.put(key52, value52);
|
||
map.put(key53, value53);
|
||
map.put(key54, value54);
|
||
map.put(key55, value55);
|
||
map.put(key56, value56);
|
||
return map;
|
||
}
|
||
|
||
public static <K, V> Map<K, V> of(
|
||
K key,
|
||
V value,
|
||
K key2,
|
||
V value2,
|
||
K key3,
|
||
V value3,
|
||
K key4,
|
||
V value4,
|
||
K key5,
|
||
V value5,
|
||
K key6,
|
||
V value6,
|
||
K key7,
|
||
V value7,
|
||
K key8,
|
||
V value8,
|
||
K key9,
|
||
V value9,
|
||
K key10,
|
||
V value10,
|
||
K key11,
|
||
V value11,
|
||
K key12,
|
||
V value12,
|
||
K key13,
|
||
V value13,
|
||
K key14,
|
||
V value14,
|
||
K key15,
|
||
V value15,
|
||
K key16,
|
||
V value16,
|
||
K key17,
|
||
V value17,
|
||
K key18,
|
||
V value18,
|
||
K key19,
|
||
V value19,
|
||
K key20,
|
||
V value20,
|
||
K key21,
|
||
V value21,
|
||
K key22,
|
||
V value22,
|
||
K key23,
|
||
V value23,
|
||
K key24,
|
||
V value24,
|
||
K key25,
|
||
V value25,
|
||
K key26,
|
||
V value26,
|
||
K key27,
|
||
V value27,
|
||
K key28,
|
||
V value28,
|
||
K key29,
|
||
V value29,
|
||
K key30,
|
||
V value30,
|
||
K key31,
|
||
V value31,
|
||
K key32,
|
||
V value32,
|
||
K key33,
|
||
V value33,
|
||
K key34,
|
||
V value34,
|
||
K key35,
|
||
V value35,
|
||
K key36,
|
||
V value36,
|
||
K key37,
|
||
V value37,
|
||
K key38,
|
||
V value38,
|
||
K key39,
|
||
V value39,
|
||
K key40,
|
||
V value40,
|
||
K key41,
|
||
V value41,
|
||
K key42,
|
||
V value42,
|
||
K key43,
|
||
V value43,
|
||
K key44,
|
||
V value44,
|
||
K key45,
|
||
V value45,
|
||
K key46,
|
||
V value46,
|
||
K key47,
|
||
V value47,
|
||
K key48,
|
||
V value48,
|
||
K key49,
|
||
V value49,
|
||
K key50,
|
||
V value50,
|
||
K key51,
|
||
V value51,
|
||
K key52,
|
||
V value52,
|
||
K key53,
|
||
V value53,
|
||
K key54,
|
||
V value54,
|
||
K key55,
|
||
V value55,
|
||
K key56,
|
||
V value56,
|
||
K key57,
|
||
V value57
|
||
) {
|
||
var map = new HashMap<K, V>(61);
|
||
map.put(key, value);
|
||
map.put(key2, value2);
|
||
map.put(key3, value3);
|
||
map.put(key4, value4);
|
||
map.put(key5, value5);
|
||
map.put(key6, value6);
|
||
map.put(key7, value7);
|
||
map.put(key8, value8);
|
||
map.put(key9, value9);
|
||
map.put(key10, value10);
|
||
map.put(key11, value11);
|
||
map.put(key12, value12);
|
||
map.put(key13, value13);
|
||
map.put(key14, value14);
|
||
map.put(key15, value15);
|
||
map.put(key16, value16);
|
||
map.put(key17, value17);
|
||
map.put(key18, value18);
|
||
map.put(key19, value19);
|
||
map.put(key20, value20);
|
||
map.put(key21, value21);
|
||
map.put(key22, value22);
|
||
map.put(key23, value23);
|
||
map.put(key24, value24);
|
||
map.put(key25, value25);
|
||
map.put(key26, value26);
|
||
map.put(key27, value27);
|
||
map.put(key28, value28);
|
||
map.put(key29, value29);
|
||
map.put(key30, value30);
|
||
map.put(key31, value31);
|
||
map.put(key32, value32);
|
||
map.put(key33, value33);
|
||
map.put(key34, value34);
|
||
map.put(key35, value35);
|
||
map.put(key36, value36);
|
||
map.put(key37, value37);
|
||
map.put(key38, value38);
|
||
map.put(key39, value39);
|
||
map.put(key40, value40);
|
||
map.put(key41, value41);
|
||
map.put(key42, value42);
|
||
map.put(key43, value43);
|
||
map.put(key44, value44);
|
||
map.put(key45, value45);
|
||
map.put(key46, value46);
|
||
map.put(key47, value47);
|
||
map.put(key48, value48);
|
||
map.put(key49, value49);
|
||
map.put(key50, value50);
|
||
map.put(key51, value51);
|
||
map.put(key52, value52);
|
||
map.put(key53, value53);
|
||
map.put(key54, value54);
|
||
map.put(key55, value55);
|
||
map.put(key56, value56);
|
||
map.put(key57, value57);
|
||
return map;
|
||
}
|
||
|
||
public static <K, V> Map<K, V> of(
|
||
K key,
|
||
V value,
|
||
K key2,
|
||
V value2,
|
||
K key3,
|
||
V value3,
|
||
K key4,
|
||
V value4,
|
||
K key5,
|
||
V value5,
|
||
K key6,
|
||
V value6,
|
||
K key7,
|
||
V value7,
|
||
K key8,
|
||
V value8,
|
||
K key9,
|
||
V value9,
|
||
K key10,
|
||
V value10,
|
||
K key11,
|
||
V value11,
|
||
K key12,
|
||
V value12,
|
||
K key13,
|
||
V value13,
|
||
K key14,
|
||
V value14,
|
||
K key15,
|
||
V value15,
|
||
K key16,
|
||
V value16,
|
||
K key17,
|
||
V value17,
|
||
K key18,
|
||
V value18,
|
||
K key19,
|
||
V value19,
|
||
K key20,
|
||
V value20,
|
||
K key21,
|
||
V value21,
|
||
K key22,
|
||
V value22,
|
||
K key23,
|
||
V value23,
|
||
K key24,
|
||
V value24,
|
||
K key25,
|
||
V value25,
|
||
K key26,
|
||
V value26,
|
||
K key27,
|
||
V value27,
|
||
K key28,
|
||
V value28,
|
||
K key29,
|
||
V value29,
|
||
K key30,
|
||
V value30,
|
||
K key31,
|
||
V value31,
|
||
K key32,
|
||
V value32,
|
||
K key33,
|
||
V value33,
|
||
K key34,
|
||
V value34,
|
||
K key35,
|
||
V value35,
|
||
K key36,
|
||
V value36,
|
||
K key37,
|
||
V value37,
|
||
K key38,
|
||
V value38,
|
||
K key39,
|
||
V value39,
|
||
K key40,
|
||
V value40,
|
||
K key41,
|
||
V value41,
|
||
K key42,
|
||
V value42,
|
||
K key43,
|
||
V value43,
|
||
K key44,
|
||
V value44,
|
||
K key45,
|
||
V value45,
|
||
K key46,
|
||
V value46,
|
||
K key47,
|
||
V value47,
|
||
K key48,
|
||
V value48,
|
||
K key49,
|
||
V value49,
|
||
K key50,
|
||
V value50,
|
||
K key51,
|
||
V value51,
|
||
K key52,
|
||
V value52,
|
||
K key53,
|
||
V value53,
|
||
K key54,
|
||
V value54,
|
||
K key55,
|
||
V value55,
|
||
K key56,
|
||
V value56,
|
||
K key57,
|
||
V value57,
|
||
K key58,
|
||
V value58
|
||
) {
|
||
var map = new HashMap<K, V>(62);
|
||
map.put(key, value);
|
||
map.put(key2, value2);
|
||
map.put(key3, value3);
|
||
map.put(key4, value4);
|
||
map.put(key5, value5);
|
||
map.put(key6, value6);
|
||
map.put(key7, value7);
|
||
map.put(key8, value8);
|
||
map.put(key9, value9);
|
||
map.put(key10, value10);
|
||
map.put(key11, value11);
|
||
map.put(key12, value12);
|
||
map.put(key13, value13);
|
||
map.put(key14, value14);
|
||
map.put(key15, value15);
|
||
map.put(key16, value16);
|
||
map.put(key17, value17);
|
||
map.put(key18, value18);
|
||
map.put(key19, value19);
|
||
map.put(key20, value20);
|
||
map.put(key21, value21);
|
||
map.put(key22, value22);
|
||
map.put(key23, value23);
|
||
map.put(key24, value24);
|
||
map.put(key25, value25);
|
||
map.put(key26, value26);
|
||
map.put(key27, value27);
|
||
map.put(key28, value28);
|
||
map.put(key29, value29);
|
||
map.put(key30, value30);
|
||
map.put(key31, value31);
|
||
map.put(key32, value32);
|
||
map.put(key33, value33);
|
||
map.put(key34, value34);
|
||
map.put(key35, value35);
|
||
map.put(key36, value36);
|
||
map.put(key37, value37);
|
||
map.put(key38, value38);
|
||
map.put(key39, value39);
|
||
map.put(key40, value40);
|
||
map.put(key41, value41);
|
||
map.put(key42, value42);
|
||
map.put(key43, value43);
|
||
map.put(key44, value44);
|
||
map.put(key45, value45);
|
||
map.put(key46, value46);
|
||
map.put(key47, value47);
|
||
map.put(key48, value48);
|
||
map.put(key49, value49);
|
||
map.put(key50, value50);
|
||
map.put(key51, value51);
|
||
map.put(key52, value52);
|
||
map.put(key53, value53);
|
||
map.put(key54, value54);
|
||
map.put(key55, value55);
|
||
map.put(key56, value56);
|
||
map.put(key57, value57);
|
||
map.put(key58, value58);
|
||
return map;
|
||
}
|
||
|
||
public static <K, V> Map<K, V> of(
|
||
K key,
|
||
V value,
|
||
K key2,
|
||
V value2,
|
||
K key3,
|
||
V value3,
|
||
K key4,
|
||
V value4,
|
||
K key5,
|
||
V value5,
|
||
K key6,
|
||
V value6,
|
||
K key7,
|
||
V value7,
|
||
K key8,
|
||
V value8,
|
||
K key9,
|
||
V value9,
|
||
K key10,
|
||
V value10,
|
||
K key11,
|
||
V value11,
|
||
K key12,
|
||
V value12,
|
||
K key13,
|
||
V value13,
|
||
K key14,
|
||
V value14,
|
||
K key15,
|
||
V value15,
|
||
K key16,
|
||
V value16,
|
||
K key17,
|
||
V value17,
|
||
K key18,
|
||
V value18,
|
||
K key19,
|
||
V value19,
|
||
K key20,
|
||
V value20,
|
||
K key21,
|
||
V value21,
|
||
K key22,
|
||
V value22,
|
||
K key23,
|
||
V value23,
|
||
K key24,
|
||
V value24,
|
||
K key25,
|
||
V value25,
|
||
K key26,
|
||
V value26,
|
||
K key27,
|
||
V value27,
|
||
K key28,
|
||
V value28,
|
||
K key29,
|
||
V value29,
|
||
K key30,
|
||
V value30,
|
||
K key31,
|
||
V value31,
|
||
K key32,
|
||
V value32,
|
||
K key33,
|
||
V value33,
|
||
K key34,
|
||
V value34,
|
||
K key35,
|
||
V value35,
|
||
K key36,
|
||
V value36,
|
||
K key37,
|
||
V value37,
|
||
K key38,
|
||
V value38,
|
||
K key39,
|
||
V value39,
|
||
K key40,
|
||
V value40,
|
||
K key41,
|
||
V value41,
|
||
K key42,
|
||
V value42,
|
||
K key43,
|
||
V value43,
|
||
K key44,
|
||
V value44,
|
||
K key45,
|
||
V value45,
|
||
K key46,
|
||
V value46,
|
||
K key47,
|
||
V value47,
|
||
K key48,
|
||
V value48,
|
||
K key49,
|
||
V value49,
|
||
K key50,
|
||
V value50,
|
||
K key51,
|
||
V value51,
|
||
K key52,
|
||
V value52,
|
||
K key53,
|
||
V value53,
|
||
K key54,
|
||
V value54,
|
||
K key55,
|
||
V value55,
|
||
K key56,
|
||
V value56,
|
||
K key57,
|
||
V value57,
|
||
K key58,
|
||
V value58,
|
||
K key59,
|
||
V value59
|
||
) {
|
||
var map = new HashMap<K, V>(63);
|
||
map.put(key, value);
|
||
map.put(key2, value2);
|
||
map.put(key3, value3);
|
||
map.put(key4, value4);
|
||
map.put(key5, value5);
|
||
map.put(key6, value6);
|
||
map.put(key7, value7);
|
||
map.put(key8, value8);
|
||
map.put(key9, value9);
|
||
map.put(key10, value10);
|
||
map.put(key11, value11);
|
||
map.put(key12, value12);
|
||
map.put(key13, value13);
|
||
map.put(key14, value14);
|
||
map.put(key15, value15);
|
||
map.put(key16, value16);
|
||
map.put(key17, value17);
|
||
map.put(key18, value18);
|
||
map.put(key19, value19);
|
||
map.put(key20, value20);
|
||
map.put(key21, value21);
|
||
map.put(key22, value22);
|
||
map.put(key23, value23);
|
||
map.put(key24, value24);
|
||
map.put(key25, value25);
|
||
map.put(key26, value26);
|
||
map.put(key27, value27);
|
||
map.put(key28, value28);
|
||
map.put(key29, value29);
|
||
map.put(key30, value30);
|
||
map.put(key31, value31);
|
||
map.put(key32, value32);
|
||
map.put(key33, value33);
|
||
map.put(key34, value34);
|
||
map.put(key35, value35);
|
||
map.put(key36, value36);
|
||
map.put(key37, value37);
|
||
map.put(key38, value38);
|
||
map.put(key39, value39);
|
||
map.put(key40, value40);
|
||
map.put(key41, value41);
|
||
map.put(key42, value42);
|
||
map.put(key43, value43);
|
||
map.put(key44, value44);
|
||
map.put(key45, value45);
|
||
map.put(key46, value46);
|
||
map.put(key47, value47);
|
||
map.put(key48, value48);
|
||
map.put(key49, value49);
|
||
map.put(key50, value50);
|
||
map.put(key51, value51);
|
||
map.put(key52, value52);
|
||
map.put(key53, value53);
|
||
map.put(key54, value54);
|
||
map.put(key55, value55);
|
||
map.put(key56, value56);
|
||
map.put(key57, value57);
|
||
map.put(key58, value58);
|
||
map.put(key59, value59);
|
||
return map;
|
||
}
|
||
|
||
public static <K, V> Map<K, V> of(
|
||
K key,
|
||
V value,
|
||
K key2,
|
||
V value2,
|
||
K key3,
|
||
V value3,
|
||
K key4,
|
||
V value4,
|
||
K key5,
|
||
V value5,
|
||
K key6,
|
||
V value6,
|
||
K key7,
|
||
V value7,
|
||
K key8,
|
||
V value8,
|
||
K key9,
|
||
V value9,
|
||
K key10,
|
||
V value10,
|
||
K key11,
|
||
V value11,
|
||
K key12,
|
||
V value12,
|
||
K key13,
|
||
V value13,
|
||
K key14,
|
||
V value14,
|
||
K key15,
|
||
V value15,
|
||
K key16,
|
||
V value16,
|
||
K key17,
|
||
V value17,
|
||
K key18,
|
||
V value18,
|
||
K key19,
|
||
V value19,
|
||
K key20,
|
||
V value20,
|
||
K key21,
|
||
V value21,
|
||
K key22,
|
||
V value22,
|
||
K key23,
|
||
V value23,
|
||
K key24,
|
||
V value24,
|
||
K key25,
|
||
V value25,
|
||
K key26,
|
||
V value26,
|
||
K key27,
|
||
V value27,
|
||
K key28,
|
||
V value28,
|
||
K key29,
|
||
V value29,
|
||
K key30,
|
||
V value30,
|
||
K key31,
|
||
V value31,
|
||
K key32,
|
||
V value32,
|
||
K key33,
|
||
V value33,
|
||
K key34,
|
||
V value34,
|
||
K key35,
|
||
V value35,
|
||
K key36,
|
||
V value36,
|
||
K key37,
|
||
V value37,
|
||
K key38,
|
||
V value38,
|
||
K key39,
|
||
V value39,
|
||
K key40,
|
||
V value40,
|
||
K key41,
|
||
V value41,
|
||
K key42,
|
||
V value42,
|
||
K key43,
|
||
V value43,
|
||
K key44,
|
||
V value44,
|
||
K key45,
|
||
V value45,
|
||
K key46,
|
||
V value46,
|
||
K key47,
|
||
V value47,
|
||
K key48,
|
||
V value48,
|
||
K key49,
|
||
V value49,
|
||
K key50,
|
||
V value50,
|
||
K key51,
|
||
V value51,
|
||
K key52,
|
||
V value52,
|
||
K key53,
|
||
V value53,
|
||
K key54,
|
||
V value54,
|
||
K key55,
|
||
V value55,
|
||
K key56,
|
||
V value56,
|
||
K key57,
|
||
V value57,
|
||
K key58,
|
||
V value58,
|
||
K key59,
|
||
V value59,
|
||
K key60,
|
||
V value60
|
||
) {
|
||
var map = new HashMap<K, V>(64);
|
||
map.put(key, value);
|
||
map.put(key2, value2);
|
||
map.put(key3, value3);
|
||
map.put(key4, value4);
|
||
map.put(key5, value5);
|
||
map.put(key6, value6);
|
||
map.put(key7, value7);
|
||
map.put(key8, value8);
|
||
map.put(key9, value9);
|
||
map.put(key10, value10);
|
||
map.put(key11, value11);
|
||
map.put(key12, value12);
|
||
map.put(key13, value13);
|
||
map.put(key14, value14);
|
||
map.put(key15, value15);
|
||
map.put(key16, value16);
|
||
map.put(key17, value17);
|
||
map.put(key18, value18);
|
||
map.put(key19, value19);
|
||
map.put(key20, value20);
|
||
map.put(key21, value21);
|
||
map.put(key22, value22);
|
||
map.put(key23, value23);
|
||
map.put(key24, value24);
|
||
map.put(key25, value25);
|
||
map.put(key26, value26);
|
||
map.put(key27, value27);
|
||
map.put(key28, value28);
|
||
map.put(key29, value29);
|
||
map.put(key30, value30);
|
||
map.put(key31, value31);
|
||
map.put(key32, value32);
|
||
map.put(key33, value33);
|
||
map.put(key34, value34);
|
||
map.put(key35, value35);
|
||
map.put(key36, value36);
|
||
map.put(key37, value37);
|
||
map.put(key38, value38);
|
||
map.put(key39, value39);
|
||
map.put(key40, value40);
|
||
map.put(key41, value41);
|
||
map.put(key42, value42);
|
||
map.put(key43, value43);
|
||
map.put(key44, value44);
|
||
map.put(key45, value45);
|
||
map.put(key46, value46);
|
||
map.put(key47, value47);
|
||
map.put(key48, value48);
|
||
map.put(key49, value49);
|
||
map.put(key50, value50);
|
||
map.put(key51, value51);
|
||
map.put(key52, value52);
|
||
map.put(key53, value53);
|
||
map.put(key54, value54);
|
||
map.put(key55, value55);
|
||
map.put(key56, value56);
|
||
map.put(key57, value57);
|
||
map.put(key58, value58);
|
||
map.put(key59, value59);
|
||
map.put(key60, value60);
|
||
return map;
|
||
}
|
||
|
||
public static <K, V> Map<K, V> of(
|
||
K key,
|
||
V value,
|
||
K key2,
|
||
V value2,
|
||
K key3,
|
||
V value3,
|
||
K key4,
|
||
V value4,
|
||
K key5,
|
||
V value5,
|
||
K key6,
|
||
V value6,
|
||
K key7,
|
||
V value7,
|
||
K key8,
|
||
V value8,
|
||
K key9,
|
||
V value9,
|
||
K key10,
|
||
V value10,
|
||
K key11,
|
||
V value11,
|
||
K key12,
|
||
V value12,
|
||
K key13,
|
||
V value13,
|
||
K key14,
|
||
V value14,
|
||
K key15,
|
||
V value15,
|
||
K key16,
|
||
V value16,
|
||
K key17,
|
||
V value17,
|
||
K key18,
|
||
V value18,
|
||
K key19,
|
||
V value19,
|
||
K key20,
|
||
V value20,
|
||
K key21,
|
||
V value21,
|
||
K key22,
|
||
V value22,
|
||
K key23,
|
||
V value23,
|
||
K key24,
|
||
V value24,
|
||
K key25,
|
||
V value25,
|
||
K key26,
|
||
V value26,
|
||
K key27,
|
||
V value27,
|
||
K key28,
|
||
V value28,
|
||
K key29,
|
||
V value29,
|
||
K key30,
|
||
V value30,
|
||
K key31,
|
||
V value31,
|
||
K key32,
|
||
V value32,
|
||
K key33,
|
||
V value33,
|
||
K key34,
|
||
V value34,
|
||
K key35,
|
||
V value35,
|
||
K key36,
|
||
V value36,
|
||
K key37,
|
||
V value37,
|
||
K key38,
|
||
V value38,
|
||
K key39,
|
||
V value39,
|
||
K key40,
|
||
V value40,
|
||
K key41,
|
||
V value41,
|
||
K key42,
|
||
V value42,
|
||
K key43,
|
||
V value43,
|
||
K key44,
|
||
V value44,
|
||
K key45,
|
||
V value45,
|
||
K key46,
|
||
V value46,
|
||
K key47,
|
||
V value47,
|
||
K key48,
|
||
V value48,
|
||
K key49,
|
||
V value49,
|
||
K key50,
|
||
V value50,
|
||
K key51,
|
||
V value51,
|
||
K key52,
|
||
V value52,
|
||
K key53,
|
||
V value53,
|
||
K key54,
|
||
V value54,
|
||
K key55,
|
||
V value55,
|
||
K key56,
|
||
V value56,
|
||
K key57,
|
||
V value57,
|
||
K key58,
|
||
V value58,
|
||
K key59,
|
||
V value59,
|
||
K key60,
|
||
V value60,
|
||
K key61,
|
||
V value61
|
||
) {
|
||
var map = new HashMap<K, V>(65);
|
||
map.put(key, value);
|
||
map.put(key2, value2);
|
||
map.put(key3, value3);
|
||
map.put(key4, value4);
|
||
map.put(key5, value5);
|
||
map.put(key6, value6);
|
||
map.put(key7, value7);
|
||
map.put(key8, value8);
|
||
map.put(key9, value9);
|
||
map.put(key10, value10);
|
||
map.put(key11, value11);
|
||
map.put(key12, value12);
|
||
map.put(key13, value13);
|
||
map.put(key14, value14);
|
||
map.put(key15, value15);
|
||
map.put(key16, value16);
|
||
map.put(key17, value17);
|
||
map.put(key18, value18);
|
||
map.put(key19, value19);
|
||
map.put(key20, value20);
|
||
map.put(key21, value21);
|
||
map.put(key22, value22);
|
||
map.put(key23, value23);
|
||
map.put(key24, value24);
|
||
map.put(key25, value25);
|
||
map.put(key26, value26);
|
||
map.put(key27, value27);
|
||
map.put(key28, value28);
|
||
map.put(key29, value29);
|
||
map.put(key30, value30);
|
||
map.put(key31, value31);
|
||
map.put(key32, value32);
|
||
map.put(key33, value33);
|
||
map.put(key34, value34);
|
||
map.put(key35, value35);
|
||
map.put(key36, value36);
|
||
map.put(key37, value37);
|
||
map.put(key38, value38);
|
||
map.put(key39, value39);
|
||
map.put(key40, value40);
|
||
map.put(key41, value41);
|
||
map.put(key42, value42);
|
||
map.put(key43, value43);
|
||
map.put(key44, value44);
|
||
map.put(key45, value45);
|
||
map.put(key46, value46);
|
||
map.put(key47, value47);
|
||
map.put(key48, value48);
|
||
map.put(key49, value49);
|
||
map.put(key50, value50);
|
||
map.put(key51, value51);
|
||
map.put(key52, value52);
|
||
map.put(key53, value53);
|
||
map.put(key54, value54);
|
||
map.put(key55, value55);
|
||
map.put(key56, value56);
|
||
map.put(key57, value57);
|
||
map.put(key58, value58);
|
||
map.put(key59, value59);
|
||
map.put(key60, value60);
|
||
map.put(key61, value61);
|
||
return map;
|
||
}
|
||
|
||
public static <K, V> Map<K, V> of(
|
||
K key,
|
||
V value,
|
||
K key2,
|
||
V value2,
|
||
K key3,
|
||
V value3,
|
||
K key4,
|
||
V value4,
|
||
K key5,
|
||
V value5,
|
||
K key6,
|
||
V value6,
|
||
K key7,
|
||
V value7,
|
||
K key8,
|
||
V value8,
|
||
K key9,
|
||
V value9,
|
||
K key10,
|
||
V value10,
|
||
K key11,
|
||
V value11,
|
||
K key12,
|
||
V value12,
|
||
K key13,
|
||
V value13,
|
||
K key14,
|
||
V value14,
|
||
K key15,
|
||
V value15,
|
||
K key16,
|
||
V value16,
|
||
K key17,
|
||
V value17,
|
||
K key18,
|
||
V value18,
|
||
K key19,
|
||
V value19,
|
||
K key20,
|
||
V value20,
|
||
K key21,
|
||
V value21,
|
||
K key22,
|
||
V value22,
|
||
K key23,
|
||
V value23,
|
||
K key24,
|
||
V value24,
|
||
K key25,
|
||
V value25,
|
||
K key26,
|
||
V value26,
|
||
K key27,
|
||
V value27,
|
||
K key28,
|
||
V value28,
|
||
K key29,
|
||
V value29,
|
||
K key30,
|
||
V value30,
|
||
K key31,
|
||
V value31,
|
||
K key32,
|
||
V value32,
|
||
K key33,
|
||
V value33,
|
||
K key34,
|
||
V value34,
|
||
K key35,
|
||
V value35,
|
||
K key36,
|
||
V value36,
|
||
K key37,
|
||
V value37,
|
||
K key38,
|
||
V value38,
|
||
K key39,
|
||
V value39,
|
||
K key40,
|
||
V value40,
|
||
K key41,
|
||
V value41,
|
||
K key42,
|
||
V value42,
|
||
K key43,
|
||
V value43,
|
||
K key44,
|
||
V value44,
|
||
K key45,
|
||
V value45,
|
||
K key46,
|
||
V value46,
|
||
K key47,
|
||
V value47,
|
||
K key48,
|
||
V value48,
|
||
K key49,
|
||
V value49,
|
||
K key50,
|
||
V value50,
|
||
K key51,
|
||
V value51,
|
||
K key52,
|
||
V value52,
|
||
K key53,
|
||
V value53,
|
||
K key54,
|
||
V value54,
|
||
K key55,
|
||
V value55,
|
||
K key56,
|
||
V value56,
|
||
K key57,
|
||
V value57,
|
||
K key58,
|
||
V value58,
|
||
K key59,
|
||
V value59,
|
||
K key60,
|
||
V value60,
|
||
K key61,
|
||
V value61,
|
||
K key62,
|
||
V value62
|
||
) {
|
||
var map = new HashMap<K, V>(66);
|
||
map.put(key, value);
|
||
map.put(key2, value2);
|
||
map.put(key3, value3);
|
||
map.put(key4, value4);
|
||
map.put(key5, value5);
|
||
map.put(key6, value6);
|
||
map.put(key7, value7);
|
||
map.put(key8, value8);
|
||
map.put(key9, value9);
|
||
map.put(key10, value10);
|
||
map.put(key11, value11);
|
||
map.put(key12, value12);
|
||
map.put(key13, value13);
|
||
map.put(key14, value14);
|
||
map.put(key15, value15);
|
||
map.put(key16, value16);
|
||
map.put(key17, value17);
|
||
map.put(key18, value18);
|
||
map.put(key19, value19);
|
||
map.put(key20, value20);
|
||
map.put(key21, value21);
|
||
map.put(key22, value22);
|
||
map.put(key23, value23);
|
||
map.put(key24, value24);
|
||
map.put(key25, value25);
|
||
map.put(key26, value26);
|
||
map.put(key27, value27);
|
||
map.put(key28, value28);
|
||
map.put(key29, value29);
|
||
map.put(key30, value30);
|
||
map.put(key31, value31);
|
||
map.put(key32, value32);
|
||
map.put(key33, value33);
|
||
map.put(key34, value34);
|
||
map.put(key35, value35);
|
||
map.put(key36, value36);
|
||
map.put(key37, value37);
|
||
map.put(key38, value38);
|
||
map.put(key39, value39);
|
||
map.put(key40, value40);
|
||
map.put(key41, value41);
|
||
map.put(key42, value42);
|
||
map.put(key43, value43);
|
||
map.put(key44, value44);
|
||
map.put(key45, value45);
|
||
map.put(key46, value46);
|
||
map.put(key47, value47);
|
||
map.put(key48, value48);
|
||
map.put(key49, value49);
|
||
map.put(key50, value50);
|
||
map.put(key51, value51);
|
||
map.put(key52, value52);
|
||
map.put(key53, value53);
|
||
map.put(key54, value54);
|
||
map.put(key55, value55);
|
||
map.put(key56, value56);
|
||
map.put(key57, value57);
|
||
map.put(key58, value58);
|
||
map.put(key59, value59);
|
||
map.put(key60, value60);
|
||
map.put(key61, value61);
|
||
map.put(key62, value62);
|
||
return map;
|
||
}
|
||
|
||
public static <K, V> Map<K, V> of(
|
||
K key,
|
||
V value,
|
||
K key2,
|
||
V value2,
|
||
K key3,
|
||
V value3,
|
||
K key4,
|
||
V value4,
|
||
K key5,
|
||
V value5,
|
||
K key6,
|
||
V value6,
|
||
K key7,
|
||
V value7,
|
||
K key8,
|
||
V value8,
|
||
K key9,
|
||
V value9,
|
||
K key10,
|
||
V value10,
|
||
K key11,
|
||
V value11,
|
||
K key12,
|
||
V value12,
|
||
K key13,
|
||
V value13,
|
||
K key14,
|
||
V value14,
|
||
K key15,
|
||
V value15,
|
||
K key16,
|
||
V value16,
|
||
K key17,
|
||
V value17,
|
||
K key18,
|
||
V value18,
|
||
K key19,
|
||
V value19,
|
||
K key20,
|
||
V value20,
|
||
K key21,
|
||
V value21,
|
||
K key22,
|
||
V value22,
|
||
K key23,
|
||
V value23,
|
||
K key24,
|
||
V value24,
|
||
K key25,
|
||
V value25,
|
||
K key26,
|
||
V value26,
|
||
K key27,
|
||
V value27,
|
||
K key28,
|
||
V value28,
|
||
K key29,
|
||
V value29,
|
||
K key30,
|
||
V value30,
|
||
K key31,
|
||
V value31,
|
||
K key32,
|
||
V value32,
|
||
K key33,
|
||
V value33,
|
||
K key34,
|
||
V value34,
|
||
K key35,
|
||
V value35,
|
||
K key36,
|
||
V value36,
|
||
K key37,
|
||
V value37,
|
||
K key38,
|
||
V value38,
|
||
K key39,
|
||
V value39,
|
||
K key40,
|
||
V value40,
|
||
K key41,
|
||
V value41,
|
||
K key42,
|
||
V value42,
|
||
K key43,
|
||
V value43,
|
||
K key44,
|
||
V value44,
|
||
K key45,
|
||
V value45,
|
||
K key46,
|
||
V value46,
|
||
K key47,
|
||
V value47,
|
||
K key48,
|
||
V value48,
|
||
K key49,
|
||
V value49,
|
||
K key50,
|
||
V value50,
|
||
K key51,
|
||
V value51,
|
||
K key52,
|
||
V value52,
|
||
K key53,
|
||
V value53,
|
||
K key54,
|
||
V value54,
|
||
K key55,
|
||
V value55,
|
||
K key56,
|
||
V value56,
|
||
K key57,
|
||
V value57,
|
||
K key58,
|
||
V value58,
|
||
K key59,
|
||
V value59,
|
||
K key60,
|
||
V value60,
|
||
K key61,
|
||
V value61,
|
||
K key62,
|
||
V value62,
|
||
K key63,
|
||
V value63
|
||
) {
|
||
var map = new HashMap<K, V>(67);
|
||
map.put(key, value);
|
||
map.put(key2, value2);
|
||
map.put(key3, value3);
|
||
map.put(key4, value4);
|
||
map.put(key5, value5);
|
||
map.put(key6, value6);
|
||
map.put(key7, value7);
|
||
map.put(key8, value8);
|
||
map.put(key9, value9);
|
||
map.put(key10, value10);
|
||
map.put(key11, value11);
|
||
map.put(key12, value12);
|
||
map.put(key13, value13);
|
||
map.put(key14, value14);
|
||
map.put(key15, value15);
|
||
map.put(key16, value16);
|
||
map.put(key17, value17);
|
||
map.put(key18, value18);
|
||
map.put(key19, value19);
|
||
map.put(key20, value20);
|
||
map.put(key21, value21);
|
||
map.put(key22, value22);
|
||
map.put(key23, value23);
|
||
map.put(key24, value24);
|
||
map.put(key25, value25);
|
||
map.put(key26, value26);
|
||
map.put(key27, value27);
|
||
map.put(key28, value28);
|
||
map.put(key29, value29);
|
||
map.put(key30, value30);
|
||
map.put(key31, value31);
|
||
map.put(key32, value32);
|
||
map.put(key33, value33);
|
||
map.put(key34, value34);
|
||
map.put(key35, value35);
|
||
map.put(key36, value36);
|
||
map.put(key37, value37);
|
||
map.put(key38, value38);
|
||
map.put(key39, value39);
|
||
map.put(key40, value40);
|
||
map.put(key41, value41);
|
||
map.put(key42, value42);
|
||
map.put(key43, value43);
|
||
map.put(key44, value44);
|
||
map.put(key45, value45);
|
||
map.put(key46, value46);
|
||
map.put(key47, value47);
|
||
map.put(key48, value48);
|
||
map.put(key49, value49);
|
||
map.put(key50, value50);
|
||
map.put(key51, value51);
|
||
map.put(key52, value52);
|
||
map.put(key53, value53);
|
||
map.put(key54, value54);
|
||
map.put(key55, value55);
|
||
map.put(key56, value56);
|
||
map.put(key57, value57);
|
||
map.put(key58, value58);
|
||
map.put(key59, value59);
|
||
map.put(key60, value60);
|
||
map.put(key61, value61);
|
||
map.put(key62, value62);
|
||
map.put(key63, value63);
|
||
return map;
|
||
}
|
||
|
||
public static <K, V> Map<K, V> of(
|
||
K key,
|
||
V value,
|
||
K key2,
|
||
V value2,
|
||
K key3,
|
||
V value3,
|
||
K key4,
|
||
V value4,
|
||
K key5,
|
||
V value5,
|
||
K key6,
|
||
V value6,
|
||
K key7,
|
||
V value7,
|
||
K key8,
|
||
V value8,
|
||
K key9,
|
||
V value9,
|
||
K key10,
|
||
V value10,
|
||
K key11,
|
||
V value11,
|
||
K key12,
|
||
V value12,
|
||
K key13,
|
||
V value13,
|
||
K key14,
|
||
V value14,
|
||
K key15,
|
||
V value15,
|
||
K key16,
|
||
V value16,
|
||
K key17,
|
||
V value17,
|
||
K key18,
|
||
V value18,
|
||
K key19,
|
||
V value19,
|
||
K key20,
|
||
V value20,
|
||
K key21,
|
||
V value21,
|
||
K key22,
|
||
V value22,
|
||
K key23,
|
||
V value23,
|
||
K key24,
|
||
V value24,
|
||
K key25,
|
||
V value25,
|
||
K key26,
|
||
V value26,
|
||
K key27,
|
||
V value27,
|
||
K key28,
|
||
V value28,
|
||
K key29,
|
||
V value29,
|
||
K key30,
|
||
V value30,
|
||
K key31,
|
||
V value31,
|
||
K key32,
|
||
V value32,
|
||
K key33,
|
||
V value33,
|
||
K key34,
|
||
V value34,
|
||
K key35,
|
||
V value35,
|
||
K key36,
|
||
V value36,
|
||
K key37,
|
||
V value37,
|
||
K key38,
|
||
V value38,
|
||
K key39,
|
||
V value39,
|
||
K key40,
|
||
V value40,
|
||
K key41,
|
||
V value41,
|
||
K key42,
|
||
V value42,
|
||
K key43,
|
||
V value43,
|
||
K key44,
|
||
V value44,
|
||
K key45,
|
||
V value45,
|
||
K key46,
|
||
V value46,
|
||
K key47,
|
||
V value47,
|
||
K key48,
|
||
V value48,
|
||
K key49,
|
||
V value49,
|
||
K key50,
|
||
V value50,
|
||
K key51,
|
||
V value51,
|
||
K key52,
|
||
V value52,
|
||
K key53,
|
||
V value53,
|
||
K key54,
|
||
V value54,
|
||
K key55,
|
||
V value55,
|
||
K key56,
|
||
V value56,
|
||
K key57,
|
||
V value57,
|
||
K key58,
|
||
V value58,
|
||
K key59,
|
||
V value59,
|
||
K key60,
|
||
V value60,
|
||
K key61,
|
||
V value61,
|
||
K key62,
|
||
V value62,
|
||
K key63,
|
||
V value63,
|
||
K key64,
|
||
V value64
|
||
) {
|
||
var map = new HashMap<K, V>(68);
|
||
map.put(key, value);
|
||
map.put(key2, value2);
|
||
map.put(key3, value3);
|
||
map.put(key4, value4);
|
||
map.put(key5, value5);
|
||
map.put(key6, value6);
|
||
map.put(key7, value7);
|
||
map.put(key8, value8);
|
||
map.put(key9, value9);
|
||
map.put(key10, value10);
|
||
map.put(key11, value11);
|
||
map.put(key12, value12);
|
||
map.put(key13, value13);
|
||
map.put(key14, value14);
|
||
map.put(key15, value15);
|
||
map.put(key16, value16);
|
||
map.put(key17, value17);
|
||
map.put(key18, value18);
|
||
map.put(key19, value19);
|
||
map.put(key20, value20);
|
||
map.put(key21, value21);
|
||
map.put(key22, value22);
|
||
map.put(key23, value23);
|
||
map.put(key24, value24);
|
||
map.put(key25, value25);
|
||
map.put(key26, value26);
|
||
map.put(key27, value27);
|
||
map.put(key28, value28);
|
||
map.put(key29, value29);
|
||
map.put(key30, value30);
|
||
map.put(key31, value31);
|
||
map.put(key32, value32);
|
||
map.put(key33, value33);
|
||
map.put(key34, value34);
|
||
map.put(key35, value35);
|
||
map.put(key36, value36);
|
||
map.put(key37, value37);
|
||
map.put(key38, value38);
|
||
map.put(key39, value39);
|
||
map.put(key40, value40);
|
||
map.put(key41, value41);
|
||
map.put(key42, value42);
|
||
map.put(key43, value43);
|
||
map.put(key44, value44);
|
||
map.put(key45, value45);
|
||
map.put(key46, value46);
|
||
map.put(key47, value47);
|
||
map.put(key48, value48);
|
||
map.put(key49, value49);
|
||
map.put(key50, value50);
|
||
map.put(key51, value51);
|
||
map.put(key52, value52);
|
||
map.put(key53, value53);
|
||
map.put(key54, value54);
|
||
map.put(key55, value55);
|
||
map.put(key56, value56);
|
||
map.put(key57, value57);
|
||
map.put(key58, value58);
|
||
map.put(key59, value59);
|
||
map.put(key60, value60);
|
||
map.put(key61, value61);
|
||
map.put(key62, value62);
|
||
map.put(key63, value63);
|
||
map.put(key64, value64);
|
||
return map;
|
||
}
|
||
|
||
public static <K, V> Map<K, V> of(
|
||
K key,
|
||
V value,
|
||
K key2,
|
||
V value2,
|
||
K key3,
|
||
V value3,
|
||
K key4,
|
||
V value4,
|
||
K key5,
|
||
V value5,
|
||
K key6,
|
||
V value6,
|
||
K key7,
|
||
V value7,
|
||
K key8,
|
||
V value8,
|
||
K key9,
|
||
V value9,
|
||
K key10,
|
||
V value10,
|
||
K key11,
|
||
V value11,
|
||
K key12,
|
||
V value12,
|
||
K key13,
|
||
V value13,
|
||
K key14,
|
||
V value14,
|
||
K key15,
|
||
V value15,
|
||
K key16,
|
||
V value16,
|
||
K key17,
|
||
V value17,
|
||
K key18,
|
||
V value18,
|
||
K key19,
|
||
V value19,
|
||
K key20,
|
||
V value20,
|
||
K key21,
|
||
V value21,
|
||
K key22,
|
||
V value22,
|
||
K key23,
|
||
V value23,
|
||
K key24,
|
||
V value24,
|
||
K key25,
|
||
V value25,
|
||
K key26,
|
||
V value26,
|
||
K key27,
|
||
V value27,
|
||
K key28,
|
||
V value28,
|
||
K key29,
|
||
V value29,
|
||
K key30,
|
||
V value30,
|
||
K key31,
|
||
V value31,
|
||
K key32,
|
||
V value32,
|
||
K key33,
|
||
V value33,
|
||
K key34,
|
||
V value34,
|
||
K key35,
|
||
V value35,
|
||
K key36,
|
||
V value36,
|
||
K key37,
|
||
V value37,
|
||
K key38,
|
||
V value38,
|
||
K key39,
|
||
V value39,
|
||
K key40,
|
||
V value40,
|
||
K key41,
|
||
V value41,
|
||
K key42,
|
||
V value42,
|
||
K key43,
|
||
V value43,
|
||
K key44,
|
||
V value44,
|
||
K key45,
|
||
V value45,
|
||
K key46,
|
||
V value46,
|
||
K key47,
|
||
V value47,
|
||
K key48,
|
||
V value48,
|
||
K key49,
|
||
V value49,
|
||
K key50,
|
||
V value50,
|
||
K key51,
|
||
V value51,
|
||
K key52,
|
||
V value52,
|
||
K key53,
|
||
V value53,
|
||
K key54,
|
||
V value54,
|
||
K key55,
|
||
V value55,
|
||
K key56,
|
||
V value56,
|
||
K key57,
|
||
V value57,
|
||
K key58,
|
||
V value58,
|
||
K key59,
|
||
V value59,
|
||
K key60,
|
||
V value60,
|
||
K key61,
|
||
V value61,
|
||
K key62,
|
||
V value62,
|
||
K key63,
|
||
V value63,
|
||
K key64,
|
||
V value64,
|
||
K key65,
|
||
V value65
|
||
) {
|
||
var map = new HashMap<K, V>(69);
|
||
map.put(key, value);
|
||
map.put(key2, value2);
|
||
map.put(key3, value3);
|
||
map.put(key4, value4);
|
||
map.put(key5, value5);
|
||
map.put(key6, value6);
|
||
map.put(key7, value7);
|
||
map.put(key8, value8);
|
||
map.put(key9, value9);
|
||
map.put(key10, value10);
|
||
map.put(key11, value11);
|
||
map.put(key12, value12);
|
||
map.put(key13, value13);
|
||
map.put(key14, value14);
|
||
map.put(key15, value15);
|
||
map.put(key16, value16);
|
||
map.put(key17, value17);
|
||
map.put(key18, value18);
|
||
map.put(key19, value19);
|
||
map.put(key20, value20);
|
||
map.put(key21, value21);
|
||
map.put(key22, value22);
|
||
map.put(key23, value23);
|
||
map.put(key24, value24);
|
||
map.put(key25, value25);
|
||
map.put(key26, value26);
|
||
map.put(key27, value27);
|
||
map.put(key28, value28);
|
||
map.put(key29, value29);
|
||
map.put(key30, value30);
|
||
map.put(key31, value31);
|
||
map.put(key32, value32);
|
||
map.put(key33, value33);
|
||
map.put(key34, value34);
|
||
map.put(key35, value35);
|
||
map.put(key36, value36);
|
||
map.put(key37, value37);
|
||
map.put(key38, value38);
|
||
map.put(key39, value39);
|
||
map.put(key40, value40);
|
||
map.put(key41, value41);
|
||
map.put(key42, value42);
|
||
map.put(key43, value43);
|
||
map.put(key44, value44);
|
||
map.put(key45, value45);
|
||
map.put(key46, value46);
|
||
map.put(key47, value47);
|
||
map.put(key48, value48);
|
||
map.put(key49, value49);
|
||
map.put(key50, value50);
|
||
map.put(key51, value51);
|
||
map.put(key52, value52);
|
||
map.put(key53, value53);
|
||
map.put(key54, value54);
|
||
map.put(key55, value55);
|
||
map.put(key56, value56);
|
||
map.put(key57, value57);
|
||
map.put(key58, value58);
|
||
map.put(key59, value59);
|
||
map.put(key60, value60);
|
||
map.put(key61, value61);
|
||
map.put(key62, value62);
|
||
map.put(key63, value63);
|
||
map.put(key64, value64);
|
||
map.put(key65, value65);
|
||
return map;
|
||
}
|
||
|
||
public static <K, V> Map<K, V> of(
|
||
K key,
|
||
V value,
|
||
K key2,
|
||
V value2,
|
||
K key3,
|
||
V value3,
|
||
K key4,
|
||
V value4,
|
||
K key5,
|
||
V value5,
|
||
K key6,
|
||
V value6,
|
||
K key7,
|
||
V value7,
|
||
K key8,
|
||
V value8,
|
||
K key9,
|
||
V value9,
|
||
K key10,
|
||
V value10,
|
||
K key11,
|
||
V value11,
|
||
K key12,
|
||
V value12,
|
||
K key13,
|
||
V value13,
|
||
K key14,
|
||
V value14,
|
||
K key15,
|
||
V value15,
|
||
K key16,
|
||
V value16,
|
||
K key17,
|
||
V value17,
|
||
K key18,
|
||
V value18,
|
||
K key19,
|
||
V value19,
|
||
K key20,
|
||
V value20,
|
||
K key21,
|
||
V value21,
|
||
K key22,
|
||
V value22,
|
||
K key23,
|
||
V value23,
|
||
K key24,
|
||
V value24,
|
||
K key25,
|
||
V value25,
|
||
K key26,
|
||
V value26,
|
||
K key27,
|
||
V value27,
|
||
K key28,
|
||
V value28,
|
||
K key29,
|
||
V value29,
|
||
K key30,
|
||
V value30,
|
||
K key31,
|
||
V value31,
|
||
K key32,
|
||
V value32,
|
||
K key33,
|
||
V value33,
|
||
K key34,
|
||
V value34,
|
||
K key35,
|
||
V value35,
|
||
K key36,
|
||
V value36,
|
||
K key37,
|
||
V value37,
|
||
K key38,
|
||
V value38,
|
||
K key39,
|
||
V value39,
|
||
K key40,
|
||
V value40,
|
||
K key41,
|
||
V value41,
|
||
K key42,
|
||
V value42,
|
||
K key43,
|
||
V value43,
|
||
K key44,
|
||
V value44,
|
||
K key45,
|
||
V value45,
|
||
K key46,
|
||
V value46,
|
||
K key47,
|
||
V value47,
|
||
K key48,
|
||
V value48,
|
||
K key49,
|
||
V value49,
|
||
K key50,
|
||
V value50,
|
||
K key51,
|
||
V value51,
|
||
K key52,
|
||
V value52,
|
||
K key53,
|
||
V value53,
|
||
K key54,
|
||
V value54,
|
||
K key55,
|
||
V value55,
|
||
K key56,
|
||
V value56,
|
||
K key57,
|
||
V value57,
|
||
K key58,
|
||
V value58,
|
||
K key59,
|
||
V value59,
|
||
K key60,
|
||
V value60,
|
||
K key61,
|
||
V value61,
|
||
K key62,
|
||
V value62,
|
||
K key63,
|
||
V value63,
|
||
K key64,
|
||
V value64,
|
||
K key65,
|
||
V value65,
|
||
K key66,
|
||
V value66
|
||
) {
|
||
var map = new HashMap<K, V>(70);
|
||
map.put(key, value);
|
||
map.put(key2, value2);
|
||
map.put(key3, value3);
|
||
map.put(key4, value4);
|
||
map.put(key5, value5);
|
||
map.put(key6, value6);
|
||
map.put(key7, value7);
|
||
map.put(key8, value8);
|
||
map.put(key9, value9);
|
||
map.put(key10, value10);
|
||
map.put(key11, value11);
|
||
map.put(key12, value12);
|
||
map.put(key13, value13);
|
||
map.put(key14, value14);
|
||
map.put(key15, value15);
|
||
map.put(key16, value16);
|
||
map.put(key17, value17);
|
||
map.put(key18, value18);
|
||
map.put(key19, value19);
|
||
map.put(key20, value20);
|
||
map.put(key21, value21);
|
||
map.put(key22, value22);
|
||
map.put(key23, value23);
|
||
map.put(key24, value24);
|
||
map.put(key25, value25);
|
||
map.put(key26, value26);
|
||
map.put(key27, value27);
|
||
map.put(key28, value28);
|
||
map.put(key29, value29);
|
||
map.put(key30, value30);
|
||
map.put(key31, value31);
|
||
map.put(key32, value32);
|
||
map.put(key33, value33);
|
||
map.put(key34, value34);
|
||
map.put(key35, value35);
|
||
map.put(key36, value36);
|
||
map.put(key37, value37);
|
||
map.put(key38, value38);
|
||
map.put(key39, value39);
|
||
map.put(key40, value40);
|
||
map.put(key41, value41);
|
||
map.put(key42, value42);
|
||
map.put(key43, value43);
|
||
map.put(key44, value44);
|
||
map.put(key45, value45);
|
||
map.put(key46, value46);
|
||
map.put(key47, value47);
|
||
map.put(key48, value48);
|
||
map.put(key49, value49);
|
||
map.put(key50, value50);
|
||
map.put(key51, value51);
|
||
map.put(key52, value52);
|
||
map.put(key53, value53);
|
||
map.put(key54, value54);
|
||
map.put(key55, value55);
|
||
map.put(key56, value56);
|
||
map.put(key57, value57);
|
||
map.put(key58, value58);
|
||
map.put(key59, value59);
|
||
map.put(key60, value60);
|
||
map.put(key61, value61);
|
||
map.put(key62, value62);
|
||
map.put(key63, value63);
|
||
map.put(key64, value64);
|
||
map.put(key65, value65);
|
||
map.put(key66, value66);
|
||
return map;
|
||
}
|
||
|
||
public static <K, V> Map<K, V> of(
|
||
K key,
|
||
V value,
|
||
K key2,
|
||
V value2,
|
||
K key3,
|
||
V value3,
|
||
K key4,
|
||
V value4,
|
||
K key5,
|
||
V value5,
|
||
K key6,
|
||
V value6,
|
||
K key7,
|
||
V value7,
|
||
K key8,
|
||
V value8,
|
||
K key9,
|
||
V value9,
|
||
K key10,
|
||
V value10,
|
||
K key11,
|
||
V value11,
|
||
K key12,
|
||
V value12,
|
||
K key13,
|
||
V value13,
|
||
K key14,
|
||
V value14,
|
||
K key15,
|
||
V value15,
|
||
K key16,
|
||
V value16,
|
||
K key17,
|
||
V value17,
|
||
K key18,
|
||
V value18,
|
||
K key19,
|
||
V value19,
|
||
K key20,
|
||
V value20,
|
||
K key21,
|
||
V value21,
|
||
K key22,
|
||
V value22,
|
||
K key23,
|
||
V value23,
|
||
K key24,
|
||
V value24,
|
||
K key25,
|
||
V value25,
|
||
K key26,
|
||
V value26,
|
||
K key27,
|
||
V value27,
|
||
K key28,
|
||
V value28,
|
||
K key29,
|
||
V value29,
|
||
K key30,
|
||
V value30,
|
||
K key31,
|
||
V value31,
|
||
K key32,
|
||
V value32,
|
||
K key33,
|
||
V value33,
|
||
K key34,
|
||
V value34,
|
||
K key35,
|
||
V value35,
|
||
K key36,
|
||
V value36,
|
||
K key37,
|
||
V value37,
|
||
K key38,
|
||
V value38,
|
||
K key39,
|
||
V value39,
|
||
K key40,
|
||
V value40,
|
||
K key41,
|
||
V value41,
|
||
K key42,
|
||
V value42,
|
||
K key43,
|
||
V value43,
|
||
K key44,
|
||
V value44,
|
||
K key45,
|
||
V value45,
|
||
K key46,
|
||
V value46,
|
||
K key47,
|
||
V value47,
|
||
K key48,
|
||
V value48,
|
||
K key49,
|
||
V value49,
|
||
K key50,
|
||
V value50,
|
||
K key51,
|
||
V value51,
|
||
K key52,
|
||
V value52,
|
||
K key53,
|
||
V value53,
|
||
K key54,
|
||
V value54,
|
||
K key55,
|
||
V value55,
|
||
K key56,
|
||
V value56,
|
||
K key57,
|
||
V value57,
|
||
K key58,
|
||
V value58,
|
||
K key59,
|
||
V value59,
|
||
K key60,
|
||
V value60,
|
||
K key61,
|
||
V value61,
|
||
K key62,
|
||
V value62,
|
||
K key63,
|
||
V value63,
|
||
K key64,
|
||
V value64,
|
||
K key65,
|
||
V value65,
|
||
K key66,
|
||
V value66,
|
||
K key67,
|
||
V value67
|
||
) {
|
||
var map = new HashMap<K, V>(71);
|
||
map.put(key, value);
|
||
map.put(key2, value2);
|
||
map.put(key3, value3);
|
||
map.put(key4, value4);
|
||
map.put(key5, value5);
|
||
map.put(key6, value6);
|
||
map.put(key7, value7);
|
||
map.put(key8, value8);
|
||
map.put(key9, value9);
|
||
map.put(key10, value10);
|
||
map.put(key11, value11);
|
||
map.put(key12, value12);
|
||
map.put(key13, value13);
|
||
map.put(key14, value14);
|
||
map.put(key15, value15);
|
||
map.put(key16, value16);
|
||
map.put(key17, value17);
|
||
map.put(key18, value18);
|
||
map.put(key19, value19);
|
||
map.put(key20, value20);
|
||
map.put(key21, value21);
|
||
map.put(key22, value22);
|
||
map.put(key23, value23);
|
||
map.put(key24, value24);
|
||
map.put(key25, value25);
|
||
map.put(key26, value26);
|
||
map.put(key27, value27);
|
||
map.put(key28, value28);
|
||
map.put(key29, value29);
|
||
map.put(key30, value30);
|
||
map.put(key31, value31);
|
||
map.put(key32, value32);
|
||
map.put(key33, value33);
|
||
map.put(key34, value34);
|
||
map.put(key35, value35);
|
||
map.put(key36, value36);
|
||
map.put(key37, value37);
|
||
map.put(key38, value38);
|
||
map.put(key39, value39);
|
||
map.put(key40, value40);
|
||
map.put(key41, value41);
|
||
map.put(key42, value42);
|
||
map.put(key43, value43);
|
||
map.put(key44, value44);
|
||
map.put(key45, value45);
|
||
map.put(key46, value46);
|
||
map.put(key47, value47);
|
||
map.put(key48, value48);
|
||
map.put(key49, value49);
|
||
map.put(key50, value50);
|
||
map.put(key51, value51);
|
||
map.put(key52, value52);
|
||
map.put(key53, value53);
|
||
map.put(key54, value54);
|
||
map.put(key55, value55);
|
||
map.put(key56, value56);
|
||
map.put(key57, value57);
|
||
map.put(key58, value58);
|
||
map.put(key59, value59);
|
||
map.put(key60, value60);
|
||
map.put(key61, value61);
|
||
map.put(key62, value62);
|
||
map.put(key63, value63);
|
||
map.put(key64, value64);
|
||
map.put(key65, value65);
|
||
map.put(key66, value66);
|
||
map.put(key67, value67);
|
||
return map;
|
||
}
|
||
|
||
public static <K, V> Map<K, V> of(
|
||
K key,
|
||
V value,
|
||
K key2,
|
||
V value2,
|
||
K key3,
|
||
V value3,
|
||
K key4,
|
||
V value4,
|
||
K key5,
|
||
V value5,
|
||
K key6,
|
||
V value6,
|
||
K key7,
|
||
V value7,
|
||
K key8,
|
||
V value8,
|
||
K key9,
|
||
V value9,
|
||
K key10,
|
||
V value10,
|
||
K key11,
|
||
V value11,
|
||
K key12,
|
||
V value12,
|
||
K key13,
|
||
V value13,
|
||
K key14,
|
||
V value14,
|
||
K key15,
|
||
V value15,
|
||
K key16,
|
||
V value16,
|
||
K key17,
|
||
V value17,
|
||
K key18,
|
||
V value18,
|
||
K key19,
|
||
V value19,
|
||
K key20,
|
||
V value20,
|
||
K key21,
|
||
V value21,
|
||
K key22,
|
||
V value22,
|
||
K key23,
|
||
V value23,
|
||
K key24,
|
||
V value24,
|
||
K key25,
|
||
V value25,
|
||
K key26,
|
||
V value26,
|
||
K key27,
|
||
V value27,
|
||
K key28,
|
||
V value28,
|
||
K key29,
|
||
V value29,
|
||
K key30,
|
||
V value30,
|
||
K key31,
|
||
V value31,
|
||
K key32,
|
||
V value32,
|
||
K key33,
|
||
V value33,
|
||
K key34,
|
||
V value34,
|
||
K key35,
|
||
V value35,
|
||
K key36,
|
||
V value36,
|
||
K key37,
|
||
V value37,
|
||
K key38,
|
||
V value38,
|
||
K key39,
|
||
V value39,
|
||
K key40,
|
||
V value40,
|
||
K key41,
|
||
V value41,
|
||
K key42,
|
||
V value42,
|
||
K key43,
|
||
V value43,
|
||
K key44,
|
||
V value44,
|
||
K key45,
|
||
V value45,
|
||
K key46,
|
||
V value46,
|
||
K key47,
|
||
V value47,
|
||
K key48,
|
||
V value48,
|
||
K key49,
|
||
V value49,
|
||
K key50,
|
||
V value50,
|
||
K key51,
|
||
V value51,
|
||
K key52,
|
||
V value52,
|
||
K key53,
|
||
V value53,
|
||
K key54,
|
||
V value54,
|
||
K key55,
|
||
V value55,
|
||
K key56,
|
||
V value56,
|
||
K key57,
|
||
V value57,
|
||
K key58,
|
||
V value58,
|
||
K key59,
|
||
V value59,
|
||
K key60,
|
||
V value60,
|
||
K key61,
|
||
V value61,
|
||
K key62,
|
||
V value62,
|
||
K key63,
|
||
V value63,
|
||
K key64,
|
||
V value64,
|
||
K key65,
|
||
V value65,
|
||
K key66,
|
||
V value66,
|
||
K key67,
|
||
V value67,
|
||
K key68,
|
||
V value68
|
||
) {
|
||
var map = new HashMap<K, V>(72);
|
||
map.put(key, value);
|
||
map.put(key2, value2);
|
||
map.put(key3, value3);
|
||
map.put(key4, value4);
|
||
map.put(key5, value5);
|
||
map.put(key6, value6);
|
||
map.put(key7, value7);
|
||
map.put(key8, value8);
|
||
map.put(key9, value9);
|
||
map.put(key10, value10);
|
||
map.put(key11, value11);
|
||
map.put(key12, value12);
|
||
map.put(key13, value13);
|
||
map.put(key14, value14);
|
||
map.put(key15, value15);
|
||
map.put(key16, value16);
|
||
map.put(key17, value17);
|
||
map.put(key18, value18);
|
||
map.put(key19, value19);
|
||
map.put(key20, value20);
|
||
map.put(key21, value21);
|
||
map.put(key22, value22);
|
||
map.put(key23, value23);
|
||
map.put(key24, value24);
|
||
map.put(key25, value25);
|
||
map.put(key26, value26);
|
||
map.put(key27, value27);
|
||
map.put(key28, value28);
|
||
map.put(key29, value29);
|
||
map.put(key30, value30);
|
||
map.put(key31, value31);
|
||
map.put(key32, value32);
|
||
map.put(key33, value33);
|
||
map.put(key34, value34);
|
||
map.put(key35, value35);
|
||
map.put(key36, value36);
|
||
map.put(key37, value37);
|
||
map.put(key38, value38);
|
||
map.put(key39, value39);
|
||
map.put(key40, value40);
|
||
map.put(key41, value41);
|
||
map.put(key42, value42);
|
||
map.put(key43, value43);
|
||
map.put(key44, value44);
|
||
map.put(key45, value45);
|
||
map.put(key46, value46);
|
||
map.put(key47, value47);
|
||
map.put(key48, value48);
|
||
map.put(key49, value49);
|
||
map.put(key50, value50);
|
||
map.put(key51, value51);
|
||
map.put(key52, value52);
|
||
map.put(key53, value53);
|
||
map.put(key54, value54);
|
||
map.put(key55, value55);
|
||
map.put(key56, value56);
|
||
map.put(key57, value57);
|
||
map.put(key58, value58);
|
||
map.put(key59, value59);
|
||
map.put(key60, value60);
|
||
map.put(key61, value61);
|
||
map.put(key62, value62);
|
||
map.put(key63, value63);
|
||
map.put(key64, value64);
|
||
map.put(key65, value65);
|
||
map.put(key66, value66);
|
||
map.put(key67, value67);
|
||
map.put(key68, value68);
|
||
return map;
|
||
}
|
||
|
||
public static <K, V> Map<K, V> of(
|
||
K key,
|
||
V value,
|
||
K key2,
|
||
V value2,
|
||
K key3,
|
||
V value3,
|
||
K key4,
|
||
V value4,
|
||
K key5,
|
||
V value5,
|
||
K key6,
|
||
V value6,
|
||
K key7,
|
||
V value7,
|
||
K key8,
|
||
V value8,
|
||
K key9,
|
||
V value9,
|
||
K key10,
|
||
V value10,
|
||
K key11,
|
||
V value11,
|
||
K key12,
|
||
V value12,
|
||
K key13,
|
||
V value13,
|
||
K key14,
|
||
V value14,
|
||
K key15,
|
||
V value15,
|
||
K key16,
|
||
V value16,
|
||
K key17,
|
||
V value17,
|
||
K key18,
|
||
V value18,
|
||
K key19,
|
||
V value19,
|
||
K key20,
|
||
V value20,
|
||
K key21,
|
||
V value21,
|
||
K key22,
|
||
V value22,
|
||
K key23,
|
||
V value23,
|
||
K key24,
|
||
V value24,
|
||
K key25,
|
||
V value25,
|
||
K key26,
|
||
V value26,
|
||
K key27,
|
||
V value27,
|
||
K key28,
|
||
V value28,
|
||
K key29,
|
||
V value29,
|
||
K key30,
|
||
V value30,
|
||
K key31,
|
||
V value31,
|
||
K key32,
|
||
V value32,
|
||
K key33,
|
||
V value33,
|
||
K key34,
|
||
V value34,
|
||
K key35,
|
||
V value35,
|
||
K key36,
|
||
V value36,
|
||
K key37,
|
||
V value37,
|
||
K key38,
|
||
V value38,
|
||
K key39,
|
||
V value39,
|
||
K key40,
|
||
V value40,
|
||
K key41,
|
||
V value41,
|
||
K key42,
|
||
V value42,
|
||
K key43,
|
||
V value43,
|
||
K key44,
|
||
V value44,
|
||
K key45,
|
||
V value45,
|
||
K key46,
|
||
V value46,
|
||
K key47,
|
||
V value47,
|
||
K key48,
|
||
V value48,
|
||
K key49,
|
||
V value49,
|
||
K key50,
|
||
V value50,
|
||
K key51,
|
||
V value51,
|
||
K key52,
|
||
V value52,
|
||
K key53,
|
||
V value53,
|
||
K key54,
|
||
V value54,
|
||
K key55,
|
||
V value55,
|
||
K key56,
|
||
V value56,
|
||
K key57,
|
||
V value57,
|
||
K key58,
|
||
V value58,
|
||
K key59,
|
||
V value59,
|
||
K key60,
|
||
V value60,
|
||
K key61,
|
||
V value61,
|
||
K key62,
|
||
V value62,
|
||
K key63,
|
||
V value63,
|
||
K key64,
|
||
V value64,
|
||
K key65,
|
||
V value65,
|
||
K key66,
|
||
V value66,
|
||
K key67,
|
||
V value67,
|
||
K key68,
|
||
V value68,
|
||
K key69,
|
||
V value69
|
||
) {
|
||
var map = new HashMap<K, V>(73);
|
||
map.put(key, value);
|
||
map.put(key2, value2);
|
||
map.put(key3, value3);
|
||
map.put(key4, value4);
|
||
map.put(key5, value5);
|
||
map.put(key6, value6);
|
||
map.put(key7, value7);
|
||
map.put(key8, value8);
|
||
map.put(key9, value9);
|
||
map.put(key10, value10);
|
||
map.put(key11, value11);
|
||
map.put(key12, value12);
|
||
map.put(key13, value13);
|
||
map.put(key14, value14);
|
||
map.put(key15, value15);
|
||
map.put(key16, value16);
|
||
map.put(key17, value17);
|
||
map.put(key18, value18);
|
||
map.put(key19, value19);
|
||
map.put(key20, value20);
|
||
map.put(key21, value21);
|
||
map.put(key22, value22);
|
||
map.put(key23, value23);
|
||
map.put(key24, value24);
|
||
map.put(key25, value25);
|
||
map.put(key26, value26);
|
||
map.put(key27, value27);
|
||
map.put(key28, value28);
|
||
map.put(key29, value29);
|
||
map.put(key30, value30);
|
||
map.put(key31, value31);
|
||
map.put(key32, value32);
|
||
map.put(key33, value33);
|
||
map.put(key34, value34);
|
||
map.put(key35, value35);
|
||
map.put(key36, value36);
|
||
map.put(key37, value37);
|
||
map.put(key38, value38);
|
||
map.put(key39, value39);
|
||
map.put(key40, value40);
|
||
map.put(key41, value41);
|
||
map.put(key42, value42);
|
||
map.put(key43, value43);
|
||
map.put(key44, value44);
|
||
map.put(key45, value45);
|
||
map.put(key46, value46);
|
||
map.put(key47, value47);
|
||
map.put(key48, value48);
|
||
map.put(key49, value49);
|
||
map.put(key50, value50);
|
||
map.put(key51, value51);
|
||
map.put(key52, value52);
|
||
map.put(key53, value53);
|
||
map.put(key54, value54);
|
||
map.put(key55, value55);
|
||
map.put(key56, value56);
|
||
map.put(key57, value57);
|
||
map.put(key58, value58);
|
||
map.put(key59, value59);
|
||
map.put(key60, value60);
|
||
map.put(key61, value61);
|
||
map.put(key62, value62);
|
||
map.put(key63, value63);
|
||
map.put(key64, value64);
|
||
map.put(key65, value65);
|
||
map.put(key66, value66);
|
||
map.put(key67, value67);
|
||
map.put(key68, value68);
|
||
map.put(key69, value69);
|
||
return map;
|
||
}
|
||
|
||
public static <K, V> Map<K, V> of(
|
||
K key,
|
||
V value,
|
||
K key2,
|
||
V value2,
|
||
K key3,
|
||
V value3,
|
||
K key4,
|
||
V value4,
|
||
K key5,
|
||
V value5,
|
||
K key6,
|
||
V value6,
|
||
K key7,
|
||
V value7,
|
||
K key8,
|
||
V value8,
|
||
K key9,
|
||
V value9,
|
||
K key10,
|
||
V value10,
|
||
K key11,
|
||
V value11,
|
||
K key12,
|
||
V value12,
|
||
K key13,
|
||
V value13,
|
||
K key14,
|
||
V value14,
|
||
K key15,
|
||
V value15,
|
||
K key16,
|
||
V value16,
|
||
K key17,
|
||
V value17,
|
||
K key18,
|
||
V value18,
|
||
K key19,
|
||
V value19,
|
||
K key20,
|
||
V value20,
|
||
K key21,
|
||
V value21,
|
||
K key22,
|
||
V value22,
|
||
K key23,
|
||
V value23,
|
||
K key24,
|
||
V value24,
|
||
K key25,
|
||
V value25,
|
||
K key26,
|
||
V value26,
|
||
K key27,
|
||
V value27,
|
||
K key28,
|
||
V value28,
|
||
K key29,
|
||
V value29,
|
||
K key30,
|
||
V value30,
|
||
K key31,
|
||
V value31,
|
||
K key32,
|
||
V value32,
|
||
K key33,
|
||
V value33,
|
||
K key34,
|
||
V value34,
|
||
K key35,
|
||
V value35,
|
||
K key36,
|
||
V value36,
|
||
K key37,
|
||
V value37,
|
||
K key38,
|
||
V value38,
|
||
K key39,
|
||
V value39,
|
||
K key40,
|
||
V value40,
|
||
K key41,
|
||
V value41,
|
||
K key42,
|
||
V value42,
|
||
K key43,
|
||
V value43,
|
||
K key44,
|
||
V value44,
|
||
K key45,
|
||
V value45,
|
||
K key46,
|
||
V value46,
|
||
K key47,
|
||
V value47,
|
||
K key48,
|
||
V value48,
|
||
K key49,
|
||
V value49,
|
||
K key50,
|
||
V value50,
|
||
K key51,
|
||
V value51,
|
||
K key52,
|
||
V value52,
|
||
K key53,
|
||
V value53,
|
||
K key54,
|
||
V value54,
|
||
K key55,
|
||
V value55,
|
||
K key56,
|
||
V value56,
|
||
K key57,
|
||
V value57,
|
||
K key58,
|
||
V value58,
|
||
K key59,
|
||
V value59,
|
||
K key60,
|
||
V value60,
|
||
K key61,
|
||
V value61,
|
||
K key62,
|
||
V value62,
|
||
K key63,
|
||
V value63,
|
||
K key64,
|
||
V value64,
|
||
K key65,
|
||
V value65,
|
||
K key66,
|
||
V value66,
|
||
K key67,
|
||
V value67,
|
||
K key68,
|
||
V value68,
|
||
K key69,
|
||
V value69,
|
||
K key70,
|
||
V value70
|
||
) {
|
||
var map = new HashMap<K, V>(74);
|
||
map.put(key, value);
|
||
map.put(key2, value2);
|
||
map.put(key3, value3);
|
||
map.put(key4, value4);
|
||
map.put(key5, value5);
|
||
map.put(key6, value6);
|
||
map.put(key7, value7);
|
||
map.put(key8, value8);
|
||
map.put(key9, value9);
|
||
map.put(key10, value10);
|
||
map.put(key11, value11);
|
||
map.put(key12, value12);
|
||
map.put(key13, value13);
|
||
map.put(key14, value14);
|
||
map.put(key15, value15);
|
||
map.put(key16, value16);
|
||
map.put(key17, value17);
|
||
map.put(key18, value18);
|
||
map.put(key19, value19);
|
||
map.put(key20, value20);
|
||
map.put(key21, value21);
|
||
map.put(key22, value22);
|
||
map.put(key23, value23);
|
||
map.put(key24, value24);
|
||
map.put(key25, value25);
|
||
map.put(key26, value26);
|
||
map.put(key27, value27);
|
||
map.put(key28, value28);
|
||
map.put(key29, value29);
|
||
map.put(key30, value30);
|
||
map.put(key31, value31);
|
||
map.put(key32, value32);
|
||
map.put(key33, value33);
|
||
map.put(key34, value34);
|
||
map.put(key35, value35);
|
||
map.put(key36, value36);
|
||
map.put(key37, value37);
|
||
map.put(key38, value38);
|
||
map.put(key39, value39);
|
||
map.put(key40, value40);
|
||
map.put(key41, value41);
|
||
map.put(key42, value42);
|
||
map.put(key43, value43);
|
||
map.put(key44, value44);
|
||
map.put(key45, value45);
|
||
map.put(key46, value46);
|
||
map.put(key47, value47);
|
||
map.put(key48, value48);
|
||
map.put(key49, value49);
|
||
map.put(key50, value50);
|
||
map.put(key51, value51);
|
||
map.put(key52, value52);
|
||
map.put(key53, value53);
|
||
map.put(key54, value54);
|
||
map.put(key55, value55);
|
||
map.put(key56, value56);
|
||
map.put(key57, value57);
|
||
map.put(key58, value58);
|
||
map.put(key59, value59);
|
||
map.put(key60, value60);
|
||
map.put(key61, value61);
|
||
map.put(key62, value62);
|
||
map.put(key63, value63);
|
||
map.put(key64, value64);
|
||
map.put(key65, value65);
|
||
map.put(key66, value66);
|
||
map.put(key67, value67);
|
||
map.put(key68, value68);
|
||
map.put(key69, value69);
|
||
map.put(key70, value70);
|
||
return map;
|
||
}
|
||
|
||
public static <K, V> Map<K, V> of(
|
||
K key,
|
||
V value,
|
||
K key2,
|
||
V value2,
|
||
K key3,
|
||
V value3,
|
||
K key4,
|
||
V value4,
|
||
K key5,
|
||
V value5,
|
||
K key6,
|
||
V value6,
|
||
K key7,
|
||
V value7,
|
||
K key8,
|
||
V value8,
|
||
K key9,
|
||
V value9,
|
||
K key10,
|
||
V value10,
|
||
K key11,
|
||
V value11,
|
||
K key12,
|
||
V value12,
|
||
K key13,
|
||
V value13,
|
||
K key14,
|
||
V value14,
|
||
K key15,
|
||
V value15,
|
||
K key16,
|
||
V value16,
|
||
K key17,
|
||
V value17,
|
||
K key18,
|
||
V value18,
|
||
K key19,
|
||
V value19,
|
||
K key20,
|
||
V value20,
|
||
K key21,
|
||
V value21,
|
||
K key22,
|
||
V value22,
|
||
K key23,
|
||
V value23,
|
||
K key24,
|
||
V value24,
|
||
K key25,
|
||
V value25,
|
||
K key26,
|
||
V value26,
|
||
K key27,
|
||
V value27,
|
||
K key28,
|
||
V value28,
|
||
K key29,
|
||
V value29,
|
||
K key30,
|
||
V value30,
|
||
K key31,
|
||
V value31,
|
||
K key32,
|
||
V value32,
|
||
K key33,
|
||
V value33,
|
||
K key34,
|
||
V value34,
|
||
K key35,
|
||
V value35,
|
||
K key36,
|
||
V value36,
|
||
K key37,
|
||
V value37,
|
||
K key38,
|
||
V value38,
|
||
K key39,
|
||
V value39,
|
||
K key40,
|
||
V value40,
|
||
K key41,
|
||
V value41,
|
||
K key42,
|
||
V value42,
|
||
K key43,
|
||
V value43,
|
||
K key44,
|
||
V value44,
|
||
K key45,
|
||
V value45,
|
||
K key46,
|
||
V value46,
|
||
K key47,
|
||
V value47,
|
||
K key48,
|
||
V value48,
|
||
K key49,
|
||
V value49,
|
||
K key50,
|
||
V value50,
|
||
K key51,
|
||
V value51,
|
||
K key52,
|
||
V value52,
|
||
K key53,
|
||
V value53,
|
||
K key54,
|
||
V value54,
|
||
K key55,
|
||
V value55,
|
||
K key56,
|
||
V value56,
|
||
K key57,
|
||
V value57,
|
||
K key58,
|
||
V value58,
|
||
K key59,
|
||
V value59,
|
||
K key60,
|
||
V value60,
|
||
K key61,
|
||
V value61,
|
||
K key62,
|
||
V value62,
|
||
K key63,
|
||
V value63,
|
||
K key64,
|
||
V value64,
|
||
K key65,
|
||
V value65,
|
||
K key66,
|
||
V value66,
|
||
K key67,
|
||
V value67,
|
||
K key68,
|
||
V value68,
|
||
K key69,
|
||
V value69,
|
||
K key70,
|
||
V value70,
|
||
K key71,
|
||
V value71
|
||
) {
|
||
var map = new HashMap<K, V>(75);
|
||
map.put(key, value);
|
||
map.put(key2, value2);
|
||
map.put(key3, value3);
|
||
map.put(key4, value4);
|
||
map.put(key5, value5);
|
||
map.put(key6, value6);
|
||
map.put(key7, value7);
|
||
map.put(key8, value8);
|
||
map.put(key9, value9);
|
||
map.put(key10, value10);
|
||
map.put(key11, value11);
|
||
map.put(key12, value12);
|
||
map.put(key13, value13);
|
||
map.put(key14, value14);
|
||
map.put(key15, value15);
|
||
map.put(key16, value16);
|
||
map.put(key17, value17);
|
||
map.put(key18, value18);
|
||
map.put(key19, value19);
|
||
map.put(key20, value20);
|
||
map.put(key21, value21);
|
||
map.put(key22, value22);
|
||
map.put(key23, value23);
|
||
map.put(key24, value24);
|
||
map.put(key25, value25);
|
||
map.put(key26, value26);
|
||
map.put(key27, value27);
|
||
map.put(key28, value28);
|
||
map.put(key29, value29);
|
||
map.put(key30, value30);
|
||
map.put(key31, value31);
|
||
map.put(key32, value32);
|
||
map.put(key33, value33);
|
||
map.put(key34, value34);
|
||
map.put(key35, value35);
|
||
map.put(key36, value36);
|
||
map.put(key37, value37);
|
||
map.put(key38, value38);
|
||
map.put(key39, value39);
|
||
map.put(key40, value40);
|
||
map.put(key41, value41);
|
||
map.put(key42, value42);
|
||
map.put(key43, value43);
|
||
map.put(key44, value44);
|
||
map.put(key45, value45);
|
||
map.put(key46, value46);
|
||
map.put(key47, value47);
|
||
map.put(key48, value48);
|
||
map.put(key49, value49);
|
||
map.put(key50, value50);
|
||
map.put(key51, value51);
|
||
map.put(key52, value52);
|
||
map.put(key53, value53);
|
||
map.put(key54, value54);
|
||
map.put(key55, value55);
|
||
map.put(key56, value56);
|
||
map.put(key57, value57);
|
||
map.put(key58, value58);
|
||
map.put(key59, value59);
|
||
map.put(key60, value60);
|
||
map.put(key61, value61);
|
||
map.put(key62, value62);
|
||
map.put(key63, value63);
|
||
map.put(key64, value64);
|
||
map.put(key65, value65);
|
||
map.put(key66, value66);
|
||
map.put(key67, value67);
|
||
map.put(key68, value68);
|
||
map.put(key69, value69);
|
||
map.put(key70, value70);
|
||
map.put(key71, value71);
|
||
return map;
|
||
}
|
||
|
||
public static <K, V> Map<K, V> of(
|
||
K key,
|
||
V value,
|
||
K key2,
|
||
V value2,
|
||
K key3,
|
||
V value3,
|
||
K key4,
|
||
V value4,
|
||
K key5,
|
||
V value5,
|
||
K key6,
|
||
V value6,
|
||
K key7,
|
||
V value7,
|
||
K key8,
|
||
V value8,
|
||
K key9,
|
||
V value9,
|
||
K key10,
|
||
V value10,
|
||
K key11,
|
||
V value11,
|
||
K key12,
|
||
V value12,
|
||
K key13,
|
||
V value13,
|
||
K key14,
|
||
V value14,
|
||
K key15,
|
||
V value15,
|
||
K key16,
|
||
V value16,
|
||
K key17,
|
||
V value17,
|
||
K key18,
|
||
V value18,
|
||
K key19,
|
||
V value19,
|
||
K key20,
|
||
V value20,
|
||
K key21,
|
||
V value21,
|
||
K key22,
|
||
V value22,
|
||
K key23,
|
||
V value23,
|
||
K key24,
|
||
V value24,
|
||
K key25,
|
||
V value25,
|
||
K key26,
|
||
V value26,
|
||
K key27,
|
||
V value27,
|
||
K key28,
|
||
V value28,
|
||
K key29,
|
||
V value29,
|
||
K key30,
|
||
V value30,
|
||
K key31,
|
||
V value31,
|
||
K key32,
|
||
V value32,
|
||
K key33,
|
||
V value33,
|
||
K key34,
|
||
V value34,
|
||
K key35,
|
||
V value35,
|
||
K key36,
|
||
V value36,
|
||
K key37,
|
||
V value37,
|
||
K key38,
|
||
V value38,
|
||
K key39,
|
||
V value39,
|
||
K key40,
|
||
V value40,
|
||
K key41,
|
||
V value41,
|
||
K key42,
|
||
V value42,
|
||
K key43,
|
||
V value43,
|
||
K key44,
|
||
V value44,
|
||
K key45,
|
||
V value45,
|
||
K key46,
|
||
V value46,
|
||
K key47,
|
||
V value47,
|
||
K key48,
|
||
V value48,
|
||
K key49,
|
||
V value49,
|
||
K key50,
|
||
V value50,
|
||
K key51,
|
||
V value51,
|
||
K key52,
|
||
V value52,
|
||
K key53,
|
||
V value53,
|
||
K key54,
|
||
V value54,
|
||
K key55,
|
||
V value55,
|
||
K key56,
|
||
V value56,
|
||
K key57,
|
||
V value57,
|
||
K key58,
|
||
V value58,
|
||
K key59,
|
||
V value59,
|
||
K key60,
|
||
V value60,
|
||
K key61,
|
||
V value61,
|
||
K key62,
|
||
V value62,
|
||
K key63,
|
||
V value63,
|
||
K key64,
|
||
V value64,
|
||
K key65,
|
||
V value65,
|
||
K key66,
|
||
V value66,
|
||
K key67,
|
||
V value67,
|
||
K key68,
|
||
V value68,
|
||
K key69,
|
||
V value69,
|
||
K key70,
|
||
V value70,
|
||
K key71,
|
||
V value71,
|
||
K key72,
|
||
V value72
|
||
) {
|
||
var map = new HashMap<K, V>(76);
|
||
map.put(key, value);
|
||
map.put(key2, value2);
|
||
map.put(key3, value3);
|
||
map.put(key4, value4);
|
||
map.put(key5, value5);
|
||
map.put(key6, value6);
|
||
map.put(key7, value7);
|
||
map.put(key8, value8);
|
||
map.put(key9, value9);
|
||
map.put(key10, value10);
|
||
map.put(key11, value11);
|
||
map.put(key12, value12);
|
||
map.put(key13, value13);
|
||
map.put(key14, value14);
|
||
map.put(key15, value15);
|
||
map.put(key16, value16);
|
||
map.put(key17, value17);
|
||
map.put(key18, value18);
|
||
map.put(key19, value19);
|
||
map.put(key20, value20);
|
||
map.put(key21, value21);
|
||
map.put(key22, value22);
|
||
map.put(key23, value23);
|
||
map.put(key24, value24);
|
||
map.put(key25, value25);
|
||
map.put(key26, value26);
|
||
map.put(key27, value27);
|
||
map.put(key28, value28);
|
||
map.put(key29, value29);
|
||
map.put(key30, value30);
|
||
map.put(key31, value31);
|
||
map.put(key32, value32);
|
||
map.put(key33, value33);
|
||
map.put(key34, value34);
|
||
map.put(key35, value35);
|
||
map.put(key36, value36);
|
||
map.put(key37, value37);
|
||
map.put(key38, value38);
|
||
map.put(key39, value39);
|
||
map.put(key40, value40);
|
||
map.put(key41, value41);
|
||
map.put(key42, value42);
|
||
map.put(key43, value43);
|
||
map.put(key44, value44);
|
||
map.put(key45, value45);
|
||
map.put(key46, value46);
|
||
map.put(key47, value47);
|
||
map.put(key48, value48);
|
||
map.put(key49, value49);
|
||
map.put(key50, value50);
|
||
map.put(key51, value51);
|
||
map.put(key52, value52);
|
||
map.put(key53, value53);
|
||
map.put(key54, value54);
|
||
map.put(key55, value55);
|
||
map.put(key56, value56);
|
||
map.put(key57, value57);
|
||
map.put(key58, value58);
|
||
map.put(key59, value59);
|
||
map.put(key60, value60);
|
||
map.put(key61, value61);
|
||
map.put(key62, value62);
|
||
map.put(key63, value63);
|
||
map.put(key64, value64);
|
||
map.put(key65, value65);
|
||
map.put(key66, value66);
|
||
map.put(key67, value67);
|
||
map.put(key68, value68);
|
||
map.put(key69, value69);
|
||
map.put(key70, value70);
|
||
map.put(key71, value71);
|
||
map.put(key72, value72);
|
||
return map;
|
||
}
|
||
|
||
public static <K, V> Map<K, V> of(
|
||
K key,
|
||
V value,
|
||
K key2,
|
||
V value2,
|
||
K key3,
|
||
V value3,
|
||
K key4,
|
||
V value4,
|
||
K key5,
|
||
V value5,
|
||
K key6,
|
||
V value6,
|
||
K key7,
|
||
V value7,
|
||
K key8,
|
||
V value8,
|
||
K key9,
|
||
V value9,
|
||
K key10,
|
||
V value10,
|
||
K key11,
|
||
V value11,
|
||
K key12,
|
||
V value12,
|
||
K key13,
|
||
V value13,
|
||
K key14,
|
||
V value14,
|
||
K key15,
|
||
V value15,
|
||
K key16,
|
||
V value16,
|
||
K key17,
|
||
V value17,
|
||
K key18,
|
||
V value18,
|
||
K key19,
|
||
V value19,
|
||
K key20,
|
||
V value20,
|
||
K key21,
|
||
V value21,
|
||
K key22,
|
||
V value22,
|
||
K key23,
|
||
V value23,
|
||
K key24,
|
||
V value24,
|
||
K key25,
|
||
V value25,
|
||
K key26,
|
||
V value26,
|
||
K key27,
|
||
V value27,
|
||
K key28,
|
||
V value28,
|
||
K key29,
|
||
V value29,
|
||
K key30,
|
||
V value30,
|
||
K key31,
|
||
V value31,
|
||
K key32,
|
||
V value32,
|
||
K key33,
|
||
V value33,
|
||
K key34,
|
||
V value34,
|
||
K key35,
|
||
V value35,
|
||
K key36,
|
||
V value36,
|
||
K key37,
|
||
V value37,
|
||
K key38,
|
||
V value38,
|
||
K key39,
|
||
V value39,
|
||
K key40,
|
||
V value40,
|
||
K key41,
|
||
V value41,
|
||
K key42,
|
||
V value42,
|
||
K key43,
|
||
V value43,
|
||
K key44,
|
||
V value44,
|
||
K key45,
|
||
V value45,
|
||
K key46,
|
||
V value46,
|
||
K key47,
|
||
V value47,
|
||
K key48,
|
||
V value48,
|
||
K key49,
|
||
V value49,
|
||
K key50,
|
||
V value50,
|
||
K key51,
|
||
V value51,
|
||
K key52,
|
||
V value52,
|
||
K key53,
|
||
V value53,
|
||
K key54,
|
||
V value54,
|
||
K key55,
|
||
V value55,
|
||
K key56,
|
||
V value56,
|
||
K key57,
|
||
V value57,
|
||
K key58,
|
||
V value58,
|
||
K key59,
|
||
V value59,
|
||
K key60,
|
||
V value60,
|
||
K key61,
|
||
V value61,
|
||
K key62,
|
||
V value62,
|
||
K key63,
|
||
V value63,
|
||
K key64,
|
||
V value64,
|
||
K key65,
|
||
V value65,
|
||
K key66,
|
||
V value66,
|
||
K key67,
|
||
V value67,
|
||
K key68,
|
||
V value68,
|
||
K key69,
|
||
V value69,
|
||
K key70,
|
||
V value70,
|
||
K key71,
|
||
V value71,
|
||
K key72,
|
||
V value72,
|
||
K key73,
|
||
V value73
|
||
) {
|
||
var map = new HashMap<K, V>(77);
|
||
map.put(key, value);
|
||
map.put(key2, value2);
|
||
map.put(key3, value3);
|
||
map.put(key4, value4);
|
||
map.put(key5, value5);
|
||
map.put(key6, value6);
|
||
map.put(key7, value7);
|
||
map.put(key8, value8);
|
||
map.put(key9, value9);
|
||
map.put(key10, value10);
|
||
map.put(key11, value11);
|
||
map.put(key12, value12);
|
||
map.put(key13, value13);
|
||
map.put(key14, value14);
|
||
map.put(key15, value15);
|
||
map.put(key16, value16);
|
||
map.put(key17, value17);
|
||
map.put(key18, value18);
|
||
map.put(key19, value19);
|
||
map.put(key20, value20);
|
||
map.put(key21, value21);
|
||
map.put(key22, value22);
|
||
map.put(key23, value23);
|
||
map.put(key24, value24);
|
||
map.put(key25, value25);
|
||
map.put(key26, value26);
|
||
map.put(key27, value27);
|
||
map.put(key28, value28);
|
||
map.put(key29, value29);
|
||
map.put(key30, value30);
|
||
map.put(key31, value31);
|
||
map.put(key32, value32);
|
||
map.put(key33, value33);
|
||
map.put(key34, value34);
|
||
map.put(key35, value35);
|
||
map.put(key36, value36);
|
||
map.put(key37, value37);
|
||
map.put(key38, value38);
|
||
map.put(key39, value39);
|
||
map.put(key40, value40);
|
||
map.put(key41, value41);
|
||
map.put(key42, value42);
|
||
map.put(key43, value43);
|
||
map.put(key44, value44);
|
||
map.put(key45, value45);
|
||
map.put(key46, value46);
|
||
map.put(key47, value47);
|
||
map.put(key48, value48);
|
||
map.put(key49, value49);
|
||
map.put(key50, value50);
|
||
map.put(key51, value51);
|
||
map.put(key52, value52);
|
||
map.put(key53, value53);
|
||
map.put(key54, value54);
|
||
map.put(key55, value55);
|
||
map.put(key56, value56);
|
||
map.put(key57, value57);
|
||
map.put(key58, value58);
|
||
map.put(key59, value59);
|
||
map.put(key60, value60);
|
||
map.put(key61, value61);
|
||
map.put(key62, value62);
|
||
map.put(key63, value63);
|
||
map.put(key64, value64);
|
||
map.put(key65, value65);
|
||
map.put(key66, value66);
|
||
map.put(key67, value67);
|
||
map.put(key68, value68);
|
||
map.put(key69, value69);
|
||
map.put(key70, value70);
|
||
map.put(key71, value71);
|
||
map.put(key72, value72);
|
||
map.put(key73, value73);
|
||
return map;
|
||
}
|
||
|
||
public static <K, V> Map<K, V> of(
|
||
K key,
|
||
V value,
|
||
K key2,
|
||
V value2,
|
||
K key3,
|
||
V value3,
|
||
K key4,
|
||
V value4,
|
||
K key5,
|
||
V value5,
|
||
K key6,
|
||
V value6,
|
||
K key7,
|
||
V value7,
|
||
K key8,
|
||
V value8,
|
||
K key9,
|
||
V value9,
|
||
K key10,
|
||
V value10,
|
||
K key11,
|
||
V value11,
|
||
K key12,
|
||
V value12,
|
||
K key13,
|
||
V value13,
|
||
K key14,
|
||
V value14,
|
||
K key15,
|
||
V value15,
|
||
K key16,
|
||
V value16,
|
||
K key17,
|
||
V value17,
|
||
K key18,
|
||
V value18,
|
||
K key19,
|
||
V value19,
|
||
K key20,
|
||
V value20,
|
||
K key21,
|
||
V value21,
|
||
K key22,
|
||
V value22,
|
||
K key23,
|
||
V value23,
|
||
K key24,
|
||
V value24,
|
||
K key25,
|
||
V value25,
|
||
K key26,
|
||
V value26,
|
||
K key27,
|
||
V value27,
|
||
K key28,
|
||
V value28,
|
||
K key29,
|
||
V value29,
|
||
K key30,
|
||
V value30,
|
||
K key31,
|
||
V value31,
|
||
K key32,
|
||
V value32,
|
||
K key33,
|
||
V value33,
|
||
K key34,
|
||
V value34,
|
||
K key35,
|
||
V value35,
|
||
K key36,
|
||
V value36,
|
||
K key37,
|
||
V value37,
|
||
K key38,
|
||
V value38,
|
||
K key39,
|
||
V value39,
|
||
K key40,
|
||
V value40,
|
||
K key41,
|
||
V value41,
|
||
K key42,
|
||
V value42,
|
||
K key43,
|
||
V value43,
|
||
K key44,
|
||
V value44,
|
||
K key45,
|
||
V value45,
|
||
K key46,
|
||
V value46,
|
||
K key47,
|
||
V value47,
|
||
K key48,
|
||
V value48,
|
||
K key49,
|
||
V value49,
|
||
K key50,
|
||
V value50,
|
||
K key51,
|
||
V value51,
|
||
K key52,
|
||
V value52,
|
||
K key53,
|
||
V value53,
|
||
K key54,
|
||
V value54,
|
||
K key55,
|
||
V value55,
|
||
K key56,
|
||
V value56,
|
||
K key57,
|
||
V value57,
|
||
K key58,
|
||
V value58,
|
||
K key59,
|
||
V value59,
|
||
K key60,
|
||
V value60,
|
||
K key61,
|
||
V value61,
|
||
K key62,
|
||
V value62,
|
||
K key63,
|
||
V value63,
|
||
K key64,
|
||
V value64,
|
||
K key65,
|
||
V value65,
|
||
K key66,
|
||
V value66,
|
||
K key67,
|
||
V value67,
|
||
K key68,
|
||
V value68,
|
||
K key69,
|
||
V value69,
|
||
K key70,
|
||
V value70,
|
||
K key71,
|
||
V value71,
|
||
K key72,
|
||
V value72,
|
||
K key73,
|
||
V value73,
|
||
K key74,
|
||
V value74
|
||
) {
|
||
var map = new HashMap<K, V>(78);
|
||
map.put(key, value);
|
||
map.put(key2, value2);
|
||
map.put(key3, value3);
|
||
map.put(key4, value4);
|
||
map.put(key5, value5);
|
||
map.put(key6, value6);
|
||
map.put(key7, value7);
|
||
map.put(key8, value8);
|
||
map.put(key9, value9);
|
||
map.put(key10, value10);
|
||
map.put(key11, value11);
|
||
map.put(key12, value12);
|
||
map.put(key13, value13);
|
||
map.put(key14, value14);
|
||
map.put(key15, value15);
|
||
map.put(key16, value16);
|
||
map.put(key17, value17);
|
||
map.put(key18, value18);
|
||
map.put(key19, value19);
|
||
map.put(key20, value20);
|
||
map.put(key21, value21);
|
||
map.put(key22, value22);
|
||
map.put(key23, value23);
|
||
map.put(key24, value24);
|
||
map.put(key25, value25);
|
||
map.put(key26, value26);
|
||
map.put(key27, value27);
|
||
map.put(key28, value28);
|
||
map.put(key29, value29);
|
||
map.put(key30, value30);
|
||
map.put(key31, value31);
|
||
map.put(key32, value32);
|
||
map.put(key33, value33);
|
||
map.put(key34, value34);
|
||
map.put(key35, value35);
|
||
map.put(key36, value36);
|
||
map.put(key37, value37);
|
||
map.put(key38, value38);
|
||
map.put(key39, value39);
|
||
map.put(key40, value40);
|
||
map.put(key41, value41);
|
||
map.put(key42, value42);
|
||
map.put(key43, value43);
|
||
map.put(key44, value44);
|
||
map.put(key45, value45);
|
||
map.put(key46, value46);
|
||
map.put(key47, value47);
|
||
map.put(key48, value48);
|
||
map.put(key49, value49);
|
||
map.put(key50, value50);
|
||
map.put(key51, value51);
|
||
map.put(key52, value52);
|
||
map.put(key53, value53);
|
||
map.put(key54, value54);
|
||
map.put(key55, value55);
|
||
map.put(key56, value56);
|
||
map.put(key57, value57);
|
||
map.put(key58, value58);
|
||
map.put(key59, value59);
|
||
map.put(key60, value60);
|
||
map.put(key61, value61);
|
||
map.put(key62, value62);
|
||
map.put(key63, value63);
|
||
map.put(key64, value64);
|
||
map.put(key65, value65);
|
||
map.put(key66, value66);
|
||
map.put(key67, value67);
|
||
map.put(key68, value68);
|
||
map.put(key69, value69);
|
||
map.put(key70, value70);
|
||
map.put(key71, value71);
|
||
map.put(key72, value72);
|
||
map.put(key73, value73);
|
||
map.put(key74, value74);
|
||
return map;
|
||
}
|
||
|
||
public static <K, V> Map<K, V> of(
|
||
K key,
|
||
V value,
|
||
K key2,
|
||
V value2,
|
||
K key3,
|
||
V value3,
|
||
K key4,
|
||
V value4,
|
||
K key5,
|
||
V value5,
|
||
K key6,
|
||
V value6,
|
||
K key7,
|
||
V value7,
|
||
K key8,
|
||
V value8,
|
||
K key9,
|
||
V value9,
|
||
K key10,
|
||
V value10,
|
||
K key11,
|
||
V value11,
|
||
K key12,
|
||
V value12,
|
||
K key13,
|
||
V value13,
|
||
K key14,
|
||
V value14,
|
||
K key15,
|
||
V value15,
|
||
K key16,
|
||
V value16,
|
||
K key17,
|
||
V value17,
|
||
K key18,
|
||
V value18,
|
||
K key19,
|
||
V value19,
|
||
K key20,
|
||
V value20,
|
||
K key21,
|
||
V value21,
|
||
K key22,
|
||
V value22,
|
||
K key23,
|
||
V value23,
|
||
K key24,
|
||
V value24,
|
||
K key25,
|
||
V value25,
|
||
K key26,
|
||
V value26,
|
||
K key27,
|
||
V value27,
|
||
K key28,
|
||
V value28,
|
||
K key29,
|
||
V value29,
|
||
K key30,
|
||
V value30,
|
||
K key31,
|
||
V value31,
|
||
K key32,
|
||
V value32,
|
||
K key33,
|
||
V value33,
|
||
K key34,
|
||
V value34,
|
||
K key35,
|
||
V value35,
|
||
K key36,
|
||
V value36,
|
||
K key37,
|
||
V value37,
|
||
K key38,
|
||
V value38,
|
||
K key39,
|
||
V value39,
|
||
K key40,
|
||
V value40,
|
||
K key41,
|
||
V value41,
|
||
K key42,
|
||
V value42,
|
||
K key43,
|
||
V value43,
|
||
K key44,
|
||
V value44,
|
||
K key45,
|
||
V value45,
|
||
K key46,
|
||
V value46,
|
||
K key47,
|
||
V value47,
|
||
K key48,
|
||
V value48,
|
||
K key49,
|
||
V value49,
|
||
K key50,
|
||
V value50,
|
||
K key51,
|
||
V value51,
|
||
K key52,
|
||
V value52,
|
||
K key53,
|
||
V value53,
|
||
K key54,
|
||
V value54,
|
||
K key55,
|
||
V value55,
|
||
K key56,
|
||
V value56,
|
||
K key57,
|
||
V value57,
|
||
K key58,
|
||
V value58,
|
||
K key59,
|
||
V value59,
|
||
K key60,
|
||
V value60,
|
||
K key61,
|
||
V value61,
|
||
K key62,
|
||
V value62,
|
||
K key63,
|
||
V value63,
|
||
K key64,
|
||
V value64,
|
||
K key65,
|
||
V value65,
|
||
K key66,
|
||
V value66,
|
||
K key67,
|
||
V value67,
|
||
K key68,
|
||
V value68,
|
||
K key69,
|
||
V value69,
|
||
K key70,
|
||
V value70,
|
||
K key71,
|
||
V value71,
|
||
K key72,
|
||
V value72,
|
||
K key73,
|
||
V value73,
|
||
K key74,
|
||
V value74,
|
||
K key75,
|
||
V value75
|
||
) {
|
||
var map = new HashMap<K, V>(79);
|
||
map.put(key, value);
|
||
map.put(key2, value2);
|
||
map.put(key3, value3);
|
||
map.put(key4, value4);
|
||
map.put(key5, value5);
|
||
map.put(key6, value6);
|
||
map.put(key7, value7);
|
||
map.put(key8, value8);
|
||
map.put(key9, value9);
|
||
map.put(key10, value10);
|
||
map.put(key11, value11);
|
||
map.put(key12, value12);
|
||
map.put(key13, value13);
|
||
map.put(key14, value14);
|
||
map.put(key15, value15);
|
||
map.put(key16, value16);
|
||
map.put(key17, value17);
|
||
map.put(key18, value18);
|
||
map.put(key19, value19);
|
||
map.put(key20, value20);
|
||
map.put(key21, value21);
|
||
map.put(key22, value22);
|
||
map.put(key23, value23);
|
||
map.put(key24, value24);
|
||
map.put(key25, value25);
|
||
map.put(key26, value26);
|
||
map.put(key27, value27);
|
||
map.put(key28, value28);
|
||
map.put(key29, value29);
|
||
map.put(key30, value30);
|
||
map.put(key31, value31);
|
||
map.put(key32, value32);
|
||
map.put(key33, value33);
|
||
map.put(key34, value34);
|
||
map.put(key35, value35);
|
||
map.put(key36, value36);
|
||
map.put(key37, value37);
|
||
map.put(key38, value38);
|
||
map.put(key39, value39);
|
||
map.put(key40, value40);
|
||
map.put(key41, value41);
|
||
map.put(key42, value42);
|
||
map.put(key43, value43);
|
||
map.put(key44, value44);
|
||
map.put(key45, value45);
|
||
map.put(key46, value46);
|
||
map.put(key47, value47);
|
||
map.put(key48, value48);
|
||
map.put(key49, value49);
|
||
map.put(key50, value50);
|
||
map.put(key51, value51);
|
||
map.put(key52, value52);
|
||
map.put(key53, value53);
|
||
map.put(key54, value54);
|
||
map.put(key55, value55);
|
||
map.put(key56, value56);
|
||
map.put(key57, value57);
|
||
map.put(key58, value58);
|
||
map.put(key59, value59);
|
||
map.put(key60, value60);
|
||
map.put(key61, value61);
|
||
map.put(key62, value62);
|
||
map.put(key63, value63);
|
||
map.put(key64, value64);
|
||
map.put(key65, value65);
|
||
map.put(key66, value66);
|
||
map.put(key67, value67);
|
||
map.put(key68, value68);
|
||
map.put(key69, value69);
|
||
map.put(key70, value70);
|
||
map.put(key71, value71);
|
||
map.put(key72, value72);
|
||
map.put(key73, value73);
|
||
map.put(key74, value74);
|
||
map.put(key75, value75);
|
||
return map;
|
||
}
|
||
|
||
public static <K, V> Map<K, V> of(
|
||
K key,
|
||
V value,
|
||
K key2,
|
||
V value2,
|
||
K key3,
|
||
V value3,
|
||
K key4,
|
||
V value4,
|
||
K key5,
|
||
V value5,
|
||
K key6,
|
||
V value6,
|
||
K key7,
|
||
V value7,
|
||
K key8,
|
||
V value8,
|
||
K key9,
|
||
V value9,
|
||
K key10,
|
||
V value10,
|
||
K key11,
|
||
V value11,
|
||
K key12,
|
||
V value12,
|
||
K key13,
|
||
V value13,
|
||
K key14,
|
||
V value14,
|
||
K key15,
|
||
V value15,
|
||
K key16,
|
||
V value16,
|
||
K key17,
|
||
V value17,
|
||
K key18,
|
||
V value18,
|
||
K key19,
|
||
V value19,
|
||
K key20,
|
||
V value20,
|
||
K key21,
|
||
V value21,
|
||
K key22,
|
||
V value22,
|
||
K key23,
|
||
V value23,
|
||
K key24,
|
||
V value24,
|
||
K key25,
|
||
V value25,
|
||
K key26,
|
||
V value26,
|
||
K key27,
|
||
V value27,
|
||
K key28,
|
||
V value28,
|
||
K key29,
|
||
V value29,
|
||
K key30,
|
||
V value30,
|
||
K key31,
|
||
V value31,
|
||
K key32,
|
||
V value32,
|
||
K key33,
|
||
V value33,
|
||
K key34,
|
||
V value34,
|
||
K key35,
|
||
V value35,
|
||
K key36,
|
||
V value36,
|
||
K key37,
|
||
V value37,
|
||
K key38,
|
||
V value38,
|
||
K key39,
|
||
V value39,
|
||
K key40,
|
||
V value40,
|
||
K key41,
|
||
V value41,
|
||
K key42,
|
||
V value42,
|
||
K key43,
|
||
V value43,
|
||
K key44,
|
||
V value44,
|
||
K key45,
|
||
V value45,
|
||
K key46,
|
||
V value46,
|
||
K key47,
|
||
V value47,
|
||
K key48,
|
||
V value48,
|
||
K key49,
|
||
V value49,
|
||
K key50,
|
||
V value50,
|
||
K key51,
|
||
V value51,
|
||
K key52,
|
||
V value52,
|
||
K key53,
|
||
V value53,
|
||
K key54,
|
||
V value54,
|
||
K key55,
|
||
V value55,
|
||
K key56,
|
||
V value56,
|
||
K key57,
|
||
V value57,
|
||
K key58,
|
||
V value58,
|
||
K key59,
|
||
V value59,
|
||
K key60,
|
||
V value60,
|
||
K key61,
|
||
V value61,
|
||
K key62,
|
||
V value62,
|
||
K key63,
|
||
V value63,
|
||
K key64,
|
||
V value64,
|
||
K key65,
|
||
V value65,
|
||
K key66,
|
||
V value66,
|
||
K key67,
|
||
V value67,
|
||
K key68,
|
||
V value68,
|
||
K key69,
|
||
V value69,
|
||
K key70,
|
||
V value70,
|
||
K key71,
|
||
V value71,
|
||
K key72,
|
||
V value72,
|
||
K key73,
|
||
V value73,
|
||
K key74,
|
||
V value74,
|
||
K key75,
|
||
V value75,
|
||
K key76,
|
||
V value76
|
||
) {
|
||
var map = new HashMap<K, V>(80);
|
||
map.put(key, value);
|
||
map.put(key2, value2);
|
||
map.put(key3, value3);
|
||
map.put(key4, value4);
|
||
map.put(key5, value5);
|
||
map.put(key6, value6);
|
||
map.put(key7, value7);
|
||
map.put(key8, value8);
|
||
map.put(key9, value9);
|
||
map.put(key10, value10);
|
||
map.put(key11, value11);
|
||
map.put(key12, value12);
|
||
map.put(key13, value13);
|
||
map.put(key14, value14);
|
||
map.put(key15, value15);
|
||
map.put(key16, value16);
|
||
map.put(key17, value17);
|
||
map.put(key18, value18);
|
||
map.put(key19, value19);
|
||
map.put(key20, value20);
|
||
map.put(key21, value21);
|
||
map.put(key22, value22);
|
||
map.put(key23, value23);
|
||
map.put(key24, value24);
|
||
map.put(key25, value25);
|
||
map.put(key26, value26);
|
||
map.put(key27, value27);
|
||
map.put(key28, value28);
|
||
map.put(key29, value29);
|
||
map.put(key30, value30);
|
||
map.put(key31, value31);
|
||
map.put(key32, value32);
|
||
map.put(key33, value33);
|
||
map.put(key34, value34);
|
||
map.put(key35, value35);
|
||
map.put(key36, value36);
|
||
map.put(key37, value37);
|
||
map.put(key38, value38);
|
||
map.put(key39, value39);
|
||
map.put(key40, value40);
|
||
map.put(key41, value41);
|
||
map.put(key42, value42);
|
||
map.put(key43, value43);
|
||
map.put(key44, value44);
|
||
map.put(key45, value45);
|
||
map.put(key46, value46);
|
||
map.put(key47, value47);
|
||
map.put(key48, value48);
|
||
map.put(key49, value49);
|
||
map.put(key50, value50);
|
||
map.put(key51, value51);
|
||
map.put(key52, value52);
|
||
map.put(key53, value53);
|
||
map.put(key54, value54);
|
||
map.put(key55, value55);
|
||
map.put(key56, value56);
|
||
map.put(key57, value57);
|
||
map.put(key58, value58);
|
||
map.put(key59, value59);
|
||
map.put(key60, value60);
|
||
map.put(key61, value61);
|
||
map.put(key62, value62);
|
||
map.put(key63, value63);
|
||
map.put(key64, value64);
|
||
map.put(key65, value65);
|
||
map.put(key66, value66);
|
||
map.put(key67, value67);
|
||
map.put(key68, value68);
|
||
map.put(key69, value69);
|
||
map.put(key70, value70);
|
||
map.put(key71, value71);
|
||
map.put(key72, value72);
|
||
map.put(key73, value73);
|
||
map.put(key74, value74);
|
||
map.put(key75, value75);
|
||
map.put(key76, value76);
|
||
return map;
|
||
}
|
||
|
||
public static <K, V> Map<K, V> of(
|
||
K key,
|
||
V value,
|
||
K key2,
|
||
V value2,
|
||
K key3,
|
||
V value3,
|
||
K key4,
|
||
V value4,
|
||
K key5,
|
||
V value5,
|
||
K key6,
|
||
V value6,
|
||
K key7,
|
||
V value7,
|
||
K key8,
|
||
V value8,
|
||
K key9,
|
||
V value9,
|
||
K key10,
|
||
V value10,
|
||
K key11,
|
||
V value11,
|
||
K key12,
|
||
V value12,
|
||
K key13,
|
||
V value13,
|
||
K key14,
|
||
V value14,
|
||
K key15,
|
||
V value15,
|
||
K key16,
|
||
V value16,
|
||
K key17,
|
||
V value17,
|
||
K key18,
|
||
V value18,
|
||
K key19,
|
||
V value19,
|
||
K key20,
|
||
V value20,
|
||
K key21,
|
||
V value21,
|
||
K key22,
|
||
V value22,
|
||
K key23,
|
||
V value23,
|
||
K key24,
|
||
V value24,
|
||
K key25,
|
||
V value25,
|
||
K key26,
|
||
V value26,
|
||
K key27,
|
||
V value27,
|
||
K key28,
|
||
V value28,
|
||
K key29,
|
||
V value29,
|
||
K key30,
|
||
V value30,
|
||
K key31,
|
||
V value31,
|
||
K key32,
|
||
V value32,
|
||
K key33,
|
||
V value33,
|
||
K key34,
|
||
V value34,
|
||
K key35,
|
||
V value35,
|
||
K key36,
|
||
V value36,
|
||
K key37,
|
||
V value37,
|
||
K key38,
|
||
V value38,
|
||
K key39,
|
||
V value39,
|
||
K key40,
|
||
V value40,
|
||
K key41,
|
||
V value41,
|
||
K key42,
|
||
V value42,
|
||
K key43,
|
||
V value43,
|
||
K key44,
|
||
V value44,
|
||
K key45,
|
||
V value45,
|
||
K key46,
|
||
V value46,
|
||
K key47,
|
||
V value47,
|
||
K key48,
|
||
V value48,
|
||
K key49,
|
||
V value49,
|
||
K key50,
|
||
V value50,
|
||
K key51,
|
||
V value51,
|
||
K key52,
|
||
V value52,
|
||
K key53,
|
||
V value53,
|
||
K key54,
|
||
V value54,
|
||
K key55,
|
||
V value55,
|
||
K key56,
|
||
V value56,
|
||
K key57,
|
||
V value57,
|
||
K key58,
|
||
V value58,
|
||
K key59,
|
||
V value59,
|
||
K key60,
|
||
V value60,
|
||
K key61,
|
||
V value61,
|
||
K key62,
|
||
V value62,
|
||
K key63,
|
||
V value63,
|
||
K key64,
|
||
V value64,
|
||
K key65,
|
||
V value65,
|
||
K key66,
|
||
V value66,
|
||
K key67,
|
||
V value67,
|
||
K key68,
|
||
V value68,
|
||
K key69,
|
||
V value69,
|
||
K key70,
|
||
V value70,
|
||
K key71,
|
||
V value71,
|
||
K key72,
|
||
V value72,
|
||
K key73,
|
||
V value73,
|
||
K key74,
|
||
V value74,
|
||
K key75,
|
||
V value75,
|
||
K key76,
|
||
V value76,
|
||
K key77,
|
||
V value77
|
||
) {
|
||
var map = new HashMap<K, V>(81);
|
||
map.put(key, value);
|
||
map.put(key2, value2);
|
||
map.put(key3, value3);
|
||
map.put(key4, value4);
|
||
map.put(key5, value5);
|
||
map.put(key6, value6);
|
||
map.put(key7, value7);
|
||
map.put(key8, value8);
|
||
map.put(key9, value9);
|
||
map.put(key10, value10);
|
||
map.put(key11, value11);
|
||
map.put(key12, value12);
|
||
map.put(key13, value13);
|
||
map.put(key14, value14);
|
||
map.put(key15, value15);
|
||
map.put(key16, value16);
|
||
map.put(key17, value17);
|
||
map.put(key18, value18);
|
||
map.put(key19, value19);
|
||
map.put(key20, value20);
|
||
map.put(key21, value21);
|
||
map.put(key22, value22);
|
||
map.put(key23, value23);
|
||
map.put(key24, value24);
|
||
map.put(key25, value25);
|
||
map.put(key26, value26);
|
||
map.put(key27, value27);
|
||
map.put(key28, value28);
|
||
map.put(key29, value29);
|
||
map.put(key30, value30);
|
||
map.put(key31, value31);
|
||
map.put(key32, value32);
|
||
map.put(key33, value33);
|
||
map.put(key34, value34);
|
||
map.put(key35, value35);
|
||
map.put(key36, value36);
|
||
map.put(key37, value37);
|
||
map.put(key38, value38);
|
||
map.put(key39, value39);
|
||
map.put(key40, value40);
|
||
map.put(key41, value41);
|
||
map.put(key42, value42);
|
||
map.put(key43, value43);
|
||
map.put(key44, value44);
|
||
map.put(key45, value45);
|
||
map.put(key46, value46);
|
||
map.put(key47, value47);
|
||
map.put(key48, value48);
|
||
map.put(key49, value49);
|
||
map.put(key50, value50);
|
||
map.put(key51, value51);
|
||
map.put(key52, value52);
|
||
map.put(key53, value53);
|
||
map.put(key54, value54);
|
||
map.put(key55, value55);
|
||
map.put(key56, value56);
|
||
map.put(key57, value57);
|
||
map.put(key58, value58);
|
||
map.put(key59, value59);
|
||
map.put(key60, value60);
|
||
map.put(key61, value61);
|
||
map.put(key62, value62);
|
||
map.put(key63, value63);
|
||
map.put(key64, value64);
|
||
map.put(key65, value65);
|
||
map.put(key66, value66);
|
||
map.put(key67, value67);
|
||
map.put(key68, value68);
|
||
map.put(key69, value69);
|
||
map.put(key70, value70);
|
||
map.put(key71, value71);
|
||
map.put(key72, value72);
|
||
map.put(key73, value73);
|
||
map.put(key74, value74);
|
||
map.put(key75, value75);
|
||
map.put(key76, value76);
|
||
map.put(key77, value77);
|
||
return map;
|
||
}
|
||
|
||
public static <K, V> Map<K, V> of(
|
||
K key,
|
||
V value,
|
||
K key2,
|
||
V value2,
|
||
K key3,
|
||
V value3,
|
||
K key4,
|
||
V value4,
|
||
K key5,
|
||
V value5,
|
||
K key6,
|
||
V value6,
|
||
K key7,
|
||
V value7,
|
||
K key8,
|
||
V value8,
|
||
K key9,
|
||
V value9,
|
||
K key10,
|
||
V value10,
|
||
K key11,
|
||
V value11,
|
||
K key12,
|
||
V value12,
|
||
K key13,
|
||
V value13,
|
||
K key14,
|
||
V value14,
|
||
K key15,
|
||
V value15,
|
||
K key16,
|
||
V value16,
|
||
K key17,
|
||
V value17,
|
||
K key18,
|
||
V value18,
|
||
K key19,
|
||
V value19,
|
||
K key20,
|
||
V value20,
|
||
K key21,
|
||
V value21,
|
||
K key22,
|
||
V value22,
|
||
K key23,
|
||
V value23,
|
||
K key24,
|
||
V value24,
|
||
K key25,
|
||
V value25,
|
||
K key26,
|
||
V value26,
|
||
K key27,
|
||
V value27,
|
||
K key28,
|
||
V value28,
|
||
K key29,
|
||
V value29,
|
||
K key30,
|
||
V value30,
|
||
K key31,
|
||
V value31,
|
||
K key32,
|
||
V value32,
|
||
K key33,
|
||
V value33,
|
||
K key34,
|
||
V value34,
|
||
K key35,
|
||
V value35,
|
||
K key36,
|
||
V value36,
|
||
K key37,
|
||
V value37,
|
||
K key38,
|
||
V value38,
|
||
K key39,
|
||
V value39,
|
||
K key40,
|
||
V value40,
|
||
K key41,
|
||
V value41,
|
||
K key42,
|
||
V value42,
|
||
K key43,
|
||
V value43,
|
||
K key44,
|
||
V value44,
|
||
K key45,
|
||
V value45,
|
||
K key46,
|
||
V value46,
|
||
K key47,
|
||
V value47,
|
||
K key48,
|
||
V value48,
|
||
K key49,
|
||
V value49,
|
||
K key50,
|
||
V value50,
|
||
K key51,
|
||
V value51,
|
||
K key52,
|
||
V value52,
|
||
K key53,
|
||
V value53,
|
||
K key54,
|
||
V value54,
|
||
K key55,
|
||
V value55,
|
||
K key56,
|
||
V value56,
|
||
K key57,
|
||
V value57,
|
||
K key58,
|
||
V value58,
|
||
K key59,
|
||
V value59,
|
||
K key60,
|
||
V value60,
|
||
K key61,
|
||
V value61,
|
||
K key62,
|
||
V value62,
|
||
K key63,
|
||
V value63,
|
||
K key64,
|
||
V value64,
|
||
K key65,
|
||
V value65,
|
||
K key66,
|
||
V value66,
|
||
K key67,
|
||
V value67,
|
||
K key68,
|
||
V value68,
|
||
K key69,
|
||
V value69,
|
||
K key70,
|
||
V value70,
|
||
K key71,
|
||
V value71,
|
||
K key72,
|
||
V value72,
|
||
K key73,
|
||
V value73,
|
||
K key74,
|
||
V value74,
|
||
K key75,
|
||
V value75,
|
||
K key76,
|
||
V value76,
|
||
K key77,
|
||
V value77,
|
||
K key78,
|
||
V value78
|
||
) {
|
||
var map = new HashMap<K, V>(82);
|
||
map.put(key, value);
|
||
map.put(key2, value2);
|
||
map.put(key3, value3);
|
||
map.put(key4, value4);
|
||
map.put(key5, value5);
|
||
map.put(key6, value6);
|
||
map.put(key7, value7);
|
||
map.put(key8, value8);
|
||
map.put(key9, value9);
|
||
map.put(key10, value10);
|
||
map.put(key11, value11);
|
||
map.put(key12, value12);
|
||
map.put(key13, value13);
|
||
map.put(key14, value14);
|
||
map.put(key15, value15);
|
||
map.put(key16, value16);
|
||
map.put(key17, value17);
|
||
map.put(key18, value18);
|
||
map.put(key19, value19);
|
||
map.put(key20, value20);
|
||
map.put(key21, value21);
|
||
map.put(key22, value22);
|
||
map.put(key23, value23);
|
||
map.put(key24, value24);
|
||
map.put(key25, value25);
|
||
map.put(key26, value26);
|
||
map.put(key27, value27);
|
||
map.put(key28, value28);
|
||
map.put(key29, value29);
|
||
map.put(key30, value30);
|
||
map.put(key31, value31);
|
||
map.put(key32, value32);
|
||
map.put(key33, value33);
|
||
map.put(key34, value34);
|
||
map.put(key35, value35);
|
||
map.put(key36, value36);
|
||
map.put(key37, value37);
|
||
map.put(key38, value38);
|
||
map.put(key39, value39);
|
||
map.put(key40, value40);
|
||
map.put(key41, value41);
|
||
map.put(key42, value42);
|
||
map.put(key43, value43);
|
||
map.put(key44, value44);
|
||
map.put(key45, value45);
|
||
map.put(key46, value46);
|
||
map.put(key47, value47);
|
||
map.put(key48, value48);
|
||
map.put(key49, value49);
|
||
map.put(key50, value50);
|
||
map.put(key51, value51);
|
||
map.put(key52, value52);
|
||
map.put(key53, value53);
|
||
map.put(key54, value54);
|
||
map.put(key55, value55);
|
||
map.put(key56, value56);
|
||
map.put(key57, value57);
|
||
map.put(key58, value58);
|
||
map.put(key59, value59);
|
||
map.put(key60, value60);
|
||
map.put(key61, value61);
|
||
map.put(key62, value62);
|
||
map.put(key63, value63);
|
||
map.put(key64, value64);
|
||
map.put(key65, value65);
|
||
map.put(key66, value66);
|
||
map.put(key67, value67);
|
||
map.put(key68, value68);
|
||
map.put(key69, value69);
|
||
map.put(key70, value70);
|
||
map.put(key71, value71);
|
||
map.put(key72, value72);
|
||
map.put(key73, value73);
|
||
map.put(key74, value74);
|
||
map.put(key75, value75);
|
||
map.put(key76, value76);
|
||
map.put(key77, value77);
|
||
map.put(key78, value78);
|
||
return map;
|
||
}
|
||
|
||
public static <K, V> Map<K, V> of(
|
||
K key,
|
||
V value,
|
||
K key2,
|
||
V value2,
|
||
K key3,
|
||
V value3,
|
||
K key4,
|
||
V value4,
|
||
K key5,
|
||
V value5,
|
||
K key6,
|
||
V value6,
|
||
K key7,
|
||
V value7,
|
||
K key8,
|
||
V value8,
|
||
K key9,
|
||
V value9,
|
||
K key10,
|
||
V value10,
|
||
K key11,
|
||
V value11,
|
||
K key12,
|
||
V value12,
|
||
K key13,
|
||
V value13,
|
||
K key14,
|
||
V value14,
|
||
K key15,
|
||
V value15,
|
||
K key16,
|
||
V value16,
|
||
K key17,
|
||
V value17,
|
||
K key18,
|
||
V value18,
|
||
K key19,
|
||
V value19,
|
||
K key20,
|
||
V value20,
|
||
K key21,
|
||
V value21,
|
||
K key22,
|
||
V value22,
|
||
K key23,
|
||
V value23,
|
||
K key24,
|
||
V value24,
|
||
K key25,
|
||
V value25,
|
||
K key26,
|
||
V value26,
|
||
K key27,
|
||
V value27,
|
||
K key28,
|
||
V value28,
|
||
K key29,
|
||
V value29,
|
||
K key30,
|
||
V value30,
|
||
K key31,
|
||
V value31,
|
||
K key32,
|
||
V value32,
|
||
K key33,
|
||
V value33,
|
||
K key34,
|
||
V value34,
|
||
K key35,
|
||
V value35,
|
||
K key36,
|
||
V value36,
|
||
K key37,
|
||
V value37,
|
||
K key38,
|
||
V value38,
|
||
K key39,
|
||
V value39,
|
||
K key40,
|
||
V value40,
|
||
K key41,
|
||
V value41,
|
||
K key42,
|
||
V value42,
|
||
K key43,
|
||
V value43,
|
||
K key44,
|
||
V value44,
|
||
K key45,
|
||
V value45,
|
||
K key46,
|
||
V value46,
|
||
K key47,
|
||
V value47,
|
||
K key48,
|
||
V value48,
|
||
K key49,
|
||
V value49,
|
||
K key50,
|
||
V value50,
|
||
K key51,
|
||
V value51,
|
||
K key52,
|
||
V value52,
|
||
K key53,
|
||
V value53,
|
||
K key54,
|
||
V value54,
|
||
K key55,
|
||
V value55,
|
||
K key56,
|
||
V value56,
|
||
K key57,
|
||
V value57,
|
||
K key58,
|
||
V value58,
|
||
K key59,
|
||
V value59,
|
||
K key60,
|
||
V value60,
|
||
K key61,
|
||
V value61,
|
||
K key62,
|
||
V value62,
|
||
K key63,
|
||
V value63,
|
||
K key64,
|
||
V value64,
|
||
K key65,
|
||
V value65,
|
||
K key66,
|
||
V value66,
|
||
K key67,
|
||
V value67,
|
||
K key68,
|
||
V value68,
|
||
K key69,
|
||
V value69,
|
||
K key70,
|
||
V value70,
|
||
K key71,
|
||
V value71,
|
||
K key72,
|
||
V value72,
|
||
K key73,
|
||
V value73,
|
||
K key74,
|
||
V value74,
|
||
K key75,
|
||
V value75,
|
||
K key76,
|
||
V value76,
|
||
K key77,
|
||
V value77,
|
||
K key78,
|
||
V value78,
|
||
K key79,
|
||
V value79
|
||
) {
|
||
var map = new HashMap<K, V>(83);
|
||
map.put(key, value);
|
||
map.put(key2, value2);
|
||
map.put(key3, value3);
|
||
map.put(key4, value4);
|
||
map.put(key5, value5);
|
||
map.put(key6, value6);
|
||
map.put(key7, value7);
|
||
map.put(key8, value8);
|
||
map.put(key9, value9);
|
||
map.put(key10, value10);
|
||
map.put(key11, value11);
|
||
map.put(key12, value12);
|
||
map.put(key13, value13);
|
||
map.put(key14, value14);
|
||
map.put(key15, value15);
|
||
map.put(key16, value16);
|
||
map.put(key17, value17);
|
||
map.put(key18, value18);
|
||
map.put(key19, value19);
|
||
map.put(key20, value20);
|
||
map.put(key21, value21);
|
||
map.put(key22, value22);
|
||
map.put(key23, value23);
|
||
map.put(key24, value24);
|
||
map.put(key25, value25);
|
||
map.put(key26, value26);
|
||
map.put(key27, value27);
|
||
map.put(key28, value28);
|
||
map.put(key29, value29);
|
||
map.put(key30, value30);
|
||
map.put(key31, value31);
|
||
map.put(key32, value32);
|
||
map.put(key33, value33);
|
||
map.put(key34, value34);
|
||
map.put(key35, value35);
|
||
map.put(key36, value36);
|
||
map.put(key37, value37);
|
||
map.put(key38, value38);
|
||
map.put(key39, value39);
|
||
map.put(key40, value40);
|
||
map.put(key41, value41);
|
||
map.put(key42, value42);
|
||
map.put(key43, value43);
|
||
map.put(key44, value44);
|
||
map.put(key45, value45);
|
||
map.put(key46, value46);
|
||
map.put(key47, value47);
|
||
map.put(key48, value48);
|
||
map.put(key49, value49);
|
||
map.put(key50, value50);
|
||
map.put(key51, value51);
|
||
map.put(key52, value52);
|
||
map.put(key53, value53);
|
||
map.put(key54, value54);
|
||
map.put(key55, value55);
|
||
map.put(key56, value56);
|
||
map.put(key57, value57);
|
||
map.put(key58, value58);
|
||
map.put(key59, value59);
|
||
map.put(key60, value60);
|
||
map.put(key61, value61);
|
||
map.put(key62, value62);
|
||
map.put(key63, value63);
|
||
map.put(key64, value64);
|
||
map.put(key65, value65);
|
||
map.put(key66, value66);
|
||
map.put(key67, value67);
|
||
map.put(key68, value68);
|
||
map.put(key69, value69);
|
||
map.put(key70, value70);
|
||
map.put(key71, value71);
|
||
map.put(key72, value72);
|
||
map.put(key73, value73);
|
||
map.put(key74, value74);
|
||
map.put(key75, value75);
|
||
map.put(key76, value76);
|
||
map.put(key77, value77);
|
||
map.put(key78, value78);
|
||
map.put(key79, value79);
|
||
return map;
|
||
}
|
||
|
||
public static <K, V> Map<K, V> of(
|
||
K key,
|
||
V value,
|
||
K key2,
|
||
V value2,
|
||
K key3,
|
||
V value3,
|
||
K key4,
|
||
V value4,
|
||
K key5,
|
||
V value5,
|
||
K key6,
|
||
V value6,
|
||
K key7,
|
||
V value7,
|
||
K key8,
|
||
V value8,
|
||
K key9,
|
||
V value9,
|
||
K key10,
|
||
V value10,
|
||
K key11,
|
||
V value11,
|
||
K key12,
|
||
V value12,
|
||
K key13,
|
||
V value13,
|
||
K key14,
|
||
V value14,
|
||
K key15,
|
||
V value15,
|
||
K key16,
|
||
V value16,
|
||
K key17,
|
||
V value17,
|
||
K key18,
|
||
V value18,
|
||
K key19,
|
||
V value19,
|
||
K key20,
|
||
V value20,
|
||
K key21,
|
||
V value21,
|
||
K key22,
|
||
V value22,
|
||
K key23,
|
||
V value23,
|
||
K key24,
|
||
V value24,
|
||
K key25,
|
||
V value25,
|
||
K key26,
|
||
V value26,
|
||
K key27,
|
||
V value27,
|
||
K key28,
|
||
V value28,
|
||
K key29,
|
||
V value29,
|
||
K key30,
|
||
V value30,
|
||
K key31,
|
||
V value31,
|
||
K key32,
|
||
V value32,
|
||
K key33,
|
||
V value33,
|
||
K key34,
|
||
V value34,
|
||
K key35,
|
||
V value35,
|
||
K key36,
|
||
V value36,
|
||
K key37,
|
||
V value37,
|
||
K key38,
|
||
V value38,
|
||
K key39,
|
||
V value39,
|
||
K key40,
|
||
V value40,
|
||
K key41,
|
||
V value41,
|
||
K key42,
|
||
V value42,
|
||
K key43,
|
||
V value43,
|
||
K key44,
|
||
V value44,
|
||
K key45,
|
||
V value45,
|
||
K key46,
|
||
V value46,
|
||
K key47,
|
||
V value47,
|
||
K key48,
|
||
V value48,
|
||
K key49,
|
||
V value49,
|
||
K key50,
|
||
V value50,
|
||
K key51,
|
||
V value51,
|
||
K key52,
|
||
V value52,
|
||
K key53,
|
||
V value53,
|
||
K key54,
|
||
V value54,
|
||
K key55,
|
||
V value55,
|
||
K key56,
|
||
V value56,
|
||
K key57,
|
||
V value57,
|
||
K key58,
|
||
V value58,
|
||
K key59,
|
||
V value59,
|
||
K key60,
|
||
V value60,
|
||
K key61,
|
||
V value61,
|
||
K key62,
|
||
V value62,
|
||
K key63,
|
||
V value63,
|
||
K key64,
|
||
V value64,
|
||
K key65,
|
||
V value65,
|
||
K key66,
|
||
V value66,
|
||
K key67,
|
||
V value67,
|
||
K key68,
|
||
V value68,
|
||
K key69,
|
||
V value69,
|
||
K key70,
|
||
V value70,
|
||
K key71,
|
||
V value71,
|
||
K key72,
|
||
V value72,
|
||
K key73,
|
||
V value73,
|
||
K key74,
|
||
V value74,
|
||
K key75,
|
||
V value75,
|
||
K key76,
|
||
V value76,
|
||
K key77,
|
||
V value77,
|
||
K key78,
|
||
V value78,
|
||
K key79,
|
||
V value79,
|
||
K key80,
|
||
V value80
|
||
) {
|
||
var map = new HashMap<K, V>(84);
|
||
map.put(key, value);
|
||
map.put(key2, value2);
|
||
map.put(key3, value3);
|
||
map.put(key4, value4);
|
||
map.put(key5, value5);
|
||
map.put(key6, value6);
|
||
map.put(key7, value7);
|
||
map.put(key8, value8);
|
||
map.put(key9, value9);
|
||
map.put(key10, value10);
|
||
map.put(key11, value11);
|
||
map.put(key12, value12);
|
||
map.put(key13, value13);
|
||
map.put(key14, value14);
|
||
map.put(key15, value15);
|
||
map.put(key16, value16);
|
||
map.put(key17, value17);
|
||
map.put(key18, value18);
|
||
map.put(key19, value19);
|
||
map.put(key20, value20);
|
||
map.put(key21, value21);
|
||
map.put(key22, value22);
|
||
map.put(key23, value23);
|
||
map.put(key24, value24);
|
||
map.put(key25, value25);
|
||
map.put(key26, value26);
|
||
map.put(key27, value27);
|
||
map.put(key28, value28);
|
||
map.put(key29, value29);
|
||
map.put(key30, value30);
|
||
map.put(key31, value31);
|
||
map.put(key32, value32);
|
||
map.put(key33, value33);
|
||
map.put(key34, value34);
|
||
map.put(key35, value35);
|
||
map.put(key36, value36);
|
||
map.put(key37, value37);
|
||
map.put(key38, value38);
|
||
map.put(key39, value39);
|
||
map.put(key40, value40);
|
||
map.put(key41, value41);
|
||
map.put(key42, value42);
|
||
map.put(key43, value43);
|
||
map.put(key44, value44);
|
||
map.put(key45, value45);
|
||
map.put(key46, value46);
|
||
map.put(key47, value47);
|
||
map.put(key48, value48);
|
||
map.put(key49, value49);
|
||
map.put(key50, value50);
|
||
map.put(key51, value51);
|
||
map.put(key52, value52);
|
||
map.put(key53, value53);
|
||
map.put(key54, value54);
|
||
map.put(key55, value55);
|
||
map.put(key56, value56);
|
||
map.put(key57, value57);
|
||
map.put(key58, value58);
|
||
map.put(key59, value59);
|
||
map.put(key60, value60);
|
||
map.put(key61, value61);
|
||
map.put(key62, value62);
|
||
map.put(key63, value63);
|
||
map.put(key64, value64);
|
||
map.put(key65, value65);
|
||
map.put(key66, value66);
|
||
map.put(key67, value67);
|
||
map.put(key68, value68);
|
||
map.put(key69, value69);
|
||
map.put(key70, value70);
|
||
map.put(key71, value71);
|
||
map.put(key72, value72);
|
||
map.put(key73, value73);
|
||
map.put(key74, value74);
|
||
map.put(key75, value75);
|
||
map.put(key76, value76);
|
||
map.put(key77, value77);
|
||
map.put(key78, value78);
|
||
map.put(key79, value79);
|
||
map.put(key80, value80);
|
||
return map;
|
||
}
|
||
|
||
public static <K, V> Map<K, V> of(
|
||
K key,
|
||
V value,
|
||
K key2,
|
||
V value2,
|
||
K key3,
|
||
V value3,
|
||
K key4,
|
||
V value4,
|
||
K key5,
|
||
V value5,
|
||
K key6,
|
||
V value6,
|
||
K key7,
|
||
V value7,
|
||
K key8,
|
||
V value8,
|
||
K key9,
|
||
V value9,
|
||
K key10,
|
||
V value10,
|
||
K key11,
|
||
V value11,
|
||
K key12,
|
||
V value12,
|
||
K key13,
|
||
V value13,
|
||
K key14,
|
||
V value14,
|
||
K key15,
|
||
V value15,
|
||
K key16,
|
||
V value16,
|
||
K key17,
|
||
V value17,
|
||
K key18,
|
||
V value18,
|
||
K key19,
|
||
V value19,
|
||
K key20,
|
||
V value20,
|
||
K key21,
|
||
V value21,
|
||
K key22,
|
||
V value22,
|
||
K key23,
|
||
V value23,
|
||
K key24,
|
||
V value24,
|
||
K key25,
|
||
V value25,
|
||
K key26,
|
||
V value26,
|
||
K key27,
|
||
V value27,
|
||
K key28,
|
||
V value28,
|
||
K key29,
|
||
V value29,
|
||
K key30,
|
||
V value30,
|
||
K key31,
|
||
V value31,
|
||
K key32,
|
||
V value32,
|
||
K key33,
|
||
V value33,
|
||
K key34,
|
||
V value34,
|
||
K key35,
|
||
V value35,
|
||
K key36,
|
||
V value36,
|
||
K key37,
|
||
V value37,
|
||
K key38,
|
||
V value38,
|
||
K key39,
|
||
V value39,
|
||
K key40,
|
||
V value40,
|
||
K key41,
|
||
V value41,
|
||
K key42,
|
||
V value42,
|
||
K key43,
|
||
V value43,
|
||
K key44,
|
||
V value44,
|
||
K key45,
|
||
V value45,
|
||
K key46,
|
||
V value46,
|
||
K key47,
|
||
V value47,
|
||
K key48,
|
||
V value48,
|
||
K key49,
|
||
V value49,
|
||
K key50,
|
||
V value50,
|
||
K key51,
|
||
V value51,
|
||
K key52,
|
||
V value52,
|
||
K key53,
|
||
V value53,
|
||
K key54,
|
||
V value54,
|
||
K key55,
|
||
V value55,
|
||
K key56,
|
||
V value56,
|
||
K key57,
|
||
V value57,
|
||
K key58,
|
||
V value58,
|
||
K key59,
|
||
V value59,
|
||
K key60,
|
||
V value60,
|
||
K key61,
|
||
V value61,
|
||
K key62,
|
||
V value62,
|
||
K key63,
|
||
V value63,
|
||
K key64,
|
||
V value64,
|
||
K key65,
|
||
V value65,
|
||
K key66,
|
||
V value66,
|
||
K key67,
|
||
V value67,
|
||
K key68,
|
||
V value68,
|
||
K key69,
|
||
V value69,
|
||
K key70,
|
||
V value70,
|
||
K key71,
|
||
V value71,
|
||
K key72,
|
||
V value72,
|
||
K key73,
|
||
V value73,
|
||
K key74,
|
||
V value74,
|
||
K key75,
|
||
V value75,
|
||
K key76,
|
||
V value76,
|
||
K key77,
|
||
V value77,
|
||
K key78,
|
||
V value78,
|
||
K key79,
|
||
V value79,
|
||
K key80,
|
||
V value80,
|
||
K key81,
|
||
V value81
|
||
) {
|
||
var map = new HashMap<K, V>(85);
|
||
map.put(key, value);
|
||
map.put(key2, value2);
|
||
map.put(key3, value3);
|
||
map.put(key4, value4);
|
||
map.put(key5, value5);
|
||
map.put(key6, value6);
|
||
map.put(key7, value7);
|
||
map.put(key8, value8);
|
||
map.put(key9, value9);
|
||
map.put(key10, value10);
|
||
map.put(key11, value11);
|
||
map.put(key12, value12);
|
||
map.put(key13, value13);
|
||
map.put(key14, value14);
|
||
map.put(key15, value15);
|
||
map.put(key16, value16);
|
||
map.put(key17, value17);
|
||
map.put(key18, value18);
|
||
map.put(key19, value19);
|
||
map.put(key20, value20);
|
||
map.put(key21, value21);
|
||
map.put(key22, value22);
|
||
map.put(key23, value23);
|
||
map.put(key24, value24);
|
||
map.put(key25, value25);
|
||
map.put(key26, value26);
|
||
map.put(key27, value27);
|
||
map.put(key28, value28);
|
||
map.put(key29, value29);
|
||
map.put(key30, value30);
|
||
map.put(key31, value31);
|
||
map.put(key32, value32);
|
||
map.put(key33, value33);
|
||
map.put(key34, value34);
|
||
map.put(key35, value35);
|
||
map.put(key36, value36);
|
||
map.put(key37, value37);
|
||
map.put(key38, value38);
|
||
map.put(key39, value39);
|
||
map.put(key40, value40);
|
||
map.put(key41, value41);
|
||
map.put(key42, value42);
|
||
map.put(key43, value43);
|
||
map.put(key44, value44);
|
||
map.put(key45, value45);
|
||
map.put(key46, value46);
|
||
map.put(key47, value47);
|
||
map.put(key48, value48);
|
||
map.put(key49, value49);
|
||
map.put(key50, value50);
|
||
map.put(key51, value51);
|
||
map.put(key52, value52);
|
||
map.put(key53, value53);
|
||
map.put(key54, value54);
|
||
map.put(key55, value55);
|
||
map.put(key56, value56);
|
||
map.put(key57, value57);
|
||
map.put(key58, value58);
|
||
map.put(key59, value59);
|
||
map.put(key60, value60);
|
||
map.put(key61, value61);
|
||
map.put(key62, value62);
|
||
map.put(key63, value63);
|
||
map.put(key64, value64);
|
||
map.put(key65, value65);
|
||
map.put(key66, value66);
|
||
map.put(key67, value67);
|
||
map.put(key68, value68);
|
||
map.put(key69, value69);
|
||
map.put(key70, value70);
|
||
map.put(key71, value71);
|
||
map.put(key72, value72);
|
||
map.put(key73, value73);
|
||
map.put(key74, value74);
|
||
map.put(key75, value75);
|
||
map.put(key76, value76);
|
||
map.put(key77, value77);
|
||
map.put(key78, value78);
|
||
map.put(key79, value79);
|
||
map.put(key80, value80);
|
||
map.put(key81, value81);
|
||
return map;
|
||
}
|
||
|
||
public static <K, V> Map<K, V> of(
|
||
K key,
|
||
V value,
|
||
K key2,
|
||
V value2,
|
||
K key3,
|
||
V value3,
|
||
K key4,
|
||
V value4,
|
||
K key5,
|
||
V value5,
|
||
K key6,
|
||
V value6,
|
||
K key7,
|
||
V value7,
|
||
K key8,
|
||
V value8,
|
||
K key9,
|
||
V value9,
|
||
K key10,
|
||
V value10,
|
||
K key11,
|
||
V value11,
|
||
K key12,
|
||
V value12,
|
||
K key13,
|
||
V value13,
|
||
K key14,
|
||
V value14,
|
||
K key15,
|
||
V value15,
|
||
K key16,
|
||
V value16,
|
||
K key17,
|
||
V value17,
|
||
K key18,
|
||
V value18,
|
||
K key19,
|
||
V value19,
|
||
K key20,
|
||
V value20,
|
||
K key21,
|
||
V value21,
|
||
K key22,
|
||
V value22,
|
||
K key23,
|
||
V value23,
|
||
K key24,
|
||
V value24,
|
||
K key25,
|
||
V value25,
|
||
K key26,
|
||
V value26,
|
||
K key27,
|
||
V value27,
|
||
K key28,
|
||
V value28,
|
||
K key29,
|
||
V value29,
|
||
K key30,
|
||
V value30,
|
||
K key31,
|
||
V value31,
|
||
K key32,
|
||
V value32,
|
||
K key33,
|
||
V value33,
|
||
K key34,
|
||
V value34,
|
||
K key35,
|
||
V value35,
|
||
K key36,
|
||
V value36,
|
||
K key37,
|
||
V value37,
|
||
K key38,
|
||
V value38,
|
||
K key39,
|
||
V value39,
|
||
K key40,
|
||
V value40,
|
||
K key41,
|
||
V value41,
|
||
K key42,
|
||
V value42,
|
||
K key43,
|
||
V value43,
|
||
K key44,
|
||
V value44,
|
||
K key45,
|
||
V value45,
|
||
K key46,
|
||
V value46,
|
||
K key47,
|
||
V value47,
|
||
K key48,
|
||
V value48,
|
||
K key49,
|
||
V value49,
|
||
K key50,
|
||
V value50,
|
||
K key51,
|
||
V value51,
|
||
K key52,
|
||
V value52,
|
||
K key53,
|
||
V value53,
|
||
K key54,
|
||
V value54,
|
||
K key55,
|
||
V value55,
|
||
K key56,
|
||
V value56,
|
||
K key57,
|
||
V value57,
|
||
K key58,
|
||
V value58,
|
||
K key59,
|
||
V value59,
|
||
K key60,
|
||
V value60,
|
||
K key61,
|
||
V value61,
|
||
K key62,
|
||
V value62,
|
||
K key63,
|
||
V value63,
|
||
K key64,
|
||
V value64,
|
||
K key65,
|
||
V value65,
|
||
K key66,
|
||
V value66,
|
||
K key67,
|
||
V value67,
|
||
K key68,
|
||
V value68,
|
||
K key69,
|
||
V value69,
|
||
K key70,
|
||
V value70,
|
||
K key71,
|
||
V value71,
|
||
K key72,
|
||
V value72,
|
||
K key73,
|
||
V value73,
|
||
K key74,
|
||
V value74,
|
||
K key75,
|
||
V value75,
|
||
K key76,
|
||
V value76,
|
||
K key77,
|
||
V value77,
|
||
K key78,
|
||
V value78,
|
||
K key79,
|
||
V value79,
|
||
K key80,
|
||
V value80,
|
||
K key81,
|
||
V value81,
|
||
K key82,
|
||
V value82
|
||
) {
|
||
var map = new HashMap<K, V>(86);
|
||
map.put(key, value);
|
||
map.put(key2, value2);
|
||
map.put(key3, value3);
|
||
map.put(key4, value4);
|
||
map.put(key5, value5);
|
||
map.put(key6, value6);
|
||
map.put(key7, value7);
|
||
map.put(key8, value8);
|
||
map.put(key9, value9);
|
||
map.put(key10, value10);
|
||
map.put(key11, value11);
|
||
map.put(key12, value12);
|
||
map.put(key13, value13);
|
||
map.put(key14, value14);
|
||
map.put(key15, value15);
|
||
map.put(key16, value16);
|
||
map.put(key17, value17);
|
||
map.put(key18, value18);
|
||
map.put(key19, value19);
|
||
map.put(key20, value20);
|
||
map.put(key21, value21);
|
||
map.put(key22, value22);
|
||
map.put(key23, value23);
|
||
map.put(key24, value24);
|
||
map.put(key25, value25);
|
||
map.put(key26, value26);
|
||
map.put(key27, value27);
|
||
map.put(key28, value28);
|
||
map.put(key29, value29);
|
||
map.put(key30, value30);
|
||
map.put(key31, value31);
|
||
map.put(key32, value32);
|
||
map.put(key33, value33);
|
||
map.put(key34, value34);
|
||
map.put(key35, value35);
|
||
map.put(key36, value36);
|
||
map.put(key37, value37);
|
||
map.put(key38, value38);
|
||
map.put(key39, value39);
|
||
map.put(key40, value40);
|
||
map.put(key41, value41);
|
||
map.put(key42, value42);
|
||
map.put(key43, value43);
|
||
map.put(key44, value44);
|
||
map.put(key45, value45);
|
||
map.put(key46, value46);
|
||
map.put(key47, value47);
|
||
map.put(key48, value48);
|
||
map.put(key49, value49);
|
||
map.put(key50, value50);
|
||
map.put(key51, value51);
|
||
map.put(key52, value52);
|
||
map.put(key53, value53);
|
||
map.put(key54, value54);
|
||
map.put(key55, value55);
|
||
map.put(key56, value56);
|
||
map.put(key57, value57);
|
||
map.put(key58, value58);
|
||
map.put(key59, value59);
|
||
map.put(key60, value60);
|
||
map.put(key61, value61);
|
||
map.put(key62, value62);
|
||
map.put(key63, value63);
|
||
map.put(key64, value64);
|
||
map.put(key65, value65);
|
||
map.put(key66, value66);
|
||
map.put(key67, value67);
|
||
map.put(key68, value68);
|
||
map.put(key69, value69);
|
||
map.put(key70, value70);
|
||
map.put(key71, value71);
|
||
map.put(key72, value72);
|
||
map.put(key73, value73);
|
||
map.put(key74, value74);
|
||
map.put(key75, value75);
|
||
map.put(key76, value76);
|
||
map.put(key77, value77);
|
||
map.put(key78, value78);
|
||
map.put(key79, value79);
|
||
map.put(key80, value80);
|
||
map.put(key81, value81);
|
||
map.put(key82, value82);
|
||
return map;
|
||
}
|
||
|
||
public static <K, V> Map<K, V> of(
|
||
K key,
|
||
V value,
|
||
K key2,
|
||
V value2,
|
||
K key3,
|
||
V value3,
|
||
K key4,
|
||
V value4,
|
||
K key5,
|
||
V value5,
|
||
K key6,
|
||
V value6,
|
||
K key7,
|
||
V value7,
|
||
K key8,
|
||
V value8,
|
||
K key9,
|
||
V value9,
|
||
K key10,
|
||
V value10,
|
||
K key11,
|
||
V value11,
|
||
K key12,
|
||
V value12,
|
||
K key13,
|
||
V value13,
|
||
K key14,
|
||
V value14,
|
||
K key15,
|
||
V value15,
|
||
K key16,
|
||
V value16,
|
||
K key17,
|
||
V value17,
|
||
K key18,
|
||
V value18,
|
||
K key19,
|
||
V value19,
|
||
K key20,
|
||
V value20,
|
||
K key21,
|
||
V value21,
|
||
K key22,
|
||
V value22,
|
||
K key23,
|
||
V value23,
|
||
K key24,
|
||
V value24,
|
||
K key25,
|
||
V value25,
|
||
K key26,
|
||
V value26,
|
||
K key27,
|
||
V value27,
|
||
K key28,
|
||
V value28,
|
||
K key29,
|
||
V value29,
|
||
K key30,
|
||
V value30,
|
||
K key31,
|
||
V value31,
|
||
K key32,
|
||
V value32,
|
||
K key33,
|
||
V value33,
|
||
K key34,
|
||
V value34,
|
||
K key35,
|
||
V value35,
|
||
K key36,
|
||
V value36,
|
||
K key37,
|
||
V value37,
|
||
K key38,
|
||
V value38,
|
||
K key39,
|
||
V value39,
|
||
K key40,
|
||
V value40,
|
||
K key41,
|
||
V value41,
|
||
K key42,
|
||
V value42,
|
||
K key43,
|
||
V value43,
|
||
K key44,
|
||
V value44,
|
||
K key45,
|
||
V value45,
|
||
K key46,
|
||
V value46,
|
||
K key47,
|
||
V value47,
|
||
K key48,
|
||
V value48,
|
||
K key49,
|
||
V value49,
|
||
K key50,
|
||
V value50,
|
||
K key51,
|
||
V value51,
|
||
K key52,
|
||
V value52,
|
||
K key53,
|
||
V value53,
|
||
K key54,
|
||
V value54,
|
||
K key55,
|
||
V value55,
|
||
K key56,
|
||
V value56,
|
||
K key57,
|
||
V value57,
|
||
K key58,
|
||
V value58,
|
||
K key59,
|
||
V value59,
|
||
K key60,
|
||
V value60,
|
||
K key61,
|
||
V value61,
|
||
K key62,
|
||
V value62,
|
||
K key63,
|
||
V value63,
|
||
K key64,
|
||
V value64,
|
||
K key65,
|
||
V value65,
|
||
K key66,
|
||
V value66,
|
||
K key67,
|
||
V value67,
|
||
K key68,
|
||
V value68,
|
||
K key69,
|
||
V value69,
|
||
K key70,
|
||
V value70,
|
||
K key71,
|
||
V value71,
|
||
K key72,
|
||
V value72,
|
||
K key73,
|
||
V value73,
|
||
K key74,
|
||
V value74,
|
||
K key75,
|
||
V value75,
|
||
K key76,
|
||
V value76,
|
||
K key77,
|
||
V value77,
|
||
K key78,
|
||
V value78,
|
||
K key79,
|
||
V value79,
|
||
K key80,
|
||
V value80,
|
||
K key81,
|
||
V value81,
|
||
K key82,
|
||
V value82,
|
||
K key83,
|
||
V value83
|
||
) {
|
||
var map = new HashMap<K, V>(87);
|
||
map.put(key, value);
|
||
map.put(key2, value2);
|
||
map.put(key3, value3);
|
||
map.put(key4, value4);
|
||
map.put(key5, value5);
|
||
map.put(key6, value6);
|
||
map.put(key7, value7);
|
||
map.put(key8, value8);
|
||
map.put(key9, value9);
|
||
map.put(key10, value10);
|
||
map.put(key11, value11);
|
||
map.put(key12, value12);
|
||
map.put(key13, value13);
|
||
map.put(key14, value14);
|
||
map.put(key15, value15);
|
||
map.put(key16, value16);
|
||
map.put(key17, value17);
|
||
map.put(key18, value18);
|
||
map.put(key19, value19);
|
||
map.put(key20, value20);
|
||
map.put(key21, value21);
|
||
map.put(key22, value22);
|
||
map.put(key23, value23);
|
||
map.put(key24, value24);
|
||
map.put(key25, value25);
|
||
map.put(key26, value26);
|
||
map.put(key27, value27);
|
||
map.put(key28, value28);
|
||
map.put(key29, value29);
|
||
map.put(key30, value30);
|
||
map.put(key31, value31);
|
||
map.put(key32, value32);
|
||
map.put(key33, value33);
|
||
map.put(key34, value34);
|
||
map.put(key35, value35);
|
||
map.put(key36, value36);
|
||
map.put(key37, value37);
|
||
map.put(key38, value38);
|
||
map.put(key39, value39);
|
||
map.put(key40, value40);
|
||
map.put(key41, value41);
|
||
map.put(key42, value42);
|
||
map.put(key43, value43);
|
||
map.put(key44, value44);
|
||
map.put(key45, value45);
|
||
map.put(key46, value46);
|
||
map.put(key47, value47);
|
||
map.put(key48, value48);
|
||
map.put(key49, value49);
|
||
map.put(key50, value50);
|
||
map.put(key51, value51);
|
||
map.put(key52, value52);
|
||
map.put(key53, value53);
|
||
map.put(key54, value54);
|
||
map.put(key55, value55);
|
||
map.put(key56, value56);
|
||
map.put(key57, value57);
|
||
map.put(key58, value58);
|
||
map.put(key59, value59);
|
||
map.put(key60, value60);
|
||
map.put(key61, value61);
|
||
map.put(key62, value62);
|
||
map.put(key63, value63);
|
||
map.put(key64, value64);
|
||
map.put(key65, value65);
|
||
map.put(key66, value66);
|
||
map.put(key67, value67);
|
||
map.put(key68, value68);
|
||
map.put(key69, value69);
|
||
map.put(key70, value70);
|
||
map.put(key71, value71);
|
||
map.put(key72, value72);
|
||
map.put(key73, value73);
|
||
map.put(key74, value74);
|
||
map.put(key75, value75);
|
||
map.put(key76, value76);
|
||
map.put(key77, value77);
|
||
map.put(key78, value78);
|
||
map.put(key79, value79);
|
||
map.put(key80, value80);
|
||
map.put(key81, value81);
|
||
map.put(key82, value82);
|
||
map.put(key83, value83);
|
||
return map;
|
||
}
|
||
|
||
public static <K, V> Map<K, V> of(
|
||
K key,
|
||
V value,
|
||
K key2,
|
||
V value2,
|
||
K key3,
|
||
V value3,
|
||
K key4,
|
||
V value4,
|
||
K key5,
|
||
V value5,
|
||
K key6,
|
||
V value6,
|
||
K key7,
|
||
V value7,
|
||
K key8,
|
||
V value8,
|
||
K key9,
|
||
V value9,
|
||
K key10,
|
||
V value10,
|
||
K key11,
|
||
V value11,
|
||
K key12,
|
||
V value12,
|
||
K key13,
|
||
V value13,
|
||
K key14,
|
||
V value14,
|
||
K key15,
|
||
V value15,
|
||
K key16,
|
||
V value16,
|
||
K key17,
|
||
V value17,
|
||
K key18,
|
||
V value18,
|
||
K key19,
|
||
V value19,
|
||
K key20,
|
||
V value20,
|
||
K key21,
|
||
V value21,
|
||
K key22,
|
||
V value22,
|
||
K key23,
|
||
V value23,
|
||
K key24,
|
||
V value24,
|
||
K key25,
|
||
V value25,
|
||
K key26,
|
||
V value26,
|
||
K key27,
|
||
V value27,
|
||
K key28,
|
||
V value28,
|
||
K key29,
|
||
V value29,
|
||
K key30,
|
||
V value30,
|
||
K key31,
|
||
V value31,
|
||
K key32,
|
||
V value32,
|
||
K key33,
|
||
V value33,
|
||
K key34,
|
||
V value34,
|
||
K key35,
|
||
V value35,
|
||
K key36,
|
||
V value36,
|
||
K key37,
|
||
V value37,
|
||
K key38,
|
||
V value38,
|
||
K key39,
|
||
V value39,
|
||
K key40,
|
||
V value40,
|
||
K key41,
|
||
V value41,
|
||
K key42,
|
||
V value42,
|
||
K key43,
|
||
V value43,
|
||
K key44,
|
||
V value44,
|
||
K key45,
|
||
V value45,
|
||
K key46,
|
||
V value46,
|
||
K key47,
|
||
V value47,
|
||
K key48,
|
||
V value48,
|
||
K key49,
|
||
V value49,
|
||
K key50,
|
||
V value50,
|
||
K key51,
|
||
V value51,
|
||
K key52,
|
||
V value52,
|
||
K key53,
|
||
V value53,
|
||
K key54,
|
||
V value54,
|
||
K key55,
|
||
V value55,
|
||
K key56,
|
||
V value56,
|
||
K key57,
|
||
V value57,
|
||
K key58,
|
||
V value58,
|
||
K key59,
|
||
V value59,
|
||
K key60,
|
||
V value60,
|
||
K key61,
|
||
V value61,
|
||
K key62,
|
||
V value62,
|
||
K key63,
|
||
V value63,
|
||
K key64,
|
||
V value64,
|
||
K key65,
|
||
V value65,
|
||
K key66,
|
||
V value66,
|
||
K key67,
|
||
V value67,
|
||
K key68,
|
||
V value68,
|
||
K key69,
|
||
V value69,
|
||
K key70,
|
||
V value70,
|
||
K key71,
|
||
V value71,
|
||
K key72,
|
||
V value72,
|
||
K key73,
|
||
V value73,
|
||
K key74,
|
||
V value74,
|
||
K key75,
|
||
V value75,
|
||
K key76,
|
||
V value76,
|
||
K key77,
|
||
V value77,
|
||
K key78,
|
||
V value78,
|
||
K key79,
|
||
V value79,
|
||
K key80,
|
||
V value80,
|
||
K key81,
|
||
V value81,
|
||
K key82,
|
||
V value82,
|
||
K key83,
|
||
V value83,
|
||
K key84,
|
||
V value84
|
||
) {
|
||
var map = new HashMap<K, V>(88);
|
||
map.put(key, value);
|
||
map.put(key2, value2);
|
||
map.put(key3, value3);
|
||
map.put(key4, value4);
|
||
map.put(key5, value5);
|
||
map.put(key6, value6);
|
||
map.put(key7, value7);
|
||
map.put(key8, value8);
|
||
map.put(key9, value9);
|
||
map.put(key10, value10);
|
||
map.put(key11, value11);
|
||
map.put(key12, value12);
|
||
map.put(key13, value13);
|
||
map.put(key14, value14);
|
||
map.put(key15, value15);
|
||
map.put(key16, value16);
|
||
map.put(key17, value17);
|
||
map.put(key18, value18);
|
||
map.put(key19, value19);
|
||
map.put(key20, value20);
|
||
map.put(key21, value21);
|
||
map.put(key22, value22);
|
||
map.put(key23, value23);
|
||
map.put(key24, value24);
|
||
map.put(key25, value25);
|
||
map.put(key26, value26);
|
||
map.put(key27, value27);
|
||
map.put(key28, value28);
|
||
map.put(key29, value29);
|
||
map.put(key30, value30);
|
||
map.put(key31, value31);
|
||
map.put(key32, value32);
|
||
map.put(key33, value33);
|
||
map.put(key34, value34);
|
||
map.put(key35, value35);
|
||
map.put(key36, value36);
|
||
map.put(key37, value37);
|
||
map.put(key38, value38);
|
||
map.put(key39, value39);
|
||
map.put(key40, value40);
|
||
map.put(key41, value41);
|
||
map.put(key42, value42);
|
||
map.put(key43, value43);
|
||
map.put(key44, value44);
|
||
map.put(key45, value45);
|
||
map.put(key46, value46);
|
||
map.put(key47, value47);
|
||
map.put(key48, value48);
|
||
map.put(key49, value49);
|
||
map.put(key50, value50);
|
||
map.put(key51, value51);
|
||
map.put(key52, value52);
|
||
map.put(key53, value53);
|
||
map.put(key54, value54);
|
||
map.put(key55, value55);
|
||
map.put(key56, value56);
|
||
map.put(key57, value57);
|
||
map.put(key58, value58);
|
||
map.put(key59, value59);
|
||
map.put(key60, value60);
|
||
map.put(key61, value61);
|
||
map.put(key62, value62);
|
||
map.put(key63, value63);
|
||
map.put(key64, value64);
|
||
map.put(key65, value65);
|
||
map.put(key66, value66);
|
||
map.put(key67, value67);
|
||
map.put(key68, value68);
|
||
map.put(key69, value69);
|
||
map.put(key70, value70);
|
||
map.put(key71, value71);
|
||
map.put(key72, value72);
|
||
map.put(key73, value73);
|
||
map.put(key74, value74);
|
||
map.put(key75, value75);
|
||
map.put(key76, value76);
|
||
map.put(key77, value77);
|
||
map.put(key78, value78);
|
||
map.put(key79, value79);
|
||
map.put(key80, value80);
|
||
map.put(key81, value81);
|
||
map.put(key82, value82);
|
||
map.put(key83, value83);
|
||
map.put(key84, value84);
|
||
return map;
|
||
}
|
||
|
||
public static <K, V> Map<K, V> of(
|
||
K key,
|
||
V value,
|
||
K key2,
|
||
V value2,
|
||
K key3,
|
||
V value3,
|
||
K key4,
|
||
V value4,
|
||
K key5,
|
||
V value5,
|
||
K key6,
|
||
V value6,
|
||
K key7,
|
||
V value7,
|
||
K key8,
|
||
V value8,
|
||
K key9,
|
||
V value9,
|
||
K key10,
|
||
V value10,
|
||
K key11,
|
||
V value11,
|
||
K key12,
|
||
V value12,
|
||
K key13,
|
||
V value13,
|
||
K key14,
|
||
V value14,
|
||
K key15,
|
||
V value15,
|
||
K key16,
|
||
V value16,
|
||
K key17,
|
||
V value17,
|
||
K key18,
|
||
V value18,
|
||
K key19,
|
||
V value19,
|
||
K key20,
|
||
V value20,
|
||
K key21,
|
||
V value21,
|
||
K key22,
|
||
V value22,
|
||
K key23,
|
||
V value23,
|
||
K key24,
|
||
V value24,
|
||
K key25,
|
||
V value25,
|
||
K key26,
|
||
V value26,
|
||
K key27,
|
||
V value27,
|
||
K key28,
|
||
V value28,
|
||
K key29,
|
||
V value29,
|
||
K key30,
|
||
V value30,
|
||
K key31,
|
||
V value31,
|
||
K key32,
|
||
V value32,
|
||
K key33,
|
||
V value33,
|
||
K key34,
|
||
V value34,
|
||
K key35,
|
||
V value35,
|
||
K key36,
|
||
V value36,
|
||
K key37,
|
||
V value37,
|
||
K key38,
|
||
V value38,
|
||
K key39,
|
||
V value39,
|
||
K key40,
|
||
V value40,
|
||
K key41,
|
||
V value41,
|
||
K key42,
|
||
V value42,
|
||
K key43,
|
||
V value43,
|
||
K key44,
|
||
V value44,
|
||
K key45,
|
||
V value45,
|
||
K key46,
|
||
V value46,
|
||
K key47,
|
||
V value47,
|
||
K key48,
|
||
V value48,
|
||
K key49,
|
||
V value49,
|
||
K key50,
|
||
V value50,
|
||
K key51,
|
||
V value51,
|
||
K key52,
|
||
V value52,
|
||
K key53,
|
||
V value53,
|
||
K key54,
|
||
V value54,
|
||
K key55,
|
||
V value55,
|
||
K key56,
|
||
V value56,
|
||
K key57,
|
||
V value57,
|
||
K key58,
|
||
V value58,
|
||
K key59,
|
||
V value59,
|
||
K key60,
|
||
V value60,
|
||
K key61,
|
||
V value61,
|
||
K key62,
|
||
V value62,
|
||
K key63,
|
||
V value63,
|
||
K key64,
|
||
V value64,
|
||
K key65,
|
||
V value65,
|
||
K key66,
|
||
V value66,
|
||
K key67,
|
||
V value67,
|
||
K key68,
|
||
V value68,
|
||
K key69,
|
||
V value69,
|
||
K key70,
|
||
V value70,
|
||
K key71,
|
||
V value71,
|
||
K key72,
|
||
V value72,
|
||
K key73,
|
||
V value73,
|
||
K key74,
|
||
V value74,
|
||
K key75,
|
||
V value75,
|
||
K key76,
|
||
V value76,
|
||
K key77,
|
||
V value77,
|
||
K key78,
|
||
V value78,
|
||
K key79,
|
||
V value79,
|
||
K key80,
|
||
V value80,
|
||
K key81,
|
||
V value81,
|
||
K key82,
|
||
V value82,
|
||
K key83,
|
||
V value83,
|
||
K key84,
|
||
V value84,
|
||
K key85,
|
||
V value85
|
||
) {
|
||
var map = new HashMap<K, V>(89);
|
||
map.put(key, value);
|
||
map.put(key2, value2);
|
||
map.put(key3, value3);
|
||
map.put(key4, value4);
|
||
map.put(key5, value5);
|
||
map.put(key6, value6);
|
||
map.put(key7, value7);
|
||
map.put(key8, value8);
|
||
map.put(key9, value9);
|
||
map.put(key10, value10);
|
||
map.put(key11, value11);
|
||
map.put(key12, value12);
|
||
map.put(key13, value13);
|
||
map.put(key14, value14);
|
||
map.put(key15, value15);
|
||
map.put(key16, value16);
|
||
map.put(key17, value17);
|
||
map.put(key18, value18);
|
||
map.put(key19, value19);
|
||
map.put(key20, value20);
|
||
map.put(key21, value21);
|
||
map.put(key22, value22);
|
||
map.put(key23, value23);
|
||
map.put(key24, value24);
|
||
map.put(key25, value25);
|
||
map.put(key26, value26);
|
||
map.put(key27, value27);
|
||
map.put(key28, value28);
|
||
map.put(key29, value29);
|
||
map.put(key30, value30);
|
||
map.put(key31, value31);
|
||
map.put(key32, value32);
|
||
map.put(key33, value33);
|
||
map.put(key34, value34);
|
||
map.put(key35, value35);
|
||
map.put(key36, value36);
|
||
map.put(key37, value37);
|
||
map.put(key38, value38);
|
||
map.put(key39, value39);
|
||
map.put(key40, value40);
|
||
map.put(key41, value41);
|
||
map.put(key42, value42);
|
||
map.put(key43, value43);
|
||
map.put(key44, value44);
|
||
map.put(key45, value45);
|
||
map.put(key46, value46);
|
||
map.put(key47, value47);
|
||
map.put(key48, value48);
|
||
map.put(key49, value49);
|
||
map.put(key50, value50);
|
||
map.put(key51, value51);
|
||
map.put(key52, value52);
|
||
map.put(key53, value53);
|
||
map.put(key54, value54);
|
||
map.put(key55, value55);
|
||
map.put(key56, value56);
|
||
map.put(key57, value57);
|
||
map.put(key58, value58);
|
||
map.put(key59, value59);
|
||
map.put(key60, value60);
|
||
map.put(key61, value61);
|
||
map.put(key62, value62);
|
||
map.put(key63, value63);
|
||
map.put(key64, value64);
|
||
map.put(key65, value65);
|
||
map.put(key66, value66);
|
||
map.put(key67, value67);
|
||
map.put(key68, value68);
|
||
map.put(key69, value69);
|
||
map.put(key70, value70);
|
||
map.put(key71, value71);
|
||
map.put(key72, value72);
|
||
map.put(key73, value73);
|
||
map.put(key74, value74);
|
||
map.put(key75, value75);
|
||
map.put(key76, value76);
|
||
map.put(key77, value77);
|
||
map.put(key78, value78);
|
||
map.put(key79, value79);
|
||
map.put(key80, value80);
|
||
map.put(key81, value81);
|
||
map.put(key82, value82);
|
||
map.put(key83, value83);
|
||
map.put(key84, value84);
|
||
map.put(key85, value85);
|
||
return map;
|
||
}
|
||
|
||
public static <K, V> Map<K, V> of(
|
||
K key,
|
||
V value,
|
||
K key2,
|
||
V value2,
|
||
K key3,
|
||
V value3,
|
||
K key4,
|
||
V value4,
|
||
K key5,
|
||
V value5,
|
||
K key6,
|
||
V value6,
|
||
K key7,
|
||
V value7,
|
||
K key8,
|
||
V value8,
|
||
K key9,
|
||
V value9,
|
||
K key10,
|
||
V value10,
|
||
K key11,
|
||
V value11,
|
||
K key12,
|
||
V value12,
|
||
K key13,
|
||
V value13,
|
||
K key14,
|
||
V value14,
|
||
K key15,
|
||
V value15,
|
||
K key16,
|
||
V value16,
|
||
K key17,
|
||
V value17,
|
||
K key18,
|
||
V value18,
|
||
K key19,
|
||
V value19,
|
||
K key20,
|
||
V value20,
|
||
K key21,
|
||
V value21,
|
||
K key22,
|
||
V value22,
|
||
K key23,
|
||
V value23,
|
||
K key24,
|
||
V value24,
|
||
K key25,
|
||
V value25,
|
||
K key26,
|
||
V value26,
|
||
K key27,
|
||
V value27,
|
||
K key28,
|
||
V value28,
|
||
K key29,
|
||
V value29,
|
||
K key30,
|
||
V value30,
|
||
K key31,
|
||
V value31,
|
||
K key32,
|
||
V value32,
|
||
K key33,
|
||
V value33,
|
||
K key34,
|
||
V value34,
|
||
K key35,
|
||
V value35,
|
||
K key36,
|
||
V value36,
|
||
K key37,
|
||
V value37,
|
||
K key38,
|
||
V value38,
|
||
K key39,
|
||
V value39,
|
||
K key40,
|
||
V value40,
|
||
K key41,
|
||
V value41,
|
||
K key42,
|
||
V value42,
|
||
K key43,
|
||
V value43,
|
||
K key44,
|
||
V value44,
|
||
K key45,
|
||
V value45,
|
||
K key46,
|
||
V value46,
|
||
K key47,
|
||
V value47,
|
||
K key48,
|
||
V value48,
|
||
K key49,
|
||
V value49,
|
||
K key50,
|
||
V value50,
|
||
K key51,
|
||
V value51,
|
||
K key52,
|
||
V value52,
|
||
K key53,
|
||
V value53,
|
||
K key54,
|
||
V value54,
|
||
K key55,
|
||
V value55,
|
||
K key56,
|
||
V value56,
|
||
K key57,
|
||
V value57,
|
||
K key58,
|
||
V value58,
|
||
K key59,
|
||
V value59,
|
||
K key60,
|
||
V value60,
|
||
K key61,
|
||
V value61,
|
||
K key62,
|
||
V value62,
|
||
K key63,
|
||
V value63,
|
||
K key64,
|
||
V value64,
|
||
K key65,
|
||
V value65,
|
||
K key66,
|
||
V value66,
|
||
K key67,
|
||
V value67,
|
||
K key68,
|
||
V value68,
|
||
K key69,
|
||
V value69,
|
||
K key70,
|
||
V value70,
|
||
K key71,
|
||
V value71,
|
||
K key72,
|
||
V value72,
|
||
K key73,
|
||
V value73,
|
||
K key74,
|
||
V value74,
|
||
K key75,
|
||
V value75,
|
||
K key76,
|
||
V value76,
|
||
K key77,
|
||
V value77,
|
||
K key78,
|
||
V value78,
|
||
K key79,
|
||
V value79,
|
||
K key80,
|
||
V value80,
|
||
K key81,
|
||
V value81,
|
||
K key82,
|
||
V value82,
|
||
K key83,
|
||
V value83,
|
||
K key84,
|
||
V value84,
|
||
K key85,
|
||
V value85,
|
||
K key86,
|
||
V value86
|
||
) {
|
||
var map = new HashMap<K, V>(90);
|
||
map.put(key, value);
|
||
map.put(key2, value2);
|
||
map.put(key3, value3);
|
||
map.put(key4, value4);
|
||
map.put(key5, value5);
|
||
map.put(key6, value6);
|
||
map.put(key7, value7);
|
||
map.put(key8, value8);
|
||
map.put(key9, value9);
|
||
map.put(key10, value10);
|
||
map.put(key11, value11);
|
||
map.put(key12, value12);
|
||
map.put(key13, value13);
|
||
map.put(key14, value14);
|
||
map.put(key15, value15);
|
||
map.put(key16, value16);
|
||
map.put(key17, value17);
|
||
map.put(key18, value18);
|
||
map.put(key19, value19);
|
||
map.put(key20, value20);
|
||
map.put(key21, value21);
|
||
map.put(key22, value22);
|
||
map.put(key23, value23);
|
||
map.put(key24, value24);
|
||
map.put(key25, value25);
|
||
map.put(key26, value26);
|
||
map.put(key27, value27);
|
||
map.put(key28, value28);
|
||
map.put(key29, value29);
|
||
map.put(key30, value30);
|
||
map.put(key31, value31);
|
||
map.put(key32, value32);
|
||
map.put(key33, value33);
|
||
map.put(key34, value34);
|
||
map.put(key35, value35);
|
||
map.put(key36, value36);
|
||
map.put(key37, value37);
|
||
map.put(key38, value38);
|
||
map.put(key39, value39);
|
||
map.put(key40, value40);
|
||
map.put(key41, value41);
|
||
map.put(key42, value42);
|
||
map.put(key43, value43);
|
||
map.put(key44, value44);
|
||
map.put(key45, value45);
|
||
map.put(key46, value46);
|
||
map.put(key47, value47);
|
||
map.put(key48, value48);
|
||
map.put(key49, value49);
|
||
map.put(key50, value50);
|
||
map.put(key51, value51);
|
||
map.put(key52, value52);
|
||
map.put(key53, value53);
|
||
map.put(key54, value54);
|
||
map.put(key55, value55);
|
||
map.put(key56, value56);
|
||
map.put(key57, value57);
|
||
map.put(key58, value58);
|
||
map.put(key59, value59);
|
||
map.put(key60, value60);
|
||
map.put(key61, value61);
|
||
map.put(key62, value62);
|
||
map.put(key63, value63);
|
||
map.put(key64, value64);
|
||
map.put(key65, value65);
|
||
map.put(key66, value66);
|
||
map.put(key67, value67);
|
||
map.put(key68, value68);
|
||
map.put(key69, value69);
|
||
map.put(key70, value70);
|
||
map.put(key71, value71);
|
||
map.put(key72, value72);
|
||
map.put(key73, value73);
|
||
map.put(key74, value74);
|
||
map.put(key75, value75);
|
||
map.put(key76, value76);
|
||
map.put(key77, value77);
|
||
map.put(key78, value78);
|
||
map.put(key79, value79);
|
||
map.put(key80, value80);
|
||
map.put(key81, value81);
|
||
map.put(key82, value82);
|
||
map.put(key83, value83);
|
||
map.put(key84, value84);
|
||
map.put(key85, value85);
|
||
map.put(key86, value86);
|
||
return map;
|
||
}
|
||
|
||
public static <K, V> Map<K, V> of(
|
||
K key,
|
||
V value,
|
||
K key2,
|
||
V value2,
|
||
K key3,
|
||
V value3,
|
||
K key4,
|
||
V value4,
|
||
K key5,
|
||
V value5,
|
||
K key6,
|
||
V value6,
|
||
K key7,
|
||
V value7,
|
||
K key8,
|
||
V value8,
|
||
K key9,
|
||
V value9,
|
||
K key10,
|
||
V value10,
|
||
K key11,
|
||
V value11,
|
||
K key12,
|
||
V value12,
|
||
K key13,
|
||
V value13,
|
||
K key14,
|
||
V value14,
|
||
K key15,
|
||
V value15,
|
||
K key16,
|
||
V value16,
|
||
K key17,
|
||
V value17,
|
||
K key18,
|
||
V value18,
|
||
K key19,
|
||
V value19,
|
||
K key20,
|
||
V value20,
|
||
K key21,
|
||
V value21,
|
||
K key22,
|
||
V value22,
|
||
K key23,
|
||
V value23,
|
||
K key24,
|
||
V value24,
|
||
K key25,
|
||
V value25,
|
||
K key26,
|
||
V value26,
|
||
K key27,
|
||
V value27,
|
||
K key28,
|
||
V value28,
|
||
K key29,
|
||
V value29,
|
||
K key30,
|
||
V value30,
|
||
K key31,
|
||
V value31,
|
||
K key32,
|
||
V value32,
|
||
K key33,
|
||
V value33,
|
||
K key34,
|
||
V value34,
|
||
K key35,
|
||
V value35,
|
||
K key36,
|
||
V value36,
|
||
K key37,
|
||
V value37,
|
||
K key38,
|
||
V value38,
|
||
K key39,
|
||
V value39,
|
||
K key40,
|
||
V value40,
|
||
K key41,
|
||
V value41,
|
||
K key42,
|
||
V value42,
|
||
K key43,
|
||
V value43,
|
||
K key44,
|
||
V value44,
|
||
K key45,
|
||
V value45,
|
||
K key46,
|
||
V value46,
|
||
K key47,
|
||
V value47,
|
||
K key48,
|
||
V value48,
|
||
K key49,
|
||
V value49,
|
||
K key50,
|
||
V value50,
|
||
K key51,
|
||
V value51,
|
||
K key52,
|
||
V value52,
|
||
K key53,
|
||
V value53,
|
||
K key54,
|
||
V value54,
|
||
K key55,
|
||
V value55,
|
||
K key56,
|
||
V value56,
|
||
K key57,
|
||
V value57,
|
||
K key58,
|
||
V value58,
|
||
K key59,
|
||
V value59,
|
||
K key60,
|
||
V value60,
|
||
K key61,
|
||
V value61,
|
||
K key62,
|
||
V value62,
|
||
K key63,
|
||
V value63,
|
||
K key64,
|
||
V value64,
|
||
K key65,
|
||
V value65,
|
||
K key66,
|
||
V value66,
|
||
K key67,
|
||
V value67,
|
||
K key68,
|
||
V value68,
|
||
K key69,
|
||
V value69,
|
||
K key70,
|
||
V value70,
|
||
K key71,
|
||
V value71,
|
||
K key72,
|
||
V value72,
|
||
K key73,
|
||
V value73,
|
||
K key74,
|
||
V value74,
|
||
K key75,
|
||
V value75,
|
||
K key76,
|
||
V value76,
|
||
K key77,
|
||
V value77,
|
||
K key78,
|
||
V value78,
|
||
K key79,
|
||
V value79,
|
||
K key80,
|
||
V value80,
|
||
K key81,
|
||
V value81,
|
||
K key82,
|
||
V value82,
|
||
K key83,
|
||
V value83,
|
||
K key84,
|
||
V value84,
|
||
K key85,
|
||
V value85,
|
||
K key86,
|
||
V value86,
|
||
K key87,
|
||
V value87
|
||
) {
|
||
var map = new HashMap<K, V>(91);
|
||
map.put(key, value);
|
||
map.put(key2, value2);
|
||
map.put(key3, value3);
|
||
map.put(key4, value4);
|
||
map.put(key5, value5);
|
||
map.put(key6, value6);
|
||
map.put(key7, value7);
|
||
map.put(key8, value8);
|
||
map.put(key9, value9);
|
||
map.put(key10, value10);
|
||
map.put(key11, value11);
|
||
map.put(key12, value12);
|
||
map.put(key13, value13);
|
||
map.put(key14, value14);
|
||
map.put(key15, value15);
|
||
map.put(key16, value16);
|
||
map.put(key17, value17);
|
||
map.put(key18, value18);
|
||
map.put(key19, value19);
|
||
map.put(key20, value20);
|
||
map.put(key21, value21);
|
||
map.put(key22, value22);
|
||
map.put(key23, value23);
|
||
map.put(key24, value24);
|
||
map.put(key25, value25);
|
||
map.put(key26, value26);
|
||
map.put(key27, value27);
|
||
map.put(key28, value28);
|
||
map.put(key29, value29);
|
||
map.put(key30, value30);
|
||
map.put(key31, value31);
|
||
map.put(key32, value32);
|
||
map.put(key33, value33);
|
||
map.put(key34, value34);
|
||
map.put(key35, value35);
|
||
map.put(key36, value36);
|
||
map.put(key37, value37);
|
||
map.put(key38, value38);
|
||
map.put(key39, value39);
|
||
map.put(key40, value40);
|
||
map.put(key41, value41);
|
||
map.put(key42, value42);
|
||
map.put(key43, value43);
|
||
map.put(key44, value44);
|
||
map.put(key45, value45);
|
||
map.put(key46, value46);
|
||
map.put(key47, value47);
|
||
map.put(key48, value48);
|
||
map.put(key49, value49);
|
||
map.put(key50, value50);
|
||
map.put(key51, value51);
|
||
map.put(key52, value52);
|
||
map.put(key53, value53);
|
||
map.put(key54, value54);
|
||
map.put(key55, value55);
|
||
map.put(key56, value56);
|
||
map.put(key57, value57);
|
||
map.put(key58, value58);
|
||
map.put(key59, value59);
|
||
map.put(key60, value60);
|
||
map.put(key61, value61);
|
||
map.put(key62, value62);
|
||
map.put(key63, value63);
|
||
map.put(key64, value64);
|
||
map.put(key65, value65);
|
||
map.put(key66, value66);
|
||
map.put(key67, value67);
|
||
map.put(key68, value68);
|
||
map.put(key69, value69);
|
||
map.put(key70, value70);
|
||
map.put(key71, value71);
|
||
map.put(key72, value72);
|
||
map.put(key73, value73);
|
||
map.put(key74, value74);
|
||
map.put(key75, value75);
|
||
map.put(key76, value76);
|
||
map.put(key77, value77);
|
||
map.put(key78, value78);
|
||
map.put(key79, value79);
|
||
map.put(key80, value80);
|
||
map.put(key81, value81);
|
||
map.put(key82, value82);
|
||
map.put(key83, value83);
|
||
map.put(key84, value84);
|
||
map.put(key85, value85);
|
||
map.put(key86, value86);
|
||
map.put(key87, value87);
|
||
return map;
|
||
}
|
||
|
||
public static <K, V> Map<K, V> of(
|
||
K key,
|
||
V value,
|
||
K key2,
|
||
V value2,
|
||
K key3,
|
||
V value3,
|
||
K key4,
|
||
V value4,
|
||
K key5,
|
||
V value5,
|
||
K key6,
|
||
V value6,
|
||
K key7,
|
||
V value7,
|
||
K key8,
|
||
V value8,
|
||
K key9,
|
||
V value9,
|
||
K key10,
|
||
V value10,
|
||
K key11,
|
||
V value11,
|
||
K key12,
|
||
V value12,
|
||
K key13,
|
||
V value13,
|
||
K key14,
|
||
V value14,
|
||
K key15,
|
||
V value15,
|
||
K key16,
|
||
V value16,
|
||
K key17,
|
||
V value17,
|
||
K key18,
|
||
V value18,
|
||
K key19,
|
||
V value19,
|
||
K key20,
|
||
V value20,
|
||
K key21,
|
||
V value21,
|
||
K key22,
|
||
V value22,
|
||
K key23,
|
||
V value23,
|
||
K key24,
|
||
V value24,
|
||
K key25,
|
||
V value25,
|
||
K key26,
|
||
V value26,
|
||
K key27,
|
||
V value27,
|
||
K key28,
|
||
V value28,
|
||
K key29,
|
||
V value29,
|
||
K key30,
|
||
V value30,
|
||
K key31,
|
||
V value31,
|
||
K key32,
|
||
V value32,
|
||
K key33,
|
||
V value33,
|
||
K key34,
|
||
V value34,
|
||
K key35,
|
||
V value35,
|
||
K key36,
|
||
V value36,
|
||
K key37,
|
||
V value37,
|
||
K key38,
|
||
V value38,
|
||
K key39,
|
||
V value39,
|
||
K key40,
|
||
V value40,
|
||
K key41,
|
||
V value41,
|
||
K key42,
|
||
V value42,
|
||
K key43,
|
||
V value43,
|
||
K key44,
|
||
V value44,
|
||
K key45,
|
||
V value45,
|
||
K key46,
|
||
V value46,
|
||
K key47,
|
||
V value47,
|
||
K key48,
|
||
V value48,
|
||
K key49,
|
||
V value49,
|
||
K key50,
|
||
V value50,
|
||
K key51,
|
||
V value51,
|
||
K key52,
|
||
V value52,
|
||
K key53,
|
||
V value53,
|
||
K key54,
|
||
V value54,
|
||
K key55,
|
||
V value55,
|
||
K key56,
|
||
V value56,
|
||
K key57,
|
||
V value57,
|
||
K key58,
|
||
V value58,
|
||
K key59,
|
||
V value59,
|
||
K key60,
|
||
V value60,
|
||
K key61,
|
||
V value61,
|
||
K key62,
|
||
V value62,
|
||
K key63,
|
||
V value63,
|
||
K key64,
|
||
V value64,
|
||
K key65,
|
||
V value65,
|
||
K key66,
|
||
V value66,
|
||
K key67,
|
||
V value67,
|
||
K key68,
|
||
V value68,
|
||
K key69,
|
||
V value69,
|
||
K key70,
|
||
V value70,
|
||
K key71,
|
||
V value71,
|
||
K key72,
|
||
V value72,
|
||
K key73,
|
||
V value73,
|
||
K key74,
|
||
V value74,
|
||
K key75,
|
||
V value75,
|
||
K key76,
|
||
V value76,
|
||
K key77,
|
||
V value77,
|
||
K key78,
|
||
V value78,
|
||
K key79,
|
||
V value79,
|
||
K key80,
|
||
V value80,
|
||
K key81,
|
||
V value81,
|
||
K key82,
|
||
V value82,
|
||
K key83,
|
||
V value83,
|
||
K key84,
|
||
V value84,
|
||
K key85,
|
||
V value85,
|
||
K key86,
|
||
V value86,
|
||
K key87,
|
||
V value87,
|
||
K key88,
|
||
V value88
|
||
) {
|
||
var map = new HashMap<K, V>(92);
|
||
map.put(key, value);
|
||
map.put(key2, value2);
|
||
map.put(key3, value3);
|
||
map.put(key4, value4);
|
||
map.put(key5, value5);
|
||
map.put(key6, value6);
|
||
map.put(key7, value7);
|
||
map.put(key8, value8);
|
||
map.put(key9, value9);
|
||
map.put(key10, value10);
|
||
map.put(key11, value11);
|
||
map.put(key12, value12);
|
||
map.put(key13, value13);
|
||
map.put(key14, value14);
|
||
map.put(key15, value15);
|
||
map.put(key16, value16);
|
||
map.put(key17, value17);
|
||
map.put(key18, value18);
|
||
map.put(key19, value19);
|
||
map.put(key20, value20);
|
||
map.put(key21, value21);
|
||
map.put(key22, value22);
|
||
map.put(key23, value23);
|
||
map.put(key24, value24);
|
||
map.put(key25, value25);
|
||
map.put(key26, value26);
|
||
map.put(key27, value27);
|
||
map.put(key28, value28);
|
||
map.put(key29, value29);
|
||
map.put(key30, value30);
|
||
map.put(key31, value31);
|
||
map.put(key32, value32);
|
||
map.put(key33, value33);
|
||
map.put(key34, value34);
|
||
map.put(key35, value35);
|
||
map.put(key36, value36);
|
||
map.put(key37, value37);
|
||
map.put(key38, value38);
|
||
map.put(key39, value39);
|
||
map.put(key40, value40);
|
||
map.put(key41, value41);
|
||
map.put(key42, value42);
|
||
map.put(key43, value43);
|
||
map.put(key44, value44);
|
||
map.put(key45, value45);
|
||
map.put(key46, value46);
|
||
map.put(key47, value47);
|
||
map.put(key48, value48);
|
||
map.put(key49, value49);
|
||
map.put(key50, value50);
|
||
map.put(key51, value51);
|
||
map.put(key52, value52);
|
||
map.put(key53, value53);
|
||
map.put(key54, value54);
|
||
map.put(key55, value55);
|
||
map.put(key56, value56);
|
||
map.put(key57, value57);
|
||
map.put(key58, value58);
|
||
map.put(key59, value59);
|
||
map.put(key60, value60);
|
||
map.put(key61, value61);
|
||
map.put(key62, value62);
|
||
map.put(key63, value63);
|
||
map.put(key64, value64);
|
||
map.put(key65, value65);
|
||
map.put(key66, value66);
|
||
map.put(key67, value67);
|
||
map.put(key68, value68);
|
||
map.put(key69, value69);
|
||
map.put(key70, value70);
|
||
map.put(key71, value71);
|
||
map.put(key72, value72);
|
||
map.put(key73, value73);
|
||
map.put(key74, value74);
|
||
map.put(key75, value75);
|
||
map.put(key76, value76);
|
||
map.put(key77, value77);
|
||
map.put(key78, value78);
|
||
map.put(key79, value79);
|
||
map.put(key80, value80);
|
||
map.put(key81, value81);
|
||
map.put(key82, value82);
|
||
map.put(key83, value83);
|
||
map.put(key84, value84);
|
||
map.put(key85, value85);
|
||
map.put(key86, value86);
|
||
map.put(key87, value87);
|
||
map.put(key88, value88);
|
||
return map;
|
||
}
|
||
|
||
public static <K, V> Map<K, V> of(
|
||
K key,
|
||
V value,
|
||
K key2,
|
||
V value2,
|
||
K key3,
|
||
V value3,
|
||
K key4,
|
||
V value4,
|
||
K key5,
|
||
V value5,
|
||
K key6,
|
||
V value6,
|
||
K key7,
|
||
V value7,
|
||
K key8,
|
||
V value8,
|
||
K key9,
|
||
V value9,
|
||
K key10,
|
||
V value10,
|
||
K key11,
|
||
V value11,
|
||
K key12,
|
||
V value12,
|
||
K key13,
|
||
V value13,
|
||
K key14,
|
||
V value14,
|
||
K key15,
|
||
V value15,
|
||
K key16,
|
||
V value16,
|
||
K key17,
|
||
V value17,
|
||
K key18,
|
||
V value18,
|
||
K key19,
|
||
V value19,
|
||
K key20,
|
||
V value20,
|
||
K key21,
|
||
V value21,
|
||
K key22,
|
||
V value22,
|
||
K key23,
|
||
V value23,
|
||
K key24,
|
||
V value24,
|
||
K key25,
|
||
V value25,
|
||
K key26,
|
||
V value26,
|
||
K key27,
|
||
V value27,
|
||
K key28,
|
||
V value28,
|
||
K key29,
|
||
V value29,
|
||
K key30,
|
||
V value30,
|
||
K key31,
|
||
V value31,
|
||
K key32,
|
||
V value32,
|
||
K key33,
|
||
V value33,
|
||
K key34,
|
||
V value34,
|
||
K key35,
|
||
V value35,
|
||
K key36,
|
||
V value36,
|
||
K key37,
|
||
V value37,
|
||
K key38,
|
||
V value38,
|
||
K key39,
|
||
V value39,
|
||
K key40,
|
||
V value40,
|
||
K key41,
|
||
V value41,
|
||
K key42,
|
||
V value42,
|
||
K key43,
|
||
V value43,
|
||
K key44,
|
||
V value44,
|
||
K key45,
|
||
V value45,
|
||
K key46,
|
||
V value46,
|
||
K key47,
|
||
V value47,
|
||
K key48,
|
||
V value48,
|
||
K key49,
|
||
V value49,
|
||
K key50,
|
||
V value50,
|
||
K key51,
|
||
V value51,
|
||
K key52,
|
||
V value52,
|
||
K key53,
|
||
V value53,
|
||
K key54,
|
||
V value54,
|
||
K key55,
|
||
V value55,
|
||
K key56,
|
||
V value56,
|
||
K key57,
|
||
V value57,
|
||
K key58,
|
||
V value58,
|
||
K key59,
|
||
V value59,
|
||
K key60,
|
||
V value60,
|
||
K key61,
|
||
V value61,
|
||
K key62,
|
||
V value62,
|
||
K key63,
|
||
V value63,
|
||
K key64,
|
||
V value64,
|
||
K key65,
|
||
V value65,
|
||
K key66,
|
||
V value66,
|
||
K key67,
|
||
V value67,
|
||
K key68,
|
||
V value68,
|
||
K key69,
|
||
V value69,
|
||
K key70,
|
||
V value70,
|
||
K key71,
|
||
V value71,
|
||
K key72,
|
||
V value72,
|
||
K key73,
|
||
V value73,
|
||
K key74,
|
||
V value74,
|
||
K key75,
|
||
V value75,
|
||
K key76,
|
||
V value76,
|
||
K key77,
|
||
V value77,
|
||
K key78,
|
||
V value78,
|
||
K key79,
|
||
V value79,
|
||
K key80,
|
||
V value80,
|
||
K key81,
|
||
V value81,
|
||
K key82,
|
||
V value82,
|
||
K key83,
|
||
V value83,
|
||
K key84,
|
||
V value84,
|
||
K key85,
|
||
V value85,
|
||
K key86,
|
||
V value86,
|
||
K key87,
|
||
V value87,
|
||
K key88,
|
||
V value88,
|
||
K key89,
|
||
V value89
|
||
) {
|
||
var map = new HashMap<K, V>(93);
|
||
map.put(key, value);
|
||
map.put(key2, value2);
|
||
map.put(key3, value3);
|
||
map.put(key4, value4);
|
||
map.put(key5, value5);
|
||
map.put(key6, value6);
|
||
map.put(key7, value7);
|
||
map.put(key8, value8);
|
||
map.put(key9, value9);
|
||
map.put(key10, value10);
|
||
map.put(key11, value11);
|
||
map.put(key12, value12);
|
||
map.put(key13, value13);
|
||
map.put(key14, value14);
|
||
map.put(key15, value15);
|
||
map.put(key16, value16);
|
||
map.put(key17, value17);
|
||
map.put(key18, value18);
|
||
map.put(key19, value19);
|
||
map.put(key20, value20);
|
||
map.put(key21, value21);
|
||
map.put(key22, value22);
|
||
map.put(key23, value23);
|
||
map.put(key24, value24);
|
||
map.put(key25, value25);
|
||
map.put(key26, value26);
|
||
map.put(key27, value27);
|
||
map.put(key28, value28);
|
||
map.put(key29, value29);
|
||
map.put(key30, value30);
|
||
map.put(key31, value31);
|
||
map.put(key32, value32);
|
||
map.put(key33, value33);
|
||
map.put(key34, value34);
|
||
map.put(key35, value35);
|
||
map.put(key36, value36);
|
||
map.put(key37, value37);
|
||
map.put(key38, value38);
|
||
map.put(key39, value39);
|
||
map.put(key40, value40);
|
||
map.put(key41, value41);
|
||
map.put(key42, value42);
|
||
map.put(key43, value43);
|
||
map.put(key44, value44);
|
||
map.put(key45, value45);
|
||
map.put(key46, value46);
|
||
map.put(key47, value47);
|
||
map.put(key48, value48);
|
||
map.put(key49, value49);
|
||
map.put(key50, value50);
|
||
map.put(key51, value51);
|
||
map.put(key52, value52);
|
||
map.put(key53, value53);
|
||
map.put(key54, value54);
|
||
map.put(key55, value55);
|
||
map.put(key56, value56);
|
||
map.put(key57, value57);
|
||
map.put(key58, value58);
|
||
map.put(key59, value59);
|
||
map.put(key60, value60);
|
||
map.put(key61, value61);
|
||
map.put(key62, value62);
|
||
map.put(key63, value63);
|
||
map.put(key64, value64);
|
||
map.put(key65, value65);
|
||
map.put(key66, value66);
|
||
map.put(key67, value67);
|
||
map.put(key68, value68);
|
||
map.put(key69, value69);
|
||
map.put(key70, value70);
|
||
map.put(key71, value71);
|
||
map.put(key72, value72);
|
||
map.put(key73, value73);
|
||
map.put(key74, value74);
|
||
map.put(key75, value75);
|
||
map.put(key76, value76);
|
||
map.put(key77, value77);
|
||
map.put(key78, value78);
|
||
map.put(key79, value79);
|
||
map.put(key80, value80);
|
||
map.put(key81, value81);
|
||
map.put(key82, value82);
|
||
map.put(key83, value83);
|
||
map.put(key84, value84);
|
||
map.put(key85, value85);
|
||
map.put(key86, value86);
|
||
map.put(key87, value87);
|
||
map.put(key88, value88);
|
||
map.put(key89, value89);
|
||
return map;
|
||
}
|
||
|
||
public static <K, V> Map<K, V> of(
|
||
K key,
|
||
V value,
|
||
K key2,
|
||
V value2,
|
||
K key3,
|
||
V value3,
|
||
K key4,
|
||
V value4,
|
||
K key5,
|
||
V value5,
|
||
K key6,
|
||
V value6,
|
||
K key7,
|
||
V value7,
|
||
K key8,
|
||
V value8,
|
||
K key9,
|
||
V value9,
|
||
K key10,
|
||
V value10,
|
||
K key11,
|
||
V value11,
|
||
K key12,
|
||
V value12,
|
||
K key13,
|
||
V value13,
|
||
K key14,
|
||
V value14,
|
||
K key15,
|
||
V value15,
|
||
K key16,
|
||
V value16,
|
||
K key17,
|
||
V value17,
|
||
K key18,
|
||
V value18,
|
||
K key19,
|
||
V value19,
|
||
K key20,
|
||
V value20,
|
||
K key21,
|
||
V value21,
|
||
K key22,
|
||
V value22,
|
||
K key23,
|
||
V value23,
|
||
K key24,
|
||
V value24,
|
||
K key25,
|
||
V value25,
|
||
K key26,
|
||
V value26,
|
||
K key27,
|
||
V value27,
|
||
K key28,
|
||
V value28,
|
||
K key29,
|
||
V value29,
|
||
K key30,
|
||
V value30,
|
||
K key31,
|
||
V value31,
|
||
K key32,
|
||
V value32,
|
||
K key33,
|
||
V value33,
|
||
K key34,
|
||
V value34,
|
||
K key35,
|
||
V value35,
|
||
K key36,
|
||
V value36,
|
||
K key37,
|
||
V value37,
|
||
K key38,
|
||
V value38,
|
||
K key39,
|
||
V value39,
|
||
K key40,
|
||
V value40,
|
||
K key41,
|
||
V value41,
|
||
K key42,
|
||
V value42,
|
||
K key43,
|
||
V value43,
|
||
K key44,
|
||
V value44,
|
||
K key45,
|
||
V value45,
|
||
K key46,
|
||
V value46,
|
||
K key47,
|
||
V value47,
|
||
K key48,
|
||
V value48,
|
||
K key49,
|
||
V value49,
|
||
K key50,
|
||
V value50,
|
||
K key51,
|
||
V value51,
|
||
K key52,
|
||
V value52,
|
||
K key53,
|
||
V value53,
|
||
K key54,
|
||
V value54,
|
||
K key55,
|
||
V value55,
|
||
K key56,
|
||
V value56,
|
||
K key57,
|
||
V value57,
|
||
K key58,
|
||
V value58,
|
||
K key59,
|
||
V value59,
|
||
K key60,
|
||
V value60,
|
||
K key61,
|
||
V value61,
|
||
K key62,
|
||
V value62,
|
||
K key63,
|
||
V value63,
|
||
K key64,
|
||
V value64,
|
||
K key65,
|
||
V value65,
|
||
K key66,
|
||
V value66,
|
||
K key67,
|
||
V value67,
|
||
K key68,
|
||
V value68,
|
||
K key69,
|
||
V value69,
|
||
K key70,
|
||
V value70,
|
||
K key71,
|
||
V value71,
|
||
K key72,
|
||
V value72,
|
||
K key73,
|
||
V value73,
|
||
K key74,
|
||
V value74,
|
||
K key75,
|
||
V value75,
|
||
K key76,
|
||
V value76,
|
||
K key77,
|
||
V value77,
|
||
K key78,
|
||
V value78,
|
||
K key79,
|
||
V value79,
|
||
K key80,
|
||
V value80,
|
||
K key81,
|
||
V value81,
|
||
K key82,
|
||
V value82,
|
||
K key83,
|
||
V value83,
|
||
K key84,
|
||
V value84,
|
||
K key85,
|
||
V value85,
|
||
K key86,
|
||
V value86,
|
||
K key87,
|
||
V value87,
|
||
K key88,
|
||
V value88,
|
||
K key89,
|
||
V value89,
|
||
K key90,
|
||
V value90
|
||
) {
|
||
var map = new HashMap<K, V>(94);
|
||
map.put(key, value);
|
||
map.put(key2, value2);
|
||
map.put(key3, value3);
|
||
map.put(key4, value4);
|
||
map.put(key5, value5);
|
||
map.put(key6, value6);
|
||
map.put(key7, value7);
|
||
map.put(key8, value8);
|
||
map.put(key9, value9);
|
||
map.put(key10, value10);
|
||
map.put(key11, value11);
|
||
map.put(key12, value12);
|
||
map.put(key13, value13);
|
||
map.put(key14, value14);
|
||
map.put(key15, value15);
|
||
map.put(key16, value16);
|
||
map.put(key17, value17);
|
||
map.put(key18, value18);
|
||
map.put(key19, value19);
|
||
map.put(key20, value20);
|
||
map.put(key21, value21);
|
||
map.put(key22, value22);
|
||
map.put(key23, value23);
|
||
map.put(key24, value24);
|
||
map.put(key25, value25);
|
||
map.put(key26, value26);
|
||
map.put(key27, value27);
|
||
map.put(key28, value28);
|
||
map.put(key29, value29);
|
||
map.put(key30, value30);
|
||
map.put(key31, value31);
|
||
map.put(key32, value32);
|
||
map.put(key33, value33);
|
||
map.put(key34, value34);
|
||
map.put(key35, value35);
|
||
map.put(key36, value36);
|
||
map.put(key37, value37);
|
||
map.put(key38, value38);
|
||
map.put(key39, value39);
|
||
map.put(key40, value40);
|
||
map.put(key41, value41);
|
||
map.put(key42, value42);
|
||
map.put(key43, value43);
|
||
map.put(key44, value44);
|
||
map.put(key45, value45);
|
||
map.put(key46, value46);
|
||
map.put(key47, value47);
|
||
map.put(key48, value48);
|
||
map.put(key49, value49);
|
||
map.put(key50, value50);
|
||
map.put(key51, value51);
|
||
map.put(key52, value52);
|
||
map.put(key53, value53);
|
||
map.put(key54, value54);
|
||
map.put(key55, value55);
|
||
map.put(key56, value56);
|
||
map.put(key57, value57);
|
||
map.put(key58, value58);
|
||
map.put(key59, value59);
|
||
map.put(key60, value60);
|
||
map.put(key61, value61);
|
||
map.put(key62, value62);
|
||
map.put(key63, value63);
|
||
map.put(key64, value64);
|
||
map.put(key65, value65);
|
||
map.put(key66, value66);
|
||
map.put(key67, value67);
|
||
map.put(key68, value68);
|
||
map.put(key69, value69);
|
||
map.put(key70, value70);
|
||
map.put(key71, value71);
|
||
map.put(key72, value72);
|
||
map.put(key73, value73);
|
||
map.put(key74, value74);
|
||
map.put(key75, value75);
|
||
map.put(key76, value76);
|
||
map.put(key77, value77);
|
||
map.put(key78, value78);
|
||
map.put(key79, value79);
|
||
map.put(key80, value80);
|
||
map.put(key81, value81);
|
||
map.put(key82, value82);
|
||
map.put(key83, value83);
|
||
map.put(key84, value84);
|
||
map.put(key85, value85);
|
||
map.put(key86, value86);
|
||
map.put(key87, value87);
|
||
map.put(key88, value88);
|
||
map.put(key89, value89);
|
||
map.put(key90, value90);
|
||
return map;
|
||
}
|
||
|
||
public static <K, V> Map<K, V> of(
|
||
K key,
|
||
V value,
|
||
K key2,
|
||
V value2,
|
||
K key3,
|
||
V value3,
|
||
K key4,
|
||
V value4,
|
||
K key5,
|
||
V value5,
|
||
K key6,
|
||
V value6,
|
||
K key7,
|
||
V value7,
|
||
K key8,
|
||
V value8,
|
||
K key9,
|
||
V value9,
|
||
K key10,
|
||
V value10,
|
||
K key11,
|
||
V value11,
|
||
K key12,
|
||
V value12,
|
||
K key13,
|
||
V value13,
|
||
K key14,
|
||
V value14,
|
||
K key15,
|
||
V value15,
|
||
K key16,
|
||
V value16,
|
||
K key17,
|
||
V value17,
|
||
K key18,
|
||
V value18,
|
||
K key19,
|
||
V value19,
|
||
K key20,
|
||
V value20,
|
||
K key21,
|
||
V value21,
|
||
K key22,
|
||
V value22,
|
||
K key23,
|
||
V value23,
|
||
K key24,
|
||
V value24,
|
||
K key25,
|
||
V value25,
|
||
K key26,
|
||
V value26,
|
||
K key27,
|
||
V value27,
|
||
K key28,
|
||
V value28,
|
||
K key29,
|
||
V value29,
|
||
K key30,
|
||
V value30,
|
||
K key31,
|
||
V value31,
|
||
K key32,
|
||
V value32,
|
||
K key33,
|
||
V value33,
|
||
K key34,
|
||
V value34,
|
||
K key35,
|
||
V value35,
|
||
K key36,
|
||
V value36,
|
||
K key37,
|
||
V value37,
|
||
K key38,
|
||
V value38,
|
||
K key39,
|
||
V value39,
|
||
K key40,
|
||
V value40,
|
||
K key41,
|
||
V value41,
|
||
K key42,
|
||
V value42,
|
||
K key43,
|
||
V value43,
|
||
K key44,
|
||
V value44,
|
||
K key45,
|
||
V value45,
|
||
K key46,
|
||
V value46,
|
||
K key47,
|
||
V value47,
|
||
K key48,
|
||
V value48,
|
||
K key49,
|
||
V value49,
|
||
K key50,
|
||
V value50,
|
||
K key51,
|
||
V value51,
|
||
K key52,
|
||
V value52,
|
||
K key53,
|
||
V value53,
|
||
K key54,
|
||
V value54,
|
||
K key55,
|
||
V value55,
|
||
K key56,
|
||
V value56,
|
||
K key57,
|
||
V value57,
|
||
K key58,
|
||
V value58,
|
||
K key59,
|
||
V value59,
|
||
K key60,
|
||
V value60,
|
||
K key61,
|
||
V value61,
|
||
K key62,
|
||
V value62,
|
||
K key63,
|
||
V value63,
|
||
K key64,
|
||
V value64,
|
||
K key65,
|
||
V value65,
|
||
K key66,
|
||
V value66,
|
||
K key67,
|
||
V value67,
|
||
K key68,
|
||
V value68,
|
||
K key69,
|
||
V value69,
|
||
K key70,
|
||
V value70,
|
||
K key71,
|
||
V value71,
|
||
K key72,
|
||
V value72,
|
||
K key73,
|
||
V value73,
|
||
K key74,
|
||
V value74,
|
||
K key75,
|
||
V value75,
|
||
K key76,
|
||
V value76,
|
||
K key77,
|
||
V value77,
|
||
K key78,
|
||
V value78,
|
||
K key79,
|
||
V value79,
|
||
K key80,
|
||
V value80,
|
||
K key81,
|
||
V value81,
|
||
K key82,
|
||
V value82,
|
||
K key83,
|
||
V value83,
|
||
K key84,
|
||
V value84,
|
||
K key85,
|
||
V value85,
|
||
K key86,
|
||
V value86,
|
||
K key87,
|
||
V value87,
|
||
K key88,
|
||
V value88,
|
||
K key89,
|
||
V value89,
|
||
K key90,
|
||
V value90,
|
||
K key91,
|
||
V value91
|
||
) {
|
||
var map = new HashMap<K, V>(95);
|
||
map.put(key, value);
|
||
map.put(key2, value2);
|
||
map.put(key3, value3);
|
||
map.put(key4, value4);
|
||
map.put(key5, value5);
|
||
map.put(key6, value6);
|
||
map.put(key7, value7);
|
||
map.put(key8, value8);
|
||
map.put(key9, value9);
|
||
map.put(key10, value10);
|
||
map.put(key11, value11);
|
||
map.put(key12, value12);
|
||
map.put(key13, value13);
|
||
map.put(key14, value14);
|
||
map.put(key15, value15);
|
||
map.put(key16, value16);
|
||
map.put(key17, value17);
|
||
map.put(key18, value18);
|
||
map.put(key19, value19);
|
||
map.put(key20, value20);
|
||
map.put(key21, value21);
|
||
map.put(key22, value22);
|
||
map.put(key23, value23);
|
||
map.put(key24, value24);
|
||
map.put(key25, value25);
|
||
map.put(key26, value26);
|
||
map.put(key27, value27);
|
||
map.put(key28, value28);
|
||
map.put(key29, value29);
|
||
map.put(key30, value30);
|
||
map.put(key31, value31);
|
||
map.put(key32, value32);
|
||
map.put(key33, value33);
|
||
map.put(key34, value34);
|
||
map.put(key35, value35);
|
||
map.put(key36, value36);
|
||
map.put(key37, value37);
|
||
map.put(key38, value38);
|
||
map.put(key39, value39);
|
||
map.put(key40, value40);
|
||
map.put(key41, value41);
|
||
map.put(key42, value42);
|
||
map.put(key43, value43);
|
||
map.put(key44, value44);
|
||
map.put(key45, value45);
|
||
map.put(key46, value46);
|
||
map.put(key47, value47);
|
||
map.put(key48, value48);
|
||
map.put(key49, value49);
|
||
map.put(key50, value50);
|
||
map.put(key51, value51);
|
||
map.put(key52, value52);
|
||
map.put(key53, value53);
|
||
map.put(key54, value54);
|
||
map.put(key55, value55);
|
||
map.put(key56, value56);
|
||
map.put(key57, value57);
|
||
map.put(key58, value58);
|
||
map.put(key59, value59);
|
||
map.put(key60, value60);
|
||
map.put(key61, value61);
|
||
map.put(key62, value62);
|
||
map.put(key63, value63);
|
||
map.put(key64, value64);
|
||
map.put(key65, value65);
|
||
map.put(key66, value66);
|
||
map.put(key67, value67);
|
||
map.put(key68, value68);
|
||
map.put(key69, value69);
|
||
map.put(key70, value70);
|
||
map.put(key71, value71);
|
||
map.put(key72, value72);
|
||
map.put(key73, value73);
|
||
map.put(key74, value74);
|
||
map.put(key75, value75);
|
||
map.put(key76, value76);
|
||
map.put(key77, value77);
|
||
map.put(key78, value78);
|
||
map.put(key79, value79);
|
||
map.put(key80, value80);
|
||
map.put(key81, value81);
|
||
map.put(key82, value82);
|
||
map.put(key83, value83);
|
||
map.put(key84, value84);
|
||
map.put(key85, value85);
|
||
map.put(key86, value86);
|
||
map.put(key87, value87);
|
||
map.put(key88, value88);
|
||
map.put(key89, value89);
|
||
map.put(key90, value90);
|
||
map.put(key91, value91);
|
||
return map;
|
||
}
|
||
|
||
public static <K, V> Map<K, V> of(
|
||
K key,
|
||
V value,
|
||
K key2,
|
||
V value2,
|
||
K key3,
|
||
V value3,
|
||
K key4,
|
||
V value4,
|
||
K key5,
|
||
V value5,
|
||
K key6,
|
||
V value6,
|
||
K key7,
|
||
V value7,
|
||
K key8,
|
||
V value8,
|
||
K key9,
|
||
V value9,
|
||
K key10,
|
||
V value10,
|
||
K key11,
|
||
V value11,
|
||
K key12,
|
||
V value12,
|
||
K key13,
|
||
V value13,
|
||
K key14,
|
||
V value14,
|
||
K key15,
|
||
V value15,
|
||
K key16,
|
||
V value16,
|
||
K key17,
|
||
V value17,
|
||
K key18,
|
||
V value18,
|
||
K key19,
|
||
V value19,
|
||
K key20,
|
||
V value20,
|
||
K key21,
|
||
V value21,
|
||
K key22,
|
||
V value22,
|
||
K key23,
|
||
V value23,
|
||
K key24,
|
||
V value24,
|
||
K key25,
|
||
V value25,
|
||
K key26,
|
||
V value26,
|
||
K key27,
|
||
V value27,
|
||
K key28,
|
||
V value28,
|
||
K key29,
|
||
V value29,
|
||
K key30,
|
||
V value30,
|
||
K key31,
|
||
V value31,
|
||
K key32,
|
||
V value32,
|
||
K key33,
|
||
V value33,
|
||
K key34,
|
||
V value34,
|
||
K key35,
|
||
V value35,
|
||
K key36,
|
||
V value36,
|
||
K key37,
|
||
V value37,
|
||
K key38,
|
||
V value38,
|
||
K key39,
|
||
V value39,
|
||
K key40,
|
||
V value40,
|
||
K key41,
|
||
V value41,
|
||
K key42,
|
||
V value42,
|
||
K key43,
|
||
V value43,
|
||
K key44,
|
||
V value44,
|
||
K key45,
|
||
V value45,
|
||
K key46,
|
||
V value46,
|
||
K key47,
|
||
V value47,
|
||
K key48,
|
||
V value48,
|
||
K key49,
|
||
V value49,
|
||
K key50,
|
||
V value50,
|
||
K key51,
|
||
V value51,
|
||
K key52,
|
||
V value52,
|
||
K key53,
|
||
V value53,
|
||
K key54,
|
||
V value54,
|
||
K key55,
|
||
V value55,
|
||
K key56,
|
||
V value56,
|
||
K key57,
|
||
V value57,
|
||
K key58,
|
||
V value58,
|
||
K key59,
|
||
V value59,
|
||
K key60,
|
||
V value60,
|
||
K key61,
|
||
V value61,
|
||
K key62,
|
||
V value62,
|
||
K key63,
|
||
V value63,
|
||
K key64,
|
||
V value64,
|
||
K key65,
|
||
V value65,
|
||
K key66,
|
||
V value66,
|
||
K key67,
|
||
V value67,
|
||
K key68,
|
||
V value68,
|
||
K key69,
|
||
V value69,
|
||
K key70,
|
||
V value70,
|
||
K key71,
|
||
V value71,
|
||
K key72,
|
||
V value72,
|
||
K key73,
|
||
V value73,
|
||
K key74,
|
||
V value74,
|
||
K key75,
|
||
V value75,
|
||
K key76,
|
||
V value76,
|
||
K key77,
|
||
V value77,
|
||
K key78,
|
||
V value78,
|
||
K key79,
|
||
V value79,
|
||
K key80,
|
||
V value80,
|
||
K key81,
|
||
V value81,
|
||
K key82,
|
||
V value82,
|
||
K key83,
|
||
V value83,
|
||
K key84,
|
||
V value84,
|
||
K key85,
|
||
V value85,
|
||
K key86,
|
||
V value86,
|
||
K key87,
|
||
V value87,
|
||
K key88,
|
||
V value88,
|
||
K key89,
|
||
V value89,
|
||
K key90,
|
||
V value90,
|
||
K key91,
|
||
V value91,
|
||
K key92,
|
||
V value92
|
||
) {
|
||
var map = new HashMap<K, V>(96);
|
||
map.put(key, value);
|
||
map.put(key2, value2);
|
||
map.put(key3, value3);
|
||
map.put(key4, value4);
|
||
map.put(key5, value5);
|
||
map.put(key6, value6);
|
||
map.put(key7, value7);
|
||
map.put(key8, value8);
|
||
map.put(key9, value9);
|
||
map.put(key10, value10);
|
||
map.put(key11, value11);
|
||
map.put(key12, value12);
|
||
map.put(key13, value13);
|
||
map.put(key14, value14);
|
||
map.put(key15, value15);
|
||
map.put(key16, value16);
|
||
map.put(key17, value17);
|
||
map.put(key18, value18);
|
||
map.put(key19, value19);
|
||
map.put(key20, value20);
|
||
map.put(key21, value21);
|
||
map.put(key22, value22);
|
||
map.put(key23, value23);
|
||
map.put(key24, value24);
|
||
map.put(key25, value25);
|
||
map.put(key26, value26);
|
||
map.put(key27, value27);
|
||
map.put(key28, value28);
|
||
map.put(key29, value29);
|
||
map.put(key30, value30);
|
||
map.put(key31, value31);
|
||
map.put(key32, value32);
|
||
map.put(key33, value33);
|
||
map.put(key34, value34);
|
||
map.put(key35, value35);
|
||
map.put(key36, value36);
|
||
map.put(key37, value37);
|
||
map.put(key38, value38);
|
||
map.put(key39, value39);
|
||
map.put(key40, value40);
|
||
map.put(key41, value41);
|
||
map.put(key42, value42);
|
||
map.put(key43, value43);
|
||
map.put(key44, value44);
|
||
map.put(key45, value45);
|
||
map.put(key46, value46);
|
||
map.put(key47, value47);
|
||
map.put(key48, value48);
|
||
map.put(key49, value49);
|
||
map.put(key50, value50);
|
||
map.put(key51, value51);
|
||
map.put(key52, value52);
|
||
map.put(key53, value53);
|
||
map.put(key54, value54);
|
||
map.put(key55, value55);
|
||
map.put(key56, value56);
|
||
map.put(key57, value57);
|
||
map.put(key58, value58);
|
||
map.put(key59, value59);
|
||
map.put(key60, value60);
|
||
map.put(key61, value61);
|
||
map.put(key62, value62);
|
||
map.put(key63, value63);
|
||
map.put(key64, value64);
|
||
map.put(key65, value65);
|
||
map.put(key66, value66);
|
||
map.put(key67, value67);
|
||
map.put(key68, value68);
|
||
map.put(key69, value69);
|
||
map.put(key70, value70);
|
||
map.put(key71, value71);
|
||
map.put(key72, value72);
|
||
map.put(key73, value73);
|
||
map.put(key74, value74);
|
||
map.put(key75, value75);
|
||
map.put(key76, value76);
|
||
map.put(key77, value77);
|
||
map.put(key78, value78);
|
||
map.put(key79, value79);
|
||
map.put(key80, value80);
|
||
map.put(key81, value81);
|
||
map.put(key82, value82);
|
||
map.put(key83, value83);
|
||
map.put(key84, value84);
|
||
map.put(key85, value85);
|
||
map.put(key86, value86);
|
||
map.put(key87, value87);
|
||
map.put(key88, value88);
|
||
map.put(key89, value89);
|
||
map.put(key90, value90);
|
||
map.put(key91, value91);
|
||
map.put(key92, value92);
|
||
return map;
|
||
}
|
||
|
||
public static <K, V> Map<K, V> of(
|
||
K key,
|
||
V value,
|
||
K key2,
|
||
V value2,
|
||
K key3,
|
||
V value3,
|
||
K key4,
|
||
V value4,
|
||
K key5,
|
||
V value5,
|
||
K key6,
|
||
V value6,
|
||
K key7,
|
||
V value7,
|
||
K key8,
|
||
V value8,
|
||
K key9,
|
||
V value9,
|
||
K key10,
|
||
V value10,
|
||
K key11,
|
||
V value11,
|
||
K key12,
|
||
V value12,
|
||
K key13,
|
||
V value13,
|
||
K key14,
|
||
V value14,
|
||
K key15,
|
||
V value15,
|
||
K key16,
|
||
V value16,
|
||
K key17,
|
||
V value17,
|
||
K key18,
|
||
V value18,
|
||
K key19,
|
||
V value19,
|
||
K key20,
|
||
V value20,
|
||
K key21,
|
||
V value21,
|
||
K key22,
|
||
V value22,
|
||
K key23,
|
||
V value23,
|
||
K key24,
|
||
V value24,
|
||
K key25,
|
||
V value25,
|
||
K key26,
|
||
V value26,
|
||
K key27,
|
||
V value27,
|
||
K key28,
|
||
V value28,
|
||
K key29,
|
||
V value29,
|
||
K key30,
|
||
V value30,
|
||
K key31,
|
||
V value31,
|
||
K key32,
|
||
V value32,
|
||
K key33,
|
||
V value33,
|
||
K key34,
|
||
V value34,
|
||
K key35,
|
||
V value35,
|
||
K key36,
|
||
V value36,
|
||
K key37,
|
||
V value37,
|
||
K key38,
|
||
V value38,
|
||
K key39,
|
||
V value39,
|
||
K key40,
|
||
V value40,
|
||
K key41,
|
||
V value41,
|
||
K key42,
|
||
V value42,
|
||
K key43,
|
||
V value43,
|
||
K key44,
|
||
V value44,
|
||
K key45,
|
||
V value45,
|
||
K key46,
|
||
V value46,
|
||
K key47,
|
||
V value47,
|
||
K key48,
|
||
V value48,
|
||
K key49,
|
||
V value49,
|
||
K key50,
|
||
V value50,
|
||
K key51,
|
||
V value51,
|
||
K key52,
|
||
V value52,
|
||
K key53,
|
||
V value53,
|
||
K key54,
|
||
V value54,
|
||
K key55,
|
||
V value55,
|
||
K key56,
|
||
V value56,
|
||
K key57,
|
||
V value57,
|
||
K key58,
|
||
V value58,
|
||
K key59,
|
||
V value59,
|
||
K key60,
|
||
V value60,
|
||
K key61,
|
||
V value61,
|
||
K key62,
|
||
V value62,
|
||
K key63,
|
||
V value63,
|
||
K key64,
|
||
V value64,
|
||
K key65,
|
||
V value65,
|
||
K key66,
|
||
V value66,
|
||
K key67,
|
||
V value67,
|
||
K key68,
|
||
V value68,
|
||
K key69,
|
||
V value69,
|
||
K key70,
|
||
V value70,
|
||
K key71,
|
||
V value71,
|
||
K key72,
|
||
V value72,
|
||
K key73,
|
||
V value73,
|
||
K key74,
|
||
V value74,
|
||
K key75,
|
||
V value75,
|
||
K key76,
|
||
V value76,
|
||
K key77,
|
||
V value77,
|
||
K key78,
|
||
V value78,
|
||
K key79,
|
||
V value79,
|
||
K key80,
|
||
V value80,
|
||
K key81,
|
||
V value81,
|
||
K key82,
|
||
V value82,
|
||
K key83,
|
||
V value83,
|
||
K key84,
|
||
V value84,
|
||
K key85,
|
||
V value85,
|
||
K key86,
|
||
V value86,
|
||
K key87,
|
||
V value87,
|
||
K key88,
|
||
V value88,
|
||
K key89,
|
||
V value89,
|
||
K key90,
|
||
V value90,
|
||
K key91,
|
||
V value91,
|
||
K key92,
|
||
V value92,
|
||
K key93,
|
||
V value93
|
||
) {
|
||
var map = new HashMap<K, V>(97);
|
||
map.put(key, value);
|
||
map.put(key2, value2);
|
||
map.put(key3, value3);
|
||
map.put(key4, value4);
|
||
map.put(key5, value5);
|
||
map.put(key6, value6);
|
||
map.put(key7, value7);
|
||
map.put(key8, value8);
|
||
map.put(key9, value9);
|
||
map.put(key10, value10);
|
||
map.put(key11, value11);
|
||
map.put(key12, value12);
|
||
map.put(key13, value13);
|
||
map.put(key14, value14);
|
||
map.put(key15, value15);
|
||
map.put(key16, value16);
|
||
map.put(key17, value17);
|
||
map.put(key18, value18);
|
||
map.put(key19, value19);
|
||
map.put(key20, value20);
|
||
map.put(key21, value21);
|
||
map.put(key22, value22);
|
||
map.put(key23, value23);
|
||
map.put(key24, value24);
|
||
map.put(key25, value25);
|
||
map.put(key26, value26);
|
||
map.put(key27, value27);
|
||
map.put(key28, value28);
|
||
map.put(key29, value29);
|
||
map.put(key30, value30);
|
||
map.put(key31, value31);
|
||
map.put(key32, value32);
|
||
map.put(key33, value33);
|
||
map.put(key34, value34);
|
||
map.put(key35, value35);
|
||
map.put(key36, value36);
|
||
map.put(key37, value37);
|
||
map.put(key38, value38);
|
||
map.put(key39, value39);
|
||
map.put(key40, value40);
|
||
map.put(key41, value41);
|
||
map.put(key42, value42);
|
||
map.put(key43, value43);
|
||
map.put(key44, value44);
|
||
map.put(key45, value45);
|
||
map.put(key46, value46);
|
||
map.put(key47, value47);
|
||
map.put(key48, value48);
|
||
map.put(key49, value49);
|
||
map.put(key50, value50);
|
||
map.put(key51, value51);
|
||
map.put(key52, value52);
|
||
map.put(key53, value53);
|
||
map.put(key54, value54);
|
||
map.put(key55, value55);
|
||
map.put(key56, value56);
|
||
map.put(key57, value57);
|
||
map.put(key58, value58);
|
||
map.put(key59, value59);
|
||
map.put(key60, value60);
|
||
map.put(key61, value61);
|
||
map.put(key62, value62);
|
||
map.put(key63, value63);
|
||
map.put(key64, value64);
|
||
map.put(key65, value65);
|
||
map.put(key66, value66);
|
||
map.put(key67, value67);
|
||
map.put(key68, value68);
|
||
map.put(key69, value69);
|
||
map.put(key70, value70);
|
||
map.put(key71, value71);
|
||
map.put(key72, value72);
|
||
map.put(key73, value73);
|
||
map.put(key74, value74);
|
||
map.put(key75, value75);
|
||
map.put(key76, value76);
|
||
map.put(key77, value77);
|
||
map.put(key78, value78);
|
||
map.put(key79, value79);
|
||
map.put(key80, value80);
|
||
map.put(key81, value81);
|
||
map.put(key82, value82);
|
||
map.put(key83, value83);
|
||
map.put(key84, value84);
|
||
map.put(key85, value85);
|
||
map.put(key86, value86);
|
||
map.put(key87, value87);
|
||
map.put(key88, value88);
|
||
map.put(key89, value89);
|
||
map.put(key90, value90);
|
||
map.put(key91, value91);
|
||
map.put(key92, value92);
|
||
map.put(key93, value93);
|
||
return map;
|
||
}
|
||
|
||
public static <K, V> Map<K, V> of(
|
||
K key,
|
||
V value,
|
||
K key2,
|
||
V value2,
|
||
K key3,
|
||
V value3,
|
||
K key4,
|
||
V value4,
|
||
K key5,
|
||
V value5,
|
||
K key6,
|
||
V value6,
|
||
K key7,
|
||
V value7,
|
||
K key8,
|
||
V value8,
|
||
K key9,
|
||
V value9,
|
||
K key10,
|
||
V value10,
|
||
K key11,
|
||
V value11,
|
||
K key12,
|
||
V value12,
|
||
K key13,
|
||
V value13,
|
||
K key14,
|
||
V value14,
|
||
K key15,
|
||
V value15,
|
||
K key16,
|
||
V value16,
|
||
K key17,
|
||
V value17,
|
||
K key18,
|
||
V value18,
|
||
K key19,
|
||
V value19,
|
||
K key20,
|
||
V value20,
|
||
K key21,
|
||
V value21,
|
||
K key22,
|
||
V value22,
|
||
K key23,
|
||
V value23,
|
||
K key24,
|
||
V value24,
|
||
K key25,
|
||
V value25,
|
||
K key26,
|
||
V value26,
|
||
K key27,
|
||
V value27,
|
||
K key28,
|
||
V value28,
|
||
K key29,
|
||
V value29,
|
||
K key30,
|
||
V value30,
|
||
K key31,
|
||
V value31,
|
||
K key32,
|
||
V value32,
|
||
K key33,
|
||
V value33,
|
||
K key34,
|
||
V value34,
|
||
K key35,
|
||
V value35,
|
||
K key36,
|
||
V value36,
|
||
K key37,
|
||
V value37,
|
||
K key38,
|
||
V value38,
|
||
K key39,
|
||
V value39,
|
||
K key40,
|
||
V value40,
|
||
K key41,
|
||
V value41,
|
||
K key42,
|
||
V value42,
|
||
K key43,
|
||
V value43,
|
||
K key44,
|
||
V value44,
|
||
K key45,
|
||
V value45,
|
||
K key46,
|
||
V value46,
|
||
K key47,
|
||
V value47,
|
||
K key48,
|
||
V value48,
|
||
K key49,
|
||
V value49,
|
||
K key50,
|
||
V value50,
|
||
K key51,
|
||
V value51,
|
||
K key52,
|
||
V value52,
|
||
K key53,
|
||
V value53,
|
||
K key54,
|
||
V value54,
|
||
K key55,
|
||
V value55,
|
||
K key56,
|
||
V value56,
|
||
K key57,
|
||
V value57,
|
||
K key58,
|
||
V value58,
|
||
K key59,
|
||
V value59,
|
||
K key60,
|
||
V value60,
|
||
K key61,
|
||
V value61,
|
||
K key62,
|
||
V value62,
|
||
K key63,
|
||
V value63,
|
||
K key64,
|
||
V value64,
|
||
K key65,
|
||
V value65,
|
||
K key66,
|
||
V value66,
|
||
K key67,
|
||
V value67,
|
||
K key68,
|
||
V value68,
|
||
K key69,
|
||
V value69,
|
||
K key70,
|
||
V value70,
|
||
K key71,
|
||
V value71,
|
||
K key72,
|
||
V value72,
|
||
K key73,
|
||
V value73,
|
||
K key74,
|
||
V value74,
|
||
K key75,
|
||
V value75,
|
||
K key76,
|
||
V value76,
|
||
K key77,
|
||
V value77,
|
||
K key78,
|
||
V value78,
|
||
K key79,
|
||
V value79,
|
||
K key80,
|
||
V value80,
|
||
K key81,
|
||
V value81,
|
||
K key82,
|
||
V value82,
|
||
K key83,
|
||
V value83,
|
||
K key84,
|
||
V value84,
|
||
K key85,
|
||
V value85,
|
||
K key86,
|
||
V value86,
|
||
K key87,
|
||
V value87,
|
||
K key88,
|
||
V value88,
|
||
K key89,
|
||
V value89,
|
||
K key90,
|
||
V value90,
|
||
K key91,
|
||
V value91,
|
||
K key92,
|
||
V value92,
|
||
K key93,
|
||
V value93,
|
||
K key94,
|
||
V value94
|
||
) {
|
||
var map = new HashMap<K, V>(98);
|
||
map.put(key, value);
|
||
map.put(key2, value2);
|
||
map.put(key3, value3);
|
||
map.put(key4, value4);
|
||
map.put(key5, value5);
|
||
map.put(key6, value6);
|
||
map.put(key7, value7);
|
||
map.put(key8, value8);
|
||
map.put(key9, value9);
|
||
map.put(key10, value10);
|
||
map.put(key11, value11);
|
||
map.put(key12, value12);
|
||
map.put(key13, value13);
|
||
map.put(key14, value14);
|
||
map.put(key15, value15);
|
||
map.put(key16, value16);
|
||
map.put(key17, value17);
|
||
map.put(key18, value18);
|
||
map.put(key19, value19);
|
||
map.put(key20, value20);
|
||
map.put(key21, value21);
|
||
map.put(key22, value22);
|
||
map.put(key23, value23);
|
||
map.put(key24, value24);
|
||
map.put(key25, value25);
|
||
map.put(key26, value26);
|
||
map.put(key27, value27);
|
||
map.put(key28, value28);
|
||
map.put(key29, value29);
|
||
map.put(key30, value30);
|
||
map.put(key31, value31);
|
||
map.put(key32, value32);
|
||
map.put(key33, value33);
|
||
map.put(key34, value34);
|
||
map.put(key35, value35);
|
||
map.put(key36, value36);
|
||
map.put(key37, value37);
|
||
map.put(key38, value38);
|
||
map.put(key39, value39);
|
||
map.put(key40, value40);
|
||
map.put(key41, value41);
|
||
map.put(key42, value42);
|
||
map.put(key43, value43);
|
||
map.put(key44, value44);
|
||
map.put(key45, value45);
|
||
map.put(key46, value46);
|
||
map.put(key47, value47);
|
||
map.put(key48, value48);
|
||
map.put(key49, value49);
|
||
map.put(key50, value50);
|
||
map.put(key51, value51);
|
||
map.put(key52, value52);
|
||
map.put(key53, value53);
|
||
map.put(key54, value54);
|
||
map.put(key55, value55);
|
||
map.put(key56, value56);
|
||
map.put(key57, value57);
|
||
map.put(key58, value58);
|
||
map.put(key59, value59);
|
||
map.put(key60, value60);
|
||
map.put(key61, value61);
|
||
map.put(key62, value62);
|
||
map.put(key63, value63);
|
||
map.put(key64, value64);
|
||
map.put(key65, value65);
|
||
map.put(key66, value66);
|
||
map.put(key67, value67);
|
||
map.put(key68, value68);
|
||
map.put(key69, value69);
|
||
map.put(key70, value70);
|
||
map.put(key71, value71);
|
||
map.put(key72, value72);
|
||
map.put(key73, value73);
|
||
map.put(key74, value74);
|
||
map.put(key75, value75);
|
||
map.put(key76, value76);
|
||
map.put(key77, value77);
|
||
map.put(key78, value78);
|
||
map.put(key79, value79);
|
||
map.put(key80, value80);
|
||
map.put(key81, value81);
|
||
map.put(key82, value82);
|
||
map.put(key83, value83);
|
||
map.put(key84, value84);
|
||
map.put(key85, value85);
|
||
map.put(key86, value86);
|
||
map.put(key87, value87);
|
||
map.put(key88, value88);
|
||
map.put(key89, value89);
|
||
map.put(key90, value90);
|
||
map.put(key91, value91);
|
||
map.put(key92, value92);
|
||
map.put(key93, value93);
|
||
map.put(key94, value94);
|
||
return map;
|
||
}
|
||
|
||
public static <K, V> Map<K, V> of(
|
||
K key,
|
||
V value,
|
||
K key2,
|
||
V value2,
|
||
K key3,
|
||
V value3,
|
||
K key4,
|
||
V value4,
|
||
K key5,
|
||
V value5,
|
||
K key6,
|
||
V value6,
|
||
K key7,
|
||
V value7,
|
||
K key8,
|
||
V value8,
|
||
K key9,
|
||
V value9,
|
||
K key10,
|
||
V value10,
|
||
K key11,
|
||
V value11,
|
||
K key12,
|
||
V value12,
|
||
K key13,
|
||
V value13,
|
||
K key14,
|
||
V value14,
|
||
K key15,
|
||
V value15,
|
||
K key16,
|
||
V value16,
|
||
K key17,
|
||
V value17,
|
||
K key18,
|
||
V value18,
|
||
K key19,
|
||
V value19,
|
||
K key20,
|
||
V value20,
|
||
K key21,
|
||
V value21,
|
||
K key22,
|
||
V value22,
|
||
K key23,
|
||
V value23,
|
||
K key24,
|
||
V value24,
|
||
K key25,
|
||
V value25,
|
||
K key26,
|
||
V value26,
|
||
K key27,
|
||
V value27,
|
||
K key28,
|
||
V value28,
|
||
K key29,
|
||
V value29,
|
||
K key30,
|
||
V value30,
|
||
K key31,
|
||
V value31,
|
||
K key32,
|
||
V value32,
|
||
K key33,
|
||
V value33,
|
||
K key34,
|
||
V value34,
|
||
K key35,
|
||
V value35,
|
||
K key36,
|
||
V value36,
|
||
K key37,
|
||
V value37,
|
||
K key38,
|
||
V value38,
|
||
K key39,
|
||
V value39,
|
||
K key40,
|
||
V value40,
|
||
K key41,
|
||
V value41,
|
||
K key42,
|
||
V value42,
|
||
K key43,
|
||
V value43,
|
||
K key44,
|
||
V value44,
|
||
K key45,
|
||
V value45,
|
||
K key46,
|
||
V value46,
|
||
K key47,
|
||
V value47,
|
||
K key48,
|
||
V value48,
|
||
K key49,
|
||
V value49,
|
||
K key50,
|
||
V value50,
|
||
K key51,
|
||
V value51,
|
||
K key52,
|
||
V value52,
|
||
K key53,
|
||
V value53,
|
||
K key54,
|
||
V value54,
|
||
K key55,
|
||
V value55,
|
||
K key56,
|
||
V value56,
|
||
K key57,
|
||
V value57,
|
||
K key58,
|
||
V value58,
|
||
K key59,
|
||
V value59,
|
||
K key60,
|
||
V value60,
|
||
K key61,
|
||
V value61,
|
||
K key62,
|
||
V value62,
|
||
K key63,
|
||
V value63,
|
||
K key64,
|
||
V value64,
|
||
K key65,
|
||
V value65,
|
||
K key66,
|
||
V value66,
|
||
K key67,
|
||
V value67,
|
||
K key68,
|
||
V value68,
|
||
K key69,
|
||
V value69,
|
||
K key70,
|
||
V value70,
|
||
K key71,
|
||
V value71,
|
||
K key72,
|
||
V value72,
|
||
K key73,
|
||
V value73,
|
||
K key74,
|
||
V value74,
|
||
K key75,
|
||
V value75,
|
||
K key76,
|
||
V value76,
|
||
K key77,
|
||
V value77,
|
||
K key78,
|
||
V value78,
|
||
K key79,
|
||
V value79,
|
||
K key80,
|
||
V value80,
|
||
K key81,
|
||
V value81,
|
||
K key82,
|
||
V value82,
|
||
K key83,
|
||
V value83,
|
||
K key84,
|
||
V value84,
|
||
K key85,
|
||
V value85,
|
||
K key86,
|
||
V value86,
|
||
K key87,
|
||
V value87,
|
||
K key88,
|
||
V value88,
|
||
K key89,
|
||
V value89,
|
||
K key90,
|
||
V value90,
|
||
K key91,
|
||
V value91,
|
||
K key92,
|
||
V value92,
|
||
K key93,
|
||
V value93,
|
||
K key94,
|
||
V value94,
|
||
K key95,
|
||
V value95
|
||
) {
|
||
var map = new HashMap<K, V>(99);
|
||
map.put(key, value);
|
||
map.put(key2, value2);
|
||
map.put(key3, value3);
|
||
map.put(key4, value4);
|
||
map.put(key5, value5);
|
||
map.put(key6, value6);
|
||
map.put(key7, value7);
|
||
map.put(key8, value8);
|
||
map.put(key9, value9);
|
||
map.put(key10, value10);
|
||
map.put(key11, value11);
|
||
map.put(key12, value12);
|
||
map.put(key13, value13);
|
||
map.put(key14, value14);
|
||
map.put(key15, value15);
|
||
map.put(key16, value16);
|
||
map.put(key17, value17);
|
||
map.put(key18, value18);
|
||
map.put(key19, value19);
|
||
map.put(key20, value20);
|
||
map.put(key21, value21);
|
||
map.put(key22, value22);
|
||
map.put(key23, value23);
|
||
map.put(key24, value24);
|
||
map.put(key25, value25);
|
||
map.put(key26, value26);
|
||
map.put(key27, value27);
|
||
map.put(key28, value28);
|
||
map.put(key29, value29);
|
||
map.put(key30, value30);
|
||
map.put(key31, value31);
|
||
map.put(key32, value32);
|
||
map.put(key33, value33);
|
||
map.put(key34, value34);
|
||
map.put(key35, value35);
|
||
map.put(key36, value36);
|
||
map.put(key37, value37);
|
||
map.put(key38, value38);
|
||
map.put(key39, value39);
|
||
map.put(key40, value40);
|
||
map.put(key41, value41);
|
||
map.put(key42, value42);
|
||
map.put(key43, value43);
|
||
map.put(key44, value44);
|
||
map.put(key45, value45);
|
||
map.put(key46, value46);
|
||
map.put(key47, value47);
|
||
map.put(key48, value48);
|
||
map.put(key49, value49);
|
||
map.put(key50, value50);
|
||
map.put(key51, value51);
|
||
map.put(key52, value52);
|
||
map.put(key53, value53);
|
||
map.put(key54, value54);
|
||
map.put(key55, value55);
|
||
map.put(key56, value56);
|
||
map.put(key57, value57);
|
||
map.put(key58, value58);
|
||
map.put(key59, value59);
|
||
map.put(key60, value60);
|
||
map.put(key61, value61);
|
||
map.put(key62, value62);
|
||
map.put(key63, value63);
|
||
map.put(key64, value64);
|
||
map.put(key65, value65);
|
||
map.put(key66, value66);
|
||
map.put(key67, value67);
|
||
map.put(key68, value68);
|
||
map.put(key69, value69);
|
||
map.put(key70, value70);
|
||
map.put(key71, value71);
|
||
map.put(key72, value72);
|
||
map.put(key73, value73);
|
||
map.put(key74, value74);
|
||
map.put(key75, value75);
|
||
map.put(key76, value76);
|
||
map.put(key77, value77);
|
||
map.put(key78, value78);
|
||
map.put(key79, value79);
|
||
map.put(key80, value80);
|
||
map.put(key81, value81);
|
||
map.put(key82, value82);
|
||
map.put(key83, value83);
|
||
map.put(key84, value84);
|
||
map.put(key85, value85);
|
||
map.put(key86, value86);
|
||
map.put(key87, value87);
|
||
map.put(key88, value88);
|
||
map.put(key89, value89);
|
||
map.put(key90, value90);
|
||
map.put(key91, value91);
|
||
map.put(key92, value92);
|
||
map.put(key93, value93);
|
||
map.put(key94, value94);
|
||
map.put(key95, value95);
|
||
return map;
|
||
}
|
||
|
||
public static <K, V> Map<K, V> of(
|
||
K key,
|
||
V value,
|
||
K key2,
|
||
V value2,
|
||
K key3,
|
||
V value3,
|
||
K key4,
|
||
V value4,
|
||
K key5,
|
||
V value5,
|
||
K key6,
|
||
V value6,
|
||
K key7,
|
||
V value7,
|
||
K key8,
|
||
V value8,
|
||
K key9,
|
||
V value9,
|
||
K key10,
|
||
V value10,
|
||
K key11,
|
||
V value11,
|
||
K key12,
|
||
V value12,
|
||
K key13,
|
||
V value13,
|
||
K key14,
|
||
V value14,
|
||
K key15,
|
||
V value15,
|
||
K key16,
|
||
V value16,
|
||
K key17,
|
||
V value17,
|
||
K key18,
|
||
V value18,
|
||
K key19,
|
||
V value19,
|
||
K key20,
|
||
V value20,
|
||
K key21,
|
||
V value21,
|
||
K key22,
|
||
V value22,
|
||
K key23,
|
||
V value23,
|
||
K key24,
|
||
V value24,
|
||
K key25,
|
||
V value25,
|
||
K key26,
|
||
V value26,
|
||
K key27,
|
||
V value27,
|
||
K key28,
|
||
V value28,
|
||
K key29,
|
||
V value29,
|
||
K key30,
|
||
V value30,
|
||
K key31,
|
||
V value31,
|
||
K key32,
|
||
V value32,
|
||
K key33,
|
||
V value33,
|
||
K key34,
|
||
V value34,
|
||
K key35,
|
||
V value35,
|
||
K key36,
|
||
V value36,
|
||
K key37,
|
||
V value37,
|
||
K key38,
|
||
V value38,
|
||
K key39,
|
||
V value39,
|
||
K key40,
|
||
V value40,
|
||
K key41,
|
||
V value41,
|
||
K key42,
|
||
V value42,
|
||
K key43,
|
||
V value43,
|
||
K key44,
|
||
V value44,
|
||
K key45,
|
||
V value45,
|
||
K key46,
|
||
V value46,
|
||
K key47,
|
||
V value47,
|
||
K key48,
|
||
V value48,
|
||
K key49,
|
||
V value49,
|
||
K key50,
|
||
V value50,
|
||
K key51,
|
||
V value51,
|
||
K key52,
|
||
V value52,
|
||
K key53,
|
||
V value53,
|
||
K key54,
|
||
V value54,
|
||
K key55,
|
||
V value55,
|
||
K key56,
|
||
V value56,
|
||
K key57,
|
||
V value57,
|
||
K key58,
|
||
V value58,
|
||
K key59,
|
||
V value59,
|
||
K key60,
|
||
V value60,
|
||
K key61,
|
||
V value61,
|
||
K key62,
|
||
V value62,
|
||
K key63,
|
||
V value63,
|
||
K key64,
|
||
V value64,
|
||
K key65,
|
||
V value65,
|
||
K key66,
|
||
V value66,
|
||
K key67,
|
||
V value67,
|
||
K key68,
|
||
V value68,
|
||
K key69,
|
||
V value69,
|
||
K key70,
|
||
V value70,
|
||
K key71,
|
||
V value71,
|
||
K key72,
|
||
V value72,
|
||
K key73,
|
||
V value73,
|
||
K key74,
|
||
V value74,
|
||
K key75,
|
||
V value75,
|
||
K key76,
|
||
V value76,
|
||
K key77,
|
||
V value77,
|
||
K key78,
|
||
V value78,
|
||
K key79,
|
||
V value79,
|
||
K key80,
|
||
V value80,
|
||
K key81,
|
||
V value81,
|
||
K key82,
|
||
V value82,
|
||
K key83,
|
||
V value83,
|
||
K key84,
|
||
V value84,
|
||
K key85,
|
||
V value85,
|
||
K key86,
|
||
V value86,
|
||
K key87,
|
||
V value87,
|
||
K key88,
|
||
V value88,
|
||
K key89,
|
||
V value89,
|
||
K key90,
|
||
V value90,
|
||
K key91,
|
||
V value91,
|
||
K key92,
|
||
V value92,
|
||
K key93,
|
||
V value93,
|
||
K key94,
|
||
V value94,
|
||
K key95,
|
||
V value95,
|
||
K key96,
|
||
V value96
|
||
) {
|
||
var map = new HashMap<K, V>(100);
|
||
map.put(key, value);
|
||
map.put(key2, value2);
|
||
map.put(key3, value3);
|
||
map.put(key4, value4);
|
||
map.put(key5, value5);
|
||
map.put(key6, value6);
|
||
map.put(key7, value7);
|
||
map.put(key8, value8);
|
||
map.put(key9, value9);
|
||
map.put(key10, value10);
|
||
map.put(key11, value11);
|
||
map.put(key12, value12);
|
||
map.put(key13, value13);
|
||
map.put(key14, value14);
|
||
map.put(key15, value15);
|
||
map.put(key16, value16);
|
||
map.put(key17, value17);
|
||
map.put(key18, value18);
|
||
map.put(key19, value19);
|
||
map.put(key20, value20);
|
||
map.put(key21, value21);
|
||
map.put(key22, value22);
|
||
map.put(key23, value23);
|
||
map.put(key24, value24);
|
||
map.put(key25, value25);
|
||
map.put(key26, value26);
|
||
map.put(key27, value27);
|
||
map.put(key28, value28);
|
||
map.put(key29, value29);
|
||
map.put(key30, value30);
|
||
map.put(key31, value31);
|
||
map.put(key32, value32);
|
||
map.put(key33, value33);
|
||
map.put(key34, value34);
|
||
map.put(key35, value35);
|
||
map.put(key36, value36);
|
||
map.put(key37, value37);
|
||
map.put(key38, value38);
|
||
map.put(key39, value39);
|
||
map.put(key40, value40);
|
||
map.put(key41, value41);
|
||
map.put(key42, value42);
|
||
map.put(key43, value43);
|
||
map.put(key44, value44);
|
||
map.put(key45, value45);
|
||
map.put(key46, value46);
|
||
map.put(key47, value47);
|
||
map.put(key48, value48);
|
||
map.put(key49, value49);
|
||
map.put(key50, value50);
|
||
map.put(key51, value51);
|
||
map.put(key52, value52);
|
||
map.put(key53, value53);
|
||
map.put(key54, value54);
|
||
map.put(key55, value55);
|
||
map.put(key56, value56);
|
||
map.put(key57, value57);
|
||
map.put(key58, value58);
|
||
map.put(key59, value59);
|
||
map.put(key60, value60);
|
||
map.put(key61, value61);
|
||
map.put(key62, value62);
|
||
map.put(key63, value63);
|
||
map.put(key64, value64);
|
||
map.put(key65, value65);
|
||
map.put(key66, value66);
|
||
map.put(key67, value67);
|
||
map.put(key68, value68);
|
||
map.put(key69, value69);
|
||
map.put(key70, value70);
|
||
map.put(key71, value71);
|
||
map.put(key72, value72);
|
||
map.put(key73, value73);
|
||
map.put(key74, value74);
|
||
map.put(key75, value75);
|
||
map.put(key76, value76);
|
||
map.put(key77, value77);
|
||
map.put(key78, value78);
|
||
map.put(key79, value79);
|
||
map.put(key80, value80);
|
||
map.put(key81, value81);
|
||
map.put(key82, value82);
|
||
map.put(key83, value83);
|
||
map.put(key84, value84);
|
||
map.put(key85, value85);
|
||
map.put(key86, value86);
|
||
map.put(key87, value87);
|
||
map.put(key88, value88);
|
||
map.put(key89, value89);
|
||
map.put(key90, value90);
|
||
map.put(key91, value91);
|
||
map.put(key92, value92);
|
||
map.put(key93, value93);
|
||
map.put(key94, value94);
|
||
map.put(key95, value95);
|
||
map.put(key96, value96);
|
||
return map;
|
||
}
|
||
|
||
public static <K, V> Map<K, V> of(
|
||
K key,
|
||
V value,
|
||
K key2,
|
||
V value2,
|
||
K key3,
|
||
V value3,
|
||
K key4,
|
||
V value4,
|
||
K key5,
|
||
V value5,
|
||
K key6,
|
||
V value6,
|
||
K key7,
|
||
V value7,
|
||
K key8,
|
||
V value8,
|
||
K key9,
|
||
V value9,
|
||
K key10,
|
||
V value10,
|
||
K key11,
|
||
V value11,
|
||
K key12,
|
||
V value12,
|
||
K key13,
|
||
V value13,
|
||
K key14,
|
||
V value14,
|
||
K key15,
|
||
V value15,
|
||
K key16,
|
||
V value16,
|
||
K key17,
|
||
V value17,
|
||
K key18,
|
||
V value18,
|
||
K key19,
|
||
V value19,
|
||
K key20,
|
||
V value20,
|
||
K key21,
|
||
V value21,
|
||
K key22,
|
||
V value22,
|
||
K key23,
|
||
V value23,
|
||
K key24,
|
||
V value24,
|
||
K key25,
|
||
V value25,
|
||
K key26,
|
||
V value26,
|
||
K key27,
|
||
V value27,
|
||
K key28,
|
||
V value28,
|
||
K key29,
|
||
V value29,
|
||
K key30,
|
||
V value30,
|
||
K key31,
|
||
V value31,
|
||
K key32,
|
||
V value32,
|
||
K key33,
|
||
V value33,
|
||
K key34,
|
||
V value34,
|
||
K key35,
|
||
V value35,
|
||
K key36,
|
||
V value36,
|
||
K key37,
|
||
V value37,
|
||
K key38,
|
||
V value38,
|
||
K key39,
|
||
V value39,
|
||
K key40,
|
||
V value40,
|
||
K key41,
|
||
V value41,
|
||
K key42,
|
||
V value42,
|
||
K key43,
|
||
V value43,
|
||
K key44,
|
||
V value44,
|
||
K key45,
|
||
V value45,
|
||
K key46,
|
||
V value46,
|
||
K key47,
|
||
V value47,
|
||
K key48,
|
||
V value48,
|
||
K key49,
|
||
V value49,
|
||
K key50,
|
||
V value50,
|
||
K key51,
|
||
V value51,
|
||
K key52,
|
||
V value52,
|
||
K key53,
|
||
V value53,
|
||
K key54,
|
||
V value54,
|
||
K key55,
|
||
V value55,
|
||
K key56,
|
||
V value56,
|
||
K key57,
|
||
V value57,
|
||
K key58,
|
||
V value58,
|
||
K key59,
|
||
V value59,
|
||
K key60,
|
||
V value60,
|
||
K key61,
|
||
V value61,
|
||
K key62,
|
||
V value62,
|
||
K key63,
|
||
V value63,
|
||
K key64,
|
||
V value64,
|
||
K key65,
|
||
V value65,
|
||
K key66,
|
||
V value66,
|
||
K key67,
|
||
V value67,
|
||
K key68,
|
||
V value68,
|
||
K key69,
|
||
V value69,
|
||
K key70,
|
||
V value70,
|
||
K key71,
|
||
V value71,
|
||
K key72,
|
||
V value72,
|
||
K key73,
|
||
V value73,
|
||
K key74,
|
||
V value74,
|
||
K key75,
|
||
V value75,
|
||
K key76,
|
||
V value76,
|
||
K key77,
|
||
V value77,
|
||
K key78,
|
||
V value78,
|
||
K key79,
|
||
V value79,
|
||
K key80,
|
||
V value80,
|
||
K key81,
|
||
V value81,
|
||
K key82,
|
||
V value82,
|
||
K key83,
|
||
V value83,
|
||
K key84,
|
||
V value84,
|
||
K key85,
|
||
V value85,
|
||
K key86,
|
||
V value86,
|
||
K key87,
|
||
V value87,
|
||
K key88,
|
||
V value88,
|
||
K key89,
|
||
V value89,
|
||
K key90,
|
||
V value90,
|
||
K key91,
|
||
V value91,
|
||
K key92,
|
||
V value92,
|
||
K key93,
|
||
V value93,
|
||
K key94,
|
||
V value94,
|
||
K key95,
|
||
V value95,
|
||
K key96,
|
||
V value96,
|
||
K key97,
|
||
V value97
|
||
) {
|
||
var map = new HashMap<K, V>(101);
|
||
map.put(key, value);
|
||
map.put(key2, value2);
|
||
map.put(key3, value3);
|
||
map.put(key4, value4);
|
||
map.put(key5, value5);
|
||
map.put(key6, value6);
|
||
map.put(key7, value7);
|
||
map.put(key8, value8);
|
||
map.put(key9, value9);
|
||
map.put(key10, value10);
|
||
map.put(key11, value11);
|
||
map.put(key12, value12);
|
||
map.put(key13, value13);
|
||
map.put(key14, value14);
|
||
map.put(key15, value15);
|
||
map.put(key16, value16);
|
||
map.put(key17, value17);
|
||
map.put(key18, value18);
|
||
map.put(key19, value19);
|
||
map.put(key20, value20);
|
||
map.put(key21, value21);
|
||
map.put(key22, value22);
|
||
map.put(key23, value23);
|
||
map.put(key24, value24);
|
||
map.put(key25, value25);
|
||
map.put(key26, value26);
|
||
map.put(key27, value27);
|
||
map.put(key28, value28);
|
||
map.put(key29, value29);
|
||
map.put(key30, value30);
|
||
map.put(key31, value31);
|
||
map.put(key32, value32);
|
||
map.put(key33, value33);
|
||
map.put(key34, value34);
|
||
map.put(key35, value35);
|
||
map.put(key36, value36);
|
||
map.put(key37, value37);
|
||
map.put(key38, value38);
|
||
map.put(key39, value39);
|
||
map.put(key40, value40);
|
||
map.put(key41, value41);
|
||
map.put(key42, value42);
|
||
map.put(key43, value43);
|
||
map.put(key44, value44);
|
||
map.put(key45, value45);
|
||
map.put(key46, value46);
|
||
map.put(key47, value47);
|
||
map.put(key48, value48);
|
||
map.put(key49, value49);
|
||
map.put(key50, value50);
|
||
map.put(key51, value51);
|
||
map.put(key52, value52);
|
||
map.put(key53, value53);
|
||
map.put(key54, value54);
|
||
map.put(key55, value55);
|
||
map.put(key56, value56);
|
||
map.put(key57, value57);
|
||
map.put(key58, value58);
|
||
map.put(key59, value59);
|
||
map.put(key60, value60);
|
||
map.put(key61, value61);
|
||
map.put(key62, value62);
|
||
map.put(key63, value63);
|
||
map.put(key64, value64);
|
||
map.put(key65, value65);
|
||
map.put(key66, value66);
|
||
map.put(key67, value67);
|
||
map.put(key68, value68);
|
||
map.put(key69, value69);
|
||
map.put(key70, value70);
|
||
map.put(key71, value71);
|
||
map.put(key72, value72);
|
||
map.put(key73, value73);
|
||
map.put(key74, value74);
|
||
map.put(key75, value75);
|
||
map.put(key76, value76);
|
||
map.put(key77, value77);
|
||
map.put(key78, value78);
|
||
map.put(key79, value79);
|
||
map.put(key80, value80);
|
||
map.put(key81, value81);
|
||
map.put(key82, value82);
|
||
map.put(key83, value83);
|
||
map.put(key84, value84);
|
||
map.put(key85, value85);
|
||
map.put(key86, value86);
|
||
map.put(key87, value87);
|
||
map.put(key88, value88);
|
||
map.put(key89, value89);
|
||
map.put(key90, value90);
|
||
map.put(key91, value91);
|
||
map.put(key92, value92);
|
||
map.put(key93, value93);
|
||
map.put(key94, value94);
|
||
map.put(key95, value95);
|
||
map.put(key96, value96);
|
||
map.put(key97, value97);
|
||
return map;
|
||
}
|
||
|
||
public static <K, V> Map<K, V> of(
|
||
K key,
|
||
V value,
|
||
K key2,
|
||
V value2,
|
||
K key3,
|
||
V value3,
|
||
K key4,
|
||
V value4,
|
||
K key5,
|
||
V value5,
|
||
K key6,
|
||
V value6,
|
||
K key7,
|
||
V value7,
|
||
K key8,
|
||
V value8,
|
||
K key9,
|
||
V value9,
|
||
K key10,
|
||
V value10,
|
||
K key11,
|
||
V value11,
|
||
K key12,
|
||
V value12,
|
||
K key13,
|
||
V value13,
|
||
K key14,
|
||
V value14,
|
||
K key15,
|
||
V value15,
|
||
K key16,
|
||
V value16,
|
||
K key17,
|
||
V value17,
|
||
K key18,
|
||
V value18,
|
||
K key19,
|
||
V value19,
|
||
K key20,
|
||
V value20,
|
||
K key21,
|
||
V value21,
|
||
K key22,
|
||
V value22,
|
||
K key23,
|
||
V value23,
|
||
K key24,
|
||
V value24,
|
||
K key25,
|
||
V value25,
|
||
K key26,
|
||
V value26,
|
||
K key27,
|
||
V value27,
|
||
K key28,
|
||
V value28,
|
||
K key29,
|
||
V value29,
|
||
K key30,
|
||
V value30,
|
||
K key31,
|
||
V value31,
|
||
K key32,
|
||
V value32,
|
||
K key33,
|
||
V value33,
|
||
K key34,
|
||
V value34,
|
||
K key35,
|
||
V value35,
|
||
K key36,
|
||
V value36,
|
||
K key37,
|
||
V value37,
|
||
K key38,
|
||
V value38,
|
||
K key39,
|
||
V value39,
|
||
K key40,
|
||
V value40,
|
||
K key41,
|
||
V value41,
|
||
K key42,
|
||
V value42,
|
||
K key43,
|
||
V value43,
|
||
K key44,
|
||
V value44,
|
||
K key45,
|
||
V value45,
|
||
K key46,
|
||
V value46,
|
||
K key47,
|
||
V value47,
|
||
K key48,
|
||
V value48,
|
||
K key49,
|
||
V value49,
|
||
K key50,
|
||
V value50,
|
||
K key51,
|
||
V value51,
|
||
K key52,
|
||
V value52,
|
||
K key53,
|
||
V value53,
|
||
K key54,
|
||
V value54,
|
||
K key55,
|
||
V value55,
|
||
K key56,
|
||
V value56,
|
||
K key57,
|
||
V value57,
|
||
K key58,
|
||
V value58,
|
||
K key59,
|
||
V value59,
|
||
K key60,
|
||
V value60,
|
||
K key61,
|
||
V value61,
|
||
K key62,
|
||
V value62,
|
||
K key63,
|
||
V value63,
|
||
K key64,
|
||
V value64,
|
||
K key65,
|
||
V value65,
|
||
K key66,
|
||
V value66,
|
||
K key67,
|
||
V value67,
|
||
K key68,
|
||
V value68,
|
||
K key69,
|
||
V value69,
|
||
K key70,
|
||
V value70,
|
||
K key71,
|
||
V value71,
|
||
K key72,
|
||
V value72,
|
||
K key73,
|
||
V value73,
|
||
K key74,
|
||
V value74,
|
||
K key75,
|
||
V value75,
|
||
K key76,
|
||
V value76,
|
||
K key77,
|
||
V value77,
|
||
K key78,
|
||
V value78,
|
||
K key79,
|
||
V value79,
|
||
K key80,
|
||
V value80,
|
||
K key81,
|
||
V value81,
|
||
K key82,
|
||
V value82,
|
||
K key83,
|
||
V value83,
|
||
K key84,
|
||
V value84,
|
||
K key85,
|
||
V value85,
|
||
K key86,
|
||
V value86,
|
||
K key87,
|
||
V value87,
|
||
K key88,
|
||
V value88,
|
||
K key89,
|
||
V value89,
|
||
K key90,
|
||
V value90,
|
||
K key91,
|
||
V value91,
|
||
K key92,
|
||
V value92,
|
||
K key93,
|
||
V value93,
|
||
K key94,
|
||
V value94,
|
||
K key95,
|
||
V value95,
|
||
K key96,
|
||
V value96,
|
||
K key97,
|
||
V value97,
|
||
K key98,
|
||
V value98
|
||
) {
|
||
var map = new HashMap<K, V>(102);
|
||
map.put(key, value);
|
||
map.put(key2, value2);
|
||
map.put(key3, value3);
|
||
map.put(key4, value4);
|
||
map.put(key5, value5);
|
||
map.put(key6, value6);
|
||
map.put(key7, value7);
|
||
map.put(key8, value8);
|
||
map.put(key9, value9);
|
||
map.put(key10, value10);
|
||
map.put(key11, value11);
|
||
map.put(key12, value12);
|
||
map.put(key13, value13);
|
||
map.put(key14, value14);
|
||
map.put(key15, value15);
|
||
map.put(key16, value16);
|
||
map.put(key17, value17);
|
||
map.put(key18, value18);
|
||
map.put(key19, value19);
|
||
map.put(key20, value20);
|
||
map.put(key21, value21);
|
||
map.put(key22, value22);
|
||
map.put(key23, value23);
|
||
map.put(key24, value24);
|
||
map.put(key25, value25);
|
||
map.put(key26, value26);
|
||
map.put(key27, value27);
|
||
map.put(key28, value28);
|
||
map.put(key29, value29);
|
||
map.put(key30, value30);
|
||
map.put(key31, value31);
|
||
map.put(key32, value32);
|
||
map.put(key33, value33);
|
||
map.put(key34, value34);
|
||
map.put(key35, value35);
|
||
map.put(key36, value36);
|
||
map.put(key37, value37);
|
||
map.put(key38, value38);
|
||
map.put(key39, value39);
|
||
map.put(key40, value40);
|
||
map.put(key41, value41);
|
||
map.put(key42, value42);
|
||
map.put(key43, value43);
|
||
map.put(key44, value44);
|
||
map.put(key45, value45);
|
||
map.put(key46, value46);
|
||
map.put(key47, value47);
|
||
map.put(key48, value48);
|
||
map.put(key49, value49);
|
||
map.put(key50, value50);
|
||
map.put(key51, value51);
|
||
map.put(key52, value52);
|
||
map.put(key53, value53);
|
||
map.put(key54, value54);
|
||
map.put(key55, value55);
|
||
map.put(key56, value56);
|
||
map.put(key57, value57);
|
||
map.put(key58, value58);
|
||
map.put(key59, value59);
|
||
map.put(key60, value60);
|
||
map.put(key61, value61);
|
||
map.put(key62, value62);
|
||
map.put(key63, value63);
|
||
map.put(key64, value64);
|
||
map.put(key65, value65);
|
||
map.put(key66, value66);
|
||
map.put(key67, value67);
|
||
map.put(key68, value68);
|
||
map.put(key69, value69);
|
||
map.put(key70, value70);
|
||
map.put(key71, value71);
|
||
map.put(key72, value72);
|
||
map.put(key73, value73);
|
||
map.put(key74, value74);
|
||
map.put(key75, value75);
|
||
map.put(key76, value76);
|
||
map.put(key77, value77);
|
||
map.put(key78, value78);
|
||
map.put(key79, value79);
|
||
map.put(key80, value80);
|
||
map.put(key81, value81);
|
||
map.put(key82, value82);
|
||
map.put(key83, value83);
|
||
map.put(key84, value84);
|
||
map.put(key85, value85);
|
||
map.put(key86, value86);
|
||
map.put(key87, value87);
|
||
map.put(key88, value88);
|
||
map.put(key89, value89);
|
||
map.put(key90, value90);
|
||
map.put(key91, value91);
|
||
map.put(key92, value92);
|
||
map.put(key93, value93);
|
||
map.put(key94, value94);
|
||
map.put(key95, value95);
|
||
map.put(key96, value96);
|
||
map.put(key97, value97);
|
||
map.put(key98, value98);
|
||
return map;
|
||
}
|
||
|
||
public static <K, V> Map<K, V> of(
|
||
K key,
|
||
V value,
|
||
K key2,
|
||
V value2,
|
||
K key3,
|
||
V value3,
|
||
K key4,
|
||
V value4,
|
||
K key5,
|
||
V value5,
|
||
K key6,
|
||
V value6,
|
||
K key7,
|
||
V value7,
|
||
K key8,
|
||
V value8,
|
||
K key9,
|
||
V value9,
|
||
K key10,
|
||
V value10,
|
||
K key11,
|
||
V value11,
|
||
K key12,
|
||
V value12,
|
||
K key13,
|
||
V value13,
|
||
K key14,
|
||
V value14,
|
||
K key15,
|
||
V value15,
|
||
K key16,
|
||
V value16,
|
||
K key17,
|
||
V value17,
|
||
K key18,
|
||
V value18,
|
||
K key19,
|
||
V value19,
|
||
K key20,
|
||
V value20,
|
||
K key21,
|
||
V value21,
|
||
K key22,
|
||
V value22,
|
||
K key23,
|
||
V value23,
|
||
K key24,
|
||
V value24,
|
||
K key25,
|
||
V value25,
|
||
K key26,
|
||
V value26,
|
||
K key27,
|
||
V value27,
|
||
K key28,
|
||
V value28,
|
||
K key29,
|
||
V value29,
|
||
K key30,
|
||
V value30,
|
||
K key31,
|
||
V value31,
|
||
K key32,
|
||
V value32,
|
||
K key33,
|
||
V value33,
|
||
K key34,
|
||
V value34,
|
||
K key35,
|
||
V value35,
|
||
K key36,
|
||
V value36,
|
||
K key37,
|
||
V value37,
|
||
K key38,
|
||
V value38,
|
||
K key39,
|
||
V value39,
|
||
K key40,
|
||
V value40,
|
||
K key41,
|
||
V value41,
|
||
K key42,
|
||
V value42,
|
||
K key43,
|
||
V value43,
|
||
K key44,
|
||
V value44,
|
||
K key45,
|
||
V value45,
|
||
K key46,
|
||
V value46,
|
||
K key47,
|
||
V value47,
|
||
K key48,
|
||
V value48,
|
||
K key49,
|
||
V value49,
|
||
K key50,
|
||
V value50,
|
||
K key51,
|
||
V value51,
|
||
K key52,
|
||
V value52,
|
||
K key53,
|
||
V value53,
|
||
K key54,
|
||
V value54,
|
||
K key55,
|
||
V value55,
|
||
K key56,
|
||
V value56,
|
||
K key57,
|
||
V value57,
|
||
K key58,
|
||
V value58,
|
||
K key59,
|
||
V value59,
|
||
K key60,
|
||
V value60,
|
||
K key61,
|
||
V value61,
|
||
K key62,
|
||
V value62,
|
||
K key63,
|
||
V value63,
|
||
K key64,
|
||
V value64,
|
||
K key65,
|
||
V value65,
|
||
K key66,
|
||
V value66,
|
||
K key67,
|
||
V value67,
|
||
K key68,
|
||
V value68,
|
||
K key69,
|
||
V value69,
|
||
K key70,
|
||
V value70,
|
||
K key71,
|
||
V value71,
|
||
K key72,
|
||
V value72,
|
||
K key73,
|
||
V value73,
|
||
K key74,
|
||
V value74,
|
||
K key75,
|
||
V value75,
|
||
K key76,
|
||
V value76,
|
||
K key77,
|
||
V value77,
|
||
K key78,
|
||
V value78,
|
||
K key79,
|
||
V value79,
|
||
K key80,
|
||
V value80,
|
||
K key81,
|
||
V value81,
|
||
K key82,
|
||
V value82,
|
||
K key83,
|
||
V value83,
|
||
K key84,
|
||
V value84,
|
||
K key85,
|
||
V value85,
|
||
K key86,
|
||
V value86,
|
||
K key87,
|
||
V value87,
|
||
K key88,
|
||
V value88,
|
||
K key89,
|
||
V value89,
|
||
K key90,
|
||
V value90,
|
||
K key91,
|
||
V value91,
|
||
K key92,
|
||
V value92,
|
||
K key93,
|
||
V value93,
|
||
K key94,
|
||
V value94,
|
||
K key95,
|
||
V value95,
|
||
K key96,
|
||
V value96,
|
||
K key97,
|
||
V value97,
|
||
K key98,
|
||
V value98,
|
||
K key99,
|
||
V value99
|
||
) {
|
||
var map = new HashMap<K, V>(103);
|
||
map.put(key, value);
|
||
map.put(key2, value2);
|
||
map.put(key3, value3);
|
||
map.put(key4, value4);
|
||
map.put(key5, value5);
|
||
map.put(key6, value6);
|
||
map.put(key7, value7);
|
||
map.put(key8, value8);
|
||
map.put(key9, value9);
|
||
map.put(key10, value10);
|
||
map.put(key11, value11);
|
||
map.put(key12, value12);
|
||
map.put(key13, value13);
|
||
map.put(key14, value14);
|
||
map.put(key15, value15);
|
||
map.put(key16, value16);
|
||
map.put(key17, value17);
|
||
map.put(key18, value18);
|
||
map.put(key19, value19);
|
||
map.put(key20, value20);
|
||
map.put(key21, value21);
|
||
map.put(key22, value22);
|
||
map.put(key23, value23);
|
||
map.put(key24, value24);
|
||
map.put(key25, value25);
|
||
map.put(key26, value26);
|
||
map.put(key27, value27);
|
||
map.put(key28, value28);
|
||
map.put(key29, value29);
|
||
map.put(key30, value30);
|
||
map.put(key31, value31);
|
||
map.put(key32, value32);
|
||
map.put(key33, value33);
|
||
map.put(key34, value34);
|
||
map.put(key35, value35);
|
||
map.put(key36, value36);
|
||
map.put(key37, value37);
|
||
map.put(key38, value38);
|
||
map.put(key39, value39);
|
||
map.put(key40, value40);
|
||
map.put(key41, value41);
|
||
map.put(key42, value42);
|
||
map.put(key43, value43);
|
||
map.put(key44, value44);
|
||
map.put(key45, value45);
|
||
map.put(key46, value46);
|
||
map.put(key47, value47);
|
||
map.put(key48, value48);
|
||
map.put(key49, value49);
|
||
map.put(key50, value50);
|
||
map.put(key51, value51);
|
||
map.put(key52, value52);
|
||
map.put(key53, value53);
|
||
map.put(key54, value54);
|
||
map.put(key55, value55);
|
||
map.put(key56, value56);
|
||
map.put(key57, value57);
|
||
map.put(key58, value58);
|
||
map.put(key59, value59);
|
||
map.put(key60, value60);
|
||
map.put(key61, value61);
|
||
map.put(key62, value62);
|
||
map.put(key63, value63);
|
||
map.put(key64, value64);
|
||
map.put(key65, value65);
|
||
map.put(key66, value66);
|
||
map.put(key67, value67);
|
||
map.put(key68, value68);
|
||
map.put(key69, value69);
|
||
map.put(key70, value70);
|
||
map.put(key71, value71);
|
||
map.put(key72, value72);
|
||
map.put(key73, value73);
|
||
map.put(key74, value74);
|
||
map.put(key75, value75);
|
||
map.put(key76, value76);
|
||
map.put(key77, value77);
|
||
map.put(key78, value78);
|
||
map.put(key79, value79);
|
||
map.put(key80, value80);
|
||
map.put(key81, value81);
|
||
map.put(key82, value82);
|
||
map.put(key83, value83);
|
||
map.put(key84, value84);
|
||
map.put(key85, value85);
|
||
map.put(key86, value86);
|
||
map.put(key87, value87);
|
||
map.put(key88, value88);
|
||
map.put(key89, value89);
|
||
map.put(key90, value90);
|
||
map.put(key91, value91);
|
||
map.put(key92, value92);
|
||
map.put(key93, value93);
|
||
map.put(key94, value94);
|
||
map.put(key95, value95);
|
||
map.put(key96, value96);
|
||
map.put(key97, value97);
|
||
map.put(key98, value98);
|
||
map.put(key99, value99);
|
||
return map;
|
||
}
|
||
|
||
public static <K, V> Map<K, V> of(
|
||
K key,
|
||
V value,
|
||
K key2,
|
||
V value2,
|
||
K key3,
|
||
V value3,
|
||
K key4,
|
||
V value4,
|
||
K key5,
|
||
V value5,
|
||
K key6,
|
||
V value6,
|
||
K key7,
|
||
V value7,
|
||
K key8,
|
||
V value8,
|
||
K key9,
|
||
V value9,
|
||
K key10,
|
||
V value10,
|
||
K key11,
|
||
V value11,
|
||
K key12,
|
||
V value12,
|
||
K key13,
|
||
V value13,
|
||
K key14,
|
||
V value14,
|
||
K key15,
|
||
V value15,
|
||
K key16,
|
||
V value16,
|
||
K key17,
|
||
V value17,
|
||
K key18,
|
||
V value18,
|
||
K key19,
|
||
V value19,
|
||
K key20,
|
||
V value20,
|
||
K key21,
|
||
V value21,
|
||
K key22,
|
||
V value22,
|
||
K key23,
|
||
V value23,
|
||
K key24,
|
||
V value24,
|
||
K key25,
|
||
V value25,
|
||
K key26,
|
||
V value26,
|
||
K key27,
|
||
V value27,
|
||
K key28,
|
||
V value28,
|
||
K key29,
|
||
V value29,
|
||
K key30,
|
||
V value30,
|
||
K key31,
|
||
V value31,
|
||
K key32,
|
||
V value32,
|
||
K key33,
|
||
V value33,
|
||
K key34,
|
||
V value34,
|
||
K key35,
|
||
V value35,
|
||
K key36,
|
||
V value36,
|
||
K key37,
|
||
V value37,
|
||
K key38,
|
||
V value38,
|
||
K key39,
|
||
V value39,
|
||
K key40,
|
||
V value40,
|
||
K key41,
|
||
V value41,
|
||
K key42,
|
||
V value42,
|
||
K key43,
|
||
V value43,
|
||
K key44,
|
||
V value44,
|
||
K key45,
|
||
V value45,
|
||
K key46,
|
||
V value46,
|
||
K key47,
|
||
V value47,
|
||
K key48,
|
||
V value48,
|
||
K key49,
|
||
V value49,
|
||
K key50,
|
||
V value50,
|
||
K key51,
|
||
V value51,
|
||
K key52,
|
||
V value52,
|
||
K key53,
|
||
V value53,
|
||
K key54,
|
||
V value54,
|
||
K key55,
|
||
V value55,
|
||
K key56,
|
||
V value56,
|
||
K key57,
|
||
V value57,
|
||
K key58,
|
||
V value58,
|
||
K key59,
|
||
V value59,
|
||
K key60,
|
||
V value60,
|
||
K key61,
|
||
V value61,
|
||
K key62,
|
||
V value62,
|
||
K key63,
|
||
V value63,
|
||
K key64,
|
||
V value64,
|
||
K key65,
|
||
V value65,
|
||
K key66,
|
||
V value66,
|
||
K key67,
|
||
V value67,
|
||
K key68,
|
||
V value68,
|
||
K key69,
|
||
V value69,
|
||
K key70,
|
||
V value70,
|
||
K key71,
|
||
V value71,
|
||
K key72,
|
||
V value72,
|
||
K key73,
|
||
V value73,
|
||
K key74,
|
||
V value74,
|
||
K key75,
|
||
V value75,
|
||
K key76,
|
||
V value76,
|
||
K key77,
|
||
V value77,
|
||
K key78,
|
||
V value78,
|
||
K key79,
|
||
V value79,
|
||
K key80,
|
||
V value80,
|
||
K key81,
|
||
V value81,
|
||
K key82,
|
||
V value82,
|
||
K key83,
|
||
V value83,
|
||
K key84,
|
||
V value84,
|
||
K key85,
|
||
V value85,
|
||
K key86,
|
||
V value86,
|
||
K key87,
|
||
V value87,
|
||
K key88,
|
||
V value88,
|
||
K key89,
|
||
V value89,
|
||
K key90,
|
||
V value90,
|
||
K key91,
|
||
V value91,
|
||
K key92,
|
||
V value92,
|
||
K key93,
|
||
V value93,
|
||
K key94,
|
||
V value94,
|
||
K key95,
|
||
V value95,
|
||
K key96,
|
||
V value96,
|
||
K key97,
|
||
V value97,
|
||
K key98,
|
||
V value98,
|
||
K key99,
|
||
V value99,
|
||
K key100,
|
||
V value100
|
||
) {
|
||
var map = new HashMap<K, V>(104);
|
||
map.put(key, value);
|
||
map.put(key2, value2);
|
||
map.put(key3, value3);
|
||
map.put(key4, value4);
|
||
map.put(key5, value5);
|
||
map.put(key6, value6);
|
||
map.put(key7, value7);
|
||
map.put(key8, value8);
|
||
map.put(key9, value9);
|
||
map.put(key10, value10);
|
||
map.put(key11, value11);
|
||
map.put(key12, value12);
|
||
map.put(key13, value13);
|
||
map.put(key14, value14);
|
||
map.put(key15, value15);
|
||
map.put(key16, value16);
|
||
map.put(key17, value17);
|
||
map.put(key18, value18);
|
||
map.put(key19, value19);
|
||
map.put(key20, value20);
|
||
map.put(key21, value21);
|
||
map.put(key22, value22);
|
||
map.put(key23, value23);
|
||
map.put(key24, value24);
|
||
map.put(key25, value25);
|
||
map.put(key26, value26);
|
||
map.put(key27, value27);
|
||
map.put(key28, value28);
|
||
map.put(key29, value29);
|
||
map.put(key30, value30);
|
||
map.put(key31, value31);
|
||
map.put(key32, value32);
|
||
map.put(key33, value33);
|
||
map.put(key34, value34);
|
||
map.put(key35, value35);
|
||
map.put(key36, value36);
|
||
map.put(key37, value37);
|
||
map.put(key38, value38);
|
||
map.put(key39, value39);
|
||
map.put(key40, value40);
|
||
map.put(key41, value41);
|
||
map.put(key42, value42);
|
||
map.put(key43, value43);
|
||
map.put(key44, value44);
|
||
map.put(key45, value45);
|
||
map.put(key46, value46);
|
||
map.put(key47, value47);
|
||
map.put(key48, value48);
|
||
map.put(key49, value49);
|
||
map.put(key50, value50);
|
||
map.put(key51, value51);
|
||
map.put(key52, value52);
|
||
map.put(key53, value53);
|
||
map.put(key54, value54);
|
||
map.put(key55, value55);
|
||
map.put(key56, value56);
|
||
map.put(key57, value57);
|
||
map.put(key58, value58);
|
||
map.put(key59, value59);
|
||
map.put(key60, value60);
|
||
map.put(key61, value61);
|
||
map.put(key62, value62);
|
||
map.put(key63, value63);
|
||
map.put(key64, value64);
|
||
map.put(key65, value65);
|
||
map.put(key66, value66);
|
||
map.put(key67, value67);
|
||
map.put(key68, value68);
|
||
map.put(key69, value69);
|
||
map.put(key70, value70);
|
||
map.put(key71, value71);
|
||
map.put(key72, value72);
|
||
map.put(key73, value73);
|
||
map.put(key74, value74);
|
||
map.put(key75, value75);
|
||
map.put(key76, value76);
|
||
map.put(key77, value77);
|
||
map.put(key78, value78);
|
||
map.put(key79, value79);
|
||
map.put(key80, value80);
|
||
map.put(key81, value81);
|
||
map.put(key82, value82);
|
||
map.put(key83, value83);
|
||
map.put(key84, value84);
|
||
map.put(key85, value85);
|
||
map.put(key86, value86);
|
||
map.put(key87, value87);
|
||
map.put(key88, value88);
|
||
map.put(key89, value89);
|
||
map.put(key90, value90);
|
||
map.put(key91, value91);
|
||
map.put(key92, value92);
|
||
map.put(key93, value93);
|
||
map.put(key94, value94);
|
||
map.put(key95, value95);
|
||
map.put(key96, value96);
|
||
map.put(key97, value97);
|
||
map.put(key98, value98);
|
||
map.put(key99, value99);
|
||
map.put(key100, value100);
|
||
return map;
|
||
}
|
||
|
||
/**
|
||
* 使用Entry对象创建Map的替代方案
|
||
*
|
||
* @param entries Entry对象数组
|
||
* @param <K> 键的类型
|
||
* @param <V> 值的类型
|
||
* @return 包含指定键值对的HashMap实例
|
||
*/
|
||
public static <K, V> Map<K, V> ofEntries(Map.Entry<K, V>... entries) {
|
||
var map = new HashMap<K, V>(entries.length + 2);
|
||
for (Map.Entry<K, V> entry : entries) {
|
||
map.put(entry.getKey(), entry.getValue());
|
||
}
|
||
return map;
|
||
}
|
||
|
||
public static <K, V> Map<K, V> ofEntries(List<Map.Entry<K, V>> entries) {
|
||
var map = new HashMap<K, V>(entries.size() + 2);
|
||
for (Map.Entry<K, V> entry : entries) {
|
||
map.put(entry.getKey(), entry.getValue());
|
||
}
|
||
return map;
|
||
}
|
||
}
|