Java对象的排序ArrayList

我有一个对象的

ArrayList

，我想按它们的值排序。基本上我有9个不同的数学函数（即，

f1（n）=logn

，

f2（n）=n

，

f3（n）=n logn

，等等）。我将值1插入到所有9个函数中，并将它们的结果放入对象的

ArrayList

，并将它们的标签附加到对象上，如下面的代码所示。我想对整个结果列表进行排序

ArrayList<Object>val1 = new ArrayList<Object>();
        val1.add("f\u2081(1) = " + log(funcValues[0]));
        val1.add("f\u2082(1) = " + funcValues[0]);
        val1.add("f\u2083(1) = " + exponent(funcValues[0]));
        val1.add("f\u2084(1) = " + f4(funcValues[0]));
        val1.add("f\u2085(1) = " + squared(funcValues[0]));
        val1.add("f\u2086(1) = " + cubed(funcValues[0]));
        val1.add("f\u2087(1) = " + twoN(funcValues[0]));
        val1.add("f\u2088(1) = " + factorial(funcValues[0]));
        val1.add("f\u2089(1) = " + f9(funcValues[0]));

ArrayListval1=新的ArrayList（）；
val1.add（“f\u2081（1）=”+log（funcValues[0]）；
val1.添加（“f\u2082（1）=”+funcValues[0]）；
val1.添加（“f\u2083（1）=”+指数（funcValues[0]）；
val1.添加（“f\u2084（1）=”+f4（funcValues[0]）；
值1.加上（“f\u2085（1）=”+平方（funcValues[0]）；
val1.添加（“f\u2086（1）=”+立方（funcValues[0]）；
val1.add（“f\u2087（1）=”+twoN（funcValues[0]）；
val1.添加（“f\u2088（1）=”+阶乘（funcValues[0]）；
val1.add（“f\u2089（1）=”+f9（funcValues[0]）；

基本上，无论你在哪里看到log，funcValues，exponent，f4，squared，等等，这些都是计算数学函数答案的函数。此ArrayList的输出为：

f₁（1） =0.0
f₂（1） =1
f₃（1） =1.0
f₄（1） =0.0
f₅(1) = 1
f₆（1） =1.0
f₇（1） =2.0
f₈（1） =1
f₉（1） =0.0

我只想对数字进行排序。我试着这样做：

class ValuesSorted implements Comparator<Object> {

        @Override
        public int compare(Object v1, Object v2) {
            if ()
            return 0;
        }
    }

类值比较器{
@凌驾
公共整数比较（对象v1、对象v2）{
如果（）
返回0；
}
}

我被if语句卡住了，因为我无法执行类似if（v1.getValue>v2.getValue）的操作，因为我使用了9个不同的函数调用来提取每个值

Simply try

---

您正在尝试跟踪两件事，值和标签。当你追踪两个相关的东西时，使用地图。在本例中，是一个已排序的映射，即树映射

TreeMap map = new TreeMap<Double, String>();
// for each function, map.put(value, label), e.g.
map.put(log(funcValues[0]), "f\u2081(1)");
...
map.put(f4(funcValues[0]),"f\u2084(1)");
...
map.put(f9(funcValues[0]), "f\u2089(1)");

TreeMap map=newtreemap（）；
//对于每个函数，map.put（值、标签），例如。
map.put（log（funcValues[0]），“f\u2081（1）”；
...
map.put（f4（funcvalue[0]），“f\u2084（1）”；
...
map.put（f9（funcvalue[0]），“f\u2089（1）”；

结果将按数值排序

map.values（）

将按排序顺序显示标签。

类对{
class Pair<X,Y>{

    private X first;
    private Y second;

    Pair(X first,Y second){
        this.first=first;
        this.second=second;
    }

    public X getX() {
        return first;
    }

    public void setX(X first) {
        this.first = first;
    }

    public Y getY() {
        return second;
    }

    public void setY(Y second) {
        this.second = second;
    }


    public Comparator<Pair<X, Y>> getComparator(){
        return new Comparator<Pair<X, Y>>() {

            @Override
            public int compare(Pair<X, Y> o1, Pair<X, Y> o2) {
                double a=(Double) o1.getY();
                double b=(Double) o2.getY();
                if(a==b){
                    return 0;
                }else if(a>b){
                    return 1;
                }else{
                    return -1;
                }
            }
        };
    }

}

public class Main{

    public static void main(String[] arg){

        List<Pair<String,Double>> val1 = new ArrayList<Pair<String,Double>>();

        val1.add(new Pair<String,Double>("f\u2081(1) = ", 0.1));
        val1.add(new Pair<String,Double>("f\u2082(1) = ", 0.2));
        val1.add(new Pair<String,Double>("f\u2083(1) = ", 0.1));
        val1.add(new Pair<String,Double>("f\u2084(1) = ", 1.1));
        val1.add(new Pair<String,Double>("f\u2085(1) = ", 1.2));
        val1.add(new Pair<String,Double>("f\u2086(1) = ", 2.0));
        val1.add(new Pair<String,Double>("f\u2087(1) = ", 2.1));
        val1.add(new Pair<String,Double>("f\u2088(1) = ", 0.3));

        Collections.sort(val1,new Pair<String,Double>("",0.0).getComparator());

        for (Pair<String, Double> pair : val1) {
            System.out.println(pair.getX()+" "+pair.getY());
        }
    }
}

私人X优先；
二等兵；
成对（X第一，Y第二）{
这个。第一=第一；
这个。秒=秒；
}
公共X getX（）{
先返回；
}
公共无效集合X（X优先）{
this.first=first；
}
公共场所{
返回第二；
}
公共空间设置（Y秒）{
这个秒=秒；
}
公共比较器getComparator（）{
返回新的比较器（）{
@凌驾
公共整数比较（对o1，对o2）{
double a=（double）o1.getY（）；
double b=（double）o2.getY（）；
如果（a==b）{
返回0；
}否则，如果（a>b）{
返回1；
}否则{
返回-1；
}
}
};
}
}
公共班机{
公共静态void main（字符串[]arg）{
List val1=new ArrayList（）；
val1.添加（新对（“f\u2081（1）=”，0.1））；
val1.添加（新对（“f\u2082（1）=”，0.2））；
val1.添加（新对（“f\u2083（1）=”，0.1））；
val1.添加（新对（“f\u2084（1）=”，1.1））；
val1.添加（新对（“f\u2085（1）=”，1.2））；
val1.add（新对（“f\u2086（1）=”，2.0））；
val1.添加（新对（“f\u2087（1）=”，2.1））；
val1.添加（新对（“f\u2088（1）=”，0.3））；
Collections.sort（val1，新对（“，0.0）.getComparator（））；
for（配对：val1）{
System.out.println（pair.getX（）+“”+pair.getY（））；
}
}
}

我建议您创建自己的自定义类，该类同时包含函数和值。重写

equals

、

hashCode

和

toString

方法，并为该类实现一个基于值字段排序的

比较器。Marc-还可以使用映射，请参阅我的答案。这与其说是答案，不如说是评论。@voidHead评论需要50reputation@Gaurav这不起作用，因为您不能在对象的Arraylist上使用Collections.sort。@Gaurav这不是检查。将答案视为对所提出问题的全面回答。这样你就可以写出一个好的答案。我这样做的时候，似乎只有三个结果输出，而值没有输出。例如，以下是输出：[f₉（1） =，f₈（1） =，f₇（1） =]Hmm，这是因为在本例中，只有3个不同的值，0.0、1.0和2.0。在一个“真实”的例子中，会有更多的变化吗？也就是说，不要使用1作为每个函数的参数，因为1平方=1立方=2等于（1）。如果你真的有重复的值，这个答案不起作用。
class Pair<X,Y>{

    private X first;
    private Y second;

    Pair(X first,Y second){
        this.first=first;
        this.second=second;
    }

    public X getX() {
        return first;
    }

    public void setX(X first) {
        this.first = first;
    }

    public Y getY() {
        return second;
    }

    public void setY(Y second) {
        this.second = second;
    }


    public Comparator<Pair<X, Y>> getComparator(){
        return new Comparator<Pair<X, Y>>() {

            @Override
            public int compare(Pair<X, Y> o1, Pair<X, Y> o2) {
                double a=(Double) o1.getY();
                double b=(Double) o2.getY();
                if(a==b){
                    return 0;
                }else if(a>b){
                    return 1;
                }else{
                    return -1;
                }
            }
        };
    }

}

public class Main{

    public static void main(String[] arg){

        List<Pair<String,Double>> val1 = new ArrayList<Pair<String,Double>>();

        val1.add(new Pair<String,Double>("f\u2081(1) = ", 0.1));
        val1.add(new Pair<String,Double>("f\u2082(1) = ", 0.2));
        val1.add(new Pair<String,Double>("f\u2083(1) = ", 0.1));
        val1.add(new Pair<String,Double>("f\u2084(1) = ", 1.1));
        val1.add(new Pair<String,Double>("f\u2085(1) = ", 1.2));
        val1.add(new Pair<String,Double>("f\u2086(1) = ", 2.0));
        val1.add(new Pair<String,Double>("f\u2087(1) = ", 2.1));
        val1.add(new Pair<String,Double>("f\u2088(1) = ", 0.3));

        Collections.sort(val1,new Pair<String,Double>("",0.0).getComparator());

        for (Pair<String, Double> pair : val1) {
            System.out.println(pair.getX()+" "+pair.getY());
        }
    }
}