使用比较器或多个比较器进行优先级排序？

Question

所以我有一个FlashCards的大LinkedList，1000卡，用于flashcard应用程序。有些以前从未见过，有些已经被看到过，并且多次猜测正确或不正确。

有了这么多的卡片，我想要那些我从来没有注意到的名单上的第一个，其次是那些比他们被钉了更多的错过。

理想情况下，这将是一般规则，并不总是如此;仍然会有一张我以前见过的偶尔卡片，但其中大多数卡片是看不见的。

另外，现在我正在使用Collections.shuffle（），在上述标准中，我仍然希望卡片随机出现。

我刚熟了这个比较：

public class TimesSeenComparator implements Comparator<Card> { 
    public int compare(Card one, Card two){ 
     boolean oneNeverSeen = false; 
     boolean twoNeverSeen = false; 
     if(one.getMissed() + one.getMade() == 0){ oneNeverSeen = true; } 
     if(two.getMissed() + two.getMade() == 0){ twoNeverSeen = true; } 
     if(oneNeverSeen && twoNeverSeen){ return 0; } 

     if(one.getMissed() > two.getMissed()){ 
      return 1; 
     } else if(one.getMissed() == two.getMissed()){ 
      return 0; 
     } else{ 
      return -1; 
     } 
    } 

} 

它非常艰难，我知道！任何帮助表示赞赏。

编辑： 最后一个比较合作伙伴视其合同，我显然是想在一个比较器中做太多。如果您有几个比较器，然后执行Collections.sort（x，comp1），它将如何工作; Collections.sort（X，COMP2）; Collections.sort（X，COMP3）; ？

public class TimesSeenComparator implements Comparator<Card> { 
    public int compare(Card one, Card two){ 
     boolean oneNeverSeen = false; 
     boolean twoNeverSeen = false; 
     if(one.getMissed() + one.getMade() == 0){ oneNeverSeen = true; } 
     if(two.getMissed() + two.getMade() == 0){ twoNeverSeen = true; } 

     if(oneNeverSeen && !twoNeverSeen){ 
      return 1; 
     } else if(oneNeverSeen && twoNeverSeen){ 
      return 0; 
     } else { 
      return -1; 
     } 
    } 

} 

Answer 1

我不知道你煮了比较那么我要回答这个问题：

有了这么多的卡我想，我从来没有奠定眼睛的人就成为第一位名单，然后是那些比他们被钉的更多的错过。

理想情况下，这将是一般规则，并不总是如此;仍然会有一张我以前见过的偶尔卡片，但其中大多数卡片是看不见的。

下面的代码会做你想要什么：

List<Card> cards; 

List<Card> neverSeen = new ArrayList<>(); 
List<Card> missedMore = new ArrayList<>(); 
List<Card> other = new ArrayList<>(); 

for (Card card : cards) { 
    if (card.getMade() == 0 && card.getMissed() == 0) { 
     neverSeen.add(card); 
    } else if (card.getMissed() > card.getMade()) { 
     // Add about 1 in 10 to the beginning 
     if (Math.random() < 0.1) { 
      neverSeen.add(card); 
     } else { 
      missedMore.add(card); 
     } 
    } else { 
     // Add about 1 in 20 to the beginning 
     if (Math.random() < 0.05) { 
      neverSeen.add(card); 
     } else { 
      other.add(card); 
     } 
    } 
} 

Collections.shuffle(neverSeen); 
Collections.shuffle(missedMore); 
Collections.shuffle(other); 

neverSeen.addAll(missedMore); 
neverSeen.addAll(other); 

cards = neverSeen; 

注：

• Collections.sort（X，COMP1）; Collections.sort（X，COMP2）; Collections.sort（X，COMP3）;
  与Collections相同。排序（X，COMP3）;
  如果你想使用多个比较可以使用ComparatorChain
  或Java 8 Comparator.comparing.thenComparing
• 它几乎总是更好（更快）使用ArrayList比LinkedList的

Answer 2

考虑比较与收藏的基本的例子：

// Create and initialize linked list 
     LinkedList ll = new LinkedList(); 
     ll.add(new Integer(-8)); 
     ll.add(new Integer(20)); 
     ll.add(new Integer(-20)); 
     ll.add(new Integer(8)); 
// Create a reverse order comparator 
     Comparator r = Collections.reverseOrder(); 
// Sort list by using the comparator 
     Collections.sort(ll, r); 
     // Get iterator 
     Iterator li = ll.iterator(); 
System.out.print("List sorted in reverse: "); 
while(li.hasNext()) 
    System.out.print(li.next() + " "); 
System.out.println(); 
Collections.shuffle(ll); 
// display randomized list 
li = ll.iterator(); 
System.out.print("List shuffled: "); 
while(li.hasNext()) 
    System.out.print(li.next() + " "); 
System.out.println(); 
System.out.println("Minimum: " + Collections.min(ll)); 
System.out.println("Maximum: " + Collections.max(ll)); 

输出将是：

同样，你可以通过初始化像这样使用多个类别：

// Create a reverse order comparator 
     Comparator r1 = Collections.reverseOrder(); 
     Collections.sort(ll, r1); 

     Comparator r2 = Collections.reverseOrder(); 
     Collections.sort(ll, r2); 

     Comparator r3 = Collections.reverseOrder(); 
     Collections.sort(ll, r3); 

并通过迭代器访问它。它取决于你想用什么方法。我在这里使用reverseOrder（），但你可以根据你的逻辑使用。我希望这会帮助你。 谢谢！