AprendiendoJava PDF

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.
ESTE LIBRO ES LIBRE Y GRATUITO, CONSIDERA HACER UNA PEQUEA
DONACIN EN LA WEB INDICADA ARRIBA.
Para navegar el *ndice con Adobe Acrobat +eader$ abrir 'avoritos o boo)mar)s
,ltima actualizacin$ lunes -- de 'ebrero de .//0
INDICE DEL TEMARIO
Prlogo...........................................................................................................................................................1
2. 345A6 273+O8,93O+2O6..................................................................................................................:
;a 5<"uina =irtual de Java >J=5$ Java =irtual 5ac#ine?.....................................................................:
@it de desarrollo y 4ntorno de ejecucin >J8@$ J+4?........................................................................:
9omandos "ue inician el J8@$ J+4....................................................................................................:
6alida por pantalla de los comandos del J8@$ J+4............................................................................A
Programacin Orientada a Objetos con Java...........................................................................................B
8escripcin 4mpCrica del 'uncionamiento del entorno J+4...............................................................B
!erencia soportada por Java..............................................................................................................-/
3ipos de datos D<sicos.......................................................................................................................-/
Operadores y 8elimitadores D<sicos................................................................................................--
7ombres de variables y 'unciones.....................................................................................................-.
22. 9odi'icacin 2nicial y 4structuras de 8atos...........................................................................................-E
4l primer programa.................................................................................................................................-E
Pa"uetes.............................................................................................................................................-E
Palabras clave o reservadas...............................................................................................................-1
3ipos de datos...............................................................................................................................-1
Permisos y declaracin de clases$ propiedades o mtodos..........................................................-1
Ducles y tomas de decisin...........................................................................................................-:
+eservadas....................................................................................................................................-A
4(cepciones$ control de errores....................................................................................................-A
6ecuencias de escape.........................................................................................................................-A
9oncatenacin y conversiones a te(to...................................................................................................-F
6alida por pantalla y entrada por teclado...............................................................................................-0
6ystem.out..........................................................................................................................................-0
6ystem.in............................................................................................................................................./
6ystem.err.........................................................................................................................................../
6ystem.e(it>int cod?G...........................................................................................................................-
;eer lCneas de la entrada est<ndar.......................................................................................................-
9rear Objetos >de la biblioteca de Java?...................................................................................................
4l blo"ue de control de errores$ tryHIcatc#>?HI.......................................................................................
4jercicios.................................................................................................................................................E
..-. 4ntrada de 8atos y conversiones. Ji'$ try$ catc#K........................................................................E
... 7umberLormat4(ception w#ile>?HI.............................................................................................1
..E 5ezcla de bucles doHI w#ile>?G y 'or>GG?HI..................................................................................1
..1 6witc# 6elect.................................................................................................................................:
Pr<ctica 9omplementaria +esuelta >sin procedimientos$ sin arreglos?..................................................:
P.9.4-.................................................................................................................................................:
P.9.4..................................................................................................................................................A
P.9.4E.................................................................................................................................................F
P.9.41.................................................................................................................................................0
P.9.4:.................................................................................................................................................B
P.9.4A................................................................................................................................................E-
P.9.4F................................................................................................................................................E.
P.9.40................................................................................................................................................EE
P.9.4B................................................................................................................................................E:
Pr<ctica 9omplementaria >bucles sin arreglos?......................................................................................E0
222 M 5todos est<ticos y 5ecanismos de Programacin...........................................................................EB
5todos est<ticos >'unciones o procedimientos?...................................................................................EB
P<gina .&FE
Arreglos >Arrays? o =ectores.................................................................................................................1-
;a clase 5at# de procedimientos y constantes matem<ticas.................................................................1.
Du''ering M 5emoria temporal...............................................................................................................1:
,sando arreglos para un bu''er$ colas de espera$ pilas y listas.........................................................1:
2mplementacin del bu''er tipo L2LO >9ola de espera$ el primero es primero en salir?.............1A
2mplementacin del bu''er tipo ;2LO >;a pila$ Nltimo en llegar es primero en salir?................:E
2mplementacin de una ;ista de datos.........................................................................................:F
DNs"ueda de datos..................................................................................................................................A/
DNs"ueda secuencial..........................................................................................................................A/
DNs"ueda aleatoria$ desordenar lista.................................................................................................A/
DNs"ueda Dinaria >lista ordenada?.....................................................................................................A.
5todos para ordenar listas....................................................................................................................AE
5todo de la burbuja o 5todo de Ordenacin por 6eleccin........................................................AE
5todo Ouic)6ort +ecursivo............................................................................................................A:
Otros mecanismos para ordenar........................................................................................................AA
4jercicios................................................................................................................................................AF
4jercicio E.-.......................................................................................................................................AF
4jercicio E.........................................................................................................................................AB
4jercicio E.E.......................................................................................................................................AB
2=P Primeros Objetos como mecanismo de programacin.........................................................................F/
;ista con punteros para ordenar datos....................................................................................................F/
7uestro primer objeto........................................................................................................................F/
Propiedades...................................................................................................................................F/
P<gina E&FE
Prlogo
4ste libro se #izo con la idea de proveer a mis alumnos y cursos un material did<ctico 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. ;a 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 podr<n ir muy lejos si no se les inculca los conceptos b<sicos$ entonces
este material no avanzara de lleno sobre la programacin orientada a objetos$ sino #asta "ue los
conceptos de programacin b<sicos$ 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 P9$ ;inu($
Qindows$ #asta 5A9$ tel'onos$ poc)et P9s$ 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 matem<ticos b<sicos y
tipos de datos b<sicos sin importar "ue estos mismos e(istan o no en otros lenguajes de programacin.
4ste libro se distribuye bajo la licencia G7, GP; v.$ con la e(cepcin "ue est< 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.
;as sugerencias son bienvenidas.
P<gina 1&FE
I. TEMAS INTRODUCTORIOS
La Mquina Virtual de Java (JVM, Java Virtual Machine)
;a m<"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. 8e 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 din<mica de programacin?.
Podemos entonces generar un binario y este podr< 9orrer en ;inu($ 5A9 O6R$ LreeD68$
6olaris$ o Qindows$ y para las ar"uitecturas disponibles en las "ue podamos obtener la J=5$ como ser
A58A1$ 6PA+9$ P2=$ etc. etc.
;a m<"uina virtual de Java #a tenido la caracterCstica 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 podrCan llegar a ser insu'icientes y las aplicaciones ejecutarse de manera muy
lenta. 4sto no es cierto en la actualidad$ e(isten alternativas a la J=5 provista por 6un 5icrosystems
"ue permiten una velocidad comparable a una aplicacin compilada en 9SS nativa en la ar"uitectura$ un
ejemplo de esto es @a''e$ @a''e >www.)a''e.org? es una m<"uina de Java Open6ource "ue puede
compilarse sin mayores modi'icaciones en nuestra ar"uitectura necesaria y correr< increCblemente m<s
r<pida "ue la distribucin est<ndar de J=5 de 6un 5icrosystems y consumir< muc#os menos recursos.
Kit de desarrollo y Entorno de eje!in "#DK$ #RE%
4l @it de desarrollo conocido como J8@ >Java 8evelopment @it? provee de un compilador$ un
mecanismo para comprimir un proyecto en un solo arc#ivo de tipo JA+ >"ue es compatible con T2P? y
un entorno de ejecucin para nuestros binarios.
9uando nuestro proyecto terminado se prepara para distribuir$ no es necesario tener el compilador
y la mayorCa de las #erramientas "ue se proveen en el J8@$ entonces podemos prescindir de dic#o J8@
y utilizar el entorno de ejecucin "ue es m<s pe"ueUo en cuestiones slo de espacio en disco. 4ste J+4
>Java +untime 4nvironment? tambin puede redistribuirse sin problemas de licencias.
4n las plata'ormas basadas en ;inu($ e(isten mejores #erramientas de desarrollo y por supuesto en
casi todas las distribuciones de ;inu($ se encuentra disponible @it de desarrollo o J8@. AsC como
recomendamos @a''e como J=5 para proyectos avanzados o de alto rendimiento$ recomendamos Ji)es
como compilador de Dyte9odes para Java$ Ji)es no es interpretado como el compilador proporcionado
en el J8@ de 6un 5icrosystems.
Co&andos '!e iniian el #DK$ #RE
Comando Descripcin
java
2nicia el entorno de ejecucin recibiendo como argumento el nombre del binario ejecutable
en 'ormato Dyte9odes sin la e(tensin de arc#ivo .class "ue identi'ica de manera visual un
binario java. 4ste comando es parte de J8@ y J+4
javac
2nicia el compilador Java recibiendo como argumento todos los arc#ivos de cdigo 'uente
cuya terminacin es .java incluida dic#a e(tensin. 4ste comando no es parte de J+4.
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
gr<'icos. 4ste comando es parte slo de J8@.
P<gina :&FE
Salida (or (antalla de los o&andos del #DK$ #RE
6i 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.
4n ;inu($ podemos abrir una R3erm$ buscando el menN ejecutar y escribiendo xterm. 4n
Qindows$ podemos #acerlo abriendo el di<logo ejecutar y escribiendo command o cmd dependiendo si
el sistema es basado en 73 o BR.
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 ~ $
P<gina A&FE
,sando @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 ~ $
P<gina F&FE
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 ~ $
P<gina 0&FE
Programacin Orientada a Objetos con Java
9omo 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 '<brica de objetos$ para introducir los trminos clase$ objeto, mtodo, propiedad, esttico,
dinmico, donde la '<brica de objetos ser< el entorno de ejecucin o J+4.
Ilustracin 1: La fbrica de Objetos dentro de !"
Desri(in E&()ria del *!niona&iento del entorno #RE
9omo podemos ver en la imagen anterior la '<brica 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 contendr< un objeto. ,n objeto cambiar< sus
propiedades o las propiedades de otros objetos por medio de los mtodos. ;os mtodos "ue slo pueden
ejecutarse cuando el objeto e(iste$ son los denominados din<micos$ y los mtodos "ue pertenecen a la
clase son denominados est<ticos$ por"ue pueden ser llamados sin necesidad de la e(istencia de un
objeto.
4n el ejemplo tenemos dos objetos$ +eloj y ;<mpara los cuales tienen mtodos 9uerda e
2nterruptor$ "ue son los "ue cambiaran el estado de las propiedades !ora e 2luminando. ;a clase reloj$
podrCa tener un mtodo esttico llamado ponerVenV#ora$ para ajustar todos los relojes 'abricados. 4l
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){
.....
}
8onde ar#s es un vector o arreglo unidimensional "ue contendr< los argumentos "ue #ayan sido
pasados al comando java despus de las rdenes y el nombre de la clase principal "ue alojar< este
mtodo. 4l entorno de ejecucin o la J=5 'abricar< objetos de sistema "ue podr<n ser utilizados
llamando a mtodos estticos de clases pertenecientes a la biblioteca de java.
P<gina B&FE
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 !a "o#$e!%a#&'! #o$p(e%a e! &!)(*+ "e %o"a (a ,&,(&o%e#a &!#(&"a e!
(a ver+&'! "e JRE o JD-, !a ,e!a pr.#%&#a e+ !o %&(&/ar (a+ $.+ ava!/a"a+ 0
#o$p(e1a+ 2!#&o!e+ "e (a API 3App(&#a%&o! Pro)ra$&!) I!%er2a#e4 0a 5e a( 5erer
&!&#&ar !e+%ro pro)ra$a e! !a ver+&'! a!%er&or 5e !o %e!)a !a ,&,(&o%e#a
a#%a(&/a"a, +e pe"e! pro"#&r pro,(e$a+ "e $*%o"o+ 2a(%a!%e+.
+erenia so(ortada (or #a,a
Java no soporta #erencia mNltiple$ es decir no podemos 'abricar un objeto m<s complejo con dos
di'erentes m<s simples$ sino "ue slo podremos #eredar objetos nuevos de un slo objeto padre$ "ue
proveer< los mtodos y propiedades b<sicas "ue ser<n e(tendidas y&o ampliadas por el nuevo objeto. 4s
decir no podrCamos tener un objeto ;<mpara +eloj "ue derive del objeto ;<mpara y del objeto +eloj$
sino "ue tendrCamos "ue usar otros mecanismos para proporcionar esa 'uncionalidad$ inter'aces y
alojamiento de objetos.
4sto podrCa comprenderse como%
2nter'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 ;<mpara le insertamos en su interior un objeto +eloj
entonces podemos llamar a los mtodos del +eloj "ue est< en la ;<mpara$ esto lo veremos m<s
adelante en algunos ejemplos. Wa no serCa la ;<mpara +eloj$ pero serCa una ;<mpara #o! +eloj.
!erencia% 7os 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
4n todos los lenguajes de programacin e(isten tipos de datos b<sicos con los "ue se realizar<n las
operaciones matem<ticas b<sicas y las operaciones booleanas de verdadero o 'also.
Tipo de Datos Alcance o Rango
int de P.-1F10EA10 a .-1F10EA1F >1bytes ?
byte de P-.0 a -.F >-Dyete?
s#ort de PE.FA0 a E.FAF >.Dytes?
long de PB..EEF./EA0:1FF:0/0 a B..EEF./EA0:1FF:0/F >0Dytes?
c#ar de XYu////X a XYu''''X$ ambos incluidos "ue es lo mismo "ue de / a A::E:$ - letra
boolean / o - >-bit?
'loat 1Dytes$ punto 'lotante
double 0Dytes$ punto 'lotante
6tring 7o es un tipo de datos b<sico$ es un objeto b<sico$ con propiedades y mtodos$
pero el lenguaje Java permite de'inir un nuevo objeto con el delimitador >Z?$ por
lo "ue podemos concatenar >unir? te(to utilizando el operador >S? con los
nombres de los objetos de tipo 6tring y los trozos de te(to delimitados con >Z?.
$abla 1: $ipos de datos bsicos
P<gina -/&FE
O(eradores y Deli&itadores -.sios
Operador Datos Accin
+
6tring ,ne te(to >concatenador?.
nNmero 6uma.
-
nNmero invierte el signo del nNmero.
nNmero +esta.
nNmero 5ultiplica y tiene prioridad sobre la suma y resta.
& nNmero 8ivide y tiene prioridad sobre la suma y resta.
[ nNmero 8evuelve el resto de la divisin del operador derec#o por el iz"uierdo.
! booleano 4l operador NOT booleano.
\ nNmero 2nvierte bit por bit el operando de la derec#a
&
entero o
booleano
4l operador AND$ booleano bit por bit del elemento a la iz"uierda contra el de la
derec#a.
&& 9ual"uier 4l operador A78 condicional.
|
entero o
booleano
4l operador OR$ booleano bit por bit del elemento a la iz"uierda contra el de la
derec#a.
|| 9ual"uier 4l operador O+ condicional.
]] nNmero 8esplaza los bits #acia la iz"uierda la cantidad de la derec#a.
^^ nNmero 8esplaza los bits #acia la derec#a la cantidad de la derec#a.
^^^ nNmero 8esplaza bits #acia la derec#a pero no conserva el signo.
== 9ual"uier
4l operador condicional de igualdad$ devuelve verdadero si derec#a e iz"uierda es
lo mismo.
] D<sicos 5enor "ue$ devuelve verdadero si iz"uierda es menor "ue derec#a.
]_ D<sicos 5enor o igual "ue$ devuelve verdadero si iz"uierda es menor o igual "ue derec#a.
^ D<sicos 5ayor "ue$ devuelve verdadero si iz"uierda es mayor "ue derec#a.
^_ D<sicos 5ayor o igual "ue$ devuelve verdadero si iz"uierda es mayor o igual "ue derec#a.
= 9ual"uier Asigna al elemento de la iz"uierda$ el de la derec#a.
(op)= D<sicos
!ace la operacin op JS$P$$&.etc..K entre los dos operandos y el resultado lo guarda
en el de la iz"uierda.
varSS D<sicos 2ncrementa en uno la variable var.
varPP D<sicos 8ecrementa en uno la variable var.
. objetos
6epara los nombres de los objetos o propiedades o mtodos o nombres y jerar"uCa
de clases.
(int) tipo de datos
9onvierte 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 9ual"uier 3ermina una lCnea de orden.
$ 9ual"uier 6epara argumentos de un mtodo o 'uncin.
&& 9ual"uier 4mpieza una lCnea de comentario.
& & 9ual"uier 8elimitan un trozo de te(to como comentario.
& & 9ual"uier 8elimitan un trozo de te(to como documentacin para Java8oc
P<gina --&FE
Operador Datos Accin
HI 9ual"uier 8elimitan un blo"ue de cdigo de una estructura de datos.
> ? 9ual"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.
4n 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 9lases de objetos con la primer letra de cada palabra "ue la de'ine en mayNsculas.
4jemplos%
=ariables
int soles=3;
char salir='q';
Lunciones%
public static int redondearPromedio(int[] valores){
...
}
9lases%
public class RelojAtomico{
....
}
P<gina -.&FE
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
6uponemos "ue nuestro sistema operativo ya tiene instalado el )it de desarrollo >J8@? y
procedemos a abrir un editor de te(to de nuestro gusto. 4n @84$ podemos abrir %&rite en otros sistemas
bus"uemos loc% de notas u otro editor como Edit'lus$ de todas maneras cual"uier editor estar< bien.
8entro del editor de te(tos escribiremos lo siguiente%
public class HolaMundo {
public static void main(String[] args) {
System.out.println("Hola, mi primer programa");
}
}
4l 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 J=5 >comando java?
para correr el programa$ pero para trabajar mejor #aremos una carpeta donde guardaremos los ejemplos$
para los "ue usen Qindows #<ganla en la unidad c%Y 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
4n 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 ejecutar<n el componente principal del
programa >el mtodo est<tico main? sean pNblicas.
;as clases de objetos "ue no "ueramos #acer visibles a otros componentes de nuestro proyecto$
entonces se podr<n declarar como privadas$ de esa manera slo una clase de objetos "ue pertenezca al
grupo de clases podr< acceder a las dem<s privadas.
;os pa"uetes suelen tener un nombre especial re'erente al de la organizacin "ue realiza el
P<gina -E&FE
proyecto$ esto es una sugerencia$ en realidad se puede utilizar casi cual"uier nombre$ asC "ue por
ejemplo si nuestra empresa es compunauta$ y el nombre de dominio de los servicios "ue se proporcionan
en 2nternet es compunauta.com$ entonces nuestro pa"uete podrCa llamarse com.compunauta y a su vez si
tenemos un subproyecto$ este podrCamos nombrarlo como com.compunauta.aprendiendojava$ slo
tengamos en cuenta "ue es el orden inverso de como aparecerCa en 2nternet. ,samos 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
;as 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 lCnea en particular de nuestro programa$
tenemos "ue trabajar con llamadas a 'unciones y otras maneras de codi'icacin.
"i!os de datos
8e'inen tipos de datos "ue devolver<n los mtodos o los tipos de datos "ue de'inir<n una
propiedad b<sica. 4stos ya los #abCamos visto anteriormente pero a#ora los describiremos por el espacio
"ue ocupan en memoria.
'alara Clave /ignificado
boolean =alores Dooleanos >-bit?
byte -Dyte$ nNmero entero >0bits?
short .Dytes$ nNmero entero
int 1Dytes$ nNmero entero
long 0Dytes$ nNmero entero
char .Dytes$ >s#ort? -9aracter
float 1Dytes$ punto 'lotante.
double 0Dytes$ punto 'lotante$ doble precisin
void 9uando no #ay nada "ue devolver
null 3ipo de datos 7ulo$ vacCo$ cual"uier operacin sobre null produce un error.
$abla *: Palabras claves + $ipos de datos
Permisos # declaracin de clases, !ro!iedades o m$todos%
8e'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.
P<gina -1&FE
'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 6lo se permite a la misma clase de objetos acceder a sus propiedades o mtodos.
protected 6lo se permite al pa"uete acceder a esta clase.
pac)age 8e'ine a "ue pa"uete pertenece una clase.
import 8e'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 2nicia la declaracin de una 9lase >tipo de datos?.
new 2nstancia un objeto$ crea un objeto partiendo de una clase en particular.
$abla ,: Palabras clave + Permisos - .eclaraciones
&ucles # tomas de decisin
6e 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
&2 >condicion?H
....
I e(+e H
....
I
4jecuta el blo"ue separado por HI siempre y cuando se cumpla la condicin$
acompaUada a esta estructura e(iste else >sin? "ue es para el caso contrario a la
condicin$ sin tener "ue evaluar la condicin negada.
2or >inicialGcondicinGrepeticin?H
....
I
6e 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 seguir< ejecutando.
67&(e >condicin?H
....
I
5ientras se cumpla la condicin entre parntesis$ se ejecuta el cdigo en el interior
de HI de manera in'inita #asta.
+6&%#7 >varieblenumrica?H
case num-%
.....
brea)G
case num.%
.....
brea)G
de'ault%
I
;a sentencia switc# es un tanto compleja y probabilCsticamente 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 seguir< ejecutando la siguiente cl<usula case$ e(iste una opcin de'ault "ue es
para cuando ninguno de los casos resulta ser el correcto.
"oH
...
I67&(e>condicin?G
4l blo"ue dentro de la palabra clave do$ se ejecutar< al menos una vez y si la
condicin de w#ile se cumple$ se repetir< mientras sea cierta.
,rea8 2nterrumpe un blo"ue y se ejecuta la siguiente lCnea 'uera de l.
#o!%&!e 2nterrumpe el resto del cdigo del blo"ue y vuelve a empezar con la siguiente
iteracin.
re%r! 2nterrumpe 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
P<gina -:&FE
'eservadas
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 podrCan 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
4n 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 tendr<n el comportamiento por de'ecto de la m<"uina virtual de java$
"ue es reportarlos como e(cepciones y terminar el programa.
t#rows 2ndica "ue tipo de e(cepciones lanzar< este mtodo en caso de errores$ es Ntil para
"ue los mtodos "ue llaman a este "ue lanzar< una e(cepcin en caso de errores$ se
vean obligados a tratar esa situacin.
t#row 3rans'iere el control de errores al manejador de e(cepciones.
%r0H
...
I#a%#73%&po e(cepcion?H
...
I2&!a((0H
...
I
4sta es la estructura de un manejador de e(cepciones o control de errores$ try inicia
el blo"ue de cdigo "ue ser< manejado en caso de errores$ la sentencia catc# indica
el tipo de e(cepcin "ue se capturar<$ 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. ;a sentencia 'inally se ejecutar< de todas maneras al salir
del cdigo.
6i una e(cepcin no es capturada por el listado de cl<usulas catc#$ entonces es
probable "ue la J=5 inicie el reporte y la salida de la instancia completa de la
J=5$ interrumpiendo todos los #ilos de ejecucin.
$abla 4: Palabras clave + 0ontrol de errores
Se!enias de esa(e
;as secuencias de escape son a"uellas combinaciones de caracteres "ue nos permiten insertar un
caracter especial "ue no es posible tipear con el teclado est<ndar 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 est<n dentro de
la 'uncin println.
System.out.println("Hola, mi primer programa");
6i "uisiramos incluir las comillas dobles en la ejecucin deberCamos incluirlas con una secuencia
de escape$ para ello se utiliza la barra invertida Y seguida de las comillas dobles Y`.
System.out.println("\Hola, mi primer programa\");
8e esa manera el compilador entiende "ue el trozo de te(to contendr< las comillas dobles$ pero
"ue pasarCa si "uisiramos escribir el caracter Y "ue en algNn sistema operativo distinto de ;inu( podrCa
signi'icar divisin de directorios o carpetas$ bueno para esto usarCamos una Y seguida de otra Y$ es decir YY
para insertar el caracter Y.
System.out.println("Hola, mi primer programa, est en c:\\");
P<gina -A&FE
A"uC #ay una lista de las secuencias de escape m<s usadas y una breve e(plicacin de su utilidad$
ya "ue Java soporta ,nicode$ una representacin e(tensa de lo "ue es un caracter "ue permite inclusin
de varios idiomas.
/ecuencia /ignificado
Yb +etroceder un espacio >bac)space?
Yt 3abulador !orizontal$ sirve para alinear te(to en la salida est<ndar de datos cuando
es una terminal o consola de comandos.
Yn 6alto de lCnea$ es el caracter usado incluso en las viejas impresoras "ue necesitaban
avanzar de lCnea para escribir en el pr(imo rengln.
Yr +etorno de carro$ es el caracter "ue devuelve el cursor o el cabezal de la imprezora
al inicio del rengln$ ;inu($ usa Yn para un nuevo rengln en los arc#ivos de te(to$
Qindows utiliza una combinacin YnYr.
Y` 2nsertan las comillas dobles
YX 2nsertan la coma simple.
YY 2nsertan la misma barra invertida "ue usamos como escape.
Y888 ;as tres 8 son dCgitos y representan un caracter en su versin octal.
Yu8888 ;as cuatro 8 son dCgitos y representan un caracter unicode en #e(adecimal.
)oncatenacin # conversiones a te(to
;a 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
autom<ticamente los tipos de datos b<sicos a te(to antes de unirlos y llama por cada objeto al mtodo
especial to6tring>? para realizar la conversin de objetos nuestros o de la biblioteca de la J=5.
=eamos 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. }
4n la lCnea -$ de'inimos el nombre de la clase$ "ue es pNblica y se llama 5uma5imple$ en la
segunda lCnea de'inimos el mtodo est<tico main "ue es el "ue la J=5 ejecutar< para iniciar nuestros
programas.
Nota: El arreglo o vector args +e %&(&/a para re#&,&r %o"a+ (a+ 'r"e!e+ "e (a J9:, (o+
ve#%ore+ e! Java +o! o,1e%o+ 5e %&e!e! prop&e"a"e+.
4n la lCnea E$ se de'ine una variable de tipo entero llamada Za` "ue inicialmente guardar< un -
positivo$ la 1
ta
lCnea ejecuta el mtodo println65trin# line7 "ue pertenece al objeto out "ue a su vez es
propiedad del objeto 6ystem$ tener un objeto de salida$ se imprimir< en pantalla el trozo de te(to 8el
valor de a9: seguido del valor >el contenido de a?.
4n la lCnea :$ al contenido de la variable a$ le agregamos el resultado de sumar aS-/$ eso no tiene
"ue dar un total de -- "ue se ver< re'lejado en la lCnea A$ cuando volvemos a llamar al mtodo println
del objeto out "ue pertenece al objeto 6ystem.
P<gina -F&FE
4n las lCneas F y 0 se cierran las llaves "ue iniciaron los blo"ues de cdigo del mtodo main o la
declaracin de la clase 5uma5imple.
No%a; S'(o #o$o #o$e!%ar&o (o 5e e! rea(&"a" e( #o$p&(a"or e+%. 7a#&e!"o a( ((a$ar a
pr&!%(!, e+ #o!#a%e!ar %e<%o, para e((o e+ !e#e+ar&o #o!ver%&r e( !=$ero e! %e<%o,
&!%er!a$e!%e e( #o$p&(a"or e+%ar. ((a$a!"o a !a #(a+e 5e e+ par%e "e (a ,&,(&o%e#a
#0o !o$,re e+ I!%e)er 0 po+ee ! $*%o"o %oS%r&!)34 5e #o!ver%&r. e( !=$ero, a +
ve/, e( %ro/o "e %e<%o per%e!e#er. a (a prop&e"a" "e ! o,1e%o S%r&!) e( #a( %&e!e !
$*%o"o #o!#a%34 5e e+ e( e!#ar)a"o "e pro"#&r ! !evo o,1e%o &)a( a (a +$a "e
(o+ "o+ %ro/o+ "e %e<%o.
4l ejemplo podrCa escribirse asC%
1. public class SumaSimple2 {
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. }
8onde 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 6tring$ cual"uier trozo de te(to entre comillas dobles es un objeto
6tring 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$
4n ambos casos la salida por pantalla ser< la misma y la siguiente%
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
*alida !or !antalla # entrada !or teclado
Para los siguientes ejemplos ya tenemos casi todo discutido$ e(cepto "ue por cuestiones
educativas serCa interesante "ue el programa no solo contenga los valores "ue interactuar<n
almacenados$ sino "ue tambin sea posible preguntar al usuario.
Syste&.o!t
4l objeto 6ystem es parte de la biblioteca de Java y es instanciado o 'abricado al iniciar la J=5
muc#o antes "ue se comience a ejecutar nuestro programa. 4ste almacena E objetos$ son out, in y err.
P<gina -0&FE
4l objeto out es del tipo o clase Printstream "ue tiene las siguientes propiedades y mtodos
importantes$ no listaremos todos%
Resumen de (1todos
boolean checkError()
4nvCa todo el bu''er y devuelve verdadero si #ay error o 'also.
void close()
9ierra el 'lujo de datos
void flush()
4nvCa todo el bu''er.
void print(boolean b)
2mprime una variable booleana
void print(char c)
2mprime un caracter.
void print(char[] s)
2mprime un arreglo de caracteres.
void print(double d)
2mprime un numero de tipo double.
void print(float f)
2mprime un nNmero de punto 'lotante.
void print(int i)
2mprime un entero.
void print(long l)
2mprime un entero largo.
void print(Object obj)
2mprime un objeto$ invocando su 'uncin to6tring>?
void print(String s)
2mprime un objeto de tipo 6tring
void println()
2mprime una separador de nueva lCnea.
void println(boolean x)
2mprime un valor booleano y termina la lCnea.
void println(char x)
2mprime un caracter y termina la lCnea.
void println(char[] x)
2mprime un arreglo de caracteres y termina la lCnea.
void println(double x)
2mprime un nNmero de precisin doble y termina la lCnea.
void println(float x)
2mprime un nNmero de punto 'lotante y termina la lCnea.
void println(int x)
2mprime un entero y termina la lCnea.
P<gina -B&FE
void println(long x)
2mprime un entero largo y termina la lCnea.
void println(Object x)
2mprime un objeto invocando su mtodo to6tring>? y termina la lCnea.
void println(String x)
2mprime un trozo de te(to y termina la lCnea.
$abla ;: !esumen de mtodos importantes para out.
Syste&.in
4l 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"uC vemos los mtodos "ue nos interesan.
Resumen de (1todos
int available()
8evuelve 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()
9ierra esta entrada de datos y libera todos los recursos asociados.
abstract
int
read()
;ee el pr(imo byte de datos desde la entrada$ espera por los datos.
int read(byte[] b)
;ee 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)
;ee #asta len bytes de datos adentro del arreglo de bytes b empezando en o''.
long skip(long n)
6alta y destrulle los n caracteres de datos.
$abla <: !esumen de mtodos importantes del tipo de objetos in.
Syste&.err
4ste objeto es del mismo tipo "ue out >Printstream? y tiene las mismas propiedades$ en los
sistemas operativos derivados de ,ni( como ser ;inu($ e(iste muc#o la di'erencia entre salida est<ndar
de datos >6ystem.out? y la salida est<ndar de errores >6ystem.err?$ por ejemplo al imprimir todos los
carteles de errores en un tipo de salida no a'ectarCamos a los resultados$ un ejemplo serCa el siguiente%
public class SumaSimple3 {
public static void main(String[] args) {
int a=1;
System.err.println("el valor de a="+a);
System.out.println(a);
a=a+10;
System.err.println("ahora sumndole 10 es a="+a);
System.out.println(a);
}
}
P<gina ./&FE
6i este cdigo lo compilamos al ejecutarlo podemos separar los comentarios de los valores de a.
gus@gusgus ~/ejemplos $ javac SumaSimple3.java
gus@gusgus ~/ejemplos $ java SumaSimple3
el valor de a=1
1
11
gus@gusgus ~/ejemplos $ java SumaSimple3 > resultados.txt
el valor de a=1
gus@gusgus ~/ejemplos $ java SumaSimple3 2> errores.txt
1
11
8e 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
4l mtodo est<tico e(it>cod? de la clase 6ystem interrumpe la ejecucin total del programa y
devuelve el control al sistema operativo$ es decir la J=5 termina por completo liberando los recursos.
,n 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 lCneas de la entrada est<ndar podemos utilizar una combinacin de objetos de la
biblioteca "ue nos permitir<n 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 lCnea$
tengamos en cuenta "ue java es multiplata'orma$ y si el sistema operativo no es ;inu($ es probable "ue
se introduzca m<s de un caracter para el salto de lCnea lo cual incrementa la complejidad del problema.
1. package com.compunauta.aprendiendojava;
2. import java.io.*;
3. public class LeerRenglones {
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();}
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$
P<gina .-&FE
)rear Objetos (de la biblioteca de Java)
4n java para crear objetos utilizamos una palabra clave$ !e6$ esta misma crea un objeto del tipo
indicado a su derec#a$ repasemos del ejemplo anterior la siguiente lCnea%
BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
;a clase Du''ered+eader$ pertenece a la biblioteca de Java Zjava.io` la cual 'ue importada antes de la
declaracin de la clase Leer!en#lones$ 2nput6tream+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$
=eamos "ue signi'ica cada parte de esta lCnea$ el concepto de 8&uffered!eader br9: es una
asignacin y una declaracin simult<nea$ como vimos antes el signo 89: asigna a la variable u nombre
de objeto de la iz"uierda el contenido de la derec#a. 4so "uiere decir "ue 8br: ser< una variable "ue
apuntar< a un objeto del tipo &uffered!eader$ br no ser< un objeto$ ser< el nombre con el "ue
accederemos al objeto en memoria ram$ si en la siguiente lCnea repitiramos otra asignacin a br, es
decir Zbr9....: sin la declaracin por"ue ya se sabe "ue es del tipo &uffered!eader$ entonces la variable
br apuntar< a otro objeto del tipo &uffered!eader$ el anterior sigue e(istiendo en memoria$ pero ser<
eliminado en la pr(ima ejecucin del recolector de basura de la J=5.
9ada 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 'abricar< e
inicializar< de acuerdo a las variables "ue recibe como argumentos uno nuevo del tipo de su clase. 4sto
lo veremos m<s 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$ 4n 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()+,
9omo podemos ver en este ejemplo utilizamos la estructura de control de errores "ue es
obligatoria para esa conversin "ue #icimos para poder leer lCneas con el mtodo read;ine>?$ 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#>4(ception e(?HI$ en este caso solo capturamos la e(cepcin
"ue puede surgir y cual"uier otra "ue no sea 2O4(ception no ser< capturada.
try {nombre = br.readLine();
catch (IOException ex) {ex.printStackTrace();}
9atc# captura un tipo de error dentro del blo"ue tryHI$ y el blo"ue encerrado entre llaves ejecutar<
cdigo "ue deberCa manejar la e(cepcin$ en este caso ignoramos todo tipo de accin "ue podrCamos
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.
P<gina ..&FE
jercicios
4n esta y todas las secciones de ejercicios veremos la solucin a uno o dos$ y el resto "uedar<n
para ejercitacin del lector$ en el material multimedia "ue se adjunta con este libro tal vez se encuentren
otras soluciones a los dem<s problemas.
2.3. Entrada de Datos y on,ersiones. 4i*$ try$ at56
Preguntar el nombre del usuario y su edad$ mostrar cuantos aUos tendrCa en una dcada m<s y
clasi'icar segNn su edad en AJ/P.:K$ DJ.AP:/K$ 9J:-P...K. ;a salida por pantalla deberCa 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$
6olucin%
3. /**
4. * Ttulo: Aprendiendo Java
5. * Descripcin: Ejemplos del Libro Aprendiendo Java de Compunauta
6. * Copyright: Copyright (c) 2006 www.compunauta.com
7. * Empresa: COMPUNAUTA
8. * @author Gustavo Guillermo Prez
9. * @version 2006.01.01
10. */
11.
12.public class Cap2Ej1 {
14. //Definimos el objeto br para leer lneas de la entrada
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());}
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
P<gina .E&FE
36.}//final de la clase
9omentarios%
9apturamos "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 capCtulo y el otro al ingresar te(to en vez de
un nNmero. ,tilizamos 6ystem.e(it>P-?G para salir del programa inesperadamente. 4s 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 est<
recomendada por los nuevos )its de desarrollo solo e(iste por compatibilidad.
2.2 -umber.ormat(ce!tion /hile()+,
Dasados en el enunciado del ejemplo anterior$ capturar correctamente los errores de entrada de
datos respecto de los de conversin de te(to en nNmeros. 2mprimir en pantalla con print5tac=$race$ para
el caso de entrada$ y avisar al usuario "ue la edad no 'ue ingresada correctamente.
I"ea; U%&(&/ar ! ,(o5e 67&(e para 2or/ar a( +ar&o a &!)re+ar "e!evo + !o$,re 0 e"a"
+& +e "e%e#%a ! error.
2.7 Me8la de /!les do9: ;5ile"%1 y *or"11%9:
Pedir por teclado el nombre al usuario$ y a continuacin solicitar -/ puntuaciones de supuestos
e(<menes$ para promediarlos$ la salida por pantalla deberCa ser algo asC%
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$
6olucin%
3. /**
9. * @version 2006.01.01
10. */
11.
12.public class Cap2Ej3 {
14. //Definimos el objeto br para leer lneas de la entrada
16. //Definimos variables nombre, error y acumulador dndole valores por
defecto
P<gina .1&FE
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 -/$ e(igir "ue no se pase de esos valores$ capturar errores
y repetir #asta "ue se introduzca el / "ue ser< "ue sale del programa. ;as 'rases inventarlas.
Prctica )om!lementaria 'esuelta (sin !rocedimientos, sin arreglos)
4sta pr<ctica se aUadi con el objeto de "ue el alumno cuente con problemas resueltso para
practicar la sinta(is del lenguaje$ est<n resueltos y no utilizan bucles ni arreglos >"ue los veremos en el
pr(imo capCtulo?.
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. /**
10. * Empresa: julioduarte@gmail.com
11. * @author Julio Csar Duarte
P<gina .:&FE
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.
22. int numero1 = 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) {
37. System.out.println("Error imprevisto");
39. }
40. System.out.print("Ingrese el segundo numero: ");
41. try {
43. }
48. }
53. }
54. resultado = numero1 + numero2;
55. System.out.print("El resultado es: " + resultado);
56. }
57. }
P.C.E2
5.
6. /**
P<gina .A&FE
12. * @version 2006.01.01
13. */
14.
15.
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
26. System.out.print("Ingrese su nombre: ");
27. try
28. {
29. nombre=br.readLine();
30. }
31. catch(IOException e)
32. {
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
5.
6. /**
12. * @version 2006.01.01
13. */
14.
16. /**
17. * Ejercicio3: Dado el valor de los tres lados de un tringulo, calcular el
18. * permetro
19. */
20.
22. int lado1 = 0;
23. int lado2 = 0;
24. int lado3 = 0;
25. int perimetro;
P<gina .F&FE
27. System.out.print("Ingrese el primer lado del triangulo: ");
28. try {
29. lado1 = Integer.parseInt(br.readLine());
30. }
35. }
40. }
41. System.out.print("Ingrese el segundo lado del triangulo: ");
42. try {
44. }
49. }
54. }
55. System.out.print("Ingrese el tercer lado del triangulo: ");
56. try {
58. }
63. }
68. }
69. perimetro = lado1 + lado2 + lado3;
70. System.out.println("El Perimetro del triangulo es: " + perimetro);
71. }
72.}
P.C.E<
5.
6.
7. /**
P<gina .0&FE
13. * @version 2006.01.01
14. */
15.
16.
18. /**
19. * Ejercicio4: Se conocen dos nmeros. Determinar y mostrar el mayor
20. */
26. try {
28. }
33. }
38. }
40. try {
42. }
47. }
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);
59. }
60. else {
61. System.out.println("Los dos numeros son iguales: " + numero1);
62. }
63. }
64. }
65.}
P.C.E=
P<gina .B&FE
5.
6. /**
12. * @version 2006.01.01
13. */
14.
16. /**
17. * Ejercicio5: Se conocen dos nmeros distintos.
18. * Determinar si el primero de ellos es el mayor
19. */
25. try {
27. }
32. }
37. }
38. System.out.print("Ingrese el segundo numero distinto del primero: ");
39. try {
41. }
46. }
51. }
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<gina E/&FE
P.C.E>
5.
6. /**
12. * @version 2006.01.01
13. */
14.
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.
26. int mayor = 0;
27. int menor = 0;
28. int cuadrado = 0;
29. double circulo = 0;
32. try {
34. }
39. }
44. }
45. System.out.print("Ingrese el segundo numero distinto del primero: ");
46. try {
48. }
53. }
58. }
60. mayor = numero1;
P<gina E-&FE
61. menor = numero2;
62. }
63. else {
64. mayor = numero2;
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?
5.
6. /**
12. * @version 2006.01.01
13. */
14.
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.
25. int menor;
28. try {
30. }
35. }
40. }
42. try {
44. }
P<gina E.&FE
49. }
54. }
55. System.out.print("Ingrese el tercer numero: ");
56. try {
58. }
63. }
68. }
69. if (numero1 < numero2) {
71. }
72. else {
74. }
75. if (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@
5.
6. /**
12. * @version 2006.01.01
13. */
14.
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
P<gina EE&FE
20. * fue la mayor nota, y cul fue el alumno que la obtuvo.
21. */
23. int nota1 = 0;
24. int nota2 = 0;
25. int nota3 = 0;
26. int mejor;
27. int alumno;
29. System.out.print("Ingrese la nota del primer alumno: ");
30. try {
31. nota1 = Integer.parseInt(br.readLine());
32. }
37. }
42. }
43. System.out.print("Ingrese la nota del segundo alumno: ");
44. try {
46. }
51. }
56. }
57. System.out.print("Ingrese la nota del tercer alumno: ");
58. try {
60. }
65. }
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");
P<gina E1&FE
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
5.
6. /**
12. * @version 2006.01.01
13. */
14.
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.
26. String buf = new String("");
27. float precio1 = 0;
28. int cantidad1 = 0;
29. float aporte1 = 0;
39. float aportetotal = 0;
40. float mayor = 0;
P<gina E:&FE
41. int id = 0;
42. float porcentaje = 0;
44. System.out.print("Ingrese el precio producto1: ");
45. try {
46. //precio1=Double.valueOf(br.readLine());
47. precio1 = Float.valueOf(br.readLine()).floatValue();
48. }
53. }
58. }
60. try {
62. }
67. }
72. }
74. try {
76. }
81. }
86. }
88. try {
90. }
95. }
100. }
P<gina EA&FE
101. System.out.print("Ingrese la cantida vendida del producto1: ");
102. try {
103. cantidad1 = Integer.parseInt(br.readLine());
104. }
109. }
114. }
116. try {
118. }
123. }
128. }
130. try {
132. }
137. }
142. }
144. try {
146. }
151. }
156. }
157. aporte1 = precio1 * cantidad1;
161. aportetotal = aporte1 + aporte2 + aporte3 + aporte4;
P<gina EF&FE
162. if (aporte1 > aporte2) {
163. mayor = aporte1;
164. id = 1;
165. }
166. else {
168. id = 2;
169. }
170. if (mayor < aporte3) {
172. id = 3;
173. }
174. if (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)
P<gina E0&FE
III B MCtodos est.tios y Meanis&os de Progra&ain.
4ste capCtulo pretende proporcionar al usuario 'inal las #erramientas para solucionar problemas
del tipo programacin estructurada$ de pilas$ colas$ vectores$ <rboles$ etc. Oue 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 todavCa sino #asta m<s adelante$ de esta manera este capCtulo
puede utilizarse para a'ianzar los conocimientos necesarios para un curso de 'Csica o matem<ticas donde
se desee aplicar a problemas en general.
;a P.O.O. en este capCtulo ser< completamente b<sica$ y ni si"uiera la mencionaremos en muc#os
caso #asta el 'inal del capCtulo a menos "ue sea necesario.
M$todos estticos (0unciones o !rocedimientos)
4n 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.
Pro,(e$a; necesitamos ingresar datos por teclado$ #acer varios c<lculos y volver a ingresar datos
por teclado y #acer otros c<lculos di'erentes$ y este mismo proceso$ repetidas veces$ como vimos en los
ejemplos anteriores tendrCamos "ue repetir el blo"ue tryHIcatc#>?HI varias veces$ y si "uisiramos
repetir un blo"ue de c<lculos para ciertos datos... >Qe pa+ar?a +& 5&ero #a$,&ar e+a+ 'r"e!e+ (a+
ve#e+ 5e +e 7a0a! repe%&"o@.
4ntonces comenzamos con las 'unciones$ o mtodos est<ticos en Java$ se les denomina est<ticos
por"ue pertenecen a la 9lase o tipo de datos y no es necesario crear un objeto para invocarlos o
llamarlos$ para nosotros en este momento nos servir<n para solucionar el problema de repeticin y
mantenimiento de cdigo.
4jemplo E.-%
6e re"uiere ingresar los datos de E valores y calcular su promedio$ paso seguido$ preguntar el
nombre del usuario e imprimir de manera personalizada Z,suario$ el promedio de tus tres valores es%
RRR`$ 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.
3. /**
9. * @version 2006.01.01
10. */
11.
12.public class MetodoLeer {
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;
P<gina EB&FE
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
9omo podemos ver desde la lCnea .A a la E. se de'ine la 'uncin est<tica leer$ "ue es pNblica y
devolver< datos de tipo 6tring$ 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 lCneas$ 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.
Dien$ a#ora veamos el cdigo mejorado utilizando una 'uncin para leer te(to y otra para los
nNmeros enteros%
3. /**
9. * @version 2006.01.01
10. */
11.
12.public class MetodoLeer {
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;
33.
34.public static int leerInt(BufferedReader buff){
35. int lee=0;
36. boolean error;
P<gina 1/&FE
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;
47.
48.}
1rreglos (1rra#s) o Vectores%
;os arreglos son como un vector$ con varias componentes incluso en programacin un arreglo
puede representar una matriz de varias dimensiones. Por ejemplo si tenemos -/ 'rases "ue enseUaremos
segNn un nNmero del - al -/$ podemos utilizar un vector de una sola dimensin$ donde indicaremos con
un subCndice a los elementos "ue este mismo almacene.
4n Java un arreglo se representa por un objeto "ue tiene un lCmite de elementos al ser de'inido$ o
en alguna parte de nuestro programa le asignaremos un objeto arreglo de cierto tipo. ;os elementos "ue
pondremos en nuestro arreglo de datos deben estar de'inidos en cantidad$ no en valor$ si creemos "ue
podemos necesitar m<s o menos -/S&PE elementos asignaremos -E por m<s "ue a veces usemos F.
;os arreglos tienen una cantidad de elementos$ pero el subCndice "ue usaremos para acceder al
contenido de cada elemento ir< del / a 4;45473O6P-. =eamos un ejemplo%
'rolema:
6e desea ingresar por teclado tres resultados de e(<menes$ e imprimir el -a y Nltimo$ utilizamos la
'uncin leerInt67 "ue ejempli'icamos anteriormente.
3. /**
9. * @version 2006.01.01
10. */
11.
12.public class Arreglos {
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){
P<gina 1-&FE
25. int lee=0;
26. boolean error;
27. do {
28. error=false;
31.System.out.println("Entrada erronea, repetir:?");
32. error=true;}
35.return lee;
37.
38.}
;a salida por pantalla ser< algo como esto%
La longitud de datos de mi arreglo es:3
Ingrese el valor para el examen 1 de 3
23
21
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 9lase de la biblioteca m<s Ntil$ "ue provee algunas
cuantas 'unciones matem<ticas "ue usaremos para resolver nuestros problemas en este capCtulo.
Resumen de Campos
static double
E
4l valor double "ue es el mas cercano a e$ la base de los logaritmos
naturales.
static double
!"
4l valor double "ue es m<s cercano a pi$ la relacin de una circun'erencia
con su di<metro.

Resumen de (1todos
static double
abs(double a)
8evuelve el valor absoluto de un valor double.
static float
abs(float a)
8evuelve el valor absoluto de un valor float.
static int
abs(int a)
8evuelve el valor absoluto de un valor int.
static long
abs(long a)
8evuelve el valor absoluto de un valor long.
P<gina 1.&FE
static double
acos(double a)
8evuelve el arcocoseno de un <ngulo$ en el rango de /./ #asta pi.
static double
asin(double a)
8evuelve el arcoseno de un <ngulo$ en el rango de Ppi&. #asta pi&..
static double
atan(double a)
8evuelve el arcotangente de un <ngulo$ en el rango de Ppi&. #asta pi&..
static double
atan#(double y, double x)
9onvierte coordenadas rectangulares >x$ y? a polares >r$ t>eta?.
static double
cbrt(double a)
8evuelve la raCz cuadrada de un valor double.
static double
ceil(double a)
8evuleve el m<s pe"ueUo >cercano al in'inito negativo? valor double "ue es
m<s grande o igual al argumento a y es igual a un entero matem<tico.
static double
cos(double a)
8evuelve el coseno trigonomtrico de un <ngulo.
static double
cosh(double x)
8evuelve el coseno #iperblico de un valor value.
static double
e$p(double a)
8evuelve el valor e de 4uler elevado a la potencia del valor double a.
static double
e$pm%(double x)
8evuelve e
(
P-.
static double
floor(double a)
8evuelve el m<s largo >cercano al positivo in'inito? valor double "ue es
menor o igual al argumento a y es igual a un entero matem<tico.
static double
hypot(double x, double y)
8evuelve s"rt>x
.
S-
.
? sin el over'low o under'low intermedio.
static double
"EEEremainder(double f1, double f2)
9omputa la operacin prescripta por el est<ndar 2444 F:1 entre los dos
argumentos '- y '..
static double
log(double a)
8evuelve el logaritmo natural >base e? de un valor double.
static double
log%&(double a)
8evuelve el logaritmo en base -/ de un valor double.
static double
log%p(double x)
devuelve e
(S-
.
static double
ma$(double a, double b)
8evuelve el m<s grande de los dos valores double a y b.
static float
ma$(float a, float b)
8evuelve el m<s grande de los dos valores float a y b.
static int
ma$(int a, int b)
8evuelve el m<s grande de los dos valores int a y b.
static long
ma$(long a, long b)
P<gina 1E&FE
8evuelve el m<s grande de los dos valores long a y b.
static double
min(double a, double b)
8evuelve el m<s pe"ueUo de los dos valores double a y b.
static float
min(float a, float b)
8evuelve el m<s pe"ueUo de los dos valores float a y b.
static int
min(int a, int b)
8evuelve el m<s pe"ueUo de los dos valores int a y b.
static long
min(long a, long b)
8evuelve el m<s pe"ueUo de los dos valores long a y b.
static double
pow(double a, double b)
8evuelve el valor del argumento a elevado a la potencia de b% a
b
.
static double
random()
8evuelve un valor de tipo double con signo positivo$mayor o igual "ue cero
y menor "ue uno 1.0.
static double
rint(double a)
8evuelve el valor double "ue es m<s cercano al valor a y es igual a un
entero matem<tico.
static long
round(double a)
8evuelve el valor long m<s cercano al argumento.
static int
round(float a)
8evuelve el valor int m<s cercano al argumento.
static double
signum(double d)
;a 'uncin signo$ cero si el argumento es cero$ -./ si el argumento es mayor
"ue cero y P-./ si el argumento es menor "ue cero.
static float
signum(float f)
;a 'uncin signo$ cero si el argumento es cero$ -./ si el argumento es mayor
"ue cero y P-./ si el argumento es menor "ue cero.
static double
sin(double a)
8evuelve el seno trigonomtrico de un <ngulo.
static double
sinh(double x)
8evuelve el seno #iperblico de un valor double.
static double
s'rt(double a)
8evuelve la raCz cuadrada positiva redondeada de un valor double.
static double
tan(double a)
8evuelve la tangente trigonomtrica de un <ngulo.
static double
tanh(double x)
8evuelve la tangente #iperblica de un valor double.
static double
to(egrees(double angrad)
9onvierte un <ngulo medido en radianes al apro(imado en grados..
static double
to)adians(double angdeg)
9onvierte un <ngulo medido en grados al apro(imado en radianes.
static double
ulp(double d)
P<gina 11&FE
=er de'inicin en la documentacin completa.
static float
ulp(float f)
=er 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 m<s e'ectivo leer un arc#ivo por blo"ues de datos grandes "ue de byte en byte
>sobrecarga de llamadas a la misma 'uncin?.
4n 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 m<s 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 asC aprovec#ar el tiempo en el "ue no llegan
datos.
4l criterio para implementar estos tipos de memorias temporales >bu''ers de a"uC en adelante? es
variable$ siempre se tomar< 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 m<s pe"ueUos o
m<s grandes$ el valor ptimo siempre es empCrico.
Para determinar este valor siempre tendremos en cuenta "ue blo"ues m<s grandes de datos
consumen m<s 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$ estarCamos desperdiciando memoria si abriramos muc#os arc#ivos m<s pe"ueUos
"ue el bu''er$ por otro lado si el bu''er es muy pe"ueUo$ entonces el e'ecto es contrario$ estarCamos
llamando innumerables cantidades de veces a la 'uncin leer$ por lo "ue producirCamos un desperdicio
de recursos del procesador$ enlentecerCamos el sistema operativo$ entonces "ueda claro "ue no leeremos
arc#ivos en blo"ues de -5D ni lo #aremos byte por byte.
Usando arreglos (ara !n /!**er$ olas de es(era$ (ilas y listas.
Dien$ pongamos el siguiente ejemplo$ se "uieren enviar datos de una m<"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 : minutos envCa los tel'onos del soporte tcnico "ue deben ser
atendidos por la tele'onista$ teniendo en cuenta "ue las llamadas suelen durar entre -/ a E/ minutos y
"ue los correos "ue pueden llegar al mismo tiempo no son m<s de A 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 dCa.
Cr&%er&o+;
-. 6obredimensionar es sobrecargar
.. 5inimizar es sobrecargar
E. 6i llenamos el bu''er$ no se podr<n ingresar m<s d<tos.
1. 6upondremos "ue en el peor de los casos llegan -/ correos
:. 6upondremos "ue en el peor de los casos duran E/ minutos
A. 6upondremos "ue en el peor de los casos el lapso es de ./ minutos durante 1 perCodos.
;os Nltimos tres criterios son suposiciones$ "ue en la vida real son la tele'onista y secretaria
P<gina 1:&FE
"uienes pueden proveer este tipo de estadCstica sobre los #orarios m<s saturados$ tenemos "ue tener en
cuenta "ue el problema es #umanamente soluble ya "ue no "uedan pendientes sin tratar asC "ue durante
el dCa se resuelven todos los llamados% ./min ( 1p _ 0/min _^ -? se resuelven en 0/ minutos . llamados
y b .? se acumularon casi 1/ tel M E tel _ EF tel
4ntonces en el peor de los casos la acumulacin m<(ima probable y el despac#o de tel'onos m<s
tardado producen un m<(imo de EF tel'onos. 4ntonces nuestro uffer ptimo es de AB e(e$e!%o+.
9omo almacenar un tel'ono no consume tanta cantidad de recursos de un sistema utilizaremos un
bu''er de 1/ 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)
4l 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 todavCa asC "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.
,tilizaremos una cone(in de red$ donde la tele'onista tendr< un programa en espera "ue
escuc#ar< en la red y la secretaria el "ue enviar< los datos al establecer una cone(in.
Te(e2o!&+%a;
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 ~$
Se#re%ar&a;
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 ~$
9odi'icacin%
9omo dijimos antes la implementacin y codi'icacin de este ejemplo necesitar< 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 P9 puede actuar como una red de - sola
P<gina 1A&FE
m<"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. 4sta direccin especial$ permite conectarse por medio de los protocolos
de red a la misma m<"uina en caso "ue estemos en un laboratorio de in'orm<tica y dispongamos de la
in'ormacin de las direcciones ip de las otras P9s de la red serCa 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 compar<ndolo con un puerto real donde
llegan barcos$ dic#os barcos una vez "ue llegan son atendidos y siempre "ue #aya "uien atenderlos
podr< entrar otro.
4n este caso solo esperaremos una Nnica cone(in en el puerto$ y cuando esta se establezca no
esperaremos ninguna otra.
;a clase 6erver6oc)et nos permitir< 'abricar un objeto "ue podr< esperar una cone(in$ y cuando
esta llegue podemos abrirla por medio del objeto resultante 6oc)et >cone(in?. 4l puerto de escuc#a en
este ejemplo ser<% 1:AF$ muc#os 'irewalls y mecanismos de proteccin de red pueden blo"uear el acceso
a estos puertos$ asC "ue cual"uier cosa preguntamos al administrador de la red$ por otro lado no podemos
usar un puerto m<s bajo in'erior a los -/.1 por"ue ser< necesario por lo general permisos especiales en
el sistema operativo.
Te(e2o!&+%a;
3. import java.net.*;
4. /**
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.
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
P<gina 1F&FE
35. System.err.println("Esperando conexin...");
36. try {skt = Ss.accept();}
37. catch (IOException ex1) {
38. ex1.printStackTrace(System.err);
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) {
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
P<gina 10&FE
95. return tel;
96.}
97.
8e las lCneas -: a la -B se declaran las variables globales "ue ser<n accesibles por todos los
mtodos est<ticos de la clase como ser el puerto de escuc#a$ el tamaUo del bu''er y el verdadero bu''er
donde utilizamos el tamaUo de'inido para crearlo$ recordemos "ue una vez de'inido el arreglo "ue
actuar< de bu''er no podemos e(pandirlo o reducirlo$ por ello el c<lculo previo para estimar su m<(ima
cantidad de datos. 3ambin se de'ine el tiempo en milisegundos "ue esperaremos antes de mostrar en
pantalla el siguiente tel'ono.
A partir de la lCnea .- comienza el mtodo principal$ el cual se ejecutar< paso seguido de
inicializar las variables globales. +evisemos la lCnea .E$ 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 !(o$
este objeto llamado null es un objeto vacCo "ue no posee propiedades de ningNn tipo y cada vez "ue
"ueramos operar sobre el producir< un error de puntero nulo$ entonces cpor"u lo necesitamosd. 4l
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.
4n la lCnea .: declaramos el objeto de la biblioteca 6erver6oc)et "ue escuc#ar< y devolver< un
objeto del tipo 6oc)et$ usamos el mismo objeto !(o para inicializarlo.
8esde la lCnea .F a la E. intentamos crear el objeto 6erver6oc)et y lo "ue es m<s 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.
4ntre las lCneas E1 y EB 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 6erver6oc)et$ como podemos ver$ la 'uncin accept>?G de
6erver6oc)et aceptar< 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 caracterCsticas de la cone(in.
A partir de la lCnea 1. comenzamos la operacin de lectura de la cone(in de red y de la impresin
en pantalla de los tel'onos.
Wa #abCamos 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 permitirCa enviar objetos a travs del
canal o 'lujo de datos.
4l objeto +8% provee la 'uncin get2nput6tream>?G "ue nos devolver< el Objeto del tipo
2nput6tream "ue necesita el objeto de la biblioteca del tipo O-ect6nput/tream para ser construido.
4n la lCnea 1: declaramos una variable de tipo entero largo >long? %&$er "ue utilizaremos para
medir el tiempo y asC crear nuestro temporizador$ le damos un valor inicial.
4n la lCnea 1A declaramos una variable booleana %&$erCo! "ue nos servir< de bandera para saber
el estado del temporizador$ si es "ue est< activo >true? o parado >'alse?. ;o inicializamos en parado
por"ue no tenemos tel'onos #asta "ue la secretaria los comience a escribir.
4n la lCnea 1F se comienza un blo"ue del tipo Zmientras`$ w#ile>?HI el cual deseamos "ue sea
in'inito por"ue leeremos datos #asta "ue la secretaria envCe la seUal de 'in$ pero mientras tengamos
tel'onos para mostrar en el bu''er no podremos dejar de mostrarlos$ asC "ue para mejor comprensin del
cdigo$ el blo"ue w#ile>%re?HI se ejecutar< por siempre a menos "ue el programa decida terminar.
+evisemos el cdigo de la lCnea 10 a la :.$ en este blo"ue comparamos dos condiciones
P<gina 1B&FE
importantes para decidir si el programa debe salir o no$ la primera es una condicin doble$ por eso est<
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.
4l siguiente blo"ue desde la lCnea :1$:: almacenamos un nNmero entero desde la cone(in de red
"a%o+$ slo si es "ue #ay datos disponibles$ eso lo revisamos con la 'uncin available>?G "ue no se
"uedar< esperando$ si e(isten o no datos disponibles de todas maneras el programa sigue su curso.
4l timer$ entre las lCneas :0 a la A:$ '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 ser< m<s 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 suceder< si #ay m<s de - elemento en
el bu''er$ recordemos "ue en bu''Velem almacenamos la cantidad de elementos de nuestra memoria
temporal.
4n las lCneas AF$A0 incluimos otro blo"ue de control de errores obligatorio por"ue utilizaremos
otra 'uncin de la biblioteca de Java "ue pertenece a la clase 3#read >#ilo? esa 'uncin detiene la
ejecucin del programa una cierta cantidad de milisegundos$ el uso de este pe"ueUo retardo de -//
milisegundos es para no sobrecargar el procesador$ ya "ue estarCamos 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.
4n la lCnea AB 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 ser< necesario terminar el programa.
;os mtodos au(iliares%
public static void put_tel(int tel){
4sta 'uncin agregar< 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.
6i esto no sucede$ la lCnea m<s importante de esta 'uncin es%
buffer[buff_elem++]=tel;
8onde como vimos al principio de este libro el signo SS a la derec#a de bu''Velem simboliza "ue
primero se utilizar< el valor y despus se incrementar<$ entonces en una sola lCnea representamos las dos
operaciones bu''erJbu''VelemKtelG bu''VelemSSG
public static int get_tel(){
4sta 'uncin e(traer< un elemento del bu''er$ pero al mismo tiempo "ue lo e(trae debe posicionar
los dem<s elementos #acia el inicio del arreglo.
3ampoco #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 deberCamos por buena pr<ctica
por"ue si este es un prototipo y nuestro programa ir< 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];
8espus de eso "uitamos uno al apuntador de elementos$ y lo "uitamos antes por"ue para subir los
datos sumaremos uno al Cndice "ue recorremos para acomodar los datos y tendrCamos "ue estar
P<gina :/&FE
revisando "ue el Cndice no supere bu''VelemP-$ como esa condicin se compararCa cada vez "ue pasamos
por un valor del Cndice estarCamos ejecutando innecesariamente una resta "ue podrCamos #acer antes.
,na 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$
Se#re%ar&a;
4. /**
10. * @version 2006.01.01
11. */
12.
13.public class Cap3_sock_sec {
16.public static String HOST="127.0.0.1";
17.
19. System.err.println("Intentando conectar con la telefonista");
21. try {skt = new Socket(HOST, PORT);}
22. catch (Exception ex) {
23. System.err.println("La telefonista no est en lnea");
25. }
26.
27. int tel;
28. BufferedReader teclado=new BufferedReader(new
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);
43. datos.flush();
44. }
45. }//fin de la lectura eterna
46. }catch (IOException ex1) {ex1.printStackTrace(System.err);}
P<gina :-&FE
47.
49.
51.public static int leerInt(BufferedReader buff){
52. int lee=0;
53. boolean error;
54. do {
55. error=false;
58. System.err.println("Entrada erronea, repetir:?");
59. error=true;}
62. return lee;
63. }//final de la funcion leer
64.
8escripcin del 'uncionamiento%
4n las lCneas -: y -A declaramos las variables globales "ue almacenar<n el puerto y la direccin
de red donde nos conectaremos$ en este caso la direccin -.F././.- es universal y permite conectarse a
la misma m<"uina asC "ue podremos ejecutar el programa de la secretaria y la tele'onista en la misma
P9 en consolas de comandos di'erentes$ si estamos en el laboratorio con m<s de - P9 en +48$ entonces
en ese nNmero pondremos el "ue nos comente el administrador del sistema para conectarnos a la P9 "ue
correr< la tele'onista.
4n la lCnea -0 comienza nuestro mtodo principal y de la misma manera "ue en el programa
anterior de'inimos el 6oc)et >s)t? como un elemento vacCo sin inicializar$ ya "ue estamos obligados a
revisar errores.
4ntre las lCneas .- a .: 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 est< en lCnea 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.
6i nos pudimos conectar el programa sigui adelante y procedemos a crear un objeto
Du''ered+eader para manipular la entrada por teclado y declaramos una variable tel "ue almacenar< un
tel'ono para enviar.
4n la lCnea .B comienza el blo"ue donde abriremos la cone(in de datos remota por medio de un
'lujo de datos del tipo O-etOutput/tream.
9omo en el componente anterior utilizamos un bucle eterno para la ejecucin del programa "ue
saldr< por otros mecanismos. >lCnea EE?.
4n la lCnea E1$ asignamos el valor "ue se lee por teclado a la variable tel$ ese segmento est< entre
parntesis por"ue por"ue ese mismo valor asignado lo compararemos antes de proseguir$ podrCamos
#aber #ec#o primero la asignacin y despus la comparacin.
6i la secretaria escribi P- enviamos el P- a la tele'onista para avisarle "ue terminamos$ >lCnea EA?$
la orden datos$flu*,34< vacCa los datos de memoria +A5 al 'lujo de datos inmediatamente y en las
lCneas E0 y EB cerramos debidamente el 'lujo de datos y la cone(in de red antes de salir sin producir
error$ salir con el cdigo / es no producir error.
4n la lCnea 1- comienza el blo"ue de datos "ue se ejecutar< caso contrario a "ue la secretaria
ingrese un P-. 8onde 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<.
P<gina :.&FE
3ermina el bucle etenro w#ile>true?HI termina el blo"ue de control de errores y el mtodo
principal$ a continuacin est<n la 'uncin au(iliar leer2nt "ue no e(plicaremos por"ue es la misma "ue
vimos en el capCtulo 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)
5odi'i"uemos el ejemplo anterior para "ue a#ora sean una bibliotecaria y su asistente$ la
bibliotecaria recibir< libros nuevos para catalogar y los enviar< a apilar en el escritorio de la asistente$ la
asistente tendr< 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 saldr<n en 'orma de pila y no cola de espera$ el lCmite ser< la
altura de la asistente "ue #ace las tarjetas sentada$ pero no lo calcularemos %p.
;ibros en total .1$ se envCa el contenido de la tarjeta en modo te(to.
A+&+%e!%e;
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 ~$
B&,(&o%e#ar&a;
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 ~$
A+&+%e!%e;
4. /**
10. * @version 2006.01.01
P<gina :E&FE
11. */
12.
13.public class Cap3_lifo_asis {
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.
22. //Declaramos la variable socket (ser un puntero a objeto)
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");
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) {
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;}
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
P<gina :1&FE
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) {
79. }
80.
82.
83.
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.
8escripcin del 'uncionamiento%
;a declaracin de variables globales a la clase o tipo de datos se realiza entre las lCneas -: y -B.
4l mtodo principal comienza en la lCnea .-$ y declaramos los objetos del tipo 6oc)et y
6erver6oc)et como en el apartado anterior.
8esde la lCnea .0 a la E. intentamos abrir el puerto para escuc#ar cone(iones entrantes$ si sucede
un error nos salimos.
6i no #ay errores$ entre la lCnea E: y E0 esperamos una cone(in entrante con su respectivo blo"ue
de control de errores.
9omo la 'uncin accept34<detendr< el programa #asta "ue arribe una cone(in$ si estamos
ejecutando el blo"ue principal entre las lCneas 1E y siguientes$ es por"ue se recibi una cone(in. 4n 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 lCneas desde el teclado$ solo
"ue a#ora las leeremos desde la cone(in de red.
8eclaramos algunas cuantas variables para crear nuestro temporizador de - minuto igual "ue en el
ejemplo anterior$ y de'inimos una variable (%&$o "ue nos avisar< cuando los libros son todos.
4n este caso la bandera "ue usamos para saber "ue #emos terminado por parte de la bibliotecaria
es la palabra clave Z'in`$ y por supuesto revisamos "ue la cone(in no est cerrada$ "ue #aya elementos
y todo eso antes de proceder a retirar un libro del bu''er y enseUarlo en pantalla. ;a bandera binaria
(%&$o solo se activar< en la condicin anterior para asegurar "ue seguiremos mostrando tCtulos
mientras$ es una variacin respecto del ejemplo anterior para ver otras maneras de resolver algo similar.
P<gina ::&FE
6i$ el ultimo elemento ya lleg y no #ay m<s en la memoria temporal$ entonces nos salimos del
programa. >lCneas :AP:0?.
6i no es el ultimo elemento y #ay datos disponibles en el 'lujo de datos de red$ entonces leer una
lCnea y ponerla en la memoria temporal.
6i el timer est< encendido entonces procedemos igual "ue antes$ el Nnico cambio sustancial ser<n
las 'unciones "ue guardan y e(traen los datos del bu''er.
;a Nnica 'uncin "ue cambia es la "ue "uita elementos del bu''er$ "ue es muc#o m<s simple "ue
antes.
return buffer[--buff_elem];
8onde estamos decrementando el contador de elementos antes >el PP est< a la iz"uierda? y como
sabemos "ue los arreglos se acceden desde el / a cantidadP- entonces es correcto el resultado devuelto.
B&,(&o%e#ar&a;
4. /**
10. * @version 2006.01.01
11. */
12.
13.public class Cap3_lifo_bib {
16.public static String HOST="127.0.0.1";
17.
19. System.err.println("Intentando conectar con la asistente");
21. try {skt = new Socket(HOST, PORT);}
22. catch (Exception ex) {
23. System.err.println("La asistente no est en lnea");
25. }
26.
27. String titulo;
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");
36. datos.println("fin");
37. datos.flush();
38. datos.close();
39. skt.close();
40. System.exit(0);
41. }else{
42. datos.println(titulo);
P<gina :A&FE
43. datos.flush();
44. }
45. }//fin de la lectura eterna
46. }catch (IOException ex1) {ex1.printStackTrace(System.err);}
47.
49.
51.public static String leerLinea(BufferedReader buff){
52. try {return buff.readLine();}
54. return "";
55. }//final de la funcin leer
56.
4sta 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%
4n este caso la memoria temporal ser< una simple lista$ se pretender< "ue el usuario ingrese una
lista de nombres y "ue en cual"uier momento se pueda buscar$ borrar$ o agregar elementos.
6alida 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]
0) Salir
opcin?
3
P<gina :F&FE
Item a borrar:?
2
0) Salir
opcin?
2
Item[0]:[Azul]
Item[1]:[Celeste]
Item[2]:[Osos]
gus@gusgus ~$
A#ora veamos el cdigo%
3.
4. /**
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.
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..");
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
P<gina :0&FE
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());}
79.System.err.println("Entrada erronea, repetir:?");
80. error=true;}
83.return lee;
85.
86.public static String leerLinea(BufferedReader buff){
87. try {return buff.readLine();}
89. return "";
91.
92.}//fin de la clase
4n esta implementacin agregamos un menN de usuario en pantalla "ue nos permitir< interoperar
un poco mejor el programa para probar todas las opciones e incluso #acer e(perimentos y e(pandirlo
con los ejemplos "ue seguir<n a este.
9omo antes entre las lCneas -: y -F declaramos globalmente la lista$ sus lCmites y el apuntador de
elementos.
7uestro mtodo principal >lCnea ./? crear< un objeto como antes #icimos para leer desde el
teclado >o podrCa ser una 'uente e(terna como la red en los ejemplos anteriores?.
8e'inimos de manera local al mtodo principal la variable op "ue almacenar< la opcin de menN
"ue #aya escogido el usuario >lCnea .-?.
P<gina :B&FE
8e la misma manera "ue antes ejecutamos inde'inidamente el blo"ue w#ile>true?HI aun"ue
podrCamos igual "ue en todos los casos anteriores proponer una condicin viable "ue tambin sea v<lida
para terminar el programa como por ejemplo >op__/?.
9ada cl<usula case ejecutar< 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 >lCnea 1/?.
4n las lCneas 1- y 1. 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 >lCnea 1F?$ muy simple antes de aumentar en uno el contador de elementos se
utiliza el valor del Cndice para almacenar el valor del dato "ue se desea ingresar a la lista.
Luncin listar >lCnea :-?$ listamos todos los elementos de la lista en pantalla indicando su Cndice en
el arreglo de te(to listaJK.
Luncin borrar >lCnea :F?$ decrementamos en uno el contador de elementos y recorremos todos los
elementos restantes a la posicin "ue "ueremos eliminar.
Luncin imprimirVmenu>? >lCnea A1?$ slo imprime en pantalla las opciones "ue compara el
mtodo principal para realizar acciones.
Luncin opcin >lCnea F.?$ idntica a leer2nt "ue #emos estado viendo en todos estos ejemplos.
Luncin leer;inea >lCnea 0A?$ idntica a leer;inea 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
=eremos tres maneras di'erentes de encontrar un elemento en una lista de datos$ el primero es el
m<s lgico$ el secuencial$ el opuesto$ aleatorio$ y el binario cuando la lista lleva algNn tipo de orden.
-Ds'!eda se!enial
;a 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$
-Ds'!eda aleatoria$ desordenar lista.
4ste mtodo es completamente probabilCstico y es 'uncional cuando el mtodo binario u otro
mtodo m<s e'icaz no visto sea aplicable. 4s 'actible si el acceso a los datos es e(tremadamente lento$ es
decir si la bNs"ueda secuencial podrCa 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
P<gina A/&FE
sirve para desordenar una lista$ por ejemplo para repartir Zcartas mezcladas de un juego virtual`.
4jemplo% 4n una situacin donde la consulta en lCnea 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 minimizarCa de manera aleatoria si tenemos suerte$ otro ejemplo
serCa 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
minimizarCamos el tiempo de bNs"ueda de manera "ue en el peor de los casos nuestra respuesta estarCa
entre el :/[ y el -//[ de los Nltimos registros y en el mejor de los casos entre el /[ y el :/[ de los
primeros registros$ de todas maneras es la misma probabilidad "ue la bNs"ueda secuencial asC "ue solo
el azar es el "ue in'luye.
DNs"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 Cndice para acceder a la lista$ con la cantidad de elementos actual y no la m<(ima
"ue es su capacidad$ ya "ue ser< de manera temporal y local a la 'uncin$ todos los objetos y variables
declarados dentro de una 'uncin a menos "ue sean declarados est<ticos se perder<n y se liberar<
memoria del sistema.
+ellenamos el Cndice con los elementos desde el / al m<(imo menos uno. 4(traemos al azar un
elemento del Cndice y recorremos los dem<s #asta el "ue "uitamos$ asC 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$
8esordenar 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];
24.}
Para desordenar la lista estamos usando una lista temporal$ con su respectivo contador e Cndice
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
P<gina A-&FE
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%
;a bNs"ueda binaria es un mtodo simple "ue se usa para encontrar datos en una lista ordenada$ el
mecanismo es el siguiente...
6i tenemos una lista de n datos$ ordenados de mayor a menor y "ueremos encontrar uno en
particular$ #aremos una bNs"ueda con dos Cndices$ o sea almacenaremos el valor del elemento
comparado m<s grande y m<s pe"ueUo #asta arrinconar el resultado o llegar a un punto donde no e(iste
tal elemento pero los dos mas cercanos son estos Cndices mayor y menor.
=eamos a#ora un trozo de cdigo para cuando la lista est< ordenada de manera creciente y
decreciente$ estas dos 'unciones utilizan la 'rmula "ue vimos en la ilustracin anterior para calcular el
Cndice superior e in'erior$ de esa manera y teniendo en cuenta "ue la operacin de divisin ser<
redondeada y slo tendremos un nNmero entero veamos como "uedarCan nuestras 'unciones.
Orden ascendente de 3e(to%
1. public static String buscar_ordenado_az(String inicio){
2. int Is=lista_elem-1;
P<gina A.&FE
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
6
I
2
]
.
I
2
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%$
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. }
4n 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 m<"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$
M$todos !ara ordenar listas
=eremos a continuacin algunos pocos mtodos para ordenar listas de datos$ esto nos servir< 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 r<pida como 5y6O; compilado para el procesador de la P9.
MCtodo de la /!r/!ja o MCtodo de Ordenain (or Selein
4ste 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% tenemos una lista de datos desordenada
y comparamos los dos primeros y slo esos dos los ordenamos de mayor a menor$ el paso siguiente es
comparar el "ue sigue con el anterior y asC sucesivamente #asta llegar al 'inal$ si contamos las
P<gina AE&FE
comparaciones$ 'ueron el total de los datos de la lista$ menos una por"ue son de dos en dos. 9on cada
pasada por la lista un dato "ueda ordenado$ y el nombre de burbuja es por"ue podrCamos imaginarnos
una burbuja "ue se lleva nuestro dato m<s grande #acia abajo o #acia arriba dependiendo como estemos
recorriendo la lista y como estemos ordenando$ si de mayor a menor o menor a mayor.
9omo podemos ver$ para "ue la lista "uede ordenada en el ejemplo de la ilustracin anterior$
debemos repetir el procedimiento 7P- veces$ pero tambin como podemos ver ya "ue el elemento m<s
grande "ued ordenado$ podemos reducir el espacio de la burbuja desde el primer elemento al 7P-Pi
donde i es el nNmero de veces "ue se #a recorrido la lista para ordenarla$ de esa manera reducimos la
cantidad de comparaciones$ "ue #ace la burbuja para "uedarse con el elemento m<s grande.
P<gina A1&FE
Ilustracin *: (todo de la burbuja o (todo de Ordenacin por 5eleccin, para ordenar datos
3
20 34 10 4 89 100 23 45 12 15 20 90 47
3
20 34 10 4 89 100 23 45 12 15 20 90 47
20 10 34 4 89 100 23 45 12 15 20 90 47
20 10 4 34 89 100 23 45 12 15 20 90 47
20 10 4 34 89 100 23 45 12 15 20 90 47
20 10 4 34 89 100 23 45 12 15 20 90 47
20 10 4 34 89 23 100 45 12 15 20 90 47
20 10 4 34 89 23 45 100 12 15 20 90 47
20 10 4 34 89 23 45 12 15 20 90 47 100
=eamos un ejemplo%
1. public static void burbuja_mayormenor(int[] listado){
2. int temporal;
3. for (int j = 0; j < listado.length - 1; j++) {
4. for (int i = 0; i < listado.length - 1; i++) {
5. if (listado[i] < listado[i + 1]) {
6. temporal = listado[i + 1];
7. listado[i + 1] = listado[i];
8. listado[i] = temporal;
9. }
10. }
11. }
12. } //final metodo ordenar burbuja mayor menor
la 'uncin descrita arriba ordena de mayor a menor los elementos de la lista$ la lista es un arreglo
de nNmeros enteros "ue se recorre de la misma manera "ue en la 2lustracin E slo "ue se compara de
manera "ue el m<s pe"ueUo sea el "ue se "ueda$ en la linea E repetimos el proceso 7 cantidad de veces$
ya "ue la burbuja ordena de - elemento por pasada y el proceso de recorrido empieza en la lCnea 1$ en la
lCnea : se #ace la comparacin y dado el caso se dan vuelta los elementos utilizando una variable
temporal del mismo tipo "ue almacena el arreglo.
A#ora veamos como acotar los recorridos para reducir la cantidad de comparaciones%
13.public static void ordenar_burbuja_mayormenor(int[] listado){
14. int temporal;
15. for (int j = listado.length - 1; j > 0; j--) {
16. for (int i = 0; i < j; i++) {
21. }
22. }
23. }
24. }//final metodo ordenar burbuja mayor menor
4ste ejemplo es idntico al anterior slo "ue a#ora la lCnea E no slo se utiliza para contar la
cantidad de veces "ue tenemos "ue recorrer el arreglo sino "ue va decreciendo para "ue el recorrido
siempre sea un elemento menos$ es decir el "ue "ued ordenado no se vuelve a comparar.
Nota: 2ueda como e-ercicio para el lector construir las dos funciones inversas, las +ue
ordenan de menor a mayor, y la +ue ordena de menor a mayor acotando las comparaciones$
MCtodo E!iFSort Re!rsi,o
4ste mtodo para ordenar$ es recursivo$ si entendimos el ejemplo anterior$ pudimos ver "ue la
ejecucin del algoritmo era secuencial$ es decir - sola 'uncin #izo todo el trabajo en si misma.
4ste algoritmo implementa la divisin en dos grupos del arreglo a ordenar y por lo tanto la misma
operacin se realiza con cada subgrupo "ue a su vez se vuelve a dividir$ y como es la misma operacin
se llama a la misma 'uncin varias veces.
4sto tiene una desventaja$ la plata'orma "ue corre nuestra implementacin debe producir una
interrupcin del proceso de ejecucin para llamar a otra 'uncin$ esto no tiene nada de malo e(cepto "ue
cuando sean demasiados elementos la cantidad de veces "ue una 'uncin llam a la misma 'uncin "ue
llam a la misma 'uncin puede ser tan larga "ue podrCa producir un agotamiento de recursos "ue
ralentice o impida la ejecucin de este tipo de algoritmos$ en conclusin este mtodo es muy di'Ccil
P<gina A:&FE
implementarlo de manera secuencial pero la cantidad de comparaciones se reduce notablemente.H-IH.I
1. public static void quicksort_menormayor(int[] listado,int i,int j){
2. if (i>=j){return;}
3. int p = dividiren_menormayor(listado,i,j);
4. quicksort_menormayor(listado,i,p-1);
5. quicksort_menormayor(listado,p+1,j);
6. }//final del mtodo principal de quicksort
7.
8. public static int dividiren_menormayor(int[] listado,int i,int j){
9. int p= i; i++;
10. while (true){
11. while (i < j && listado[i]<=listado[p]){i++;}
12. while (i < j && listado[j]>=listado[p]){j--;}
13. if (i == j) break;
14. swap(listado,i,j);
15. }
16. if (listado[p]<listado[i]){i--;}
17. swap(listado,p,i);
18. return i;
19. }//final del mtodo que divide y ordena
4n el cdigo de ejemplo vemos "ue se declararon varias 'unciones$ la 'uncin swap #ace el
intercambio con la variable temporal como en el mtodo anterior$ la 'uncin dividiren es la m<s
importante de este procedimiento$ es no solo la "ue divide sino la "ue intercambia los elementos "ue se
van ordenando. W por supuesto "uic)sort se llama asC misma por cada subsegmento.
9ada segmento se recorre #acia arriba y #acia abajo salt<ndose los menores e iguales y mayores e
iguales "ue el elemento in'erior$ cuando no #ay nada "ue saltar$ se intercambian los valores de manera
"ue "uedan por encima y debajo de p los mayores y los menores.
A#ora veamos la misma 'uncin pero ordenando de mayor a menor$ como podemos ver slo
cambian los signos de comparacin re'erentes a los contenidos del listado.
1. public static void quicksort_mayormenor(int[] listado,int i,int j){
2. if (i>=j){return;}
3. int p = dividiren_mayormenor(listado,i,j);
4. quicksort_mayormenor(listado,i,p-1);
5. quicksort_mayormenor(listado,p+1,j);
6. }//final del mtodo principal de quicksort
7.
8. public static int dividiren_mayormenor(int[] listado,int i,int j){
9. int p= i; i++;
10. while (true){
11. while (i < j && listado[i]>=listado[p]){i++;}
12. while (i < j && listado[j]<=listado[p]){j--;}
13. if (i == j) break;
14. swap(listado,i,j);
15. }
16. if (listado[p]>listado[i]){i--;}
17. swap(listado,p,i);
18. return i;
19. }//final del mtodo que divide y ordena
Otros &eanis&os (ara ordenar.
4(isten otros mecanismos "ue no podemos tratar en este momento por"ue es necesario
implementar objetos$ asC "ue ese ser< el pr(imo tema$ algunos son$ por insercin$ por 'usin$ de s#ell y
con un <rbol binario.
P<gina AA&FE
Ejeriios
;os ejercicios del capCtulo 222 son los Nltimos antes de proceder con objetos$ es recomendable "ue
todo a"uello "ue se #a visto #asta el momento "uede per'ectamente asimilado ya "ue en el pr(imo
tema los objetos comenzar<n a ser la #erramienta principal.
Ejeriio 7.3
+ealizar un programa cuyo mtodo principal pida -/ valores numricos y los asigne a un arreglo$
posteriormente imprimir en pantalla el resultado ordenado creciente$ y decreciente utilizando el mtodo
de la burbuja$ computar la cantidad de comparaciones realizadas entre elementos del arreglo y
mostrarlas al 'inal como estadCstica.
3. /**
9. * @version 2007.10.01
10. */
11.
12.public class Cap3_ej1 {
13. public static int comparaciones=0;
16. int[] listado=new int[10];
17. System.out.println("Ingrese 10 nmeros, de a uno presionando ENTER");
18. for(int i=0;i<10;i++){
19. listado[i]=leerInt(br);
20. }
21.
22. burbuja_mayormenor(listado);
23. for(int i=0;i<10;i++){
24. System.out.println("NRO >:["+i+"] "+listado[i]);
25. }
26. System.out.println("Comparaciones:"+comparaciones);
27. burbuja_menormayor(listado);
28. for(int i=0;i<10;i++){
29. System.out.println("NRO <:["+i+"] "+listado[i]);
30. }
31.
32. }
34. int lee=0;
35. boolean error;
36. do {
37. error=false;
41. error=true;}
44. return lee;
45. }//final de la funcin leer
46.
47. public static void ordenar_burbuja_mayormenor(int[] listado){
P<gina AF&FE
48. int temporal;
49. for (int j = listado.length - 1; j > 0; j--) {
50. for (int i = 0; i < j; i++) {
51. comparaciones++;
56. }
57. }
58. }
59. }//final mtodo ordenar burbuja mayor menor
60.
61. public static void burbuja_mayormenor(int[] listado){
62. int temporal;
64. for (int i = 0; i < listado.length - 1; i++) {
70. }
71. }
72. }
73. } //final mtodo ordenar burbuja mayor menor
74.
75. public static void ordenar_burbuja_menormayor(int[] listado){
76. int temporal;
78. for (int i = listado.length - 1; i > j; i--) {
80. if (listado[i] < listado[i - 1]) {
81. temporal = listado[i - 1];
82. listado[i - 1] = listado[i];
84. }
85. }
86. }
87. }//final mtodo ordenar burbuja menor mayor
88.
89. public static void burbuja_menormayor(int[] listado){
90. int temporal;
92. for (int i = listado.length - 1; i > 0; i--) {
94. if (listado[i] < listado[i - 1]) {
95. temporal = listado[i - 1];
96. listado[i - 1] = listado[i];
98. }
99. }
100. }
101. } //final mtodo ordenar burbuja menor mayor
102.}
;Cnea -$ declaracin del pa"uete$ lCnea . importamos java.io para usar los mtodos de lectura del
teclado$ ;Cnea -. declaracin de la clase$ lCnea -E declaramos la variable est<tica a la clase
comparaciones "ue es la "ue usaremos para computar la cantidad de comparaciones para ordenar el
arreglo.
P<gina A0&FE
4l programa en sC comienza en el mtodo principal lCnea -1$ lCnea -: se construye un objeto
&uffered!eader para lectura por teclado$ lCnea -A se inicializa un arreglo de -/ elementos "ue ser< el
tamaUo del arreglo a trabajar.
;Cneas -F a ./ es la entrada por teclado de los nNmeros del arreglo utilizando la 'uncin
leer2nt>&uffered!eader? utilizada en ejercicios anteriores.
;Cnea .. se invoca a la 'uncin "ue ordena sobre el arreglo listado de nNmeros enteros$ y en las
lCneas .E a .A se imprime en pantalla la in'ormacin correspondiente y la estadCstica de las
comparaciones. ;Cnea EE a 1: Luncin leer.
;Cnea 1F M :B la 'uncin ordenar de mayor a menor con la optimizacin de acotacin de Cndices$ y
las dem<s variantes con y sin optimizacin.
Ejeriio 7.2
+ealizar un programa cuyo 'in sea el del ejercicio E.- pero utilizando el procedimiento "uic)sort.
Ejeriio 7.7
2ntegrar con un pe"ueUo menN en pantalla la seleccin del mtodo "ue se utilizar< para ordenar el
arreglo reutilizando el cdigo de los ejercicios anteriores E.- y E..$ pero aUadir al cmputo las
comparaciones en total incluyendo las de los Cndices en bucles.
P<gina AB&FE
IGH Pri&eros O/jetos o&o &eanis&o de (rogra&ain.
4n este capCtulo del libro comenzaremos a utilizar objetos para resolver problemas$ la
construccin e'iciente del objeto tambin ser< parte del problema$ recordemos "ue un objeto puede
tener$ mtodos est<ticos y din<micos y propiedades est<ticas y din<micas$ la seleccin de cada una
depender< del problema y del criterio utilizado.
Lista on (!nteros (ara ordenar datos.
este es otro mtodo un poco m<s complejo para ordenar datos mientras se insertan$ lo
propondremos como una variante a los mtodos vistos anteriormente pero construiremos un objeto "ue
almacenar< el dato$ proveer< mtodos para compararlo con otros objetos iguales y tendr< propiedades
"ue nos permitir< conectarlo con otros objetos del mismo tipo. 4l objeto y el procedimiento ir<
#acindose m<s complejo con'orme avancemos en el tema.
2maginemos una persona$ tiene dos manos y cada mano puede unirse a otra persona$ cada persona
simboliza un objeto "ue almacena un dato o un conocimiento$ entonces el objeto de nuestra lista puede
vincularse por la iz"uierda y derec#a o puede estar vinculado por solo uno de los dos lados$ o ninguno
en el estado inicial.
9uando "ueremos insertar un elemento en nuestra lista$ compararemos el nuevo de manera binaria
recorriendo la lista como #emos visto anteriormente$ y desconectaremos el lugar donde le corresponde ir
uniendo su lado derec#o e iz"uierdo con los elementos de la ruptura.
4ste tipo de lista se maneja por apuntadores$ vCnculos entre objetos "ue no es lo mismo "ue tener
un arreglo de datos "ue se puede acceder en cual"uier momento a cual"uier elemento por medio de su
Cndice. 4n este caso es necesario ir recorriendo cada elemento para saber a "uien est< conectado y seguir
la cadena de datos de derec#a a iz"uierda y viceversa.HEI
N!estro (ri&er o/jeto
Para poder realizar la lista ordenada "ue mencionamos utilizaremos un objeto "ue representar< el
nodo "ue puede conectarse por iz"uierda y por derec#a y "ue almacena el dato$ con'orme podamos
introduciremos 'unciones e(tra para realizar comparaciones.
Pro!iedades
7ecesitamos la propiedad derec#a e iz"uierda "ue ser<n punteros o variables "ue almacenar<n
objetos del mismo tipo Znodo` "ue ser<n como las manos "ue conectan los objetos adyacentes.
7ecesitamos la propiedad valor "ue almacenar< una cantidad entera dentro del objeto$ y esta
cantidad se establecer< al construir el objeto.
1.package com.compunauta.aprendiendojava;
2.public class Nodo {
3. public Nodo izquierda=null;
4. public Nodo derecha=null;
5. public int Dato;
6. public Nodo(int Dato) {
7. this.Dato=Dato;
8. }
9.}
A#ora para #acer pruebas construiremos un mtodo principal y como esta vez la in'ormacin la
almacenaremos en un arreglo serCa interesante "ue tengamos un par de apuntadores principales "ue nos
permitan acceder al primer y Nltimo objeto de manera inmediata$ asC "ue incluiremos esos apuntadores
para trabajar. ,tilizaremos tambin las 'unciones "ue #emos visto anteriormente para leer enteros del
P<gina F/&FE
teclado y recorreremos la lista del elemento inicial >el m<s pe"ueUo? al elemento 'inal >el m<s grande?$
despus incluiremos algunas modi'icaciones para mejorar la capacidad de insercin acortando las
comparaciones y m<s adelante rediseUaremos el mtodo para tener mayor control sobre los elementos
"ue no pertenecen a un arreglo en concreto.
1.package com.compunauta.aprendiendojava;
2.import java.io.*;
3./**
9. * @version 2007.10.02
10. */
11.
12.public class Nodo {
13. public Nodo izquierda=null;
14. public Nodo derecha=null;
15. public int Dato;
16. public Nodo(int Dato) {
17. this.Dato=Dato;
18. }
19. public static Nodo ini=null; //inicio
20. public static Nodo fin=null; //final
21. public static int total=0;
24. System.out.println("Ingrese 10 nmeros, de a uno presionando ENTER");
25. for (int i = 0; i < 10; i++) {
26. addObject(leerInt(br));
27. }
28. printList();
29. }
30. public static void addObject(int Dato){
31. Nodo dato=new Nodo(Dato);
32. Nodo apuntador;
33. total++;
34. if (total==1){
35. ini=dato;
36. fin=ini;
37. }else{
38. if (fin.Dato <= Dato){
39. fin.derecha=dato;
40. dato.izquierda=fin;
41. fin=dato;
42. return;
43. }
44. if (ini.Dato >= Dato){
45. ini.izquierda=dato;
46. dato.derecha=ini;
47. ini=dato;
48. return;
49. }
50. apuntador=ini;
51. while (apuntador.Dato < Dato){
52. apuntador=apuntador.derecha;
53. }
54. dato.izquierda=apuntador.izquierda;
55. apuntador.izquierda.derecha=dato;
P<gina F-&FE
56. dato.derecha=apuntador;
57. apuntador.izquierda=dato;
58. return;
59. }
60. }
61.
62. public static void printList(){
63. Nodo apuntador=ini;
64. int elementos=0;
65. while (apuntador!=null){
66. System.out.println("Elemento ["+(elementos++)+"]:"+apuntador.Dato);
67. apuntador=apuntador.derecha;
68. }
69. }
71. int lee=0;
72. boolean error;
73. do {
74. error=false;
78. error=true;}
81. return lee;
83.
84.}
9omo podemos ver la 'uncin print;ist>? recorre la lista para impresin en pantalla y la 'uncin
leer renglones$ es como la "ue #emos visto anteriormente$ la "ue realiza la operacin de insercin en la
lista es addObject>int 8ato? y tenemos en cuenta 1 casos.
-. 4l primer objeto es ini y 'in y tiene nulas derec#a e iz"uierda
.. 6i no es el primer objeto y es m<s grande "ue todos unir a la derec#a
E. 6i no es el primer objeto y es m<s pe"ueUo "ue todos unir a la iz"uierda
1. 6i se encuentra en medio$ recorremos desde el inicio #asta encontrar uno m<s grande.
Nota: 2ueda como e-ercicio para el lector modificar el programa para recorrer la lista de
menor a mayor o mayor a menor dependiendo del valor del dato a insertar$
P<gina F.&FE
Indie de ta/las
3abla -% 3ipos de datos b<sicos...................................................................................................................-/
3abla .% Operadores D<sicos.......................................................................................................................-.
3abla E% Palabras claves P 3ipos de datos...................................................................................................-1
3abla 1% Palabras clave P Permisos y 8eclaraciones...................................................................................-:
3abla :% Palabras 9lave P 9ontrol de Llujos$ tomas de decisin................................................................-:
3abla A% Palabras clave M +eservadas.........................................................................................................-A
3abla F% Palabras clave P 9ontrol de errores...............................................................................................-A
3abla 0% +esumen de mtodos importantes para out.................................................................................../
3abla B% +esumen de mtodos importantes del tipo de objetos in............................................................../
3abla -/% ;a 9lase 5at# P mtodos y constantes.......................................................................................1:
Indie de il!straiones
2lustracin -% ;a '<brica de Objetos dentro de J+4......................................................................................B
2lustracin .% DNs"ueda binaria en una lista ordenada...............................................................................A.
2lustracin E% 5todo de la burbuja o 5todo de Ordenacin por 6eleccin$ para ordenar datos............A1
Re*erenias Reo&endadas
-% $ Ordenamiento de Arreglos$ #ttp%&&www.dcc.uc#ile.cl&\lmateu&Java&3ransparencias&9ompl&sort.#tm
.% $ Ordenacin$ #ttp%&&www.dcc.uc#ile.cl&\ccE/a&apuntes&Ordenacion&
E% Pro'. Juan Andrs 9olmenares$ 5.6c. $ 5todos de Ordenacin 7otas de 9lase $
#ttp%&&www.ica.luz.ve&juancol&eda&ordenacion&inde(.#tml
P<gina FE&FE

AprendiendoJava PDF

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

AprendiendoJava PDF

Uploaded by

Copyright:

Available Formats

Aprendiendo Java

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

You might also like