Question

我一直试图找到可能的答案，但没有找到答案。

我有ArrayList个自定义对象。他们的一个字段是boolean。

我想首先放置此对象，保留其余元素

例如，如果我有这个列表，obj5是将此布尔值设置为true的那个：

obj3, obj2, obj5, obj7, obj9

我想得到这个：

obj5, obj3, obj2, obj7, obj9

编辑：可以使用LAMBDAS，JAVA 6

编辑2：请注意，列表的其余部分必须保留旧订单

编辑3：简而言之，我需要这个程序输出[B，A，C，D，E]：

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

public class Trip {

@Override
public String toString() {
    return name;
}

private String name;
private boolean freeCancellation;


public Trip(String name, boolean freeCancellation) {
    this.name = name;
    this.freeCancellation = freeCancellation;
}

static Comparator<Trip> myOrder = new Comparator<Trip>() {
    public int compare(Trip a, Trip b) {
        if (a.freeCancellation == b.freeCancellation) return 0;
        return a.freeCancellation ? -1 : 1;
    }
};

public static void main(String [] args){
    Trip t1 = new Trip("A", false);
    Trip t2 = new Trip("B", true);
    Trip t3 = new Trip("C", false);
    Trip t4 = new Trip("D", true);
    Trip t5 = new Trip("E", false);


    List<Trip> tripList = new ArrayList<>();
    tripList.add(t1);
    tripList.add(t2);
    tripList.add(t3);
    tripList.add(t4);
    tripList.add(t5);

    System.out.println(Arrays.toString(tripList.toArray()));
    Collections.sort(tripList, myOrder);
    //result should be [B, A, C, D, E]
    System.out.println(Arrays.toString(tripList.toArray()));
}

}

Answer 1

写一个Comparator。

Comparator<MyType> myOrder = new Comparator<MyType>() {
    public int compare(MyType a, MyType b) {
         return (b.booleanField() ? 1 : 0) - (a.booleanField() ? 1 : 0);
    }
}

使用此比较器排序。

Collections.sort(myList, myOrder);

请参阅Collections.sort

修改

因此，您实际要求的是将仅一个匹配元素移动到列表的前面。这应该很容易。

找到要移动的元素的索引：

int foundIndex = -1;
for (int i = 0; i < tripList.size(); ++i) {
    if (tripList.get(i).freeCancellation) {
        foundIndex = i;
        break;
    }
}

如果您找到这样的元素，并且它尚未在开头，请将其移至开头：

if (foundIndex > 0) {
    tripList.add(0, tripList.remove(foundIndex));
}

Answer 2

以下是如何实现此目标的示例：

class Element {
    public boolean shouldBeFirst();
}

List<Element> elements;
elements.sort(Comparator.comparing(Element::shouldBeFirst));

这是有效的，因为首先是布尔的自然顺序。

如果你不能使用Java 8，那么等价物将是：

Collections.sort(elements, new Comparator() {
    int compareTo(Element el1, Element el2) {
        return (el1.shouldBeFirst() ? 1 : 0) - (el2.shouldBeFirst() ? 1 : 0);
    }
}

Answer 3

 List<Object> objList = findObj(name);Collections.sort(objList, new Comparator<Object>() {
    @Override
    public int compare(Object a1, Object a2) {
        return (a1.getBooleanField()== a2.getBooleanField())?0:(a1.getBooleanField()?1:-1);
    }});

这可能有助于您解决此问题。您可以通过更改比较逻辑来修改结果

Answer 4

import java.util.*;

public class Test {

    public static void main(String[] args) {
        List<A> list = new ArrayList<A>();
        list.add(new A(true));
        list.add(new A(false));
        list.add(new A(true));
        list.add(new A(false));
        Collections.sort(list);
        System.out.println(list);
    }

}

class A implements Comparable<A> {
    private boolean b;

    public A(boolean b) {
        this.b = b;
    }

    public boolean isB() {
        return b;
    }

    public void setB(boolean b) {
        this.b = b;
    }

    @Override
    public int compareTo(A a) {
        return a.isB() ? 1 : -1;
    }

    @Override
    public String toString() {
        return "A [b=" + b + "]";
    }



}

也许这就是你要找的东西。如果你想给对象赋予自然顺序，然后实现Comparable并使用Collections.sort - https://docs.oracle.com/javase/6/docs/api/java/util/Collections.html#sort(java.util.List)，这就是解决方案。如果你在课堂上有各种各样的成员，那么也许可以使用Comparator实现，这样你就可以实现基于不同成员对对象进行排序的多种方式。

Answer 5

如果我理解你在问什么，你需要创建一个名为＆＃34; Comparators＆＃34;的新课程。在这个课程中，你需要定义你的方法，他们需要static final ... 然后你可以通过致电Collections.sort(-your array-, Comparator method name);

来使用它

仅获取与条件匹配的ArrayList的第一个元素

5 个答案:

修改