PODEMOS USAR CUALQUIER TIPO COMO TIPO BASE PARA UNA SERIE. Puede ser una serie de ints, una serie de Strings, o una serie de Objects…Y dado que las series, en Java, son también un tipo, puede ser también una serie de series. Por ejemplo, una serie de ints decimos que tiene como tipo  int[]. Esto significa que automáticamente hay otro tipo, int[][], que representa una «serie de serie de ints». Una serie así, se dice que tiene dos dimensiones. (Naturalmente, una vez conseguido el tipo int[][], no hay nada que le impida el formar el tipo int[][][], que representa una serie de tres dimensiones, y así sucesivamente. Sin embargo, en estas notas no quiero aventurarme mas allá de la segunda dimensión).

La instrucción «int[][] A = new int[3][4]» declara una variable , A de tipo int[][],e inicializa la variable creando un nuevo objeto. Este objeto es una serie de serie de ints. La notación  int[3][4] indica que en A, hay tres series de ints, y en cada una de estas series hay 4 ints. Sin embargo, el imaginarse esos temas puede ser un poco confuso, puede que ya se haya dado cuenta. Es por esos que se acostumbra a pensar en una serie de dos dimensiones como en una matriz de elementos. La notación int[3][4] puede servir para describir una rejilla o matriz de 3 filas y cuatro columnas. La siguiente imagen, puede que le ayude

fig5

Para la mayor parte de casos, puede ignorar la realidad y mantener en la mente la imagen de la rejilla. Sin embargo, algunas veces, necesitara recordar que cada fila de la rejilla es, en si misma, una serie. Estas filas se pueden referenciar como A[0], A[1], y A[2].Cada fila es en realidad una serie de tipo int [].Puede , por ejemplo, pasarlo a una subrutina que espere parámetros de tipo int [].

Puede escoger un ítem concreto de una fila colocando otro índice. Por ejemplo, A[1][3] se refiere al elemento 3 en la fila 1.  Naturalmente que no debe olvidar que , tanto filas como columnas, se numeran empezando por cero por lo que en el ejemplo anterior, A[1][3] es 5. De forma mas general,  A[i][j] se refiere al int en la fila numero i y la columna numero j. Los 12 elementos de A tienen los siguientes nombres :

      A[0][0]    A[0][1]     A[0][2]     A[0][3]
      A[1][0]    A[1][1]     A[1][2]     A[1][3]
      A[2][0]    A[2][1]     A[2][2]     A[2][3]

Puede ser interesante destacar que A.length nos da el numero de filas de A. Para obtener el numero de columnas de A deberemos preguntar cuantos ints hay en cada fila, este numero nos vendrá definido por A[0].length, o sus equivalentes A[1].length o A[2].length.(Realmente no hay ninguna regla que nos diga que todas las filas de una serie han de tener la misma longitud, y en algunas aplicaciones avanzadas sobre series, utilizaremos filas de distinto tamaño. Pero si usa el operador new para crear la serie, tal y como hemos comentado antes, obtendrá una serie en la que todas las filas serán iguales.)


Es posible el rellenar una serie de dos dimensiones especificando los elementos en el momento de crearla. Recuerde que cuando declarábamos una serie unidimensional podíamos asignar un «inicializador de series», que era concretamente una lista de valores encerrados entre llaves { y }. De forma similar, una serie de dos dimensiones puede crearse con una lista de «inicializadores de series», para cada una de las filas de la serie. Por ejemplo, la serie A presentada en la imagen anterior pudo ser creada como:

        int[][]  A  =  {  {  1,  0, 12, -1 },
                          {  7, -3,  2,  5 },
                          { -5, -2,  2,  9 }
                       };

Si en una serie no se facilita inicializador cuando se crea, se rellenara automáticamente con el valor apropiado: cero para numéricas, false para boleanas, y null para objetos.


Las series de dos dimensiones pueden emplearse en cualquier momento en que los datos que se tengan que manejar puedan ser organizados de forma natural, en filas y columnas. A menudo, la rejilla se genera con el problema. Por ejemplo, un juego de ajedrez es una rejilla de 8 filas por 8 columnas. Si existe una clase ChessPiece que pueda representar una pieza del ajedrez, el contenido del tablero de ajedrez puede ser representado como una serie de dos dimensiones

        ChessPiece[][]  tablero  =  new ChessPiece[8][8];

O considerando el «mosaico» de cuadrados coloreados empleado en el ejemplo de la Sección 3.6. Los datos sobre los colores de cada cuadrado del mosaico se almacenan en una serie de tipo Color[][].  Si el mosaico tiene ROWS filas y COLUMNS columnas, entonces la serie de datos de color se puede crear con la instrucción

        Color[][]  colorGrid  =  new Color[ROWS][COLUMNS];

Cuando el color del cuadrado de la fila i y columna j cambie  a un valor c, se redibujará el cuadrado en la pantalla, con el nuevo color, y podemos guardar este nuevo color en la serie con la asignación «colorGrid[i][j] = c«. La información de la serie colorGrid puede utilizarse para redibujar el mosaico entero cuando sea necesario. La información de la serie, también se puede utilizar cuando quiera saber que color en concreto hay en una posición del mosaico. La asignación «c = colorGrid[i][j]»  obtiene el color del cuadrado situado en la fila i, columna j.

En un programa, no siempre se vera tan clara la posibilidad de utilizar una matriz. Considere una compañía que tiene 25 almacenes, suponga que la compañía tiene datos sobre los beneficios mensuales de 2014. obtenidos en cada uno de sus almacenes. Si numeramos los almacenes de 0 a 24, y los doce meses de Enero 14 a Diciembre 14, los numeramos de 0 a 11, los datos sobre el beneficio se pueden almacenar en una serie profit construida como

        double[][]  profit  =  new double[25][12];

profit[3][2] contendrá el importe del beneficio generado por el almacén 3 en Marzo, y de forma mas general, profit[storeNum][monthNum] será el importe de los beneficios devengados por el almacén storeNum en el mes indicado en month. En este ejemplo, la serie de una dimensión profit[storeNum] tiene mucho sentido, es justamente el beneficio obtenido por un almacén concreto durante todo el año.


Como en el caso de las series de una dimensión, las series de dos dimensiones a menudo se procesan usando la instrucción for. Para procesar todos los elementos de una serie de dos dimensiones, deberá utilizar una instrucción for anidada dentro de otra. Si la serie A se declara como:

          int[][]  A  =  new int[3][4];

Puede poner a cero cada posición con:

          for (int row = 0;  row < 3;  row++) {
             for (int column = 0;  row < 4;  column++) {
                A[row][column] = 0;
             }
          }

La primera vez que el bucle exterior se ejecuta (con row=0), el bucle interno realiza cuatro pasadas poniendo a cero los cuatro valores de la fila cero de A llamados A[0][0] = 0, A[0][1] = 0, A[0][2] = 0, y A[0][3] = 0. La siguiente ejecución del bucle exterior rellena la segunda fila de A y la tercera y ultima ejecución del bucle exterior, rellena la ultima fila de A.

De forma similar, puede sumar todos los elementos de A con:

          int sum = 0;
          for (int i = 0; i < 3; i++)
             for (int j = 0; j < 4; i++)
                sum = sum + A[i][j];

Si hacemos esto mismo con la serie profit que hemos estado utilizando antes, puede ser que el ejemplo sea mas interesante. La suma seria el beneficio total obtenido por la compañía en el transcurso del año, en los 25 almacenes.

El siguiente ejemplo de la serie profit demuestra que a veces es necesario procesar solamente una fila o una columna se la serie. Por ejemplo, para calcular el beneficio total obtenido por la compañía en el mes de Diciembre, esto es , en el mes 11, deberá utilizar el bucle:

          double decemberProfit = 0.0;
          for (storeNum = 0; storeNum < 25; storeNum++)
             decemberProfit += profit[storeNum][11];

Podemos continuar con la idea para crear una serie de una dimensión que contenga el beneficio para cada mes del año:

          double[] monthlyProfit = new double[12];

          for (int month = 0; month < 12; month++) {
             // calcula el beneficio de todos los almacenes en un mes
             monthlyProfit[month] = 0.0;
             for (int store = 0; store < 25; store++)
                monthlyProfit[month] += profit[store][month];
          }

Como ejemplo final del tratamiento de una serie de dos dimensiones, supongamos que quiere saber qué almacén ha generado mas beneficio a lo largo del año. Para conseguirlo, debe sumar los beneficios obtenidos por cada almacén . En términos de la serie, significa que debe obtener la suma de cada una de las filas de la serie, y una vez hecho esto, buscar cual de ellas produce un total mayor.

          double maxProfit; // beneficio maximo obtenido por un almacén
          int bestStore;    // numero de almacén con el 
                            //  beneficio maximo

          double total = 0.0;    // beneficio total para un almacén;

          // primero calculo el beneficio para el almacén 0

          for (int month = 0;  month < 12; month++)
             total += profit[0][month];

          bestStore = 0;      // empiezo asumiendo que es el mejor
          maxProfit = total;  //     almacén, y guardo el numero 0

          //Ahora, voy pasando por los otros almacenes, y en cada uno
          // compruebo si su total es mayor que maxProfit, modificando
          // el supuesto inicial de que el 0 era bestStore y maxProfit

          for (store = 1; store < 25; store++) {
             total = 0.0;
             for (month = 0; month < 12; month++)
                total += profit[store][month];
             if (total > maxProfit) {
                maxProfit = total;    // mejor beneficio hasta ahora!
                bestStore = store;    // y voy por este almacén
             }
          }

          // En este punto, maxProfit es el mejor beneficio del año
          // de los 25 almacenes, y bestStore es el almacén que
          // ha generado este beneficio.  (Observe que pueden haber
          // mas almacenes que hayan generado el mismo beneficio.)

2 comentarios sobre “Java para programadores (7.4).Series de dos dimensiones”

Deja un comentario

Este sitio usa Akismet para reducir el spam. Aprende cómo se procesan los datos de tus comentarios.