基于实例变量java的排序列表

我有一个订单对象列表。每个order对象有5个实例变量。有没有办法根据这些Instance变量对列表进行排序？我需要实现可比较的接口。但是，在这种情况下，如何对特定变量进行排序？

您的问题有很多歧义。下面是一个5字段类的示例。此类可使用

Comparable

进行排序，在本例中，该类按字段

a

排序，然后按字段

b

排序，如果

a

和

b

相同，则这两个类在排序顺序上是等效的。如果要实现，可能还需要实现

equals（）

，并确保其一致性，如

Compariable

接口规范中所要求的。有关详细信息，请参见

工作示例：

import java.util.Arrays;

class SortableThing implements Comparable<SortableThing>
{
  final String foo;
  final int a, b, c, d, e;

  public SortableThing(String foo, int a, int b, int c, int d, int e)
  {
    this.foo = foo;   this.a = a;
    this.b = b;       this.c = c;
    this.d = d;       this.e = e;
  }

  @Override
  public int compareTo(SortableThing o)
  {
    if (this.a != o.a) 
      return this.a - o.a;
    else if (this.b != o.a)
      return this.b - o.b;
    else return 0;
  }

  @Override
  public boolean equals(Object o)
  {
    if (!(o instanceof SortableThing)) return false;
    SortableThing st = (SortableThing)o;
    return st.a == this.a && st.b == this.b;
  }

  @Override 
  public String toString()
  {
    return new StringBuilder().append(foo).append(": <").append(a)
     .append(',').append(b)
     .append(',').append(c)
     .append(',').append(d)
     .append(',').append(e).append('>').toString();
  }

  public static void main(String[] args)
  {
    final SortableThing one, two, three, four;
    one = new SortableThing("one", 4, 2, 42, 42, 42);
    two = new SortableThing("two", 2, 3, 42, 42, 42);
    three = new SortableThing("three", 2, 2, 42, 42, 42);
    four = new SortableThing("four", 1, 50, 42, 42, 42);
    SortableThing[] list = new SortableThing[] {one,two,three,four};
    System.out.println("Before: "+Arrays.deepToString(list));
    Arrays.sort(list);
    System.out.println("After: "+Arrays.deepToString(list));
  }
}

导入java.util.array；
类可排序实现可比较
{
最终字符串foo；
最终int a、b、c、d、e；
公共排序（字符串foo，int a，int b，int c，int d，int e）
{
this.foo=foo；this.a=a；
这个.b=b；这个.c=c；
这个.d=d；这个.e=e；
}
@凌驾
公共int比较（Sortableo）
{
如果（这个a！=o.a）
把这个还给我。a-o.a；
否则，如果（此.b！=o.a）
把这个退回。b-o.b；
否则返回0；
}
@凌驾
公共布尔等于（对象o）
{
如果（！（o可排序对象的实例））返回false；
可排序的st=（可排序的）o；
返回st.a==this.a&&st.b==this.b；
}
@凌驾
公共字符串toString（）
{
返回新的StringBuilder（）.append（foo）.append("：你的问题有很多歧义。下面是一个5字段类的示例。这个类可以使用
Comparable
进行排序，在本例中，它按字段
a
排序，然后按字段
b
排序，如果
a
和
b
相同，则这两个类在排序顺序上是等价的。如果你实现了，你可能也需要d实现
equals（）
，并确保其一致性，如
可比
接口规范中所要求。有关详细信息，请参见

工作示例：

import java.util.Arrays;

class SortableThing implements Comparable<SortableThing>
{
  final String foo;
  final int a, b, c, d, e;

  public SortableThing(String foo, int a, int b, int c, int d, int e)
  {
    this.foo = foo;   this.a = a;
    this.b = b;       this.c = c;
    this.d = d;       this.e = e;
  }

  @Override
  public int compareTo(SortableThing o)
  {
    if (this.a != o.a) 
      return this.a - o.a;
    else if (this.b != o.a)
      return this.b - o.b;
    else return 0;
  }

  @Override
  public boolean equals(Object o)
  {
    if (!(o instanceof SortableThing)) return false;
    SortableThing st = (SortableThing)o;
    return st.a == this.a && st.b == this.b;
  }

  @Override 
  public String toString()
  {
    return new StringBuilder().append(foo).append(": <").append(a)
     .append(',').append(b)
     .append(',').append(c)
     .append(',').append(d)
     .append(',').append(e).append('>').toString();
  }

  public static void main(String[] args)
  {
    final SortableThing one, two, three, four;
    one = new SortableThing("one", 4, 2, 42, 42, 42);
    two = new SortableThing("two", 2, 3, 42, 42, 42);
    three = new SortableThing("three", 2, 2, 42, 42, 42);
    four = new SortableThing("four", 1, 50, 42, 42, 42);
    SortableThing[] list = new SortableThing[] {one,two,three,four};
    System.out.println("Before: "+Arrays.deepToString(list));
    Arrays.sort(list);
    System.out.println("After: "+Arrays.deepToString(list));
  }
}

导入java.util.array；
类可排序实现可比较
{
最终字符串foo；
最终int a、b、c、d、e；
公共排序（字符串foo，int a，int b，int c，int d，int e）
{
this.foo=foo；this.a=a；
这个.b=b；这个.c=c；
这个.d=d；这个.e=e；
}
@凌驾
公共int比较（Sortableo）
{
如果（这个a！=o.a）
把这个还给我。a-o.a；
否则，如果（此.b！=o.a）
把这个退回。b-o.b；
否则返回0；
}
@凌驾
公共布尔等于（对象o）
{
如果（！（o可排序对象的实例））返回false；
可排序的st=（可排序的）o；
返回st.a==this.a&&st.b==this.b；
}
@凌驾
公共字符串toString（）
{
返回新的StringBuilder（）.append（foo）.append（：您可以像这样在类中定义
static
s

public static final Comparator<Order> NAME_COMPARATOR = Comparator<Order>(){
                              public int compare(Order o1, Order o2) {
                                  // provide an impl here using order name
                              }
                          }

public static final Comparator<Order> ID_COMPARATOR = Comparator<Order>(){
                              public int compare(Order o1, Order o2) {
                                  // provide an impl here using order id
                              }
                          }

Collections.sort(list, Order.NAME_COMPARATOR);
Collections.sort(list, Order.ID_COMPARATOR);

您可以像这样在类中定义
静态
比较器
s

public static final Comparator<Order> NAME_COMPARATOR = Comparator<Order>(){
                              public int compare(Order o1, Order o2) {
                                  // provide an impl here using order name
                              }
                          }

public static final Comparator<Order> ID_COMPARATOR = Comparator<Order>(){
                              public int compare(Order o1, Order o2) {
                                  // provide an impl here using order id
                              }
                          }

Collections.sort(list, Order.NAME_COMPARATOR);
Collections.sort(list, Order.ID_COMPARATOR);

如果你的意思是“按a，b，c排序”，我写了一个博客来解决这个问题：。请看第二段代码，抱歉，它是中文的，但代码和注释是英文的：）
如果你的意思是“按a，b，c排序”，我写了一个博客来解决这个问题：。请看第二段代码，抱歉，它是中文的，但代码和注释是英文的：）
假设你有“get”实例变量的“get”方法您可以使用，这样您就不必编写自定义代码。
假设您有实例变量的“get”方法，您可以使用，这样您就不必编写自定义代码。
您可以在Scala中非常优雅地完成这项工作

val sortedOrders = orders.sortBy(o => (o.a, o.b, o.c))

首先按字段
a
对
订单进行排序，然后按字段
b
，然后按字段
c
对
列表进行排序。您可以在Scala中非常优雅地执行此操作

val sortedOrders = orders.sortBy(o => (o.a, o.b, o.c))

首先按字段
a
对
订单
列表排序，然后按字段
b
，然后按字段
c
对其进行排序。它们是什么类型的变量？原语？如果是，您只需使用compareTo方法对它们进行比较（您说过您将实现可比较接口）.您是指多个字段的顺序？如SQL“按a、b、c排序”。它们是什么类型的变量？原语？如果是，您只需在compareTo方法中比较它们（您说过您将实现可比较的接口）.你是说多个字段的顺序？如SQL“按a、b、c排序”。解释否决票？给出理由，这样人们可以自己决定。但我需要用英语和德语进行排序…这门课有可能吗？解释否决票？给出理由，这样人们可以自己决定。但我需要用英语和德语进行排序…可能吗你喜欢这个班吗？