Documentos de Académico
Documentos de Profesional
Documentos de Cultura
INTRODUCCIN A LA PROGRAMACIN 1
TEMA 1.
Introduccin a la programacin.
1.1. CONCEPTOS BSICOS.
Un programa es un conjunto ordenado de instrucciones, que se aloja en la memoria
del ordenador. Estas instrucciones operan sobre datos, normalmente (aunque no
necesariamente) procedentes del mundo exterior a dicha memoria: usuarios, dispositivos de
almacenamiento (electrnicos, magnticos, pticos, etc), redes de comunicaciones, etc, para
producir resultados tanto en forma de acciones como de nuevos datos (informacin).
Acciones
Datos
ORDENADOR
(memoria)
Resultados
PROGRAMA
Informacin
2 INTRODUCCIN A LA PROGRAMACIN
ESTRUCTURAS DE DATOS
Ordenador
TRADUCTOR
Programa
ejecutable
Por el contrario, sera la tcnica ms eficiente (mayor velocidad de ejecucin y menor consumo de
memoria). No obstante, y como consecuencia de la incesante mejora y abaratamiento de la tecnologa, esta
alternativa no ha sido nunca tomada en consideracin.
2
Difcilmente se podr encontrar otra actividad ms viva que el desarrollo de lenguajes de programacin:
en tan solo cincuenta aos de existencia de los ordenadores y de la Informtica algunos autores llegan a
identificar en torno a medio millar de ellos. Se puede encontrar una referencia en:
http://www.lenguajesdeprogramacion.com/
3
Se trata de un modelo muy elemental. La realidad es algo ms compleja.
4
Existen otras soluciones intermedias.
ESTRUCTURAS DE DATOS
INTRODUCCIN A LA PROGRAMACIN 3
4 INTRODUCCIN A LA PROGRAMACIN
ESTRUCTURAS DE DATOS
o protected: tienen acceso las clases del resto del paquete, as como desde
subclases definidas fuera del paquete.
o public: se puede acceder desde cualquier otra clase.
1.1.1.4. Excepciones.
Las excepciones son elementos que almacenan informacin para detectar hechos
excepcionales, como por ejemplo errores. En Java existen muchos tipos de excepciones
estndar y las ms habituales son del tipo IOException (errores de lectura), as como del
tipo NumberFormatException (que se genera cuando se espera leer un nmero y se recibe
algo diferente).
1.1.2. Entorno de programacin (IDE).
Para realizar la actividad de programacin se requiere, adems del correspondiente
programa traductor (compilador o intrprete), un conjunto de herramientas (software
development tools) que proporcionan funcionalidades tales como escribir / modificar
(editar) el cdigo fuente, facilitar la puesta a punto de programas (debugger), cargar
(load), montar (link) y ejecutar (run) programas, gestionar ficheros con cdigo fuente y
ejecutable, etc. Normalmente estas herramientas se ofrecen en forma de paquete integrado
(Integrated Development Environment IDE-). Uno de ellos, de libre distribucin para
programacin en Java es Eclipse (http://www.eclipse.org, donde adems de descargar la
aplicacin, se pueden encontrar distintos recursos como por ejemplo tutoriales para
aprender el manejo del entorno).
ESTRUCTURAS DE DATOS
INTRODUCCIN A LA PROGRAMACIN 5
Explicacin
Lnea de comentario.
Se indica el nombre del programa.
Delimitador de inicio del programa.
Clase principal
Delimitador de inicio de la clase
Ejemplo de accin: sentencia println (escribir en el dispositivo
de salida system.out y avanzar al comienzo de la lnea
siguiente) que acta sobre un sujeto (dato): la cadena de
caracteres Hola EUI.
Delimitador de fin de clase.
Delimitador de fin de programa.
Semntica
import <nombre>;
public class <nombre de la clase general>
{
6 INTRODUCCIN A LA PROGRAMACIN
ESTRUCTURAS DE DATOS
ESTRUCTURAS DE DATOS
INTRODUCCIN A LA PROGRAMACIN 7
El concepto tipo de datos se asocia implcitamente al los datos elementales (simples). Ms adelante
(apartado 1.4) se contemplar la posibilidad de agrupar datos simples en unidades de orden superior para dar
lugar a diferentes estructuras de datos.
9
Las operaciones con ms de dos operandos las consideramos dentro del epgrafe de expresiones.
8 INTRODUCCIN A LA PROGRAMACIN
ESTRUCTURAS DE DATOS
Tipo
Operacin
Operador
Entero (int)
Suma
Resta
Multiplicacin
Cociente
Resto
Suma
Resta
Multiplicacin
Divisin
Negacin
Unin (or)
Interseccin (and)
No existen
Concatenacin
+
*
/
%
+
*
/
!
||
&&
Ejemplo
Operacin
3+5
1-3
2 * (-5)
7/3
7%3
1,23 + 8,77
1,23 - 8,77
-3,2 * 4,6
3,2 / (-4,6)
! true
true || false
true && false
Hola + Antonio
Real (float)
Lgico (boolean)
Carcter (char)
Cadena (String)
Resultado
8
-2
-10
2
1
10,0
-7,54
-14,72
-0,6956
false
true
false
10
Hola Antonio
Operador
>
<
==
>=
<=
!=
Result.
true
false
false
true
true
false
Result.
false
12
true
false
true
true
true
10
ESTRUCTURAS DE DATOS
INTRODUCCIN A LA PROGRAMACIN 9
14
Adems de las componentes (clases) proporcionadas por el fabricante (en este caso Eclipse) el
programador puede incorporar otras de desarrollo propio (ver tema 2: Tipos Abstractos de Datos) o
adquiridas a terceros.
10 INTRODUCCIN A LA PROGRAMACIN
ESTRUCTURAS DE DATOS
1.2.3.2.3. Expresiones.
Una expresin es una combinacin (coherente) de datos (literales, constantes y/o
variables), operaciones y funciones, enlazados entre s por medio de operadores.
Como consecuencia de evaluar una expresin, siguiendo las reglas
correspondientes, se obtiene un resultado de tipo acorde con la naturaleza de la expresin.
1.2.4. Sentencias.
Las sentencias son construcciones sintcticas que indican al ordenador qu
operaciones debe realizar y, normalmente, con qu datos. Materializan la parte operativa
de un programa que implementa el algoritmo (definicin de Wirth, 1985) que se deber
ejecutar15. Dicha parte constituye un bloque delimitado por { y }.
Se describe a continuacin, la sintaxis de las sentencia de Java, agrupadas en funcin
de su naturaleza.
1.2.4.1. Asignacin.
Permite, como su propio nombre indica, asignar un valor a una variable (ver 1.2.2)
definida en la parte declarativa. Su sintaxis es:
16
Ejemplo (HolaEui2.Java):
//Ejemplo de asignacion a variables.
public class HolaEui2 {
public static void main (String [ ] args) {
String cadena = "Hola EUI";
System.out.println (cadena);
}
}
15
ESTRUCTURAS DE DATOS
INTRODUCCIN A LA PROGRAMACIN 11
cadena = linea.readLine();
.
n = Integer.parseInt (linea.readLine());
.
12 INTRODUCCIN A LA PROGRAMACIN
ESTRUCTURAS DE DATOS
import java.io.*;
//Ejemplo de sentencias de entrada/salida.
public class HolaEui3 {
public static void main(String [] args) throws
NumberFormatException,IOException{
String cadena, cadena2;
int edad, ao = 2010;
BufferedReader linea=new BufferedReader (new InputStreamReader (System.in));
System.out.println ("Hola, como te llamas? ");
cadena = linea.readLine();
System.out.println ("Encantado de conocerte, " + cadena);
System.out.println ("Cuantos aos tienes? ");
edad = Integer.parseInt (linea.readLine());
edad = edad+3;
ao = ao+3;
cadena2 = cadena+", en algun momento de "+ao+" tendrs "+edad+" aos";
System.out.println (cadena2);
System.out.println (cadena);
}
}
ESTRUCTURAS DE DATOS
INTRODUCCIN A LA PROGRAMACIN 13
Ejemplo:
El siguiente programa informa al usuario de la paridad de un nmero entero
introducido por el teclado.
import java.io.*;
//Ejemplo de alternativa simple.
public class PruebaIf {
public static void main (String [] args) throws NumberFormatException,
IOException {
int dato;
BufferedReader linea=new BufferedReader (new InputStreamReader (System.in));
System.out.print("Numero: ");
dato = Integer.parseInt (linea.readLine());
if ((dato % 2) == 0)
System.out.println (" es par");
else System.out.println (" es impar");
}
}
Operador condicional
El operador condicional ?: se puede usar como abreviatura de la sentencia if, cuya
sintaxis es:
expresionCondicional ? expresionSI : expresionNO;
18
14 INTRODUCCIN A LA PROGRAMACIN
ESTRUCTURAS DE DATOS
Ejemplo:
El programa siguiente espera recibir desde el teclado un dgito, entre 1 y 7,
correspondiente al ordinal del da de la semana (lunes a domingo) y mostrar por la
pantalla el literal del da asociado o un mensaje de error si el cdigo no es vlido.
import java.io.*;
//Ejemplo de alternativa multiple.
public class PruebaSwitch {
public static void main (String [ ] args) throws NumberFormatException,
IOException {
BufferedReader linea = new BufferedReader (new InputStreamReader
(System.in));
System.out.print ("Opcion: ");
int opc = Integer.parseInt (linea.readLine ());
switch (opc) {
case 1: System.out.println ("lunes");
break;
case 2: System.out.println ("martes");
break;
case 3: System.out.println ("miercoles");
break;
case 4: System.out.println ("jueves");
break;
case 5: System.out.println ("viernes");
break;
case 6: System.out.println ("sabado");
break;
case 7: System.out.println ("domingo");
break;
default: System.out.println ("opcion no valida");
break;
}
}
}
ESTRUCTURAS DE DATOS
INTRODUCCIN A LA PROGRAMACIN 15
Ejemplo:
El siguiente programa muestra por la pantalla el valor de los cuadrados de 5
nmeros introducidos por el teclado.
import java.io.*;
//Ejemplo de bucle for.
public class PruebaFor {
public static void main(String[] args) throws NumberFormatException,IOException{
int i, dato, cuadrado;
BufferedReader linea = new BufferedReader (new InputStreamReader (System.in));
for (i = 1; i <= 5; i ++) {
System.out.print ("Numero: ");
dato = Integer.parseInt (linea.readLine ());
cuadrado = dato * dato;
System.out.println ("El cuadrado de " + dato + " es: " + cuadrado);
}
}
}
19
En consecuencia, podra ser que el bloque de cdigo pudiera no ejecutarse ninguna vez.
16 INTRODUCCIN A LA PROGRAMACIN
ESTRUCTURAS DE DATOS
Ejemplo:
El siguiente programa ejecuta reiteradamente el ejemplo de los das de la
semana, salvo que el usuario teclee 0 como opcin20.
import java.io.*;
//Ejemplo de bucle while.
public class PruebaWhile {
public static void main (String [] args) throws NumberFormatException,
IOException {
int opc;
BufferedReader linea = new BufferedReader (new InputStreamReader
(System.in));
System.out.print ("Opcin: ");
opc = Integer.parseInt (linea.readLine());
while (opc != 0) {
switch (opc) {
case 1: System.out.println ("lunes");
break;
case 2: System.out.println ("martes");
break;
case 3: System.out.println ("miercoles");
break;
case 4: System.out.println ("jueves");
break;
case 5: System.out.println ("viernes");
break;
case 6: System.out.println ("sabado");
break;
case 7: System.out.println ("domingo");
break;
default: System.out.println ("opcin no valida");
break;
}
System.out.print ("Opcin: ");
opc = Integer.parseInt (linea.readLine ());
}
}
}
<grupo de sentencias;>
(<condicin>);
20
21
ESTRUCTURAS DE DATOS
INTRODUCCIN A LA PROGRAMACIN 17
Ejemplo:
El programa siguiente constituye una variante del ejemplo anterior en el que
el bloque de cdigo se ejecuta una vez y volver a repetirse reiteradamente, o
no, hasta que el usuario teclee 0 como opcin22.
import java.io.*;
//Ejemplo de bucle do ... while.
public class PruebaDoWhile {
public static void main (String [] args) throws NumberFormatException,
IOException {
int opc = 7;
BufferedReader linea=new BufferedReader (new InputStreamReader (System.in));
System.out.println("Empezamos en domingo");
do {
switch (opc) {
case 1: System.out.println ("lunes");
break;
case 2: System.out.println ("martes");
break;
case 3: System.out.println ("miercoles");
break;
case 4: System.out.println ("jueves");
break;
case 5: System.out.println ("viernes");
break;
case 6: System.out.println ("sabado");
break;
case 7: System.out.println ("domingo");
break;
default: System.out.println ("opcin no valida");
break;
};
System.out.print ("Opcin: ");
opc = Integer.parseInt (linea.readLine ());
} while (opc != 0);
}
}
22
18 INTRODUCCIN A LA PROGRAMACIN
ESTRUCTURAS DE DATOS
23
Internet es una fuente casi inagotable donde obtener este tipo de recursos.
ESTRUCTURAS DE DATOS
INTRODUCCIN A LA PROGRAMACIN 19
Zona de
algoritmo
Subprograma (mdulo)
Zona de datos
>
<retorno
Zona de
algoritmo
---------------------
<Llamada>
---------------------
Programa principal
24
20 INTRODUCCIN A LA PROGRAMACIN
ESTRUCTURAS DE DATOS
27
Lo que se explica en el apartado debe entenderse con carcter general. El lenguaje Java solo
admite el paso de argumentos por valor. Esta afirmacin es extensiva al caso de que el argumento sea un
objeto (por ejemplo, un vector) dado que lo que se pasa como argumento por valor es un puntero (referencia)
a dicho objeto que no puede ser modificado por el mdulo subordinado (aunque s el propio objeto).
28
No hay ningn inconveniente en que dos variables locales de mdulos diferentes tengan el mismo
nombre.
29
Una modificacin de una variable global realizada por un mdulo afectar al resto.
30
En este caso si habra ambigedad en caso de coincidencia de nombres de una variable local y otra
global. Esto no supone ningn error de compilacin y la ejecucin podra producir resultados no esperados (ni
deseados).
31
No tiene sentido pasar como argumentos variables globales. Ya estn accesibles desde todos los
mdulos.
ESTRUCTURAS DE DATOS
INTRODUCCIN A LA PROGRAMACIN 21
Los nombres de los argumentos son formales. No tienen por qu coincidir con los
nombres reales de las variables utilizadas en la llamada al mtodo32. El compilador solo
verifica que las listas de argumentos empleadas en la llamada (reales) y en la cabecera
(formales) coinciden en nmero, tipo y orden.
Las sintaxis de las llamadas es similar a la de las cabeceras, si bien en este caso se
utiliza una versin reducida de la <lista de argumentos> en la que solo aparecen sus
nombres (reales), separados por comas.
El mtodo est delimitado por las llaves de inicio y fin de bloque ({ y }), y a
continuacin aparece la declaracin de variables locales del subprograma y el algoritmo.
Los mtodos que no sean de tipo void deben acabar con la siguiente sentencia:
return <variableDeTrabajo>;
32
22 INTRODUCCIN A LA PROGRAMACIN
ESTRUCTURAS DE DATOS
Dado que el lenguaje Java solo admite el paso de argumentos por valor no es posible
que el modulo subordinado modifique una variable del mdulo de llamada (salvo que se
trate del valor devuelto por el mtodo). En tales situaciones optamos por crear una clase
esttica que declare dicha variable como global de la clase (lo que no contraviene la
recomendacin general de no utilizar variables globales)33 por lo que carecera de sentido
pasarla como argumento.
Como consecuencia de la utilizacin de la tcnica de subprogramacin, el esquema de
estructura general de un programa en Java visto en la seccin 1.2.1 queda ampliado tal
como se muestra a continuacin.
Sintaxis
import <nombre>
public class <nombre de la clase general>
{
Semntica
Llamada a una (o varias) componente(s) de la biblioteca.
Nombre de la clase general (obligatorio)
Principio de la clase.
{
<constantes y variables del mtodo>
....
......
public static void main (String [ ] args)
{
33
Algunos programadores optan por la alternativa de declarar dicha variable como vector (objeto) y pasar el
puntero (referencia) correspondiente como argumento (por valor).
ESTRUCTURAS DE DATOS
INTRODUCCIN A LA PROGRAMACIN 23
1.3.4.1. Ejemplo.
El siguiente programa pide al usuario una serie de cinco nmeros enteros y muestra
por la pantalla dos de sus estadsticas: valor medio y rango.
import java.io.*;
public class PruebaMetodos {
static float media (int dato1, int dato2, int dato3, int dato4, int dato5) {
float resul;
resul = (dato1 + dato2 + dato3 + dato4 + dato5) / 5;
return resul;
}
static int max (int dato1, int dato2, int dato3, int dato4, int dato5) {
int resul;
resul=dato1;
if (dato2 > resul)
resul = dato2;
if (dato3 > resul)
resul = dato3;
if (dato4 > resul)
resul = dato4;
if (dato5 > resul)
resul = dato5;
return resul;
}
static int min (int dato1, int dato2, int dato3, int dato4, int dato5) {
int resul;
resul = dato1;
if (dato2 < resul)
resul = dato2;
if (dato3 < resul)
resul = dato3;
if (dato4 < resul)
resul = dato4;
if (dato5 < resul)
resul = dato5;
return resul;
}
public static void main(String[] args) throws NumberFormatException,IOException{
int d1, d2, d3, d4, d5, rango;
float media;
BufferedReader linea = new BufferedReader(new InputStreamReader(System.in));
System.out.println ("Introduce cinco nmeros enteros: ");
d1 = Integer.parseInt (linea.readLine ());
d2 = Integer.parseInt (linea.readLine ());
d3 = Integer.parseInt (linea.readLine ());
d4 = Integer.parseInt (linea.readLine ());
d5 = Integer.parseInt (linea.readLine ());
media = media (d1, d2, d3, d4, d5);
System.out.println("El valor medio es: " + media);
rango = max (d1, d2, d3, d4, d5) - min (d1, d2, d3, d4, d5);
System.out.println ("y el rango: " + rango);
}
}
24 INTRODUCCIN A LA PROGRAMACIN
ESTRUCTURAS DE DATOS
1.3.5. Recursividad.
1.3.5.1. Concepto.
Se define objeto recursivo como: aquel que forma parte de s mismo o que forma
parte de su propia definicin.
La recursividad es un concepto matemtico que permite formular definiciones
como, por ejemplo, la de nmero natural:
o El 1 es un nmero natural.
o El siguiente de un nmero natural es un nmero natural.
Otro ejemplo sera la definicin de factorial de nmero natural:
o 0! = 1;
o
N > 0, N! = N * (N-1)!
1.3.5.2. Aplicacin del concepto de recursividad en programacin.
Los ejemplos anteriores se pueden implementar mediante programas informticos que
proporcionan un mtodo sencillo, til y potente de resolucin de infinidad de problemas.
De hecho, hay algunos cuya solucin no recursiva sera de elevada complejidad y escasa
eficiencia34. Frente a las ventajas indicadas (robustez y legibilidad) de la recursividad frente
al tratamiento iterativo se contrapone el inconveniente del mayor consumo de memoria, por
las razones que se explican a continuacin.
La recursividad en programacin se obtiene mediante subprogramas que se llaman a
s mismos (es decir, una de las sentencias del cuerpo del subprograma coincide con el
nombre del mismo), no obstante sera ms correcto decir que llama a otra copia (instancia)
del mismo, esa copia a otra nueva y as sucesivamente hasta que se alcanza una condicin
denominada de terminacin o de parada.
Una vez que se alcanza la condicin de terminacin, en la instancia n-sima se
retorna (como en todo subprograma) al punto del modulo de llamada de la instancia previa
desde donde sta se realiz, y as sucesivamente, teniendo lugar una fase de vuelta por las
instancias anteriores, hasta llegar al punto del programa principal en que se produjo la
llamada al subprograma recursivo.
La implementacin en ordenador de algoritmos recursivos requiere una tecnologa
dinmica, diferente a la esttica (explicada en el apartado 1.3.2), dado que no se sabe, a
priori, cuantas instancias se van a necesitar. Durante la fase de ida se cargan en la
memoria nuevas copias del subprograma35 hasta alcanzar la terminacin (fase de
34
ESTRUCTURAS DE DATOS
INTRODUCCIN A LA PROGRAMACIN 25
Explicacin:
El programa principal llama al subprograma factorial y le pasa como argumento la
variable d. Cuando ste termine de ejecutarse, el programa de llamada dispondr de
un resultado que podr mostrar por la pantalla.
El subprograma factorial es recursivo.
o
36
Su nmero de orden ser uno ms que el dato cuyo factorial se quiere calcular.
26 INTRODUCCIN A LA PROGRAMACIN
ESTRUCTURAS DE DATOS
37
static void B () {
<sentencia 1>;
...
A ();
......
<sentencia m>;
}
En algunos casos la terminacin anticipada es necesaria para el correcto funcionamiento del programa
mientras que en otros, aunque el programa funcione se debe usar por consideraciones de eficiencia.
ESTRUCTURAS DE DATOS
INTRODUCCIN A LA PROGRAMACIN 27
1.3.5.4. Ejemplos.
Ejemplo 1. (Utilizacin de un mdulo de llamada).
El programa que se muestra a continuacin utiliza un mtodo que obtiene la suma de
los divisores de un nmero natural. Por ejemplo: la suma de los divisores de 40 (2, 4, 5,
8, 10, 20) es 49.
import java.io.*;
public class Recursividad1 {
static int sumaDivisores (int dato, int presuntoDivisor) {
int resul = 0;
if ((presuntoDivisor*2) <= dato) {
resul = sumaDivisores (dato, presuntoDivisor+1);
if ((dato % presuntoDivisor) == 0)
resul = resul + presuntoDivisor;
}
return resul;
}
static int sumaDivisores (int dato) {
return sumaDivisores (dato, 2);
}
public static void main(String[] args) throws NumberFormatException,IOException{
int d, suma;
BufferedReader linea = new BufferedReader (new InputStreamReader(System.in));
do {
System.out.print ("Introduzca un nmero mayor que cero: ");
d = Integer.parseInt (linea.readLine ());
} while (d <= 0);
suma = sumaDivisores (d);
System.out.print ("La suma de los divisores de " + d + " es " + suma);
}
}
El diseador del programa principal no tiene por qu saber que se necesitan otros
argumentos adicionales al dato (d), sin embargo, el subprograma recursivo realmente
necesita otro argumento (presuntoDivisor, de tipo entero), para probar recursivamente
desde 2 hasta d/2 y controlar la terminacin (pesimista).
Ejemplo 2. (Terminacin anticipada).
El siguiente ejemplo consiste en una funcin booleana (esPrim) que indica si un
nmero (d) que se introduce desde el teclado es primo (true) o no (false).
La condicin de terminacin pesimista es d >
dato
28 INTRODUCCIN A LA PROGRAMACIN
ESTRUCTURAS DE DATOS
ESTRUCTURAS DE DATOS
INTRODUCCIN A LA PROGRAMACIN 29
import java.io.*;
public class Recursividad3 {
static boolean esPrim (int dato, int presuntoDivisor) {
boolean resul;
if ((presuntoDivisor*presuntoDivisor) <= dato)
if ((dato % presuntoDivisor) != 0)
resul = esPrim (dato, presuntoDivisor+1);
else resul = false;
else resul = true;
return resul;
}
public static class Suma {
static int numeroFactores = 0; //variable global de la clase Suma
static int sumaPrimos (int dato, int presuntoPrimo) {
int resul, orden;
if ((presuntoPrimo * 2) <= dato)
if ((dato % presuntoPrimo) == 0)
if (esPrim (presuntoPrimo, 2)) {
numeroFactores= numeroFactores + 1;
orden = numeroFactores;
resul = sumaPrimos(dato, presuntoPrimo + 1);
if ((numeroFactores% 2) == 0) {
if (orden <= (numeroFactores / 2))
resul = resul + presuntoPrimo;
}
else {
if (orden > ((numeroFactores / 2) + 1))
resul = resul + presuntoPrimo;
}
}
else resul = sumaPrimos (dato, presuntoPrimo + 1);
else resul = sumaPrimos (dato, presuntoPrimo + 1);
else resul = 0;
return resul;
}
static int sumaPrimosCondicionada (int dato) {
int resul;
resul = sumaPrimos (dato, 2);
return resul;
}
}
public static void main(String[] args) throws NumberFormatException,IOException{
int d, suma;
BufferedReader linea = new BufferedReader (new InputStreamReader(System.in));
do {
System.out.print("Introduzca un nmero mayor que cero: ");
d = Integer.parseInt (linea.readLine());
} while (d <= 0);
suma = Suma.sumaPrimosCondicionada (d);
System.out.println ("El resultado es: " + suma);
}
}
30 INTRODUCCIN A LA PROGRAMACIN
ESTRUCTURAS DE DATOS
primos, por lo que no se sabe qu hay que sumar. La parte de proceso que se realiza
en ella consiste en:
o Identificar si un nmero (argumento presuntoPrimo, pasado por valor) es
primo y factor de d.
En caso negativo se realiza una nueva llamada recursiva con
presuntoPrimo+1.
En caso afirmativo:
Se contabiliza en la variable numeroFactores global dentro de la clase
Suma, inicializado a 0 (pues se utilizar su valor final en la fase de
vuelta).
Se toma nota del nmero de orden (orden) del factor primo
encontrado (variable local que recoge el valor actual de
numeroFactores)38.
NOTA IMPORTANTE: Evitar el error de intentar pasar a la siguiente instancia el valor
de una variable local.
En caso contrario:
Se recibe el valor devuelto por el mtodo desde la instancia siguiente
(resul).
Si el valor de orden se encuentra dentro del rango adecuado (primeros o
ltimos, segn proceda) se suma al valor de resul el de presuntoPrimo.
Se devuelve el resultado a la instancia anterior.
38
En las instancias correspondientes a valores de presuntoPrimo que no son factores primos el valor de la
variable orden es aleatorio
39
Vamos marcha atrs.
ESTRUCTURAS DE DATOS
INTRODUCCIN A LA PROGRAMACIN 31
32 INTRODUCCIN A LA PROGRAMACIN
ESTRUCTURAS DE DATOS
40
Este concepto toma su suporte fsico en el mecanismo de direccionamiento indirecto tal como se maneja en
los lenguajes de bajo nivel.
ESTRUCTURAS DE DATOS
INTRODUCCIN A LA PROGRAMACIN 33
Variable de trabajo
(apuntada por puntero)
puntero
Memoria
dinmica
Memoria
esttica
se declara una variable (puntVector) de tal forma que, al realizar la operacin new se
reserve el espacio necesario para almacenar un vector de 100 caracteres.
Adems de la operacin ya indicada de reserva (new), las referencias admiten las
siguientes operaciones:
34 INTRODUCCIN A LA PROGRAMACIN
ESTRUCTURAS DE DATOS
Aunque, como se ha indicado, una variable de tipo puntero apunta a una zona de
memoria (nodo) existe una situacin excepcional consistente en no apuntar a ninguno. En
Java se utiliza para esto la constante null.
Sobre las variables referencia, se realizan las operaciones propias del tipo de datos a
que pertenezcan.
41
Este tipo de operaciones deber hacerse con especial cuidado pues, si no se han tomado previamente las
precauciones oportunas, podra perderse la informacin almacenada en el nodo inicialmente apuntado por
<puntero1> (se perder si no tenemos otra referencia a esa informacin)
ESTRUCTURAS DE DATOS
INTRODUCCIN A LA PROGRAMACIN 35
20
40
60
80
100
int [] vector1;
Declara una variable llamada vector1 que es un vector de enteros inicialmente vaco.
Para indicar el tamao del vector, se puede hacer directamente en la propia lnea de
declaracin:
Int [] vector1 = new int [5];
Acceso:
o Al conjunto. Por ejemplo asignar un vector a otro del mismo tipo:
vector2 = vector1.
42
36 INTRODUCCIN A LA PROGRAMACIN
ESTRUCTURAS DE DATOS
Con lo que se podr realizar cualquier operacin acorde con el tipo del elemento
correspondiente. Por ejemplo, si datos es un vector de nmeros enteros podramos hacer:
datos [3] = datos [3] * 2;
Ejemplo.
A continuacin se retoma el ejemplo expuesto en el apartado 1.3.4.1 (valores medio y
rango de un conjunto de 5 nmeros enteros) utilizando un vector.
import java.io.*;
public class PruebaVectores {
static float media (int [ ] dato) {
float resul = 0;
int i;
for (i = 0; i < 5; i ++)
resul = resul + dato [i];
resul = resul / i;
return resul;
}
static int max (int [] dato) {
int resul,i;
resul = dato[0];
for (i = 1; i<5; i++)
if (dato[i] > resul)
resul = dato[i];
return resul;
}
static int min (int [] dato) {
int resul,i;
resul = dato[0];
for (i = 1; i < 5; i ++)
if (dato [i] < resul)
resul = dato [i];
return resul;
}
public static void main(String [] args)throws NumberFormatException,IOException{
int [ ] d = new int [5];
int i, rango;
float media;
BufferedReader linea = new BufferedReader(new InputStreamReader(System.in));
System.out.println ("Introduce cinco nmeros enteros: ");
for (i = 0; i < 5; i ++)
d[i] = Integer.parseInt (linea.readLine ());
media = media (d);
System.out.println ("El valor medio es: " + media);
rango = max (d) - min (d);
System.out.println ("y el rango: " + rango);
}
}
ESTRUCTURAS DE DATOS
INTRODUCCIN A LA PROGRAMACIN 37
7
8
6
5
7
6
5
15
17
13
14
14
16
13
1
2
3
4
5
6
(Con lo que se podr realizar cualquier operacin acorde con el tipo del elemento
correspondiente). Por ejemplo: temperaturas [3] [1] = temperaturas [3] [1] + 2;
Ejemplo.
El siguiente cdigo permite encontrar la temperatura mnima de la semana y el da en
que se produjo la mxima diferencia (en caso de coincidencia de varias se muestra el
primero de ellos). En el ejemplo anterior los resultados seran:
Temperatura mnima: 5 grados.
Da de mxima diferencia de temperaturas: 5 (10 grados).
38 INTRODUCCIN A LA PROGRAMACIN
ESTRUCTURAS DE DATOS
import java.io.*;
public class PruebaMatrices {
static BufferedReader linea=new BufferedReader(new
InputStreamReader(System.in));
public static void leerMatriz (int [][] temperaturas) throws
NumberFormatException, IOException{
int i,j;
for (i = 0;i < 7; i ++)
for (j = 0; j < 2; j ++) {
System.out.println ("Valor dia: " + i + " extremo: " + j + ": ");
temperaturas [i] [j] = Integer.parseInt (linea.readLine ());
}
}
public static int min (int [][] temperaturas) {
int resul, i;
resul = temperaturas [0] [0];
for (i = 1; i < 7; i++)
if (temperaturas [i] [0] < resul)
resul = temperaturas [i] [0];
return resul;
}
public static int maxDif (int [] [] temperaturas) {
int resul, i, dif;
resul = 0;
dif = temperaturas [0][1]- temperaturas [0][0];
for (i = 1; i < 7; i++) {
if (temperaturas [i][1] - temperaturas [i][0] > dif) {
dif = temperaturas [i][1] - temperaturas [i][0];
resul = i;
}
}
return resul;
}
public static void main(String[] args) throws NumberFormatException,
IOException{
int [][] temperaturas = new int [7][2];
int minimaTemperatura, diferenciaTemperaturas;
leerMatriz (temperaturas);
minimaTemperatura = min (temperaturas);
diferenciaTemperaturas = maxDif (temperaturas);
System.out.println ("Resultados:");
System.out.println ("Temperatura minima: " + minimaTemperatura);
System.out.println ("Dia extremo: " + diferenciaTemperaturas);
}
}
ESTRUCTURAS DE DATOS
INTRODUCCIN A LA PROGRAMACIN 39
1.4.2.1.3. N-dimensionales.
Por extensin, lo explicado para una y dos dimensiones se puede aplicar al caso de
matrices N-dimensionales.
1.4.2.2. Estructuras de datos heterogneas.
Como ya se ha indicado, estn constituidas por un conjunto de tipos de datos (ya sean
datos simples u otras estructuras de datos) de diferente naturaleza. La forma bsica de
estructura de datos heterognea es el registro cuyos elementos se llaman campos (o
atributos)44.
Por ejemplo, la figura siguiente muestra un registro (alumno) cuyos campos son: el
nmero de matrcula (numeroMatricula), apellidos (apellidos), nombre (nombre), direccin
de correo electrnico (eMail), ao de nacimiento (anio) y calificacin (calificacion).
alumno
numeroMatricula
apellidos
nombre
ao
calificacion
bc2658
Snchez Arellano
Estela
esanchez@servidor.es
1987
6.75
String numeroMatricula;
String apellidos;
String nombre;
String eMail;
int ao;
float calificacion;
44
Con frecuencia uno de los campos (o combinacin de ellos) se utiliza como identificativo del registro. A
dicho campo (o conjunto) se le denomina clave (key).
45
Existen otras operaciones. Consultar el manual del lenguaje.
40 INTRODUCCIN A LA PROGRAMACIN
ESTRUCTURAS DE DATOS
Acceso:
o Al conjunto. Por ejemplo apuntar con una variable de tipo registro mismo sitio
que apunta otra del mismo tipo:
variable2_RegistroAlumno = variable1_RegistroAlumno;
Con lo que se podr realizar cualquier operacin acorde con el tipo del
elemento correspondiente. Por ejemplo: alumno.eMail = esanchez@servidor.es;
Normalmente, el trabajo con un registro (o con un conjunto pequeo de variables
independientes de tipo registro) ofrece poco juego. Lo habitual es utilizar una coleccin
de registros estructurados en un vector, o mucho mejor, almacenarlos, como un fichero
en un dispositivo de almacenamiento externo (tpicamente disco).
La utilizacin de ficheros en dispositivos de almacenamiento externos se explica en el
apartado 1.5. A continuacin se muestra un ejemplo que utiliza un vector de registros del
tipo anterior cuyo modelo se ilustra grficamente en la figura siguiente:
0
1
2
3
4
5
numeroMatricula
apellidos
nombre
ao
calificacion
aa1253
ax0074
mj7726
lp1523
bc2658
gb1305
Arias Gonzlez
Garca Sacedn
Lpez Medina
Ramrez Heredia
Snchez Arellano
Yuste Pelez
Felipe
Manuel
Margarita
Jorge
Estela
Juan
farias@servidor.es
mgarcia@servidor.es
mlopez@servidor.es
jramirez@servidor.es
esanchez@servidor.es
jyuste@servidor.es
1988
1985
1990
1998
1989
1990
3.50
8.35
7,70
4,50
6.75
5,50
ESTRUCTURAS DE DATOS
INTRODUCCIN A LA PROGRAMACIN 41
Import java.io.*;
class RegistroAlumno {
public RegistroAlumno () {
numeroMatricula= null;
apellidos = null;
nombre = null;
eMail= null;
ao = 1980;
calificacion = 0;
}
public String aCadena () {
return numeroMatricula + " " + apellidos + " " + nombre + " " + eMail +
" " + ao + " " + calificacion;
}
public String numeroMatricula;
public String apellidos;
public String nombre;
public String eMail;
public int ao;
public float calificacion;
public void cargarRegistro () throws IOException {
BufferedReader linea = new BufferedReader (new InputStreamReader (System.in));
System.out.println ("Numero de matricula: ");
numeroMatricula = new String (linea.readLine ());
System.out.println ("Apellidos: ");
apellidos = new String (linea.readLine ());
System.out.println ("Nombre: ");
nombre = new String (linea.readLine ());
System.out.println ("Correo electronico: ");
eMail = new String (linea.readLine ());
System.out.println ("Ao de nacimiento: ");
ao = Integer.parseInt (linea.readLine());
System.out.println ("Calificacin: ");
calificacion = Float.parseFloat (linea.readLine());
System.out.println (this.aCadena ());
}
}
42 INTRODUCCIN A LA PROGRAMACIN
ESTRUCTURAS DE DATOS
import java.io.*;
public class PruebaRegistro {
static void cargarTabla (RegistroAlumno [ ] alumnos) throws IOException {
int i;
for (i = 0; i < 6; i++) {
System.out.println ("Datos del alumno N: "+ i);
alumnos [i].cargarRegistro ();
}
}
static float mediaCalif (RegistroAlumno [ ] alumnos) {
float resul = 0;
int i;
for (i = 0; i < 6; i++) {
System.out.println(alumnos [i].aCadena ());
resul = resul + alumnos [i].calificacion;
}
return resul/6;
}
public static void main (String [ ] args) throws IOException {
RegistroAlumno [ ] alumnos = new RegistroAlumno [6];
float media;
int i;
for (i = 0; i < 6; i++)
alumnos [i]= new RegistroAlumno ();
cargarTabla (alumnos);
media = mediaCalif (alumnos);
System.out.println ("La media de las calificaciones es: " + media);
}
}
ESTRUCTURAS DE DATOS
INTRODUCCIN A LA PROGRAMACIN 43
Entre cada una de las lneas existen cdigos invisibles cuyo efecto es hacer saltar al
inicio de la lnea siguiente. Estos cdigos se generan automticamente al pulsar la tecla
Intro. As mismo, para indicar el final del fichero de texto, el usuario deber haber
pulsado la tecla de funcin F6.
La figura siguiente muestra el cdigo ASCII correspondiente al ejemplo.
46
Este concepto est heredado de los antiguos ficheros (o archivadores) que contenan fichas (de papel)
cada una de las cuales representaba una informacin unitaria: ficheros de pelculas, personas, asignaturas.
44 INTRODUCCIN A LA PROGRAMACIN
ESTRUCTURAS DE DATOS
import java.io.*;
public class prueba_fichero_texto {
lineaLeida
Marse.txt
47
La ruta, nombre y extensin del fichero se eligen libremente (con las restricciones propias del sistema
operativo). En el ejemplo se han utilizado:
Ruta: (por omisin) la misma que el programa.
Nombre: archivo.
Extensin txt (para poder visualizarlo mediante el bloc de notas notepad- de Windows).
ESTRUCTURAS DE DATOS
INTRODUCCIN A LA PROGRAMACIN 45
import java.io.*;
public class PruebaFicheroSalida {
public static void main (String [ ] args) throws IOException {
FileWriter fich_s = new FileWriter ("archivo.txt");
BufferedWriter bw = new BufferedWriter (fich_s);
PrintWriter salida = new PrintWriter (bw);
BufferedReader linea = new BufferedReader (new InputStreamReader(System.in));
String lineaLeida;
System.out.println ("Escriba la primera
lineaLeida = new String (linea.readLine
salida.println (lineaLeida);
System.out.println ("Escriba la segunda
lineaLeida = new String (linea.readLine
salida.println (lineaLeida);
salida.close ();
linea: ");
());
linea: ");
());
}
}
46 INTRODUCCIN A LA PROGRAMACIN
ESTRUCTURAS DE DATOS
establece una vinculacin entre el nombre fsico del fichero y el nombre lgico.
Se utiliza una variable de tipo String (en el ejemplo: lineaLeida) como puente
entre la memoria del ordenador y el dispositivo de almacenamiento (disco). Segn
sea el sentido de la transferencia se puede hablar de lectura: disco memoria
(readline) o de escritura memoria disco (println).
Hay que preparar el fichero en disco para utilizarlo (apertura) y dejarlo disponible
para posteriores usos (cierre).
1.5.1.2. Sintaxis de las principales operaciones relacionadas con los ficheros de texto49.
Acceso (Asignacin y apertura) y declaracin de variables:
o Crear un nuevo fichero y destruir, en su caso, un fichero previo.
Posteriormente se podr escribir en l:
FileWriter <nombre lgico> = new FileWriter (<nombre fsico>);
BufferedWriter <buffer escritura> = new BufferedWriter (<nombre lgico>);
PrintWriter <variable> = new PrintWriter (<buffer escritura>);
Proceso:
o Leer (transferir a la variable correspondiente) el contenido de una lnea del
fichero y prepararse para la siguiente.
<variable tipo String> = <buffer lectura>.readline();
48
Dicho fichero estar gestionado por el sistema operativo. Con frecuencia se cambia de ubicacin los
ficheros (fsicos) y de no seguir esta filosofa, esto implicara re-escribir parte del cdigo cada vez que un
fichero cambiase de ubicacin.
49
Para mayor informacin consultar el manual de programacin.
ESTRUCTURAS DE DATOS
INTRODUCCIN A LA PROGRAMACIN 47
Terminacin:
o Dejar el fichero preparado para usos posteriores:
<variable>.close ();
Por ejemplo, si queremos leer un fichero hasta llegar al final lo podemos hacer
utilizando lo siguiente:
import java.io.*;
public class PruebaFicheroEntrada {
public static void main (String [ ] args) throws IOException {
String lineaLeida;
FileReader fichLeido = new FileReader ("archivo.txt");
BufferedReader entrada = new BufferedReader (fichLeido);
System.out.println ("Contenido del fichero: ");
while ((lineaLeida = entrada.readLine ()) != null)
System.out.println (lineaLeida);
entrada.close ();
}
}
Para poder leer y escribir objetos que se han declarado como serializables se utilizan
las clases ObjectInputStream y ObjectOutputStream, que cuentan con los mtodos
writeObject() y readObject().
Para escribir un objeto en un fichero se utilizar:
ObjectOutputStream <objEscrito> = new ObjectOutputStream (new
FileOutputStream("<nombre fichero>"));
<objEscrito>.writeObject (<variable>);
50
48 INTRODUCCIN A LA PROGRAMACIN
ESTRUCTURAS DE DATOS
Por simplicidad no se han considerado situaciones excepcionales (por excepcin). Por ejemplo:
No tiene sentido utilizar la opcin [2]: Cargar tabla de registros, si no existe el fichero en disco.
Tampoco lo tiene utilizar la opcin [3]: Calcular calificacin media, si no se ha ejecutado (con xito)
previamente la opcin [2].
ESTRUCTURAS DE DATOS
INTRODUCCIN A LA PROGRAMACIN 49
Inicio
menu
Mdulo
principal
Fin
crearFichero
cargarTabla
op
mediaCalif
50 INTRODUCCIN A LA PROGRAMACIN
ESTRUCTURAS DE DATOS
("OPCIONES:");
("Opcion 1: Crear fichero.");
("Opcion 2: Cargar tabla de registros.");
("Opcion 3: Calcular calificacion media.");
("Opcion 0: Salir.");
("\n Introduzca opcion: ");
ESTRUCTURAS DE DATOS
INTRODUCCIN A LA PROGRAMACIN 51
TEMA 1. ....................................................................................................................... 1
1.1.
1.1.1.
1.1.2.
1.2.
1.2.1.
1.2.2.
1.2.3.
Los datos................................................................................................. 6
1.2.4.
Sentencias. ............................................................................................ 10
1.3.
1.3.1.
1.3.2.
1.3.3.
1.3.4.
1.3.5.
Recursividad. ........................................................................................ 24
1.4.
1.4.1.
1.4.2.
1.5.
1.5.1.
1.5.2.