Java-获取对象的arrayList中最常见的元素

我有一个

ArrayList

如下所示：

ArrayList<TravelData> listOfTravels;

以下是我初始化arrayList的方式：

listOfTravels.add(new TravelData(1,"group a", "Ross"));
listOfTravels.add(new TravelData(2,"group a", "Chandler"));
listOfTravels.add(new TravelData(3,"group a", "Monica"));
listOfTravels.add(new TravelData(4,"group b", "Phoebe"));
listOfTravels.add(new TravelData(5,"group b", "Rachel"));
listOfTravels.add(new TravelData(6,"group c", "Joey"));
listOfTravels.add(new TravelData(7,"group c", "Rachel"));
listOfTravels.add(new TravelData(8,"group d", "Chandler"));

我想获得该列表中最常见的3个组和指南。 在本例中：

Top 3 groups: "group a", "group b", "group c"
Top 3 guides: "Rachel", "Chandler", "Ross"

（导游的第三名可能是其他人，因为罗斯、莫妮卡、菲比和乔伊的出场次数相同）

---

我找到了这样的好答案，但它只适用于整数的数组列表，并且只显示第一个最常见的元素。

您可以为

组创建一个
hashMap
结构，其中
键将是
组名
，值将是出现的次数

然后，只需按值对
hashMap
结构进行排序
降序
即可得到结果。
您可以为
组创建
hashMap
结构，其中
键将为
组名
，值将为出现次数

然后，只需按值对
hashMap
结构进行排序
降序
，并获得结果。
试试这个方法，它会对您有所帮助

public class TravelData {
int id;
String groupName;
public String getGroupName() {
    return groupName;
}

public String getGuideName() {
    return guideName;
}

String guideName;

public TravelData(int id, String groupName, String guideName) {
    this.id = id;
    this.groupName = groupName;
    this.guideName = guideName;
}

public static void getcommonGroups(ArrayList<TravelData>  list){
    Map<String, Integer> wordMap = new HashMap<String, Integer>();

    for(TravelData td:list){
        if(wordMap.containsKey(td.getGroupName())){
            wordMap.put(td.getGroupName(), wordMap.get(td.getGroupName())+1);
        } else {
            wordMap.put(td.getGroupName(), 1);
        }
    }

    List<Map.Entry<String, Integer>> sortedList = sortByValue(wordMap);
    for(Map.Entry<String, Integer> entry:sortedList){
        System.out.println(entry.getKey()+" ===="+entry.getValue());
    } }

  public static List<Map.Entry<String, Integer>> sortByValue(Map<String, Integer> 
  wordMap)  {

    Set<Map.Entry<String, Integer>> set = wordMap.entrySet();
    List<Map.Entry<String, Integer>> list = new ArrayList<Map.Entry<String, Integer>>(set);
    Collections.sort( list, new Comparator<Map.Entry<String, Integer>>()
    {
        public int compare( Map.Entry<String, Integer> o1, Map.Entry<String, Integer> o2 )
        {
            return (o2.getValue()).compareTo( o1.getValue() );
        }
    } );
    return list;
}


public static  void main(String args[]){
    ArrayList<TravelData> listOfTravels=new ArrayList() ;
    listOfTravels.add(new TravelData(1,"group a", "Ross"));
    listOfTravels.add(new TravelData(2,"group a", "Chandler"));
    listOfTravels.add(new TravelData(3,"group a", "Monica"));
    listOfTravels.add(new TravelData(4,"group b", "Phoebe"));
    listOfTravels.add(new TravelData(5,"group b", "Rachel"));
    listOfTravels.add(new TravelData(6,"group c", "Joey"));
    listOfTravels.add(new TravelData(7,"group c", "Rachel"));
    listOfTravels.add(new TravelData(8,"group d", "Chandler"));
    getcommonGroups(listOfTravels);
}}

公共类旅行数据{
int-id；
字符串组名；
公共字符串getGroupName（）{
返回groupName；
}
公共字符串getGuideName（）{
返回指南名称；
}
字符串名称；
公共TravelData（int id、字符串groupName、字符串guideName）{
this.id=id；
this.groupName=groupName；
this.guideName=guideName；
}
公共静态无效getcommonGroups（ArrayList列表）{
Map wordMap=newhashmap（）；
对于（TravelData td:list）{
if（wordMap.containsKey（td.getGroupName（）））{
put（td.getGroupName（），wordMap.get（td.getGroupName（））+1）；
}否则{
put（td.getGroupName（），1）；
}
}
List sortedList=sortByValue（wordMap）；
用于（地图条目：sortedList）{
System.out.println（entry.getKey（）+“=”+entry.getValue（））；
} }
公共静态列表sortByValue（映射
文字地图）{
Set=wordMap.entrySet（）；
列表=新的ArrayList（集合）；
Collections.sort（list，newcomparator（）
{
公共整数比较（映射项o1，映射项o2）
{
return（o2.getValue（））.compareTo（o1.getValue（））；
}
} );
退货清单；
}
公共静态void main（字符串参数[]）{
ArrayList listOfTravels=新的ArrayList（）；
添加（新的旅行数据（1，“a组”、“罗斯”）；
添加（新的旅行数据（2，“a组”、“钱德勒”）；
添加（新的TravelData（3，“a组”、“Monica”）；
添加（新的TravelData（4，“b组”、“Phoebe”）；
添加（新的TravelData（5，“b组”、“Rachel”）；
添加（新的旅行数据（6，“c组”、“乔伊”）；
添加（新的TravelData（7，“c组”、“Rachel”）；
添加（新的旅行数据（8，“d组”、“钱德勒”）；
GetCommonGroup（旅行列表）；
}}
试试这个，它会帮你的

public class TravelData {
int id;
String groupName;
public String getGroupName() {
    return groupName;
}

public String getGuideName() {
    return guideName;
}

String guideName;

public TravelData(int id, String groupName, String guideName) {
    this.id = id;
    this.groupName = groupName;
    this.guideName = guideName;
}

public static void getcommonGroups(ArrayList<TravelData>  list){
    Map<String, Integer> wordMap = new HashMap<String, Integer>();

    for(TravelData td:list){
        if(wordMap.containsKey(td.getGroupName())){
            wordMap.put(td.getGroupName(), wordMap.get(td.getGroupName())+1);
        } else {
            wordMap.put(td.getGroupName(), 1);
        }
    }

    List<Map.Entry<String, Integer>> sortedList = sortByValue(wordMap);
    for(Map.Entry<String, Integer> entry:sortedList){
        System.out.println(entry.getKey()+" ===="+entry.getValue());
    } }

  public static List<Map.Entry<String, Integer>> sortByValue(Map<String, Integer> 
  wordMap)  {

    Set<Map.Entry<String, Integer>> set = wordMap.entrySet();
    List<Map.Entry<String, Integer>> list = new ArrayList<Map.Entry<String, Integer>>(set);
    Collections.sort( list, new Comparator<Map.Entry<String, Integer>>()
    {
        public int compare( Map.Entry<String, Integer> o1, Map.Entry<String, Integer> o2 )
        {
            return (o2.getValue()).compareTo( o1.getValue() );
        }
    } );
    return list;
}


public static  void main(String args[]){
    ArrayList<TravelData> listOfTravels=new ArrayList() ;
    listOfTravels.add(new TravelData(1,"group a", "Ross"));
    listOfTravels.add(new TravelData(2,"group a", "Chandler"));
    listOfTravels.add(new TravelData(3,"group a", "Monica"));
    listOfTravels.add(new TravelData(4,"group b", "Phoebe"));
    listOfTravels.add(new TravelData(5,"group b", "Rachel"));
    listOfTravels.add(new TravelData(6,"group c", "Joey"));
    listOfTravels.add(new TravelData(7,"group c", "Rachel"));
    listOfTravels.add(new TravelData(8,"group d", "Chandler"));
    getcommonGroups(listOfTravels);
}}

公共类旅行数据{
int-id；
字符串组名；
公共字符串getGroupName（）{
返回groupName；
}
公共字符串getGuideName（）{
返回指南名称；
}
字符串名称；
公共TravelData（int id、字符串groupName、字符串guideName）{
this.id=id；
this.groupName=groupName；
this.guideName=guideName；
}
公共静态无效getcommonGroups（ArrayList列表）{
Map wordMap=newhashmap（）；
对于（TravelData td:list）{
if（wordMap.containsKey（td.getGroupName（）））{
put（td.getGroupName（），wordMap.get（td.getGroupName（））+1）；
}否则{
put（td.getGroupName（），1）；
}
}
List sortedList=sortByValue（wordMap）；
用于（地图条目：sortedList）{
System.out.println（entry.getKey（）+“=”+entry.getValue（））；
} }
公共静态列表sortByValue（映射
文字地图）{
Set=wordMap.entrySet（）；
列表=新的ArrayList（集合）；
Collections.sort（list，newcomparator（）
{
公共整数比较（映射项o1，映射项o2）
{
return（o2.getValue（））.compareTo（o1.getValue（））；
}
} );
退货清单；
}
公共静态void main（字符串参数[]）{
ArrayList listOfTravels=新的ArrayList（）；
添加（新的旅行数据（1，“a组”、“罗斯”）；
添加（新的旅行数据（2，“a组”、“钱德勒”）；
添加（新的TravelData（3，“a组”、“Monica”）；
添加（新的TravelData（4，“b组”、“Phoebe”）；
添加（新的TravelData（5，“b组”、“Rachel”）；
添加（新的旅行数据（6，“c组”、“乔伊”）；
添加（新的TravelData（7，“c组”、“Rachel”）；
添加（新的旅行数据（8，“d组”、“钱德勒”）；
GetCommonGroup（旅行列表）；
}}
这是我的流解决方案

//用于反向排序的比较器
Comparator reversed=Map.Entry.comparingByValue（）；
Comparator entryComparator=集合。反转顺序（反转）；
List collect=listOfTravels.stream（）
.collect（Collectors.groupingBy（TravelData:：getGuideName，Collectors.counting（）））
.entrySet（）
.stream（）
.已排序（入口比较器）
.map（map.Entry:：getKey）
.限额（3）
.collect（Collectors.toList（））；
系统输出打印项次（收集）；
这是我的流解决方案

//用于反向排序的比较器
Comparator reversed=Map.Entry.comparingByValue（）；
Comparator entryComparator=集合。反转顺序（反转）；
List collect=listOfTravels.stream（）
.collect（Collectors.groupingBy（TravelData:：getGuideName，Collectors.counting（）））
.entrySet（）
.stream（）
.已排序（入口比较器）
.map（map.Entry:：getKey）
.限额（3）
.collect（Collectors.toList（））；
系统输出打印项次（收集）；
这是流的一个很好的用例。其思想是，首先将
列表
转换为
映射
，将组映射为指南数（或指南映射为组数）
final comparator = Comparator.comparing(Map::getValue)
                             .reversed();

final top3Groups = listOfTravels.stream().collect(Collectors.groupingBy(TravelData::getGroup(),
                                                                        Collectors.counting())
                                .entrySet()
                                .stream().sorted(comparator)
                                         .map(Map::getKey)
                                         .limit(3)
                                         .collect(Collectors.toList());

final top3Guides = listOfTravels.stream().collect(Collectors.groupingBy(TravelData::getGuide(),
                                                                        Collectors.counting())
                                .entrySet()
                                .stream().sorted(comparator)
                                         .map(Map::getKey)
                                         .limit(3)
                                         .collect(Collectors.toList());