Semana 8

 Arreglos multidimensionales.

Los arreglos multidimensionales de dos dimensiones se utilizan con frecuencia para representar tablas de valores, con datos ordenados en filas y columnas. Para identificar un elemento específico de una tabla, debemos especificar dos índices. Por convención, el primero identifica la fila del elemento y el segundo su columna. Los arreglos que requieren dos índices para identificar un elemento específico se llaman arreglos bidimensionales (los arreglos multidimensionales pueden tener más de dos dimensiones). Java no soporta los arreglos multidimensionales directamente, pero permite al programador especificar arreglos unidimensionales, cuyos elementos sean también arreglos unidimensionales, con lo cual se obtiene el mismo efecto.

Arreglo bidimensional con tres filas y cuatro columnas.

Cada elemento en el arreglo a se identifica en la figura, mediante una expresión de acceso a un arreglo de la forma a[fila][columna]; a es el nombre del arreglo, fila y columna son los índices que identifican en forma única a cada elemento por índice de fila y columna. Todos los nombres de los elementos en la fila 0 tienen un primer índice de 0, y los nombres de los elementos en la columna 3 tienen un segundo índice de 3.

Arreglos de arreglos unidimensionales
Al igual que los arreglos unidimensionales, los multidimensionales pueden inicializarse mediante inicializadores de arreglos en las declaraciones. Un arreglo bidimensional b con dos filas y dos columnas podría declararse e inicializarse con inicializadores de arreglos anidados, como se muestra a continuación:
int[][] b = {{1, 2}, {3, 4}};
Los valores iniciales se agrupan por fila entre llaves. Por lo tanto, 1 y 2 inicializan a b[0][0] y b[0][1],respectivamente; 3 y 4 inicializan a b[1][0] y b[1][1], respectivamente. El compilador cuenta el número de inicializadores de arreglos anidados (representados por conjuntos de llaves dentro de las llaves externas) para determinar el número de filas en el arreglo b. El compilador cuenta los valores inicializadores en el inicializador de arreglos anidado de una fila, para determinar el número de columnas en esa fila. 

Los arreglos multidimensionales se mantienen como arreglos de arreglos unidimensionales. Por lo tanto, el arreglo b en la declaración anterior en realidad está compuesto de dos arreglos unidimensionales independientes: uno que contiene los valores en la primera lista inicializadora anidada {1, 2} y otro que contiene los valores en la segunda lista inicializadora anidada {3, 4}.

Arreglos bidimensionales con filas de distintas longitudes

La forma en que se representan los arreglos multidimensionales los hace bastante flexibles. De hecho, las longitudes de las filas en el arreglo b no tienen que ser iguales. Por ejemplo,

int[][] b = {{1, 2}, {3, 4, 5}};

Creación de arreglos bidimensionales mediante expresiones de creación de arreglos.
Un arreglo multidimensional con el mismo número de columnas en cada fila puede formarse mediante una expresión de creación de arreglos. Por ejemplo, en las siguientes líneas se declara el arreglo b y se le asigna una referencia a un arreglo de tres por cuatro:

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

Listas de argumentos de longitud variable.
Con las listas de argumentos de longitud variable podemos crear métodos que reciben un número no especificado de argumentos. Un tipo que va precedido por una elipsis(...) en la lista de parámetros de un método indica que éste recibe un número variable de argumentos de ese tipo específico. Este uso de la elipsis puede ocurrir sólo una vez en una lista de parámetros, y la elipsis, junto con su tipo y el nombre del parámetro, debe colocarse al final de la lista. 

Uso de argumentos de línea de comandos
En muchos sistemas, es posible pasar argumentos desde la línea de comandos a una aplicación mediante el parámetro String[] de main, el cual recibe un arreglo de objetos String. Por convención, a este parámetro sele llama args. Cuando se ejecuta una aplicación con el comando java, Java pasa los argumentos de línea de comandos que aparecen después del nombre de la clase en el comando java al método main de la aplicación, en forma de objetos String en el arreglo args. El número de argumentos que se pasan desde la línea de comandos se obtiene accediendo al atributo length del arreglo. Los usos comunes de los argumentos de línea de comandos incluyen pasar opciones y nombres de archivos a las aplicaciones.

Ejemplos.

1)
package ejemplo.diivisibles.matriz;
import java.util.Scanner;
/**
 *
 * @author angel
 */
public class EjemploDiivisiblesMatriz {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        Scanner entrada=new Scanner(System.in);
        int[][] num=new int [2][3];
        int[][] div3=new int [2][3];
        int[][] div5=new int [2][3];
        int[][] divA=new int [2][3];
        int[][] nodiv=new int [2][3];
        int i, j; 
        
        for(i=0; i<2; i++){
            for(j=0; j<3; j++){
                System.out.println("Ingrese valor ");
                num[i][j]=entrada.nextInt();
            }
        }
        for(i=0; i<2; i++){
            for(j=0; j<3; j++){
              if(num[i][j]%3==0 && num[i][j]%5==0 ){
                  divA[i][j]=num[i][j];
              } else if(num[i][j]%3==0) {
                  div3[i][j]=num[i][j];
              } else if (num[i][j]%5==0){
                      div5[i][j]=num[i][j];
              } else{
                  nodiv[i][j]=num[i][j];
              }   
        }
    }
        System.out.println("Numero   Divisible en ambos         Divisible en 3             Divisible en 5            No divisible");
        for(i=0; i<2; i++){
            for(j=0; j<3; j++){
                System.out.println(num[i][j] +"            "+divA[i][j] +"           "+div3[i][j] +"           "+div5[i][j] +"           "+nodiv[i][j]); 
            }
                
        }
    }
}

2)
package ejemplo.pkg1.matriz;
import java.util.Scanner;
/**
 *
 * @author angel
 */
public class Ejemplo1Matriz {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        int [][] m=new int [2][2];
        int i, j, v = 0;
        Scanner entrada=new Scanner(System.in);
        for(i=0; i<2; i++ ){
            for(j=0; j<2; j++){
                System.out.println("Ingrese valor ");
                m[i][j]=entrada.nextInt();
            }
        }
        for(i=0; i<2; i++){
            for(j=0; j<2; j++){
                System.out.println(m[i][j]);
            }
            int n = 0;
        }
        System.out.println("Cantidad de ceros " +m);
    }
    
}

3)
package ejemplo.alberca.pkg2.matriz;
import java.util.Scanner;
/**
 *
 * @author angel
 */
public class EjemploAlberca2Matriz {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        double [][] l=new double [3][3];
        double [][] a=new double [2][3];
        double [][] p=new double [2][3];
        double [][] v=new double [2][3];
        double [][] pr=new double [2][3];
        double [][] ar=new double [2][3];
        int i, j;
        Scanner entrada=new Scanner(System.in);
        for(i=0; i<2; i++){
            for(j=0; j<=2; j++){
                System.out.println("Ingrese largo ");
                l[i][j]=entrada.nextDouble();
                System.out.println("Ingrese ancho ");
                a[i][j]=entrada.nextDouble();
                System.out.println("Ingrese profundidad ");
                pr[i][j]=entrada.nextDouble();
        }
    }
      for(i=0; i<2; i++){
            for(j=0; j<=2; j++){
                p[i][j]= 2*(l[i][j]+a[i][j]);
                v[i][j]=l[i][j]*a[i][j]*pr[i][j];
                ar[i][j]=2*(l[i][j]+a[i][j])*pr[i][j]+l[i][j]*a[i][j];
                
            }
                
        }
        System.out.println("Perimetro "); 
         for(i=0; i<2; i++){
            for(j=0; j<=2; j++){
                System.out.println(p[i][j]); 
                
            }
                
            }
         System.out.println("Volumen "); 
         for(i=0; i<2; i++){
            for(j=0; j<=2; j++){
                System.out.println(v[i][j]);
        }
    }
         System.out.println("Area de superficie");
         for(i=0; i<2; i++){
            for(j=0; j<=2; j++){
                System.out.println(p[i][j]);
    }
}
    }
}


Para que el tema quede un poco mas claro.


Comentarios

Publicar un comentario

Entradas populares de este blog

Semana No.2

Imagen
   Programación. Es el proceso utilizado para idear y ordenar las acciones necesarias para realizar un proyecto, preparar ciertas máquinas o aparatos para que empiecen a funcionar en el momento y en la forma deseada. La programación se encuentra muy asociada a la creación de aplicaciones informática y videojuegos. Para crear un programa, y que la computadora lo interprete y ejecute las instrucciones escritas en él, debe escribirse en un lenguaje de programación. Objetivo de la programación. Perseguir la obtención de programas de calidad. Factores de calidad:  Correctitud  Claridad  Eficiencia  Portabilidad Programas y algoritmos. Un programa normalmente implementa  ( traduce a un lenguaje de programación  concreto)  uno o más algoritmos. Un algoritmo puede expresarse de distintas maneras: en forma gráfica, como un diagrama de flujo, en forma de código como en pseudocódigo o un lenguaje deprogramación, en forma explicativa. Los programas suelen...
Leer más

Semana 12

Imagen
 Poliformismo. herencia. El polimorfismo nos permite “programar en forma general ”, en vez de “programar en forma específica”. En particular, nos permite escribir programas que procesen objetos que compartan la misma superclase (ya sea de manera directa o indirecta) como si todos fueran objetos de la superclase; esto puede simplificar la programación. Con el polimorfismo podemos diseñar e implementar sistemas que puedan extenderse con facilidad, ya que se pueden agregar nuevas clases con sólo modificar un poco (o nada) las porciones generales del programa, siempre y cuando las nuevas clases sean parte de la jerarquía de herencia que el programa procesa en forma genérica. Las nuevas clases simplemente “se integran”. Las únicas partes de un programa que deben alterarse son las que requieren un conocimiento directo de las nuevas clases que agregamos a la jerarquía. Algunas veces, cuando se lleva a cabo el procesamiento polimórfico, es necesario programar “en forma específica”. Nuestro...
Leer más

Semana 15

Imagen
JList Es un componente que contiene una lista de objetos. Es parecido a  JComboBox , pero posee algunas diferencias: Se utilizan cuando se quiere ver varios elementos de la lista a la vez. Se puede seleccionar uno o varios elementos a la vez. Para trabajar con este componente es necesario establecerle un modelo ( Model ). Una clase modelo es la que contiene los datos a representar en la interfaz gráfica. Los cambios en el objeto modelo actualizan automáticamente los cambios en la interfaz gráfica. Básicamente un modelo contiene una lista de objetos a mostrar en la lista y una serie de operaciones que podemos realizar sobre los objetos, como insertar, eliminar, etc.... Existen clases ya definidas para realizar este trabajo como  DefaultListModel . Las propiedades importantes en Netbeans son: model : Modelo que usa el componente para mostrar datos. selectionMode : El modo de selección, simple o múltiple. Propiedades de  JList  en Netbeans: jTable   Los modelos de ...
Leer más