将键列表和值列表转换为Map<br>
以键为准，值与键位置需对应。如果键元素数多于值元素，多余部分值用null代替。<br>
如果值多于键，忽略多余的值。

@param <K> 键类型
@param <V> 值类型
@param keys 键列表
@param values 值列表
@return 标题内容Map
@since 3.1.0
163208
public static <K, V> Map<K, V> toMap(Iterable<K> keys, Iterable<V> values) {
		return toMap(keys, values, false);
	}
934179
public static <K, V> Map<K, V> zip(K[] keys, V[] values, boolean isOrder) {
		if (isEmpty(keys) || isEmpty(values)) {
			return null;
		}

		final int size = Math.min(keys.length, values.length);
		final Map<K, V> map = CollectionUtil.newHashMap(size, isOrder);
		for (int i = 0; i < size; i++) {
			map.put(keys[i], values[i]);
		}

		return map;
	}
238676
public static <K, V> Map<K, V> toMap(Iterator<K> keys, Iterator<V> values, boolean isOrder) {
		final Map<K, V> resultMap = MapUtil.newHashMap(isOrder);
		if (isNotEmpty(keys)) {
			while (keys.hasNext()) {
				resultMap.put(keys.next(), (null != values && values.hasNext()) ? values.next() : null);
			}
		}
		return resultMap;
	}
147644
public final Set<V> getValues(K key) {
	Set<V> set = _getValues(key);
	if(set == null)
	    return Collections.emptySet();
	else 
	    return Collections.unmodifiableSet(set);
    }
11508
@Override
  public Map<K, V> peekAll(final Iterable<? extends K> keys) {
    Map<K, CacheEntry<K, V>> map = new HashMap<K, CacheEntry<K, V>>();
    for (K k : keys) {
      CacheEntry<K, V> e = execute(k, SPEC.peekEntry(k));
      if (e != null) {
        map.put(k, e);
      }
    }
    return heapCache.convertCacheEntry2ValueMap(map);
  }
389078
public static <K, V> ImmutableSet<K> allKeys(final Iterable<? extends Map<K, V>> maps) {
    final ImmutableSet.Builder<K> builder = ImmutableSet.builder();

    for (final Map<K, V> map : maps) {
      builder.addAll(map.keySet());
    }

    return builder.build();
  }
1044201
public T value(Object... values) {
        if (values == null || values.length == 0) {
            return (T) this;
        }
        if (this.value == null) {
            this.value = new ArrayList<Object>(values.length);
        }
        if (this.value instanceof List) {
            ((List) this.value).addAll(Arrays.asList(values));
        }
        return (T) this;
    }
1146917
public static <K, V> Map<K, V> wrap(final String key, final Object value) {
        val map = new LinkedHashMap();
        if (value != null && StringUtils.isNotBlank(key)) {
            map.put(key, value);
        }
        return map;
    }
712560
@SafeVarargs
    public static <T> Set<T> create(final T... values) {
        Set<T> result = new HashSet<>(values.length);
        Collections.addAll(result, values);
        return result;
    }
512916
@SuppressWarnings("unchecked")
    public static <K extends Object, V extends Object> Map<K, V> createMap(
            Object... keysAndValues) {
        if (keysAndValues == null) {
            return null;
        }
        if (keysAndValues.length % 2 != 0) {
            throw new IllegalArgumentException("Number of arguments must be even!");
        }
        Map<K, V> result = new LinkedHashMap<>();
        for (int i = 0, n = keysAndValues.length / 2; i < n; i++) {
            result.put((K) keysAndValues[i * 2], (V) keysAndValues[i * 2 + 1]);
        }
        return result;
    }
646510
public ValueMap withList(String key, Object ... vals) {
        super.put(key, 
            vals == null ? null : new ArrayList<Object>(Arrays.asList(vals)));
        return this;
    }
1347949
public Map<String, String> getMulti(String columnName, String... keys) {
    MultigetSliceQuery<String, String,String> q = createMultigetSliceQuery(keyspace, serializer, serializer, serializer);
    q.setColumnFamily(columnFamilyName);
    q.setKeys(keys);
    q.setColumnNames(columnName);

    QueryResult<Rows<String,String,String>> r = q.execute();
    Rows<String,String,String> rows = r.get();
    Map<String, String> ret = new HashMap<String, String>(keys.length);
    for (String k: keys) {
      HColumn<String, String> c = rows.getByKey(k).getColumnSlice().getColumnByName(columnName);
      if (c != null && c.getValue() != null) {
        ret.put(k, c.getValue());
      }
    }
    return ret;
  }
72161
public static <T> Set<T> set(T... values) {
        return new HashSet<T>(Arrays.asList(values));
    }
409419
public static <X,Y> Map<X,Y> zip(List<X> keys, List<Y> values) {
        if (keys.size() != values.size()) {
            throw new IllegalArgumentException("Lengths are not equal");
        }
        Map<X,Y> map = new HashMap<>(keys.size());
        for (int i=0; i<keys.size(); i++) {
            map.put(keys.get(i), values.get(i));
        }
        return map;
    }
634940
@SuppressWarnings("rawtypes")
	public List mget(Object... keys) {
		Jedis jedis = getJedis();
		try {
			byte[][] keysBytesArray = keysToBytesArray(keys);
			List<byte[]> data = jedis.mget(keysBytesArray);
			return valueListFromBytesList(data);
		}
		finally {close(jedis);}
	}
250772
@Override
    public <K, M extends Map<K, ?>> Expression<Set<K>> keys(M arg0)
    {
        // TODO Auto-generated method stub
        return null;
    }
869904
public static Map<String, String> zip(String keys, String values, String delimiter) {
		return zip(keys, values, delimiter, false);
	}