对Java通用对象的数组列表进行排序

我有一个类Vertex，它有一个通用类型T的字段元素

我有一个顶点对象的数组列表，我想对其进行排序，但我不确定如何排序

我尝试使用比较器，如下所示：

listOfNeighbours.sort(new Comparator<Vertex<T>>() {
        @Override
        public int compare(Vertex<T> v1, Vertex<T> v2) {
            if(v1.getElement() == v2.getElement()){
                return 0;
            }else if(v1.getElement() < v2.getElement()) {
                return -1;
            }else {
                return 1;
            }

         }
    });

listOfNeighbours.sort（新的比较器（）{
@凌驾
公共整数比较（顶点v1，顶点v2）{
如果（v1.getElement（）==v2.getElement（））{
返回0；
}else if（v1.getElement（）

显然，上面的解决方案是错误的，因为我们无法比较泛型，但我希望类似的方法可以对顶点对象列表进行排序

在我的应用程序中，T可以是整数、双精度或字符串

感谢您的帮助

多谢各位

编辑：我的顶点类如下：

public class Vertex<T>{

private ObjectProperty<T> element;
private BooleanProperty visited;

public Vertex() {
    element = null;
    visited = new SimpleBooleanProperty(false);
}

public Vertex(T element) {
    this.element = new SimpleObjectProperty<T>(element);
    this.visited = new SimpleBooleanProperty(false);
}

public Vertex(T element, boolean visited) {
    this.element = new SimpleObjectProperty<T>(element);
    this.visited = new SimpleBooleanProperty(visited);
}

public void setElement(T elem) {
    this.element.set(elem);
}

public T getElement() {
    return this.element.get();
}

public ObjectProperty<T> elementProperty(){
    return this.element;
}

public void setVisited(boolean b) {
    this.visited.set(b);
}

public boolean isVisited() {
    return this.visited.get();
}

public BooleanProperty visitedProperty(){
    return this.visited;
}

@Override
public boolean equals(Object o) {
    if(o == this) {
        return true;
    }

    if(!(o instanceof Vertex<?>)) {
        return false;
    }

    Vertex<?> v=  (Vertex<?>) o;

    if(v.getElement() instanceof String) {
        return v.getElement().equals(this.element.get());
    }else {
        return v.getElement() == this.element.get();
    }


}

@Override
public String toString() {
    return element.get().toString();
}

}

公共类顶点{
私有财产要素；
访问了布尔的私人财产；
公共顶点（）{
元素=空；
已访问=新的SimpleBoleAnProperty（false）；
}
公共顶点（T元素）{
this.element=新的SimpleObject属性（element）；
this.visitored=新的SimpleBoleAnProperty（false）；
}
公共顶点（T元素，布尔值）{
this.element=新的SimpleObject属性（element）；
this.visted=新的SimpleBoleAnProperty（已访问）；
}
公共无效集合元素（T元素）{
此.element.set（elem）；
}
公共T getElement（）{
返回此.element.get（）；
}
公共对象属性elementProperty（）{
返回此.element；
}
公共无效集合（布尔b）{
本.参观.集（b）；
}
公共布尔值（）{
返回此。已访问。获取（）；
}
公共布尔属性visitedProperty（）{
把这个还给我；
}
@凌驾
公共布尔等于（对象o）{
如果（o==这个）{
返回true；
}
如果（！（顶点的o实例））{
返回false；
}
顶点v=（顶点）o；
if（v.getElement（）字符串实例）{
返回v.getElement（）.equals（this.element.get（））；
}否则{
return v.getElement（）==this.element.get（）；
}
}
@凌驾
公共字符串toString（）{
返回元素.get（）.toString（）；
}
}

问题是，在进行比较时，您是否知道顶点中的元素类型

即，由于类型擦除，此代码有效：

Vertex<String> strVtx = ...
Vertex<Integer> intVtx = ...
List<Vertex> list = Arrays.asList(strVtx, intVtx);
list.sort(aComparer);

顶点strVtx=。。。
顶点intVtx=。。。
列表=Arrays.asList（strVtx、intVtx）；
列表.排序（比较程序）；

因此，这里的比较器实现需要是不确定的

但是，如果您知道类型，您可以简单地执行以下操作：

List<Vertex<Integer>> list = ...
list.sort(Comparator.comparing(Vertex::getElement);

List=。。。
list.sort（Comparator.comparing（顶点：：getElement））；

问题是，在进行比较时，您是否知道顶点中的元素类型

即，由于类型擦除，此代码有效：

Vertex<String> strVtx = ...
Vertex<Integer> intVtx = ...
List<Vertex> list = Arrays.asList(strVtx, intVtx);
list.sort(aComparer);

顶点strVtx=。。。
顶点intVtx=。。。
列表=Arrays.asList（strVtx、intVtx）；
列表.排序（比较程序）；

因此，这里的比较器实现需要是不确定的

但是，如果您知道类型，您可以简单地执行以下操作：

List<Vertex<Integer>> list = ...
list.sort(Comparator.comparing(Vertex::getElement);

List=。。。
list.sort（Comparator.comparing（顶点：：getElement））；

A是一件好事。它对这个特定问题有一个解决方案。在您的情况下，这就是

listOfNeighbours.sort(Comparator.comparing(Vertex::getElement))

如果顶点组件不可比较，我建议使用自定义比较器

比如说,

import java.util.*;
import javafx.beans.property.*;

public class Vertex<T>{

  private ObjectProperty<T> element;
  private BooleanProperty visited;

  public Vertex() {
      element = null;
      visited = new SimpleBooleanProperty(false);
  }

  public Vertex(T element) {
      this.element = new SimpleObjectProperty<T>(element);
      this.visited = new SimpleBooleanProperty(false);
  }

  public Vertex(T element, boolean visited) {
      this.element = new SimpleObjectProperty<T>(element);
      this.visited = new SimpleBooleanProperty(visited);
  }

  public void setElement(T elem) {
      this.element.set(elem);
  }

  public T getElement() {
      return this.element.get();
  }

  public ObjectProperty<T> elementProperty(){
      return this.element;
  }

  public void setVisited(boolean b) {
      this.visited.set(b);
  }

  public boolean isVisited() {
      return this.visited.get();
  }

  public BooleanProperty visitedProperty(){
      return this.visited;
  }

  @Override
  public boolean equals(Object o) {
      if(o == this) {
          return true;
      }

      if(!(o instanceof Vertex<?>)) {
          return false;
      }

      Vertex<?> v=  (Vertex<?>) o;

      if(v.getElement() instanceof String) {
          return v.getElement().equals(this.element.get());
      }else {
          return v.getElement() == this.element.get();
      }


  }

  @Override
  public String toString() {
      return element.get().toString();
  }

  public static void main(String[] args) {
    ArrayList<Vertex<String>> listOfNeighbours = new ArrayList<>();
    listOfNeighbours.add(new Vertex<>("foo"));
    listOfNeighbours.add(new Vertex<>("bar"));
    System.out.println(listOfNeighbours);
    listOfNeighbours.sort(Comparator.comparing(Vertex::getElement));
    System.out.println(listOfNeighbours);

    ArrayList<Vertex<Integer>> list2 = new ArrayList<>();
    list2.add(new Vertex<>(1));
    list2.add(new Vertex<>(123));
    list2.add(new Vertex<>(15));
    list2.add(new Vertex<>(2));
    System.out.println(list2);
    list2.sort(Comparator.comparing(Vertex::getElement));
    System.out.println(list2);
    list2.sort(Comparator.comparing(Vertex::getElement, Comparator.comparing(i -> i.toString())));
    System.out.println(list2);
  }
}

（原始输入）

（按字符串排序）

（原始输入）

（按整数自然顺序排序）

（按字符串的顺序排序，即按字母顺序排列）

后者是通过

比较器完成的，比较器通过从给定的
顶点
提取值，然后将其转换为
字符串
，然后用作排序键来完成其工作。
a是一件好事。它对这个特定问题有一个解决方案。在您的情况下，这就是

listOfNeighbours.sort(Comparator.comparing(Vertex::getElement))

如果顶点组件不可比较，我建议使用自定义比较器

比如说,

import java.util.*;
import javafx.beans.property.*;

public class Vertex<T>{

  private ObjectProperty<T> element;
  private BooleanProperty visited;

  public Vertex() {
      element = null;
      visited = new SimpleBooleanProperty(false);
  }

  public Vertex(T element) {
      this.element = new SimpleObjectProperty<T>(element);
      this.visited = new SimpleBooleanProperty(false);
  }

  public Vertex(T element, boolean visited) {
      this.element = new SimpleObjectProperty<T>(element);
      this.visited = new SimpleBooleanProperty(visited);
  }

  public void setElement(T elem) {
      this.element.set(elem);
  }

  public T getElement() {
      return this.element.get();
  }

  public ObjectProperty<T> elementProperty(){
      return this.element;
  }

  public void setVisited(boolean b) {
      this.visited.set(b);
  }

  public boolean isVisited() {
      return this.visited.get();
  }

  public BooleanProperty visitedProperty(){
      return this.visited;
  }

  @Override
  public boolean equals(Object o) {
      if(o == this) {
          return true;
      }

      if(!(o instanceof Vertex<?>)) {
          return false;
      }

      Vertex<?> v=  (Vertex<?>) o;

      if(v.getElement() instanceof String) {
          return v.getElement().equals(this.element.get());
      }else {
          return v.getElement() == this.element.get();
      }


  }

  @Override
  public String toString() {
      return element.get().toString();
  }

  public static void main(String[] args) {
    ArrayList<Vertex<String>> listOfNeighbours = new ArrayList<>();
    listOfNeighbours.add(new Vertex<>("foo"));
    listOfNeighbours.add(new Vertex<>("bar"));
    System.out.println(listOfNeighbours);
    listOfNeighbours.sort(Comparator.comparing(Vertex::getElement));
    System.out.println(listOfNeighbours);

    ArrayList<Vertex<Integer>> list2 = new ArrayList<>();
    list2.add(new Vertex<>(1));
    list2.add(new Vertex<>(123));
    list2.add(new Vertex<>(15));
    list2.add(new Vertex<>(2));
    System.out.println(list2);
    list2.sort(Comparator.comparing(Vertex::getElement));
    System.out.println(list2);
    list2.sort(Comparator.comparing(Vertex::getElement, Comparator.comparing(i -> i.toString())));
    System.out.println(list2);
  }
}

（原始输入）

（按字符串排序）

（原始输入）

（按整数自然顺序排序）

（按字符串的顺序排序，即按字母顺序排列）

后者使用
比较器来完成，比较器通过从给定的
顶点
提取值，然后将其转换为
字符串
，然后用作排序键。
如果T被限制为
可比如果T被限制为
可比
v1.getElement（）==v2.getElement（）
不是比较，它只是检查内存地址。您的代码应该是
返回v1.getElement（）.compareTo（v2.getElement（））
。Vertex元素必须实现
Comparable
v1.getElement（）==v2.getElement（）
不是比较，它只是检查内存地址。您的代码应该是
返回v1.getElement（）.compareTo（v2.getElement（））
.Vertex元素必须实现
可比
。这个解决方案假设
T
是一个
可比的，也就是说我刚才注意到在问题中T通常是整数、双精度、字符串中的一个，所有这些都是可比的，所以我想只要他确实对
T
施加限制，就足够了看，如果他不能控制自己的Graph/Vertex类源代码，他可能没有或可能没有这样做的能力，所以我仍然建议添加一个不做这种假设的解决方案。@ValentinRuano你是对的。在这种情况下（它们可以比较，但不可比
），我建议改为。大家好，我仍然有点困惑@glglglgl我尝试了上面的解决方案，但我得到了一个错误。它说“类型Vertex没有定义适用于此处的getElement（Object）”。不确定这是否相关，但在我的Vertex类中，元素字段的类型是ObjectProperty，但我的getElement（）meth
[1, 123, 15, 2]

static <T> void sortNeightbours(Collection<Vertex<? extends T>> neighbours, Comparator<? super T> elementComparator) {
    neighbours.sort(Comparator.comparing(Vertex::getElement, elementComparator);
} 

   List<Vertex<Integer>> ints = ...;
   List<Vertex<Double>> dbls = ...;
   List<Vertex<String>> strs = ...;

   sortNeighbours(ints, Comparator.naturalOrder());
   sortNeighbours(dbls, Comparator.naturalOrder());
   sortNeighbours(strs, Comparator.naturalOrder());