Java：使用带有属性第二个字的Comparator对对象列表进行排序

我有一个

对象的列表

，我想根据

名称

进行排序。我已经完成了编码，它确实会根据

name

进行排序，但我有一个稍微不同的要求

例如，我目前使用以下代码对这些名称进行了排序：

Bull AMP
Cat DEF
Dog AMP
Frog STR
Zebra DEF

但是我想根据名字中的第二个词来排序。基本上，

列表

应该是这样的：

Bull AMP
Dog AMP
Cat DEF
Zebra DEF
Frog STR

public class AnimalDataComparer implements Comparator<AnimalData> 
{
    @Override
    public int compare(final AnimalData object1, final AnimalData object2) 
    {
      return object1.getName().split(" ")[1].compareTo(object2.getName().split(" ")[1]);
    }
}

下面是我的代码：

对象类：

public class AnimalData implements Serializable
{
    private static final long serialVersionUID = 3952396152688462601L;
    public String name;
    public long age;
    private String animal;
    private String animalParts;
    private String animalType;
}

比较器类

public class AnimalDataComparer implements Comparator<AnimalData> 
      {
  @Override
  public int compare(final AnimalData object1, final AnimalData object2) 
  {
          return object1.getName().compareTo(object2.getName());
  }
  }

公共类AnimalDataComparer实现Comparator
{
@凌驾
公共整数比较（最终动物数据对象1，最终动物数据对象2）
{
返回object1.getName（）.compareTo（object2.getName（））；
}
}

使用集合进行排序

  private List<AnimalData> AnimalDataList;

  Collections.sort(AnimalDataList, AnimalDataComparer);

私有列表动物催化剂；
Collections.sort（animalatalist、AnimalDataComparer）；

假设单词是

name

的一部分，您需要自己实现这一点，如下所示：

---

如果出于某种原因，您有两个以上的单词，而最后一个是您想要的单词，则使用以下方法更改比较器：

Bull AMP
Dog AMP
Cat DEF
Zebra DEF
Frog STR

public class AnimalDataComparer implements Comparator<AnimalData> 
{
    @Override
    public int compare(final AnimalData object1, final AnimalData object2) 
    {
      return object1.getName().split(" ")[1].compareTo(object2.getName().split(" ")[1]);
    }
}

公共类AnimalDataComparer实现Comparator
{
@凌驾
公共整数比较（最终动物数据对象1，最终动物数据对象2）
{
返回object1.getName（）.split（“”[1]）。比较（object2.getName（）.split（“”[1]）；
}
}

或者使用Java较新的Comparator API：

Comparator<AnimalData> c = Comparator.comparing(animal -> animal.getName().split(" ")[1]);

Comparator c=Comparator.comparing（动物->动物.getName（）.split（“”[1]）；

请注意，这是假设所有名称实际上都有两个单词。如果您不确定这一点，则需要在访问拆分阵列之前进行检查

除此之外，您可能需要考虑其他注释并在构造函数中拆分名称，并有两个字段，

name

和

category

。或者您可以为category编写一个getter，在其中进行拆分和验证。

在这里

输出：：

[AnimalData[name=Dog AMP]、AnimalData[name=Cat DEF]、AnimalData[name=Zebra DEF]、AnimalData[name=Frog STR]]

import java.io.IOException;
import java.io.Serializable;
import java.text.ParseException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class test {
    public static void main(String[] args) throws IOException, ParseException {

        AnimalData data1 = new AnimalData("Cat DEF");
        AnimalData data2 = new AnimalData("Dog AMP");
        AnimalData data3 = new AnimalData("Frog STR");
        AnimalData data4 = new AnimalData("Zebra DEF");
        List<AnimalData> list = new ArrayList<>();
        list.add(data1);
        list.add(data2);
        list.add(data3);
        list.add(data4);
        Collections.sort(list);
        System.out.println(list);

    }
}

class AnimalData implements Serializable, Comparable<AnimalData> {
    private static final long serialVersionUID = 3952396152688462601L;
    public String name;
    public long age;
    private String animal;
    private String animalParts;
    private String animalType;

    public AnimalData(String name) {
        super();
        this.name = name;
    }

    @Override
    public int compareTo(AnimalData o) {
        String secondPartThis = this.name.split(" ")[1];
        String secondPartObject = o.name.split(" ")[1];
        return secondPartThis.compareTo(secondPartObject);
    }

    @Override
    public String toString() {
        return "AnimalData [name=" + name + "]";
    }

import java.io.IOException；
导入java.io.Serializable；
导入java.text.ParseException；
导入java.util.ArrayList；
导入java.util.Collections；
导入java.util.List；
公开课考试{
公共静态void main（字符串[]args）引发IOException、ParseException{
动物数据1=新动物数据（“Cat DEF”）；
动物数据2=新动物数据（“狗放大器”）；
动物数据3=新动物数据（“青蛙数据”）；
动物数据4=新动物数据（“斑马定义”）；
列表=新的ArrayList（）；
列表。添加（数据1）；
列表。添加（数据2）；
列表。添加（数据3）；
列表。添加（数据4）；
集合。排序（列表）；
系统输出打印项次（列表）；
}
}
类AnimalData实现可序列化、可比较的{
私有静态最终长serialVersionUID=39523961522688462601L；
公共字符串名称；
公众长寿；
私家弦动物；
私人字符串动物部件；
私有字符串animalType；
公共动物数据（字符串名称）{
超级（）；
this.name=名称；
}
@凌驾
公共国际比较组织（动物组织）{
字符串secondPartThis=this.name.split（“”[1]；
字符串secondPartObject=o.name.split（“”[1]；
返回secondPartThis.compareTo（secondPartObject）；
}
@凌驾
公共字符串toString（）{
返回“AnimalData[name=“+name+”]”；
}

在Java 8流模式下：

Comparator<? super Animal> animalComparator = (a, b) -> {
        StringTokenizer firstTokenizer = new StringTokenizer(a.getName(), " ");
        firstTokenizer.nextToken();
        StringTokenizer secondTokenizer = new StringTokenizer(b.getName(), " ");
        secondTokenizer.nextToken();
        return firstTokenizer.nextToken().compareTo(secondTokenizer.nextToken());
    };

    myList = myList.stream().sorted(animalComparator).collect(Collectors.toList());

---

comparatory您的equals方法还需要表示该行为。字段的AMP、DEF等是什么？或者这些sufixes是字段字符串名称的一部分吗？您可以使用
split（）
并比较名称的第二部分。这是一个非常糟糕的设计。如果可能的话，您应该为
name
和
category
添加单独的字段。如果需要这样的格式，请添加一个类似
String foo（）{return name+“”+category；}
的方法，该方法不是“完整的”Java 8代码-它为两个参数复制了比较器逻辑。因为它使用的是StringTokenizer类，所以有两个不同的变量需要比较