Operadores

OPERADORES ARITMÉTICOS COMBINADOS

Combinan un operador aritmético con el operador asignación. Como en el caso de los operadores aritméticos pueden tener operandos numéricos enteros o reales y el tipo específico de resultado numérico dependerá del tipo de éstos. En la siguiente tabla se resumen los diferentes operadores de esta categoría.

Figura 4.4 Operadores aritméticos combinados

OPERADORES ARITMÉTICOS INCREMENTALES

Los operadores aritméticos incrementales son operadores unarios (un único operando). El operando puede ser numérico o de tipo char y el resultado es del mismo tipo que el operando. Estos operadores pueden emplearse de dos formas dependiendo de su posición con respecto al operando.

 OPERADORES DE RELACIÓN

Realizan comparaciones entre datos compatibles de tipos primitivos (numéricos, carácter y booleanos) teniendo siempre un resultado booleano. Los operandos booleanos sólo pueden emplear los operadores de igualdad y desigualdad.

OPERADORES LÓGICOS O BOOLEANOS

Realizan operaciones sobre datos booleanos y tienen como resultado un valor booleano. En la siguiente tabla se resumen los diferentes operadores de esta categoría.

Operadores de Asignación y Aritméticos Java

Operador de Asignación

El operador Java más sencillo es el operador de asignación. Mediante este operador se asigna un valor a una variable. El operador de asignación es el símbolo igual.

La estructura del operador de asignación es:

variable = valor;

Así podemos asignar valores a variables de tipo entero, cadena,…

int numero = 3;
String cadena = "Hola Mundo";
double decimal = 4.5;
boolean verdad = true;

                                                         CLASE MATH 

La clase Math representa la librería matemática de Java. Las funciones que contiene son las de todos los lenguajes, parece que se han metido en una clase solamente a propósito de agrupación, por eso se encapsulan en Math, y lo mismo sucede con las demás clases que corresponden a objetos que tienen un tipo equivalente (Character, Float, etc.). El constructor de la clase es privado, por los que no se pueden crear instancias de la clase. Sin embargo, Math es public para que se pueda llamar desde cualquier sitio y static para que no haya que inicializarla.

Funciones matemáticas

Si se importa la clase, se tiene acceso al conjunto de funciones matemáticas estándar:
Math.abs( x )          para int, long, float y double
Math.sin( double )
Math.cos( double )
Math.tan( double )
Math.asin( double )
Math.acos( double )
Math.atan( double )
Math.atan2( double,double )
Math.exp( double )
Math.log( double )
Math.sqrt( double )
Math.ceil( double )
Math.floor( double )
Math.rint( double )
Math.pow( a,b )
Math.round( x )       para double y float
Math.random()         devuelve un double
Math.max( a,b )       para int, long, float y double
Math.min( a,b )       para int, long, float y double
Math.E                para la base exponencial
Math.PI               para PI
He aquí un ejemplo, Mates.java, de uso de algunas funciones de la clase Math:


    class Mates {
        public static void main( String args[] ) {
            int x;
            double rand,y,z;
            float max;
    
            rand = Math.random();
            x = Math.abs( -123 );
            y = Math.round( 123.567 );
            z = Math.pow( 2,4 );
            max = Math.max( (float)1e10,(float)3e9 );
    
            System.out.println( rand );
            System.out.println( x );
            System.out.println( y );
            System.out.println( z );
            System.out.println( max );
            }
        }

ESTRUCTURAS CONDICIONALES EN JAVA

IF EN JAVA

La estructura condicional más simple en Java es el if, se evalúa una condición y en caso de que se cumpla se ejecuta el contenido entre las llaves {} o en caso de que se omitan se ejecuta el código hasta el primer “;” por lo tanto si no se usan los {} la condición aplica solo a la siguiente instrucción al if.

if (condicion) {
    ejecutar();
}

// Los {} son opcionales
if (condicion)
    ejecutar();

// Y mas compacto
if (condicion) ejecutar();

Por lo tanto el uso de las llaves es opcional cuando dentro de la condición hay una sola línea de código, pero puede generar errores si se añade más código que se espere que se ejecute bajo la condición si no recordamos que tenemos que añadir las llaves en estos casos. Personalmente, prefiero usar las llaves y en caso de no utilizarlas pondría el if completo en una única línea para que sea más claro que la condición solo aplica a esa línea.

IF ELSE EN JAVA

Con el if solo podemos hacer que se ejecute un fragmento de código o no pero en el caso de que no se cumpla la condición no se hace nada (sigue el flujo normal de ejecución) por lo que si queremos que se ejecute otra cosa cuando no se cumpla la condición solo con el if tenemos que hacer otro con la condición inversa provocando que se tenga que comprobar la condición 2 veces mientras que si usamos el else solo necesitamos hacer la comprobación una sola vez.

// Usando solo ifs
if (temperatura > 25) {
    System.out.println("A la playa!!!");
}

if (temperatura <= 25) {
    System.out.println("Esperando al buen tiempo...");
}

// Usando if con else
// Si la temperatura es mayor que 25 ... y si no ...
if (temperatura > 25) {
    System.out.println("A la playa!!!");
} else {
    System.out.println("Esperando al buen tiempo...");
}

IF ELSE IF EN JAVA

El siguiente nivel es hacer el else condicional añadiendo un if para que si no se cumple la primera condición (la del if principal) se evalue esta nueva condición de modo que se puede concatenar la cantidad de if else que se necesiten para cubrir todos los distintos escenarios que precisen ser tratados de una forma particular, siendo el ultimo else el que se ejecute cuando no se cumpla ninguna condición (el else es siempre opcional).

if (temperatura > 25) {
    // Si la temperatura es mayor que 25 ...
    System.out.println("A la playa!!!");
} else if (temperatura > 15) {
    // si es mayor que 15 y no es mayor que 25 ..
    System.out.println("A la montaña!!!");
} else if (temperatura < 5 && nevando) {
    // si es menor que 5 y esta nevando y no es mayor que 15 ni mayor que 25
    System.out.println("A esquiar!!!");
} else {
    // si la tempera  no es mayor que 25 ni que 15 ni menor que 5 si esta nevando
    System.out.println("A descansar... zZz");
}
        

IF ANIDADOS

Es posible anidar ifs para reorganizar las condiciones o hacerlas más sencillas lo que en muchas ocasiones hace el código más fácil de leer, a continuación una de las posibles formas posibles para reescribir el ejemplo anterior.

if (temperatura > 15) {
    if (temperatura > 25) {
        // Si la temperatura es mayor que 25 ...
        System.out.println("A la playa!!!");
    } else {
        System.out.println("A la montaña!!!");
    }
} else if (temperatura < 5) {
    if (nevando) {
        System.out.println("A esquiar!!!");
    }
} else {
    System.out.println("A descansar... zZz");
}

4.4.8.3 Instrucciones iterativas

También conocidas como bucles, las instrucciones iterativas tienen la misión de ejecutar las mismas instrucciones de código un número de veces, determinado por una condición. En java tenemos tres bucles: while, do while y for. while: La sintaxis es: while (condición) { //Instrucciones a ejecutar } Este bucle evalúa la condición, si es cierta ejecutará las instrucciones de su interior, una vez ejecutadas regresará al comienzo y se repetirá el proceso de evaluar/ejecutar. Este proceso sólo finalizará cuando en la evaluación la condición de cómo resultado false. Prácticas: Vamos a construir una aplicación que tome un número como argumento y muestre la tabla de multiplicar de dicho número. Crear While1.java Agregar el siguiente código: public class While1{ public static void main(String arg[]){ if ( arg.length>0) { int valor = Integer.parseInt(arg[0]); int contador = 1; while (contador<=9) { System.out.println("" + valor + " * " + contador + " = " + (valor*contador)); contador++; } } else { System.out.println("No hay ningún parámetro"); } } } do while: La sintaxis es: do { //Instrucciones a ejecutar } while (condición); Este bucle comienza ejecutando las instrucciones que hay en su interior, una vez ejecutadas comprueba el valor de condición, si es true vuelve de nuevo a repetir el proceso ejecutar/evaluar. Si la evaluación de condición es false, entonces finaliza la ejecución del bucle. Un bucle while ejecutará sus instrucciones de 0 a n veces, dependiendo del valor de las condiciones. Mientras que un bucle do while ejecutará sus instrucciones de 1 a n veces dependiendo del valor de la condición. Prácticas: Crear una aplicación que solicite una contraseña al usuario, si es correcta mostrará que es correcta, si el usuario se equivoca tres veces finalizará el programa. Crear el fichero DoWhile1.java Agregar el siguiente código: public class DoWhile1{ public static void main(String arg[]){ String clave = "Sin clave"; String candidata; int nVeces = 0; do { System.out.println("Introduzca la clave: "); candidata = leerLinea(); nVeces++; }while(!clave.equals(candidata) && nVeces<3); if(nVeces==3 && !clave.equals(candidata)) { System.out.println("Lo siento no acertó."); } else { System.out.println("Clave correcta."); } } /* Esta función permite leer una línea de texto, veremos su funcionamiento cuando lleguemos al capítulo de flujos de entrada y salida */ public static String leerLinea(){ try{ java.io.BufferedReader d = new java.io.BufferedReader(new java.io.InputStreamReader(System.in)); return d.readLine(); }catch(Exception e) {} return ""; } } for La sintaxis del bucle for es: for (inicialización;condición;evaluación){ //instrucciones a ejecutar } Antes de nada veamos una equivalencia de un bucle while configurado como un bucle for: inicialización; while (condición) { //Instrucciones a ejecutar evaluación; } En esta equivalencia veremos que inicialización es empleada para dar un valor inicial a la variable que utilizaremos para ser evaluada posteriormente en la condición. La condición, que será evaluada para comprobar si se detiene o no el bucle for, y la evaluación, empleada para indicar los incrementos que se realizarán sobre la variable. Prácticas: Crear una aplicación que muestre los primeros 256 caracteres por pantalla, en cada fila aparecerán 5 caracteres. Crear el fichero For1.java Agregar el siguiente código: public class For1{ public static void main(String arg[]){ for (int nLetra = 0; nLetra<=255 ; nLetra ++) { System.out.print(" " + nLetra + ": " + (char)nLetra); if (nLetra%4==0) System.out.println(""); } } }

COLECCIONES
Las colecciones son una especie de arrays de tamaño dinámico. Para usarlas haremos uso del Java Collections Framework (JCF), el cual contiene un conjunto de clases e interfaces del paquete java.util para gestionar colecciones de objetos.

En Java las principales interfaces que disponemos para trabajar con colecciones son: Collection, Set, List, Queue y Map:

• Collection<E>: Un grupo de elementos individuales, frecuentemente con alguna regla aplicada a ellos.
• List<E>: Elementos en una secuencia particular que mantienen un orden y permite duplicados. La lista puede ser recorrida en ambas direcciones con un ListIterator. Hay 3 tipos de constructores:
  1. ArrayList<E>: Su ventaja es que el acceso a un elemento en particular es ínfimo. Su desventaja es que para eliminar un elemento, se ha de mover toda la lista para eliminar ese “hueco”.
  2. Vector<E>: Es igual que ArrayList, pero sincronizado. Es decir, que si usamos varios hilos, no tendremos de qué preocuparnos hasta cierto punto.
  3. LinkedList<E>: En esta, los elementos están conectados con el anterior y el posterior. La ventaja es que es fácil mover/eliminar elementos de la lista, simplemente moviendo/eliminando sus referencias hacia otros elementos. La desventaja es que para usar el elemento N de la lista, debemos realizar N movimientos a través de la lista.
  Veamos un ejemplo de List:
  
  

  
  

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37

  import java.util.*; public class Main { public static void main(String[] args) { // LinkedList List lista1 = new LinkedList(); // Añadimos nodos y creamos un Iterator lista1.add("Madrid"); lista1.add("Sevilla"); lista1.add("Valencia"); Iterator iterador = lista1.iterator(); // Recorremos y mostramos la lista while (iterador.hasNext()) { String elemento = (String) iterador.next(); System.out.print(elemento + " "); } System.out.println("--LinkedList--"); // ArrayList List lista2 = new ArrayList(); // Añadimos nodos y creamos un Iterator lista2.add("Madrid"); lista2.add("Sevilla"); lista2.add("Valencia"); Iterator iterador2 = lista2.iterator(); // Recorremos y mostramos la lista while (iterador2.hasNext()) { String elemento = (String) iterador2.next(); System.out.print(elemento + " "); } System.out.println("--ArrayList--"); } }

¿Qué es un Array en Java?

tipo_dato nombre_array[]; nombre_array = new tipo_dato[tamaño];char arrayCaracteres[]; arrayCaracteres = new char[10];arrayCaracteres[numero_elemento];// Lectura de su valor. char x = arrayCaracteres[2]; // Asignación de un valor: arrayCaracteres[2] = 'b'Tamaño del array: .lengthchar array[]; array = new char[10]; for (int x=0;x

Un array es una estructura de datos que nos permite almacenar una gran cantidad de datos de un mismo tipo. El tamaño de los arrays se declara en un primer momento y no puede cambiar en tiempo de ejecución como puede producirse en otros lenguajes.

La declaración de un array en Java y su inicialización se realiza de la siguiente manera:

Por ejemplo, podríamos declarar un array de caracteres e inicializarlo de la siguiente manera:

Los arrays se numeran desde el elemento cero, que sería el primer elemento, hasta el tamaño-1 que sería el último elemento. Es decir, si tenemos un array de diez elementos, el primer elemento sería el cero y el último elemento sería el nueve.

Para acceder a un elemento especifico utilizaremos los corchetes de la siguiente forma. Entendemos por acceso, tanto el intentar leer el elemento, como asignarle un valor.

Por ejemplo, para acceder al tercer elemento lo haríamos de la siguiente forma:

El objeto array, aunque podríamos decir que no existe como tal, posee una variable, la cual podremos utilizar para facilitar su manejo.

Esta variable nos devuelve el número de elementos que posee el array. Hay que tener en cuenta que es una variable de solo lectura, es por ello que no podremos realizar una asignación a dicha variable.

Por ejemplo esto nos serviría a la hora de mostrar el contenido de los elementos de un array: