LenProg F05

Fascículo
Lenguaje de
Programación
Semestre 2
Lenguaje de programación
Lenguaje de
programación Semestre 2
Tabla de contenido Página
Introducción 1
Conceptos previos 1
Mapa conceptual Fascículo 5 2
Logros 3
Arrays de Una Dimensión. Utilizar sólo un Inicializador 3
Utilizar la palabra clave "new" y un Inicializador 8
Trabajar con un array uni-dimensional 10
Algoritmos de búsqueda de datos en vectores y métodos de
Ordenamiento 12
Resumen 24
Bibliografía recomendada 24
Nexo 25
Seguimiento al autoaprendizaje 27
Anexo 5 28
Créditos: 3
Tipo de asignatura: Teórica – Práctico
Semestre 2
Copyright©2008 FUNDICIÓN UNIVERSITARIA SAN MARTÍN

Facultad de Universidad Abierta y a Distancia,
“Educación a Través de Escenarios Múltiples”
Bogotá, D.C.
Prohibida la reproducción total o parcial sin autorización

por escrito del Presidente de la Fundación.
La redacción de este fascículo estuvo a cargo de

JAIME ALBERTO GUTIERREZ
Docente tutor – Programa de Ingeniería de Sistemas a Distancia.
Sede Bogotá, D.C.
Orientación a cargo de;

ESPERANZA MARTINEZ G.
Directora Nacional de Material Educativo.
Diseño gráfico y diagramación a cargo de

SANTIAGO BECERRA SÁENZ
ORLANDO DÍAZ CÁRDENAS
Impreso en: GRÁFICAS SAN MARTÍN

Calle 61A No. 14-18 - Tels.: 2350298 - 2359825
Bogotá, D.C., Febrero de 2010
Lenguaje de
programación Semestre 2
Lenguaje de programación 1
Introducción
Uno de los grandes problemas en la computación moderna, lo constituye
la organización de la información y las capacidades que se deben tener en
cuenta para acceder no sólo a este proceso, sino al desarrollo de una serie
de tareas complementarias a esta, que permitan a los desarrolladores de
aplicaciones hacer que el acceso a los datos sea limpio, transparente y
eficiente. En este contexto, es donde la algoritmia y los métodos tradicio-
nales de optimización entran a jugar un papel fundamental en la definición
de nuevas tareas operativas para la construcción de funcionalidades de
búsqueda y organización de datos que ayuden a que la información
relevante para los usuarios sea manejada con propiedad y cumpla sus
objetivos.
Hasta el momento hemos visto programas que almacenan los datos de

manera individualizada por variable, es decir, que cada dato para ser
accedido en la memoria, requiere ser puesto en una variable en la cual
sólo él puede vivir. El objetivo en este fascículo es explorar otros tipos de
datos, que por supuesto, basados en el uso de los objetos, permitan
almacenar grandes cantidades de datos con propósitos específicos.
Conceptos previos
Es fundamental para el desarrollo de los temas de este fascículo, realizar
un repaso del manejo de las clases, los métodos y el diseño de estos
últimos. Igualmente, es clave tener claridad frente a los conceptos de
herencia, retorno de métodos e instanciación de objetos.
Fascículo No. 5 Lenguaje de

Semestre 2 programación
Mapa conceptual fascículo 5
Fascículo No. 5
Lenguajede
programación
2 Semestre 2
Logros
Al finalizar el estudio del presente fascículo, el estudiante estará en capacidad

de:
 Crear arreglos unidimensionales y emplearlos para almacenar en una varia-

ble datos multitipo y monotipo.
 Emplear la instrucción new como herramienta para la instanciación de obje-
tos y la definición de nuevos elementos en la ejecución de una aplicación de
computadora.
 Implementar algoritmos de búsqueda y utilizarlos para localizar información
puntual dentro de un arreglo de datos primitivos o de objetos.
Arrays de Una Dimensión. Utilizar sólo un Inicializador

A medida que se van desarrollando las aplicaciones escritas en el lenguaje
Java, ya se tiene a nuestra disposición el concepto del dato primitivo como
mecanismo para el almacenamiento de datos de manera individual, de los
ocho tipos primitivos existentes (byte, short, char, int, float, double, long y
boolean). No obstante, gracias al concepto del Javabean o value object,
sabemos que existen datos de tipo abstracto o de tipo de clase que per-
miten almacenar infinitud de registros, en virtud de la cantidad de atributos
o variables de instancia establecidos en dichas clases creadas por el pro-
gramador. ¿Pero qué ocurre, cuando se hace necesario almacenar gran-
des cantidades de datos de un tipo o incluso de varios tipos, como lo que
podría ser un listado enorme de números o una colección muy grande de
cadenas de caracteres? Ejemplos puntuales se pueden encontrar en el
contenido de una agenda telefónica o en una tabla de datos de un proceso
estadístico.
En este punto, Java y los demás lenguajes de programación orientados a

objetos brindan el concepto de la Estructura de Datos. Esta permite agru-
par grandes cantidades de datos de un mismo o de varios tipos en una
sola variable, que gracias a operaciones implementadas por el desarro-
llador, facilitan la manipulación de dichos datos a través de operaciones de
Fascículo No. 5
Semestre 2 3 Lenguaje de
programación
registro (creación de nuevos datos), eliminación (borrado o retiro de un

dato de la estructura) y en el caso que nos compete en este fascículo,
también de búsqueda y de organización, en aras de aprovechar dichos
elementos para un posterior proceso de utilización de estos elementos de
almacenamiento.
Java ofrece muchas estructuras de datos con múltiples propósitos. En

este fascículo se tratará la estructura básica de almacenamiento, conocida
como arreglo o Array, la cual visualmente puede ilustrarse como lo
muestra la siguiente figura (5.1):
Figura 5.1
Ilustración de un arreglo simple de datos (en este caso datos de tipo entero (int)).
Todo arreglo siempre tiene tres características:

 Una dimensión, es decir, una longitud o cantidad total de datos que
lo forman. En el caso visto en la figura 5.1, se tiene un arreglo de ente-
ros de 6 posiciones de longitud.
 Una indización, que indica la posición de cada elemento dentro de la
estructura. En la figura 5.1 se encuentra, por ejemplo, que el dato 33 es-
tá ubicado tanto en la posición 1 como en la posición 5 del arreglo. Pe-
ro no son el mismo dato, son más bien datos idénticos en posiciones
diferentes.
 Un tipo, que define qué clases de datos se van a almacenar en él.
Cuando no tenemos certeza de si los datos van a ser del mismo tipo
para todas las posiciones, lenguajes como Java ofrecen la maravilla de
contar con arreglos de tipo Object (objeto) para poder almacenar en las
posiciones de un arreglo cualquier tipo dato, incluyendo por supuesto
datos de tipo objeto.
Fascículo No. 5
Lenguajede
programación
4 Semestre 2
Con base en esto, Java, ofrece la declaración de cualquier nuevo array,

utilizando para ello el operador de instanciación new, estudiado anterior-
mente, para declarar cualquier nuevo objeto de cualquier tipo de clase
desarrollada por nosotros o que ya previamente exista en la API del JDK.
Si se quisiera crear un arreglo como el del ejemplo, debemos instanciar un

nuevo array o arreglo de 6 posiciones, mediante la instrucción de instan-
ciación:
int [] arregloNumerosEnteros = new int[6];
Donde los corchetes ([ ]) le indican al compilador que debe crearse un

arreglo de un tipo específico de datos (int). El uso del constructor int []
con un valor paramétrico entre los corchetes (6) le indica al compilador
que en tiempo de ejecución debe construirse un arreglo de 6 posiciones y
nada más.
Ahora surge un segundo cuestionamiento ¿Si con la instrucción de

instanciación vista anteriormente se ha creado un nuevo arreglo? ¿Qué
debo hacer ahora con él? Fundamentalmente debemos usarlo y para ello
existen tres procesos claves:
a. Cargar de datos el arreglo (es decir, poblar todas sus posiciones con
datos del tipo de la declaración de la cual fue hecho el arreglo).
b. Navegar el arreglo de arriba hacia abajo y como sea necesario hacerlo
para poder ubicar sus datos y hacer algún proceso algorítmico espe-
cífico con ellos.
c. Finalmente, si es necesario y conveniente, acceder al arreglo y sacar
sus datos ya sea para imprimirlos o para usarlos en algún proceso
complejo de cálculo que involucre su uso.
Fascículo No. 5
programación
La siguiente pregunta es ¿cómo navegamos ese arreglo? La respuesta es

muy sencilla: gracias a la ayuda de tres estructuras de repetición condicio-
nal (for, while y do-while) las cuales se han diseñado para automatizar
tareas que pueden ser muy complejas y repetitivas. Gracias al concepto
del contador usado por estas instrucciones se puede acceder a las
posiciones del arreglo con el fin de ubicar sus registros y hacer algo útil
con ellos.
Ahora se explica la implementación de una Clase encargada de leer tres

tipos de arreglos: (cadenas de caracteres (String), reales (double) y
enteros (int)) y se determina en la implementación puntual bajo Java la
creación de los tres procesos sobre los cuales se hizo alusión en líneas
anteriores (creación, cargado de datos y navegación exploratoria del
arreglo).
(Ver Anexo 5 – implementación de métodos para la lectura e impresión de arreglos de datos
primitivos).
Un programa como el descrito en el anexo 5 se encargará:
a) Primero de solicitar el número total de elementos que van a formar los

tres arreglos implementados. Dicho valor se pasa como argumento al
método constructor, el cual se encarga de la instanciación de las tres
estructuras de datos.
Figura 5.2
Lectura de datos para la creación de un nuevo arreglo en tiempo de ejecución.
b) Invocar el método encargado de la lectura. En donde se mostró el códi-

go de dicho método, éste utiliza un ciclo repeticional para (for) con el fin
de solicitar la lectura elemento a elemento del arreglo. Esto no quiere
Fascículo No. 5
Lenguajede
programación
6 Semestre 2
decir que siempre tengan que leerse los datos manualmente. Si datos
se leen de un archivo plano, dicho archivo debe abrirse y utilizar el ciclo
for leer línea a línea del archivo hasta que ya no hayan más líneas que
leer en éste. El punto es que gracias al ciclo repetitivo, se automatiza la
lectura y se garantiza que todos los elementos del arreglo queden
debidamente almacenados en las posiciones.
Figura 5.3
Solicitud por parte del programa dentro
de un ciclo de repetición de todos los
elementos que forman el arreglo.
c) Una vez los datos se han almacenado en el arreglo gracias al for, se

puede proceder a procesarlos de la manera que se considere más apro-
piada. Por ejemplo, sumar sus valores, imprimirlos, extraerlos cada n
posiciones pares o impares, etc. Todo depende de la lógica de negocio
establecida para el desarrollo del problema quien tenga que hacer uso
de dichos elementos.
Figura 5.4
Proceso manejado con el arreglo. En
este caso, el proceso hace alusión a la
impresión los datos en él contenidos.
Fascículo No. 5
programación
5.1
Con base en el ejemplo de creación de arreglos visto anteriormente,

elabore las siguientes implementaciones:
1. Cree una clase Java para leer un arreglo de datos booleanos (valores
true y false) y que imprima el arreglo, pero que en vez de que salgan
los datos true y false en la impresión, aparezcan las letras V por cada
valor true y F por cada valor false.
2. Construya una clase Java que cree un arreglo de caracteres (chars) y
lo pueble con las letras del alfabeto de manera automática.
Recuerde utilizar el concepto del código ASCII, el uso de casting y el
manejo de la sentencia repeticional for o while para poblar el arreglo
mediante el uso de un método, para que el usuario no tenga que
digitar las 27 letras del alfabeto (recuerde que se debe incluir la Ñ
junto las con las 26 letras estándar del alfabeto occidental latino).
Utilizar la palabra clave "new" y un Inicializador

El uso de la palabra new como operador de instanciación de objetos es
una herramienta fundamental para la creación de nuevos elementos a lo
largo del ciclo de vida de una aplicación. Debido a ella se realiza a nivel de
computación, el proceso de reservación de memoria necesario para que la
aplicación pueda definir los tamaños específicos en bytes y kilobytes que
habrán de ser consumidos por los recursos (variables, constantes e
instrucciones) desarrolladas a lo largo del código de todos los métodos y
atributos definidos en la clase. Es importante tener en cuenta que el pro-
ceso de reservación de memoria debe realizarse de acuerdo con la si-
guiente estructura de declaración de instrucciones:
Constructor nombreNuevoObjeto = new Constructor();

o
Constructor nombreNuevoObjeto = new
Constructor(Párametros del Constructor);
Y en este caso, la declaración de nuevos arreglos
TipoDatoDelArreglo [] nombreNuevoArreglo = new

TipoDatoArreglo[dimensiones];
Fascículo No. 5
Lenguajede
programación
8 Semestre 2
Si, si se desea crear un arreglo de números enteros de 20 posiciones,

debemos escribir:
int [] arregloDatosEnteros = new int [20];
Igualmente, si se quiere construir un arreglo de cadenas de caracteres de

n posiciones, entonces se deberá generar una instanciación de la forma:
String [] coleccionCadenasCaracteres = new String[n];
Donde n es una variable previamente declarada y que en algún punto de

los métodos de la clase fue debidamente almacenada con un valor leído
desde una fuente externa al programa (como por ejemplo el teclado o de
un archivo de texto, etc.).
Lo más importante en todos estos procesos, es que ejecutando correcta-

mente el método constructor de la clase a través del operador new, el
nuevo objeto instanciado no puede tener una referencia nula (null), ya que
el cargador de clases de la máquina virtual se encarga de cargar la
referencia en memoria de dicho objeto y permitir su validación durante el
proceso de ejecución en el ciclo de vida de la aplicación Java quien haga
uso de dichos objetos. Una vez el objeto ha sido utilizado, el Garbage
Collector (o proceso recolector de basura) de la máquina virtual se
encarga de eliminar automáticamente la referencia de memoria de dicho
objeto, con el fin de liberar espacio para otros objetos y con ello mejorar el
desempeño de las aplicaciones Java actualmente bajo ejecución en la
máquina virtual.
5.2
1. Desarrolle un conjunto de Aplicaciones Java para crear una ensalada

de frutas de objetos. Cree una clase para definir una piña, una pera,
un mango, un banano, una manzana, una sandía y un melón. Luego,
utilizando el concepto de asociación visto en el fascículo II, realice el
proceso de creación de la ensalada de frutas virtual y usando la
Fascículo No. 5
programación
instanciación como base para este ejercicio, indique cuántas frutas

forman la ensalada, imprima que la ensalada ha sido armada e invite
al usuario a comérsela. Capture una excepción para la creación de
la ensalada de frutas, si alguna de ellas se encuentra en mal estado
(considere por lo tanto en el diseño de cada clase de cada fruta, un
atributo para manejar el estado de vencimiento de la fruta).
2. Desarrolle una aplicación Java que permita crear un arreglo de
números reales. Implemente dentro de dicha aplicación un método
que se encargue de calcular el inverso de cada número presente en
el arreglo, entendiendo por inverso, como el cociente de 1 entre el
número actual. Así, si ingresan los valores 4,1,2,3,5, el método debe
calcular 0.25,1,0.5,0.333333333,0.2.
3. Desarrolle una clase Java que lea un arreglo de caracteres (char) y a
partir de dicho arreglo cree una nueva cadena que contenga los
caracteres impresos al revés. Así si ingresan al arreglo los caracteres
a,v,i,o,n, el Sistema imprime la cadena noiva.
4. Desarrolle una clase Java que lea dos arreglos de números reales y
calcule el producto entre las posiciones equivalentes de cada
arreglo, permitiendo almacenar dicho valor en un tercer y nuevo
arreglo, tal como lo ilustra la siguiente figura:
Trabajar con un array uni-dimensional

Como en explicó en líneas anteriores, el principal fundamento del proceso
de trabajo con arreglos lo constituye la capacidad de navegar a través de
sus elementos, con el fin de poder ubicarlos por medio de su indizador
[índice], el cual la forma cómo se accede a las posiciones contenidas en la
estructura del arreglo. Para ello, es factible utilizar las tres estructuras
repeticionales como punto de partida para el desarrollo de dicho recorrido.
El siguiente programa es una aplicación Java que crea un arreglo de nú-
meros enteros y puebla sus posiciones con números aleatorios mediante
el método random() del objeto Math. Es importante observar en este
punto se aplica nuevamente el concepto del casting, para poder asignar
los datos al arreglo, dado que el método random retorna un valor de tipo
real (double).
Fascículo No. 5
Lenguajede
programación
10 Semestre 2
Analice el código de la aplicación.

(Ver Anexo 5 – Implementación de una clase para el manejo de datos de un arreglo
unidimensional)
Observe su funcionamiento:
Figura 5.5
Configuración de la cantidad de datos del arreglo.
Figura 5.6
Despliegue del arreglo usando un ciclo while (ejecute mientras).
Figura 5.7
Despliegue del arreglo usando un ciclo do-while (repita mientras).
Fascículo No. 5
programación
Figura 5.8
Despliegue del arreglo usando un ciclo for (para).
Considérese ahora el siguiente problema: se tiene un conjunto de datos

reales sobre los cuales se desea calcular su sumatoria, su promedio, su
productoria geométrica y finalmente determinar cuál es el elemento más
grande de todos. Debemos por tanto, considerar la elaboración, como en
todos los problemas que hemos tratado, de construir un método por cada
problema, asumiendo el diseño de variables, procesos y retornos:
FUNCIONALIDAD A IMPLEMENTAR: SUMATORIA
Retorno Un número real (la sumatoria de los valores)
Nombre del Método calcularSumaElementosArreglo
Parámetros El arreglo de datos del cual queremos sumar sus elementos.
FUNCIONALIDAD A IMPLEMENTAR: PROMEDIO

Retorno Un número real (el promedio de los valores del arreglo)
Nombre del Método calcularPromedioDatosArreglo
FUNCIONALIDAD A IMPLEMENTAR: PRODUCTORIA

Retorno Un número largo (long, puesto que si los valores de los
números reales son muy grandes, la productoria de valores
enormes puede generar un dato de mayor capacidad que la
que un double puede soportar)
Nombre del Método calcularProductoriaElementosArreglo
FUNCIONALIDAD A IMPLEMENTAR: OBTENER EL DATO MÁS GRANDE DEL ARREGLO

Retorno Un número real (el número que queremos determinar que es el
más grande del arreglo)
Nombre del Método obtenerElementoMasGrandeArreglo
Fascículo No. 5
Lenguajede
programación
12 Semestre 2
Ahora observe la implementación de la solución.

(Ver Anexo 5 – Clase Java para ilustrar el manejo de métodos que emplean arreglos de datos).
Algoritmos de búsqueda de datos en vectores y métodos

de ordenamiento
En ocasiones se hace necesario localizar datos dentro de un arreglo,
puesto que ese es el principio básico que todo sistema de búsqueda de
información debe implementar como requerimiento funcional mínimo.
Debe tenerse en cuenta que la búsqueda es un proceso de comparación
que debe verificar si el dato se encuentra efectivamente o no dentro de la
estructura de datos, pero dado que un arreglo podría tener una cantidad
enorme de elementos, sería altamente ineficiente realizar la comparación
por todas las posiciones del arreglo de datos. Por ello, el principio reza
que una vez el dato ha sido encontrado debe detenerse el ciclo y salirse
del flujo de control del ciclo de búsqueda del dato.
Un algoritmo de búsqueda es aquél que está diseñado para localizar un

elemento concreto dentro de una estructura de datos. Consiste en
solucionar un problema de existencia o no de un elemento determinado en
un conjunto finito de elementos, es decir, si el elemento en cuestión
pertenece o no a dicho conjunto, además de su localización dentro de
éste. Este problema puede reducirse a devolver la existencia de un número
en un vector.
Las búsquedas de datos pueden realizarse mediante dos procesos: el

lineal y el binario.
a) Búsqueda Lineal: se utiliza cuando el contenido del vector no se en-

cuentra o no puede ser ordenado. Consiste en buscar el elemento
comparándolo secuencialmente (de ahí su nombre) con cada elemento
del arreglo hasta que éste se encuentre, o hasta que se llegue al final
Fascículo No. 5
programación
del arreglo. La existencia se puede asegurar desde el momento que el

elemento es localizado, pero no podemos asegurar la no existencia
hasta no haber analizado todos los elementos del arreglo. A continua-
ción se muestra el pseudocódigo del algoritmo:
Algoritmo BusquedaLineal;
//Variables
vector []: Arreglo de datos (independientes del tipo)
longitud: Entero; //Tamaño del arreglo
dato: Cualquier tipo de dato; //Elemento a localizar
posicion: Entero; //Contador para recorrer el arreglo (indizador)
Inicio
posición = 0;
Mientras (posicion < longitud)
Inicio mientras
Si (vector[posicion] == dato)
Inicio Si
Devolver Verdadero o la posición
Parar el ciclo;
Fin Si;
Fin mientras;
Fin algoritmo.
Implementándolo en Java, tendríamos el siguiente método:

//Método para implementar la búsqueda lineal. Si encuentra el objeto,
//devuelve true, de lo contrario, false
public boolean buscarElementoAlgoritmoLineal (int [] datos, int
elementoABuscar)
{
int i = 0;
boolean estaEnElArreglo = false;
try
{
for (i = 0; i < datos.length; i++)
{
//Recorremos el arreglo y preguntamos si
//está en el elemento
//en alguna de sus posiciones
if (datos[i] == elementoABuscar)
{
estaEnElArreglo = true;
//Si lo encontró paramos el ciclo
break;
}
}//Fin del for
}
Fascículo No. 5
Lenguajede
programación
14 Semestre 2
catch (Exception errorBusquedaLineal)

{
JOptionPane.showMessageDialog(null,"Error
encontrando el dato: " +
errorBusquedaLineal.toString());
errorBusquedaLineal.printStackTrace();
return (false);
}
return (estaEnElArreglo);
}
Con esto, se optimiza el tiempo y se determina qué debe indicar el

sistema en caso de encontrarlo. Un valor de true indicaría que el elemento
fue localizado. Si después de buscar en todas las posiciones del arreglo, el
dato no se encuentra, el valor false debe dar la certeza de que dicho
elemento no se encuentra ubicado en ninguna parte de la estructura.
b) Búsqueda Binaria (Proceso de Divide y Vencerás): se utiliza cuando

el vector en el que queremos determinar la existencia o no de un ele-
mento está ordenado, o puede estarlo. Este algoritmo reduce el tiempo
de búsqueda considerablemente, ya que disminuye exponencialmente
con el número de iteraciones.
Para implementar este algoritmo se compara el elemento a buscar con un

elemento cualquiera del arreglo (normalmente el elemento central), si el
valor de éste es mayor que el del elemento buscado, se repite el proce-
dimiento en la parte del arreglo que va desde el inicio de éste hasta el
elemento tomado, en caso contrario se toma la parte del arreglo que va
desde el elemento tomado hasta el final. De esta manera obtenemos
intervalos cada vez más pequeños, hasta que se obtenga un intervalo
indivisible, con el elemento buscado como elemento central. Si el elemento
no se encuentra dentro de este último entonces se deduce que el
elemento buscado no se encuentra en el arreglo.
Fascículo No. 5
programación
A continuación se presenta el pseudocódigo del algoritmo, tomando como

elemento inicial el elemento central del arreglo:
Algoritmo BusquedaBinaria;
//Variables
vector []: Cualquier tipo de dato; //Arreglo en el que se desea buscar el
elemento
longitud: Entero; //Tamaño del arreglo
dato: Cualquier tipo de dato; //Elemento que se va a buscar
rangoInferior: Entero; //Límite inferior del intervalo
rangoSuperior: Entero;//Límite superior del intervalo
rangoCentral: Entero; //Posición central del intervalo
Inicio
rangoInferior = 0;
rangoSuperior = longitud;
Ejecute mientras (rangoInferior <= rangoSuperior)

Inicio mientras
rangoCentral = (rangoSuperior + rangoInferior)/2;
Si (vector[rangoCentral] == dato)
Inicio Si
Devolver verdadero o la posición
Parar el ciclo;
Fin Si
DLC
Si (dato < vector[rangoCentral])
Inicio Si
rangoSuperior = rangoCentral - 1;
Fin Si
DLC
Inicio DLC
rangoInferior = rangoCentral + 1;
Fin DLC
Fin ejecute mientras;
//No se encontró el elemento

retornar (falso);
Fin.
Su correspondiente implementación bajo Java, sería:

//Método para implementar la búsqueda lineal. Si encuentra el
//objeto, devuelve true, de lo contrario, false
public boolean buscarElementoAlgoritmoBinario (int [] datos, int
elementoABuscar)
{
int rangoInferior = 0;
int rangoSuperior = 0;
int rangoCentral = 0;
boolean estaEnElArreglo = false;
Fascículo No. 5
Lenguajede
programación
16 Semestre 2
try
{
rangoInferior = 0;
rangoSuperior = datos.length;
while (rangoInferior <= rangoSuperior)

{
//Obtenemos el pivote central
rangoCentral = (rangoInferior +
rangoSuperior)/2;
if (datos[rangoCentral] ==
elementoABuscar)
{
estaEnElArreglo = true;
break;
}
else
if (elementoABuscar < datos[rangoCentral])
{
//Si el elemento a buscar está bajo el
//rango inferior
//entonces el rango superior se
//vuelve el rango central
//mas 1, para buscar en rango del
//otro lado
rangoSuperior = rangoCentral - 1;
}
else
{
//Buscamos en el otro lado del
//arreglo
rangoInferior = rangoCentral + 1;
}
}//Fin del while
}//fin del try
catch (Exception errorBusquedaLineal)

{
encontrando el dato: " +
errorBusquedaLineal.toString());
errorBusquedaLineal.printStackTrace();
return (false);
}
return (estaEnElArreglo);
}
Fascículo No. 5
programación
Figura 5.9
Funcionamiento del algoritmo de búsqueda binaria.
Otro proceso, complementario a la búsqueda de registros dentro de una

estructura, y es fundamental para la definición de la forma como se trabaja
con los datos, lo constituye el ordenamiento, como veíamos en los
conceptos relacionados con el tema de búsqueda, pueden ayudar
muchísimo al proceso de localización de datos. Si se tiene, por ejemplo,
un arreglo de números, y primero procedemos a organizarlos de menor a
mayor, no se hace necesario implementar un método para determinar cuál
es el dato mayor y el menor del arreglo, puesto que dichos valores
estarían convenientemente ubicados, en la última y primera posición del
arreglo ordenado, respectivamente. Dado que el ordenamiento, en virtud
del tamaño de un arreglo puede ser un proceso muy largo y dispendioso,
algorítmicamente se han diseñado muchos métodos probados que
Fascículo No. 5
Lenguajede
programación
18 Semestre 2
permiten realizar este proceso con base en ciertos criterios, tales como la
cercanía de los elementos dentro del arreglo o el uso de un recurso como
podría ser un pivote central que permita intercambiar los datos, disminu-
yendo significativamente el tiempo de ejecución del programa de ordena-
ción.
Ahora, se aborda la esencia de los métodos de ordenamiento y se

consideran los criterios de su implementación.
a) Ordenamiento interno: Se lleva a cabo completamente en memoria

principal. Todos los objetos que se ordenan caben en la memoria
principal de la computadora.
b) Ordenamiento externo: No cabe toda la información en memoria prin-
cipal y es necesario ocupar memoria secundaria. El ordenamiento
ocurre transfiriendo bloques de información a memoria principal en
donde se ordena el bloque y este es regresado, ya ordenado, a la
memoria secundaria.
Hay métodos muy simples de implementar que son útiles en los casos en
donde el número de elementos a ordenar no es muy grande. Por otro lado
hay métodos sofisticados, más difíciles de implementar pero que son más
eficientes en cuestión de tiempo de ejecución. La eficiencia de los
algoritmos se mide por el número de comparaciones e intercambios que
tienen que hacer, tomándose a n como el número de elementos que tiene
el arreglo a ordenar.
Veamos algunos de los métodos existentes:
a) Algoritmo de Ordenamiento por Burbuja: El Ordenamiento de Burbuja

(Bubble Sort en inglés) es un sencillo algoritmo de ordenamiento.
Funciona revisando cada elemento de la lista que va a ser ordenada con
Fascículo No. 5
programación
el siguiente, intercambiándolos de posición si están en el orden equi-

vocado. Es necesario revisar varias veces toda la lista hasta que no se
necesiten más intercambios, lo cual significa que la lista está ordenada.
Este algoritmo obtiene su nombre de la forma con la que suben por la
lista los elementos durante los intercambios, como si fueran pequeñas
"burbujas".
Debido a la cantidad de veces que recorre la lista su eficiencia no es muy

buena, por lo que se recomiendan otros métodos para realizar el ordena-
miento, aunque sí tiene la gran ventaja de permitir la comprensión del
mecanismo de implementación de un algoritmo que debe realizar compa-
raciones y procesos de recorrido lineal, lo que ayuda en gran medida a
comprender la esencia del funcionamiento de los ciclos repetitivos y la
estructuras de decisión como la que él utiliza. También es conocido como
el método del intercambio directo. Dado que sólo usa comparaciones para
operar elementos, se lo considera un algoritmo de comparación, siendo el
más sencillo de implementar.
Veamos su implementación:
//Método de ordenamiento por burbuja
public int [] ordenarArregloPorBurbuja (int [] datos)
{
int i = 0;
int j = 0;
int temporal = 0;
try
{
arregloNumeros = datos;
//Recorremos la totalidad de elementos del arreglo
for (i = 0; i < arregloNumeros.length; i++)
{
//Por cada elemento evaluado, recorremos el
arreglo nuevamente
//comparando cada elemento con el actual,
con el fin de buscar el más
//grande y montarlo en una burbuja para que
suba a la siguiente
//posición, de manera que podamos bajar el
encontrado
Fascículo No. 5
Lenguajede
programación
20 Semestre 2
//a la posición actual
for (j = 0; j < arregloNumeros.length-1; j++)

{
if (arregloNumeros[j] >
arregloNumeros[j+1])
{
//Guardamos el grande en un
temporal
temporal = arregloNumeros[j];
//Hacemos el intercambio o
//swapping
arregloNumeros[j] =
arregloNumeros[j+1];
//Asignamos a la siguiente posición

//el temporal para subir el dato más
// grande en la burbuja
arregloNumeros[j+1] = temporal;
}//Fin del if de intercambio
}//Fin del for interno
}//Fin del for externo
//Asignamos al arreglo ordenado el resultado

arregloOrdenado = arregloNumeros;
}//fin del try
catch (Exception errorOrdenamiento)

{
JOptionPane.showMessageDialog(null,"Error en el
método de ordenamiento: " +
errorOrdenamiento.toString());
errorOrdenamiento.printStackTrace();
}
return (arregloOrdenado);
}
b) Método de Ordenamiento por Inserción: El ordenamiento por

inserción (insertion sort en inglés) es una manera muy natural de
ordenar para un ser humano, y puede usarse fácilmente para ordenar
un mazo de cartas numeradas en forma arbitraria. Requiere (n2)
operaciones para ordenar una lista de n elementos. Inicialmente se
tiene un solo elemento, que obviamente es un conjunto ordenado.
Después, cuando hay k elementos ordenados de menor a mayor, se
toma el elemento k+1 y se compara con todos los elementos ya
Fascículo No. 5
programación
ordenados, deteniéndose cuando se encuentra un elemento menor

(todos los elementos mayores han sido desplazados una posición a la
derecha). En este punto se inserta el elemento k+1 debiendo
desplazarse los demás elementos.
Esto quiere decir que cada vez que se encuentra un elemento menor
comparado con el elemento actual, los demás elementos a la derecha
deben ser desplazados hasta que quede el espacio para insertar el
elemento comparado que era más grande que él. De esta manera se
reducen la cantidad de intercambios que consumen más tiempo de
computación que el proceso de desplazamiento, el cual es solo una
asignación y por lo tanto no requiere del uso de la conmutación de tres
variables como si ocurre en el algoritmo de ordenamiento por burbuja.
Para entenderlo mejor, veamos el siguiente ejemplo, en el cual 33 debe

ser insertado entre 27 y 48, y por lo tanto 48, 60 y 97 deben ser
desplazados.
En la implementación computacional, el elemento k+1 va comparándose

de atrás hacia adelante, deteniéndose con el primer elemento menor.
Simultáneamente se van haciendo los desplazamientos.
Analicemos ahora su implementación bajo Java:

public int [] ordenarArregloPorInsercion (int [] datos)
{
int i = 0;
Fascículo No. 5
Lenguajede
programación
22 Semestre 2
int j = 0;
int temporal = 0;
try
{
arregloNumeros = datos;
//Recorremos la totalidad de elementos del arreglo
//Empezando por 1
for (i = 1; i < arregloNumeros.length; i++)
{
//Obtenemos el elemento i+1
temporal = arregloNumeros[i];
//Recorremos el arreglo en forma

//descendente
//para comparar el temporal con los
//restantes elementos
for (j = i-1; j >= 0 && arregloNumeros[j] >
temporal; j--)
{
//Hacemos el desplazamiento
arregloNumeros[j+1] =
arregloNumeros[j];
}//Fin del for interno
//Reasignamos al siguiente número el

//temporal
//es decir, insertamos el número
arregloNumeros[j+1] = temporal;
}//Fin del for externo
//Asignamos al arreglo ordenado el resultado

arregloOrdenado = arregloNumeros;
}//fin del try
catch (Exception errorOrdenamiento)

{
JOptionPane.showMessageDialog(null,"Error en el
método de ordenamiento: " +
errorOrdenamiento.toString());
errorOrdenamiento.printStackTrace();
}
return (arregloOrdenado);
}
5.3
Revisando la implementación del algoritmo de burbuja, rediseñe las

instrucciones de su desarrollo para ordenar el arreglo en orden inverso.
Piense que el criterio más importante para esto es preguntar el caso
opuesto a lo que actualmente el algoritmo está desarrollando.
Implemente una clase Java que reciba un arreglo de números reales
Fascículo No. 5
programación
(donde el valor decimal también sea tenido en cuenta) e implemente el

algoritmo de burbuja para realizar la organización de sus datos.
Finalmente, implemente un segundo método que reciba el arreglo de
reales organizado e imprima solo aquellos números del arreglo que
sean pares.
Como se estudió en este fascículo, el desarrollo de aplicaciones con mayor

nivel de estructuración de sus procesos, como lo pueden constituir los
métodos de búsqueda y ordenamiento, comienzan a mostrar el uso de los
algoritmos como mecanismo para obtener resultados de valor agregado
para los usuarios.
Así pues, cuando se observan programas de computadora, como por

ejemplo el Outlook que maneja listas de contactos y correos electrónicos,
y pulsamos en la bandeja de entrada el botón de ordenamiento por nom-
bre, destinatario, mensaje o fecha de envío, lo que se hace intrínsecamente
es utilizar uno de estos algoritmos de ordenamiento vistos en este
fascículo con el objeto de dar un criterio de organización a estos registros
y con ello ayudar al usuario a localizar mucho más rápido sus registros.
La búsqueda también es fundamental puesto que gracias a ella, el usuario

puede ubicar registros extraviados y que pueden estar dispersos en una
cantidad de datos que, a medida que van creciendo, van haciendo cada
vez más compleja la ubicación y recuperación de los mismos.
VILLALOBOS S., J. A., & Casallas G., R. (2006). Fundamentos de

Programación - Aprendizaje Activo basado en casos. México, D.F.:
PEARSON, Prentice Hall.
Fascículo No. 5
Lenguajede
programación
24 Semestre 2
Deitel, H. M., & Deitel, P. J. (2004). CÓMO PROGRAMAR EN JAVA. México,

D.F.: PEARSON EDUCATION.
Format, E. C. (1999). Java Enterprise In A Nutshell. New York.
En el siguiente fascículo se abordarán los conceptos básicos de las

interfaces gráficas de usuario las cuales se pueden desarrollar bajo Java y
seguiremos aplicando, como siempre, el paradigma orientado a objetos
para el diseño de componentes visuales que harán mucho más ricas y
dinámicas nuestras aplicaciones.
Fascículo No. 5
programación
Fascículo No. 5
Lenguajede
programación
26 Semestre 2
Seguimientoal autoaprendizaje
Lenguaje de Programación - Fascículo No. 4

Nombre_______________________________________________________
Apellidos ________________________________ Fecha: _________________
Ciudad___________________________________Semestre: _______________
1. Desarrolle una aplicación Java que lea un conjunto de valores booleanos y

calcule las operaciones de conjunción y disyunción lógica entre todos los
valores booleanos almacenados en el arreglo (verdadero o falso). Por
ejemplo, si el arreglo tiene 5 elementos y se ingresan estos dos arreglos, los
métodos deben devolver:
Recuerde que la conjunción lógica es la operación AND (&& en Java) y la

disyunción la operación OR (|| en Java)
2. Desarrolle una aplicación Java que lea un arreglo de números enteros y solicite
un número adicional. El programa con base en ese número adicional solici-
tado, debe decir cuántas veces se encuentra el número adicional en el interior
del arreglo:
3. Desarrolle una aplicación Java que reciba un arreglo de cadenas de caracteres

y empleando el método de ordenamiento por burbuja los ordene alfabéti-
camente. El programa debe validar que sólo se reciban las letras de la ‘a’ a la
‘z’, tanto en mayúsculas como en minúsculas. Desarrolle un método para im-
primir el arreglo completo y no letra por letra.
4. Desarrolle una aplicación Java que lea dos arreglos de números reales. El
programa debe sumar todos los elementos pares del arreglo y todos los
impares y finalmente ambos resultados debe multiplicarlos. Sobre el producto
de dichos números se debe indicar si es un número también par o impar.
Recuerde desarrollar un método para cada proceso, tal como se ha visto en
los ejemplos expuestos en los fascículos.
Fascículo No. 5
programación
Anexo 5
IMPLEMENTACIÓN DE MÉTODOS PARA LA LECTURA E IMPRESIÓN DE ARREGLOS DE
DATOS PRIMITIVOS
package arreglosbasicos;
import javax.swing.JOptionPane;
/**
* @author Ingeniero Jaime Alberto Gutiérrez Mejía
* Fundación Universitaria San Martín
* Programa de Ingeniería de Sistemas
* Facultad de Universidad Abierta y a Distancia
*
* UNIDAD V: ORGANIZACIÓN DE DATOS EN ARREGLOS
* Y VECTORES.
* ALGORITMOS DE BÚSQUEDA Y ORDENAMIENTO.
*
* Clase Java para declarar un arreglo de números enteros,
* de números reales y de cadenas de caracteres, con sus
* correspondientes procesos de poblamiento y recorrido
* para obtener nuevamente los datos en ellos almacenados
*/
public class ArregloDatos
{
/*******************************************/
/*******************************************/
/*******************************************/
//Atributos de la clase
private int [] arregloEnteros;
private double [] arregloReales;
private String [] arregloCadenas;
//Constructor de la clase
public ArregloDatos()
{
}
/*******************************************/
/*******************************************/
/*******************************************/
//Método constructor para instanciar los tres arreglos al tiempo
public ArregloDatos (int totalElementos)
{
//En este constructor instanciamos los arreglos
arregloEnteros = new int[totalElementos];
arregloReales = new double[totalElementos];
arregloCadenas = new String[totalElementos];
}
/*******************************************/
/*******************************************/
/*******************************************/
//Método para cargar de datos el arreglo de enteros
public int [] leerDatosArregloEnteros (int totalelementos)
{
JOptionPane.showMessageDialog(null,"Lectura de un arreglo
de enteros");
//Contador del ciclo de lectura
int i = 0;
Fascículo No. 5
Lenguajede
programación
28 Semestre 2
try
{
for (i = 0; i < totalelementos; i++)
{
arregloEnteros[i] =
Integer.parseInt(JOptionPane.showInputDialog(null,
"Ingrese el valor para la posición [" + i + "]: "));
}
}
catch (Exception errorLecturaArregloEnteros)

{
JOptionPane.showMessageDialog(null,"Error en la
carga de datos: " +
errorLecturaArregloEnteros.toString());
errorLecturaArregloEnteros.printStackTrace();
}
return (arregloEnteros);
}
/*******************************************/
/*******************************************/
/*******************************************/
//Método para leer un arreglo de números reales
public double [] leerDatosArregloReales (int totalelementos)
{
de reales");
int i = 0;
try
{
{
arregloReales[i] =
Double.parseDouble(JOptionPane.showInputDialog(null
,"Ingrese el valor para la posición [" + i + "]: "));
}
}
catch (Exception errorLecturaArregloReales)

{
carga de datos: " +
errorLecturaArregloReales.toString());
errorLecturaArregloReales.printStackTrace();
}
return (arregloReales);
}
/*******************************************/
/*******************************************/
/*******************************************/
public String [] leerArregloCadenasCaracteres (int totalelementos)
{
de cadenas de caracteres");
int i = 0;
Fascículo No. 5
programación
try
{
{
arregloCadenas[i] =
JOptionPane.showInputDialog(null,"Ingrese el valor
para la posición [" + i + "]: ");
}
}
catch (Exception errorLecturaArregloCadenas)

{
carga de datos: " +
errorLecturaArregloCadenas.toString());
errorLecturaArregloCadenas.printStackTrace();
}
return (arregloCadenas);
}
/*******************************************/
/*******************************************/
/*******************************************/
//Método para imprimir los elementos del arreglo de enteros
public void imprimirArregloEnteros (int [] datos)
{
JOptionPane.showMessageDialog(null,"Impresión de un
arreglo de enteros");
int i = 0;
try
{
{
JOptionPane.showMessageDialog(null,"Dato de la
posición [" + i + "]: " + datos[i]);
}
}
catch (Exception errorImpresionArreglo)

{
imprimiendo el arreglo: " +
errorImpresionArreglo.toString());
errorImpresionArreglo.printStackTrace();
}
}
/*******************************************/
/*******************************************/
/*******************************************/
//Método para imprimir los elementos del arreglo de reales
public void imprimirArregloReales (double [] datos)
{
arreglo de reales");
int i = 0;
try
{
{
Fascículo No. 5
Lenguajede
programación
30 Semestre 2
JOptionPane.showMessageDialog(null,"Dato
de la posición [" + i + "]: " + datos[i]);
}
}

{
}
}
/*******************************************/
/*******************************************/
/*******************************************/
//Método para imprimir los elementos del arreglo de cadenas
public void imprimirArregloCadenas (String [] datos)
{
arreglo de cadenas de caracteres");
int i = 0;
try
{
{
JOptionPane.showMessageDialog(null,"Dato
de la posición [" + i + "]: " + datos[i]);
}
}

{
}
}
/*******************************************/
/*******************************************/
/*******************************************/
/**
* @param args
* Programa principal
* Se solicita un número específico de elementos
* y acto seguido se solicitan los tres arreglos de datos
*
* Luego se imprimen para ver que se almacenó en
* cada arreglo
*/
public static void main(String[] args)
{
/*******************************************/
/*******************************************/
/*******************************************/
// TODO Auto-generated method stub
int totalElementos = 0;
totalElementos =
Integer.parseInt(JOptionPane.showInputDialog(null,"Ingrese el total de elementos para
Fascículo No. 5
programación
los tres arreglos: "));

int [] datosEnteros = null;
double [] datosReales = null;
String [] datosCadenas = null;
//Instanciamos los arreglos

ArregloDatos arreglos = new ArregloDatos(totalElementos);
//Ingresamos el arreglo de enteros y lo imprimimos

datosEnteros =
arreglos.leerDatosArregloEnteros(totalElementos);
arreglos.imprimirArregloEnteros(datosEnteros);
//Ingresamos el arreglo de reales y lo imprimimos

datosReales =
arreglos.leerDatosArregloReales(totalElementos);
arreglos.imprimirArregloReales(datosReales);
//Ingresamos el arreglo de enteros y lo imprimimos

datosCadenas =
arreglos.leerArregloCadenasCaracteres(totalElementos);
arreglos.imprimirArregloCadenas(datosCadenas);
/*******************************************/
/*******************************************/
/*******************************************/
}//Fin del main
/*******************************************/
/*******************************************/
/*******************************************/
}//Fin de la clase
IMPLEMENTACIÓN DE UNA CLASE PARA EL MANEJO DE DATOS DE UN

ARREGLO UNIDIMENSIONAL
/********************************************/
/********************************************/
public class RecorridoArreglos
{
/********************************************/
/********************************************/
//Datos
private int [] datos;
/********************************************/
/********************************************/
public RecorridoArreglos()
{
// TODO Auto-generated constructor stub
}
/********************************************/
/********************************************/
public RecorridoArreglos(int numeroElementos)
{
datos = new int[numeroElementos];
}
/********************************************/
/********************************************/
//Método para poblar el arreglo automáticamente de datos
Fascículo No. 5
Lenguajede
programación
32 Semestre 2
public void poblarArregloConDatos (int numeroDatos)

{
int i = 0;
try
{
for (i = 0; i < numeroDatos; i++)
{
//Poblamos el arreglo con datos aleatorios
datos[i] = (int)(Math.random()*10000);
}
}
catch (Exception errorPoblado)

{
JOptionPane.showMessageDialog(null,"Error de
poblamiento: " + errorPoblado.getMessage());
errorPoblado.printStackTrace();
}
}
/********************************************/
/********************************************/
//Método para recorrer el arreglo con un While
public void recorrerArregloConWhile ()
{
JOptionPane.showMessageDialog(null,"Recorrido de un arreglo
con un while");
int i = 0;
int dato = 0;
String arreglo = "";
try
{
i = 0;
while (i < datos.length)
{
dato = datos[i];
arreglo += String.valueOf(dato);
arreglo += " ";
i++;
}//Fin del while
//Imprimimos el arreglo
JOptionPane.showMessageDialog(null,arreglo);
catch (ArrayIndexOutOfBoundsException errorDesbordamiento)

{
desbordamiento: " +
errorDesbordamiento.getLocalizedMessage());
errorDesbordamiento.printStackTrace();
}
/********************************************/
/********************************************/
//Método para recorrer el arreglo con un do-while
public void recorrerArregloConDoWhile ()
Fascículo No. 5
programación
{
con un do-while");
int i = 0;
int dato = 0;
try
{
i = 0;
do
{
dato = datos[i];
arreglo += " ";
i++;
} while (i < datos.length);

{
desbordamiento: " +
}
/********************************************/
/********************************************/
//Método para recorrer el arreglo con un for
public void recorrerArregloConFor ()
{
con un ciclo for");
int i = 0;
int dato = 0;
try
{
{
dato = datos[i];
arreglo += " ";
}

{
desbordamiento: " +
Fascículo No. 5
Lenguajede
programación
34 Semestre 2
}
}
/********************************************/
/********************************************/
/**
* @param args
*/
{
// TODO Auto-generated method stub
int numeroDatos = 0;
numeroDatos =
Integer.parseInt(JOptionPane.showInputDialog(null,"Ingrese el
número de elementos del arreglo: "));
//Creamos el arreglo
RecorridoArreglos recorredorArreglos = new
RecorridoArreglos(numeroDatos);
//Lo poblamos de datos

recorredorArreglos.poblarArregloConDatos(numeroDatos);
//Lo recorremos con las tres estructuras
//while
recorredorArreglos.recorrerArregloConWhile();

//do-while
recorredorArreglos.recorrerArregloConDoWhile();

//for
recorredorArreglos.recorrerArregloConFor();
}//Fin del main
/********************************************/
/********************************************/
}
CLASE JAVA PARA ILUSTRAR EL MANEJO DE MÉTODOS QUE

EMPLEAN ARREGLOS DE DATOS
package arreglosbasicos;
/**
* @author Ingeniero Jaime Alberto Gutiérrez Mejía
* Fundación Universitaria San Martín
* Programa de Ingeniería de Sistemas
* Facultad de Universidad Abierta y a Distancia
*
* UNIDAD V: ORGANIZACIÓN DE DATOS EN ARREGLOS
* Y VECTORES.
* ALGORITMOS DE BÚSQUEDA Y ORDENAMIENTO.
*
Fascículo No. 5
programación
* Clase Java para ilustrar la implementación de métodos

* que emplean arreglos de datos para procesar criterios
* y obtener resultados concretos.
*
* Esta clase lee un arreglo de números reales y
*
* - calcula el promedio de los datos
* - Otro método la suma de los mismos
* - Otro su productoria
* - y el último método determina cual es el valor más grande
* del arreglo
*/
public class ManejoArreglos
{
/*******************************************/
/*******************************************/
/*******************************************/
//Atributos de la clase
private double [] arregloDatos;
private double sumatoria;
private long productoria;
private double promedio;
private double datoMayor;
/*******************************************/
/*******************************************/
/*******************************************/
//Constructor de la clase
public ManejoArreglos()
{
}
/*******************************************/
/*******************************************/
/*******************************************/
public ManejoArreglos(int totalElementos)
{
arregloDatos = new double[totalElementos];
}
/*******************************************/
/*******************************************/
/*******************************************/
public double [] leerDatosArregloReales (int totalelementos)
{
de reales");
int i = 0;
try
{
{
arregloDatos[i] =
Double.parseDouble(JOptionPane.showInputDialog(null,"Ingrese el valor para la
posición [" + i + "]: "));
}
}
catch (Exception errorLecturaArregloReales)

{
Fascículo No. 5
Lenguajede
programación
36 Semestre 2
carga de datos: " +
errorLecturaArregloReales.toString());
errorLecturaArregloReales.printStackTrace();
}
return (arregloDatos);
}
/*******************************************/
/*******************************************/
/*******************************************/
//Método para calcular la suma de los elementos
//del arreglo. Recibe como parámetro el arreglo
//y retorna la suma de los elementos de cada una
//de sus posiciones
public double calcularSumaElementosArreglo (double [] datos)
{
sumatoria = 0.0;
int i = 0;
try
{
{
sumatoria = sumatoria + datos[i];
}
}
catch (Exception errorCalculoSuma)

{
suma de los elementos del arreglo: " +
errorCalculoSuma.toString());
errorCalculoSuma.printStackTrace();
return (0.0);
}
return (sumatoria);
}
/*******************************************/
/*******************************************/
/*******************************************/
//y retorna la productoria los elementos de cada una
//de sus posiciones
public long calcularProductoriaElementosArreglo (double [] datos)
{
productoria = 1;
int i = 0;
try
{
{
productoria = productoria * (long)datos[i];
}
}
catch (Exception errorCalculoProductoria)
Fascículo No. 5
programación
{
errorCalculoProductoria.toString());
errorCalculoProductoria.printStackTrace();
return (0L);
}
return (productoria);
}
/*******************************************/
/*******************************************/
/*******************************************/
//y retorna el promedio aritmético de los elementos
//de sus posiciones
public double calcularPromedioDatosArreglo (double [] datos)
{
promedio = 0.0;
int i = 0;
try
{
{
promedio = promedio + datos[i];
}
//Dividimos por el total de elementos

promedio = promedio/datos.length;
}
catch (Exception errorCalculoPromedio)

{
errorCalculoPromedio.toString());
errorCalculoPromedio.printStackTrace();
return (0.0);
}
return (promedio);
}
/*******************************************/
/*******************************************/
/*******************************************/
//Método para determinar cuál es el número más grande
//de los elementos presentes en el arreglo
public double obtenerElementoMasGrandeArreglo (double []
datos)
{
int i = 0;
datoMayor = 0.0;
try
{
datoMayor = datos[0];
{
if (datos[i] > datoMayor)
Fascículo No. 5
Lenguajede
programación
38 Semestre 2
{
datoMayor = datos[i];
}
}
}
catch (Exception errorElementoMasGrande)

{
JOptionPane.showMessageDialog(null,"Error buscando
el elemento más grande del arreglo: " + errorElementoMasGrande.toString());
errorElementoMasGrande.printStackTrace();
return (0.0);
}
return (datoMayor);
}
/*******************************************/
/*******************************************/
/*******************************************/
/**
* @param args
* Programa principal
*
* Lee el número de elementos del arreglo
* Luego lee el arreglo y calcula la suma, la productoria,
* el promedio y busca el dato más grande
*/
{
/*******************************************/
/*******************************************/
/*******************************************/
int numeroElementos = 0;
double suma = 0.0;
double promedio = 0.0;
double masgrande = 0.0;
long productoria = 0L;
double [] datos = null;
numeroElementos =
Integer.parseInt(JOptionPane.showInputDialog(null,"Ingrese el
número de elementos del arreglo: "));
ManejoArreglos manejadorArreglos = new ManejoArreglos(numeroElementos);
//Leemos el arreglo
datos =
manejadorArreglos.leerDatosArregloReales(numeroElementos);
//Obtenemos los estadísticos

//La suma
suma =
manejadorArreglos.calcularSumaElementosArreglo(datos);
JOptionPane.showMessageDialog(null,"La suma de los
elementos del arreglo es igual a " + suma);
//El promedio
promedio =
manejadorArreglos.calcularPromedioDatosArreglo(datos);
JOptionPane.showMessageDialog(null, "El promedio de los elementos del arreglo es: "
Fascículo No. 5
programación
+ promedio);
//La productoria
productoria =
manejadorArreglos.calcularProductoriaElementosArreglo(datos);
JOptionPane.showMessageDialog(null,"La productoria de los datos del arreglo es: " +
productoria);
//El dato más grande

masgrande = manejadorArreglos.obtenerElementoMasGrandeArreglo(datos);
JOptionPane.showMessageDialog(null,"El dato más grande del arreglo: " + masgrande);
/*******************************************/
/*******************************************/
/*******************************************/
}
/*******************************************/
/*******************************************/
/*******************************************/
}//Fin de la clase
Fascículo No. 5
Lenguajede
programación
40 Semestre 2

LenProg F05

Загружено:

Сведения о документе

Оригинальное название

Авторское право

Доступные форматы

Поделиться этим документом

Поделиться или встроить документ

Параметры публикации

Этот документ был вам полезен?

Это неприемлемый материал?

Авторское право:

Доступные форматы

LenProg F05

Загружено:

Авторское право:

Доступные форматы

Fascículo

Tabla de contenido Página

Copyright©2008 FUNDICIÓN UNIVERSITARIA SAN MARTÍN

Prohibida la reproducción total o parcial sin autorización

La redacción de este fascículo estuvo a cargo de

Orientación a cargo de;

Diseño gráfico y diagramación a cargo de

Impreso en: GRÁFICAS SAN MARTÍN

Hasta el momento hemos visto programas que almacenan los datos de

Fascículo No. 5 Lenguaje de

Mapa conceptual fascículo 5

Al finalizar el estudio del presente fascículo, el estudiante estará en capacidad

 Crear arreglos unidimensionales y emplearlos para almacenar en una varia-

Arrays de Una Dimensión. Utilizar sólo un Inicializador

En este punto, Java y los demás lenguajes de programación orientados a

registro (creación de nuevos datos), eliminación (borrado o retiro de un

Java ofrece muchas estructuras de datos con múltiples propósitos. En

Todo arreglo siempre tiene tres características:

Con base en esto, Java, ofrece la declaración de cualquier nuevo array,

Si se quisiera crear un arreglo como el del ejemplo, debemos instanciar un

Donde los corchetes ([ ]) le indican al compilador que debe crearse un

Ahora surge un segundo cuestionamiento ¿Si con la instrucción de

La siguiente pregunta es ¿cómo navegamos ese arreglo? La respuesta es

Ahora se explica la implementación de una Clase encargada de leer tres

Un programa como el descrito en el anexo 5 se encargará:

a) Primero de solicitar el número total de elementos que van a formar los

b) Invocar el método encargado de la lectura. En donde se mostró el códi-

c) Una vez los datos se han almacenado en el arreglo gracias al for, se

Con base en el ejemplo de creación de arreglos visto anteriormente,

Utilizar la palabra clave "new" y un Inicializador

Constructor nombreNuevoObjeto = new Constructor();

Y en este caso, la declaración de nuevos arreglos

TipoDatoDelArreglo [] nombreNuevoArreglo = new

Si, si se desea crear un arreglo de números enteros de 20 posiciones,

int [] arregloDatosEnteros = new int [20];

Igualmente, si se quiere construir un arreglo de cadenas de caracteres de

String [] coleccionCadenasCaracteres = new String[n];

Donde n es una variable previamente declarada y que en algún punto de

Lo más importante en todos estos procesos, es que ejecutando correcta-

1. Desarrolle un conjunto de Aplicaciones Java para crear una ensalada

instanciación como base para este ejercicio, indique cuántas frutas

Trabajar con un array uni-dimensional

Analice el código de la aplicación.

Considérese ahora el siguiente problema: se tiene un conjunto de datos

FUNCIONALIDAD A IMPLEMENTAR: PROMEDIO

FUNCIONALIDAD A IMPLEMENTAR: PRODUCTORIA

FUNCIONALIDAD A IMPLEMENTAR: OBTENER EL DATO MÁS GRANDE DEL ARREGLO

Ahora observe la implementación de la solución.

Algoritmos de búsqueda de datos en vectores y métodos

Un algoritmo de búsqueda es aquél que está diseñado para localizar un

Las búsquedas de datos pueden realizarse mediante dos procesos: el

a) Búsqueda Lineal: se utiliza cuando el contenido del vector no se en-

del arreglo. La existencia se puede asegurar desde el momento que el

Implementándolo en Java, tendríamos el siguiente método:

catch (Exception errorBusquedaLineal)

Con esto, se optimiza el tiempo y se determina qué debe indicar el

b) Búsqueda Binaria (Proceso de Divide y Vencerás): se utiliza cuando

Para implementar este algoritmo se compara el elemento a buscar con un

A continuación se presenta el pseudocódigo del algoritmo, tomando como

Ejecute mientras (rangoInferior <= rangoSuperior)

rangoCentral = (rangoSuperior + rangoInferior)/2;

Fin ejecute mientras;

//No se encontró el elemento