Java.Clases.

Clases Predefinidas.

En Java existen clases predefinidas listas para usarla el programador. Podemos buscar estas clases dentro del Api de Java.

¿Qué es eso de Api de Java?. Es una colección de clases públicas prediseñadas que puede usar el programador cuando lo desee y así evitar programarlo él mismo. Se actualiza con muchísima frecuencia y va aumentando día a día. Está organizado por paquetes y clases.

Api de Java.

En esta parte voy hablar de algunas clases que me parecen interesantes saber para el día a dia.

Clase Math.

Es una clase que vienen incrustada en el propio Java en el que se pueden hacer muchísimas operaciones matemáticas. Vamos a ver algunas de ellas:

Como Math es una clase se accede a sus métodos de la misma forma que cualquier otra clase, es decir, clase.método(parámetro1, parámetro2…);

public class Mate {
  public static void main(String[] args) {
    int num;
    num=Math.min(7, 25); // mínimo
    System.out.println("El mínimo es "+num);
    num=Math.max(7, 25); //máximo
    System.out.println("El máximo es "+num);
    num=Math.abs(25); //valor absoluto
    System.out.println("El valor absoluto es "+num);
  }
}

Aquí algunos ejemplos de los posibles métodos que podemos utilizar con la Clase Math. Hay muchos más en solo hay que ojear un poco en la Api de Java.

Yo ahora voy hablar de un par de ellas que creo que hay que prestar un poco de atención:

• Sqrt. Raíz cuadrada. Devuelve un tipo double.
• Pow. Potencia. Devuelve un double.
• Random. Devuelve un valor aleatorio tipo double.
• Round. Redondea un número y devuelve un tipo double.

Si intentamos guarda en una variable entera un método que el valor que nos devuelva es de otro tipo, Java nos dará un error porque no puede meter por ejemplo un double en un entero, ya que es más pequeño.

Error

¿Y como arreglo esto?. Pues muy simple, o usamos una variable del tipo que nos pide el propio método, que en estos casos es tipo double o hacemos lo que se llama en Java un Casting de variables.

Casting, ¿eso que es?. Es convertir una variable de un tipo a otro en tiempo de ejecución. Para esto sólo basta poner entre paréntesis el tipo de conversión detrás de la variable;

Casting.

Evidentemente si convertimos un resultado que va a ser de coma flotante a un entero, la parte fraccionaria se va perder, eso hay que tenerlo en cuenta y todo dependerá si nos interesa hacer un casting o no.

En los casting es compatible entre sí todos los tipos numéricos, pero un booleano y un texto no lo son.

Math.Random.

Este método nos devuelve un random comprendido entre el 0 y 1 si no le indicamos parámetros. Pero habrá veces que nos interese cambiar ese rango. Vemos unos ejemplos para ver como funciona:

num=Math.random()*30; //Comprendido entre el 0 y 29.
num=Math.random()*(5-20)+20. //Comprendido entre el 5 y 19.

Para indicarlo un rango es sólo ponerle Math.random()*(mínimo-máximo)+máximo.

Clase String.

Cuando vamos los tipos de datos primitivos no nombramos la cadena de caracteres, sólo el tipo char para un sólo carácter. Java no considera las cadenas de caracteres como un dato primitivo, él lo trata como un objeto.

• Representa cadena de caracteres.
• Este tipo debe ir entre comillas dobles.
• Es una clase que se puede declarar como un objeto invocando al constructor como cualquier otra clase o como un tipo de variable primitiva.

y bueno ¿Cómo lo hago?

String texto= new String("Cadena de texto"); //Como un objeto
String texto2="Cadena de texto"; //Como un tipo primitivo.

Algunos métodos que podemos usar con la clase String:

• length(): Devuelve la cantidad de caracteres del String.

"Hola".length(); // devuelve 4

• charAt(int i): Devuelve el carácter en el índice i.

System.out.println("hola mundo".charAt(3)); // devuelve 'a'

• substring (int i): Devuelve la cadena a partir del índice que le digamos.

"holita mundo".substring(4); // devuelve "ta mundo"

• substring (int i, int j): Devuelve la cadeana del índice i a j-1.

"Holita mundo".substring(2,5); // devuelve "lista"

• concat( String parámetro): Concatena la cadena especificada al final de esta cadena.

String texto= "Hola";
String texto2= " mundo;
String salida = texto.concat(texto2); // devuelve "Hola mundo"

• indexOf (String parámetro): Devuelve el índice a partir de cual aparece la cadena especificada.

String s = "El mundo de java";
int salida = s.indexOf("java"); // devuelve 11

• int indexOf (String texto, int i): Devuelve el índice a partir del cual aparece la cadena especificada comenzando en el índice especificado.

String texto= "El Mundo de Java";
int salida = texto.indexOf('a',3); // devuelve 13

• lastIndexOf (int parámetro): Devuelve el índice dentro de la cadena de la última aparición de la cadena especificada.

String texto= "El mundo de java";
int salida = texto.lastIndexOf('e'); // devuelve 15

• equals (Objeto1 Objeto2): Compara dos cadenas.

Boolean salida = "Java".equals("Java"); // devuelve true
Boolean salida = "Java".equals("java"); // devuelve false

• equalsIgnoreCase (String Objeto2): Compara dos cadenas ignorando mayúsculas y minúsculas.

Boolean salida= "Java".equalsIgnoreCase("Java"); // devuelve true
Boolean salida = "Java".equalsIgnoreCase("java"); // devuelve true

• compareTo (String texto2): Compara dos cadenas lexicográficamente, es decir, cuenta los caracteres que tienen los String y averigua cual es menor, mayor o igual.

int salida = texto1.compareTo(texto2); 
Esto devuelve la diferencia texto1-texto2. Si :
salida < 0 // texto1 es menor que texto2
salida = 0 // texto1 y texto2 son iguales
salida > 0 // texto1 es mayor que texto2

• compareToIgnoreCase (String texto2): Hace lo mismo que la anterior pero ignorando mayúsculas y minúsculas.
• toLowerCase(): Convierte todos los caracteres de una cadena a minúsculas.

String palabra1 = "HoLa";
String palabra2 = palabra1.toLowerCase(); // devuelve "hola"

• String toUpperCase(): Convierte todos los caracteres de una cadena a mayúsculas.

String palabra1 = "HoLa";
String palabra2 = palabra1.toUpperCase(); // devuelve "HOLA"

• trim(): Devuelve la copia de la cadena, eliminando espacios en blanco en ambos extremos. No afecta los espacios en blanco en el medio.

String palabra1 = " El mundo de java ";
String palabra2 = palabra1.trim(); // devuelve "El mundo de java"

• replace (char viejo, char nuevo): Reemplaza un carácter o cadena por otra.

String palabra1 = "El mundo de yava";
String palabra2 = palabra1.replace('y' ,'j'); // Devuelve "El mundo de java"

Clase Scanner.

Esta clase es muy interesante cuando queremos introducir datos por teclado. Hay que importar la librería java.util.Scanner para poder utilizarla.

¿Cómo creamos el objeto?

Scanner entrada= new Scanner(System.in);

El system.in representa la entrada de datos standard.

¿Y ahora como hago para introducir datos? Vamos a usar el ejercicio que hicimos en artículos anteriores, aquel que hacía operaciones matemáticas pero esta vez vamos a introducir los datos nosotros mismos a través del teclado.

import java.util.Scanner; //importamos la librería scanner.
public class Mate {
  
  public static void main(String[] args) {
    int num;
    int num2;
    Scanner entrada = new Scanner(System.in); // creamos el objeto   scanner.
  
  System.out.println("Dame dos número entero: ");
  num=entrada.nextInt(); // introducimos un valor entero.
  num2=entrada.nextInt();  //introducimos otro valor entero.
  System.out.println("El mínimo es "+Math.min(num, num2));
  System.out.println("El máximo es "+Math.max(num, num2)); 
  System.out.println("El resultado de la suma es "+(num+num2));
  System.out.println("El resultado de la resta es "+(num-num2));
  System.out.println("El resultado de la multiplicación es "+(num*num2));
  System.out.println("El resultado de la potencia es "+Math.pow(num, num2));
  }
}

Si nos fijamos en el código hemos usado el objeto entrada con algunos métodos para especificar que tipo de datos vamos a introducir:

• nextInt(). Valores tipo enteros.
• nextLine(). Valores tipo cadena de caracteres.
• nextByte(). Valores tipo byte.
• nextDouble(). Valores tipo double.
• nextLong(). Valores tipo long.
• nextFloat(). Valores tipo float.
• nextShort(). Valores tipo short.

Un poquito de programación pura y dura.

Condicionales. Son bloques de código que indican comparación/condición y en función del resultado se hacen unas instrucciones. Vamos al IF de toda la vida.

IF Simples. Si corre esto hazme estas instrucciones.

if (condicion)
{
  instrucciones...
}

IF ELSE. Si ocurre este hazme estas instrucciones y en caso contrario me haces estas otras instrucciones.

if (condicion)
{
  instrucciones...
}
else
{
  instrucciones...
}

IF Anidados. Viene a ser un IF dentro de Otro IF, así complicamos un poco más la cosa.

if (condicion)
{
  instrucciones...
  if (condicion)
  {
    instrucciones...
  }
  else
  {
    instrucciones...
  }
}
else
{
  instrucciones...
}

IF ELSE IF. Es como los IF anidados pero de otra forma, pero viene a ser lo mismo IF anidados.

if (condicion)
{
  instrucciones...
  else if (condicion)
  {
    instrucciones...
  }
  else
  {
    instrucciones...
  }
}
else if(condicion)
{
  instrucciones...
}

La diferencia que hay respecto a los IF anidados, es que el ELSE IF puedes hacerlo todo en una instrucción. Con éste último queda más ordenadito cuando nos encontremos muchos condicionales seguidos.

SWITCH CASE. Es otra forma de usar condicionales anidados, pero SWITCH es más especial. Veamos como funciona:

switch (expresión)
{
  case valor1:
    instrucciones...
    break;
  case valor2:
    instrucciones...
    break;
  case valor3:
    instrucciones...
    break;
  case valorN:
    instrucciones...
    break;
  default:
    instrucciones...
}

Cosas a tener en cuenta con el SWITCH:

• En los case no están permitidos los valores duplicados.
• El valor para cada case debe de ser del mismo tipo que la variable del switch.
• El valor para cada case debe de ser una constante y no están permitidas poner variables.
• Se debe poner la instrucción break en cada case para que salga de swicth en el caso de que se cumpla una condición. Si no lo ponemos pasará a la siguiente condición y ejecutará lo que hay dentro y eso no es lo que queremos que haga.
• La instrucción default es opcional, pero en el caso de que lo pongamos debe ir siempre al final. Este sentencia lo que hace es ejecutarse cuando no se cumplen ninguno de los case anteriores.

En cuanto no se cumpla alguno de estos requisitos ya sabemos que no podemos usar el SWITCH y deberíamos utilizar el IF.

Bucles. Instrucciones repetitivas.

WHILE. Yo lo he llamado siempre el bucle “mientras”, es decir, va a ejecutar todo lo que haya dentro mientras se cumple la condición

public class bucles
{
  public static void main(String args[])
  {
    int x=1;
    while (x<=4) //saldrá del bucle cuando sea mayor de 4.
    {
      System.out.println("El valor de x es "+x);
      x++; // le sumo 1 a x.
    }
  }
}

Este tipo de bucle lo que hace es preguntar primero por la condición y si se cumple, ejecuta lo que hay dentro, que no se cumple pues no ejecuta nada y se sale.

DO WHILE. Es otro bucle “mientras”, la diferencia que hay frente al anterior es que este ejecuta y luego pregunta. Veamos como funciona:

public class bucles
{
  public static void main(String args[])
  {
    int x=21;
    do
    {
      System.out.println("El valor de x es "+x);
      x++; // le sumo 1 a x.
    }
    while (x<21)
  }
}

Este bucle lo que hace es ejecutar lo que hay dentro del do, da igual que se cumpla la condición o no, siempre lo hará una vez mínimo y después pregunta por la condición de while, en el caso de que no se cumpla se sale del bucle.

Tenemos que tener muy claro cuando usar uno u otro , si mínimo se hace una vez(do while), en cambio si siempre va depender de la condición la ejecución de las instrucciones (while).

FOR. Este tipo de bucle se utiliza cuando sabemos de antemano cuanta vece se va a repetir las instrucciones. Veamos como funciona:

public class bucles
{
  public static void main(String args[])
  {
    for(int x=2; x<=4; x++)
    {
      System.out.println("El valor de x es "+x);
    }
  }
}

A diferencia de los otros bucles, el for hace tres instrucciones en la misma línea:

for(inicializa la variable; condición mientras; incrementa en 1 x).

• En el for tanto se puede incrementar como decrementar.
• Se pueden usar variables en la condición, no pasa como con el switch.
• El for trabaja como el while, primero pregunta y si no se cumple la condición se sale del bucle.

Break y Continue.

Existen ocasiones puede interesar romper una instrucción repetitiva o un bucle y que haga la instrucción siguiente que se encuentre después de éste. Para romper o parar un bucle se utiliza la instrucción break. Veamos como funciona:

public class Romper{
  public static void main(String[] args) {
    for(int i=1;i<=10;i++){
      if(i==5){
        //Rompemos el bucle cuando i llegue a 5 
        break;
      }  
      System.out.println(i);
    }  
  }  
}

En este ejemplo lo único que hace el programa es mostrar el valor del conteo de i, de forma que cuando llegue a 5 hacemos la instrucción break y automáticamente se sale del bucle, evitando hacer hasta el 10. En este caso se termina el programa porque no hay ninguna instrucción siguiente.

Hay que tener mucho cuidado cuando se usa el break, ya que es una instrucción peligrosa, se suele usar en situaciones concretas.

¿Y si son varios bucles anidados, como funciona el break?

Cuando se usan un bucle dentro de otro el break funciona igual, la diferencia está en que rompe soló uno, dependiendo de donde lo utilicemos. Veamos un ejemplo:

public class Romper{
  public static void main(String[] args) {
    for(int i=1;i<=3;i++){
      for(int j=1;j<=3;j++){
        if(i==2&&j==2){
          break; //Rompo el segundo bucle y empieza de nuevo.
        }    
        System.out.println(i+" "+j);
      }    
    }    
  }  
}

En este ejemplo el break lo que hace es saltarse el segundo bucle, es decir, al llegar al conteo de i a 2 y j a 2 se lo salta y continua por el siguiente, que en este caso será el 3–1, ya que al romper el bucle se sale y no haría 3–3, empezaría de nuevo. Mostremos el resultado para entenderlo un poco mejor.

1 1
1 2
1 3
2 1
2 2 no lo muestra, se lo salta y reinicia el segundo bucle.
3 1 Sigue el conteo del primero y empieza de nuevo con el segundo.
3 2
3 3

Continue.

Este instrucción hace algo parecido al break, sólo que en vez de romper el bucle lo que hace es saltar una iteración. Veamos un ejemplo:

public class Romper{
  public static void main(String[] args) {
    for(int i=1;i<=10;i++){
      if(i==5){
        //Rompemos la iteración cuando i llegue a 5 
        continue;
      }  
      System.out.println(i);
    }  
  }  
}

En este ejemplo lo que hace es mostrarte el valor de i, pero cuando llegamos al 5 hacemos un continue, es decir, lo que hará el programa es no mostrar el 5 y continúa con los siguientes, no rompe el bucle, simplemente se salta una iteración del bucle.

¿Y si lo hacemos con bucles anidados? Pues pasaría exactamente lo mismo, la diferencia es que se saltaría la iteración del bucle donde usemos el continue. Veamos un ejemplo:

public class Romper{
  public static void main(String[] args) {
    for(int i=1;i<=3;i++){
      for(int j=1;j<=3;j++){
        if(i==2&&j==2){
          continue; //Rompo la iteración del segundo bucle.
        }    
        System.out.println(i+" "+j);
      }    
    }    
  }  
}

En este ejemplo le resultado sería siguiente:

1 1
1 2
1 3
2 1
2 3
2 2 no lo mostraría y continúa con la siguiente iteración.
3 1
3 2
3 3