Java-получить наиболее распространенный элемент в списке
есть ли у Java или Guava что-то, что вернет наиболее распространенный элемент в списке?
List<BigDecimal> listOfNumbers= new ArrayList<BigDecimal>();
[1,3,4,3,4,3,2,3,3,3,3,3]
возврат 3
10 ответов
Это довольно легко реализовать себя:
public static <T> T mostCommon(List<T> list) {
Map<T, Integer> map = new HashMap<>();
for (T t : list) {
Integer val = map.get(t);
map.put(t, val == null ? 1 : val + 1);
}
Entry<T, Integer> max = null;
for (Entry<T, Integer> e : map.entrySet()) {
if (max == null || e.getValue() > max.getValue())
max = e;
}
return max.getKey();
}
List<Integer> list = Arrays.asList(1,3,4,3,4,3,2,3,3,3,3,3);
System.out.println(mostCommon(list));
3
Если вы хотите обрабатывать случаи, когда есть более одного наиболее частого элемента, вы можете сканировать список один раз, чтобы определить, сколько раз наиболее частые элементы происходят, а затем Сканировать список снова, поместить эти элементы в набор и вернуть его.
вероятно, самое простое решение с Guava выглядит как
Multiset<BigDecimal> multiset = HashMultiset.create(listOfNumbers);
BigDecimal maxElement = null;
int maxCount = 0;
for (Multiset.Entry<BigDecimal> entry : multiset.entrySet()) {
if (entry.getCount() > maxCount) {
maxElement = entry.getElement();
maxCount = entry.getCount();
}
}
это полное решение и короче, чем другие альтернативы, которые я вижу обсуждаемыми.
в статистике это называется"mode". Решение vanilla Java 8 выглядит следующим образом:
Stream.of(1, 3, 4, 3, 4, 3, 2, 3, 3, 3, 3, 3)
.collect(Collectors.groupingBy(Functions.identity(), Collectors.counting()))
.entrySet()
.stream()
.max(Comparator.comparing(Entry::getValue))
.ifPresent(System.out::println);
что дает:
3=8
jOOλ - это библиотека, которая поддерживает mode()
на потоки. Следующая программа:
System.out.println(
Seq.of(1, 3, 4, 3, 4, 3, 2, 3, 3, 3, 3, 3)
.mode()
);
выходы:
Optional[3]
для простоты я опустил использование BigDecimal
. Однако решение будет тем же самым.
(отказ от ответственности: я работаю на компанию за jOOλ)
вот чисто Java 8 решение (примечание: не используйте это, см. ниже):
List<Integer> theList = Arrays.asList(1, 3, 4, 3, 4, 3, 2, 3, 3, 3, 3, 3);
Integer maxOccurredElement = theList.stream()
.reduce(BinaryOperator.maxBy((o1, o2) -> Collections.frequency(theList, o1) -
Collections.frequency(theList, o2))).orElse(null);
System.out.println(maxOccurredElement);
другое решение, собирая элементы на карту по их частоте, затем находя запись с максимальным значением и возвращая ее ключ (в основном то же решение на arshajii это!--10-->, написано с помощью Java 8):
Integer maxVal = theList.stream()
.collect(Collectors.groupingBy(Function.identity(), Collectors.counting()))
.entrySet().stream().max((o1, o2) -> o1.getValue().compareTo(o2.getValue()))
.map(Map.Entry::getKey).orElse(null);
обновление: Если наиболее частые элементы более одного, и вы хотите получить все из них в коллекции, Я предлагаю два метода:--7-->
Метод A: после сбора исходной коллекции на карту с ключами в качестве элементов и значениями в качестве их количества вхождений, получения записи с максимальным значением и фильтрации записей карты со значением, равным этому максимальному значению (если), мы нашли. Что-то вроде этого:--7-->
Map<Integer, Long> elementCountMap = theList.stream()
.collect(Collectors.groupingBy(Function.identity(), Collectors.counting()));
List<Integer> result = elementCountMap.values().stream()
.max(Long::compareTo).map(maxValue -> elementCountMap.entrySet().stream()
.filter(entry -> maxValue.equals(entry.getValue())).map(Map.Entry::getKey).collect(Collectors.toList()))
.orElse(Collections.emptyList());
Метод B: после сбора исходной коллекции на карту с ключами в качестве элементов и значения их число вхождений, преобразование этой карты в новую карту с ключами в виде числа событий, значениями в виде списка элементов с этим числом событий. А затем найти элемент max этой карты с помощью пользовательского компаратора, который сравнивает ключи и получает значение этой записи. Вот так:
List<Integer> result = theList.stream().collect(Collectors.groupingBy(Function.identity(), Collectors.counting()))
.entrySet().stream()
.collect(Collectors.groupingBy(Map.Entry::getValue, Collectors.mapping(Map.Entry::getKey, Collectors.toList())))
.entrySet().stream().max((o1, o2) -> o1.getKey().compareTo(o2.getKey())).map(Map.Entry::getValue)
.orElse(Collections.emptyList());
гуава предоставляет метод это поможет, хотя это менее эффективно, чем решение Луиса.
BigDecimal mostCommon =
Multisets.copyHighestCountFirst(ImmutableMultiset.copyOf(listOfNumbers))
.iterator().next();
классический способ сделать это, чтобы отсортировать список, а затем работать через них по одному:
public static BigInteger findMostCommon(List<BigInteger> list) {
Collections.sort(list);
BigInteger mostCommon = null;
BigInteger last = null;
int mostCount = 0;
int lastCount = 0;
for (BigInteger x : list) {
if (x.equals(last)) {
lastCount++;
} else if (lastCount > mostCount) {
mostCount = lastCount;
mostCommon = last;
}
last = x;
}
return mostCommon;
}
Это немного более эффективное пространство, чем использование хэша для подсчета подсчетов, поскольку он сортирует массив на месте. Вы можете бросить это в класс generics и заменить BigInteger на T или просто использовать Object вместо BigInteger.
вот расширение ответа Луи, которое поддерживает случай, когда существует несколько элементов с одинаковым максимальным количеством вхождений:
private <T> List<T> getMostFrequentElements(List<T> list) {
Multiset<T> multiset = HashMultiset.create(list);
List<T> mostFrequents = new ArrayList<>();
int maxCount = 0;
for (Multiset.Entry<T> entry : multiset.entrySet()) {
if (entry.getCount() > maxCount) {
maxCount = entry.getCount();
mostFrequents.clear();
mostFrequents.add(entry.getElement());
} else if (entry.getCount() == maxCount) {
mostFrequents.add(entry.getElement());
}
}
return mostFrequents;
}
мы можем сделать только в одной итерации с легкостью:
public static Integer mostFrequent(List<Integer> list) {
if (list == null || list.isEmpty())
return null;
Map<Integer, Integer> counterMap = new HashMap<Integer, Integer>();
Integer maxValue = 0;
Integer mostFrequentValue = null;
for(Integer valueAsKey : list) {
Integer counter = counterMap.get(valueAsKey);
counterMap.put(valueAsKey, counter == null ? 1 : counter + 1);
counter = counterMap.get(valueAsKey);
if (counter > maxValue) {
maxValue = counter;
mostFrequentValue = valueAsKey;
}
}
return mostFrequentValue;
}
Если вы готовы использовать Google Guava, вы можете использовать его MultiSet
классы:
MultiSet<BigNumber> numbers = HashMultiSet.create();
numberSet.addAll(list);
Set<MultiSet.Entry<BigNumber>> pairs = numbers.emtrySet();
Set<MultiSet.Entry<BigNumber>> copies = new HashSet<MultiSet.Entry<BigNumber>>(pairs);
сейчас, вроде copies
по его значениям по убыванию.
найти наиболее частый элемент в коллекции:
private <V> V findMostFrequentItem(final Collection<V> items)
{
return items.stream()
.filter(Objects::nonNull)
.collect(Collectors.groupingBy(Functions.identity(), Collectors.counting())).entrySet().stream()
.max(Comparator.comparing(Entry::getValue))
.map(Entry::getKey)
.orElse(null);
}