feed twitter facebook LinkedIn facebook

Java » Primer punto de la cadena con Java

junio 21, 2015 por Víctor Cuervo Sin Comentarios Imprimir Imprimir

Nos solicitaban en los comentarios de la web como podíamos localizar el primer punto de la cadena con Java. Y sobre si era aconsejable utilizar un StrintTokenizer al respecto.

La verdad que localizar el primer punto de la cadena con Java es algo relativamente sencillo. Para ello lo que debemos de hacer es utilizar el método indexOf. Mediante el método indexOf obtendremos la posición en la cual se encuentra el carácter buscado. En nuestro caso un punto.

Pero lo primero será definir nuestra cadena.

  1. String sCadena = "www.lineadecodigo.com";

Ahora vamos a buscar la posición del primer punto.

  1. int posicionPunto = sCadena.indexOf('.');

Ahora que ya tenemos la posición solo tendremo que cortar desde el principio de la cadena hasta la posición del punto

  1. String sHastaPrimerPunto = sCadena.substring(0,posicionPunto);

Y desde la posición del punto + 1 hasta el final de la cadena. El final de la cadena lo podemos conseguir mediante el método length.

  1. String sDesdePrimerPunto = sCadena.substring(posicionPunto+1,sCadena.length());

Ya solo tendremos que volcar estas cadenas por consola.

  1. System.out.println(sHastaPrimerPunto);
  2. System.out.println(sDesdePrimerPunto);

Y lo que veremos será algo parecido a:

www
lineadecodigo.com

Como se puede observar es muy sencillo el obtener el primer punto de la cadena con Java.

Java » Llenar un array con números aleatorios en Java

junio 20, 2015 por Víctor Cuervo Sin Comentarios Imprimir Imprimir

En este ejemplo vamos a ver como podemos llenar un array con números aleatorios en Java. Es decir vamos a inicializarlo e ir insertando diferentes números aleatorios.

Para ello lo primero que tenemos que saber es como definir un array de números enteros.

  1. int[] numeros = new int[10]

En este caso hemos definido un array llamado números con capacidad para diez elementos.

Lo siguiente que tenemos que saber es como acceder a un elemento para insertarle información. Para ello utilizamos el nombre del array y el operador [] con la posición del array en el que insertaremos la información.

  1. array[posicion] = valor;

Hay que recordar que la primera posición de un array corresponde al número 0.

Así si queremos insertar un valor de 4 en la posición 2 utilizamos el siguiente código:

  1. umeros[2] = 4;

Lo siguiente que tenemos que saber es como generar un número aleatorio en Java. Para ello utilizamos el método Math.random() el cual genera valores entre 0.0 y 1.0

  1. int aleatorio = (int) Math.random();

Ya que queremos un número entero lo que hacemos es forzar su conversión a int. Deberemos de hacer algún ajuste más que es, crear un límite de número aleatorio superior y añadirle 1 para no tener el 0 como número aleatorio.

  1. int aleatorio = (int) (Math.random()*20)+1;

Este código nos genera números entre 1 y 20.

Ahora lo que vamos a realizar es la carga en el array Java. Par ello utilizamos un bucle for en el cual vamos generando un número.

  1. for (int x=0;x<numeros.length;x++)
  2. numeros[x] = (int) (Math.random()*20)+1;

De esta forma hemos conseguido llenar un array con números aleatorios en Java.

Java » Invertir una cadena con recursividad en Java

junio 15, 2015 por Víctor Cuervo Sin Comentarios Imprimir Imprimir

En la página ya teníamos publicados dos artículos sobre como invertir una cadena en Java. Por un lado podíais ver como invertirla utilizando un bucle y por otro apoyándonos en el método reverse de un StringBuilder. Pero en el día de hoy vamos a ver como podemos invertir una cadena con recursividad en Java.

Lo primero que tenemos que saber para poder invertir una cadena con recursividad en Java es el concepto de recursividad. Podríamos decir que la recursividad consiste en ejecutar un mismo código un número de veces limitado para luego acabar dando como resultado la agregación de todas estas ejecuciones. Si bien está agregación se ejecutará de forma inversa, el decir lo primero será lo último ejecutado.

Para poder invertir una cadena con recursividad en Java nos vamos a apoyar en esa ejecución inversa. Lo primero será crear la función reverse.

  1. public String reverse(String palabra) {
  2. ...
  3. }

Como vemos lo que recibe la función reverse es una cadena. Dentro de las funciones preparadas para la recursividad siempre hay una comprobación por la cual nos saldremos de la ejecución y otra con la cual llamaremos a la función.

En este caso el fin de la ejecución será cuando la palabra solo tenga un carácter.

  1. public String reverse(String palabra) {
  2. if (palabra.length() == 1)
  3. return palabra;
  4. }

En el caso contrario lo que haremos será llamar a la función nuevamente, pero en este caso la llamaremos con el contenido de la palabra a partir del segundo carácter.

  1. public String reverse(String palabra) {
  2. if (palabra.length() == 1)
  3. return palabra;
  4. else
  5. return reverse(palabra.substring(1));
  6. }

Pero todavía tenemos que tener en cuenta es qué hacer con el carácter que nos queda en la pila. Es decir, el carácter que está en la posición 0. Este carácter habrá que añadirlo al final de la cadena para conseguir que esté invertida.

Por lo que nuestro código para invertir una cadena con recursividad en Java será el siguiente:

  1. public String reverse(String palabra) {
  2. if (palabra.length() == 1)
  3. return palabra;
  4. else
  5. return reverse(palabra.substring(1)) + charAt(0);
  6. }

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 1 Comentario 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.