如何在java中使用集合对从类填充的列表进行排序

我无法对以下列表进行排序。 简单地使用Collections.sort（mylist）；显示了一个我无法理解的错误，因为我是java的初学者

Myclass x1 = new Myclass("8", "12");
Myclass x2 = new Myclass("6", "9");
Myclass x3 = new Myclass("11", "14");
List<Myclass> mylist = Arrays.asList(x1, x2, x3);

Myclass x1=新的Myclass（“8”、“12”）；
Myclass x2=新的Myclass（“6”、“9”）；
Myclass x3=新的Myclass（“11”、“14”）；
List mylist=Arrays.asList（x1，x2，x3）；

如何对“mylist”进行排序，使其按以下顺序存储—（6,9）、（8,12）、（11,14） i、 e根据元组的第一个值

Collections.sort(myList, myComparator);

myComparator

应该是

Comparator

接口的自定义实现

假设

Myclass

有一个

getFirstValue

方法，那么

比较器可以是：

public class MyComaparator implements Comparator<Myclass> {

    @Override
    public int compare(Myclass arg0, Myclass arg1) {
        return arg0.getFirstValue() - arg1.getFirstValue();
    }

}

公共类MyMaparator实现Comparator{
@凌驾
公共整数比较（Myclass arg0、Myclass arg1）{
返回arg0.getFirstValue（）-arg1.getFirstValue（）；
}
}

请注意，我还假设
getFirstValue（）
不返回
null
。验证部分由您决定。我建议您应该在
Tuple
实现中使用原语来轻松解决这个问题

官方文件是

myComparator
应该是
Comparator
接口的自定义实现

假设
Myclass
有一个
getFirstValue
方法，那么
比较器可以是：

public class MyComaparator implements Comparator<Myclass> {

    @Override
    public int compare(Myclass arg0, Myclass arg1) {
        return arg0.getFirstValue() - arg1.getFirstValue();
    }

}

公共类MyMaparator实现Comparator{
@凌驾
公共整数比较（Myclass arg0、Myclass arg1）{
返回arg0.getFirstValue（）-arg1.getFirstValue（）；
}
}

请注意，我还假设
getFirstValue（）
不返回
null
。验证部分由您决定。我建议您应该在
Tuple
实现中使用原语来轻松解决这个问题

官方文档是。
您可以通过使用可比或比较器界面来实现这一点。由于您的是一个自定义对象，您必须告诉
集合。sort
方法它应该根据什么来比较集合中的两个对象。
这是一个很好的例子。
您可以通过使用comparable或comparator界面来实现这一点。由于您的是一个自定义对象，您必须告诉
集合。sort
方法它应该根据什么来比较集合中的两个对象。
这是一个很好的例子。
有两种方法可以用来实现类的排序功能Myclass

方法#1-->使用Myclass实现
Comparable
，并在compareTo方法中编写自定义比较。像

Myclass==>

public class Myclass implements Comparable {

private String value1;
private String value2;

public Myclass(String value1, String value2) {
    super();
    this.value1 = value1;
    this.value2 = value2;
}

public String getValue1() {
    return value1;
}

public void setValue1(String value1) {
    this.value1 = value1;
}

public String getValue2() {
    return value2;
}

public void setValue2(String value2) {
    this.value2 = value2;
}

@Override
public int compareTo(Object o) {

    Myclass cl = (Myclass)o;
    return Integer.valueOf(value1) - Integer.valueOf(cl.getValue1()) ;
}

}

测试代码==>

public class Main {
public static void main(String[] args) {
    Myclass x1 = new Myclass("8", "12");
    Myclass x2 = new Myclass("6", "9");
    Myclass x3 = new Myclass("11", "14");
    List<Myclass> mylist = Arrays.asList(x1, x2, x3);

            //Sort list
    Collections.sort(mylist);

            //Print List content
    for( Myclass cla : mylist )
    {
        System.out.printf("(%s,%s)", cla.getValue1(),cla.getValue2());
    }
}
}

使用此方法，可以使用Collections.sort（myList）；对列表中的对象进行排序

方法#2-->

如果您不想让Myclass实现具有可比性，请编写一个客户比较器。

使用此方法，可以使用
Collections.sort（myList、customComparator）
对列表中的对象进行排序

关于方法2，
Adam提供了上述示例。我不打算在这里提供它。
可以使用两种方法实现类的排序功能Myclass

方法#1-->使用Myclass实现
Comparable
，并在compareTo方法中编写自定义比较。像

Myclass==>

public class Myclass implements Comparable {

private String value1;
private String value2;

public Myclass(String value1, String value2) {
    super();
    this.value1 = value1;
    this.value2 = value2;
}

public String getValue1() {
    return value1;
}

public void setValue1(String value1) {
    this.value1 = value1;
}

public String getValue2() {
    return value2;
}

public void setValue2(String value2) {
    this.value2 = value2;
}

@Override
public int compareTo(Object o) {

    Myclass cl = (Myclass)o;
    return Integer.valueOf(value1) - Integer.valueOf(cl.getValue1()) ;
}

}

测试代码==>

public class Main {
public static void main(String[] args) {
    Myclass x1 = new Myclass("8", "12");
    Myclass x2 = new Myclass("6", "9");
    Myclass x3 = new Myclass("11", "14");
    List<Myclass> mylist = Arrays.asList(x1, x2, x3);

            //Sort list
    Collections.sort(mylist);

            //Print List content
    for( Myclass cla : mylist )
    {
        System.out.printf("(%s,%s)", cla.getValue1(),cla.getValue2());
    }
}
}

使用此方法，可以使用Collections.sort（myList）；对列表中的对象进行排序

方法#2-->

如果您不想让Myclass实现具有可比性，请编写一个客户比较器。

使用此方法，可以使用
Collections.sort（myList、customComparator）
对列表中的对象进行排序

关于方法2，
Adam提供了上述示例。我不打算在这里提供它。
您真的想将数字作为字符串传递，然后尽可能将它们作为数字进行比较吗

我假设
Myclass
具有以下接口：

class Myclass {
    public Myclass(String first, String second) {..}
    public String getFirst() {..}
    public String getSecond() {..}
}

然后实现定制的
比较器
，如下所示。由于您正在比较字符串但考虑数字，请使用（将java实现放入某个包中）：

也可以让类实现，然后实现集合。sort（myList）将根据该接口的
compareTo
方法对其进行排序

但是，如果您的问题没有被正确询问，并且
Myclass
实际上是一对整数（不是字符串），那么您可以简单地定义比较器，如下所示：

public class MyComparator implements Comparator<Myclass> {
   @Override
   public int compare(Myclass a, Myclass b) {
      return a.getFirst() - b.getFirst();
   }
}

公共类MyComparator实现Comparator{
@凌驾
公共整数比较（Myclass a、Myclass b）{
返回a.getFirst（）-b.getFirst（）；
}
}
是否确实要将数字作为字符串传递，然后尽可能将它们作为数字进行比较

我假设
Myclass
具有以下接口：

class Myclass {
    public Myclass(String first, String second) {..}
    public String getFirst() {..}
    public String getSecond() {..}
}

然后实现定制的
比较器
，如下所示。由于您正在比较字符串但考虑数字，请使用（将java实现放入某个包中）：

也可以让类实现，然后实现集合。sort（myList）将根据该接口的
compareTo
方法对其进行排序

但是，如果您的问题没有被正确询问，并且
Myclass
实际上是一对整数（不是字符串），那么您可以简单地定义比较器，如下所示：

public class MyComparator implements Comparator<Myclass> {
   @Override
   public int compare(Myclass a, Myclass b) {
      return a.getFirst() - b.getFirst();
   }
}

公共类MyComparator实现Comparator{
@凌驾
公共整数比较（Myclass a、Myclass b）{
返回a.getFirst（）-b.getFirst（）；
}
}
因为对象没有自然顺序（如整数），所以需要使用指定比较