Arrays in C#

Ein Array ist eine Menge von Objekten. Die in einem Array vorhandenen Elemente sind vom gleichen Datentyp. Es kann int, float, char usw. sein. Das Konzept der Arrays in C# entstand, um die umständliche Speicherung verschiedener Werte durch die Erstellung verschiedener Variablen zu vermeiden.

Der Index eines Arrays beginnt bei 0 und der Index eines Arrays wird basierend auf der spezifischen Größe eines Arrays erhöht. Wenn wir ein Array mit der Länge 5 haben, beginnt das Array bei Index 0 und endet bei Index 4. Die Länge des Arrays definiert also die Anzahl der Elemente in diesem Array.

Wie funktioniert das Array in C#?

In C# kann die Länge des Arrays fest oder dynamisch sein. In einem Array fester Länge kann eine feste Anzahl von Elementen gespeichert werden. In einem dynamischen Array nimmt die Größe zu, wenn neue Elemente zum Array hinzugefügt werden, da die Speicherzuweisung eines Arrays dynamisch ist. In Arrays speichert der Stapelspeicher die Variable des Arrays, während der verwaltete Heap die Elemente speichert. In C# wird das Array von System abgeleitet. Array-Klasse. Wenn wir ein Ganzzahl-Array haben, haben alle Elemente ihren jeweiligen Wert, und da ein Array in C# ein Referenztyp ist, enthalten die Elemente einen Verweis auf tatsächliche Objekte.

Wie erstelle ich ein Array in C#?

Syntax eines Arrays:

data_type [] name_of_array

1. Deklaration eines Arrays

Code:

class Name
{
static void Main(string[]args)
{
Int32[] intarray;   //array declaration
}
}

Code-Erklärung: In der Array-Deklaration ist der erste Teil der Datentyp, der den Typ der Objekte in einem Array definiert. Der zweite Teil ist [], der die Anzahl der Objekte in einem Array definiert, und als nächstes kommt der Name des Arrays, in diesem Fall int array

2. Array-Initialisierung

Code:

class Name
{
static void Main(string[]args)
{
Int32[] Intarray;   //array declaration
Intarray = new Int32[4]; // array initialization
Intarray[0]= 23;  // assigning values to the elements
Intarray[1]=5;
Intarray[2]=88;
Intarray[3]=6;
}
}

Code-Erklärung: Bei der Array-Initialisierung müssen wir die Anzahl der Werte in einem Array angeben, indem wir eckige Klammern verwenden und diese Werte jedem Array-Element zuweisen. Hier bedeutet intarray[0] also, dass wir einen Wert an der ersten Position zuweisen, intarray[1] bedeutet, dass wir Werte an der zweiten Position zuweisen und so weiter.

3. Werte von Array

Code:

class Name
{
static void Main(string[]args)
{
Int32[] Intarray;   //array declaration
Intarray = new Int32[4]; //array initialization
Intarray[0]= 23; //assigning values to array
Intarray[1]=5;
Intarray[2]=88;
Intarray[3]=6;
Console.WriteLine(Intarray[0]);
Console.WriteLine(Intarray[1]);
Console.WriteLine(Intarray[2]);
Console.WriteLine(Intarray[3]);
Console.ReadKey();
}
}

Code-Erklärung: Console.WriteLine ist eine Methode, um jeden Wert eines Arrays in der Konsole anzuzeigen.

Beispiele für Arrays in C#

Beispiele und Ergebnisse in C# werden unten angezeigt

Beispiel #1

Code:

using System;
namespace ArrayDemo
{
class Name
{
static void Main(string[] args)
{
Int32[] Intarray;   // array declaration
Intarray = new Int32[4]; // array initialization
Intarray[0] = 23;   // assigning values to the array element
Intarray[1] = 5;
Intarray[2] = 88;
Intarray[3] = 6;
Console.WriteLine(Intarray[0]);
Console.WriteLine(Intarray[1]);
Console.WriteLine(Intarray[2]);
Console.WriteLine(Intarray[3]);
Console.ReadKey();
}
}
}

Im obigen Code wird das Array mit vier Elementen deklariert und initialisiert und Console.WriteLine zeigt alle Werte an.

Ausgabe:

Beispiel #2

Code:

using System;
namespace Demo
{
class Array
{
static void Main(string[] args)
{
int[] arr = new int[4] { 10, 20, 30, 40 };
for (int i = 0; i < arr.Length; i++)    // Traverse array elements
{
Console.WriteLine(arr[i]);
}
}
}
}

Im obigen Code wird das Array mit vier Elementen initialisiert und deklariert und dann wird eine Schleife verwendet, um auf die Elemente des Arrays zuzugreifen.

Ausgabe:

Beispiel #3

Wir können foreach auch verwenden, um auf die Elemente des Arrays zuzugreifen

Code:

using System;
namespace Demo
{
class Array
{
static void Main(string[] args)
{
int[] arr = new int[4] { 10, 20, 30, 40 };
foreach (int i in arr)
{
Console.WriteLine(i);
}
}
}
}

Ausgabe:

Array-Typen in C#

In C# gibt es mehrere Arten von Arrays:

1. Eindimensionales Array.
2. Mehrdimensionales Array.
3. Gezackte Anordnung.

Die obigen Beispiele beziehen sich auf eindimensionale Arrays.

Mehrdimensionales Array

In rechteckigen Arrays oder mehrdimensionalen Arrays werden Daten in Tabellenform gespeichert.

Int[,] intArray = new int[4,3]

Darin haben wir die Größe des Arrays mit vier Zeilen und drei Spalten angegeben.

1. Deklaration mehrdimensionaler Arrays

int[,] array = new int[3,3]; //declaration of 2D array
int[,,] array=new int[3,3,3]; //declaration of 3D array

2. Initialisierung eines mehrdimensionalen Arrays

int[,] array = new int[3,3]; //declaration of 2D array
array[0,1]=10; //initialization
array[1,2]=20;
array[2,0]=30;<c/ode>

Beispiel für ein mehrdimensionales Array

Code:

using System;
namespace Demo
{
class Array
{
public static void Main()
{
int[,] intArray = new int[3, 2]{
{1, 2},
{2, 4},
{4, 8}
};
Console.WriteLine(intArray[0, 0]);
Console.WriteLine(intArray[0, 1]);
Console.WriteLine(intArray[1, 0]);
Console.WriteLine(intArray[1, 1]);
Console.WriteLine(intArray[2, 0]);
Console.WriteLine(intArray[2, 1]);
}
}
}

Code-Erklärung: Im obigen Code werden Zeilen und Spalten mit drei Zeilen und vier Spalten angegeben und Console.WriteLine zeigt alle Werte an.

Ausgabe:

Gezackte Anordnung

Elemente von gezackten Arrays sind „Array“, weil sie das Array direkt speichern.

1. Deklaration des gezackten Arrays

int[][] array = new int[3][];

Die erste Klammer gibt Auskunft über die Größe und die zweite Klammer über die Abmessungen des Arrays.

2. Initialisierung und Zuweisung von Werten zu den gezackten Arrays

array[0] = new int[4] { 1, 2, 3, 4 };
array[1] = new int[5] { 1, 2, 3, 4,5 };

Die Größe der Elemente kann unterschiedlich sein.

Unten finden Sie Beispiele für das gezackte Array:

Beispiel #1

Code:

using System;
namespace Demo
{
class Array
{
public static void Main()
{
int[][] array = new int[2][];// Declare the array
array[0] = new int[] { 1, 2, 6, 8 };// Initialize the array
array[1] = new int[] { 72, 51, 47, 23, 54, 13 };
// Traverse array elements
for (int i = 0; i < array.Length; i++)
{
for (int j = 0; j < array[i].Length; j++)
{
System.Console.Write(array[i][j] + " ");
}
System.Console.WriteLine();
}
}
}
}

Ausgabe:

Beispiel #2

Code:

using System;
namespace Demo
{
class Array
{
public static void Main()
{
int[][] array = new int[3][]{
new int[] { 51, 22, 43, 87 },
new int[] { 2, 3, 4, 56, 94, 23 },
new int[] { 4, 5 }
};
// Traverse array elements
for (int i = 0; i < array.Length; i++)
{
for (int j = 0; j < array[i].Length; j++)
{
System.Console.Write(array[i][j] + " ");
}
System.Console.WriteLine();
}
}
}
}

Ausgabe:

Array-Methode in C#

Die folgenden Punkte lauten wie folgt:

1. Clear(Array, Int32, Int32): This method is used to set the element range to default based on the type of element.
2. Clone(): This method is used to create a copy of the element.
3. Copy(Array, Array, Int32): This method is used to copy the elements of one array to another array.
4. Equals(Object): This method basically checks if the mentioned object is equal to the current object.
5. Sort(Array): This method is used to sort the array.
6. CreateInstance(Type, Int32): This method is used to create an array of a specific type, length, and size.
7. ToString(): This is used to display string representation.
8. GetType(): This method is used to return the type of object.
9. IndexOf(Array, Object): This method is used to search the particular object and return the first occurrence index in a 1D array.
10. Reverse(Array): This method is used to reverse the sequence of the elements.
11. SetValue(Object, Int32): This method in the 1D array is used to set the value of an element.

Example

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace ArrayMethod
{
class Program
{
static void Main(string[] args)
{
int[] arr = new int[6] { 5, 8, 9, 25, 0, 7 };
// Creating an empty array
int[] arr2 = new int[6];
Console.WriteLine("length of first array: " + arr.Length); // length of array
Array.Sort(arr);  //sorting array elements
Console.Write("Sorted array elements: ");
PrintArray(arr);
Array.Copy(arr, arr2, arr.Length);  // copy elements of one array to other
Console.Write("Second array elements: ");
PrintArray(arr2);
Console.WriteLine("Get Index:\t{0}", Array.IndexOf(arr, 9));  // index of value
Array.Reverse(arr);
Console.Write("\nFirst Array elements in reverse order: ");  // reverse the elements of array
PrintArray(arr);
Array.Clear(arr, 0, 6);  //set default value of elements
PrintArray(arr);
}
static void PrintArray(int[] arr)
{
foreach (int i in arr)
{
Console.Write("\t{0}", i);
}
Console.WriteLine("\n");
}
}
}

Code Explanation: The above code shows several methods of the array in which arr. Length is used to get the length which is equal to 6, Array. Sort gives the values in sorted form. Array. Copy copies the values from the first array to the second array. Array. The reverse displays the array in reverse order, whereas Clear sets the default values of the elements.

Output:

Conclusion

So it is better to declare one array variable instead of declaring too many different variables as elements in the memory are stored sequentially, which makes it faster. Also, it’s easy to traverse, manipulate and sort the data by using arrays.

Das obige ist der detaillierte Inhalt vonArrays in C#. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!