Использование сопоставления для сортировки ArrayList

Question

Пытаясь использовать Comparable, я довольно новичок в программировании и никогда не сортировал ArrayList. Я рассмотрел некоторые другие примеры переполнения стека и посмотрел на Java Doc, но это довольно запутанно, я не уверен, как применить его к моей программе.

По существу у меня есть два класса: класс Personality и класс PersonalityList , Класс PersonalityList включает массив персонажей, называемый личностями, в котором хранится множество объектов личности в списке массивов.

Мне нужно отсортировать его по количеству голосов, которое имеет каждая Личность. Метод top (int topValue) должен возвращать новый массив длины topValue, с объектами Personality с наивысшим количеством голосов.

Я понимаю, что мне нужно использовать некоторые Comparable в моем классе Personality, но не уверен, как это сделать.

Это мой PersonalityList класс до сих пор:

import java.util.ArrayList; 
import java.util.Iterator; 
import java.util.Collections; 

public class PersonalityList 
{ 
    private ArrayList<Personality> personalities; //Create ArrayList of Personality, called personalities. 
    private ArrayList<Personality> sortedPersonalities; 

    /** 
    * Constructor for objects of class PersonalityList 
    */ 
    public PersonalityList() 
    { 
     personalities = new ArrayList<Personality>(); //Initialise personalities ArrayList. 
     sortedPersonalities = new ArrayList<Personality>(); 
    } 

    /** 
    * Adds a personality to the ArrayList of Personality, called personalities. 
    */ 
    public void addPersonality(Personality personality) 
    { 
     personalities.add(personality); 
    } 

    /** 
    * Returns the number of Personality objects in the ArrayList 
    */ 
    public int getSize() 
    { 
     return personalities.size(); 
    } 

    /** 
    * Lists the details of all the Personality objects stored in the ArrayList 
    */ 
    public void list() 
    { 
     System.out.println("Personality List"); 

     for(Personality personality : personalities) { //Iterates through each personality in ArrayList 
      System.out.println(personality.getDetails()); 
     } 

     System.out.println(); 
    } 

    /** 
    * Adds one vote to the personality which matches the name entered into the method 
    */ 
    public void voteFor(String name) 
    { 
     boolean nameFound = false; //Boolean variable to identify if the personality has been found 
     int index = 0; 

     while (index < personalities.size() && !nameFound) { 
      Personality personality = personalities.get(index); 
      String compName = personality.getName(); 

      if (compName.equals(name)) { //Adds a vote if the name is found 
       personality.increaseVotes(1); 
       nameFound = true; 
      } 

      index++; 
     } 

     if (nameFound == false) { //Error message if name not found 
      System.out.println(name + " could not be found."); 
     } 
    } 

    /** 
    * Removes personalities if they have less votes than the parameter value 
    */ 
    public void shortlist(int minimumVotes) 
    { 
     Iterator<Personality> it = personalities.iterator(); 

     while(it.hasNext()) { 
      Personality personality = it.next(); 
      int currentP = personality.getVotes(); 

      if (currentP < minimumVotes) { 
       it.remove(); 
      } 
     } 
    } 



    /** 
    * 
    */ 
    public Personality top(int topValue) 
    { 
     int index = 0; 
     int listSize = personalities.size(); 

     if (topValue > listSize) { 
      topValue = listSize; 
     } 

     if(listSize > 0) { 

      //Coppies the ArrayList personalities to the sortedPersonalities ArrayList 
      while(index < topValue) { 
       Personality sortedPersonality = personalities.get(index); 
       sortedPersonalities.add(sortedPersonality); 
       System.out.println(sortedPersonality.getDetails()); 
       index++; 
      } 

      Collections.sort(sortedPersonalities, Collections.reverseOrder(new Personality.votesComparator())); 
      System.out.println("Sorted by Votes"); 
      System.out.println("\t" + people); 
     } 
     else { 
      System.out.println("No personalities are currently in the Array List"); 
     } 

     return sortedPersonalities ; 
    } 
} 

Спасибо заранее.

Answer 1

Или вы можете легко выполнять сравнение между объектом с помощью лямбда-выражения, как показано ниже:

Предположим, что у нас есть список Лица с их возрастами;

 List<Person> peopleList =new ArrayList<Person>(); 
     peopleList.add(new Person("Ann", 23)); 
     peopleList.add(new Person("Sam", 22)); 
     peopleList.add(new Person("John", 20)); 
     peopleList.add(new Person("Watson", 23)); 
     peopleList.add(new Person("Samuels", 31)); 
     peopleList.add(new Person("Peter",41)); 
     peopleList.add(new Person("Harry", 28)); 
     peopleList.add(new Person("Carter", 19)); 
     peopleList.add(new Person("Lilly", 26)); 
     peopleList.add(new Person("Kumar", 12)); 
     peopleList.add(new Person("Insaf", 51)); 

Мы можем сравнить эти люди, используя свой возраст с Comparator интерфейсом

Comparator<Person> personComparatorByAgeUsingStream =(Person b1,Person b2)->{return ((Integer)b1.getAge()).compareTo((Integer)b2.getAge());}; 

Тогда мы можем сортировать этих людей в список:

List<Person> streamSort= peopleList 
         .stream() 
      .sorted(personComparatorByAgeUsingStream).collect(Collectors.toList()); 

streamSort.forEach(x->{System.out.println(x.getName()+" is "+x.getAge()+" years old.");}); 

Answer 2

Вот моя попытка показать полный пример создания компаратор для пользовательского объекта:

/* 
** Use the Collections API to sort a List for you. 
** 
** When your class has a "natural" sort order you can implement 
** the Comparable interface. 
** 
** You can use an alternate sort order when you implement 
** a Comparator for your class. 
*/ 
import java.util.*; 

public class Person implements Comparable<Person> 
{ 
    String name; 
    int age; 

    public Person(String name, int age) 
    { 
     this.name = name; 
     this.age = age; 
    } 

    public String getName() 
    { 
     return name; 
    } 

    public int getAge() 
    { 
     return age; 
    } 

    public String toString() 
    { 
     return name + " : " + age; 
    } 

    /* 
    ** Implement the natural order for this class 
    */ 
    public int compareTo(Person p) 
    { 
     return getName().compareTo(p.getName()); 
    } 

    static class AgeComparator implements Comparator<Person> 
    { 
     public int compare(Person p1, Person p2) 
     { 
      return p1.getAge() - p2.getAge(); 
     } 
    } 

    public static void main(String[] args) 
    { 
     List<Person> people = new ArrayList<Person>(); 
     people.add(new Person("Homer", 38)); 
     people.add(new Person("Marge", 35)); 
     people.add(new Person("Bart", 15)); 
     people.add(new Person("Lisa", 13)); 

     // Sort by natural order 

     Collections.sort(people); 
     System.out.println("Sort by Natural order"); 
     System.out.println("\t" + people); 

     // Sort by reverse natural order 

     Collections.sort(people, Collections.reverseOrder()); 
     System.out.println("Sort by reverse natural order"); 
     System.out.println("\t" + people); 

     // Use a Comparator to sort by age 

     Collections.sort(people, new Person.AgeComparator()); 
     System.out.println("Sort using Age Comparator"); 
     System.out.println("\t" + people); 

     // Use a Comparator to sort by descending age 

     Collections.sort(people, Collections.reverseOrder(new Person.AgeComparator())); 
     System.out.println("Sort using Reverse Age Comparator"); 
     System.out.println("\t" + people); 
    } 
} 

Answer 3

Список может содержать элемент в два раза , В этом случае кто будет первым и кто второй? Ответ туманный, поэтому они решают не иметь список, отсортированный с помощью компаратора.

Возможно, вы ищете TreeSet (у кого есть естественная поддержка comperable)? A Set не может содержать элемент несколько раз.

Вы можете сказать: Эй, у меня действительно есть коллекции без дубликатов, но я всегда использую списки!. Да, это широко распространенная ошибка.

Пожалуйста, используйте Set, чтобы мир знал: нет дубликатов.