Question

我有public List<FriendProfile> friends = new ArrayList<FriendProfile>();。我通过从服务器读取信息来初始化好友列表。 FriendProfile对象包含一个名为private int userPosition;

的int

一旦朋友列表被初始化，我想通过在列表的索引0处具有最高userPosition的FriendProfile对象来排序朋友列表，然后相应地排序，索引1具有第二高userPosition ...

我想我可以写一个排序算法，但我正在寻找预先编写的代码（也许JDK有一些提供的方法？）

非常感谢帮助！

Answer 1

使用Collections.sort()并指定Comparator：

Collections.sort(friends,
                 new Comparator<FriendProfile>()
                 {
                     public int compare(FriendProfile o1,
                                        FriendProfile o2)
                     {
                         if (o1.getUserPosition() ==
                                 o2.getUserPosition())
                         {
                             return 0;
                         }
                         else if (o1.getUserPosition() <
                                      o2.getUserPosition())
                         {
                             return -1;
                         }
                         return 1;
                     }
                 });

或让FriendProfile实施Comparable<FriendProfile>。

Answer 2

实施可比接口。

class FriendProfile implements Comparable<FriendProfile> {

    private int userPosition;

    @Override
    public int compareTo(FriendProfile o) {

        if(this.userPosition > o.userPosition){
            return 1;
        }
        return 0;
    }

}

只需调用Collection.sort（List）方法。

    FriendProfile f1=new  FriendProfile();
    f1.userPosition=1;
    FriendProfile f2=new  FriendProfile();
    f2.userPosition=2;
    List<FriendProfile> list=new ArrayList<FriendProfile>();
    list.add(f2);
    list.add(f1);
    Collections.sort(list);

列表将被排序。

Answer 3

现在不需要拳击（即无需使用新的运算符创建OBJECT使用valueOf使用compareTo of Collections.Sort ..）

1）升序

Collections.sort(temp, new Comparator<XYZBean>() 
{
     @Override
     public int compare(XYZBean lhs, XYZBean rhs) {

       return Integer.valueOf(lhs.getDistance()).compareTo(rhs.getDistance());
      }
 });

1）对于Deascending order

Collections.sort(temp, new Comparator<XYZBean>() 
{
     @Override
     public int compare(XYZBean lhs, XYZBean rhs) {

       return Integer.valueOf(rhs.getDistance()).compareTo(lhs.getDistance());
      }
 });

Answer 4

使用Collections.Sort并撰写基于Comparator进行比较的自定义userPosition。

Answer 5

将Comparator与Collections.sort方法一起使用

java.util.Collections.sort(list, new Comparator<FriendProfile >(){
     public int compare(FriendProfile a,  FriendProfile b){
          if(a.getUserPosition() > b.getUserPosition()){
             return 1;
           }else if(a.getUserPosition() > b.getUserPosition()){
            return -1;
         }
          return 0;
     }
});

请参阅此link

Answer 6

有两种方法可以做到这一点。

1。 FriendProfile可以实现Comparable接口。

public class FriendProfile implements Comparable<FriendProfile>
{
   public int compareTo(FriendProfile that)
   {
     // Descending order
     return that.userPosition - this.userPosition;
   }
}

...

Collections.sort(friendProfiles);

2。你可以写一个比较器。

public class FriendProfileComparator implements Comparator<FriendProfile>
{
   public int compare(FriendProfile fp1, FriendProfile fp2) 
   {
     // Descending order
     return fp2.userPosition - fp1.userPosition;
   }
}

...

Collections.sort(friendProfiles, new FriendProfileComparator());

比较对象而不是基元时，请注意您可以委托包装对象compareTo。例如return fp2.userPosition.compareTo(fp1.userPosition)

如果对象具有您想要实现的自然顺序，则第一个很有用。例如Integer实现数字顺序，String实现字母顺序。如果您在不同情况下需要不同的订单，则第二个非常有用。

如果你写一个比较器，那么你需要考虑把它放在哪里。由于它没有状态，你可以把它写成Singleton，或者是FriendProfile的静态方法。

Answer 7

You can use java.lang.Comparable接口，如果您只想以单向排序。

But if you want to sort 以多种方式使用java.util.Compartor接口。

例如：

要在其roll_nos

上对其对象进行排序的类

public class Timet {

    String name;
    int roll_no;

    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getN() {
        return roll_no;
    }
    public void setN(int n) {
        this.roll_no = n;
    }
    public Timet(String name, int n) {

        this.name = name;
        this.roll_no = n;
    }

    public String toString(){
        return this.getName();



    }

}

排序类：

public class SortClass {


    public void go(){

        ArrayList<Timet> arr = new ArrayList<Timet>();
        arr.add(new Timet("vivek",5));
        arr.add(new Timet("alexander",2));
        arr.add(new Timet("catherine",15));

        System.out.println("Before Sorting :"+arr);





        Collections.sort(arr,new SortImp());

        System.out.println("After Sorting :"+arr);


    }
    class SortImp implements Comparator<Timet>{

        @Override
        public int compare(Timet t1, Timet t2) {




            return new Integer(t1.getN()).compareTo (new Integer((t2.getN())));
        }



    }
    public static void main(String[] args){

        SortClass s = new SortClass();
        s.go();

    }

}

排序列表＆lt;＆gt;按数值

7 个答案: