com.weicoder.common.lang.Maps Maven / Gradle / Ivy

Go to download
package com.weicoder.common.lang;

import java.util.Collections;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;

import com.weicoder.common.util.EmptyUtil;

/**
 * Map的帮助类,获得Map的一些操作
 * @author WD
 * @since JDK7
 * @version 1.0 2009-09-08
 */
public final class Maps {
	/**
	 * 判断是否Map
	 * @param obj 对象
	 * @return 是否Map
	 */
	public static boolean isMap(Object obj) {
		return !EmptyUtil.isEmpty(obj) && obj instanceof Map;
	}

	/**
	 * 获得Map实例 默认初始化大小为10
	 * @return Map
	 */
	public static  Map getMap() {
		return getHashMap();
	}

	/**
	 * 获得Map实例
	 * @param size 初始化大小
	 * @return Map
	 */
	public static  Map getMap(int size) {
		return getHashMap(size < 1 ? 1 : size);
	}

	/**
	 * 获得Map实例
	 * @param map 初始化的Map
	 * @return Map
	 */
	public static  Map getMap(Map map) {
		return getHashMap(map);
	}

	/**
	 * 获得Map实例
	 * @param key 键
	 * @param value 值
	 * @return Map
	 */
	public static  Map getMap(K key, V value) {
		// 获得Map
		Map map = getMap();
		// 设置键值
		map.put(key, value);
		// 返回Map
		return map;
	}

	/**
	 * 获得Map实例
	 * @param keys 键数组
	 * @param values 值数组
	 * @return Map
	 */
	public static  Map getMap(K[] keys, V[] values) {
		return getMap(Lists.getList(keys), Lists.getList(values));
	}

	/**
	 * 获得Map实例
	 * @param keys 键数组
	 * @param values 值数组
	 * @return Map
	 */
	public static  Map getMap(List keys, List values) {
		// 判断key和value为空或则键值数量不同 返回空Map
		if (EmptyUtil.isEmpty(keys) || EmptyUtil.isEmpty(values) || keys.size() != values.size()) {
			return emptyMap();
		}
		// 获得Map
		Map map = getMap();
		// 循环填充map
		for (int i = 0; i < keys.size(); i++) {
			// 设置键值
			map.put(keys.get(i), values.get(i));
		}
		// 返回Map
		return map;
	}

	/**
	 * 获得Map实例
	 * @param map 初始化的Map
	 * @return Map
	 */
	@SafeVarargs
	public static  Map getMap(Map... maps) {
		// 获得一个map
		Map map = getMap();
		// 循环maps
		for (int i = 0; i < maps.length; i++) {
			// 添加到map
			map.putAll(maps[i]);
		}
		// 返回map
		return map;
	}

	/**
	 * 获得Map实例 实现类是HashMap
	 * @return Map
	 */
	public static  HashMap getHashMap() {
		return new HashMap();
	}

	/**
	 * 获得Map实例 实现类是HashMap
	 * @param size 初始化大小
	 * @return Map
	 */
	public static  HashMap getHashMap(int size) {
		return new HashMap(size);
	}

	/**
	 * 获得Map实例 实现类是HashMap
	 * @param map 初始化的Map
	 * @return Map
	 */
	public static  HashMap getHashMap(Map map) {
		return map == null ? new HashMap() : new HashMap(map);
	}

	/**
	 * 获得Map实例 实现类是LinkedHashMap 默认初始化大小为10
	 * @return Map
	 */
	public static  LinkedHashMap getLinkedHashMap() {
		return getLinkedHashMap(10);
	}

	/**
	 * 获得Map实例 实现类是LinkedHashMap
	 * @param size 初始化大小
	 * @return Map
	 */
	public static  LinkedHashMap getLinkedHashMap(int size) {
		return new LinkedHashMap(size);
	}

	/**
	 * 获得Map实例 实现类是LinkedHashMap
	 * @param map 初始化的Map
	 * @return Map
	 */
	public static  LinkedHashMap getLinkedHashMap(Map map) {
		return new LinkedHashMap(map);
	}

	/**
	 * 获得同步的Map实例 实现类是HashMap 默认初始化大小为10
	 * @return Map
	 */
	public static  Map getSynchronizedMap() {
		return getSynchronizedMap(10);
	}

	/**
	 * 获得同步的Map实例 实现类是HashMap
	 * @param size 初始化大小
	 * @return Map
	 */
	public static  Map getSynchronizedMap(int size) {
		return Collections.synchronizedMap(new HashMap(size));
	}

	/**
	 * 获得同步的Map实例 实现类是HashMap
	 * @param map 初始化的Map
	 * @return Map
	 */
	public static  Map getSynchronizedMap(Map map) {
		return Collections.synchronizedMap(new HashMap(map));
	}

	/**
	 * 获得同步的Map实例 实现类是ConcurrentHashMap 默认初始化大小为10
	 * @return Map
	 */
	public static  ConcurrentMap getConcurrentMap() {
		return new ConcurrentHashMap();
	}

	/**
	 * 获得同步的Map实例 实现类是ConcurrentHashMap
	 * @param size 初始化大小
	 * @return Map
	 */
	public static  ConcurrentMap getConcurrentMap(int size) {
		return new ConcurrentHashMap(size);
	}

	/**
	 * 获得同步的Map实例 实现类是ConcurrentHashMap
	 * @param map 初始化的Map
	 * @return Map
	 */
	public static  ConcurrentMap getConcurrentMap(Map map) {
		return new ConcurrentHashMap(map);
	}

	/**
	 * 获得一个不可变的空Map
	 * @return 一个不可变的空Map
	 */
	public static  Map emptyMap() {
		return Collections.emptyMap();
	}

	/**
	 * 获得列表数量
	 * @param map 数据列表
	 * @return 数量
	 */
	public static int size(Map map) {
		return EmptyUtil.isEmpty(map) ? 0 : map.size();
	}

	/**
	 * 私有构造 禁止外部实例化
	 */
	private Maps() {}
}