String, StringBuilder y StringBuffer (Objetivo 3.1):
Un String es un objeto inmutable, una vez que el mismo se creó, no puede ser modificado. Cuando se realiza una concatenación de dos String, lo que hace la JVM es crear un nuevo objeto String con el valor de las dos cadenas concatenadas. Cuando se invoca un método del objeto String (por ej.: toUpperCase()), el método devuelve un nuevo objeto String con su correspondiente valor, no se modifica el valor original del String (con el que se invoco el método).
Algunos métodos de los objetos String:
- public char charAt(int index): Devuelve el carácter alojado en el índice pasado como parámetro.
- public String concat(String s): Agrega un String al final de otro (como el operador ‘+’).
- public boolean equalsIgnoreCase(String s): Determina la igualdad de dos String, ignorando las diferencias de mayúsculas y minúsculas.
- public int length(): Devuelve la cantidad de caracteres que componen un String.
- public String replace(char old, char new): Reemplaza las ocurrencias de un carácter con otro nuevo.
- public String substring(int begin) - public String substring(int begin, int end): Devuelve una parte de un String.
- public String toLowerCase(): Devuelve el String con todos los caracteres convertidos a minúsculas.
- public String toUpperCase(): Devuelve el String con todos los caracteres convertidos a mayúsculas.
- public String trim(): Remueve los espacios en blanco del principio y final del String.
La clase StringBuilder (agregada en Java 5), posee exactamente los mismos métodos que la clase StringBuffer. La única diferencia entre ellas, es que la clase StringBuilder es más rápida debido a que sus métodos no están sincronizados. Estas dos clases se utilizan para realizar muchas modificaciones sobre los caracteres de una cadena. Los objetos de estas clases no crean un nuevo objeto cada vez que se modifican (como los objetos String), es por esto que son más eficientes para realizar muchas modificaciones sobre cadenas.
Algunos métodos de los objetos StringBuilder y StringBuffer:
- public synchronized StringBuffer append(String s)
- public StringBuilder delete(int start, int end)
- public StringBuilder insert(int offset, String s)
- public synchronized StringBuffer reverse()
- public String toString()
Resumen (TWO-MINUTE DRILL):
- Los objetos String son inmutables, pero las referencias a String no lo son.
- Si se crea un nuevo objeto String, pero no se asigna a una variable de referencia, el mismo se pierde para el programa.
- Si se redirecciona una variable referencia a un nuevo objeto String, el objeto String anterior se pierde.
- Los métodos de objetos String utilizan los índices basados en cero, excepto el método substring(), el cuál utiliza su segundo argumento basado en uno.
- La clase String es final, sus métodos no pueden ser sobreescritos.
- Cuando la JVM encuentra un literal String, este se agrega al “String literal pool”.
- Los objetos String poseen el método length(), los arreglos poseen la propiedad length.
- La API de la clase StringBuffer es la misma que la de StringBuilder, salvo que los métodos de esta última no se encuentran sincronizados.
- Los métodos de los objetos StringBuilder son más rápidos que los de StringBuffer.
- Los siguientes puntos se aplican a ambas clases (StringBuilder y StringBuffer):
- Son mutables, pueden cambiar su valor sin crear un nuevo objeto.
- La invocación de sus métodos cambian el valor del objeto, sin realizar ninguna asignación explícita.
- El método equals() no está sobreescrito, no compara los valores.
- La encadenación de métodos se evalúa de izquierda a derecha.
Ejemplo: Main01.java
public class Main01 {
public static void main(String[] args) {
String s1 = new String("Matias Emiliano Alvarez Duran");
String s2 = "Lucas Mariano";
String s3 = s1;
System.out.println("nCLASE: String");
System.out.println("s1: " + s1);
System.out.println("s2: " + s2);
System.out.println("s3: " + s3);
System.out.println("s2.concat(s1.substring(15)): " + s2.concat(s1.substring(15)));
System.out.println("s1.charAt(3): " + s1.charAt(3));
System.out.println("s1.toLowerCase().equalsIgnoreCase(s3.toUpperCase()): " + s1.toLowerCase().equalsIgnoreCase(s3.toUpperCase()));
System.out.println("s1.length(): " + s1.length());
System.out.println("(s3 = s3.substring(7, 15)): " + (s3 = s3.substring(7, 15)));
System.out.println("s1: " + s1);
System.out.println("s2: " + s2);
System.out.println("s3: " + s3);
/*******************************************************************/
StringBuffer sb1 = new StringBuffer("0123456789");
StringBuilder sb2 = new StringBuilder("0123456789");
System.out.println("nCLASE: StringBuffer y StringBuilder");
System.out.println("sb1: " + sb1);
System.out.println("sb2: " + sb2);
System.out.println("sb1.append(sb2): " + sb1.append(sb2));
System.out.println("sb1.delete(4, 9): " + sb1.delete(4, 9));
System.out.println("sb1.insert(4, "45678"): " + sb1.insert(4, "45678"));
System.out.println("sb2.reverse().toString(): " + sb2.reverse().toString());
System.out.println("sb1: " + sb1);
System.out.println("sb2: " + sb2);
}
}
/*
SALIDA:
CLASE: String
s1: Matias Emiliano Alvarez Duran
s2: Lucas Mariano
s3: Matias Emiliano Alvarez Duran
s2.concat(s1.substring(15)): Lucas Mariano Alvarez Duran
s1.charAt(3): i
s1.toLowerCase().equalsIgnoreCase(s3.toUpperCase()): true
s1.length(): 29
(s3 = s3.substring(7, 15)): Emiliano
s1: Matias Emiliano Alvarez Duran
s2: Lucas Mariano
s3: Emiliano
CLASE: StringBuffer y StringBuilder
sb1: 0123456789
sb2: 0123456789
sb1.append(sb2): 01234567890123456789
sb1.delete(4, 9): 012390123456789
sb1.insert(4, "45678"): 01234567890123456789
sb2.reverse().toString(): 9876543210
sb1: 01234567890123456789
sb2: 9876543210
*/
File e I/O (Objetivo 3.2):
Clases que se necesitan saber para el examen:
- File: Es una representación abstracta de un archivo o directorio. Esta clase no se utiliza para escribir o leer datos, si no para trabajar a alto nivel. Es decir, para crear, buscar, eliminar archivos y para trabajar con directorios y rutas.
- FileReader: Esta clase se usa para leer caracteres de un archivo. Tiene un método read() de bajo nivel, el cual se puede utilizar para leer un simple carácter, un flujo entero de caracteres, o un número especifico de caracteres.
- BufferedReader: Esta clase se utiliza para hacer más eficientes las clases de bajo nivel como FileReader. Permite leer grandes cantidades de información de un archivo de una sola vez, y almacenar los datos en un buffer. De este modo cada vez que se necesite obtener la información, se obtendrá desde el buffer minimizando así los accesos a disco. También provee el método readLine().
- FileWriter: Esta clase se usa para escribir caracteres en un archivo. Posee el método write() que permite escribir caracteres o Strings a un archivo.
- BufferedWriter: Se utiliza para hacer más eficientes y más fácil de utilizar las clases de bajo nivel como FileWriter. Esta clase escribe grandes cantidades de información a un archivo de una vez, minimizando el número de operaciones de escritura. También provee el método writeLine(), el cual añade los caracteres de salto de línea correspondientes a la plataforma en la que se ejecuta.
- PrintWriter: Envuelve las clases FileWriter y BufferedWriter. Añade varios métodos como format(), printf() y append() que brindan mayor flexibilidad y poder.
Cuando se crea una instancia de la clase File, solo se está creando el nombre de un archivo. Esta clase contiene métodos de utilidad para realizar operaciones sobre archivos y directorios:
- public boolean exists(): Devuelve true si el archivo existe.
- public boolean createNewFile(): Crea un nuevo archivo, si el mismo no existe.
- public boolean mkdir(): Crea un nuevo directorio, si el mismo no existe.
- public boolean delete(): Elimina un archivo o directorio. No se puede eliminar directorios si los mismos no se encuentran vacios.
- public boolean renameTo(): Se pasa como argumento una instancia de File con el nuevo nombre del archivo.
- public String[] list(): Devuelve un arreglo de String’s con los archivos y directorios contenidos en la ubicación actual.
La clase Console permite aceptar entradas desde la línea de comandos. El método readLine() devuelve un String que contiene lo que el usuario haya ingresado. El método readPassword() devuelve un arreglo de caracteres que contienen el password solicitado. La clase Console no se puede instanciar a través de su constructor. Para obtener una instancia se debe invocar el método estático System.console().
Resumen (TWO-MINUTE DRILL):
- Las clases que se deben entender del paquete java.io son: File, FileReader, BufferedReader, FileWriter, BufferedWriter, PrintWriter y Console.
- Cuando se crea un nuevo objeto File, no significa que se crea un nuevo objeto.
- Un objeto File puede representar tanto un archivo como un directorio.
- La clase File permite administrar (crear, renombrar y eliminar) archivos y directorios.
- Los métodos createNewFile() y mkdir() agregan archivos y directorios al sistema de archivos.
- FileWriter y FileReader son clases I/O de bajo nivel. Se pueden utilizar para escribir y leer archivos, pero generalmente se envuelven en clases con mayor funcionalidad.
- Es muy común envolver un objeto FileReader con una instancia de BufferedReader o una instancia de FileWriter con una de BufferedWriter, para tener métodos más eficientes y de alto nivel.
- Los objetos PrintWriter’s pueden ser utilizados para envolver tipos Writer, pero desde Java 5 pueden ser instanciados directamente desde instancias File o String.
- La clase PrintWriter desde Java 5 posee nuevos métodos: append(), format() y printf().
Ejemplo: Main02.java
import java.io.*;
public class Main02 {
static void showFile(File file) {
System.out.println("ARCHIVO: " + file);
FileReader fr = null;
try {
fr = new FileReader(file);
} catch (FileNotFoundException e) {
System.out.println("NO SE ENCONTRO EL ARCHIVO " + file + ".");
System.out.println(e);
}
if (fr != null) {
BufferedReader br = new BufferedReader(fr);
try {
String line = null;
while((line = br.readLine()) != null)
System.out.println(line);
} catch (IOException e) {
System.out.println(e);
}
}
System.out.println();
}
public static void main(String[] args) {
File dir = new File("Directorio");
File sub = new File(dir, "Subdirectorio");
File archivo1 = new File(dir, "archivo1.txt");
File archivo2 = new File(sub, "archivo2.txt");
System.out.println("dir.mkdir() = " + dir.mkdir());
System.out.println("sub.mkdir() = " + sub.mkdir());
try {
System.out.println("archivo1.createNewFile() = " + archivo1.createNewFile());
System.out.println("archivo2.createNewFile() = " + archivo2.createNewFile());
} catch (IOException e) {
System.out.println("Imposible crear archivos: " + archivo1 + " y " + archivo2);
System.out.println(e);
}
File otroArchivo = new File(dir, "otroArchivo.txt");
System.out.println("archivo2.exists() = " + archivo2.exists());
System.out.println("archivo2.delete() = " + archivo2.delete());
System.out.println("archivo2.exists() = " + archivo2.exists());
System.out.println("archivo1.renameTo(otroArchivo) = " + archivo1.renameTo(otroArchivo));
System.out.println();
System.out.println();
/*****************************************************************/
File file = new File(dir, "archivo_File.txt");
PrintWriter pw1 = null;
try {
pw1 = new PrintWriter(file);
} catch (FileNotFoundException e) {
System.out.println("NO SE ENCONTRO EL ARCHIVO archivo_File.txt");
System.out.println(e);
}
if (pw1 != null) {
pw1.println("pw1.println("Desde un PrintWriter inicializado con un File");");
pw1.print("pw1.print(""); --- ");
pw1.write("pw1.write("");");
pw1.flush();
pw1.close();
}
/*****************************************************************/
PrintWriter pw2 = null;
try {
pw2 = new PrintWriter("archivo_String.txt");
} catch (FileNotFoundException e) {
System.out.println("NO SE ENCONTRO EL ARCHIVO archivo_String.txt");
System.out.println(e);
} catch (Exception e) {
System.out.println("ERROR EN EL ARCHIVO archivo_String.txt");
System.out.println(e);
}
if (pw2 != null) {
pw2.println("pw2.println("Desde un PrintWriter inicializado con un String");");
pw2.print("pw2.print(""); --- ");
pw2.write("pw2.write("");");
pw2.flush();
pw2.close();
}
/*****************************************************************/
File file2 = new File(dir, "archivo_Writer.txt");
FileWriter fw = null;
PrintWriter pw3 = null;
try {
fw = new FileWriter(file2);
pw3 = new PrintWriter(fw);
} catch (FileNotFoundException e) {
System.out.println("NO SE ENCONTRO EL ARCHIVO archivo_Writer.txt");
System.out.println(e);
} catch (IOException e) {
System.out.println("NO SE PUDO CREAR EL ARCHIVO archivo_Writer.txt");
System.out.println(e);
}
if (pw3 != null) {
pw3.println("pw3.println("Desde un PrintWriter inicializado con un Writer");");
pw3.print("pw3.print(""); --- ");
pw3.write("pw3.write("");");
pw3.flush();
pw3.close();
}
/*****************************************************************/
showFile(file);
showFile(new File("archivo_String.txt"));
showFile(file2);
System.out.println("nLIST");
for (String s : dir.list())
System.out.println(s);
}
}
/*
SALIDA:
dir.mkdir() = true
sub.mkdir() = true
archivo1.createNewFile() = true
archivo2.createNewFile() = true
archivo2.exists() = true
archivo2.delete() = true
archivo2.exists() = false
archivo1.renameTo(otroArchivo) = true
ARCHIVO: Directorioarchivo_File.txt
pw1.println("Desde un PrintWriter inicializado con un File");
pw1.print(""); --- pw1.write("");
ARCHIVO: archivo_String.txt
pw2.println("Desde un PrintWriter inicializado con un String");
pw2.print(""); --- pw2.write("");
ARCHIVO: Directorioarchivo_Writer.txt
pw3.println("Desde un PrintWriter inicializado con un Writer");
pw3.print(""); --- pw3.write("");
LIST
archivo_File.txt
archivo_Writer.txt
otroArchivo.txt
Subdirectorio
*/
Serialización (Objetivo 3.3):
La serialización permite guardar el estado de un objeto (es decir, todas sus variables de instancia). Si una variable de instancia tiene el especificador transient, la misma no será almacenada por el proceso de serialización.
Para que un objeto pueda ser serializado, el mismo debe implementar la interface Serializable (dicha interface no posee métodos para implementar, solo es un marcador). Un objeto serializado se almacena en un archivo de bytes, se utilizan dos métodos que permiten leer y escribir un stream de datos.
- ObjectOutputStream.writeObject()
- ObjectInputStream.readObject()
Ambas clases son envoltorios de las clases FileOutputStream y FileInputStream. Los métodos writeObject() y readObject() trabajan con objetos de tipo Serializable.
Cuando se intenta serializar un objeto (Serializable) que contiene (relación TIENE-UN) una referencia a otro tipo de objeto pueden ocurrir ciertas situaciones:
- Si el objeto contenido no implementa la interface Serializable: Se produce la siguiente excepción en tiempo de ejecución NoSerializableException.
- Si la variable de referencia al objeto contenido está marcada con el especificador transient: Se serializa el estado del objeto contenedor, dejando de lado el estado del objeto contenido.
- Si la clase del objeto contenido implementa la interface Serializable: Se guarda todo el estado completo del objeto. Es decir, cuando se deserialice el estado del objeto contenedor, también se recuperará el estado del objeto contenido.
El proceso de serialización de Java posee un mecanismo especial para los objetos que son especiales y difíciles de guardar. Se trata de un conjunto de métodos privados que se pueden implementar en la clase en cuestión. Si dichos métodos concuerdan con la signatura exacta, se invocarán durante el proceso de serialización y deserialización del objeto. Las signaturas son las siguientes:
- private void writeObject (ObjectOutputStream os) { }
- private void readObject (ObjectInputStream is) { }
Gracias a estos dos métodos es posible manejar el proceso de serialización. Esto se puede realizar debido a que los objetos ‘os’ e ‘is’ tienen un conjunto de métodos para invocar el proceso de serialización por defecto y además métodos para almacenar y leer datos adicionales.
Proceso de serialización por defecto:
- ObjectOutputStream.defaultWriteObject()
- ObjectInputStream.defaultReadObject()
Métodos para almacenar y leer datos adicionales:
- ObjectOutputStream.writeInt()
- ObjectOutputStream.writeFloat()
- ObjectInputStream.readInt()
- ObjectInputStream.readFloat()
La herencia también se ve afectada por el proceso de serialización. Cuando una clase base implementa la interface Serializable, hace que todas sus subclases también la implementen.
El problema real se da cuando una clase base no es Serializable pero una de sus clases hijas si lo es. Esta situación produce que se serialice solo el estado de la clase hija, dejando de lado todas las variables de instancia de la clase base. Para que este escenario sea posible, la clase base debe poseer un constructor por defecto. En caso contrario se producirá un error en tiempo de ejecución a la hora de deserializar el objeto, ya que se intentará invocar automáticamente el constructor por defecto de clase base.
Resumen (TWO-MINUTE DRILL):
- Las clases que se necesitan conocer del paquete java.io son: ObjectInputStream, ObjectOutputStream, FileInputStream, FileOutputStream.
- Una clase debe implementar la interface Serializable antes de poder ser serializada.
- El método ObjectOutputStream.writeObject() serializa los objetos, y el método ObjectInputStream.readObject() deserializa los objetos.
- Si una variable de instancia es marcada con el especificador transient, la misma no será serializada, aunque todas las demás variables de instancia si lo hagan.
- Si una superclase implementa la interface Serializable, entonces las subclases lo hacen automáticamente.
- Si una superclase no implementa Serializable, cuando una subclase se deserializa, se invoca el constructor por defecto de la clase padre.
- DataInputStream y DataOutputStream no se toman en el examen.
Ejemplo: Main03.java
import java.io.*;
import java.util.*;
class ClaseBase {
private int vInt;
private float vFloat;
public ClaseBase() {
vInt = 10;
vFloat = 0.5734f;
}
public void change() {
vInt *= 2;
vFloat *= 3;
}
public String toString() {
return "vInt: " + vInt + " - vFloat: " + vFloat;
}
}
class ClaseDerivada extends ClaseBase implements Serializable {
private String clase;
private int ano;
private transient Persona persona;
public ClaseDerivada(String c, int a) {
clase = c;
ano = a;
}
public void setPersona(Persona p) { persona = p; }
public String toString() {
return "clase: " + clase + " - ano: " + ano + "nsuper: " + super.toString() + "npersona: " + persona;
}
private void writeObject(ObjectOutputStream os) {
try {
os.defaultWriteObject();
os.writeUTF(persona.getNombres());
os.writeUTF(persona.getApellidos());
} catch (Exception e) {
System.out.println(e);
}
}
private void readObject(ObjectInputStream is) {
try {
is.defaultReadObject();
persona = new Persona(is.readUTF(), is.readUTF(), 22L, 100);
} catch (Exception e) {
System.out.println(e);
}
}
}
class Persona implements Serializable {
private String nombres;
private String apellidos;
private Long dni;
private Integer anoNacimiento;
public Persona(String n, String a, Long d, Integer o) {
nombres = n;
apellidos = a;
dni = d;
anoNacimiento = o;
}
public String toString() {
return apellidos + ", " + nombres + " - dni: " + dni + " - fecha nac.: " + anoNacimiento;
}
public String getNombres() { return nombres; }
public String getApellidos() { return apellidos; }
public void setNombres(String n) { nombres = n; }
public void setApellidos(String a) { apellidos = a; }
}
public class Main03 {
public static void main(String[] args) {
List<Persona> lista = new ArrayList<Persona>();
lista.add(new Persona("Alvarez Duran", "Matias Emiliano", 33273444L, 1987));
lista.add(new Persona("Alvarez Duran", "Lucas Mariano", 32323424L, 1986));
lista.add(new Persona("Gosling", "James", 11295833L, 1950));
lista.add(new Persona("Gonzales", "Nicolas", 31563444L, 1985));
lista.add(new Persona("Garcia", "Juan Martin", 20273444L, 1977));
ClaseDerivada cd = new ClaseDerivada("ClaseDerivada1", 2009);
cd.setPersona(new Persona("Federer", "Roger", 20111044L, 1981));
cd.change();
System.out.println("n" + lista);
System.out.println("n" + cd);
try {
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("lista.ser"));
oos.writeObject(lista);
oos.close();
oos = new ObjectOutputStream(new FileOutputStream("cd.ser"));
oos.writeObject(cd);
oos.close();
} catch (Exception e) {
System.out.println("NO SE PUDO GUARDAR LA LISTA - " + e);
}
lista = null;
cd = null;
lista = new LinkedList<Persona>();
Persona p = null;
try {
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("lista.ser"));
lista = (ArrayList<Persona>) ois.readObject();
ois.close();
ois = new ObjectInputStream(new FileInputStream("cd.ser"));
cd = (ClaseDerivada) ois.readObject();
ois.close();
} catch (Exception e) {
System.out.println("NO SE PUDO CARGAR LA LISTA - " + e);
}
System.out.println("n" + lista);
System.out.println("n" + cd);
}
}
/*
SALIDA:
[Matias Emiliano, Alvarez Duran - dni: 33273444 - fecha nac.: 1987, Lucas Marian
o, Alvarez Duran - dni: 32323424 - fecha nac.: 1986, James, Gosling - dni: 11295
833 - fecha nac.: 1950, Nicolas, Gonzales - dni: 31563444 - fecha nac.: 1985, Ju
an Martin, Garcia - dni: 20273444 - fecha nac.: 1977]
clase: ClaseDerivada1 - ano: 2009
super: vInt: 20 - vFloat: 1.7202001
persona: Roger, Federer - dni: 20111044 - fecha nac.: 1981
[Matias Emiliano, Alvarez Duran - dni: 33273444 - fecha nac.: 1987, Lucas Marian
o, Alvarez Duran - dni: 32323424 - fecha nac.: 1986, James, Gosling - dni: 11295
833 - fecha nac.: 1950, Nicolas, Gonzales - dni: 31563444 - fecha nac.: 1985, Ju
an Martin, Garcia - dni: 20273444 - fecha nac.: 1977]
clase: ClaseDerivada1 - ano: 2009
super: vInt: 10 - vFloat: 0.5734
persona: Roger, Federer - dni: 22 - fecha nac.: 100
*/
Fechas, números y monedas (Objetivo 3.4):
Clases que se necesitan saber para el examen:
- java.util.Date: La mayoría de los métodos de esta clase están depreciados. Pero esta clase es útil como puente entre Calendar y DateFormat.
- java.util.Calendar: Provee una gran variedad de métodos que ayudan a convertir y manipular fechas y tiempos.
- java.text.DateFormat: Esta clase se utiliza no solo para formatear fechas en varios estilos, sino también para formatear fechas de varias localidades del planeta.
- java.text.NumberFormat: Esta clase se utiliza para formatear números y monedas para varias localidades del planeta.
- java.util.Locale: Esta clase se utiliza junto con DateFormat y NumberFormat para formatear fechas, números y monedas para una localidad específica.
Resumen (TWO-MINUTE DRILL):
- Las clases que se necesitan saber para este objetivo son: java.util.Date, java.util.Calendar, java.text.DateFormat, java.text.NumberFormat y java.util.Locale.
- La mayoría de los métodos de la clase Date están depreciados.
- Dentro de una instancia Date, la fecha se almacena como un valor long, la cantidad de milisegundos desde el 1ro de Enero de 1970.
- Los objetos Date son utilizados con instancias Calendar y Locale.
- La clase Calendar provee un poderoso conjunto de métodos para manipular fechas, realizar tareas como obtener los días de la semana, o agregar un numero de meses o años (u otros tipos de incrementos) a una fecha.
- Para crear una instancia de la clase Calendar, se debe invocar el método estático (getInstance()).
- Los métodos de Calendar que se deben conocer son:
- add(): Permite adicionar o sustraer varias piezas (minutos, días, horas, etc.) de fechas.
- roll(): Funciona al igual que add(), a diferencia que no incrementa las piezas más grandes de la fecha.
- Para crear instancias de la clase DateFormat, se deben utilizar los métodos estáticos getInstance() y getDateInstance().
- Existen diferentes estilos disponibles en la clase DateFormat.
- El método DateFormat.format() se utiliza para crear String que contienen fechas formateadas.
- La clase Locale se utiliza conjuntamente con las clases DateFormat y NumberFormat.
- Las instancias de DateFormat y NumberFormat pueden ser creadas con un objeto Locale específico, el cuál es inmutable.
- Para el examen se debe saber cómo crear objetos Locale utilizando el leguaje, o la combinación de lenguaje y país.
Ejemplo: Main04.java
import java.text.*;
import java.util.*;
public class Main04 {
public static void main(String[] args) {
System.out.println("new Date(): " + new Date());
Calendar c = Calendar.getInstance();
c.setTime(new Date());
c.add(Calendar.HOUR, -4);
System.out.println("c.add(Calendar.HOUR, -4): " + c.getTime());
c.add(Calendar.YEAR, 2);
System.out.println("c.add(Calendar.YEAR, 2): " + c.getTime());
System.out.println("DateFormat.getDateInstance(DateFormat.SHORT).format(c.getTime()): " + DateFormat.getDateInstance(DateFormat.SHORT).format(c.getTime()));
System.out.println("DateFormat.getDateInstance(DateFormat.MEDIUM).format(c.getTime()): " + DateFormat.getDateInstance(DateFormat.MEDIUM).format(c.getTime()));
System.out.println("DateFormat.getDateInstance(DateFormat.FULL, new Locale("it")).format(c.getTime()): " + DateFormat.getDateInstance(DateFormat.FULL, new Locale("it")).format(c.getTime()));
Locale es_AR = new Locale("es", "AR");
Locale en_US = new Locale("en", "US");
DateFormat df1 = DateFormat.getDateInstance(DateFormat.FULL, es_AR);
DateFormat df2 = DateFormat.getDateInstance(DateFormat.FULL, en_US);
System.out.println("df1.format(c.getTime()): " + df1.format(c.getTime()));
System.out.println("df2.format(c.getTime()): " + df2.format(c.getTime()));
float f = 123.4567f;
System.out.println("NumberFormat.getCurrencyInstance(es_AR).format(f): " + NumberFormat.getCurrencyInstance(es_AR).format(f));
System.out.println("NumberFormat.getCurrencyInstance(en_US).format(f): " + NumberFormat.getCurrencyInstance(en_US).format(f));
System.out.println("NumberFormat.getInstance(es_AR).format(f): " + NumberFormat.getInstance(es_AR).format(f));
System.out.println("NumberFormat.getInstance(en_US).format(f): " + NumberFormat.getInstance(en_US).format(f));
}
}
/*
SALIDA:
new Date(): Mon Aug 17 20:06:14 ART 2009
c.add(Calendar.HOUR, -4): Mon Aug 17 16:06:14 ART 2009
c.add(Calendar.YEAR, 2): Wed Aug 17 16:06:14 ART 2011
DateFormat.getDateInstance(DateFormat.SHORT).format(c.getTime()): 17/08/11
DateFormat.getDateInstance(DateFormat.MEDIUM).format(c.getTime()): 17/08/2011
DateFormat.getDateInstance(DateFormat.FULL, new Locale("it")).format(c.getTime()
): mercoledý 17 agosto 2011
df1.format(c.getTime()): miÚrcoles 17 de agosto de 2011
df2.format(c.getTime()): Wednesday, August 17, 2011
NumberFormat.getCurrencyInstance(es_AR).format(f): $123,46
NumberFormat.getCurrencyInstance(en_US).format(f): $123.46
NumberFormat.getInstance(es_AR).format(f): 123,457
NumberFormat.getInstance(en_US).format(f): 123.457
*/
Parseo, Tokenizing y Formateo (Objetivo 3.5):
Resumen (TWO-MINUTE DRILL):
- Las expresiones regulares, son patrones utilizados para buscar información dentro de grandes fuentes de datos.
- Las expresiones regulares, son un sub-lenguaje que existe dentro de Java.
- Las expresiones regulares permiten crear patrones de búsqueda mediante caracteres o metacaracteres. Los metacaracteres permiten buscar información más abstracta como dígitos o espacios en blanco.
- Los metacaracteres utilizados en el examen son: ‘d’, ‘w’, ‘s’ y ‘.’.
- Los cuantificadores utilizados en el examen son: ‘?’, ‘*’ y ‘+’.
- Los metacaracteres deben ser escapados dentro de los Strings. String s = “d”.
- Las clases Pattern y Matcher poseen las capacidades más poderosas de Java para las expresiones regulares.
- Los métodos que son utilizados en el examen son:
- Pattern: compile()
- Matcher: matches(), pattern(), find(), start() y group().
- Tokenizing es el proceso de dividir información delimitada en pequeñas piezas.
- El proceso Tokenizing se puede llevar a cabo mediante la clase Scanner o a través del método String.split().
- Los delimitadores pueden ser caracteres simples como una coma, o expresiones regulares.
- La clase Scanner permite dividir información dentro de un bucle, pero también permite parar este proceso en cualquier parte (a diferencia del método String.split() el cuál debe procesar todos los datos de una vez para obtener un resultado).
- La clase Scanner permite dividir Strings, streams (flujos de datos) o archivos.
- A partir de Java 5 se encuentran disponibles los métodos format() y printf(). Los cuales pertenecen a la clase PrintWriter. Ambos métodos poseen la misma funcionalidad, formatear una salida.
- %[arg_index$][flags][ancho][.precision]carcter de conversión
- Flags: ‘-‘, ‘+’, ‘0’, ‘,’ y ‘(‘.
- Conversiones: b, c, d, f y s.
- Si en carácter de conversión no concuerda con el tipo de argumento, se lanza una excepción.
Ejemplo: Main05.java
import java.util.*;
public class Main05 {
static Formatter f = new Formatter(System.out);
public static void showCabecera() {
f.format("| %1$-20s | %1$-20s | %2$-10s | %2$-10s |n", "--------------------", "----------");
f.format("| %-20s | %-20s | %-10s | %-10s |n", "Nombre", "Direccion", "Telefono", "Sueldo");
f.format("| %1$-20s | %1$-20s | %2$-10s | %2$-10s |n", "--------------------", "----------");
}
public static void showContacto(String nom, String dir, Long tel, Float sue) {
f.format("| %-20.20s | %-20.20s | %10d | %010.3f |n", nom, dir, tel, sue);
}
public static void main(String[] args) {
System.out.println("--- LISTADO DE EMPLEADOS ---");
showCabecera();
showContacto("Matias Emiliano Alvarez Duran", "Chaco 2961", 4738205L, 4650.5466f);
showContacto("Lucas Mariano Alvarez Duran", "San Juan 661 3A", 4745432L, 1650.33456f);
showContacto("Nicolas Ezequiel Garcia", "Guido 2345", 4723433L, 2000f);
showContacto("Martin Enrique Juarez", "Buenos Aires 2234", 4941882L, 700.50343f);
String nota = String.format("n| %69s |", "NOTA: Los sueldos estan expresados en sueldo neto por mes."); // Método sprintf() de C.
System.out.println(nota);
}
}
/*
SALIDA:
--- LISTADO DE EMPLEADOS ---
| -------------------- | -------------------- | ---------- | ---------- |
| Nombre | Direccion | Telefono | Sueldo |
| -------------------- | -------------------- | ---------- | ---------- |
| Matias Emiliano Alva | Chaco 2961 | 4738205 | 004650,546 |
| Lucas Mariano Alvare | San Juan 661 3A | 4745432 | 001650,335 |
| Nicolas Ezequiel Gar | Guido 2345 | 4723433 | 002000,000 |
| Martin Enrique Juare | Buenos Aires 2234 | 4941882 | 000700,503 |
| NOTA: Los sueldos estan expresados en sueldo neto por mes. |
*/
¡Hola! Soy Javier. Soy informático y me gusta documentar todo lo que aprendo. En mi blog te enseño todo lo que sé y cómo puedes aprender a crear tu propia web, mejorar el SEO y aplicar técnicas de Marketing Digital para conseguir mayor visibilidad. Suscríbete para no perderte ninguna de mis guías sobre WordPress, posicionamiento SEO o Marketing Digital.
Trackbacks/Pingbacks