Tipos primitivos

Los tipos primitivos se dividen en:

• Caracteres
  • char
  • String
• boolean
• Numéricos
  • Enteros
    • byte
    • short
    • int
    • long
  • Reales
    • float
    • double
• Arrays

Los tipos primitivos se caracterizan por tener definidos un mismo tamaño en todas las plataformas (a diferencia del C / C++)

Los literales reales son de tipo double a menos que se incluya el sufijo F

3.14 no es del mismo tipo que 3.14F, el primero será double y el segundo float

Cuando se desea provocar una conversión se utiliza el operador cast

Tiene la siguiente sintáxis:

(tipo a convertir) expresión

Usando el cast se pueden realizar aquellas conversiones que el compilador no realiza por defecto

int i = (int) 5.4;

double x = 5 / (double) 2;

En el ejemplo se ha realizado un casting del double 5.4 a int para guardarlo en la variable i

El resultado de esa operación será que el compilador tomará sólo la parte entera del double, es decir, guardará en i el valor 5

En la segunda operación del ejemplo se divide 5 entre 2, dicha operación devolvería su resultado como un double, pero si el resultado no tendría decimales, se guardaría como un entero

Al hacer un casting en el denominador, forzamos al compilador a que guarde el resultado de la división como un double aunque no tenga decimales

Hay que tener en cuenta, que un casting no corrige el error de división por 0, debe controlarse mediante el uso de excepciones

Wrappers

Un wapper es una envoltura que se aplica a un tipo primitivo concreto

Hay una clase wrapper asociada a cada tipo primitivo

java.util.Vector

class Ejemplo{
    class Integer{
        private int value;

        public Integer (int value){
            this.value = i;
        }

	public intValue(){
            return this.value;
        }
    }

    class Double{
        private double value;

        public Double (double value){
            this.value = value;
        }

	public doubleValue(){
            return this.value;
        }
    }

    public static void main(String args[] ){
        Vector v = new Vector();

        v.addElement(new Integer(5));
        v.addElement(new Double(3.14));
    }
}

En el ejemplo se han redefinido los wrappers para int (es Integer) y para double (es Double) para poder añadir los datos primitivos int y double en la clase Vector

Las clases Wrapper tienen una segunda funcionalidad

Se utilizan para ubicar todos aquellos servicios propios de los tipos primitivos que representan

Algunos métodos de wrappers importantes:

Caracteres

Un carácter es un símbolo que sigue el estándar ASCII y que nos sirve para generar los textos de nuestros programas

Una cadena de caracteres es un array de caracteres que permiten guardar textos o frases

char

Es una letra que sigue el estándar ASCII y es la unidad menor de cadena

Su tamaño es de 8 bits

Su valor se podría considerar un entero pequeño ya que su rango es -128 a 127

Los valores char tienen asociada la clase Character

Se inicializa con comillas simples

char cad = 'A';

En el ejemplo se inicializado la variable cad como cadena y como puede apreciarse se ha guardado el símbolo ASCII que corresponde a la letra a mayúscula

String

Los cadenas de caracteres no son un tipo primitivo

Sin embargo Java le ofrece unas clases especiales para su tratamiento

Las cadenas son objetos que se manipulan mediante las clases String y StringBuffer

Se usa String cuando la cadena no va a ser modificada

Se usa StringBuffer cuando se desea manipular la cadena

Se recomienda usar habitualmente String (al ser constantes) por ser más eficientes

Inicialización de un String

Las cadenas van entre comillas dobles y los carácter con comillas simples

Cuando el compilador encuentre un literal de cadena, creará un objeto String con el texto de la misma

String s1 = "Hola";

String s2= new String("Hola");

En el ejemplo se han inicializado dos variables que podrían ser equivalentes

s1 se ha inicializado usando sólo las comillas dobles

s2 se ha inicializando el constructor de objetos de la clase String pasándole como argumento el valor con comillas dobles

Ambas inicializaciones son válidas y el contenido de las variables s1 y s2 será en ambas Hola

La única diferencia es que al ser objetos distintos, su referencia en memoria será también distinta

Métodos básicos

length

El método length devuelve el número de caracteres de una cadena

"Hola".length();

s1.length();

En el ejemplo se han pedido a dos cadenas de caracteres su número de caracteres

En la primera se han usado comillas dobles y en la segunda el objeto String s1 del ejemplo anterior

Las dos expresiones anteriores serian equivalentes, devuelven un entero con el número de caracteres de la cadena

charAt

El método charAt devuelve el carácter de la posición especificada

Si el argumento de charAt no es un número entre 0 y length – 1 se producirá una excepción

int cuentaChar(String str, char busca){
    int contador = 0;

    for(int i = 0; i ‹ str.length(); i++){
        if(str.charAt(i) == busca){
    	    contador++;
	}
    }

    return contador;
}

En el ejemplo se ha creado una función que dados un String str y el char busca, se busca el carácter en esa cadena y si se encuentra, el valor de retorno será mayor que 0

Para lograrlo se ha usado el método charAt al que se le ha pasado el valor de i que representa la posición de carácter leído hasta el momento

Como devuelve el carácter leído en ese momento hemos podido compararlo con el carácter busca que nos pasaron como argumento

Métodos de búsqueda

Los métodos para realizar búsquedas en cadenas devuelven la posición del elemento buscado o -1 si no se ha encontrado:

• indexOf(int ch)
• indexOf(int ch, int start)
• indexOf(String str)
• indexOf(String, int start)
• lastIndexOf(int ch)
• lastIndexOf(int ch, int start)
• lastIndexOf(String str)
• lastIndexOf(String str, int start)

String s = "Hola Caracola";

s.indexOf('o');    //devuelve 1

s.indexOf('o', 2);    //devuelve 10

s.indexOf("la");    //devuelve 2

s.indexOf("la", 3);    //devuelve 11

s.lastIndexOf('o');    //devuelve 10

s.lastIndexOf("la");    //devuelve 11

En el ejemplo se ha usado cada uno de los métodos y se ha comentado su valor devuelto para poder comprenderlos mejor

Comparación de cadenas

Para comparar cadenas no sirve el operador ==, ya que en realidad estamos comparando objetos

La clase String tiene varios métodos para comparar cadenas

Dos cadenas serán iguales si tienen la misma longitud y los mismos caracteres Unicode (a y á son distintos)

Los métodos más habituales son:

• equals
• equalsIgnoreCase

  distingue entre mayúsculas y minúsculas

• compareTo

  además de permitir averiguar si dos cadenas son iguales, también nos dice cual es mayor de las dos:

  • Igual a 0

    Eran iguales

  • Mayor que 0

    El segundo valor era mayor

  • Menor que 0

    El segundo valor era menor

String s1 = "Hola";
String s2 = "hola";
String s3 ="Adiós";

System.out.println(s1 == s2);    //devuelve Falso, aunque este resultado no es muy fiable

System.out.println(s1.equals(s2));    //devuelve Falso

System.out.println(s1.equalsIgnoreCase(s2));    //devuelve Verdadero

System.out.println(s3.compareTo("Hola"));    //devuelve Falso y nos dice de forma numérica que la segunda es mayor

System.out.println("Hola".compareTo(s3));    //devuelve Falso y nos dice de forma numérica que la primera es mayor

System.out.println(s3.compareTo("Adiós"));    //devuelve Verdadero y nos dice que eran iguales

En el ejemplo se ha usado cada uno de los métodos y se ha comentado su valor devuelto para poder comprenderlos mejor

Métodos para comparar prefijos y sufijos

• boolean starsWith(String)
• boolean starsWith(String, int start)
• boolean endsWith(String)

String s1 = "Hola";
String s2 = "Caracola";

System.out.println(s1.startWith("Ho"));    //Devuelve True

System.out.prinln(s1.endsWith("la"));    //Devuelve True

System.out.println(s2.startWith("Ho"));   //Devuelve False

System.out.prinln(s2.endsWith("la"));    //Devuelve True

En el ejemplo se ha usado cada uno de los métodos y se ha comentado su valor devuelto para poder comprenderlos mejor

Extracción de cadenas

Hay una serie de métodos que devuelven una nueva cadena que resulta de manipular la cadena original

La cadena original no se modifica (se crea una nueva instancia de la cadena, es decir, se usa otra posición de memoria)

• String concat(String)
• String replace(char, char)
• String replaceAll(String, String)
• String substring(int start)
• String substring(int start, int end)
• String toLowerCase()
• String toUpperCase()
• String trim()

String s1 = "Hola";
String s2 = "Caracola";
String s3 = s1.concat(s2);    //se concatenan las variables s1 y s2, el resultado se guarda en s3

System.out.println(s3);    //devuelve HolaCaracola
System.out.println(s1);    //devuelve Hola, la variable s1 no ha sido modificada

s3 = s2.substring(4, 8);  //se obtienen la cadena contendia en las posiciones de 4 a 8 de s2 y se guarda en s3

System.out.println(s3);   //devuelve cola, ya que el contenido anterior de s3 ha sido sobrescrito
System.out.println(s2);   //devuelve Caracola, la variable s2 no ha sido modificada
System.out.println("Hola ".trim().toUpperCase());
/* devuelve HOLA, primero se aplica el método trim, que borra los espacios de la cadena
   y después se aplica el método toUpperCase, que cambia todos los caracteres a caracteres en mayúsculas */

En el ejemplo se han usado algunos de los métodos y se ha comentado su valor devuelto para poder comprenderlos mejor

Conversiones de cadenas

Los tipos primitivos se pueden convertir automáticamente a cadenas

Para convertir las cadenas en tipos primitivos hay que utilizar alguna de las siguientes funciones:

• boolean new Boolean(String).booleanValue()
• int Integer.parseInt(String)
• long Long.parseLong(String)
• float Float.parseFloat(String)
• double Double.parseDouble(String)

Otros métodos

• char[] toCharArray()
• void getChars(int srcBegin, int srcEnd, char[] dest, int destBegin)
• int hashCode()
• String valueOf(boolean)
• String valueOf(int)
• String valueOf(long)
• String valueOf(float)
• String valueOf(double)
• String[] split(String)

String cad = "Hola caracola".split(" "); //se trocea la cadena usando como token el espacio

System.out.println(cad[0]); //devuelve Hola
System.out.println(cad[1]); //devuelve caracola

Como puede verse en el ejemplo, usaremos split para trocear cadenas usando un token, en este caso hemos usado el espacio

Este método es bastante útil para trabajar con ficheros de texto en formato CSV, ya que se suele utilizar el símbolo ; (u otro símbolo de token) para separar las distintas columnas o celdas

StringBuffer

Aunque la clase String es la más habitual no es la adecuada para cadenas que deben modificarse frecuentemente

String ad1 = '¡';
String ad2 = '!'
String str = 'Ejemplo'
String admiracion1 = ad1 + str + ad2;
String admiracion2 = String.valueOf(ad1).concat(str).concat(String.valueOf(ad2));

//Si usamos sólo String podemos observar que admiracion1 y admiracion2 son equivalentes en su valor
System.out.println(admiracion1); //devuelve ¡Ejemplo!
System.out.println(admiracion2); //devuelve ¡Ejemplo!

En el ejemplo se crean cuatro objetos String de los cuales sólo uno va a ser usado, admiracion1 o admiracion2

La clase StringBuffer permite modificar la cadena original sin necesidad de crear objetos intermedios como se hizo en el ejemplo

Inicialización de un StringBuffer

Admite los siguientes constructores:

• StringBuffer()
• StringBuffer(int i)
• StringBuffer(String str)

Métodos de modificación

Admite los siguientes métodos de modificación:

• append(Objetc obj)
• append(String str)
• append(char str[] )
• append(boolean b)
• append(int i)
• append(long l)
• append(float f)
• append(double d)
• append(char ch)
• insert(int offset, Object obj)
• insert(int offset, String str)
• insert(int offset, char str[] )
• insert(int offset, boolean b)
• insert(int offset, int i)
• insert(int offset, long l)
• insert(int offset, float f)
• insert(int offset, double d)
• insert(int offset, char ch)
• setCharAt(int index, char c)
• setLength(int longitud)

StringBuffer s1 = new StringBuffer("hola");

s1.append("caracola");

System.out.println(s1);  //devuelve holacaracola

s1.insert(4, ' ');

System.out.println(s1); //devuelve hola caracola

s1.setCharAt(0, 'H');

System.out.println(s1); //devuelve Hola caracola

En el ejemplo se han usado algunos de los métodos y se ha comentado su valor devuelto para poder comprenderlos mejor

Métodos básicos

length

Es similar al de String

charAt

Es similar al de String

toString

Realiza la conversión del BufferString a un String

Operador +

Java permite la concatenación de cadenas mediante el +

String saludo = "Hola";

System.out.println(saludo + " a todos");    //devuelve Hola a todos

En el ejemplo, internamente el compilador utiliza un StringBuffer en vez de un String

String saludo= "Hola";

System.out.println(new StringBuffer(saludo).append(" a todos"));   //devuelve Hola a todos

Por lo que este ejemplo es totalmente compatible con el anterior

int valor = 5;

System.out.println("Valor = " + valor);    //devuelve Valor = 5

En el ejemplo hemos concatenado la cadena con otro tipo (entero), este último se convierte automáticamente a cadena (el compilador invoca implícitamente el método toString() de la clase StringBuffer)

boolean

Su tamaño es de 1 bit

Su valor se podría considerar un entero pequeño ya que su rango es 0 a 1

Siendo el valor 0 igual a FALSE y 1 igual a TRUE

Los valores boolean tienen asociada la clase Boolean

boolean b = 0;	//declaración de una variable de un tipo primitivo, puede declararse o en número o en letra

Boolean b = new Boolean(TRUE);	//declaración de un objeto de la clase Boolean

Métodos básicos

booleanValue

Devuelve el valor del booleano

toString

Convierte el tipo booleano a una cadena

Numéricos

Son todos los tipos que permiten trabajar con números y se pueden distinguir según si son enteros o decimales o según su precisión

Enteros

Son todos los tipos que permiten trabajar con números enteros, hay varios tipos según su precisión y el rango de números que pueden llegar a manejar

byte

Su tamaño es de 8 bits

Su valor se podría considerar un entero pequeño sin signo ya que su rango es 0 a 255

Los valores byte tienen asociada la clase Byte

short

Su tamaño es de 16 bits

Su valor se podría considerar un entero sin signo ya que su rango es 0 a 65535

Los valores short tienen asociada la clase Short

int

Su tamaño es de 16 bits

Su valor se podría considerar un entero con signo ya que su rango es -32768 a 32767

Los valores int tienen asociada la clase Integer

long

Su tamaño es de 32 bits

Su valor se podría considerar un entero grande ya que su rango es -2147483648 a 2147483647

Los valores long tienen asociada la clase Long

Reales

Son todos los tipos que permiten trabajar con números decimales, hay varios tipos según su precisión y el rango de números que pueden llegar a manejar

float

Su tamaño es de 32 bits

Su valor se podría considerar un decimal pequeño ya que su rango es 3,4E-38 a 3,4E+38

Los valores float tienen asociada la clase Float

double

Su tamaño es de 64 bits

Su valor se podría considerar un decimal grande ya que su rango es 1,7E-308 a 1,7E+308

Los valores double tienen asociada la clase Double

Arrays

Un array es una agrupación de elementos del mismo tipo

Los arrays en Java se caracterizan por ser objetos

Por tanto, se necesitará una referencia para manipularlos

int v[]; //No se indica el tamaño

v = new int[10]; //al usar new debemos especificar el tamaño o lanzará una excepción
v[0]=5;    //se asigna un valor a la posición 0 del array

System.out.println(v[0]); //devuelve 5

En el ejemplo podemos ver que como cualquier otro objeto, se inicializa con new

Para acceder a los elementos del array se usa la notación clásica de arrays (usando un índice)

Si no se especifica el valor máximo del indice, el compilador lo tomará como un array dinámico

Se puede considerar que la notación es equivalente a enviar un mensaje al array para consultar un elemento o modificarlo

El rango de un array está entre 0 y N-1 (siendo N el tamaño del array)

Si se accede a una posición fuera de rango se producirá una excepción

int [] a = {1, 2, 3, 4};

for(int i=0; i < a.length; i++){
    System.out.println(a[i]);
}

En el ejemplo hemos inicializado el array a para luego poder visualizar todo su contenido por pantalla

Como puede verse, Java permite inicializar el array en su declaración

El operador length permite averiguar el tamaño de un array

Cronometro[] v={new Cronometro(), new Cronometro()};
Cronometro[] v=new Cronometro[2];

v[0]=new Cronometro();
v[1]=new Cronometro();

En el ejemplo hemos inicializado un array de referencias en su declaración

Como puede verse, ambas declaraciones son equivalentes

Arrays bidimensionales

Un array bidimensional puede tener varias filas, y en cada fila no tiene por qué haber el mismo número de elementos o columnas

double[][]   matriz={{1,2,3,4},{5,6},{7,8,9,10,11,12},{13}};

for (int i=0; i < matriz.length; i++){
    for (int j=0; j < matriz[i].length; j++){
    	System.out.print(matriz[i][j]+"\t");
    }

    System.out.println("");
}

En el ejemplo hemos declarar e inicializado la matriz bidimensional de doubles matriz para luego recorrerla y visualizarla por pantalla

La primer fila tiene cuatro elementos {1,2,3,4}

La segunda fila tiene dos elementos {5,6}

La tercera fila tiene seis elementos {7,8,9,10,11,12}

La cuarta fila tiene un elemento {13}

matriz.length nos proporciona el número de filas que en este caso es

matriz[i].length nos proporciona el número de elementos en cada fila

Mostramos los elementos de una fila separados por un tabulador usando la función print

Una vez completada una fila se pasa a la siguiente mediante println

Ejemplo de matriz identidad

Para mostrar la potencia de una matriz bidimensional, en este ejemplo se va a construir una matriz identidad de dimensión 4

Una matriz identidad es aquella cuyos elementos son ceros excepto los de la diagonal principal, i = = j, que son unos

double[][] identidad = new double[4][4];

for (int i=0; i < identidad.length; i++){
    for (int j=0; j < identidad[i].length; j++){
        if (i == j){
            identidad[i][j] = 1.0;
        }else{
            identidad[i][j] = 0.0;
        }
    }
}
for (int i=0; i < identidad.length; i++){
    for (int j=0; j < identidad[i].length; j++){
        System.out.print(identidad[i][j]+"\t");
    }
    System.out.println("");
}

Mediante un doble bucle for recorremos los elementos de la matriz especificando su fila i y su columna j poblando la matriz con 1 o 0 en función de si coincide i y j

Mediante un doble bucle for recorremos los elementos de la matriz especificando su fila i y su columna j

Mostramos los elementos de una fila separados por un tabulador usando la función print

Una vez completada una fila se pasa a la siguiente mediante println