ArrayList 转为 LinkedHashMap 代码实现

可以使用以下代码实现ArrayList转为LinkedHashMap：

List<String> list = new ArrayList<String>();
list.add("key1=value1");
list.add("key2=value2");
list.add("key3=value3");
Map<String, String> map = new LinkedHashMap<String, String>();
for (String s : list) {
    String[] keyValue = s.split("=");
    map.put(keyValue[0], keyValue[1]);
}

这段代码首先创建了一个ArrayList对象，并向其中添加了几个键值对。然后创建了一个LinkedHashMap对象，使用for循环遍历ArrayList中的元素，将每个元素按照"="分割，拆分成键值对并加入到LinkedHashMap中。最终，LinkedHashMap对象就包含了与ArrayList对象中相同的键值对数据。

相关问题

List<LinkedHashMap<String, Object>> 转为List<Map<String, String>>

将 `List<LinkedHashMap<String, Object>>` 转换为 `List<Map<String, String>>` 的过程通常需要遍历原列表，并对每个 `LinkedHashMap` 对象进行检查和转换。因为 `LinkedHashMap` 可能包含非字符串键值对，所以你需要确保每个键都是 `String` 类型并且对应的值也是 `String` 类型。

这是一个示例步骤：

1. 创建一个新的空列表，用于存放转换后的 `Map<String, String>` 实例。
2. 遍历原始 `List<LinkedHashMap<String, Object>>` 中的每个元素。
3. 对于每个 `LinkedHashMap`，创建一个新的 `Map<String, String>`，并只保留那些键和值都是字符串的条目。
4. 将新的 `Map<String, String>` 添加到新列表中。
5. 遍历结束后，返回新的 `List<Map<String, String>>`。

以下是伪代码形式的转换：

List<Map<String, String>> newList = new ArrayList<>();
for (LinkedHashMap<String, Object> map : oldList) {
    Map<String, String> tempMap = new HashMap<>();
    for (Map.Entry<String, Object> entry : map.entrySet()) {
        if (entry.getKey().getClass() == String.class && entry.getValue().getClass() == String.class) {
            tempMap.put((String) entry.getKey(), (String) entry.getValue());
        }
    }
    if (!tempMap.isEmpty()) { // 如果转换后有内容才添加
        newList.add(tempMap);
    }
}

将以下javascript函数转为Java代码 function objKeySort(e) { var t = Object.keys(e).sort(function(a, b) { return a.toString().toUpperCase() > b.toString().toUpperCase() ? 1 : a.toString().toUpperCase() === b.toString().toUpperCase() ? 0 : -1; }); var a = {}; for (var n = 0; n < t.length; n++) { a[t[n]] = e[t[n]]; } return a; }

将给定的JavaScript函数转换为Java代码如下：

import java.util.*;

public class SortObjectKeys {
    public static Map<String, Object> objKeySort(Map<String, Object> e) {
        List<String> keys = new ArrayList<>(e.keySet());
        Collections.sort(keys, new Comparator<String>() {
            @Override
            public int compare(String a, String b) {
                return a.toString().toUpperCase().compareTo(b.toString().toUpperCase());
            }
        });

        Map<String, Object> a = new LinkedHashMap<>();
        for (String key : keys) {
            a.put(key, e.get(key));
        }

        return a;
    }
}

在上述Java代码中，我们创建了一个名为`SortObjectKeys`的类。该类包含了一个名为`objKeySort`的静态方法，它接受一个`Map<String, Object>`作为参数，并返回按键排序后的新`Map`对象。

在方法内部，我们首先将原始`Map`对象的键提取为一个列表，并使用`Collections.sort`方法对键进行排序。排序时，我们使用了一个自定义的比较器，根据键的字母顺序（忽略大小写）进行比较。

然后，我们创建一个新的有序`Map`对象`a`，并通过遍历排序后的键列表，将原始`Map`对象中对应键的值复制到新的`Map`对象中。

最后，我们将新的有序`Map`对象`a`作为结果返回。请注意，在Java中，我们使用`LinkedHashMap`来保持键的顺序。