Práctica 3: Utilerías y clases de uso general

Objetivo

Utilizar bibliotecas propias del lenguaje para realizar algunas tareas comunes y recurrentes.

Introducción

Tipos primitivos

En Java, los tipos primitivos son los tipos de datos que no heredan de la clase Object. Se caracterizan por estar implementados de forma nativa, y por ser mucho más rápidos y simples que sus contrapartes en clases.

Tipos de clase

Por otro lado, las clases heredan su forma de la clase Object, y son más lentas y complejas que sus contrapartes primitivas, pero permiten aprovechar todas las características de la programación orientada a objetos.

Desarrollo

Tipos primitivos

Empezamos viendo las dos formas de crear arrays primitivos en Java:

int num1[] = new int[10];
int[] num2 = {1,2,3,4,5};

La primera forma se ha heredado de la sintaxis de C, mientras que la segunda forma es innovación de Java, y es la forma recomendada.

Luego, vimos que las listas tienen un atributo que indica el número de elementos que contienen:

num1.length // = 10
num2.length // = 5

Bucle for-each

Vimos también la forma de iterar sobre una lista:

for (int o : num2){
  // Imprimirá 1, 2, 3, 4, 5
  System.out.println(o);
}

Dentro de la definición del bucle, lo que va antes de los dos puntos es una variable que tendrá el valor a usar en cada iteración, y lo que va después es la lista a iterar.

En el ejemplo, o tendrá en cada iteración un valor diferente, el de cada elemento de la lista.

Concatenar cadenas

Aquí vimos primero que una clase basada en un tipo primitivo tiene dos formas de ser inicializada:

String s = new String("Hola!");
System.out.println(s);

String s1 = "Hola!";
System.out.println(s1);

La primera declaración es la forma de objeto, y la segunda es la forma primitiva. Ambas son equivalentes.

Luego, creamos dos cadenas de texto para concatenarlas:

String nombre = "Giovanni";
String apellido = "Garciliano";
String nCompleto = nombre + " " + apellido;
// = Giovanni Garciliano
System.out.println(nombreCompleto);

El operador + permite concatenar cadenas de texto. Entre las dos variables introducimos un espacio por legibilidad.

Operador punto

El operador punto sirve para acceder a los atributos y métodos de un objeto:

// = 5
System.out.println("Arreglo con elementos: " +num2.length);

// = 19
System.out.println("Elementos en la cadena: " + nCompleto.length());

// = GIOVANNI GARCILIANO
System.out.println(nCompleto.toUpperCase());

System.out.println(nCompleto);

El array de primitivos expone su longitud mediante un atributo, mientras que el objeto expone la suya mediante un método, ambos llamados size. Por último, se usó el método toUpperCase() como ejemplo de que en las clases principales, generalmente los métodos devuelven el objeto modificado con la operación realizada, pero no modifican el objeto original.

Wrappers y autoboxing

Aquí vimos la relación entre un tipo primitivo, y su clase relacionada. Primero declaramos un entero, y luego declaramos dos objetos Integer, a como se vio en la sección C. Concatenar cadenas: primero en forma de objeto y luego de forma primitiva.

Luego, vimos cómo convertir un entero, sea primitivo u objeto, a un objeto String: la primitiva se concatena con una cadena vacía, convirtiéndose el entero automáticamente en una cadena; y el objeto Integer aprovecha el método toString.

En el ejemplo de la primitiva, adicionalmente vimos que asignar un objeto a una variable del tipo de su primitiva correspondiente no asigna el objeto a esa variable, sino sólo su valor primitivo.

int l = 25;

// Forma objeto
Integer k = new Integer(50);

// Forma primitiva
Integer m = 66;

String s3 = k.toString();
System.out.println(s3); // = "50"

int r = k;
String s4 = r + "";
System.out.println(s4); // = "50"

//String s5 = l; // error

Por último, vimos que asignar un objeto de un tipo a una variable de otra clase es ilegal en Java.

ArrayList

Aquí vimos cómo instanciar un objeto ArrayList que contiene objetos Integer. También vimos los métodos add, size y get, que, respectivamente, añaden elementos a la lista, devuelve el tamaño de la lista, y devuelve elementos de la lista.

ArrayList<Integer> miList = new
ArrayList<Integer>();

miList.add(99);
miList.add(6);

// = 2
System.out.println(miList.size());
// = 6
System.out.println(miList.get(1));

miArrayList.add(77);
miArrayList.add(0, 4);

// Imprimirá 4, 99, 6, 77
for (Integer e : miList){
  System.out.println(e);
}

Para usar la clase es necesario importar lo siguiente:

import java.util.ArrayList;

HashTable

Aquí vimos cómo instanciar un objeto Hashtable que contiene objetos Integer, indexados por objetos String. También vimos dos métodos: put, que añade elementos al diccionario, y size, que devuelve el número de elementos del diccionario.

Hashtable<String, Integer> miTabla = new Hashtable<String, Integer>();

miTabla.put("Antonio", 12657);
miTabla.put("Juan", 14537);
miTabla.put("Fernando", 19357);

// = 3
System.out.println("Número de elementos: " + miTabla.size());

Por último, vimos dos métodos que nos ayudarán a iterar sobre los elementos guardados en un objeto Hashtable.

for(Integer valor: miTabla.values()){
  System.out.println(valor);
}
for(String clave: miTabla.keySet()){
  System.out.println(clave);
}

Pero iterar mediante keySet. ya no se recomienda, sino que debe hacerse con objetos enumerados, como se explicará en la siguiente seccion.

Para usar la clase es necesario importar lo siguiente:

import java.util.Hashtable;

Enumeraciones

Aquí vimos cómo instanciar un objeto Enumeration que contiene objetos String. También vimos los métodos hasMoreElements y nextElement: la idea es ir recorriendo la lista mientras existan elementos, cosa que se comprueba con el primer método, y los elementos se obtienen con el segundo método.

String eClave;
Integer eValor;
Enumeration<String> iteraClaves = miTabla.keys();
while (iteraClaves.hasMoreElements()){
  eClave = iteraClaves.nextElement();
  eValor = miTabla.get(eClave);
  System.out.println("Clave:"+eClave+", Valor: "+eValor);
}

Para usar la clase es necesario importar lo siguiente:

import java.util.Enumeration;

Math

La clase Math contiene muchas utilidades sobre cuestiones matemáticas. En clase se vieron los siguientes elementos:

Math.PI
número Pi
Math.abs()
devuelve el valor absoluto de un número
Math.pow()
eleva un número a una potencia
Math.sqrt()
devuelve la raíz cuadrada de un número
Math.max()
devuelve el mayor de dos números dados
// = 3.1415926...
System.out.println(Math.PI);
// = 9
System.out.println(Math.abs(-9));
// = 8
System.out.println(Math.pow(2, 3));
// = 3
System.out.println(Math.sqrt(9));
// = 55
System.out.println(Math.max(4,55));

Date

La clase Date contiene varias utilidades para manejar fechas y horas.

Al instanciar la clase Date obtenemos un objeto con la fecha del momento de la instanciación.

Por otro lado, la clase SimpleDateFormat provee una forma de formatear fechas, formatos que pueden usarse con los objetos Date mediante el método format().

Date hoy = new Date();

// = Thu Oct 07 06:57:10 UTC 2021
System.out.println(hoy);

SimpleDateFormat formatoFecha = new SimpleDateFormat("dd-MM-yyyy");

// = 07-10-2021
System.out.println(formatoFecha.format(hoy));

Para usar la clase es necesario importar lo siguiente:

import java.util.Date;

Calendar

La clase Calendar contiene varias utilidades para manejar fechas, basados en un calendario.

Obtenemos una instancia del objeto calendario mediante el método getInstance().

El objeto Calendario tiene varios atributos para obtener información como el día, el mes o el año.

Calendar calendarioHoy = Calendar.getInstance();
System.out.println(calendarioHoy);

String fechaActual = calendarioHoy.get(Calendar.DAY_OF_MONTH) + " de ";
fechaActual += (calendarioHoy.get(Calendar.MONTH)+1) + " de ";
fechaActual += calendarioHoy.get(Calendar.YEAR);

// = 7 de 10 de 2021
System.out.println(fechaActual);

Para usar la clase es necesario importar lo siguiente:

import java.util.Calendar;
import java.text.SimpleDateFormat;

Conclusión

En esta práctica aprendimos muchas cosas nuevas sobre Java: más estructuras de control, y empezamos a ver las primeras utilidades que nos provee la API de Java. También empezamos a ver la diferencia entre los objetos primitivos, que son herencia de C, y los objetos, que forman parte del paradigma de la programación orientada a objetos.

Referencias