Zusammenstellung von C#-Grundkenntnissen: Array „Grundkenntnisse (14)“.

Egal in welcher Sprache, es wird auf jeden Fall das Konzept der Mengen geben. Die einfachste und intuitivste Sammlung sollte ein Array sein. Ein Array ist ein kontinuierlicher Raum im Speicher. Schauen Sie sich die Definition von Array

in C# an.
1. int[] intArry;
intArry= new int[6];
Hier wird eine int-Array-Variable intArry deklariert und ein int-Array-Objekt mit 6 Einheiten gespeichert; = new int[3, 4];
Deklarieren Sie eine zweidimensionale Array-Variable vom Typ int und initialisieren Sie ein Array-Objekt mit 3 Zeilen und 4 Spalten
int[][] intArry3 = new int[9 ][] ;
Deklarieren Sie eine Array-Einheit als Array-Variable vom Array-Typ int. Jedes Array-Element ist eine Objektreferenz vom Array-Typ int.
Da es sich um eine objektorientierte Sprache handelt, werden Referenzen und Objekte oben erwähnt. Tatsächlich:
1. .net Frameword-Array ist keine einfache Datenstruktur, sondern ein Typ, der als Array-Typ bezeichnet wird.
2. Array-Variablen in .net Framework speichern Verweise auf Array-Typ-Objekte , das Array ist ein Objekt.
Alle .net Framework-Arrays (int[], string[], object[]) sind von Array geerbte Unterklassen. Im Allgemeinen wird die Array-Klasse nicht direkt verwendet, da verschiedene Sprachen

unter dem .net Framework, darunter natürlich auch C#, Array-Objekte ihrer eigenen speziellen Syntax zuordnen, z. B. int[], string[] .

Arrays haben hauptsächlich zwei Attribute: Index und Länge, dh Index und Länge. Der Index wird für den Zugriff auf die Elemente im Array-Objekt verwendet, und die Länge ist die Länge des Arrays.
Sehen Sie sich einen Teil des Kontaktcodes an:

public class MyArray
    {
        /// <summary>
        /// 定义数组测试
        /// </summary>
        public void TestInt()
        {
            int[] intArry1 = null;

            intArry1 = new int[6];

            int[,] intArry2 = new int[3, 4];

            int[][] intArry3 = new int[9][];
        }
        
        /// <summary>
        /// 值类型数组转引用类型数组测试
        /// </summary>
        /// <param name="array"></param>
        /// <returns></returns>
        public static object[] Int32ToArrayOfObject(int[] array)
        {
            object[] objArray = new object[array.Length];

            for (int i = 0; i < array.Length; i++)
            {
                objArray[i] = array[i];
            }

            return objArray;
        }
        /// <summary>
        /// 数组的主要特性测试
        /// </summary>
        public static void MainTest()
        {
            //声明一个包含是个元素的字符串型数组
            string[] sArray = new string[10];
            //访问数组
            //赋值
            for (int i = 0; i < sArray.Length; i++)
            {
                sArray[i] = @"string" + i;
            }

            ConsoleToClientString(sArray);

            //另一种方式声明数组，所谓的枚举法
            sArray = new string[] { "TestString0", "TestString1", "TestString2" };

            ConsoleToClientString(sArray);

            //数组复制
            string[] newSArray = sArray.Clone() as string[];

            ConsoleToClientString(newSArray);

            //使用Array的CreateInstance方法声明10元素的整形数组
            int[] intArray = Array.CreateInstance(typeof(int), 10) as int[];

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

            ConsoleToClientInt(intArray);

            //数组之间的复制，指定位置，指定长度
            int[] newIntArray = new int[20];

            Array.Copy(intArray, 3, newIntArray, 4, intArray.Length - 3);

            ConsoleToClientInt(newIntArray);

            object[] objArray = sArray;

            ConsoleToClientObject(objArray);

            objArray = Int32ToArrayOfObject(intArray);

            ConsoleToClientObject(objArray);

            //数组的数组
            int[][] intArrayArray = new int[9][];

            Console.WriteLine("数组长度：" + intArrayArray.Length);

            //赋值
            for (int i = 1; i < 10; i++)
            {
                intArrayArray[i - 1] = new int[i];

                for (int j = 1; j <= i; j++)
                {
                    intArrayArray[i - 1][j - 1] = i * j;
                }
            }

            ConsoleToClientArrayArrayInt(intArrayArray);
            
            //二维数组
            int[,] intArray2D = new int[9, 9];

            Console.WriteLine(string.Format("二维数组 长度：{0},维数：{1}*{2}", intArray2D.Length, 

intArray2D.GetLength(0), intArray2D.GetLength(1)));

            for (int i = 1; i < 10; i++)
            {
                for (int j = 1; j <= i; j++)
                {
                    intArray2D[i - 1, j - 1] = i * j;
                }
            }

            int count = 0;

            foreach (int item in intArray2D)
            {
                if (item > 0)
                {
                    Console.Write("{0,2}", item);
                }

                if (++count >= 9)
                {
                    Console.WriteLine();

                    count = 0;
                }
            }
        }

        static void ConsoleToClientArrayArrayInt(int[][] intArrayArray)
        {
            foreach (int[] item1 in intArrayArray)
            {
                foreach (int item2 in item1)
                {
                    Console.Write("{0,2}", item2);
                }

                Console.WriteLine();
            }

            Console.WriteLine();
        }

        static void ConsoleToClientString(string[] sArray)
        {
            foreach (string item in sArray)
            {
                Console.Write(item + @",");
            }

            Console.WriteLine();
        }

        static void ConsoleToClientInt(int[] intArray)
        {
            foreach (int item in intArray)
            {
                Console.Write(item + @",");
            }

            Console.WriteLine();
        }

        static void ConsoleToClientObject(object[] objArray)
        {
            foreach (object item in objArray)
            {
                Console.Write(item.ToString() + @",");
            }

            Console.WriteLine();
        }

    }

Anruf

    class Program
    {
        static void Main(string[] args)
        {
            MyArray.MainTest();

            Console.ReadLine();
        }
    }

Ergebnis

Wie Sie sehen können aus dem oben Gesagten:
Arrays haben Referenztyp-Arrays und Werttyp-Arrays. Elemente werden zum Speichern von Referenzen auf Objekte verwendet, und der Initialisierungswert ist null. Bei Werttyp-Arrays speichern Elemente den Wert von

Objekte und für die numerische Typinitialisierung Der Wert ist 0.

Arrays haben Dimensionen, aber mehrdimensionale Arrays und Arrays von Arrays sind unterschiedliche Konzepte. IntArrayArray und intArray2D sind unterschiedlich. Das Array von Arrays stellt eine m*n-Determinante

dar, und ein mehrdimensionales Array ist ein Array, in dem jedes Element ein Array-Objekt ist.

Arrays implementieren wie andere Sammlungsklassen die ICollection-Schnittstelle und verfügen über Aufzählungs- und Iterationsfunktionen.

Das Obige ist die Zusammenstellung der C#-Grundkenntnisse: Grundkenntnisse (14) Array-Inhalte Weitere verwandte Inhalte finden Sie auf der chinesischen PHP-Website (www.php.cn)!