com.github.andyshao.util.MapOperation Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of Gear Show documentation
Enhance and formating the coding of JDK
The newest version!
package com.github.andyshao.util;

import com.github.andyshao.lang.Convert;
import com.github.andyshao.lang.StringOperation;
import com.github.andyshao.util.stream.Pair;

import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
import java.util.Optional;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import java.util.function.Supplier;

/**
 * 
 * Title:

 * Descript:

 * Copyright: Copryright(c) Apr 26, 2018

 * Encoding:UNIX UTF-8
 * @author Andy.Shao
 *
 */
public final class MapOperation {
    private MapOperation() {
    }

	/**
	 * of operation
	 * @param map {@link Map}
	 * @param key key
	 * @param value value
	 * @return origin {@link Map}
	 */
	@SuppressWarnings({"rawtypes", "unchecked"})
	public static Map of(Map map, Object key, Object value){
		map.put(key, value);
		return map;
	}

	/**
	 * is empty or null
	 * @param map {@link Map}
	 * @return if it is then true
	 * @param  key type
	 * @param  value type
	 */
    public static final  boolean isEmptyOrNull(Map map) {
        return map == null || map.isEmpty();
    }

	/**
	 * convert map
	 * @param convert key & value {@link Convert}
	 * @param suplier {@link Map} factory
	 * @return the {@link Map}
	 * @param  origin key type
	 * @param  new key type
	 * @param  origin value type
	 * @param  new value type
	 * @param  new {@link Map} type
	 */
    public static final > Convert, R> convertMap(
    		Convert, Optional>> convert, 
    		Supplier suplier) {
    	return origin -> {
    		R ret = suplier.get();
    		origin.forEach((k, v) -> {
    			Optional> converted = convert.convert(Pair.of(k, v));
    			if(converted.isPresent()) {
    				Pair pair = converted.get();
    				ret.put(pair.getFirst(), pair.getSecond());
    			}
    		});
			return ret;
    	};
    }

	/**
	 * convert map
	 * @param convert key & value {@link Convert}
	 * @return new {@link Map}
	 * @param  origin key type
	 * @param  new key type
	 * @param  origin value type
	 * @param  new value type
	 */
    public static final  Convert, Map> convertMap(
    		Convert, Optional>> convert) {
    	return convertMap(convert, HashMap::new);
    }

	/**
	 * convert {@link ConcurrentMap}
	 * @param convert key & value {@link Convert}
	 * @return new {@link Map}
	 * @param  origin key type
	 * @param  new key type
	 * @param  origin value type
	 * @param  new value type
	 */
    public static final  Convert, ConcurrentMap> convertConcurrentMap(
    		Convert, Optional>> convert) {
    	return convertMap(convert, ConcurrentHashMap::new);
    }

	/**
	 * wrap {@link Map}
	 * @param supplier {@link Map} factory
	 * @param valStr value string
	 * @param convert key & value {@link Convert}
	 * @return a new {@link Map}
	 * @param  new key type
	 * @param  origin value type
	 * @param  new {@link Map} type
	 */
    public static final > R wrapMap(
    		Supplier supplier, 
    		String valStr, 
    		Convert, Optional>> convert) {
    	final R result = supplier.get();
    	Arrays.stream(valStr.split(","))
    		.filter(it -> !StringOperation.isEmptyOrNull(it))
    		.forEach(it -> {
    			String[] items = it.split(":");
    			Optional> op = Optional.empty();
    			switch(items.length) {
    			case 1:
    				op = convert.convert(Pair.of(items[0].trim(), null));
    				break;
    			case 2:
    				op = convert.convert(Pair.of(items[0].trim(), items[1].trim()));
    				break;
    		    default:
    		    	break;
    			}
    			if(op.isPresent()) {
    				Pair pair = op.get();
    				result.put(pair.getFirst(), pair.getSecond());
    			}
    		});

		return result;
    }

	/**
	 * wrap {@link Map}
	 * @param valStr value string
	 * @param convert key & value {@link Convert}
	 * @return new {@link Map}
	 * @param  key type
	 * @param  value type
	 */
    public static final  Map wrapMap(
    		String valStr, 
    		Convert, Optional>> convert) {
    	return wrapMap(HashMap::new, valStr, convert);
    }

	/**
	 * wrap {@link ConcurrentMap}
	 * @param valStr value string
	 * @param convert key & value {@link Convert}
	 * @return new {@link ConcurrentMap}
	 * @param  key type
	 * @param  value type
	 */
    public static final  ConcurrentMap wrapConcurrentMap(
    		String valStr, 
    		Convert, Optional>> convert) {
    	return wrapMap(ConcurrentHashMap::new, valStr, convert);
    }

	/**
	 * wrap {@link Map}
	 * @param valStr value string
	 * @return {@link Map}
	 */
	public static final Map wrapMap(String valStr) {
    	return wrapMap(valStr, input -> Optional.of(Pair.of(input.getFirst(), input.getSecond())));
    }

	/**
	 * wrap string map
	 * @param valStr value string
	 * @return {@link Map}
	 */
	public static final Map wrapStringMap(String valStr) {
    	return wrapMap(valStr, input -> Optional.of(Pair.of(input.getFirst(), input.getSecond())));
    }
}