LINQ

[C#/LINQ] Intersectメソッドの使い方 – 共通要素の取得

2025-04-15更新日: 2025-04-15

C#のLINQにおけるIntersectメソッドは、2つのコレクションの共通要素を取得するために使用されます。

これは、2つのシーケンスのうち、両方に存在する要素を返します。

例えば、list1.Intersect(list2)とすると、list1とlist2の両方に含まれる要素が返されます。

デフォルトでは、要素の比較はEqualsメソッドとGetHashCodeメソッドを使用して行われますが、カスタムの比較ロジックを指定することも可能です。

目次から探す

Intersectメソッドとは
Intersectメソッドの基本的な使い方
Intersectメソッドの応用
Intersectメソッドのパフォーマンス
Intersectメソッドの注意点
Intersectメソッドの代替手段
まとめ

C#を使った求人

読み込み中…

Intersectメソッドとは

Intersectメソッドは、C#のLINQ(Language Integrated Query)において、2つのコレクションから共通の要素を取得するためのメソッドです。

このメソッドを使用することで、リストや配列などのデータ構造に含まれる重複しない要素を簡単に抽出できます。

例えば、2つの整数のリストがある場合、Intersectメソッドを使うことで、両方のリストに存在する整数だけを取り出すことができます。

このメソッドは、コレクションの型が同じである必要がありますが、カスタムクラスを使用する場合は、IEqualityComparerインターフェースを実装することで、独自の比較ロジックを定義することも可能です。

Intersectメソッドは、データの重複を排除し、効率的に共通要素を見つけるための強力なツールです。

Intersectメソッドの基本的な使い方

2つのリストから共通要素を取得する

2つのリストから共通の要素を取得するには、Intersectメソッドを使用します。

以下のサンプルコードでは、整数のリストを作成し、共通の要素を取得しています。

using System;
using System.Collections.Generic;
using System.Linq;
class Program
{
    static void Main()
    {
        List<int> list1 = new List<int> { 1, 2, 3, 4, 5 };
        List<int> list2 = new List<int> { 4, 5, 6, 7, 8 };
        // 共通要素を取得
        var commonElements = list1.Intersect(list2);
        foreach (var element in commonElements)
        {
            Console.WriteLine(element); // 共通要素を出力
        }
    }
}

4
5

配列を使った共通要素の取得

配列を使用して共通要素を取得することも可能です。

以下のサンプルコードでは、整数の配列を使って共通の要素を取得しています。

using System;
using System.Linq;
class Program
{
    static void Main()
    {
        int[] array1 = { 1, 2, 3, 4, 5 };
        int[] array2 = { 4, 5, 6, 7, 8 };
        // 共通要素を取得
        var commonElements = array1.Intersect(array2);
        foreach (var element in commonElements)
        {
            Console.WriteLine(element); // 共通要素を出力
        }
    }
}

4
5

コレクションの型が異なる場合の共通要素取得

コレクションの型が異なる場合でも、カスタムクラスを使用することで共通要素を取得できます。

以下のサンプルコードでは、カスタムクラスを使って共通の要素を取得しています。

using System;
using System.Collections.Generic;
using System.Linq;
class Person
{
    public string Name { get; set; }
}
class Program
{
    static void Main()
    {
        List<Person> list1 = new List<Person> { new Person { Name = "Alice" }, new Person { Name = "Bob" } };
        List<Person> list2 = new List<Person> { new Person { Name = "Bob" }, new Person { Name = "Charlie" } };
        // 共通要素を取得
        var commonElements = list1.Intersect(list2, new PersonComparer());
        foreach (var element in commonElements)
        {
            Console.WriteLine(element.Name); // 共通要素を出力
        }
    }
}
class PersonComparer : IEqualityComparer<Person>
{
    public bool Equals(Person x, Person y)
    {
        return x.Name == y.Name; // 名前で比較
    }
    public int GetHashCode(Person obj)
    {
        return obj.Name.GetHashCode(); // 名前のハッシュコードを取得
    }
}

Bob

空のコレクションを扱う場合の挙動

空のコレクションを扱う場合、Intersectメソッドは常に空のコレクションを返します。

以下のサンプルコードでは、空のリストを使って共通要素を取得しています。

using System;
using System.Collections.Generic;
using System.Linq;
class Program
{
    static void Main()
    {
        List<int> list1 = new List<int> { };
        List<int> list2 = new List<int> { 1, 2, 3 };
        // 共通要素を取得
        var commonElements = list1.Intersect(list2);
        foreach (var element in commonElements)
        {
            Console.WriteLine(element); // 共通要素を出力
        }
    }
}

(何も出力されない)

このように、空のコレクションを使用した場合、Intersectメソッドは結果として何も出力しません。

Intersectメソッドの応用

カスタムクラスでの共通要素取得

カスタムクラスを使用することで、特定のプロパティに基づいて共通要素を取得することができます。

以下に、IEqualityComparerを使ったカスタム比較と、匿名型を使った共通要素の取得の例を示します。

IEqualityComparerを使ったカスタム比較

IEqualityComparerを実装することで、カスタムクラスの特定のプロパティを基準に共通要素を取得できます。

以下のサンプルコードでは、PersonクラスのNameプロパティを使って共通要素を取得しています。

using System;
using System.Collections.Generic;
using System.Linq;
class Person
{
    public string Name { get; set; }
}
class Program
{
    static void Main()
    {
        List<Person> list1 = new List<Person> { new Person { Name = "Alice" }, new Person { Name = "Bob" } };
        List<Person> list2 = new List<Person> { new Person { Name = "Bob" }, new Person { Name = "Charlie" } };
        // 共通要素を取得
        var commonElements = list1.Intersect(list2, new PersonComparer());
        foreach (var element in commonElements)
        {
            Console.WriteLine(element.Name); // 共通要素を出力
        }
    }
}
class PersonComparer : IEqualityComparer<Person>
{
    public bool Equals(Person x, Person y)
    {
        return x.Name == y.Name; // 名前で比較
    }
    public int GetHashCode(Person obj)
    {
        return obj.Name.GetHashCode(); // 名前のハッシュコードを取得
    }
}

Bob

匿名型を使った共通要素の取得

匿名型を使用することで、簡単に共通要素を取得することも可能です。

以下のサンプルコードでは、匿名型を使って共通の要素を取得しています。

using System;
using System.Collections.Generic;
using System.Linq;
class Program
{
    static void Main()
    {
        var list1 = new[] { new { Id = 1, Name = "Alice" }, new { Id = 2, Name = "Bob" } };
        var list2 = new[] { new { Id = 2, Name = "Bob" }, new { Id = 3, Name = "Charlie" } };
        // 共通要素を取得
        var commonElements = list1.Intersect(list2);
        foreach (var element in commonElements)
        {
            Console.WriteLine($"Id: {element.Id}, Name: {element.Name}"); // 共通要素を出力
        }
    }
}

Id: 2, Name: Bob

複数のコレクションから共通要素を取得する

複数のコレクションから共通要素を取得する場合、Intersectメソッドを連続して使用することができます。

以下のサンプルコードでは、3つのリストから共通の要素を取得しています。

using System;
using System.Collections.Generic;
using System.Linq;
class Program
{
    static void Main()
    {
        List<int> list1 = new List<int> { 1, 2, 3, 4, 5 };
        List<int> list2 = new List<int> { 4, 5, 6, 7, 8 };
        List<int> list3 = new List<int> { 5, 6, 7, 8, 9 };
        // 共通要素を取得
        var commonElements = list1.Intersect(list2).Intersect(list3);
        foreach (var element in commonElements)
        {
            Console.WriteLine(element); // 共通要素を出力
        }
    }
}

(何も出力されない)

Intersectメソッドと他のLINQメソッドの組み合わせ

Intersectメソッドは、他のLINQメソッドと組み合わせて使用することで、より複雑なクエリを構築できます。

以下に、IntersectとWhere、IntersectとSelectの組み合わせの例を示します。

IntersectとWhereの組み合わせ

Whereメソッドを使って条件を指定し、その後にIntersectメソッドを使用することで、特定の条件を満たす共通要素を取得できます。

using System;
using System.Collections.Generic;
using System.Linq;
class Program
{
    static void Main()
    {
        List<int> list1 = new List<int> { 1, 2, 3, 4, 5 };
        List<int> list2 = new List<int> { 4, 5, 6, 7, 8 };
        // 条件を指定して共通要素を取得
        var commonElements = list1.Where(x => x > 2).Intersect(list2.Where(x => x > 4));
        foreach (var element in commonElements)
        {
            Console.WriteLine(element); // 共通要素を出力
        }
    }
}

(何も出力されない)

IntersectとSelectの組み合わせ

Selectメソッドを使って、共通要素を取得した後に特定のプロパティを選択することもできます。

以下のサンプルコードでは、共通の要素を取得し、その要素を加工しています。

using System;
using System.Collections.Generic;
using System.Linq;
class Program
{
    static void Main()
    {
        List<int> list1 = new List<int> { 1, 2, 3, 4, 5 };
        List<int> list2 = new List<int> { 4, 5, 6, 7, 8 };
        // 共通要素を取得し、加工
        var commonElements = list1.Intersect(list2).Select(x => x * 10);
        foreach (var element in commonElements)
        {
            Console.WriteLine(element); // 加工した共通要素を出力
        }
    }
}

40
50

このように、Intersectメソッドは他のLINQメソッドと組み合わせることで、柔軟なデータ操作が可能になります。

Intersectメソッドのパフォーマンス

Intersectメソッドの計算量

Intersectメソッドの計算量は、主に入力コレクションのサイズに依存します。

一般的に、IntersectメソッドはO(n + m)の計算量を持ちます。

ここで、nは最初のコレクションの要素数、mは2番目のコレクションの要素数です。

この計算量は、最初のコレクションの要素をハッシュセットに格納し、次に2番目のコレクションの要素をチェックするため、効率的です。

したがって、コレクションのサイズが大きくなるほど、Intersectメソッドのパフォーマンスが重要になります。

大規模データセットでのIntersectの最適化

大規模データセットを扱う場合、Intersectメソッドのパフォーマンスを最適化するためのいくつかの戦略があります。

以下にその例を示します。

HashSetの使用: Intersectメソッドは内部でHashSetを使用しているため、最初のコレクションをHashSetに変換することで、検索時間を短縮できます。
小さいコレクションを最初に: より小さいコレクションを最初の引数として渡すことで、パフォーマンスを向上させることができます。

これにより、ハッシュテーブルのサイズが小さくなり、メモリ使用量も削減されます。

並列処理: PLINQ(Parallel LINQ)を使用して、Intersectメソッドを並列に実行することで、パフォーマンスを向上させることができます。

大規模データセットでは、並列処理が有効です。

Intersectメソッドのメモリ使用量

Intersectメソッドのメモリ使用量は、主に内部で使用されるデータ構造に依存します。

特に、HashSetを使用するため、コレクションのサイズが大きくなると、メモリ使用量も増加します。

以下の点に注意が必要です。

コレクションのサイズ: 大きなコレクションを扱う場合、HashSetのメモリ使用量が増加します。

特に、重複要素が多い場合、メモリのオーバーヘッドが発生する可能性があります。

ガーベジコレクション: Intersectメソッドの実行後、使用されなくなったオブジェクトはガーベジコレクションによって回収されますが、大規模データセットでは、ガーベジコレクションの頻度が増加する可能性があります。
メモリの最適化: 必要に応じて、メモリ使用量を最適化するために、コレクションのサイズを制限したり、不要なデータを削除したりすることが重要です。

これらの要素を考慮することで、Intersectメソッドのパフォーマンスを向上させ、効率的に共通要素を取得することができます。

Intersectメソッドの注意点

順序が保持されないこと

Intersectメソッドを使用する際の注意点の一つは、結果の順序が元のコレクションの順序を保持しないことです。

Intersectメソッドは、内部でHashSetを使用して共通要素を取得するため、要素の順序は保証されません。

これは、特に順序が重要な場合に問題となることがあります。

以下のサンプルコードでは、元のリストの順序が保持されないことを示しています。

using System;
using System.Collections.Generic;
using System.Linq;
class Program
{
    static void Main()
    {
        List<int> list1 = new List<int> { 1, 2, 3, 4, 5 };
        List<int> list2 = new List<int> { 1, 3, 5, 7, 9 };
        // 共通要素を取得
        var commonElements = list1.Intersect(list2);
        foreach (var element in commonElements)
        {
            Console.WriteLine(element); // 順序が保持されない
        }
    }
}

1
3
5

重複要素の扱い

Intersectメソッドは、重複要素を自動的に排除します。

つまり、結果には各要素が一度だけ表示されます。

これは、重複を許可しないコレクション(例えば、HashSet)を使用しているためです。

以下のサンプルコードでは、重複要素を含むリストから共通要素を取得しています。

using System;
using System.Collections.Generic;
using System.Linq;
class Program
{
    static void Main()
    {
        List<int> list1 = new List<int> { 1, 2, 2, 3, 4 };
        List<int> list2 = new List<int> { 2, 2, 3, 5 };
        // 共通要素を取得
        var commonElements = list1.Intersect(list2);
        foreach (var element in commonElements)
        {
            Console.WriteLine(element); // 重複要素は一度だけ出力
        }
    }
}

2
3

Null値を含むコレクションの扱い

Intersectメソッドは、Null値を含むコレクションを扱うことができますが、Null値の扱いには注意が必要です。

Null値が含まれている場合、他の要素との比較が行われるため、Null値が共通要素として扱われることがあります。

以下のサンプルコードでは、Null値を含むリストから共通要素を取得しています。

using System;
using System.Collections.Generic;
using System.Linq;
class Program
{
    static void Main()
    {
        List<string> list1 = new List<string> { "Alice", null, "Bob" };
        List<string> list2 = new List<string> { null, "Charlie", "Bob" };
        // 共通要素を取得
        var commonElements = list1.Intersect(list2);
        foreach (var element in commonElements)
        {
            Console.WriteLine(element ?? "null"); // Null値を出力
        }
    }
}

null
Bob

このように、Null値を含むコレクションを扱う際は、Null値が共通要素として出力されることを考慮する必要があります。

Intersectメソッドの代替手段

Intersectメソッドは非常に便利ですが、他にも共通要素を取得するための代替手段があります。

以下に、HashSetを使った方法、手動でループを使った方法、そしてExceptメソッドとの違いについて説明します。

HashSetを使った共通要素の取得

HashSetを使用することで、共通要素を効率的に取得することができます。

HashSetは、要素の重複を許さず、検索が高速であるため、Intersectメソッドと同様の結果を得ることができます。

以下のサンプルコードでは、HashSetを使って共通要素を取得しています。

using System;
using System.Collections.Generic;
class Program
{
    static void Main()
    {
        List<int> list1 = new List<int> { 1, 2, 3, 4, 5 };
        List<int> list2 = new List<int> { 4, 5, 6, 7, 8 };
        // HashSetを使用して共通要素を取得
        HashSet<int> set1 = new HashSet<int>(list1);
        set1.IntersectWith(list2); // list2との共通要素を取得
        foreach (var element in set1)
        {
            Console.WriteLine(element); // 共通要素を出力
        }
    }
}

4
5

手動でループを使った共通要素の取得

手動でループを使って共通要素を取得することも可能です。

この方法は、特に小規模なデータセットや特定の条件でのフィルタリングが必要な場合に有効です。

以下のサンプルコードでは、手動でループを使って共通要素を取得しています。

using System;
using System.Collections.Generic;
class Program
{
    static void Main()
    {
        List<int> list1 = new List<int> { 1, 2, 3, 4, 5 };
        List<int> list2 = new List<int> { 4, 5, 6, 7, 8 };
        // 手動でループを使って共通要素を取得
        List<int> commonElements = new List<int>();
        foreach (var item in list1)
        {
            if (list2.Contains(item)) // list2に含まれているか確認
            {
                commonElements.Add(item); // 共通要素を追加
            }
        }
        foreach (var element in commonElements)
        {
            Console.WriteLine(element); // 共通要素を出力
        }
    }
}

4
5

Exceptメソッドとの違い

Exceptメソッドは、指定したコレクションに含まれない要素を取得するためのメソッドです。

Intersectメソッドが共通要素を取得するのに対し、Exceptメソッドは差集合を取得します。

以下に、両者の違いを示すサンプルコードを示します。

using System;
using System.Collections.Generic;
using System.Linq;
class Program
{
    static void Main()
    {
        List<int> list1 = new List<int> { 1, 2, 3, 4, 5 };
        List<int> list2 = new List<int> { 4, 5, 6, 7, 8 };
        // Intersectメソッドを使用
        var intersectElements = list1.Intersect(list2);
        Console.WriteLine("共通要素 (Intersect):");
        foreach (var element in intersectElements)
        {
            Console.WriteLine(element); // 共通要素を出力
        }
        // Exceptメソッドを使用
        var exceptElements = list1.Except(list2);
        Console.WriteLine("差集合 (Except):");
        foreach (var element in exceptElements)
        {
            Console.WriteLine(element); // list2に含まれない要素を出力
        }
    }
}

共通要素 (Intersect):
4
5
差集合 (Except):
1
2
3

このように、Intersectメソッドは共通要素を取得するために使用され、Exceptメソッドは差集合を取得するために使用されます。

用途に応じて使い分けることが重要です。

まとめ

この記事では、C#のLINQにおけるIntersectメソッドの基本的な使い方や応用、パフォーマンスに関する注意点について詳しく解説しました。

特に、Intersectメソッドを使用する際の順序や重複要素、Null値の扱いについても触れ、他の代替手段との違いを明確にしました。

これらの情報を参考にして、実際のプログラミングにおいてIntersectメソッドを効果的に活用し、データ処理の効率を向上させてみてください。