首先收集名字并计数，然后使用它来筛选出非欺骗者：

Map<String, Long> freq = portugalCities.stream()
  .map(City::getName)
  .collect(groupingBy(n -> n, counting()));

List<City> dupes = portugalCities.stream()
  .filter(c -> freq.get(c.getName()) > 1)
  .collect(toList());

然后按你喜欢的方式打印出来：

dupes.forEach(System.out::println);

理想情况下，流一次处理一个元素，而不需要存储中间结果。但是在这种情况下，我们需要存储按名称分组的城市，因为我们无法知道哪些是重复的，除非我们处理了所有元素。因此，给定类City的定义和问题的数据集，我提出了以下两步过程：

Map<String, List<City>> citiesByName =
  portugalCities.stream().collect(Collectors.groupingBy(City::getName));
List<City> result =
  citiesByName.values().stream()
    .filter(list -> list.size() > 1)
    .flatMap(List::stream)
    .toList();

可以在一个更好的单链中完成，但仍然有一个中间结果，citiesByName。
结果包含 * 所有重复项 *（据我所知，这是问题的对象），而不仅仅是计数。

您可能希望使用自定义收集器来实现这一点，这与https://mdn.io/Array.reduce不同：
此示例生成输出：

{Alentejo=1, Braga=3, Faro=1, Guarda=2, Lisboa=3, Viseu=1}

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.experimental.Accessors;

import java.util.List;
import java.util.Map;
import java.util.TreeMap;
import java.util.stream.Collector;

public class Example {

    public static void main(String[] args) {

        List<City> portugalCities = List.of(
                new City("Lisboa", "Estremadura", 2275591),
                new City("Lisboa", "Estremadura", 2275591),
                new City("Faro", "Algarve", 67650),
                new City("Braga", "Minho", 193324),
                new City("Braga", "Esposende", 193324),
                new City("Braga", "Fafe", 193324),
                new City("Alentejo", "Ribatejo", 704533),
                new City("Viseu", "Beira Alta", 99561),
                new City("Lisboa", "Alenquer", 2275591),
                new City("Guarda", "Almeida", 143019),
                new City("Guarda", "Aguiar da Beira", 143019)
        );

        Map<String, Integer> counts = portugalCities.stream()
                .collect(Collector.<City, Map<String, Integer>>of(
                        // this means our collector starts by creating a tree map
                        // using the default constructor,
                        // which we passed here
                        TreeMap::new,
                        //
                        // then, process each element collecting to a map.
                        // basically:
                        // [{ name: 'a' }, { name: 'a' }, { name: 'b' }]
                        //  .reduce((acc /* accumulator*/, next) => {
                        //    acc[next.name] = (acc[next.name] || 0) + 1;
                        //    return acc; }, {} /* initial value of acc */)
                        (map, next) -> map.put(next.getName(),
                                map.computeIfAbsent(next.getName(), k -> 0) + 1),
                        // this is not needed, as you only have 1 map
                        // if given, it would be how to combine 2 maps (a, and b)
                        (a, b) -> {
                            throw new UnsupportedOperationException();
                        }
                ));

        System.out.println(counts);
    }

    @AllArgsConstructor
    @Accessors(chain = true)
    @Data
    static class City {
        private String name;
        private String province;
        private int population;
    }
}