我有一个public List<FriendProfile> friends = new ArrayList<FriendProfile>();. 我通过从服务器读取信息来初始化好友列表。FriendProfile 对象包含一个名为private int userPosition;
初始化朋友列表后，我想通过在列表的userPosition索引 0 处具有最高的 FriendProfile 对象对朋友列表进行排序，然后相应地排序，索引 1 具有第二高userPosition...
我想我可以编写一个排序算法，但我正在寻找预先编写的代码（也许 JDK 有一些方法可以提供？）
帮助表示赞赏！
使用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>。
实现可比接口。
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);
列表将被排序。
现在不需要装箱（即不需要OBJECT使用 new Operator 使用 valueOf 与 Collections.Sort 的 compareTo 来创建。）
1)升序
Collections.sort(temp, new Comparator<XYZBean>()
{
@Override
public int compare(XYZBean lhs, XYZBean rhs) {
return Integer.valueOf(lhs.getDistance()).compareTo(rhs.getDistance());
}
});
1)对于降序
Collections.sort(temp, new Comparator<XYZBean>()
{
@Override
public int compare(XYZBean lhs, XYZBean rhs) {
return Integer.valueOf(rhs.getDistance()).compareTo(lhs.getDistance());
}
});
使用Collections.Sort并编写一个Comparator基于userPosition.
将 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;
}
});
看到这个链接
有两种方法可以做到这一点。
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 的静态方法。
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();
}
}