Programacin en Java

Sentencia while
Programacin en Java/Sentencia while
Estructuras de iteracin Sentencia while Sentencia do-while
La sentencia while es la ms sencilla de las estructuras de iteracin. La iteracin continuar
hasta que su condicin sea alsa.
while ( condicin ) sentencia ;
La condicin tiene que tomar un valor !ooleano "verdadero o also#. Si este valor es
verdadero$ se e%ecutar la sentencia. &oncluida esta accin se vuelve a evaluar la condicin.
Proseguirn los ciclos hasta que la condicin no cam!ie a also.
Esta es una estructura de iteracin 're'rue!a$ es decir 'rimero se eval(a la condicin antes
de reali)ar cualquier accin. Si de entrada la condicin es alsa nunca e%ecutar el con%unto
de sentencias.
int n = 0;
while ( n > 0 ) System.out.println("Esto nunca lo vers");
*entro del con%unto de sentencia que controla$ de!e e+istir alguna que cam!ie el valor de la
condicin que se est evaluando.
oolean pruea = true;
while ( pruea ) !
System.out.println("Esto lo vers una ve"");
pruea = #alse;
$
Entrar,amos en un ciclo ininito si nunca se modiica la condicin - 'ermanece verdadera.
oolean pruea = true;
while ( pruea ) !
System.out.println("Esto lo vers muchas veces");
$
.eneralmente esta estructura se utili)a en situaciones en donde desconocemos la cantidad
de ciclos que se de!en e%ecutar 'ara 'roducir un resultado. /ostraremos como se utili)a en
estas circunstancias con el e%em'lo de 'ase a !inario$ mostrado en el ca',tulo anterior.
0en,amos que transormar un n(mero decimal a !inario. El 'rograma en %ava nos queda de
esta manera1
pulic class %ec&'in!
pulic static void main(Strin( ar(s)*)!
int decimal = &+&&&&;
Strin( inario = "";
while ( decimal > 0 ) !
inario = decimal , & - inario;
decimal .= &;
$
System.out.println(inario);
$
$
&omo no sa!emos de antemano cuantas vueltas de!e dar$ sim'lemente es'eramos que el
resultado de las divisiones sucesivas sea igual a cero.
0am!i2n se 'ueden reali)ar ciclos con while en donde -a conocemos$ antes de entrar en la
estructura$ cuantas vueltas de!e dar 'ara terminar. Para esto nos au+iliamos con un
contador de vueltas. Previamente tiene que iniciali)arse antes de ingresar al ciclo. Luego en
cada vuelta se modiicara seg(n la lgica del algoritmo.
3ealicemos el 'rograma que des'liegue 'or 'antalla cinco l,neas de caracteres.
pulic class /uadrado!
pulic static void main(Strin( ar(s)*)!
int contador = 0;
while ( contador 1= + ) !
System.out.println("22222");
contador--;
$
$
$
En este algoritmo$ iniciali)amos el contador a 4 - luego en cada ciclo se incrementa. La
condicin de corte tiene como o!%etivo no 'ermitir mas vueltas si el contador su'er el
valor 5.
Para tener varias veces el asterisco sin necesidad de im'rimirlo asi 6777776$ utili)amos otro
ciclo while - otra varia!le que iniciali)aremos dentro del ciclo 'ara que se cum'la la cual
llamaremos 6contador86$ o!tendremos el mismo resultado que el anterior$ el codigo
quedaria asi1
'u!lic class &uadrado 9
pulic static void main (Strin( ar(s )*)
!
int contador = 0;
while (contador 1= +)
!
int contador& = 0;
while (contador& 1= +)
!
System.out.print ("2");
contador&--;
$
System.out.println ();
contador--;
$
$
:
"co'ian la 'arte que queda uera del recuadro 'unteado al 'rinci'io$ - la llave que queda
uera al inal del mismo$ lo 'egan en read- to 'rogram - lo corren#
Programacin en Java
Sentencia do-while
Programacin en Java/Sentencia do-while
Sentencia while Sentencia do-while Sentencia or
La sentencia de iteracin do-while es de ti'o 'os'rue!a. Primero reali)a las acciones luego
'regunta. La sinta+is es la siguiente1
do sentencia while ( condicin );
;!servamos que es como un while 'ero al rev2s. Primeramente se e%ecuta la sentencia -
luego eval(a la condicin. Si la e+'resin de la condicin es verdadera vuelve a dar un
ciclo. *e lo contrario$ termina. Esto nos garanti)a que la sentencia se e%ecute al menos una
ve).
do System.out.println("3o veras una ve"");
while ( #alse );
3esulta (til 'ara los casos en donde tendremos que reali)ar ciertas acciones antes de
veriicar una condicin.
3ealicemos un 'rograma que cuente la cantidad de d,gitos que 'osee un n(mero. Para ello
tendremos que dividir 'or die) el n(mero que nos han dado$ hasta que el resultado se
vuelva cero. Entonces recurrimos al while 'ara realice los ciclos necesarios.
pulic class /uenta%i(itos!
pulic static void main(Strin( ar(s)*)!
int n4mero = 5++6777;
int d8(itos = 0;
while ( n4mero > 0 ) !
n4mero .=00;
d8(itos--;
$
System.out.println(d8(itos);
$
$
<=u2 ocurre si el n(mero que nos dan es el cero> El resultado nos dar cero. ;!viamente es
errneo$ de!er,a devolver un d,gito. Pero no entra en el ciclo de!ido a que de entrada no
satisace la condicin. Podr,amos im'lementar una solucin 6ad hoc6.
n4mero .=00;
d8(itos--;
while ( n4mero > 0 ) !
n4mero .=00;
d8(itos--;
$
3eali)amos 'rimeramente las o'eraciones - luego entramos en el !ucle si se veriica la
condicin. Pero no hace alta mirar mucho 'ara darnos cuenta que es una solucin 'oco
elegante. En realidad quedar me%or con la sentencia do-while
pulic class /uenta%i(itos!
pulic static void main(Strin( ar(s)*)!
int n4mero = 5++6777;
int d8(itos = 0;
do !
n4mero .=00;
d8(itos--;
$
while ( n4mero > 0 );
System.out.println(d8(itos);
$
$
Programacin en Java
Sentencia for
Programacin en Java/Sentencia for
0ra!a%amos con casos de interaccin en donde a 'riori no conoc,amos la cantidad de ciclos
que se e%ecuta!an hasta cum'lir con una condicin. Para esto utili)amos la sentencia while.
Pero ahora estudiaremos con ms detalle aquellos casos en donde se sa!e de antemano
cuantos ciclos se de!en cum'lir 'ara terminar la e%ecucin.
?m'rimiremos una ta!la de multi'licar hasta el actor noveno. Si no utili)amos ninguna
estructura de interaccin$ de!er,amos im'rimir nueve l,neas de cdigo secuencial.
System.out.println("9 : 0 = 9");
System.out.println("9 : & = ;");
System.out.println("9 : 9 = <");
System.out.println("9 : 5 = 0&");
System.out.println("9 : + = 0+");
System.out.println("9 : ; = 07");
System.out.println("9 : 6 = &0");
System.out.println("9 : 7 = &5");
System.out.println("9 : < = &6");
Pero -a conocemos las estructuras que nos ahorran el esuer)o de escri!ir tanto cdigo.
@tili)aremos una sentencia que -a conocemos1 el while
int #actor = 0;
while ( #actor 1= < ) !
System.out.println("9 : " - #actor - " = " - 92#actor );
#actor--;
$
@tili)amos la varia!le actor 'ara contar la cantidad de l,neas que im'rimimos.
Primeramente la iniciali)amos en uno. &uando se e%ecuta la interaccin se controla que no
su'ere su valor de A. Si el valor es menor o igual que nueve$ im'rime una l,nea de la ta!la e
incrementa a uno el valor de actor. &ualquier caso de interaccin que se com'lete en una
cantidad 'rei%ada de ciclos$ necesitamos una varia!le de control. Si utili)amos la sentencia
while$ esta varia!le se de!e deinir e iniciali)ar antes del !ucle - contar con una instruccin
que modiique su valor dentro del !ucle.
Beremos como este cdigo cam!ia ligeramente si en lugar de while 'resentamos una nueva
sentencia denominada for
#or ( int #actor = 0; #actor 1= <; #actor -- ) !
System.out.println("9 : " - #actor - " = " - 92#actor );
$
la sentencia or me 'ermite re'etir un ciclo n veces$ en donde se de!e determinar el valor
inicial - cuantas veces se re'etira.
sinta+is
#or(!valor inicial$;!condicin de termino$;!#actor de incremento del
valor inicial$)!
..ac va lo =ue se repetir n veces de acuerdo a la condicin de
termino
$
Cucle ininito1 no ha- control$ entonces no se detiene
#or ( ;;)!$
;'erador coma 1
#or ( int >=0? @=00 ;> 1 @ ;>-- ?@AA )!
System.out.println(> - " " - @);
$
[editar] for mejorado
Su'ongamos que tenemos un arreglo de enteros que deseamos 'resentar en 'antalla$ usando
la orden or tradicional$ el cdigo$ 'odr,a quedar as,1
int)* laiEnteros = !0? &? 9? 5? +? ;? 6? 7? <? 00$;
#or (int i = 0; i 1 00; i --)
System.out.println (laiEnteros)i*);
Java orece una uncionalidad e+tra 'ara la orden or$ mediante la que se 'uede sim'liicar
nota!lemente el codigo anterior$ quedando as,1
int)* laiEnteros = !0? &? 9? 5? +? ;? 6? 7? <? 00$;
#or (int liElemento B laiEnteros)
System.out.println (liElemento);
En este caso$ liElemento toma el valor de cada uno de los elementos de laiEnteros$
'ermitiendo una navegacin ms sim'le$ 'uesto que se evitan 'osi!les errores derivados
del uso de los arreglos en orma directa. 0am!i2n se 'uede usar esta orma$ 'ara estructuras
ms com'le%as como o!%etos de la clase &ollection
pulic void Cresenta (/ollection 1Dnte(er> po/on@unto)!
#or (Dterator 1Dnte(er> loElemento B po/on@unto)
System.out.println (loElemento)
$