Java 在按字母顺序排序后,如何获得列表中重复最多的值的计数?
获取列表中重复最多的值并按降序排序的最简单方法是什么。。。 例如:Java 在按字母顺序排序后,如何获得列表中重复最多的值的计数?,java,string,duplicates,Java,String,Duplicates,获取列表中重复最多的值并按降序排序的最简单方法是什么。。。 例如: List<String> list = new ArrayList<>(List.of("Renault","BMW","Renault","Renault","Toyota","Rexon","BMW","Opel","Rexon&qu
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;
}
}