Question

我有objects的列表，我希望根据name进行排序。我已经完成了编码，它根据name进行排序，但我的要求略有不同。

这些名称是我目前使用以下代码排序的示例：

Bull AMP
Cat DEF
Dog AMP
Frog STR
Zebra DEF

但我想根据名字中的第二个单词对名称进行排序。基本上list应该是这样的：

Bull AMP
Dog AMP
Cat DEF
Zebra DEF
Frog STR

以下是我的代码：

对象类：

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());
  }
  }

使用集合进行排序

  private List<AnimalData> AnimalDataList;

  Collections.sort(AnimalDataList, AnimalDataComparer);

Answer 1

更改您的比较器，如下所示：

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]);
    }
}

或使用Java的新Comparator API：

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

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

除此之外，您可能还需要考虑其他注释并在构造函数中拆分名称，并有两个字段name和category。或者你可以为类别编写一个getter，你可以在其中进行拆分和验证。

Answer 2

你需要自己实现这个，如下所示，假设这个词是name的一部分，substring()和indexOf()：

@Override
public int compare(final AnimalData object1, final AnimalData object2) 
{
    return object1.getName().substring(
        object1.getName().indexOf(" ") 
    ).compareTo(object2.getName().substring(
        object2.getName().indexOf(" ")
    ));
}

如果由于某种原因你有两个以上的单词而且最后一个是你想要的单词，那么请使用lastIndexOf()

Answer 3

在Java 8 Streams模式中：

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());

Answer 4

这是

OUTPUT ::

[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 + "]";
    }

Java：使用Comparator将对象列表与属性的第二个单词排序

4 个答案: