Java 在按字母顺序排序后，如何获得列表中重复最多的值的计数？

获取列表中重复最多的值并按降序排序的最简单方法是什么。。。 例如：

List<String> list = new ArrayList<>(List.of("Renault","BMW","Renault","Renault","Toyota","Rexon","BMW","Opel","Rexon","Rexon"));

List List=new ArrayList（列表中的“雷诺”、“宝马”、“雷诺”、“雷诺”、“雷诺”、“丰田”、“雷克森”、“宝马”、“欧宝”、“雷克森”、“雷克森”）；

`

---

“雷诺”和“雷克森”是最重复的，如果按字母顺序降序排列，我希望得到雷克森。

过了一段时间后，这就是我的产品（我只使用您的示例测试了它，它成功了）：

公共类重复{
公共静态字符串MOST重复（字符串[]a）{
int-dup=0；
int位置=-1；
int maxDup=0；
对于（int i=0；imaxDup）{maxDup=dup；position=i；}
//如果复制的数量
//大于到目前为止的最大值，请保存此位置。
如果（dup==maxDup）{
如果（a[i].compareTo（a[position]）>0{position=i；}
//如果相同，则保留按字母顺序排列的最后一个的位置
//（如果您想先按字母顺序排列，只需更改“”）
}
}
返回[position]；//返回保存的位置
}
}

事实上，我找到了一个有效的解决方案：

public static void main(String[] args) {

    List<String> list = new ArrayList<>(List.of("Renault", "BMW", "BMW", "Renault", "Renault", "Toyota",
            "Rexon", "BMW", "Opel", "Rexon", "Rexon"));
    Map<String, Integer> soldProducts = new HashMap<>();
    for (String s : list) {
        soldProducts.put(s, soldProducts.getOrDefault(s, 0) + 1);
    }
    LinkedHashMap<String, Integer> sortedMap = soldProducts.entrySet()
            .stream()
            .sorted(VALUE_COMPARATOR.thenComparing(KEY_COMPARATOR_REVERSED))
            .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, (e1, e2) -> e2, LinkedHashMap::new));
    String result = "";
    for (Map.Entry<String, Integer> s : sortedMap.entrySet()) {
        result = s.getKey();
    }
    System.out.println(result);
}

static final Comparator<Map.Entry<String, Integer>> KEY_COMPARATOR_REVERSED =
        Map.Entry.comparingByKey(Comparator.naturalOrder());

static final Comparator<Map.Entry<String, Integer>> VALUE_COMPARATOR =
        Map.Entry.comparingByValue();

publicstaticvoidmain（字符串[]args）{
列表=新的ArrayList（列表中的“雷诺”、“宝马”、“宝马”、“雷诺”、“雷诺”、“丰田”，
“雷克森”、“宝马”、“欧宝”、“雷克森”、“雷克森”）；
Map soldProducts=new HashMap（）；
用于（字符串s:列表）{
soldProducts.put（s，soldProducts.getOrDefault（s，0）+1）；
}
LinkedHashMap sortedMap=soldProducts.entrySet（）
.stream（）
.排序（值\u比较器。然后比较（键\u比较器\u反转））
.collect（Collectors.toMap（Map.Entry:：getKey，Map.Entry:：getValue，（e1，e2）->e2，LinkedHashMap:：new））；
字符串结果=”；
对于（Map.Entry s:sortedMap.entrySet（））{
结果=s.getKey（）；
}
系统输出打印项次（结果）；
}
静态最终比较器键\u比较器\u反转=
Map.Entry.comparingByKey（Comparator.naturalOrder（））；
静态最终比较器值\u比较器=
Map.Entry.comparingByValue（）；

快速算法利用列表已排序的事实，在

O（n）

中查找重复次数最多的列表，其中

n

是列表的大小。由于列表已排序，重复项将以连续位置排列在一起：

private static String getMostDuplicates(List<String> list) {
    if(!list.isEmpty()) {
        list.sort(Comparator.reverseOrder());
        String prev = list.get(0);
        String found_max = prev;
        int max_dup = 1;
        int curr_max_dup = 0;
        for (String s : list) {
            if (!s.equals(prev)) {
                if (curr_max_dup > max_dup) {
                    max_dup = curr_max_dup;
                    found_max = prev;
                }
                curr_max_dup = 0;
            }
            curr_max_dup++;
            prev = s;
        }
        return found_max;
    }
    return "";
}

---

我认为最具可读性和优雅的方法之一是使用Streams API

strings.stream()
       .collect(Collectors.groupingBy(x -> x, Collectors.counting()))
       .entrySet().stream()
       .max(Comparator.comparingLong((ToLongFunction<Map.Entry<String, Long>>) Map.Entry::getValue).thenComparing(Map.Entry::getKey))
       .map(Map.Entry::getKey)
       .ifPresent(System.out::println);

strings.stream（）
.collect（Collectors.groupingBy（x->x，Collectors.counting（））
.entrySet（）.stream（）
.max（Comparator.comparingLong（（tolong函数）Map.Entry:：getValue）。然后比较（Map.Entry:：getKey））
.map（map.Entry:：getKey）
.ifPresent（System.out:：println）；

创建名称及其相应出现次数的地图

获取名称并按降序排序

打印出现次数最多的名字

类刮擦{
公共静态void main（字符串[]args）{
列表=列表（“雷诺”、“宝马”、“雷诺”、“雷诺”、“雷诺”、“丰田”、“雷克森”、“宝马”、“欧宝”、“雷克森”、“雷克森”）；
Map duplicates=new HashMap（）；
//1.创建名称及其对应名称的地图
//发生次数。
用于（字符串s:列表）{
重复。合并（s，1，Integer:：sum）；
}
//2.获取名称并按降序排序。
List newList=newarraylist（duplicates.keySet（））；
排序（Collections.reverseOrder（））；
//3.打印具有最多用户的第一个姓名
//事件。
整数max=Collections.max（duplicates.values（））；
newList.stream（）.filter（name->duplicates.get（name）.equals（max））
.findFirst（）
.ifPresent（System.out:：println）；
}
}

您要求对列表进行排序，然后查找最常见的项目

我建议对列表进行排序的最简单方法是使用列表中内置的排序方法

然后，我建议通过循环for..each构造，跟踪当前和最长的条纹来找到最常见的条纹

我喜欢Yassin Hajaj关于streams的回答，但我发现这种方法更容易书写和阅读。您的里程数可能会有所不同，因为这是主观的。：）

import java.util.*；
公共类排序和最常见的演示{
公共静态void main（字符串[]args）{
列表=新的ArrayList（列表包括（“雷诺”、“宝马”、“雷诺”、“雷诺”、“丰田”、“雷克森”、“宝马”、“欧宝”、“雷克森”、“雷克森”））；
list.sort（Comparator.reverseOrder（））；
系统输出打印项次（列表）；
System.out.println（“最常见的是“+mostCommon（list）+”）；
}
私有静态字符串MOSTCOMON（列表）{
字符串mostCommon=null；
int longeststrike=0；
字符串previous=null；
int currentStreak=0；
用于（字符串s:列表）{
currentStreak=1+（s.equals（先前）？currentStreak:0）；
如果（当前条纹>最长条纹）{
MOSTCOMON=s；
最长条纹=当前条纹；
}
先前=s；
}
返回最常见的；
}
}

我希望您不介意编辑，但如果您介意的话rollback@dreamcrash+1用于优化

max

而不是“流”实现。我真的很感激。

public class Duplicates {

        private static String getMostDuplicates(List<String> list) {
            if(!list.isEmpty()) {
                list.sort(Comparator.reverseOrder());
                String prev = list.get(0);
                String found_max = prev;
                int max_dup = 1;
                int curr_max_dup = 0;
                for (String s : list) {
                    if (!s.equals(prev)) {
                        if (curr_max_dup > max_dup) {
                            max_dup = curr_max_dup;
                            found_max = prev;
                        }
                        curr_max_dup = 0;
                    }
                    curr_max_dup++;
                    prev = s;
                }
                return found_max;
            }
            return "";
        }
    
        public static void main(String[] args) {
            List<String> list = new ArrayList<>(List.of("Renault","BMW","Renault","Renault","Toyota","Rexon","BMW","Opel","Rexon","Rexon"));
            String duplicates = getMostDuplicates(list);
            System.out.println("----- Test 1 -----");
            System.out.println(duplicates);
    
            list = new ArrayList<>(List.of("Renault","BMW"));
            duplicates = getMostDuplicates(list);
            System.out.println("----- Test 2 -----");
            System.out.println(duplicates);
    
            list = new ArrayList<>(List.of("Renault"));
            duplicates = getMostDuplicates(list);
            System.out.println("----- Test 3 -----");
            System.out.println(duplicates);
        }
    }

----- Test 1 -----
Rexon
----- Test 2 -----
Renault
----- Test 3 -----
Renault

strings.stream()
       .collect(Collectors.groupingBy(x -> x, Collectors.counting()))
       .entrySet().stream()
       .max(Comparator.comparingLong((ToLongFunction<Map.Entry<String, Long>>) Map.Entry::getValue).thenComparing(Map.Entry::getKey))
       .map(Map.Entry::getKey)
       .ifPresent(System.out::println);

import java.util.*;

public class SortingAndMostCommonDemo {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>(List.of("Renault","BMW","Renault","Renault","Toyota","Rexon","BMW","Opel","Rexon","Rexon"));
        list.sort(Comparator.reverseOrder());
        System.out.println(list);
        System.out.println("The most common is " + mostCommon(list) + ".");
    }

    private static String mostCommon(List<String> list) {
        String mostCommon = null;
        int longestStreak = 0;
        String previous = null;
        int currentStreak = 0;
        
        for (String s : list) {
            currentStreak = 1 + (s.equals(previous) ? currentStreak : 0);
            if (currentStreak > longestStreak) {
                mostCommon = s;
                longestStreak = currentStreak;
            }
            previous = s;
        }
        return mostCommon;
    }
}