Java CollectionUtil类代码示例

import org.febit.util.CollectionUtil; //导入依赖的package包/类
public Map<String, String> createDictMap(GeoLite2CsvDict dict) {
    Map<String, String> result = CollectionUtil.createMap(this.map.size());
    for (IntMap.Entry<DictEntry> entry : this.map) {
        DictEntry keyEntry = entry.getValue();
        DictEntry valueEntry = dict.get(keyEntry.geoId);
        if (valueEntry == null) {
            continue;
        }
        result.put(keyEntry.countryCode, valueEntry.countryCode);
        result.put(keyEntry.country, valueEntry.country);
        result.put(keyEntry.province, valueEntry.province);
        result.put(keyEntry.city, valueEntry.city);
        result.put(LocationUtil.fixProvince(keyEntry.province), valueEntry.province);
        result.put(LocationUtil.fixCity(keyEntry.city), valueEntry.city);
        result.put(StringUtil.cutSuffix(StringUtil.cutSuffix(keyEntry.city, "市"), "县"), valueEntry.city);
    }
    return result;
}
 

import org.febit.util.CollectionUtil; //导入依赖的package包/类
protected void initRoot() throws IOException {

        GlobalManager globalManager = this.templateEngine.getGlobalManager();
        globalManager.setConst("DEBUG", debug);
        globalManager.setConst("basePkg", basePkg);
        globalManager.setConst("modelPkg", modelPkg);
        globalManager.setConst("modelPrefix", modelPrefix);

        globalManager.setConst("db", config.extract("db."));

        globalManager.setConst("depends", depends);
        globalManager.setConst("testDepends", testDepends);
        globalManager.setConst("providedDepends", providedDepends);

        for (Map.Entry<String, String> entry : config.extract("extra.").entrySet()) {
            globalManager.setConst(entry.getKey(), entry.getValue());
        }

        this.tableList = tableFactory.getTables();
        this.whiteTables = CollectionUtil.toIter(this.tableList)
                .filter((Table table) -> !table.isBlackEntity)
                .readList();

        globalManager.setConst("tables", this.tableList);
    }
 

import org.febit.util.CollectionUtil; //导入依赖的package包/类
@SuppressWarnings("unchecked")
public static Map<String, String> getParamStringMap(HttpServletRequest request) {
    Map<String, Object> map = request.getParameterMap();

    boolean encode = "GET".equalsIgnoreCase(request.getMethod());
    Map<String, String> ret = CollectionUtil.createMap(map.size());
    for (Map.Entry<String, Object> entrySet : map.entrySet()) {
        Object value = entrySet.getValue();
        if (value == null) {
            continue;
        }
        if (value instanceof String[]) {
            String[] arr = (String[]) value;
            if (arr.length == 0) {
                continue;
            }
            value = arr[0];
        }
        if (encode) {
            try {
                ret.put(entrySet.getKey(), new String(value.toString().getBytes("ISO-8859-1"), "UTF-8"));
            } catch (UnsupportedEncodingException ignore) {
                ret.put(entrySet.getKey(), value.toString());
            }
        } else {
            ret.put(entrySet.getKey(), value.toString());
        }
    }
    return ret;
}
 

import org.febit.util.CollectionUtil; //导入依赖的package包/类
@SuppressWarnings("unchecked")
public Iter<String> getParameterNames() {
    Enumeration<String> paramNames = this.request.getParameterNames();
    if (macroParams.isEmpty()) {
        return CollectionUtil.toIter(paramNames);
    }
    return CollectionUtil.concat(
            macroParams.keySet().iterator(),
            CollectionUtil.toIter(paramNames)
                    .filter(name -> !macroParams.containsKey(name))
    );
}
 

import org.febit.util.CollectionUtil; //导入依赖的package包/类
public static Map<String, Object> modifyMap(BaseFormImpl form, int profile) {
    Peer[] peers = getPeers(form, false, profile);
    if (peers.length == 0) {
        return Collections.emptyMap();
    }
    Map<String, Object> ret = CollectionUtil.createHashMap(profile);
    for (int i = 0, len = peers.length; i < len; i++) {
        Peer peer = peers[i];
        ret.put(peer.name, peer.from.get(form));
    }
    return ret;
}
 

import org.febit.util.CollectionUtil; //导入依赖的package包/类
public static Map<String, Setter> resolveSetters(Class cls) {
    final FieldInfo[] fieldInfos = FieldInfoResolver.resolve(cls);
    final Map<String, Setter> map = CollectionUtil.createMap(fieldInfos.length);
    for (FieldInfo fieldInfo : fieldInfos) {
        Setter setter = createSetterIfAccessable(fieldInfo);
        if (setter != null) {
            map.put(fieldInfo.name, setter);
        }
    }
    return map;
}
 

import org.febit.util.CollectionUtil; //导入依赖的package包/类
static Map<String, Accessor> resolveAccessors(Class cls) {
    final FieldInfo[] fieldInfos = FieldInfoResolver.resolve(cls);
    final Map<String, Accessor> map = CollectionUtil.createMap(fieldInfos.length);
    for (FieldInfo fieldInfo : fieldInfos) {
        map.put(fieldInfo.name, createAccessor(fieldInfo));
    }
    return map;
}
 

import org.febit.util.CollectionUtil; //导入依赖的package包/类
@SuppressWarnings("unchecked")
public static Map<String, Map<String, Entity>> resolveLinks(Collection<?> rows, Class type) {
    if (rows == null || rows.isEmpty()) {
        return null;
    }
    ArangoLinkInfo[] infos = LINKS_CACHING.unsafeGet(type);
    if (infos == null) {
        infos = collectInfosIfAbsent(type);
    }
    if (infos.length == 0) {
        return null;
    }
    final Map<String, Map<String, Entity>> ret = CollectionUtil.createMap(infos.length);

    final HashSet<String> ids = new HashSet<>(rows.size());
    for (ArangoLinkInfo info : infos) {

        //collect ids
        ids.clear();
        final Field field = info.field;
        for (Object row : rows) {
            try {
                String id = (String) field.get(row);
                if (id != null) {
                    ids.add(id);
                }
            } catch (IllegalArgumentException | IllegalAccessException ex) {
                throw new RuntimeException(ex);
            }
        }
        if (ids.isEmpty()) {
            continue;
        }

        //fetch entitys
        Map<String, Entity> map = CollectionUtil.createMap(ids.size());
        Map<String, Object> vars = new HashMap<>(4);
        vars.put("keys", ids);
        ArangoCursor<Entity> iterator = info.dao.cursor(
                "FOR d in " + info.dao.getTableName() + ""
                + " FILTER d._key in @keys "
                + " RETURN d",
                vars, null, info.linkType);

        while (iterator.hasNext()) {
            Entity next = iterator.next();
            map.put(next.id(), next);
        }
        ret.put(info.name, map);
    }

    return ret;
}
 

import org.febit.util.CollectionUtil; //导入依赖的package包/类
@Override
public <T> Iter<T> map(final Function1<T, E> func) {
    return CollectionUtil.map(this, func);
}
 

import org.febit.util.CollectionUtil; //导入依赖的package包/类
@Override
public <T> Iter<T> flatMap(final Function1<Iterator<T>, E> func) {
    return CollectionUtil.flatMap(this, func);
}
 

import org.febit.util.CollectionUtil; //导入依赖的package包/类
@Override
public Iter<E> filter(final Predicate<E> valid) {
    return CollectionUtil.filter(this, valid);
}
 

import org.febit.util.CollectionUtil; //导入依赖的package包/类
@Override
public Iter<E> excludeNull() {
    return CollectionUtil.excludeNull(this);
}
 

import org.febit.util.CollectionUtil; //导入依赖的package包/类
@Override
public List<E> readList() {
    return CollectionUtil.read(this);
}