Curso de ASP.NET

La única forma de tener copias independientes de dos arrays que contengan los mismos elementos es haciendo una copia de un array a otro. Esto lo podemos hacer mediante el método CopyTo, al cual habrá que indicarle el array de destino y el índice de inicio a partir del cual se hará la copia. Sólo aclarar que el destino debe tener espacio suficiente para recibir los elementos indicados, por tanto deberá estar inicializado con los índices necesarios. Aclaremos todo esto con un ejemplo:

Dim a() As Integer = {1, 42, 15, 90, 2}
Dim b(a.Length - 1) As Integer
'
a.CopyTo(b, 0)
'
a(3) = 55
'
Dim i As Integer
For i = 0 To a.Length - 1
    Response.Write("a(i) = " & a(i) & ", b(i)= " & b(i))
Next

En este ejemplo, inicializamos un array, declaramos otro con el mismo número de elementos, utilizamos el método CopyTo del array con los valores, en el parámetro le decimos qué array será el que recibirá una copia de esos datos y la posición (o índice) a partir de la que se copiarán los datos, (indicando cero se copiarán todos los elementos); después cambiamos el contenido de uno de los elementos del array original y al mostrar el contenido de ambos arrays, comprobamos que cada uno es independiente del otro.

Para manejarnos con las matrices tenemos de momento dos instrucciones muy interesantes:

• Ubound. Devuelve el mayor subíndice disponible para la dimensión indicada de una matriz
• Lbound. Devuelve el menor subíndice disponible para la dimensión indicada de una matriz

Es decir me dice cuantos elementos puede contener la matriz porque me dice el índice mayor disponible. Luego Ubound (mimatriz) me devolverá 7 por ejemplo si es ese su número de elementos. Mira este ejemplo de Ubound para una matriz de dos dimensiones:

	Dim A(100, 5, 4) As Byte

Llamada a UBound	Valor devuelto
UBound(A, 1)	100
UBound(A, 2)	5
UBound(A, 3)	4

La diferencia entre los arrays unidimensionales y los arrays multidimensionales es precisamente eso, que los arrays unidimensionales, (o normales, por llamarlos de alguna forma), sólo tienen una dimensión: los elementos se referencian por medio de un solo índice. A menudo a los arrays de una sola dimensión se les llama vectores. Por otro lado, los arrays multidimensionales tienen más de una dimensión. Para acceder a uno de los valores que contengan habrá que usar más de un índice. La forma de acceder, por ejemplo en el caso de que sea de dos dimensiones, sería algo como esto: multiDimensional(x, y).

Es decir, usaremos una coma para separar cada una de las dimensiones que tenga. El número máximo de dimensiones que podemos tener es de 32, aunque no es recomendable usar tantas, (según la documentación de Visual Studio .NET no deberían usarse más de tres o al menos no debería ser el caso habitual), en caso de que pensemos que debe ser así, (que tengamos que usar más de tres), deberíamos plantearnos usar otro tipo de datos en lugar de una matriz. Entre otras cosas, porque el Visual Basic reservará espacio de memoria para cada uno de los elementos que reservemos al dimensionar un array, con lo cual, algo que puede parecernos pequeño no lo será tanto.

Hay que tener en cuenta que cuando usamos arrays de más de una dimensión cada dimensión declarada más a la izquierda tendrá los elementos de cada una de las dimensiones declaradas a su derecha. De esto te enterarás mejor en cuanto te explique cómo crear los arrays multidimensionales...

Para declarar un array multidimensional, lo podemos hacer, (al igual que con las unidimensionales), de varias formas, dependiendo de que simplemente declaremos el array, que le indiquemos (o reservemos) el número de elementos que tendrá o de que le asignemos los valores al mismo tiempo que la declaramos, veamos ejemplos de estos tres casos:

'Una dimensión sin indicar número de elementos
Dim a1() As Integer
'Dos dimensiones sin indicar número de elementos
Dim a2(,) As Integer
'Tres dimensiones sin indicar número de elementos
Dim a3(,,) As Integer

'Una dimensión indicando número de elementos
Dim b1(2) As Integer
'Dos dimensiones indicando número de elementos
Dim b2(1, 6) As Integer
'Cuatro dimensiones indicando número de elementos
Dim b3(3, 1, 5, 2) As Integer

'Una dimensión, sin indicar cuantos elementos y declarando
Dim c1() As Integer = {1, 2, 3, 4}
'Dos dimensiones, sin indicar cuantos elementos y declarando
Dim c2(,) As Integer = {{1, 2, 3}, {4, 5, 6}}
'Tres dimensiones, sin indicar cuantos elementos y declarando
Dim c3(,,) As Integer = { _
                         {{1, 2}, {3, 4}, {5, 6}}, _
                         {{7, 8}, {9, 10}, {11, 12}}, _
                         {{13, 14}, {15, 16}, {17, 18}}, _
                         {{19, 20}, {21, 22}, {23, 24}} _
                        }

En estos ejemplos he usado arrays con una, dos, tres y cuatro dimensiones.

En el último caso, he usado el continuador de líneas para que sea más fácil leer la asignación  de cada una de las dimensiones... imagínate que en lugar de tres dimensiones hubiese usado más... sería prácticamente imposible saber cuantos elementos tiene cada una de las dimensiones.

En la entrega anterior utilizamos la propiedad Length para averiguar el tamaño de un array de una sola dimensión, en el caso de los arrays de varias dimensiones, se puede seguir usando Length para saber el número total de elementos que contiene, (será la suma de todos los elementos en su totalidad), ya que Length representa la longitud o tamaño, pero para saber cuantos elementos hay en cada una de las dimensiones tendremos que usar otra de las propiedades que exponen los arrays: GetUpperBound(dimensión).

Esta propiedad se usará indicando como parámetro la dimensión de la que queremos averiguar el índice superior.

Por ejemplo, en el caso del array c3, podemos usar c3.GetUpperBound(2) para saber cuantos elementos hay en la tercera dimensión.

Veamos cómo haríamos para averiguar cuantos elementos tiene cada una de las tres dimensiones del array c3:

Response.Write("Las dimensiones de c3 son: " & c3.GetUpperBound(0) 
	& " - " & c3.GetUpperBound(1) & " - " & c3.GetUpperBound(2))

Una cosa es saber cuantos elementos tiene un array (o una de las dimensiones del array) y otra cosa es saber cuantas dimensiones tiene dicho array.

Para saber el número de dimensiones del array, usaremos la propiedad Rank. Por ejemplo, (si usamos la declaración hecha anteriormente), el siguiente código nos indicará que el array c3 tiene tres dimensiones:

Response.Write("El array c3 tiene " & c3.Rank & "dimensiones.")

Como siempre, el valor devuelto por Rank será el número total de dimensiones del array, pero ese número de dimensiones será desde cero hasta Rank - 1.

Veamos ahora un ejemplo de cómo recorrer todos los elementos del array c3, los cuales se mostrarán en la consola. Para saber cuantos elementos hay en cada una de las dimensiones, utilizaremos la propiedad GetUpperBound para indicar hasta qué valor debe contar el bucle For, el valor o índice menor sabemos que siempre será cero, aunque se podría usar la propiedad GetLowerBound.

Dejemos esto de momento y veamos el ejemplo:

Dim i, j, k As Integer

For i = 0 To c3.GetUpperBound(0)
    For j = 0 To c3.GetUpperBound(1)
        For k = 0 To c3.GetUpperBound(2)
            Response.Write("El valor de c3(" i & "," & j & "," & k & ") es:" & c3(i, j, k))
        Next
    Next
Next

Para poder cambiar el tamaño de un array manteniendo sus datos debemos usar ReDim seguida de la palabra clave Preserve, por tanto si tenemos la siguiente declaración:

Dim a() As Integer = {1, 2, 3, 4, 5}

Y queremos que en lugar de 5 elementos (de 0 a 4) tenga, por ejemplo 10 y no perder los otros valores, usaremos la siguiente instrucción:

ReDim Preserve a(10)

A partir de ese momento, el array tendrá 11 elementos (de 0 a 10), los 5 primeros con los valores que antes tenía y los nuevos elementos tendrán un valor cero, que es el valor por defecto de los valores numéricos.

Si sólo usamos ReDim a(10), también tendremos once elementos en el array, pero todos tendrán un valor cero, es decir, si no se usa Preserve, se pierden los valores contenidos en el array.

Acabamos de ver que usando ReDim podemos cambiar el número de elementos de un array, e incluso que usando ReDim Preserve podemos cambiar el número de elementos y mantener los que hubiese anteriormente en el array. Con los arrays multidimensionales también podemos usar esas instrucciones con el mismo propósito que en los arrays unidimensionales.

El único problema con el que nos podemos encontrar, al menos si queremos usar Preserve para conservar los valores previos, es que sólo podemos cambiar el número de elementos de la última dimensión del array. Si has usado el VB6 esto es algo que te sonará, ya que con el VB clásico tenemos el mismo inconveniente, pero a diferencia de aquél, con ReDim podemos cambiar el número del resto de las dimensiones, al menos la cantidad de elementos de cada dimensión, ya que si un array es de 3 dimensiones siempre será de tres dimensiones.

Con esto último hay que tener cuidado, ya que si bien será el propio IDE el que nos avise de que no podemos cambiar "la cantidad" de dimensiones de un array, es decir, si tiene tres dimensiones, siempre debería tener tres dimensiones, por ejemplo, siguiendo con el ejemplo del array c3, si hacemos esto:

ReDim c3(1, 4)

Será el IDE de Visual Studio .NET el que nos avise indicando con un subrayado que hay algo que no está bien.

Pero si cambiamos el número de elementos de las dimensiones (usando Preserve), hasta que no estemos en tiempo de ejecución, es decir, cuando el programa llegue a la línea que cambia el número de elementos de cada dimensión, no se nos avisará de que no podemos hacerlo.

Veamos qué podemos hacer sin problemas y que daría error. Si tenemos c3 dimensionada con tres dimensiones, al estilo de Dim c3(3, 2, 1):

ReDim c3(3, 2) 'dará error en tiempo de diseño.
ReDim c3(2, 3, 4) 'funcionará bien.
ReDim Preserve c3(3, 3, 1) 'en tiempo de ejecución nos dirá que no se puede.
ReDim Preserve c3(3, 2, 4) 'será correcto y los nuevos elementos tendrán el valor por defecto.
ReDim Preserve c3(3, 2, 0) 'será correcto, hemos reducido el número de elementos de la última dimensión.

Resumiendo, podemos usar ReDim para cambiar el número de elementos de cada una de las dimensiones, pero no podemos cambiar el número de dimensiones.

Podemos usar ReDim Preserve para cambiar el número de elementos de la última dimensión sin perder los valores que previamente hubiera. En ningún caso podemos cambiar el número de dimensiones de un array.

Si en algún momento del programa queremos eliminar el contenido de un array, por ejemplo para que no siga ocupando memoria, ya que es posible que no siga ocupando memoria, podemos usar Erase seguida del array que queremos "limpiar", por ejemplo:

Erase a

Esto eliminará el contenido del array a.

Si después de eliminar el contenido de un array queremos volver a usarlo, tendremos que ReDimensionarlo con el mismo número de dimensiones que tenía, ya que Erase sólo borra el contenido, no la definición del array.

Pues la respuesta es: No.

El método Sort sólo permite clasificar un array unidimensional, (de una sola dimensión). La única forma de clasificar un array multidimensional sería haciéndolo de forma manual.

De igual forma que no podemos clasificar un array multidimensional, al menos de forma "automática", tampoco podemos usar el resto de métodos de la clase Array que se suelen usar con arrays unidimensionales, como puede ser Reverse.

Para copiar el contenido de un array, sea o no multidimensional, podemos usar el método Copy de la clase Array.

Seguramente te preguntarás si se puede usar CopyTo, que es la forma que vimos antes para copiar el contenido de un array, la respuesta es NO, simplemente porque CopyTo sólo se puede usar con arrays unidimensionales.

Para usar el método Copy de la clase Array, debemos indicar el array de origen, el de destino y el número de elementos a copiar. Siguiendo con el ejemplo del array c3, podríamos copiar el contenido en otro array de la siguiente forma:

Dim c31(,,) As Integer
'
ReDim c31(c3.GetUpperBound(0), c3.GetUpperBound(1), c3.GetUpperBound(2))
Array.Copy(c3, c31, c3.Length)

Fíjate que no se indica qué dimensión queremos copiar, ya que se copia "todo" el contenido del array, además de que el array de destino debe tener como mínimo el mismo número de elementos.

Otra condición para poder usar Copy es que los dos arrays deben tener el mismo número de dimensiones, es decir, si el array origen tiene 3 dimensiones, el de destino también debe tener el mismo número de dimensiones. Si bien, el número de dimensiones debe ser el mismo en los dos arrays, el número de elementos de cada una de las dimensiones no tiene porqué serlo. Sea como fuere, el número máximo de elementos a copiar tendrá que ser el del array que menos elementos tenga... sino, tendremos una excepción en tiempo de ejecución.

Para entenderlo mejor, veamos varios casos que se podrían dar. Usaremos el contenido del array c3 que, como sabemos, está definido de esta forma: c3(3, 2, 1) y como destino un array llamado c31. Para copiar los elementos haremos algo así:

Array.Copy(c3, c31, c3.Length)

Ahora veamos ejemplos de cómo estaría dimensionado el array de destino y si son o no correctos:

• Dim c31(3, 2, 1), correcto ya que tiene el mismo número de dimensiones y elementos.
• Dim c31(3, 3, 2), correcto porque tiene el mismo número de dimensiones y más elementos.
• Dim c31(2, 1, 0), correcto, tiene el mismo número de dimensiones aunque tiene menos elementos, por tanto la cantidad de elementos a copiar debe ser el del array de destino: Array.Copy(c3, c31, c31.Length).
• Dim c31(3, 2), no es correcto porque tiene un número diferente de dimensiones.

Y con esto finalizamos una buena introducción a las matrices, seguramente no necesitemos saber mas que todo esto en mucho tiempo, así que tómalo como referencia.