这是可行的。。。你可以优化它

var list = [1, 1, 2, 2, 3, 4, 5];
  list.sort();
  var popularNumbers = [];
  List<Map<dynamic, dynamic>> data = [];
  var maxOccurrence = 0;

  var i = 0;
  while (i < list.length) {
    var number = list[i];
    var occurrence = 1;
    for (int j = 0; j < list.length; j++) {
      if (j == i) {
        continue;
      }
      else if (number == list[j]) {
        occurrence++;
      }
    }
    list.removeWhere((it) => it == number);
    data.add({number: occurrence});
    if (maxOccurrence < occurrence) {
      maxOccurrence = occurrence;
    }
  }

  data.forEach((map) {
    if (map[map.keys.toList()[0]] == maxOccurrence) {
      popularNumbers.add(map.keys.toList()[0]);
    }
  });

  print(popularNumbers);

试试这个方法来计算列表中的每个元素：

var list = [0, 1, 1, 2, 2, 2, 3, 3, 4];
  var popular = Map();

  list.forEach((l) {
    if(!popular.containsKey(l)) {
      popular[l] = 1;
    } else {
      popular[l] +=1;
    }
  });

我想我找到解决办法了。

让我解释给你听：

我已经查询了你的列表，并检查了map的键是否包含元素。如果map不包含元素作为键，那么它将从元素创建一个键并传递1作为值。如果map包含元素作为键，那么它将简单地增加值。
Map准备好后，我对Map值进行了排序，并将它们存储在一个列表中。从排序后的Map值中，我从排序后的值列表中取出了最后一个元素，因为我们是按升序排序的，所以最受欢迎的值将出现在最后。
最后，我通过map查询并检查特定键的值是否等于popularValue。如果是，那么我们将当前键和值添加到mostPopularValues列表中。
如果我做错了什么，请让我知道。

void main() {
  List list = [0, 1, 1, 1, 2, 2, 2, 3, 3, 4];

  List mostPopularValues = [];

  var map = Map();

  list.forEach((element) {
    if (!map.containsKey(element)) {
      map[element] = 1;
    } else {
      map[element] += 1;
    }
  });

  print(map);
  // o/p : {0: 1, 1: 3, 2: 3, 3: 2, 4: 1}

  List sortedValues = map.values.toList()..sort();

  print(sortedValues);
  // o/p : [1, 1, 2, 3, 3]

  int popularValue = sortedValues.last;

  print(popularValue);
  // o/p : 3

  map.forEach((k, v) {
    if (v == popularValue) {
      mostPopularValues.add("$k occurs $v time in the list");
    }
  });

  print(mostPopularValues);
  // o/p : [1 occurs 3 time in the list, 2 occurs 3 time in the list]
}

我不确定这是不是最好的解决方案，但效果很好。如果有任何疑问，请告诉我。

final list = [0, 1, 1, 2, 2, 2, 3, 3, 4];

    // Count occurrences of each item
    final folded = list.fold({}, (acc, curr) {
      acc[curr] = (acc[curr] ?? 0) + 1;
      return acc;
    }) as Map<dynamic, dynamic>;

    // Sort the keys (your values) by its occurrences
    final sortedKeys = folded.keys
        .toList()
        ..sort((a, b) => folded[b].compareTo(folded[a]));

    print('Most popular value: ${sortedKeys.first}'); // 1
    print('Second most popular value: ${sortedKeys[1]}'); // 2

我通过在Iterable上定义一个扩展来解决这个问题：

extension MostPopularItemsExtension<E> on Iterable<E> {
  /// Returns the most popular items, where all items in the returned
  /// list have the same number of occurances. If [this] is empty, returns an
  /// empty list
  ///
  /// Examples:
  ///   `[1,2,3,2].mostPopularItems() == [2]`
  ///   `[1,1,2,2].mostPopularItems() == [1,2]`
  Iterable<E> mostPopularItems() {
    if (isEmpty) return [];
    final itemsCounted = <E, int>{};
    for (final e in this) {
      if (itemsCounted.containsKey(e)) {
        itemsCounted[e] = itemsCounted[e]! + 1;
      } else {
        itemsCounted[e] = 1;
      }
    }
    final highestCount = (itemsCounted.values.toList()..sort()).last;
    return itemsCounted.entries
        .where((e) => e.value == highestCount)
        .map((e) => e.key);
  }
}

基本思想是计算Map对象中每个项的所有出现次数，从该Map中获得最高计数，然后返回具有该特定出现次数的所有项。

你可以从这样的东西开始，不管它是字符串还是整数

void main() {
    var userInputs = [1,2,2,2,0,1,0,2,2]; 
    int mostPicked = -1;
    for(var i in userInputs.toSet().toList()) {
      var countOfI = userInputs.where((e)=> i==e).toList().length;
      print('user used $i  $countOfI times');
      if(countOfI > mostPicked){
         mostPicked = i;
      }
    }
    print('most picked: $mostPicked');
}
// Output: 
user used 1  2 times
user used 2  5 times
user used 0  2 times
most picked: 2