Java 如何在HashMap中获取已排序的arrayList？

我已经尝试了以下java代码。但是我不能得到正确的输出

publicstaticvoidmain（字符串[]args）引发IOException
{
ArrayList结果=新建ArrayList（）；
列表=新的ArrayList（）；
添加（新的ArrayList（Arrays.asList（“a”）））；
添加（新的ArrayList（Arrays.asList（“a，b，c”））；
添加（新的ArrayList（Arrays.asList（“a，c”））；
添加（新的ArrayList（Arrays.asList（“c”））；
添加（新的ArrayList（Arrays.asList（“b，d”））；
添加（新的ArrayList（Arrays.asList（“b”）））；
ArrayList值=新的ArrayList（）；
增值（1）；
增值（5）；
增值（3）；
增值（4）；
增值（2）；
增值（1）；
HashMap=newHashMap（）；
对于（int i=0；i您可以使用以下排序：

public static void main(String[] args) throws IOException {
    ArrayList<HashMap<ArrayList<String>, Integer>> result = new ArrayList<>();

    List<ArrayList<String>> list = new ArrayList<>();
    list.add(new ArrayList<>(Arrays.asList("a")));
    list.add(new ArrayList<>(Arrays.asList("a,b,c")));
    list.add(new ArrayList<>(Arrays.asList("a,c")));
    list.add(new ArrayList<>(Arrays.asList("c")));
    list.add(new ArrayList<>(Arrays.asList("b,d")));
    list.add(new ArrayList<>(Arrays.asList("b")));

    List<Integer> value = new ArrayList<>();
    value.add(1);
    value.add(5);
    value.add(3);
    value.add(4);
    value.add(2);
    value.add(1);

    HashMap<ArrayList<String>, Integer> map = new HashMap<>();
    for (int i = 0; i < list.size(); i++) {
        map.put(list.get(i), value.get(i));
    }
    Map<ArrayList<String>, Integer> sorted = map.entrySet()
            .stream()
            .sorted((Map.Entry.<ArrayList<String>, Integer>comparingByValue()))
            .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, (e1, e2) -> e1, LinkedHashMap::new));

    System.out.println(map);//output : [{[a]=1, [a,b,c]=5, [b]=1, [c]=4, [a,c]=3, [b,d]=2}]
    System.out.println(sorted);//output : {[a]=1, [b]=1, [b,d]=2, [a,c]=3, [c]=4, [a,b,c]=5}
}

publicstaticvoidmain（字符串[]args）引发IOException{
ArrayList结果=新建ArrayList（）；
列表=新的ArrayList（）；
添加（新的ArrayList（Arrays.asList（“a”）））；
添加（新的ArrayList（Arrays.asList（“a，b，c”））；
添加（新的ArrayList（Arrays.asList（“a，c”））；
添加（新的ArrayList（Arrays.asList（“c”））；
添加（新的ArrayList（Arrays.asList（“b，d”））；
添加（新的ArrayList（Arrays.asList（“b”）））；
列表值=新的ArrayList（）；
增值（1）；
增值（5）；
增值（3）；
增值（4）；
增值（2）；
增值（1）；
HashMap=newHashMap（）；
对于（int i=0；ie1，LinkedHashMap:：new））；
System.out.println（map）；//输出：[{[a]=1[a，b，c]=5[b]=1[c]=4[a，c]=3[b，d]=2}]
System.out.println（排序）；//输出：{[a]=1[b]=1[b，d]=2[a，c]=3[c]=4[a，b，c]=5}
}
您可以使用以下排序：

public static void main(String[] args) throws IOException {
    ArrayList<HashMap<ArrayList<String>, Integer>> result = new ArrayList<>();

    List<ArrayList<String>> list = new ArrayList<>();
    list.add(new ArrayList<>(Arrays.asList("a")));
    list.add(new ArrayList<>(Arrays.asList("a,b,c")));
    list.add(new ArrayList<>(Arrays.asList("a,c")));
    list.add(new ArrayList<>(Arrays.asList("c")));
    list.add(new ArrayList<>(Arrays.asList("b,d")));
    list.add(new ArrayList<>(Arrays.asList("b")));

    List<Integer> value = new ArrayList<>();
    value.add(1);
    value.add(5);
    value.add(3);
    value.add(4);
    value.add(2);
    value.add(1);

    HashMap<ArrayList<String>, Integer> map = new HashMap<>();
    for (int i = 0; i < list.size(); i++) {
        map.put(list.get(i), value.get(i));
    }
    Map<ArrayList<String>, Integer> sorted = map.entrySet()
            .stream()
            .sorted((Map.Entry.<ArrayList<String>, Integer>comparingByValue()))
            .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, (e1, e2) -> e1, LinkedHashMap::new));

    System.out.println(map);//output : [{[a]=1, [a,b,c]=5, [b]=1, [c]=4, [a,c]=3, [b,d]=2}]
    System.out.println(sorted);//output : {[a]=1, [b]=1, [b,d]=2, [a,c]=3, [c]=4, [a,b,c]=5}
}

publicstaticvoidmain（字符串[]args）引发IOException{
ArrayList结果=新建ArrayList（）；
列表=新的ArrayList（）；
添加（新的ArrayList（Arrays.asList（“a”）））；
添加（新的ArrayList（Arrays.asList（“a，b，c”））；
添加（新的ArrayList（Arrays.asList（“a，c”））；
添加（新的ArrayList（Arrays.asList（“c”））；
添加（新的ArrayList（Arrays.asList（“b，d”））；
添加（新的ArrayList（Arrays.asList（“b”）））；
列表值=新的ArrayList（）；
增值（1）；
增值（5）；
增值（3）；
增值（4）；
增值（2）；
增值（1）；
HashMap=newHashMap（）；
对于（int i=0；ie1，LinkedHashMap:：new））；
System.out.println（map）；//输出：[{[a]=1[a，b，c]=5[b]=1[c]=4[a，c]=3[b，d]=2}]
System.out.println（排序）；//输出：{[a]=1[b]=1[b，d]=2[a，c]=3[c]=4[a，b，c]=5}
}
好的，下面是我认为您需要的：

publicstaticvoidmain（字符串[]args）{
List mapList=new ArrayList（）；
put（mapList，Arrays.asList（“a”），1）；
put（mapList，Arrays.asList（“a”、“b”、“c”），5）；
put（mapList，Arrays.asList（“a”，“c”），3）；
put（mapList，Arrays.asList（“c”），4）；
put（mapList，Arrays.asList（“b”，“d”），2）；
put（mapList，Arrays.asList（“b”），1）；
System.out.println（mapList）；//输出：[{[a]=1[b]=1[c]=4}，{[a，c]=3[b，d]=2}，{[a，b，c]=5}]
}
私有静态void put（列表映射列表、列表字、整数）{
assert！words.isEmpty（）：“列表中必须至少有一个单词”；
//首先，确保我们的地图列表足够长，可以容纳我们要添加的单词列表
while（mapList.size（）

或者，我们可以构造一个包含所有内容的初始
Map
，然后按单词数对其进行分区并对结果集合进行排序。这种方法意味着，如果没有任何特定长度的单词列表，则不会向结果中添加用于保存此类单词列表的空
Map
（在上面的解决方案中，可能是）。此解决方案的代码更难理解-您可能需要阅读以下内容：

publicstaticvoidmain（字符串[]args）{
Map initial=新的HashMap（）；
首字母.put（Arrays.asList（“a”），1）；
首字母.put（Arrays.asList（“a”、“b”、“c”），5）；
首字母.put（Arrays.asList（“a”，“c”），3）；
首字母.put（Arrays.asList（“c”），4）；
首字母.put（Arrays.asList（“b”，“d”），2）；
首字母.put（Arrays.asList（“b”），1）；
首字母.put（数组.asList（“v”、“w”、“x”、“y”、“z”），99）；
列表结果=新建ArrayList(
initial.entrySet（）//获取无序的条目集合
.stream（）
.collect（收集器.groupingBy(
e->e.getKey（）.size（），//按单词列表大小分组。。。
树映射：：新建，//…到已排序的映射中。。。
Collectors.toMap（Map.Entry:：getKey，Map.Entry:：getValue）/…将具有相同字数的所有值收集到各个映射中
))
.values（）//使用映射值的有序集合构造我们的ArrayList
);
System.out.println（result）；//输出：[{[a]=1[b]=1[c]=4}，{[a，c]=3[b，d]=2}，{[a，b，c]=5}，{[v，w，x，y，z]=99}]
//请注意，上面的结果不包含4字列表的空映射（“{}”）
}
好的，下面是我认为您需要的：

publicstaticvoidmain（字符串[]args）{
List mapList=new ArrayList（）；
put（mapList，Arrays.asList（“a”），1）；
放置（地图列表，
public static void main(String[] args) throws IOException {
    ArrayList<HashMap<ArrayList<String>, Integer>> result = new ArrayList<>();

    List<ArrayList<String>> list = new ArrayList<>();
    list.add(new ArrayList<>(Arrays.asList("a")));
    list.add(new ArrayList<>(Arrays.asList("a,b,c")));
    list.add(new ArrayList<>(Arrays.asList("a,c")));
    list.add(new ArrayList<>(Arrays.asList("c")));
    list.add(new ArrayList<>(Arrays.asList("b,d")));
    list.add(new ArrayList<>(Arrays.asList("b")));

    List<Integer> value = new ArrayList<>();
    value.add(1);
    value.add(5);
    value.add(3);
    value.add(4);
    value.add(2);
    value.add(1);

    HashMap<ArrayList<String>, Integer> map = new HashMap<>();
    for (int i = 0; i < list.size(); i++) {
        map.put(list.get(i), value.get(i));
    }
    Map<ArrayList<String>, Integer> sorted = map.entrySet()
            .stream()
            .sorted((Map.Entry.<ArrayList<String>, Integer>comparingByValue()))
            .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, (e1, e2) -> e1, LinkedHashMap::new));

    System.out.println(map);//output : [{[a]=1, [a,b,c]=5, [b]=1, [c]=4, [a,c]=3, [b,d]=2}]
    System.out.println(sorted);//output : {[a]=1, [b]=1, [b,d]=2, [a,c]=3, [c]=4, [a,b,c]=5}
}

List<List<String>> list = Arrays.asList(
        Arrays.asList("a"),
        Arrays.asList("a", "b", "c"),
        Arrays.asList("a", "c"),
        Arrays.asList("c"),
        Arrays.asList("b", "d"),
        Arrays.asList("b"));

List<Integer> value = Arrays.asList(1, 5, 3, 4, 2, 1);

Comparator<List<String>> comparator = Comparator.<List<String>>comparingInt(List::size)
        .thenComparing(List::hashCode);
TreeMap<List<String>, Integer> map = new TreeMap<>(comparator);
for (int i = 0; i < list.size(); i++) {
    map.put(list.get(i), value.get(i));
}

{[a]=1, [b]=1, [c]=4, [a, c]=3, [b, d]=2, [a, b, c]=5}