Question

我想知道listA中是否至少有一个listRef元素出现？其他值可以多次出现。

List<string> listA = new List<string> { "A", "A", "B", "C", "D", "E" };
List<string> listRef = new List<string> { "B", "D" };

谢谢，

Answer 1

试试这个：

bool hasRef = listref.Any(r => listA.Count(a => a == r) > 1);

Answer 2

我会先使用ToLookup方法生成Lookup<string, string>，然后用它来检查您的情况：

var lookup = listA.ToLookup(x => x);
return listRef.Any(x => lookup.Contains(x) && lookup[x].Count() > 1);

您可以使用GroupBy和ToDictionary来实现相同目标：

var groups = listA.GroupBy(x => x).ToDictionary(g => g.Key, g => g.Count());
return listRef.Any(x => groups.ContainsKey(x) && groups[x] > 1);

Answer 3

类似这样的事情

    var query = listRef.Where(x=>
        listA.Where(a => a == x)
             .Skip(1)
             .Any());

Answer 4

listRef.ForEach(refEl => {

   var count = listA.Count(aEl => aEl == refEl);
   if(count > 1) {

      //Do something

   }

});

Answer 5

在这种情况下找到效果最佳的选项并不简单，因为这取决于列表中的项目数和预期结果。

这是一种在大名单面前表现出色的方法：

var appearances = listA.GroupBy(s => s)
                       .Where(g => g.Count() > 1)
                       .ToDictionary(g => g.Key, g => g.Count());
var hasItemAppearingMoreThanOnce = listRef.Any(r => appearances.ContainsKey(r));

Answer 6

这是有效的

    List<string> listA = new List<string> { "A", "A", "B", "C", "D", "E" };
    List<string> listRef = new List<string> { "A", "D" };
    foreach (var item in listRef)
    {
        if (listA.Where(x => x.Equals(item)).Count() > 1)
        { 
        //item is present more than once
        }
    }

Answer 7

var result = listA.GroupBy(x=>x)
                  .Where(g=>g.Count()>1&&listRef.Contains(g.Key))
                  .Select(x=>x.First());
bool a = result.Any();

Answer 8

这可以是另一种方式

        List<string> listA = new List<string> { "A", "A", "B", "C", "D", "E" , "D" };
        List<string> listRef = new List<string> { "B", "D" };

        var duplicates = listA.GroupBy(s => s).SelectMany(grp => grp.Skip(1));
        var newData = duplicates.Select(i => i.ToString()).Intersect(listRef);

Answer 9

如果第二个列表很大并且可以包含重复项，我会使用HashSet<string>和IntersectWith来删除可能的重复项和strings，它们不在第二个列表的第一个列表中：< / p>

var refSet = new HashSet<string>(listRef);
refSet.IntersectWith(listA);
bool anyMoreThanOne = refSet.Any(rs => listA.ContainsMoreThanOnce(rs, StringComparison.OrdinalIgnoreCase));

这里的扩展不是很优雅，但有效：

public static bool ContainsMoreThanOnce(this IEnumerable<string> coll, String value, StringComparison comparer)
{
    if (coll == null) throw new ArgumentNullException("col");
    bool contains = false;
    foreach (string str in coll)
    {
        if (String.Compare(value, str, comparer) == 0)
        {
            if (contains)
                return true;
            else
                contains = true;
        }
    }
    return false;
}

DEMO

但是，如果第二个listRef不大或不包含重复项，您可以使用：

bool anyMoreThanOne = listRef
  .Any(rs => listA.ContainsMoreThanOnce(rs, StringComparison.OrdinalIgnoreCase));

从引用列表中查找列表中的副本

9 个答案: