(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

Descargar código fuente

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

Descargar código fuente

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

Descargar código fuente

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

Descargar código fuente

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

Descargar código fuente

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

Descargar código fuente