将参数数组转换为HashMap [关闭]

Question

我有一个字符串数组，就像：

String [] paramEnv = {"key1=value1","key2=value2","key2=value2"};

现在，我需要将其转换为HashMap。

我为此写了两种方法，我想知道哪种方法在效率上更好。

方法1：

String param = "";
String paramName = "";
String paramValue = "";
if ((null != paramEnv) && (paramEnv.length > 0)) {
        for (int i = 0; i < paramEnv.length; i++) {
            param = paramEnv[i];
            int indexOfEqualTo = param.indexOf("=");
            paramName = param.substring(0, indexOfEqualTo);
            paramValue = param.substring(indexOfEqualTo + 1);
            hmKeyValFromParamEnv.put(paramName, paramValue);
        }
    }
    return hmKeyValFromParamEnv;

方法2：

String param = "";
String paramName = "";
String paramValue = "";
if ((null != paramEnv) && (paramEnv.length > 0)) {
        for (int i = 0; i < paramEnv.length; i++) {
            param = paramEnv[i];
            paramName = (param.split("="))[0];
            paramValue = (param.split("="))[1];
            hmKeyValFromParamEnv.put(paramName, paramValue);
        }
    }
    return hmKeyValFromParamEnv;

也请让我知道更好的实现方法。

Answer 1

如果可以使用Java 8

public class ArrayToMap {

    public static void main(String[] args) {
        String[] arr = new String[]{"key1=value1","key2=value2"};

    Arrays.stream(arr)
            .map(s -> s.split("="))
            .collect(Collectors.toMap(sa -> sa[0], sb -> sb[1], (v1, v2)->v1));
    }
}

• 从数组制作流
• 将每个数组elementy映射到两个元素数组（拆分）
• 使用自定义合并功能将其收集以映射

//编辑：

添加重复项消除。 这只是一个例子。 您应该制定自己的策略以消除重复（如果需要一些特定的）。

//编辑2：@ZouZou发表评论后，将隐式更改为使用自定义合并功能

//编辑3：如果您无法使用Java 8，请使用guava：

class KeyEntry<K, V> implements Map.Entry<K, V> {
    @Override
    public boolean equals(Object o) {
        if (this == o) {
            return true;
        }
        if (!(o instanceof KeyEntry)) {
            return false;
        }

        KeyEntry keyEntry = (KeyEntry) o;

        if (!key.equals(keyEntry.key)) {
            return false;
        }

        return true;
    }

    @Override
    public String toString() {
        return "{\"KeyEntry\":{" +
                "\"key\": \"" + key + "\"" +
                ", \"value\": \"" + value + "\"" +
                "}}";
    }

    @Override
    public int hashCode() {
        return key.hashCode();
    }

    KeyEntry(K key, V value) {
        this.key = key;
        this.value = value;
    }

    @Override
    public K getKey() {
        return key;
    }

    @Override
    public V getValue() {
        return value;
    }

    @Override
    public V setValue(V value) {
        throw new UnsupportedOperationException("NO!");
    }

    private final K key;
    private final V value;


}

因为常见的Entry暗示使用键和值equals我们需要自定义类。

然后我们可以创建如下内容：

    Map<String, String> m = new HashMap<>();
    ImmutableSet<Map.Entry<String, String>> uniqueKey = FluentIterable.from(new ArrayList<String>(Arrays.asList(arr)))
            .transform(new Function<String, Map.Entry<String, String>>() {
                @Override
                public Map.Entry<String, String> apply(String s) {
                    String[] splited = s.split("=");
                    return new KeyEntry(splited[0], splited[1]) {
                    };
                }
            }).toSet();

    for (Map.Entry<String, String> s : uniqueKey) {
        m.put(s.getKey(), s.getValue());
        System.out.println(s);
    }

• 将每个元素转换为我们的KeyEntry
• Set
• 重写到Map

Answer 2

两者都具有O（n）复杂度。 要使速度有显着差异，您将需要非常大的paramEnv数组。

正如评论者所指出的，您可以通过将split的两个参数存储在数组中，然后将它们放入map中来对其进行优化。 尚不清楚这样做是否会显着提高速度（我想您可能不会获得那么快的速度）。

Answer 3

我将采用第一个实现，因为子字符串比基于模式匹配和此处所述的split更快，更高效（只需遍历字符直到找到等于symbol的字符）。