Java 根据整数值对对象进行排序

有一个带有私有字段

Num

的类条目和包含条目列表（条目）的类MyList。我需要根据Num的值对条目列表进行排序。如何以最佳方式进行排序？我是否应该使用集合.sort（）

public类MyList（）
{
私人名单条目；
公共MyList（）
{
...
}
}
公共类条目（）
{
私有整数；
私有字符串Val；
公共MyClass（）
{
这个.Num=0；
这个。Val=“”；
} 
公共void setNum（int Num）
{
this.Num=Num；
}
公共int getNum（）
{
返回这个.Num（）；
}
}

您需要编写一个实现接口并重写方法的类。然后，您可以使用collection和comparator类作为输入调用该方法

以下是一个简单的教程，可帮助您了解示例：

---

您需要编写一个类来实现接口并重写该方法。然后，您可以使用collection和comparator类作为输入调用该方法

以下是一个简单的教程，可帮助您了解示例：

公共类CustomComparator实现Comparator{
@凌驾
公共int比较（YourObject o1，YourObject o2）{
int cmp=Integer.compare（o1.getNum（），o2.getNum（））；
返回补偿；
}
}

您也可以使用compare

int cmp=整数。比较（a，b）；//在Java7中

int cmp=Double。比较（a，b）；//Java 7之前

公共类CustomComparator实现Comparator{
@凌驾
公共int比较（YourObject o1，YourObject o2）{
int cmp=Integer.compare（o1.getNum（），o2.getNum（））；
返回补偿；
}
}

您也可以使用compare

int cmp=整数。比较（a，b）；//在Java7中

int cmp=Double。比较（a，b）；//Java 7之前

使用。通过为

compareTo（）

提供实现，使您的

Entry

类实现此接口，如果此

Entry

对象等于另一个，则该类应返回

0

，如果比较大，则返回正值；如果比较小，则返回负值

public class Entry implements Comparable<Entry> // Use Generics
{
  private int Num;
  private String Val;

  public MyClass()
  {
    this.Num = 0;
    this.Val = "";
  }

  // getters/seters()

  public int compareTo(Entry otherEntry)
  {
   int num2 = otherEntry.getNum();
   return num == num2 ? 0 :
          (num > num2 ? 1 : -1);
  }

}

要支持使用不同标准的多个排序顺序，请改用。

使用。通过为

compareTo（）

提供实现，使您的

Entry

类实现此接口，如果此

Entry

对象等于另一个，则该类应返回

0

，如果比较大，则返回正值；如果比较小，则返回负值

public class Entry implements Comparable<Entry> // Use Generics
{
  private int Num;
  private String Val;

  public MyClass()
  {
    this.Num = 0;
    this.Val = "";
  }

  // getters/seters()

  public int compareTo(Entry otherEntry)
  {
   int num2 = otherEntry.getNum();
   return num == num2 ? 0 :
          (num > num2 ? 1 : -1);
  }

}

---

要支持使用不同标准的多个排序顺序，请改用。

您可以按照如下方式实现

Comparable

接口（注意，根据Jon Skeet的评论，我修复了几个错误，并更改了几个变量名称以匹配约定）：

import java.util.ArrayList；
导入java.util.Collections；
导入java.util.List；
公共类条目实现了可比性{
私有整数；
私有字符串val；
公众进入（）{
this.num=0；
this.val=”“；
} 
公共void setNum（int num）{
this.num=num；
}
公共int getNum（）{
返回这个.num；
}
@凌驾
公共整数比较（条目）{
if（this.numentry.num）返回1；
返回0；
}
公共静态void main（字符串[]args）{
系统输出打印项次（“测试1”）；
test1（）；
System.out.println（“\n测试2”）；
test2（）；
}
公共静态void test1（）{
条目e1=新条目（）；
e1.setNum（5）；
条目e2=新条目（）；
e2.setNum（4）；
System.out.println（“e1=“+e1.getNum（）+”，e2=“+e2.getNum（）+”，e1.compareTo（e2）=“+e1.compareTo（e2））；
条目e3=新条目（）；
e3.setNum（5）；
System.out.println（“e1=“+e1.getNum（）+”，e3=“+e3.getNum（）+”，e1.compareTo（e3）：“+e1.compareTo（e3））；
条目e4=新条目（）；
e4.setNum（6）；
System.out.println（“e1=“+e1.getNum（）+”，e4=“+e4.getNum（）+”，e1.compareTo（e4）：“+e1.compareTo（e4））；
}
公共静态void test2（）{
列表=新的ArrayList（）；
int[]nums={5,3,9,25,1，-8}；
for（int i:nums）{
条目e=新条目（）；
e、 setNum（i）；
列表.添加（e）；
}
集合。排序（列表）；
系统输出打印（“原始列表”）；
for（int i:nums）{
系统输出打印（i+“，”）；
}
System.out.println（）；
系统输出打印（“排序列表：”）；
对于（条目e：列表）{
System.out.print（e.getNum（）+“，”）；
}
}
}

您可以按如下方式实现

可比较的

接口（注意：根据Jon Skeet的评论，我修复了几个错误，并更改了几个变量名称以匹配约定）：

import java.util.ArrayList；
导入java.util.Collections；
导入java.util.List；
公共类条目实现了可比性{
私有整数；
私有字符串val；
公众进入（）{
this.num=0；
this.val=”“；
} 
公共void setNum（int num）{
this.num=num；
}
公共int getNum（）{
返回这个.num；
}
@凌驾
公共整数比较（条目）{
if（this.numentry.num）返回1；
返回0；
}
公共静态void main（字符串[]args）{
系统输出打印项次（“测试1”）；
test1（）；
System.out.println（“\n测试2”）；
test2（）；
}
公共静态void test1（）{
条目e1=新条目（）；
e1.setNum（5）；
条目e2=新条目（）；
e2.setNum（4）；
System.out.println（“e1=“+e1.getNum（）+”，e2=“+e2.getNum（）+”，e1.compareTo（e2）=“+e1.compareTo（e2））；
条目e3=新条目（）；
e3.setNum（5）；
System.out.println（“e1=“+e1.getNum（）+”，e3=“+e3.getNum（）+”，e1.compareTo（e3）：“+e1.compareTo（e3））；
条目e4=新条目（）；
e4.setNum（6）；
System.out.println（“e1=“+e1.getNum（）+”，e4=“+e4.getNum（）+”，e1.compareTo（e4）：“+e1.compareTo（e4））；
}
公共静态void test2（）{
列表=新的ArrayList（）；
int[]nums={5,3,9,25,1，-8}；
for（int i:nums）{
条目e=新条目（）；
e、 setNum（i）；
public class Entry implements Comparable<Entry> // Use Generics
{
  private int Num;
  private String Val;

  public MyClass()
  {
    this.Num = 0;
    this.Val = "";
  }

  // getters/seters()

  public int compareTo(Entry otherEntry)
  {
   int num2 = otherEntry.getNum();
   return num == num2 ? 0 :
          (num > num2 ? 1 : -1);
  }

}

List<Entry> lisOfEntries = new ArrayList<Entry>();
// populate the list; then sort using
Collections.sort(listOfEntries);

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class Entry implements Comparable<Entry> {
private int num;
private String val;

public Entry() {
    this.num = 0;
    this.val = "";
} 

public void setNum(int num) {
    this.num = num;
}

public int getNum() {
    return this.num;
}

@Override
public int compareTo(Entry entry) {
    if (this.num < entry.num) return -1;
    if (this.num > entry.num) return 1;
    return 0;
}

public static void main(String[] args) {
    System.out.println("TEST 1");
    test1();

    System.out.println("\nTEST 2");
    test2();
}

public static void test1() {
    Entry e1 = new Entry();
    e1.setNum(5);

    Entry e2 = new Entry();
    e2.setNum(4);
    System.out.println("e1 = " + e1.getNum() + ", e2 = " + e2.getNum() + ", e1.compareTo(e2) = " + e1.compareTo(e2));

    Entry e3 = new Entry();
    e3.setNum(5);
    System.out.println("e1 = " + e1.getNum() + ", e3 = " + e3.getNum() + ", e1.compareTo(e3): " + e1.compareTo(e3));

    Entry e4 = new Entry();
    e4.setNum(6);
    System.out.println("e1 = " + e1.getNum() + ", e4 = " + e4.getNum() + ", e1.compareTo(e4): " + e1.compareTo(e4));
}

public static void test2() {
    List<Entry> list = new ArrayList<Entry>();
    int[] nums = { 5, 3, 9, 25, 1, -8 };
    for (int i : nums) {
        Entry e = new Entry();
        e.setNum(i);
        list.add(e);
    }
    Collections.sort(list);

    System.out.print("Orig list: ");
    for (int i : nums) {
        System.out.print(i + ", ");
    }

    System.out.println();

    System.out.print("Sorted list: ");
    for (Entry e : list) {
        System.out.print(e.getNum() + ", ");
    }

}
}