C# 如何检查列表A是否包含列表B中的任何值？

清单A：

1, 2, 3, 4

清单B：

2, 5

如何检查列表A是否包含列表B中的任何值

---

e、 例如A.contains（A=>A.id=B.id）？

如果您不关心性能，您可以尝试：

a.Any(item => b.Contains(item))
// or, as in the column using a method group
a.Any(b.Contains)

但我会先试试这个：

a.Intersect(b).Any()

您可以选择以下两个列表：

if (A.Intersect(B).Any())

---

我介绍了贾斯汀的两种解决方案

a.Any（a=>b.Contains（a））

是最快的

using System;
using System.Collections.Generic;
using System.Linq;

namespace AnswersOnSO
{
    public class Class1
    {
        public static void Main(string []args)
        {
//            How to check if list A contains any value from list B?
//            e.g. something like A.contains(a=>a.id = B.id)?
            var a = new List<int> {1,2,3,4};
            var b = new List<int> {2,5};
            var times = 10000000;

            DateTime dtAny = DateTime.Now;
            for (var i = 0; i < times; i++)
            {
                var aContainsBElements = a.Any(b.Contains);
            }
            var timeAny = (DateTime.Now - dtAny).TotalSeconds;

            DateTime dtIntersect = DateTime.Now;
            for (var i = 0; i < times; i++)
            {
                var aContainsBElements = a.Intersect(b).Any();
            }
            var timeIntersect = (DateTime.Now - dtIntersect).TotalSeconds;

            // timeAny: 1.1470656 secs
            // timeIn.: 3.1431798 secs
        }
    }
}

使用系统；
使用System.Collections.Generic；
使用System.Linq；
名称空间应答器
{
公共班级1
{
公共静态void Main（字符串[]args）
{
//如何检查列表A是否包含列表B中的任何值？
//例如，像A.contains（A=>A.id=B.id）这样的东西？
var a=新列表{1,2,3,4}；
var b=新列表{2,5}；
风险价值倍数=10000000；
DateTime dtAny=DateTime.Now；
对于（变量i=0；i<次；i++）
{
var aContainsBElements=a.Any（b.Contains）；
}
var timeAny=（DateTime.Now-dtAny）.TotalSeconds；
DateTime dtIntersect=DateTime.Now；
对于（变量i=0；i<次；i++）
{
var aContainsBElements=a.Intersect（b）.Any（）；
}
var timeIntersect=（DateTime.Now-dtIntersect）.TotalSeconds；
//时间：1.1470656秒
//时间：3.1431798秒
}
}
}

我写了一个更快的方法，因为它可以设置较小的方法。但我在一些数据中测试它，有时相交速度更快，但有时相交速度比我的代码快

    public static bool Contain<T>(List<T> a, List<T> b)
    {
        if (a.Count <= 10 && b.Count <= 10)
        {
            return a.Any(b.Contains);
        }

        if (a.Count > b.Count)
        {
            return Contain((IEnumerable<T>) b, (IEnumerable<T>) a);
        }
        return Contain((IEnumerable<T>) a, (IEnumerable<T>) b);
    }

    public static bool Contain<T>(IEnumerable<T> a, IEnumerable<T> b)
    {
        HashSet<T> j = new HashSet<T>(a);
        return b.Any(j.Contains);
    }

两种方法的区别在于我的方法使用

HashSet

并检查计数和

Intersect

使用

set

，这比

HashSet

快。我们不担心它的性能

测试：

   static void Main(string[] args)
    {
        var a = Enumerable.Range(0, 100000);
        var b = Enumerable.Range(10000000, 1000);
        var t = new Stopwatch();
        t.Start();
        Repeat(()=> { Contain(a, b); });
        t.Stop();
        Console.WriteLine(t.ElapsedMilliseconds);//490ms

        var a1 = Enumerable.Range(0, 100000).ToList();
        var a2 = b.ToList();
        t.Restart();
        Repeat(()=> { Contain(a1, a2); });
        t.Stop();

        Console.WriteLine(t.ElapsedMilliseconds);//203ms

        t.Restart();
        Repeat(()=>{ a.Intersect(b).Any(); });
        t.Stop();
        Console.WriteLine(t.ElapsedMilliseconds);//190ms

        t.Restart();
        Repeat(()=>{ b.Intersect(a).Any(); });
        t.Stop();
        Console.WriteLine(t.ElapsedMilliseconds);//497ms

        t.Restart();
        a.Any(b.Contains);
        t.Stop();
        Console.WriteLine(t.ElapsedMilliseconds);//600ms

    }

    private static void Repeat(Action a)
    {
        for (int i = 0; i < 100; i++)
        {
            a();
        }
    }

static void Main（字符串[]args）
{
var a=可枚举范围（0，100000）；
var b=可枚举范围（10000000，1000）；
var t=新秒表（）；
t、 Start（）；
重复（（）=>{Contain（a，b）；}）；
t、 停止（）；
Console.WriteLine（t.elapsedmillyses）；//490ms
var a1=可枚举的.Range（0，100000）.ToList（）；
var a2=b.ToList（）；
t、 重启（）；
重复（（）=>{Contain（a1，a2）；}）；
t、 停止（）；
Console.WriteLine（t.elapsedmillyses）；//203ms
t、 重启（）；
重复（（）=>{a.Intersect（b.Any（）；}）；
t、 停止（）；
Console.WriteLine（t.elapsedmillyses）；//190ms
t、 重启（）；
重复（（）=>{b.Intersect（a）.Any（）；}）；
t、 停止（）；
Console.WriteLine（t.elapsedmillyses）；//497ms
t、 重启（）；
a、 任何（b）项；
t、 停止（）；
Console.WriteLine（t.elapsedmillyses）；//600ms
}
私有静态无效重复（动作a）
{
对于（int i=0；i<100；i++）
{
a（）；
}
}

我用它来计算：

int cnt = 0;

foreach (var lA in listA)
{
    if (listB.Contains(lA))
    {
        cnt++;
    }
}

---

抱歉，如果这是irelevant，但如果您需要，将使用FindAll（）返回包含匹配项的列表：

        private bool IsContain(string cont)
    {
        List<string> ListToMatch= new List<string>() {"string1","string2"};

        if (ListToMatch.ToArray().Any(cont.Contains))
        {
            return false;
        }
        else
            return true;
    }

private bool IsContain（字符串cont）
{
List ListToMatch=new List（）{“string1”、“string2”}；
if（ListToMatch.ToArray（）.Any（cont.Contains））
{
返回false；
}
其他的
返回true；
}

使用方法：

List<string> ListToCheck = new List<string>() {"string1","string2","string3","string4"};
List<string> FinalList = ListToCheck.FindAll(IsContain);

List ListToCheck=new List（）{“string1”、“string2”、“string3”、“string4”}；
List FinalList=ListToCheck.FindAll（IsContain）；

最终列表仅包含要检查的列表中匹配的元素string1和string2。

---

可以很容易地切换到int List。

要获得更快、更简短的解决方案，您可以使用

HashSet

而不是

List

a.Overlaps(b);

---

此方法是一个O（n）而不是一个有两个列表的O（n^2）。

您可以使用此方法检查一个列表是否在另一个列表中

var list1 = new List<int> { 1, 2, 3, 4, 6 };
var list2 = new List<int> { 2, 3 };
bool a = list1.Any(c => list2.Contains(c));

var list1=新列表{1,2,3,4,6}；
var list2=新列表{2,3}；
boola=list1.Any（c=>list2.Contains（c））；

工作起来很有魅力。因为你是第一个答辩人，所以我把你的作为答案。谢谢。你不能在列表和lambda中同时使用“a”<代码>a.Any（a=>b.Contains（a））。我建议使用一个方法组，而不是

a.Any（b.Contains）

我以前使用过“Any..Contains”方法，但是Intersect方法对我的问题的处理速度快了一个数量级。谢谢你的选择！不要求计数。这是一个非常低效的命令式代码。对于这个答案，可能需要更多的解释，比如为什么选择使用计数而不是布尔值。这确实完成了任务。如果A和B的大小和大小相似怎么办？这种性能分析似乎取决于这些列表的相对大小。我尝试了@radbyx的两组500个随机整数的解决方案，

Any

比

Intersect

快得多

Any

约为4秒，

Intersect

约为185秒。这正好说明

Any

的最佳情况是数据相交时速度更快，因为它可以提前返回。然而，当列表没有交集时，

Any

的最坏情况是较慢的，因为它是

O（N^2）

。

var list1 = new List<int> { 1, 2, 3, 4, 6 };
var list2 = new List<int> { 2, 3 };
bool a = list1.Any(c => list2.Contains(c));