HashSet<T> Constructors

Definitie

Naamruimte:: System.Collections.Generic

Assembly's:: System.Collections.dll, System.Core.dll

Assembly:: System.Core.dll

Assembly:: System.Collections.dll

Assembly:: netstandard.dll

Belangrijk

Bepaalde informatie heeft betrekking op een voorlopige productversie die aanzienlijk kan worden gewijzigd voordat deze wordt uitgebracht. Microsoft biedt geen enkele expliciete of impliciete garanties met betrekking tot de informatie die hier wordt verstrekt.

Initialiseert een nieuw exemplaar van de HashSet<T> klasse.

Overloads

Name	Description
HashSet<T>()	Initialiseert een nieuw exemplaar van de HashSet<T> klasse die leeg is en maakt gebruik van de standaard gelijkheids comparer voor het settype.
HashSet<T>(IEnumerable<T>)	Initialiseert een nieuw exemplaar van de HashSet<T> klasse die gebruikmaakt van de standaard gelijkheidsgelijker voor het settype, bevat elementen die zijn gekopieerd uit de opgegeven verzameling en heeft voldoende capaciteit voor het aantal gekopieerde elementen.
HashSet<T>(IEqualityComparer<T>)	Initialiseert een nieuw exemplaar van de HashSet<T> klasse die leeg is en gebruikt de opgegeven gelijkheidsgelijker voor het settype.
HashSet<T>(Int32)	Initialiseert een nieuw exemplaar van de HashSet<T> klasse die leeg is, maar heeft gereserveerde ruimte voor `capacity` items en gebruikt de standaard gelijkheidsgelijker voor het settype.
HashSet<T>(IEnumerable<T>, IEqualityComparer<T>)	Initialiseert een nieuw exemplaar van de HashSet<T> klasse die gebruikmaakt van de opgegeven gelijkheidsgelijker voor het settype, bevat elementen die zijn gekopieerd uit de opgegeven verzameling en heeft voldoende capaciteit voor het aantal gekopieerde elementen.
HashSet<T>(Int32, IEqualityComparer<T>)	Initialiseert een nieuw exemplaar van de HashSet<T> klasse die gebruikmaakt van de opgegeven gelijkheidsgelijker voor het settype en heeft voldoende capaciteit voor `capacity` elementen.
HashSet<T>(SerializationInfo, StreamingContext)	Initialiseert een nieuw exemplaar van de HashSet<T> klasse met geserialiseerde gegevens.

HashSet<T>()

Initialiseert een nieuw exemplaar van de HashSet<T> klasse die leeg is en maakt gebruik van de standaard gelijkheids comparer voor het settype.

public:
 HashSet();

public HashSet();

Public Sub New ()

Voorbeelden

In het volgende voorbeeld ziet u hoe u twee HashSet<T> objecten maakt en vult. Dit voorbeeld maakt deel uit van een groter voorbeeld dat is opgegeven voor de UnionWith methode.

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);
}

let evenNumbers = HashSet<int>()
let oddNumbers = HashSet<int>()

for i = 0 to 4 do
    // Populate numbers with just even numbers.
    evenNumbers.Add(i * 2) |> ignore

    // Populate oddNumbers with just odd numbers.
    oddNumbers.Add(i * 2 + 1) |> ignore

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

Opmerkingen

De capaciteit van een HashSet<T> object is het aantal elementen dat het object kan bevatten. De capaciteit van een HashSet<T> object wordt automatisch verhoogd naarmate elementen aan het object worden toegevoegd.

Deze constructor is een O(1)-bewerking.

Van toepassing op

HashSet<T>(IEnumerable<T>)

Initialiseert een nieuw exemplaar van de HashSet<T> klasse die gebruikmaakt van de standaard gelijkheidsgelijker voor het settype, bevat elementen die zijn gekopieerd uit de opgegeven verzameling en heeft voldoende capaciteit voor het aantal gekopieerde elementen.

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))

Parameters

collection: IEnumerable<T>

De verzameling waarvan de elementen naar de nieuwe set worden gekopieerd.

Uitzonderingen

ArgumentNullException

collection is null.

Voorbeelden

In het volgende voorbeeld ziet u hoe u een HashSet<T> verzameling maakt op basis van een bestaande set. In dit voorbeeld worden twee sets gemaakt met respectievelijk even en oneven gehele getallen. Er wordt vervolgens een derde HashSet<T> object gemaakt op basis van de even gehele set.

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 }
*/


let displaySet (collection: HashSet<int>) =
    printf "{"

    for i in collection do
        printf $" {i}"

    printfn " }"

let evenNumbers = HashSet<int>()
let oddNumbers = HashSet<int>()

for i = 0 to 4 do
    // Populate numbers with just even numbers.
    evenNumbers.Add(i * 2) |> ignore

    // Populate oddNumbers with just odd numbers.
    oddNumbers.Add(i * 2 + 1) |> ignore

printf $"evenNumbers contains {evenNumbers.Count} elements: "
displaySet evenNumbers

printf $"oddNumbers contains {oddNumbers.Count} elements: "
displaySet oddNumbers

// Create a new HashSet populated with even numbers.
let numbers = HashSet<int> evenNumbers
printfn "numbers UnionWith oddNumbers..."
numbers.UnionWith oddNumbers

printf $"numbers contains {numbers.Count} elements: "
displaySet numbers
// 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

Opmerkingen

Als collection er duplicaten zijn, bevat de set een van elk uniek element. Er wordt geen uitzondering gegenereerd. Daarom is de grootte van de resulterende set niet identiek aan de grootte van collection.

Deze constructor is een O(n-bewerking, waarbij n het aantal elementen in de collection parameter is.

Van toepassing op

HashSet<T>(IEqualityComparer<T>)

Initialiseert een nieuw exemplaar van de HashSet<T> klasse die leeg is en gebruikt de opgegeven gelijkheidsgelijker voor het settype.

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))

Parameters

comparer: IEqualityComparer<T>

De IEqualityComparer<T> implementatie die moet worden gebruikt bij het vergelijken van waarden in de set of null het gebruik van de standaard EqualityComparer<T> implementatie voor het ingestelde type.

Opmerkingen

Deze constructor is een O(1)-bewerking.

Van toepassing op

HashSet<T>(Int32)

Initialiseert een nieuw exemplaar van de HashSet<T> klasse die leeg is, maar heeft gereserveerde ruimte voor capacity items en gebruikt de standaard gelijkheidsgelijker voor het settype.

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)

Parameters

capacity: Int32

De oorspronkelijke grootte van de HashSet<T>.

Opmerkingen

Omdat het formaat relatief duur is (herhashing vereist), wordt geprobeerd de grootte te minimaliseren door de aanvankelijke capaciteit in te stellen op basis van de waarde van de capacity.

Caution

Als capacity deze afkomstig is van gebruikersinvoer, geeft u de voorkeur aan het gebruik van een overbelasting van een constructor zonder parameter capacity en kunt u de grootte van de verzameling wijzigen als elementen worden toegevoegd. Als u een door de gebruiker opgegeven waarde moet gebruiken, kunt u deze vastzetten op een redelijke limiet (bijvoorbeeld Math.Clamp(untrustedValue, 0, 20)) of controleren of het aantal elementen overeenkomt met de opgegeven waarde.

Van toepassing op

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

Initialiseert een nieuw exemplaar van de HashSet<T> klasse die gebruikmaakt van de opgegeven gelijkheidsgelijker voor het settype, bevat elementen die zijn gekopieerd uit de opgegeven verzameling en heeft voldoende capaciteit voor het aantal gekopieerde elementen.

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))

Parameters

collection: IEnumerable<T>

De verzameling waarvan de elementen naar de nieuwe set worden gekopieerd.

comparer: IEqualityComparer<T>

Uitzonderingen

ArgumentNullException

collection is null.

Voorbeelden

In het volgende voorbeeld wordt gebruikgemaakt van een gegeven IEqualityComparer<T> om hoofdlettergevoelige vergelijkingen toe te staan op de elementen van een HashSet<T> verzameling voertuigtypen.

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

let allVehicles = HashSet<string> StringComparer.OrdinalIgnoreCase
let someVehicles = ResizeArray()

someVehicles.Add "Planes"
someVehicles.Add "Trains"
someVehicles.Add "Automobiles"

// Add in the vehicles contained in the someVehicles list.
allVehicles.UnionWith someVehicles

printfn "The current HashSet contains:\n"

for vehicle in allVehicles do
    printfn $"{vehicle}"

allVehicles.Add "Ships" |> ignore
allVehicles.Add "Motorcycles" |> ignore
allVehicles.Add "Rockets" |> ignore
allVehicles.Add "Helicopters" |> ignore
allVehicles.Add "Submarines" |> ignore

printfn "\nThe updated HashSet contains:\n"

for vehicle in allVehicles do
    printfn $"{vehicle}"

// Verify that the 'All Vehicles' set contains at least the vehicles in
// the 'Some Vehicles' list.
if allVehicles.IsSupersetOf someVehicles then
    printfn "\nThe 'All' vehicles set contains everything in 'Some' vehicles list."

// Check for Rockets. Here the OrdinalIgnoreCase comparer will compare
// true for the mixed-case vehicle type.
if allVehicles.Contains "roCKeTs" then
    printfn "\nThe 'All' vehicles set contains 'roCKeTs'"

allVehicles.ExceptWith someVehicles
printfn "\nThe excepted HashSet contains:\n"

for vehicle in allVehicles do
    printfn $"{vehicle}"

// Predicate to determine vehicle 'coolness'.
let isNotSuperCool vehicle =
    let superCool = vehicle = "Helicopters" || vehicle = "Motorcycles"
    not superCool

// Remove all the vehicles that are not 'super cool'.
allVehicles.RemoveWhere isNotSuperCool |> ignore

printfn "\nThe super cool vehicles are:\n"

for vehicle in allVehicles do
    printfn $"{vehicle}"

// 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' vehicles 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

Opmerkingen

Deze constructor is een O(n-bewerking, waarbij n het aantal elementen in de collection parameter is.

Van toepassing op

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

Initialiseert een nieuw exemplaar van de HashSet<T> klasse die gebruikmaakt van de opgegeven gelijkheidsgelijker voor het settype en heeft voldoende capaciteit voor capacity elementen.

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))

Parameters

capacity: Int32

De oorspronkelijke grootte van de HashSet<T>.

comparer: IEqualityComparer<T>

De IEqualityComparer<T>-implementatie die moet worden gebruikt bij het vergelijken van waarden in de set of null (niets in Visual Basic) om de standaard-IEqualityComparer<T>-implementatie voor het settype te gebruiken.

Opmerkingen

Omdat het formaat relatief duur is (herhashing vereist), wordt geprobeerd de grootte te minimaliseren door de aanvankelijke capaciteit in te stellen op basis van de waarde van de capacity.

Caution

Van toepassing op

HashSet<T>(SerializationInfo, StreamingContext)

Initialiseert een nieuw exemplaar van de HashSet<T> klasse met geserialiseerde gegevens.

protected:
 HashSet(System::Runtime::Serialization::SerializationInfo ^ info, System::Runtime::Serialization::StreamingContext context);

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>

Protected Sub New (info As SerializationInfo, context As StreamingContext)

Parameters

info: SerializationInfo

Een SerializationInfo object dat de informatie bevat die nodig is om het HashSet<T> object te serialiseren.

context: StreamingContext

Een StreamingContext structuur die de bron en het doel van de geserialiseerde stroom bevat die aan het HashSet<T> object is gekoppeld.

Opmerkingen

Deze constructor wordt aangeroepen tijdens deserialisatie om een object te reconstitueren dat via een stroom wordt verzonden. Zie XML- en SOAP-serialisatie voor meer informatie.

Van toepassing op

Feedback

Is deze pagina nuttig?