feed twitter facebook LinkedIn facebook

HTML » Agrupar filas en una tabla html

Cuando estemos diseñando una tabla puede darse el caso de que queramos que una celda agrupe al contenido de dos celdas del resto de fila. Es por ello que vamos a ver como podemos agrupar filas en una tabla HTML.

Para entender mejor de lo que hablamos vamos a ver cómo quedaría visualmente:

País Datos T1 T2 T3 T4
España Cantidad 10 15 8 9
Porcentaje 40% 25% 32% 38%
Italia Cantidad 12 8 15 20
Porcentaje 10% 9% 45% 80%

Podemos ver que el contenido del País agrupa al contenido que tiene la cantidad y el porcentaje. Es decir se agrupa la primera celda con las dos filas siguientes.

Para agrupar filas en una tabla html vamos a utilizar el atributo rowspan de las celdas. El atributo rowspan indica el número de filas a las cual se expande su contenido.

El valor del atributo rowspan equivaldrá al número de filas sobre las que queramos expander dicha celda.

De esta forma la primera fila de datos de la tabla quedaría de la siguiente forma:

  1. <td rowspan="2">España</td>
  2. <td>Cantidad</td>
  3. <td>10</td>
  4. <td>15</td>
  5. <td>8</td>
  6. <td>9</td>
  7. </tr>

Vemos que hemos indicado que la primera celda se expanderá a dos filas. De esta forma, a la hora de crear la segunda fila, esta tendrá una celda menos que la primera (en vez de 6 celdas se tendrán 5 celdas), ya que hemos dicho que la primera celda equivale a dos.

  1. <td>Porcentaje</td>
  2. <td>40%</td>
  3. <td>25%</td>
  4. <td>32%</td>
  5. <td>38%</td>
  6. </tr>

De esta forma hemos visto como el atributo rowspan nos ayuda a agrupar filas en una tabla HTML.

HTML » Pie de tabla HTML

Ya hemos visto cómo podemos poner una cabecera a una tabla HTML, ahora vamos a poner un pie de tabla HTML. Los pie de tabla HTML se suelen utilizar para poner resúmenes, totalizadores,...

Para poder crear un pie de tabla HTML vamos a recurrir al agrupador ftoot. El elemento ftoot será el que agrupe a las filas que representen el pie de tabla HTML.

Lo primero será echar un vistazo a la tabla que queremos representar y ver como hacer el pie de tabla HTML.

Cabecera 1 Cabecera 2 Cabecera 3
Sumatorio 1 Sumatorio 2 Sumatorio 3
Celda 1.1 Celda 1.2 Celda 1.3
Celda 2.1 Celda 2.2 Celda 2.3
Celda 3.1 Celda 3.2 Celda 3.3

En este ejemplo el pie de página HTML a implementar sería el que tiene los sumatorios.

El código HTML que necesitamos es el siguiente:

  1. <td>Sumatorio 1</td>
  2. <td>Sumatorio 2</td>
  3. <td>Sumatorio 3</td>
  4. </tr>
  5. </tfoot>

Como podemos ver el elemento ftoot agrupa una fila definida por el elemento tr y las celdas td. Con lo cual vemos que es sencillo modificar una tabla tipo.

Pero hay que tener una cosa en cuenta. Y es que el elemento ftoot deberá de ir justo detrás del elemento thead. Es decir, la fila de sumatorios NO será la última de nuestro código, si no la segunda.

Así para tener un pie de tabla HTML deberemos de codificar de la siguiente forma:

  1. <th>Cabecera 1</th>
  2. <th>Cabecera 2</th>
  3. <th>Cabecera 3</th>
  4. </tr>
  5. </thead>
  6. <td>Sumatorio 1</td>
  7. <td>Sumatorio 2</td>
  8. <td>Sumatorio 3</td>
  9. </tr>
  10. </tfoot>
  11. <td>Celda 1.1</td>
  12. <td>Celda 1.2</td>
  13. <td>Celda 1.3</td>
  14. </tr>
  15. ...
  16. </table>

CSS » Título tabla HTML inferior

El otro día veíamos como podía poner un título en tabla HTML mediante el elemento caption. En este ejemplo vamos a ver como tener un título tabla HTML inferior, es decir, que el título se vea después de la tabla.

Lo primero será poner el título tabla HTML mediante el elemento caption.

  1. <caption>Datos Demográficos</caption>
  2. <th>País</th>
  3. <th>Capital</th>
  4. <th>Superficie</th>
  5. <th>Habitantes</th>
  6. </tr>
  7. ...
  8. </table>

Hay que recordar que el elemento caption debe de ir justamente después del elemento table y que el texto corresponderá al título de la tabla.

Ahora vamos a ver cómo poner el título tabla HTML inferior y ello lo haremos mediante un estilo CSS y en concreto mediante el atributo caption-side. Al atributo caption-side podemos darle los valores "bottom" o "top", dependiendo de si lo queremos tener sobre la tabla o debajo de la tabla.

Así si queremos el título tabla HTML inferior deberemos de configurar las CSS de la siguiente forma:

  1. caption {
  2. caption-side: bottom;
  3. }

HTML » Título en tabla HTML

En este ejemplo vamos a ver cómo podemos poner un título en tabla HTML. Para ello vamos a ver cómo podemos utilizar el elemento caption de HTML.

Lo primero será partir de una tabla. En este caso hemos escogido una tabla con datos demográficos.

  1. <th>País</th>
  2. <th>Capital</th>
  3. <th>Superficie</th>
  4. <th>Habitantes</th>
  5. </tr>
  6. <td>España</td>
  7. <td>Madrid</td>
  8. <td>504.645 km<sup>2</sup></td>
  9. <td>46,6 M</td>
  10. </tr>
  11.  
  12. <td>Italia</td>
  13. <td>Roma</td>
  14. <td>301.338 km<sup>2</sup></td>
  15. <td>60,7 M</td>
  16. </tr>
  17. </table>

Vemos que la estructura de la tabla es la normal, con su elemento table, con sus filas definidas mediante el elemento tr y las celdas ya sean de cabecera th o normales td.

Para poner el título en tabla HTML deberemos de añadir el elemento caption justamente después del elemento table. El elemento caption es un elemento con etiquetas de inicio y cierre que contendrá el texto representativo del título.

Es decir, el código HTML nos quedará de la siguiente forma:

  1. <caption>Datos Demográficos</caption>
  2. <th>País</th>
  3. <th>Capital</th>
  4. <th>Superficie</th>
  5. <th>Habitantes</th>
  6. </tr>
  7. ...
  8. </table>

Visualmente el título en tabla HTML se muestra centrado encima de la tabla. Si bien mediante CSS podremos ponerlo encima o debajo de la tabla (lo veremos en otro artículo) o modificar su representación visual.

En el ejemplo que hemos visto para poner el título en tabla HTML el resultado sería parecido a este:

Datos Demográficos
País Capital Superficie Habitantes
España Madrid 504.645 km2 46,6 M
Italia Roma 301.338 km2 60,7 M
Francia París 675.417 km2 66 M
Grecia Atenas 131.990 km2 10,7 M
Alemania Berlin 357.168 km2 81,2 M

HTML » Cabecera en tabla HTML

A la hora de definir una cabecera en tabla HTML tenemos que conocer dos elementos del lenguaje HTML. El primer elemento es thead. thead es un elemento agrupador de celdas, estas celdas serán las que conformen una cabecera en tabla HTML. El segundo de los elementos será th. En este caso th representa a una celda independiente que es una cabecera en sí misma.

Como ejemplo y para mostrar de una forma sencilla que sería la cabecera en tabla HTML vamos a ver la siguiente tabla...

Cabecera 1 Cabecera 2 Cabecera 3
Celda 1.1 Celda 1.2 Celda 1.3
Celda 2.1 Celda 2.2 Celda 2.3
Celda 3.1 Celda 3.2 Celda 3.3

Como podemos apreciar, los elementos Cabecera 1, 2 y 3 serán aquellos que formen la cabecera en tabla HTML.

Pero veamos como utilizar los elementos thead y th para conseguir estos efectos.

Agrupado una cabecera en tabla HTML con thead

Cuando creamos una tabla en HTML utilizamos como base el elemento table. Después vamos a ir añadiendo las filas mediante elementos tr y td. Es decir una tabla básica sería algo así:

  1. <td>Celda 1.1</td>
  2. <td>Celda 1.2</td>
  3. <td>Celda 1.3</td>
  4. </tr>
  5. <td>Celda 2.1</td>
  6. <td>Celda 2.2</td>
  7. <td>Celda 2.3</td>
  8. </tr>
  9. <td>Celda 3.1</td>
  10. <td>Celda 3.2</td>
  11. <td>Celda 3.3</td>
  12. </tr>
  13. </table>

Lo que nos va a permitir el elemento thead es agrupar una serie de elementos, para indicar que estos elementos son la cabecera. Estos elementos no dejarán de ser una o varias líneas, dependiendo de lo compleja que sea nuestra cabecera.

Utilizaremos el elemento thead de la siguiente forma:

  1. <td>Cabecera 1</td>
  2. <td>Cabecera 2</td>
  3. <td>Cabecera 3</td>
  4. </tr>
  5. </thead>
  6. <td>Celda 1.1</td>
  7. <td>Celda 1.2</td>
  8. <td>Celda 1.3</td>
  9. </tr>
  10. <td>Celda 2.1</td>
  11. <td>Celda 2.2</td>
  12. <td>Celda 2.3</td>
  13. </tr>
  14. <td>Celda 3.1</td>
  15. <td>Celda 3.2</td>
  16. <td>Celda 3.3</td>
  17. </tr>
  18. </table>

De esta forman hemos identificado que la primera línea de celdas delimitada por el elemento tr es la cabecera. Visualmente, los navegadores ante esta situación no hacen ningún cambio de aspecto visual, es más una información semántica.

Definiendo celdas de cabecera con th

Si queremos realmente dar más información sobre la cabecera en tabla HTML deberemos de definir celdas que sean de tipo th.

Las celdas de una tabla se definen con el elemento td. Si bien, si queremos hacer que las celdas representen a una cabecera deberemos definirlas de la misma forma, pero utilizando el elemento th.

Es decir el código sería el siguiente:

  1. <th>Cabecera 1</th>
  2. <th>Cabecera 2</th>
  3. <th>Cabecera 3</th>
  4. </tr>
  5. </table>

Importante destacar que los navegadores web suelen resaltar en negrita los elementos que se encuentran dentro de los elementos th. Si bien, recomendamos que utilices CSS para darle forma a las cabeceras.

Si ahora combinamos los elementos thead y th para crear una cabecera en tabla HTML nos quedaría el siguiente código:

  1. <th>Cabecera 1</th>
  2. <th>Cabecera 2</th>
  3. <th>Cabecera 3</th>
  4. </tr>
  5. </thead>
  6. <td>Celda 1.1</td>
  7. <td>Celda 1.2</td>
  8. <td>Celda 1.3</td>
  9. </tr>
  10. <td>Celda 2.1</td>
  11. <td>Celda 2.2</td>
  12. <td>Celda 2.3</td>
  13. </tr>
  14. <td>Celda 3.1</td>
  15. <td>Celda 3.2</td>
  16. <td>Celda 3.3</td>
  17. </tr>
  18. </table>

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();