指定组批量写入字符串
@param groupName 缓存组
@param keyValueMap
@return
962232
public static boolean setStringsWithGroup(String groupName,Map<String, Object> keyValueMap){
		if(keyValueMap == null || keyValueMap.isEmpty())return false;
		String[] keysValues = new String[keyValueMap.size() * 2];
		int index = 0;
		for (String key : keyValueMap.keySet()) {
			if(keyValueMap.get(key) == null)continue;
			keysValues[index++] = key;
			keysValues[index++] = keyValueMap.get(key).toString();
		}
		try {			
			if(JedisProviderFactory.isCluster(groupName)){
				return JedisProviderFactory.getMultiKeyJedisClusterCommands(groupName).mset(keysValues).equals(RESP_OK);
			}else{
				return JedisProviderFactory.getMultiKeyCommands(groupName).mset(keysValues).equals(RESP_OK);
			}
		} finally {
			JedisProviderFactory.getJedisProvider(groupName).release();
		}
	}
515432
public GroupedMap putAll(String group, Map<? extends String, ? extends String> m) {
		for (Entry<? extends String, ? extends String> entry : m.entrySet()) {
			this.put(group, entry.getKey(), entry.getValue());
		}
		return this;
	}
688828
private static Map<String, Object> convertLogicalMap(Group g, boolean binaryAsString)
  {
    /*
      // Map<String, Integer> (nullable map, non-null values)
      optional group my_map (MAP) {
        repeated group map {
          required binary str (UTF8);
          required int32 num;
        }
      }

      // Map<String, Integer> (nullable map, nullable values)
      optional group my_map (MAP_KEY_VALUE) {(
        repeated group map {
          required binary key (UTF8);
          optional int32 value;
        }
      }
     */
    assert isLogicalMapType(g.getType());
    int mapEntries = g.getFieldRepetitionCount(0);
    Map<String, Object> converted = new HashMap<>();
    for (int i = 0; i < mapEntries; i++) {
      Group mapEntry = g.getGroup(0, i);
      String key = convertPrimitiveField(mapEntry, 0, binaryAsString).toString();
      Object value = convertField(mapEntry, "value", binaryAsString);
      converted.put(key, value);
    }
    return converted;
  }
1175523
public Setting set(String group, String key, String value) {
		this.put(group, key, value);
		return this;
	}
865998
public boolean hasGroup(String groupName) {
        boolean result = false;
        for (Group item : getGroupsList()) {
            if (item.getName().equals(groupName)) {
                result = true;
            }
        }
        return result;
    }
1200884
public static <T> T getValue(Map<String, Object> map, String key, Class<T> clazz) {
        return map != null ? ValueUtils.convertValue(map.get(key), clazz) : null;
    }
668331
public static <K,V> MultiValueMap<K,V> unmodifiableMultiValueMap(MultiValueMap<? extends K, ? extends V> map) {
		Assert.notNull(map, "'map' must not be null");
		Map<K, List<V>> result = new LinkedHashMap<K, List<V>>(map.size());
		for (Map.Entry<? extends K, ? extends List<? extends V>> entry : map.entrySet()) {
			List<V> values = Collections.unmodifiableList(entry.getValue());
			result.put(entry.getKey(), values);
		}
		Map<K, List<V>> unmodifiableMap = Collections.unmodifiableMap(result);
		return toMultiValueMap(unmodifiableMap);
	}
1038828
public GroupedMap clear(String group) {
		group = StrUtil.nullToEmpty(group).trim();
		writeLock.lock();
		try {
			final LinkedHashMap<String, String> valueMap = this.get(group);
			if (MapUtil.isNotEmpty(valueMap)) {
				valueMap.clear();
			}
		} finally {
			writeLock.unlock();
		}
		return this;
	}
1332480
public String remove(String group, String key) {
		group = StrUtil.nullToEmpty(group).trim();
		writeLock.lock();
		try {
			final LinkedHashMap<String, String> valueMap = this.get(group);
			if (MapUtil.isNotEmpty(valueMap)) {
				return valueMap.remove(key);
			}
		} finally {
			writeLock.unlock();
		}
		return null;
	}
132603
@Override
	public CPOptionValue fetchCPOptionValueByUuidAndGroupId(String uuid,
		long groupId) {
		return cpOptionValuePersistence.fetchByUUID_G(uuid, groupId);
	}
1059660
public static <K, V> KeyValueSink<K, V> asMapSink(ImmutableMultimap.Builder<K, V> multimapB) {
    return new ImmutableMultimapBuilderSink<>(multimapB);
  }
56831
public static <K, V> MultiValueMap<K, V> toMultiValueMap(Map<K, List<V>> map) {
		return new MultiValueMapAdapter<K, V>(map);

	}
457813
public static String resolve(
            final Map<String, Map<String, String>> data, final String group,
            final String key
    )
    {
        return resolve(data, group, key, null);
    }
364745
public Response deleteGroup(String groupName) {
		return restClient.delete("groups/" + groupName, new HashMap<String, String>());
	}
1119162
public static <T, K, V, P, C extends Collection<V>> HashMap<K, HashMap<P, C>> groupTwice(
			Collection<T> entities, Function<T, K> keyMapper1,
			Function<T, P> keyMapper2, Function<T, V> valueMapper,
			Supplier<C> collectionFactory) {
		if (entities == null)
			return null;
		return entities.stream().collect(
				Collectors.groupingBy(keyMapper1, HashMap::new, Collectors
						.groupingBy(keyMapper2, HashMap::new, Collectors
								.mapping(valueMapper, Collectors
										.toCollection(collectionFactory)))));
	}
733216
@SuppressWarnings("unchecked")
    public Map<String,String> getMap(String name) {
        Map<String,String> map = null;
        Map<String,Object> groupMap = (Map<String,Object>)get(name, PropType.group);
        if (groupMap != null) {
            map = new HashMap<>();
            for (String groupKey : groupMap.keySet()) {
                String value = decryptValue(groupMap.get(groupKey).toString());
                map.put(groupKey.substring(name.length() + 1), value);
            }
        }
        return map;
    }
537054
public static SortedMap<Short, List<MappeableContainer>> groupByKey(
          ImmutableRoaringBitmap... bitmaps) {
    Map<Short, List<MappeableContainer>> grouped = new HashMap<>();
    for (ImmutableRoaringBitmap bitmap : bitmaps) {
      MappeableContainerPointer it = bitmap.highLowContainer.getContainerPointer();
      while (null != it.getContainer()) {
        MappeableContainer container = it.getContainer();
        Short key = it.key();
        List<MappeableContainer> slice = grouped.get(key);
        if (null == slice) {
          slice = new ArrayList<>();
          grouped.put(key, slice);
        }
        slice.add(container);
        it.advance();
      }
    }
    SortedMap<Short, List<MappeableContainer>> sorted = new TreeMap<>(BufferUtil::compareUnsigned);
    sorted.putAll(grouped);
    return sorted;
  }