How to use

isNotEmpty

method

in

com.y3tu.tool.core.map.MapUtil

@Override
public void destroy() {
  if (MapUtil.isNotEmpty(dsMap)) {
    Collection<HikariDataSource> values = dsMap.values();
    for (HikariDataSource ds : values) {
      IOUtil.close(ds);
    }
    dsMap.clear();
  }
}

@Override
public void destroy() {
  if (MapUtil.isNotEmpty(dsMap)) {
    Collection<DruidDataSource> values = dsMap.values();
    for (DruidDataSource dds : values) {
      IOUtil.close(dds);
    }
    dsMap.clear();
  }
}

@Override
public void destroy() {
  if(MapUtil.isNotEmpty(dsMap)){
    Collection<SimpleDataSource> values = dsMap.values();
    for (SimpleDataSource ds : values) {
      IOUtil.close(ds);
    }
    dsMap.clear();
  }
}

@Override
public void destroy() {
  if (MapUtil.isNotEmpty(dsMap)) {
    Collection<BasicDataSource> values = dsMap.values();
    for (BasicDataSource ds : values) {
      IOUtil.close(ds);
    }
    dsMap.clear();
  }
}

@Override
public void destroy() {
  if (MapUtil.isNotEmpty(dsMap)) {
    Collection<ComboPooledDataSource> values = dsMap.values();
    for (ComboPooledDataSource ds : values) {
      ds.close();
    }
    dsMap.clear();
  }
}

@Override
public void destroy() {
  if (MapUtil.isNotEmpty(dsMap)) {
    Collection<DataSource> values = dsMap.values();
    for (DataSource ds : values) {
      if (null != ds) {
        ds.close();
      }
    }
    dsMap.clear();
  }
}

  /**
   * 关闭全部连接
   */
  public static void closeAll() {
    if (MapUtil.isNotEmpty(dsMap)) {
      for (MongoDS ds : dsMap.values()) {
        ds.close();
      }
      dsMap.clear();
    }
  }
}

@Override
public void destroy() {
  if(MapUtil.isNotEmpty(dsMap)){
    Collection<PooledDataSource> values = dsMap.values();
    for (PooledDataSource ds : values) {
      IOUtil.close(ds);
    }
    dsMap.clear();
  }
}

/**
 * 指定分组下所有值
 *
 * @param group 分组
 * @return 值
 */
public Collection<String> values(String group) {
  group = StringUtils.nullToEmpty(group).trim();
  final LinkedHashMap<String, String> valueMap = this.get(group);
  if (MapUtil.isNotEmpty(valueMap)) {
    return valueMap.values();
  }
  return Collections.emptyList();
}

/**
 * 指定分组所有键的Set
 *
 * @param group 分组
 * @return 键Set
 */
public Set<String> keySet(String group) {
  group = StringUtils.nullToEmpty(group).trim();
  final LinkedHashMap<String, String> valueMap = this.get(group);
  if (MapUtil.isNotEmpty(valueMap)) {
    valueMap.keySet();
  }
  return Collections.emptySet();
}

/**
 * 某个分组对应的键值对是否为空
 *
 * @param group 分组
 * @return 是否为空
 */
public boolean isEmpty(String group) {
  group = StringUtils.nullToEmpty(group).trim();
  final LinkedHashMap<String, String> valueMap = this.get(group);
  if (MapUtil.isNotEmpty(valueMap)) {
    return valueMap.isEmpty();
  }
  return true;
}

  /**
   * 指定分组下所有键值对
   *
   * @param group 分组
   * @return 键值对
   */
  public Set<Entry<String, String>> entrySet(String group) {
    group = StringUtils.nullToEmpty(group).trim();
    final LinkedHashMap<String, String> valueMap = this.get(group);
    if (MapUtil.isNotEmpty(valueMap)) {
      return valueMap.entrySet();
    }
    return Collections.emptySet();
  }
}

/**
 * 清除指定分组下的所有键值对
 *
 * @param group 分组
 * @return this
 */
public GroupedMap clear(String group) {
  group = StringUtils.nullToEmpty(group).trim();
  final LinkedHashMap<String, String> valueMap = this.get(group);
  if (MapUtil.isNotEmpty(valueMap)) {
    valueMap.clear();
  }
  return this;
}

/**
 * 从指定分组中删除指定值
 *
 * @param group 分组
 * @param key   键
 * @return 被删除的值，如果值不存在，返回null
 */
public String remove(String group, String key) {
  group = StringUtils.nullToEmpty(group).trim();
  final LinkedHashMap<String, String> valueMap = this.get(group);
  if (MapUtil.isNotEmpty(valueMap)) {
    return valueMap.remove(key);
  }
  return null;
}

/**
 * 指定分组中是否包含指定key
 *
 * @param group 分组
 * @param key   键
 * @return 是否包含key
 */
public boolean containsKey(String group, String key) {
  group = StringUtils.nullToEmpty(group).trim();
  final LinkedHashMap<String, String> valueMap = this.get(group);
  if (MapUtil.isNotEmpty(valueMap)) {
    return valueMap.containsKey(key);
  }
  return false;
}

/**
 * 获取分组对应的值，如果分组不存在或者值不存在则返回null
 *
 * @param group 分组
 * @param key   键
 * @return 值，如果分组不存在或者值不存在则返回null
 */
public String get(String group, String key) {
  LinkedHashMap<String, String> map = this.get(StringUtils.nullToEmpty(group));
  if (MapUtil.isNotEmpty(map)) {
    return map.get(key);
  }
  return null;
}

/**
 * 指定分组中是否包含指定值
 *
 * @param group 分组
 * @param value 值
 * @return 是否包含值
 */
public boolean containsValue(String group, String value) {
  group = StringUtils.nullToEmpty(group).trim();
  final LinkedHashMap<String, String> valueMap = this.get(group);
  if (MapUtil.isNotEmpty(valueMap)) {
    return valueMap.containsValue(value);
  }
  return false;
}

/**
 * 根据Entity中现有字段条件从数据库中加载一个Entity对象
 * 
 * @return this
 */
public ActiveEntity load() {
  try {
    final Entity result = db.get(this);
    if(MapUtil.isNotEmpty(result)) {
      this.putAll(result);
    }
  } catch (SQLException e) {
    throw new DbRuntimeException(e);
  }
  return this;
}

/**
 * 插入数据<br>
 * 此方法不会关闭Connection
 * 
 * @param conn 数据库连接
 * @param record 记录
 * @param keys 需要检查唯一性的字段
 * @return 插入行数
 * @throws SQLException SQL执行异常
 */
public int insertOrUpdate(Connection conn, Entity record, String... keys) throws SQLException {
  final Entity where = record.filter(keys);
  if(MapUtil.isNotEmpty(where) && count(conn, where) > 0) {
    return update(conn, record, where);
  }else {
    return insert(conn, record);
  }
}