Tema 13 Arreglos.

1.- Definición.

Arreglos:

Los arreglos se pueden definir como objetos en los que podemos guardar mas de una variable, es decir, al tener un unico arreglo, este puede guardar multiples variables de acuerdo a su tamaño o capacidad, es importante recordar que las variables guardadas deben ser del mismo tipo, por ejemplo: Si tenemos un arreglo de tipo Numerico que puede almacenar 10 variables, solo podra almacenar 10 numeros diferentes, no otras variables como caracteres o Strings.

2.- ¿ Cómo llenar un arreglo?.
           
  

3.- Bucle for each.
EL FOR EXTENDIDO O BUCLES FOR EACH EN JAVA
En las últimas versiones de Java se introdujo una nueva forma de uso del for, a la que se denomina “for extendido” o “for each”. Esta forma de uso del for, que ya existía en otros lenguajes, facilita el recorrido de objetos existentes en una colección sin necesidad de definir el número de elementos a recorrer. La sintaxis que se emplea es:
       for ( TipoARecorrer nombreVariableTemporal : nombreDeLaColección ) {
                                               Instrucciones
       }

Fíjate que en ningún momento se usa la palabra clave each que se usa en otros lenguajes, aunque al for muchas veces se le nombre como for each. Para saber si un for es un for extendido o un for normal hemos de fijarnos en la sintaxis que se emplea. La interpretación que podemos hacer de la sintaxis del for extendido es: “Para cada elemento del tipo TipoARecorrer que se encuentre dentro de la colección nombreDeLaColección ejecuta las instrucciones que se indican”. La variable local-temporal del ciclo almacena en cada paso el objeto que se visita y sólo existe durante la ejecución del ciclo y desaparece después. Debe ser del mismo tipo que los elementos a recorrer. Ejemplo
//Ejemplo aprenderaprogramar.com
public void listarTodosLosNombres () {
        for (String i: listaDeNombres) {
        System.out.println (i); //Muestra cada uno de los nombres dentro de listaDeNombres
    }
  }


En este tipo de ciclos podemos darle un nombre más descriptivo a la variable temporal, por ejemplo:
//Ejemplo aprenderaprogramar.com
public void listarTodosLosNombres () {
        for (String nombre: listaDeNombres) {
        System.out.println (nombre);              }
   }


Un ejemplo de llamada desde un método main (u otro lugar) sería:
//Ejemplo aprenderaprogramar.com
System.out.println ("Mostramos todos los nombres con un ciclo for-each");
lista1.listarTodosLosNombres();


El for extendido tiene algunas ventajas y algunos inconvenientes. No se debe usar siempre. Su uso no es obligatorio, de hecho, como hemos indicado, en versiones anteriores ni siquiera existía en el lenguaje. En vez de un for extendido podemos preferir usar un ciclo while. Lo haríamos así:
//Ejemplo aprenderaprogramar.com
int i = 0;
while (i < lista1.size() ) {        System.out.println (lista1.getNombre(i) );
                                           i++;                                                     }


El ciclo for-each es una herramienta muy útil cuando tenemos que realizar recorridos completos de colecciones, por lo que lo usaremos en numerosas ocasiones antes que ciclos for o while que nos obligan a estar pendientes de más cuestiones (por ejemplo en este caso con el while, de llevar un contador, llamar en cada iteración a un método, etc.). Un for extendido en principio recorre todos y cada uno de los elementos de una colección. Sin embargo, podemos introducir un condicional asociado a una sentencia break; que aborte el recorrido una vez se cumpla una determinada condición. Escribe y compila el siguiente código ejemplo de uso de un for extendido:
import java.util.ArrayList;
//Test del for extendido ejemplo aprenderaprogramar.com
public class TestForExtendido {
    public static void main (String [] Args) {
        ArrayList <String> jugadoresDeBaloncesto = new ArrayList<String> ();
        jugadoresDeBaloncesto.add ("Michael Jordan"); jugadoresDeBaloncesto.add ("Kobe Briant");
        jugadoresDeBaloncesto.add ("Pau Gasol"); jugadoresDeBaloncesto.add ("Drazen Petrovic");
        int i = 0;
        System.out.println ("Los jugadores de baloncesto en la lista son: ");

        for (String nombre : jugadoresDeBaloncesto) {  System.out.println ((i+1) + ".- " +nombre);
                                                                                       i++;  }
    } //Cierre del main
} //Cierre de la clase

4.- Método Burbuja.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
import java.io.*;
 
public class burbuja
{
    public static void main(String arg[]) throws IOException
    {
        /*creacion del objeto para leer por teclado*/

        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        /*ingreso del tamaño de arreglos*/

        System.out.print("\n Ingrese Numero de Datos a Ingresar : ");
        int tam = Integer.parseInt(in.readLine());
        /*creacion del arreglo*/

        int arr[] = new int[tam];
        System.out.println();
        /*lectura del arreglo*/

        int j = 0;
        for (int i = 0 ; i < arr.length;i++)
        {
            j+=1;
            System.out.print("Elemento " + j + " : ");
            arr[i] = Integer.parseInt(in.readLine());
        }
        burbuja(arr);
    }
 
    static void burbuja(int arreglo[])
    {
        for(int i = 0; i < arreglo.length - 1; i++)
        {
            for(int j = 0; j < arreglo.length - 1; j++)
            {
                if (arreglo[j] < arreglo[j + 1])
                {
                    int tmp = arreglo[j+1];
                    arreglo[j+1] = arreglo[j];
                    arreglo[j] = tmp;
                }
            }
        }
        for(int i = 0;i < arreglo.length; i++)
        {
            System.out.print(arreglo[i]+"\n");
        }
    }
}

5.- Metódo inserción.

El método de ordenación por inserción directa consiste en recorrer todo el array comenzando desde el segundo elemento hasta el final. Para cada elemento, se trata de colocarlo en el lugar correcto entre todos los elementos anteriores a él o sea entre los elementos a su izquierda en el array.
Dada una posición actual p, el algoritmo se basa en que los elementos A[0], A[1], ..., A[p-1] ya están ordenados.
De forma gráfica el proceso que sigue el método de inserción directa es el siguiente:
 El método de Ordenamiento por inserción directa en Java es el siguiente:
public static void insercionDirecta(int A[]){
    int p, j;
    int aux;
    for (p = 1; p < A.length; p++){ // desde el segundo elemento hasta
              aux = A[p]; // el final, guardamos el elemento y
              j = p - 1; // empezamos a comprobar con el anterior
              while ((j >= 0) && (aux < A[j])){ // mientras queden posiciones y el
                                                                    // valor de aux sea menor que los
                             A[j + 1] = A[j];       // de la izquierda, se desplaza a
                             j--;                   // la derecha
              }
              A[j + 1] = aux; // colocamos aux en su sitio
    }
}
En el peor de los casos, el tiempo de ejecución en O(n2).
En el mejor caso (cuando el array ya estaba ordenado), el tiempo de ejecución de este método de ordenamiento es O(n).
El caso medio dependerá de cómo están inicialmente distribuidos los elementos. Cuanto más ordenada esté inicialmente más se acerca a O(n) y cuanto más desordenada, más se acerca a O(n2).
El peor caso el método de inserción directa es igual que en los métodos de burbuja y selección, pero el mejor caso podemos tener ahorros en tiempo de ejecución.

6.- Busqueda secuencial.

El método de búsqueda secuencial consiste en ir comparando el elemento o criterio de búsqueda con cada uno de los elementos en el arreglo, esto se hace recorriendo el arreglo y deteniéndose en cada elemento y hacer la comparación, en caso de ser verdadera la comparación, guardar la posición el elemento o dato.

He aquí el código:

public int busquedaSecuencial(int []arreglo,int dato){ 
int posicion = -1; for(int i = 0; i < arreglo.length; i++){ //recorremos todo el arreglo 
if(arreglo[i] == dato){
//comparamos el elemento en el arreglo con el buscado posicion = i; //Si es verdadero guardamos la posicion break; //Para el ciclo } } return posicion; }


Este método nos halla la posición del elemento o dato buscado pero en su primero coincidencia, si queremos que nos halle la posición de la ultima coincidencia, lo único que tenemos que hacer es eliminar la linea donde aparece 'break'.

Si el resultado del método anterior es -1, significa que el elemento no se encuentra en el arreglo.

Ahora cabe la pregunta, ¿y si el elemento que deseo buscar aparece varias veces en el arreglo y yo deseo conocer cada una de estas posiciones, como hago?

Lo que hacemos es deshacernos de la linea 'break' para que el vector sea recorrido en su totalidad, y de alguna forma ir almacenando cada una de las posiciones resultantes de las comparaciones verdaderas.

He aquí el código:

public String busquedaSecuencial2(int []arreglo,int valor){ String posicion = ""; 
 for(int i = 0; i < arreglo.length; i++){ if(arreglo[i] == valor)
{ posicion += i+","; } 
 } 
 return posicion;
 }


                                                                                                                                              

Comentarios

Publicar un comentario

Entradas populares de este blog

TEMA 7: Entradas y salidas por ventanas emergentes.

Imagen
1. Entrada y salida  por ventanas emergentes. Algo muy común a la hora de programar, es como avisar al usuario de ciertas actividades, o como hacerlo escoger para recapacitar o darle la oportunidad de elegir que es lo que se desea hacer, para esto, en Java tenemos elementos muy sencillos pero funcionales, que nos permiten mostrar mensajes de dialogo, o cuadros de dialogo, como los prefieran llamar, estos elementos son sumamente sencillos de utilizar con un poco de lectura al API de Java, sin embargo, como siempre, surgen las dudas, y para aclararlas dedicaré este post para mostrarles los diferentes tipos de diálogos que podemos utilizar en Swing, bien, para esto he preparado lo siguiente (Utilizando Netbeans como IDE): Un proyecto con un nombre cualquiera (En este caso SerProgramador.es). Un paquete donde iremos trabajando durante este post. Y con esto, comencemos a trabajar, dado que existen varias formas de hacer distintos tipos de cuadros de diálogo, comenzaremos a ve...
Leer más

TEMA 11: Clase Math.

Imagen
1.- Metodo de la clase Math. Esta clase ya viene incluida en nuevas versiones de Java, por lo que no habrá que importar ningún paquete para ello. Para utilizar esta clase, debemos escribir Math.método(parámetros); donde método sera uno de los siguientes y parámetros aquellos que tengamos que usar. Un método puede estar sobrescrito para distintos tipos de datos. Recuerda que si almacenas el resultado de la función, debe coincidir con el tipo de la variable. Veamos algún ejemplo: public class PruebaApp { public static void main(String[] args) { double operador1=25.5; double operador2=15.21; System.out.println(Math.ceil(operador1)); // Devuelve 26.0 System.out.println(Math.floor(operador2)); //Devuelve 15.0 System.out.println(Math.pow(operador1, operador2)); // Devuelve 2.474435537975361E21 System.out.println(Math.max(operador1, operador2)); //Devuelve 25.5 System.out.println(Math.sqrt(oper...
Leer más
Imagen
11.- Encapsulamiento y métodos accesores. Encapsulamiento en Java Imaginemos que se crea una clase, una docena de programadores tienen acceso a dicha clase y la utilizan a discreción, posteriormente dicha clase comienza a comportarse de una manera inesperada debido a que los valores que algunas variables han tomado no fueron anticipados y todo comienza a desmoronarse. Para corregir el problema se crea una versión más nueva de dicha clase y listo. Bueno, a esto le llamamos flexibilidad y capacidad de mantenimiento, ambas son características y beneficios de la programación Orientada a Objetos (OO) pero para que una clase pueda cumplir dichas funciones los programadores debemos de hacer algo. Imaginemos que creamos una clase con variables de instancia públicas a las cuales podemos acceder sin problemas desde fuera de la misma clase... Analizando el código anterior podemos darnos cuenta de que las variables enteras tipo y clase son públicas y pueden ser accedidas directamente a...
Leer más