LEP IV - Unidad 4 - Teoria y taller.

Unidad 4. Arreglos Unidimensionales en Java.

Se puede definir un arreglo como un conjunto finito de elementos del mismo tipo. En un arreglo unidimensional, cada elemento del mismo es referenciado por un indice, por este motivo, los arreglos unidimensionales son conocidos tambien como vectores.

En el caso del lenguaje de programacion Java, el primer elemento del arreglo se encuentra en la posicion 0, mientras que el ultimo se encuentra en la posicion longitud del arreglo - 1.

Visualmente, sea el arreglo de enteros a:
a = 4, 22, 7, 15, 1

El mismo tiene una longitud de 5, el primer elemento se encuentra en la posicion 0, mientras que el ultimo se encuentra en la posicion 4. El elemento en la posicion 2 es 7.

Ahora nos queda por saber como declarar, crear, referenciar y recorre un arreglo en el Lenguaje de programacion Java.

1. Declarar un areglo: Declarar un arreglo es unicamente decirle a Java que existe una variable de tipo arreglo que va a contener un tipo de datos especificos, pero sin indicar cuantos elementos, ni cuales seran los elementos. La forma de hacerlo es como se describe:

- 'tipo de dato'[] 'nombre de variable'; // Tipo de datos puede ser un tipo primitivo (int, float, double, etc...) o una clase (String, Cuadrado, etc...).
- Ejemplos:
- int[] notas; // Se esta declarando un arreglo llamado notas que contendra enteros.
- String[] nombres; // Se esta declarando un arreglo llamado nombres que contendra Strings.
- Cuadrado[] cuadrados; // Se esta declarando un arreglo llamado cuadrados que contendra Cuadrados, en este caso, la clase debe haber sido creado previamente.

2. Crear un arreglo: Una vez declarado un arreglo, podemos proceder a crearlo. Crear un arreglo consiste en decirle a Java cuantos elementos contendra el mismo. La forma de hacerlo es como se describe:
'nombre de variable' = new 'tipo de dato'['Numero de elementos'];
- Ejemplos:
- notas = new int(10); // Se esta diciendo que el arreglo notas podra contener 10 elementos.
- nombres = new String(15); // Se esta diciendo que el arreglo nombres podra contener 15 elementos.
- cuadrados = new Cuadrado(5); // Se esta diciendo que el arreglo cuadrados podra contener 5 elementos.

3. Declarar y crear al mismo tiempo: tambien es posible declarar y crear un arreglo al mismo tiempo, como una combinacion de lo mostrado anteriormente, de la siguiente forma.

- int[] notas = new int(10);
- String[] nombres = new String(15);
- Cuadrado[] cuadrados new Cuadrado(5);

4. Acceder a los elementos de un arreglo: Los elementos de un arreglo son accedidos a traves de su indice y usando los corchetes '[]', el indice de cada elemento del arreglo debe estar entre 0 y numero de elementos - 1.

Ej: Sea el arreglo de enteros arr y supongamos que el mismo tiene 10 elementos.
Syso(arr[2]); // Acceder para lectura
arr[5] = 4; // Acceder para escritura

5. Recorrer un arreglo: Todos los arreglos tienen una propiedad llamada length, la cual nos devuelve el numero de elementos del mismo. Cuando deseamos recorrer un arreglo usaremos esta propiedad para obtener el numero de elementos y asi recorrer el arreglo.

     - Ascendentemente, sea el nombre del arreglo arr:
      for (int 1 = 0; i < arr.length; i++) {
           Syso(arr[i]); // Mostramos por pantalla el valor.
      }
     - Descendentemente, sea el nombre del arreglo arr:
      for (int 1 = arr.length; i >= 0; i--) {
           arr[i] = 10 + (int)(Math.random() * 91); 
           // Le asignamos a cada elemento 
           //del arreglo un numero aleatorio entre 10 y 100.
      }

Taller:
Condiciones: 4 integrantes, 4 puntos, Fecha de entrega Domingo 28 de Marzo.
Elaborar un proyecto en Java para que usando arreglos obtener todos los numeros primos entre 2 y un numero generado aleatoriamente entre 100 y 1000 de la siguiente forma:
1. Generar un numero aleatorio entre 100 y 1000, lo llamaremos ale.
2. Crear un arreglo de enteros con ese numero de elementos (ale).
3. Asignar a cada elemento del arreglo su indice. Es decir arr[0] = 0, arr[1] = 1, arr[2] = 2, etc..
3. Recorrer el arreglo desde 2 hasta la raiz cuadrada de ese numero ((int)Math.sqrt(ale)).
4. Por cada elemento recorrido en la parte anterior que tenga un valor distinto de cero, asignar cero a todos los elementos del arreglo que sean multiplos del mismo.
5. Al finalizar el bucle, todos los elementos que no valgan distinto de 0 son los primos.
6. La salida del programa debe ser, mostrar por pantalla, Los numero primos entre 2 y (ale), son: y se deben colocar los elemntos del arreglo que sean distintos de cero.

Ejemplo:
Supongamos que el numero aleatorio generado es 26.
Creamos un arreglo con 26 elementos, le asugnamos a cada elemento del del arreglo su indice.
Sacamos la raiz cuadrada a 26 y obtenemos su parte entera, es decir 5.
Luego desde 2 hasta 5 vamos a ver en todo el arreglo cuales elementos son multiplos de estos numeros y le vamos a asignar 0, ya que esos seran los no primos. Para el caso de i = 2 marcariamos con 0 a los elementos, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26. Seguimos con el siguiente que seria 3, en este caso marcamos con 0 los elementos, 6, 9, (12 ya valdria 0, previament marcado con 2), 15, (18 ya estaria marcado), 21, (24 ya estaria marcado). Continuariamos con (4 pero en este punto valdria 0 ya que fue marcado cuando lo hicimos con el 2), por lo tanto continuariamos al 5, con 5 marcariamos, (10 ya estaria en 0), (15 ya estaria en 0), (20 ya estaria en 0), 25 nada mas.
En este punto el arreglo tendria:
0, 1, 2, 3, 0, 5, 0, 7, 0, 0, 0, 11, 0, 13, 0, 0, 0, 17, 0, 19, 0, 0, 0 , 23, 0, 0, 0

Entonces soloque daria mostrar por pantalla los que son distintos de 0.
Cualquier duda, pregunten y por favor recuerden no copiarse entre grupos. Saludos.

Hacer click en la siguiente imagen.