Dela via

F#-samlingstyper

  • Artikel

Genom att granska det här avsnittet kan du avgöra vilken F#-samlingstyp som passar bäst för ett visst behov. Dessa samlingstyper skiljer sig från samlingstyperna i .NET, till exempel de i System.Collections.Generic namnområdet, eftersom F#-samlingstyperna är utformade ur ett funktionellt programmeringsperspektiv snarare än ett objektorienterat perspektiv. Mer specifikt är det bara matrissamlingen som har föränderliga element. När du ändrar en samling skapar du därför en instans av den ändrade samlingen i stället för att ändra den ursprungliga samlingen.

Samlingstyperna skiljer sig också åt i vilken typ av datastruktur objekt lagras i. Datastrukturer som hash-tabeller, länkade listor och matriser har olika prestandaegenskaper och en annan uppsättning tillgängliga åtgärder.

Tabell med samlingstyper

I följande tabell visas F#-samlingstyper.

Typ Beskrivning Relaterade länkar
Lista En ordnad, oföränderlig serie med element av samma typ. Implementerad som en länkad lista. Listor

Listmodul
Matris En fast storlek, nollbaserad, föränderlig samling av på varandra följande dataelement som alla är av samma typ. Matriser

Matrismodul

Array2D-modul

Array3D-modul
Seq En logisk serie med element som alla är av en typ. Sekvenser är särskilt användbara när du har en stor, ordnad datasamling men inte nödvändigtvis förväntar dig att använda alla element. Enskilda sekvenselement beräknas endast efter behov, så en sekvens kan prestera bättre än en lista om inte alla element används. Sekvenser representeras av seq<'T> typen, som är ett alias för IEnumerable<T>. Därför kan alla .NET Framework-typer som implementeras System.Collections.Generic.IEnumerable<'T> användas som en sekvens. Sekvenser

Seq-modul
Map En oföränderlig ordlista med element. Element används av nyckeln. Mappningsmodul
Ställ in En oföränderlig uppsättning som baseras på binära träd, där jämförelse är funktionen för strukturell jämförelse av F#, som potentiellt använder implementeringar av System.IComparable gränssnittet på nyckelvärden. Ange modul

Tabell med funktioner

I det här avsnittet jämförs de funktioner som är tillgängliga för F#-samlingstyper. Funktionens beräkningskomplexitet anges, där N är storleken på den första samlingen och M är storleken på den andra samlingen, om någon. Ett bindestreck (-) anger att den här funktionen inte är tillgänglig i samlingen. Eftersom sekvenser utvärderas lazily kan en funktion som Seq.distinct kan vara O(1) eftersom den returnerar omedelbart, även om den fortfarande påverkar sekvensens prestanda när den räknas upp.

Funktion Matris List Sequence Mappning Ställ in beskrivning
append O(N) O(N) O(N) - - Returnerar en ny samling som innehåller elementen i den första samlingen följt av element i den andra samlingen.
add - - - O(log(N)) O(log(N)) Returnerar en ny samling med elementet tillagt.
Genomsnittliga O(N) O(N) O(N) - - Returnerar medelvärdet av elementen i samlingen.
averageBy O(N) O(N) O(N) - - Returnerar medelvärdet av resultatet av den angivna funktionen som tillämpas på varje element.
blit O(N) - - - - Kopierar ett avsnitt av en matris.
cache - - O(N) - - Beräknar och lagrar element i en sekvens.
Kasta - - O(N) - - Konverterar elementen till den angivna typen.
Välja O(N) O(N) O(N) - - Tillämpar den angivna funktionen f på varje element x i listan. Returnerar listan som innehåller resultatet för varje element där funktionen returnerar Some(f(x)).
Samla O(N) O(N) O(N) - - Tillämpar den angivna funktionen på varje element i samlingen, sammanfogar alla resultat och returnerar den kombinerade listan.
compareWith - - O(N) - - Jämför två sekvenser med hjälp av den angivna jämförelsefunktionen, element för element.
concat O(N) O(N) O(N) - - Kombinerar den angivna uppräkningen av uppräkningar som en enda sammanlänkad uppräkning.
innehåller - - - - O(log(N)) Returnerar true om uppsättningen innehåller det angivna elementet.
containsKey - - - O(log(N)) - Testar om ett element finns i domänen för en karta.
antal - - - - O(N) Returnerar antalet element i uppsättningen.
countBy - - O(N) - - Tillämpar en nyckelgenererande funktion på varje element i en sekvens och returnerar en sekvens som ger unika nycklar och deras antal förekomster i den ursprungliga sekvensen.
kopiering O(N) - O(N) - - Kopierar samlingen.
skapa O(N) - - - - Skapar en matris med hela element som från början är det angivna värdet.
fördröjning - - O(1) - - Returnerar en sekvens som har skapats från den angivna fördröjda specifikationen för en sekvens.
Skillnaden - - - - O(M*log(N)) Returnerar en ny uppsättning med elementen i den andra uppsättningen borttagna från den första uppsättningen.
distinct O(1)* Returnerar en sekvens som inte innehåller några duplicerade poster enligt generiska hash- och likhetsjämförelser på posterna. Om ett element inträffar flera gånger i sekvensen ignoreras senare förekomster.
distinctBy O(1)* Returnerar en sekvens som inte innehåller några duplicerade poster enligt den generiska hash- och likhetsjämförelserna på de nycklar som den angivna nyckelgenererande funktionen returnerar. Om ett element inträffar flera gånger i sekvensen ignoreras senare förekomster.
empty O(1) O(1) O(1) O(1) O(1) Skapar en tom samling.
finns O(N) O(N) O(N) O(log(N)) O(log(N)) Testar om något element i sekvensen uppfyller det angivna predikatet.
exists2 O(min(N,M)) - O(min(N,M)) Testar om något par av motsvarande element i indatasekvenserna uppfyller det angivna predikatet.
Fylla O(N) Anger ett område med element i matrisen till det angivna värdet.
filter O(N) O(N) O(N) O(N) O(N) Returnerar en ny samling som endast innehåller elementen i samlingen som det angivna predikatet returnerar true.
find O(N) O(N) O(N) O(log(N)) - Returnerar det första element som den angivna funktionen returnerar true. Returnerar System.Collections.Generic.KeyNotFoundException om det inte finns något sådant element.
findIndex O(N) O(N) O(N) - - Returnerar indexet för det första elementet i matrisen som uppfyller det angivna predikatet. Genererar System.Collections.Generic.KeyNotFoundException om inget element uppfyller predikatet.
findKey - - - O(log(N)) - Utvärderar funktionen för varje mappning i samlingen och returnerar nyckeln för den första mappningen där funktionen returnerar true. Om det inte finns något sådant element genererar System.Collections.Generic.KeyNotFoundExceptionden här funktionen .
Vik O(N) O(N) O(N) O(N) O(N) Tillämpar en funktion på varje element i samlingen och trådar ett ackumulatorargument via beräkningen. Om indatafunktionen är f och elementen är i0... iN, den här funktionen beräknar f (... (f s i0)...) I.
fold2 O(N) O(N) - - - Tillämpar en funktion på motsvarande element i två samlingar och trådar ett ackumulatorargument genom beräkningen. Samlingarna måste ha identiska storlekar. Om indatafunktionen är f och elementen är i0... iN och j0... jN, den här funktionen beräknar f (... (f s i0 j0)...) iN jN.
foldBack O(N) O(N) - O(N) O(N) Tillämpar en funktion på varje element i samlingen och trådar ett ackumulatorargument via beräkningen. Om indatafunktionen är f och elementen är i0... iN, den här funktionen beräknar f i0 (... (f iN s)).
foldBack2 O(N) O(N) - - - Tillämpar en funktion på motsvarande element i två samlingar och trådar ett ackumulatorargument genom beräkningen. Samlingarna måste ha identiska storlekar. Om indatafunktionen är f och elementen är i0... iN och j0... jN, den här funktionen beräknar f i0 j0 (... (f iN jN s)).
forall O(N) O(N) O(N) O(N) O(N) Testar om alla element i samlingen uppfyller det angivna predikatet.
forall2 O(N) O(N) O(N) - - Testar om alla motsvarande element i samlingen uppfyller det angivna predikatparet.
get/nth O(1) O(N) O(N) - - Returnerar ett element från samlingen givet dess index.
Huvud - O(1) O(1) - - Returnerar det första elementet i samlingen.
Init O(N) O(N) O(1) - - Skapar en samling med tanke på dimensionen och en generatorfunktion för att beräkna elementen.
initInfinite - - O(1) - - Genererar en sekvens som, när den itereras, returnerar efterföljande element genom att anropa den angivna funktionen.
intersect - - - - O(log(N)*log(M)) Beräknar skärningspunkten mellan två uppsättningar.
intersectMany - - - - O(N1*N2...) Beräknar skärningspunkten för en sekvens med uppsättningar. Sekvensen får inte vara tom.
isEmpty O(1) O(1) O(1) O(1) - Returnerar true om samlingen är tom.
isProperSubset - - - - O(M*log(N)) Returnerar true om alla element i den första uppsättningen finns i den andra uppsättningen och minst ett element i den andra uppsättningen inte finns i den första uppsättningen.
isProperSuperset - - - - O(M*log(N)) Returnerar true om alla element i den andra uppsättningen finns i den första uppsättningen och minst ett element i den första uppsättningen inte finns i den andra uppsättningen.
isSubset - - - - O(M*log(N)) Returnerar true om alla element i den första uppsättningen finns i den andra uppsättningen.
isSuperset - - - - O(M*log(N)) Returnerar true om alla element i den andra uppsättningen finns i den första uppsättningen.
Iter O(N) O(N) O(N) O(N) O(N) Tillämpar den angivna funktionen på varje element i samlingen.
iteri O(N) O(N) O(N) - - Tillämpar den angivna funktionen på varje element i samlingen. Heltalet som skickas till funktionen anger elementets index.
iteri2 O(N) O(N) - - - Tillämpar den angivna funktionen på ett par element som hämtas från matchande index i två matriser. Heltalet som skickas till funktionen anger indexet för elementen. De två matriserna måste ha samma längd.
iter2 O(N) O(N) O(N) - - Tillämpar den angivna funktionen på ett par element som hämtas från matchande index i två matriser. De två matriserna måste ha samma längd.
senaste O(1) O(N) O(N) - - Returnerar det sista objektet i den tillämpliga samlingen.
längd O(1) O(N) O(N) - - Returnerar antalet element i samlingen.
map O(N) O(N) O(1) - - Skapar en samling vars element är resultatet av att tillämpa den angivna funktionen på varje element i matrisen.
map2 O(N) O(N) O(1) - - Skapar en samling vars element är resultatet av att tillämpa den angivna funktionen på motsvarande element i de två samlingarna parvis. De två indatamatriserna måste ha samma längd.
map3 - O(N) - - - Skapar en samling vars element är resultatet av att tillämpa den angivna funktionen på motsvarande element i de tre samlingarna samtidigt.
Mapi O(N) O(N) O(N) - - Skapar en matris vars element är resultatet av att tillämpa den angivna funktionen på varje element i matrisen. Heltalsindexet som skickas till funktionen anger indexet för elementet som transformeras.
mapi2 O(N) O(N) - - - Skapar en samling vars element är resultatet av att tillämpa den angivna funktionen på motsvarande element i de två samlingarna parvis, och skickar även indexet för elementen. De två indatamatriserna måste ha samma längd.
max O(N) O(N) O(N) - - Returnerar det största elementet i samlingen, jämfört med maxoperatorn.
maxBy O(N) O(N) O(N) - - Returnerar det största elementet i samlingen, jämfört med max på funktionsresultatet.
maxElement - - - - O(log(N)) Returnerar det största elementet i uppsättningen enligt den ordning som används för uppsättningen.
min O(N) O(N) O(N) - - Returnerar det minsta elementet i samlingen, jämfört med min-operatorn.
minBy O(N) O(N) O(N) - - Returnerar det minsta elementet i samlingen, jämfört med min-operatorn i funktionsresultatet.
minElement - - - - O(log(N)) Returnerar det lägsta elementet i uppsättningen enligt den ordning som används för uppsättningen.
ofArray - O(N) O(1) O(N) O(N) Skapar en samling som innehåller samma element som den angivna matrisen.
ofList O(N) - O(1) O(N) O(N) Skapar en samling som innehåller samma element som den angivna listan.
ofSeq O(N) O(N) - O(N) O(N) Skapar en samling som innehåller samma element som den angivna sekvensen.
Pairwise - - O(N) - - Returnerar en sekvens av varje element i indatasekvensen och dess föregångare förutom det första elementet, som endast returneras som föregående element för det andra elementet.
Partition O(N) O(N) - O(N) O(N) Delar upp samlingen i två samlingar. Den första samlingen innehåller de element för vilka det angivna predikatet returnerar true, och den andra samlingen innehåller de element för vilka det angivna predikatet returnerar false.
permute O(N) O(N) - - - Returnerar en matris med alla element permuterade enligt den angivna permutationen.
Plocka O(N) O(N) O(N) O(log(N)) - Tillämpar den angivna funktionen på efterföljande element och returnerar det första resultatet där funktionen returnerar Vissa. Om funktionen aldrig returnerar Vissa utlöses System.Collections.Generic.KeyNotFoundException .
ReadOnly - - O(N) - - Skapar ett sekvensobjekt som delegerar till det angivna sekvensobjektet. Den här åtgärden säkerställer att en typavbildning inte kan återupptäcka och mutera den ursprungliga sekvensen. Om du till exempel anger en matris returnerar den returnerade sekvensen elementen i matrisen, men du kan inte omvandla det returnerade sekvensobjektet till en matris.
Minska O(N) O(N) O(N) - - Tillämpar en funktion på varje element i samlingen och trådar ett ackumulatorargument via beräkningen. Den här funktionen börjar med att tillämpa funktionen på de två första elementen, skickar det här resultatet till funktionen tillsammans med det tredje elementet och så vidare. Funktionen returnerar slutresultatet.
reduceBack O(N) O(N) - - - Tillämpar en funktion på varje element i samlingen och trådar ett ackumulatorargument via beräkningen. Om indatafunktionen är f och elementen är i0... iN, den här funktionen beräknar f i0 (... (f iN-1 iN)).
ta bort - - - O(log(N)) O(log(N)) Tar bort ett element från kartans domän. Inget undantag utlöses om elementet inte finns.
Replikera - O(N) - - - Skapar en lista med en angiven längd med varje element inställt på det angivna värdet.
Rev O(N) O(N) - - - Returnerar en ny lista med elementen i omvänd ordning.
Scan O(N) O(N) O(N) - - Tillämpar en funktion på varje element i samlingen och trådar ett ackumulatorargument via beräkningen. Den här åtgärden tillämpar funktionen på det andra argumentet och det första elementet i listan. Åtgärden skickar sedan det här resultatet till funktionen tillsammans med det andra elementet och så vidare. Slutligen returnerar åtgärden listan över mellanliggande resultat och slutresultatet.
scanBack O(N) O(N) - - - Liknar foldBack-åtgärden men returnerar både mellanliggande och slutliga resultat.
Singleton - - O(1) - O(1) Returnerar en sekvens som endast ger ett objekt.
set O(1) - - - - Anger ett element i en matris till det angivna värdet.
hoppa över - - O(N) - - Returnerar en sekvens som hoppar över N-element i den underliggande sekvensen och sedan ger de återstående elementen i sekvensen.
skipWhile - - O(N) - - Returnerar en sekvens som, när den itereras, hoppar över element i den underliggande sekvensen medan det angivna predikatet returnerar true och sedan ger de återstående elementen i sekvensen.
sortera O(N*log(N)) genomsnitt

O(N^2) värsta fall		 O(N*log(N)) O(N*log(N)) - - Sorterar samlingen efter elementvärde. Element jämförs med jämför.
sortBy O(N*log(N)) genomsnitt

O(N^2) värsta fall		 O(N*log(N)) O(N*log(N)) - - Sorterar den angivna listan med hjälp av nycklar som den angivna projektionen tillhandahåller. Nycklar jämförs med jämför.
sortInPlace O(N*log(N)) genomsnitt

O(N^2) värsta fall		 - - - - Sorterar elementen i en matris genom att mutera den på plats och använda den angivna jämförelsefunktionen. Element jämförs med jämför.
sortInPlaceBy O(N*log(N)) genomsnitt

O(N^2) värsta fall		 - - - - Sorterar elementen i en matris genom att mutera den på plats och använda den angivna projektionen för nycklarna. Element jämförs med jämför.
sortInPlaceWith O(N*log(N)) genomsnitt

O(N^2) värsta fall		 - - - - Sorterar elementen i en matris genom att mutera den på plats och använda den angivna jämförelsefunktionen som ordning.
sortWith O(N*log(N)) genomsnitt

O(N^2) värsta fall		 O(N*log(N)) - - - Sorterar elementen i en samling med den angivna jämförelsefunktionen som ordning och returnerar en ny samling.
under O(N) - - - - Skapar en matris som innehåller det angivna underintervallet som anges genom att starta index och längd.
summa O(N) O(N) O(N) - - Returnerar summan av elementen i samlingen.
sumBy O(N) O(N) O(N) - - Returnerar summan av de resultat som genereras genom att tillämpa funktionen på varje element i samlingen.
Svans - O(1) - - - Returnerar listan utan sitt första element.
ta - - O(N) - - Returnerar elementen i sekvensen upp till ett angivet antal.
takeWhile - - O(1) - - Returnerar en sekvens som, när den itereras, ger element i den underliggande sekvensen medan det angivna predikatet returnerar true och sedan inte returnerar fler element.
toArray - O(N) O(N) O(N) O(N) Skapar en matris från den angivna samlingen.
toList O(N) - O(N) O(N) O(N) Skapar en lista från den angivna samlingen.
toSeq O(1) O(1) - O(1) O(1) Skapar en sekvens från den angivna samlingen.
trunkera - - O(1) - - Returnerar en sekvens som, när den räknas upp, inte returnerar mer än N-element.
tryFind O(N) O(N) O(N) O(log(N)) - Söker efter ett element som uppfyller ett visst predikat.
tryFindIndex O(N) O(N) O(N) - - Söker efter det första elementet som uppfyller ett visst predikat och returnerar indexet för matchande element, eller None om det inte finns något sådant element.
tryFindKey - - - O(log(N)) - Returnerar nyckeln för den första mappningen i samlingen som uppfyller det angivna predikatet eller returnerar None om det inte finns något sådant element.
tryPick O(N) O(N) O(N) O(log(N)) - Tillämpar den angivna funktionen på efterföljande element och returnerar det första resultatet där funktionen returnerar Some för något värde. Om det inte finns något sådant element returnerar Noneåtgärden .
Utvecklas - - O(N) - - Returnerar en sekvens som innehåller de element som den angivna beräkningen genererar.
union - - - - O(M*log(N)) Beräknar union av de två uppsättningarna.
unionMany - - - - O(N1*N2...) Beräknar union av en sekvens med uppsättningar.
Packa upp O(N) O(N) O(N) - - Delar upp en lista med par i två listor.
packa upp3 O(N) O(N) O(N) - - Delar upp en lista med tripplar i tre listor.
Fönsterläge - - O(N) - - Returnerar en sekvens som ger skjutfönster som innehåller element som hämtas från indatasekvensen. Varje fönster returneras som en ny matris.
Zip O(N) O(N) O(N) - - Kombinerar de två samlingarna i en lista över par. De två listorna måste ha samma längd.
zip3 O(N) O(N) O(N) - - Kombinerar de tre samlingarna till en lista över tripplar. Listorna måste ha lika långa längder.

Se även