Una array es un grupo de variables del mismo tipo a las que se hace referencia con un nombre común. Y cada elemento de datos se llama un elemento de la array. Los tipos de datos de los elementos pueden ser cualquier tipo de datos válido como char, int, float, etc. y los elementos se almacenan en una ubicación contigua. La longitud de la array especifica el número de elementos presentes en la array. En C#, la asignación de memoria para las arrays se realiza de forma dinámica. Y las arrays son tipos de objetos, por lo tanto, es fácil encontrar su tamaño usando las funciones predefinidas. Las variables en la array están ordenadas y cada una tiene un índice que comienza en 0. Las arrays en C# funcionan de manera diferente a como lo hacen en C/C++.
Puntos importantes para recordar acerca de las arrays en C#
- En C#, todas las arrays se asignan dinámicamente.
- Dado que las arrays son objetos en C#, podemos encontrar su longitud utilizando la longitud de los miembros. Esto es diferente de C/C++ donde encontramos la longitud usando el operador sizeof.
- La variable de array AC# también se puede declarar como otras variables con [] después del tipo de datos.
- Las variables en la array están ordenadas y cada una tiene un índice que comienza en 0.
- La array de C# es un objeto de tipo base System.Array .
- Los valores predeterminados de la array numérica y los elementos de tipo de referencia se establecen en cero y nulo, respectivamente.
- Los elementos de una array irregular son tipos de referencia y se inicializan en nulo.
- Los elementos de array pueden ser de cualquier tipo, incluido un tipo de array.
- Los tipos de array son tipos de referencia que se derivan del tipo base abstracto Array. Estos tipos implementan IEnumerable y, para ello, usan la iteración foreach en todas las arrays en C#.
La array puede contener tipos de datos primitivos, así como objetos de una clase, según la definición de una array. Siempre que use tipos de datos primitivos, los valores reales deben almacenarse en ubicaciones de memoria contiguas. En el caso de objetos de una clase, los objetos reales se almacenan en el segmento de montón.
La siguiente figura muestra cómo la array almacena valores secuencialmente:
Explicación :
el índice comienza desde 0, que almacena valor. también podemos almacenar un número fijo de valores en una array. El índice de la array se incrementará en 1 secuencialmente siempre que no alcance el tamaño de la array.
Declaración de array
Sintaxis:
< Data Type > [ ] < Name_Array >
Aquí,
< Tipo de datos > : Define el tipo de elemento de la array.
[ ] : Define el tamaño del arreglo.
< Name_Array > : Es el Nombre de la array.
Ejemplo :
int[] x; // can store int values string[] s; // can store string values double[] d; // can store double values Student[] stud1; // can store instances of Student class which is custom class
Nota: solo la declaración de una array no asigna memoria a la array. Para esa array se debe inicializar.
Inicialización de arrays
Como se dijo anteriormente, una array es un tipo de referencia, por lo que la nueva palabra clave se usa para crear una instancia de la array. Podemos asignar inicializar elementos de array individuales, con la ayuda del índice.
Sintaxis:
type [ ] < Name_Array > = new < datatype > [size];
Aquí, el tipo especifica el tipo de datos que se asignan, el tamaño especifica la cantidad de elementos en la array y Name_Array es el nombre de una variable de array. Y new asignará memoria a una array de acuerdo con su tamaño.
Ejemplos: para mostrar diferentes formas para la declaración e inicialización de arrays
Ejemplo 1 :
// defining array with size 5. // But not assigns values int[] intArray1 = new int[5];
La declaración anterior declara e inicializa una array de tipo int que puede almacenar cinco valores int. El tamaño de la array se especifica entre corchetes ([]).
Ejemplo 2:
// defining array with size 5 and assigning
// values at the same time
int[] intArray2 = new int[5]{1, 2, 3, 4, 5};
La declaración anterior es la misma, pero asigna valores a cada índice en {}.
Ejemplo 3:
// defining array with 5 elements which
// indicates the size of an array
int[] intArray3 = {1, 2, 3, 4, 5};
En la declaración anterior, el valor de la array se inicializa directamente sin tomar su tamaño. Entonces, el tamaño de la array será automáticamente la cantidad de valores que se toman directamente.
Inicialización de una array después de la declaración
Las arrays se pueden inicializar después de la declaración. No es necesario declarar e inicializar al mismo tiempo usando la nueva palabra clave. Sin embargo, al inicializar una array después de la declaración, debe inicializarse con la nueva palabra clave. No se puede inicializar solo asignando valores.
Ejemplo :
// Declaración del arreglo
string[] str1, str2;// Inicialización de la array
str1 = new string[5]{ “Elemento 1”, “Elemento 2”, “Elemento 3”, “Elemento 4”, “Elemento 5” };str2 = nueva string[5]{ “Elemento 1”, “Elemento 2”, “Elemento 3”, “Elemento 4”, “Elemento 5” };
Nota: la inicialización sin dar tamaño no es válida en C#. Dará un error en tiempo de compilación.
Ejemplo: declaración incorrecta para inicializar una array
// error en tiempo de compilación: debe dar el tamaño de una array
int[] intArray = new int[];// error: inicialización incorrecta de una array
string[] str1;
str1 = {“Elemento 1”, “Elemento 2”, “Elemento 3”, “Elemento 4” };
Acceso a los elementos de la array
En el momento de la inicialización, podemos asignar el valor. Pero también podemos asignar el valor de la array utilizando su índice de forma aleatoria después de la declaración y la inicialización. Podemos acceder a un valor de array a través de la indexación, colocando el índice del elemento entre corchetes con el nombre de la array
Ejemplo:
//declares & initializes int type array int[] intArray = new int[5]; // assign the value 10 in array on its index 0 intArray[0] = 10; // assign the value 30 in array on its index 2 intArray[2] = 30; // assign the value 20 in array on its index 1 intArray[1] = 20; // assign the value 50 in array on its index 4 intArray[4] = 50; // assign the value 40 in array on its index 3 intArray[3] = 40; // Accessing array elements using index intArray[0]; //returns 10 intArray[2]; //returns 30
Implementación: Acceder a elementos de Array usando diferentes bucles
// C# program to illustrate creating an array
// of integers, puts some values in the array,
// and prints each value to standard output.
using System;
namespace geeksforgeeks {
class GFG {
// Main Method
public static void Main()
{
// declares an Array of integers.
int[] intArray;
// allocating memory for 5 integers.
intArray = new int[5];
// initialize the first elements
// of the array
intArray[0] = 10;
// initialize the second elements
// of the array
intArray[1] = 20;
// so on...
intArray[2] = 30;
intArray[3] = 40;
intArray[4] = 50;
// accessing the elements
// using for loop
Console.Write("For loop :");
for (int i = 0; i < intArray.Length; i++)
Console.Write(" " + intArray[i]);
Console.WriteLine("");
Console.Write("For-each loop :");
// using for-each loop
foreach(int i in intArray)
Console.Write(" " + i);
Console.WriteLine("");
Console.Write("while loop :");
// using while loop
int j = 0;
while (j < intArray.Length) {
Console.Write(" " + intArray[j]);
j++;
}
Console.WriteLine("");
Console.Write("Do-while loop :");
// using do-while loop
int k = 0;
do
{
Console.Write(" " + intArray[k]);
k++;
} while (k < intArray.Length);
}
}
}
Producción :
For loop : 10 20 30 40 50 For-each loop : 10 20 30 40 50 while loop : 10 20 30 40 50 Do-while loop : 10 20 30 40 50
Array unidimensional
En esta array contiene solo una fila para almacenar los valores. Todos los valores de esta array se almacenan de forma contigua desde 0 hasta el tamaño de la array. Por ejemplo, declarar una array unidimensional de 5 enteros:
int[] arrayint = new int[5];
La array anterior contiene los elementos desde arrayint[0] hasta arrayint[4]. Aquí, el nuevo operador tiene que crear la array y también inicializar su elemento con sus valores predeterminados. El ejemplo anterior, todos los elementos se inicializan con cero, porque es del tipo int.
Ejemplo :
// C# program to creating an array
// of the string as week days, store
// day values in the weekdays,
// and prints each value.
using System;
namespace geeksforgeeks {
class GFG {
// Main Method
public static void Main()
{
// declares a 1D Array of string.
string[] weekDays;
// allocating memory for days.
weekDays = new string[] {"Sun", "Mon", "Tue", "Wed",
"Thu", "Fri", "Sat"};
// Displaying Elements of array
foreach(string day in weekDays)
Console.Write(day + " ");
}
}
}
Producción :
Sun Mon Tue Wed Thu Fri Sat
Arrays multidimensionales
La array multidimensional contiene más de una fila para almacenar los valores. También se conoce como array rectangular en C# porque la longitud de cada fila es la misma. Puede ser una array 2D o una array 3D o más. Para almacenar y acceder a los valores de la array, se requería el bucle anidado. La declaración, inicialización y acceso a la array multidimensional es la siguiente:
// creates a two-dimensional array of // four rows and two columns. int[, ] intarray = new int[4, 2]; //creates an array of three dimensions, 4, 2, and 3 int[,, ] intarray1 = new int[4, 2, 3];
Ejemplo :
// C# program to illustrate creating
// an multi- dimensional array
// puts some values in the array,
// and print them
using System;
namespace geeksforgeeks {
class GFG {
// Main Method
public static void Main()
{
// Two-dimensional array
int[, ] intarray = new int[, ] { { 1, 2 },
{ 3, 4 },
{ 5, 6 },
{ 7, 8 } };
// The same array with dimensions
// specified 4 row and 2 column.
int[, ] intarray_d = new int[4, 2] { { 1, 2 }, { 3, 4 },
{ 5, 6 }, { 7, 8 } };
// A similar array with string elements.
string[, ] str = new string[4, 2] { { "one", "two" },
{ "three", "four" },
{ "five", "six" },
{ "seven", "eight" } };
// Three-dimensional array.
int[,, ] intarray3D = new int[,, ] { { { 1, 2, 3 },
{ 4, 5, 6 } },
{ { 7, 8, 9 },
{ 10, 11, 12 } } };
// The same array with dimensions
// specified 2, 2 and 3.
int[,, ] intarray3Dd = new int[2, 2, 3] { { { 1, 2, 3 },
{ 4, 5, 6 } },
{ { 7, 8, 9 },
{ 10, 11, 12 } } };
// Accessing array elements.
Console.WriteLine("2DArray[0][0] : " + intarray[0, 0]);
Console.WriteLine("2DArray[0][1] : " + intarray[0, 1]);
Console.WriteLine("2DArray[1][1] : " + intarray[1, 1]);
Console.WriteLine("2DArray[2][0] " + intarray[2, 0]);
Console.WriteLine("2DArray[1][1] (other) : "
+ intarray_d[1, 1]);
Console.WriteLine("2DArray[1][0] (other)"
+ intarray_d[1, 0]);
Console.WriteLine("3DArray[1][0][1] : "
+ intarray3D[1, 0, 1]);
Console.WriteLine("3DArray[1][1][2] : "
+ intarray3D[1, 1, 2]);
Console.WriteLine("3DArray[0][1][1] (other): "
+ intarray3Dd[0, 1, 1]);
Console.WriteLine("3DArray[1][0][2] (other): "
+ intarray3Dd[1, 0, 2]);
// using nested loop show string elements
Console.WriteLine("To String element");
for (int i = 0; i < 4; i++)
for (int j = 0; j < 2; j++)
Console.Write(str[i, j] + " ");
}
}
}
Producción :
2DArray[0][0] : 1 2DArray[0][1] : 2 2DArray[1][1] : 4 2DArray[2][0] 5 2DArray[1][1] (other) : 4 2DArray[1][0] (other)3 3DArray[1][0][1] : 8 3DArray[1][1][2] : 12 3DArray[0][1][1] (other): 5 3DArray[1][0][2] (other): 9 To String element one two three four five six seven eight
Arrays irregulares
Una array cuyos elementos son arrays se conoce como arrays irregulares, que significa » array de arrays «. Los elementos de array dentados pueden ser de diferentes dimensiones y tamaños. A continuación se muestran los ejemplos para mostrar cómo declarar, inicializar y acceder a las arrays irregulares.
Ejemplo :
// C# program to single-dimensional jagged array
// that contains two single-dimensional array
// elements of different sizes.
using System;
namespace geeksforgeeks {
class GFG {
// Main Method
public static void Main()
{
/*----------2D Array---------------*/
// Declare the array of two elements:
int[][] arr = new int[2][];
// Initialize the elements:
arr[0] = new int[5] { 1, 3, 5, 7, 9 };
arr[1] = new int[4] { 2, 4, 6, 8 };
// Another way of Declare and
// Initialize of elements
int[][] arr1 = { new int[] { 1, 3, 5, 7, 9 },
new int[] { 2, 4, 6, 8 } };
// Display the array elements:
for (int i = 0; i < arr.Length; i++)
{
System.Console.Write("Element [" + i + "] Array: ");
for (int j = 0; j < arr[i].Length; j++)
Console.Write(arr[i][j] + " ");
Console.WriteLine();
}
Console.WriteLine("Another Array");
// Display the another array elements:
for (int i = 0; i < arr1.Length; i++)
{
System.Console.Write("Element [" + i + "] Array: ");
for (int j = 0; j < arr1[i].Length; j++)
Console.Write(arr1[i][j] + " ");
Console.WriteLine();
}
}
}
}
Producción :
Element [0] Array: 1 3 5 7 9 Element [1] Array: 2 4 6 8 Another Array Element [0] Array: 1 3 5 7 9 Element [1] Array: 2 4 6 8
Es posible mezclar arrays irregulares y multidimensionales. La array irregular es una array de arrays y, por lo tanto, sus elementos son tipos de referencia y se inicializan en nulo.
Ejemplo: para declarar e inicializar una array irregular unidimensional que contiene tres elementos de array bidimensionales de diferentes tamaños.
// C# program to single-dimensional jagged array
// that contains three two-dimensional array
// elements of different sizes.
using System;
namespace geeksforgeeks {
class GFG {
// Main Method
public static void Main()
{
int[][, ] arr = new int[3][, ] {new int[, ] {{1, 3}, {5, 7}},
new int[, ] {{0, 2}, {4, 6}, {8, 10}},
new int[, ] {{11, 22}, {99, 88}, {0, 9}}};
// Display the array elements:
for (int i = 0; i < arr.Length; i++)
{
int x = 0;
for (int j = 0; j < arr[i].GetLength(x); j++)
{
for (int k = 0; k < arr[j].Rank; k++)
Console.Write(" arr[" + i + "][" + j + ", " + k + "]:"
+ arr[i][j, k] + " ");
Console.WriteLine();
}
x++;
Console.WriteLine();
}
}
}
}
Producción :
arr[0][0, 0]:1 arr[0][0, 1]:3 arr[0][1, 0]:5 arr[0][1, 1]:7 arr[1][0, 0]:0 arr[1][0, 1]:2 arr[1][1, 0]:4 arr[1][1, 1]:6 arr[1][2, 0]:8 arr[1][2, 1]:10 arr[2][0, 0]:11 arr[2][0, 1]:22 arr[2][1, 0]:99 arr[2][1, 1]:88 arr[2][2, 0]:0 arr[2][2, 1]:9
Puntos para recordar :
- GetLength(int): devuelve el número de elementos de la primera dimensión del Array.
- Cuando use arrays irregulares, asegúrese de que si el índice no existe, arrojará una excepción que es IndexOutOfRange.
Publicación traducida automáticamente
Artículo escrito por GeeksforGeeks-1 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA