Check the new version here

Popular channels

Curso de Java para Android (Para fines Educativos) [CLASE 9]



Hola gente, bueno, acá les paso la clase nro 9 que se refiere a arrays y donde veremos una parte teórica y otra práctica para poder entenderlo mejor.



CLASE 9: LOS ARREGLOS -ARRAYS

9.1 USO DE ARRAYS
Los Arrays nos permiten agrupar variables relacionadas entre sí y que comparten el mismo tipo. Podemos crearlos para cualquier tipo de información que pueda ser almacenado en una variable, veamos un ejemplo objetivo:

Los Arrays se construyen con la siguiente sintaxis:
Primero va el tipo de dato, luego van los corchetes y finalmente el nombre de la variable.

Además hay que tener en cuenta que los Arrays son también clases. Veamos un ejemplo con la sintaxis completa:



A todos los elementos de un Array se les da un valor inicial que varía según el tipo:

•Numéricos tienen un valor inicial de 0
Booleans tienen un valor inicial false
Strings y Objetos tienen un valor inicial null.

Podemos hacer una sintaxis un poco más simple en el caso que no sean demasiados los elementos, van entre llaves y separados entre comas:
String[]marcasImpresoras={"Brother","Canon","HP","Epson","Lexmark","Xerox","Samsung"};
Java es muy flexible en cuanto a la localización de los corchetes. Como podemos ver en la siguiente sintaxis:
String [] marcasImpresoras =
String marcasImpresoras [] =

Veamos unos ejemplos del uso concreto de los Arrays:
numeroHabitantes[14]=40733851
paises [ 2 ]= “Argentina”;
if(paisCostero[paisActual]==true{indicarCosta();}

Para saber el número de elementos que tenemos en un Array podemos utilizar el método Length que ya vimos anteriormente:



Esto sirve a la hora de saber cuál es el último elemento indexado, pues como hemos visto en los Arrays el número de inicialización es 0, null o false.
Tenemos a continuación un ejemplo de array un poco más complejo para desglosarlo y poder entender mejor:

import javax.swing.*;
public class unoArreglo {

public static void main(String[] args) {
int arreglo[]; // declarar la referencia a un arreglo

arreglo = new int[10]; // crear el arreglo

String salida = "ÍndicetValorn";

// anexar el valor de cada elemento del arreglo al String salida
for ( int contador = 0; contador < arreglo.length; contador++ )
salida += contador + "t" + arreglo[ contador ] + "n";

JTextArea areaSalida = new JTextArea();
areaSalida.setText( salida );

JOptionPane.showMessageDialog( null, areaSalida,
"Inicialización de un arreglo de valores int",
JOptionPane.INFORMATION_MESSAGE );

System.exit( 0 );

}

}


Cuando ejecutamos el programa, nos dará:



9.2 ARRAYS MULTIDIMENSIONALES
Los Arrays pueden tener más de una dimensión, antes usamos de una sola dimensión, en donde podíamos recuperar un elemento usando un único número. Pero cuando los programas se hacen más complicados vamos a tener que recurrir para poder guardar más valores de acuerdo a la funcionalidad que deseemos darles. Veremos cómo se construyen:



Ahora veremos cómo podemos reordenar los elementos de un Array del modo que querramos:

1)Antes que nada debemos hacer la importación de alguna clase de la biblioteca: import java.util.*;
2)Como segundo paso, crearemos el array.
3)Y finalmente usar el método para que funcione: sort() claseArray.
Ejemplo:
int temp = numeros [ 5 ];
numeros [ 5 ] = numeros [ 6 ];
numeros [ 6 ] = temp;


Veremos un ejemplo para poder entenderlo mejor:





los String se ordenan alfabéticamente y los valores numéricos en orden ascendente.



En el ejemplo vemos un Array que primero da los nombres como fueron escritos y luego del empleo del método sort() hace que los ordene de manera alfabética. Si a cualquier nombre le ponemos un espacio delante, tomará a aquél como el primero de la lista.

En el ejemplo siguiente podemos observar que le damos una cantidad de 5, sin embargo es necesario que empiece con 0 el arreglo:



CALCULO DE LOS VALORES A GUARDAR EN UN ARREGLO
Veremos un ejemplo en donde se crean 10 arreglos y se asigna a cada uno de los elementos uno de los números pares del 2 al 20.

public class inicArreglo {

public static void main(String[] args) {

final int LONGITUD_ARREGLO = 10; // declara la constante con un valor de 10
int arreglo[] = new int[LONGITUD_ARREGLO]; //Crea el arreglo

// calcula el valor para cada elemento del arreglo
*for (int contador =0; contador< arreglo.length; contador++)
arreglo[contador] = 2+2*contador;
System.out.printf("%s%8sn", "Indice", "Valor" ); // encabezado de columnas
// imprime el valor de cada elemento del arreglo
for (int contador =0; contador< arreglo.length; contador++)

System.out.printf("%5d%8dn", contador, arreglo[contador]);
}

}


No dará el siguiente resultado:



9.3 SUMA DE LOS ELEMENTOS DE UNA ARREGLO

A menudo necesitamos resolver ciertas operaciones con nuestros valores dentro de un Array, y tal vez utilizar este total para hacer otra cuenta. Veremos un ejemplo para darnos una mejor idea:

1 public class sumaArreglo {
2
3public static void main(String[] args) {
4
5int arreglo[] = {87,68,94,100,83,78,85,91,76,87};
6int total = 0;
7// suma el valor de cada elemento al total
8for (int contador = 0; contador < arreglo.length; contador++)
9total += arreglo[contador];
10
11System.out.printf("Total de los elementos del arreglo: %dn", total);


Los elementos totales nos darían 849, que es la suma de los números del arreglo.




EJERCICIOS

1.Programa para realizar histogramas:

import javax.swing.*;
public class histograma {

public static void main(String[] args) {
int arreglo[] = { 19, 3, 15, 7, 11, 9, 13, 5, 17, 1 };

String salida = "ElementotValortHistograma";

// para cada elemento del arreglo, mostrar una barra en el histograma
for ( int contador = 0; contador < arreglo.length; contador++ )
{
salida += "n" + contador + "t" + arreglo[ contador ] + "t";

// imprimir barra de asteriscos
for ( int estrellas = 0; estrellas < arreglo[ contador ]; estrellas++ )
salida += "*";

} // fin de instrucción for externa

JTextArea areaSalida = new JTextArea();
areaSalida.setText( salida );

JOptionPane.showMessageDialog( null, areaSalida,
"Programa para imprimir histogramas", JOptionPane.INFORMATION_MESSAGE );

System.exit( 0 );


}

}




2. Simulación de votación utilizando arreglos

import javax.swing.*;
public class VotacionEstudiantes {

public static void main(String[] args) {
int respuestas[] = { 1, 2, 6, 4, 8, 5, 9, 7, 8, 10, 1, 6, 3, 8, 6,
10, 3, 8, 2, 7, 6, 5, 7, 6, 8, 6, 7, 5, 6, 6, 5, 6, 7, 5, 6,4, 8, 6, 8, 10 };
int frecuencia[] = new int[ 11 ];

// para cada respuesta, seleccionar el elemento de respuestas y usar ese valor
// como índice en frecuencia para determinar el elemento a incrementar
for ( int respuesta = 0; respuesta < respuestas.length; respuesta++ )
++frecuencia[ respuestas[ respuesta ] ];

String salida = "CalificacióntFrecuencian";

// anexar frecuencias al String salida
for ( int calificacion = 1; calificacion < frecuencia.length; calificacion++ )
salida += calificacion + "t" + frecuencia[ calificacion ] + "n";

JTextArea areaSalida = new JTextArea();
areaSalida.setText( salida );

JOptionPane.showMessageDialog( null, areaSalida,"Programa de votación de estudiantes", JOptionPane.INFORMATION_MESSAGE );

System.exit( 0 );

}

}




3.Paso de arreglos y elementos individuales de un arreglo a métodos.

1.import java.awt.Container;
2.import javax.swing.*;
3.
4.public class PasoArreglos extends JApplet {
5.
6.
7.
8.// inicializar subprograma
9. public void init()
10. {
11. JTextArea areaSalida = new JTextArea();
12. Container contenedor = getContentPane();
13. contenedor.add( areaSalida );
14.
15. int arreglo[] = { 1, 2, 3, 4, 5 };
16.
17. String salida = "Efectos de pasar el arreglo completo por referencia:n" +
18. "Los valores del arreglo original son:n";
19.
20. // anexar los elementos del arreglo original al String salida
21. for ( int contador = 0; contador < arreglo.length; contador++ )
22. salida += " " + arreglo[ contador ];
23.
24. modificarArreglo( arreglo ); // arreglo pasado por referencia
25.
26. salida += "nnLos valores del arreglo modificado son:n";
27.
28. // anexar los elementos del arreglo modificado al String salida
29. for ( int contador = 0; contador < arreglo.length; contador++ )
30. salida += " " + arreglo[ contador ];
31.
32. salida += "nnEfectos de pasar el elemento de un arreglo por valor:n" +
33. "arreglo[3] antes de modificarElemento: " + arreglo[ 3 ];
34. modificarElemento( arreglo[ 3 ] ); // intento de modificar arreglo[ 3 ]
35.
36. salida += "narreglo[3] después de modificarElemento: " + arreglo[ 3 ];
37. areaSalida.setText( salida );
38.
39. } // fin del método init
40.
41. // multiplicar cada elemento de un arreglo por 2
42. public void modificarArreglo( int arreglo2[] )
43. {
44. for ( int contador = 0; contador < arreglo2.length; contador++ )
45. arreglo2[ contador ] *= 2;
46. }
47.
48. // multiplicar argumento por 2
49. public void modificarElemento( int elemento )
50. {
51. elemento *= 2;
52. }
53.
54.}





4. Ordenamiento de un arreglo utilizando el método de Burbuja.

import java.awt.*;
import javax.swing.*;

public class OrdenamBurbuja extends JApplet {

// inicializar subprograma
public void init()
{
JTextArea areaSalida = new JTextArea();
Container contenedor = getContentPane();
contenedor.add( areaSalida );

int arreglo[] = { 2, 6, 4, 8, 10, 12, 89, 68, 45, 37 };

String salida = "Elementos de datos en su orden originaln";

// anexar los valores originales al String salida
for ( int contador = 0; contador < arreglo.length; contador++ )
salida += " " + arreglo[ contador ];

ordenamBurbuja( arreglo ); // ordenar arreglo

salida += "nnElementos de datos en orden ascendenten";

// anexar los valores ordenados del arreglo al String salida
for ( int contador = 0; contador < arreglo.length; contador++ )
salida += " " + arreglo[ contador ];

areaSalida.setText( salida );

} // fin del método init

// ordenar elementos del arreglo con el método burbuja
public void ordenamBurbuja( int arreglo2[] )
{
// ciclo para controlar número de pasadas
for ( int pasada = 1; pasada < arreglo2.length; pasada++ ) {

// ciclo para controlar número de comparaciones
for ( int elemento = 0;
elemento < arreglo2.length - 1;
elemento++ ) {

// comparar elementos uno a uno e intercambiarlos si
// el primer elemento es mayor que el segundo
if ( arreglo2[ elemento ] > arreglo2[ elemento + 1 ] )
intercambiar( arreglo2, elemento, elemento + 1 );

} // fin del ciclo para controlar las comparaciones

} // fin del ciclo para controlar las pasadas

} // fin del método ordenamBurbuja

// intercambiar dos elementos de un arreglo
public void intercambiar( int arreglo3[], int primero, int segundo )
{
int almacen; // área temporal de almacenamiento para intercambiar

almacen = arreglo3[ primero ];
arreglo3[ primero ] = arreglo3[ segundo ];
arreglo3[ segundo ] = almacen;
}

} // fin de la clase OrdenamBurbuja


Bueno gente, eso fue todo por esta vez. de todas formas iré colgando las clases conforme vaya desocupándome. saludos y a practicar. No queda otra...
Hasta la....


CLASE 8 <<< IR A LA CLASE >>> CLASE 10
0
0
0
0No comments yet