C# Language
arrayer

Syntax

• Förklara en matris:

  <typ> [] <namn>;

• Förklara tvådimensionell matris:

  <type> [,] <name> = new <type> [<value>, <value>];

• Förklara en Jagged Array:

  <type> [] <name> = new <type> [<value>];

• Förklarar en subarray för en Jagged Array:

  <namn> [<värde>] = ny <typ> [<värde>];

• Initiera en matris utan värden:

  <namn> = ny <typ> [<längd>];

• Initierar en matris med värden:

  <namn> = ny <typ> [] {<värde>, <värde>, <värde>, ...};

• Initiera en tvådimensionell matris med värden:

  <namn> = ny <typ> [,] {{<value>, <value>}, {<value>, <value}}, ...};

• Åtkomst till ett element på index i:

  <Namn> [i]

• Få arrayens längd:

  <Namn> .Length

Anmärkningar

Array samvariation

string[] strings = new[] {"foo", "bar"};
object[] objects = strings; // implicit conversion from string[] to object[]

Denna konvertering är inte typsäker. Följande kod höjer ett runtime-undantag:

string[] strings = new[] {"Foo"};
object[] objects = strings;

objects[0] = new object(); // runtime exception, object is not string
string str = strings[0];   // would have been bad if above assignment had succeeded

Få och ställa in matrisvärden

int[] arr = new int[] { 0, 10, 20, 30}; 

// Get 
Console.WriteLine(arr[2]); // 20

// Set 
arr[2] = 100;

// Get the updated value
Console.WriteLine(arr[2]); // 100

Förklarar en matris

En matris kan deklareras och fyllas med standardvärdet med hjälp av initieringssyntax med kvadratisk parentes ( [] ). Skapa till exempel en rad med 10 heltal:

int[] arr = new int[10];

Index i C # är nollbaserat. Indexen för arrayen ovan kommer att vara 0-9. Till exempel:

int[] arr = new int[3] {7,9,4};
Console.WriteLine(arr[0]); //outputs 7
Console.WriteLine(arr[1]); //outputs 9

Vilket innebär att systemet börjar räkna elementindexet från 0. Dessutom görs åtkomst till element i matriser i konstant tid . Det betyder att åtkomst till det första elementet i matrisen har samma kostnad (i tid) för åtkomst till det andra elementet, det tredje elementet och så vidare.

Du kan också förklara att det är en hänvisning till en matris utan att omedelbart ange en matris.

int[] arr = null;   // OK, declares a null reference to an array.
int first = arr[0]; // Throws System.NullReferenceException because there is no actual array.

En matris kan också skapas och initialiseras med anpassade värden med hjälp av samlingsinitieringssyntax:

int[] arr = new int[] { 24, 2, 13, 47, 45 };

Det new int[] -partiet kan utelämnas när en arrayvariabel deklareras. Detta är inte ett fristående uttryck , så att använda det som en del av ett annat samtal fungerar inte (för det använder du versionen med new ):

int[] arr = { 24, 2, 13, 47, 45 };  // OK
int[] arr1;
arr1 = { 24, 2, 13, 47, 45 };       // Won't compile

Implicit typmatade matriser

Alternativt, i kombination med var nyckelordet, kan den specifika typen utelämnas så att arraytypen sluts:

// same as int[]
var arr = new [] { 1, 2, 3 };
// same as string[]
var arr = new [] { "one", "two", "three" };
// same as double[]
var arr = new [] { 1.0, 2.0, 3.0 };

Iterera över en matris

int[] arr = new int[] {1, 6, 3, 3, 9};

for (int i = 0; i < arr.Length; i++) 
{
    Console.WriteLine(arr[i]);
}

använder förhand:

foreach (int element in arr) 
{
    Console.WriteLine(element);
}

använder osäker åtkomst med pekare https://msdn.microsoft.com/en-ca/library/y31yhkeb.aspx

unsafe
{
    int length = arr.Length;
    fixed (int* p = arr)
    {
        int* pInt = p;
        while (length-- > 0)
        {
            Console.WriteLine(*pInt);
            pInt++;// move pointer to next element
        }
    }
}

Produktion:

1
6
3
3
9

Multidimensionella matriser

Matriser kan ha mer än en dimension. Följande exempel skapar en tvådimensionell grupp med tio rader och tio kolumner:

int[,] arr = new int[10, 10];

En matris med tre dimensioner:

int[,,] arr = new int[10, 10, 10];

Du kan också initialisera matrisen efter deklaration:

int[,] arr = new int[4, 2] { {1, 1}, {2, 2}, {3, 3}, {4, 4} };

// Access a member of the multi-dimensional array:
Console.Out.WriteLine(arr[3, 1]);  // 4

Jaggade matriser

Jaggade matriser är matriser som istället för primitiva typer innehåller matriser (eller andra samlingar). Det är som en matris med matriser - varje arrayelement innehåller en annan matris.

De liknar flerdimensionella matriser, men har en liten skillnad - eftersom flerdimensionella matriser är begränsade till ett fast antal rader och kolumner, med taggade matriser, kan varje rad ha ett annat antal kolumner.

Förklarar en taggad matris

Att till exempel förklara en taggad matris med 8 kolumner:

int[][] a = new int[8][];

Den andra [] initieras utan nummer. För att initialisera undermatriserna måste du göra det separat:

for (int i = 0; i < a.length; i++) 
{
    a[i] = new int[10];
}

Hämta / ställa in värden

Det är enkelt att få en av delområdena. Låt oss skriva ut alla siffrorna i den tredje kolumnen i a :

for (int i = 0; i < a[2].length; i++)
{
    Console.WriteLine(a[2][i]);
}

Få ett specifikt värde:

a[<row_number>][<column_number>]

Ställa in ett specifikt värde:

a[<row_number>][<column_number>] = <value>

Kom ihåg : Det rekommenderas alltid att använda taggade matriser (matriser av matriser) snarare än flerdimensionella matriser (matriser). Det är snabbare och säkrare att använda.

Notera om parentesernas ordning

Tänk på en tredimensionell matris med femdimensionella matriser av endimensionella matriser av int . Detta är skrivet i C # som:

int[,,][,,,,][] arr = new int[8, 10, 12][,,,,][];

I CLR-systemet är konventionen för beställning av konsolerna omvänd, så med ovanstående arr instans har vi:

    arr.GetType().ToString() == "System.Int32[][,,,,][,,]"

och på samma sätt:

    typeof(int[,,][,,,,][]).ToString() == "System.Int32[][,,,,][,,]"

Kontrollera om en grupp innehåller en annan grupp

public static class ArrayHelpers
{
    public static bool Contains<T>(this T[] array, T[] candidate)
    {
        if (IsEmptyLocate(array, candidate))
            return false;

        if (candidate.Length > array.Length)
            return false;

        for (int a = 0; a <= array.Length - candidate.Length; a++)
        {
            if (array[a].Equals(candidate[0]))
            {
                int i = 0;
                for (; i < candidate.Length; i++)
                {
                    if (false == array[a + i].Equals(candidate[i]))
                        break;
                }
                if (i == candidate.Length)
                    return true;
            }
        }
        return false;
    }

    static bool IsEmptyLocate<T>(T[] array, T[] candidate)
    {
        return array == null
            || candidate == null
            || array.Length == 0
            || candidate.Length == 0
            || candidate.Length > array.Length;
    }
}

/// Prov

byte[] EndOfStream = Encoding.ASCII.GetBytes("---3141592---");
byte[] FakeReceivedFromStream = Encoding.ASCII.GetBytes("Hello, world!!!---3141592---");
if (FakeReceivedFromStream.Contains(EndOfStream))
{
    Console.WriteLine("Message received");
}

Initierar en matris fylld med ett upprepat icke-standardvärde

Som vi vet kan vi förklara en matris med standardvärden:

int[] arr = new int[10];

Detta skapar en matris med 10 heltal med varje element i matrisen med värde 0 (standardvärdet för typ int ).

För att skapa en matris initialiserad med ett icke-standardvärde kan vi använda Enumerable.Repeat från System.Linq namnområdet:

1. För att skapa en bool grupp i storlek 10 fylld med "sant"

   bool[] booleanArray = Enumerable.Repeat(true, 10).ToArray(); 
   

2. Så här skapar du en int array i storlek 5 fylld med "100"

   int[] intArray = Enumerable.Repeat(100, 5).ToArray();
   

3. För att skapa en string array av storlek 5 fylld med "C #"

   string[] strArray = Enumerable.Repeat("C#", 5).ToArray();
   

Kopiera matriser

Kopiering av en partiell matris med Array.Copy() statisk Array.Copy() , börjar vid index 0 i både, källa och destination:

var sourceArray = new int[] { 11, 12, 3, 5, 2, 9, 28, 17 };
var destinationArray= new int[3];
Array.Copy(sourceArray, destinationArray, 3);

// destinationArray will have 11,12 and 3

Kopiera hela matrisen med CopyTo() , börjar vid index 0 för källan och det angivna indexet i destinationen:

var sourceArray = new int[] { 11, 12, 7 };
var destinationArray = new int[6];
sourceArray.CopyTo(destinationArray, 2);

// destinationArray will have 0, 0, 11, 12, 7 and 0

Clone används för att skapa en kopia av ett arrayobjekt.

var sourceArray = new int[] { 11, 12, 7 };
var destinationArray = (int)sourceArray.Clone();

//destinationArray will be created and will have 11,12,17.

Både CopyTo och Clone utför grunt exemplar vilket innebär att innehållet innehåller referenser till samma objekt som elementen i den ursprungliga matrisen.

Skapa en matris med sekvensnummer

LINQ tillhandahåller en metod som gör det enkelt att skapa en samling fylld med sekvensnummer. Till exempel kan du deklarera en matris som innehåller heltal mellan 1 och 100.

Metoden Enumerable.Range tillåter oss att skapa sekvens med heltal från en specificerad startposition och ett antal element.

Metoden tar två argument: startvärdet och antalet element som ska genereras.

Enumerable.Range(int start, int count)

Observera att count inte kan vara negativ.

Användande:

int[] sequence = Enumerable.Range(1, 100).ToArray();

Detta kommer att generera en matris som innehåller siffrorna 1 till 100 ( [1, 2, 3, ..., 98, 99, 100] ).

Eftersom Range metoden returnerar ett IEnumerable<int> , kan vi använda andra LINQ-metoder på den:

int[] squares = Enumerable.Range(2, 10).Select(x => x * x).ToArray();

Detta genererar en matris som innehåller 10 heltal kvadrater som börjar vid 4 : [4, 9, 16, ..., 100, 121] .

Jämföra matriser för jämlikhet

LINQ tillhandahåller en inbyggd funktion för att kontrollera jämställdheten mellan två IEnumerable , och den funktionen kan användas på matriser.

Den SequenceEqual funktionen åter true om matriser har samma längd och värdena i motsvarande index är lika och false annars.

int[] arr1 = { 3, 5, 7 };
int[] arr2 = { 3, 5, 7 };
bool result = arr1.SequenceEqual(arr2);
Console.WriteLine("Arrays equal? {0}", result);

Detta kommer att skriva ut:

Arrays equal? True

Matriser som IEnumerable <> instanser

Alla matriser implementerar det icke-generiska IList gränssnittet (och därmed icke-generiska ICollection och IEnumerable ).

IList<> viktigare är att endimensionell matris implementerar IList<> och IReadOnlyList<> generiska gränssnitt (och deras basgränssnitt) för den typ av data som de innehåller. Detta innebär att de kan behandlas som generiska otaliga typer och överlämnas till olika metoder utan att först behöva konvertera dem till en icke-matrisform.

int[] arr1 = { 3, 5, 7 };
IEnumerable<int> enumerableIntegers = arr1; //Allowed because arrays implement IEnumerable<T>
List<int> listOfIntegers = new List<int>();
listOfIntegers.AddRange(arr1); //You can pass in a reference to an array to populate a List.

Efter att ha kört den här koden kommer listan listOfIntegers att innehålla en List<int> innehåller värdena 3, 5 och 7.

IEnumerable<> betyder att matriser kan frågas med LINQ, till exempel arr1.Select(i => 10 * i) .