Question

我有这堂课：

public class Test {

  private int    priority;
  private String desciption;
...
}

我有这个arraylist：

Priority: 1, Description: C2
Priority: 2, Description: C1
Priority: 3, Description: C1
Priority: 4, Description: C2

我想要这个结果：

Priority: 1, Description: C2
Priority: 4, Description: C2
Priority: 2, Description: C1
Priority: 3, Description: C1

我如何用比较器做到这一点？谢谢！

编辑：

我回答你的所有问题：

@retro：没有。 description是没有特定格式的字符串。它也可以是空的。

@tobias_k：首先按描述“分组”，然后按优先顺序排序。优先级始终不等于。

@ user270349：

这是我的尝试：

int result = 0;
if (o1.getPriority() < o2.getPriority()) result = -1;
else if (o1.getPriority() > o2.getPriority()) result = 1

result *= o1.getDescription().compareTo(o2.getDescription());

return result;

编辑2：

另一个输入/输出示例：

我有这个arraylist：

Priority: 1, Description: C2
Priority: 2, Description: C3
Priority: 3, Description: C1
Priority: 4, Description: C2

我想要这个结果：

Priority: 1, Description: C2
Priority: 4, Description: C2
Priority: 2, Description: C3
Priority: 3, Description: C1

这是我的解决方案：

            List<Test> testList = new ArrayList<>();
    testList.add(new Test(4, "C2"));
    testList.add(new Test(2, "C3"));
    testList.add(new Test(3, "C1"));
    testList.add(new Test(1, "C2"));


    Comparator<Test> comparator = new Comparator<Test>() {

        @Override
        public int compare(Test o1, Test o2) {
            int res = o1.getDescription().compareTo(o2.getDescription());
            if (res == 0)
                return o1.getPriority() < o2.getPriority() ? -1 : 1;
            else
                return res;
        }
    };

    Collections.sort(testList, comparator);


    List<String> valoriInseriti = new ArrayList<>();
    List<Test> grouping = new ArrayList<>();
    for (Test t : testList) {
        if (!valoriInseriti.contains(t.getDescription())) {
            valoriInseriti.add(t.getDescription());
            grouping.add(t);
        }
    }


    comparator = new Comparator<Test>() {

        @Override
        public int compare(Test o1, Test o2) {
            return o1.getPriority() < o2.getPriority() ? -1 : 1;
        }
    };

    Collections.sort(grouping, comparator);


    Collections.sort(testList, comparator);

    List<Test> output = new ArrayList<>();
    for (Test t1 : grouping) {
        for (Test t2 : testList) {
            if (t2.getDescription().equals(t1.getDescription())) {
                output.add(t2);
            }
        }
    }

    System.out.println("==============================");
    for (Test t : output)
        System.out.println(t);

Answer 1

Test implements Comparator并覆盖compare()方法

  public class Test implements Comparator<Test>{
    private int    priority;
    private String desciption;

    @Override
    public int compare(Test o1, Test o2) {
       // your code here
    }

  }

Answer 2

Comparator<Test> myComparator = new Comparator<Test>() {
    public int compare(Test o1, Test o2) {
        int result = o2.desciption.compareTo(o1.desciption);

        if (result == 0) {
            return o1.priority - o2.priority;
        }

        return result;

    }
};

List<Test> sortedList = Collections.sort(testList, myComparator);

Answer 3

您要做的第一件事就是让Test类实现Comparator。

public class Test implements Comparator<Test> {
    // Fields etc.

    public int compare(Test test1, Test test2)
    {
         // Add your logic in here.
         return test1.getDescription().compareTo(test2.getDescription()) * -1;
    }
}

这将起作用，因为String在词汇上进行比较。它将尝试按照第一个字母的升序排序。如果第一个字母相等，它将移动到下一个值。通过反转它，您可以按降序存储。

然后对其进行排序，使用Collections.sort(myList);。这是一个有效的例子：http://ideone.com/SdFGFg

Answer 4

Comparator<Test> comparator = new Comparator<Test>() {

            @Override
            public int compare(Test o1, Test o2) {
                return o1.desciption.compareTo(o2.desciption);
            }
                  };

正如您的问题指定的那样，您希望按照Test字段的降序排序description类的对象，请使用Collections.reverseOrder(comparator)

Comparator<Test>reverse = Collections.reverseOrder(comparator);

Answer 5

这样做

您的TestComparator

class TestComparator implements Comparator<Test> {
    @Override
    public int compare(Test o1, Test o2) {

        String[] arr1 = o1.getDesciption().split("(?<=\\D)(?=\\d)");
        String[] arr2 = o2.getDesciption().split("(?<=\\D)(?=\\d)");
        if(Integer.parseInt(arr2[1])!=Integer.parseInt(arr1[1])){
            return  new Integer(Integer.parseInt(arr2[1])).compareTo(Integer.parseInt(arr1[1]));
        }
        if(o1.getPriority()!=o2.getPriority()){
           return   new Integer(o1.getPriority()).compareTo(o2.getPriority());
        }
        return 0;
    }    
}

你的排序

 System.out.println(list);      
 Collections.sort(list,new TestComparator());
 System.out.println("After sorting");
 System.out.println(list);

你的输出

[Test [priority=1, desciption=C2], Test [priority=2, desciption=C1], Test [priority=3, desciption=C1], Test [priority=4, desciption=C2]]
After sorting
[Test [priority=1, desciption=C2], Test [priority=4, desciption=C2], Test [priority=2, desciption=C1], Test [priority=3, desciption=C1]]

Answer 6

我认为您应该排序（使用比较器），然后分组，然后对组进行排序（使用另一个比较器，可以使用应用于列表中第一个元素的第一个比较器），然后进行去组合。

如何创建这个java比较器

6 个答案: