Arrays y colecciones

Arrays
Introducción.
En C# un array es un dato de tipo referencia. Un array es una estructura de datos que
contiene variables (elementos) a los que se accede a través de ndices.
!odos los elementos de un array son del mismo tipo. "e dice entonces que ése es el
tipo
del array. As# se $abla por e%emplo# de un array de enteros o un array de strin&# etc#
dependiendo de que los elementos del array sean de un tipo o de otro.
Un array puede tener m's de una dimensión. (or cada dimensión de un array se
necesita
un nivel de ndices para acceder a sus elementos.
(ara declarar un array se especi)ca el tipo de dato de los elementos se&uido de
unos corc$etes vacos y del nombre del array que es una referencia al ob%eto
array. (or e%emplo*
int+, unArray-
.a lnea anterior declara unArray como una referencia a un array de enteros. /espués
de esta lnea unArray es una referencia que contiene null# ya que no referencia a
nin&0n array.
Como cualquier otro ob%eto# para crear un array de cualquier tipo se utili1a el operador
ne2# que devuelve un array del n0mero de elementos que se especi)que en el n0mero
entre corc$etes. As# para crear un array de strin& de 344 elementos# se escribe*
strin&+, un"trin&-
un"trin& 5 ne2 strin&+344,-
o bien# en una sola lnea*
strin&+, un"trin& 5 ne2 strin&+344,-
Aqu# se $a creado 6con ne27 un ob%eto que es un array de 344 strin&# se declara una
referencia al array 6un"trin&7# y se asi&na el ob%eto a la referencia.
En un array de 8 elementos el primero tiene ndice 4 y el 0ltimo 873. (ara acceder a un
elemento cualquiera# se utili1a el ndice. (or e%emplo# para almacenar el valor 39 en el
primer elemento de un array# se puede escribir*
::de)ne un array de enteros de 9; elementos
int+, unArray5ne2 int+9;,-
::almacena 39 en el primer elemento del array
unArray+4,539-
3:3<
=arco >esteiro y =i&uel ?odr&ue1 Arrays y Colecciones
.a sinta@is de la declaración e iniciali1ación de un array es bastante Ae@ible. "e puede#
como se $a $ec$o anteriormente# declarar un array sin iniciali1arlo# y posteriormente
iniciali1arlo.
(or e%emplo*
strin&+, unArray-
B
::Códi&o
B
unArray5ne2 strin&+;,-
unArray+4,5CEduardoC-
unArray+3,5C>or%aC-
unArray+9,5CDabrielC-
!ambién es posible declararlo e iniciali1arlo directamente# sin utili1ar el operador ne2*
strin&+, unArray5EFEduardoC#C>or%aC#CDabrielCG-
.o anterior es equivalente a *
strin&+, unArray5 ne2 strin&+,EFEduardoC#C>or%aC#CDabrielCG-
o bien
strin&+, unArray5 ne2 strin&+;,EFEduardoC#C>or%aC#CDabrielCG-
El n0mero de elementos que de)ne la lon&itud de un array debe ser constante. (or
eso#
no es posible iniciali1ar un array de esta manera*
int unEntero5;-
strin& +, unArray5 ne2 strin&+unEntero,EFEduardoC#C>or%aC#CDabrielCG-
(ara poder compilar# es necesario cambiar la primera de las dos lneas. "e $a de
sustituir
por la lnea*
const int unEntero5;-
.os arrays son ob%etos
En C## los arrays son ob%etos. Adem's# todos los arrays# de cualquier tipo derivan de la
clase "ystem.Array# que es el tipo base abstracto de todos los tipos de arrays.
.a clase "ystem.Array proporciona muc$os métodos y propiedades para manipular
arrays. "e pueden utili1ar las propiedades y otros miembros que tiene esta clase para
manipular los arrays. (or e%emplo# para obtener la lon&itud de un array se usa la
propiedad .en&t$. El códi&o si&uiente asi&na la lon&itud del array unArray# que es H# a
la variable lon&itud/elArray*
int+,unArray 5 E3# 9# ;# I# HG-
int lon&itud/elArray 5 unArray..en&t$-
9:3<
=arco >esteiro y =i&uel ?odr&ue1 Arrays y Colecciones
Es importante tener en cuenta que el tipo "ystem.Array no es un tipo array# sino un
tipo del cual derivan todos los tipos array.
.as propiedades y métodos m's importantes son las si&uientes*
8ota* En los e%emplos se utili1ar' el si&uiente array de enteros*
int +, unArray5ne2 int+,E9#H#;#IG-
7 .en&t$* devuelve el n0mero de elementos de un array. (or e%emplo*
int lon&itud5unArray..en&t$-
7 Det.en&t$* obtiene la lon&itud de una determinada dimensión cuando el array es
multidimensional. (or e%emplo# para obtener el n0mero de elementos de la primera
dimensión*
int lon&itud5otroArray.Det.en&t$(4)-
7 "ort y ?everse* Estos métodos permiten ordenar un array de modo ascendente o
descendente. "on métodos est'ticos. (or e%emplo*
Array."ort(unArray)-
o bien*
Array.?everse (unArray)-
En el si&uiente e%emplo# se de)ne un array de nombres y se ordenan*
::"e crea el array
strin&+, nombres5EFCristinaC#C=atildeC#C=J del KalleC#C=J !eresaCG-
::"e ordenan alfabéticamente dic$os nombres
Array."ort(nombres)-
::"e imprimen los nombres ordenados
for(int i54-iLnombres..en&t$-iMM)
Console.Nrite.ine(nombres+i,)-
.a salida de este pro&rama es*
Cristina
=atilde
=J del Kalle
=J !eresa
(or otro lado# aunque es una clase abstracta# el valor de una referencia de tipo
"ystem.Array en tiempo de e%ecución puede ser null o la referencia a una instancia de
un tipo array. "ystem.Array no tiene un alias.
Arrays de varias dimensiones.
C# soporta arrays simples 6de una dimensión7# multidimensionales y arrays de
arrays.
;:3<
=arco >esteiro y =i&uel ?odr&ue1
/eclaración de arrays
.a sinta@is para declarar un array es la si&uiente*
Array de una dimensión*
int+, unArray-
Arrays y Colecciones
Array multidimensional o matri1 rectan&ular*
strin&+#, array=ultidimensional-
int+##, botones
Array de arrays*
byte+,+, array/e>ytes-
Cuando se declara un array# sólo se de)ne una referencia que puede apuntar a un
array
de ese tipo# pero que apunta a null. En C# los arrays son ob%etos y para que e@istan
fsicamente# debe crearse un ob%eto 7deben ser instanciados7. .a sinta@is para crear un
array es*
o Array de una dimensión*
int+,unArray 5 ne2 int+H,-
Con esta sentencia# se crea una referencia a un array de enteros# se crea un array de H
enteros 6el ob%eto7 y posteriormente se asi&na la referencia anteriormente creada al
array.
o Array multidimensional*
strin&+#, una=atri1 5 ne2 strin&+H#I,-
int+##, otra=atri1 5 ne2 int+I#H#;,-
o Array de arrays*
byte+,+,array/e>ytes 5 ne2 byte+H,+,-
for (int @ 5 4- @ L array/e>ytes..en&t$- @MM)
E
array/e>ytes +@, 5 ne2 byte+I,-
G
"e pueden me1clar matrices rectan&ulares y arrays de arrays. (or
e%emplo*
int+,+##,+#, numeros-
Iniciali1ación de arrays
I:3<
=arco >esteiro y =i&uel ?odr&ue1 Arrays y Colecciones
C# proporciona una manera simple de declarar# crear e iniciali1ar un array
simult'neamente# incluyendo los valores iniciales entre llaves EG. "i no se $ace as# el
compilador lo iniciali1a autom'ticamente al valor por defecto.
A continuación se muestran distintos caminos para iniciali1ar diferentes tipos de
arrays.
o Array de una dimensión
int+, unArray 5 ne2 int+H, E3# 9# ;# I# HG-
strin&+, otroArray 5 ne2 strin&+;, EO(abloO# OArant1aO# O=arcoOG-
P (uede omitirse el tamaQo del array cuando se iniciali1a*
int+, unArray 5 ne2 int+, E3# 9# ;# I# HG-
strin&+, otroArray 5 ne2 strin&+, EO(abloO# OArant1aO# O=arcoOG-
P "e puede omitir ne2 si se iniciali1a*
int+, unArray 5 E3# 9# ;# I# HG-
strin&+, otroArray 5 EO(abloO# OArant1aO# O=arcoOG-
o Array multidimensional*
int+#, num 5 ne2 int+;# 9, E E3# 9G# E;# IG# EH# <G G-
strin&+#, par5ne2 strin&+9# 9,EEORuanO#OAnaOG# EOAlbertoO#O=ariaOG G-
P "e puede omitir el tamaQo*
int+#, num 5 ne2 int+#, E E3# 9G# E;# IG# EH# <G G-
strin&+#, par 5 ne2 strin&+#, E EORuanO#OAnaOG# EOAlbertoO#O=ariaOG G-
P !ambién la cl'usula ne2 si se iniciali1a*
int+#, num 5 E E3# 9G# E;# IG# EH# <G G-
strin&+#, par 5 E EORuanO#OAnaOG# EOAlbertoO#O=ariaOG G-
o Arrays de arrays
P "e puede iniciali1ar de la si&uiente forma*
int+,+, num 5 ne2 int+9,+, Ene2 int+, E9#;#IG#ne2 int+,EH#<#S#T#UG G-
P u omitir el tamaQo*
int+,+, nums 5 ne2 int+,+, Ene2 int+, E9#;#IG#ne2 int+, EH#<#S#T#UGG-
Acceso a los miembros de un array
"e accede a los elementos de un array de manera similar a como se $ace en C y CMM.
(or e%emplo# para acceder al quinto elemento del array y asi&narle 9S*
H:3<
=arco >esteiro y =i&uel ?odr&ue1
int+, unArray 5 E34# U# T# S# <# H# I# ;# 9# 3# 4G-
unArray+I, 5 9S-
Arrays y Colecciones
El si&uiente códi&o declara un array multidimensional y asi&na 9S al elemento
locali1ado en +3# 3,*
int+#, otroArray 5 E E3# 9G# E;# IG# EH# <G# ES# TG# EU# 34G G-
otroArray+3# 3, 5 9S-
Con los arrays de arrays el acceso es como si&ue*
int+,+, tercerArray 5 ne2 int+,+,
E
ne2 int+, E3# 9G#
ne2 int+, E;# IG
G-
tercerArray+3,+3, 5 H-
C# permite dos tipos de array multidimensionales* los arrays rectan&ulares y los
arrays
dentados.
Un array bidimensional rectan&ular es aquel en el cual todas sus )las tienen
el mismo n0mero de columnas. .os arrays que anteriormente se $an mostrado
como e%emplos# son rectan&ulares. En &eneral son sencillos de declarar#
iniciali1ar y mane%ar. A continuación se declara un array de strin&
bidimensional de cuatro )las y dos columnas*
strin& +#, mis8ombres5E EF>or%aC#CVosuneCG#
EFDabrielC#C(atriciaCG#
EF=arcoC#CArant@aCG#
EFEduardoC#.olaCG G-
.a otra alternativa de arrays multidimensionales es el array dentado# es decir# un array
que no es rectan&ular. Un array bidimensional dentado# es un array en el que cada )la
tinen un n0mero diferente de columnas. Aunque evidentemente proporciona una
mayor
Ae@ibilidad que el array rectan&ular# sin embar&o son m's complicados de declarar e
iniciali1ar. (ara crear un array dentado# b'sicamente lo que se $ace es crear un array
de
arrays*
(or e%emplo*
int+,+, a5ne2 int+;,+,-
a+4,5ne2 int+I,-
a+3,5ne2 int+;,-
a+9,5ne2 int+3,-
<:3<
=arco >esteiro y =i&uel ?odr&ue1 Arrays y Colecciones
En lu&ar de usar la coma en el corc$ete# lo que se $ace es usar un corc$ete e@tra# por
cada dimensión. (or e%emplo# para declarar un array dentado de tres dimensiones*
int +,+,+, unArray/eEnteros-
Un e%emplo completo puede aclarar esta idea*
strin& +,+,animales5ne2 strin& +;,+,-
animales+4,5ne2 strin&+,EF>allenaC#C!iburónC#C/elfnC#C(ulpoCG-
animales+3,5ne2 strin&+,EFDorriónC#C.oroC#C>uitreCG-
animales+9,5ne2 strin&+,EF(erroC#CDatoCG-
::"e imprime
for(int i54-iLanimales.Det.en&t$(4)-iMM)
for(int %54 - %L animales+i,..en&t$ - %MM)
Console.Nrite.ine(animales +i,+%,)-
E%emplo*
:: arrays.cs
usin& "ystem-
class E%emplo/e/eclaracion/eArrays
E
public static void =ain()
E
::array de una dimensión
int+, unArray 5 ne2 int+H,-
Console.Nrite.ine(O.a lon&itud de unArray es E4GO#
unArray..en&t$)-
::array =ultidimensional
strin&+#, otroArray 5 ne2 strin&+H#I,-
Console.Nrite.ine(O.a lon&itud de otroArray es E4GO#
otroArray..en&t$)-
:: Array de arrays
byte+,+, array/eArrays 5 ne2 byte+H,+,-
Console.Nrite.ine(O.a lon&itud de array/eArrays es E4GO#
array/eArrays..en&t$)-
:: crea un array de arrays
for (int i 5 4- i L array/eArrays..en&t$- iMM)
E
array/eArrays+i, 5 ne2 byte+iM;,-
G
for (int i 5 4- i L array/eArrays..en&t$- iMM)
E
Console.Nrite.ine(O.a lon&itud de E4G es E3GO# i#
array/eArrays+i,..en&t$)-
G
G
G
.a salida que se obtiene al e%ecutar este pro&rama es*
S:3<
=arco >esteiro y =i&uel ?odr&ue1
.a
.a
.a
.a
.a
.a
.a
.a
lon&itud
lon&itud
lon&itud
lon&itud
lon&itud
lon&itud
lon&itud
lon&itud
de
de
de
de
de
de
de
de
unArray es H
otroArray es 94
array/eArrays es H
4 es ;
3 es I
9 es H
; es <
I es S
Arrays y Colecciones
Usando foreac$ en Arrays
"e puede f'cilmente recorrer un array con la sentencia foreac$. Esta sentencia
proporciona una manera ele&ante y sencilla de FrecorrerC los distintos elementos de un
array. "e utili1a para recorrer m's f'cilmente la colección o el array pero no debera
utili1arse para cambiar los contenidos de la colección o array porque puede tener
efectos
colaterales no deseados. (or e%emplo# el si&uiente códi&o crea un array llamado
unArray *
usin& "ystem-
class ?ecorriendoArrays
E
public static void =ain()
E
int+, unArray 5 EI# H# <# 73# 4G-
foreac$ (int i in unArray)
E
"ystem.Console.Nrite.ine(i)-
G
G
G
.a salida de este códi&o es*
I
H
<
73
4
El si&uiente pro&rama recorre un array y describe cada uno de sus elementos como
par o
impar.
usin& "ystem-
class ?ecorriendoArrays
E
public static void =ain()
E
int+, unArray 5 EI# H# <# 73# 9SG-
int par54-
int impar54-
strin& dos5OparO-
strin& uno5OimparO-
foreac$(int i in unArray)
E
T:3<
=arco >esteiro y =i&uel ?odr&ue1 Arrays y Colecciones
Console.Nrite.ine(i)-
if(iW9554)
E
parMM-
Console.Nrite.ine(OEl elemento E4G es E3GO#i#dos)-
G
else
E
imparMM-
Console.Nrite.ine(OEl elemento E4G es E3GO#i#uno)-
G
G
Console.Nrite.ine(OXay E4G pares y E3G imparesO #par# impar)-
G
G
G
.a salida de este pro&rama es*
I
El elemento I es par
H
El elemento H es impar
<
El elemento < es par
73
El elemento 73 es impar
9S
El elemento 9S es impar
Xay dos pares y ; impares
Colecciones
Introducción
Anteriormente se $a estudiado cómo utili1ar los arrays para referenciar un
con%unto de ob%etos o de variables. Es evidente# sin embar&o que los arrays tienen
al&unas limitaciones. .a mayor de ella es que una ve1 que el pro&ramador $a creado
el
array# su tamaQo no se puede cambiar porque es )%o# constante. El problema se
presenta
cuando se pretende aQadir nuevos elementos al array# sin crear uno nuevo.
En &eneral# se puede decir que una colección se utili1a para traba%ar con listas o
con%untos ordenados de ob%etos y proporciona una funcionalidad mayor que la de un
simple array. Esta funcionalidad proviene de la implementación de una serie de
interfaces del namespace "ystem.Collections. Este namespace también contiene
clases que implementan estos interfaces y facilitan enormemente la tarea del
pro&ramador.
.as colecciones proporcionan métodos b'sicos para acceder a los elementos de
la colección utili1ando corc$etes# de manera idéntica a como se accede a los
elementos
de un array.
U:3<
=arco >esteiro y =i&uel ?odr&ue1 Arrays y Colecciones
C# proporciona una serie de clases e interfaces que est'n contenidas en el
namespace "ystem.Collections# que nos permite traba%ar con%untos de datos o
colecciones# de manera muy sencilla.
.os interfaces que proporcionan
si&uientes*
funcionalidad a las colecciones# son los
P IEnumerable* (roporciona la capacidad para FrecorrerC una colección a través de sus
elementos# por medio de una sentencia foreac$.
P ICollection* Xereda de IEnumerable. (roporciona la capacidad para obtener el
n0mero de elementos de la colección y de copiar elementos a un simple array.
o I.ist* Xereda de IEnumerable y de ICollection. (roporciona una lista de los
elementos de la colección con las capacidades de los interfaces anteriormente citados
y
al&unas otras capacidades b'sicas.
P I/ictionary* Xereda de IEnumerable y de ICollection. (roporciona una lista de
elementos de la colección accesibles a través de un valor en lu&ar de un ndice.
.os arrays# en C# son ob%etos de la clase "ystem.Array que es un tipo de colección. .a
clase "ystem.Array $ereda de I.ist# ICollection e IEnumerable pero no
proporciona al&unas funcionalidades avan1adas de I.ist. ?epresenta una lista de
elementos con un tamaQo )%o. El pro&ramador puede también crear sus propias
colecciones espec)cas.
.a clase Array.ist
Una de las clases m's importantes que proporciona el namespace
"ystems.Collections se denomina "ystem.Collections.Array.ist# que implementa
las interfaces I.ist# ICollection e IEnumerable.
Este tipo puede utili1arse para representar una lista de elementos con un tamaQo
variable# es decir es un array cuyo tamaQo puede cambiar din'micamente cuando sea
necesario. (roporciona un determinado n0mero de métodos y propiedades para
manipular sus elementos.
Al&unos de los m's importantes son los si&uientes*
Adapter( )
Capacity
Count
Item( )
Add( )
Add?au&e ( )
=étodo est'tico que crea un Array.ist para un ob%eto que
implementa I.ist.
/etermina o lee el n0mero de elementos del Array.ist.
El n0mero actual de elementos del Array.ist.
Ybtiene o )%a el elemento correspondiente a su ndice
determinado.
AQade elementos al Array.ist.
(ermite aQadir los elementos de una ICollection al )nal
del Array.ist.
34:3<
=arco >esteiro y =i&uel ?odr&ue1
Clear ( )
Contains ( )
Inde@ Yf ( )
Insert ( )
Insert?an&e( )
?emove
?emoveAt
"ort( )
!oArray( )
Arrays y Colecciones
Elimina todos los elementos del Array.ist.
/etermina si un elemento est' en la Array.ist.
/evuelve el ndice de un determinado elemento.
Inserta un elemento en un Array.ist.
Inserta elementos de una colección en un Array.ist.
Elimina un determinado elemento.
Elimina un determinado elemento accediendo a él a través de
su ndice.
Yrdena un Array.ist.
Copia los elementos del Array.ist a un array.
El si&uiente e%emplo ilustra bien la diferencia entre un Array y un Array.ist puede
ser*
Considere la clase Animal almacenada en el )c$ero Animal.cs con el si&uiente códi&o*
usin& "ystem-
namespace ConsoleApplication9
E
publicclass Animal
E
protected strin& nombre-
public Animal(strin& un8ombre)
E
nombre5un8ombre-
G
public strin& 8ombre
E
&et
E
return nombre-
G
set
E
nombre5value-
G
G
public void Comer()
E
Console.Nrite.ine(O el animal E4G $a comidoO#nombre)-
G
G
G
A continuación# modi)que el códi&o en el método =ain() por el si&uiente*
usin& "ystem-
namespace ConsoleApplication9
E
class =iAplicacion
E
static void =ain(strin&+, ar&s)
E
Console.Nrite.ine(OZZZZE%emplo de ArrayZZZZO)-
::"e de)ne un array de dos elementos de la clase Animal
Animal+, arrayAnimal 5 ne2 Animal+9,-
33:3<
=arco >esteiro y =i&uel ?odr&ue1 Arrays y Colecciones
Animal &ato5ne2 Animal (O=imosoO)-
arrayAnimal+4,5&ato-
arrayAnimal+3,5ne2 Animal(OAndra%osoO)-
:: se recorre el array por medio de la sentencia foreac$
Console.Nrite.ine(O[n?ecorremos el array con
foreac$O)-
foreac$(Animal an in arrayAnimal)
Console.Nrite.ine(an.8ombre)-
:: se recorre el array por medio de la sentencia for
Console.Nrite.ine(O[n?ecorremos el array con una
sentencia forO)-
for (int i54-iLarrayAnimal..en&t$-iMM)
Console.Nrite.ine(arrayAnimal+i,.8ombre)-
Console.Nrite.ine(OEln0mero
E4GO#arrayAnimal..en&t$)-
G
G
G
de elementos del array es
.a salida de este pro&rama es*
\i&ura S.3
En este e%emplo se observa bien la diferencia que e@iste cuando se accede a los
elementos del array por medio de las sentencias for o foreac$
En el si&uiente e%emplo# se pretende traba%ar de forma parecida con una colección de
tipo Array.ist. (ara ello# adem's de aQadir la directiva*
usin& "ystem.Collections-
aQada el si&uiente códi&o al )nal del método =ain()*
Console.Nrite.ine(O[nZZZE%emplo de Array.istZZZZZO)-
Array.ist listaArrayAnimales 5 ne2 Array.ist()-
listaArrayAnimales.Add(ne2 Animal(O(ericoO))-
listaArrayAnimales.Add(ne2 Animal(OAnquilosadoO))-
Animal pantera5ne2 Animal(O=ou&liO)-
listaArrayAnimales.Add (pantera)-
39:3<
=arco >esteiro y =i&uel ?odr&ue1 Arrays y Colecciones
Console.Nrite.ine(OElarraylilsttienea$oraE4GelementosO#
listaArrayAnimales.Count)-
::(uede utili1arse unArray.ist como un Array
::.oselementosdeunArray.istsonob%etos#yesnecesario
::convertirlos a ob%etos de la clase Animal al utili1arlo como array
Console.Nrite.ine(O[n?ecorremos la coleccion con una sentencia forO)-
for(int i54-iLlistaArrayAnimales.Count-iMM)
Console.Nrite.ine(O8ombre*E4GO#
((Animal)listaArrayAnimales+i,).8ombre)-
Console.Nrite.ine(O[n?ecorremos la coleccion con una sentencia
foreac$O)-
::Aqu no es necesaria la conversión
foreac$(Animal an in listaArrayAnimales)
Console.Nrite.ine(an.8ombre)-
::Un Array.ist puede cambiar de tamaQo
Console.Nrite.ine(O[nZZZZZE%emplodecambiodetamaQoenel
Array.istZZZO)-
Console.Nrite.ine(OAQadimos a$ora array creado al comien1oO)-
listaArrayAnimales.Add?an&e(arrayAnimal)-
Console.Nrite.ine(OElarraylilsttienea$oraE4GelementosO#
listaArrayAnimales.Count)-
Console.Nrite.ine(O[n?ecorremos el array con una sentencia forO)-
for(int i54-iLlistaArrayAnimales.Count-iMM)
Console.Nrite.ine(O8ombre* E4G O#
((Animal)listaArrayAnimales+i,).8ombre)-
Console.Nrite.ine(O[n?ecorremos el array con una sentencia foreac$O)-
foreac$(Animal an in listaArrayAnimales)
Console.Nrite.ine(an.8ombre)-
.a salida de este pro&rama es*
3;:3<
=arco >esteiro y =i&uel ?odr&ue1 Arrays y Colecciones
\i&ura S.9
En el anterior e%emplo se $an creado dos colecciones de ob%etos* el primero utili1a la
clase "ystem.Array 6que de $ec$o es una colección7# y el se&undo utili1a la clase
"ystem.Collections.Array.ist. Ambas colecciones tienen ob%etos de la clase
Animal que est' de)nida en el )c$ero Animal.cs. ?especto a la manipulación del
array# probablemente el lector encontrar' pocas di)cultades para su comprensión. "in
embar&o# es importante seQalar aqu que cuando se crea un array se especi)ca un
tamaQo# que ser' )%o y constante a lo lar&o del pro&rama*
Animal+, arrayAnimal 5 ne2 Animal+9,-
Cuando se crea un ob%eto de la clase Array.ist# no se de)ne nin&0n tamaQo. (ara crear
la colección# simplemente se utili1a el códi&o si&uiente*
Array.ist listaArrayAnimales 5 ne2 Array.ist()-
E@isten otros dos constructores de esta clase. El primero de ellos# utili1a como
par'metro una colección y el otro# especi)ca la capacidad 6la propiedad capacity7 o
n0mero de elementos inicial de la colección y se pasa como par'metro entero.
Inicialmente# la colección Array.ist no tiene nin&0n elemento. 8o se puede aQadir
ob%etos a través del ndice# como en los arrays. (ara ello# se utili1a el método Add()
como se ve en el e%emplo*
3I:3<
=arco >esteiro y =i&uel ?odr&ue1
listaArrayAnimales.Add(ne2 Animal(O(ericoO))-
listaArrayAnimales.Add(ne2 Animal(OAnquilosadoO))-
Animal pantera5ne2 Animal(O=ou&liO)-
listaArrayAnimales.Add (pantera)-
Arrays y Colecciones
Una ve1 que se $a aQadido un elemento# se puede modi)car como si fuera un array#
aunque no se $a $ec$o anteriormente. (or e%emplo*
listaArrayAnimales+4,5ne2 Animal(O(epeO)-
"e puede recorrer# por medio de una sentencia foreac$# tanto un array como un
Array.ist porque ambos implementan la interface IEnumerable*
foreac$(Animal an in arrayAnimal)
Console.Nrite.ine(an.8ombre)-
foreac$(Animal an in listaArrayAnimales)
Console.Nrite.ine(an.8ombre)-
"e puede acceder al n0mero de elemento o tamaQo de un array por medio de la
propiedad .en&t$*
Console.Nrite.ine(OEl n0merodeelementosdel
arrayAnimal..en&t$)-
array es E4GO#
V al tamaQo de una colección Array.ist por medio de la propiedad Count# &racias a
que esta clase implementa la interface ICollection*
Console.Nrite.ine(OEl arraylisttienea$ora
listaArrayAnimales.Count)-
E4G elementosO#
.a diferencia m's importante es que un array est' fuertemente tipado# y permite
acceder
a sus elementos directamente*
Console.Nrite.ine(arrayAnimal+i,.8ombre)-
Cuando se accede a los elementos por medio del ndice debe reali1arse una conversión
de tipos*
Console.Nrite.ine(O8ombre*E4G
((Animal)listaArrayAnimales+i,).8ombre)-
O#
\inalmente# pueden eliminarse ob%etos de una colección por medio de los
métodos
?emove(ob%ect unYb%eto) o ?emoveAt(int indice).
(or e%emplo# si se pretende eliminar el elemento &ato y el primer elemento de la
colección# $an de aQadirse estas lneas al )nal del códi&o del método =ain()*
listaArrayAnimales.?emove(&ato)-
listaArrayAnimales.?emoveAt(4)-
Console.Nrite.ine(OElarraylisttienea$ora
listaArrayAnimales.Count)-
E4G elementosO#
3H:3<
=arco >esteiro y =i&uel ?odr&ue1 Arrays y Colecciones
Adem's puede obtenerse el ndice de un determinado elemento por medio del método
Inde@Yf()# por e%emplo*
Console.Nrite.ine(listaArrayAnimales.Inde@Yf(&ato))-
"i no e@iste el elemento en la colección# este método devuelve 63.
Adem's# puede aQadirse una colección a un ob%eto de la clase Array.ist# por medio
del método Add?an&e()# al que se le pasa la colección como par'metro. /ic$a
colección puede ser también un array# que es una colección también. (or e%emplo# en
la
si&uiente lnea se aQade el array arrayAnimal al Array.ist*
listaArrayAnimales.Add?an&e(arrayAnimal)-
.as colecciones son imprescindibles para traba%ar con al&unos controles como .ist>o@#
Combo>o@# etc# y su conocimiento reduce enormemente el esfuer1o de la pro&ramación
de este tipo de controles.
3<:3<