Partage via


HashSet<T> Constructeurs

Définition

Initialise une nouvelle instance de la classe HashSet<T>.

Surcharges

HashSet<T>()

Initialise une nouvelle instance de la classe HashSet<T> vide et utilise le comparateur d'égalité par défaut pour le type du jeu.

HashSet<T>(IEnumerable<T>)

Initialise une nouvelle instance de la classe HashSet<T> qui utilise le comparateur d'égalité par défaut pour le type du jeu, contient des éléments copiés à partir de la collection spécifiée et possède une capacité suffisante pour accueillir le nombre d'éléments copiés.

HashSet<T>(IEqualityComparer<T>)

Initialise une nouvelle instance de la classe HashSet<T> vide et utilise le comparateur d'égalité spécifié pour le type du jeu.

HashSet<T>(Int32)

Initialise une nouvelle instance de la classe HashSet<T> qui est vide, mais qui a de l’espace réservé pour des éléments capacity et qui utilise le comparateur d’égalité par défaut pour le type de l’ensemble.

HashSet<T>(IEnumerable<T>, IEqualityComparer<T>)

Initialise une nouvelle instance de la classe HashSet<T> qui utilise le comparateur d'égalité spécifié pour le type du jeu, contient des éléments copiés à partir de la collection spécifiée et possède une capacité suffisante pour accueillir le nombre d'éléments copiés.

HashSet<T>(Int32, IEqualityComparer<T>)

Initialise une nouvelle instance de la classe HashSet<T> qui utilise le comparateur d’égalité spécifié pour le type de jeu et dispose d’une capacité suffisante pour accueillir les éléments capacity.

HashSet<T>(SerializationInfo, StreamingContext)
Obsolète.

Initialise une nouvelle instance de la classe HashSet<T> avec des données sérialisées.

HashSet<T>()

Source:
HashSet.cs
Source:
HashSet.cs
Source:
HashSet.cs

Initialise une nouvelle instance de la classe HashSet<T> vide et utilise le comparateur d'égalité par défaut pour le type du jeu.

public:
 HashSet();
public HashSet ();
Public Sub New ()

Exemples

L’exemple suivant montre comment créer et remplir deux HashSet<T> objets. Cet exemple fait partie d’un exemple plus grand fourni pour la UnionWith méthode .

HashSet<int> evenNumbers = new HashSet<int>();
HashSet<int> oddNumbers = new HashSet<int>();

for (int i = 0; i < 5; i++)
{
    // Populate numbers with just even numbers.
    evenNumbers.Add(i * 2);

    // Populate oddNumbers with just odd numbers.
    oddNumbers.Add((i * 2) + 1);
}
Dim evenNumbers As HashSet(Of Integer) = New HashSet(Of Integer)()
Dim oddNumbers As HashSet(Of Integer) = New HashSet(Of Integer)()

For i As Integer = 0 To 4

    ' Populate evenNumbers with only even numbers.
    evenNumbers.Add(i * 2)

    ' Populate oddNumbers with only odd numbers.
    oddNumbers.Add((i * 2) + 1)
Next i

Remarques

La capacité d’un HashSet<T> objet est le nombre d’éléments que l’objet peut contenir. La capacité d’un HashSet<T> objet augmente automatiquement à mesure que des éléments sont ajoutés à l’objet.

Ce constructeur est une opération O(1).

S’applique à

HashSet<T>(IEnumerable<T>)

Source:
HashSet.cs
Source:
HashSet.cs
Source:
HashSet.cs

Initialise une nouvelle instance de la classe HashSet<T> qui utilise le comparateur d'égalité par défaut pour le type du jeu, contient des éléments copiés à partir de la collection spécifiée et possède une capacité suffisante pour accueillir le nombre d'éléments copiés.

public:
 HashSet(System::Collections::Generic::IEnumerable<T> ^ collection);
public HashSet (System.Collections.Generic.IEnumerable<T> collection);
new System.Collections.Generic.HashSet<'T> : seq<'T> -> System.Collections.Generic.HashSet<'T>
Public Sub New (collection As IEnumerable(Of T))

Paramètres

collection
IEnumerable<T>

Collection dont les éléments sont copiés dans le nouvel ensemble.

Exceptions

collection a la valeur null.

Exemples

L’exemple suivant montre comment créer une HashSet<T> collection à partir d’un jeu existant. Dans cet exemple, deux jeux sont créés avec des entiers pairs et impairs, respectivement. Un troisième HashSet<T> objet est ensuite créé à partir du jeu d’entiers pairs.

HashSet<int> evenNumbers = new HashSet<int>();
HashSet<int> oddNumbers = new HashSet<int>();

for (int i = 0; i < 5; i++)
{
    // Populate numbers with just even numbers.
    evenNumbers.Add(i * 2);

    // Populate oddNumbers with just odd numbers.
    oddNumbers.Add((i * 2) + 1);
}

Console.Write("evenNumbers contains {0} elements: ", evenNumbers.Count);
DisplaySet(evenNumbers);

Console.Write("oddNumbers contains {0} elements: ", oddNumbers.Count);
DisplaySet(oddNumbers);

// Create a new HashSet populated with even numbers.
HashSet<int> numbers = new HashSet<int>(evenNumbers);
Console.WriteLine("numbers UnionWith oddNumbers...");
numbers.UnionWith(oddNumbers);

Console.Write("numbers contains {0} elements: ", numbers.Count);
DisplaySet(numbers);

void DisplaySet(HashSet<int> collection)
{
    Console.Write("{");
    foreach (int i in collection)
    {
        Console.Write(" {0}", i);
    }
    Console.WriteLine(" }");
}

/* This example produces output similar to the following:
* evenNumbers contains 5 elements: { 0 2 4 6 8 }
* oddNumbers contains 5 elements: { 1 3 5 7 9 }
* numbers UnionWith oddNumbers...
* numbers contains 10 elements: { 0 2 4 6 8 1 3 5 7 9 }
*/
Shared Sub Main()

    Dim evenNumbers As HashSet(Of Integer) = New HashSet(Of Integer)()
    Dim oddNumbers As HashSet(Of Integer) = New HashSet(Of Integer)()

    For i As Integer = 0 To 4

        ' Populate evenNumbers with only even numbers.
        evenNumbers.Add(i * 2)

        ' Populate oddNumbers with only odd numbers.
        oddNumbers.Add((i * 2) + 1)
    Next i

    Console.Write("evenNumbers contains {0} elements: ", evenNumbers.Count)
    DisplaySet(evenNumbers)

    Console.Write("oddNumbers contains {0} elements: ", oddNumbers.Count)
    DisplaySet(oddNumbers)

    ' Create a new HashSet populated with even numbers.
    Dim numbers As HashSet(Of Integer) = New HashSet(Of Integer)(evenNumbers)
    Console.WriteLine("numbers UnionWith oddNumbers...")
    numbers.UnionWith(oddNumbers)

    Console.Write("numbers contains {0} elements: ", numbers.Count)
    DisplaySet(numbers)
End Sub

Remarques

La capacité d’un HashSet<T> objet est le nombre d’éléments que l’objet peut contenir. La capacité d’un HashSet<T> objet augmente automatiquement à mesure que des éléments sont ajoutés à l’objet.

Si collection contient des doublons, le jeu contient un de chaque élément unique. Aucune exception ne sera levée. Par conséquent, la taille du jeu résultant n’est pas identique à la taille de collection.

Ce constructeur est une opération O(n), où n est le nombre d’éléments dans le collection paramètre .

S’applique à

HashSet<T>(IEqualityComparer<T>)

Source:
HashSet.cs
Source:
HashSet.cs
Source:
HashSet.cs

Initialise une nouvelle instance de la classe HashSet<T> vide et utilise le comparateur d'égalité spécifié pour le type du jeu.

public:
 HashSet(System::Collections::Generic::IEqualityComparer<T> ^ comparer);
public HashSet (System.Collections.Generic.IEqualityComparer<T> comparer);
public HashSet (System.Collections.Generic.IEqualityComparer<T>? comparer);
new System.Collections.Generic.HashSet<'T> : System.Collections.Generic.IEqualityComparer<'T> -> System.Collections.Generic.HashSet<'T>
Public Sub New (comparer As IEqualityComparer(Of T))

Paramètres

comparer
IEqualityComparer<T>

Implémentation du IEqualityComparer<T> à utiliser pendant la comparaison des valeurs du jeu, ou null pour utiliser l'implémentation du EqualityComparer<T> par défaut pour le type du jeu.

Remarques

La capacité d’un HashSet<T> objet est le nombre d’éléments que l’objet peut contenir. La capacité d’un HashSet<T> objet augmente automatiquement à mesure que des éléments sont ajoutés à l’objet.

Ce constructeur est une opération O(1).

S’applique à

HashSet<T>(Int32)

Source:
HashSet.cs
Source:
HashSet.cs
Source:
HashSet.cs

Initialise une nouvelle instance de la classe HashSet<T> qui est vide, mais qui a de l’espace réservé pour des éléments capacity et qui utilise le comparateur d’égalité par défaut pour le type de l’ensemble.

public:
 HashSet(int capacity);
public HashSet (int capacity);
new System.Collections.Generic.HashSet<'T> : int -> System.Collections.Generic.HashSet<'T>
Public Sub New (capacity As Integer)

Paramètres

capacity
Int32

Taille initiale de .HashSet<T>

Remarques

Étant donné que les redimensionnements sont relativement coûteux (nécessitent un ressassement), cela tente de réduire le besoin de redimensionnement en définissant la capacité initiale en fonction de la valeur de .capacity

S’applique à

HashSet<T>(IEnumerable<T>, IEqualityComparer<T>)

Source:
HashSet.cs
Source:
HashSet.cs
Source:
HashSet.cs

Initialise une nouvelle instance de la classe HashSet<T> qui utilise le comparateur d'égalité spécifié pour le type du jeu, contient des éléments copiés à partir de la collection spécifiée et possède une capacité suffisante pour accueillir le nombre d'éléments copiés.

public:
 HashSet(System::Collections::Generic::IEnumerable<T> ^ collection, System::Collections::Generic::IEqualityComparer<T> ^ comparer);
public HashSet (System.Collections.Generic.IEnumerable<T> collection, System.Collections.Generic.IEqualityComparer<T> comparer);
public HashSet (System.Collections.Generic.IEnumerable<T> collection, System.Collections.Generic.IEqualityComparer<T>? comparer);
new System.Collections.Generic.HashSet<'T> : seq<'T> * System.Collections.Generic.IEqualityComparer<'T> -> System.Collections.Generic.HashSet<'T>
Public Sub New (collection As IEnumerable(Of T), comparer As IEqualityComparer(Of T))

Paramètres

collection
IEnumerable<T>

Collection dont les éléments sont copiés dans le nouvel ensemble.

comparer
IEqualityComparer<T>

Implémentation du IEqualityComparer<T> à utiliser pendant la comparaison des valeurs du jeu, ou null pour utiliser l'implémentation du EqualityComparer<T> par défaut pour le type du jeu.

Exceptions

collection a la valeur null.

Exemples

L’exemple suivant utilise un fourni IEqualityComparer<T> pour autoriser les comparaisons ne respectant pas la casse sur les éléments d’une HashSet<T> collection de types de véhicules.

#using <System.Core.dll>

using namespace System;
using namespace System::Collections::Generic;

ref class Program
{
public:
    static void Main()
    {
        HashSet<String^> ^allVehicles = gcnew HashSet<String^>(StringComparer::OrdinalIgnoreCase);
        List<String^>^ someVehicles = gcnew List<String^>();

        someVehicles->Add("Planes");
        someVehicles->Add("Trains");
        someVehicles->Add("Automobiles");

        // Add in the vehicles contained in the someVehicles list.
        allVehicles->UnionWith(someVehicles);

        Console::WriteLine("The current HashSet contains:\n");
        for each (String^ vehicle in allVehicles)
        {
            Console::WriteLine(vehicle);
        }

        allVehicles->Add("Ships");
        allVehicles->Add("Motorcycles");
        allVehicles->Add("Rockets");
        allVehicles->Add("Helicopters");
        allVehicles->Add("Submarines");

        Console::WriteLine("\nThe updated HashSet contains:\n");
        for each (String^ vehicle in allVehicles)
        {
            Console::WriteLine(vehicle);
        }

        // Verify that the 'All Vehicles' set contains at least the vehicles in
        // the 'Some Vehicles' list.
        if (allVehicles->IsSupersetOf(someVehicles))
        {
            Console::Write("\nThe 'All' vehicles set contains everything in ");
            Console::WriteLine("'Some' vechicles list.");
        }

        // Check for Rockets. Here the OrdinalIgnoreCase comparer will compare
        // true for the mixed-case vehicle type.
        if (allVehicles->Contains("roCKeTs"))
        {
            Console::WriteLine("\nThe 'All' vehicles set contains 'roCKeTs'");
        }

        allVehicles->ExceptWith(someVehicles);
        Console::WriteLine("\nThe excepted HashSet contains:\n");
        for each (String^ vehicle in allVehicles)
        {
            Console::WriteLine(vehicle);
        }

        // Remove all the vehicles that are not 'super cool'.
        allVehicles->RemoveWhere(gcnew Predicate<String^>(&isNotSuperCool));

        Console::WriteLine("\nThe super cool vehicles are:\n");
        for each (String^ vehicle in allVehicles)
        {
            Console::WriteLine(vehicle);
        }
    }

private:
    // Predicate to determine vehicle 'coolness'.
    static bool isNotSuperCool(String^ vehicle)
    {
        bool superCool = (vehicle == "Helicopters") || (vehicle == "Motorcycles");

        return !superCool;
    }
};

int main()
{
    Program::Main();
}

// The program writes the following output to the console::
//
// The current HashSet contains:
//
// Planes
// Trains
// Automobiles
//
// The updated HashSet contains:
//
// Planes
// Trains
// Automobiles
// Ships
// Motorcycles
// Rockets
// Helicopters
// Submarines
//
// The 'All' vehicles set contains everything in 'Some' vechicles list.
//
// The 'All' vehicles set contains 'roCKeTs'
//
// The excepted HashSet contains:
//
// Ships
// Motorcycles
// Rockets
// Helicopters
// Submarines
//
// The super cool vehicles are:
//
// Motorcycles
// Helicopters
HashSet<string> allVehicles = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
List<string> someVehicles = new List<string>();

someVehicles.Add("Planes");
someVehicles.Add("Trains");
someVehicles.Add("Automobiles");

// Add in the vehicles contained in the someVehicles list.
allVehicles.UnionWith(someVehicles);

Console.WriteLine("The current HashSet contains:\n");
foreach (string vehicle in allVehicles)
{
    Console.WriteLine(vehicle);
}

allVehicles.Add("Ships");
allVehicles.Add("Motorcycles");
allVehicles.Add("Rockets");
allVehicles.Add("Helicopters");
allVehicles.Add("Submarines");

Console.WriteLine("\nThe updated HashSet contains:\n");
foreach (string vehicle in allVehicles)
{
    Console.WriteLine(vehicle);
}

// Verify that the 'All Vehicles' set contains at least the vehicles in
// the 'Some Vehicles' list.
if (allVehicles.IsSupersetOf(someVehicles))
{
    Console.Write("\nThe 'All' vehicles set contains everything in ");
    Console.WriteLine("'Some' vechicles list.");
}

// Check for Rockets. Here the OrdinalIgnoreCase comparer will compare
// true for the mixed-case vehicle type.
if (allVehicles.Contains("roCKeTs"))
{
    Console.WriteLine("\nThe 'All' vehicles set contains 'roCKeTs'");
}

allVehicles.ExceptWith(someVehicles);
Console.WriteLine("\nThe excepted HashSet contains:\n");
foreach (string vehicle in allVehicles)
{
    Console.WriteLine(vehicle);
}

// Remove all the vehicles that are not 'super cool'.
allVehicles.RemoveWhere(isNotSuperCool);

Console.WriteLine("\nThe super cool vehicles are:\n");
foreach (string vehicle in allVehicles)
{
    Console.WriteLine(vehicle);
}

// Predicate to determine vehicle 'coolness'.
bool isNotSuperCool(string vehicle)
{
    bool superCool = (vehicle == "Helicopters") || (vehicle == "Motorcycles");

    return !superCool;
}

// The program writes the following output to the console.
//
// The current HashSet contains:
//
// Planes
// Trains
// Automobiles
//
// The updated HashSet contains:
//
// Planes
// Trains
// Automobiles
// Ships
// Motorcycles
// Rockets
// Helicopters
// Submarines
//
// The 'All' vehicles set contains everything in 'Some' vechicles list.
//
// The 'All' vehicles set contains 'roCKeTs'
//
// The excepted HashSet contains:
//
// Ships
// Motorcycles
// Rockets
// Helicopters
// Submarines
//
// The super cool vehicles are:
//
// Motorcycles
// Helicopters
Imports System.Collections.Generic

Class Program
    Public Shared Sub Main()
        Dim allVehicles As New HashSet(Of String)(StringComparer.OrdinalIgnoreCase)
        Dim someVehicles As New List(Of String)()

        someVehicles.Add("Planes")
        someVehicles.Add("Trains")
        someVehicles.Add("Automobiles")

        ' Add in the vehicles contained in the someVehicles list.
        allVehicles.UnionWith(someVehicles)

        Console.WriteLine("The current HashSet contains:" + Environment.NewLine)
        For Each vehicle As String In allVehicles
            Console.WriteLine(vehicle)
        Next vehicle

        allVehicles.Add("Ships")
        allVehicles.Add("Motorcycles")
        allVehicles.Add("Rockets")
        allVehicles.Add("Helicopters")
        allVehicles.Add("Submarines")

        Console.WriteLine(Environment.NewLine + "The updated HashSet contains:" + Environment.NewLine)
        For Each vehicle As String In allVehicles
            Console.WriteLine(vehicle)
        Next vehicle

        ' Verify that the 'All Vehicles' set contains at least the vehicles in
        ' the 'Some Vehicles' list.
        If allVehicles.IsSupersetOf(someVehicles) Then
            Console.Write(Environment.NewLine + "The 'All' vehicles set contains everything in ")
            Console.WriteLine("'Some' vechicles list.")
        End If

        ' Check for Rockets. Here the OrdinalIgnoreCase comparer will compare
        ' True for the mixed-case vehicle type.
        If allVehicles.Contains("roCKeTs") Then
            Console.WriteLine(Environment.NewLine + "The 'All' vehicles set contains 'roCKeTs'")
        End If

        allVehicles.ExceptWith(someVehicles)
        Console.WriteLine(Environment.NewLine + "The excepted HashSet contains:" + Environment.NewLine)
        For Each vehicle As String In allVehicles
            Console.WriteLine(vehicle)
        Next vehicle

        ' Remove all the vehicles that are not 'super cool'.
        allVehicles.RemoveWhere(AddressOf isNotSuperCool)

        Console.WriteLine(Environment.NewLine + "The super cool vehicles are:" + Environment.NewLine)
        For Each vehicle As String In allVehicles
            Console.WriteLine(vehicle)
        Next vehicle
    End Sub

    ' Predicate to determine vehicle 'coolness'.
    Private Shared Function isNotSuperCool(vehicle As String) As Boolean
        Dim notSuperCool As Boolean = _
            (vehicle <> "Helicopters") And (vehicle <> "Motorcycles")

        Return notSuperCool
    End Function
End Class

'
' The program writes the following output to the console.
'
' The current HashSet contains:
'
' Planes
' Trains
' Automobiles
'
' The updated HashSet contains:
'
' Planes
' Trains
' Automobiles
' Ships
' Motorcycles
' Rockets
' Helicopters
' Submarines
'
' The 'All' vehicles set contains everything in 'Some' vechicles list.
'
' The 'All' vehicles set contains 'roCKeTs'
'
' The excepted HashSet contains:
'
' Ships
' Motorcycles
' Rockets
' Helicopters
' Submarines
'
' The super cool vehicles are:
'
' Motorcycles
' Helicopters

Remarques

La capacité d’un HashSet<T> objet est le nombre d’éléments que l’objet peut contenir. La capacité d’un HashSet<T> objet augmente automatiquement à mesure que des éléments sont ajoutés à l’objet.

Si collection contient des doublons, le jeu contient un de chaque élément unique. Aucune exception ne sera levée. Par conséquent, la taille du jeu résultant n’est pas identique à la taille de collection.

Ce constructeur est une opération O(n), où n est le nombre d’éléments dans le collection paramètre .

S’applique à

HashSet<T>(Int32, IEqualityComparer<T>)

Source:
HashSet.cs
Source:
HashSet.cs
Source:
HashSet.cs

Initialise une nouvelle instance de la classe HashSet<T> qui utilise le comparateur d’égalité spécifié pour le type de jeu et dispose d’une capacité suffisante pour accueillir les éléments capacity.

public:
 HashSet(int capacity, System::Collections::Generic::IEqualityComparer<T> ^ comparer);
public HashSet (int capacity, System.Collections.Generic.IEqualityComparer<T>? comparer);
public HashSet (int capacity, System.Collections.Generic.IEqualityComparer<T> comparer);
new System.Collections.Generic.HashSet<'T> : int * System.Collections.Generic.IEqualityComparer<'T> -> System.Collections.Generic.HashSet<'T>
Public Sub New (capacity As Integer, comparer As IEqualityComparer(Of T))

Paramètres

capacity
Int32

Taille initiale de .HashSet<T>

comparer
IEqualityComparer<T>

Implémentation de IEqualityComparer<T> à utiliser lors de la comparaison des valeurs du jeu, ou null (Nothing en Visual Basic) pour utiliser l’implémentation de IEqualityComparer<T> par défaut pour le type de jeu.

Remarques

Étant donné que les redimensionnements sont relativement coûteux (nécessitent un ressassement), cela tente de réduire le besoin de redimensionnement en définissant la capacité initiale en fonction de la valeur de .capacity

S’applique à

HashSet<T>(SerializationInfo, StreamingContext)

Source:
HashSet.cs
Source:
HashSet.cs
Source:
HashSet.cs

Attention

This API supports obsolete formatter-based serialization. It should not be called or extended by application code.

Initialise une nouvelle instance de la classe HashSet<T> avec des données sérialisées.

protected:
 HashSet(System::Runtime::Serialization::SerializationInfo ^ info, System::Runtime::Serialization::StreamingContext context);
protected HashSet (System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context);
[System.Obsolete("This API supports obsolete formatter-based serialization. It should not be called or extended by application code.", DiagnosticId="SYSLIB0051", UrlFormat="https://aka.ms/dotnet-warnings/{0}")]
protected HashSet (System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context);
new System.Collections.Generic.HashSet<'T> : System.Runtime.Serialization.SerializationInfo * System.Runtime.Serialization.StreamingContext -> System.Collections.Generic.HashSet<'T>
[<System.Obsolete("This API supports obsolete formatter-based serialization. It should not be called or extended by application code.", DiagnosticId="SYSLIB0051", UrlFormat="https://aka.ms/dotnet-warnings/{0}")>]
new System.Collections.Generic.HashSet<'T> : System.Runtime.Serialization.SerializationInfo * System.Runtime.Serialization.StreamingContext -> System.Collections.Generic.HashSet<'T>
Protected Sub New (info As SerializationInfo, context As StreamingContext)

Paramètres

info
SerializationInfo

Objet SerializationInfo qui contient les informations nécessaires pour sérialiser l'objet HashSet<T>.

context
StreamingContext

Structure de StreamingContext qui contient la source et la destination du flux sérialisé associé à l'objet HashSet<T>.

Attributs

Remarques

Ce constructeur est appelé lors de la désérialisation pour reconstituer un objet transmis sur un flux. Pour plus d’informations, consultez Sérialisation XML et SOAP.

S’applique à