[código] Arreglos (arrays) en Java (2)
(anterior) Los arreglos en Java son objetos, demostrando el compromiso de Java con la orientación a objetos. En esta sección se encuentran diversos ejemplos de arreglos unidimensionales y multidimensionales, y se exponen las manipulaciones más comunes de estos. También el proceso de pasar arreglos a métodos y las técnicas elementales para ordenar y realizar búsquedas, junto con la presentación de la búsqueda binaria como una mejora sobre la búsqueda lineal. Veámos algunos ejemplos:
Paso de arreglos y elementos individuales de un arreglo a métodos
// Paso de arreglos y elementos individuales de un arreglo a métodos.
import java.awt.Container;
import javax.swing.*;
public class PasoArreglos extends JApplet {
// inicializar subprograma
public void init()
{
JTextArea areaSalida = new JTextArea();
Container contenedor = getContentPane();
contenedor.add( areaSalida );
int arreglo[] = { 1, 2, 3, 4, 5 };
String salida = "Efectos de pasar el arreglo completo por referencia:\n" +
"Los valores del arreglo original son:\n";
// anexar los elementos del arreglo original al String salida
for ( int contador = 0; contador < arreglo.length; contador++ )
salida += " " + arreglo[ contador ];
modificarArreglo( arreglo ); // arreglo pasado por referencia
salida += "\n\nLos valores del arreglo modificado son:\n";
// anexar los elementos del arreglo modificado al String salida
for ( int contador = 0; contador < arreglo.length; contador++ )
salida += " " + arreglo[ contador ];
salida += "\n\nEfectos de pasar el elemento de un arreglo por valor:\n" +
"arreglo[3] antes de modificarElemento: " + arreglo[ 3 ];
modificarElemento( arreglo[ 3 ] ); // intento de modificar arreglo[ 3 ]
salida += "\narreglo[3] después de modificarElemento: " + arreglo[ 3 ];
areaSalida.setText( salida );
} // fin del método init
// multiplicar cada elemento de un arreglo por 2
public void modificarArreglo( int arreglo2[] )
{
for ( int contador = 0; contador < arreglo2.length; contador++ )
arreglo2[ contador ] *= 2;
}
// multiplicar argumento por 2
public void modificarElemento( int elemento )
{
elemento *= 2;
}
} // fin de la clase PasoArreglos
Ordenamiento de un arreglo utilizando el método de Burbuja
// Ordenamiento de los valores de un arreglo en orden ascendente.
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 original\n";
// anexar los valores originales al String salida
for ( int contador = 0; contador < arreglo.length; contador++ )
salida += " " + arreglo[ contador ];
ordenamBurbuja( arreglo ); // ordenar arreglo
salida += "\n\nElementos de datos en orden ascendente\n";
// 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
Búsqueda lineal en un arreglo
// Búsqueda lineal en un arreglo.
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
public class BusquedaLineal extends JApplet implements ActionListener {
JLabel escribirEtiqueta, resultadoEtiqueta;
JTextField escribirCampo, resultadoCampo;
int arreglo[];
// configurar GUI del subprograma
public void init()
{
// obtener panel de contenido y configurar su esquema como FlowLayout
Container contenedor = getContentPane();
contenedor.setLayout( new FlowLayout() );
// configurar JLabel y JTextField para la entrada del usuario
escribirEtiqueta = new JLabel( "Escriba clave de búsqueda (entero)" );
contenedor.add( escribirEtiqueta );
escribirCampo = new JTextField( 10 );
contenedor.add( escribirCampo );
// registrar este subprograma para escuchar acciones de escribirCampo
escribirCampo.addActionListener( this );
// configurar JLabel y JTextField para mostrar los resultados
resultadoEtiqueta = new JLabel( "Resultado" );
contenedor.add( resultadoEtiqueta );
resultadoCampo = new JTextField( 20 );
resultadoCampo.setEditable( false );
contenedor.add( resultadoCampo );
// crear arreglo y llenarlo con enteros pares de 0 a 198
arreglo = new int[ 100 ];
for ( int contador = 0; contador < arreglo.length; contador++ )
arreglo[ contador ] = 2 * contador;
} // fin del método init
// buscar en arreglo el valor clave especificado
public int busquedaLineal( int arreglo2[], int clave )
{
// iterar a través de los elementos del arreglo
for ( int contador = 0; contador < arreglo2.length; contador++ )
// si el elemento del arreglo es igual al valor de la clase, devolver ubicación
if ( arreglo2[ contador ] == clave )
return contador;
return -1; // clave no encontrada
} // fin del método busquedaLineal
// obtener entrada del usuario y llamar al método busquedaLineal
public void actionPerformed( ActionEvent actionEvent )
{
// la entrada puede obtenerse también mediante escribirCampo.getText()
String claveBusqueda = actionEvent.getActionCommand();
// pasar referencia de arreglo a busquedaLineal; generalmente se pasa la referencia
// a un arreglo a un método, para buscar el objeto arreglo correspondiente
int elemento = busquedaLineal( arreglo, Integer.parseInt( claveBusqueda ) );
// mostrar el resultao de la búsqueda
if ( elemento != -1 )
resultadoCampo.setText( "Valor encontrado en el elemento " + elemento );
else
resultadoCampo.setText( "Valor no encontrado" );
} // fin del método actionPerformed
} // fin de la clase BusquedaLineal
Búsqueda binaria en un arreglo
// Búsqueda binaria en un arreglo.
import java.awt.*;
import java.awt.event.*;
import java.text.*;
import javax.swing.*;
public class BusquedaBinaria extends JApplet implements ActionListener {
JLabel escribirEtiqueta, resultadoEtiqueta;
JTextField escribirCampo, resultadoCampo;
JTextArea salida;
int arreglo[];
String pantalla = "";
// configurar GUI del subprograma
public void init()
{
// obtener panel de contenido y configurar su esquema como FlowLayout
Container contenedor = getContentPane();
contenedor.setLayout( new FlowLayout() );
// configurar JLabel y JTextField para la entrada del usuario
escribirEtiqueta = new JLabel( "Escriba clave de búsqueda (entero)" );
contenedor.add( escribirEtiqueta );
escribirCampo = new JTextField( 10 );
contenedor.add( escribirCampo );
// registrar este subprograma para escuchar acciones de escribirCampo
escribirCampo.addActionListener( this );
// configurar JLabel y JTextField para mostrar los resultados
resultadoEtiqueta = new JLabel( "Resultado" );
contenedor.add( resultadoEtiqueta );
resultadoCampo = new JTextField( 20 );
resultadoCampo.setEditable( false );
contenedor.add( resultadoCampo );
// configurar JTextArea para mostrar datos de comparación
salida = new JTextArea( 6, 60 );
salida.setFont( new Font( "Monospaced", Font.PLAIN, 12 ) );
contenedor.add( salida );
// crear arreglo y llenarlo con enteros pares de 0 a 28
arreglo = new int[ 15 ];
for ( int contador = 0; contador < arreglo.length; contador++ )
arreglo[ contador ] = 2 * contador;
} // fin del método init
// obtener entrada del usuario y llamar al método busquedaBinaria
public void actionPerformed( ActionEvent actionEvent )
{
// la entrada también puede obtenerse mediante escribirCampo.getText()
String claveBusqueda = actionEvent.getActionCommand();
// inicializar cadena pantalla para la nueva búsqueda
pantalla = "Porciones del arreglo buscadas\n";
// realizar búsqueda binaria
int elemento = busquedaBinaria( arreglo, Integer.parseInt( claveBusqueda ) );
salida.setText( pantalla );
// mostrar resultado de la búsqueda
if ( elemento != -1 )
resultadoCampo.setText( "Valor encontrado en el elemento " + elemento );
else
resultadoCampo.setText( "Valor no encontrado" );
} // fin del método actionPerformed
// método para realizar la búsqueda binaria en un arreglo
public int busquedaBinaria( int arreglo2[], int clave )
{
int inferior = 0; // índice del elemento inferior
int superior = arreglo2.length - 1; // índice del elemento superior
int medio; // índice del elemento medio
// iterar hasta que el índice inferior sea mayor que el superior
while ( inferior <= superior ) {
medio = ( inferior + superior ) / 2; // determinar índice medio
// mostrar subconjunto de elementos del arreglo utilizados en esta
// iteración del ciclo de búsqueda binaria
crearSalida( arreglo2, inferior, medio, superior );
// si clave concuerda con elemento medio, devolver su ubicación
if ( clave == arreglo[ medio ] )
return medio;
// si clave es menor que elemento medio, establecer nuevo elemento superior
else if ( clave < arreglo[ medio ] )
superior = medio - 1;
// clave mayor que elemento medio, establecer nuevo elemento inferior
else
inferior = medio + 1;
} // fin de instrucción while
return -1; // clave no encontrada
} // fin del método busquedaBinaria
// crear fila de salida mostrando subconjunto de elementos del arreglo
// que se están procesando
void crearSalida( int arreglo3[], int inferior, int medio, int superior )
{
// crear formato numérico entero de 2 dígitos
DecimalFormat twoDigits = new DecimalFormat( "00" );
// iterar a través de los elementos del arreglo
for ( int contador = 0; contador < arreglo3.length; contador++ ) {
// si contador está fuera de subconjunto actual del arreglo, anexar
// espacios de relleno al String pantalla
if ( contador < inferior || contador > superior )
pantalla += " ";
// si elemento medio, anexar elemento al String pantalla
// seguido de un asterisco (*), para indicar el elemento medio
else if ( contador == medio )
pantalla += twoDigits.format( arreglo3[ contador ] ) + "* ";
else // anexar elemento al String pantalla
pantalla += twoDigits.format( arreglo3[ contador ] ) + " ";
} // fin de instrucción for
pantalla += "\n";
} // fin del método crearSalida
} // fin de la clase BusquedaBinaria
Inicialización de arreglos bidimensionales
// Inicialización de arreglos bidimensionales.
import java.awt.Container;
import javax.swing.*;
public class InicArregloB extends JApplet {
JTextArea areaSalida;
// configurar GUI e inicializar el subprograma
public void init()
{
areaSalida = new JTextArea();
Container contenedor = getContentPane();
contenedor.add( areaSalida );
int arreglo1[][] = { { 1, 2, 3 }, { 4, 5, 6 } };
int arreglo2[][] = { { 1, 2 }, { 3 }, { 4, 5, 6 } };
areaSalida.setText( "Los valores en arreglo1 por fila son\n" );
crearSalida( arreglo1 );
areaSalida.append( "\nLos valores en arreglo2 por fila son\n" );
crearSalida( arreglo2 );
} // fin del método init
// anexar filas y columnas de un arreglo a areaSalida
public void crearSalida( int arreglo[][] )
{
// iterar a través de las filas del arreglo
for ( int fila = 0; fila < arreglo.length; fila++ ) {
// iterar a través de las columnas de la fila actual
for ( int columna = 0; columna < arreglo[ fila ].length; columna++ )
areaSalida.append( arreglo[ fila ][ columna ] + " " );
areaSalida.append( "\n" );
}
} // fin del método crearSalida
} // fin de la clase InicArreglo
Ejemplo de arreglo bidimensional
// Ejemplo de arreglo bidimensional.
import java.awt.*;
import javax.swing.*;
public class ArregloDoble extends JApplet {
int calificaciones[][] = { { 77, 68, 86, 73 },
{ 96, 87, 89, 81 },
{ 70, 90, 86, 81 } };
int estudiantes, examenes;
String salida;
JTextArea areaSalida;
// inicializar campos
public void init()
{
estudiantes = calificaciones.length; // número de estudiantes
examenes = calificaciones[ 0 ].length; // número de exámenes
// crear objeto JTextArea y adjuntarlo al subprograma
areaSalida = new JTextArea();
Container contenedor = getContentPane();
contenedor.add( areaSalida );
// crear cadena de salida
salida = "El arreglo es:\n";
crearCadena();
// llamar a los métodos minima y maxima
salida += "\n\nCalificación más baja: " + minima() +
"\nCalificación más alta: " + maxima() + "\n";
// llamar al método promedio para calcular el promedio de cada estudiante
for ( int contador = 0; contador < estudiantes; contador++ )
salida += "\nEl promedio del estudiante " + contador + " es " +
promedio( calificaciones[ contador ] ); // pasar fila arreglo calificaciones
// cambiar el tipo de letra a mostrar de areaSalida
areaSalida.setFont( new Font( "Monospaced", Font.PLAIN, 12 ) );
// colocar la cadena salida en areaSalida
areaSalida.setText( salida );
} // fin del método init
// buscar calificación mínima
public int minima()
{
// suponer que el primer elemento del arreglo calificaciones es el menor
int califBaja = calificaciones[ 0 ][ 0 ];
// iterar a través de las filas del arreglo calificaciones
for ( int fila = 0; fila < estudiantes; fila++ )
// iterar a través de las columnas de la fila actual
for ( int columna = 0; columna < examenes; columna++ )
// si la calificacion es menor que califBaja, asignarla a califBaja
if ( calificaciones[ fila ][ columna ] < califBaja )
califBaja = calificaciones[ fila ][ columna ];
return califBaja; // devolver la calificación más baja
} // fin del método minima
// buscar calificación máxima
public int maxima()
{
// suponer que el primer elemento del arreglo calificaciones es el mayor
int califAlta = calificaciones[ 0 ][ 0 ];
// iterar a través de las filas del arreglo calificaciones
for ( int fila = 0; fila < estudiantes; fila++ )
// iterar a través de las columnas de la fila actual
for ( int columna = 0; columna < examenes; columna++ )
// si la calificación es mayor que califAlta, asignarla a califAlta
if ( calificaciones[ fila ][ columna ] > califAlta )
califAlta = calificaciones[ fila ][ columna ];
return califAlta; // devolver la calificación más alta
} // fin del método maxima
// determinar la calificación promedio para un estudiante (o conjunto de calif.)
public double promedio( int conjuntoDeCalificaciones[] )
{
int total = 0; // inicializar el total
// sumar calificaciones para un estudiante
for ( int cuenta = 0; cuenta < conjuntoDeCalificaciones.length; cuenta++ )
total += conjuntoDeCalificaciones[ cuenta ];
// devolver el promedio de calificaciones
return ( double ) total / conjuntoDeCalificaciones.length;
} // fin del método promedio
// crear cadena de salida
public void crearCadena()
{
salida += " "; // se usa para alinear los encabezados de columnas
// crear encabezados de columnas
for ( int contador = 0; contador < examenes; contador++ )
salida += "[" + contador + "] ";
// crear filas/columnas de texto que representan el arreglo calificaciones
for ( int fila = 0; fila < estudiantes; fila++ ) {
salida += "\ncalificaciones[" + fila + "] ";
for ( int columna = 0; columna < examenes; columna++ )
salida += calificaciones[ fila ][ columna ] + " ";
}
} // fin del método crearCadena
} // fin de la clase ArregloDoble
Los ejercicios utilizados en este post están basados en ejemplos del libro Cómo programar en Java de Deitel, y por lo tanto están bajo la licencia que esta editorial disponga.
56 Comentarios | deja el tuyo





necesito saber como programar en java del metodo simplex alguien tiene idea
Oye, hay una pagina muy buena; el problema es que no me acuerdo en donde lo econtre. Pero hay otros en dode bienen sobre lo que pides…. Solo dejame investigar y encontrarlo para luego enviatelo.
Jejejeje Salu2 (ojO)
Checkito buena onda tengo el mismo problema que jahi sera que me podias pasar el link de la pagina
hey la repuesta a todas su inquietudes estan aqui j(avaya.com)
Alguien tiene el codigo para capturar un vector de string, osea que no defina sus valores previamente como Ana, juan, mas bien que los capture desde pantalla?
algunos programas sobretodo los aplee no me corren que tengo que hacer gracias por la ayuda