Vous êtes sur la page 1sur 65

Aprendiendo Java

y
Programacin Orientada a Objetos
Gustavo Guillermo Prez
www.compunauta.com
gustavo@compunauta.com
!asta "ue esta leyenda no desaparezca el libro no #a sido terminado revisar$
#ttp$%%compunauta.com%&orums%linu'%programacion%java%eboo(.#tml
para las actualizaciones diarias o semanales y para descargar el cdigo de los ejemplos.
Para navegar el )ndice con Adobe Acrobat *eader+ abrir &avoritos o boo(mar(s
INDICE DEL TEMARIO
Prlogo.....................................................................................................................................................,
-. ./0A1 -2.*O345.O*-O1.............................................................................................................6
7a 08"uina 9irtual de Java :J90+ Java 9irtual 0ac#ine;................................................................6
<it de desarrollo y /ntorno de ejecucin :J3<+ J*/;....................................................................6
5omandos "ue inician el J3<+ J*/................................................................................................6
1alida por pantalla de los comandos del J3<+ J*/........................................................................=
Programacin Orientada a Objetos con Java.......................................................................................>
3escripcin /mp?rica del &uncionamiento del entorno J*/...........................................................>
!erencia soportada por Java.........................................................................................................@A
.ipos de datos B8sicos..................................................................................................................@A
Operadores y 3elimitadores B8sicos............................................................................................@@
2ombres de variables y &unciones................................................................................................@C
--. 5odi&icacin -nicial y /structuras de 3atos......................................................................................@D
/l primer programa............................................................................................................................@D
Pa"uetes........................................................................................................................................@D
Palabras clave o reservadas...........................................................................................................@,
.ipos de datos..........................................................................................................................@,
Permisos y declaracin de clases+ propiedades o mtodos......................................................@,
Bucles y tomas de decisin......................................................................................................@6
*eservadas................................................................................................................................@=
/'cepciones+ control de errores...............................................................................................@=
1ecuencias de escape....................................................................................................................@=
5oncatenacin y conversiones a te'to...............................................................................................@E
1alida por pantalla y entrada por teclado...........................................................................................@F
1ystem.out.....................................................................................................................................@>
1ystem.in.......................................................................................................................................CA
1ystem.err.....................................................................................................................................CA
1ystem.e'it:int cod;G.....................................................................................................................C@
7eer l?neas de la entrada est8ndar.................................................................................................C@
5rear Objetos :de la biblioteca de Java;............................................................................................CC
/l blo"ue de control de errores+ tryHIcatc#:;HI.................................................................................CC
/jercicios...........................................................................................................................................CD
C.@. /ntrada de 3atos y conversiones. Ji&+ try+ catc#K...................................................................CD
C.C 2umberLormat/'ception w#ile:;HI.......................................................................................C,
C.D 0ezcla de bucles doHI w#ile:;G y &or:GG;HI.............................................................................C,
C., 1witc# 1elect...........................................................................................................................C6
Pr8ctica 5omplementaria *esuelta :sin procedimientos+ sin arreglos;.............................................C6
P.5./@...........................................................................................................................................C=
P.5./C...........................................................................................................................................CE
P.5./D...........................................................................................................................................CE
P.5./,...........................................................................................................................................C>
P.5./6...........................................................................................................................................DA
P.5./=...........................................................................................................................................D@
P.5./E...........................................................................................................................................DC
P.5./F...........................................................................................................................................DD
P.5./>...........................................................................................................................................D6
Pr8ctica 5omplementaria :bucles sin arreglos;.................................................................................DF
5ap?tulo D M 0todos est8ticos y 0ecanismos de Programacin..........................................................D>
0todos est8ticos :&unciones o procedimientos;...............................................................................D>
Arreglos :Arrays; o 9ectores............................................................................................................,@
P8gina C%=6
7a clase 0at# de procedimientos y constantes matem8ticas............................................................,C
Bu&&ering M 0emoria temporal..........................................................................................................,6
4sando arreglos para un bu&&er+ colas de espera+ pilas y listas.....................................................,6
-mplementacin del bu&&er tipo L-LO :5ola de espera+ el primero es primero en salir;..........,=
-mplementacin del bu&&er tipo 7-LO :7a pila+ Nltimo en llegar es primero en salir;.............6@
-mplementacin de una 7ista de datos.....................................................................................66
BNs"ueda de datos.............................................................................................................................6E
BNs"ueda secuencial.....................................................................................................................6E
BNs"ueda aleatoria+ desordenar lista.............................................................................................6E
BNs"ueda Binaria :lista ordenada;................................................................................................6F
P8gina D%=6
Prlogo
/ste libro se #izo con la idea de proveer a mis alumnos y cursos un material did8ctico con "u
trabajar :tambin es Ntil para pro&esores y otros cursos; y al mismo tiempo dar una idea concisa de lo
"ue signi&ican los objetos en Java. 7a programacin orientada a objetos en Java no es tratada y
en&ocada en muc#os te'tos tutoriales+ manuales o libros sobre el tema y considero "ue es la etapa
inicial del aprendizaje donde se &alla en muc#os cursos respecto a Java. Por otro lado los estudiantes
"ue recin se inician en la programacin+ no podr8n ir muy lejos si no se les inculca los conceptos
b8sicos+ entonces este material no avanzara de lleno sobre la programacin orientada a objetos+ sino
#asta "ue los conceptos de programacin b8sicos+ como tomas de decisin+ bucles+ variables etc+ estn
&ijados lo su&iciente.
Java es un lenguaje muy Ntil debido a la opcin multiplata&orma "ue provee :desde P5+ 7inu'+
Oindows+ #asta 0A5+ tel&onos+ poc(et P5s+ etc.; y veremos en el transcurso de este te'to como se
puede optimizar la ejecucin de una aplicacin Java para "ue se apro'ime a la ejecucin de un binario
nativo como los "ue se compilan con gcc.
Por lo tanto suponer "ue el alumno posee conocimientos avanzados de programacin orientada a
objetos o de otros lenguajes de programacin no siempre suele ser la mejor opcin+ en este libro
dejaremos en claro "ue el lenguaje de programacin Java tiene sus operadores matem8ticos b8sicos y
tipos de datos b8sicos sin importar "ue estos mismos e'istan o no en otros lenguajes de programacin.
/ste libro se distribuye bajo la licencia G24 GP7 vC+ con la e'cepcin "ue est8 pro#ibido #acer
impresiones modi&icadas del te'to+ si alguien tiene una sugerencia o una modi&icacin para sugerir+
puede enviar al correo electrnico indicado la in&ormacin+ para una &utura actualizacin o correccin.
7as sugerencias son bienvenidas.
P8gina ,%=6
I. TEMAS INTRODUCTORIOS
La Mquina Virtual de Java (JVM, Java Virtual Machine)
7a m8"uina virtual de Java se denomina al procesador o entorno virtual "ue se utiliza para
interpretar los bytecodes de los binarios de Java+ ya "ue como sabemos Java se #izo para correr en
cual"uier plata&orma sin recompilar los binarios. 3e esta manera este entorno virtual se puede obtener
para nuestra ar"uitectura y sistema operativo sin modi&icaciones a nuestro programa original :esto no
es cierto si utilizamos una mala din8mica de programacin;.
Podemos entonces generar un binario y este podr8 5orrer en 7inu'+ 0A5 O1P+ LreeB13+
1olaris+ o Oindows+ y para las ar"uitecturas disponibles en las "ue podamos obtener la J90+ como
ser A03=,+ 1PA*5+ P-9+ etc. etc.
7a m8"uina virtual de Java #a tenido la caracter?stica de ser un entorno de ejecucin pesado en
trminos de recursos del procesador y memoria+ "ue por medio de una administracin rigurosa del
sistema operativo estos podr?an llegar a ser insu&icientes y las aplicaciones ejecutarse de manera muy
lenta. /sto no es cierto en la actualidad+ e'isten alternativas a la J90 provista por 1un 0icrosystems
"ue permiten una velocidad comparable a una aplicacin compilada en 5QQ nativa en la ar"uitectura+
un ejemplo de esto es <a&&e+ <a&&e :www.(a&&e.org; es una m8"uina de Java Open1ource "ue puede
compilarse sin mayores modi&icaciones en nuestra ar"uitectura necesaria y correr8 incre?blemente m8s
r8pida "ue la distribucin est8ndar de J90 de 1un 0icrosystems y consumir8 muc#os menos
recursos.
Kit de desarrollo y Entorno de eje!in "#DK$ #RE%
/l <it de desarrollo conocido como J3< :Java 3evelopment <it; provee de un compilador+ un
mecanismo para comprimir un proyecto en un solo arc#ivo de tipo JA* :"ue es compatible con R-P; y
un entorno de ejecucin para nuestros binarios.
5uando nuestro proyecto terminado se prepara para distribuir+ no es necesario tener el
compilador y la mayor?a de las #erramientas "ue se proveen en el J3<+ entonces podemos prescindir
de dic#o J3< y utilizar el entorno de ejecucin "ue es m8s pe"ueSo en cuestiones slo de espacio en
disco. /ste J*/ :Java *untime /nvironment; tambin puede redistribuirse sin problemas de licencias.
/n las plata&ormas basadas en 7inu'+ e'isten mejores #erramientas de desarrollo y por supuesto
en casi todas las distribuciones de 7inu'+ se encuentra disponible <it de desarrollo o J3<. As? como
recomendamos <a&&e como J90 para proyectos avanzados o de alto rendimiento+ recomendamos
Ji(es como compilador de Byte5odes para Java+ Ji(es no es interpretado como el compilador
proporcionado en el J3< de 1un 0icrosystems.
Co&andos '!e iniian el #DK$ #RE
Comando Descripcin
java
-nicia el entorno de ejecucin recibiendo como argumento el nombre del binario ejecutable
en &ormato Byte5odes sin la e'tensin de arc#ivo .class "ue identi&ica de manera visual un
binario java. /ste comando es parte de J3< y J*/
javac
-nicia el compilador Java recibiendo como argumento todos los arc#ivos de cdigo &uente
cuya terminacin es .java incluida dic#a e'tensin. /ste comando no es parte de J*/.
jar
Por medio de este comando iniciamos el empa"uetador de clases y arc#ivos de Java "ue nos
permiten &abricar un Nnico arc#ivo contenedor de nuestras aplicaciones+ multimedia y
gr8&icos. /ste comando es parte slo de J3<.
P8gina 6%=6
Salida (or (antalla de los o&andos del #DK$ #RE
1i abrimos una consola de comandos+ y ejecutamos estos comandos podremos detectar la
versin del entorno de ejecucin y las rdenes de entrada "ue estos soportan.
/n 7inu'+ podemos abrir una P.erm+ buscando el menN ejecutar y escribiendo xterm. /n
Oindows+ podemos #acerlo abriendo el di8logo ejecutar y escribiendo command o cmd dependiendo
si el sistema es basado en 2. o >P.
gus@gusgus ~ $ java
Usage: java [-options] class [args...]
(to execute a class)
or java [-options] -jar jarfile [args...]
(to execute a jar file)
where options include:
-client to select the "client" VM
-server to select the "server" VM
-hotspot is a synonym for the "client" VM [deprecated]
The default VM is client.
-cp <class search path of directories and zip/jar files>
-classpath <class search path of directories and zip/jar files>
A : separated list of directories, JAR archives,
and ZIP archives to search for class files.
-D<name>=<value>
set a system property
-verbose[:class|gc|jni]
enable verbose output
-version print product version and exit
-version:<value>
require the specified version to run
-showversion print product version and continue
-jre-restrict-search | -jre-no-restrict-search
include/exclude user private JREs in the version search
-? -help print this help message
-X print help on non-standard options
-ea[:<packagename>...|:<classname>]
-enableassertions[:<packagename>...|:<classname>]
enable assertions
-da[:<packagename>...|:<classname>]
-disableassertions[:<packagename>...|:<classname>]
disable assertions
-esa | -enablesystemassertions
enable system assertions
-dsa | -disablesystemassertions
disable system assertions
gus@gusgus ~ $ java -version
java version "1.4.2-02"
Java(TM) 2 Runtime Environment, Standard Edition (build Blackdown-1.4.2-02)
Java HotSpot(TM) Client VM (build Blackdown-1.4.2-02, mixed mode)
gus@gusgus ~ $
P8gina =%=6
4sando <a&&e y Ji(es
gus@gusgus ~ $ java -version
java full version "kaffe-1.4.2"
kaffe VM "1.1.6"
Copyright (c) 1996-2005 Kaffe.org project contributors (please see
the source code for a full list of contributors). All rights reserved.
Portions Copyright (c) 1996-2002 Transvirtual Technologies, Inc.
The Kaffe virtual machine is free software, licensed under the terms of
the GNU General Public License. Kaffe.org is a an independent, free software
community project, not directly affiliated with Transvirtual Technologies,
Inc. Kaffe is a Trademark of Transvirtual Technologies, Inc. Kaffe comes
with ABSOLUTELY NO WARRANTY.
Engine: Just-in-time v3 Version: 1.1.6 Java Version: 1.4
Heap defaults: minimum size: 5 MB, maximum size: unlimited
Stack default size: 256 KB
gus@gusgus ~ $ javac
Usage: javac <options> <source files>
where possible options include:
-g Generate all debugging info
-g:none Generate no debugging info
-g:{lines,vars,source} Generate only some debugging info
-nowarn Generate no warnings
-verbose Output messages about what the compiler is doing
-deprecation Output source locations where deprecated APIs are
used
-classpath <path> Specify where to find user class files
-sourcepath <path> Specify where to find input source files
-bootclasspath <path> Override location of bootstrap class files
-extdirs <dirs> Override location of installed extensions
-d <directory> Specify where to place generated class files
-encoding <encoding> Specify character encoding used by source files
-source <release> Provide source compatibility with specified release
-target <release> Generate class files for specific VM version
-help Print a synopsis of standard options
gus@gusgus ~ $
P8gina E%=6
gus@gusgus ~ $ jar
Sintaxis: jar {ctxu}[vfm0Mi] [archivo-jar] [archivo-manifest] [-C dir] archivos
...
Opciones:
-c crear nuevo contenedor
-t mostrar contenido de contenedor
-x extraer archivos nombrados (o todos) del contenedor
-u actualizar contenedor existente
-v generar salida detallada en salida estndar
-f especificar nombre de archivo contenedor
-m incluir informacin de manifest del archivo manifest especificado
-0 solo almacenar; no utilizar compresin ZIP
-M no crear un archivo manifest para las entradas
-i generar informacin de ndice para los archivos jar especificados
-C cambiar al directorio especificado e incluir el archivo siguiente
Si alguno de los archivos es un directorio, se procesar de forma recursiva.
Se deben especificar los nombres del archivo manifest y del archivo contenedor
en el mismo orden en que se especifiquen los indicadores 'm' y 'f'.
Ejemplo 1: para archivar dos archivos de clase en un contenedor llamado
classes.jar:
jar cvf classes.jar Foo.class Bar.class
Ejemplo 2: utilizar un archivo manifest existente, 'mymanifest', y archivar todos
los
archivos del directorio foo/ en 'classes.jar':
jar cvfm classes.jar mymanifest -C foo/ .
gus@gusgus ~ $
P8gina F%=6
Programacin Orientada a Objetos con Java
5omo es sabido #ay muc#os lenguajes de programacin orientada a objetos POO "ue tienen
muc#as similitudes entre si+ pero puntualmente nos en&ocaremos en Java+ utilizaremos para tal e&ecto
un modelo de &8brica de objetos+ para introducir los trminos clase+ objeto, mtodo, propiedad,
esttico, dinmico, donde la &8brica de objetos ser8 el entorno de ejecucin o J*/.
Ilustracin 1: La fbrica de Objetos dentro de !"
Desri(in E&()ria del *!niona&iento del entorno #RE
5omo podemos ver en la imagen anterior la &8brica de objetos utiliza memoria del sistema para
&abricar los objetos+ pero para &abricarlos necesita la in&ormacin pregrabada llamada clases+ las clases
son las "ue almacenan las propiedades y mtodos "ue contendr8 un objeto. 4n objeto cambiar8 sus
propiedades o las propiedades de otros objetos por medio de los mtodos. 7os mtodos "ue slo
pueden ejecutarse cuando el objeto e'iste+ son los denominados din8micos+ y los mtodos "ue
pertenecen a la clase son denominados est8ticos+ por"ue pueden ser llamados sin necesidad de la
e'istencia de un objeto.
/n el ejemplo tenemos dos objetos+ *eloj y 78mpara los cuales tienen mtodos 5uerda e
-nterruptor+ "ue son los "ue cambiaran el estado de las propiedades !ora e -luminando. 7a clase reloj+
podr?a tener un mtodo esttico llamado ponerTenT#ora+ para ajustar todos los relojes &abricados. /l
programa en ejecucin inicia en un mtodo esttico ya "ue no e'isten inicialmente objetos en nuestro
programa+ este mtodo se llama main "ue se de&ine como$
static int main(String[] args){
.....
}
3onde ar#s es un vector o arreglo unidimensional "ue contendr8 los argumentos "ue #ayan sido
pasados al comando java despus de las rdenes y el nombre de la clase principal "ue alojar8 este
mtodo. /l entorno de ejecucin o la J90 &abricar8 objetos de sistema "ue podr8n ser utilizados
llamando a mtodos estticos de clases pertenecientes a la biblioteca de java.
P8gina >%=6
RAM
Objeto
Lmpara
JVM
Clase
Reloj
Clase
Lamp
Objeto
Reloj
Propiedad
Hora
Propiedad
Ilumina
Mtodo
Interruptor
Mtodo Cuerda
Programa en Ejeui!n
Nota: Java provee una documentacin completa en ingls de toda la biblioteca incluida en
la versin de JRE o JDK, una buena prctica es no utilizar las ms avanzadas y
complejas funciones de la !" #pplication !rograming "nterface$ ya %ue al %uerer
iniciar nuestro programa en una versin anterior %ue no tenga una biblioteca
actualizada, se pueden producir problemas de mtodos faltantes&
+erenia so(ortada (or #a,a
Java no soporta #erencia mNltiple+ es decir no podemos &abricar un objeto m8s complejo con dos
di&erentes m8s simples+ sino "ue slo podremos #eredar objetos nuevos de un slo objeto padre+ "ue
proveer8 los mtodos y propiedades b8sicas "ue ser8n e'tendidas y%o ampliadas por el nuevo objeto.
/s decir no podr?amos tener un objeto 78mpara *eloj "ue derive del objeto 78mpara y del objeto
*eloj+ sino "ue tendr?amos "ue usar otros mecanismos para proporcionar esa &uncionalidad+ inter&aces
y alojamiento de objetos.
/sto podr?a comprenderse como$
-nter&aces$ Permiten "ue sean implementadas por objetos para ad"uirir comportamiento+ pero
el comportamiento no es provisto por la inter&az+ sino "ue el programador debe proporcionar
una manera e&icaz de construir los mtodos de&inidos en dic#a inter&az uno por uno. Pueden
implementarse varias inter&aces al mismo tiempo+ en todos los casos es necesario codi&icar
&unciones o mtodos.
Alojamiento$ Podemos pensar "ue al objeto 78mpara le insertamos en su interior un objeto
*eloj entonces podemos llamar a los mtodos del *eloj "ue est8 en la 78mpara+ esto lo
veremos m8s adelante en algunos ejemplos. Ua no ser?a la 78mpara *eloj+ pero ser?a una
78mpara con *eloj.
!erencia$ 2os permite crear un objeto nuevo en base a uno e'istente+ es una nueva clase de
objeto+ puede utilizar el alojamiento de otros objetos como propiedades para ad"uirir
&uncionalidad.
Ti(os de datos -.sios
/n todos los lenguajes de programacin e'isten tipos de datos b8sicos con los "ue se realizar8n
las operaciones matem8ticas b8sicas y las operaciones booleanas de verdadero o &also.
Tipo de Datos Alcance o Rango
int de VC@,E,FD=,F a C@,E,FD=,E :,bytes ;
byte de V@CF a @CE :@Byete;
s#ort de VDCE=F a DCE=E :CBytes;
long de V>CCDDECAD=F6,EE6FAF a >CCDDECAD=F6,EE6FAE :FBytes;
c#ar de WXuAAAAW a WXu&&&&W+ ambos incluidos "ue es lo mismo "ue de A a =66D6+ @ letra
boolean A o @ :@bit;
&loat ,Bytes+ punto &lotante
double FBytes+ punto &lotante
1tring 2o es un tipo de datos b8sico+ es un objeto b8sico+ con propiedades y mtodos+
pero el lenguaje Java permite de&inir un nuevo objeto con el delimitador :Y;+
por lo "ue podemos concatenar :unir; te'to utilizando el operador :Q; con los
nombres de los objetos de tipo 1tring y los trozos de te'to delimitados con :Y;.
$abla 1: $ipos de datos bsicos
P8gina @A%=6
O(eradores y Deli&itadores -.sios
Operador Datos Accin
+
1tring 4ne te'to :concatenador;.
nNmero 1uma.
-
nNmero invierte el signo del nNmero.
nNmero *esta.
nNmero 0ultiplica y tiene prioridad sobre la suma y resta.
% nNmero 3ivide y tiene prioridad sobre la suma y resta.
Z nNmero 3evuelve el resto de la divisin del operador derec#o por el iz"uierdo.
! booleano /l operador NOT booleano.
[ nNmero -nvierte bit por bit el operando de la derec#a
&
entero o
booleano
/l operador AND+ booleano bit por bit del elemento a la iz"uierda contra el de la
derec#a.
&& 5ual"uier /l operador A23 condicional.
|
entero o
booleano
/l operador OR+ booleano bit por bit del elemento a la iz"uierda contra el de la
derec#a.
|| 5ual"uier /l operador O* condicional.
\\ nNmero 3esplaza los bits #acia la iz"uierda la cantidad de la derec#a.
]] nNmero 3esplaza los bits #acia la derec#a la cantidad de la derec#a.
]]] nNmero 3esplaza bits #acia la derec#a pero no conserva el signo.
== 5ual"uier
/l operador condicional de igualdad+ devuelve verdadero si derec#a e iz"uierda es
lo mismo.
\ B8sicos 0enor "ue+ devuelve verdadero si iz"uierda es menor "ue derec#a.
\^ B8sicos 0enor o igual "ue+ devuelve verdadero si iz"uierda es menor o igual "ue derec#a.
] B8sicos 0ayor "ue+ devuelve verdadero si iz"uierda es mayor "ue derec#a.
]^ B8sicos 0ayor o igual "ue+ devuelve verdadero si iz"uierda es mayor o igual "ue derec#a.
= 5ual"uier Asigna al elemento de la iz"uierda+ el de la derec#a.
(op)= B8sicos
!ace la operacin op JQ+V++%.etc..K entre los dos operandos y el resultado lo guarda
en el de la iz"uierda.
varQQ B8sicos -ncrementa en uno la variable var.
varVV B8sicos 3ecrementa en uno la variable var.
& objetos
1epara los nombres de los objetos o propiedades o mtodos o nombres y jerar"u?a
de clases.
(int) tipo de datos
5onvierte un tipo de datos a entero+ si reemplazamos int por una clase de objetos+
podemos siempre y cuando sea correcto convertir al tipo de datos indicado entre
parntesis.
G 5ual"uier .ermina una l?nea de orden.
+ 5ual"uier 1epara argumentos de un mtodo o &uncin.
%% 5ual"uier /mpieza una l?nea de comentario.
% % 5ual"uier 3elimitan un trozo de te'to como comentario.
% % 5ual"uier 3elimitan un trozo de te'to como documentacin para Java3oc
P8gina @@%=6
Operador Datos Accin
HI 5ual"uier 3elimitan un blo"ue de cdigo de una estructura de datos.
: ; 5ual"uier
Asocia una operacin teniendo prioridad+ o en caso de un mtodo agrupa los
argumentos separados por comas.
$abla %: Operadores &sicos
No&/res de ,aria/les y *!niones.
/n Java los nombres de las variables y las &unciones siguen ciertas reglas+ por ejemplo las
variables se acostumbra a nombrarlas con todas sus letras en minNsculas+ las &unciones con la primer
palabra "ue la identi&ica en minNsculas y las palabras siguientes con la primer letra en mayNsculas y
los nombres de las 5lases de objetos con la primer letra de cada palabra "ue la de&ine en mayNsculas.
/jemplos$
9ariables
int soles=3;
char salir='q';
Lunciones$
public static int redondearPromedio(int[] valores){
...
}
5lases$
public class RelojAtomico{
....
}
P8gina @C%=6
II. Codi*iain Iniial y Estr!t!ras de Datos
Nota: En este captulo veremos como codificar y compilar el primer programa, a
continuacin emplearemos los operadores y tipos de datos !sicos y por "ltimo
veremos las estructuras de datos !sicas soportadas por #ava$
l !rimer !rograma
1uponemos "ue nuestro sistema operativo ya tiene instalado el (it de desarrollo :J3<; y
procedemos a abrir un editor de te'to de nuestro gusto. /n <3/+ podemos abrir %&rite en otros
sistemas bus"uemos loc% de notas u otro editor como Edit'lus+ de todas maneras cual"uier editor
estar8 bien.
3entro del editor de te'tos escribiremos lo siguiente$
public class HolaMundo {
public static void main(String[] args) {
System.out.println("Hola, mi primer programa");
}
}
/l arc#ivo debe guardarse como 'ola(undo.java respetando las mayNsculas y minNsculas+
necesitamos compilar el programa para obtener el binario con e'tensin class+ entonces procedemos a
llamar al compilador con una consola de comandos para poder despus usar la J90 :comando java;
para correr el programa+ pero para trabajar mejor #aremos una carpeta donde guardaremos los
ejemplos+ para los "ue usen Oindows #8ganla en la unidad c$X y nmbrenla ejemplos+ para los "ue
usamos un sistema mejor+ en nuestra carpeta de usuario y la llamamos ejemplos tambin slo "ue en
minNsculas.
gus@gusgus ~ $ cd ejemplos
gus@gusgus ~/ejemplos $ javac HolaMundo.java
gus@gusgus ~/ejemplos $ java HolaMundo
Hola, mi primer programa
gus@gusgus ~/ejemplos $
Nota: (!s adelante veremos como utili)ar un editor asado en #ava para practicar este
curso, antes de e*plicar lnea por lnea del programa, es necesario introducir un tema
+ue ser! utili)ado con muc,a frecuencia, estos son los pa+uetes, los cuales dar!n el
concepto de Clase '"lica$
Pa'!etes
/n el ejemplo anterior #emos omitido una parte esencial de la programacin en el lenguaje Java+
estos son los Pa)uetes+ se utilizan para di&erenciar una clase respecto de otras con el mismo nombre+
si nos ponemos a pensar sobre la cantidad de nombres di&erentes de clases "ue podemos poner a los
tipos de objetos en nuestros programas es in&inita+ pero dos programadores di&erentes pueden llegar a
usar dos veces el mismo nombre para una misma clase+ de esta manera podemos #acer "ue slo las
clases de objetos "ue #aremos visibles a otros programadores o "ue ejecutar8n el componente
principal del programa :el mtodo est8tico main; sean pNblicas.
7as clases de objetos "ue no "ueramos #acer visibles a otros componentes de nuestro proyecto+
entonces se podr8n declarar como privadas+ de esa manera slo una clase de objetos "ue pertenezca al
grupo de clases podr8 acceder a las dem8s privadas.
P8gina @D%=6
7os pa"uetes suelen tener un nombre especial re&erente al de la organizacin "ue realiza el
proyecto+ esto es una sugerencia+ en realidad se puede utilizar casi cual"uier nombre+ as? "ue por
ejemplo si nuestra empresa es compunauta+ y el nombre de dominio de los servicios "ue se
proporcionan en -nternet es compunauta.com+ entonces nuestro pa"uete podr?a llamarse
com.compunauta y a su vez si tenemos un subproyecto+ este podr?amos nombrarlo como
com.compunauta.aprendiendojava+ slo tengamos en cuenta "ue es el orden inverso de como
aparecer?a en -nternet. 4samos puntos para separar los nombres y tenemos cuidado respecto de las
mayNsculas y minNsculas.
Nota: El lengua-e #ava es sensile a las may"sculas y min"sculas, es decir si tenemos el
nomre del pa+uete com$compunauta$aprendiendo-ava no ser! lo mismo si lo
escriimos como com$compunauta$Aprendiendo#ava$ De la misma manera no es lo
mismo .ola(undo +ue ,olamundo$
Pala/ras la,e o reser,adas
7as palabras clave o reservadas son a"uellas "ue de&inen o se combinan con una de&inicin de
datos de una variable o propiedad+ clase de objetos o mtodos+ por ejemplo class es una palabra clave
y nos indica "ue a continuacin pondremos el nombre a la clase de objeto "ue vamos a crear+ si
"ueremos "ue dic#a clase pueda ser accedida desde dentro o &uera de nuestro pa"uete de clases de
objetos+ entonces la de&iniremos como public :pNblica;+ donde esta es otra palabra clave.
A veces las palabras claves son palabras reservadas+ por ejemplo #oto es una palabra clave
reservada en Java+ ya "ue no tenemos permitido saltar a una l?nea en particular de nuestro programa+
tenemos "ue trabajar con llamadas a &unciones y otras maneras de codi&icacin.
"i!os de datos
3e&inen tipos de datos "ue devolver8n los mtodos o los tipos de datos "ue de&inir8n una
propiedad b8sica. /stos ya los #ab?amos visto anteriormente pero a#ora los describiremos por el
espacio "ue ocupan en memoria.
'alara Clave /ignificado
boolean 9alores Booleanos :@bit;
byte @Byte+ nNmero entero :Fbits;
short CBytes+ nNmero entero
int ,Bytes+ nNmero entero
long FBytes+ nNmero entero
char CBytes+ :s#ort; @5aracter
float ,Bytes+ punto &lotante.
double FBytes+ punto &lotante+ doble precisin
void 5uando no #ay nada "ue devolver
null .ipo de datos 2ulo+ vac?o+ cual"uier operacin sobre null produce un error.
$abla *: Palabras claves + $ipos de datos
Permisos # declaracin de clases, !ro!iedades o m$todos%
3e&inen los permisos a un mtodo o clase de objetos+ #aciendo visible u oculto un mtodo
propiedad o clase a otras clases de objetos u otros objetos "ue "uieran accederlas.
P8gina @,%=6
'alara clave /ignificado
public Para una clase+ "ue es accesible desde cual"uier parte+ para un mtodo+ "ue es
accesible por cual"uier mtodo "ue pueda acceder a la clase de objetos. Para "ue
una clase "ue deriva de otra tiene "ue ser pNblica la clase de objetos padre para
poder ser accecible.
private 1lo se permite a la misma clase de objetos acceder a sus propiedades o mtodos.
protected 1lo se permite al pa"uete acceder a esta clase.
pac(age 3e&ine a "ue pa"uete pertenece una clase.
import 3e&ine "ue pa"uetes usaremos+ para no escribir el nombre completo de la clase a la
"ue #acemos re&erencia como$ com.compunauta.aprendiendojava.'ola(undo
class -nicia la declaracin de una 5lase :tipo de datos;.
new -nstancia un objeto+ crea un objeto partiendo de una clase en particular.
$abla ,: Palabras clave + Permisos - .eclaraciones
&ucles # tomas de decisin
1e utilizan para el control de bucles y tomas de decisin en un programa+ se utilizan parntesis :;
para encerrar las condiciones+ y llaves HI para los blo"ues de datos
'alara clave /ignificado
if :condicion;H
....
I else H
....
I
/jecuta el blo"ue separado por HI siempre y cuando se cumpla la condicin+
acompaSada a esta estructura e'iste else :sin; "ue es para el caso contrario a la
condicin+ sin tener "ue evaluar la condicin negada.
for :inicialGcondicinGrepeticin;H
....
I
1e ejecuta la sentencia inicial+ y si se cumple la condicin se ejecuta el cdigo en el
interior de la llaves+ una vez "ue se termina se ejecuta la repeticin y se vuelve a
comparar la condicin+ mientras la condicin sea cierta el blo"ue encerrado entre
llaves se seguir8 ejecutando.
'(ile :condicin;H
....
I
0ientras se cumpla la condicin entre parntesis+ se ejecuta el cdigo en el interior
de HI de manera in&inita #asta.
s'itc( :varieblenumrica;H
case num@$
.....
brea(G
case numC$
.....
brea(G
de&ault$
I
7a sentencia switc# es un tanto compleja y probabil?sticamente poco usada ya "ue
no puede usarse con objetos y las comparaciones son primitivas+ en algunos trozos
o segmentos de cdigo es crucial para optimizar la velocidad de nuestro programa+
de acuerdo al contenido de la variable numrica se ejecuta la sentencia case "ue
coincida+ cada blo"ue de cdigo debe terminar con brea(+ ya "ue en caso contrario
se seguir8 ejecutando la siguiente cl8usula case+ e'iste una opcin de&ault "ue es
para cuando ninguno de los casos resulta ser el correcto.
doH
...
I'(ile:condicin;G
/l blo"ue dentro de la palabra clave do+ se ejecutar8 al menos una vez y si la
condicin de w#ile se cumple+ se repetir8 mientras sea cierta.
brea) -nterrumpe un blo"ue y se ejecuta la siguiente l?nea &uera de l.
continue -nterrumpe el resto del cdigo del blo"ue y vuelve a empezar con la siguiente
iteracin.
return -nterrumpe el mtodo entero y devuelve el tipo de datos de la derec#a al punto
donde se llam a la &uncin.
$abla /: Palabras 0lave + 0ontrol de 1lujos, tomas de decisin
P8gina @6%=6
'eservadas
'alara clave /ignificado
goto Palabra reservada en el lenguaje de programacin Java+ no puede utilizarse pero el
compilador en ciertas ocasiones es capaz de generar un comportamiento similar en
las optimizaciones+ de tal manera "ue los binarios si podr?an estar utilizando este
tipo de salto a una eti"ueta.
const Palabra reservada "ue no es utilizada por el momento en Java.
$abla 2: Palabras clave 3 !eservadas
(ce!ciones, control de errores
/n casi todos los lenguajes de programacin e'isten mecanismos para actuar segNn sucedan
errores de cual"uier tipo+ desde accesos al disco #asta divisin por cero+ los cuales de no ser
manipulados por nuestro programa tendr8n el comportamiento por de&ecto de la m8"uina virtual de
java+ "ue es reportarlos como e'cepciones y terminar el programa.
'alara clave /ignificado
t#rows -ndica "ue tipo de e'cepciones lanzar8 este mtodo en caso de errores+ es Ntil para
"ue los mtodos "ue llaman a este "ue lanzar8 una e'cepcin en caso de errores+ se
vean obligados a tratar esa situacin.
t#row .rans&iere el control de errores al manejador de e'cepciones.
tryH
...
Icatc(#tipo e'cepcion;H
...
IfinallyH
...
I
/sta es la estructura de un manejador de e'cepciones o control de errores+ try inicia
el blo"ue de cdigo "ue ser8 manejado en caso de errores+ la sentencia catc# indica
el tipo de e'cepcin "ue se capturar8+ esta Nltima puede repetirse para #acer cosas
di&erentes de acuerdo por ejemplo si el problema &ue una divisin por cero o un
error de acceso de disco. 7a sentencia &inally se ejecutar8 de todas maneras al salir
del cdigo.
1i una e'cepcin no es capturada por el listado de cl8usulas catc#+ entonces es
probable "ue la J90 inicie el reporte y la salida de la instancia completa de la
J90+ interrumpiendo todos los #ilos de ejecucin.
$abla 4: Palabras clave + 0ontrol de errores
Se!enias de esa(e
7as secuencias de escape son a"uellas combinaciones de caracteres "ue nos permiten insertar un
caracter especial "ue no es posible tipear con el teclado est8ndar o "ue no es posible utilizar por"ue
denota un trozo de te'to+ por ejemplo las comillas dobles en el ejemplo #ola mundo "ue est8n dentro
de la &uncin println.
System.out.println("Hola, mi primer programa");
1i "uisiramos incluir las comillas dobles en la ejecucin deber?amos incluirlas con una
secuencia de escape+ para ello se utiliza la barra invertida X seguida de las comillas dobles X_.
System.out.println("\Hola, mi primer programa\");
3e esa manera el compilador entiende "ue el trozo de te'to contendr8 las comillas dobles+ pero
"ue pasar?a si "uisiramos escribir el caracter X "ue en algNn sistema operativo distinto de 7inu'
podr?a signi&icar divisin de directorios o carpetas+ bueno para esto usar?amos una X seguida de otra X+
es decir XX para insertar el caracter X.
System.out.println("Hola, mi primer programa, est en c:\\");
P8gina @=%=6
A"u? #ay una lista de las secuencias de escape m8s usadas y una breve e'plicacin de su
utilidad+ ya "ue Java soporta 4nicode+ una representacin e'tensa de lo "ue es un caracter "ue permite
inclusin de varios idiomas.
/ecuencia /ignificado
Xb *etroceder un espacio :bac(space;
Xt .abulador !orizontal+ sirve para alinear te'to en la salida est8ndar de datos cuando
es una terminal o consola de comandos.
Xn 1alto de l?nea+ es el caracter usado incluso en las viejas impresoras "ue necesitaban
avanzar de l?nea para escribir en el pr'imo rengln.
Xr *etorno de carro+ es el caracter "ue devuelve el cursor o el cabezal de la imprezora
al inicio del rengln+ 7inu'+ usa Xn para un nuevo rengln en los arc#ivos de te'to+
Oindows utiliza una combinacin XnXr.
X_ -nsertan las comillas dobles
XW -nsertan la coma simple.
XX -nsertan la misma barra invertida "ue usamos como escape.
X333 7as tres 3 son d?gitos y representan un caracter en su versin octal.
Xu3333 7as cuatro 3 son d?gitos y representan un caracter unicode en #e'adecimal.
)oncatenacin # conversiones a te(to
7a concatenacin de te'to se denomina a la unin de trozos o &ragmentos de te'tos y
comNnmente se utiliza la conversin de nNmeros o de objetos a su representacin en te'to+ Java
convierte autom8ticamente los tipos de datos b8sicos a te'to antes de unirlos y llama por cada objeto
al mtodo especial to1tring:; para realizar la conversin de objetos nuestros o de la biblioteca de la
J90.
9eamos un ejemplo$
1. public class SumaSimple {
2. public static void main(String[] args) {
3. int a=1;
4. System.out.println("el valor de a="+a);
5. a=a+10;
6. System.out.println("ahora sumndole 10 es a="+a);
7. }
8. }
/n la l?nea @+ de&inimos el nombre de la clase+ "ue es pNblica y se llama 5uma5imple+ en la
segunda l?nea de&inimos el mtodo est8tico main "ue es el "ue la J90 ejecutar8 para iniciar nuestros
programas.
Nota: El arreglo o vector args se utiliza para recibir todas las rdenes de la J*+, los
vectores en Java son objetos %ue tienen propiedades&
/n la l?nea D+ se de&ine una variable de tipo entero llamada Ya_ "ue inicialmente guardar8 un @
positivo+ la ,
ta
l?nea ejecuta el mtodo println65trin# line7 "ue pertenece al objeto out "ue a su vez es
propiedad del objeto 1ystem+ tener un objeto de salida+ se imprimir8 en pantalla el trozo de te'to 8el
valor de a9: seguido del valor :el contenido de a;.
/n la l?nea 6+ al contenido de la variable a+ le agregamos el resultado de sumar aQ@A+ eso no
tiene "ue dar un total de @@ "ue se ver8 re&lejado en la l?nea =+ cuando volvemos a llamar al mtodo
P8gina @E%=6
println del objeto out "ue pertenece al objeto 1ystem.
/n las l?neas E y F se cierran las llaves "ue iniciaron los blo"ues de cdigo del mtodo main o la
declaracin de la clase 5uma5imple.
,ota- .lo como comentario lo %ue en realidad el compilador est (aciendo al llamar a
println, es concatenar te/to, para ello es necesario convertir el n0mero en te/to,
internamente el compilador estar llamando a una clase %ue es parte de la
biblioteca cuyo nombre es "nteger y posee un mtodo to.tring#$ %ue convertir el
n0mero, a su vez, el trozo de te/to pertenecer a la propiedad de un objeto .tring el
cual tiene un mtodo concat#$ %ue es el encargado de producir un nuevo objeto
igual a la suma de los dos trozos de te/to&
/l ejemplo podr?a escribirse as?$
1. public class SumaSimple2 {
2. public static void main(String[] args) {
3. int a=1;
4. System.out.println("el valor de a=".concat(Integer.toString(a)));
5. a=a+10;
6. System.out.println("ahora sumndole 10 es
a=".concat(Integer.toString(a)));
7. }
8. }
3onde se #a reemplazado la concatenacin del compilador por su e"uivalente+ recordemos "ue no
es necesario #acer esto+ vemos "ue despus de las comillas dobles encontramos un punto+ eso es
por"ue de esa manera se representa un objeto 1tring+ cual"uier trozo de te'to entre comillas dobles es
un objeto 1tring y tiene propiedades y el punto separa objetos de otros objetos+ propiedades o
mtodos.
Nota: 0as lneas +ue no empie)an con n"mero representan la continuacin de la anterior
+ue por cuestiones de espacio no entra en la misma lnea, esa representacin es la
misma +ue en muc,os editores de cdigo, al guardarse estos arc,ivos se guardar!n
como una "nica lnea, sin importar cuantos renglones sean necesarios para ver todo
su contenido$
/n ambos casos la salida por pantalla ser8 la misma y la siguiente$
gus@gusgus ~ $ cd ejemplos
gus@gusgus ~/ejemplos $ javac SumaSimple.java
gus@gusgus ~/ejemplos $ java SumaSimple
el valor de a=1
ahora sumndole 10 es a=11
gus@gusgus ~/ejemplos $ javac SumaSimple2.java
gus@gusgus ~/ejemplos $ java SumaSimple2
el valor de a=1
ahora sumndole 10 es a=11
gus@gusgus ~/ejemplos $
*alida !or !antalla # entrada !or teclado
Para los siguientes ejemplos ya tenemos casi todo discutido+ e'cepto "ue por cuestiones
educativas ser?a interesante "ue el programa no solo contenga los valores "ue interactuar8n
almacenados+ sino "ue tambin sea posible preguntar al usuario.
P8gina @F%=6
Syste&.o!t
/l objeto 1ystem es parte de la biblioteca de Java y es instanciado o &abricado al iniciar la J90
muc#o antes "ue se comience a ejecutar nuestro programa. /ste almacena D objetos+ son out, in y err.
/l objeto out es del tipo o clase Printstream "ue tiene las siguientes propiedades y mtodos
importantes+ no listaremos todos$
Resumen de (1todos
boolean checkError()
/nv?a todo el bu&&er y devuelve verdadero si #ay error o &also.
void close()
5ierra el &lujo de datos
void flush()
/nv?a todo el bu&&er.
void print(boolean b)
-mprime una variable booleana
void print(char c)
-mprime un caracter.
void print(char[] s)
-mprime un arreglo de caracteres.
void print(double d)
-mprime un numero de tipo double.
void print(float f)
-mprime un nNmero de punto &lotante.
void print(int i)
-mprime un entero.
void print(long l)
-mprime un entero largo.
void print(Object obj)
-mprime un objeto+ invocando su &uncin to1tring:;
void print(String s)
-mprime un objeto de tipo 1tring
void println()
-mprime una separador de nueva l?nea.
void println(boolean x)
-mprime un valor booleano y termina la l?nea.
void println(char x)
-mprime un caracter y termina la l?nea.
void println(char[] x)
-mprime un arreglo de caracteres y termina la l?nea.
void println(double x)
-mprime un nNmero de precisin doble y termina la l?nea.
P8gina @>%=6
void println(float x)
-mprime un nNmero de punto &lotante y termina la l?nea.
void println(int x)
-mprime un entero y termina la l?nea.
void println(long x)
-mprime un entero largo y termina la l?nea.
void println(Object x)
-mprime un objeto invocando su mtodo to1tring:; y termina la l?nea.
void println(String x)
-mprime un trozo de te'to y termina la l?nea.
$abla ;: !esumen de mtodos importantes para out.
Syste&.in
/l objeto in "ue es una propiedad de 5-stem es de la clase o tipo Input5tream+ "ue tambin es
parte de la biblioteca de Java. A"u? vemos los mtodos "ue nos interesan.
Resumen de (1todos
int available()
3evuelve la cantidad de bytes "ue se pueden leer :o pasar por alto; desde esta
entrada sin blo"uear la pr'ima llamada a lectura.
void close()
5ierra esta entrada de datos y libera todos los recursos asociados.
abstract
int
read()
7ee el pr'imo byte de datos desde la entrada+ espera por los datos.
int read(byte[] b)
7ee de la entrada los bytes "ue llenan el arreglo b+ devuelve la cantidad de bytes
"ue se almacenaron.
int read(byte[] b, int off, int len)
7ee #asta len bytes de datos adentro del arreglo de bytes b empezando en o&&.
long skip(long n)
1alta y destrulle los n caracteres de datos.
$abla <: !esumen de mtodos importantes del tipo de objetos in.
Syste&.err
/ste objeto es del mismo tipo "ue out :Printstream; y tiene las mismas propiedades+ en los
sistemas operativos derivados de 4ni' como ser 7inu'+ e'iste muc#o la di&erencia entre salida
est8ndar de datos :1ystem.out; y la salida est8ndar de errores :1ystem.err;+ por ejemplo al imprimir
todos los carteles de errores en un tipo de salida no a&ectar?amos a los resultados+ un ejemplo ser?a el
siguiente$
public class SumaSimple3 {
public static void main(String[] args) {
int a=1;
System.err.println("el valor de a="+a);
P8gina CA%=6
System.out.println(a);
a=a+10;
System.err.println("ahora sumndole 10 es a="+a);
System.out.println(a);
}
}
1i este cdigo lo compilamos al ejecutarlo podemos separar los comentarios de los valores de a.
gus@gusgus ~ $ cd ejemplos
gus@gusgus ~/ejemplos $ javac SumaSimple3.java
gus@gusgus ~/ejemplos $ java SumaSimple3
el valor de a=1
1
ahora sumndole 10 es a=11
11
gus@gusgus ~/ejemplos $ java SumaSimple3 > resultados.txt
el valor de a=1
ahora sumndole 10 es a=11
gus@gusgus ~/ejemplos $ java SumaSimple3 2> errores.txt
1
11
gus@gusgus ~/ejemplos $
3e esa manera generamos y almacenamos por separado los errores y los resultados.
Nota: Es muy uena pr!ctica acostumrarse a separar los datos de errores a cada flo-o de
datos err y out, ya +ue si el flu-o fuera un protocolo de comunicacin me)claramos
los datos con los errores$
Syste&.e0it"int od%1
/l mtodo est8tico e'it:cod; de la clase 1ystem interrumpe la ejecucin total del programa y
devuelve el control al sistema operativo+ es decir la J90 termina por completo liberando los recursos.
4n cdigo de salida igual a cero es considerado como una ejecucin satis&actoria del programa+ un
cdigo di&erente a este+ se considera un error y sirve para "ue el sistema operativo u otro programa
"ue llame al nuestro sepa de alguna manera "ue ocurri.
Leer l)neas de la entrada est.ndar.
Para leer l?neas de la entrada est8ndar podemos utilizar una combinacin de objetos de la
biblioteca "ue nos permitir8n simplemente esperar a "ue el usuario ingrese te'to y presione enter+ o
podemos codi&icar la lectura secuencial de caracteres uno en uno #asta "ue se detecte un salto de l?nea+
tengamos en cuenta "ue java es multiplata&orma+ y si el sistema operativo no es 7inu'+ es probable
"ue se introduzca m8s de un caracter para el salto de l?nea lo cual incrementa la complejidad del
problema.
1. package com.compunauta.aprendiendojava;
2. import java.io.*;
3. public class LeerRenglones {
4. public static void main(String[] args) {
5. BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
6. System.out.println("Hola, ingresa tu nombre");
7. String nombre;
8. try {nombre = br.readLine();}
P8gina C@%=6
9. catch (IOException ex) {ex.printStackTrace();System.exit(-1);}
10. System.out.println("Hola, "+nombre+" ten un buen da");
11. System.exit(0);}
12.}
Nota: 2ueda como e-ercicio para el lector ver los m1todos y propiedades de la
documentacin de la api proporcionada por /un (icrosystems 3-ava$sun$com4 para
las clases 5ufferedReader, 6nput/treamReader y E*ception$
)rear Objetos (de la biblioteca de Java)
/n java para crear objetos utilizamos una palabra clave+ ne'+ esta misma crea un objeto del tipo
indicado a su derec#a+ repasemos del ejemplo anterior la siguiente l?nea$
BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
7a clase Bu&&ered*eader+ pertenece a la biblioteca de Java Yjava.io_ la cual &ue importada antes de
la declaracin de la clase Leer!en#lones+ -nput1tream*eader+ pertenece a la misma biblioteca.
Nota: En este punto, estamos utili)ando y creando o-etos pertenecientes a la ilioteca,
como podemos ver la declaracin de nuestra clase 0eerRenglones no tiene
propiedades ni m1todos din!micos +ue puedan llegar a ser m1todos de alg"n o-eto,
slo el m1todo est!tico main +ue es el +ue nos permite iniciar la e-ecucin de cdigo$
Tami1n podramos ,aer usado Data6nput/tream$
9eamos "ue signi&ica cada parte de esta l?nea+ el concepto de 8&uffered!eader br9: es una
asignacin y una declaracin simult8nea+ como vimos antes el signo 89: asigna a la variable u
nombre de objeto de la iz"uierda el contenido de la derec#a. /so "uiere decir "ue 8br: ser8 una
variable "ue apuntar8 a un objeto del tipo &uffered!eader+ br no ser8 un objeto+ ser8 el nombre con el
"ue accederemos al objeto en memoria ram+ si en la siguiente l?nea repitiramos otra asignacin a
br, es decir Ybr9....: sin la declaracin por"ue ya se sabe "ue es del tipo &uffered!eader+ entonces la
variable br apuntar8 a otro objeto del tipo &uffered!eader+ el anterior sigue e'istiendo en memoria+
pero ser8 eliminado en la pr'ima ejecucin del recolector de basura de la J90.
5ada vez "ue se crea un objeto nuevo el nombre de la clase se utiliza como el de una &uncin+ en
realidad esta &uncin especial es el mtodo llamado constructor de la clase "ue es el "ue &abricar8 e
inicializar8 de acuerdo a las variables "ue recibe como argumentos uno nuevo del tipo de su clase.
/sto lo veremos m8s adelante+ por el momento slo #aremos mencin de "ue el objeto
&uffered!eader+ necesita otro objeto "ue no es del tipo Input5tream como lo es el objeto 5-stem.in+
/n cambio necesita uno del tipo Input5tream!eader+ "ue es el "ue es capaz de trans&ormar un objeto
Input5tream, en Input5tream!eader "ue es re"uerido para "ue el constructor de &uffered!eader
&abri"ue un objeto &uffered!eader+ a partir de uno Input5tream!eader.
Nota: Todo este procedimiento tiene el "nico fin de tener una variale llamada r +ue
apunta a un o-eto de tipo 5ufferedReader +ue es capa) de leer lneas desde la
entrada, como lo construimos con la entrada del teclado, nos leer! los renglones +ue
pretendamos sin codificar la entrada del salto de lnea$
l bloque de control de errores, tr#+,catch()+,
5omo podemos ver en este ejemplo utilizamos la estructura de control de errores "ue es
obligatoria para esa conversin "ue #icimos para poder leer l?neas con el mtodo read7ine:;+ la
estructura tryHI encierra entre las llaves el cdigo "ue puede producir una e'cepcin :un error grave;
"ue debe ser manejado por el blo"ue catc#:/'ception e';HI+ en este caso solo capturamos la
P8gina CC%=6
e'cepcin "ue puede surgir y cual"uier otra "ue no sea -O/'ception no ser8 capturada.
try {nombre = br.readLine();
catch (IOException ex) {ex.printStackTrace();}
5atc# captura un tipo de error dentro del blo"ue tryHI+ y el blo"ue encerrado entre llaves
ejecutar8 cdigo "ue deber?a manejar la e'cepcin+ en este caso ignoramos todo tipo de accin "ue
podr?amos llevar a cabo y usamos la variable ex del tipo IO"xception para imprimir en pantalla los
errores con el mtodo print5tac=$race de dic#o objeto.
jercicios
/n esta y todas las secciones de ejercicios veremos la solucin a uno o dos+ y el resto "uedar8n
para ejercitacin del lector+ en el material multimedia "ue se adjunta con este libro tal vez se
encuentren otras soluciones a los dem8s problemas.
2.3. Entrada de Datos y on,ersiones. 4i*$ try$ at56
Preguntar el nombre del usuario y su edad+ mostrar cuantos aSos tendr?a en una dcada m8s y
clasi&icar segNn su edad en AJAVC6K+ BJC=V6AK+ 5J6@V...K. 7a salida por pantalla deber?a ser algo como
la siguiente$
Nombre:?
Gustavo
Edad:?29
Usuario Gustavo de Categora B, en una dcada tendr 39 aos.
Nota: Al preguntar por el nomre el cursor dee +uedar dea-o y al preguntar por la edad
-unto, utili)ar la estructura try7 8catc,347 8 y los lo+ues if347 8$ Tami1n uscar en la
documentacin de la A'6 los m1todos parse6nt3 4 de la clase 6nteger$
1olucin$
1. package com.compunauta.aprendiendojava;
2. import java.io.*;
3. /**
4. * <p>Ttulo: Aprendiendo Java</p>
5. * <p>Descripcin: Ejemplos del Libro Aprendiendo Java de Compunauta</p>
6. * <p>Copyright: Copyright (c) 2006 www.compunauta.com</p>
7. * <p>Empresa: COMPUNAUTA</p>
8. * @author Gustavo Guillermo Prez
9. * @version 2006.01.01
10. */
11.
12.public class Cap2Ej1 {
13. public static void main(String[] args) {
14. //Definimos el objeto br para leer lneas de la entrada
15. BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
16. //Definimos variables nombre, edad y categora dndole valores por
defecto
17. String nombre="";
18. int edad=0;
19. char categoria='A';
20. //Iniciamos el bloque que podr producir errores
21. try {
22. System.out.println("Nombre:?");
23. nombre = br.readLine();
24. System.out.print("Edad:?");
25. edad=Integer.parseInt(br.readLine());}
P8gina CD%=6
26. //capturamos cualquier excepcin que se pueda producir y la reportamos
27. catch (Exception ex) {ex.printStackTrace(System.err);System.exit(-1);}
28. //Como por defecto la categora es A, revisamos si aumentamos a B o C
29. if(edad>25){categoria='B';}
30. if(edad>50){categoria='C';}
31. //Imprimimos en pantalla la respuesta solicitada
32. edad+=10;
33. System.out.println("El usuario "+nombre+" de categora "+categoria+" en
una dcada tendr "+edad+ " aos");
34. System.exit(0);
35. }//final de main
36.}//final de la clase
5omentarios$
5apturamos "xception+ por"ue pueden producirse dos tipos de errores+ uno el de IO"xception,
como vimos en el ejemplo de lectura de renglones de este cap?tulo y el otro al ingresar te'to en vez de
un nNmero. 4tilizamos 1ystem.e'it:V@;G para salir del programa inesperadamente. /s conveniente "ue
el alumno reemplace la doble creacin de objetos por la de .ataInput5tream+ "ue para nuestro caso es
el mismo comportamiento+ pero tengamos en cuenta "ue la &uncin readLine67 de .ataInput5tream no
est8 recomendada por los nuevos (its de desarrollo solo e'iste por compatibilidad.
2.2 -umber.ormat(ce!tion /hile()+,
Basados en el enunciado del ejemplo anterior+ capturar correctamente los errores de entrada de
datos respecto de los de conversin de te'to en nNmeros. -mprimir en pantalla con print5tac=$race+
para el caso de entrada+ y avisar al usuario "ue la edad no &ue ingresada correctamente.
"dea- 1tilizar un blo%ue '(ile para forzar al usuario a ingresar denuevo su nombre y
edad si se detecta un error&
2.7 Me8la de /!les do9: ;5ile"%1 y *or"11%9:
Pedir por teclado el nombre al usuario+ y a continuacin solicitar @A puntuaciones de supuestos
e'8menes+ para promediarlos+ la salida por pantalla deber?a ser algo as?$
Nombre?Csar
Examen 1? 10
Examen 2? 7
Examen 4? 8.5
....
Examen 10? 9.3
Csar, tu promedio es de 8.93
Nota: 9tili)ar variales +ue permitan almacenar decimales, revisar en la documentacin las
otras Clases +ue proveen m1todos de conversin con decimales de te*to a n"meros$ :
5uscar en la clase (at,, los m1todos est!ticos +ue permitan redondear los decimales$
: por supuesto repetir el ingreso de los E*!menes +ue +ue ,ayan sido ingresados
incorrectamente$
1olucin$
1. package com.compunauta.aprendiendojava;
2. import java.io.*;
3. /**
4. * <p>Ttulo: Aprendiendo Java</p>
5. * <p>Descripcin: Ejemplos del Libro Aprendiendo Java de Compunauta</p>
6. * <p>Copyright: Copyright (c) 2006 www.compunauta.com</p>
P8gina C,%=6
7. * <p>Empresa: COMPUNAUTA</p>
8. * @author Gustavo Guillermo Prez
9. * @version 2006.01.01
10. */
11.
12.public class Cap2Ej3 {
13. public static void main(String[] args) {
14. //Definimos el objeto br para leer lneas de la entrada
15. BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
16. //Definimos variables nombre, error y acumulador dndole valores por
defecto
17. String nombre="";
18. float acumulador=0;
19. boolean error;
20. //Iniciamos el bloque que podr producir errores, slo para el nombre
21. try {
22. System.out.println("Nombre:?");
23. nombre = br.readLine();}
24. catch (Exception ex) {ex.printStackTrace(System.err);}
25. //iniciamos una iteracin del 0 al 9
26. for(int i=0;i<10;i++){
27. error=false;
28. //iniciamos el bloque do{} while(); que se repetir en caso de error
29. do{
30. error=false;
31. //iniciamos el bloque try que podr dar error de conversin numrica
32. try{
33. //ponemos i+1 entre (), caso contrario se concatenarn como texto
34. System.out.print("Examen "+(i+1)+"? ");
35. acumulador+=Float.parseFloat(br.readLine());
36. }catch(NumberFormatException ex){System.out.println("Error, ingresar
denuevo");error=true;}
37. catch(IOException ex){ex.printStackTrace();System.exit(-1);}
38. }while (error);
39.}
40. //Tenemos lista la suma parcial y calculamos su promedio.
41. acumulador/=10;
42. //Redondeamos el resultado a dos digitos.
43.acumulador=(float)Math.round(acumulador*100)/100;
44. System.out.println(nombre+", tu promedio es de: "+acumulador);
45. System.exit(0);
46.}
47.}
2.< S;it5 Selet
!acer un programa "ue utilice la estructura switc#:; para mostrar una &rase de acuerdo a un
nNmero+ pedir por teclado un nNmero del @ al @A+ e'igir "ue no se pase de esos valores+ capturar
errores y repetir #asta "ue se introduzca el A "ue ser8 "ue sale del programa. 7as &rases inventarlas.
Prctica )om!lementaria 'esuelta (sin !rocedimientos, sin arreglos)
/sta pr8ctica se aSadi con el objeto de "ue el alumno cuente con problemas resueltso para
practicar la sinta'is del lenguaje+ est8n resueltos y no utilizan bucles ni arreglos :"ue los veremos en el
pr'imo cap?tulo;.
P8gina C6%=6
P.C.E3
1. package com.compunauta.aprendiendojava.ex;
2. import java.io.BufferedReader;
3. import java.io.InputStreamReader;
4. import java.io.IOException;
5.
6. /**
7. * <p>Ttulo: Aprendiendo Java</p>
8. * <p>Descripcin: Ejemplos del Libro Aprendiendo Java de Compunauta</p>
9. * <p>Copyright: Copyright (c) 2006 www.compunauta.com</p>
10. * <p>Empresa: julioduarte@gmail.com</p>
11. * @author Julio Csar Duarte
12. * @version 2006.01.01
13. */
14.
15.public class Comp0Ej1 {
16. /**
17. * Ejercicio1: Un programa que carga por teclado dos nmeros y obtiene y
18. * muestra la suma de ambos
19. */
20.
21. public static void main(String[] args) {
22. int numero1 = 0;
23. int numero2 = 0;
24. int resultado;
25. BufferedReader br = new BufferedReader(new
InputStreamReader(System.in));
26. System.out.print("Ingrese el primer numero: ");
27. try {
28. numero1 = Integer.parseInt(br.readLine());
29. }
30. catch (IOException e) {
31. e.printStackTrace(System.err);
32. System.out.println("el programa se debe finalizar");
33. System.exit( -1);
34. }
35. catch (Exception e) {
36. e.printStackTrace(System.err);
37. System.out.println("Error imprevisto");
38. System.exit( -1);
39. }
40. System.out.print("Ingrese el segundo numero: ");
41. try {
42. numero2 = Integer.parseInt(br.readLine());
43. }
44. catch (IOException e) {
45. e.printStackTrace(System.err);
46. System.out.println("el programa se debe finalizar");
47. System.exit( -1);
48. }
49. catch (Exception e) {
50. e.printStackTrace(System.err);
51. System.out.println("Error imprevisto");
52. System.exit( -1);
53. }
54. resultado = numero1 + numero2;
55. System.out.print("El resultado es: " + resultado);
56. }
57. }
P8gina C=%=6
P.C.E2
1. package com.compunauta.aprendiendojava.ex;
2. import java.io.BufferedReader;
3. import java.io.InputStreamReader;
4. import java.io.IOException;
5.
6. /**
7. * <p>Ttulo: Aprendiendo Java</p>
8. * <p>Descripcin: Ejemplos del Libro Aprendiendo Java de Compunauta</p>
9. * <p>Copyright: Copyright (c) 2006 www.compunauta.com</p>
10. * <p>Empresa: julioduarte@gmail.com</p>
11. * @author Julio Csar Duarte
12. * @version 2006.01.01
13. */
14.
15.
16.public class Comp0Ej2 {
17. /**
18. * Ejercicio2: Un programa que carga por teclado el nombre de una persona y le
19. * muestra un saludo
20. */
21.
22. public static void main (String[] args)
23. {
24. String nombre=new String("");
25. BufferedReader br=new BufferedReader(new
InputStreamReader(System.in));
26. System.out.print("Ingrese su nombre: ");
27. try
28. {
29. nombre=br.readLine();
30. }
31. catch(IOException e)
32. {
33. e.printStackTrace(System.err);
34. System.out.println("el programa se debe
finalizar");
35. System.exit(-1);
36. }
37. System.out.println("Hola "+nombre);
38. }
39. }
P.C.E7
1. package com.compunauta.aprendiendojava.ex;
2. import java.io.BufferedReader;
3. import java.io.InputStreamReader;
4. import java.io.IOException;
5.
6. /**
7. * <p>Ttulo: Aprendiendo Java</p>
8. * <p>Descripcin: Ejemplos del Libro Aprendiendo Java de Compunauta</p>
9. * <p>Copyright: Copyright (c) 2006 www.compunauta.com</p>
10. * <p>Empresa: julioduarte@gmail.com</p>
11. * @author Julio Csar Duarte
12. * @version 2006.01.01
13. */
14.
15.public class Comp0Ej3 {
P8gina CE%=6
16. /**
17. * Ejercicio3: Dado el valor de los tres lados de un tringulo, calcular el
18. * permetro
19. */
20.
21. public static void main(String[] args) {
22. int lado1 = 0;
23. int lado2 = 0;
24. int lado3 = 0;
25. int perimetro;
26. BufferedReader br = new BufferedReader(new
InputStreamReader(System.in));
27. System.out.print("Ingrese el primer lado del triangulo: ");
28. try {
29. lado1 = Integer.parseInt(br.readLine());
30. }
31. catch (IOException e) {
32. e.printStackTrace(System.err);
33. System.out.println("el programa se debe finalizar");
34. System.exit( -1);
35. }
36. catch (Exception e) {
37. e.printStackTrace(System.err);
38. System.out.println("Error imprevisto");
39. System.exit( -1);
40. }
41. System.out.print("Ingrese el segundo lado del triangulo: ");
42. try {
43. lado2 = Integer.parseInt(br.readLine());
44. }
45. catch (IOException e) {
46. e.printStackTrace(System.err);
47. System.out.println("el programa se debe finalizar");
48. System.exit( -1);
49. }
50. catch (Exception e) {
51. e.printStackTrace(System.err);
52. System.out.println("Error imprevisto");
53. System.exit( -1);
54. }
55. System.out.print("Ingrese el tercer lado del triangulo: ");
56. try {
57. lado3 = Integer.parseInt(br.readLine());
58. }
59. catch (IOException e) {
60. e.printStackTrace(System.err);
61. System.out.println("el programa se debe finalizar");
62. System.exit( -1);
63. }
64. catch (Exception e) {
65. e.printStackTrace(System.err);
66. System.out.println("Error imprevisto");
67. System.exit( -1);
68. }
69. perimetro = lado1 + lado2 + lado3;
70. System.out.println("El Perimetro del triangulo es: " + perimetro);
71. }
72.}
P8gina CF%=6
P.C.E<
1. package com.compunauta.aprendiendojava.ex;
2. import java.io.BufferedReader;
3. import java.io.InputStreamReader;
4. import java.io.IOException;
5.
6.
7. /**
8. * <p>Ttulo: Aprendiendo Java</p>
9. * <p>Descripcin: Ejemplos del Libro Aprendiendo Java de Compunauta</p>
10. * <p>Copyright: Copyright (c) 2006 www.compunauta.com</p>
11. * <p>Empresa: julioduarte@gmail.com</p>
12. * @author Julio Csar Duarte
13. * @version 2006.01.01
14. */
15.
16.
17.public class Comp0Ej4 {
18. /**
19. * Ejercicio4: Se conocen dos nmeros. Determinar y mostrar el mayor
20. */
21. public static void main(String[] args) {
22. int numero1 = 0;
23. int numero2 = 0;
24. BufferedReader br = new BufferedReader(new
InputStreamReader(System.in));
25. System.out.print("Ingrese el primer numero: ");
26. try {
27. numero1 = Integer.parseInt(br.readLine());
28. }
29. catch (IOException e) {
30. e.printStackTrace(System.err);
31. System.out.println("el programa se debe finalizar");
32. System.exit( -1);
33. }
34. catch (Exception e) {
35. e.printStackTrace(System.err);
36. System.out.println("Error imprevisto");
37. System.exit( -1);
38. }
39. System.out.print("Ingrese el segundo numero: ");
40. try {
41. numero2 = Integer.parseInt(br.readLine());
42. }
43. catch (IOException e) {
44. e.printStackTrace(System.err);
45. System.out.println("el programa se debe finalizar");
46. System.exit( -1);
47. }
48. catch (Exception e) {
49. e.printStackTrace(System.err);
50. System.out.println("Error imprevisto");
51. System.exit( -1);
52. }
53. if (numero1 > numero2) {
54. System.out.println("El numero mayor es: " + numero1);
55. }
56. else {
57. if (numero1 < numero2) {
58. System.out.println("El numero mayor es: " + numero2);
P8gina C>%=6
59. }
60. else {
61. System.out.println("Los dos numeros son iguales: " + numero1);
62. }
63. }
64. }
65.}
P.C.E=
1. package com.compunauta.aprendiendojava.ex;
2. import java.io.BufferedReader;
3. import java.io.InputStreamReader;
4. import java.io.IOException;
5.
6. /**
7. * <p>Ttulo: Aprendiendo Java</p>
8. * <p>Descripcin: Ejemplos del Libro Aprendiendo Java de Compunauta</p>
9. * <p>Copyright: Copyright (c) 2006 www.compunauta.com</p>
10. * <p>Empresa: julioduarte@gmail.com</p>
11. * @author Julio Csar Duarte
12. * @version 2006.01.01
13. */
14.
15.public class Comp0Ej5 {
16. /**
17. * Ejercicio5: Se conocen dos nmeros distintos.
18. * Determinar si el primero de ellos es el mayor
19. */
20. public static void main(String[] args) {
21. int numero1 = 0;
22. int numero2 = 0;
23. BufferedReader br = new BufferedReader(new
InputStreamReader(System.in));
24. System.out.print("Ingrese el primer numero: ");
25. try {
26. numero1 = Integer.parseInt(br.readLine());
27. }
28. catch (IOException e) {
29. e.printStackTrace(System.err);
30. System.out.println("el programa se debe finalizar");
31. System.exit( -1);
32. }
33. catch (Exception e) {
34. e.printStackTrace(System.err);
35. System.out.println("Error imprevisto");
36. System.exit( -1);
37. }
38. System.out.print("Ingrese el segundo numero distinto del primero: ");
39. try {
40. numero2 = Integer.parseInt(br.readLine());
41. }
42. catch (IOException e) {
43. e.printStackTrace(System.err);
44. System.out.println("el programa se debe finalizar");
45. System.exit( -1);
46. }
47. catch (Exception e) {
48. e.printStackTrace(System.err);
P8gina DA%=6
49. System.out.println("Error imprevisto");
50. System.exit( -1);
51. }
52. if (numero1 > numero2) {
53. System.out.println("Se confirma que el primer numero es mas
grande");
54. }
55. else {
56. System.out.println("El primer numero no resulta ser el mas grande");
57. }
58.
59. }
60. }
P.C.E>
1. package com.compunauta.aprendiendojava.ex;
2. import java.io.BufferedReader;
3. import java.io.InputStreamReader;
4. import java.io.IOException;
5.
6. /**
7. * <p>Ttulo: Aprendiendo Java</p>
8. * <p>Descripcin: Ejemplos del Libro Aprendiendo Java de Compunauta</p>
9. * <p>Copyright: Copyright (c) 2006 www.compunauta.com</p>
10. * <p>Empresa: julioduarte@gmail.com</p>
11. * @author Julio Csar Duarte
12. * @version 2006.01.01
13. */
14.
15.public class Comp0Ej6 {
16. /**
17. * Ejercicio6: Se conocen dos nmeros distintos. Calcular la superficie de un
18. * cuadrado, suponiendo como lado del mismo al mayor de los nmeros
19. * dados y la superficie de n crculo suponiendo como radio del
20. * mismo al menor de los nmeros dados.
21. */
22.
23. public static void main(String[] args) {
24. int numero1 = 0;
25. int numero2 = 0;
26. int mayor = 0;
27. int menor = 0;
28. int cuadrado = 0;
29. double circulo = 0;
30. BufferedReader br = new BufferedReader(new
InputStreamReader(System.in));
31. System.out.print("Ingrese el primer numero: ");
32. try {
33. numero1 = Integer.parseInt(br.readLine());
34. }
35. catch (IOException e) {
36. e.printStackTrace(System.err);
37. System.out.println("el programa se debe finalizar");
38. System.exit( -1);
39. }
40. catch (Exception e) {
41. e.printStackTrace(System.err);
42. System.out.println("Error imprevisto");
43. System.exit( -1);
44. }
P8gina D@%=6
45. System.out.print("Ingrese el segundo numero distinto del primero: ");
46. try {
47. numero2 = Integer.parseInt(br.readLine());
48. }
49. catch (IOException e) {
50. e.printStackTrace(System.err);
51. System.out.println("el programa se debe finalizar");
52. System.exit( -1);
53. }
54. catch (Exception e) {
55. e.printStackTrace(System.err);
56. System.out.println("Error imprevisto");
57. System.exit( -1);
58. }
59. if (numero1 > numero2) {
60. mayor = numero1;
61. menor = numero2;
62. }
63. else {
64. mayor = numero2;
65. menor = numero1;
66. }
67. cuadrado = mayor * mayor;
68. circulo = Math.PI * menor * menor;
69. System.out.println("La supercie del cuadrado es: " + cuadrado);
70. System.out.println("La supercie del circulo es: " + circulo);
71. }
72.}
P.C.E?
1. package com.compunauta.aprendiendojava.ex;
2. import java.io.BufferedReader;
3. import java.io.InputStreamReader;
4. import java.io.IOException;
5.
6. /**
7. * <p>Ttulo: Aprendiendo Java</p>
8. * <p>Descripcin: Ejemplos del Libro Aprendiendo Java de Compunauta</p>
9. * <p>Copyright: Copyright (c) 2006 www.compunauta.com</p>
10. * <p>Empresa: julioduarte@gmail.com</p>
11. * @author Julio Csar Duarte
12. * @version 2006.01.01
13. */
14.
15.public class Comp0Ej7 {
16. /**
17. * Ejercicio7: Se conocen tres nmeros distintos. Determinar el menor de ellos y
18. * cacular el cuadrado y el cubo del mismo
19. */
20.
21. public static void main(String[] args) {
22. int numero1 = 0;
23. int numero2 = 0;
24. int numero3 = 0;
25. int menor;
26. BufferedReader br = new BufferedReader(new
InputStreamReader(System.in));
27. System.out.print("Ingrese el primer numero: ");
28. try {
P8gina DC%=6
29. numero1 = Integer.parseInt(br.readLine());
30. }
31. catch (IOException e) {
32. e.printStackTrace(System.err);
33. System.out.println("el programa se debe finalizar");
34. System.exit( -1);
35. }
36. catch (Exception e) {
37. e.printStackTrace(System.err);
38. System.out.println("Error imprevisto");
39. System.exit( -1);
40. }
41. System.out.print("Ingrese el segundo numero: ");
42. try {
43. numero2 = Integer.parseInt(br.readLine());
44. }
45. catch (IOException e) {
46. e.printStackTrace(System.err);
47. System.out.println("el programa se debe finalizar");
48. System.exit( -1);
49. }
50. catch (Exception e) {
51. e.printStackTrace(System.err);
52. System.out.println("Error imprevisto");
53. System.exit( -1);
54. }
55. System.out.print("Ingrese el tercer numero: ");
56. try {
57. numero3 = Integer.parseInt(br.readLine());
58. }
59. catch (IOException e) {
60. e.printStackTrace(System.err);
61. System.out.println("el programa se debe finalizar");
62. System.exit( -1);
63. }
64. catch (Exception e) {
65. e.printStackTrace(System.err);
66. System.out.println("Error imprevisto");
67. System.exit( -1);
68. }
69. if (numero1 < numero2) {
70. menor = numero1;
71. }
72. else {
73. menor = numero2;
74. }
75. if (menor > numero3) {
76. menor = numero3;
77. }
78. System.out.println("El numero menor es: " + menor);
79. System.out.println("El cuadrado es: " + menor * menor);
80. System.out.println("El cubo es: " + menor * menor * menor);
81. }
82.}
P.C.E@
1. package com.compunauta.aprendiendojava.ex;
2. import java.io.BufferedReader;
3. import java.io.InputStreamReader;
P8gina DD%=6
4. import java.io.IOException;
5.
6. /**
7. * <p>Ttulo: Aprendiendo Java</p>
8. * <p>Descripcin: Ejemplos del Libro Aprendiendo Java de Compunauta</p>
9. * <p>Copyright: Copyright (c) 2006 www.compunauta.com</p>
10. * <p>Empresa: julioduarte@gmail.com</p>
11. * @author Julio Csar Duarte
12. * @version 2006.01.01
13. */
14.
15.public class Comp0Ej8 {
16. /**
17. * Ejercicio8: Se ingresan por teclado las notas obtenidas por tres alumnos en
18. * un parcial de ciertas materia. Se desea saber cules de estos
19. * alumnos resultaron aplazados, y adems se pide determinar cul
20. * fue la mayor nota, y cul fue el alumno que la obtuvo.
21. */
22. public static void main(String[] args) {
23. int nota1 = 0;
24. int nota2 = 0;
25. int nota3 = 0;
26. int mejor;
27. int alumno;
28. BufferedReader br = new BufferedReader(new
InputStreamReader(System.in));
29. System.out.print("Ingrese la nota del primer alumno: ");
30. try {
31. nota1 = Integer.parseInt(br.readLine());
32. }
33. catch (IOException e) {
34. e.printStackTrace(System.err);
35. System.out.println("el programa se debe finalizar");
36. System.exit( -1);
37. }
38. catch (Exception e) {
39. e.printStackTrace(System.err);
40. System.out.println("Error imprevisto");
41. System.exit( -1);
42. }
43. System.out.print("Ingrese la nota del segundo alumno: ");
44. try {
45. nota2 = Integer.parseInt(br.readLine());
46. }
47. catch (IOException e) {
48. e.printStackTrace(System.err);
49. System.out.println("el programa se debe finalizar");
50. System.exit( -1);
51. }
52. catch (Exception e) {
53. e.printStackTrace(System.err);
54. System.out.println("Error imprevisto");
55. System.exit( -1);
56. }
57. System.out.print("Ingrese la nota del tercer alumno: ");
58. try {
59. nota3 = Integer.parseInt(br.readLine());
60. }
61. catch (IOException e) {
62. e.printStackTrace(System.err);
63. System.out.println("el programa se debe finalizar");
64. System.exit( -1);
P8gina D,%=6
65. }
66. catch (Exception e) {
67. e.printStackTrace(System.err);
68. System.out.println("Error imprevisto");
69. System.exit( -1);
70. }
71. System.out.println("Alumno Aplazados: ");
72. if (nota1 < 4) {
73. System.out.println("-Primer alumno aplazado");
74. }
75. if (nota2 < 4) {
76. System.out.println("-Segundo alumno aplazado");
77. }
78. if (nota3 < 4) {
79. System.out.println("-Tercer alumno aplazado");
80. }
81. System.out.println("Alumno que obtuvo la mejor nota: ");
82. if (nota1 > nota2) {
83. mejor = nota1;
84. alumno = 1;
85. }
86. else {
87. mejor = nota2;
88. alumno = 2;
89. }
90. if (mejor < nota3) {
91. mejor = nota3;
92. alumno = 3;
93. }
94. System.out.println("El alumno" + alumno + " fue quien obtuvo un: " +
mejor);
95. }
96.}
P.C.EA
1. package com.compunauta.aprendiendojava.ex;
2. import java.io.BufferedReader;
3. import java.io.InputStreamReader;
4. import java.io.IOException;
5.
6. /**
7. * <p>Ttulo: Aprendiendo Java</p>
8. * <p>Descripcin: Ejemplos del Libro Aprendiendo Java de Compunauta</p>
9. * <p>Copyright: Copyright (c) 2006 www.compunauta.com</p>
10. * <p>Empresa: julioduarte@gmail.com</p>
11. * @author Julio Csar Duarte
12. * @version 2006.01.01
13. */
14.
15.public class Comp0Ej9 {
16. /**
17. * Ejercicio9: Un comerciante tiene la venta de 4 tipos de productos principales
18. * Conociendo la cantidad vendida de cada artculo, y el precio
19. * unitario de cada artculo, hacer un programa que determine cul
20. * fue el producto que realiz el mayor aporte en los ingresos.
21. * Calcular adems, el porcentaje que dicho aporte significa en el
22. * ingreso absoluto por los cuatro artculos sumados.
23. */
24.
25. public static void main(String[] args) {
P8gina D6%=6
26. String buf = new String("");
27. float precio1 = 0;
28. int cantidad1 = 0;
29. float aporte1 = 0;
30. float precio2 = 0;
31. int cantidad2 = 0;
32. float aporte2 = 0;
33. float precio3 = 0;
34. int cantidad3 = 0;
35. float aporte3 = 0;
36. float precio4 = 0;
37. int cantidad4 = 0;
38. float aporte4 = 0;
39. float aportetotal = 0;
40. float mayor = 0;
41. int id = 0;
42. float porcentaje = 0;
43. BufferedReader br = new BufferedReader(new
InputStreamReader(System.in));
44. System.out.print("Ingrese el precio producto1: ");
45. try {
46. //precio1=Double.valueOf(br.readLine());
47. precio1 = Float.valueOf(br.readLine()).floatValue();
48. }
49. catch (IOException e) {
50. e.printStackTrace(System.err);
51. System.out.println("el programa se debe finalizar");
52. System.exit( -1);
53. }
54. catch (Exception e) {
55. e.printStackTrace(System.err);
56. System.out.println("Error imprevisto");
57. System.exit( -1);
58. }
59. System.out.print("Ingrese el precio producto2: ");
60. try {
61. precio2 = Float.valueOf(br.readLine()).floatValue();
62. }
63. catch (IOException e) {
64. e.printStackTrace(System.err);
65. System.out.println("el programa se debe finalizar");
66. System.exit( -1);
67. }
68. catch (Exception e) {
69. e.printStackTrace(System.err);
70. System.out.println("Error imprevisto");
71. System.exit( -1);
72. }
73. System.out.print("Ingrese el precio producto3: ");
74. try {
75. precio3 = Float.valueOf(br.readLine()).floatValue();
76. }
77. catch (IOException e) {
78. e.printStackTrace(System.err);
79. System.out.println("el programa se debe finalizar");
80. System.exit( -1);
81. }
82. catch (Exception e) {
83. e.printStackTrace(System.err);
84. System.out.println("Error imprevisto");
85. System.exit( -1);
P8gina D=%=6
86. }
87. System.out.print("Ingrese el precio producto4: ");
88. try {
89. precio4 = Float.valueOf(br.readLine()).floatValue();
90. }
91. catch (IOException e) {
92. e.printStackTrace(System.err);
93. System.out.println("el programa se debe finalizar");
94. System.exit( -1);
95. }
96. catch (Exception e) {
97. e.printStackTrace(System.err);
98. System.out.println("Error imprevisto");
99. System.exit( -1);
100. }
101. System.out.print("Ingrese la cantida vendida del producto1: ");
102. try {
103. cantidad1 = Integer.parseInt(br.readLine());
104. }
105. catch (IOException e) {
106. e.printStackTrace(System.err);
107. System.out.println("el programa se debe finalizar");
108. System.exit( -1);
109. }
110. catch (Exception e) {
111. e.printStackTrace(System.err);
112. System.out.println("Error imprevisto");
113. System.exit( -1);
114. }
115. System.out.print("Ingrese la cantida vendida del producto2: ");
116. try {
117. cantidad2 = Integer.parseInt(br.readLine());
118. }
119. catch (IOException e) {
120. e.printStackTrace(System.err);
121. System.out.println("el programa se debe finalizar");
122. System.exit( -1);
123. }
124. catch (Exception e) {
125. e.printStackTrace(System.err);
126. System.out.println("Error imprevisto");
127. System.exit( -1);
128. }
129. System.out.print("Ingrese la cantida vendida del producto3: ");
130. try {
131. cantidad3 = Integer.parseInt(br.readLine());
132. }
133. catch (IOException e) {
134. e.printStackTrace(System.err);
135. System.out.println("el programa se debe finalizar");
136. System.exit( -1);
137. }
138. catch (Exception e) {
139. e.printStackTrace(System.err);
140. System.out.println("Error imprevisto");
141. System.exit( -1);
142. }
143. System.out.print("Ingrese la cantida vendida del producto4: ");
144. try {
145. cantidad4 = Integer.parseInt(br.readLine());
146. }
P8gina DE%=6
147. catch (IOException e) {
148. e.printStackTrace(System.err);
149. System.out.println("el programa se debe finalizar");
150. System.exit( -1);
151. }
152. catch (Exception e) {
153. e.printStackTrace(System.err);
154. System.out.println("Error imprevisto");
155. System.exit( -1);
156. }
157. aporte1 = precio1 * cantidad1;
158. aporte2 = precio2 * cantidad2;
159. aporte3 = precio3 * cantidad3;
160. aporte4 = precio4 * cantidad4;
161. aportetotal = aporte1 + aporte2 + aporte3 + aporte4;
162. if (aporte1 > aporte2) {
163. mayor = aporte1;
164. id = 1;
165. }
166. else {
167. mayor = aporte2;
168. id = 2;
169. }
170. if (mayor < aporte3) {
171. mayor = aporte3;
172. id = 3;
173. }
174. if (mayor < aporte4) {
175. mayor = aporte4;
176. id = 4;
177. }
178. porcentaje = (mayor / aportetotal) * 100;
179. System.out.println("El producto" + id + " fue el que mas aporto con: "
+
180. mayor);
181. System.out.println("El porentaje de aporte sobre el total es de: " +
182. porcentaje + "%");
183.
184. }
185.}
Prctica )om!lementaria (bucles sin arreglos)
P8gina DF%=6
Ca()t!lo 7 B MCtodos est.tios y Meanis&os de Progra&ain.
/ste cap?tulo pretende proporcionar al usuario &inal las #erramientas para solucionar problemas
del tipo programacin estructurada+ de pilas+ colas+ vectores+ 8rboles+ etc. `ue es necesario para
&ormar correctamente al alumno en cual"uier ambiente de programacin+ incluida la programacin
orientada a objetos+ no pretendemos ir a la P.O.O todav?a sino #asta m8s adelante+ de esta manera este
cap?tulo puede utilizarse para a&ianzar los conocimientos necesarios para un curso de &?sica o
matem8ticas donde se desee aplicar a problemas en general.
7a P.O.O. en este cap?tulo ser8 completamente b8sica+ y ni si"uiera la mencionaremos en
muc#os caso #asta el &inal del cap?tulo a menos "ue sea necesario.
M$todos estticos (0unciones o !rocedimientos)
/n el capitulo anterior no utilizamos nada de la programacin estructurada+ slo seguimos un
orden de ejecucin secuencial+ es decir paso a paso y no planteamos el problema de la reutilizacin de
cdigo.
!roblema- necesitamos ingresar datos por teclado+ #acer varios c8lculos y volver a ingresar
datos por teclado y #acer otros c8lculos di&erentes+ y este mismo proceso+ repetidas veces+ como vimos
en los ejemplos anteriores tendr?amos "ue repetir el blo"ue tryHIcatc#:;HI varias veces+ y si
"uisiramos repetir un blo"ue de c8lculos para ciertos datos... 23ue pasar4a si %uiero cambiar esas
rdenes las veces %ue se (ayan repetido5.
/ntonces comenzamos con las &unciones+ o mtodos est8ticos en Java+ se les denomina est8ticos
por"ue pertenecen a la 5lase o tipo de datos y no es necesario crear un objeto para invocarlos o
llamarlos+ para nosotros en este momento nos servir8n para solucionar el problema de repeticin y
mantenimiento de cdigo.
/jemplo D.@$
1e re"uiere ingresar los datos de D valores y calcular su promedio+ paso seguido+ preguntar el
nombre del usuario e imprimir de manera personalizada Y4suario+ el promedio de tus tres valores es$
PPP_+ es un problema muy similar a los anteriores+ pero utilizaremos una &uncin llamada leer "ue
&abricaremos para no repetir el cdigo de lectura del teclado.
1. package com.compunauta.aprendiendojava;
2. import java.io.*;
3. /**
4. * <p>Ttulo: Aprendiendo Java</p>
5. * <p>Descripcin: Ejemplos del Libro Aprendiendo Java de Compunauta</p>
6. * <p>Copyright: Copyright (c) 2006 www.compunauta.com</p>
7. * <p>Empresa: COMPUNAUTA</p>
8. * @author Gustavo Guillermo Prez
9. * @version 2006.01.01
10. */
11.
12.public class MetodoLeer {
13. public static void main(String[] args) {
14. BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
15. int acumulador=0;
16. for(int i=0;i<3;i++){
17. System.out.println("Ingrese el valor "+(i+1)+" de 3?");
18. acumulador=acumulador+=Integer.parseInt(leer(br));
19. }
20. acumulador/=3;
P8gina D>%=6
21. System.out.println("Ingrese su nombre?");
22. String nombre=leer(br);
23. System.out.println("Usuario: "+nombre+" tu promedio es:"+acumulador);
24. }
25.
26.public static String leer(BufferedReader buff){
27. String lee="";
28.try{lee=buff.readLine();}
29.catch(Exception ex){
30. ex.printStackTrace(System.err);}
31.return lee;
32.}//final de la funcion leer
33.}//final de la clase
5omo podemos ver desde la l?nea C= a la DC se de&ine la &uncin est8tica leer+ "ue es pNblica y
devolver8 datos de tipo 1tring+ esta &uncin para poder procesar la lectura necesita "ue le pasemos
como argumento un objeto del tipo &uffered!eader "ue es el encargado de leer las l?neas+ esta &uncin
tiene como objetivo "ue no se repita el cdigo de control de errores y en el &uturo podremos modi&icar
esta &uncin o &abricar otra para leer nNmeros "ue revise una correcta entrada de datos.
Bien+ a#ora veamos el cdigo mejorado utilizando una &uncin para leer te'to y otra para los
nNmeros enteros$
1. package com.compunauta.aprendiendojava;
2. import java.io.*;
3. /**
4. * <p>Ttulo: Aprendiendo Java</p>
5. * <p>Descripcin: Ejemplos del Libro Aprendiendo Java de Compunauta</p>
6. * <p>Copyright: Copyright (c) 2006 www.compunauta.com</p>
7. * <p>Empresa: COMPUNAUTA</p>
8. * @author Gustavo Guillermo Prez
9. * @version 2006.01.01
10. */
11.
12.public class MetodoLeer {
13. public static void main(String[] args) {
14. BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
15. int acumulador=0;
16. for(int i=0;i<3;i++){
17. System.out.println("Ingrese el valor "+(i+1)+" de 3?");
18. acumulador=acumulador+=Integer.parseInt(leerTexto(br));
19. }
20. acumulador/=3;
21. System.out.println("Ingrese su nombre?");
22. String nombre=leerTexto(br);
23. System.out.println("Usuario: "+nombre+" tu promedio es:"+acumulador);
24. }
25.
26.public static String leerTexto(BufferedReader buff){
27. String lee="";
28.try{lee=buff.readLine();}
29.catch(Exception ex){
30. ex.printStackTrace(System.err);}
31.return lee;
32.}//final de la funcion leer
33.
34.public static int leerInt(BufferedReader buff){
35. int lee=0;
36. boolean error;
P8gina ,A%=6
37. do {
38. error=false;
39. try {lee = Integer.parseInt(buff.readLine());}
40. catch (NumberFormatException ex) {
41. System.out.println("Entrada erronea, repetir:?");
42. error=true;}
43. catch (Exception ex){ex.printStackTrace(System.err);}
44. } while (error);
45.return lee;
46.}//final de la funcion leer
47.
48.}
1rreglos (1rra#s) o Vectores%
7os arreglos son como un vector+ con varias componentes incluso en programacin un arreglo
puede representar una matriz de varias dimensiones. Por ejemplo si tenemos @A &rases "ue
enseSaremos segNn un nNmero del @ al @A+ podemos utilizar un vector de una sola dimensin+ donde
indicaremos con un sub?ndice a los elementos "ue este mismo almacene.
/n Java un arreglo se representa por un objeto "ue tiene un l?mite de elementos al ser de&inido+ o
en alguna parte de nuestro programa le asignaremos un objeto arreglo de cierto tipo. 7os elementos
"ue pondremos en nuestro arreglo de datos deben estar de&inidos en cantidad+ no en valor+ si creemos
"ue podemos necesitar m8s o menos @AQ%VD elementos asignaremos @D por m8s "ue a veces usemos E.
7os arreglos tienen una cantidad de elementos+ pero el sub?ndice "ue usaremos para acceder al
contenido de cada elemento ir8 del A a /7/0/2.O1V@. 9eamos un ejemplo$
'rolema:
1e desea ingresar por teclado tres resultados de e'8menes+ e imprimir el @a y Nltimo+ utilizamos
la &uncin leerInt67 "ue ejempli&icamos anteriormente.
1. package com.compunauta.aprendiendojava;
2. import java.io.*;
3. /**
4. * <p>Ttulo: Aprendiendo Java</p>
5. * <p>Descripcin: Ejemplos del Libro Aprendiendo Java de Compunauta</p>
6. * <p>Copyright: Copyright (c) 2006 www.compunauta.com</p>
7. * <p>Empresa: COMPUNAUTA</p>
8. * @author Gustavo Guillermo Prez
9. * @version 2006.01.01
10. */
11.
12.public class Arreglos {
13. public static void main(String[] args) {
14. BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
15. int[] examenes=new int[3];
16. System.out.println("La longitud de datos de mi arreglo
es:"+examenes.length);
17. for (int i=0;i<examenes.length;i++){
18. System.out.println("Ingrese el valor para el examen "+(i+1)+" de
"+examenes.length);
19. examenes[i]=leerInt(br);
20. }
21. System.out.println("El resultado del primer examen es:"+examenes[0]);
22. System.out.println("El resultado del ltimo examen
es:"+examenes[examenes.length-1]);
23. }
24. public static int leerInt(BufferedReader buff){
P8gina ,@%=6
25. int lee=0;
26. boolean error;
27. do {
28. error=false;
29. try {lee = Integer.parseInt(buff.readLine());}
30. catch (NumberFormatException ex) {
31.System.out.println("Entrada erronea, repetir:?");
32. error=true;}
33. catch (Exception ex){ex.printStackTrace(System.err);}
34. } while (error);
35.return lee;
36.}//final de la funcion leer
37.
38.}
7a salida por pantalla ser8 algo como esto$
La longitud de datos de mi arreglo es:3
Ingrese el valor para el examen 1 de 3
23
Ingrese el valor para el examen 2 de 3
21
Ingrese el valor para el examen 3 de 3
12
El resultado del primer examen es:23
El resultado del ltimo examen es:12
La clase Math de !rocedimientos # constantes matemticas
A continuacin veremos la utilidad de la 5lase de la biblioteca m8s Ntil+ "ue provee algunas
cuantas &unciones matem8ticas "ue usaremos para resolver nuestros problemas en este cap?tulo.
Resumen de Campos
static double
E
/l valor double "ue es el mas cercano a e+ la base de los logaritmos
naturales.
static double
!"
/l valor double "ue es m8s cercano a pi+ la relacin de una circun&erencia
con su di8metro.

Resumen de (1todos
static double
abs(double a)
3evuelve el valor absoluto de un valor double.
static float
abs(float a)
3evuelve el valor absoluto de un valor float.
static int
abs(int a)
3evuelve el valor absoluto de un valor int.
static long
abs(long a)
3evuelve el valor absoluto de un valor long.
P8gina ,C%=6
static double
acos(double a)
3evuelve el arcocoseno de un 8ngulo+ en el rango de A.A #asta pi.
static double
asin(double a)
3evuelve el arcoseno de un 8ngulo+ en el rango de Vpi%C #asta pi%C.
static double
atan(double a)
3evuelve el arcotangente de un 8ngulo+ en el rango de Vpi%C #asta pi%C.
static double
atan#(double y, double x)
5onvierte coordenadas rectangulares :x+ y; a polares :r+ t>eta;.
static double
cbrt(double a)
3evuelve la ra?z cuadrada de un valor double.
static double
ceil(double a)
3evuleve el m8s pe"ueSo :cercano al in&inito negativo; valor double "ue
es m8s grande o igual al argumento a y es igual a un entero matem8tico.
static double
cos(double a)
3evuelve el coseno trigonomtrico de un 8ngulo.
static double
cosh(double x)
3evuelve el coseno #iperblico de un valor value.
static double
e$p(double a)
3evuelve el valor e de /uler elevado a la potencia del valor double a.
static double
e$pm%(double x)
3evuelve e
'
V@.
static double
floor(double a)
3evuelve el m8s largo :cercano al positivo in&inito; valor double "ue es
menor o igual al argumento a y es igual a un entero matem8tico.
static double
hypot(double x, double y)
3evuelve s"rt:x
C
Q-
C
; sin el over&low o under&low intermedio.
static double
"EEEremainder(double f1, double f2)
5omputa la operacin prescripta por el est8ndar -/// E6, entre los dos
argumentos &@ y &C.
static double
log(double a)
3evuelve el logaritmo natural :base e; de un valor double.
static double
log%&(double a)
3evuelve el logaritmo en base @A de un valor double.
static double
log%p(double x)
devuelve e
'Q@
.
static double
ma$(double a, double b)
3evuelve el m8s grande de los dos valores double a y b.
static float
ma$(float a, float b)
3evuelve el m8s grande de los dos valores float a y b.
static int
ma$(int a, int b)
3evuelve el m8s grande de los dos valores int a y b.
static long
ma$(long a, long b)
P8gina ,D%=6
3evuelve el m8s grande de los dos valores long a y b.
static double
min(double a, double b)
3evuelve el m8s pe"ueSo de los dos valores double a y b.
static float
min(float a, float b)
3evuelve el m8s pe"ueSo de los dos valores float a y b.
static int
min(int a, int b)
3evuelve el m8s pe"ueSo de los dos valores int a y b.
static long
min(long a, long b)
3evuelve el m8s pe"ueSo de los dos valores long a y b.
static double
pow(double a, double b)
3evuelve el valor del argumento a elevado a la potencia de b$ a
b
.
static double
random()
3evuelve un valor de tipo double con signo positivo+mayor o igual "ue
cero y menor "ue uno 1.0.
static double
rint(double a)
3evuelve el valor double "ue es m8s cercano al valor a y es igual a un
entero matem8tico.
static long
round(double a)
3evuelve el valor long m8s cercano al argumento.
static int
round(float a)
3evuelve el valor int m8s cercano al argumento.
static double
signum(double d)
7a &uncin signo+ cero si el argumento es cero+ @.A si el argumento es mayor
"ue cero y V@.A si el argumento es menor "ue cero.
static float
signum(float f)
7a &uncin signo+ cero si el argumento es cero+ @.A si el argumento es mayor
"ue cero y V@.A si el argumento es menor "ue cero.
static double
sin(double a)
3evuelve el seno trigonomtrico de un 8ngulo.
static double
sinh(double x)
3evuelve el seno #iperblico de un valor double.
static double
s'rt(double a)
3evuelve la ra?z cuadrada positiva redondeada de un valor double.
static double
tan(double a)
3evuelve la tangente trigonomtrica de un 8ngulo.
static double
tanh(double x)
3evuelve la tangente #iperblica de un valor double.
static double
to(egrees(double angrad)
5onvierte un 8ngulo medido en radianes al apro'imado en grados..
static double
to)adians(double angdeg)
5onvierte un 8ngulo medido en grados al apro'imado en radianes.
static double
ulp(double d)
P8gina ,,%=6
9er de&inicin en la documentacin completa.
static float
ulp(float f)
9er de&inicin en la documentacin completa.
$abla 1?: La 0lase (at> + mtodos - constantes
&u00ering 2 Memoria tem!oral
Algunas veces es necesario procesar datos con cierta velocidad o cantidad conocida+ la lectura
de datos de @ en @ puede producir "ue en un cierto momento nuestro programa se "uede sin #acer
nada+ o simplemente es m8s e&ectivo leer un arc#ivo por blo"ues de datos grandes "ue de byte en byte
:sobrecarga de llamadas a la misma &uncin;.
/n otras ocasiones podemos estar recibiendo datos por la red y si nuestro programa es lento para
procesarlos o necesita atencin por parte de un usuario para decidir "ue #acer+ puede suceder "ue
lleguen m8s datos de los "ue se pueden procesar+ en este caso podemos utilizar un segmento de
memoria temporal para almacenar estos datos y "ue no se pierdan y as? aprovec#ar el tiempo en el "ue
no llegan datos.
/l criterio para implementar estos tipos de memorias temporales :bu&&ers de a"u? en adelante; es
variable+ siempre se tomar8 en cuenta el promedio de datos "ue lleguen a nuestro programa o la
cantidad de veces "ue es necesario llamar a una &uncin "ue lee datos si lo #acemos con blo"ues m8s
pe"ueSos o m8s grandes+ el valor ptimo siempre es emp?rico.
Para determinar este valor siempre tendremos en cuenta "ue blo"ues m8s grandes de datos
consumen m8s memoria del sistema operativo+ y "ue muc#as veces para mover blo"ues grandes de
datos se puede perder muc#o tiempo+ por otra parte si nuestro arc#ivo del disco no dispone de datos
para llenar esos blo"ues+ estar?amos desperdiciando memoria si abriramos muc#os arc#ivos m8s
pe"ueSos "ue el bu&&er+ por otro lado si el bu&&er es muy pe"ueSo+ entonces el e&ecto es contrario+
estar?amos llamando innumerables cantidades de veces a la &uncin leer+ por lo "ue producir?amos un
desperdicio de recursos del procesador+ enlentecer?amos el sistema operativo+ entonces "ueda claro
"ue no leeremos arc#ivos en blo"ues de @0B ni lo #aremos byte por byte.
Usando arreglos (ara !n /!**er$ olas de es(era$ (ilas y listas.
Bien+ pongamos el siguiente ejemplo+ se "uieren enviar datos de una m8"uina a otra en un slo
sentido+ una tele&onista debe llamar a ciertos tel&onos "ue llegan desde otro punto de una red y no
puede ver el siguiente tel&ono #asta "ue #aya terminado su llamada+ del otro lado una secretaria "ue
revisa el correo con una &recuencia de 6 minutos env?a los tel&onos del soporte tcnico "ue deben ser
atendidos por la tele&onista+ teniendo en cuenta "ue las llamadas suelen durar entre @A a DA minutos y
"ue los correos "ue pueden llegar al mismo tiempo no son m8s de = y "ue e'isten lapsos de #asta =A
minutos sin recibir ni un slo correo+ y "ue no "uedan llamadas pendientes en el transcurso del d?a.
6riterios-
@. 1obredimensionar es sobrecargar
C. 0inimizar es sobrecargar
D. 1i llenamos el bu&&er+ no se podr8n ingresar m8s d8tos.
,. 1upondremos "ue en el peor de los casos llegan @A correos
6. 1upondremos "ue en el peor de los casos duran DA minutos
=. 1upondremos "ue en el peor de los casos el lapso es de CA minutos durante , per?odos.
7os Nltimos tres criterios son suposiciones+ "ue en la vida real son la tele&onista y secretaria
P8gina ,6%=6
"uienes pueden proveer este tipo de estad?stica sobre los #orarios m8s saturados+ tenemos "ue tener en
cuenta "ue el problema es #umanamente soluble ya "ue no "uedan pendientes sin tratar as? "ue
durante el d?a se resuelven todos los llamados$ CAmin ' ,p ^ FAmin ^] @; se resuelven en FA minutos
C llamados y b C; se acumularon casi ,A tel M D tel ^ DE tel
/ntonces en el peor de los casos la acumulacin m8'ima probable y el despac#o de tel&onos
m8s tardado producen un m8'imo de DE tel&onos. /ntonces nuestro uffer ptimo es de 78
elementos. 5omo almacenar un tel&ono no consume tanta cantidad de recursos de un sistema
utilizaremos un bu&&er de ,A elementos.
@ota: el manejo de memoria !A( en el sistema para valores o tipos de datos de
almacenamiento fijo, como son todos los tipos de datos bsicos exclu-endo 85trin#:, es
de potencias de %
n
- a veces de mBltiplos de estas potencias, siendo recomendable ele#ir
siempre un valor cercano pero no i#ual por)ue si la C( utiliDa blo)ues de 2,enteros
como buffer interno si usramos 2/enteros estarEamos obli#ando a usar el espacio de
1%;enteros.
3m!lementacin del bu00er ti!o .3.O ()ola de es!era, el !rimero es !rimero en salir)
/l ejemplo anterior necesita conocimientos de ejecucin paralela de dos procesos+ uno para leer
del soc(et :cone'in de red; y otro para atender a la tele&onista+ eso no lo veremos todav?a as? "ue
cambiaremos el enunciado para implementar esta cola de espera.
La telefonista recibe los telfonos - tardar solo 1 minuto como mximo por llamada, es decir
los nBmeros saldrn de a 1 por minuto, pudiendo descansar en el tiempo sobrante, si no >a- nBmeros
esperar, - si >a- muc>os #uardarlos temporalmente.
4tilizaremos una cone'in de red+ donde la tele&onista tendr8 un programa en espera "ue
escuc#ar8 en la red y la secretaria el "ue enviar8 los datos al establecer una cone'in.
9elefonista-
gus@gusgus ~$ java com.compunauta.aprendiendojava.Cap3_sock_tel
Escuchando el puerto:4567
Esperando conexin...
Conectado... Esperando telfonos
Secretaria llamando al tel:123
Secretaria llamando al tel:432
Ultima llamada, nos vamos... programa terminado
gus@gusgus ~$
.ecretaria-
gus@gusgus ~$ java com.compunauta.aprendiendojava.Cap3_sock_sec
Intentando conectar con la telefonista
Nos conectamos con la telefonista:127.0.0.1:4567
Ingrese nmeros -1 termina
123
432
-1
Programa terminado
gus@gusgus ~$
5odi&icacin$
5omo dijimos antes la implementacin y codi&icacin de este ejemplo necesitar8 de una
cone'in de red para poder comprender mejor el uso de este tipo de estructuras+ no es necesario "ue
dispongamos de una red para llevar a cabo este programa+ ya "ue una P5 puede actuar como una red
P8gina ,=%=6
de @ sola m8"uina+ en este caso usaremos la direccin de red local :loopbac(; "ue e'iste en casi todos
los sistemas operativos en los "ue corre Java. /sta direccin especial+ permite conectarse por medio de
los protocolos de red a la misma m8"uina en caso "ue estemos en un laboratorio de in&orm8tica y
dispongamos de la in&ormacin de las direcciones ip de las otras P5s de la red ser?a interesante "ue se
trabajara en grupos de dos+ para poder apreciar la cone'in remota.
Nota: 2ueda como tarea para el lector revisar los m1todos y propiedades de la clase o tipo de
datos /oc%et y /erver/oc%et$
Para establecer una cone'in de red es necesario "ue alguien est escuc#ando en un puerto+
estos puertos son un concepto abstracto "ue podemos asimilarlo compar8ndolo con un puerto real
donde llegan barcos+ dic#os barcos una vez "ue llegan son atendidos y siempre "ue #aya "uien
atenderlos podr8 entrar otro.
/n este caso solo esperaremos una Nnica cone'in en el puerto+ y cuando esta se establezca no
esperaremos ninguna otra.
7a clase 1erver1oc(et nos permitir8 &abricar un objeto "ue podr8 esperar una cone'in+ y
cuando esta llegue podemos abrirla por medio del objeto resultante 1oc(et :cone'in;. /l puerto de
escuc#a en este ejemplo ser8$ ,6=E+ muc#os &irewalls y mecanismos de proteccin de red pueden
blo"uear el acceso a estos puertos+ as? "ue cual"uier cosa preguntamos al administrador de la red+ por
otro lado no podemos usar un puerto m8s bajo in&erior a los @AC, por"ue ser8 necesario por lo general
permisos especiales en el sistema operativo.
9elefonista-
1. package com.compunauta.aprendiendojava;
2. import java.io.*;
3. import java.net.*;
4. /**
5. * <p>Ttulo: Aprendiendo Java</p>
6. * <p>Descripcin: Ejemplos del Libro Aprendiendo Java de Compunauta</p>
7. * <p>Copyright: Copyright (c) 2006 www.compunauta.com</p>
8. * <p>Empresa: COMPUNAUTA</p>
9. * @author Gustavo Guillermo Prez
10. * @version 2006.01.01
11. */
12.
13.public class Cap3_sock_tel {
14.//Declaramos unas variables globales a este tipo de datos
15.public static int PORT=4567;
16.public static int BUFF_SIZE=40;
17.public static int TIMER_SLEEP=60*1000; //60sx1000ms
18.public static int buff_elem=0;
19.public static int[] buffer=new int[BUFF_SIZE];
20.
21. public static void main(String[] args) {
22. //Declaramos la variable socket (ser un puntero a objeto)
23. Socket skt=(Socket)null;
24. //Declaramos vaco el servidor de sockets para inicializarlo
25. ServerSocket Ss=(ServerSocket)null;
26.
27. //Tratamos de escuchar el puerto definido por la variable PORT
28. System.err.println("Escuchando el puerto:"+PORT);
29. try {Ss = new ServerSocket(PORT);}
30. catch (IOException ex) {
31. System.out.println("El sistema no permite abrir el puerto");
32. System.exit(-1);}
33.
34. //Si no ocurri error arriba entonces esperamos a la secretaria
P8gina ,E%=6
35. System.err.println("Esperando conexin...");
36. try {skt = Ss.accept();}
37. catch (IOException ex1) {
38. ex1.printStackTrace(System.err);
39. System.exit(-1);}
40.
41. //Si no ocurri error arriba la secretaria est lista para enviar
42. System.err.println("Conectado... Esperando telfonos");
43. try {
44. ObjectInputStream datos = new ObjectInputStream(skt.getInputStream());
45. long timer=0;
46. boolean timer_on=false;
47. while (true){
48. if((skt.isClosed() && (buff_elem<1)) || (buffer[0]==-1)){
49. //Terminamos el programa si la secretaria termin
50. System.err.println("Ultima llamada, nos vamos... terminado");
51. System.exit(0);
52. }
53. //si hay telfonos los guardamos
54. if(datos.available()>0){
55. put_tel(datos.readInt());}
56. if(timer_on){
57. //si el timer funciona no hacer nada, si se pas pararlo
58. if ((timer+TIMER_SLEEP)<System.currentTimeMillis()){timer_on=false;}
59. }else{
60. //Si el timer est apagado, mostramos un tel si es que hay
61. if (buff_elem>0){System.out.println("Secretaria llamando al
tel:"+get_tel());
62. //Encendemos el timer y guardamos la hora en que empez
63. timer_on=true;
64. timer=System.currentTimeMillis();}
65. }
66. //Pausamos 100ms para no sobrecargar el procesador
67. try {Thread.sleep(100);}
68. catch (InterruptedException ex3) {}
69. }//fin del bloque eterno
70. }catch (IOException ex2) {
71. ex2.printStackTrace(System.err);
72. System.exit(-1);
73. }
74.
75. }//fin del mtodo principal
76.
77.//Funciones o mtodos auxiliares
78.public static void put_tel(int tel){
79.//Si se supera el espacio producir un error
80.if (BUFF_SIZE<(buff_elem+1)){
81.System.err.println("Buffer overrun: El buffer se llen demasiado rpido");
82.System.exit(-1);}
83.//guardamos el tel y aumentamos en uno el contador
84.buffer[buff_elem++]=tel;
85.}
86.
87.public static int get_tel(){
88. //almacenamos el primer telfono
89. int tel=buffer[0];
90. //quitamos uno al contador de elementos
91. buff_elem--;
92. //recorremos los otros elementos
93. for (int i=0;i<buff_elem;i++) buffer[i]=buffer[i+1];
94. //devolvemos el primer telfono
P8gina ,F%=6
95. return tel;
96.}
97.
98.}//final de la clase
3e las l?neas @6 a la @> se declaran las variables globales "ue ser8n accesibles por todos los
mtodos est8ticos de la clase como ser el puerto de escuc#a+ el tamaSo del bu&&er y el verdadero bu&&er
donde utilizamos el tamaSo de&inido para crearlo+ recordemos "ue una vez de&inido el arreglo "ue
actuar8 de bu&&er no podemos e'pandirlo o reducirlo+ por ello el c8lculo previo para estimar su
m8'ima cantidad de datos. .ambin se de&ine el tiempo en milisegundos "ue esperaremos antes de
mostrar en pantalla el siguiente tel&ono.
A partir de la l?nea C@ comienza el mtodo principal+ el cual se ejecutar8 paso seguido de
inicializar las variables globales. *evisemos la l?nea CD+ la declaracin de la variable s%t+ no estamos
inicializando el objeto de la biblioteca+ sino "ue lo estamos apuntando a un objeto especial de tipo
nulo+ este objeto llamado null es un objeto vac?o "ue no posee propiedades de ningNn tipo y cada vez
"ue "ueramos operar sobre el producir8 un error de puntero nulo+ entonces cpor"u lo necesitamosd.
/l compilador no es lo su&icientemente inteligente como para detectar "ue lo inicializaremos en un
blo"ue de cdigo &uturo y necesitamos declararlo en este punto de nuestro mtodo principal+ por"ue
todo lo "ue se declara en blo"ues especiales como tryHIcatc#:;HI es local y desaparece &uera de ellos.
/n la l?nea C6 declaramos el objeto de la biblioteca 1erver1oc(et "ue escuc#ar8 y devolver8 un
objeto del tipo 1oc(et+ usamos el mismo objeto nulo para inicializarlo.
3esde la l?nea CE a la DC intentamos crear el objeto 1erver1oc(et y lo "ue es m8s importante+
detectar si #ubo o no un error por parte del sistema ya "ue no podremos continuar si se produce un
error+ como podemos ver en nuestro blo"ue de control de errores salimos si el sistema no nos permite
abrir dic#o puerto+ en el caso "ue tengamos algNn tipo de proteccin de red tendremos "ue
desactivarla temporalmente para poder trabajar.
/ntre las l?neas D, y D> nos encargamos de esperar una cone'in remota+ nuevamente es
necesario capturar las posibles e'cepciones de error "ue puedan producirse+ es obligatorio por el
compilador manejar las e'cepciones declaradas por 1erver1oc(et+ como podemos ver+ la &uncin
accept:;G de 1erver1oc(et aceptar8 una cone'in y esa cone'in la almacenaremos en el apuntador
s(t+ teniendo a#ora correctamente inicializado dic#o apuntador podemos usar las caracter?sticas de la
cone'in.
A partir de la l?nea ,C comenzamos la operacin de lectura de la cone'in de red y de la
impresin en pantalla de los tel&onos.
Ua #ab?amos visto los objetos del tipo 6nput/tream para la lectura de te'to desde el teclado+ en
este caso lo usaremos para la lectura desde la cone'in+ solo "ue para practicar+ utilizaremos un objeto
de la misma &amilia pero del tipo O-ect6nput/tream "ue nos permitir?a enviar objetos a travs del
canal o &lujo de datos.
/l objeto s)t provee la &uncin get-nput1tream:;G "ue nos devolver8 el Objeto del tipo
-nput1tream "ue necesita el objeto de la biblioteca del tipo O-ect6nput/tream para ser construido.
/n la l?nea ,6 declaramos una variable de tipo entero largo :long; timer "ue utilizaremos para
medir el tiempo y as? crear nuestro temporizador+ le damos un valor inicial.
/n la l?nea ,= declaramos una variable booleana timer:on "ue nos servir8 de bandera para saber
el estado del temporizador+ si es "ue est8 activo :true; o parado :&alse;. 7o inicializamos en parado
por"ue no tenemos tel&onos #asta "ue la secretaria los comience a escribir.
/n la l?nea ,E se comienza un blo"ue del tipo Ymientras_+ w#ile:;HI el cual deseamos "ue sea
in&inito por"ue leeremos datos #asta "ue la secretaria env?e la seSal de &in+ pero mientras tengamos
tel&onos para mostrar en el bu&&er no podremos dejar de mostrarlos+ as? "ue para mejor comprensin
del cdigo+ el blo"ue w#ile:true;HI se ejecutar8 por siempre a menos "ue el programa decida
P8gina ,>%=6
terminar.
*evisemos el cdigo de la l?nea ,F a la 6C+ en este blo"ue comparamos dos condiciones
importantes para decidir si el programa debe salir o no+ la primera es una condicin doble+ por eso est8
encerrada entre parntesis+ es decir si la conexin est cerrada - la cantidad de elementos del buffer
es inferior a 1 o sucede "ue el elemento cero del buffer es el nBmero +1 )ue indica la secretaria )ue
termin entonces nos vamos por"ue es el Nltimo elemento y no es necesario mostrarlo.
/l siguiente blo"ue desde la l?nea 6,+66 almacenamos un nNmero entero desde la cone'in de
red datos+ slo si es "ue #ay datos disponibles+ eso lo revisamos con la &uncin available:;G "ue no se
"uedar8 esperando+ si e'isten o no datos disponibles de todas maneras el programa sigue su curso.
/l timer+ entre las l?neas 6F a la =6+ &unciona de la siguiente manera+ cuando "ueremos comenzar
a medir el tiempo+ almacenamos dentro de la variable timer la #ora actual medida en milisegundos+
ese dato lo obtenemos con la &uncin del objeto system+ currentTime(illis34+ si al timer+ le sumamos
la cantidad de tiempo "ue "ueremos esperar+ ese valor siempre ser8 m8s grande "ue la #ora actual+
#asta "ue se pase el tiempo+ eso es lo "ue comparamos en el blo"ue i&:;HI+ caso contrario nos
preparamos para ver si es necesario encender el timer y mostrar tel&onos+ "ue slo suceder8 si #ay
m8s de @ elemento en el bu&&er+ recordemos "ue en bu&&Telem almacenamos la cantidad de elementos
de nuestra memoria temporal.
/n las l?neas =E+=F incluimos otro blo"ue de control de errores obligatorio por"ue utilizaremos
otra &uncin de la biblioteca de Java "ue pertenece a la clase .#read :#ilo; esa &uncin detiene la
ejecucin del programa una cierta cantidad de milisegundos+ el uso de este pe"ueSo retardo de @AA
milisegundos es para no sobrecargar el procesador+ ya "ue estar?amos ejecutando nuestro bucle
w#ile:true;HI in&inidades de veces en @ Nnico segundo lo cual no es necesario ya "ue la secretaria no
es tan veloz y dejamos libre el procesador para el sistema operativo.
/n la l?nea => termina el blo"ue eterno w#ile:true;HI y el blo"ue de control de errores "ue lo
contiene+ dado el caso "ue se produzca un error dentro del blo"ue ser8 necesario terminar el programa.
7os mtodos au'iliares$
public static void put_tel(int tel){
/sta &uncin agregar8 un tel&ono en la memoria temporal+ en nuestro bu&&er+ #aciendo una
cierta deteccin de errores+ en el caso "ue el bu&&er no sea lo su&icientemente grande como para
almacenar el pr'imo dato+ en este caso el programa se sale con error.
1i esto no sucede+ la l?nea m8s importante de esta &uncin es$
buffer[buff_elem++]=tel;
3onde como vimos al principio de este libro el signo QQ a la derec#a de bu&&Telem simboliza
"ue primero se utilizar8 el valor y despus se incrementar8+ entonces en una sola l?nea representamos
las dos operaciones bu&&erJbu&&TelemKtelG bu&&TelemQQG
public static int get_tel(){
/sta &uncin e'traer8 un elemento del bu&&er+ pero al mismo tiempo "ue lo e'trae debe
posicionar los dem8s elementos #acia el inicio del arreglo.
.ampoco #acemos la comprobacin de "ue no #aya elementos en el bu&&er por"ue la #acemos
en el cdigo cada vez "ue vemos si #ay tel&onos para mostrar+ aun"ue deber?amos por buena pr8ctica
por"ue si este es un prototipo y nuestro programa ir8 creciendo+ entonces tal vez se nos escape revisar.
Almacenamos de manera temporal el tel&ono pr'imo antes de recorrer los datos$
int tel=buffer[0];
P8gina 6A%=6
3espus de eso "uitamos uno al apuntador de elementos+ y lo "uitamos antes por"ue para subir
los datos sumaremos uno al ?ndice "ue recorremos para acomodar los datos y tendr?amos "ue estar
revisando "ue el ?ndice no supere bu&&TelemV@+ como esa condicin se comparar?a cada vez "ue
pasamos por un valor del ?ndice estar?amos ejecutando innecesariamente una resta "ue podr?amos
#acer antes.
4na vez terminado devolvemos el tel&ono "ue almacenamos antes "ue desapareciera.
Nota: Es incorrecto el mane-o de error en la funcin put;tel, ya +ue en #ava e*iste un
modelo de e*cepciones +ue deen ser lan)adas y capturadas como en cual+uier
lo+ue de control de errores, si no corrooramos el ndice #ava producir! una
6nde*OutOf5oundE*ception +ue de todas maneras terminar! el programa$
.ecretaria-
1. package com.compunauta.aprendiendojava;
2. import java.io.*;
3. import java.net.*;
4. /**
5. * <p>Ttulo: Aprendiendo Java</p>
6. * <p>Descripcin: Ejemplos del Libro Aprendiendo Java de Compunauta</p>
7. * <p>Copyright: Copyright (c) 2006 www.compunauta.com</p>
8. * <p>Empresa: COMPUNAUTA</p>
9. * @author Gustavo Guillermo Prez
10. * @version 2006.01.01
11. */
12.
13.public class Cap3_sock_sec {
14.//Declaramos unas variables globales a este tipo de datos
15.public static int PORT=4567;
16.public static String HOST="127.0.0.1";
17.
18. public static void main(String[] args) {
19. System.err.println("Intentando conectar con la telefonista");
20. Socket skt=(Socket)null;
21. try {skt = new Socket(HOST, PORT);}
22. catch (Exception ex) {
23. System.err.println("La telefonista no est en lnea");
24. System.exit(-1);
25. }
26.
27. int tel;
28. BufferedReader teclado=new BufferedReader(new
InputStreamReader(System.in));
29. try {
30. ObjectOutputStream datos = new
ObjectOutputStream(skt.getOutputStream());
31. System.err.println("Nos conectamos con la
telefonista:"+HOST+":"+PORT);
32. System.err.println("Ingrese nmeros -1 termina");
33. while (true){
34. if((tel=leerInt(teclado))==-1){
35. System.err.println("Programa terminado");
36. datos.writeInt(-1);
37. datos.flush();
38. datos.close();
39. skt.close();
40. System.exit(0);
41. }else{
42. datos.writeInt(tel);
P8gina 6@%=6
43. datos.flush();
44. }
45. }//fin de la lectura eterna
46. }catch (IOException ex1) {ex1.printStackTrace(System.err);}
47.
48. }//fin del mtodo principal
49.
50.//Funciones o mtodos auxiliares
51.public static int leerInt(BufferedReader buff){
52. int lee=0;
53. boolean error;
54. do {
55. error=false;
56. try {lee = Integer.parseInt(buff.readLine());}
57. catch (NumberFormatException ex) {
58. System.err.println("Entrada erronea, repetir:?");
59. error=true;}
60. catch (Exception ex){ex.printStackTrace(System.err);}
61. } while (error);
62. return lee;
63. }//final de la funcion leer
64.
65.}//final de la clase
3escripcin del &uncionamiento$
/n las l?neas @6 y @= declaramos las variables globales "ue almacenar8n el puerto y la direccin
de red donde nos conectaremos+ en este caso la direccin @CE.A.A.@ es universal y permite conectarse a
la misma m8"uina as? "ue podremos ejecutar el programa de la secretaria y la tele&onista en la misma
P5 en consolas de comandos di&erentes+ si estamos en el laboratorio con m8s de @ P5 en */3+
entonces en ese nNmero pondremos el "ue nos comente el administrador del sistema para conectarnos
a la P5 "ue correr8 la tele&onista.
/n la l?nea @F comienza nuestro mtodo principal y de la misma manera "ue en el programa
anterior de&inimos el 1oc(et :s(t; como un elemento vac?o sin inicializar+ ya "ue estamos obligados a
revisar errores.
/ntre las l?neas C@ a C6 comprobamos "ue se pueda #acer una cone'in al puerto y direccin de
red indicados+ puede suceder "ue el error no sea e'actamente "ue la tele&onista no est8 en l?nea y "ue
el sistema operativo est denegando el acceso a conectarse al e'terior+ por ello revisar el &irewall del
sistema o los permisos necesarios.
1i nos pudimos conectar el programa sigui adelante y procedemos a crear un objeto
Bu&&ered*eader para manipular la entrada por teclado y declaramos una variable tel "ue almacenar8
un tel&ono para enviar.
/n la l?nea C> comienza el blo"ue donde abriremos la cone'in de datos remota por medio de un
&lujo de datos del tipo O-etOutput/tream.
5omo en el componente anterior utilizamos un bucle eterno para la ejecucin del programa "ue
saldr8 por otros mecanismos. :l?nea DD;.
/n la l?nea D,+ asignamos el valor "ue se lee por teclado a la variable tel+ ese segmento est8 entre
parntesis por"ue por"ue ese mismo valor asignado lo compararemos antes de proseguir+ podr?amos
#aber #ec#o primero la asignacin y despus la comparacin.
1i la secretaria escribi V@ enviamos el V@ a la tele&onista para avisarle "ue terminamos+ :l?nea
D=;+ la orden datos$flu*,34< vac?a los datos de memoria *A0 al &lujo de datos inmediatamente y en
las l?neas DF y D> cerramos debidamente el &lujo de datos y la cone'in de red antes de salir sin
producir error+ salir con el cdigo A es no producir error.
P8gina 6C%=6
/n la l?nea ,@ comienza el blo"ue de datos "ue se ejecutar8 caso contrario a "ue la secretaria
ingrese un V@. 3onde podemos ver "ue escribimos en el &lujo de datos el nNmero entero
correspondiente al tel&ono y obligamos la escritura inmediata con la orden flus,34<.
.ermina el bucle etenro w#ile:true;HI termina el blo"ue de control de errores y el mtodo
principal+ a continuacin est8n la &uncin au'iliar leer-nt "ue no e'plicaremos por"ue es la misma "ue
vimos en el cap?tulo anterior.
Nota: =eremos con m!s detalles el uso de soc%ets durante el transcurso del liro, no
a,ondaremos en ello a,ora$ 2ueda como e-ercicio para el lector producir el error de
5uffer Overrun y revisar en la documentacin electrnica los m1todos y o-etos
utili)ados de la ilioteca de #ava$
3m!lementacin del bu00er ti!o L3.O (La !ila, 4ltimo en llegar es !rimero en salir)
0odi&i"uemos el ejemplo anterior para "ue a#ora sean una bibliotecaria y su asistente+ la
bibliotecaria recibir8 libros nuevos para catalogar y los enviar8 a apilar en el escritorio de la asistente+
la asistente tendr8 un minuto para leer el nombre de la eti"ueta "ue envi la bibliotecaria a travs de la
red y ordenarlo+ es visto "ue los libros a#ora saldr8n en &orma de pila y no cola de espera+ el l?mite
ser8 la altura de la asistente "ue #ace las tarjetas sentada+ pero no lo calcularemos $p.
7ibros en total C,+ se env?a el contenido de la tarjeta en modo te'to.
sistente-
gus@gusgus ~$ java com.compunauta.aprendiendojava.Cap3_lifo_asis
Escuchando el puerto:4567
Esperando conexin...
Conectado... Esperando ttulos
Libro:Introduccin a la fsica
No hay ms, nos vamos cuando terminemos...
Libro:Aprendiendo Java
Libro:Lectura I
Libro:Asambleas
Ya no es necesario esperar, terminado...
gus@gusgus ~$
;ibliotecaria-
gus@gusgus ~$ java com.compunauta.aprendiendojava.Cap3_lifo_bib
Intentando conectar con la asistente
Nos conectamos con la asistente:127.0.0.1:4567
Ingrese Ttulos (lnea vaca termina)
Introduccin a la fsica
Asambleas
Lectura I
Aprendiendo Java
Programa terminado
gus@gusgus ~$
sistente-
1. package com.compunauta.aprendiendojava;
2. import java.io.*;
3. import java.net.*;
4. /**
5. * <p>Ttulo: Aprendiendo Java</p>
6. * <p>Descripcin: Ejemplos del Libro Aprendiendo Java de Compunauta</p>
P8gina 6D%=6
7. * <p>Copyright: Copyright (c) 2006 www.compunauta.com</p>
8. * <p>Empresa: COMPUNAUTA</p>
9. * @author Gustavo Guillermo Prez
10. * @version 2006.01.01
11. */
12.
13.public class Cap3_lifo_asis {
14.//Declaramos unas variables globales a este tipo de datos
15.public static int PORT=4567;
16.public static int BUFF_SIZE=24;
17.public static int TIMER_SLEEP=60*1000; //60sx1000ms
18.public static int buff_elem=0;
19.public static String[] buffer=new String[BUFF_SIZE];
20.
21. public static void main(String[] args) {
22. //Declaramos la variable socket (ser un puntero a objeto)
23. Socket skt=(Socket)null;
24. //Declaramos vaco el servidor de sockets para inicializarlo
25. ServerSocket Ss=(ServerSocket)null;
26.
27. //Tratamos de escuchar el puerto definido por la variable PORT
28. System.err.println("Escuchando el puerto:"+PORT);
29. try {Ss = new ServerSocket(PORT);}
30. catch (IOException ex) {
31. System.out.println("El sistema no permite abrir el puerto");
32. System.exit(-1);}
33.
34. //Si no ocurri error arriba entonces esperamos a la secretaria
35. System.err.println("Esperando conexin...");
36. try {skt = Ss.accept();}
37. catch (IOException ex1) {
38. ex1.printStackTrace(System.err);
39. System.exit(-1);}
40.
41. //Si no ocurri error arriba la secretaria est lista para enviar
42. System.err.println("Conectado... Esperando ttulos");
43. try {
44. BufferedReader datos = new BufferedReader(new
InputStreamReader((skt.getInputStream())));
45. long timer=0;
46. boolean timer_on=false;
47. boolean ultimo=false;
48. while (true){
49. if(!ultimo && (skt.isClosed() || ((buff_elem>0) && buffer[buff_elem-
1]!=null && buffer[buff_elem-1].equals("fin")))){
50. //Terminamos el programa si la bibliotecaria termin
51. System.err.println("No hay ms, nos vamos cuando terminemos...");
52. //el libro fin no se debe guardar es el aviso
53. buff_elem--;
54. ultimo=true;
55. }
56. if(ultimo && (buff_elem==0)){
57. System.err.println("Ya no es necesario esperar, terminado...");
58. System.exit(0);}
59. //si hay ttulos los guardamos
60. if(!ultimo && datos.ready()){
61. put_tit(datos.readLine());}
62. if(timer_on){
63. //si el timer funciona no hacer nada, si se pas pararlo
64. if
((timer+TIMER_SLEEP)<System.currentTimeMillis()){timer_on=false;}
P8gina 6,%=6
65. }else{
66. //Si el timer est apagado, mostramos un tel si es que hay
67. if (buff_elem>0){System.out.println("Libro:"+get_tit());
68. //Encendemos el timer y guardamos la hora en que empez
69. timer_on=true;
70. timer=System.currentTimeMillis();}
71. }
72. //Pausamos 100ms para no sobrecargar el procesador
73. try {Thread.sleep(100);}
74. catch (InterruptedException ex3) {}
75. }//fin del bloque eterno
76. }catch (Exception ex2) {
77. ex2.printStackTrace(System.err);
78. System.exit(-1);
79. }
80.
81. }//fin del mtodo principal
82.
83.
84.//Funciones o mtodos auxiliares
85.public static void put_tit(String tit){
86.//Si se supera el espacio producir un error
87.if (BUFF_SIZE<(buff_elem+1)){
88.System.err.println("Buffer overrun: El buffer se llen demasiado rpido");
89.System.exit(-1);}
90.//guardamos el tel y aumentamos en uno el contador
91.buffer[buff_elem++]=tit;
92.}
93.
94.public static String get_tit(){
95. //quitamos uno al contador de elementos
96. //devolvemos el ltimo libro
97. return buffer[--buff_elem];
98.}
99.
100.}//final de la clase
3escripcin del &uncionamiento$
7a declaracin de variables globales a la clase o tipo de datos se realiza entre las l?neas @6 y @>.
/l mtodo principal comienza en la l?nea C@+ y declaramos los objetos del tipo 1oc(et y
1erver1oc(et como en el apartado anterior.
3esde la l?nea CF a la DC intentamos abrir el puerto para escuc#ar cone'iones entrantes+ si
sucede un error nos salimos.
1i no #ay errores+ entre la l?nea D6 y DF esperamos una cone'in entrante con su respectivo
blo"ue de control de errores.
5omo la &uncin accept34<detendr8 el programa #asta "ue arribe una cone'in+ si estamos
ejecutando el blo"ue principal entre las l?neas ,D y siguientes+ es por"ue se recibi una cone'in. /n
el respectivo blo"ue de control de errores iniciamos el &lujo de datos "ue usaremos para ir recibiendo
renglones+ en este caso usamos el mismo tipo de objeto "ue nos permite leer l?neas desde el teclado+
solo "ue a#ora las leeremos desde la cone'in de red.
3eclaramos algunas cuantas variables para crear nuestro temporizador de @ minuto igual "ue en
el ejemplo anterior+ y de&inimos una variable ultimo "ue nos avisar8 cuando los libros son todos.
/n este caso la bandera "ue usamos para saber "ue #emos terminado por parte de la bibliotecaria
es la palabra clave Y&in_+ y por supuesto revisamos "ue la cone'in no est cerrada+ "ue #aya
P8gina 66%=6
elementos y todo eso antes de proceder a retirar un libro del bu&&er y enseSarlo en pantalla. 7a bandera
binaria ultimo solo se activar8 en la condicin anterior para asegurar "ue seguiremos mostrando
t?tulos mientras+ es una variacin respecto del ejemplo anterior para ver otras maneras de resolver algo
similar.
1i+ el ultimo elemento ya lleg y no #ay m8s en la memoria temporal+ entonces nos salimos del
programa. :l?neas 6=V6F;.
1i no es el ultimo elemento y #ay datos disponibles en el &lujo de datos de red+ entonces leer una
l?nea y ponerla en la memoria temporal.
1i el timer est8 encendido entonces procedemos igual "ue antes+ el Nnico cambio sustancial
ser8n las &unciones "ue guardan y e'traen los datos del bu&&er.
7a Nnica &uncin "ue cambia es la "ue "uita elementos del bu&&er+ "ue es muc#o m8s simple "ue
antes.
return buffer[--buff_elem];
3onde estamos decrementando el contador de elementos antes :el VV est8 a la iz"uierda; y como
sabemos "ue los arreglos se acceden desde el A a cantidadV@ entonces es correcto el resultado
devuelto.
;ibliotecaria-
1. package com.compunauta.aprendiendojava;
2. import java.io.*;
3. import java.net.*;
4. /**
5. * <p>Ttulo: Aprendiendo Java</p>
6. * <p>Descripcin: Ejemplos del Libro Aprendiendo Java de Compunauta</p>
7. * <p>Copyright: Copyright (c) 2006 www.compunauta.com</p>
8. * <p>Empresa: COMPUNAUTA</p>
9. * @author Gustavo Guillermo Prez
10. * @version 2006.01.01
11. */
12.
13.public class Cap3_lifo_bib {
14.//Declaramos unas variables globales a este tipo de datos
15.public static int PORT=4567;
16.public static String HOST="127.0.0.1";
17.
18. public static void main(String[] args) {
19. System.err.println("Intentando conectar con la asistente");
20. Socket skt=(Socket)null;
21. try {skt = new Socket(HOST, PORT);}
22. catch (Exception ex) {
23. System.err.println("La asistente no est en lnea");
24. System.exit(-1);
25. }
26.
27. String titulo;
28. BufferedReader teclado=new BufferedReader(new
InputStreamReader(System.in));
29. try {
30. PrintWriter datos = new PrintWriter(skt.getOutputStream());
31. System.err.println("Nos conectamos con la asistente:"+HOST+":"+PORT);
32. System.err.println("Ingrese Ttulos (lnea vaca termina)");
33. while (true){
34. if((titulo=leerLinea(teclado)).length()==0){
35. System.err.println("Programa terminado");
P8gina 6=%=6
36. datos.println("fin");
37. datos.flush();
38. datos.close();
39. skt.close();
40. System.exit(0);
41. }else{
42. datos.println(titulo);
43. datos.flush();
44. }
45. }//fin de la lectura eterna
46. }catch (IOException ex1) {ex1.printStackTrace(System.err);}
47.
48. }//fin del mtodo principal
49.
50.//Funciones o mtodos auxiliares
51.public static String leerLinea(BufferedReader buff){
52. try {return buff.readLine();}
53. catch (Exception ex){ex.printStackTrace(System.err);}
54. return "";
55. }//final de la funcin leer
56.
57.}//final de la clase
/sta implementacin es idntica a la de la secretaria del ejemplo anterior+ solo "ue para variar
utilizamos otro tipo de Objeto para el &lujo de datos.
3m!lementacin de una Lista de datos%
/n este caso la memoria temporal ser8 una simple lista+ se pretender8 "ue el usuario ingrese una
lista de nombres y "ue en cual"uier momento se pueda buscar+ borrar+ o agregar elementos.
1alida por pantalla$
gus@gusgus ~$ java com.compunauta.aprendiendojava.Cap3_lista
SELECCIONE UNA OPCIN:
1) Ingresar un elemento al listado
2) Listar los elementos de la lista
3) Borrar un elemento de la lista
0) Salir
opcin?
1
Dato:?
Azul
opcin?
1
Dato:?
Celeste
opcin?
1
Dato:?
Caffe
opcin?
1
Dato:?
Osos
opcin?
2
Item[0]:[Azul]
Item[1]:[Celeste]
Item[2]:[Caffe]
Item[3]:[Osos]
P8gina 6E%=6
SELECCIONE UNA OPCIN:
1) Ingresar un elemento al listado
2) Listar los elementos de la lista
3) Borrar un elemento de la lista
0) Salir
opcin?
3
Item a borrar:?
2
SELECCIONE UNA OPCIN:
1) Ingresar un elemento al listado
2) Listar los elementos de la lista
3) Borrar un elemento de la lista
0) Salir
opcin?
2
Item[0]:[Azul]
Item[1]:[Celeste]
Item[2]:[Osos]
gus@gusgus ~$
A#ora veamos el cdigo$
1. package com.compunauta.aprendiendojava;
2. import java.io.*;
3.
4. /**
5. * <p>Ttulo: Aprendiendo Java</p>
6. * <p>Descripcin: Ejemplos del Libro Aprendiendo Java de Compunauta</p>
7. * <p>Copyright: Copyright (c) 2006 www.compunauta.com</p>
8. * <p>Empresa: COMPUNAUTA</p>
9. * @author Gustavo Guillermo Prez
10. * @version 2006.01.01
11. */
12.
13.public class Cap3_lista {
14. //Variables globales
15. public static int MAX=15;
16. public static String[] lista=new String[MAX];
17. public static int lista_elem=0;
18.
19. public static void main(String[] args) {
20. BufferedReader teclado=new BufferedReader(new
InputStreamReader(System.in));
21. int op=-1;
22. while(true){
23. switch (op){
24. case 1:
25. System.out.println("Dato:?");
26. ingresa(leerLinea(teclado));
27. break;
28. case 2:
29. listar();
30. break;
31. case 3:
32. System.out.println("Item a borrar:?");
33. borrar(opcion(teclado));
34. break;
35. case 0:
36. System.out.println("Terminado..");
P8gina 6F%=6
37. System.exit(0);
38. break;
39. }
40. if(op!=1)imprimir_menu();
41. System.out.println("opcin?");
42. op = opcion(teclado);
43. }//fin del bucle eterno
44. }//fin del mtodo principal
45.
46. //Funciones auxiliares
47. public static void ingresa(String dato){
48. lista[lista_elem++]=dato;
49. }
50.
51. public static void listar(){
52. for (int i=0;i<lista_elem;i++){
53. System.out.println("Item["+i+"]:["+lista[i]+"]");
54. }
55. }
56.
57. public static void borrar(int item){
58. lista_elem--;
59. for (int i=item;i<lista_elem;i++){
60. lista[i]=lista[i+1];
61. }
62. }
63.
64. public static void imprimir_menu(){
65. System.out.println("SELECCIONE UNA OPCIN:");
66. System.out.println("1) Ingresar un elemento al listado");
67. System.out.println("2) Listar los elementos de la lista");
68. System.out.println("3) Borrar un elemento de la lista");
69. System.out.println("0) Salir");
70. }
71.
72. public static int opcion(BufferedReader buff){
73. int lee=0;
74. boolean error;
75. do {
76. error=false;
77. try {return lee = Integer.parseInt(buff.readLine());}
78. catch (NumberFormatException ex) {
79.System.err.println("Entrada erronea, repetir:?");
80. error=true;}
81. catch (Exception ex){ex.printStackTrace(System.err);}
82. } while (error);
83.return lee;
84.}//final de la funcion leer
85.
86.public static String leerLinea(BufferedReader buff){
87. try {return buff.readLine();}
88. catch (Exception ex){ex.printStackTrace(System.err);}
89. return "";
90. }//final de la funcion leer
91.
92.}//fin de la clase
/n esta implementacin agregamos un menN de usuario en pantalla "ue nos permitir8
interoperar un poco mejor el programa para probar todas las opciones e incluso #acer e'perimentos y
e'pandirlo con los ejemplos "ue seguir8n a este.
5omo antes entre las l?neas @6 y @E declaramos globalmente la lista+ sus l?mites y el apuntador
P8gina 6>%=6
de elementos.
2uestro mtodo principal :l?nea CA; crear8 un objeto como antes #icimos para leer desde el
teclado :o podr?a ser una &uente e'terna como la red en los ejemplos anteriores;.
3e&inimos de manera local al mtodo principal la variable op "ue almacenar8 la opcin de menN
"ue #aya escogido el usuario :l?nea C@;.
3e la misma manera "ue antes ejecutamos inde&inidamente el blo"ue w#ile:true;HI aun"ue
podr?amos igual "ue en todos los casos anteriores proponer una condicin viable "ue tambin sea
v8lida para terminar el programa como por ejemplo :op^^A;.
5ada cl8usula case ejecutar8 la &uncin correcta+ para no producir una reimpresin e'cesiva
molesta en la pantalla del menN de usuario slo lo reimprimiremos si la opcin de menN no &ue la de
agregar datos :l?nea ,A;.
/n las l?neas ,@ y ,C imprimimos la leyenda para solicitar la opcin. Podemos utilizar print en
vez de println para "ue el ingreso de datos "uede junto al signo de interrogacin.
Luncin ingresa :l?nea ,E;+ muy simple antes de aumentar en uno el contador de elementos se
utiliza el valor del ?ndice para almacenar el valor del dato "ue se desea ingresar a la lista.
Luncin listar :l?nea 6@;+ listamos todos los elementos de la lista en pantalla indicando su ?ndice
en el arreglo de te'to listaJK.
Luncin borrar :l?nea 6E;+ decrementamos en uno el contador de elementos y recorremos todos
los elementos restantes a la posicin "ue "ueremos eliminar.
Luncin imprimirTmenu:; :l?nea =,;+ slo imprime en pantalla las opciones "ue compara el
mtodo principal para realizar acciones.
Luncin opcin :l?nea EC;+ idntica a leer-nt "ue #emos estado viendo en todos estos ejemplos.
Luncin leer7inea :l?nea F=;+ idntica a leer7inea de todos estos ejemplos anteriores.
Nota: a partir de a+u a>adiremos funciones para e*perimentar con la lista, es e-ercicio
para el lector agregar a este e-emplo las entradas del men" y los correctos
mecanismos para e-ecutar esa funcionalidad en los lo+ues case del m1todo principal$
&4squeda de datos
9eremos tres maneras di&erentes de encontrar un elemento en una lista de datos+ el primero es el
m8s lgico+ el secuencial+ el opuesto+ aleatorio+ y el binario cuando la lista lleva algNn tipo de orden.
-Ds'!eda se!enial
7a bNs"ueda secuencial es el e"uivalente a recorrer todos los elementos de la lista y compararlos
del primero al Nltimo de manera "ue cuando encontramos el elemento terminamos la bNs"ueda.
public static String search(String patron){
for (int i=0;i<lista_elem;i++){
if(lista[i].indexOf(patron)!=-1) return lista[i];
}
return null;
}
Nota: Recordemos +ue lista;elem siempre almacenar! la cantidad de elementos y al
comprarar i?lista;elem estamos asegur!ndonos +ue -am!s se llegar! a este valor, ya
+ue los arreglos se acceden desde @ ,asta lista;elemAB$
P8gina =A%=6
-Ds'!eda aleatoria$ desordenar lista.
/ste mtodo es completamente probabil?stico y es &uncional cuando el mtodo binario u otro
mtodo m8s e&icaz no visto sea aplicable. /s &actible si el acceso a los datos es e'tremadamente lento+
es decir si la bNs"ueda secuencial podr?a tardar #oras para encontrar el Nltimo entre unos cuantos y
"ueremos probar suerte :ya "ue las probabilidades de la bNs"ueda secuencial son las mismas;+ tambin
sirve para desordenar una lista+ por ejemplo para repartir Ycartas mezcladas de un juego virtual_.
/jemplo$ /n una situacin donde la consulta en l?nea de arc#ivos clasi&icados depende de
personal #umano para deducir la respuesta y la respuesta #umana puede tardar minutos en encontrar
por ejemplo un sello en una carpeta+ la bNs"ueda se minimizar?a de manera aleatoria si tenemos suerte+
otro ejemplo ser?a buscar dentro de los arc#ivos de una lista de arc#ivos alojados en un servidor
remoto completamente saturado y con escasas posibilidades de trans&erencia a alta velocidad+ tambin
minimizar?amos el tiempo de bNs"ueda de manera "ue en el peor de los casos nuestra respuesta estar?a
entre el 6AZ y el @AAZ de los Nltimos registros y en el mejor de los casos entre el AZ y el 6AZ de los
primeros registros+ de todas maneras es la misma probabilidad "ue la bNs"ueda secuencial as? "ue solo
el azar es el "ue in&luye.
BNs"ueda desordenada de la lista$
1. public static String buscar_desordenado(String patron){
2. int[] indice=new int[lista_elem];
3. int aleatorio;
4. for (int i=0;i<lista_elem;i++) indice[i]=i;
5. for (int i=lista_elem;i>0;i--){
6. aleatorio=(int)(Math.random()*i);
7. if(lista[indice[aleatorio]].indexOf(patron)!=-1) return
lista[indice[aleatorio]]+":"+(lista_elem-i);
8. for (int j=aleatorio;j<i-1;j++)indice[j]=indice[j+1];
9. }
10. return null;
11. }
Labricamos un ?ndice para acceder a la lista+ con la cantidad de elementos actual y no la m8'ima
"ue es su capacidad+ ya "ue ser8 de manera temporal y local a la &uncin+ todos los objetos y variables
declarados dentro de una &uncin a menos "ue sean declarados est8ticos se perder8n y se liberar8
memoria del sistema.
*ellenamos el ?ndice con los elementos desde el A al m8'imo menos uno. /'traemos al azar un
elemento del ?ndice y recorremos los dem8s #asta el "ue "uitamos+ as? comparamos un elemento de la
lista al azar y terminamos si lo encontramos.
Nota: El tipo de "s+ueda no es e*acto ya +ue usamos inde*Of en ve) de e+uals$ 2ueda
para el lector agregar esta funcin en el e-emplo anterior y proarla$
3esordenar la lista$
12. public static void desordenar(){
13. int[] indice=new int[lista_elem];
14. String[] desordenado=new String[lista_elem];
15. int des_elem=0;
16. int aleatorio;
17. for (int i=0;i<lista_elem;i++) indice[i]=i;
18. for (int i=lista_elem;i>0;i--){
19. aleatorio=(int)(Math.random()*i);
20. desordenado[des_elem++]=lista[indice[aleatorio]];
21. for (int j=aleatorio;j<i-1;j++)indice[j]=indice[j+1];
22. }
23. for (int i=0;i<lista_elem;i++) lista[i]=desordenado[i];
P8gina =@%=6
24.}
Para desordenar la lista estamos usando una lista temporal+ con su respectivo contador e ?ndice
variable de elementos.
Nota: 2ueda como tarea para el lector optimi)ar esta funcin para +ue no sea necesaria la
lista temporal +ue en caso de escasos recursos y enormes listas no sera algo
permitido, utili)ando slo B o-eto temporal del tipo /tring para intercamiar valores
y eliminar el uso del ndice temporal$
-Ds'!eda -inaria "lista ordenada%
7a bNs"ueda binaria es un mtodo simple "ue se usa para encontrar datos en una lista ordenada+
el mecanismo es el siguiente...
1i tenemos una lista de n datos+ ordenados de mayor a menor y "ueremos encontrar uno en
particular+ #aremos una bNs"ueda con dos ?ndices+ o sea almacenaremos el valor del elemento
comparado m8s grande y m8s pe"ueSo #asta arrinconar el resultado o llegar a un punto donde no
e'iste tal elemento pero los dos mas cercanos son estos ?ndices mayor y menor.
9eamos a#ora un trozo de cdigo para cuando la lista est8 ordenada de manera creciente y
decreciente+ estas dos &unciones utilizan la &rmula "ue vimos en la ilustracin anterior para calcular
P8gina =C%=6
Ilustracin %: &Bs)ueda binaria en una lista ordenada
0
1
2
3
4
5
6
7
8
9
IINFERIOR
ISUPERIOR
(9-0)/2+0
4
4
5
6
7
8
9
IINFERIOR
ISUPERIOR
(9-4)/2+4
6
Se busca e ee!e"#$ 7 %e u"a
&s#a $'%e"a%a( $s c$"#e"&%$s
)ue%e" se' "$!b'es %e u"a
a*e"%a+
IINFERIOR
ISUPERIOR
6
7
8
9
(9-6)/2+6
7
7
P0omp=
[ I
1
I
-
]
C
I
-

S& e )u"#$ %e c$!)a'ac&," es !a-$'


.ue %a#$ .ue busca!$s se ac#ua&/a e
0"%&ce su)e'&$' a )u"#$ %e
c$!)a'ac&,"( s& es !e"$' se ac#ua&/a
e &"1e'&$'( 2as#a .ue e )u"#$ %e
c$!)a'ac&," sea e 'esu#a%$ busca%$
el ?ndice superior e in&erior+ de esa manera y teniendo en cuenta "ue la operacin de divisin ser8
redondeada y slo tendremos un nNmero entero veamos como "uedar?an nuestras &unciones.
Orden ascendente de .e'to$
1. public static String buscar_ordenado_az(String inicio){
2. int Is=lista_elem-1;
3. int Ii=0;
4. int cmp=0;
5. int old_cmp=-1;
6. int compare;
7. while (cmp!=old_cmp){
8. old_cmp=cmp;
9. cmp=(Is-Ii)/2+Ii;
10. compare=lista[cmp].compareTo(inicio);
11. if(compare==0){return lista[cmp];}
12. if(compare<0){Ii=cmp;}
13. if(compare>0){Is=cmp;}
14. }
15. return lista[Is];
16. }
Orden descendente de te'to$
17. public static String buscar_ordenado_za(String inicio){
18. int Is=lista_elem-1;
19. int Ii=0;
20. int cmp=0;
21. int old_cmp=-1;
22. int compare;
23. while (cmp!=old_cmp){
24. old_cmp=cmp;
25. cmp=(Is-Ii)/2+Ii;
26. compare=lista[cmp].compareTo(inicio);
27. if(compare==0){return lista[cmp];}
28. if(compare>0){Ii=cmp;}
29. if(compare<0){Is=cmp;}
30. }
31. return lista[Ii];
32. }
/n estas dos &unciones iguales+ slo cambian las comparaciones+ el problema en este ejemplo es
la manera en la "ue la &uncin de la biblioteca e&ectNa la comparacin+ podemos crear nuestras propias
&unciones de comparacin y evitar usar las de la biblioteca+ pero+ la biblioteca suele tener &unciones
optimizadas al nivel del sistema operativo y no la m8"uina virtual de Java+ por lo tanto las usaremos
siempre "ue podamos.
Nota: 2ueda para el lector agregar esta funcin al e-emplo de las listas y reconstruirla para
el caso +ue los elementos sean n"meros cuales+uiera enteros en ve) de o-etos de
te*to$
MCtodos (ara ordenar listas
9eremos a continuacin algunos pocos mtodos para ordenar listas de datos+ esto nos servir8
para poder aplicar la bNs"ueda binaria sobre una lista de datos+ aun"ue en la actualizad esto ya casi no
se utiliza debido a "ue los motores de bases de datos ordenan los resultados :resultsets; de manera "ue
ya no es necesario ordenar+ se delega la tarea a programas optimizados para #acer eso de manera
e'traordinariamente r8pida como 0y1`7 compilado para el procesador de la P5.
P8gina =D%=6
M$todo de la burbuja
/ste mtodo es antiguo y obsoleto+ pero sirve para aprender+ por su simpleza y por"ue para
pocos elementos no consume muc#os recursos+ la idea es la siguiente+
P8gina =,%=6
Endie de ta/las
.abla @$ .ipos de datos b8sicos................................................................................................................>
.abla C$ Operadores B8sicos..................................................................................................................@@
.abla D$ Palabras claves V .ipos de datos...............................................................................................@D
.abla ,$ Palabras clave V Permisos y 3eclaraciones..............................................................................@,
.abla 6$ Palabras 5lave V 5ontrol de Llujos+ tomas de decisin............................................................@,
.abla =$ Palabras clave M *eservadas.....................................................................................................@6
.abla E$ Palabras clave V 5ontrol de errores..........................................................................................@6
.abla F$ *esumen de mtodos importantes para out..............................................................................@>
.abla >$ *esumen de mtodos importantes del tipo de objetos in.........................................................@>
.abla @A$ 7a 5lase 0at# V mtodos y constantes...................................................................................D@
Endie de il!straiones
-lustracin @$ 7a &8brica de Objetos dentro de J*/..................................................................................>
-lustracin C$ BNs"ueda binaria en una lista ordenada...........................................................................6E
P8gina =6%=6

Vous aimerez peut-être aussi