304

Intersect 可用于查找两个集合之间的匹配项，如下所示：

// Assign two arrays.
int[] array1 = { 1, 2, 3 };
int[] array2 = { 2, 3, 4 };
// Call Intersect extension method.
var intersect = array1.Intersect(array2);
// Write intersection to screen.
foreach (int value in intersect)
{
    Console.WriteLine(value); // Output: 2, 3
}

但是我想要实现的是相反的，我想列出一个集合中缺少的另一个集合中的项目：

// Assign two arrays.
int[] array1 = { 1, 2, 3 };
int[] array2 = { 2, 3, 4 };
// Call "NonIntersect" extension method.
var intersect = array1.NonIntersect(array2); // I've made up the NonIntersect method
// Write intersection to screen.
foreach (int value in intersect)
{
    Console.WriteLine(value); // Output: 4
}
4

8 回答 8

413

如前所述，如果你想得到 4 作为结果，你可以这样做：

var nonintersect = array2.Except(array1);

如果你想要真正的不相交（也是 1 和 4），那么这应该可以解决问题：

var nonintersect = array1.Except(array2).Union( array2.Except(array1));

这不是最高效的解决方案，但对于小型列表，它应该可以正常工作。

于 2011-04-11T10:56:20.807 回答
93

您可以使用

a.Except(b).Union(b.Except(a));

或者你可以使用

var difference = new HashSet(a);
difference.SymmetricExceptWith(b);
于 2011-04-11T10:57:16.160 回答
13

此代码仅枚举每个序列一次，并用于Select(x => x)隐藏结果以获得干净的 Linq 样式的扩展方法。因为它使用HashSet<T>它的运行时是O(n + m)如果散列分布良好。省略任一列表中的重复元素。

public static IEnumerable<T> SymmetricExcept<T>(this IEnumerable<T> seq1,
    IEnumerable<T> seq2)
{
    HashSet<T> hashSet = new HashSet<T>(seq1);
    hashSet.SymmetricExceptWith(seq2);
    return hashSet.Select(x => x);
}
于 2011-04-11T11:00:36.737 回答
6

我想你可能正在寻找Except：

except 运算符产生两个序列之间的集合差异。它只会返回第一个序列中没有出现在第二个序列中的元素。您可以选择提供自己的相等比较函数。

查看此链接、此链接或 Google，了解更多信息。

于 2011-04-11T10:57:04.210 回答
4

array1.NonIntersect(array2);

Nonintersect 这样的运算符在 Linq 中不存在，您应该这样做

除外 -> 联合 -> 除外

a.except(b).union(b.Except(a));
于 2014-11-15T12:05:51.810 回答
2

我不是 100% 确定你的 NonIntersect 方法应该做什么（关于集合论） - 是
B \ A （来自 B 的所有东西都不会出现在 A 中）？
如果是，那么您应该能够使用除操作 (B.Except(A))。

于 2011-04-11T11:01:24.727 回答
2 
/// <summary>
/// Given two list, compare and extract differences
/// http://stackoverflow.com/questions/5620266/the-opposite-of-intersect
/// </summary>
public class CompareList
{
    /// <summary>
    /// Returns list of items that are in initial but not in final list.
    /// </summary>
    /// <param name="listA"></param>
    /// <param name="listB"></param>
    /// <returns></returns>
    public static IEnumerable<string> NonIntersect(
        List<string> initial, List<string> final)
    {
        //subtracts the content of initial from final
        //assumes that final.length < initial.length
        return initial.Except(final);
    }

    /// <summary>
    /// Returns the symmetric difference between the two list.
    /// http://en.wikipedia.org/wiki/Symmetric_difference
    /// </summary>
    /// <param name="initial"></param>
    /// <param name="final"></param>
    /// <returns></returns>
    public static IEnumerable<string> SymmetricDifference(
        List<string> initial, List<string> final)
    {
        IEnumerable<string> setA = NonIntersect(final, initial);
        IEnumerable<string> setB = NonIntersect(initial, final);
        // sum and return the two set.
        return setA.Concat(setB);
    }
}
于 2012-12-03T10:43:00.560 回答
-1 
string left = "411329_SOFT_MAC_GREEN";
string right= "SOFT_MAC_GREEN";

string[] l = left.Split('_');
string[] r = right.Split('_');

string[] distinctLeft = l.Distinct().ToArray();
string[] distinctRight = r.Distinct().ToArray();

var commonWord = l.Except(r, StringComparer.OrdinalIgnoreCase)
string result = String.Join("_",commonWord);
result = "411329"
于 2017-06-09T16:18:27.497 回答