Conversiones
entre Datos de Java
En Java es posible transformar el
tipo de una variable u objeto en otro diferente al original con el que fue
declarado. Este proceso se denomina "conversión",
"moldeado" o "tipado" y es algo que debemos
manejar con cuidado pues un mal uso de la conversión de tipos es frecuente que
dé lugar a errores.
Una forma de realizar conversiones
consiste en colocar el tipo destino entre paréntesis, a la izquierda del valor
que queremos convertir de la forma siguiente: Tipo VariableNueva = (NuevoTipo)
VariableAntigua;
Por ejemplo: int miNumero = (int)
ObjetoInteger; char c = (char)System.in.read();
En el primer ejemplo, extraemos como
tipo primitivo int el valor entero contenido en un campo del objeto Integer. En
el segundo caso, la función read devuelve un valor int, que se convierte en un
char debido a la conversión (char), y el valor resultante se almacena en la
variable de tipo carácter c.
El tamaño de los tipos que queremos
convertir es muy importante. No todos los tipos se convertirán de forma segura.
Por ejemplo, al convertir un long en un int, el compilador corta los 32 bits
superiores del long (de 64 bits), de forma que encajen en los 32 bits del int,
con lo que si contienen información útil, ésta se perderá. Este tipo de
conversiones que suponen pérdida de información se denominan “conversiones no
seguras” y en general se tratan de evitar, aunque de forma controlada pueden
usarse puntualmente.
De forma general trataremos de
atenernos a la norma de que "en las conversiones debe evitarse la
pérdida de información". En la siguiente tabla vemos conversiones
que son seguras por no suponer pérdida de información.
|
TIPO ORIGEN
|
TIPO DESTINO
|
|
byte
|
double, float, long, int,
char, short
|
|
short
|
double, float, long, int
|
|
char
|
double, float, long, int
|
|
int
|
double, float, long
|
|
long
|
double, float
|
|
float
|
Double
|
No todos los tipos se pueden
convertir de esta manera. Como alternativa, existen otras formas para realizar
conversiones.
Int a double/Double
a Int
Double a int/Int aDouble
Para convertir
una variable de tipo double a tipo intbasta con colocar la instrucción
(int) justo antes del tipo double, como en:
x = (int)Math.pow(10,x - 1);
que es parte del
siguiente programa que genera números aleatorios entre 1 y 9. Hay que tener en
cuenta que la parte decimal será truncada.
import java.util.Random;
public class Convertir
{ // Abre clase
convertir
public static void main( String args[])
{ // Abre main
Random Aleatorios = new Random();
int x = 1;
x = (int)Math.pow(10,x - 1) +
Aleatorios.nextInt((int)Math.pow(10, x) - (int)Math.pow(10, x -1));
System.out.printf("\nEl numero x es: %d\n", x);
}
// Cierra main
}
// Cierra clase convertir
Int a String
Para convertir un String (cadena) a int (entero) hay que emplear el
método estático de la clase Integer, parseInt
Ejemplo:
String enteroString = "5";
int entero = Integer.parseInt(enteroString);
Para convertir int(entero) a String sólo debemos
hacer una llamada al método estático de la clase Integer, toString
Ejemplo:
int entero = 1;
String enteroString = Integer.toString(entero);
Análogamente para pasar de cadena a double
tenemos el método Double.parseDouble
Ejemplo:
double aDouble = Double.parseDouble(aString);
o al revés (double a string) llamamos al método
Double.toString
Ejemplo:
double d = 8342342;
System.out.println(Double.toString(d));
Double a String
public class ConvertDoubleToString
{
public static void main(String[] args) {
double aDouble = 0.11;
String aString = Double.toString(aDouble);
}
}
Estructuras
de Control de Java
Las estructuras de control determinan
la secuencia de ejecución de las sentencias de un programa.
Las estructuras de control se dividen en tres
categorías:
Secuencial
Condicional
o Selectiva
Iterativa
o Repetitiva.
Sentencias
de Salto if, switch
Se utiliza para seleccionar una de entre múltiples
alternativas.
La forma general de la instrucción switch en Java
es la siguiente:
switch (expresión){
case valor 1:
instrucciones;
break;
case valor 2:
instrucciones;
break;
· · ·
default:
instrucciones;
}
La instrucción switch se puede usar con datos de tipo
byte, short, char e int. También con tipos enumerados y con las clases
envolventes Character, Byte, Short e Integer. A partir de Java 7 también pueden
usarse datos de tipo String en un switch.
Funcionamiento de la instrucción switch:
- Primero se evalúa la expresión
y salta al case cuya constante coincida con el valor de la expresión.
– Se ejecutan las
instrucciones que siguen al case seleccionado hasta que se encuentra un break o
hasta el final del switch. El break produce un salto a la siguiente instrucción
a continuación del switch.
– Si ninguno de estos
casos se cumple se ejecuta el bloque default (si existe). No es
obligatorio que exista un bloque default y no tiene porqué ponerse siempre al
final, aunque es lo habitual.
Ejemplo de programa Java que contiene una instrucción switch: Programa que lee
por teclado un mes (número entero) y muestra el nombre del mes.
/*
* Programa que
pide un número de mes y muestra el nombre correspondiente
*/
import java.util.*;
public class Ejemplo0Switch {
public static void main(String[] args) {
int mes;
Scanner sc = new Scanner(System.in);
System.out.print("Introduzca un numero de mes: ");
mes = sc.nextInt();
switch (mes)
{
case 1: System.out.println("ENERO");
break;
case 2: System.out.println("FEBRERO");
break;
case 3: System.out.println("MARZO");
break;
case 4: System.out.println("ABRIL");
break;
case 5: System.out.println("MAYO");
break;
case 6: System.out.println("JUNIO");
break;
case 7: System.out.println("JULIO");
break;
case 8: System.out.println("AGOSTO");
break;
case 9: System.out.println("SEPTIEMBRE");
break;
case 10: System.out.println("OCTUBRE");
break;
case 11: System.out.println("NOVIEMBRE");
break;
case 12: System.out.println("DICIEMBRE");
break;
default : System.out.println("Mes no
válido");
}
}
}
Sentencias de bucle for
while do-while
3.4
BUCLES INFINITOS EN JAVA
Java permite la posibilidad de construir bucles
infinitos, los cuales se ejecutarán indefinidamente, a no ser que provoquemos
su interrupción. Tres ejemplos:
for(;;){
instrucciones
}
for(;true;){
instrucciones
}
while(true){
instrucciones
}
3.5
BUCLES ANIDADOS
Bucles
anidados son aquellos que incluyen instrucciones for, while o do-while unas
dentro de otras.
Debemos tener en cuenta que las variables de
control que utilicemos deben ser distintas.
Los anidamientos de estructuras tienen que ser
correctos, es decir, que una estructura anidada dentro de otra lo debe estar
totalmente.
Ejemplo de programa Java con bucles anidados:
/*
* Programa que dibuja un rectángulo sólido de asteriscos.
* El número de filas y columnas se pide por teclado
*/
import java.util.*;
public class Ejemplo1BuclesAnidados {
public static
void main(String[] args) {
Scanner sc = new Scanner(System.in);
int filas,
columnas;
//leer número de
filas hasta que sea un número > 0
do{
System.out.print("Introduce número de filas: ");
filas = sc.nextInt();
}while(filas<1);
//leer número de
columnas hasta que sea un número > 0
do{
System.out.print("Introduce número de columnas: ");
columnas = sc.nextInt();
}while(columnas<1);
for(int i = 1; i<=filas; i++){ //filas
for(int j = 1; j<=columnas;
j++){ //columnas
System.out.print(" * ");
}
System.out.println();
}
}
}
La salida de este programa para filas = 6 y
columnas = 10 es:
* * * * *
* * * * * * *
* * * * *
* * * * * * *
* * * * *
* * * * * * *
* * * * *
* * * * * * *
* * * * *
* * * * * * *
* * * * *
* * * * * * *
3.1
CICLO WHILE
Las instrucciones se repiten mientras la condición
sea cierta. La condición se comprueba al principio del bucle por
lo que las acciones se pueden ejecutar 0 ó más veces.
La ejecución de un bucle while sigue los siguientes pasos:
1. Se evalúa la condición.
2. Si
el resultado es false las instrucciones no se ejecutan y el programa sigue
ejecutándose por la siguiente instrucción a continuación del while.
3. Si el
resultado es true se ejecutan las instrucciones y se vuelve al paso 1
Ejemplo de programa
Java que contiene una instrucción while:
Programa que lee
números por teclado. La lectura acaba cuando el número introducido sea
negativo. El
programa calcula y muestra la suma de los números leídos.
/*
* Programa que lee números hasta que se lee un negativo y muestra
la
* suma de los números leídos
*/
import java.util.*;
public class Ejemplo1While
{
public
static void main(String[] args) {
int suma = 0, num;
Scanner sc = new Scanner(System.in);
System.out.print("Introduzca
un número: ");
num = sc.nextInt();
while (num >= 0){
suma = suma + num;
System.out.print("Introduzca un número: ");
num = sc.nextInt();
}
System.out.println("La suma es: " + suma );
}
}
3.2
CICLO DO – WHILE
Las instrucciones se ejecutan mientras la condición
sea cierta.
La condición se comprueba al final del bucle por
lo que el bloque de instrucciones se ejecutarán al menos una vez. Esta es la
diferencia fundamental con la instrucción while. Las instrucciones
de un bucle while es posible que no se ejecuten si la condición inicialmente es
falsa.
La ejecución de un bucle do - while sigue los
siguientes pasos:
1. Se ejecutan
las instrucciones a partir de do{
2. Se evalúa
la condición.
3. Si el resultado es false el
programa sigue ejecutándose por la siguiente instrucción a continuación del
while.
4. Si el
resultado es true se vuelve al paso 1
Ejemplo de programa Java que
contiene una instrucción do while:
Programa que lee un número entero N.
El número debe ser menor que 100.
/*
* Programa que obliga al usuario a introducir un número menor que
100
*/
import java.util.*;
public class
Ejemplo1DoWhile {
public
static void main(String[] args) {
int valor;
Scanner in = new Scanner( System.in );
do {
System.out.print("Escribe un entero < 100: ");
valor = in.nextInt();
}while
(valor >= 100);
System.out.println("Ha introducido: " + valor);
}
}
3.3
CICLO FOR
Hace que una instrucción o bloque de instrucciones
se repitan un número determinado de vecesmientras se cumpla
la condición.
La estructura general de una instrucción for en
Java es la siguiente:
for(inicialización; condición;
incremento/decremento){
instrucción 1;
...........
instrucción N;
}
A continuación de la palabra for y entre paréntesis
debe haber siempre tres zonas
separadas por punto y coma:
- zona
de inicialización.
- zona
de condición
- zona
de incremento ó decremento.
Si en alguna ocasión no es necesario escribir
alguna de ellas se pueden dejar en blanco, pero los dos punto y coma deben
aparecer.
Inicialización es la parte en la que la
variable o variables de control del bucle toman su valor inicial. Puede haber
una o más instrucciones en la inicialización, separadas por comas. La
inicialización se realiza solo una vez.
Condición es una expresión booleana que
hace que se ejecute la sentencia o bloque de sentencias mientras que dicha
expresión sea cierta. Generalmente en la condición se compara la variable de
control con un valor límite.
Incremento/decremento es una expresión que decrementa
o incrementa la variable de control del bucle.
La ejecución de un bucle for sigue los siguientes
pasos:
1. Se inicializa la variable o variables de control
(inicialización)
2. Se evalúa la condición.
3. Si la condición es cierta se ejecutan las
instrucciones. Si es falsa, finaliza la ejecución del bucle y continúa el
programa en la siguiente instrucción después del for.
4. Se actualiza la variable o variables de control
(incremento/decremento)
5. Se vuelve al punto 2.
Ejemplo de programa Java que
contiene una instrucción for:
/*
* programa que muestra los números del 1 al 10
*/
public class Ejemplo0For {
public
static void main(String[] args) {
int i;
for(i=1; i<=10;i++)
System.out.println(i + " ");
}
}
Sentencias break continue return
Break
Aplicable dentro de
bucles y estructuras condicionales de tipo switch. Su ejecución provoca que se
salga del bucle o etiqueta que se esté ejecutando sin finalizar el resto de las
sentencias asociadas al mismo.
Return
Se utiliza para truncar la ejecución de un método o para almacenar
el dato que devuelven. Puede emplearse para truncar bucles cuando no haya más
código después del bucle.
Las sentencias break y continue permiten manipular el
comportamiento normal de los bucles for para detener el bucle o para
saltarse algunas repeticiones. Concretamente, la sentencia break permite terminar de forma abrupta
un bucle y la sentencia continue permite saltarse algunas repeticiones del bucle.
El siguiente
ejemplo muestra el uso de la sentencia break:
var cadena = "En un lugar de la Mancha de cuyo nombre no quiero acordarme...";
var letras = cadena.split("");
var resultado = "";
for(i in letras) {
if(letras[i] == 'a') {
break;
}
else {
resultado += letras[i];
}
}
alert(resultado);
// muestra "En un lug"
