C# Dizi (Array): Tanımlama, Length, Sıralama, 2D ve Jagged Diziler

Bir dizi, tek tipte sabit sayıda elemanı bellekte yan yana saklar. Uzunluğu oluştururken seçersiniz, elemanları sıfır tabanlı bir indeksle okuyup yazarsınız ve uzunluk bundan sonra asla değişmez.

Bir diziyi tanımlamak ve başlatmak

Bir dizinin tipi, eleman tipinin ardından gelen []'dir. Bir dizi oluşturmanın birkaç yolu vardır:

using System;

class Program
{
    static void Main()
    {
        int[] scores = new int[4];                     // 4 elements, all 0
        string[] names = { "Ana", "Ben", "Chloe" };     // initializer
        double[] prices = new double[] { 2.5, 9.99 };   // explicit form
        var days = new[] { "Mon", "Tue", "Wed" };       // type inferred: string[]

        scores[0] = 90;
        scores[3] = 72;

        Console.WriteLine(string.Join(", ", scores));
        Console.WriteLine(names[1]);
        Console.WriteLine(prices.Length + " prices, " + days.Length + " days");
    }
}

Çıktı:

90, 0, 0, 72
Ben
2 prices, 3 days

new int[4] her elemanı tipin varsayılan değeriyle doldurur: sayılar için 0, bool için false, string'ler ve diğer referans tipleri için null. Kısa biçim { "Ana", "Ben" } yalnızca bir bildirimde çalışır; mevcut bir değişkene atarken names = new[] { "Dev", "Eli" }; gerekir.

Length, indeksleme ve son eleman

İndeksler 0'dan Length - 1'e kadardır. Length bir property'dir, bu yüzden parantezi yoktur (LINQ'in Count() metodunun aksine).

using System;

class Program
{
    static void Main()
    {
        int[] temps = { 18, 21, 25, 19, 16 };

        Console.WriteLine("Count: " + temps.Length);
        Console.WriteLine("First: " + temps[0]);
        Console.WriteLine("Last: " + temps[temps.Length - 1]);

        try
        {
            Console.WriteLine(temps[5]);
        }
        catch (IndexOutOfRangeException e)
        {
            Console.WriteLine("Caught " + e.GetType().Name);
        }
    }
}

Çıktı:

Count: 5
First: 18
Last: 16
Caught IndexOutOfRangeException

Sınırların dışında okumak ya da yazmak çalışma zamanında IndexOutOfRangeException fırlatır; derleyici bunu yakalamaz. Olağan neden, i < arr.Length yerine i <= arr.Length olarak yazılmış bir döngü koşuludur.

C# 8 ve sonrası, son eleman ve dilimler için daha kısa olan sondan indeks ve aralık sözdizimini ekler:

int last = temps[^1];        // 16
int[] middle = temps[1..4];  // { 21, 25, 19 }, a new array

Bir dizi üzerinde döngü

Bir for döngüsü size indeksi verir; foreach her elemanı verir ve yalnızca okurken daha anlaşılır seçimdir.

using System;

class Program
{
    static void Main()
    {
        decimal[] prices = { 4.50m, 12.00m, 3.25m };

        for (int i = 0; i < prices.Length; i++)
        {
            prices[i] = Math.Round(prices[i] * 1.10m, 2); // raise every price by 10%
        }

        decimal total = 0;
        foreach (decimal p in prices)
        {
            total += p;
        }

        Console.WriteLine(string.Join(" | ", prices));
        Console.WriteLine("Total: " + total);
    }
}

Çıktı:

4.95 | 13.20 | 3.58
Total: 21.73

foreach değişkeni salt okunurdur: döngünün içinde p = 0; bir derleme hatasıdır. Elemanları değiştirmek için indeksle dönün.

Sıralamak, ters çevirmek ve aramak

Yardımcılar statik Array sınıfındadır. Array.Sort yerinde sıralar ve hiçbir şey döndürmez, bu yüzden orijinal sıra kaybolur.

using System;

class Program
{
    static void Main()
    {
        int[] scores = { 72, 95, 60, 88, 79 };

        Array.Sort(scores);
        Console.WriteLine("Ascending:  " + string.Join(", ", scores));

        Array.Reverse(scores);
        Console.WriteLine("Descending: " + string.Join(", ", scores));

        Console.WriteLine("Index of 60: " + Array.IndexOf(scores, 60));
        Console.WriteLine("Index of 99: " + Array.IndexOf(scores, 99));
        Console.WriteLine("Any above 90: " + Array.Exists(scores, s => s > 90));
        Console.WriteLine("First below 75: " + Array.Find(scores, s => s < 75));

        string[] names = { "chloe", "Ana", "ben" };
        Array.Sort(names, StringComparer.OrdinalIgnoreCase);
        Console.WriteLine(string.Join(", ", names));

        string[] fruits = { "kiwi", "banana", "fig" };
        Array.Sort(fruits, (a, b) => a.Length.CompareTo(b.Length)); // by length
        Console.WriteLine(string.Join(", ", fruits));
    }
}

Çıktı:

Ascending:  60, 72, 79, 88, 95
Descending: 95, 88, 79, 72, 60
Index of 60: 4
Index of 99: -1
Any above 90: True
First below 75: 72
Ana, ben, chloe
fig, kiwi, banana

Array.IndexOf değer yoksa -1 döndürür. Array.Find hiçbir şey eşleşmediğinde tipin varsayılan değerini (burada 0) döndürür; bu sayılar için belirsizdir, önemli olduğunda Array.FindIndex kullanın. Tek çağrıda azalan sıralama Array.Sort(scores, (a, b) => b.CompareTo(a))'dır.

Orijinale dokunmadan sıralı sonuca ihtiyacınız varsa LINQ yeni bir dizi döndürür: var sorted = scores.OrderBy(s => s).ToArray();. Bkz. LINQ.

Yeniden boyutlandırma: bir dizi büyüyemez

Uzunluk sabittir. Array.Resize istenen boyutta yeni bir dizi oluşturur, elemanları kopyalar ve ref ile geçirdiğiniz değişkeni günceller.

using System;

class Program
{
    static void Main()
    {
        string[] queue = { "Ana", "Ben" };
        string[] before = queue;

        Array.Resize(ref queue, 4);
        queue[2] = "Chloe";

        Console.WriteLine(queue.Length);
        Console.WriteLine(before.Length);             // the old array is unchanged
        Console.WriteLine(queue[3] == null);          // new slots get the default
        Console.WriteLine(ReferenceEquals(before, queue));
    }
}

Çıktı:

4
2
True
False

Her yeniden boyutlandırma her elemanı kopyalar. Bir diziyi döngüde teker teker büyütmek yavaştır ve List<T>'nin iç dizisini ikiye katlayarak sizin için daha verimli yaptığı şey tam olarak budur.

Diziler referans tipleridir: kopyalama

Bir diziyi başka bir değişkene atamak elemanları değil referansı kopyalar. Bundan sonra iki ad da aynı diziyi gösterir.

using System;

class Program
{
    static void Main()
    {
        int[] original = { 1, 2, 3 };

        int[] alias = original;
        alias[0] = 100;
        Console.WriteLine(original[0]); // 100: same array

        int[] copy = (int[])original.Clone();
        copy[1] = 200;
        Console.WriteLine(original[1]); // 2: independent array

        int[] target = new int[5];
        Array.Copy(original, 0, target, 1, 3); // source, start, dest, start, count
        Console.WriteLine(string.Join(", ", target));
    }
}

Çıktı:

100
2
0, 100, 2, 3, 0

Aynısı bir diziyi bir metoda geçirdiğinizde de geçerlidir: metot çağıranın elemanlarını değiştirebilir. Clone, Array.Copy, CopyTo ve LINQ'in ToArray()'i hepsi sığ bir kopya yapar. Nesnelerden oluşan bir dizi için yeni dizi aynı nesnelere referanslar tutar, bu yüzden copy[0].Name'i değiştirmek original[0]'ın gördüğünü de değiştirir.

Dizileri == ile karşılaştırmak referansları karşılaştırır. İçerikleri karşılaştırmak için System.Linq'teki a.SequenceEqual(b)'yi kullanın.

2D diziler (çok boyutlu)

Dikdörtgen bir ızgara köşeli parantezlerin içinde bir virgülle bildirilir. Onu [row, col] ile indeksleyin.

using System;

class Program
{
    static void Main()
    {
        int[,] seats = new int[2, 3]; // 2 rows, 3 columns
        seats[0, 1] = 1;
        seats[1, 2] = 1;

        int[,] grid =
        {
            { 1, 2, 3 },
            { 4, 5, 6 },
        };

        Console.WriteLine("Rows: " + grid.GetLength(0));
        Console.WriteLine("Cols: " + grid.GetLength(1));
        Console.WriteLine("Length: " + grid.Length + ", Rank: " + grid.Rank);

        for (int r = 0; r < seats.GetLength(0); r++)
        {
            for (int c = 0; c < seats.GetLength(1); c++)
            {
                Console.Write(seats[r, c] == 1 ? "X " : ". ");
            }
            Console.WriteLine();
        }
    }
}

Çıktı:

Rows: 2
Cols: 3
Length: 6, Rank: 2
. X . 
. . X 

2D bir dizide Length toplam eleman sayısıdır (2'ye 3'lük bir ızgara için 6); iç içe döngülerin GetLength(0) ve GetLength(1) kullanmasının nedeni budur. Rank boyut sayısıdır. Üç boyut aynı şekilde çalışır: new int[4, 4, 4] ve cube[x, y, z]. 2D bir dizi üzerindeki foreach her elemanı satır satır ziyaret eder.

Jagged diziler (dizilerden oluşan diziler)

Jagged bir dizi int[][], elemanları kendileri dizi olan bir dizidir ve her iç dizinin kendi uzunluğu olabilir. Satırların boyutlarının farklı olduğu "müşteri başına siparişler" gibi verilere uyar.

using System;

class Program
{
    static void Main()
    {
        int[][] orders = new int[3][]; // 3 rows, none created yet
        orders[0] = new[] { 20, 35 };
        orders[1] = new[] { 12 };
        orders[2] = new[] { 8, 15, 40, 22 };

        for (int i = 0; i < orders.Length; i++)
        {
            Console.WriteLine("Customer " + i + ": " + orders[i].Length
                + " orders, " + string.Join(", ", orders[i]));
        }

        int[][] empty = new int[2][];
        Console.WriteLine(empty[0] == null);
    }
}

Çıktı:

Customer 0: 2 orders, 20, 35
Customer 1: 1 orders, 12
Customer 2: 4 orders, 8, 15, 40, 22
True

new int[3][] yalnızca dış diziyi oluşturur; her satır null olarak başlar ve bir satır atamadan önce orders[0][0] NullReferenceException fırlatır. new int[3][4] sözdizimine izin verilmez; her satırı kendiniz oluşturursunuz.

Gerçek bir ızgara için (bir tahta, bir matris, pikseller) [,], satırların uzunlukları farklıysa ya da tüm satırları değiştirmek istiyorsanız [][] kullanın.

Dizi ile List

Dönüştürmek her iki yönde de tek bir çağrıdır: new List<int>(arr) ya da arr.ToList() ve list.ToArray(). List<T> büyüyebilen sürümdür.

Yaygın hatalar

• Bir döngüde i <= arr.Length. Son geçerli indeks Length - 1'dir; bu IndexOutOfRangeException fırlatır.
• Diziyi doğrudan yazdırmak. Console.WriteLine(arr) System.Int32[] yazdırır; string.Join kullanın.
• Array.Sort'un sıralı diziyi döndürmesini beklemek. void döndürür ve yerinde sıralar.
• = ile kopyalamak. Bu referansı kopyalar; Clone() ya da ToArray() kullanın.
• Jagged satırları oluşturmadan kullanmak. new T[n][]'nin her satırı atanana kadar null'dır.
• 2D bir dizinin satırları için Length kullanmak. Her elemanı sayar; GetLength(0) kullanın.