Question

我有两个ArrayList<JLabel> label1 = new ArrayList<JLabel>(); ArrayList<JLabel> label2 = new ArrayList<JLabel>();：

label1

label2包含名称（如“John”或“car”）和Collections.sort(label2, new Sort());包含评级（如“8.5”或“10.0”）。我想通过评级对两个列表进行排序。

我已使用label2对label1进行排序，但我不知道如何以相同的方式（使用label2个对象）对ex Comparator进行排序。这是我的class Sort implements Comparator<JLabel>{ public int compare(JLabel o1, JLabel o2) { Double a = Double.parseDouble(o1.getText()); Double b = Double.parseDouble(o2.getText()); return b.compareTo(a); } }课程：

{{1}}

有什么想法吗？

Answer 1

鉴于您在两个列表之间没有定义任何关系，我认为您应该考虑将这两个值包装在一个类中：

class Foo {

   private String name;
   private double rating;

   public Foo(String name, double rating){
       this.name = name;
       this.rating = rating;
   }

   // getters & setters
}

然后，您可以List<Foo>并根据评级值对列表进行排序。

在Java 8中，这就像调用sort()中提供的List方法一样简单，传入了lambda表达式。

Answer 2

让我们使用Map来解决这个问题。我们首先定义一个比较器来按值降序排序，如下所示：

class NumericComparator extends Comparator {
    Map map;
    public NumericComparator(Map map) {
        this.map = map;
    }

    public int compare(Object o1, Object o2) {
        return ((Integer) map.get(o2)).compareTo((Integer) map.get(o1));
    }
}

我们将名称定义为键，将评级定义为值。像这样：

Map<String, Double> carMap = new HashMap<>();
//we can populate the map like so:
carMap.put("John", 10d); //works nicely in loops

然后我们获取未排序的地图，并将其所有值插入到TreeMap中，该NumericComparator实现我们之前定义的NumericComparator nc = new NumericComparator(carMap); Map<String, Double> sortedMap = new TreeMap(nc); sortedMap.putAll(carMap);。

<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml">

<head>
    <title></title>
    <meta name="viewport" content="width=device-width, initial-scale=1, user-scalable=yes">

    <style type="text/css">
        body {
            margin: 0;
            padding: 0;
        }
        .orientation {
            position: absolute;
            overflow: hidden;
            top: 0;
            left: 0;
            height: 100%;
            width: 100%;
            min-width: 200px;
            min-height: 200px;
            opacity: 0;
        }

        .orientation .outerDiv {
            position: absolute;
            overflow: hidden;
            height: 100%;
            width: 100%;
        }
        .orientation .innerDiv {
            position: absolute;
            overflow: hidden;
            left: 50%;
            top: 50%;
            margin-left: -100px;
            margin-top: -100px;
            background-image: url('rotate.gif');
            background-repeat: no-repeat;
            width: 200px;
            height: 200px;
        }

        @-webkit-keyframes show-out {
            0% {
                opacity: 1;
            }
            100% {
                opacity: 0;
            }
        }
        @keyframes show-out {
            0% {
                opacity: 1;
            }
            100% {
                opacity: 0;
            }
        }

        @media all and (orientation: portrait) {
            .orientation {
                opacity: 0;
                animation-name: show-out;
                animation-duration: 0.5s;
                 animation-delay: 2s;
                animation-fill-mode: backwards;
                animation-timing-function: linear;
            }
        }
        @media all and (orientation: landscape) {
            .orientation {}
        }
    </style>
</head>
<body>
    <div class="orientation">
        <div class="outerDiv">
            <div class="innerDiv"><img src="https://upload.wikimedia.org/wikipedia/en/2/21/EverestfromKalarPatarcrop.JPG" alt=""></div>
        </div>
    </div>
</body> 
</html>

Answer 3

首先，请编程到List界面。接下来，我假设您可以使用apache库，Pair<L, R>中有apache commons-lang（或者您可以实现自己的元组类;或者使用其他类似this one）。无论如何，您需要修改您的Comparator以在右侧操作（我个人喜欢使用左侧来打破关系）。最后，如果您想使用label1和label2，则需要将值复制回来（排序后）。像，

List<JLabel> label1 = new ArrayList<>();
List<JLabel> label2 = new ArrayList<>();
// ...
List<Pair<JLabel, JLabel>> pairs = new ArrayList<>();
int len = label1.size();
if (len == label2.size()) {
    for (int i = 0; i < len; i++) {
        pairs.add(Pair.of(label1.get(i), label2.get(i)));
    }
    Collections.sort(pairs, new Comparator<Pair<JLabel, JLabel>>() {
        @Override
        public int compare(Pair<JLabel, JLabel> o1,
                Pair<JLabel, JLabel> o2) {
            double a = Double.parseDouble(o1.getRight().getText());
            double b = Double.parseDouble(o2.getRight().getText());
            int ret = Double.compare(a, b);
            if (ret != 0) {
                return ret;
            } // if ret is 0, it's a tie.
            return o1.getLeft().getText()
                    .compareTo(o2.getLeft().getText());
        }
    });
    // ... only if you need to use label1 and label2 after the sort.
    for (int i = 0; i < len; i++) {
        label1.set(i, pairs.get(i).getLeft());
        label2.set(i, pairs.get(i).getRight());
    }
}

Answer 4

很好的问题 - 在棋盘游戏应用中通过骰子投掷排序玩家订单时，我也很麻烦。

在新的总对象或地图中绑定两个列表的前一个答案（当所有字符串都是唯一的时候）很好。

但如果你确实想要更简单的东西，那么这就是这个我最初这样做没有引用原始比较列表的深层副本，它正在进行一些排序和一些奇怪的条目混合。。。最终我看到了光线并制作了原始列表的深拷贝（label11）。还要确保将排序代码放入私有方法，以便能够访问两个列表，label11＆amp; label2，通过排序比较器的重写比较（..）方法。

 . . . .
 . . . .

ArrayList<JLabel> label1 = new ArrayList<JLabel>(); // String list
ArrayList<JLabel> label2 = new ArrayList<JLabel>(); // Double list 
System.out.println("Original String list : " + label1); // Check original list
sortByValue(label1, label2);  // Sort label1 by label2 order descending
System.out.println("Sorted String list: " + label1);    // Check sorted list

. . . . 
. . . . 

/** Private static method to facilitate access to list being sorted and 
  * the list used as a sort criterion by the code in the sort Comparator's 
  * overriding compare(..) method. */
private static void sortByValue(ArrayList<JLabel> label1,
                                ArrayList<JLabel> label2)
{
   ArrayList<JLabel> label11 = 
     new ArrayList<JLabel>(label1);     // Deep copy original string list
   Collections.sort(list1, new Comparator<JLabel>()
   {
     @Override
     public int compare(JLabel x, JLabel y)
     {
      return                            // Sort by descending label2 values
       (Double.parseDouble(label2.get(label11.indexOf(y)).getText())
        -Double.parseDouble(label2.get(label11.indexOf(x)).getText()))
        .intValue();
     }
   });
}

如何根据另一个ArrayList对ArrayList进行排序？

4 个答案: