Programacion Guia y Ejercicios Resueltos

UNIVERSIDAD C ATO LIC A BO LIVIANA
“SAN PABLO ”
FAC ULTAD DE C IENC IAS EXAC TAS E ING ENIERIA
ING ENIERIA DE SISTEMAS
LA PAZ – BO LIVIA
PRO G RAMAC IO N II
G UIA DE JAVA
+ EJERC IC IO S
2007
INTEG RANTES:
O SSIO MARIN SERG IO WILLY

PRUDENC IO RO BINSO N ANDRES MAURIC IO
SALG ADO FALLER IG NAC IO
VALDA SANC HEZ FREDDY SALVADO R
DO C ENTE: M.Sc . IRMA PRADO
SEMESTRE I AÑO 2007

PRO G RAMAC IO N II GUIA DE JAVA 2007
INDICE
INDIC E....................................................................................................................1
PRO LO G O .............................................................................................................2
INTRO DUC C IÓ N....................................................................................................3
Pro g ra m a c io n O rie nta d a a O b je to s.............................................................4
Pa rtic ula rid a d e s d e Ja va ................................................................................5
El inte rp re te d e Ja va .......................................................................................8
Dife re nc ia s y sim ilitud e s c o n C ++ ................................................................11
C la se s útile s .....................................................................................................16
Le ng ua je Ja va ................................................................................................19
EJERC IC IO S RESUELTO S......................................................................................22
Se nte nc ia s Bá sic a s (C o nd ic io na le s, Aritm e tic a s y C o nta d o re s)............22
PRO BLEMAS PRO PUESTO S..........................................................................28
C ic lo s y Se rie s..................................................................................................30
Func io ne s y e l uso d e la c la se Ma th ...........................................................44
Arre g lo s ............................................................................................................59
Ap lic a c ió n d e ve c to re s – Pro g ra m a e sta d istic o ...................................83
Ma tric e s ...........................................................................................................91
Ap lic a c ió n d e Ma tric e s – C a lc ulo s Ma tric ia le s ...................................115
Ap lic a c ió n d e m a tric e s – Inve rsio n d e Ma tric e s p o r Fa d d e vva .......123
PRO BLEMAS PRO PUESTO S........................................................................126
Re c ursivid a d ..................................................................................................129
PRO BLEMAS PRO PUESTO S........................................................................148
Eje rc ic io s c o n G rá fic o s................................................................................149
BIBLIO G RAFIA ....................................................................................................160
INTEG RANTES: Se rg io O ssio , And ré s Prud e nc io , Ig na c io Sa lg a d o , Fre d d y Va ld a 1

PROLOGO
Esta g uía fue re a liza d a p o r e stud ia nte s d e te rc e r se m e stre d e Ing e nie ria
d e Siste m a s d e la Unive rsid a d C a to lic a Bo livia na c o n e l fin d e p ro p o rc io na r una
he rra m ie nta útil a to d o s lo s e stud ia nte s q ue e sté n c ursa nd o la m a te ria d e
Pro g ra m a c io n II o q ue te ng a n a lg una d ific ulta d e n la p ro g ra m a c ió n e n Ja va o
q ue sim p le m e nte d e se e n a m p lia r su c o no c im ie nto e n e l te m a .
En e sta g uía e nc o ntra rá a p ro xim a d a m e nte 100 e je rc ic io s re sue lto s

(p ro g ra m a s e n ja va ), c la sific a d o s e n d ife re nte s se c c io ne s. To d o s e sto s
p ro g ra m a s func io na n c o rre c ta m e nte y fue ro n e je c uta d o s utiliza nd o la
he rra m ie nta Re a dy to Pro g ra m , d ip o nib le e n fo rm a g ra tuita e n
http :/ / w w w .sju.e d u/ ~p a rkinso / ja va to o ls/ re a d yto p ro g ra m .htm l

INTRODUCCIÓN
En e l a ño 1991 na c ió Ja va c ua nd o e n Sun , una e m p re sa nue va , se

p ro p usie ro n c re a r un nue vo le ng ua je d e stina d o en p rinc ip io a
e le c tro d o m é stic o s, p o r lo ta nto , la p rim e ra ve rsió n e ra un le ng ua je
se nc illo c a p a z d e g e ne ra r c ó d ig o d e ta m a ño re d uc id o .
El c o ntinuo c a m b io e n la s c o m p uta d o ra s o b lig a b a a c a m b ia r lo s

p ro g ra m a s c o ntinua m e nte p o r lo q ue se p e nsó e n d e sa rro lla r una
m á q uina virtua l ind e p e nd ie nte q ue p o ste rio rm e nte se d e no m ina ria Ja va
Virtua l Ma c hine (JVM) y e sto d io lug a r a l p rim e r le m a d e Ja va "Write
o nc e , Run Eve rywhe re ".
Evid e nte m e nte , lo s e le c tro d o m é stic o s no e sta b a n inte re sa d o s e n

Ja va , a sí q ue c o m e nzó a intro d uc irse c o m o le ng ua je d e p ro g ra m a c ió n
p a ra c o m p uta d o ra s a fina le s d e 1995, intro d uc ié nd o se c o m o una
he rra m ie nta ne c e sa ria , p ue sto q ue Ne tsc a p e Na vig a to r 2.0 la intro d ujo
c o m o inté rp re te .
Se p ub lic ó Ja va 1.1 a p rinc ip io s d e 1997 y Ja va 1.2 a fina le s d e 1998

c o n una e vo luc ió n p ro d ig io sa d e 12 p a q ue te s inic ia le s, 23 p a q ue te s e n
la ve rsió n 1.1 y 59 p a q ue te s e n la ve rsió n 1.2 ( d e no m ina d a Ja va 2).
La c o m p a ñía Sun d e sc rib e a Ja va c o m o "sim p le , o rie nta d o a

o b je to s, d istrib uid o , inte rp re ta d o , ro b usto , se g uro , d e a rq uite c tura ne utra ,
p o rta b le , d e a lta s p re sta c io ne s, m ultita re a y d iná m ic o ", y lo b ue no d e
e sta d e finic ió n e s q ue to d o lo q ue d ic e , q ue no es po c o , e s
a b so luta m e nte c ie rto , a unq ue e n a lg uno s a sp e c to s m e jo ra b le .

Programacion Orientada a Objetos
La p rinc ip a l func ió n d e e ste tuto ria l no e s e nse ña r to d o s y c a d a uno d e

lo s c o nc e p to s y p a rtic ula rid a d e s d e la p ro g ra m a c ió n d irig id a a o b je to s, a sí q ue
sim p le m e nte se d a rá n a lg uno s c o nc e p to s q ue se d e b e n te ne r c la ro s p a ra
c o m e nza r.
La e struc tura g e ne ra l d e un p ro g ra m a o rie nta d o a o b je to s (PO O ), se

e sp e c ific a e n una c la se p rinc ip a l q ue c o ntie ne n e l p ro g ra m a p rinc ip a l,
(func ió n ma in() ).
Una c la se e s una c o le c c io n d e va ria b le s y m é to d o s q ue m a ne ja n

va ria b le s y e struc tura s d e d a to s. Se d e no m ina n no rm a lm e nte d a to s y m é to d o s
m ie m b ro .
La PO O se b a sa e n la p ro g ra m a c ió n d e c la se s. Una c la se c o nstituye un
p a tró n o m o d e lo p a ra c re a r o b je to s. To d o s lo s o b je to s d e b e n p e rte ne c e r a
una c la se d e te rm ina d a y p o r lo ta nto se d ic e q ue to d o s lo s o b je to s d e b e n se r
insta nc ia s d e una c la se , e s d e c ir, q ue lo s o b je to s fo rm a n un c o nte xto d e c la se .
Un o b je to e sta rá fo rm a d o p o r la s va ria b le s y m é to d o s d e la c la se y se rá
sie m p re d ife re nte d e o tro o b je to , a unq ue e ste p e rte ne zc a a la m ism a c la se .
La s c la se s ta m b ié n p ue d e n inc luir va ria b le s sta tic q ue no fo rm a rá n p a rte d e lo s
o b je to s d e d ic ha c la se , sino d e la c la se e n sí, e sta s va ria b le s se d e no m ina n
va ria b le s d e c la se .
La he re nc ia e s o tro c o nc e p to im p o rta nte d e la PO O , p e rm ite d e finir

nue va s c la se s b a sá nd o se e n c la se s ya e xiste nte s. Una c la se q ue se e xtie nde d e
o tra , he re d a to d a s sus va ria b le s y to d o s sus m é to d o s. La c la se d e riva d a p ue d e
a ña d ir nue va s va ria b le s y m é to d o s y re d e finir la s va ria b le s y m é to d o s
he re d a d o s. En Ja va una c la se só lo p ue d e he re d a r d e o tra , e s lo q ue se
d e no m ina he re nc ia sim p le .
El últim o d e lo s c o nc e p to s c la ve s q ue se va n a p untua liza r a q uí e s e l
p o limo rfismo , e l p o lim o rfism o tie ne q ue ve r c o n la re la c ió n q ue se e sta b le c e
e ntre la lla m a d a a un m é to d o y e l c ó d ig o q ue e fe c tiva m e nte se a so c ia c o n

d ic ha lla m a d a . A e sta re la c ió n se lla m a vinc ula c ió n o b inding . La vinc ula c ió n
p ue d e se r te m p ra na , e n tie m p o d e c o m p ila c ió n, o ta rd ía , e n tie m p o d e
e je c uc ió n.
La vinc ula c ió n te m p ra na e s la m á s e fic ie nte y e s la q ue se da
no rm a lm e nte c o n func io ne s no rm a le s o so b re c a rg a d a s. La so b re c a rg a se
re fie re a la p o sib ilid a d d e te ne r d o s o m á s func io ne s c o n e l m ism o

no m b re p e ro func io na lid a d d ife re nte . Es d e c ir, d o s o m á s func io ne s c o n
e l m ism o no m b re re a liza n a c c io ne s d ife re nte s. El c o m p ila d o r usa rá una u
o tra d e p e nd ie nd o de lo s p a rá m e tro s usa d o s. A e sto se lla m a
so b re c a rg a d e func io ne s. La vinc ula c ió n ta rd ía e s la q ue se utiliza c o n
func io ne s re d e finid a s.
Ad e m á s d e c la se s, Ja va p ro p o rc io na inte rfa c e s. Un inte rfa c e e s un

c o njunto d e d e c la ra c io ne s d e m é to d o s. Si una c la se im p le m e nta un inte rfa c e ,
d e b e d e finir to d a s la s func io ne s e sp e c ific a d a s e n é l. Una c la se p ue d e
im p le m e nta r ning ún, uno , o va rio s inte rfa c e s. Un inte rfa c e si so p o rta la he re nc ia
m últip le d e va rio s inte rfa c e s.
Particularidades de Java
A c o ntinua c ió n se e nunc ia n va ria s p a rtic ula rid a d e s d e Ja va , q ue se rvirá n
a l p ro g ra m a d o r d e e ste le ng ua je a e nte nd e r m e jo r la e struc tura p a ra c re a r un
p ro g ra m a e n Ja va d e m a ne ra e xito sa .
• La sinta xis e s m uy p a re c id a a C ++ y la s p a la b ra s c la ve so n
la s m ism a s e limina nd o a lg una s e n d e suso y a ña d ie nd o o tra s
p a ra re a liza r c o sa s c a ra c te rístic a s d e Ja va .
• En Ja va e s ha b itua l utiliza r no m b re s c o n m inúsc ula s p a ra
va ria b le s sie m p re y c ua nd o no se d e n a lg una s d e la s
sig uie nte s situa c io ne s:
o El no m b re c o nsta de va ria s p a la b ra s y
no rm a lm e nte se p o ne una d e trá s d e o tra c o n la
p rim e ra le tra d e c a d a p a la b ra e n m a yúsc ula s:
Ej. e lMa yo r.
o Lo s no m b re s d e c la se s e inte rfa c e s c o m ie nza n

sie m p re p o r m a yúsc ula s: Ej. G e o m e tría .
o Lo s no m b re s d e o b je to s, m é to d o s, va ria b le s
m ie m b ro y va ria b le s lo c a le s d e lo s m é to d o s
c o m ie nza n sie m p re p o r m inúsc ula .
o Lo s no m b re s de la s va ria b le s fina le s, o
c o nsta nte s, se d e fine n sie m p re c o n m a yúsc ula s:
Ej. PI.
o To d a s la s va ria b le s e n Ja va so n re fe re nc ia s y la
utiliza c ió n d e la m e m o ria a so c ia d a a é sta s y a
lo s o b je to s q ue se m a ne ja n e s una func ió n d e l
re c o le c to r d e b a sura .
• Lo s fic he ro s d e c ó d ig o d e b e n te ne r la e xte nsió n ja va y
te nd rá n e l m ism o no m b re q ue la c la se p rinc ip a l q ue
c o ntie ne n. Esto s fic he ro s p ue d e n c o nte ne r m á s d e una
c la se , p e ro só lo una d e e lla s se rá una c la se p úb lic a y se
d e no m ina c la se p rinc ip a l.
• Lo s fic he ro s ya c o m p ila d o s tie ne n la e xte nsió n c la ss y e xiste
sie m p re un fic he ro d e e ste tip o p o r c la se .
• Una a p lic a c ió n e stá c o m p ue sta p o r uno o va rio s fic he ro s
c la ss p e rm itie nd o a sí m o d ula riza r c a d a una d e la s p a rte s d e
la a p lic a c ió n e n fic he ro s. La e je c uc ió n d e una a p lic a c ió n
c o m ie nza sie m p re p o r una c la se q ue c o ntie ne la func ió n
ma in() sin a ña d ir la e xte nsió n c la ss.
• En Ja va to d a s la s c la se s he re d a n, a unq ue no se e sp e c ifiq ue
e xp líc ita me nte d e la c la se g e ne ra l O b je c t q ue ha c e d e ra íz
d e to d a la je ra rq uía d e c la se s d e Ja va . Lo s m é to d o s q ue
d e fine la c la se o b je c t so n d e d o s c la se s, m é to d o s q ue se
p ue d e n re d e finir p o r e l p ro g ra m a d o r, c lo ne (), e q ua ls(),
to String (), fina lize () y m é to d o s q ue no p ue d e n se r re d e finid o s,
so n m é to d o s fina l c o m o g e tC la ss(), no tify(), no tifyAll()
a unq ue lo s tre s último s e stá n re la c io na d o s c o n la s he b ra s,
thre a ds.

• Ja va e s un le ng ua je fue rte m e nte tip ific a d o y la c o nve rsió n

e ntre re fe re nc ia s d e c la se s d ife re nte s e xig e q ue a m b a s
c la se s e sté n re la c io na d a s m e d ia nte he re nc ia o m e d ia nte la
im p le m e nta c ió n d e un inte rfa z e n e l c a so de q ue la
re fe re nc ia se a d e un tip o inte rfa c e .
• La s c la se s Ja va se a g rup a n e n p a c ka g e s a lo s q ue se
p ue d e n d e finir c o m o lib re ría s d e c la se s. Si se d e c la ra una
c la se sin p a c ka g e se c o nsid e ra n p e rte ne c ie nte s a un
p a c ka g e p o r d e fe c to , de fa ult q ue e s e l d ire c to rio a c tua l.
Ja va p ro p o rc io na un c o njunto d e p a q ue te s a l q ue se
d e no m ina API. El no m b re d e lo s p a q ue te s sue le se r un
no m b re e n m inúsc ula s y p ue d e c o nsta r d e va rio s no m b re s
unid o s p o r p unto s. To d a s la s c la se s q ue e stá n e n e l m ism o
p a q ue te d e b e n e sta r e n e l m ism o d ire c to rio . Lo s no m b re s
c o m p ue sto s d e lo s p a q ue te s e stá n re la c io na d o s c o n la
je ra rq uía d e d ire c to rio s e n q ue se g ua rd a n la s c la se s. Lo s
p a q ue te s se utiliza n p a ra a lm a c e na r c la se s re la c io na d a s,
e vita r c o nflic to s d e no m b re s y a yud a r a la a c c e sib ilid a d d e
la s c la se s. La inc lusió n d e una c la se e n un p a q ue te se ha c e
m e d ia nte la se nte nc ia p a c ka g e q ue se inc luye e n la p rim e ra
líne a d e l fic he ro ja va q ue c o ntie ne la c la se . la se nte nc ia
imp o rt se g uid a d e l no m b re d e un p a q ue te m á s e l no m b re
d e una c la se d e e se p a q ue te , ind ic a q ue c la se se utiliza rá
e n e se fic he ro c ua nd o se invo q ue a un o b je to d e la c la se
im p o rta d a .
• Al c o ntra rio d e C ++, Ja va no utiliza d e struc to re s, sino q ue
o p c io na lm e nte e l usua rio p ue d e inc luir n m é to d o q ue se
e je c uta rá c ua nd o e l o b je to va ya a se r re c ic la d o , e s e l
m é to d o fina lize () .

El interprete de Java
Ja va , p a ra c o nse g uir se r un le ng ua je ind e p e nd ie nte d e l siste m a

o p e ra tivo y d e l p ro c e sa d o r q ue inc o rp o re la m á q uina utiliza d a , e s ta nto
inte rp re ta d o c o m o c o m p ila d o . El c ó d ig o fue nte e sc rito c o n c ua lq uie r e d ito r se
c o m p ila g e ne ra nd o e l Byte C o d e . Este c ó d ig o inte rm e d io e s d e m uy b a jo nive l,
p e ro sin a lc a nza r la s instruc c io ne s m á q uina p ro p ia s d e c a d a p la ta fo rm a y no
tie ne na d a q ue ve r c o n e l p -c o d e d e Visua l Ba sic .
El Byte C o d e c o rre sp o nd e al 80% de la s
instruc c io ne s d e la a p lic a c ió n. Ese m ism o c ó d ig o
e s e l q ue se p ue d e e je c uta r so b re c ua lq uie r
p la ta fo rm a . Pa ra e llo ha c e fa lta e l runtim e , q ue sí
e s c o m p le ta m e nte d e p e nd ie nte d e la m á q uina y
del siste m a o p e ra tivo q ue inte rp re ta
d iná m ic a m e nte e l Byte C o d e y a ña d e e l 20% d e
instruc c io ne s q ue fa lta b a n p a ra su e je c uc ió n.
C o n e ste siste m a e s fá c il c re a r a p lic a c io ne s
m ultip la ta fo rm a , p e ro p a ra e je c uta rla s es
ne c e sa rio q ue e xista e l runtim e c o rre sp o nd ie nte
a l siste m a o p e ra tivo utiliza d o .
No o b sta nte , e ste p a no ra m a e stá c a m b ia nd o a p a so s a g ig a nta d o s, y

a unq ue Ja va sig ue sie nd o b á sic a m e nte un le ng ua je inte rp re ta d o , la situa c ió n
se a c e rc a m uc ho a la d e lo s p ro g ra m a s c o m p ila d o s, so b re to d o e n lo q ue a la
ra p id e z e n la e je c uc ió n d e l c ó d ig o se re fie re . Pa ra c o m p re nd e r e l
func io na m ie nto d e Ho tSp o t, q ue e s e l últim o la nza m ie nto q ue ha c e Sun y q ue
p ro m e te inte rp re ta r lo s Byte C o d e s m á s rá p id o q ue un p ro g ra m a c o m p ila d o ,
la s sig uie nte s im á g e ne s m ue stra n c ó m o a c túa e l siste m a runtim e e n lo s d ive rso s
c a so s q ue ha sta a ho ra p ue d e n d a rse .
La im a g e n d e la izq uie rd a m ue stra la s a c c io ne s c o rre sp o nd ie nte s a un

c o m p ila d o r tra d ic io na l. El c o m p ila d o r tra sla d a la s se nte nc ia s e sc rita s e n
le ng ua je d e a lto -nive l a m últip le s instruc c io ne s, q ue lue g o so n e nla za d a s junto

c o n e l re sulta d o d e m últip le s c o m p ila c io ne s p re via s q ue ha n d a d o o rig e n a

lib re ría s, y junta nd o to d o e llo , e s c ua nd o g e ne ra un
p ro g ra m a e je c uta b le .
La im a g e n d e la d e re c ha m ue stra la fo rm a de
a c tua c ió n d e un inté rp re te . Bá sic a m e nte e s un e no rm e
b uc le , e n e l c ua l se va le ye nd o o re c o g ie nd o c a d a una d e
la s instruc c io ne s d e l p ro g ra m a fue nte q ue se d e se a e je c uta r,
se a na liza , se p a rte e n tro zo s y se e je c uta . Lue g o se va a
re c o g e r la sig uie nte instruc c ió n q ue se d e b e inte rp re ta r y se
c o ntinúa c o n e ste p ro c e so ha sta q ue se te rm ina n la s
instruc c io ne s o ha sta q ue e ntre la s instruc c io ne s ha y
a lg una q ue c o ntie ne la o rd e n d e d e te ne r la
e je c uc ió n d e la s instruc c io ne s q ue c o m p o ne n e l
p ro g ra m a fue nte .
La im a g e n sig uie nte , situa d a a la izq uie rd a , m ue stra

un tip o d e inté rp re te m á s e fic ie nte q ue e l a nte rio r,
e l inté rp re te d e Byte C o d e s, q ue fue p o p ula riza d o
ha c e m á s d e ve inte a ño s p o r la Unive rsid a d d e
C a lifo rnia a l c re a r e l UC SD Pa sc a l. En e ste c a so , e l
inté rp re te tra b a ja so b re instruc c io ne s q ue ya ha n
sid o tra sla d a d a s a un c ó d ig o inte rm e d io e n un p a so
a nte rio r. Así, a unq ue se e je c ute e n un b uc le , se
e limina la ne c e sid a d d e a na liza r c a d a una d e la s
instruc c io ne s q ue c o m p o ne n e l p ro g ra m a fue nte ,
p o rq ue ya lo ha n sid o e n e l p a so p re vio . Este e s e l siste m a q ue Ja va utiliza , y la
Má q uina Virtua l Ja va e s un e je m p lo d e e ste tip o d e inté rp re te . No o b sta nte ,
sig ue sie nd o le nto , a unq ue se o b te ng a un c ó d ig o ind e p e nd ie nte de
p la ta fo rm a m uy c o m p a c to , q ue p ue d e se r e je c uta d o en c ua lq uie r
o rd e na d o r q ue d isp o ng a d e una m á q uina virtua l c a p a z d e inte rp re ta r lo s
Byte C o d e s tra sla d a d o s.

Un p a so a d e la nte e n e l re nd im ie nto d e l c ó d ig o
Ja va lo ha n re p re se nta d o lo s c o m p ila d o re s Just-In-
Tim e , q ue c o m p ila n e l c ó d ig o c o nvirtié nd o lo a c ó d ig o
m á q uina a nte s d e e je c uta rlo . Es d e c ir, un c o m p ila d o r
JIT va tra sla d a nd o lo s Byte C o d e s a l c ó d ig o m á q uina
d e la p la ta fo rm a se g ún lo s va le ye nd o , re a liza nd o un
c ie rto g ra d o d e o p tim iza c ió n. El re sulta d o e s q ue
c ua nd o e l p ro g ra m a se e je c ute , ha b rá p a rte s q ue no
se e je c ute n y q ue no se rá n c o m p ila d a s, y el
c o m p ila d o r JIT no p e rd e rá e l tie m p o e n o p tim iza r
c ó d ig o q ue nunc a se va a e je c uta r. No o b sta nte , lo s
c o m p ila d o re s JIT no p ue d e n re a liza r d e m a sia d a s
o p tim iza c io ne s, ya q ue ha y c ó d ig o q ue e llo s no ve n,
a sí q ue a unq ue sie m p re so n c a p a c e s d e o p tim iza r la p a rte d e c ó d ig o d e
inic ia liza c ió n d e un p ro g ra m a , ha y o tra s p a rte s q ue d e b e n se r o p timiza d a s,
se g ún se va n c a rg a nd o , c o n lo c ua l, ha y una c ie rta c a ntid a d d e tie m p o q ue
ine vita b le m e nte ha d e p e rd e rse .
Y, fina lm e nte , se p re se nta la últim a te nd e nc ia e n lo q ue a c o m p ila c ió n e

inté rp re te s se re fie re . Lo últim o e n q ue tra b a ja Sun e s Ho tSp o t, una he rra m ie nta
q ue inc luye un c o m p ila d o r
d iná m ic o y una m á q uina virtua l
p a ra inte rp re ta r lo s Byte C o d e s, ta l
c o mo se m ue stra en la fig ura
sig uie nte , situa d a a la izq uie rd a d e
la p á g ina . C ua nd o se c a rg a n lo s
Byte C o d e s p ro d uc id o s po r el
c o m p ila d o r p o r p rim e ra ve z, é sto s
so n inte rp re ta d o s e n la m á q uina
virtua l. C ua nd o ya e stá n en
e je c uc ió n, el p ro file r m a ntie ne
info rm a c ió n so b re e l re nd imie nto y
se le c c io na e l m é to d o so b re e l q ue
se va a re a liza r la c o m p ila c ió n. Lo s m é to d o s ya c o m p ila d o s se a lm a c e na n e n

un c a c hé e n c ó d ig o m á q uina na tivo . C ua nd o un m é to d o e s invo c a d o , e sta

ve rsió n e n c ó d ig o m á q uina na tivo e s la q ue se utiliza , e n c a so d e q ue e xista ;
e n c a so c o ntra rio , lo s Byte C o d e s so n re inte rp re ta d o s. La func ió n c o ntro l q ue
m ue stra e l d ia g ra m a e s c o m o un sa lto ind ire c to a tra vé s d e la m e m o ria q ue
a p unta ta nto a l c ó d ig o m á q uina c o m o a l inte rp re ta d o , a unq ue Sun no ha
p ro p o rc io na d o m uc ho s d e ta lle s so b re e ste e xtre m o .
Diferencias y similitudes con C++
Ja va no so p o rta typ e d e fs, d e fine s o c o m a nd o s d e p re p ro c e sa d o r. Al no

e xistir un p re p ro c e sa d o r, no e stá p re vista la inc lusió n d e fic he ro s d e c a b e c e ra ,
ta m p o c o tie ne c a b id a e l c o nc e p to d e m a c ro o c o nsta nte . Sin e m b a rg o , sí se
p e rm ite c ie rto uso d e c o nsta nte s e num e ra d a s a tra vé s d e la utiliza c ió n d e la
p a la b ra c la ve fina l. Ja va ta m p o c o so p o rta e num s, a unq ue so p o rte c o nsta nte s
e num e ra d a s, c o m o a c a b o d e d e c ir.
Ja va so p o rta c la se s, p e ro no so p o rta e struc tura s o unio ne s.
To d a s la s a p lic a c io ne s C ++ ne c e sita n una func ió n d e e ntra d a lla m a d a

m a in() y p ue d e ha b e r m ultitud d e o tra s func io ne s, ta nto func io ne s m ie mb ro s
d e una c la se c o m o func io ne s ind e p e nd ie nte s. En Ja va no ha y func io ne s
ind e p e nd ie nte s, a b so luta m e nte to d a s la s func io ne s ha n d e se r m ie m b ro s d e
a lg una c la se (m é to d o s). Func io ne s g lo b a le s y d a to s g lo b a le s e n Ja va no e stá n
p e rm itid o s.
En C ++ se p ue d e n c re a r á rb o le s d e he re nc ia d e c la se s ind e p e nd ie nte s
uno s d e o tro s. En Ja va e sto no e s p o sib le , e n últim a insta nc ia ha y una c la se
O b je c t, d e la q ue he re d a to d o lo q ue e l p ro g ra m a d o r c re e .
To d a s la s func io ne s o d e finic io ne s d e m é to d o s e n Ja va d e b e n e sta r

c o nte nid o s d e ntro d e la d e finic ió n d e la c la se . Pa ra un p ro g ra m a d o r C ++
p ue d e p a re c e rle q ue e sto e s se m e ja nte a la s func io ne s inline , p e ro no e s a sí.
Ja va no p e rm ite , a l m e no s d ire c ta m e nte , q ue e l p ro g ra m a d o r p ue d a d e c la ra r
func io ne s inline .

Ta nto Ja va c o m o C ++ so p o rta n func io ne s o m é to d o s (e stá tic o s) d e

c la se s, q ue p ue d e n se r invo c a d o s sin ne c e sid a d d e te ne r q ue insta nc ia r
ning ún o b je to d e la c la se .
En Ja va se intro d uc e e l c o nc e p to d e inte rfa c e , q ue no e xiste e n C ++.

Una inte rfa c e se utiliza p a ra c re a r una c la se b a se a b stra c ta q ue c o nte ng a
so la m e nte la s c o nsta nte s y la s d e c la ra c io ne s d e lo s m é to d o s d e la c la se . No se
p e rm ite q ue ha ya va ria b le s m ie m b ro ni d e finic io ne s d e m é to d o s. Ad e m á s, e n
Ja va ta m b ié n se p ue d e n c re a r ve rd a d e ra s c la se s a b stra c ta s.
Ja va no so p o rta he re nc ia m últip le , a unq ue se p ue d e n utiliza r la s

p o sib ilid a d e s q ue o fre c e e l uso d e inte rfa c e s p a ra e m p le a r la s ve nta ja s q ue
o fre c e la he re nc ia m últip le , e vita nd o lo s inc o nve nie nte s q ue se d e riva n d e su
uso . La he re nc ia sim p le e s simila r e n Ja va y e n C ++, a unq ue la fo rm a e n q ue se
im p le m e nta e s b a sta nte d ife re nte , e sp e c ia lm e nte e n lo q ue re sp e c ta a la
utiliza c ió n d e lo s c o nstruc to re s e n la c a d e na d e he re nc ia .
Ja va no so p o rta la se nte nc ia g o to , a unq ue se a una p a la b ra re se rva d a .

Sin e m b a rg o , so p o rta la s se nte nc ia s b re a k y c o ntinue c o n e tiq ue ta s, q ue no
e stá n so p o rta d a s p o r C ++. Ba jo c ie rta s c irc unsta nc ia s, e sta s se nte nc ia s
e tiq ue ta d a s se p ue d e n utiliza r c o m o un g o to e nc ub ie rto .
Ja va no so p o rta la so b re c a rg a d e o p e ra d o re s, a unq ue la utilic e

inte rna m e nte , p e ro no e stá d isp o nib le p a ra e l p ro g ra m a d o r. Ta m p o c o so p o rta
la c o nve rsió n a uto m á tic a d e tip o s, e xc e p to e n la s c o nve rsio ne s se g ura s.
Al c o ntra rio q ue C ++, Ja va d isp o ne d e un tip o String y lo s o b je to s d e

e ste tip o no p ue d e n m o d ific a rse . La c a d e na s q ue se e nc ue ntre n d e finid a s
e ntre c o m illa s d o b le s so n c o nve rtid a s a uto m á tic a m e nte a o b je to s String . Ja va
ta m b ié n d isp o ne d e l tip o String Buffe r, c uyo s o b je to s sí se p ue d e n m o d ific a r, y
a d e m á s se p ro p o rc io na n una se rie d e m é to d o s p a ra p e rm itir la m a nip ula c ió n
d e c a d e na s d e e ste tip o .

Al c o ntra rio q ue C ++, Ja va tra ta a lo s a rra ys c o m o o b je to s re a le s.

Disp o ne n d e un m ie m b ro , le ng th, q ue ind ic a la lo ng itud d e l a rra y. Se g e ne ra
una e xc e p c ió n c ua nd o se inte nta so b re p a sa r e l lím ite ind ic a d o p o r e sta
lo ng itud . To d o s lo s a rra ys so n insta nc ia d o s e n m e m o ria d iná m ic a y se p e rm ite
la a sig na c ió n d e un a rra y a o tro ; sin e m b a rg o , c ua nd o se re a liza una
a sig na c ió n, sim p le m e nte te ne m o s d o s re fe re nc ia s a un m ism o a rra y, no ha y
d o s c o p ia s d e l a rra y, p o r lo q ue si se a lte ra un e le m e nto d e un a rra y, ta m b ié n
se a lte ra rá e n e l o tro . A d ife re nc ia d e C ++, e l te ne r d o s "p unte ro s" o re fe re nc ia s
a un m ism o o b je to e n m e m o ria d iná m ic a no re p re se nta ne c e sa ria m e nte un
p ro b le m a (a unq ue sí p ue d e p ro vo c a r re sulta d o s imp re visto s). En Ja va , la
m e m o ria d iná mic a e s lib e ra d a a uto m á tic a m e nte , p e ro e sta lib e ra c ió n no se
lle va a c a b o ha sta q ue to d a s la s re fe re nc ia s a e sa m e m o ria so n NULL o d e ja n
d e e xistir. Po r ta nto , a d ife re nc ia d e C ++, una zo na d e m e m o ria d iná m ic a
nunc a p ue d e se r invá lid a m ie ntra s e sté sie nd o re fe re nc ia d a p o r a lg una
va ria b le .
Ja va no so p o rta p unte ro s, a l m e no s e n e l se ntid o q ue a trib uye C ++, e s

d e c ir, no p e rm ite m o d ific a r e l c o nte nid o d e una zo na d e m e m o ria a p unta d a
p o r un p unte ro , o re a liza r o p e ra c io ne s a ritm é tic a s c o n p unte ro s. La m a yo r
ne c e sid a d d e uso d e p unte ro s d e riva d e la utiliza c ió n d e c a d e na s y a rra ys, y
e sto se e vita a l se r o b je to s d e p rim e ra c la se e n Ja va . Po r e je m p lo , la
d e c la ra c ió n im p re sc ind ib le e n C ++, c ha r *p unte ro , p a ra re fe re nc ia r a l p rim e r
e le m e nto d e una c a d e na no se ne c e sita e n Ja va , a l se r la c a d e na un o b je to
String .
La d e finic ió n d e c la se e s se m e ja nte e n Ja va y C ++, a unq ue e n Ja va no

e s ne c e sa rio e l p unto y c o m a (;) fina l. El o p e ra d o r d e á m b ito (::) ne c e sa rio e n
C ++ no se usa e n Ja va , sino q ue se utiliza e l p unto (.) p a ra c o nstruir re fe re nc ia s.
Y, c o m o no ha y so p o rte d e p unte ro s, e l o p e ra d o r fle c ha (->) ta m p o c o e stá
so p o rta d o e n Ja va . En C ++, la s func io ne s y d a to s m ie m b ro s se invo c a n
utiliza nd o e l no m b re d e la c la se y e l no m b re d e l m ie m b ro e stá tic o c o ne c ta d o s
p o r e l o p e ra d o r d e á m b ito . En Ja va , se utiliza e l p unto (.) p a ra c o nse g uir e l
m ism o p ro p ó sito .

Al ig ua l q ue C ++, Ja va d isp o ne d e tip o s p rimitivo s c o m o int, flo a t, e tc .

Pe ro , a l c o ntra rio de C ++, lo s ta m a ño s d e e sto s tip o s so n ig ua le s
ind e p e nd ie nte m e nte d e la p la ta fo rm a e n q ue se e sté n utiliza nd o . No ha y tip o s
sin sig no e n Ja va , y la c o m p ro b a c ió n d e tip o s e s m uc ho m á s re stric tiva e n
Ja va q ue e n C ++. Ja va d isp o ne d e un tip o b o o le a n ve rd a d e ro .
La s e xp re sio ne s c o nd ic io na le s e n Ja va se e va lúa n a b o o le a no e n ve z
d e a e nte ro c o m o e n e l c a so d e C ++. Es d e c ir, e n Ja va no se p e rm ite n
se nte nc ia s d e l tip o if( x+y ), p o rq ue la e xp re sió n q ue va d e ntro d e l p a ré nte sis
no se e va lúa a b o o le a no .
El tip o c ha r e n C ++ e s un tip o d e 8 b its q ue m a p e a e l c o njunto

c o m p le to d e c a ra c te re s ASC II. En Ja va , e l tip o c ha r e s d e 16 b its y utiliza e l se t
d e c a ra c te re s Unic o d e (lo s c a ra c te re s d e l 0 a l 127 d e l se t Unic o d e , c o inc id e n
c o n e l se t ASC II).
Al c o ntra rio q ue e n C ++, e l o p e ra d o r d e sp la za m ie nto (>>) e s un

o p e ra d o r c o n sig no , inse rta nd o e l b it d e sig no e n la p o sic ió n va c ía . Po r e llo ,
Ja va inc o rp o ra e l o p e ra d o r >>>, q ue inse rta c e ro s e n la s p o sic io ne s q ue va n
q ue d a nd o va c ía s tra s e l d e sp la za m ie nto .
C ++ p e rm ite la insta nc ia c ió n d e va ria b le s u o b je to s d e c ua lq uie r tip o e n

tie m p o d e c o m p ila c ió n so b re m e m o ria e stá tic a o , e n tie m p o d e e je c uc ió n,
so b re m e m o ria d iná m ic a . Sin e m b a rg o , Ja va re q uie re q ue to d a s la s va ria b le s
d e tip o s p rimitivo s se a n insta nc ia d a s e n tie m p o d e c o m p ila c ió n, y to d o s lo s
o b je to s se a n insta nc ia d o s e n m e m o ria d iná m ic a e n tie m p o d e e je c uc ió n. Ja va
p ro p o rc io na c la se s d e e nvo ltura p a ra to d o s lo s tip o s p rimitivo s, e xc e p to p a ra
b yte y sho rt, q ue p e rm ite n q ue e sto s tip o s p rimitivo s p ue d a n se r insta nc ia d o s e n
m e m o ria d iná m ic a c o m o o b je to s e n tie m p o d e e je c uc ió n, si fue se ne c e sa rio .
C ++ re q uie re q ue la s c la se s y func io ne s e sté n d e c la ra d a s a nte s d e

utiliza rla s p o r p rim e ra ve z. Esto no e s ne c e sa rio e n Ja va . C ++ ta m b ié n re q uie re
q ue lo s m ie m b ro s e stá tic o s d e una c la se se re d e c la re n fue ra d e la c la se . Esto
ta m p o c o e s ne c e sa rio e n Ja va .

En C ++, si no se ind ic a n va lo re s d e inic ia liza c ió n p a ra la s va ria b le s d e

tip o s p rimitivo s, p ue d e n c o nte ne r b a sura . Aunq ue la s va ria b le s lo c a le s d e tip o s
p rimitivo s se p ue d e n inic ia liza r e n la d e c la ra c ió n, lo s d a to s m ie m b ro s d e tip o
p rimitivo d e una c la se no se p ue d e n inic ia liza r e n la d e finic ió n d e la c la se . En
Ja va , se p ue d e n inic ia liza r e sto s d a to s m ie m b ro s d e tip o p rimitivo e n la
d e c la ra c ió n d e la c la se . Ta m b ié n se p ue d e n inic ia liza r e n e l c o nstruc to r. Si la
inic ia liza c ió n no se re a liza e xp líc ita m e nte , o fa lla p o r lo q ue se a , lo s d a to s so n
inic ia liza d o s a c e ro (o su e q uiva le nte ) a uto m á tic a m e nte .
Al ig ua l q ue o c urre e n C ++, Ja va ta m b ié n so p o rta c o nstruc to re s q ue

p ue d e n se r so b re c a rg a d o s. Y, d e l m ism o m o d o q ue suc e d e e n C ++, si no se
p ro p o rc io na un c o nstruc to r e xp líc ita m e nte , e l siste m a p ro p o rc io na un
c o nstruc to r p o r d e fe c to .
En Ja va to d o s lo s o b je to s se p a sa r p o r re fe re nc ia , e limina nd o la
ne c e sid a d d e l c o nstruc to r c o p ia utiliza d o e n C ++. No ha y d e struc to re s e n
Ja va . La m e m o ria q ue no se utiliza e s d e vue lta a l Siste m a a tra vé s d e l
re c ic la d o r d e m e m o ria , q ue se e je c uta e n un thre a d d ife re nte a l d e l p ro g ra m a
p rinc ip a l. Esta e s una d e la s d ife re nc ia s e xtre m a d a m e nte im p o rta nte s e ntre
C ++ y Ja va .
C o m o C ++, Ja va ta m b ié n so p o rta la so b re c a rg a d e func io ne s. Sin

e m b a rg o , e l uso d e a rg um e nto s p o r d e fe c to no e stá so p o rta d o e n Ja va . Al
c o ntra rio q ue C ++, Ja va no so p o rta te m p la te s, p o r lo q ue no e xiste n func io ne s
o c la se s g e né ric a s.
El m ultithre a d ing , o m ultihilo , e s a lg o c a ra c te rístic o de Ja va , q ue se

p ro p o rc io na p o r d e fe c to .
Aunq ue Ja va utiliza la s m ism a s p a la b ra s c la ve q ue C ++ p a ra ind ic a r e l

c o ntro l d e a c c e so : p riva te , p ub lic y p ro te c te d , la inte rp re ta c ió n es
sig nific a tiva m e nte d ife re nte e ntre C ++ y Ja va .

La im p le m e nta c ió n d e l m a ne jo d e e xc e p c io ne s e n Ja va e s m á s
c o m p le to y b a sta nte d ife re nte a l e m p le a d o e n C ++.
Al c o ntra rio q ue C ++, Ja va no so p o rta la so b re c a rg a d e o p e ra d o re s. No

o b sta nte , lo s o p e ra d o re s + y += so n so b re c a rg a d o s a uto m á tic a m e nte p a ra
c o nc a te na r c a d e na s, o p a ra c o nve rtir o tro s tip o s a c a d e na s.
C o mo e n C ++, la s a p lic a c io ne s Ja va p ue d e n ha c e r lla m a d a s a

func io ne s e sc rita s e n o tro s le ng ua je s, lla m a d a s m é to d o s na tivo s. No o b sta nte ,
lo s a p p le ts no p ue d e n ha c e r lla m a d a s a m é to d o s na tivo s.
A d ife re nc ia d e C ++, Ja va d isp o ne d e un siste m a inte rno d e g e ne ra c ió n

d e d o c um e nta c ió n. Si se utiliza n c o m e nta rio s e sc rito s d e d e te rm ina d a fo rm a ,
se p ue d e utiliza r la he rra m ie nta ja va d o c p a ra g e ne ra r la d o c um e nta c ió n d e la
a p lic a c ió n Ja va , e inc luso se p ue d e n p ro g ra m a r d o c le ts p a ra g e ne ra r tip o s
e sp e c ífic o s d e d o c um e nta c ió n.
Clases útiles
Lo m e jo r p a ra c o no c e r la s c la se s m á s útile s e s p o ne rse a p ro g ra m a r.
Pa ra a yud a r a l p rinc ip io d e e ste la rg o c a m ino , se m ue stra la sig uie nte ta b la :
Arra ys
d o ub le [] x = ne w d o ub le [100];
(ve c to re s)
Arra ys
int[][] y = ne w int[3][4];
b id im e nsio na le s
int [][] b ={{1,2,3},{4,5,6}};
(m a tric e s)
String p a ra c a d e na s inva ria b le s.
(c a d e na s) String s = ne w String (...);/ / ve r d o c um e nta c ió n.
So n la s c la se s d ise ña d a s p a ra c o m p le m e nto d e lo s
Wra p p e rs tip o s p rimitivo s y NO so n o b je to s. Lo s w ra p p e rs so n Byte ,
Sho rt, Inte g e r, Lo ng , Flo a t y Do ub le
Pro p o rc io na m é to d o s sta tic p a ra re a liza r o p e ra c io ne s
ja va .la ng .Ma th m a te m á tic a s.
Ma th.ra nd o m ()
Una c o le c c ió n no e s m á s q ue un c o njunto d e o b je to s
q ue se a g rup a n, c ua lq uie r c o le c c ió n se id e ntific a p o r
C o le c c io ne s
e l inte rfa z, C o lle c tio n
So n c o le c c io ne s la s c la se s ja va .util.Ve c to r,

ja va .util.Ha shSe t, ... y ta m b ié n so n c o le c c io ne s lo s

inte rfa c e s ja va .util.List, ja va .util.Ma p , ...
-C o lle c tio n d e fine m é to d o s p a ra tra ta r una c o le c c ió n

g e né ric a d e e le m e nto s.
-Se t C o le c c ió n d e e le m e nto s q ue no a d m ite
re p e tic ió n.
-So rte dSe t e s un Se t o rd e na d o se g ún un c rite rio
e sta b le c id o .
-List a d m ite e le m e nto s re p e tid o s y m a ntie ne e l o rd e n
d e inse rc ió n.
-Ma p C o njunto d e p a re s, c la ve / va lo r, sin re p e tic ió n d e
c la ve s.
-So rte dMa p e s un Ma p o rd e na d o se g ún un c rite rio
e sta b le c id o .
-Ite ra to r Inte rfa z d e so p o rte utiliza d o p a ra re c o rre r una
c o le c c ió n y p a ra b o rra r e le m e nto s.
-ListIte ra to r inte rfa z d e so p o rte q ue p e rm ite re c o rre r List
e n a m b o s se ntid o s.
-C o mp a ra b le inte rfa z d e so p o rte q ue d e c la ra e l
m é to d o c o mp a re To () q ue p e rm ite o rd e na r la s
d ife re nte s c o le c c io ne s se g ún un o rd e n na tura l.
-C o mp a ra to r inte rfa z d e so p o rte q ue d e c la ra e l
m é to d o c o mp a re () y se utiliza e n lug a r d e
C o mp a ra b le c ua nd o se d e se a o rd e na r o b je to s no
e stá nd a r o sustituir a d ic ha inte rfa c e .
AWT e s Ab stra c t Windo ws To o lkit y e s la p a rte d e Ja va
q ue se o c up a d e c o nstruir inte rfa c e s g rá fic a s. Pa ra
c o nstruir una inte rfa z, se ne c e sita n a l m e no s tre s
e le m e nto s, un c o nte ne d o r, uno s c o m p o ne nte s y un
m o d e lo d e e ve nto s.
El c o nte ne d o r e s la ve nta na o p a rte d e la ve nta na
d o nd e se sitúa n lo s c o m p o ne nte s.
ja va .a w t
Lo s c o m p o ne nte s so n m e nús, b o to ne s, b a rra s d e
d e sp la za m ie nto , c a ja s y á re a s d e te xto , e tc , e tc .
El m o d e lo d e e ve nto s e s la he rra m ie nta q ue no s
p e rm ite c o ntro la r la s a c c io ne s d e l usua rio so b re lo s
c o m p o ne nte s. C a d a ve z q ue e l usua rio re a liza una
a c c ió n se p ro d uc e un e ve nto y AWT c re a un o b je to d e
la c la se d e e ve nto c o rre sp o nd ie nte d e riva d a d e

AWTEve nt. El e ve nto se rá p o ste rio rm e nte g e stio na d o

p o r un o b je to q ue d e b e c o no c e r e l c o m p o ne nte q ue
ha re c ib id o e l e ve nto . Así se d ife re nc ia n d o s tip o s
b á sic o s d e o b je to s, lo s q ue re c ib e n lo s e ve nto s, o
e ve nt so urc e y lo s q ue m a ne ja n lo s e ve nto s e ve nt
liste ne r.
Lo s o b je to s e ve nt so urc e d e b e n "re g istra r" lo s o b je to s
q ue ha b rá n d e g e stio na r sus e ve nto s. Lo s o b je to s e ve nt
liste ne rs d e b e n im p le m e nta r lo s m é to d o s a d e c ua d o s
p a ra m a ne ja r un e ve nto d e te rm ina d o y la fo rm a m á s
se nc illa d e c o ntro la r e sto e s im p le m e nta r e l inte rfa z
Liste ne r d e la fo rm a a d e c ua d a .
e ve ntSo urc e O b je c t.a d d Eve ntListe ne r(e ve ntListe ne rO b j
e c t);
Lo s thre a d s o hilo s d e e je c uc ió n p e rm ite n o rg a niza r lo s
re c urso s d e l o rd e na d o r d e fo rm a q ue p ue d a ha b e r
va rio s p ro g ra m a s a c tua nd o e n p a ra le lo . Un hilo d e
e je c uc ió n re a liza rá la s a c c io ne s ind ic a d a s e n e l
m é to d o run() .
p ub lic c la ss Sim p le Thre a d e xte nd s Thre a d {

p ub lic Sim p le Thre a d (String na m e ){
Thre a d s
sup e r(na m e );
}
p ub lic vo id run(){
fo r(int i=0;i<10;i++) Syste m .o ut.p rintln("Este e s e l thre a d "
+ g e tna m e ());
}
}
Una e xc e p c ió n e s la he rra m ie nta d e la q ue d isp o ne e l

p ro g ra m a d o r p a ra c o ntro la r lo s p o sib le s e rro re s. Una
e xc e p c ió n ind ic a q ue una situa c ió n inusua l se ha d a d o
y e l c o ntro l d e l p ro g ra m a ha sid o a uto m á tic a m e nte
tra nsfe rid o , thro wn, a una se c c ió n d e c ó d ig o e sp e c ia l
d o nd e se va a m a ne ja r.
La s e xc e p c io ne s e stá n o rg a niza d a s e n una je ra rq uía
q ue p a rte d e la c la se ja va .la ng .Exc e p tio n y lo s e rro re s
Exc e p tio ns
tip ific a d o s e stá n o rg a niza d o s a p a rtir d e la c la se
ja va .la ng .Erro r. La d ife re nc ia e ntre e xc e p c io ne s y
e rro re s so n q ue la s p rim e ra s so n re c up e ra b le s m ie ntra s
q ue lo s e rro re s no lo so n.
El m a ne jo d e e xc e p c io ne s se re a liza m e d ia nte
try/c a tc h/fina lly .
La s e xc e p c io ne s se la nza n m e d ia nte thro w , thro w ne w
Exc e p tio n().

Lenguaje Java
Variables y Constantes
b o o le a n, c ha r, b yte , sho rt, int, lo ng , flo a t y

Tip o s Primitivo s d e Va ria b le s
d o ub le
C re a c ió n Se c re a n ig ua l q ue e n C . p o r e je m p lo : int i;
Inic ia liza c ió n Se inic ia liza n c o n una a sig na c ió n. int i = 1;
e xiste n c o nsta nte s e n d e c im a l, e n o c ta l y e n
he xa d e c ima l.
C o nsta nte s int i = 123; / / d e c im a l
int i = 0123; / / o c ta l
int i = 0x123; / / he xa d e c im a l
La s va ria b le s d e tip o s b á sic o s y la s c o nsta nte s so n utiliza d a s c o m o

va ria b le s y c o nsta nte s tra d ic io na le s e n C . C ua nd o se utiliza una va ria b le d e un
tip o b á sic o c o m o p a rá m e tro e n un m é to d o , e sta va ria b le e s p o r va lo r. La s
Va ria b le s q ue no so n d e tip o s b á sic o s, so n o b je to s. To d o s lo s o b je to s e n Ja va
so n re fe re nc ia s. Una re fe re nc ia e s lo m ism o q ue un p unte ro tra d ic io na l e n C o
e n C ++. La s insta nc ia s d e Ja va y lo s p unte ro s d e C tie ne n una d ife re nc ia y e s
q ue una re fe re nc ia d e Ja va se p a sa a un m é to d o p o r va lo r. Esto sig nific a q ue
d e ntro d e un m é to d o un o b je to p ue d e se r m o d ific a d o e n su inte rio r, p e ro e l
p unte ro q ue lo re p re se nta , e s d e c ir, la re fe re nc ia no se p o d rá m o d ific a r p a ra
q ue a p unte a o tro o b je to d ife re nte a unq ue e ste se a d e l m ism o tip o .
Strings
Una c a d e na e n Ja va e s un o b je to d e l tip o String . Este tip o d e o b je to e s

d ife re nte a lo s d e m á s p o rq ue Ja va , a p e sa r d e se r un o b je to la s tra ta c o m o
va ria b le s p rimitiva s. Po r e je m p lo , p a ra c o nstruirla s no e s ne c e sa rio ha c e r un
ne w , sino q ue p ue d e n se r c re a d a s c o m o una va ria b le no rm a l:
String c a d e na = "mi c a d e na ";

Sentencias
La sinta xis y re g la s d e la c o nstruc c ió n d e se nte nc ia s so n la s mism a s q ue e n C o
C ++:

• Se a g rup a n p o r lla ve s, {,}

• El á m b ito d e una d e c la ra c ió n e stá d e ntro d e su b lo q ue .
La s p rinc ip a le s se nte nc ia s q ue p ro p o rc io na Ja va so n:
Es la se nte nc ia m á s b á sic a p a ra c o ntro la r e l flujo d e un

p ro g ra m a .
if(Bo o le a n-e xp re ssio n)

if-e lse sta te m e nt
if(Boolean-expression)
Sentencia
else
Sentencia
De vue lve e l re sulta d o d e un m é to d o .
re turn
w hile (Bo o le a n-e xp re ssio n)

while
se nte nc ia
w hile (Bo o le a n-e xp re ssio n)

d o -w hile
se nte nc ia
fo r(inic ia liza c ió n; Bo o le a n-e xp re ssio n;

inc re m e nto )
se nte nc ia
La inic ia liza c ió n y e l inc re m e nto p ue d e n inc luir m á s d e una

e xp re sió n unid a s p o r e l o p e ra d o r ",".
fo r
p ub lic c la ss O p e ra d o rC o m m a {
p ub lic sta tic vo id m a in(String [] a rg s) {
fo r(int i = 1, j = i + 10; i < 5;i++, j = i * 2) {
Syste m .o ut.p rintln("i= " + i + " j= " + j);
}
}
}
Bre a k ro m p e e l flujo no rm a l d e un b uc le y p a sa a la sig uie nte

se nte nc ia d e sp ué s d e l b uc le .
b re a k y
c o ntinue C o ntinue ro m p e e l flujo no rm a l d e l c ic lo d e l b uc le d o nd e se
e je c ute y p a sa a e je c uta r la c o m p ro b a c ió n d e l b uc le d e
nue vo .

sw itc h(inte g ra l-se le c to r) {

c a se inte g ra l-va lue 1 : se nte nc ia ; b re a k;
sw itc h c a se inte g ra l-va lue 4 : se nte nc ia ; b re a k;
/ / ...
d e fa ult: sta te m e nt;
}
Expresiones
Una e xp re sió n p ue d e se r una se nte nc ia o p a rte d e e lla q ue a l se r

e va lua d a p ro d uc e un va lo r. El re sulta d o d e una e xp re sió n p ue d e se r un
núm e ro , un tip o d e re fe re nc ia . El tip o d e la e xp re sió n se c o no c e e n tie m p o d e
c o m p ila c ió n y su re sulta d o e n tie m p o d e e je c uc ió n.
Lo s o p e ra d o re s q ue utiliza Ja va so n lo s m ism o s q ue e n C junto c o n e l

o p e ra d o r "insta nc e o f" q ue no s sirve p a ra d e sc ub rir d e q ue tip o e s un o b je to .
if( va ria b le insta nc e o f String ){...}
En e ste e je m p lo se c o m p rue b a si va ria b le e s d e l tip o String .
C re a un m é to d o q ue c re e e inic ia lic e un a rra y unid im e nsio na l

d e l tip o Do ub le . El ta m a ño d e l a rra y se rá d e te rm ina d o p o r un
p a rá m e tro d e e ste m é to d o y lo s va lo re s q ue se utiliza n p a ra la
inic ia liza c ió n se rá n d e ntro d e un ra ng o d e te rm ina d o p o r d o s
p a rá m e tro s d e l m é to d o . C re a o tro m é to d o q ue m ue stre p o r
p a nta lla e l a rra y ya inic ia liza d o . C o m p rue b a q ue e sto s d o s
m é to d o s func io na n d e ntro d e un p ro g ra m a a d ic io na l.
Mo d ific a e l e je rc ic io a nte rio r p a ra utiliza r un a rra y b id im e nsio na l.
Esc rib e una func ió n q ue re a lic e to d a s la s p o sib le s

c o m p a ra c io ne s ló g ic a s e ntre d o s c a d e na s, inc luye nd o ,
e q ua ls().
Esc rib e un p ro g ra m a q ue g e ne re 25 núm e ro s a le a to rio s y

c o m p rue b a si e stá n p o r e nc im a o p o r d e b a jo d e un va lo r
inte rm e d io . Alm a c e na lo s m a yo re s e n un a rra y y lo s m e no re s e n
o tro a rra y. Mue stra lo s re sulta d o s fina le s p o r p a nta lla .

EJERCICIOS RESUELTOS
Sentencias Básicas (Condicionales, Aritmeticas y Contadores)
En lo s sig uie nte s e je rc ic io s, se utiliza n la s se nte nc ia s c o nd ic io na le s if-

e lse , a d e má s de se nte nc ia s a ritm é tic a s c o mo % (m o d ulo ),
c o m p a ra tiva s (<,>,==,e tc ) y ta m b ie n se ha c e uso d e c o nta d o re s y
se ntine la s.
1. Da d o un núm e ro e nte ro y p o sitivo q ue se intro d uc e p o r te c la d o ,

d e te rm ina r si e s p a r o im p a r.
EXPLIC AC IO N DEL PRO G RAMA: Este p ro g ra m a le e un num e ro intro d uc id o

p o r te c la d o y ve rific a si e l num e ro e s p a r o im p a r, ve rific a nd o si e l m o d ulo
d e l num e ro e ntre 2 e s 0 o no .
//programa realizado por Freddy Valda Sanchez

import java.io.*;
public class a1
{
public static void main(String args[])throws IOException
{BufferedReader in;
in=new BufferedReader(new InputStreamReader(System.in));
System.out.println("Introduzca un numero entero y positivo");
int a=Integer.parseInt(in.readLine());
if(a%2==0)
System.out.println("El numero es par");
else
System.out.println("El numero es impar");
}
}
2. Da d o un núm e ro e nte ro q ue se intro d uc e p o r te c la d o , d e te rm ina r si e s

p o sitivo , ne g a tivo o nulo .
EXPLIC AC IO N DEL PRO G RAMA: El usua rio ing re sa un num e ro e nte ro y e l

p ro g ra m a d e te rm ina si e s p o sitivo , ne g a tivo o c e ro (nulo ). Utiliza sim p le s
c o m p a ra c io ne s y sa le e l m e nsa je c o rre sp o nd ie nte .

//Programa realizado por Andrés Prudencio R.

import java.io.*;
public class a2
{
public static void main (String args[])throws IOException

{
BufferedReader in;
in = new BufferedReader (new InputStreamReader (System.in));
System.out.println("Ingrese un numero entero: ");
int d = Integer.parseInt(in.readLine());
if (d==0)
System.out.print(" el numero es nulo ");
else
{if (d<0)
System.out.print("El numero es negativo");
else
System.out.print("El numero es positivo");}
}}
3. Da d o un núm e ro e nte ro q ue se intro d uc e p o r te c la d o , d e te rm ina r si se

e nc ue ntra e n e l inte rva lo c e rra d o 51 - 100.
EXPLIC AC IÓ N DEL PRO G RAMA: Este p ro g ra m a no s p e rm ite Ve rific a r q ue un

núm e ro ing re sa d o p o r te c la d o se e nc ue ntre e n e l inte rva lo c e rra d o [51,100]
// Programa realizado por Sergio W. Ossio Marin

import java.io.*;
public class A_3
{
{
BufferedReader in;
int n;
System.out.println("Ingrese el numero a verificar: ");
n = Integer.parseInt(in.readLine());
if(n>=51&n<=100)
System.out.println("El numero se encuentra en el intervalo cerrado [51-100]");
else
System.out.println("El numero no se encuentra en el intervalo cerrado [51-100]");
}}

4. Da d o un núm e ro e nte ro q ue se intro d uc e p o r te c la d o , d e te rm ina r si e s

ne g a tivo o sup e rio r a 100.
EXPLIC AC IO N DEL PRO G RAMA: e l p ro g ra m a e n p rinc ip io d e fine la c la se

a a 4 q ue c o ntie ne la func ió n p rinc ip a l m a in. Prim e ro se le e un num e ro , q ue
e s intro d uc id o p o r te c la d o y se ha c e n c o m p a ra c io ne s p a ra ve rific a r si e s
ne g a tivo , m a yo r a 100 o e n e l inte rva lo 0-100. Fina lm e nte se d e sp lie g a p o r
p a nta lla la c o nd ic ió n d e d ic ho num e ro .
//Programa realizado por Freddy Valda

import java.io.*;
public class aa4
{
{BufferedReader in;
System.out.println("Introduzca un numero");
if(a<0)
System.out.println("El numero es negativo");
else
if (a>100)
System.out.println("El numero es mayor a 100");
else
System.out.println("El numero esta en el intervalo de 0 a 100");
}}
5. Da d o un núm e ro q ue se intro d uc e p o r te c la d o , si e s p o sitivo ve rific a r si se

e nc ue ntra e n e l inte rva lo a b ie rto 60 – 90, d e lo c o ntra rio e m itir un m e nsa je
d e e rro r.
EXPLIC AC IO N DEL PRO G RAMA: Este p ro g ra m a ve rific a si un num e ro

ing re sa d o p o r e l te c la d o e s p o sitivo y si se e nc ue ntra e n un inte rva lo
p re d e te rm ina d o utiliza nd o se nte nc ia s if.

import java.io.*;
public class a5
{
{BufferedReader in;
System.out.println("Introduzca un numero");
if(a<61)
System.out.println("ERROR");
else
if (a>89)
System.out.println("ERROR");
else
System.out.println("El numero esta en el intervalo abierto 60-90");
}
}
6. Una fue nte d e d a to s re g istra va ria s e d a d e s, la e d a d 0 ind ic a e l fina l d e l

ing re so d e d a to s, re a lic e un p ro g ra m a p a ra d e te rm ina r e l p ro m e d io d e la s
e d a d e s ing re sa d a s y a d e m á s e l p o rc e nta je d e p e rso na s m a yo re s a lo s 50
a ño s.
EXPLIC AC IÓ N DEL PRO G RAMA: Este p ro g ra m a no s p e rm ite re g istra r va ria s

e d a d e s c o n la info rm a c ió n q ue una ve s ing re sa d a la e d a d 0 e sta no s
ind ic a e l fina l d e l ing re so d e e d a d e s, c a lc ula nd o le p ro m e d io d e la s
e d a d e s y a d e m á s e l p o rc e nta je d e e d a d e s m a yo re s a lo s 50 a ño s.

import java.io.*;
public class B_1
{
public static void main (String args []) throws IOException

{
BufferedReader in;
double m = 1, aux = 0, n = 0, o = 0;
System.out.println ("La edad 0 indica el final de ingreso de edades");
while (m != 0)
{
System.out.print ("Ingrese una edad ");
m = Integer.parseInt (in.readLine ());
n++;
aux = aux + m;
if (m > 50)
{
o++;
}
}
double s = (o * 100) / (n - 1);
double aux2 = aux / (n - 1);
System.out.println ("El promedio es " + aux2 );

System.out.println ("El porcentaje de personas mayores a los 50 a*os es de: " + s );}}
7. O b te ne r e l to ta l e n b o no s q ue p a g a la e m p re sa a sus e m p le a d o s, a d e m á s
d e se a c o no c e r c ua nto s e m p le a d o s tie ne n m á s d e 20 a ño s d e a ntig üe d a d
y e l p o rc e nta je q ue re c ib e n e sto s, re sp e c to a l to ta l e n b o no s q ue p a g a la
e m p re sa . (Utiliza r c e ntine la ).
EXPLIC AC IO N DEL PRO G RAMA: El p ro g ra m a p id e le e r e l m inim o d e a ño s

q ue un tra b a ja d o r d e b e tra b a ja r c o m o m inim o p a ra re c ib ir un b o no y la
c a ntid a d de a ño s q ue tra b a ja ro n c ada tra b a ja d o r (ha sta 100
tra b a ja d o re s) p a ra d e sp ué s m e d ia nte o p e ra c io ne s a ritm é tic a s, m o stra r e n
p a nta lla lo q ue se re q uie re e n e l p ro b le m a .
//Realizado por Andres Prudencio R

import java.io.*;
public class b2
{
{BufferedReader in;
int[]e=new int[100];
int cb,cv;
cb=0;cv=0;
System.out.println("Indicar el numero de anios que un empleado debera haber
trabajado como minimo para recibir el bono ");
System.out.println("Ingresar el numero de anios trabajados para cada empleado: (0
termina la entrada de datos)");
int i=1;
e[0]=1;
while (e[i-1]!=0)
{ System.out.println("Empleado "+(i)+": ");
e[i]=Integer.parseInt(in.readLine());
if (e[i]>a)
{cb++; }
if (e[i]>20)
{cv++; }
i++;}
if (cb==0)
System.out.println("Ningun empleado recibira bono");
else
{System.out.println("La empresa pagara "+cb+" bonos");

System.out.println( ((cv*100)/cb)+"% de todos los empleados que recibiran el bono han

trabajado mas de veinte anios");}
}}
8. Le e r una c ie rta c a ntid a d d e e sta tura s (d e te ng a e l p ro c e so m e d ia nte un

c e ntine la ) y d e te rm ine e l p ro m e d io d e e sta tura s p o r d e b a jo d e 1,60 m ts. y
e l p ro m e d io d e e sta tura s e n g e ne ra l.
EXPLIC AC IO N DEL PRO G RAMA: Este p ro g ra m a le e e sta tura s ha sta e nc o ntra r

un 0 (e l se ntine l), lue g o sa c a un p ro m e d io d e la s e sta tura s b a jo lo s 1.60m y
un p ro m e d io d e to d a s la s e sta tura s.
//Realizado por Ignacio Salgado Faller

import java.io.*;
public class b3
{
public static void main(String arg[])throws IOException
{BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
double []x=new double[100];
double a=1,pb=0,pg=0,nb=0;
int i =0;
System.out.println("Introduzca las estaturas (0 para terminar):");
a=(Float.valueOf (in.readLine ())).floatValue ();
if (a>=0)
{x[i]=a;
i++;}
while (a!=0)
{a=(Float.valueOf (in.readLine ())).floatValue ();
x[i] =a;
pg=pg+x[i];
if (x[i]<1.6)
{pb=pb+x[i];
nb++;}
i++;}
i=i-2;
System.out.println("El promedio de estaturas menores a 1.60m es: "+(pb/nb));
System.out.println("El promedio general de estaturas es: "+(pg/i));
}
}
9. C o nta r una lista d e n núm e ro s q ue ing re sa n p o r te c la d o , re c ha za nd o e l

núm e ro 0, lue g o o b te ng a e l to ta l d e núm e ro s p o sitivo s q ue ing re sa ro n, to ta l
d e ne g a tivo s y e l p ro m e d io d e c a d a uno .

EXPLIC AC IÓ N DEL PRO G RAMA: Este p ro g ra m a no s p e rm ite ing re sa r n

núm e ro s p o r te c la d o re c ha za nd o e l núm e ro 0 y no s c a lc ula ra e l to ta l d e
núm e ro s p o sitivo s ing re sa d o s p o r te c la d o y su p ro m e d io a la ve z
d e te rm ina ra lo m ism o c o n lo s núm e ro s ne g a tivo s

import java.io.*;
public class B_9
{
{
BufferedReader in;
double n, m, p = 0, t = 0, s = 0, s1 = 0, prop, prone;
System.out.println ("Ingrese la cantidad de numeros a evaluar ");
n = (Double.valueOf (in.readLine ())).doubleValue ();
for (int i = 0 ; i < n ; i++)
{
System.out.println ("Ingrese un numero");
m = (Double.valueOf (in.readLine ())).doubleValue ();
if (m == 0)
System.out.println ("vuelva a ingresar un numero:");
else
if (m > 0)
{
p++;
s = s + m;
} if (m < 0)
{t++;
s1 = s1 + m;
}}
prop = s / p;
prone = s1 / t;
System.out.println ("El total de numeros positivos es:" + p);
System.out.println ("El total de numeros negativos es:" + t);
System.out.println ("El promedio de numeros positivos es: "+prop);
System.out.println ("El promedio de numeros negativos es:" + prone);
}}
PROBLEMAS PROPUESTOS
1. Esc rib ir un p ro g ra m a q ue p id a e l tip o d e c a m b io p a ra q ue d a d a una
c a ntid a d e n Bo livia no s y la c o nvie rta e n Do la re s y vic e ve rsa .

2. Esc rib ir un p ro g ra m a q ue p id a una ho ra e n se g und o s y la sa q ue p o r
p a nta lla e n e l fo rm a to “ hh:m m :ss” , e s d e c ir ho ra s, m inuto s y se g und o s
3. Inte rc a m b ia r e l c o nte nid o d e d o s va ria b le s.
4. De te rm ina r si un a ño e s b isie sto (ve rific a r la s c o nd ic io ne s)
5. Le e r un p a r o rd e na d o y d e te rm ina r e n q ué c ua d ra nte se e nc ue ntra .
6. C o nve rtir g ra d o s C e ntig ra d o s e n g ra d o s Fa hre nhe it
7. Le e r tre s núm e ro s d ife re nte s (e la b o ra r la va lid a c ió n d e d a to s) y d e te rm ina r
e l va lo r inte rm e d io (e l num e ro q ue no e s m a yo r ni m e no r).
8. Re a liza r un p ro g ra m a c o n e l c ua l se le a la ho ra , lo s m inuto s y se g und o s
p a ra lue g o m o stra r su e q uiva le nte e n se g und o s.
9. Da d o un num e ro x d e te rm ina r si e s m últip lo d e o tro num e ro y.
10. Da d o s tre s núm e ro s, d e te rm ina r e l m a yo r y m e no r.

Ciclos y Series
En lo s sig uie nte s e je rc ic io s, se utiliza n c ic lo s, m e d ia nte la s se nte nc ia s

fo r, w hile , d o - w hile , ta m b ié n se d e sa rro lla n se rie s d e núm e ro s.
1. Re a liza r un p ro g ra m a q ue le a un num e ro , lue g o d e sp le g a r e sa c a ntid a d d e

*.
EXPLIC AC IÓ N DEL PRO G RAMA: Este p ro g ra m a no s p e rm ite d e sp le g a r (*) n
ve c e s utiliza nd o un p e q ue ño c ic lo fo r.

import java.io.*;
public class A_67
{

{
BufferedReader in;
int n;
System.out.println ("Ingrese un numero");
n = Integer.parseInt (in.readLine ());
System.out.println ("La cantidad de * a desplegar son:"+n);
for (int i = 0 ; i < n ; i++)
{System.out.print("-*-");}}}
2. Da d o un va lo r n y o tro va lo r y, d e sp le g a r e n p a nta lla núm e ro s c o rre la tivo s

d e sd e 1 ha sta n, re e m p la za nd o p o r un * c a d a ve z q ue c o rre sp o nd a
d e sp le g a r un núm e ro m últip lo d e y.
EXPLIC AC IO N DEL PRO BLEMA: Se p id e un num e ro e l c ua l se rá la c a ntid a d

d e té rm ino s p a ra la se rie c o rre la tiva . Po ste rio rm e nte se p id o o tro num e ro
c uyo s m últip lo s no se rá n m o stra d o s, p e ro se m o stra ra un a ste risc o e n ve z d e
e so s núm e ro s. Sim p le m e nte se usa un c ic lo fo r p a ra a na liza r c a d a núm e ro .
//Realizado por Andres Prudencio R.

import java.io.*;
public class b6
{
{BufferedReader in;

System.out.println("Ingresar el ultimo numero de la serie ");
int n=Integer.parseInt(in.readLine());
System.out.println("Ingresar el numero cuyos multiplos no seran mostrados");
int y=Integer.parseInt(in.readLine());
for (int i=1;n>=i;i++)
{
if (i%y==0)
System.out.print("*"+" ");
else
System.out.print(i+" ");
}
}}
3. Pro g ra m a q ue le a un núm e ro n lue g o d e sp le g a r la ta b la d e m ultip lic a r d e

e se núm e ro . Re a liza r e l p ro g ra m a : a ) utiliza nd o fo r b ) Utiliza nd o while
c ) utiliza nd o d o w hile .
EXPLIC AC IO N DEL PRO G RAMA: De sp lie g a la ta b la d e m ultip lic a r tre s ve c e s

d e un num e ro n usa nd o c ic lo s fo r, while , d o while usa nd o la m ism a
c o nd ic ió n: 10>=j d o nd e j e s e l m ultip lic a d o r.

import java.io.*;
public class b10

{
{BufferedReader in;
System.out.println("Ingresar el numero cuya tabla de multiplicar sera mostrada");
int j=1;
for(j=1;10>=j;j++)
{System.out.println(n+"*"+j+"="+n*j);}
System.out.println("----------------------------------------------");
j=1;
while(10>=j)
{
System.out.println(n+"*"+j+"="+n*j);
j++;
}
System.out.println("----------------------------------------------");
j=1;
do
{
System.out.println(n+"*"+j+"="+n*j);
j++;
}
while(10>=j);
}}
4. De sp le g a r lo s núm e ro s d e x ha sta z, d o nd e x <=z, a ) utiliza nd o fo r`s b)

Utiliza nd o w hile c ) utiliza nd o d o w hile .
EXPLIC AC IO N DEL PRO G RAMA: Este p ro g ra m a d e sp lie g a una se rie d e

núm e ro s d e sd e x ha sta z, sig ue p id ie nd o lo s va lo re s ha sta q ue se c um p la
q ue x<=z. Se utiliza n to d o s lo s tip o s p e d id o s e n e l e nunc ia d o .
//programa realizado por Ignacio Salgado Faller

import java.io.*;
public class b11
{
{BufferedReader in;
int x=1,z=0,opc=5;
int num=0;
while (x>z)
{System.out.println("Ingresar el valor de x y z (x debe ser<=z):");
x=Integer.parseInt(in.readLine());
z=Integer.parseInt(in.readLine());
}
while (opc>3||opc<1)
{System.out.println("1. Realizar desplegamiento mediante for");
System.out.println("2. Realizar desplegamiento mediante while");
System.out.println("3.Realizar el desplegamiento mediante do-while");
System.out.println("Ingresar su opcion:");
opc=Integer.parseInt(in.readLine());
}
switch (opc)
{case 1:System.out.println("Los numeros son: ");
for (int i=x;i<=z;i++)
{System.out.print(i+" ");}
break;
case 2: System.out.println("Los numeros son: ");int i=x;
while (i<=z)
{System.out.print(i+" ");
i++;}
break;
case 3:System.out.println("Los numeros son: ");int j=x;
do
{System.out.print(j+" ");
j++;}
while (j<=z);
break;
}
}
}
5. De sa rro lla r un p ro g ra ma q ue , utiliza nd o una func ió n mue stre e n p a nta lla N

fila s d e núme ro s na tura le s imp a re s, d e lo s sig uie nte s núme ro s y e n la fo rma
sig uie nte :
1
13
135
......
N (núme ro d e fila s) se d e b e ind ic a r p o r te c la d o .
EXPLIC AC IO N DEL PRO G RAMA: El usua rio ing re sa e l num e ro d e fila s a

m o stra r, a q ue l num e ro e s p a rá m e tro d e la func ió n se rie la c ua l e s lla m a d a
d e sd e e l m é to d o m a in d e la c la se a 6. La func ió n se rie e s una func ió n vo id q ue
im p rim e la se rie . No ta : la func ió n se rie d e b e e sta r a fue ra d e l m é to d o m a in,
d e ntro d e la c la se a 6

import java.io.*;
public class a6
{
{ BufferedReader in;
System.out.print("Ingrese el numero de filas ");
int d=Integer.parseInt(in.readLine());
serie(d);
public static void serie(int d)
{int a=1,b=2;
for (int f=1;d>=f;f++)
{System.out.println("");
for (int c=1;f*2>=c;c++)
{
{if ((c%2)!=0)
System.out.print(c+" ");
}
}}}}

6. Me d ia nte e l uso d e una func ió n, e sc rib ir un p ro g ra m a p a ra sum a r lo s

p rim e ro s N núm e ro s na tura le s. El re sulta d o d e sp le g a r e n la func ió n p rinc ip a l.
EXPLIC AC IÓ N DEL PRO G RAMA : Este p ro g ra m a no s p e rite sum a r n núm e ro s

ing re sa d o s p o r te c la d o y ta m b ié n no s m ue stra la sum a to ta l

import java.io.*;
public class A_7
{
{
BufferedReader in;
int m,n,c=0;
System.out.println("La cantidad de numeros a sumar : ");

for (int i=0;i<n;i++)
{
System.out.println("Ingrese un numero ");
m = Integer.parseInt(in.readLine());
c=c+m;
}
System.out.println("La suma de los números ingresados es:"+c);
}}
7. Me d ia nte una func ió n d e sp le g a r e n p a nta lla N núm e ro s na tura le s, e n la

sig uie nte fo rm a :
1
23
456
…………
EXPLIC AC IO N DEL PRO G RAMA: Este p ro g ra m a g e ne ra la se c ue nc ia m o stra d a

a rrib a utiliza nd o fo r’ s.
//Programa realizado por Ignacio Salgado Faller

import java.io.*;
public class a8
{public static void main (String args[])throws IOException
{BufferedReader in;
in=new BufferedReader (new InputStreamReader (System.in));
int c=1;
System.out.println("Ingrese el numero de filas: ");
int num = Integer.parseInt(in.readLine());
System.out.println("La cadena es: ");
for (int i=1;i<=num;i++)
for (int j=1;j<=i;j++)
{System.out.print(c+" ");
c=c+1;}}
}
}
8. Da d a la sig uie nte suc e sió n d e núm e ro s: 2, 4, 8, 6, 36, 72, 70, 4900, 9800,...
m e d ia nte e l uso d e func io ne s, m o stra r e n p a nta lla lo s té rm ino s d e e sta se rie
y c a lc ula r la sum a d e N (N se ind ic a p o r te c la d o ) e le m e nto s, e s d e c ir,
SUMA=2+4+8+6+.....
EXPLIC AC IO N DEL PRO G RAMA: El p ro g ra m a c a lc ula la sum a d e la se rie

a nte rio r p a ra n te rm ino s. Pa ra e llo , g e ne ra c a d a uno d e lo s va lo re s d e
d ic ha se rie ha sta e l lim ite ing re sa d o p o r e l usua rio . La lo g ic a q ue sig ue la
se rie e s d e e le va r a l c ua d ra d o , m ultip lic a r p o r d o s y re sta r d o s.
//Programa realizado por Freddy Valda Sanchez

import java.io.*;
public class a9
{
{BufferedReader in;
int s=0,a=2;
System.out.println("Introduzca el limite N");
for(int i=0;i<n;)
{
System.out.println(a);
s=s+a;
i++;
a=op1(a);
if(i==n)
break;
else
{System.out.println(a);
s=s+a;

a=op2(a);
i++;
}
if(i==n)
break;
else
{System.out.println(a);
s=s+a;
a=op3(a);
i++;
}
}
System.out.println("La suma de la serie es: "+s);
}
public static int op1 (int b)
{return b*b;}
{return b*2;}
{return b-2;}
}
9. De sa rro lla r un p ro g ra ma q ue , utiliza nd o func io ne s, se d e sp lie g ue e n p a nta lla

N té rmino s d e la se rie : 1, 3, 1, 1, 4, 1, 1, 1, 5, 1 , 1, 1, 1, 6, . . .
EXPLIC AC IO N DEL PRO G RAMA: El usua rio ing re sa e l num e ro d e té rm ino s a

m o stra r, a q ue l num e ro e s p a rá m e tro d e la func ió n se rie la c ua l e s lla m a d a
d e sd e e l m é to d o m a in d e la c la se a 10. La func ió n se rie e s una func ió n vo id
q ue im p rime la se rie .

import java.io.*;
public class a10
{
System.out.println("Ingrese el numero de terminos ");

serie(n);
}
public static void serie(int n)
{int a=3,k=0,ct=1;
if(n<=0)
System.out.print("el numero de terminos debe ser mayor a cero");
else
{if (n==2)
System.out.print("1,3,");
else
System.out.print("1,");
}
while(ct<=n-2)
{ System.out.print(a+",");
ct++;
k=a-1;
for (int j=1;k>=j;j++)
{System.out.print("1,");
ct++;
if (ct==n)
{j=k*2;}
}
a++;
}
System.out.print("...");
}}
10. De sa rro lla r un p ro g ra m a , utiliza nd o func io ne s, p a ra c a lc ula r la sig uie nte
sum a :
Ind ic a r e l va lo r d e x (0<=x<= 1) p o r te c la d o y sum a r té rm ino s m ie ntra s
e sto s se a n m a yo re s a 10 -8.
EXPLIC AC IO N DEL PRO G RAMA: e l p ro g ra m a c a lc ula la sum a d e la se rie
a nte rio r, p a ra e llo se d e fine una func ió n c o n re to rno q ue c a lc ula e l
fa c to ria l d e un num e ro , una va ria b le sum y una va ria b le x q ue e s
intro d uc id a p o r te c la d o . Fina lme nte , e n un c ic lo w hile se g e ne ra n c a d a
uno d e lo s té rm ino s d e la se rie y se va n sum a nd o , d e sp ué s se d e sp lie g a
la sum a d e la se rie .

import java.io.*;
public class a17

{
{BufferedReader in;
double sum=0,n=1;
int k=1;
System.out.println("Ingrese el valor de x (0<=x<=1)");
double x = (Double.valueOf(in.readLine())).doubleValue();
while (n>0.00000001)
{sum=sum+n;
n=(Math.pow(x,k)/fact(k));
k=k+1;
}
System.out.println("La suma de la serie es :"+ sum);
}
public static double fact(double k)
{double s=1;
for(double i=k;i>0;i--)
{s=s*i;}
return s;}
}
11. De sa rro lla r un p ro g ra ma , utiliza nd o func io ne s, p a ra c a lc ula r la sig uie nte suma :
x− + − + − ......
x3 x5 x7 x9
3! 5! 7! 9!
Ind ic a r e l va lo r d e x (0 ≤ x ≤ 1) p o r te c la d o y suma r té rmino s mie ntra s e sto s
se a n ma yo re s a 10-8.
EXPLIC AC IO N DEL PRO G RAMA: Este p ro g ra m a g e ne ra la sum a to ria d e la
se c ue nc ia m e nc io na d a a rrib a utiliza nd o se nte nc ia s w hile . Utiliza va ria s
va ria b le s p a ra g e ne ra r e l e xp o ne nte y e l num e ro d e l c ua l se d e b e
c a lc ula r e l fa c to ria l, p a ra e l fa c to ria l se c a lc ula m e d ia nte una func io n
a d ic io na l.
//Programa realizado por Ignacio Salgado Faller

import java.io.*;
public class a18
{


double x;
System.out.println("Introduzca el valor de x entre 0 y 1:");
x = (Float.valueOf (in.readLine ())).floatValue ();
double term=0,conta=1,aux=1,sig=1;
while (aux>0.00000001)
{
term=(sig*(Math.pow(conta,x)/facto(conta)))+term;
conta=conta+2;
sig=-sig;
aux=Math.pow(conta,x)/facto(conta);
}
System.out.println("La sumatoria es: "+aux);
}
public static double facto(double xx)

{if (xx==0)
{xx=1;
return xx;}
else
{double sum=0;
for (double i=1;i<xx;i++)
{sum=i*xx+sum;}
xx=sum;
return xx;}
}
}
12. De sa rro lla r un p ro g ra m a p a ra q ue a c e p te p o r te c la d o va lo re s p a ra A, B y N

y c a lc ule la sum a d e la sig uie nte se rie :
+ + + + ........ +
1 1 1 1 1
A A + B A + 2 B A + 3B A + NB
EXPLIC AC IÓ N DEL PRO G RAMA: Este p ro g ra m a no s p e rm ite sum a r n

té rm ino s d e la se rie ya e nte s p ro p ue sta y ta m b ié n d e sp le g a rla m ism a

import java.io.*;
public class A_11
{
{
BufferedReader in;

double A,B,N,C,D=0,E;
System.out.println("Ingrese el valor para A: ");
A = Integer.parseInt(in.readLine());
System.out.println("Ingrese el valor para B: ");
B = Integer.parseInt(in.readLine());
System.out.println("Ingrese el valor para N: ");
N = Integer.parseInt(in.readLine());
C=(1/A)+(1/(A+B));
for(int i=2;i<=N;i++)
{
D=(D+1/(A+(i*B)));
}
E=C+D;
System.out.println("La suma de la serie es:"+E);
}}
13. Re a lic e un p ro g ra m a p a ra m e d ia nte un m e nú d e o p c io ne s c a lc ula r a )

se no (x), b ) c o se no (x) y c ) ln(x). Utilic e la s se rie s d e Ta ylo r.
EXPLIC AC IO N DEL PRO G RAMA: e l p ro g ra m a utiliza func io ne s y un m e nú d e

o p c io ne s p a ra c a lc ula r e l se no , c o se no y lo g a ritm o ne p e ria no d e un
núm e ro intro d uc id o p o r te c la d o . Existe o tra func ió n p a ra c a lc ula r e l
fa c to ria l d e un núm e ro . Se utiliza n la s se rie s d e Ta ylo r p a ra c a lc ula r d ic ha s
func io ne s m a te m á tic a s.
import java.io.*;
public class b4
{
{double x;
int opc=0;
BufferedReader in;
do
{System.out.println("--------------MENU DE OPCIONES --------------");
System.out.println("1. Seno de un numero");
System.out.println("2. Coseno de un numero");
System.out.println("3. Logaritmo de un numero");
System.out.println("4. Salir");
System.out.println("Ingrese una opcion: ");
switch(opc)
{case 1:sen();break;
case 2:cos();break;
case 3:log();break;

case 4:break;}
}
while(opc!=4);
}
static double fact(double e)

{
float f=1;
for (int i=1;e>=i;i++)
{f=f*i;}
return f;}
static void sen()throws IOException

{BufferedReader in;
double x;
System.out.println("Ingrese el angulo en grados para calcular el seno: ");
x=(x*3.1416)/180;
double sum=0,den,num,nn,op;
for (float n=0;10>=n;n++)
{num=Math.pow(-1,n);
nn=(2*n)+1;
den=fact(nn);
op=(num*Math.pow(x,nn))/den;
sum=sum+op;}
System.out.println("El resultado es: "+sum);}
static void cos()throws IOException

{BufferedReader in;
double sum=0,den,num,nn,op;
double x;
System.out.println("Ingrese el angulo en grados para calcular el coseno: ");
x=(x*3.1416)/180;

nn=(2*n);
den=fact(nn);
sum=sum+op;}
System.out.println("El resultado es: "+sum);}
static void log()throws IOException

{BufferedReader in;
double x;
System.out.println("Ingrese el numero para calcular el logaritmo neperiano: ");
double sum=0,suma,den,num,nn,op;
nn=n+1;
den=nn;
sum=sum+op;}
suma=Math.log(x);
System.out.println("El resultado es: "+suma);}}

1. Esc rib ir un p ro g ra m a q ue p id a una c o ntra se ña num e ric a y p e rm ita tre s
inte nto s. Si e l usua rio ing re sa la c o ntra se ña c o rre c ta , q ue se m ue stre
"C o rre c to !" y q ue e je c ute un p ro g ra m a c ua lq uie ra , d e sp ué s d e l m e nsa je .
En c a so c o ntra rio e l p ro g ra m a d e b e m o stra r " C o ntra se ña e q uivo c a d a ".
Po ste rio rm e nte te rm ina r e l p ro g ra m a d e inm e d ia to .
2. Esc rib ir un p ro g ra m a q ue le a una lista d e núm e ro s y d e te rm ine c ua nto s so n

p o sitivo s, y c ua nto s so n ne g a tivo s.
3. O b te ne r la se rie :
1,-1,2,-2,3,-3,… p a ra n núm e ro s
4. Esc rib ir un p ro g ra m a q ue p e rm ita o b te ne r e l va lo r a p ro xim a d o d e PI,

m e d ia nte la se rie :
4 - 4/ 3 + 4/ 5 – 4/ 7 + 4/ 9 – 4/ 11 + … p a ra n té rm ino s.
5. Esc rib ir un p ro g ra m a q ue p e rm ita a d ivina r un num e ro q ue se g e ne re

inte rna m e nte a l a za r, e l c ua l e sta e n e l ra ng o d e 1 a 50. El usua rio d e b e
a d ivina r e ste num e ro e n b a se a a p ro xim a c io ne s, p a ra lo c ua l se d isp o ne d e
5 inte nto s. Eje m p lo :
Sa lida :
Esto y p e nsa nd o e n un num e ro e ntre 1 y 50

Inte nto 1
? 25
El num e ro e sta e ntre 25 y 50
Inte nto 2
? 34
Inte nto 3
? 45
Inte nto 4
? 40
Inte nto 5
? 42
Si e s c o rre c to , q ue m ue stre : “ Fe lic id a d e s, a d ivina ste e l num e ro ”
De lo c o ntra rio : “ Se a c a b a ro n lo s inte nto s, e l num e ro q ue p e nsé e ra 42” .
6. Esc rib ir un p ro g ra m a q ue d a d o s d o s núm e ro s, uno re a l (b a se ) y un e nte ro

p o sitivo (e xp o ne nte ), sa q ue p o r p a nta lla to d a s la s p o te nc ia s c o n b a se e l
num e ro d a d o y e xp o ne nte s e ntre uno y e l e xp o ne nte intro d uc id o .
7. G e ne ra r la s se c ue nc ia :
55555
4444
333
22
1
8. G e ne ra r la se rie d e Fib o na c c i
9. G e ne ra r: 1,2,6,24,120,… p a ra n té rm ino s
10. O b te ne r e l va lo r d e la se rie :
2,5,7,10,12,15,17,…,1800

Funciones y el uso de la clase Math
En lo s sig uie nte s e je rc ic io s, se utiliza n func io ne s, c o n o sin re to rno .

Ta m b ie n se ha c e uso d e la c la se Ma th, p a ra c a lc ula r p o te nc ia s, ra íc e s,
lo g a ritm o s, num e ro s a le a to rio s , e tc .
1. Pre p a ra r un p ro g ra ma , utiliza nd o func io ne s, p a ra q ue a d mita p o r te c la d o un

e nte ro p o sitivo M y q ue o b te ng a to d o s lo s núme ro s p rimo s q ue se a n me no re s
q ue o ig ua le s a M.
EXPLIC AC IO N DEL PRO G RAMA: El usua rio ing re sa un núm e ro . El p ro g ra m a

m o stra ra to d o s lo s núm e ro s p rimo s m e no re s o ig ua le s a l núm e ro ing re sa d o .
El p ro g ra m a re a liza p rim e ra m e nte una va lid a c ió n d e la e ntra d a d e l usua rio .
El num e ro d e b e se r p o sitivo , si se ing re sa un num e ro ne g a tivo , se vo lve rá a
re q ue rir la e ntra d a d e l num e ro . Una ve z va lid a d o , se lla m a a la func ió n
p rim o s la c ua l m o stra ra la se rie .
import java.io.*;
public class a19
{
System.out.print(" Los numeros primos deben ser menores o iguales a: ");

int m=Integer.parseInt(in.readLine());
if(m<0)
{System.out.print("Debe introducir un numero POSITIVO ");
while(m<0)
{System.out.print("Intente de nuevo ");
m=Integer.parseInt(in.readLine());
}}
primos(m);
}
public static void primos(int m)

{int cd=0;
for(int h=1;m>=h;h++)
{ for(int g=1;h>=g;g++)

{if(h%g==0)
cd++;
}
if(cd==2)
{System.out.print(h+" ");
cd=0;}
else
cd=0;
}
}
}
2. De sa rro lla r un p ro g ra ma c o n func io ne s p a ra lista r e n una ta b la , c o n lo s

e nc a b e za d o s c o rre sp o nd ie nte s, lo s va lo re s d e X, Y y f(x,y), d e a c ue rd o a la
sig uie nte e c ua c ió n:
x 2 + 3x + y 2
f ( x, y) =
xy − 5 y − 3x + 15
, d o nd e x=2, 2.5, 3, 3.5; y=0, 0.1, 0.2,.0.3, 0.4.
EXPLIC AC IÓ N DEL PRO G RAMA: Este p ro g ra m a no s p e rm ite c a lc ula r lo s

va lo re s d e la func io n ya a nte s m e nc io na d a c o n lo s va lo re s e stá tic o s d e
la s va ria b le s x e y lo s c ua le s no s m ue stra e n una ta b la .

import java.io.*;
public class A_20
{public static void main (String args[])throws IOException
{
BufferedReader in;
double c,d,e;
System.out.println("Listado de una tabla de X , Y f(x,y)");
for(double x=2;x<=3.5;x=x+0.5)
{for(double y=0;y<=0.4;y=y+0.1)
{
c=(x*x)+(3*x)+(y*y);
d=(x*y)-(5*y)-(3*x)+15;
e=c/d;
System.out.println(":f("+x+" , "+y+")es:"+e);
}}}}

3. De sa rro lla r un p ro g ra m a p a ra lista r e n una ta b la , c o n lo s e nc a b e za d o s

c o rre sp o nd ie nte s, lo s va lo re s d e X, Y y f(x,y), d e a c ue rd o a la sig uie nte
func ió n:
EXPLIC AC IO N DEL PRO G RAMA: e l p ro g ra m a lista e n p a nta lla lo s va lo re s

d e “ x” , ” y” y d e f(x,y). Pa ra e llo se d e fine n 2 c ic lo s tip o fo r, uno q ue
g e ne re la s x y o tro q ue g e ne re la s y e n e l ra ng o q ue ind ic a e l p ro b le m a .
Existe una func ió n c o n re to rno q ue c a lc ula e l va lo r d e f(x,y). Fina lm e nte ,
c a d a f(x,y) e xiste nte e n e l ra ng o e s d e sp le g a d a p o r p a nta lla .

import java.io.*;
public class a21
{
{
double a,b;
System.out.println("TABLA DE VALORES DE X y Y");
System.out.println("---------------------------");
System.out.println("X Y f(X,Y)");
for( a=0;a<=3;a++)
{for(b=1;b<=5;b++)
{System.out.println(a+" "+b+" "+func(a,b));
}}
}
public static double func(double x,double y)
{double aw,aq;
aw=(x*x)-(y*y);
aq=(x*y)-(2*y)+(6*x);
return (aw/aq);}
}
4. De sa rro lla r un p ro g ra m a c o n un m e nú p a ra c a lc ula r:
1. El vo lum e n d e un p a ra le le p íp e d o re c ta ng ula r d e lo ng itud A, a ltura B

y a nc ho C .
2. El vo lum e n d e una e sfe ra d e ra d io r.
3. El vo lum e n d e un c ilind ro re c to d e ra d io r y a ltura h
4. El vo lum e n d e un c o no c irc ula r re c to d e ra d io r y a ltura h.

EXPLIC AC IO N DEL PRO G RAMA: Este p ro g ra m a c a lc ula lo s vo lúm e ne s d e va ria s

fig ura s g e o m e tric a s. Pa ra e sto utiliza m o s la s fo rm ula s c o no c id a d y a d e m a s
utiliza m o s un m e nú d e o p c io ne s p a ra q ue e l usua rio p ue d a c a lc ula r e l
vo lum e n d e se a d o .
import java.io.*;
public class a22
{
int opc=6;
int a,b,c,v;
double pi=3.1416,r,v1,h;
while (opc<1||opc>5)
{System.out.println("1. Volumen de un Paralelepipedo Rectangular");
System.out.println("2. Volumen de una Esfera");
System.out.println("3. Volumen de un Cilindro Recto");
System.out.println("4. Volumen de un Cono Circular Recto");
System.out.println("5. Salir");
System.out.println("Seleccionar su opcion: ");
opc = Integer.parseInt(in.readLine( ));
}
switch (opc)
{case 1: System.out.println("Ingresar la base, altura y ancho: ");
a = Integer.parseInt(in.readLine( ));
b = Integer.parseInt(in.readLine( ));
c = Integer.parseInt(in.readLine( ));
v=a*b*c;System.out.println("El volumen es: "+v);break;
case 2: System.out.println("Ingresar el radio: ");
r= Integer.parseInt(in.readLine( ));v1=(r*r*r)*pi*(4/3);
System.out.println("El volumen es: "+v1);break;
case 3: System.out.println("Ingresar el radio y la altura: ");
r= Integer.parseInt(in.readLine( ));
h= Integer.parseInt(in.readLine( ));v1=pi*(r*r)*h;
case 4: System.out.println("Ingresar el radio y la altura: ");
r= Integer.parseInt(in.readLine( ));
h= Integer.parseInt(in.readLine( ));v1=(pi*(r*r)*h)/3;
}
}}
5. De sa rro lla r un p ro g ra m a p a ra d e sp le g a r e n p a nta lla lo s sig uie nte s núm e ro s,

m e d ia nte e l uso d e func io ne s:
1 2 3 4 5
5 4 3 2 1

1 2 3 4
4 3 2 1
1 2 3
3 2 1
1 2
2 1
1
1
EXPLIC AC IO N DEL PRO G RAMA: El usua rio ing re sa un núm e ro e l c ua l se rá

e l m á xim o p a ra la se rie a m o stra r. En e l e je m p lo a nte rio r se ria 5. Al ig ua l
q ue e n e l e je rc ic io 19, se va lid a la e ntra d a y se lla m a a la func ió n
a nid a d a la c ua l m o stra ra la se rie .

import java.io.*;
public class a23
{
System.out.print(" Numero maximo: ");

if(n<0)
while(n<0)
n=Integer.parseInt(in.readLine());}}
anidado(n);
}
public static void anidado(int n)

{for (int i=n;i>0;i--)
{System.out.println();
for (int y=1;y<=i;y++)
{System.out.print(y+" ");}
System.out.println();
for (int j=i;j>0;j--)
System.out.print(j+" ");
}}}

6. Esc rib ir un p ro g ra m a q ue p re se nte un m e nú p a ra c o nve rtir g ra d o s

C e ntíg ra d o s, q ue se intro d uc e p o r te c la d o , e n g ra d o s Fa hre nhe it y
vic e ve rsa , utiliza nd o func io ne s. La s fó rm ula s d e c o nve rsió n so n:
9.0
C e ntíg ra d o s = (g ra d o s Fa hre nhe it) + 32.
5.0
5.0
Fa hre nhe it = (g ra d o s C e ntíg ra d o s – 32).
9.0
EXPLIC AC IÓ N DEL PRO G RAMA: Este p ro g ra m a no s p e rm ite c o nve rtir g ra d o s

c e ntíg ra d o s ing re sa d o s p o r te c la d o a g ra d o s Fa hre nhe it y vic e ve rsa .

import java.io.*;
public class A_24
{
{
BufferedReader in;
double n,f,c;
int res=1;
while(res!=0)
{
System.out.println("MENU DE OPCIONES ");
System.out.println("1.Ingresar grados centigrados y convertirlo a fahrenheit ");
System.out.println("2.Ingresar grados fahrenheit y convertirlo a centigrado ");
System.out.println("3. SALIR");
System.out.println("INGRESE LA OPCION");
res=Integer.parseInt(in.readLine());
switch (res)
{
case 1:
System.out.println("Ingrese la temperatura en grados centigrados");
f=(1.8*n)+32;
System.out.println("La temperatura ingresada en grados fahrenheit es:"+f);
break;
case 2:
System.out.println("Ingrese la temperatura en grados fahrenheit");
c=(n-32)*(0.55);
System.out.println("La temperatura ingresada en grados centigrados es:"+c);
case 3:System.exit(0);
break;
}}}}

7. Esc rib ir un p ro g ra m a q ue p re se nte un m e nú p a ra c a lc ula r func io ne s

m a te m á tic a s, c o m o la ra íz c ua d ra d a , lo g a ritm o ne p e ria no , lo g a ritm o
d e c im a l y e l va lo r d e e x, p a ra un núm e ro q ue se intro d uc e p o r te c la d o ,
utiliza nd o func io ne s.
EXPLIC AC IO N DEL PRO G RAMA: e l p ro g ra m a d e sp lie g a un m e nú d e

o p c io ne s p a ra c a lc ula r d ive rsa s func io ne s m a te m á tic a s. Existe n func io ne s
c o n re to rno p a ra c a lc ula r e l c a d a una d e e lla s. Prim e ro se d e b e ing re sa r e l
va lo r p a ra p o ste rio rm e nte ha lla r la func ió n d e se a d a . Pa ra d ic ha s func io ne s
se utiliza la c la se Ma th.

import java.io.*;
public class a25
{
{BufferedReader in;
double x=0;
int resp;
do
{
System.out.println("MENU PARA CALCULAR FUNCIONES MATEMATICAS");
System.out.println("1. RAIZ CUADRADA");
System.out.println("2. LOGARITMO NEPERIANO");
System.out.println("3. LOGARITMO DECIMAL");
System.out.println("4. VALOR DE e ELEVADO A LA X");
System.out.println("5. INGRESAR EL VALOR");
System.out.println("6. SALIR");
System.out.println("INGRESE LA OPCION POR FAVOR");
resp=Integer.parseInt(in.readLine());
switch (resp){
case 1:raiz(x);break;
case 2:lognep(x);break;
case 3:logdec(x);break;
case 4:ealax(x);break;
case 5:
x = (Double.valueOf(in.readLine())).doubleValue();break;
case 6:
break;
}
}
while(resp!=6);
}
public static void raiz(double x)
{double r;

r=Math.sqrt(x);
System.out.println("RAIZ CUADRADA:"+r);}
public static void lognep(double x)
{double r;
r=Math.log(x);
System.out.println("LOGARITMO NEPERIANO:"+r);}
public static void logdec(double x)
{double r;
r=Math.log(x)/Math.log(10);
System.out.println("LOGARITMO DECIMAL:"+r);}
public static void ealax(double x)
{double r,e;
e=2.717281;
r=Math.pow(e,x);
System.out.println("VALOR DE e ELEVADO A LA X:"+r);}
}
8. Esc rib ir un p ro g ra m a , p a ra g e ne ra r y d e sp le g a r 20 núm e ro s a le a to rio s

utiliza nd o la func ió n RAND(), e n e l ra ng o d e 20 a 80.
EXPLIC AC IO N DEL PRO G RAMA: Este p ro g ra m a g e ne ra num e ro s a le a to rio s

e ntre lo s lim ite s p ro p ue sto s utiliza nd o la fo rm ula (Lim ite sup e rio r – Lim ite
infe rio r)+Lim ite infe rio r p a ra la se nte nc ia ra nd o m . Lue g o d e sp lie g a lo s
num e ro s

import java.io.*;
public class a26
{
{BufferedReader in;
int num;
System.out.println("Los numeros son: ");
for (int u=1;u<=20;u++)
{num=(int)(Math.random()*60+20);
System.out.print(num+" ");}
}}
9. Esc rib ir un p ro g ra m a , c o n func io ne s, p a ra g e ne ra r y d e sp le g a r N núm e ro s

a le a to rio s c o m p re nd id o s e ntre 0 y 1.

EXPLIC AC IO N DEL PRO G RAMA: El usua rio ing re sa la c a ntid a d d e núm e ro s

q ue se rá n m o stra d o s, b a jo e sa c a ntid a d , se g e ne ra ra n núm e ro s a l a za r
e ntre 0 y 1. En e ste p ro g ra m a se utiliza e n la sa lid a d e núm e ro s la func ió n
d f.fo rm a t, la c ua l re d uc e la c a ntid a d d e d e c im a le s a m o stra r p a ra lo s tip o s
de d a to s re a le s. En e ste c a so d o s. Esto se d e fine e n la se nte nc ia
De c ima lFo rma t df = ne w De c ima lFo rma t("0.00");. Se d e b e inc luir la lib re ría
ja va .te xt.De c im a lFo rm a t a nte s d e d e c la ra r la c la se .

import java.io.*;
import java.text.DecimalFormat;
public class a27
{
System.out.print(" Cantidad de numeros: ");

if(n<0)
while(n<0)
n=Integer.parseInt(in.readLine());}}
rr(n);
}
public static void rr(int n)
{DecimalFormat df = new DecimalFormat("0.00");
float f;
for (int i=1;n>=i;i++)
{if (i%40==0)
f=(float)(Math.random()*0.9);
System.out.print(df.format(f)+" "); }}}
10. Esc rib ir un p ro g ra m a , p a ra g e ne ra r y d e sp le g a r N núm e ro s a le a to rio s

c o m p re nd id o s e ntre d o s va lo re s lím ite s q ue se ind ic a n p o r te c la d o .
EXPLIC AC IÓ N DEL PRO G RAMA: Este p ro g ra m a no s p e rm ite d e sp le g a r n

núm e ro s c o m p re nd id o s e ntre d o s lim ite s x e y q ue ta m b ié n so n ing re sa d o s
p o r te c la d o utiliza nd o una fo rm a a le a to ria p a ra d e sp le g a r lo s d istinto s
núm e ro s


import java.lang.Math.*;
import java.io.*;
public class A_28
{
{
BufferedReader in;
int n,x,y,i,k;
System.out.println("Ingrese cantidad de números a desplegar: ");

System.out.println("Ingrese el limite inferior: ");
x = Integer.parseInt(in.readLine());
System.out.println("Ingrese el limite superior: ");
y = Integer.parseInt(in.readLine());
for (i=0;i<n;i++)
{k=( int)(Math.random()*(y-10)+x);
System.out.println("los numeros son "+k);
}}}
11. Re a liza un p ro g ra m a p a ra d e sp le g a r n núm e ro s a le a to rio s m e no re s q ue y .

Do nd e n ta m b ié n e s a le a to rio .
EXPLIC AC IO N DEL PRO G RAMA: Este p ro g ra m a d e sp lie g a ta nto s núm e ro s

a le a to rio s g e ne re e l p ro g ra m a sie m p re y c ua nd o se a n m e no re s q ue y, q ue
ta m b ié n e s a le a to rio .

import java.io.*;
public class b7
{
{BufferedReader in;
int y=(int) (Math.random()*50);
int num=0;
int n=(int)(Math.random()*50);
System.out.println("Se desplegaran "+n+" numeros menores que "+y);
{num=(int)(Math.random()*50);
if (num>=y)
{i--;}
else
{System.out.print(num+" ");}
}
}
}
12. Re a liza r un p ro g ra m a p a ra c a lc ula r y d e sp le g a r, m e d ia nte func io ne s, d e lo s

p rim e ro s 1 5 núm e ro s na tura le s, una ta b la c o n va lo re s c o rre sp o nd ie nte s a
la s sig uie nte s func io ne s m a te m á tic a s
EXPLIC AC IO N DEL PRO G RAMA: e l p ro g ra m a c a lc ula la s func io ne s

m a te m á tic a s c o rre sp o nd ie nte s a la ta b la a nte rio r, p a ra e llo se ha c e uso
d e un c ic lo fo r d e l 1 a l 15 y se c a lc ula va lo re s c o n la c la se Ma th. Existe n
func io ne s a l fina l d e la c la se a 29 p a ra re a liza r d ic ha s o p e ra c io ne s. Pa ra
p o d e r d e sp le g a r lo s re sulta d o s c o n 4 d e c im a le s se d e fine un fo rm a to
d e c im a l y se lo utiliza a l m o m e nto d e d e sp le g a r e l num e ro .

import java.io.*;
public class a29
{
{
double x;
DecimalFormat df = new DecimalFormat("0.0000");
System.out.println("TABLA DE VALORES");
System.out.println("No Sen(x) Cos(X) Tan(X) log(x) log10(x)
sqrt(x)");
for(x=1;x<=15;x++)
{System.out.println(df.format(x)+" "+df.format(seno(x))+"
"+df.format(coseno(x))+" "+df.format(tangente(x))+" "+df.format(lognep(x))+"
"+df.format(logdec(x))+" "+df.format(raiz(x)));
}
}
public static double seno(double x)

{double r;
r=Math.sin(x);
return r;
}
public static double coseno(double x)

{double r;
r=Math.cos(x);
return r;
}
public static double tangente(double x)

{double r;
r=Math.tan(x);
return r;}
public static double raiz(double x)

{double r;
r=Math.sqrt(x);
return r;}
public static double lognep(double x)
{double r;
r=Math.log(x);
return r;}
public static double logdec(double x)
{double r;
r=Math.log(x)/Math.log(10);
return r;}
}
13. Re a liza r un p ro g ra m a p a ra c a lc ula r y d e sp le g a r d e 15 núm e ro s re a le s c o n

d o s d e c im a le s, q ue se g e ne ra n a le a to ria m e nte , una ta b la c o n va lo re s
c o rre sp o nd ie nte s a la s sig uie nte s func io ne s:
TABLA DE VALO RES

------------------------------------------------------------------------------------
No . C e il(x) Flo o r(x) Po w (x, 2) Po w (10,x)
-------------------------------------------------------------------------------------
EXPLIC AC IO N DEL PRO G RAMA: Este p ro g ra m a g e ne ra la ta b la m o stra d a

a rrib a , utiliza nd o una lib re ria p a ra q ue lo s num e ro s g e ne ra d o s so lo
m ue stre n 2 d e c im a le s e n ve z d e to d o s lo s d e c im a ls q ue g e ne ra ra nd o m .
Se utiliza ro n va ria s func io ne s vo id p a ra c a lc ula r c a d a d a to re q ue rid o .
Po r e je m p lo , si g e ne ra e l num e ro 2.3, la func io n c e il m o stra ra su va lo r
e nte ro inm e d ia to infe rio r (e s d e c ir, 2), la func io n flo o r m o stra ra su va lo r
e nte ro inm e d ia to sup e rio r (e s d e c ir, 3). Po w (2,x)a ra e l num e ro d o s a la x-
e sim a p o te nc ia (2^2.3) y p o w (10,x) e le va ra x a la d e c im a p o te nc ia
(2.3^10)


import java.io.*;
import java.math.*;
public class a30
{
{
double y;
int x;
System.out.println(" TABLA DE VALORES");
System.out.println("-----------------------------------------------------------------");
System.out.println("No. Ceil(x) Floor(X) Pow(x,2) Pow(10,x)");
System.out.println("-----------------------------------------------------------------");
for(x=1;x<=15;x++)
{y=(double)(Math.random()*100);
System.out.println(x+" "+df.format(ceil(y))+" "+df.format(floor(y))+"
"+df.format(pow(y))+" "+df.format(pow2(y)));
}
}
public static double ceil(double x)

{long d;
d=(long)x;
return d;
}
public static double floor(double x)

{long j;
j=(long)x;
if (x%j==0)
{return x;}
else
{x=x+1;
j=(long)x;
return j;}
}
public static double pow(double x)

{double bb;
bb= Math.pow(x,2);
return bb;
}
public static double pow2(double x)

{double ss;
ss= Math.pow(10,x);
return ss;
}
}


1. Usa nd o func io ne s y la se nte nc ia switc h, e sc rib ir un p ro g ra m a q ue
p id a lo s d a to s ne c e sa rio s y c a lc ule e l á re a y e l p e rím e tro p a ra c a d a
fig ura ind ic a d a .
a ) Un c ua d ra d o b ) Un re c tá ng ulo c ) Un triá ng ulo d ) Un c írc ulo
2. Ela b o re un p ro g ra m a q ue c a lc ule e l a re a d e un tria ng ulo m e d ia nte

la fo rm ula :
Area = p( p − a )* ( p − b )( p − c )
la d o s d e l tria ng ulo . Pa ra q ue e l tria ng ulo e xista , d e b e c um p lirse

d o nd e p e s e l se m ip e rim e tro , p =(a +b +c )/ 2, sie nd o a , b , c lo s tre s
q ue lo s la d o s se a n to d o s p o sitivo s, y a d e m á s q ue la sum a d e d o s
la d o s c ua le sq uie ra se a m a yo r q ue e l o tro la d o .
3. Dise ña r una func ió n q ue c a lc ule e l p ro m e d io d e va rio s núm e ro s

intro d uc id o s p o r e l te c la d o . Ha c e r d o s ve rsio ne s, una p a ra un
núm e ro fijo d e va lo re s y o tra p a ra un núm e ro c ua lq uie ra .d e va lo re s.
4. Esc rib ir una func ió n q ue inte rc a m b ie e l va lo r d e d o s va ria b le s, e s

d e c ir si X=5 e Y=7 tra s a p lic a r la func ió n, p o r e je m p lo ha c ie nd o
"inte rc a m b ia r(X,Y)" se tie ne q ue X=7 e Y=5.
5. Dise ña r una func ió n q ue c a lc ule la p o te nc ia e né sim a d e un núm e ro ,

e s d e c ir q ue c a lc ule X n p a ra X re a l y n e nte ro .
6. Esc rib a una func ió n c o n re to rno q ue d e te rm ine si un num e ro e s c ub o

p e rfe c to (un c ub o p e rfe c to e s a q ue l num e ro q ue la sum a d e sus
d íg ito s e le va d o s a l c ub o re p ro d uc e e l m ism o num e ro . Ej: 13 + 53 +
3 3 = 153 , e n c a so d e se rlo re to rne 1 o 0 si no lo e s.

7. Esc rib a una func ió n VO ID q ue o b te ng a la sum a d e lo s n p rim e ro s

p a re s p rimo s.
8. Le e r un núm e ro e nte ro y d e te rm ina r si e l m ism o e s un num e ro

c a p ic úa e m p le a r una func ió n c o n re to rno (1 si e s c a p ic úa , 0 si no lo
e s).
9. Esc rib ir una func ió n c o n re to rno q ue e nc ue ntre la ra íz c ua d ra d a d e

un núm e ro e m p le a nd o e l m é to d o d e Ne w to n.
10. Esc rib ir una func ió n c o n re to rno p a ra d e te rm ina r si 3 núm e ro s le íd o s

d e sd e e l te c la d o fo rm a n un tria ng ulo (re to rna r 1 si a sí lo fue ra n y 0 d e
no se r a sí), lue g o m e d ia nte una se g und a func ió n c o n re to rno
d e te rmina r si fo rma n un tria ng ulo e q uilá te ro (1), isó sc e le s(2) o
e sc a le no (3). Lo s va lo re s q ue a p a re c e n e ntre p a ré nte sis so n lo s
va lo re s a re to rna r.

Arreglos
Lo s sig uie nte s p ro g ra m a s, fue ro n re a liza d o s utiliza nd o a rre g lo s o

ve c to re s. Me d ia nte e l uso d e e ste tip o d e va ria b le s se re so lvie ro n e sto s
p ro b le m a s.
1. Esc rib ir un p ro g ra m a q ue lle ne un ve c to r c o n una lista d e núm e ro s d e l 1 a l

20, lue g o d e sp lie g ue e ste ve c to r ind ic a nd o a la d e re c ha d e c a d a uno si e s
d ivisib le p o r 3 o no .
EXPLIC AC IO N DEL PRO G RAMA: En e ste p ro g ra m a no e xiste la e ntra d a d e

d a to s. G e ne ra un lista d o d e núm e ro s e n lo s q ue se d e te rm ina si so n o no
m últip lo s d e 3. Pa ra d e te rm ina r e sto , se a na liza e l re sto d e la d ivisió n d e
c a d a num e ro d e l ve c to r e ntre 3, si e ste e s c e ro , e l num e ro e s m últip lo .

import java.io.*;
public class a31
{
public static void main(String args[])
{
int[]vector=new int[20];
int n=20;
for(int i=0;i<n;i++)//llenado del vector
{
vector[i]=i+1;
}
for(int i=0;i<n;i++)
{
if (vector[i]%3==0)
System.out.println(vector[i]+" es Divisible por 3");
else
System.out.println(vector[i]+" No es divisible por 3");
}
}}

2. Esc rib ir un p ro g ra m a q ue lle ne un ve c to r c o n la sig uie nte se c ue nc ia

num é ric a : 1, 5, 3, 7, 5, 9, 7, ..., 23. La se c ue nc ia d e b e d e te ne rse a l lle g a r a l
23. Lue g o d e sp le g a r e l ve c to r e n p a nta lla .
EXPLIC AC IÓ N DEL PRO G RAMA: Este p ro g ra m a no s p e rm ite g e ne ra r la se rie

ya a nte s m e nc io na d a y p o d e rla lle na r e n un ve c to r y a su ve s m o stra rla .

class A_32
{public static void main (String args [])
{
int [] vector = new int [100];
int s = 1;
vector [0] = 1;
for (int i = 1 ; i <= 20 ; i++)
{
if (i % 2 != 0)
{
s = s + 4;
vector [i] = s;
}
if (i % 2 == 0)
{
s = s - 2;
vector [i] = s;
}}
for (int j = 0 ; j < 20 ; j++)
System.out.print (" " + vector [j]);
}}
3. Ha c e r un p ro g ra m a q ue le a 10 va lo re s e nte ro s e n un a rra y d e sd e e l
te c la d o y c a lc ule y m ue stre : la sum a , e l va lo r m e d io , e l m a yo r y e l m e no r
EXPLIC AC IO N DEL PRO G RAMA: El p ro g ra m a le e 10 va lo re s d e sd e te c la d o y

c a lc ula la sum a d e e sto s, e l va lo r m e d io , e l m a yo r y e l m e no r, p a ra e sto se
utiliza un c ic lo p a ra lle na r una a rre g lo p re via m e nte d e c la ra d o ,
p o ste rio rm e nte m e d ia nte c o m p a ra c io ne s sim p le s y lue g o d e d e c la ra r 2
va ria b le s q ue se rá n e l m a yo r y e l m e no r y utiliza nd o un c ic lo fo r, se ha lla e l
m a yo r y m e no r va lo re s.


//Arreglo
import java.io.*;
public class a33
{
{BufferedReader in;
int suma=0,prom,aux1,aux2;
System.out.println("INGRESE LOS 10 VALORES DEL ARREGLO ");
for(int i=1;i<=10;i++)
{vector[i]=Integer.parseInt(in.readLine());
suma=suma+vector[i];
}
prom=suma/10;
aux1=vector[1];
aux2=vector[1];
for(int j=1;j<=10;j++)
{if(vector[j]>aux1)
aux1=vector[j];
else
;
if(vector[j]<aux2)
aux2=vector[j];
}
System.out.println("LA SUMA DEL ARREGLO ES: "+suma);

System.out.println("EL VALOR MEDIO DEL ARREGLO ES: "+prom);
System.out.println("EL MAYOR VALOR ES: "+aux1);
System.out.println("EL MENOR VALOR ES: "+aux2);
}
}
4. Dise ña r e im p le m e nte un p ro g ra m a p a ra inte rc a la r lo s e le m e nto s d e d o s

ve c to re s A y B, c uyo s e le m e nto s e stá n o rd e na d o r d e m e no r a m a yo r y q ue
dé c o mo re sulta d o o tro ve c to r C o rd e na d a a sc e nd e nte m e nte sin
e le m e nto s re p e tid o s. De sp le g a r e n p a nta lla lo s tre s ve c to re s.
EXPLIC AC IO N DEL PRO G RAMA: Este p ro g ra m a p e rm ite a l usua rio c re a r d o s

ve c to re s, lue g o e sto s so n o rd e na d o s a sc e nd e nte m e nte m e d ia nte el
m e to d o she ll so rt y lo s m ue stra . Lue g o e l p ro g ra m a c re a un te rc e r ve c to r
d o nd e se g ua rd a n lo s e le m e nto s no re p e tid o s d e c a d a uno d e lo s d o s
ve c to re s, lo o rd e na y lo m ue stra .

import java.io.*;
public class a34

{
{BufferedReader in;
int[]a=new int[100];
int[]b=new int[100];
int[]c=new int[200];
int k,aux,cc=0,cia=0,cib=0,pg=0;
System.out.println("Introduzca la longitud del primer y segundo vector: ");
int m=Integer.parseInt(in.readLine());
System.out.println("Introduzca los datos del primer vector(1-100): ");
{a[i]=Integer.parseInt(in.readLine());}
System.out.println("Introduzca los datos del segundo vector(1-100): ");
for(int f=0;f<m;f++)
{b[f]=Integer.parseInt(in.readLine());}
k=n/2;
while (k>0)
{ for(int x=0;x<n;x++)
{if((k+x)<=(n-1))
{if (a[x]>a[x+k])
{aux=a[x+k];
a[x+k]=a[x];
a[x]=aux;
cc=cc+1;}}}
if (cc==0)
k=(int)(k/2);
cc=0;}
k=m/2;
while (k>0)
{ for(int x=0;x<m;x++)
{if((k+x)<=(m-1))
{if (b[x]>b[x+k])
{aux=b[x+k];
b[x+k]=b[x];
b[x]=aux;
cc=cc+1;}}}
if (cc==0)
k=(int)(k/2);
cc=0;}
pg=0;
for (int nb=0;nb<n+m;nb++)
{c[nb]=0;}
{for (int nb=0;nb<n+m;nb++)
{if (a[i]==c[nb])
{cia++;}}
if (cia==0)
{c[pg]=a[i];
cia=0;
pg=pg+1;}
else
{cia=0;}}
for (int i=0;i<m;i++)
{if (b[i]==c[nb])
{cib++;}}
if (cib==0)
{c[pg]=b[i];
cib=0;
pg=pg+1;}
else
{cib=0;}}
k=(m+n)/2;
while (k>0)
{ for(int x=0;x<m+n;x++)
{if((k+x)<=(n+m-2))
{if (c[x]>c[x+k])
{aux=c[x+k];
c[x+k]=c[x];
c[x]=aux;
cc=cc+1;}}}
if (cc==0)
k=(int)(k/2);
cc=0;}
System.out.println("Los vectores son: ");
for(int f=0;f<n;f++)
{System.out.print(a[f]+" ");}
System.out.println("");
for(int i=0;i<m;i++)
{System.out.print(b[i]+" ");}
for(int i=0;i<pg;i++)
{System.out.print(c[i]+" ");}
}
}
5. Esc rib ir un p ro g ra m a p a ra q ue c a lc ule unió n, inte rse c c ió n y d ife re nc ia d e

d o s ve c to re s d e e nte ro s A y B d e ta m a ño m á xim o 10. El p ro g ra m a d e b e
p e rm itir la inic ia liza c ió n d e lo s ve c to re s d e sd e e l te c la d o .
EXPLIC AC IO N DEL PRO G RAMA: Este p ro g ra m a no ultilza func io ne s, e sta

d ivid id o e n c ua tro se c c io ne s. La p rim e ra e s la e ntra d a d e d a to s d e lo s
ve c to re s c o n c ic lo s fo r. La se g und a e s la o b te nc ió n d e l ve c to r unió n. Un
ve c to r e n e l c ua l se ira n g ra b a nd o to d o s lo s d a to s d e a m b o s ve c to re s. La
te rc e ra p a rte e s m o stra r lo s ve c to re s y su unió n. La c ua rta p a rte m ue stra la

inte rse c c ió n g ra b a d a ta m b ié n e n un ve c to r(a ib ) y p o r ultim o se m ue stra n

la s d ife re nc ia s a -b y b -a sie nd o a y b lo s ve c to re s c o nte nie nd o lo s va lo re s
ing re sa d o s.
//Programa realizado por Andres Prudencio R.

import java.io.*;
public class a35
{
{BufferedReader in;
int[]a=new int[10];
int[]b=new int[10];
int[]c=new int[20];//vector union
int[]aib=new int[10];
int k,aux,cc=0,cia=0,cib=0,pg=0,n,m;
//entrada de datos
System.out.print("Introduzca el tamanio de los vectores: ");
n=Integer.parseInt(in.readLine());
m=n;
System.out.println("Introduzca los datos del primer vector(1-10): ");
System.out.println("Introduzca los datos del segundo vector(1-10): ");
for(int f=0;f<m;f++)
{b[f]=Integer.parseInt(in.readLine());}
//obtencion del vector union
k=n/2;
while (k>0)
{if((k+x)<=(n-1))
{if (a[x]>a[x+k])
{aux=a[x+k];
a[x+k]=a[x];
a[x]=aux;
cc=cc+1;}}}
if (cc==0)
k=(int)(k/2);
cc=0;}
k=m/2;
while (k>0)
{ for(int x=0;x<m;x++)
{if((k+x)<=(m-1))
{if (b[x]>b[x+k])
{aux=b[x+k];
b[x+k]=b[x];
b[x]=aux;
cc=cc+1;}}}
if (cc==0)
k=(int)(k/2);
cc=0;}
pg=0;
for (int nb=0;nb<n+m;nb++)

{c[nb]=0;}
{if (a[i]==c[nb])
{cia++;}}
if (cia==0)
{c[pg]=a[i];
cia=0;
pg=pg+1;}
else
{cia=0;}}
for (int i=0;i<m;i++)
{if (b[i]==c[nb])
{cib++;}}
if (cib==0)
{c[pg]=b[i];
cib=0;
pg=pg+1;}
else
{cib=0;}}
k=(m+n)/2;
while (k>0)
{ for(int x=0;x<m+n;x++)
{if((k+x)<=(n+m-2))
{if (c[x]>c[x+k])
{aux=c[x+k];
c[x+k]=c[x];
c[x]=aux;
cc=cc+1;}}}
if (cc==0)
k=(int)(k/2);
cc=0;}
//mostrar vectores
System.out.println("Los vectores son: ");
for(int f=0;f<n;f++)
{System.out.print(a[f]+" ");}
for(int i=0;i<m;i++)
{System.out.print(b[i]+" ");}
System.out.println("Union:");
for(int i=0;i<pg;i++)
{System.out.print(c[i]+" ");}
int i,p=0;
//obtiene y muestra la interseccion
for (i=0;i<n;i++)
{for(int j=0;j<n;j++)
{if (a[i]==b[j])
{aib[p]=b[j];
p++;}//contador de elementos en la interseccion
}
}
if (p==0)
System.out.print("No existen elementos comunes");
else
{System.out.print("Interseccion de A y B ");
for (i=0;i<p;i++)
System.out.print(aib[i]+"");}
//Diferencia A-B las diferencias se basan en las interseccion
System.out.print("A-B: ");
int y=0;
for (i=0;i<n;i++)
{for(int j=0;j<p;j++)
{if (a[i]==aib[j])
{y++;}}
if (y==0)
System.out.print(a[i]+" ");
y=0;
}
//Diferencia B-A
System.out.print("B-A: ");
y=0;
for (i=0;i<n;i++)
{for(int j=0;j<p;j++)
{if (b[i]==aib[j])
{y++;}}
if (y==0)
System.out.print(b[i]+" ");
y=0;
}}}
6. Re a lic e un p ro g ra m a q ue le a d o s ve c to re s d e sd e te c la d o y p ro d uzc a
c o m o sa lid a e l p ro d uc to ve c to ria l d e lo s mism o s.
EXPLIC AC IÓ N DEL PRO G RAMA: Este p ro g ra m a no s p e rm ite lle na r d o s

ve c to re s, re a liza r e l p ro d uc to ve c to ria l e ntre e llo s y e n un te rc e r ve c to r
g ua rd a r y m o stra r e s m ism o .

import java.io.*;
public class A_36
{

{
BufferedReader in;


int n,m;
System.out.println("introduzca el tama^o de los vectores: ");

int [] vector1 = new int [20];
{System.out.println("introduzca valores del vector 1: ");
vector1[i]=m;}
for(int j=0;j<n;j++)
{System.out.println("introduzca valores del vector 2: ");
vector2[j]=m;}
for(int k=0;k<n;k++)
{
vector3[k]=vector1[k]*vector2[k];
}
System.out.println("El producto vectorial de los dos vectores ingresados es");
for(int h=0;h<n;h++)
System.out.print(" "+vector3[h]);
}}
7. Re a lic e un p ro g ra m a q ue le a d o s ve c to re s d e sd e te c la d o y p ro d uzc a
c o m o sa lid a la sum a d e lo s m ism o s
EXPLIC AC IO N DEL PRO G RAMA: e l p ro g ra m a c a lc ula la sum a d e 2 ve c to re s

intro d uc id o s p o r te c la d o , p a ra e llo g ua rd a la sum a e n un nue vo ve c to r c y
fina lm e nte d e sp lie g a d ic ho ve c to r. Se utiliza n c ua tro c ic lo s fo r, uno p a ra
ing re sa r e l p rim e r a rre g lo , o tro p a ra e l se g und o , o tro p a ra c a lc ula r la sum a
d e d ic ho s ve c to re s, fina lm e nte o tro p a ra d e sle g a r e l ve c to r q ue c o ntie ne la
sum a .

import java.io.*;
public class a37
{
{BufferedReader in;
int[]b=new int[100];
int[]c=new int[100];
int n;
System.out.println("INGRESE EL TAMANO DE LOS ARREGLOS (IGUAL TAMANO)");

n =Integer.parseInt(in.readLine());
System.out.println("INGRESE EL ARREGLO 1");
for(int q=1;q<=n;q++)
{a[q]=Integer.parseInt(in.readLine());
}
for(int w=1;w<=n;w++)
{b[w]=Integer.parseInt(in.readLine());
}
for(int i=1;i<=n;i++)
{c[i]=a[i]+b[i];
}
System.out.println( " LA SUMA DE LOS ARREGLOS ES: ");
for(int j=1;j<=n;j++)
{System.out.print(c[j]+" ");
}
}
}
8. Re a lic e un p ro g ra m a q ue le a un ve c to r d e sd e te c la d o y p ro d uzc a c o m o
sa lid a e l p ro d uc to e sc a la r d e l m ism o .
EXPLIC AC IO N DEL PRO G RAMA: Este p ro g ra m a m ultip lic a lo s e le m e nto s d e l

ve c to r ing re sa d o y no s m ue stra e l re sulta d o a tra vé s d e una se nte nc ia fo r
//programa realizado por Ignacio salgado Faller

import java.io.*;
public class a38
{
{BufferedReader in;
long sum=0;
System.out.println("Introduzca la longitud del vector: ");
System.out.println("Introduzca los datos del vector(1-100): ");
{sum=sum+(a[i]*a[i]);}
System.out.println("El producto escalar es: "+sum);
}
}

9. Se tie ne n N te m p e ra tura s a lm a c e na d o s e n un ve c to r, se d e se a c a lc ula r su

m e d ia , la d e svia c ió n e stá nd a r y c uá le s d e la s te m p e ra tura s so n infe rio re s a
la m e d ia .
EXPLIC AC IÓ N DEL PRO G RAMA: Este p ro g ra m a no s p e rm ite g ua rd a r e n un

ve c to r n te m p e ra tura s ing re sa d a s p o r te c la d o y a sub e s p o d e r c a lc ula r su
m e d ia , su d e svia c ió n e stá nd a r y a d e m á s ve rific a r y m o stra r to d a s a q ue lla s
te m p e ra tura s q ue se e nc ue ntre n p o r d e b a jo d e su m e d ia .

import java.io.*;
public class A_40
{

{
BufferedReader in;
double g=0, f, t, p, e,n, m, s = 0, aux;
System.out.println ("introduzca el numero de temperaturas a registrar: ");

double [] vector = new double [20];
for (int i = 0 ; i < n ; i++)
{
System.out.println ("introduzca las temperaturas: ");
m = (Double.valueOf (in.readLine ())).doubleValue ();
vector [i] = m;
s = s + m;
}
aux = s/n;
System.out.println ("La temperatura media es: " + aux);
System.out.println ("Las temperaturas por debajo de la temperatura media son: ");
for (int k = 0 ; k < n ; k++)
{
if (vector [k] < aux)
System.out.print (" " + vector [k]);
g = g+Math.pow((vector [k] - aux),2);
}
p =g/n;
e = Math.sqrt (p);
System.out.println ();
System.out.println ("La desviacion es: " + e);
}}

10. Esc rib ir un p ro g ra m a p a ra g e ne ra r un ve c to r d e 20 e le m e nto s c o n núm e ro s

a le a to rio s re a le s(c o n d o s d e c ima le s) y lue g o ha lla r e l m á xim o y m ínim o
e le m e nto .
EXPLIC AC IO N DEL PRO G RAMA: Este p ro g ra m a g e ne ra un ve c to r a le a to rio ,

e l c ua l e s lle na d o c o n núm e ro s re a le s. Lue g o ha lla e l m inim o y e l m á xim o
va lo r a tra vé s d e c o m p a ra c io ne s utiliza nd o if-e lse .

import java.io.*;
import java.math.*;
public class a41
{
{
double[]vector=new double[20];
double a=vector[0];
double b=200;
for (int i=0;i<20;i++)
{vector[i]=(double)(Math.random()*100);
if (vector[i]>a)
{a=vector[i];}
if (vector[i]<b)
{b=vector[i];}
}
System.out.println("El vector es: ");
for (int o=0;o<20;o++)
{System.out.print(df.format(vector[o])+" ");}
System.out.println("El mayor es: "+df.format(a));
System.out.println("El menor es: "+df.format(b));
}}
11. Ela b o re un p ro g ra m a q ue inse rte un e le m e nto e n un a rre g lo o rd e na d o .

Pe nsa r e n un m é to d o d istinto a l se c ue nc ia l.
EXPLIC AC IO N DEL PRO G RAMA: Este p ro g ra m a inse rta un e le m e nt a un

a rre g lo intro d uc id o p o r e l usua rio . El m ism o e s o rd e na d o a nte s y d e sp ué s d e
ing re sa r e l nue vo e le m e nto y m o stra d o e n a m b a s o c a sio ne s.

import java.io.*;
public class a42
{
{BufferedReader in;
int[]a=new int[100],dig;
int sum=0,k,aux,cc=0;
System.out.println("Introduzca los datos del vector(1-100): ");
System.out.println("Su vector ordenado es: ");
k=n/2;
while (k>0)
{if((k+x)<=(n-1))
{if (a[x]>a[x+k])
{aux=a[x+k];
a[x+k]=a[x];
a[x]=aux;
cc=cc+1;}}}
if (cc==0)
k=(int)(k/2);
cc=0;}
{System.out.print(a[i]+" ");}
System.out.println("Que numero desea ingresar? ");
a[n]=Integer.parseInt(in.readLine());
System.out.println("Su nuevo vector es: ");
k=n/2;
while (k>0)
{if((k+x)<=(n))
{if (a[x]>a[x+k])
{aux=a[x+k];
a[x+k]=a[x];
a[x]=aux;
cc=cc+1;}}}
if (cc==0)
k=(int)(k/2);
cc=0;}
for(int i=0;i<=n;i++)
{System.out.print(a[i]+" ");}
}
}
12. Re a liza r un p ro g ra m a q ue p e rm ita c a lc ula r e l p ro d uc to e sc a la r d e d o s

ve c to re s d e d im e nsió n 2000 e n lo s c ua le s a l m e no s 99% d e sus e le m e nto s
so n c e ro .

EXPLIC AC IÓ N DEL PRO G RAMA: Este p ro g ra m a g e ne ra un ve c to r d e

ta m a ño 2000 e n e l q ue 99% d e sus e le m e nto s so n c e ro s. Prim e ro se
e sta b le c e n lo s lim ite s y d e sp ue s e l lle na d o d e d a to s e n c a d a ve c to r p a ra
p ro c e d e r a l p ro d uc to e sc a la r.
// Programa realizado por Ignacio Salgado Faller

import java.io.*;
public class a43
{
{BufferedReader in;
int n=2000,nca=0,pos=0,ncb=0,xx=2000,yy=2000;
int[]a=new int[n];
int[]b=new int[n];
int[]auxa=new int[n];
int[]auxb=new int[n];
{auxa[i]=0;
auxb[i]=0;
a[i]=0;
b[i]=0;
}
nca=(int)(Math.random()*20+1980);
ncb=(int)(Math.random()*20+1980);
xx=xx-nca;
yy=yy-ncb;
for (int u=1;u<=xx;u++)

{pos=(int)(Math.random()*1999);
if (auxa[pos]==0)
{a[pos]=(int)(Math.random()*100);
auxa[pos]=1;}
else
{u=u-1;}}
for (int g=1;g<=yy;g++)

{pos=(int)(Math.random()*1999);
if (auxb[pos]==0)
{b[pos]=(int)(Math.random()*100);
auxb[pos]=1;}
else
{g=g-1;}}
int pc=0;
{
pc=pc+(a[i]*b[i]);
}
System.out.print("Producto escalar: "+pc); }}

13. Re a lic e un p ro g ra m a q ue e limine e le m e nto s d up lic a d o s d e una lista y p o r

c a d a e le m e nto ind iq ue la c a ntid a d d e ve c e s q ue se re p ite e n la lista .
EXPLIC AC IÓ N DEL PRO G RAMA: Este p ro g ra m a no s p e rm ite e limina r lo s

e le m e nto s re p e tid o s d e un a rre g lo y a su ve s no s info rm a so b re c ua nta s
ve c e s se re p itió e l e le m e nto .

import java.io.*;
public class A_44
{

{
BufferedReader in;
int n, m;
System.out.println ("introduzca la cantidad de numeros a verificar: ");

for (int i = 0 ; i < n ; i++)
{
System.out.println ("introduzca los valores: ");
m = Integer.parseInt (in.readLine ());
vector [i] = m;
}System.out.print ("El vector es:");
for (int j = 0 ; j < n ; j++)
{
}
for (int k = 0 ; k < n ; k++)
{
int c = 0;
for (int l = k + 1 ; l < n ; l++)
{
if (vector [k] == vector [l])
{
c++;
vector [l] = 0;
}}
if (vector [k] != 0)
{
System.out.println ("El numero " + vector [k] + " " + "Se repite " + c +
"veces");
}}
System.out.println (" ");
System.out.print ("El vector sin elementos repetidos es:");

for (int q = 0 ; q < n ; q++)

{
System.out.print (" " + vector [q]);}}}
14. De sa rro lla r un p ro g ra m a q ue utilic e func io ne s p a ra g e ne ra r d o s ve c to re s A

y B d e 20 va lo re s c a d a uno , ta l q ue :
a ) Me d ia nte una func ió n c a lc ula r C (i)=A(i)+B(i)

b ) Me d ia nte o tra d e sp le g a r e n p a nta lla lo s ve c to re s A,B,C , inc luye nd o
lo s e nc a b e za d o s q ue uste d c re a c o nve nie nte
EXPLIC AC IO N DEL PRO G RAMA: e l p ro g ra m a g e ne ra la s se rie s p ro p ue sta s

m e d ia nte func io ne s, la se g und a e s la se rie d e Fib o na c c i. Utiliza nd o
func io ne s c a lc ula e n un nue vo ve c to r la sum a d e la s se rie s y fina lm e nte
d e sp lie g a c a d a ve c to r

import java.io.*;
public class a45
{
public static void main (String args[])
{
int n=20;
int[]a=new int[n];
int[]b=new int[n];
int[]c=new int[n];
llena_a(n,a);
llena_b(n,b);
calcula(n,a,b,c);
muestra(n,a,b,c);
}
public static void llena_a(int n,int a[])
{ int h=1,f=0;
while(f<n)
{
for (int j=1;h>=j;j++)
{ if(f<n)
a[f]=h;
f++;}
h++;
}
public static void llena_b(int n,int b[])

{int e=0,r=1,aux;
{b[i]=e;
aux=e;
e=e+r;
r=aux;}}
public static void calcula(int n,int a[],int b[],int c[])

{for (int i=0;i<n;i++)
c[i]=a[i]+b[i];}
public static void muestra(int n,int a[],int b[],int c[])
{System.out.println("Vector A:");
for (int o=0;o<n;o++)
{System.out.print(a[o]+" ");}
System.out.println("Vector B:");
{System.out.print(b[o]+" ");}
System.out.println("Vector C:");
{System.out.print(c[o]+" ");}
}}
15. Esc rib ir un p ro g ra m a p a ra q ue se lle ne un ve c to r c o n N núm e ro s a le a to rio s

re a le s, o tra func ió n d e sp lie g ue e n p a nta lla e l c o nte nid o d e l ve c to r, c o n
o tra func ió n se b usq ue e l m e no r y m a yo r e le m e nto , m e d ia nte o tra func ió n
se sum e lo s va lo re s d e l ve c to r.
EXPLIC AC IO N DEL PRO G RAMA: Este p ro g ra m a lle na un ve c to r c o n núm e ro s

a le a to rio s m e d ia nte una se nte nc ia fo r y lue g o re a liza c o m p a ra c io ne s p a ra
m o stra r e l m e no s y e l m a yo r va lo r.

import java.io.*;
public class a46
{
{BufferedReader in;
double[]a=new double[100];

double sum=0;
double ax=0;
double b=200;
{a[i]=(double)(Math.random()*100);
sum=sum+a[i];
if (a[i]>ax)
{ax=a[i];}
if (a[i]<b)
{b=a[i];}}
System.out.println("El vector es: ");
{System.out.print(df.format(a[o])+" ");}
System.out.println("El mayor es: "+df.format(ax));
System.out.println("La suma es: "+df.format(sum));
}}
16. Esc rib ir un p ro g ra m a p a ra q ue m e d ia nte una func ió n se lle ne e l ve c to r A

c o n N núm e ro s a le a to rio s e nte ro s, lue g o m e d ia nte o tra func ió n c re a r un
ve c to r B c o n lo s e le m e nto s d e A q ue o c up a n la s p o sic io ne s p a re s,
m e d ia nte una func ió n d e sp lie g ue e n p a nta lla lo s d o s ve c to re s.
EXPLIC AC IO N DEL PRO G RAMA: El p ro g ra m a p rim e ra m e nte d e te rm ina lo s

ta m a ño s d e a m b o s ve c to re s p a ra q ue la s func io ne s no im p rim a n c e ro s
e xc e d e nte s. Po ste rio rm e nte e n e l m é to d o m a in se lla m a n a la s func io ne s
e n la s c ua le s se intro d uc e n lo s d a to s p a ra c a d a ve c to r y p o ste rio rm e nte se
lo s m ue stra n. En la func ió n lle na _b , la s p o sic io ne s d e l ve c to r b va n d e d o s
e n d o s p a ra g ua rd a rla s e n e l ve c to r b c o n un c o nta d o r.

import java.io.*;
public class a47
{
System.out.print("Ingresar el tamanio del vector A: ");

int nb;
if(n%2==0)
{nb=(n/2);}
else
{nb=(n/2)+1;}
int[]a=new int[n];
int[]b=new int[n];
// funciones:
llena_a(n,a);
llena_b(n,a,b);
muestra(n,nb,a,b);
}
public static void llena_a(int n,int a[])
{for (int i=0;i<n;i++)
a[i]=(int)(Math.random()*89+10);}
public static void llena_b(int n,int a[],int b[])
{int d=0;b[0]=a[0];
int i=2;
int e=1;
while(n>i)
{b[e]=a[i];
e++;
i=i+2;}
}
public static void muestra(int n,int nb,int a[],int b[])
{for (int o=0;o<n;o++)

{System.out.print(a[o]+" ");}
for (int o=0;o<nb;o++)
{System.out.print(b[o]+" ");} }
}
17. Da d a una suc e sió n d e núm e ro s c o m p re nd id o s e ntre 1 y 100, a lm a c e na d o s

e n un ve c to r, e sc rib a un p ro g ra m a q ue c a lc ule to d o s lo s d iviso re s d e c a d a
núm e ro .
EXPLIC AC IÓ N DEL PRO G RAMA: Este p ro g ra m a no s p e rm ite lle na r un ve c to r

d e fo rm a a le a to ria n núm e ro s c o m p re nd id o s e ntre e l 1 y 100 y a d e m á s no s
c a lc ula lo s d iviso re s d e d ic ho s núm e ro s.

import java.io.*;
public class A_48
{

{
BufferedReader in;
int n, m;
System.out.println ("Ingrese el tam*o del vector: ");

for (int i = 0 ; i < n ; i++)
{
int k = (int) (Math.random () * 100 - 1);
vector [i] = k;
}
System.out.println ("El Vector es ");
for (int j = 0 ; j < n ; j++)
{
}
System.out.println (" ");
for (int d = 0 ; d < n ; d++)
{
System.out.println ("<Los divisores del> " + vector [d] + " son:");
for (int j = 1 ; j <= vector [d] ; j++)
{
if (vector [d] % j == 0)
System.out.print (" " + j + ",");
}
System.out.println();}}}
18. Ha c e r un p ro g ra m a q ue le a d ie z va lo re s e nte ro s e n un a rra y y lo s m ue stre

e n p a nta lla . De sp ué s q ue lo s o rd e ne d e m e no r a m a yo r y lo s vue lva a
m o stra r. Y fina lm e nte q ue lo s o rd e ne d e m a yo r a m e no r y lo s m ue stre p o r
te rc e ra ve z. Pa ra o rd e na r la lista usa r una func ió n q ue im p le m e nte e l
m é to d o d e la b urb uja y q ue te ng a c o m o p a rá m e tro d e e ntra d a e l tip o d e
o rd e na c ió n, d e m a yo r a m e no r o d e m e no r a m a yo r. Pa ra e l a rra y usa r una
va ria b le g lo b a l.
EXPLIC AC IO N DEL PRO G RAMA: El p ro g ra m a le e 10 e le m e nto s y lo s o rd e na

d e m e no r a m a yo r y vic e ve rsa m e d ia nte una func ió n q ue re c ib e 1 p a ra
o rd e na r d e m a yo r a m e no r y 2 p a ra o rd e na r d e m e no r a m a yo r. Fina lm e nte
d e sp lie g a e l a rre g lo y e l m ism o o rd e na d o d e la s 2 fo rm a s.

import java.io.*;
public class a68
{
{BufferedReader in;
int[]a=new int[15];
int[]b=new int[15];
System.out.println("INGRESE LOS 10 VALORES DEL ARREGLO ");
for(int i=1;i<=10;i++)
{a[i]=Integer.parseInt(in.readLine());
}
b=a;
System.out.println("EL ARREGLOS ES: ");
mostrar(a);
System.out.println("EL ARREGLO ORDENADO DE MAYOR A MENOR ES: ");
ordena(a,1);
System.out.println("EL ARREGLO ORDENADO DE MENOR A MAYOR ES: ");
ordena(b,2);
static void mostrar(int a[])

{for(int i=1;i<=10;i++)
{System.out.print(" "+a[i]);
}}
static void ordena(int a[],int k)

{int aux;
aux=a[1];
if(k==1)
//ORDENA DE MAYOR A MENOR
{
for(int i=1;i<=10;++i)
{for(int j=i;j<=10;++j)
{
if(a[i]<a[j])
{
aux=a[i];
a[i]=a[j];
a[j]=aux;
}
}}
}
//ORDENA DE MENOR A MAYOR

else
{
for(int yy=1;yy<=10;yy++)
{
for(int ii=yy;ii<=10;ii++)
{if(a[ii]<a[yy])
{aux=a[ii];
a[ii]=a[yy];
a[yy]=aux;}}}}
mostrar(a);
}
}
19. a ) Esc rib ir una func ió n q ue re a lic e una b úsq ue d a se c ue nc ia l (line a l) d e un

e le m e nto d e ntro d e un a rre g lo d e e nte ro s.
b ) Id e m p e ro p a ra Búsq ue d a Bina ria .
EXPLIC AC IO N DEL PRO G RAMA: Este p ro g ra m a no s o fre c e d o s m é to d o s

d e b úsq ue d a : la se c ue nc ia l y la b ina ria . C a d a m é to d o tie ne sus p ro p ia s
c a ra c te rístic a s.
import java.io.*;
public class a89
{
{BufferedReader in;
int[]x=new int[100];
int n;
int opc=3,bus=0,ii=0,is=0,im=0;
System.out.println("Introduzca los datos del arreglo: ");
{x[i]=Integer.parseInt(in.readLine());}
System.out.println("Ingresar el dato a buscar: ");
bus=Integer.parseInt(in.readLine());
{System.out.println("1. Buscar un dato realizando una busqueda secuencial: ");
System.out.println("2. Buscar un dato realizando una busqueda binaria: ");
System.out.println("Ingresar opcion: ");
}
switch (opc)
{case 1: for (int i=0;i<n;i++)
{if (x[i]==bus)
{System.out.println ("Se encontro el numero "+bus+" en la posicion "+(i+1));
return;}}
System.out.println ("No se encontro el elemento");
case 2: is=n-1;
while (ii<=is)
{im =(int)(ii+is)/2;
if(bus>x[im])
{ii=im+1;}

else
{if(bus<x[im])
{is=im-1;}
else
{break;}}}
if (ii>is)
{System.out.println ("Se encontro el numero "+bus);}
else
{System.out.println ("No se encontro el elemento");}
}}}
20. O b te ng a la sum a d e lo s e le m e nto s d e un a rra y line a l q ue c o ntie ne

núm e ro s e nte ro s.
EXPLIC AC IÓ N DEL PRO G RAMA: Este p ro g ra m a no s p e rm ite c a lc ula r la sum a

d e lo s e le m e nto s d e un a rre g lo ing re sa d o s p o r te c la d o .

import java.io.*;
public class B_5
{

{
BufferedReader in;
int n,m,s = 0;
System.out.println ("introduzca la cantidad de numeros a evaluar: ");

for (int i = 0 ; i < n ; i++)
{
m = Integer.parseInt(in.readLine ());
vector [i] = m;
s = s + m;
}System.out.println ("El Vector ingresado es:");
for (int i = 0 ; i < n ; i++)
{System.out.print(vector[i]+" ");}
System.out.println ("La suma de los elementos del vector es: " + s);
}}

21. Re a lic e un p ro g ra m a p a ra le e r un a rre g lo ing re sa nd o so la m e nte núm e ro s

m últip lo s d e 3 q ue ing re sa n p o r te c la d o .
EXPLIC AC IO N DEL PRO G RAMA: e l p ro g ra m a le e e l ta m a ño d e un a rre g lo y

p id e lo s va lo re s. Lo s g ua rd a e n e l a rre g lo so lo si so n m últip lo s d e 3
d e te rm ina nd o si so n o no m últip lo s d e 3 utiliza nd o la se nte nc ia % q ue e s
mo d

import java.io.*;
public class b12
{
{BufferedReader in;
int a,m,p=0;
int []c=new int [50];
System.out.println("Ingrese la cantidad de numeros a guardar en el array:");
a=Integer.parseInt(in.readLine());
for(int i=0;i<a;)
{
System.out.println("Ingrese un valor,multiplo de 3");
if(m%3==0)
{p++;
c[i]=m;
i++;
}
else
System.out.println("valor ingresado no es multiplo de 3");
}
System.out.println("el arreglo de multiplos de 3 es:");
for(int j=0;j<p;j++)
{System.out.print(c[j]+" ");
}
}
}
22. O b te ng a la sum a to ria y la m e d ia d e lo s e le m e nto s d e un a rre g lo .
EXPLIC AC IÓ N DEL PRO G RAMA: Este p ro g ra m a no s d e te rm ina la sum a y la

m e d ia d e n e le m e nto s ing re sa d o s p o r te c la d o y a su ve s g ua rd a d o s e n un
a rre g lo .

import java.io.*;
public class B_13
{
{
BufferedReader in;
int aux,n,m,s = 0;
System.out.println ("introduzca la cantidad de numeros a evaluar: ");

for (int i = 0 ; i < n ; i++)
{
m = Integer.parseInt(in.readLine ());
vector [i] = m;
s = s + m;
}aux=s/n;
System.out.println ("El Vector ingresado es:");

for (int i = 0 ; i < n ; i++)
System.out.println ("La suma de los elementos del vector es: " + s);
System.out.println ("La media de los elementos del vector es: " + aux);
}}
Aplicación de vectores – Programa estadistico
23. Re a liza r un PO O d o nd e a p liq ue func io ne s d e a c ue rd o a l re q ue rimie nto . La

c la se d e b e lla m a rse e sta d ístic a :
A Le c tura d e un a rre g lo d e n e le m e nto s.
B Sum a to ria d e lo s e le m e nto s d e l a rre g lo
C Lista d o d e lo s e le m e nto s d e l a rre g lo
D Enc o ntra r e l e le m e nto m á xim o d e l a rre g lo .
E O rd e na r e l a rre g lo .
F Enc o ntra r e l e le m e nto m ínim o d e l a rre g lo
G Enc o ntra r e l ra ng o (e le m e nto m á xim o – e le m e nto m ínim o )
H O b te ne r la m e d ia d e lo s e le m e nto s d e l a rre g lo
I La m e d ia na , e s e l va lo r q ue se p a ra p o r la m ita d lo s e le m e nto s d e l a rre g lo

o rd e na d o d e m e no r a m a yo r, d e ta l fo rm a q ue e l 50% d e e sta s so n m e no re s
q ue la m e d ia na y e l o tro 50% so n m a yo re s. Si e l núm e ro d e d a to s e s im p a r la

m e d ia na se rá e l va lo r c e ntra l, si e s p a r se to m a c o m o m e d ia na la m e d ia
a ritm é tic a d e lo s va lo re s c e ntra le s.
J Mo d a e s e l va lo r d e la va ria b le q ue m á s ve c e s se re p ite , e s d e c ir a q ue lla

c uya fre c ue nc ia a b so luta e s m a yo r, no tie ne p o rq ué se r únic a .
N Ve rific a r si lo s e le m e nto s d e l a rre g lo tie ne n una d istrib uc ió n sim é tric a . Es

sim é tric a , c ua nd o su m e d ia na , m o d a y su m e d ia a ritm é tic a c o inc id e n.
EXPLICACION DEL PROBLEMA: El programa primeramente pide el tamaño

de un vector y sus datos. Este vector será analizado, sin embargo, se puede
leer otro vector una vez que el menú de opciones se muestre en pantalla. Este
es mostrado mediante while y switch. El usuario puede escoger cualquier
opción, no necesita ejecutar todas las 13 primeras opciones para obtener el
resultado ya que si una opción tiene una función que requiere de otras, estas
serán llamadas automáticamente.
OBSERVACIONES: No se uso sobrecarga de operadores ni de funciones

import java.io.*;
public class estadistica
{
{BufferedReader in;


System.out.print("TAMANIO DEL VECTOR: ");
{
System.out.println("INGRESE EL ELEMENTO "+(i+1));
vector[i]=Integer.parseInt(in.readLine());
}
int re=1,max=0,min=0,r=0;
float media=0,moda=0,mediana=0,sum=0;
double varza=0,dt=0,CV=0;
while(re!=16)
{
System.out.println("---MENU DE OPCIONES---");
System.out.println("1. LECTURA DE OTOR ARREGLO ");
System.out.println("2. SUMATORIA DE LOS ELEMENTOS");
System.out.println("3. LISTADO DE UN ARREGLO");
System.out.println("4. ENCONTRAR EL ELEMENTO MAXIMO ");
System.out.println("5. ORDENAR EL ARREGLO DE FORMA ASCENDENTE");
System.out.println("MOSTRAR:");
System.out.println("6. EL ELEMENTO MINIMO ");
System.out.println("7. EL RANGO ");
System.out.println("8. LA MEDIA(el vector sera ordenado de forma ascendente ");
System.out.println("9. LA MEDIANA ");
System.out.println("10. LA MODA ");
System.out.println("11. LA VARIANZA ");
System.out.println("12. LA DESVIACION TIPICA ");
System.out.println("13. EL COEFICIENTE DE VARIACION");
System.out.println("14. DETERMINAR SI EL VECTOR ES SIMETRICO");
System.out.println("==> Cualquier otro numero para salir");
re=Integer.parseInt(in.readLine());
switch (re){
case 1:
lectura(n,vector);
break;
case 2:System.out.print("La suma de los elementos es: "+sumatoria(n,vector));
sum=sumatoria(n,vector);break;
case 3:listado(n,vector);break;
case 4:System.out.print("El elemento maximo es: "+maximo(n,vector));
max=maximo(n,vector);
break;
case 5:ordena(n,vector);listado(n,vector);break;
case 6:System.out.println("El elemento minimo es: "+minimo(n,vector));
min=minimo(n,vector);
break;
case 7:
minimo(n,vector);maximo(n,vector);
r=rango(max,min);System.out.println("El rango de este vector es "+r);
break;
case 8:
sum=sumatoria(n,vector);
media=omedia(n,sum);System.out.println("La media es "+media);
break;
case 9:
ordena(n,vector);
mediana=omediana(n,vector);
System.out.println("La mediana es "+mediana);
break;
case 10:
moda=omoda(n,vector);
if (moda!=0)
System.out.println("La moda es "+moda);
else
moda=omedia(n,sum)*-1;
break;
case 11:
media=omedia(n,sum);
System.out.println("Varianza: "+varianza(n,vector,media));
break;
case 12:
varza=varianza(n,vector,media);
System.out.println("Desviacion Tipica:"+dtipica(varza));
break;
case 13:
varza=varianza(n,vector,media);
dt=dtipica(varza);
System.out.println("Coeficiente de Variacion: "+cv(media,dt));
break;
case 14:
mediana=omediana(n,vector);
moda=omoda(n,vector);
if (media==mediana&&mediana==moda)
System.out.println("El vector es simetrico");
else
System.out.println("El vector no es simetrico");
break;
default:System.exit(0);
break;
}
}}
//FUNCIONES:
public static void lectura(int n,int vector[])throws IOException
{BufferedReader in;
System.out.println("Ingrese el tamano del vector");
{
System.out.println("INGRESE EL ELEMENTO "+(i+1));
vector[i]=Integer.parseInt(in.readLine());
}
}
public static int sumatoria(int n,int vector[])

{int sum=0;
for (int i=0;n>i;i++)
{sum=sum+vector[i];}
return sum;
}
public static void listado(int n,int vector[])
{
}
public static int maximo(int n,int vector[])

{int max=vector[0];
{if (vector[i]>max)
max=vector[i];}
return max;
}
public static void ordena(int n,int vector[])
{int aux;
for(int i=0;i<n;++i)
for(int j=0;j<n;++j)
{
if(vector[i]<vector[j])
{
aux=vector[i];
vector[i]=vector[j];
vector[j]=aux;
}
}
}
public static int minimo(int n,int vector[])
{int min=vector[0];
{if (vector[i]<min)
min=vector[i];}
return min;
}
public static int rango(int max,int min)
{int r=max-min;
return r;}
public static float omedia(int n,float sum)

{float media;
media=(float)(sum/n);
return media;
}
public static float omediana(int n,int vector[])
{ float mediana=0,s,nn=n;
int a1=0,a2=0,a3=0,a4=0;
if(n%2!=0)
{s=n/2;
for(int u=0;u<n;u++)
{if(u==s)
mediana=vector[u];}
return mediana;
}
else
{if(n%2==0)
a1=(n/2)-1;
a2=n/2;
for(int e=0;e<n;e++)
{ if(e==a1)
a3=vector[e];
if(e==a2)
a4=vector[e];
}
mediana=(a3+a4)/2;
}
return mediana;
}
public static float omoda(int n,int vector[])

{float moda=0;
int maxim=0,minim=0,t=0;
{minim=0;
for(int j=0;j<n;j++)
{if(i!=j)
{if(vector[i]==vector[j])
{minim++;}}}
if (minim>maxim)
{maxim=minim;
t=vector[i];
}}
minim=0;
if (maxim==minim)
{
System.out.println("No hay moda");
return 0;}
else
{
for(int k=0;k<n;k++)
{
if (t==vector[k])
{
moda=vector[k];
}}
return moda;
}
}
public static float varianza(int n,int vector[],float media)

{
float sum=0,va,sums;
float d=n;
for (int i=0;i<d;i++)
{sums=vector[i]-media;
sum=sum+(sums*sums);
}
va=sum/d;
return va;
}
public static double dtipica(double varza)
{double dt=Math.sqrt(varza);
return dt;
}
public static double cv(float media,double dt)
{double CV=dt/media;
return CV;
}
}
1. e sc rib a un p ro g ra m a q ue p e rm ita e nc o ntra r la sum a to ria d e lo s

núm e ro s im p a re s c o m p re nd id o s d e sd e 50 a 1000 g ua rd a d o s e n un
a rre g lo
2. e la b o re un p ro g ra m a q ue p e rm ita intro d uc ir 20 e le m e nto s d e tip o

e nte ro e n un a rre g lo , e l p ro g ra m a m o stra ra im p re so e l a rre g lo e n o rd e n
inve rso
3. e la b o re un p ro g ra m a q ue p e rm ita e nc o ntra r e l p rim e r y se g und o m a yo r

d e un a rre g lo d e 15 e le m e nto s

4. ha c e r un p ro g ra m a q ue le a d ie z va lo re s e nte ro s e n un a rra y y lo s
m ue stre e n p a nta lla . d e sp ué s q ue lo s o rd e ne d e m e no r a m a yo r y lo s
vue lva a m o stra r. y fina lm e nte q ue lo s o rd e ne d e m a yo r a m e no r y lo s
m ue stre p o r te rc e ra ve z. p a ra o rd e na r la lista usa r una func ió n q ue
im p le m e nte e l m é to d o d e la b urb uja
5. e la b o re un p ro g ra m a q ue e nc ue ntre a l núm e ro m a yo r y m e no r d e un
a rre g lo y lue g o m ue stre e n q ué p o sic ió n se e nc o ntra b a n e sto s núm e ro s
o rig ina lm e nte .
6. e la b o re un p ro g ra m a q ue im p rim a e n o rd e n inve rso una c a d e na d e

c a ra c te re s
7. e la b o re un p ro g ra m a q ue p e rm ita intro d uc ir un a rre g lo de 10

e le m e nto s, e l p ro g ra m a m o stra ra un histo g ra m a d e e so s d a to s (e l
histo g ra m a se inte rp re ta ra c o n la sa lid a d e n a ste risc o s d o nd e n e s e l
va lo r d e c a d a e le m e nto d e l a rre g lo ) e j: e l a rre g lo e s 2,3,4 e l histo g ra m a
se rá 2->**
3->***
4->****
8. e la b o re un p ro g ra m a q ue p e rm ita intro d uc ir un a rre g lo d e 25 e le m e nto s

d e tip o e nte ro . lue g o p e d ir a l usua rio q ue intro d uzc a un núm e ro . e l
p ro g ra m a m o stra ra e l num e ro d e ve c e s q ue se re p ite d ic ho va lo r e n e l
a rre g lo
9. e la b o re un p ro g ra m a q ue p e rm ita e nc o ntra r e l p rim e r y se g und o m e no r

d e un a rre g lo d e 15 e le m e nto s
10. e la b o re un p ro g ra m a q ue p e rm ita intro d uc ir un a rre g lo d e 8 e le m e nto s

d e tip o e nte ro . e l p ro g ra m a m o stra ra un a rre g lo e n d o nd e m ue stre un 1
p a ra lo s p rim o s y un 0 p a ra lo s no p rim o s

Matrices
Lo s sig uie nte s p ro g ra m a s utiliza n m a tric e s p a ra su so luc ió n. So n

p ro g ra m a s o rie nta d o s a la utiliza c io n y m a ne jo d e m a tric e s. Una m a triz
e s una ta b la o a rre g lo re c ta ng ula r d e núm e ro s o , m á s g e ne ra lm e nte ,
una ta b la c o nsiste nte e n c a ntid a d e s a b stra c ta s q ue p ue d e n sum a rse y
m ultip lic a rse .
1. Esc rib ir un p ro g ra m a q ue tra nsp o ng a una m a triz sin e m p le a r una m a triz

a uxilia r.
EXPLIC AC IO N DEL PRO G RAMA: e l p ro g ra m a tra nsp o ne una m a triz d e o rd e n

n,m sin usa r una m a triz a uxilia r. Pa ra lle va r a c a b o d ic ho p ro p ó sito a l
ing re sa r la m a triz se g ua rd a n la s fila s e n ve z d e c o lum na s y vic e ve rsa ,
fina lm e nte se m ue stra la m a triz tra nsp ue sta

import java.io.*;
public class a49
{
{BufferedReader in;
int[][]a=new int[50][50];
int n,m;
System.out.println("INGRESE EL NUMERO DE FILAS DE LA MATRIZ");
System.out.println("INGRESE EL NUMERO DE COLUMNAS DE LA MATRIZ");
m =Integer.parseInt(in.readLine());
System.out.println("INGRESE LA MATRIZ");
for(int f=1;f<=n;f++)
{System.out.println("INGRESE LA FILA "+f);
for(int c=1;c<=m;c++)
{
a[c][f]=Integer.parseInt(in.readLine());
}}
System.out.println( " LA MATRIZ TRANSPUESTA ES: ");
for(int q=1;q<=m;q++)
{
{System.out.print(" "+a[q][w]);
}
}
}
}
2. Esc rib ir un p ro g ra m a q ue c o p ie un a rre g lo A d e d im e nsió n N1 = N*N e n una

m a triz d e M d e o rd e n NxN, p o r fila s
EXPLIC AC IO N DEL PRO G RAMA: Este p ro g ra m a p e rm ite q ue e l usua rio

ing re se e l o rd e n d e una m a triz y lle ne a si un ve c to r c o n n*n d a to s. Una ve z
le id o s lo s d a to s, e sto s se c o lo c a n e n la m a triz y e sta se d e sp lie g a

import java.io.*;
public class a50
{
{BufferedReader in;
int cont=0;
int [][]mat=new int[100][100];
System.out.println("Introduzca el orden de la matriz: ");
System.out.println("Introduzca los "+n*n+" datos del vector: ");
for(int i=0;i<n*n;i++)
for (int j=0;j<n;j++)
{for (int k=0;k<n;k++)
{mat[j][k]=a[cont];
cont++;}
}
System.out.println("Su matriz es: ");
for (int k=0;k<n;k++)
{System.out.print(mat[j][k]+" ");}}
}
}
3. Esc rib ir un p ro g ra m a q ue m ue stre e n p a nta lla lo s e le m e nto s d e una m a triz

a l re c o rre r e sta e n e sp ira l p a rtie nd o d e sd e e l e le m e nto 1,1 e n se ntid o d e la s
a g uja s d e l re lo j.

EXPLIC AC IO N DEL PRO G RAMA: e l p ro g ra m a lle na y m ue stra una m a triz c o n

va lo re s d e sd e e l 1 ha sta e l m a x*m a x. m a x e s la va ria b le q ue d e te rm ina e l
ta m a ño d e la m a triz.
//Realizado por Andrés Prudencio R.

import java.io.*;
public class a51
{
{
BufferedReader in;
int MAX;
System.out.println ("Ingrese el orden de la matriz cuadrada");
MAX = Integer.parseInt (in.readLine ());
int [] [] a = new int [MAX] [MAX];
int i, j, k = 1;
for (int d = 1 ; d < MAX / 2 + 1 ; d++)
{
i = j = d - 1;
for (; j < MAX - d ; j++)
a [i] [j] = k++;
for (; i < MAX - d ; i++)
a [i] [j] = k++;
for (; j >= d ; j--)
a [i] [j] = k++;
for (; i >= d ; i--)
a [i] [j] = k++;
}
a [MAX / 2] [MAX / 2] = MAX * MAX;
for (i = 0 ; i < MAX ; i++)

{System.out.println ();
for (j = 0 ; j < MAX ; j++)
System.out.print (a [i] [j] + " ");
} }
}
4. Esc rib ir un p ro g ra m a q ue ve rifiq ue q ue una m a triz M d e o rd e n N*N

(c ua d ra d a ) e s una m a triz sim é tric a .
EXPLIC AC IÓ N DEL PRO G RAMA: Este p ro g ra m a no s p e rm ite ve rific a r si una

m a triz ing re sa d a d e ta m a ño n*n (c ua d ra d a ) se a sim é tric a o no .

import java.io.*;
public class A_52
{

{
BufferedReader in;
int n, h = 0;
int matriz [] [] = new int [10] [10];
System.out.println ("Ingrese el numero de filas y columnas: ");
for (int f = 0 ; f < n ; f++)
{
for (int c = 0 ; c < n ; c++)
{
System.out.println ("Introduzca un valor");
matriz [f] [c] = Integer.parseInt (in.readLine ());
}}
for (int i = 0 ; i < n ; i++)
{
for (int j = 0 ; j < n ; j++)
{
System.out.print (matriz [i] [j] + " ");
}
}
for (int i = 0 ; i < n ; i++)
{
for (int j = 0 ; j < n ; j++)
{
if (i!= j)
{
if (matriz [i] [j] != matriz [j] [i])
h++;
}}}
if (h != 0)
System.out.println ("No es simetrica");
else
System.out.println ("Es simetrica");
}}
5. Esc rib ir un p ro g ra m a p a ra q ue m e d ia nte func io ne s se lle ne una m a triz d e N

fila s p o r M c o lum na s c o n núm e ro s a le a to rio s re a le s, m o stra r e n p a nta lla la
m a triz, lue g o se sum e n la s d ia g o na le s d e e sta m a triz.
EXPLIC AC IO N DEL PRO G RAMA: e l p ro g ra m a p id e p rim e ro e l núm e ro d e fila s

y d e c o lum na s d e la m a triz, lue g o m e d ia nte un c ic lo fo r lle na la m a triz.
Fina lm e nte se utiliza n 2 va ria b le s sum 1 y sum 2 p a ra g ua rd a r la sum a d e la

d ia g o na l p rinc ip a l y se c und a rio re sp e c tiva m e nte , p a ra m o stra r fina lm e nte
la m a triz y la s sum a s d e sus d ia g o na le s.

import java.io.*;
public class a53
{
{BufferedReader in;
float[][]a=new float[100][100];
int n,m;
float sum1=0,sum2=0;
llenar(a,n,m);
System.out.println( " LA MATRIZ ES: ");
{
for(int w=1;w<=m;w++)
}
}
for(int qq=1;qq<=n;qq++)
{for(int ww=1;ww<=m;ww++)
{
if (qq==ww)
sum1=sum1+a[qq][ww];
else
;
if((qq+ww)==(n+1))
sum2=sum2+a[qq][ww];
else
;
}}
System.out.println("LA SUMA DE LA DIAGONAL PRINCIPAL ES:"+sum1);
System.out.println("LA SUMA DE LA DIAGONAL SECUNDARIA ES:"+sum2);
}
public static float[][] llenar(float a[][],int n,int m)
{for(int f=1;f<=n;f++)
{for(int c=1;c<=m;c++)
{a[f][c]=(float)Math.random()*100;}}
return a;
}
}

6. Esc rib ir un p ro g ra m a p a ra q ue m e d ia nte func io ne s se lle ne una m a triz c o n

lo s sig uie nte s núm e ro s:
⎡1 2 3 4 5 6 7 8 9⎤
⎢1 1 2 3 4 5 6 7 8 ⎥⎥
⎢
⎢1 1 1 2 3 4 5 6 7⎥
⎢ ⎥
⎢1 1 1 1 2 3 4 5 6⎥
⎢1 1 1 1 1 2 3 4 5⎥
⎢ ⎥
⎢1 1 1 1 1 1 2 3 4⎥
⎢1 1 1 1 1 1 1 2 3⎥
⎢ ⎥
⎢1 1 1 1 1 1 1 1 2⎥
⎢1 1 1 1 1 1 1 1 1 ⎥⎦
⎣
lue g o d e sp le g a r e n p a nta lla e sta m a triz.
EXPLIC AC IO N DEL PRO G RAMA: Este p ro g ra m a g e ne ra la m a triz

m e nc io na d a a rrib a p e rm itie nd o a l usua rio ing re sa r e l o rd e n d e la m ism a ,
utiliza nd o se nte nc ia s fo r e if-e lse p a ra c o m p ro b a r q ue la fila se a m a yo r o
ig ua l a la c o lum na p a ra lle na rla c o n 1’ s.

import java.io.*;
public class a54
{
{BufferedReader in;
int cont;
{cont=2;
{if (j>=k)
{mat[j][k]=1;}
else
{mat [j][k]=cont;
cont++;}}
}
}
}
7. Re a lic e un p ro g ra m a q ue le a d o s m a tric e s d e ta m a ño NxM d e sd e te c la d o ,

y d e vue lva la m ultip lic a c ió n d e d ic ha s m a tric e s.
EXPLIC AC IO N DEL PRO G RAMA: En e ste p ro g ra m a , p rim e ra m e nte se va lid a n

lo s ta m a ño s d e la s m a tric e s q ue se d e se a n m ultip lic a r, p ue sto q ue e l
núm e ro d e c o lum na s d e la p rim e ra d e b e ig ua l a l núm e ro d e fila s d e la
se g und a . Po ste rio rm e nte se le e n d a to s y se m ultip lic a n la s m a tric e s
g ua rd a nd o lo s re sulta d o s e n la m a triz c a p a ra lue g o m o stra rla .

import java.io.*;
public class a55
{
{BufferedReader in;
int[][]a=new int[100][100];
int[][]b=new int[100][100];
int[][]ca=new int[100][100];
int f=0,c=0,resp,aux,x,y,suma=0;
int fi1=0,fi2=1,co1=2,co2=0;
while(co1!=fi2)
{System.out.println("Ingrese las filas y columnas de las MATRIZ 1");
System.out.println("recuerde que las columnas de la primera deben iguales a las
filas de la segunda)");
fi1 =Integer.parseInt(in.readLine());
co1 =Integer.parseInt(in.readLine());
System.out.println("Ingrese las filas y columnas de las MATRIZ 2");
System.out.println("recuerde que las columnas de la primera deben iguales a las
filas de la segunda)");fi2 =Integer.parseInt(in.readLine());
co2 =Integer.parseInt(in.readLine());}
System.out.println("LEER MATRIZ 1");
for(int iga=1;iga<=fi1;iga++)
{System.out.println("Ingrese la fila: "+iga);
for(int jga=1;jga<=co1;jga++)
{a[iga][jga]=Integer.parseInt(in.readLine());
}}
System.out.println("LEER MATRIZ 2");
for(int iha=1;iha<=fi2;iha++)
{System.out.println("Ingrese la fila: "+iha);
for(int jha=1;jha<=co2;jha++)

{b[iha][jha]=Integer.parseInt(in.readLine());
}}
int suum=0;
for(int i1=1;i1<=fi1;i1++)
{
for(int j1=1;j1<=co2;j1++)
{
suum=0;
for(int kk=1;kk<=co1;kk++)
{suum=(suum+a[i1][kk]*b[kk][j1]);}
ca[i1][j1]=suum;
}}
for(int i=1;i<=fi1;i++)
{
for(int j=1;j<=co1;j++)
{System.out.print(" "+a[i][j]);
}
}
System.out.println(" * ");
for(int i=1;i<=fi1;i++)
{
for(int j=1;j<=co1;j++)
{System.out.print(" "+b[i][j]);
}
System.out.println();}
for(int q1=1;q1<=fi1;q1++)
{
for(int w1=1;w1<=co2;w1++)
{System.out.print(" "+ca[q1][w1]);
}
}
}}
8. Re a liza r un p ro g ra m a p a ra tra nsp o ne r lo s e le m e nto s d e una m a triz

re c ta ng ula r.
EXPLIC AC IÓ N DEL PRO G RAMA: Este p ro g ra m a no s p e rm ite tra nsp o ne r lo s

e le m e nto s d e una m a triz re c ta ng ula r utiliza nd o una se rie d e c ic lo s fo r y
c o m p a ra c io ne s.
import java.io.*;
public class A_56
{

{
BufferedReader in;
int f, c;
int matriz1 [] [] = new int [10] [10];
int matriz2 [] [] = new int [10] [10];
System.out.println ("Introduzca el numero de filas");
f = Integer.parseInt (in.readLine ());
System.out.println ("Introduzca el numero de columnas");
c = Integer.parseInt (in.readLine ());
for (int i = 0 ; i < f ; i++)

{
for (int j = 0 ; j < c ; j++)
{
matriz1 [i] [j] = Integer.parseInt (in.readLine ());
}}
System.out.println ("La matriz es");
for (int i = 0 ; i < f ; i++)
{
for (int j = 0 ; j < c ; j++)
{
System.out.print (matriz1 [i] [j] + " ");
}
}
for (int i = 0 ; i < c ; i++)
{
for (int j = 0 ; j < f ; j++)
{
matriz2 [i] [j] = matriz1 [j] [i];
}}
System.out.println ("La matriz transpuesta");
for (int i = 0 ; i < c ; i++)
{
for (int j = 0 ; j < f ; j++)
{
System.out.print (matriz2 [i] [j] + " ");
}System.out.println ();}}}
9. Re a liza r un p ro g ra m a p a ra inte rc a m b ia r d o s fila s (c o lum na s) d e una m a triz.

EXPLIC AC IO N DEL PRO G RAMA: e l p ro g ra m a inte rc a b ia 2 fila s o 2 c o lum na s

d e una m a triz, p a ra e llo utiliza un m e nú d e o p c io ne s y p id e la s fila s o la s
c o lum na s a inte rc a m b ia r, fina lm e nte m ue stra la nue va m a triz.

import java.io.*;
public class a57
{
{BufferedReader in;
int[][]a=new int[100][100];
int n,m;
int f1,f2,res,aux1,aux2;
{
a[f][c]=Integer.parseInt(in.readLine());
}}
System.out.println( " LA MATRIZ INGRESADA ES: ");

{
}
}
System.out.println( "1. INTERCAMBIAR 2 FILAS ");
System.out.println( "2. INTERCAMBIAR 2 COLUMNAS ");
res=Integer.parseInt(in.readLine());
switch (res){
case 1:
System.out.println( "INGRESE LAS 2 FILAS A CAMBIAR ");
f1=Integer.parseInt(in.readLine());
for(int ww=1;ww<=m;ww++)
{aux1=a[f1][ww];
a[f1][ww]=a[f2][ww];
a[f2][ww]=aux1;
}
break;
case 2:
System.out.println( "INGRESE LAS 2 COLUMNAS A CAMBIAR ");
for(int qq=1;qq<=n;qq++)
{aux1=a[qq][f1];
a[qq][f1]=a[qq][f2];
a[qq][f2]=aux1;
}
break;
}
System.out.println( " LA NUEVA MATRIZ ES: ");
for(int r=1;r<=n;r++)
{
for(int e=1;e<=m;e++)
{System.out.print(" "+a[r][e]);
}
}
}
}
10. De sa rro lla r un p ro g ra m a p a ra c a rg a r una m a triz d e NxM c o n núm e ro s

a le a to rio s re a le s c o n d o s d e c im a le s, lue g o ha lla r e l m á xim o (m ínim o ) va lo r
d e e sa m a triz.
EXPLIC AC IO N DEL PRO G RAMA: Este p ro g ra m a lle na una m a triz c o n

núm e ro s g e ne ra d o s a le a to ria m e nte (re a le s) y lue g o ha lla y d e sp lie g a lo s
m á xim o s y m inim o s va lo re s.
//Realizado por Ignacio Salgado Faller

import java.io.*;
import java.math.*;
public class a58
{
{BufferedReader in;
double[][]mat=new double[100][100];
int n,m;
System.out.println("Numero de filas: ");
System.out.println("Numero de columnas: ");
double a=0;
double b=200;
{for (int u=0;u<m;u++)
{mat[i][u]=(double)(Math.random()*89+10);

if (mat[i][u]>a)
{a=mat[i][u];}
if (mat[i][u]<b)
{b=mat[i][u];}
}}
System.out.println("La matriz es: ");
for (int u=0;u<m;u++)
{System.out.print(df.format(mat[i][u])+" ");}}
System.out.println("El mayor es: "+df.format(a));
}}

a le a to rio s re a le s c o n d o s d e c im a le s, lue g o fo rm a r un ve c to r fila (c o lum na )
c uyo s e le m e nto s se a n ig ua le s a la sum a to ria d e lo s e le m e nto s d e la s
c o lum na s (fila s) d e la m a triz.
EXPLIC AC IO N DEL PRO G RAMA: Prim e ra m e nte se d e te rm ina e l ta m a ño d e la

m a triz. De b e m o s c o nsid e ra r q ue e l num e ro d e c o lum na s se rá ig ua l a l
ta m a ño d e l ve c to r, e s p o r e so , q ue e n / / c re a ve c to r se p ue d e utiliza r la
m ism a va ria b le j p a ra lle na r lo s d a to s e n ve c to r. De e se m o d o so lo se utiliza
un sum a d o r(sum ) y e l re sulta d o se g ua rd a e n e l ve c to r e n la p o sic ió n j.

import java.io.*;
import java.math.*;
public class a59
{
float[][]a=new float[100][100];
int n,m;

System.out.print("Ingresar el tamanio de la matriz(n x m).n= ");
//System.out.println();
System.out.print("m= ");
float[]vf=new float[m];

{for(int j=0;j<m;j++)
{a[i][j]=(float)(Math.random()*99+0);}}
{System.out.println();
for(int j=0;j<m;j++)
{System.out.print(df.format(a[i][j])+" ");}}
//crea vector
float sum=0;
for (int j=0;j<m;j++)
{for(int i=0;i<n;i++)
{sum=sum+a[i][j];}
vf[j]=sum;
sum=0;
}
for (int o=0;m>o;o++)

System.out.print(df.format(vf[o])+" ");
System.out.print(" <==Vector Fila");
}}

a le a to rio s re a le s c o n d o s d e c ima le s, lue g o lle va r lo s e le m e nto s d e la m a triz
p o r fila s (c o lum na s) a un ve c to r.
EXPLIC AC IÓ N DEL PRO G RAMA: Este p ro g ra m a no s p e rm ite c a rg a r una

m a triz n*m d e fo rm a a le a to ria c o n núm e ro s re a le s c o n d o s d e c im a le s
e xa c ta m e nte y lue g o tra sla d a rla a un ve c to r to d o s sus e le m e nto s.

import java.io.*;
public class A_60
{
{
BufferedReader in;
DecimalFormat df = new DecimalFormat ("0.00");
double [] [] a = new double [100] [100];
double [] vector = new double [100];
double k, f, c;
System.out.println ("Ingrese el numero de filas");
f = Integer.parseInt (in.readLine ());
System.out.println ("Ingrese el numero de columnas");
c = Integer.parseInt (in.readLine ());
k = Double.valueOf (df.format (Math.random () * 100)).doubleValue ();
for (int i = 0 ; i < f ; i++)

{
for (int j = 0 ; j < c ; j++)
{
k = Double.valueOf (df.format (Math.random () * 100)).doubleValue ();
a [i] [j] = k;
}}
for (int i = 0 ; i < f ; i++)
{
for (int j = 0 ; j < c ; j++)
{
System.out.print (a [i] [j] + " ");
}
}
int h = 0;
for (int i = 0 ; i < f ; i++)
{
for (int j = 0 ; j < c ; j++)
{
vector [h] = a [i] [j];
h++;
}}
for (int j = 0 ; j < f * c ; j++)
{
System.out.print (vector [j] + " ");
}}}
13. De sa rro lla r un p ro g ra m a p a ra c a rg a r un ve c to r d e K e le m e nto s c o n

núm e ro s a le a to rio s re a le s c o n d o s d e c im a le s, lue g o lle va r lo s e le m e nto s d e l
ve c to r a una m a triz p o r fila s, d o nd e K=NxM..
EXPLIC AC IO N DEL PRO G RAMA: e l p ro g ra m a p rim e ro lle na un ve c to r d e l

ta m a ño ing re sa d o p o r e l usua rio c o n va lo re s a le a to rio s y lo c o nvie rte e n
una m a triz d e l ta m a ño q ue ing re sa e l usua rio .

import java.io.*;
public class a61
{
{BufferedReader in;
double[][]a=new double[100][100];
double []kk=new double[100];
int k,n,m,sum=1;
System.out.println("INGRESE EL TAMANO DEL VECTOR");
k =Integer.parseInt(in.readLine());
for(int y=1;y<=k;y++)
{kk[y]=Double.valueOf(df.format(Math.random()*100)).doubleValue();
}
System.out.println("INGRESE EL NUMERO DE FILAS N, RECUERDE K=N*M");
System.out.println("INGRESE EL NUMERO DE COLUMNAS M RECUERDE K=N*M");
{
{a[f][c]=kk[sum];
sum++;
}}
System.out.println( " LA MATRIZ ES: ");

{
}
}
}
}
14. Re a lic e un p ro c e d im ie nto q ue d a d o un a rre g lo A d e (n*(n+1))/ 2

e le m e nto s a lm a c e ne sus e le m e nto s e n una m a triz d e nxn c o m o m ue stra e n
e l e je m p lo :
Si n=4 y e l a rre g lo fue se

12 24 15 13 16 9 1 2 0 3
La m a triz d e b e q ue d a r a sí:
12 0 0 0
24 15 0 0
13 16 9 0
1 2 0 3
EXPLIC AC IO N DEL PRO G RAMA: Este p ro g ra m a p e rm ite a l usua rio

ing re sa r lo s d a to s d e un ve c to r, lo s c ua le s so n g ua rd a d o s p o ste rio rm e nte
e n una m a triz d e ta ma ño nxn d e la fo rm a e n la q ue se m ue stra a rrib a .


import java.io.*;
public class a62
{
{BufferedReader in;
int cont=0,fl=0;
System.out.println("Introduzca los "+(n*(n+1))/2+" datos del vector: ");
for(int i=0;i<(n*(n+1))/2;i++)
{if (j>=k)
{mat[j][k]=a[cont];
cont++;}
else
{mat[j][k]=fl;}}
}
}
}
15. Re a liza r un p ro g ra m a p a ra q ue re c ib a , d e sd e te c la d o , una m a triz NxN d e

núm e ro s e nte ro s, lue g o c a lc ule y e sc rib a la sum a d e to d a s la s fila s y to d a s
la s c o lum na s.
EXPLIC AC IO N DEL PRO G RAMA: Se hizo uso d e sum a d o re s y c a d a re sulta d o

se g ua rd o e n una p o sic ió n e sp e c ific a d e la m ism a m a triz d e p e nd ie nd o d e
la c o lum na o fila e n e l ve c to r. Po ste rio rm e nte se p ro c e d io a m o stra r lo s
re sulta d o s.

import java.io.*;
public class a63
{
{BufferedReader in;
System.out.println("Ingrese el orden de la matriz");

System.out.println("Ingrese los "+((n)*(n))+" datos");
n=n+1;//n=n+1 porque se requiere una matriz de n+1 x n+1 para que en las ultimas
columnas y filas se realice las sumas
//para una matriz de orden n
int[][]a=new int[n+1][n+1];
int p,i,j,d=n-1;
//lee datos
for(i=0;i<n-1;i++)
{ for (j=0;j<n-1;j++)
{
a[i][j]=Integer.parseInt(in.readLine());
}
}
//realiza las sumas de filas y columnas
int sum=0,sumc=0;
for (p=0;p<n-1;p++)
{sum=0;
sumc=0;
for(i=0;i<n-1;i++)
{
sum=sum+a[i][p] ;
sumc=sumc+a[p][i];
}
a[p][d]=sum;
a[d][p]=sumc;
}
int sum1=0,sumi=0;
for(i=0;i<n-1;i++)
for (j=0;j<n-1;j++)
//muestra resultados
System.out.print("Matriz:");
for(i=0;i<n-1;i++)
for (j=0;j<n-1;j++)
{if (j==n-1)
System.out.print(" = "+a[i][j]+" ");
else
System.out.print(a[i][j]+" ");
}
}
System.out.println("---------------------------------------------------");
System.out.println("Suma de filas");
for (j=0;n-1>j;j++)
{System.out.print(a[n-1][j]+" ");
System.out.println("");}
System.out.println("Suma de columnas");
for (j=0;n-1>j;j++)
{System.out.print(a[j][n-1]+" ");}
}}
16. Esc rib ir un p ro g ra m a q ue a c e p te p o r te c la d o una m a triz d e M o rd e n NxN y

un a rre g lo V d e o rd e n N q ue d e vue lva e l núm e ro d e ve c e s q ue V a p a re c e
c o m o fila d e M.
EXPLIC AC IÓ N DEL PRO G RAMA: Este p ro g ra m a no s p e rm ite ve rific a r si un

ve c to r d e ta m a ño n se re p ite y c ua nta s ve c e s se re p ite si a sí fue ra e n una
m a triz d e o rd e n n*m .

import java.io.*;
public class A_64
{

{
BufferedReader in;
int matriz [] [] = new int [20] [20];
int n;
System.out.println ("Introduzca el tama*o de la matriz y el vector");
for (int i = 0 ; i < n ; i++)
{
vector [i] = Integer.parseInt (in.readLine ());
}
System.out.println ("El vector es");
for (int i = 0 ; i < n ; i++)

{
System.out.print (vector [i] + " ");
}
for (int i = 0 ; i < n ; i++)
{
for (int j = 0 ; j < n ; j++)
{
matriz [i] [j] = Integer.parseInt (in.readLine ());
}}
System.out.println ("La matriz es");
for (int i = 0 ; i < n ; i++)

{
for (int j = 0 ; j < n ; j++)
{
System.out.print (matriz [i] [j] + " ");
}
}
int c, d = 0;
for (int i = 0 ; i < n ; i++)
{
c = 0;
for (int j = 0 ; j < n ; j++)
{
if (matriz [i] [j] == vector [j])
{
c++;
}}
if (c == n)
{
d++;
}}
System.out.println ("El vector se repite " + d + " veces");
}}
17. Esc rib a un p ro g ra m a c o n una func ió n ES_DIAG q ue re c ib a c o mo

p a rá m e tro una m a triz M d e o rd e n NxN q ue d e vue lva TRUE si M e s una
m a triz d ia g o na l.
EXPLIC AC IO N DEL PRO G RAMA: e l p ro g ra m a re c ib e p rim e ro una m a triz

c ua d ra d a y m e d ia nte una func ió n b o o le a na re to rna true si e s d ia g o na l, si
no re to rna fa lse .
import java.io.*;
public class a65
{
{BufferedReader in;
int[][]a=new int[100][100];
int n;
System.out.println("INGRESE EL TAMANO DE LA MATRIZ (n*n)");
for(int c=1;c<=n;c++)
{
a[f][c]=Integer.parseInt(in.readLine());
}}
System.out.println( " LA MATRIZ INGRESADA ES: ");

{
}
}
if(ES_DIAG(a,n)==true)
System.out.println( "LA MATRIZ ES DIAGONAL ");
else
System.out.println( "LA MATRIZ NO ES DIAGONAL ");
}
static boolean ES_DIAG (int a[][],int n)

{
int aux=0;
{
{if(q!=w)
if(a[q][w]!=0)
aux=aux+1;
}
}
if(aux==0)
return true;
else
return false;
}
}
18. Re a lic e una func ió n q ue d a d a una m a triz d e ta m a ño MxM, un núm e ro q ue

ind iq ue una d e sus d ia g o na le s y un va lo r e nte ro , d e vue lva si to d o s lo s
e le m e nto s d e la d ia g o na l so n ig ua le s a d ic ho va lo r. Sup o ng a q ue la
d ia g o na l p rinc ip a l e s la núm e ro c e ro , la infe rio r a e sta e s -1 y a sí
suc e siva m e nte e n o rd e n d e c re c ie nte ; y la s d ia g o na le s sup e rio re s a la
p rinc ip a l sig ue n un o rd e n a sc e nd e nte a p a rtir d e 1. Utilic e e sta func ió n p a ra
ha c e r un p ro g ra m a q ue c a lc ule si la m a triz e s nula y si e s id e ntid a d .
EXPLIC AC IO N DEL PRO G RAMA: Este p ro g ra m a no s p e rm ite c o m p ro b a r, a

tra vé s d e un m e nú d e o p c io ne s, la s d ife re nte s instruc c io ne s d e l p ro b le m a .

La d ia g o na l p rinc ip a l e s la c e ro , la sig uie nte (e n o rd e n a sc e nd e nte ) e s la 1,

e tc . Y no s p e rm ite ve r si la m a triz ing re sa d a p o r e l usua rio e s la id e ntid a d , la
nula , o ning una , a d e m á s d e d e c irno s si to d o s lo s e le m e nto s d e una
d ia g o na l so n ig ua le s.

import java.io.*;
public class a66a
{
{BufferedReader in;
int opc=4,dd,dig;
System.out.println("Introduzca los datos de la matriz: ");
{mat[j][k]=Integer.parseInt(in.readLine());}
}
System.out.println("La matriz ingresada es: ");
{System.out.println("1. Verificar si los elementos de la diagonal son iguales: ");
System.out.println("2. Verificar si la matriz es nula: ");
System.out.println("3. Verificar si la matriz es la matriz identidad: ");
System.out.println("Seleccione su opcion: ");
opc=Integer.parseInt(in.readLine());}
switch(opc)
{case 1: System.out.println("Introduzca la diagonal y el digito a verificar: ");
dd=Integer.parseInt(in.readLine());
dig=Integer.parseInt(in.readLine());
diagig(mat,dd,dig,n);break;
case 2: matnul(mat,n);break;
case 3: matide(mat,n);break;
}
}
public static void diagig(int y[][],int g, int u,int kj)
{int aux,aux2=0,conti=0,g1=0;
if (g>=0)
{if(g==(kj-1))
{conti++;}
else
{g1=g;
aux=u;
while (g<kj)
{if (aux==y[aux2][g])

{conti++;}
aux2++;
g++;
}}
if (conti==(kj-g1))
{System.out.println("Todos los datos de la diagonal son iguales al valor");}
else
{System.out.println("No son todos iguales al valor");}
}
else
{g=-g;
g1=g;
aux=u;
while (g<kj)
{if (aux==y[g][aux2])
{conti++;}
aux2++;
g++;
}
if (conti==(kj-g1))
{System.out.println("Todos los datos de la diagonal son iguales al valor");}
else
{System.out.println("No son todos iguales al valor");}
}
}
public static void matnul(int y[][],int gg)
{int dab=gg-1,conti=0,aux=0,aux2=0,g1=0;
for (int ii=0;ii<gg;ii++)
{aux2=0;
if(ii==0)
{conti++;}
else
{g1=ii;
while (g1<gg)
{if (aux==y[aux2][g1])
{conti++;}
aux2++;
g1++;
}}}
for (int uu=0;uu<dab;uu++)
{g1=uu;
aux2=0;
while (g1<gg)
{if (aux==y[g1][aux2])
{conti++;}
aux2++;
g1++;
}}
if (conti==(gg*gg))
{System.out.println("La matriz es nula");}
else
{System.out.println("La matriz no es nula");}
}
public static void matide(int y[][],int gg)
{int dab=gg-1,conti=0,aux=0,aux2=0,g1=0,diago=0,diago1=1;
for (int ii=0;ii<gg;ii++)

{aux2=0;
if(y[ii][ii]==diago1)
{diago++;}
if(ii==0)
{conti++;}
else
{g1=ii;
while (g1<gg)
{if (aux==y[aux2][g1])
{conti++;}
aux2++;
g1++;
}}}
for (int uu=0;uu<dab;uu++)
{g1=uu;
aux2=0;
while (g1<gg)
{if (aux==y[g1][aux2])
{conti++;}
aux2++;
g1++;
}}
if (conti==((gg*gg)-gg)&&diago==gg)
{System.out.println("La matriz es la identidad");}
else
{System.out.println("La matriz no es la identidad");}
}
}
19. Ha c e r un p ro g ra m a q ue le a 25 va lo re s e nte ro s e n una ta b la d e 5 p o r 5, y

q ue d e sp ué s m ue stre la ta b la y la s sum a s d e c a d a fila y d e c a d a c o lum na .
Pro c ura q ue la sa lid a se a c la ra , no te lim ite s a lo s núm e ro s o b te nid o s.
EXPLIC AC IO N DEL PRO G RAMA: El p ro g ra m a utiliza una m a triz d e 6x6 e n ve z d e

una d e 5 x 5 p a ra lo s 25 d a to s, p o rq ue e n la s ultim a s c o lum na s y fila s se
g ua rd a n lo s re sulta d o s d e la s sum a s. Si se q uisie ra , se p o d ría a um e nta r e l
ra ng o e n lo s c ic lo s p a ra m o stra r la m a triz, y lo s re sulta d o s se m o stra ría n e n
p a nta lla junto a sus re sp e c tiva s c o lum na s y fila s. De to d o s m o d o s se o p to p o r
m o stra r lo s re sulta d o s d e fo rm a se p a ra d a .

import java.io.*;
public class a66b
{

{BufferedReader in;
int n=6;//6 porque se requiere una matriz de 6x6 para que en las ultimas columnas y
filas se realice las sumas
//para 25 datos, sera sqrt(25)+1
System.out.println("Ingrese los "+((n-1)*(n-1))+" datos");
//int n=Integer.parseInt(in.readLine());
int[][]a=new int[n+1][n+1];
int p,i,j,d=n-1;
//lee datos
for(i=0;i<n-1;i++)
{ for (j=0;j<n-1;j++)
{
a[i][j]=Integer.parseInt(in.readLine());
}
}
//realiza las sumas de filas y columnas
int sum=0,sumc=0;
for (p=0;p<n-1;p++)
{sum=0;
sumc=0;
for(i=0;i<n-1;i++)
{
sum=sum+a[i][p] ;
sumc=sumc+a[p][i];
}
a[p][d]=sum;
a[d][p]=sumc;
}
//muestra resultados
System.out.print("Matriz:");
for(i=0;i<n-1;i++)
for (j=0;j<n-1;j++)
{if (j==n-1)
System.out.print(" = "+a[i][j]+" ");
else
System.out.print(a[i][j]+" ");
}
}
System.out.println("---------------------------------------------------");
System.out.println("Suma de filas");
for (j=0;n-1>j;j++)
{System.out.print(a[n-1][j]+" ");
System.out.println("Suma de columnas");
for (j=0;n-1>j;j++)
{System.out.print(a[j][n-1]+" ");}
}}
Aplicación de Matrices – Calculos Matriciales
20. Realizar un P00 para trabajar con matrices, sobrecargado operadores y

funciones(si es posible o simulando estas) donde se realice:
a) Lectura de la matriz
b) Listado de la matriz
c) Ordenar todos los elementos de la matriz
d) Ordenar la fila X de la matriz
e) Ordenar la columna Y de la matriz
f) Obtener la traza de la matriz
g) Obtener el rango de la matriz.
h) Obtener el elemento máximo de la matriz
i) Suma de dos matrices
i) Multiplicación de matrices.
k) Obtener la matriz identidad en un constructor.
1) Multiplicar una matriz por un escalar.
EXPLICACION DEL PROGRAMA: el programa calcula todas las anteriores opciones,

para ello despliega un menú de opciones y realiza cada calculo utilizando la sentencia
switch para cada caso.

import java.io.*;
public class bb3
{
public bb3(int a[][],int n)
{for(int i=1;i<=n;i++)
{for(int j=1;j<=n;j++)
{if(i==j)
a[i][j]=1;
else
a[i][j]=0;
}}}

{BufferedReader in;
int[][]a=new int[100][100];
int[][]b=new int[100][100];
int[][]ca=new int[100][100];
int f=0,c=0,resp,aux,x,y,suma=0;
do
{

System.out.println(" Menu de opciones: ");

System.out.println(" 1. LECTURA DE LA MATRIZ ");
System.out.println(" 2. LISTADO DE LA MATRIZ ");
System.out.println(" 3. ORDENAR TODOS LOS ELEMENTOS DE LA MATRIZ ");
System.out.println(" 4. ORDENAR LA FILA X DE LA MATRIZ ");
System.out.println(" 5. ORDENAR LA COLUMNA Y DE LA MATRIZ ");
System.out.println(" 6. OBTENER LA TRAZA DE LA MATRIZ");
System.out.println(" 7. OBTENER EL RANGO DE LA MATRIZ ");
System.out.println(" 8. OBTENER EL ELEMENTO MAXIMO DE LA MATRIZ ");
System.out.println(" 9. SUMA DE DOS MATRICES ");
System.out.println(" 10. MULTIPLICACION DE MATRICES ");
System.out.println(" 11. OBTENER LA MATRIZ IDENTIDAD EN UN CONSTRUCTOR
");
System.out.println(" 12. MULTIPLICAR UNA MATRIZ POR UN ESCALAR ");
System.out.println(" 13. SALIR ");
System.out.println(" Ingrese la opcion: ");
resp =Integer.parseInt(in.readLine());
switch (resp)
{case 1:
System.out.println("Ingrese las filas y columnas");
f =Integer.parseInt(in.readLine());
c =Integer.parseInt(in.readLine());
for(int i=1;i<=f;i++)
{System.out.println("Ingrese la fila: "+i);
for(int jq=1;jq<=c;jq++)
{a[i][jq]=Integer.parseInt(in.readLine());
}}
break;
case 2:
for(int qq=1;qq<=f;qq++)
{
for(int ww=1;ww<=c;ww++)
{System.out.print(" "+a[qq][ww]);
}
}
break;
case 3:
for(int ii=1;ii<=f;ii++)
{for(int j=1;j<=c;j++)
{
for(int q=1;q<=f;q++){
for(int w=1;w<=c;w++)
{if (a[ii][j]<a[q][w])
{aux=a[ii][j];
a[ii][j]=a[q][w];
a[q][w]=aux;}
}}}}
break;
case 4:
System.out.println("Ingrese la fila a ordenar ");
x =Integer.parseInt(in.readLine());
for(int ja=1;ja<=c;ja++)
{
for(int qa=1;qa<=c;qa++)
{if (a[x][ja]<a[x][qa])
{aux=a[x][ja];
a[x][ja]=a[x][qa];
a[x][qa]=aux;}
}
}
break;
case 5:
System.out.println("Ingrese la columna a ordenar ");
y=Integer.parseInt(in.readLine());
for(int ia=1;ia<=f;ia++)
{
for(int wa=1;wa<=f;wa++)
{if (a[ia][y]<a[wa][y])
{aux=a[ia][y];
a[ia][y]=a[wa][y];
a[wa][y]=aux;}
}
}
break;
case 6:
suma=0;
System.out.print("La traza es: ");
for(int ib=1;ib<=f;ib++)
{for(int jb=1;jb<=c;jb++)
{if(ib==jb)
suma=suma+a[ib][jb];
}}
System.out.print(" "+suma);
break;
case 7:
int suma0=0;
for(int id=1;id<=f;id++)
{for(int jd=1;jd<=c;jd++)
{if(id==jd)
suma0=suma0+a[id][jd];
}}
int suma1=0,rango;
for(int ic=1;ic<=f;ic++)
{for(int jc=1;jc<=c;jc++)
{if((ic+jc)==(f+1))
suma1=suma1+a[ic][jc];
}}
rango=suma0-suma1;
System.out.print("EL RANGO ES: "+rango);
break;
case 8:
int max;
max=a[0][0];
for(int ie=1;ie<=f;ie++)
{for(int je=1;je<=c;je++)
{if(a[ie][je]>max)
max=a[ie][je];
}}
System.out.println("VALOR MAXIMO: "+max);
break;
case 9:
int fi,co;
System.out.println("Ingrese las filas y columnas de las 2 matrices(deben ser iguales
para que se puedan sumar)");
fi =Integer.parseInt(in.readLine());
co =Integer.parseInt(in.readLine());
System.out.println("MATRIZ 1");
for(int ig=1;ig<=fi;ig++)
{System.out.println("Ingrese la fila: "+ig);
for(int jg=1;jg<=co;jg++)
{a[ig][jg]=Integer.parseInt(in.readLine());
}}
for(int ih=1;ih<=fi;ih++)
{System.out.println("Ingrese la fila: "+ih);
for(int jh=1;jh<=co;jh++)
{b[ih][jh]=Integer.parseInt(in.readLine());
}}
for(int iq=1;iq<=fi;iq++)
{
for(int jq=1;jq<=co;jq++)
{ca[iq][jq]=a[iq][jq]+b[iq][jq];
}}
for(int qqa=1;qqa<=fi;qqa++)
{
for(int wwa=1;wwa<=co;wwa++)
{System.out.print(" "+ca[qqa][wwa]);
}
}
break;
case 10:
int fi1,fi2,co1,co2;
System.out.println("Ingrese las filas y columnas de las matriz 1 (recuerde que las
columnas de la primera deben iguales a las filas de la segunda)");
System.out.println("Ingrese las filas y columnas de las matriz 2 (recuerde que las
columnas de la primera deben iguales a las filas de la segunda)");
for(int iga=1;iga<=fi1;iga++)
{System.out.println("Ingrese la fila: "+iga);
for(int jga=1;jga<=co1;jga++)
{a[iga][jga]=Integer.parseInt(in.readLine());
}}
for(int iha=1;iha<=fi2;iha++)
{System.out.println("Ingrese la fila: "+iha);
for(int jha=1;jha<=co2;jha++)
{b[iha][jha]=Integer.parseInt(in.readLine());
}}
int suum=0;
for(int i1=1;i1<=fi1;i1++)
{
for(int j1=1;j1<=co2;j1++)
{
suum=0;
for(int kk=1;kk<=co1;kk++)
{suum=(suum+a[i1][kk]*b[kk][j1]);}
ca[i1][j1]=suum;
}}
for(int q1=1;q1<=fi1;q1++)
{
for(int w1=1;w1<=co2;w1++)
{System.out.print(" "+ca[q1][w1]);
}
}
break;
case 11:
int [][]xx=new int[100][100];
int dd;
System.out.println("Ingrese el tamano de la identidad");
dd=Integer.parseInt(in.readLine());
bb3 identidad=new bb3(xx,dd);
for(int ai=1;ai<=dd;ai++)
{for(int aj=1;aj<=dd;aj++)
{System.out.print(" "+xx[ai][aj]);
}
break;
case 12:
System.out.println("Ingrese el escalar a multiplicar");
int esc=Integer.parseInt(in.readLine());
for(int qz=1;qz<=f;qz++)
{
for(int wz=1;wz<=c;wz++)
{a[qz][wz]=(a[qz][wz]*esc);
}
}
for(int qc=1;qc<=f;qc++)
{
for(int wc=1;wc<=c;wc++)
{System.out.print(" "+a[qc][wc]);
}
}
break;
case 13:
break;}
}
while(resp != 13);
System.out.println("FIN DEL PROGRAMA");
}
}
21. Re a liza r un p ro g ra m a e n Ja va p a ra o rd e na r un ve c to r d e ta ma ño n
p o r e l m é to d o She ll, n y lo s e le m e nto s so n intro d uc id o s p o r e l usua rio ,
sup o ne r 1<n<25.
import java.io.*;
/**
* @author Hernan Payrumani M.
*/
public class Shell3 {
public static void main(String[] args) throws IOException {
BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
int[] a = new int[25];
System.out.println("Ingrese la dimension del vetor [1,25];");
int n = Integer.parseInt(in.readLine());
for(int i=0; i<n; i++){
System.out.print("a["+(i+1)+"]: ");
a[i]=Integer.parseInt(in.readLine());
}
shellSort(a,n);
}
public static void shellSort(int a[],int n){
for(int gap=n/2;gap>0;
gap=gap==2?1:(int)(gap/2.2)){
for(int i=gap;i<n;i++){
int temp=a[i];
int j;
for(j=i;j>=gap&&temp<a[j-gap];
j-=gap){
a[j]=a[j-gap];
}
a[j]=temp;
}
}
}
}

22. Re a liza r un p ro g ra m a e n Ja va q ue p o r m e d io d e un me nú e l usua rio

e lija e l m é to d o q ue d e se e p a ra o rd e na r un ve c to r d e ta m a ño n q ue
se rá intro d uc id o p o r e l m ism o
import java.io.*;
/**
* @author Hernan Payrumani M.
*/
public class SortMenu {
public static void main(String[] args) throws IOException {
BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
int[] a = new int[50];
try{
System.out.println("\t\t\tMenu");
System.out.println("\t\t1.Metodo de la Burbuja");
System.out.println("\t\t2.Metodo de Insercion");
System.out.println("\t\t3.Metodo de Seleccion");
System.out.println("\t\t4.Metodo Shell");
int op = Integer.parseInt(in.readLine());
switch(op){
case 1:
int n = Integer.parseInt(in.readLine());
}
buble(a,n);
mostrar(a,n);
break;
case 2:
}
insercion(a,n);
mostrar(a,n);
break;
case 3:
}
seleccion(a,n);
mostrar(a,n);
break;
case 4:
}
shell(a,n);
mostrar(a,n);
break;
}
}
catch( Exception ex ){
System.out.println("\n\n\n");
System.out.println( "--o--o--o--o--o--o--o--o--o--");
System.out.println( "- Error! Numero incorrecto -");
System.out.println( "--o--o-A-o--o--o--o--o--o--o--");
System.out.println("\n\n\n");
}
}
public static void buble(int a[],int n){
for(int j=0;j<n-i;j++){
if(a[j]>a[j+1]){
int aux=a[j];
a[j]=a[j+1];
a[j+1]=aux;
}
}
}
public static void insercion(int a[],int n){
for(int i=1;i<n;i++){
int aux=a[i];
int j=i-1;
while(j>=0&&aux<a[j]){
a[j+1]=a[j];
j--;
}
a[j+1]=aux;
}
}
public static void seleccion(int a[],int n){
for(int i=0;i<n;i++) {
int menor=a[i];
int pos=i;
for(int j=i+1;j< n;j++){
if(a[j]<menor){
menor=a[j];
pos=j;
}
}
a[pos]=a[i];
a[i]=menor;
}
}
public static void shell(int a[],int n){
for(int gap=n/2;gap>0;
gap=gap==2?1:(int)(gap/2.2)){
for(int i=gap;i<n;i++){
int temp=a[i];
int j;
for(j=i;j>=gap&&temp<a[j-gap];
j-=gap){
a[j]=a[j-gap];
}
a[j]=temp;
}
}
}
public static void mostrar(int a[],int n){
}
}
Aplicación de matrices – Inversion de Matrices por Faddevva
22. Nue va m e nte , Pro g ra m a p a ra e nc o ntra r la m a triz inve rsa c o n e l m é to d o d e

Fa d d e e va . (Pre g unta r e l m é to d o a l Ing . G uille rm o Esp ino za , p ro fe so r d e C s.
Exa c ta s).
EXPLIC AC IO N DEL PRO BLEMA: Este p ro g ra m a no s p e rm ite e nc o ntra r la
inve rsa d e una m a triz n x n p o r e l m e to d o d e fa d d e vva , e l c ua l e s un
m e to d o m uy d ina m ic o ya q ue e ste im p lic a to d o un p ro c e d imie nto e l c ua l
inte nta re m o s e xp lic a r b re ve m e nte : En p rime r lug a r le e r una m a triz A d e
ta m a ño n x n lue g o e sta m a triz e s c o p ia d a a una m a triz An, c a lc ula m o s la
tra za d e e sta m a triz , e sta tra za se rá m ultip lic a d o ra d e la m a triz id e ntid a d .
Este p ro d uc to lo usa re m o s p a ra q ue p ue d a se r re sta d a c o n la m a triz
o rig ina l A. Esta re sta a la ve z se rá g ua rd a d a e n o tra m a triz q ue se rá
m ultip lic a d a p o r la m a triz o rig ina l, e ste ultim o p ro d uc to ta mb ié n se rá
g ua rd a d o e n una ultim a m a triz la c ua l p a sa ra p o r to d o e l c ic lo ha sta a ho ra
m e nc io na d o .
// Programa realizado por Sergio W. Ossio Marin y Andres Prudencio R.

import java.io.*;
public class faddeeva
{
{
BufferedReader in;
double [] [] id = new double [100] [100];
double [] [] A = new double [100] [100];
double [] [] B = new double [100] [100];
double [] [] AI = new double [100] [100];
double [] [] AUX = new double [100] [100];
double [] [] An = new double [100] [100];

double [] [] BB = new double [100] [100];
int n, f, c;
double q,qq=0;
System.out.println ("Ingrese el orden de la matriz cuadrada");
//lectura de la matriz
iden (id, n);
for (int i = 0 ; i < n ; i++)
{
System.out.println ("Ingrese la fila: " + (i + 1));
for (int j = 0 ; j < n ; j++)
{
A [i] [j] = Integer.parseInt (in.readLine ());
}}
iden (id, n);
copy (A, An, n);
int cq=0;
int h = 1;
for (int i = 1 ; i <= n ; i++)
{
q = traza (An, n);
q = q / h;
cq++;
if (cq == n)
{qq = 1 / q;};
//System.out.print(q);
cxp (id, q, n, AUX);

OB_B (An, B, n, AUX);
if (i == (n-1))
{copy (B, BB, n);}
MULT (B, n, A, An);

//show(An,n);
// System.out.println();
h++;
cxp(BB,qq,n,AI);
System.out.println ("Matriz Inversa: ");
show(AI,n);

}
public static void iden (double id [] [], int n)
{
for (int i = 0 ; i < n ; i++)
{
for (int j = 0 ; j < n ; j++)
{
if (i == j)
id [i] [j] = 1;
else
id [i] [j] = 0;
}} }
public static double traza (double I [] [], int n)
{
double sum = 0;
for (int i = 0 ; i < n ; i++)
{
for (int j = 0 ; j < n ; j++)
{
if (i == j)
sum += I [i] [j];
}}
return sum;
}
public static void cxp (double O [] [], double q, int n, double P [] [])
{
for (int i = 0 ; i < n ; i++)
{
for (int j = 0 ; j < n ; j++)
{
P [i] [j] = q * O [i] [j];
}} }
public static void OB_B (double A [] [], double O [] [], int n, double U [] [])
{
for (int i = 0 ; i < n ; i++)
{
for (int j = 0 ; j < n ; j++)
{
O [i] [j] = A [i] [j] - U [i] [j];
}}}
public static void MULT (double O [] [], int n, double A [] [], double y [] [])
{
double suum = 0;
for (int i = 0 ; i < n ; i++)
{
for (int j = 0 ; j < n ; j++)
{
suum = 0;
for (int k = 0 ; k < n ; k++)
{
suum = (suum + O [i] [k] * A [k] [j]);
}
y [i] [j] = suum;
}
}}
public static void show (double O [] [], int n)
{
for (int q = 0 ; q < n ; q++)
{
for (int w = 0 ; w < n ; w++)
{
System.out.print (" " + O [q] [w]);

}
System.out.println ("");
}}
public static void copy (double O [] [], double An [] [], int n)
{
for (int q = 0 ; q < n ; q++)
{
for (int w = 0 ; w < n ; w++)
{
An [q] [w] = O [q][w];
}} }
}
1. Da d a s 2 m a tric e s d e o rd e n n*n, o b te ne r la sum a d e la s m ism a s

2. G e ne ra r la sig uie nte m a triz d e o rd e n n*n:
11111
10001
10001
10001
11111
3. G e ne ra r la sig uie nte m a triz:
124 7
3 5 8 11
6 9 12 14
10 13 15 16
4. G e ne ra r la sig uie nte m a triz d e o rd e n n*n:
*1111
1*001
10*01
100*1

1111*
5. Re a lic e un p ro g ra m a p a ra inve rtir una m a triz m e d ia nte un m é to d o

d istinto a l d e Fa d d e vva
6. Re a lic e un p ro g ra m a p a ra g e ne ra r la sig uie nte m a triz d e o rd e n

n*n:
00000
01110
01010
01110
00000
7. Re a lic e un p ro g ra m a q ue g e ne re una m a triz e n la q ue se g ua rd e n

lo s d a to s d e la s ve nta s d e 6 ve nd e d o re s d e la sig uie nte m a ne ra :
C a ntid a d Ve nd id a Ve nd e d o r 1 C a ntid a d ve nd id a
Ve nd e d o r 2 ……….
To yo ta
Pe ug e o t
Ma zd a
Fo rd
Mitsub ishi
Lue g o m o stra r la c a ntid a d d e ve nta s p o r m a rc a d e c a d a ve nd e d o r y

m o stra r a l q ue m a s ha ya ve nd id o y a l q ue m e no s ha ya ve nd id o
8. C re a r un p ro g ra m a q ue g e ne re a le a to ria m e nte una e le c c ió n

p re sid e nc ia l d e la sig uie nte m a ne ra :
MNR ADN MIR MAS ………
La Pa z
C o c ha b a m b a
Sa nta C ruz
Be ni
Ta rija

……
Una ve z lle na d a la ta b la , m o stra r q ue p a rtid o tuvo m a s vo to s e n c a d a

d e p a rta m e nto y q ue p a rtid o g a na a nive l na c io na l y c o n q ue
p o rc e nta je d e lo s vo to s.
9. Re a lic e un p ro g ra m a p a ra g e ne ra r la sig uie nte m a triz d e o rd e n

n*n:
00n00
00n00
nnnnn
00n00
00n00
Re e m p la za nd o la s n’ s p o r e l o rd e n d e la m a triz
10. Re a lic e un p ro g ra m a q ue re e m p la c e to d o s lo s lug a re s e n lo s q ue

la fila y la c o lum na sum a d a s sum e n e l o rd e n d e la m a triz p o r e l o rd e n d e
la m a triz. Se d e b e to m a r c o m o p o sic ió n inic ia l.

Recursividad
Lo s sig uie nte s p ro g ra m a s fue ro n re sue lto s ha c ie nd o uso d e func io ne s

re c ursiva s. La s func io ne s re c ursiva s so n a q ue lla s q ue se invo c a n a si
m ism a s.
1. Esc rib ir una func ió n re c ursiva q ue ha lle la sum a d e lo s p rim e ro s "n" núm e ro s
na tura le s.
EXPLIC AC IO N DEL PRO G RAMA: Este p ro g ra m a sim p le m e nte re a liza una func ió n
re c ursiva tip o vo id p a ra ha lla r la sum a re q ue rid a .

import java.io.*;
public class a69
{
{BufferedReader in;
int sum=0;
System.out.println("Introduzca ula cantidad de naturales: ");
enter(n,sum);
}
public static void enter(int y, int w)
{if (y<0)
{System.out.println("La suma es: "+w)}
else
{w=w+y;
enter(y-1,w);}
}
}
2. Esc rib ir una func ió n re c ursiva q ue d e vue lva la c a ntid a d d e d íg ito s d e un

núm e ro e nte ro .

EXPLIC AC IO N DEL PRO G RAMA: El p ro g ra m a usa una func ió n re c ursiva

d o nd e la c o nd ic ió n b á sic a e s q ue si e l la p a rte e nte ra d e un num e ro
d ivid id o e ntre 10 e s 0 e nto nc e s d e b e re to rna r 1, ha c ie nd o q ue la m ism a
func ió n a c tue c o m o c o nta d o r d e d ig ito s a l sum a rse e sta c o n un uno .

import java.io.*;
public class a70
{
{
BufferedReader in;
System.out.println("Ingrese un numero entero positivo: ");
int c=0;
int d=Integer.parseInt(in.readLine());
if (d>=0)
System.out.println("Cantidad de digitos: "+(cdig(d,c)));
else
System.out.println("Debe ingresar un numero positivo o nulo");
}
public static int cdig(int d,int c)

{
if((d/10)==0)
{
return 1;}
else
{d=d/10;
return 1+cdig(d,c);
}
}
}
3. Esc rib ir una func ió n re c ursiva q ue p e rm ita c a lc ula r e l fa c to ria l d e un

núm e ro e nte ro . ¿ C o nvie ne re a lm e nte la utiliza c ió n d e la ve rsió n re c ursiva ,
p o r so b re la ite ra tiva ? Justific a r d e b id a m e nte la re sp ue sta ? .
EXPLIC AC IÓ N DEL PRO G RAMA: Este p ro g ra m a no s p e rm ite c a lc ula r e l fa c to ria l

d e un núm e ro d e una fo rm a e le g a nte “ Re c ursiva ” .

import java.io.*;

public class A_71

{
{BufferedReader in;
System.out.println("Introduzca el numero el cual quiere calcular su factorial");
System.out.println(+fact(n));
}
static int fact(int n)
{if ( n== 0 ) {
return 1;}
else
{return n*fact(n-1);}}}
4. Esc rib ir una func ió n re c ursiva q ue c a lc ule w k m e d ia nte m ultip lic a c io ne s

suc e siva s, sie nd o k un núm e ro na tura l.
EXPLIC AC IO N DEL PRO G RAMA: e l p ro g ra m a c a lc ula un num e ro e le va d o a

una p o te nc ia utiliza nd o una func ió n re c ursiva . Prim e ro p id e e l num e ro y la
p o te nc ia y fina lm e nte d e sp lie g a e l re sulta d o lla m a nd o a la func ió n
p o t(a ,b ).

import java.io.*;
public class a72
{
{BufferedReader in;
System.out.println("Introduzca un numero y la potencia (NATURALES)");
int b=Integer.parseInt(in.readLine());
System.out.println(a+" ^ "+b+" = "+pot(a,b));
}
static int pot(int nmero,int potencia){
if ( potencia == 0 ) {
return 1;
} else {
return nmero*pot(nmero,potencia-1);
}
}
}

5. Esc rib ir un p ro c e d im ie nto re c ursivo q ue c a lc ule z*v, m e d ia nte sum a s

suc e siva s, c o n z, v e nte ro s.
EXPLIC AC IO N DEL PRO G RAMA: Aq uí se utiliza una func ió n re c ursiva tip o vo id

p a ra c a lc ula r z*v m e d ia nte sum a s suc e siva s.

import java.io.*;
public class a73
{
{BufferedReader in;
int sum=0;
System.out.println("Introduzca el primer numero: ");
int z=Integer.parseInt(in.readLine());
System.out.println("Introduzca el segundo numero: ");
int v=Integer.parseInt(in.readLine());
multi(z,v,sum);
}
public static void multi(int y, int w, int u)
{if (y<=0)
{System.out.println("La multiplicacion es: "+u);}
else
{u=u+w;
multi (y-1,w,u);}
}
}
6. Pro p o ne r un p ro c e d im ie nto re c ursivo ta l q ue d a d o un a rre g lo d e núm e ro s

re a le s p e rm ita c a lc ula r e l m ínim o e le m e nto d e l ve c to r y su p o sic ió n.
EXPLIC AC IÓ N DEL PRO G RAMA: El p ro g ra m a usa una func ió n re c ursiva la

c ua l im p rim e e l e le m e nto m e no r d e un ve c to r y su p o sic ió n usa nd o la
va ria b le c c o m o c o ntro l d e p o sic ió n p a ra a na liza r e l ve c to r. La c o nd ic ió n
b á sic a e s q ue c se a -1, p a ra im p rimir lo s re sulta d o s. La d e b id o a q ue c e sta
e n c o nsta nte d isminuc ió n (d e n-1 a -1) se va g ua rd a nd o la p o sic ió n d e l
e le m e nto m inim o e n la va ria b le p p a ra d e sp ué s im p rimirla . El a ná lisis d e l
ve c to r e s e l m ism o : a sig na r c o m o e le m e nto m inim o e l e le m e nto 1 d e l
ve c to r y c o m p a ra rlo c o n e ste . Si a lg ún e le m e nto e s m e no r a l 1, e nto nc e s
a q ue l e s a sig na d o c o m o m inim o .
//AP

import java.io.*;
import java.math.*;
public class a74
{

{
BufferedReader in;
System.out.println("Ingrese el tamanio del vector: ");
float []v=new float[100];
int c=n-1;
v[i]=(float)(Math.random()*10);
float min=v[0];
System.out.println("Vector: ");
int p=0;
System.out.print(df.format(v[i])+" ");
vmin(v,c,min,p);
}
public static float vmin(float v[],int c,float min,int p)

{DecimalFormat df = new DecimalFormat("0.0");
if (c==-1)
{System.out.println("Elemento minimo "+df.format(min)+" Posicion: "+(p+1));
return 0; }
else
{if(min>v[c])
{min=v[c];
p=c;}
return vmin(v,c-1,min,p);
}}}
7. Pro p o ne r un p ro c e d im ie nto re c ursivo ta l q ue d a d o un a rre g lo d e núm e ro s

re a le s p e rm ita c a lc ula r e l p ro m e d io d e sus e le m e nto s.
EXPLIC AC IÓ N DEL PRO G RAMA: Este p ro g ra m a no s p e rm ite c a lc ula r e l

p ro m e d io d e una se rie d e núm e ro s g ua rd a d o s e n un a rre g lo d e una fo rm a
e le g a nte “ Re c ursiva ” .


import java.io.*;
public class A_75
{
{BufferedReader in;
int n;
System.out.println("Ingrese el tamano del arreglo");
int []a=new int[100];
int sum,medio;
System.out.println("Ingrese los "+n+" elementos");
for(int y=1;y<=n;y++)
{a[y]=Integer.parseInt(in.readLine());}
System.out.println("ARREGLO ");
for(int yy=1;yy<=n;yy++)
{System.out.print(" "+a[yy]);}
System.out.println("La suma del los elementos es: "+suma(a,n));
System.out.println("El valor medio de los elementos es: "+(suma(a,n)/n));
}
static int suma(int a[],int n)
{if(n == 1)
return a[n];
else
{return a[n]+suma(a,n-1);}
}}
8. Escribir una función recursiva que dado un número entero positivo calcule su
imagen especular. Por ejemplo: f(345)=543.
EXPLICACION DEL PROGRAMA: el programa calcula un número que es el

número ingresado invertido mediante una función recursiva con retorno, utilizando
el método pow de la clase math

import java.io.*;
public class a76
{
{BufferedReader in;
System.out.println("Introduzca el numero");
int c,s=0;
c=dig(n);
System.out.println("La imagen especular es "+inv(n,c-1,s));

}
static int dig(int n)

{if(n==0)
{return 0;}
else
{return (dig(n/10)+1);}}
static int inv(int n,int c,int s)

{if(n==0)
{return 0;}
else
{
return ((n%10)*(int)Math.pow(10,c)+inv(n/10,c-1,s));
}
}
}
9. Esc rib ir un p ro c e d imie nto re c ursivo q ue imp rim a e l c o nte nid o d e la s

p o sic io ne s p a re s d e un a rre g lo d e e nte ro s.
EXPLIC AC IO N DEL PRO G RAMA: Este p ro g ra m a , a tra vé s d e una func ió n

re c ursiva vo id , le e p rim e ro un ve c to r d e n té rm ino s y ha c e q ue un c o nta d o r
q ue va d e 0 ha sta n se a so m e tid o a una p rue b a p a ra ve r si e s p a r
(c o nta d o r%2). Si la p o sic ió n e s p a r, e l num e ro e s m o stra d o

import java.io.*;
public class a77
{
{BufferedReader in;
int sum=0;
int []v=new int[100];
System.out.println("Ingrese la cantidad de datos: ");
System.out.println("Introduzca los datos del arreglo: ");
{v[i]=Integer.parseInt(in.readLine());}
System.out.println("Las posiciones pares son: ");
posi(n,v,sum);
}
public static void posi(int y, int w[], int u)
{if (u>=y)
{y=0;}
else
{System.out.print(w[u]+" ");
posi (y,w,u+2);}
}
}
10. Calcular C(n,k), los coeficientes binomiales recursivamente, siendo:

a) C(n,0)=C(n,n)=1 si n>=0
b) C(n,k)=C(n-1,k)+C(n-1,k-1) si n>k>0
EXPLICACION DEL PROGRAMA: Basicamente se introdujo las condiciones del

problema a una función recursiva con la condición básica a) y con el retorno alternativo
de b).

import java.io.*;
public class a78
{
public static void main (String arg []) throws IOException
{
BufferedReader in = new BufferedReader (new InputStreamReader
(System.in));
float n, k;
System.out.println ("Introduzca el valor de n y k: C(n,k) n>=0, n>k>0");
k = Integer.parseInt (in.readLine ());
while (0 > n || n< k)

{
System.out.println ("Introduzca valores para n y k. n>=0, n>k>0");
k = Integer.parseInt (in.readLine ());
}
System.out.println(cc(n,k));
}
public static float cc (float n, float k)
{
float c = 0;
if (n == k || k == 0)
return 1;
else
{
return cc (n - 1, k) + cc (n - 1, k - 1);
}}}
11. Dise ña r un p ro c e d imie nto re c ursivo p a ra d e te rm ina r e l Má xim o C o m ún

Diviso r (m c d ) d e d o s núm e ro s e nte ro s p o sitivo s m , n usa nd o la sig uie nte
ind ic a c ió n:
⎧ si n ≤ m y m mod n = 0
⎪
n
mcd (m, n) = ⎨ si m < n
⎪ mcd (n, m mod n)
mcd (n, m)
⎩ en otro caso
EXPLIC AC IÓ N DEL PRO G RAMA: Este p ro g ra m a no s p e rm ite c a lc ula r e l

MC D d e d o s núm e ro s ing re sa d o s p o r te c la d o d e una fo rm a e le g a nte
“ Re c ursiva ” .

import java.io.*;
public class A_79
{
{BufferedReader in;
int n,m;
System.out.println("Ingrese los dos numeros");
System.out.println(+mcd(n,m));
}
static int mcd(int n,int m)
{if ( n==m )
{return n;}
else
if(n>m)
return mcd(n-m,m);
else
return mcd(n,m-n);
}}
12. Esc rib ir una func ió n re c ursiva p a ra sum a r lo s p ro d uc to s d e lo s e le m e nto s

c o rre sp o nd ie nte s d e d o s ve c to r A y B d e n e le m e nto s c a d a uno y q ue se
ha n lle na d o c o n núm e ro s a le a to rio s.
EXPLIC AC IO N DEL PRO G RAMA: e l p ro g ra m a c a lc ula la sum a d e lo s

p ro d uc to s d e 2 ve c to re s. Se lle na ro n lo s ve c to re s c o n la func ió n ra nd o m d e
la c la se m a th. Fina lm e nte se d e sp lie g a n to d o s lo s ve c to re s y e l ve c to r d e la
sum a d e sus p ro d uc to s.


import java.io.*;
public class a80
{
{BufferedReader in;
System.out.println("Ingrese el tamano de los arreglos");
int []b=new int[100];
{a[y]=(int)(Math.random()*100);}
{b[f]=(int)(Math.random()*100);
}
System.out.println("ARREGLO 1");
for(int ff=1;ff<=n;ff++)
{System.out.print(" "+b[ff]);
}
System.out.println("La suma de los productos es: "+prod(a,b,n));
}
static int prod(int a[],int b[],int n)
{if(n == 1)
return a[n]*b[n];
else
{return a[n]*b[n]+prod(a,b,n-1);}
}
}
13. Esc rib ir un p ro g ra m a q ue utilic e func io ne s re c ursiva s p a ra c a lc ula r la sum a

sig uie nte :
x− + − + − ..... d o nd e 0 ≤ x ≤ 1.
x3 x5 x7 x9
3! 5! 7! 9!
Sum a r té rm ino s m ie ntra s e sto s se a n m a yo re s a 10 – 8. El va lo r d e x se

intro d uc e p o r te c la d o .

EXPLIC AC IO N: Este p ro g ra m a utiliza e l mism o p rinc ip io d e l e je rc ic io 18, p e ro se

utiliza una func ió n re c ursiva vo id p a ra re a liza r lo s c á lc ulo s e n ve z d e la
se nte nc ia w hile .

import java.io.*;
public class a81
{
double x;
sumat(x,aux,sig,term,conta);
}
public static void sumat(double o,double p,double q, double r, double s)

{if (p<=0.00000001)
{System.out.println("La sumatoria es: "+p);}
else
{r=(q*(Math.pow(s,o)/facto(s)))+r;
s=s+2;
q=-q;
p=Math.pow(s,o)/facto(s);
sumat(o,p,q,r,s);
}
}

{if (xx==0)
{xx=1;
return xx;}
else
{double sum=0;
{sum=i*xx+sum;}
xx=sum;
return xx;}
}}
14. Esc rib ir un p ro g ra m a q ue utilic e func io ne s re c ursiva s p a ra c a lc ula r la sum a

sig uie nte :
1− + − + − ..... d o nd e 0 ≤ x ≤ 1.
x 2 x 4 x6 x8
2! 4! 6! 8!

EXPLIC AC IO N DEL PRO G RAMA: e l p ro c e d imie nto e s e xa c ta m e nte e l

m ism o q ue se uso e n e je rc ic io 81, e xc e p to q ue e l c o nta d o r (c o nta )
d e b e inic ia liza rc e e n 0, d e m o d o q ue e n la func ió n sum a t s a um e nte d e
2 e n d o s, a si, d e vo lvie nd o lo s d e no m ina d o re s p a re s. En e ste p ro g ra m a
se a ña d ió la va lid a c io n d e d a to s.
//Realizado por Ignacio Salgado

//Modificaciones: Andres Prudencio R.
import java.io.*;
public class a82
{
double x;
while (0>x||x>1)
{System.out.println("Introduzca el valor de x entre 0 y 1:");
x = (Float.valueOf (in.readLine ())).floatValue ();}
sumat(x,aux,sig,term,conta);}
public static void sumat(double o,double p,double q, double r, double s)

{if (p<=0.00000001)
{System.out.println("La sumatoria es: "+p);}
else
{r=(q*(Math.pow(s,o)/facto(s)))+r;
s=s+2;
q=-q;
p=Math.pow(s,o)/facto(s);
sumat(o,p,q,r,s);
}
}

{if (xx==0)
{xx=1;
return xx;}
else
{double sum=0;
{sum=i*xx+sum;}
xx=sum;
return xx;}
}
}

15. Esc rib ir un func ió n re c ursiva p a ra sum a r n e le m e nto s d e la sig uie nte se rie :
1x + 2 x + 3 x + ....... + n x .
EXPLIC AC IÓ N DEL PRO G RAMA: Este p ro g ra m a no s p e rm ite c a lc ula r la sum a

d e n e le m e nto s d e la se rie ya a nte s m e nc io na d a d e una fo rm a e le g a nte
“ re c ursiva ” .

import java.io.*;
public class A_83
{
{BufferedReader in;
double n,x;
System.out.println("Ingrese el numero de terminos");
System.out.println("Ingrese el tamao de la potencia");
System.out.println(+serie(n,x));
}
public static double serie(double n,double x)
{if(n == 1)
return 1;
else
{return Math.pow(n,x)+serie(n-1,x);
}
}}
16. Ha c e r un p ro g ra m a c o n func io ne s re c ursiva s q ue le a d ie z va lo re s e nte ro s

e n un a rra y d e sd e e l te c la d o y c a lc ule y m ue stre : la sum a , e l va lo r m e d io ,
e l m a yo r y e l m e no r.
EXPLIC AC IO N DEL PRO G RAMA: e l p ro g ra m a utiliza func io ne s re c ursiva s p a ra

c a lc ula r la sum a , va lo r m e d io , m a yo r y m e no r va lo r d e un a rre g lo d e
ta m a ño 10 intro d uc id o p o r te c la d o . C a d a c á lc ulo tie ne su p ro p ia func ió n
re c ursiva .

import java.io.*;
public class a84
{

{BufferedReader in;
int n=10;
int max,min,sum,medio;
System.out.println("Ingrese los 10 elementos");
for(int y=1;y<=10;y++)
System.out.println("ARREGLO ");
for(int yy=1;yy<=10;yy++)
System.out.println("La suma del los elementos es: "+suma(a,n));
System.out.println("El valor medio de los elementos es: "+(suma(a,n)/10));
System.out.println("El mayor valor es: "+ may(a,n));
System.out.println("El menor valor es: "+ men(a,n));
}
static int suma(int a[],int n)

{if(n == 1)
return a[n];
else
{return a[n]+suma(a,n-1);}
}
static int may(int a[],int n)

{if(n == 1)
return a[n];
else
{if(a[n]>may(a,n-1))
return a[n] ;
else
return may(a,n-1);
}}
static int men(int a[],int n)

{if(n == 1)
return a[n];
else
{if(a[n]<men(a,n-1))
return a[n] ;
else
return men(a,n-1);
}}}

17. Me d ia nte una func ió n re c ursiva lle na r un ve c to r c o n núm e ro s a le a to rio s,

lue g o se p a ra r d e la m ism a a lo s e le m e nto s p a re s, y c o nfo rm a r c o n e llo s
o tra lista .
EXPLIC AC IO N DEL PRO G RAMA: Este p ro g ra m a utiliza una func ió n re c ursiva

vo id p a ra lle na r un ve c to r c o n núm e ro s a le a to rio s, lue g o g ua rd a lo s p a re s
e n un ve c to r y lo s im p a re s e n o tro y lo s m ue stra .
/programa realizado por Ignacio Salgado Faller

import java.io.*;
import java.math.*;
public class a85
{
int[]vec=new int[100];
int a=vector[0];
int b=200;
System.out.println("Cuantos datos desea generar?");
int j=Integer.parseInt(in.readLine());
int cont=0;
int conta=0;
recur(vector,vec,j,cont,conta);
}
public static void recur(int vv[],int vv2[],int jj,int co,int co2)

{if (co>=jj)
{muestra(vv,vv2,jj,co2);}
else
{vv[co]=(int)(Math.random()*100);
if ((vv[co]%2)==0)
{vv2[co2]=vv[co];
co2++;
co++;
recur(vv,vv2,jj,co,co2);}
else
{co++;
recur(vv,vv2,jj,co,co2);}
}
}
public static void muestra(int uu[],int yy[],int ww,int zz)
{System.out.println("Su vector original es: ");
for (int uy=0;uy<ww;uy++)
{System.out.print(uu[uy]+" ");}
System.out.println("Su vector de pares es: ");

if(zz==0)
{System.out.println("No existen pares en el vector original");}
else
{for (int ux=0;ux<zz;ux++)
{System.out.print(yy[ux]+" ");}}
}
}
18. Esc rib ir una func ió n re c ursiva p a ra g e ne ra r un ve c to r c o n núm e ro s

a le a to rio s, lue g o ub ic a r e l m á xim o y m ínim o e le m e nto q ue ha ya e n e l
ve c to r, sin o rd e na r lo s e le m e nto s d e l m ism o .
EXPLIC AC IO N DEL PRO G RAMA: Se uso la m ism a m e to d o lo g ía d e l e je rc ic io

74, e xc e p to a c ie rta s m o d ific a c io ne s: se a um e nta un if a la func ió n
re c ursiva p a ra g ra g a r e n la va ria b le m a x e l e le m e nto m á xim o y la
e limina c ió n d e la s va ria b le s q ue ind ic a b a n la p o sic ió n d e l ve c to r.
//Realizado por Andres Prudencio

import java.io.*;
public class a86
{
{
BufferedReader in;
System.out.println("Ingrese el tamano del vector: ");
int []v=new int[100];
int c=n-1;
v[i]=(int)(Math.random()*100+1);
int min=v[0],max=v[0];
System.out.println("Vector: ");
int p=0;
System.out.print(v[i]+" ");
vminmax(v,c,min,max);
}
public static int vminmax(int v[],int c,int min,int max)

{
if (c==-1)
{System.out.println("Elemento maximo: "+max+" Elemento minimo: "+min);

return 0; }
else
{
if(min>v[c])
{min=v[c];}
if(max<v[c])
{max=v[c];}
return vminmax(v,c-1,min,max);
}
}
}
19. Me d ia nte func io ne s re c ursiva s g e ne ra r d o s ve c to re s con núm e ro s

a le a to rio s, o rd e na rlo s y lue g o m ultip lic a r lo s e le m e nto s c o rre sp o nd ie nte s d e
lo s d o s ve c to re s y a lm a c e na r e n un te rc e r ve c to r. Mo stra r e n p a nta lla lo s
tre s ve c to re s.
EXPLIC AC IO N DEL PRO G RAMA: Este p ro g ra m a no s p e rm ite p o d e r do s

ve c to re s c o n núm e ro s a le a to rio s m e d ia nte un func ió n ra nd o m lue g o
m e d ia nte o tra func ió n o rd e na m o s e sto s ve c to re s y fina lm e nte o b te ne m o s
un te rc e r ve c to r e l c ua l c o ntie ne e l p ro d uc to ve c to ria l d e a m b o s ve c to re s
o re d e na d o s y a su ve s ta m b ié n o rd e na e ste ultim o ve c to r.

import java.io.*;
import java.math.*;
public class A_87
{
{
BufferedReader in;
int n;
System.out.println ("Ingrese el tama^o de los vectores");
for (int i = 0 ; i < n ; i++)
{
vector1 [i] = (int) (Math.random () * 98 + 1);
}
System.out.println ("El vector 1 es: ");
for (int o = 0 ; o < n ; o++)
{

System.out.print (vector1 [o] + " ");

}
for (int i = 0 ; i < 20 ; i++)
{
vector2 [i] = (int) (Math.random () * 98 + 1);
}
System.out.println ("El vector 2 es: ");
for (int o = 0 ; o < n ; o++)
{
System.out.print (vector2 [o] + " ");
}
ordena (n, vector1);
ordena (n, vector2);
mostrar (n, vector1);
mostrar (n, vector2);
mul (n, vector3, vector1, vector2);
}
public static void ordena (int n, int vectork [])
{
int aux;
for (int i = 0 ; i < n ; ++i)
for (int j = 0 ; j < n ; ++j)
{
if (vectork [i] < vectork [j])
{
aux = vectork [i];
vectork [i] = vectork [j];
vectork [j] = aux;
}}}
public static void mostrar (int n, int vectork [])
{
System.out.println ("El vector ordenado es: ");
for (int o = 0 ; o < n ; o++)
{
System.out.print (vectork [o] + " ");
}
}
public static void mul (int n, int vectork [], int vectore [], int vectord [])
{
for (int o = 0 ; o < n ; o++)

{
vectork [o] = vectore [o] * vectord [o];
}
System.out.println ("El vector ordenado del producto vectorial entre los dos
vectores ordenados es: ");
for (int o = 0 ; o < n ; o++)
{
System.out.print (vectork [o] + " ");
}}}
20. Esc rib ir un p ro c e d imie nto re c ursivo q ue c a lc ule e l p ro d uc to e sc a la r d e d o s

ve c to re s q ue re c ib e c o m o p a rá m e tro s.
EXPLIC AC IO N DEL PRO G RAMA: e l p ro g ra m a c a lc ula e l p ro d uc to e sc a la r d e

2 ve c to re s m e d ia nte una func ió n re c ursiva q ue tie ne c o m o p a rá m e tro s lo s
2 ve c to re s, p a ra e llo e n la func ió n re c ursiva se va n sum a nd o c a d a
p ro d uc to d e c a d a e le m e nto d e lo s 2 ve c to re s.

import java.io.*;
public class a88
{
{BufferedReader in;
int []b=new int[100];

{b[f]=Integer.parseInt(in.readLine());
}
for(int ff=1;ff<=n;ff++)
{System.out.print(" "+b[ff]);
}
System.out.println("El producto escalar es: "+prod(a,b,n));
}
static int prod(int a[],int b[],int n)
{if(n == 1)
return a[n]*b[n];
else
{return a[n]*b[n]+prod(a,b,n-1);}
}
}

1. Mediante un programa recursivo determine si un numero n, ingresado por

teclado es primo o no.
2. Diseñe e implemente un método recursivo que nos permita obtener el

determinante de una matriz cuadrada de dimensión n
3. Implemente, de forma recursiva, una función que le dé la vuelta a una cadena

de caracteres
4. Mediante un programa recursivo calcule la división de 2 números mediante

restas sucesivas
5. Diseña un algoritmo recursivo que lea una secuencia de caracteres de longitud

arbitraria terminada en un punto, e imprima la suma de todos los dígitos junto
con la sucesión en orden inverso de entrada.
6. Escribe un algoritmo recursivo que ordene un array de la siguiente forma:

a) Sea k el índice del elemento mitad del array.
b) Ordena los elementos hasta a[k], incluyéndolo.
c) Ordena los elementos siguientes.
d) Mezcla los dos subarrays en un único array ordenado.
Este método de clasificación interna se denomina "Mergesort".
7. Diseña un algoritmo recursivo que, dado un array de enteros, devuelva el k-

ésimo elemento más pequeño del array,
es decir, si el array contiene los elementos (4,7,3,6,8,1,9,2) y k=5, el algoritmo
debería devolver 6.
8. Implementa el algoritmo de búsqueda binaria de forma recursiva.
9. Mediante un programa recursivo, determinar si un numero es capicúa o no.
10. Generar el triangulo de Pascal para n filas utilizando funciones recursivas

Ejercicios con Gráficos
Va m o s a p re se nta r m é to d o s p a ra d ib uja r va ria s fig ura s g e o m é tric a s.

C o m o e sto s m é to d o s func io na n so la m e nte c ua nd o so n invo c a d o s p o r
una insta nc ia vá lid a d e la c la se G ra phic s, su á m b ito d e a p lic a c ió n se
re string e a lo s c o m p o ne nte s q ue se utilic e n e n lo s m é to d o s p a int() y
up d a te () . No rm a lm e nte lo s m é to d o s d e d ib ujo d e p rimitiva s g rá fic a s
func io na n p o r p a re s: un m é to d o p inta la fig ura no rm a l y e l o tro p inta la
fig ura re lle na .
Eje rc ic io 1 C re a r un a p p le t q ue d ib uje una líne a re c ta q ue e m p ie za e n

la c o o rd e na d a (10, 10) d e l a p p le t y lle g a a la c o o rd e na d a (200, 10).
// realizado por Edwin Marcelo Guzman Buezo

import java.awt.*; // Librería grafica.
import java.applet.Applet; // Librería para applet
public class Linea extends Applet

// Se indica que la clase Línea pertenece a Applet.
{
public void paint( Graphics g )
// Se declara que g es una instancia de la clase Graphics.
{
g.drawLine( 10, 10, 200, 10 ); // Método para trazar líneas
}
}
El a p p le t a nte rio r lo q ue a se e s d ib uja r una líne a d e sd e la c o o rd e na d a

(10, 10) d e la p a nta lla y tra za una líne a ha sta la c o o rd e na d a (200, 10).El
p rim e r num e ro d e c a d a c o o rd e na d a no s ind ic a e l e sp a c io q ue a b ra
e ntre e l c o m ie nzo izq uie rd o d e l a p p le t c o n la c o o rd e na d a ind ic a d a y e l
se g und o num e ro no s ind ic a e l e sp a c io e ntre e l p unto y la p a rte sup e rio r
d e l a p p le t c o m o ve m o s e n e l g ra fic o .

C a d a fle c ha e m p ie za e n la c o o rd e na d a (0, 0) d e l a p p le t la q ue se
d e sp la za ha c ia la izq uie rd a te nd rá una se g und a c o o rd e na d a d e la
fo rm a (x, 0), d o nd e “ x” se rá e l ta m a ño d e la fle c ha .
El m é to d o q ue se usa e n e ste c a so e s g .dra wLine ( 10, 10, 200, 10 ) ,
d o nd e “ g ” e s una insta nc ia d e la c la se G ra phic s.
Eje rc ic io 2 C re a r un a p p le t q ue te ng a una líne a re c ta q ue lle g ue d e

la c o o rd e na d a (0, 0) a la c o o rd e na d a q ue se e nc ue ntre a la m ita d d e l
a p p le t.

import java.awt.*;
import java.applet.Applet;
public class linea2 extends Applet
{int mancho,malto;
public void init() {

Dimension d = size(); // se crea una instancia de Dimensión.
mancho = d.width; // devuelve el ancho del applet.
malto = d.height; // devuelve la altura del applet.
repaint( );
}
{
g.drawLine( 0,0,mancho/2,malto/2 ); // Método para trazar líneas.
}
}
En e l a nte rio r a p p le t se c re a una líne a re c ta d e ta ma ño va ria b le d e

a c ue rd o a l ta m a ño d e l a p p le t, c o n a yud a d e la insta nc ia “ d ” se

e nc o ntró la a ltura y e l a nc ho d e l a p p le t d e fo rm a q ue d ivid ie nd o e ntre

d o s se p ue d a e nc o ntra r e l c e ntro d e l a p p le t.
La c la se q ue se d e c la ro fue líne a 2 y se d e c la ra q ue p e rte ne c e a Ap p le t
El m é to d o q ue se usa e n e ste c a so e s g .dra wLine ( 0,0,m a nc ho / 2,m a lto / 2
) , d o nd e “ g ” e s una insta nc ia d e la c la se G ra phic s.
Eje rc ic io 3 C re a r una e q uis q ue se inte rsé c a te e n e l c e ntro d e l a p p le t.
/ realizado por Edwin Marcelo Guzman Buezo

import java.awt.*;
public class linea3 extends Applet
{int mancho,malto;

Dimension d = size(); // se crea una instancia de Dimensión.
mancho = d.width; // devuelve el ancho del applet.
malto = d.height; // devuelve la altura del applet.
repaint( );
}
{
g.drawLine( 0,0,mancho-1,malto-1 ); // Método para trazar líneas
g.drawLine( mancho-1,0,0,malto-1 ); // Método para trazar líneas
}
C o m o se vio a nte rio rm e nte se p ue d e c re a r líne a s d e c ua lq uie r p unto a

o tro d e fo rm a se nc illa , c o m o se ve e n e l e je rc ic io se p ue d e utiliza r e l
m é to d o g .dra wLine m a s d e una ve z. Ad e m á s “ g ” e s una insta nc ia d e la
c la se G ra phic s q ue se p ue d e usa r e n m a s m é to d o s.
Eje rc ic io 4 C re a r un a p p le t q ue c o nte ng a un re c tá ng ulo c o n 200

p íxe le s d e a lto y 300 d e a nc ho q ue su e sq uina sup e rio r izq uie rd a e ste e n
la c o o rd e na d a (50, 50).


import java.awt.*;
public class Rectangulo extends Applet

{
{
g.drawRect ( 50,50,300,200 ); // Método para trazar rectángulos
}
}
Este e je rc ic io no e s d ife re nte a lo s q ue re a liza m o s c o n líne a s lo únic o

q ue c a m b ia e s e l m é to d o q ue se utiliza , e n e ste c a so se utiliza e l
m é to d o g .dra wRe c t( 50,50,300,200 ) , c o m o e n lo s o tro s e je rc ic io s se
d e c la ro q ue “ g ” e s una insta nc ia d e la c la se G ra p hic s, e n e l p a ré nte sis
se c o lo c a p rim e ro la c o o rd e na d a d e la p unta sup e rio r izq uie rd a d e l
re c tá ng ulo q ue e n e ste c a so se ria (50, 50) lue g o se c o lo c a e l a nc ho y
lue g o la a ltura e n p íxe le s e n e ste c a so e l a nc ho e s 300 y la a ltura 200.
Eje rc ic io 5 C re a r un a p p le t q ue c o nte ng a a un re c tá ng ulo re lle no c o n
200 p íxe le s d e a lto y 300 d e a nc ho q ue su e sq uina sup e rio r izq uie rd a

e ste e n la c o o rd e na d a (50, 50).

import java.awt.*;
import java.awt.*;
public class Rectangulo1 extends Applet

{
{
g.fillRect ( 50,50,300,200 ); // Método para trazar rectángulos rellenos
}
}

Este e je rc ic io e s ig ua l a l a nte rio r so lo q ue e ste e sta re lle no , p a ra c re a r

re c tá ng ulo s re lle no s se utiliza e l m é to d o g .fillRe c t y la s c o o rd e na d a s so n
ig ua le s a g .dra wRe c t.
Eje rc ic io 6 C re a r un a p p le t q ue c o nte ng a a un re c tá ng ulo re lle no c o n
200 p íxe le s d e a lto y 300 d e a nc ho q ue su e sq uina sup e rio r izq uie rd a

e ste e n la c o o rd e na d a (50, 50), a d e m á s e l c o lo r d e su re lle no d e b e se r
a le a to rio .

import java.awt.*;
public class Rectcol extends Applet { //Se declara la clase Rectcol.

Color color;
public void init(){
color = new Color( aleatorio(255),aleatorio(255),aleatorio(255) );
//Se declara un color aleatorio.
repaint();
}
public void paint( Graphics g ) {

g.setColor ( color );
g.fillRect( 50,50,300,200 );
}
private int aleatorio( int rango )

//Esta es la función que aleatorio
{
double retornoMath;
retornoMath = Math.random();
return( (int)( retornoMath * rango ) );
}
}
En e ste e je rc ic io lo nue vo e s e l uso d e un c o lo r y la fo rma d e ha c e r

núm e ro s a le a to rio s, e l c o lo r se o b tie ne c o n e l m é to d o g .se tC o lo r (c o lo r)
d o nd e c o lo r e s un ve c to r c o n tre s núm e ro s q ue se ña la n q ue c o lo r se
d e b e m o stra r.

La func ió n c re a d a a le a to rio so lo d e vue lve núm e ro s e nte ro s a le a to rio s

c o n a yud a d e l m é to d o ra ndo m () q ue p e rte ne c e a la c la se Ma th.
Eje rc ic io 7 C re a r un a p p le t q ue c o nte ng a un re c tá ng ulo c o m o m a rg e n
d e l a p p le t y d e ntro e l 5 re c tá ng ulo s ub ic a d o s a l a za r c o n c o lo re s a l a za r

import java.awt.*;
public class Rec extends Applet

{
int apAncho,apAlto;
int x,y,ancho,alto;
Color color;

Dimension d = size();
apAncho = d.width;
apAlto = d.height;
}

{
g.setColor( Color.black );
g.drawRect( 0,0,apAncho-1,apAlto-1 );
for( int i=0; i < 5; i++ )

{
x = aleatorio( apAncho );
y = aleatorio( apAlto );
ancho = aleatorio( apAncho - x );
alto = aleatorio( apAlto - y );
color = new Color( aleatorio(255),aleatorio(255),
aleatorio(255) );
g.setColor( color );
g.fillRect( x,y,ancho-1,alto-1 );
}
}
private int aleatorio( int rango ) {

double retornoMath;
retornoMath = Math.random();
return( (int)( retornoMath * rango ) );
}
}
C o m o se ha visto a nte rio rm e nte e l m a rg e n se p ue d e ub ic a r c o n e l

m é to d o g .dra wRe c t, p a ra c re a r 5 re c tá ng ulo s e n su inte rio r se uso un fo r
q ue va d e l 1 a l 5 y g ra c ia s a la func ió n a le a to rio q ue d e vue lve núm e ro s
a l a za r p o d e m o s d a rle s e l ta m a ño y p o sic ió n d e fo rm a a le a to ria sin q ue
se sa lg a n d e l m a rg e n tra za d o .
Eje rc ic io 8 C re a r la b a nd e ra d e Bo livia e n b a se a re c tá ng ulo s d e

ta m a ño 300 d e a nc ho y 200 d e a lto .

import java.awt.*;
public class Bandera extends Applet { //Se declara la clase Bandera.

g.setColor ( Color.red ); //Se declara color Rojo.
g.fillRect( 50,50,300,65 );
g.setColor ( Color.yellow ); //Se declara color Amarillo.
g.fillRect( 50,115,300,65 );
g.setColor ( Color.green ); //Se declara color verde.
g.fillRect( 50,180,300,65 );
}
}
Lo nue vo e n e ste e je rc ic io e s la fo rm a d e d e c la ra r c o lo re s e sp e c ífic o s

c la ro q ue e sto s d e b e n e sta r e n ing le s.
Eje rc ic io 9 C re a r un c írc ulo sin re lle no d e 25 p íxe le s d e ra d io .

import java.awt.*;
public class Redondo extends Applet
{
{
g.drawOval (100, 50, 50, 50 );
//Método para trazar redondos sin relleno
}
}

En e l a nte rio r e je rc ic io se usa e l m é to d o g .dra wO va l q ue sirve p a ra c re a r

c írc ulo s sin re lle no lo q ue se e nc ue ntra e n e l p a ré nte sis se e ntie nd e
c o m o ( de re c ha , a rrib a , a nc ho , a lto ).
• de re c ha e sp a c io e ntre e l c o m ie nzo d e l a p p le t c o n la d e re c ha d e l
c irc ulo .
• a rrib a e s e l e sp a c io e ntre e l c irc ulo c o n la p a rte sup e rio r d e l
a p p le t.
• a nc ho e s e l a nc ho d e l c írc ulo u o va lo .
• a lto e s la a ltura d e l c írc ulo u o va lo .
C o m o e n e l e je rc ic io no s p e d ía n q ue se a d e 25 d e ra d io e nto nc e s se
te nd rá q ue p o ne r 50 d e a nc ho y 50 d e a lto .
Eje rc ic io 10 C re a r un c írc ulo re lle no d e 25 p íxe le s d e ra d io .

import java.awt.*;
public class Redondo2 extends Applet
{
{
g.fillOval (200, 100, 100, 100 );
//Método para trazar redondos con relleno
}
}
En e l a nte rio r e je rc ic io se usa e l m é to d o g .fillO va l q ue sirve p a ra c re a r

c írc ulo s c o n re lle no , ya q ue no se d e c la ro ning ún c o lo r a nte s se usa e l
c o lo r ne g ro p a ra re lle na r la fig ura , En e l p a ré nte sis se e ntie nd e c o m o
( de re c ha , a rrib a , a nc ho , a lto ) e n e ste o rd e n.
• de re c ha e sp a c io e ntre e l c o m ie nzo d e l a p p le t c o n la d e re c ha d e l
c irc ulo .

• a rrib a e s e l e sp a c io e ntre e l c irc ulo c o n la p a rte sup e rio r d e l
a p p le t.
• a nc ho e s e l a nc ho d e l c írc ulo u o va lo .
• a lto e s la a ltura d e l c írc ulo u o va lo .
C o m o e n e l e je rc ic io no s p e d ía n q ue se a d e 25 d e ra d io e nto nc e s se
te nd rá q ue p o ne r 50 d e a nc ho y 50 d e a lto .
Eje rc ic io 11 C re a r un a p p le t q ue c o nte ng a un p a r d e o jo s q ue fije n su
m ira d a a l c urso r d e l ra tó n.

import java.awt.*;
public class Ojos extends Applet {

int Mx = -1;
int My = -1;
int OjoR1;
int OjoR2;
int Ancho;
int Alto;
int OjoIzq;
int OjoDch;
int OjoPY;
Color Pupila = Color.black;
Color Iris = Color.green.brighter();
Color Orbita = Color.white;
Image Imagen;
Graphics OjoCG;
setBackground( Color.darkGray );
// Fijamos las variables que nos van a posicionar los ojos sobre el applet
OjoIzq = d.width >> 2;
OjoDch = OjoIzq * 3;
OjoPY = d.height >> 2;
OjoR2 = d.width >> 4;
OjoR1 = d.width >> 5;
Ancho = ( d.width >> 3 ) + OjoR1;
Alto = Ancho >> 1;
}

public void update( Graphics g ) {

paint( g );
}
// Función auxiliar, para que no se
int swap( int i,int c ) {
// salgan los ojos de las orbitas
if( i > c )
i = c;
else if( i < -c )
i = -c;
return( i );
}
// Pintamos el ojo sobre el applet
void pintaOjo( Graphics g,int x )
{
// Fijamos los desplazamientos, las nuevas posiciones de
//Referencia, en función de la posición del cursor del
// ratón, determinada por Mx y My
int dx = x-Mx;
int dy = OjoPY-My;
// Pintamos el ojo solamente bordeado es decir cerrado
// para cuando el ratón pase por encima.
if( dx < Ancho && dx > -Ancho && dy < Alto && dy > -Alto )
{
g.setColor( getBackground() );
g.fillOval( x-Ancho,OjoPY-Alto,Ancho << 1,Alto << 1 );
g.setColor( getBackground().brighter() );
g.drawOval( x-Ancho,OjoPY-Alto,Ancho << 1,Alto << 1 );
}
else
{
// Pintamos el hueco del ojo, por el que se moverá el iris
g.setColor( Orbita );
g.fillOval( x-Ancho,OjoPY-Alto,Ancho << 1,Alto << 1 );
int y = OjoPY;
dx = swap( dx >> 3,OjoR1 << 1 );
dy = swap( dy >> 5,OjoR1 >> 1 );
if( Mx >= 0 && My >= 0 )
{
x -= dx;
y -= dy;
}
// Pintamos el iris, sobre el que se moverá la pupila

g.setColor( Iris );
g.fillOval( x-OjoR2,y-OjoR2,OjoR2 << 1,OjoR2 << 1 );
if( Mx >= 0 && My >= 0 )
{
x -= ( dx >> 1 );
y -= dy;
}
// Pintamos la pupila dentro del iris
g.setColor( Pupila );
g.fillOval( x-OjoR1,y-OjoR1,OjoR1 << 1,OjoR1 << 1 );
}
}

// La primera vez que se llama a este método, todavía no
// hay nada, así que creamos el soporte de los ojos
if( Imagen == null || OjoCG == null )
{
Imagen = createImage( d.width,d.height >> 1 );
OjoCG = Imagen.getGraphics();
}
// Pintamos los ojos

OjoCG.setColor( getBackground() );
OjoCG.fillRect( 0,0,d.width,d.height );
pintaOjo( OjoCG,OjoIzq );
pintaOjo( OjoCG,OjoDch );
g.drawImage( Imagen,0,0,this );
} // Cuando movemos el cursos dentro del applet, recibimos las
// coordenadas y repintamos el ojo
public boolean mouseMove( Event evt,int x,int y ) {
Mx = x;
My = y;
repaint();
return true;
}
public boolean mouseExit( Event evt,int x,int y ) {
Mx = My = -1;
repaint();
return true;
}
}
En e ste e je rc ic io se tra to d e e xp lic a r a lg uno s m o vim ie nto s q ue se

p ue d e n o b te ne r c o n m é to d o s p a re c id o s a lo s ya visto s, la s
e xp lic a c io ne s se la s e nc ue ntra e n e l c ó d ig o y la s q ue no se e xp lic a n
e stá n e n e je rc ic io s a nte rio re s.

BIBLIOGRAFIA
JO YANES AG UILAR LUIS, FERNANDEZ AZUELA MATILDE, JAVA 2

MANUAL DE PRO G RAMAC IO N, Mc g ra w -Hill, 2001
http :/ / w w w .m o no g ra fia s.c o m / tra b a jo s/ ja va / ja va .shtm l
http :/ / w w w .a rra kis.e s/ ~a b e lp / Ap unte sJa va / Intro d uc c io n.htm
http :/ / w w w d i.uja e n.e s/ ~m g a re na s/ ja va / g e ne ra l/ ind ic e .htm l
Ap unte s p ro p io s d e c la se s.
http :/ / w w w .lc c .um a .e s/ ~a fd e z/ a p unte s/ e le II/ re la c io n1.p d f
http :/ / w w w .ita p iza c o .e d u.m x/ p a g ina s/ Ja va Tut/ fro ufe / p a rte 2/
Eje rc ic io s Pro p ue sto s:
Ing . O rla nd o Rive ra , Intro d uc c io n a la Pro g ra m a c ió n, 2007
http :/ / usua rio s.lyc o s.e s/ sa np la a le / p ro g ra m a c io / Eje rc ic io sPro g ra

m a c io n.htm
Lo s m ism o s a uto re s.

Programacion Guia y Ejercicios Resueltos

Cargado por

Información del documento

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Programacion Guia y Ejercicios Resueltos

Cargado por

Copyright:

Formatos disponibles

UNIVERSIDAD C ATO LIC A BO LIVIANA

O SSIO MARIN SERG IO WILLY

DO C ENTE: M.Sc . IRMA PRADO

SEMESTRE I AÑO 2007

INTEG RANTES: Se rg io O ssio , And ré s Prud e nc io , Ig na c io Sa lg a d o , Fre d d y Va ld a 1

En e sta g uía e nc o ntra rá a p ro xim a d a m e nte 100 e je rc ic io s re sue lto s

INTEG RANTES: Se rg io O ssio , And ré s Prud e nc io , Ig na c io Sa lg a d o , Fre d d y Va ld a 2

En e l a ño 1991 na c ió Ja va c ua nd o e n Sun , una e m p re sa nue va , se

El c o ntinuo c a m b io e n la s c o m p uta d o ra s o b lig a b a a c a m b ia r lo s

Evid e nte m e nte , lo s e le c tro d o m é stic o s no e sta b a n inte re sa d o s e n

Se p ub lic ó Ja va 1.1 a p rinc ip io s d e 1997 y Ja va 1.2 a fina le s d e 1998

La c o m p a ñía Sun d e sc rib e a Ja va c o m o "sim p le , o rie nta d o a

INTEG RANTES: Se rg io O ssio , And ré s Prud e nc io , Ig na c io Sa lg a d o , Fre d d y Va ld a 3

Programacion Orientada a Objetos

La p rinc ip a l func ió n d e e ste tuto ria l no e s e nse ña r to d o s y c a d a uno d e

La e struc tura g e ne ra l d e un p ro g ra m a o rie nta d o a o b je to s (PO O ), se

Una c la se e s una c o le c c io n d e va ria b le s y m é to d o s q ue m a ne ja n

La he re nc ia e s o tro c o nc e p to im p o rta nte d e la PO O , p e rm ite d e finir

e ntre la lla m a d a a un m é to d o y e l c ó d ig o q ue e fe c tiva m e nte se a so c ia c o n

La vinc ula c ió n te m p ra na e s la m á s e fic ie nte y e s la q ue se da

re fie re a la p o sib ilid a d d e te ne r d o s o m á s func io ne s c o n e l m ism o

Ad e m á s d e c la se s, Ja va p ro p o rc io na inte rfa c e s. Un inte rfa c e e s un

o Lo s no m b re s d e c la se s e inte rfa c e s c o m ie nza n

INTEG RANTES: Se rg io O ssio , And ré s Prud e nc io , Ig na c io Sa lg a d o , Fre d d y Va ld a 6

• Ja va e s un le ng ua je fue rte m e nte tip ific a d o y la c o nve rsió n

INTEG RANTES: Se rg io O ssio , And ré s Prud e nc io , Ig na c io Sa lg a d o , Fre d d y Va ld a 7

Ja va , p a ra c o nse g uir se r un le ng ua je ind e p e nd ie nte d e l siste m a

No o b sta nte , e ste p a no ra m a e stá c a m b ia nd o a p a so s a g ig a nta d o s, y

La im a g e n d e la izq uie rd a m ue stra la s a c c io ne s c o rre sp o nd ie nte s a un

INTEG RANTES: Se rg io O ssio , And ré s Prud e nc io , Ig na c io Sa lg a d o , Fre d d y Va ld a 8

c o n e l re sulta d o d e m últip le s c o m p ila c io ne s p re via s q ue ha n d a d o o rig e n a

La im a g e n sig uie nte , situa d a a la izq uie rd a , m ue stra

INTEG RANTES: Se rg io O ssio , And ré s Prud e nc io , Ig na c io Sa lg a d o , Fre d d y Va ld a 9

Y, fina lm e nte , se p re se nta la últim a te nd e nc ia e n lo q ue a c o m p ila c ió n e

INTEG RANTES: Se rg io O ssio , And ré s Prud e nc io , Ig na c io Sa lg a d o , Fre d d y Va ld a 10

un c a c hé e n c ó d ig o m á q uina na tivo . C ua nd o un m é to d o e s invo c a d o , e sta

Diferencias y similitudes con C++

Ja va no so p o rta typ e d e fs, d e fine s o c o m a nd o s d e p re p ro c e sa d o r. Al no

Ja va so p o rta c la se s, p e ro no so p o rta e struc tura s o unio ne s.

To d a s la s a p lic a c io ne s C ++ ne c e sita n una func ió n d e e ntra d a lla m a d a

To d a s la s func io ne s o d e finic io ne s d e m é to d o s e n Ja va d e b e n e sta r

INTEG RANTES: Se rg io O ssio , And ré s Prud e nc io , Ig na c io Sa lg a d o , Fre d d y Va ld a 11

Ta nto Ja va c o m o C ++ so p o rta n func io ne s o m é to d o s (e stá tic o s) d e

En Ja va se intro d uc e e l c o nc e p to d e inte rfa c e , q ue no e xiste e n C ++.

Ja va no so p o rta he re nc ia m últip le , a unq ue se p ue d e n utiliza r la s

Ja va no so p o rta la se nte nc ia g o to , a unq ue se a una p a la b ra re se rva d a .

Ja va no so p o rta la so b re c a rg a d e o p e ra d o re s, a unq ue la utilic e

Al c o ntra rio q ue C ++, Ja va d isp o ne d e un tip o String y lo s o b je to s d e

INTEG RANTES: Se rg io O ssio , And ré s Prud e nc io , Ig na c io Sa lg a d o , Fre d d y Va ld a 12

Al c o ntra rio q ue C ++, Ja va tra ta a lo s a rra ys c o m o o b je to s re a le s.

Ja va no so p o rta p unte ro s, a l m e no s e n e l se ntid o q ue a trib uye C ++, e s

La d e finic ió n d e c la se e s se m e ja nte e n Ja va y C ++, a unq ue e n Ja va no

INTEG RANTES: Se rg io O ssio , And ré s Prud e nc io , Ig na c io Sa lg a d o , Fre d d y Va ld a 13

Al ig ua l q ue C ++, Ja va d isp o ne d e tip o s p rimitivo s c o m o int, flo a t, e tc .

El tip o c ha r e n C ++ e s un tip o d e 8 b its q ue m a p e a e l c o njunto

Al c o ntra rio q ue e n C ++, e l o p e ra d o r d e sp la za m ie nto (>>) e s un

C ++ p e rm ite la insta nc ia c ió n d e va ria b le s u o b je to s d e c ua lq uie r tip o e n

C ++ re q uie re q ue la s c la se s y func io ne s e sté n d e c la ra d a s a nte s d e

INTEG RANTES: Se rg io O ssio , And ré s Prud e nc io , Ig na c io Sa lg a d o , Fre d d y Va ld a 14

En C ++, si no se ind ic a n va lo re s d e inic ia liza c ió n p a ra la s va ria b le s d e

Al ig ua l q ue o c urre e n C ++, Ja va ta m b ié n so p o rta c o nstruc to re s q ue

C o m o C ++, Ja va ta m b ié n so p o rta la so b re c a rg a d e func io ne s. Sin

El m ultithre a d ing , o m ultihilo , e s a lg o c a ra c te rístic o de Ja va , q ue se

Aunq ue Ja va utiliza la s m ism a s p a la b ra s c la ve q ue C ++ p a ra ind ic a r e l