Java HashMap的数组列表排序的不同方法<；字符串，字符串>；

与此相关的问题很多，建议使用

Comparator

对数据进行比较和排序，我已经在尝试并努力使其工作，因此请不要将其报告为重复

我有一个

HashMap

例如

{ {title,link,number = 8}, {title,link,number = 1}, {title,link,number = 3} }

应改为,

{ {title,link,number = 1}, {title,link,number = 3}, {title,link,number = 8} }

我想根据数字进行分类，我试过这个

我创建了一个实现Comparator的新类（正如许多帖子中建议的那样，创建新类来比较数据）

public class SortData implements Comparator<ArrayList<HashMap<String, String>>> 

如何将同一arraylist与下一个值进行比较

更新：

---

每个数组列表元素有三个键/值对，其中一个是数字，我想根据该数字对arraylist进行排序，这意味着，在数组列表中，具有最低数字的键/值对应该排在第一位。

对

映射的
列表进行排序时，您要在其中按键“数字”排序我认为你应该用这个来代替：

    Collections.sort(myList, new Comparator<Map<String, String>>() {
        @Override
        public int compare(final Map<String, String> o1, final Map<String, String> o2) {
            // Do your sorting...
            return Integer.valueOf(o1.get("number"))
                          .compareTo(Integer.valueOf(o2.get("number")));
        }
    });

似乎您误解了比较器的概念。这个类应该提供一种方法来决定集合中的两个元素是否应该交换，所以它主要关注集合的内容

public class SortData implements Comparator<HashMap<String, String>>
//                                          ^^^^^^^^^^^^^^^^^^^^^^^


但是，如果您确定Map将只保存
title
、
link
和
number
的值，那么我将为此结构创建单独的类，如

class Data{//you should also pick better name :)
    private String title;
    private String link;//you can also use URL here instead of String,
    private int number;
    //add getters and setters for each field like
    public int getNumber(){
        return number;
    }
}

这样您的比较器就更简单了

public class SortData implements Comparator<Data>{

    @Override
    public int compare(Data o1, Data o2) {
        return Integer.compare(o1.getNumber(), o2.getNumber());
    }
}

或

将机具更改为比较器，然后使用：

public int compare(HashMap<String, String>> lhs,
        HashMap<String, String>> rhs) {
    return Integer.compare(Integer.parseInt(lhs.get("number")),
        Integer.parseInt(rhs.get("number")));
}

public int compare（HashMap>lhs，
HashMap>rhs）{
返回Integer.compare（Integer.parseInt（lhs.get（“number”）），
整数.parseInt（rhs.get（“number”））；
}

我想你指的是（散列）映射列表。
我强烈建议为这3个变量创建一个数据保存类，并实现该类（你可以创建一个单独的类，实现如图所示的那样，但我发现这更复杂）

实现comparable后，可以使用对列表进行排序

我在这里举了一个简短的例子：

import java.util.*;
import java.lang.*;
import java.io.*;

class Data implements Comparable<Data>
{
    public static void main (String[] args) throws java.lang.Exception
    {
        List<Data> data = new ArrayList<Data>();
        data.add(new Data("Title1", "Link1", 8));
        data.add(new Data("Title2", "Link2", 1));
        data.add(new Data("Title3", "Link3", 3));

        for(Data d : data)
        {
            System.out.print(d.getNumber() + " ");
        }

        System.out.println();

        Collections.sort(data);

        for(Data d : data)
        {
            System.out.print(d.getNumber() + " ");
        }
    }

    private String title;
    private String link;
    private int number;

    public Data(){}
    public Data(String title, String link, int number)
    {
        setTitle(title);
        setLink(link);
        setNumber(number);
    }
    public void setTitle(String title)
    {
        this.title = title;
    }

    public void setLink(String link)
    {
        this.link = link;
    }

    public void setNumber(int number)
    {
        this.number = number;
    }

    public String getTitle()
    {
        return title;
    }

    public String getLink()
    {
        return link;
    }

    public int getNumber()
    {
        return number;
    }

    @Override
    public int compareTo(Data data)
    {
        return this.getNumber() - data.getNumber();
    }
}

您可以在
上尝试，不使用
比较器

类而简单地实现冒泡排序怎么样

像这样的,

for (int c = 0; c < (yourArrayList.size() - 1); c++) {
            for (int d = 0; d < (yourArrayList.size() - c - 1); d++) {

                if (Integer.parseInt(yourArrayList.get(d).get("number")) > Integer
                        .parseInt(yourArrayList.get(d + 1).get("number"))) {

                    temporary = yourArrayList.get(d);
                    yourArrayList.set(d, yourArrayList.get(d + 1));
                    yourArrayList.set(d + 1, temporary);

                }
            }
        }

---

---

你可以在这里测试->

一个HashMap怎么能有数据

{{title，link，number}，{title，link，number}，{title，link，number}

？映射是key=value…您到底想要排序什么？你到底想通过排序来完成什么？这听起来像是一个问题。您是要对哈希映射的ArrayList进行排序，还是要在ArrayList中对哈希映射进行排序？因为您要做的是将一个arraylist与一个arraylist进行比较，这意味着您要对hashmaps的arraylist中的arraylist进行排序。。。似乎过于复杂了。O_ochancea，每个数组列表元素有三个键/值对，其中一个是数字，我想根据这个数字对数组列表进行排序，这意味着，数字最少的键/值对应位于数组的第一位list@joe如果每个变量正好有3个键值对，那么听起来您应该为这3个变量使用一个数据保持类，而不是映射。这个答案更有意义+1，我将尝试理解它…感谢像lotI这样的实现

Compariable

的想法，但值得一提的是，这只允许一种比较方式。

Comparator

的作用是提供额外的方法来比较我们的数据。如果这可以通过简单的气泡排序更容易地完成，那么为什么要首先实现

Comparable

？@sufiyan，因为

Collections

为您提供了这一功能。为什么要麻烦重新编码排序算法？哇，lambda真是太棒了。不知道that@downvoter如果这个答案有问题，请随时告诉我，这样我就可以纠正它。目前的答案包括基于OP代码的问题和解决方案的解释以及如何进一步改进的建议。我错过什么了吗？Lambdas很有趣！当然是最好的答案。@Joe bubble排序离有效的答案很远（见示例视频），但它确实很简单。如果您正在寻找有效的解决方案，请使用默认的

排序

方法，该方法使用有效的算法（目前在大多数情况下使用稍微优化的合并排序版本），您唯一的任务是提供代码，以决定是否应交换两个元素（比较器），因此您不必实现排序算法，哪项主要工作是选择应该比较哪些元素（如果它们位于错误的位置，则交换）。@Joe这就是重点，使用comparator，您甚至不需要编写嵌套循环，您只需为交换条件编写逻辑，如

for（）{for（）{if（*swapCondition*）{swap}}

，所以您所要做的就是使用

list.sort（comparator）

@Joe为了给你举个例子，让我们重写一下这个答案。你所需要做的不是编写comparator，它将比较

number

like的值，并像

Collections.sort一样使用它。sort（yourList，comparator）

或

yourList.sort（comparator）

取决于您是否有Java 8。您可以使用lambdas和用于整数值的比较器生成器进一步缩短此代码。您的整个代码可以是

yourList.sort（Comparator.comparingInt（map->integer.parseInt（map.get（“number”））

非常感谢@Pshemo，这当然更好…我有一个问题，在你的pastebin代码中，在终止语句后你是如何打开大括号的？我是说

新的Comparator（）{

@Joe是。它是嵌套类，但没有指定名称。根据您对它们不熟悉的事实判断，您可能需要在了解它之后再添加learning lambda。

public class SortData implements Comparator<ArrayList<HashMap<String, String>>>
// this would sort collection of -----------^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 
// like List<ArrayList<HashMap<String, String>>>

public int compare(HashMap<String, String> o1, HashMap<String, String> o2) {
    int nr1= Integer.parseInt(o1.get("number"));
    int nr2= Integer.parseInt(o2.get("number"));
    return Integer.compare(nr1, nr2);
}

class Data{//you should also pick better name :)
    private String title;
    private String link;//you can also use URL here instead of String,
    private int number;
    //add getters and setters for each field like
    public int getNumber(){
        return number;
    }
}

public class SortData implements Comparator<Data>{

    @Override
    public int compare(Data o1, Data o2) {
        return Integer.compare(o1.getNumber(), o2.getNumber());
    }
}

Comparator<Data> numberComparator =  (o1,o2)->Integer.compare(o1.getNumber(), o2.getNumber());

COmparator<Data> numberComparator = Comparator.comparingInt(Data::getNumber);

List<Data> list = ...

list.sort(numberComparator);

list.sort(Comparator.comparingInt(Data::getNumber));

public int compare(HashMap<String, String>> lhs,
        HashMap<String, String>> rhs) {
    return Integer.compare(Integer.parseInt(lhs.get("number")),
        Integer.parseInt(rhs.get("number")));
}

import java.util.*;
import java.lang.*;
import java.io.*;

class Data implements Comparable<Data>
{
    public static void main (String[] args) throws java.lang.Exception
    {
        List<Data> data = new ArrayList<Data>();
        data.add(new Data("Title1", "Link1", 8));
        data.add(new Data("Title2", "Link2", 1));
        data.add(new Data("Title3", "Link3", 3));

        for(Data d : data)
        {
            System.out.print(d.getNumber() + " ");
        }

        System.out.println();

        Collections.sort(data);

        for(Data d : data)
        {
            System.out.print(d.getNumber() + " ");
        }
    }

    private String title;
    private String link;
    private int number;

    public Data(){}
    public Data(String title, String link, int number)
    {
        setTitle(title);
        setLink(link);
        setNumber(number);
    }
    public void setTitle(String title)
    {
        this.title = title;
    }

    public void setLink(String link)
    {
        this.link = link;
    }

    public void setNumber(int number)
    {
        this.number = number;
    }

    public String getTitle()
    {
        return title;
    }

    public String getLink()
    {
        return link;
    }

    public int getNumber()
    {
        return number;
    }

    @Override
    public int compareTo(Data data)
    {
        return this.getNumber() - data.getNumber();
    }
}

8 1 3 
1 3 8 

for (int c = 0; c < (yourArrayList.size() - 1); c++) {
            for (int d = 0; d < (yourArrayList.size() - c - 1); d++) {

                if (Integer.parseInt(yourArrayList.get(d).get("number")) > Integer
                        .parseInt(yourArrayList.get(d + 1).get("number"))) {

                    temporary = yourArrayList.get(d);
                    yourArrayList.set(d, yourArrayList.get(d + 1));
                    yourArrayList.set(d + 1, temporary);

                }
            }
        }

import java.util.ArrayList;
import java.util.HashMap;

public class Main {

    public static void main(String[] args) {

        ArrayList<HashMap<String, String>> yourArrayList = 
                new ArrayList<HashMap<String, String>>();

        HashMap<String, String> myHashMap = new HashMap<String, String>();

        myHashMap.put("title", "first Title");
        myHashMap.put("date", "This is 1st date");
        myHashMap.put("number", "5");
        yourArrayList.add(0, myHashMap);

        myHashMap = new HashMap<String, String>();

        myHashMap.put("title", "Second Title");
        myHashMap.put("date", "This is 2nd date");
        myHashMap.put("number", "2");
        yourArrayList.add(1, myHashMap);

        myHashMap = new HashMap<String, String>();

        myHashMap.put("title", "Third Title");
        myHashMap.put("date", "This is 3rd date");
        myHashMap.put("number", "7");
        yourArrayList.add(2, myHashMap);

        myHashMap = new HashMap<String, String>();

        myHashMap.put("title", "Fourth Title");
        myHashMap.put("date", "This is 4th date");
        myHashMap.put("number", "0");
        yourArrayList.add(3, myHashMap);

        System.out.println("=================");
        System.out.println("BEFORE SORTING");
        System.out.println("=================");

        for (int i = 0; i < yourArrayList.size(); i++) {
            System.out.println(yourArrayList.get(i));
        }

        HashMap<String, String> temporary;

        for (int c = 0; c < (yourArrayList.size() - 1); c++) {
            for (int d = 0; d < (yourArrayList.size() - c - 1); d++) {

                if (Integer.parseInt(yourArrayList.get(d).get("number")) > Integer
                        .parseInt(yourArrayList.get(d + 1).get("number"))) {

                    temporary = yourArrayList.get(d);
                    yourArrayList.set(d, yourArrayList.get(d + 1));
                    yourArrayList.set(d + 1, temporary);

                }
            }
        }

        System.out.println("=================");
        System.out.println("AFTER SORTING");
        System.out.println("=================");

        for (int i = 0; i < yourArrayList.size(); i++) {
            System.out.println(yourArrayList.get(i));
        }

    }

}

=================
BEFORE SORTING
=================
{date=This is 1st date, number=5, title=first Title}
{date=This is 2nd date, number=2, title=Second Title}
{date=This is 3rd date, number=7, title=Third Title}
{date=This is 4th date, number=0, title=Fourth Title}
=================
AFTER SORTING
=================
{date=This is 4th date, number=0, title=Fourth Title}
{date=This is 2nd date, number=2, title=Second Title}
{date=This is 1st date, number=5, title=first Title}
{date=This is 3rd date, number=7, title=Third Title}