Tipos de datos en Java
Almacenamiento de datos en variables.
El trabajo con datos es parte fundamental de cualquier programa, las variables y sus tipos se encargan de almacenar esa información y la memoria que es necesaria para gestionarlas.
La manera más habitual de declarar una variable siempre contiene dos elementos, el tipo de la variable y su nombre y terminando la declaración con punto y coma.
Pero también se puede declarar en una misma instrucción más de una variable del mismo tipo siempre separadas por una coma, al igual que se puede inicializar una variable en el momento de declararla.
Inicializar una variable consiste en almacenar un determinado valor en el espacio de memoria reservado para ella.
int midato;
tipoVariable nombre;
int midato1 = 3, midato2 = 6,midato3 = 5;
Los diferentes tipos de variables.
Las variables en Java deben tener un tipo de dato asociado. El tipo de dato de esa variable indicara los valores que la variable puede contener y las operaciones que se pueden realizar con ella. Podemos diferenciar los datos en Java en dos categorías de datos principales: los tipos primitivos y los tipos referenciados.
Los tipos primitivos contienen un sólo valor e incluyen los tipos como los enteros, coma flotante, los caracteres, de tipo booleano etc...
Los tipos referenciados se llaman así porque el valor de una variable de referencia es una referencia (un puntero) hacia el valor real. En Java tenemos los arrays, las clases y los interfaces como tipos de datos referenciados.
Enteros: Estos tipos son byte, short, int y long, que guardan el signo valor, estos representan un número y no pueden representar elementos fraccionarios.
Esto puede ser un buen ejemplo de declaración de tipos de datos enteros:
{
public static void main(String[] arg)
{
byte midato1 = 1;
short midato2 = 100;
int midato3 = 10000;
long midato4 = 100000000;
System.out .println("midato = " + midato1);
....
}
}
Números en coma flotante: Estos son float y double y pueden almacenar números en coma flotante y con signo, esto quiere decir que nos permiten representar números decimales.
Todos los literales de coma flotante son del tipo double salvo que se especifique lo contrario, por eso si se intenta asignar un literal en coma flotante a una variable de tipo float el compilador nos dará un error (tipos incompatibles):
public class tipoDecinales
{
public static void main(String[] arg)
{
float valor;
valor = 2.6;
System.out .println("Valor del dato= " + valor); //esto dará un error.
}
}
Esto se solucionaría indicando que el valor 2.6 es de tipo float con una f al final 2.6f
El tipo Carácter: Estos son de tipo char, que almacena la representación de los caracteres (letras o números), un carácter está almacenado en 16 bits, y siguen un estándar que es el Unicoide.
Los caracteres en Java se pueden especificar de forma normal o con secuencias de escape, utilizando la barra invertida "\" seguida de una letra:( \r) o utilizando la barra invertida con una "u" seguida de un numero hexadecimal (\u0000d), en este caso hemos especificado la secuencia de escape \r y su código unicoide correspondiente del retorno de carro.
{
public static void main(String[] arg)
{
char valor, valor1, valor2;
valor = 'a'; // el literal de tipo carácter tiene que estar encerrado entre comillas simples.
valor1 = 65;
}
}
Ejemplo de secuencias de escape:
\'...................... comillas simples.
\"......................comillas dobles.
\\......................barra invertida.
\b......................espacio en blanco.
\ddd..................carácter octal.
\f.......................avance.
\n......................nueva línea.
\r.......................retorno de carro.
\t.......................tabulador.
\uxxxx..............carácter Unicoide
\'...................... comillas simples.
\"......................comillas dobles.
\\......................barra invertida.
\b......................espacio en blanco.
\ddd..................carácter octal.
\f.......................avance.
\n......................nueva línea.
\r.......................retorno de carro.
\t.......................tabulador.
\uxxxx..............carácter Unicoide
El tipo booleano: Este solo guarda dos valores: verdadero (true) o falso(false), y no como ocurre en otros lenguajes que toman los valores 0 y 1. Generalmente su utilización es muy frecuente para determinar el flujo de los programas:
public class tipoBoolean
{public static void main(String[] arg)
{
boolean valor1, valor2 ;
valor = true;
valor1 = false;
if (valor1){
System.out .println("valor1 = verdadero");
} else {
System.out .println("valor1 = falso");
}
}
}
Tipos de datos
|
Rango de valores
|
Descripción
|
Números enteros
| ||
byte
|
8-bit complemento a 2
|
Entero de un Byte
|
short
|
16-bit complemento a 2
|
Entero corto
|
int
|
32-bit complemento a 2
|
Entero
|
long
|
64-bit complemento a 2
|
Entero largo
|
Números reales
| ||
float
|
32-bit IEEE 754
|
Coma flotante de precisión simple
|
double
|
64-bit IEEE 754
|
Coma flotante de precisión doble
|
otros tipos
| ||
char
|
16-bit Caracter
|
Un sólo carácter
|
boolean
|
true o false
|
Un valor booleano (verdadero o falso)
|
Los Arrays (Matrices)
Java dispone de un tipo de dato de posiciones secuenciales y que cuenta de unas comprobaciones exhaustivas para su correcta manipulación como puede ser la comprobación de no sobrepasar los límites permitidos en la definición del array.
Los arrays permiten guardar grupos de datos similares, puesto que Java trata los arrays como un tipo de objeto y por lo tanto este se tendrá que instanciar con el operador new.
Para crear un array tenemos que especificar una variable que se utilizara como índice para acceder al array y el tipo de datos que este contendrá.
Antes de poder utilizar un array hay que declararlo, como Java trata este tipo como un objeto, el array en este caso no reserva memoria para contener los datos, sino que solamente localiza memoria para almacenar una referencia al array, por ejemplo cuando se pasa una matriz a un método, sólo se pasa la referencia y no todos los elementos de la matriz.
En este ejemplo he creado un array unidimensional del tipo int que nos permite almacenar diez enteros, pero también pueden ser bidimensionales...
int miDato[] = new int[5];
Podríamos inicializar el array de la siguiente manera:
String misdatos[] = new String[4];
int misdatos[][] = new int[20][10];
Y para acceder al tercer elemento utilizaríamos los índices en este caso sería la posición elemento -1, pues Java considera el índice del primer elemento como 0.
misDatos[] = {"uno","dos","tres","cuatro");
misDatos[1] = "dos"
misDatos[0] = "uno"
....
Resaltar que todos los objetos array disponen de un método público "lenght()" que se utiliza para determinar su tamaño.
int array[][] = new int[5][2];
array.length; //= 5
array[0].length; //= 2
Ver ejemplo matrices.java
Tipos de datos String (las cadenas)
class miCadena{
String cadena1 = "PRIMERA CADENA";
String cadena2 = "SEGUNDA CADENA";
En realidad una variable de tipo String, más que un típo propio de Java es una clase tratada con todo rigor como un objeto más de Java.
En Java el contenido de las cadenas no se pueden modificar aun que se vuelva a definir la variable String, si en un programa se necesita modificar el contenido de una cadena lo más correcto sería utilizar la clase StringBuffer, la cual posee muchos métodos para este cometido como append() etc..
En este ejemplo definimos una cadena:
String miCadena = "Esto es una cadena";
No podemos modificar su contenido pero si podemos hacer que miCadena se refiera a otra cadena nueva:
miCadena = miCadena + "otra cadena";
En este ejemplo muestra el hecho de que una cadena no puede ser modificada, y sin embargo una variable de referencia puede modificarse para que apunte a una nueva cadena para que parezca que se ha modificado la cadena original:
class miCadena{
String cadena1 = "PRIMERA CADENA";
String cadena2 = "SEGUNDA CADENA";
public static void main( String args[] ) {
miCadena cad = new miCadena();
System.out.println( "Los valores originales de las cadenas son:" );
System.out.println( cad.cadena1 );
System.out.println( cad.cadena2 );
System.out.println( "Reemplaza cadena1 con otra cadena" );
cad.cadena1 = cad.cadena1 + " " + cad.cadena2;
System.out.println( "Nuevo valor de cadena1:" );
System.out.println( cad.cadena1 );
}
}
miCadena cad = new miCadena();
System.out.println( "Los valores originales de las cadenas son:" );
System.out.println( cad.cadena1 );
System.out.println( cad.cadena2 );
System.out.println( "Reemplaza cadena1 con otra cadena" );
cad.cadena1 = cad.cadena1 + " " + cad.cadena2;
System.out.println( "Nuevo valor de cadena1:" );
System.out.println( cad.cadena1 );
}
}
La Clase String
| Método | Descripción |
| char charAt(int index) | Devuelve el carácter en la posición indicada por index. El rango de index va de 0 a length() - 1. |
| boolean equals(Object obj) | Compara el String con el objeto especificado. El resultado es true si y solo si el argumento es no nulo y es un objeto String que contiene la misma secuencia de caracteres. |
| boolean equalsIgnoreCase(String s) | Compara el String con otro, ignorando consideraciones de mayúsculas y minúsculas. Los dos Strings se consideran iguales si tienen la misma longitud y, los caracteres correspondientes en ambos Strings son iguales sin tener en cuenta mayúsculas y minúsculas. |
| int indexOf(char c) | Devuelve el indice donde se produce la primera aparición de c. Devuelve -1 si c no está en el string. |
| int indexOf(String s) | Igual que el anterior pero buscando la subcadena representada por s. |
| int length() | Devuelve la longitud del String (número de caracteres) |
| String substring(int begin, int end) | Devuelve un substring desde el índice begin hasta el end |
| static String valueOf(int i) | Devuelve un string que es la representación del entero i. Observese que este método es estático. Hay métodos equivalentes donde el argumento es un float, double, etc. |
| char[] toCharArray() String toLowerCase() String toUpperCase() | Transforman el string en un array de caracteres, o a mayúsculas o a minúsculas. |
