feed twitter facebook LinkedIn facebook

Java » Tipo de Objeto Boolean

febrero 6, 2015 por Víctor Cuervo Sin Comentarios Imprimir Imprimir

En este artículo vamos a ver como podemos realizar las operaciones básicas con un tipo de objeto Boolean en Java. En primer lugar hay que saber que un tipo de objeto Boolean en Java es un recubrimiento sobre el tipo de dato primitivo boolean. Con lo que a la postre deberíamos de poder realizar las mismas operaciones con el tipo de objeto Boolean y con el tipo de dato primitivo boolean.

Crear un tipo de objeto Boolean

Para crear un tipo de objeto Boolean en Java utilizamos el constructor Boolean, al cual podremos pasar un valor ya booleano:

  1. boolean b = true;
  2. Boolean miBooleano = new Boolean(b);

O bien una cadena con un literal booleano:

  1. String sBoolenao = "true";
  2. Boolean miBooleano = new Boolean(sBooleano);

Manipular un tipo de objeto Boolean

Si queremos obtener el contenido de un objeto Boolean en Java tenemos un método que nos ayudará a acceder a su contenido boolean almacenado. Este es el método .booleanValue().

  1. Boolean miBooleano = new Boolean("true");
  2. boolean b = miBooleano.booleanValue();
  3. System.out.println(b);

Realizar comparaciones

Una de las cosas que tienes que tener cuidado cuando manipules tipos de objeto Boolean es que no se pueden comparar como los tipos de datos primitivos.

Es decir, que si partimos de los dos siguientes tipos de objetos Boolean:

  1. Boolean b1 = new Boolean(true);
  2. Boolean b2 = new Boolean("true");

No podremos hacer la siguiente comparación:

  1. if (b1==b2)
  2. System.out.println("Valores Iguales");
  3. else
  4. System.out.println("Valores Diferentes");

Ya que nos dará que los dos tipos de datos Boolean son diferentes. Esto sucede ya que estamos comparando objetos y no tipos de datos primitivos. Así que lo que tendremos que hacer será utilizar el método .equals()

  1. if (b1.equals(b2))
  2. System.out.println("Valores Iguales");
  3. else
  4. System.out.println("Valores Diferentes");

Java » Literal booleano en Java

febrero 5, 2015 por Víctor Cuervo Sin Comentarios Imprimir Imprimir

Cuando estés trabajando con valores booleanos es fácil que tengas que manipular un Literal booleano en Java. Es decir, que el contenido de los valores booleanos que manejes sean cadenas "true" o "false" en vez de un valor booleano en sí.

Vamos a ver qué hacer en esos casos en los que contemos con un Literal booleano en Java.

Cargar un Literal booleano en Java

Cuando estamos manejando el literal lo mejor es cargarlo mediante el tipo de dato objeto Boolean ya que este nos permite cargar desde cadenas de texto.

Así, que si partimos de una cadena.

  1. String sLiteral = "true";

Lo que haremos será pasar la cadena Java Boolean literal como parámetro al objeto Boolean.

  1. Boolean miBoolean = new Boolean(sLiteral);

Que ahora queremos tomar decisiones en base al booleano cargado desde el literal, pues obtenemos el valor del objeto Boolean mediante el método .booleanValue();

  1. boolean b = miBoolean.booleanValue()

En este momento ya tenemos el booelano como tipo de dato primitivo y de fácil uso dentro de nuestro código fuente.

Devolver un Literal booleano en Java

Pero qué pasa si ahora que tenemos un valor booleano queremos devolver un literal hacía nuestra presentación, o servicio o dónde quiera que lo mandemos.

Es decir, que partimos de esta situación:

  1. boolean b = true;

En este caso es sencillo, ya que solo volcar el booleano sobre una cadena, convertirá a este en una cadena. Así que la solución es sencilla.

  1. System.out.println("La variable booleana tiene un valor de : "+b);

Y si queremos tenerlo en una cadena (o String) lo que hacemos es realizarlo desde el objeto Boolean con el método .toString();

  1. String sMiBooleano = new Boolean(true).toString();

Espero que esta explicación te haya ayudado a entender mejor la forma de manejar un Literal booleano en Java.

Java » Tipos de datos objeto en Java

febrero 4, 2015 por Víctor Cuervo Sin Comentarios Imprimir Imprimir

Desde la versión Java 5 existen los tipos de datos objeto en Java dentro de la librería java.lang. Aunque, quizás, siguen gozando poca popularidad quizás por cosas como el consumo de memoria o la complejidad a la hora de realizar operaciones de comparación.

Entre los tipos de datos objeto en Java encontramos:

Tipo Primitivo Tipo Objeto
boolean Booelan
char Char
byte Byte
short Short
int Integer
long Long
float Float
double Double

En todos los tipos de datos objeto en Java podemos envolver su respectivo tipo de dato primitivo para poder realizar las operaciones directamente sobre un objeto. De igual manera de un tipo de dato objeto podremos obtener su valor como tipo de dato primitivo.

Veamos como sería para cada uno de los tipos de datos primitivo y su dato objeto correspondiente:

Boolean

Podemos pasar el tipo de dato boolean al constructor del objeto Boolean y el método .booleanValue() nos devolverá el tipo boolean.

  1. Boolean refBoolean = new Boolean(true);
  2. boolean bool = refBoolean.booleanValue();

Byte

En el caso del byte al constructor Byte deberemos de hacer un casting del valor entero para poder instanciarlo. La obtención del dato byte desde un Byte se realizará con .byteValue().

  1. Byte refByte = new Byte((byte) 123);
  2. byte b = refByte.byteValue();

Character

En el caso de pasar de un char a un Character se cargará mediante el constructor. Y el método .charValue() nos resolverá el acto contrario.

  1. Character refChar = new Character('x');
  2. char c = refChar.charValue();

Short

Cuando carguemos el constructor de Short deberemos de hacer un casting mediante (short) al valor pasado como parámetro. El método .shortValue() nos retorna un short desde el objeto Short.

  1. Short refShort = new Short((short) 123);
  2. short s = refShort.shortValue();

Integer

El int e Integer tienen un constructor directo y un método .intValue() para obtener el efecto contrario.

  1. Integer refInt = new Integer(123);
  2. int i = refInt.intValue();

Long

A los datos long hay que postponerles la letra L cuando los carguemos sobre un objeto Long. El método .longValue() nos da lo inverso.

  1. Long refLong = new Long(123L);
  2. long l = refLong.longValue();

Float

Si para long era la letra L, para float es la letra F en el constructor del objeto Float. El método .floatValue() nos devuelve un tipo float.

  1. Float refFloat = new Float(12.3F);
  2. float f = refFloat.floatValue();

Double

Para los tipos de datos double tenemos que posponer la letra D en el constructor Double y utilizar el método .doubleValue() para obtener un tipo double.

  1. Double refDouble = new Double(12.3D);
  2. double d = refDouble.doubleValue();

Java » Valores máximo y mínimo de los tipos primitivos Java

febrero 3, 2015 por Víctor Cuervo Sin Comentarios Imprimir Imprimir

En algún ejemplo de Línea de Código hemos explicado los tipos de datos primitivos Java y sus valores por defecto. En este caso vamos a ver como poder mostrar los valores máximo y mínimo de los tipos primitivos Java, es decir, cual es el mayor y menor valor de los int, long, byte, double,...

Para poder calcular los valores máximo y mínimo de los tipos primitivos Java vamos a apoyarnos en los tipos de dato objeto que tiene cada uno de los datos primitivos. Y es que el lenguaje Java tiene unos objetos base definidos con las mismas funcionalidades que los tipos de datos primitivos.

Tipo Primitivo Tipo Objeto
boolean Booelan
char Char
byte Byte
short Short
int Integer
long Long
float Float
double Double

Estos tipos objeto tienen unas constantes que se repiten en cada uno de ellos que son MIN_VALUE y MAX_VALUE. De esta forma si queremos ver los valores máximo y mínimo de un tipo de datos byte deberemos de hacer lo siguiente:

  1. System.out.println("Valor Máximo Byte: " + Byte.MAX_VALUE);
  2. System.out.println("Valor Mínimo Byte: " + Byte.MIN_VALUE);

Para volcar por consola los valores máximo y mínimo de los tipos primitivos Java para todos los casos utilizaremos el siguiente código fuente:

  1. System.out.println("Tipo\tMínimo\tMáximo");
  2. System.out.println("byte\t" + Byte.MIN_VALUE + "\t" + Byte.MAX_VALUE);
  3. System.out.println("short\t" + Short.MIN_VALUE + "\t" + Short.MAX_VALUE);
  4. System.out.println("int\t" + Integer.MIN_VALUE + "\t" + Integer.MAX_VALUE);
  5. System.out.println("long\t" + Long.MIN_VALUE + "\t" + Long.MAX_VALUE);
  6. System.out.println("float\t" + Float.MIN_VALUE + "\t" + Float.MAX_VALUE);
  7. System.out.println("double\t" + Double.MIN_VALUE + "\t" + Double.MAX_VALUE);

Java » Tipos primitivos de datos en Java

febrero 2, 2015 por Víctor Cuervo Sin Comentarios Imprimir Imprimir

En este ejemplo vamos a ver los tipos primitivos de datos en Java que existen y cuales son sus valores por defecto.

Los tipos primitivos de datos en Java que hay son:

  • boolean, para valores true|false.
  • char, para representar un simple carácter.
  • byte, un tipo de dato entero de 8 bits con signo.
  • short, un tipo de dato entero de 16 bits con signo.
  • int, un tipo de dato entero de 32 bits con signo.
  • long, un tipo de dato entero de 32 bits con signo.
  • float, un tipo de dato en coma flotante de 32 bits.
  • double, un tipo de dato en coma flotante de 64 bits.

Y si miramos la documentación de los tipos primitivos de datos en Java veremos que sus valores por defecto son los siguientes:

Tipo Valor por Defecto
boolean false
char '\u0000'
byte 0
short 0
int 0
long 0L
float 0.0f
double 0.0d

Pero, ¿cómo podemos, mediante código fuente, saber los valores por defecto de los tipos primitivos de datos en Java?

De primeras se nos podría ocurrir la siguiente idea:

  1. int entero;
  2. System.out.println(entero);

Pero ese código no podremos compilarlo, ya que el compilador nos dirá que entero no está inicializado.

Este pequeño inconveniente lo podemos solventar si metemos los tipos primitivos en una clase.

  1. public class ValoresPorDefecto {
  2. boolean t;
  3. char c;
  4. byte b;
  5. short s;
  6. int i;
  7. long l;
  8. float f;
  9. double d;
  10. }

En esa clase creamos un método que realice una impresión por pantalla.

  1. void imprimirValoresIniciales() {
  2. System.out.print("Tipo Variable\tValor Inicial");
  3. System.out.print("boolean\t\t" + t);
  4. System.out.print("char\t\t[" + c + "]");
  5. System.out.print("byte\t\t" + b);
  6. System.out.print("short\t\t" + s);
  7. System.out.print("int\t\t" + i);
  8. System.out.print("long\t\t" + l);
  9. System.out.print("float\t\t" + f);
  10. System.out.print("double\t\t" + d);
  11. }

Ya solo nos quedará invocar al método para conseguir que se muestren por pantalla los valores por defecto de los tipos de datos primitivos en Java.

  1. ValoresPorDefecto vpf = new ValoresPorDefecto();
  2. vpf.imprimirValoresIniciales();

Java » Overflow de variables Java

febrero 1, 2015 por Víctor Cuervo Sin Comentarios Imprimir Imprimir

Alguna vez te has preguntado como funciona el overflow de variables Java. Es decir, qué sucede si a una variable de un un tipo primitivo, una vez alcanzado su máximo valor se le suma alguna unidad más.

Pues veamos de forma práctica como funciona el overflow de variables Java. Para ello lo primero que vamos a definir es una variable de tipo byte. El tipo bytes es una variable de 8 bits, por lo tanto almacena desde el valor -128 al valor 127.

  1. byte b = Byte.MAX_VALUE;

Si no sabemos el valor máximo de un tipo de datos siempre podemos apoyarnos en el tipo de dato objeto relacionado, en este caso en Byte, y en su constante MAX_VALUE.

Al volcar el contenido de este byte por pantalla obtendremos el siguiente resultado.

127

Ahora lo que vamos a realizar es a sumarle una unidad.

  1. b += 1;

Como teníamos el máximo valor del byte y hemos incrementado uno hemos conseguido realizar el overflow de variables Java. Pero no nos va a dar una Excepción, si no lo que hace es rotar el valor y empezar a incrementar las unidades desde el valor más pequeño de la variable.

Así, si ahora volcamos el contenido por consola obtendremos el siguiente resultado:

-128

El overflow de variables Java es aplicable para todos los tipos de datos primitivos. Así que lo puedes probar con int, long, double,...

Java » Variables Java transient

enero 31, 2015 por Víctor Cuervo Sin Comentarios Imprimir Imprimir

Uno de los modificadores que podemos aplicar a una variable Java es el transient. Las variables Java transient sirven para demarcar el carácter temporal o transitorio de dicha variable, es decir, que no siempre se tendrá acceso al valor de la variable.

Pero, realmente, ¿qué implican las variables Java transient? Cuando definimos variables Java transient lo que estamos indicando es que en caso de que serialicemos el objeto que contiene esa variable transient, si valor no se serializará.

Vamos a pensar en un usuario con nombre y contraseña que definamos de la siguiente forma:

  1. public class Usuario implements Serializable {
  2. private String nombre;
  3. private transient String password;
  4. }

Esto implicaría que cuando se serialice el valor que haya en la variable password, al ser declarada como transient, no se va a serializar.

Ampliemos un poco más el código de la clase Usuario:

  1. public class Usuario implements Serializable {
  2. private String nombre;
  3. private transient String password;
  4.  
  5. public Usuario(String nombre, String password) {
  6. this.nombre = nombre;
  7. this.password = password;
  8. }
  9.  
  10. public String toString() {
  11. String pwd = (password == null) ? "(n/a)" : password;
  12. return "Información Usuario: \n Nombre: " + nombre + "\n Contraseña: " + pwd;
  13. }
  14. }

Hemos añadido un método toString() que nos vuelque la información y un constructor para poder instanciar la clase con los valores de usuario y password.

Ahora vamos a crear una segunda clase que nos ayude a serializar y deserializar un usuario.

  1. Usuario miusuario = new Usuario("Victor", "1234");
  2. System.out.println(miusuario);
  3. o.writeObject(miusuario);
  4. o.close();

Si visualizamos el contenido del objeto Usuario veremos que sale tanto el usuario como la password. El contenido lo hemos serializado en un fichero user.out mediante un ObjectOutputStream y un FileOutputStream.

Ahora vamos a deserializarlo:

  1. System.out.println("Recupero el objeto " + new Date());
  2. miusuario = (Usuario) in.readObject();
  3. System.out.println(miusuario);

Veremos que al volcar el objeto Usuario creado desde los datos serializados no está el valor de las variables Java transient, es decir, en este caso, del password. Por lo tanto no veremos el valor.

Como hemos podido ver en este caso las variables Java transient nos servirán para no serializar aquella información que no queramos propagar.

Java » Obtener elemento de un ArrayList

noviembre 20, 2014 por Víctor Cuervo Sin Comentarios Imprimir Imprimir

Hemos visto muchos ejemplos que manipulan ArrayList, que crean iteradores o iteradores de listas sobre un ArrayList. Pero como podemos realizar una operación tan sencilla como es obtener elemento de un ArrayList.

A priori podríamos pensar que tenemos que recurrir a un iterador para recuperar los elementos mediante el método .next().

  1. Iterator<String> it = al.iterator();
  2.  
  3. while(it.hasNext())
  4. System.out.println(it.next());

Pero sería muy complicado y nos obligaría a estar iterando sobre una lista.

Por otro lado podríamos pensar que ya que es un array puede ser que tenga el operador corchete [] para acceder a sus elementos.

  1. System.out.println(al[2]);

Esto no es así y el operador corchete no existe dentro de un ArrayList.

Podríamos ser más enrevesados y convertir nuestro ArrayList en un array, para, de estar forma poder acceder mediante el operador corchete.

  1. Object[] nombres = al.toArray();
  2. System.out.println(nombres[2]);

Pero la verdad es que la respuesta es mucho más sencilla y si queremos obtener elemento de un ArrayList la clave reside en utilizar el método .get() sobre el ArrayList, indicándole el índice del elemento que quieres recuperar.

De esta forma, si queremos recuperar el segundo elemento de nuestro ArrayList, nos bastará con escribir el siguiente código:

  1. System.out.println(al.get(1));

Y es que, al igual que todas las colecciones, el ArrayList se empieza a enumerar desde el índice 0 para el primer elemento.

Así que no le des vueltas y utiliza el método .get() para obtener elemento de un ArrayList.

Java » Reemplazar un elemento del ArrayList

noviembre 18, 2014 por Víctor Cuervo Sin Comentarios Imprimir Imprimir

Un ArrayList contiene una lista de elementos enlazados. Cuando estemos manipulando una lista es posible que necesitemos reeemplazar un elemento del ArrayList. De esta forma sustituiremos el contenido de uno de estos elementos por otro contenido.

Para ilustrar el ejemplo vamos a empezar creando un ArrayList.

  1. ArrayList<String> al = new ArrayList<String>();
  2.  
  3. al.add("Víctor");
  4. al.add("Luis");
  5. al.add("Elena");

Si recorremos y mostramos el contenido del ArrayList por pantalla utilizando un iterador:

  1. Iterator<String> it = al.iterator();
  2. while(it.hasNext())
  3. System.out.println(it.next());

Veremos que se nos muestra el contenido:

Víctor
Luis
Elena

Ahora vamos a reemplazar un elemento del ArrayList. En concreto vamos a cambiar el valor del elemento "Elena". Para ello necesitamos saber dos cosas, la primera es que el método que nos permite cambiar un valor es el método .set() y la segunda es la posición que ocupa para reemplazar un elemento del ArrayList.

Así ejecutamos el siguiente código:

  1. al.set(2,"Teresa");

Vemos que se indica el valor 2 como parámetro ya que las posiciones del ArrayList empiezan a enumerarse desde el 0.

Si ahora volvemos a mostrar el contenido del ArrayList saldrá por pantalla:

Víctor
Luis
Teresa

Ya hemos visto lo sencillo que es reemplazar un elemento del ArrayList mediante el método .set().

Java » Eliminar todos los elementos de un ArrayList

noviembre 16, 2014 por Víctor Cuervo 1 Comentario Imprimir Imprimir

En este ejemplo vamos a ver como podemos eliminar todos los elementos de un ArrayList. De esta manera dejaremos elArrayList totalmente vacío.

Empezamos creando un ArrayList sobre el que insertaremos elementos:

  1. ArrayList<String> al = new ArrayList<String>();
  2.  
  3. // Añadir elementos a un ArrayList
  4. al.add("Victor");
  5. al.add("Luis");
  6. al.add("Elena");

Si comprobamos cuántos elementos contiene el ArrayList.

  1. System.out.println("La lista contiene "+al.size()+" elementos");

Veremos que nos responde que el tamaño es de 3 elementos.

Para eliminar todos los elementos de un ArrayList bastará con que ejecutemos el método .clear(). Este método lo ejecutaremos directamente sobre el ArrayList.

  1. al.clear();

Automáticamente el ArrayList se quedará vacío de elementos. Si volvemos a validar cuántos elementos contiene el ArrayList veremos que la respuesta es que el tamaño es de 0 elementos.