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"