ESTRUCTURAS DE DATOS BÁSICAS EN JAVA

TIPOS DE DATOS

En Java toda variable declarada ha de tener su tipo, y además antes de poder emplearla hemos de inicializarla a un valor, si no es compilador se quejará y no generará los archivos .class. Esto por ejemplo en C no es necesario, siendo fuente de muchos errores al emplearse en operaciones variables que nos hemos olvidado de inicializar. A continuación pasamos a describir los tipos de datos:

Almacenan como su propio nombre indica números enteros, sin parte decimal. Cabe destacar, como ya se indicó en el primer tema, que por razones de portabilidad todos los datos en Java tienen el mismo tamaño y formato. En Java hay cuatro tipos de enteros:

tipo de datos enteros en Java

Tipo        Tamaño (bytes)                  Rango

Int               4                                   -2147483648 a 2147483647

Short          2                                   -32768 a 32767

Long           8                                   -9223372036854775808 a 9223372036854775807

Byte            1                                   -128 a 127

Para indicar que una constante es de tipo long lo indicaremos con una L: 23L.

Reales

Almacenan número reales, es decir números con parte fraccionaria. Hay dos tipos:

Tipo                 Tamaño (bytes)               Rango

Float                       4                              + 3.40282347E+38

Double                    8                              + 179769313486231570E+308

En Java hay un único tipo de carácter: char. Cada carácter en Java esta codificado en un formato denominado Unicode, en este formato cada carácter ocupa dos bytes, frente a la codificación en ASCII, dónde cada carácter ocupaba un solo byte.

Unicode es una extensión de ASCII, ya que éste último al emplear un byte por carácter sólo daba acogida a 256 símbolos distintos. Para poder aceptar todos los alfabetos (chino, japonés, ruso...) y una mayor cantidad de símbolos se creó el formato Unicode.

En Java al igual que en C se distingue la representación de los datos char frente a las cadenas de caracteres. Los char van entre comillas simples: char ch = ‘a’, mientras que las cadenas de caracteres usan comillas dobles.

Boolean

Se trata de un tipo de dato que solo puede tomar dos valores: “true” y “false”. Es un tipo de dato bastante útil a la hora de realizar chequeos sobre condiciones. En C no hay un dato equivalente y para suplir su ausencia muchas veces se emplean enteros con valor 1 si “true” y 0 si “false”. Otros lenguajes como Pascal sí tiene este tipo de dato.

VARIABLES

Al igual que C, Java requiere que se declaren los tipos de todas las variables empleadas. La sintaxis de iniciación es la misma que C:

int i;

Sin embargo, y a diferencia que en C, se requiere inicializar todas las variables antes de usarlas, si no el compilador genera un error y aborta la compilación. Se puede inicializar y asignar valor a una variable en una misma línea:

int i = 0;

Asignación e inicialización pueden hacerse en líneas diferentes:

int i ;

i = 0;

Es posible iniciar varias variables en una línea:

int i, j,k;

Después de cada línea de código, bien sea de iniciación o de código, al igual que en C va un ;.En Java, al igual que en todo lenguaje de programación hay una serie de palabras reservadas que no pueden ser empleadas como nombres de variables (if, int, char, else, goto....); alguna de estas se emplean en la sintaxis del lenguaje, otras, como goto no se emplean en la actualidad pero se han reservado por motivos de compatibilidad por si se emplean en el futuro.

Los caracteres aceptados en el nombre de una variable son los comprendidos entre “A-Z”, “az”, _, $ y cualquier carácter que sea una letra en algún idioma.

OPERADORES

Los operadores básicos de Java son + , - , * , / para suma, resta, producto y división. El  operador / representa la división de enteros si ambos operandos son enteros. Su módulo puede obtenerse mediante el operador %.

Además existen los operadores decremento e incremento: -- y ++ respectivamente. La operación que realizan son incrementar y decrementar en una unidad a la variable a la que se aplican. Su acción es distinta según se apliquen antes (++a) o después (a++) de la variable. El siguiente programa ilustra estos distintos efectos:

public class ejemplo2{

public static void main(String[] args) {

int i = 1;

prt("i : " + i);

prt("++i : " + ++i); // Pre-incremento, primero

//incrementa y luego imprime por consola

prt("i++ : " + i++); // Post-incremento, primero imprime

//“2” por consola y luego incrementa i.

prt("i : " + i);//i por lo tanto vale 3

prt("--i : " + --i); // Pre-decremento, primero

//decrementa i y luego lo imprime por consola

prt("i-- : " + i--); // Post-decremento, primero imprime

//i por consola y luego de decrementa.

prt("i : " + i);//Ahora i vale 1

}

//esto nos ahorrara teclear. Invocando a prt podremos

//imprimir por consola la cadena de caracteres que le pasemos

static void prt(String s) {

System.out.println(s);

}

} ///:~

Exponenciación

En Java a diferencia que en otros lenguajes no existe el operador exponenciación. Tampoco existen los operadores Seno o Coseno. Si se desea realizar una operación de exponenciación  se deberá invocar el método correspondiente de la clase Math de Java.lang. Estos métodos son estáticos, por lo que no es necesario crear un objeto de dicha clase. Su sintaxis general es:

public class ejemplo3 {

public static void main(String[] args) {

int i = 45,j=2;

//Imprime por consola la cadena de caracteres “Cos i : “

//concatenado con el resultado de calcular el coseno de i

prt("Cos i : " + Math.cos(i));

prt("Sen i : " + Math.sin(i));

prt("j^i : " + Math.pow(j,i));

}

//esto nos ahorrara teclear

static void prt(String s) {

System.out.println(s);

}

} ///:~

En la tabla a continuación recogemos los operadores lógicos disponibles en Java:

Tabla 3: operadores lógicos

Operador                          Operación que realiza

!                                           Not lógico

==                                        Test de igualdad

!=                                         Test de desigualdad

<                                          Menor que

>                                          Mayor que

<=                                        Menor o igual que

>=                                        Mayor o igual que

&&                                        And lógico

||                                           Or lógico

Con el siguiente ejemplo se muestra la función de estos operadores:

import java.util.*;

public class ejemplo4 {

public static void main(String[] args) {

//Creamos un objeto de tipo Random, almecenado un puntero a

//el en la variable rand. En el tema 5 se detallará como se

//crean objetos.

Random rand = new Random();

//el método nextInt() del objeto Random creado (se invoca

//como rand.nextInt()) genera un número aleatorio entero. En

//el tema 5 se explica que son los métodos y como emplearlos.

//El módulo 100 de un entero aleatorio será un entero

//aleatorio entre 0 y 100.

int i = rand.nextInt() % 100;

int j = rand.nextInt() % 100;

//Imprime I y j por consola

prt("i = " + i);

prt("j = " + j);

//Imprime diversas operaciones binarias sobre i y j, junto

//con su resultado.

prt("i > j es " + (i > j));

prt("i < j es " + (i < j));

prt("i >= j es " + (i >= j));

prt("i <= j es " + (i <= j));

prt("i == j es " + (i == j));

prt("i != j es " + (i != j));

prt("(i < 10) && (j < 10) es "

+ ((i < 10) && (j < 10)) );

prt("(i < 10) || (j < 10) es "

Una posible salida de este programa es:

i = 85

j = 4

i > j                  es true

i < j                  es false

i >= j                es true

i <= j                es false

i == j                es false

i != j                 es true

//true && false = false

(i < 10) && (j < 10)              es false

//true || false = true

(i < 10) || (j < 10)                  es true

CADENAS DE CARACTERES

En Java no hay un tipo predefinido para cadenas de caracteres, en su lugar hay una clase, String, que es la que soporta las distintas operaciones con cadenas de caracteres. La definición de un String es:

String e ; //no inicializado

String e =””; //cadena vacía

String e = “Hola”; //inicialización y asignación juntas.

A continuación veremos algunas operaciones básicas soportadas por la clase String:

Concatenación

La concatenación en Java es increíblemente sencilla: se realiza con el operador +, es decir “sumando” cadenas de caracteres obtenemos la concatenación de estas. Lo ilustraremos con un ejemplo:

String saludo = “hola”;

String nombre = “Pepe”;

String saluda_pepe = “”;

saluda_pepe = saludo + nombre;// saluda_pepe toma el valor holaPepe

La sencillez de Java en el manejo de cadenas de caracteres llega incluso más alla: si una cadena la intentamos encadenar con otro tipo de variable automáticamente se convierte la otra variable a String, de tal modo que es perfectamente correcto:

String saludo = “hola”;

int n = 5;

saludo = saludo + “ “ + n;// saludo toma el valor “hola 5”

Subcadenas

En la clase String hay un método que permite la extracción de una subcadena de caracteres de otra. Su sintaxis es:

Nombre_String.substring((int)posición_inicial,(int)posición_final);

Donde posición_inicial y posición_final son respectivamente la posición del primer carácter que se desea extraer y del primer carácter que ya no se desea extraer.

String saludo = “hola”;

String subsaludo = “”;

Subsaludo = saludo.substring(0,2);// subsaludo toma el valor “ho”

Puede extraerse un char de una cadena, para ello se emplea el método charAt(posición),

siendo posición la posición del carácter que se desea extraer.

Comparación de cadenas

Se empleo otro método de String: equals. Su sintaxis es:

cadena1.equals(cadena2);

Devuelve true si son iguales y false si son distintos.

El siguiente ejemplo permitirá ilustrar estas operaciones con Strings:

public class ejemplo5 {

public static void main(String[] args) {

String saludo = "Hola";

String saludo2 ="hola";

int n = 5;

//Imprime por consola la subcadena formada por los caracteres

//comprendidos entre el caractero 0 de saludo y hasta el

//carácter 2, sin incluir el último

prt(saludo.substring(0,2));

//Concatena saludo con un espacio en blanco y con el valor de

//la variable n

prt(saludo +" " + n);

//Imprime el resultado del test de igualdad entre saludo y

//saludo2. Son distintos, en Java se distingue entre

//mayúsculas y minúsculas.

prt("saludo == saludo2 "+ saludo.equals(saludo2));

}

static void prt(String s) {

System.out.println(s);

}

}

ARRAYS

En Java los arrays son un objeto. Como tales se crean mediante el comando new (se verá su uso en el tema 5). La sintaxis en la definición de un array es la siguiente:

Tipo_datos[] nombre_array = new Tipo_datos[tamaño_array];

Tipo_datos es el tipo de los datos que se almacenarán en el array (int, char, String... o cualquier objeto). Tamaño_array es tamaño que le queremos dar a este array. Veamos un ejemplo:

Int[] edades = new int[10];

En este ejemplo hemos definido un array llamado edades, en el que podremos almacenar 10 datos tipo entero. El primer elemento de un array se sitúa en la posición 0, exactamente igual que en C. Si quisiésemos realizar un bucle que recorriese los elementos de este array escribiríamos un código del tipo:

for(int i= 0; i< 10; i++){

System.out.println(“Elemento “ + i + edades[i]);

}

+ ((i < 10) || (j < 10)) );

}

static void prt(String s) {

System.out.println(s);

}

} ///:~

Operadores lógicos

                 Math.metodo(argumentos);

En el siguiente código aparecen ejemplos. Si alguna vez deseamos realizar algún otro tipo de operación y queremos ver si la soporta Java podemos hacerlo consultando la ayuda on-line de la clase Math.

Copyright (c) 2003, Abraham Otero. Este documento puede ser distribuido sólo bajo los términos y

condiciones de la licencia de Documentación de javaHispano v1.0 o posterior (la última versión se

encuentra en

Para cualquier duda, consulta, insulto o tirón de orejas sobre este tutorial dirigirse a

http://www.javahispano.org/licencias/).abraham@javahispano.org.

Caracteres

Enteros