Resumen SCJP

String , StringBuilder y StringBuffer

StringBuilder provee acceso no-sincronizado. Tiene exactamente los mismos metodos
que StringBuffer, pero StringBuilder es mas rapida ya que sus mentodos no son
sincronizados.
La clase String
Los Strip son objetos inmutables. na vez que se le a asignado u valor a un String este
ya nunca cambia, la referencia Si puede cambiar.
!n java cada car"cter en un string es un car"cter #$-bit nicode .
%odemos crear String&
String s ' ne( String)*+
s ' ,pepe-+

String s ' ne( String),pepe-*+
String s ' ,pepe-
%or ej
String s ' ,abcdef-+
s = s.concat(" more stuff");
Ahora s referencia al valor "abcdef more stuff", pero este es un nuevo valor,
NO es el antiguo modificado.
Otro ej.
String x = "Java";
x.concat(" Rules!");
System.out.println("x = " + x); // the output is "x = Java"

Notar que el valor al que referencia x no cambio.
String y la memoria
La ./0 tiene un area de memoria llamada pool de String, cuando el compilador
encuentra un literal string, el c1equea el pool para ver si ya esta, si es asi la referencia al
nuevo literal es dirigida al que ya existe, y asi no se crea otro String.
2reacion de nuevos String
String s = "abc"; // creates one String object and one reference variable
String s = new String("abc"); // creates two objects, and one reference
//variable
3l usar la 4ey(ord ne(, se crea un 5uevo objeto String en la memoria normal )no n el
pool* , ademas el literal ,abc- es colocado en el pool.

Metodos Importantes de la clase String
public char charAt() Returns the character located at the specified index
public String concat() Appends one String to the end of another ( "+" also works)
public boolean equalsIgnoreCase() Determines the equality of two Strings ignoring case
public int length() Returns the num!er of characters in a String
public String replace() Replaces occurrences of a character with a new character
public String substring(int begin) Returns a part of a String
public String substring(int begin, int end) Returns a part of a String
public String toLowerCase() Returns a String with uppercase characters con"erted
public String toString() Returns the "alue of a String
public String toUpperCase() Returns a String with lowercase characters con"erted
public String trim() Remo"es whitespace from the ends of a String
StringBuffer y StringBuilder
!stas clases deben ser usadas cuando se tienen que modificar los string.
6ebido a que los String son inmutables, si se realizan modificaciones, se estar"n
creando strings en el pool de string, lo que resulta ineficiente.
!s por esto que se utilizan StringBuffer y StringBuilder ya que estas pueden ser
modificadas.
3lgo que es importante es que estas clases no sobrescriben el metodo equals)*
StringBuffer vs StringBuilder
La clase StringBuilder fue agregada en la java 7, tiene exactamente la misma 3%8 que
StringBuffer, excepto que StringBuilder es no t1read-Safe. Sus metodos 59 son
sync1ronized.
6ebido a lo anterior StringBuilder se ejecuta mas r"pido.
Metodos Importantes en StringBuffer y StringBuilder
public synchronized StringBuffer append(String s)
!ste metodo actualize el valor del objeto que invoca.
!ste metodo puede tomar diferentes argumentos )boolean,c1ar,double,float,int y otros*
StringBuffer sb = new StringBuffer("set ");
sb.append("point");
System.out.println(sb); // output is "set point"
public StringBuilder delete(int start, int end)
!l indice inicial es zero-base el final 59.
StringBuilder sb = new StringBuilder("0123456789");
System.out.println(sb.delete(4,6)); // output is "01236789"
public StringBuilder insert(int offset, String s)
!l arg offset es zero-based.
StringBuilder sb = new StringBuilder("01234567");
sb.insert(4, "---");
System.out.println( sb ); // output is "0123---4567"
public synchronized StringBuffer reverse()
public String toString()
NAVEGACION DE ARCHIVO Y I/O

Sumario de clases&
File: !s una representaci:n abstracta de un arc1ivo y pat1name de directorios.
La clase ;ile 59 es usada para leer o escribir un dato, ella es usada para trabajar en un
nivel superior, crear nuevos arc1ivos vacios, busqueda de arc1ivos, eliminaci:n de
arc1ivos, creaci:n de directorios y trabajo con pat1s.
FileReader& !sta clase es usada para leer arc1ivos de caracteres. Su metodo read)* es de
bajo nivel, permitiendo leer solo caracteres, el conjunto de stream de caracteres, o un
numero fijo de caracteres. !stos com<nmente son (rappeados por un objeto de nivel
superior como Buffered=eader, el cual provee performance y una manera mas
conveniente de trabajar con los datos.
BufferedReader& !sta clase es usada para 1acer una clase =eader de nivel inferior tal
como ;ile=eader pero mas eficiente y facil de usar.
2omparados con los ;ile=eader, los Buffered=eader leen relativamente grandes
,pedazos- de datos de un arc1ivo enseguida, y mantienen sus datos en un buffer.
2uando se recupera el proximo car"cter de la linea de datos, este es recuperado del
buffer, lo cual minimiza el numero de read del arc1ivo.
3dem"s provee metodos como readLine)* que permiten tomar la pr:xima linea de
caracteres de un arc1ivo.
;ile>riter& !sta clase es usada para escribir en un arc1ivo de caracteres.
Su metodo (rite)* permite escribir caracteres o Strings a un arc1ivo.
!sta clase es usualmente (rappeada por una clase de nivel superior tal como
Buffered>riter o %rint>riter.
BufferedWriter: !sta clase es usada para 1acer una clase >riter de nivel inferior tal
como ;ile>riter pero mas eficiente y f"cil de usar.
2omparado con ;ile>riter, Buffered>riter escriben relativamente grandes ,pedazos-
de datos de una sola vez, minimizando el numero de operaciones (rite.
3dem"s provee m?todos como ne(Line)* que crea um separador de linea.
PrintWriter: !sta clase a sido mejorada em la java 7, provee m?todos como format)*,
printf)*, append)*.

59T3&
L@s clases Stream son usadas para leer y escribir bytes, y las =eaders y >riters para leer
y escribir caracteres.
Creando Archivos usando la clase File
Los objetos de tipo ;ile son usados para representar los arc1ivos actuales )pero 59 los
datos en los arc1ivos* o directorios que existen en el disco fisicamente en la
computadora.
import java.io.*; // The Java 5 exam focuses on
// classes from java.io
class Writer1 {
public static void main(String [] args) {
File file = new File("fileWrite1.txt"); // There's no file yet!
}}
2uando se crea uma nueva instancia de la clase ;ile, 59 se creo todavia um arc1ivo,
solo se crea un nombre de arc1ivo.
na vez que se tiene um objeto ;ile, existen varias maneras para 2rear um arc1ivo.
import java.io.*;
class Writer1 {
public static void main(String [] args) {
try { // warning: exceptions possible
boolean newFile = false;
File file = new File // it's only an object
("fileWrite1.txt");
System.out.println(file.exists()); // look for a real file
newFile = file.createNewFile(); // maybe create a file!
System.out.println(newFile); // already there?
System.out.println(file.exists()); // look again
} catch(IOException e) { }
}
}
%roduce la salida& false , true , true.
A tambien crea un arc1ivo vacio, em el directorio actual.
Si se corre el c:digo por Bda vez produce true, false, true.
5ota& Tener en cuenta que se pone la creacion del arc1ivo en um bloque tryCcatc1.
3lgunos m?todos&
boolean exists)* =etorna true si puede encontrar el arc1ivo actual.
boolean create5e(;ile)* 2rea un nuevo arc1ivo, sino existe
sando FileWriter y FileReader
import java.io.*;
class Writer2 {
public static void main(String [] args) {
char[] in = new char[50]; // to store input
int size = 0;
try {
File file = new File( // just an object
"fileWrite2.txt");
FileWriter fw =
new FileWriter(file); // create an actual file
// & a FileWriter obj
fw.write("howdy\nfolks\n"); // write characters to
// the file
fw.flush(); // flush before closing
fw.close(); // close file when done
FileReader fr =
new FileReader(file); // create a FileReader
// object
size = fr.read(in); // read the whole file!
System.out.print(size + " "); // how many bytes read
for(char c : in) // print the array
System.out.print(c);
fr.close(); // again, always close
} catch(IOException e) { }
}
}
!l m?todo read)* lee el arc1ivo entero.
Falta sobre flush()
2uando tu utilizas una lectura o escritura a um arc1ivo 1ay que utilizar el m?todo
close)*.
2ombinando 8C9 2lases
3lgunos !j
File file = new File("fileWrite2.txt");
PrintWriter pw = new PrintWriter(file);
File file = new File("fileWrite2.txt"); // create a File object
FileWriter fw = new FileWriter(file);
PrintWriter pw = new PrintWriter(fw);
File file = new File("fileWrite2.txt");
FileReader fr = new FileReader(file);
BufferedReader br = new BufferedReader(fr);
String data = br.readLine();
!ra"a#ando con archivos y directorios
La clase ;ile es usada para crear arc1ivos y directorios. 3demas los m?todos de esta
clase pueden ser usados para eliminar arc1ivos, renombrar arc1ivos, determinar si um
arc1ivo existe, crear arc1ivos temporales, cambiar un atributo de um arc1ivo, y
diferenciar entre arc1ivos y directorios.
n punto que puede ser confuso es que una objeto ;ile puede ser usado para representar
un arc1ivo o directorio.
!.&
;ile file ' ne( ;ile),foo-*+
Siempre crea un objeto ;ile, y luego 1ace una de estas dos cosas&
Si ,foo- no existe, ningun arc1ivo actual es creado
Si ,foo- existe, el nuevo objeto ;ile)*, referencia al arc1ivo existente
5otar que ;ile file ' ne( ;ile),foo-*+ nunca crea un arc1ivo actual.
Day B maneras para crear un arc1ivo&
8nvocar create5e(;ile)*+ en un objeto ;ile.
File file = new File("foo"); // no file yet
file.createNewFile(); // make a file, "foo" which
// is assigned to 'file'
2rear un =eader o un >riter o un Stream. !specEficamente crear un ;ile=eader,
;ile>riter, %rint>riter, ;ile8nputStream, ;ile9utputStream.
2uando se crea una instancia de estas clases autom"ticamente se crea un arc1ivo, a
menos que ya exista.
File file = new File("foo");
PrintWriter pw = new PrintWriter(file);
2rear un directorio es similar a crear un arc1ivo. %rimero se crea un objeto ;ile, luego
creamos el directorio actual 1aciendo m4dir)*.
File myDir = new File("mydir"); // create an object
myDir.mkdir(); // create an actual directory
na vez que se tiene el directorio se puede trabajar con el poner arc1ivos.
File myFile = new File(myDir, "myFile.txt");
myFile.createNewFile();
Day que tener cuidado cuando se crean nuevos directorios, como se vio, construyendo
un =eader o >riter podemos autom"ticamente crear un arc1ivo, si este no existe, pero
esto no es asi para directorios.
.
File myDir = new File("mydir");
// myDir.mkdir(); // call to mkdir() omitted!
File myFile = new File(myDir, "myFile.txt");
myFile.createNewFile(); // exception if no mkdir!
#his will generate an exception something like
java.io.IOException: No such file or directory

5ota& !l metodo readLine)* de Buffered=eader cuando no 1ay mas datos retorna null.
2uando leemos un arc1ivo no se necesita metodo flus1)*, por lo tanto ninguna clase
=eader lo tendra.
$tros Metodos de File:
delete)* & 5o se puede eliminar un directorio si el no esta vacio.
renameTo)*& Se le debe pasar un valido objeto ;ile, si el nuevo ;ile es null levanta
5ull%ointer!xception.
Si es un directorio no 1ay problemas si no esta vacio.
list)*& crea un array de String de arc1ivos y directorios.

SERIALIZACION
La serializacion permite salvar objetos y todas sus variables de instancias.
3unque las variable se pueden maracar transient, lo cual significa, lo cual significa no
incluir la variable transient como parte del estado del objeto a ser salvado.
!ra"a#ando con $"#ect$utputStream y $"#ectInputStream
Lo basico de la serializacion involucra B metodos, uno para serializar y escribir el
stream y otro para leer el stream y deserializar el objeto.
ObjectOutputStream.writeObject() // serialize and write
ObjectInputStream.readObject() // read and deserialize
Las clases java.io. 9bject9utputStream y java.io. 9bject8mputStream son consideradas
de alto nivel en el pac4age java.io.
import java.io.*;
class Cat implements Serializable { } // 1
public class SerializeCat {
public static void main(String[] args) {
Cat c = new Cat(); // 2
try {
FileOutputStream fs = new FileOutputStream("testSer.ser");
ObjectOutputStream os = new ObjectOutputStream(fs);
os.writeObject(c); // 3
os.close();
} catch (Exception e) { e.printStackTrace(); }
try {
FileInputStream fis = new FileInputStream("testSer.ser");
ObjectInputStream ois = new ObjectInputStream(fis);
c = (Cat) ois.reaObject(); // !
ois.close();
} catch (Exception e) { e.printStackTrace(); }
}
}
!n el ej, se declaro que la clase 2at implementa la interface Serializable, esta es una
interface mar4er )sin metodos*.
3l invocar (rite9bject )* se serializa un 2at. Se deserializa invocando read9bject)*.
2uando serializas un objeto java serializa todo el grafo de objetos asociado.
import java.io.*;
public class SerializeDog {
public static void main(String[] args) {
Collar c = new Collar(3);
Dog d = new Dog(c, 8);
try {
FileOutputStream fs = new FileOutputStream("testSer.ser");
ObjectOutputStream os = new ObjectOutputStream(fs);
os.writeObject(d);
os.close();
} catch (Exception e) { e.printStackTrace(); }
}
}
$ut when we run this code we get a runtime exception something like this
java.io.NotSerializableException: Collar
!L ej, anterior tiro una =untime!xception debido a que se quizo serializar un 6og, pero
este al tener una variable de instancia 2ollar la cual no es serializable.
Fue pasaria si nosotros no podriamos modificar la clase 2ollar, y queremos salvar un
6ogG
!xiste el modificador transient, el cual elude la serializacion de una determinada
variable.
%ero tener cuidado ya que al marcar transient una determinada variable cuando el objeto
se deserializa, estas variables son null.
sando (rite9bject y read9bject
%ara solucionar el problema anterior )valores null al deserializar variables transient*,
java provee un mecanismo especial, un conjunto de metodos private, que se pueden
implementar en las clases, lo cual si ellos estan presentes, seran invocados
autom"ticamente durante la serializacion y deserializacion.
!stos m?todos permiten meternos entre medio de la serializacion y deserializacion.
Los metodos tienen que tener exactamente estas signaturas&
private void writeObject(ObjectOutputStream os) {
// your code for saving the Collar variables
}
private void readObject(ObjectInputStream os) {
// your code to read the Collar state, create a new Collar,
// and assign it to the Dog
}
!.
class Dog implements Serializable {
transient pri"ate Collar t#eCollar; // we can$t serialize t#is
private int dogSize;
public Dog(Collar collar, int size) {
theCollar = collar;
dogSize = size;
}
public Collar getCollar() { return theCollar; }
pri"ate "oi writeObject(ObjectO%tp%tStream os) {
// throws IOException { // 1
try {
os.e&a%lt'riteObject(); // 2
os.writeInt(theCollar.getCollarSize()); // 3
} catch (Exception e) { e.printStackTrace(); }
}
pri"ate "oi reaObject(Object(np%tStream is) {
// throws IOException, ClassNotFoundException { // 4
try {
is.e&a%lt)eaObject(); // 5
theCollar = new Collar(is.readInt()); // 6
} catch (Exception e) { e.printStackTrace(); }
}
}
2uando se invoca al metodo defau4t>rite9bject)* desde dentro de (rite9bject)*, se le
esta diciendo a la ./0, que 1aga la serializacion de manera normal para ese objeto.
Se puede escribir codigo extra antes o despu?s que se invoca al default>rite9bject)*,
pero cuando se lee el codigo extra lo tienes que 1acer en el mismo orden.
La principal razon de implementar estos metodos es si se tiene que salvar algun estado
del objeto manualmente.
Si una superclase es Serializable, luego todas sus subclases lo son.
Fue sucede si la superclase no es Serializable y la subclase si.
class Animal { }
class Dog extends Animal implements Serializable {
// the rest of the Dog code
}
!sto compila pero pueden 1aber ciertas implicaciones.
%ara entender estas implicaciones, miremos la diferencia entre un objeto que proviene
de una deserializacion y otro creado usando ne(.
Las siguientes cosas suceden&
Todas las variables de instancias toman valores por default
!l constructor es invocado )cadena de constructores*
Se completan todos los constructores de la superclase
Se le asignan los valores a las variables de instancia que se inicializan en la
declaracion
!l constructor se completa.
%ero estas cosas 59 suceden cuando un objeto se deserializa.
2uando una instancia de una clase serializable se deserializa su constructor no corre, y
las variables de instancia no toman sus valores de inicializaci:n.
2uando deserializamos un objeto las variables referencia transient , son recuperadas
como null.
Si serializas una clase, pero su superclase 59 es Serializable, luego cualquier variable
de instancia que se 1erede de la superclase, debe ser reseteada a los valores que se les da
durante la construccion normal del objeto. !sto es porque el constructor de la clase no-
serializable correra.
2ada constructor superior de la primer clase no serializable correra y asi la cadena desde
a1i.
!n sEntesis si una superclase no implementa serializable, luego cuando un objeto
subclase es deserializado, el constructor de la superclase 6ebe correr.
!.
import java.io.*;
class SuperNotSerial {
public static void main(String [] args) {
Dog d = new Dog(35, "Fido");
System.out.println("before: " + d.name + " "
+ d.weight);
try {
FileOutputStream fs = new FileOutputStream("testSer.ser");
ObjectOutputStream os = new ObjectOutputStream(fs);
os.writeObject(d);
os.close();
} catch (Exception e) { e.printStackTrace(); }
try {
FileInputStream fis = new FileInputStream("testSer.ser");
ObjectInputStream ois = new ObjectInputStream(fis);
d = (Dog) ois.readObject();
ois.close();
} catch (Exception e) { e.printStackTrace(); }
System.out.println("after: " + d.name + " "
+ d.weight);
}
}
class Dog extends Animal implements Serializable {
String name;
Dog(int w, String n) {
weight = w; // inherited
name = n; // not inherited
}
}
class Animal { // not serializable !
int weight = 42;
}
which produces the output%
before: Fido 35
after: Fido 42
59T3& Si serializas una collecion o array, cada elemento debe ser serializable.
5otar que las interfaces collecion no son serializables, las clases concretas colecci:n si.
Seriali%acion &$ es para static
Las variables static nunca son salvadas como parte del estado del objeto.
Dates , Numbers y Currency

#ava'util'(ate& La mayorEa de los m?todos de esta clase son deprecated, pero se puede
usar esta clase como conexi:n entre la clases 2alendar y 6ate;ormat.
na instancia de 6ate representa un modificable, fec1a y 1ora , en milisegundos.
#ava'util'Calendar: !sta clase provee una gran variedad de metodos que ayudan a
convertir y manipular fec1as y 1ora.
#ava'te)t'(ateFormat: !sta clase es usada para formatear fec1as, provee varios estilos,
ademas de formatear para varios lugares del mundo.
#ava'te)t'&um"erFormat& !sta clase es usada para formatear numeros y 2urrency para
distintos lugares.
#ava'util'*ocale: !sta clase es usada en conjuncion con 6ate;ormat y 5umber;ormat
para formatear fec1as, numeros y currencys para lugares especificos.
Si se quiere manipular fec1as sin producir formateo, se puede usar la clase Locale
directamente con la clase 2alendar.
*a clase (ate
La 3pi de 6ate no tiene un bvuen diseHo para situaciones de internacionalizacion y
localizacion.
La mayoria de sus metodos son deprecated, y para la mayoria de los propositos se debe
usar 2alendar en vez de date.
na instancia de 6ate, representa una fec1a y 1ora. 8nternamente la fec1a y 1ora es
almacenada como un long primitivo.
0as precisamente el long almacena el numero de milisegundos )#IIIms por seg* entre
el dato representado y #C#C#JKI.
3lgunos metodos&
getTime)* y setTime)*& 3mbos usan la escala de milisegudos.
%odemos crear 6ates usando&
Date now = new Date(); // Sin argmunetos representa la fecha actual
Date d1 = new Date(1000000000000L);
La 2lase 2alendar
0anipular datos con 6ate es complicado. La clase 2alendar fue diseHada para esto.
2alendar es una clase abstracta.
Calendar c = new Calendar(); // illegal, Calendar is abstract
%ara crear una instancia de 2alendar se debe 1acer con alguno de los sobrecargados
metodos estaicos get8nstance)*.
Calendar cal = Calendar.getInstance();
import java.util.*;
class Dates2 {
public static void main(String[] args) {
Date d1 = new Date(1000000000000L);
System.out.println("1st date " + d1.toString());
Calendar c = Calendar.getInstance();
c.set*ime(1); // +1
i&(c.S,-./0 == c.1et2irst.a3O&'ee4()) // +2
System.out.println("Sunday is the first day of the week");
System.out.println("trillionth milli day of week is "
+ c.1et(c../05O25'667)); // +3
c.a(Calenar.8O-*9: 1); // +!
.ate 2 = c.1et*ime(); // +;
System.out.println("new date " + d2.toString() );
}
}
!L metodo add)* permite agregar o substraer, unidades de tiempo apropiadas seg<n el
field que se especifique.
c.add(Calendar.HOUR, -4); // subtract 4 hours from c's value
c.add(Calendar.YEAR, 2); // add 2 years to c's value
c.add(Calendar.DAY_OF_WEEK, -2); // subtract two days from c's value
!l metodo roll)* actua como add)*, excepto que cuando una parte de la fec1a toma
incrementos o decrementos grandes en la parte significativa de la fec1a, esta no se
incrementa o decrementa.
// assume c is October 8, 2001
c.roll(Calendar.MONTH, 9); // notice the year in the output
Date d4 = c.getTime();
System.out.println("new date " + d4.toString() );
&roduce la salida
new date Fri Jul 08 19:46:40 MDT 2001
5otar que el aHo 59 cambio, aun cuando agregamos J meses. !n forma similar,
invocando roll)* ,con D9= no cambiara la fec1a, el mes o el aHo.
.
LA clase DateFormat

import java.text.*;
import java.util.*;
class Dates3 {
public static void main(String[] args) {
Date d1 = new Date(1000000000000L);
DateFormat[] dfa = new DateFormat[6];
dfa[0] = DateFormat.getInstance();
dfa[1] = DateFormat.getDateInstance();
dfa[2] = DateFormat.getDateInstance(DateFormat.SHORT);
dfa[3] = DateFormat.getDateInstance(DateFormat.MEDIUM);
dfa[4] = DateFormat.getDateInstance(DateFormat.LONG);
dfa[5] = DateFormat.getDateInstance(DateFormat.FULL);
for(DateFormat df : dfa)
System.out.println(df.format(d1));
}
}
which on our '() produces
9/8/01 7:46 PM
Sep 8, 2001
9/8/01
Sep 8, 2001
September 8, 2001
Saturday, September 8, 2001
6ate;ormat es otra clase abstracta, se usan los metodos static get8nstance)* ,
get6ate8nstance)* para obtener una instancia, entre otros.
Se usa el metodo format)*, para crear Strings para representar la version formateada de
la fec1a.
!l metodo parse)*, toma un string en el estilo de la instancia 6ate;ormat y convierte el
string a un objeto 6ate. !sta es una operaci:n riesgosa y puede levantar %arse!xception.
Date d1 = new Date(1000000000000L);
System.out.println("d1 = " + d1.toString());
DateFormat df = DateFormat.getDateInstance(
DateFormat.SHORT);
String s = df.format(d1);
System.out.println(s);
try {
Date d2 = df.parse(s);
System.out.println("parsed = " + d2.toString());
} catch (ParseException pe) {
System.out.println("parse exc"); }
which on our '() produces
d1 = Sat Sep 08 19:46:40 MDT 2001
9/8/01
parsed = Sat Sep 08 00:00:00 MDT 2001
La clase Locale
6ate;ormat y 5umber;ormat pueden usar instancias de Locale para customizar la
salida formateada a un lugar especifico.
Los constructores q se nesecitan conocer son&
Locale(String language)
Locale(String language, String country)
!l argumento lenguaje representa un codigo de lenguaje 8S9, por ej si queremos
rpresentar el italiano
Locale locPT = new Locale("it"); // Italian
Si queremos representar el italiano usado en Suiza
Locale locBR = new Locale("it", "CH"); // Switzerland
2omo se usa en conjunto con 2alendar
Calendar c = Calendar.getInstance();
c.set(2010, 11, 14); // December 14, 2010
// (month is 0-based
Date d2 = c.getTime();
Locale locIT = new Locale("it", "IT"); // Italy
DateFormat dfIT = DateFormat.getDateInstance(
DateFormat.FULL, locIT);
System.out.println("Italy " + dfIT.format(d2));
=!29=63= que 6ate;ormat y 5umber6ate;ormat pueden tener sus codigos de lugar
seteados solo en el tiempo de instanciacion. 5o existen metodos que permiten cambiar
el codigo de un objeto Locale.
!n Locale existen los metodos get6isplay2ountry)* , get6isplayLanguaje)*, estos
metodos permiten crear string que representan un determinado lugar, )pais y
lenguaje*.en terminos de ambos el default Locale y cualquier otro Locale.
Calendar c = Calendar.getInstance();
c.set(2010, 11, 14);
Date d2 = c.getTime();
Locale locBR = new Locale("pt", "BR"); // Brazil
Locale locDK = new Locale("da", "DK"); // Denmark
Locale locIT = new Locale("it", "IT"); // Italy
System.out.println("def " + locBR.getDisplayCountry());
System.out.println("loc " + locBR.getDisplayCountry(locBR));
System.out.println("def " + locDK.getDisplayLanguage());
System.out.println("loc " + locDK.getDisplayLanguage(locDK));
System.out.println("D>I " + locDK.getDisplayLanguage(locIT));
#his on our '() produces
def Brazil
loc Brasil
def Danish
loc dansk
D>I danese // En Italia el leng Danish es llamado danese
La Clase NumberFormat
!lla es abstracta, por lo tanto usamos get8nstance)* o get2urrency8nstance)* para crear
un objeto 5umber;ormat. Se usa esta clase para formatear numeros o valores currencys.
float f1 = 123.4567f;
Locale locFR = new Locale("fr"); // France
NumberFormat[] nfa = new NumberFormat[4];
nfa[0] = NumberFormat.getInstance();
nfa[1] = NumberFormat.getInstance(locFR);
nfa[2] = NumberFormat.getCurrencyInstance();
nfa[3] = NumberFormat.getCurrencyInstance(locFR);
for(NumberFormat nf : nfa)
System.out.println(nf.format(f1));
#his on our '() produces
123.457
123,457
$123.46
123,46 ?
5otar que el valor inicial de digitos fracionales para el default 5umber;ormat es L.
!L metodo format)* redondea y no trunca.
!l metodo parse)* debe estar entre un tryCcatc1.
!l metodo set%arse8nterger9nly)* toma un boolean. 6e esta manera la llamada a parse
retornara la parte entera del string formateado, a numero de punto flotante.
Parkin , !okeni"in y Formattin
import java.util.regex.*;
class RegexSmall {
public static void main(String [] args) {
Pattern p = Pattern.compile("ab"); // the expression
Matcher m = p.matcher("abaaaba"); // the source
boolean b = false;
while(b = m.find()) {
System.out.print(m.start() + " ");
}
}
}
#his produces
0 4
!n general una busqueda regex corre desde la izquierda 1acia la derec1a, y una vez que
el car"cter origen a sido usado en un matc1, este no vuelve a ser usado.
Bus+ueda usando Metacaracteres

=egex tiene un mecanismo poderoso, en el n<cleo de este mecanismo esta la idea de
metacaracter.
%or ej en regex la siguiente expresi:n es usada para digitos numericos& \d
%or ej, si tenemos un String source asi&
source: abaaaba
index: 0123456
y aplicamos Md, seran encontrados digitos en la posici:n #,B,N,$,K,O.
%ara utilizar Md es necesario 1acerlo con MMd.
=egex provee un gran conjunto de metacaracteres, descriptos en java.util.regex.%attern.
3lgunos necesarios&
\d Un digito
\s Un espacio en Blanco
\w Letras, digitos o el carcter _ undescore.
Por ej
source: "a 1 56 _Z"
index: 012345678
pattern: \w

Retornara: 0,2,4,5,7,8.
Tambien se pueden especificar conjuntos de caracteres para buscar, usando corc1etes, y
rangos de caracteres.
[abc] Searches only for a*s !*s or c*s
[a-f] Searches only for a ! c d e or f characters
3demas se pueden buscar varios rangos en uno. %or ej la siguiente expresi:n busca
ocurrencias de las letras a P f o 3 P ;.
[a-fA-F]
%or ej&
source: "cafeBABE"
index: 01234567
pattern: [a-cA-C]
returns positions% + , - . /
3demas aunque no son necesarios para el examen, existen otros caracteres como& ,Q-
para negar, corc1etes anidados para crear una unio de conjuntos, ,RR- para especificar
la interseccion de conjuntos.
Bus+ueda usando Cuantificadores
%or ej si quisieramos buscar literales 1exadecimales, la expresi:n de abajo nos
permitiria solo para valores de un digito.
0[xX][0-9a-fA-F]
2on esa expresi:n y el siguiente source
source: "12 0x 0x12 0Xf 0xg"
index: 012345678901234567
Se obtendrEa, $ , ##.
%ero si por ej quisieramos buscar ocurrencias de 8nteger, 1abria que especificar un
patron que encuentre # o mas long.
Day un conjunto de constructores regex llamados cuantificadores, que premiten
especificar el concepto de ,uno o mas-.
!l cuantificador que representa ,uno o mas- es S.
%or ej
source: "1 a12 234b"
pattern: \d+
Esta expresin produce la salida.
0 1
3 12
6 234
/olviendo al problema de los 1exadecimales
2on la siguiente expresi:n lo resolveriamos&
0[xX]([0-9a-fA-F])+
5otar el uso de par?ntesis para denotar que el cuantificador se aplica a esa parte.
Luego los cuantificadores siempre cuantifican la expresi:n que preceden.
9tros cuantificadores son&
T cero o mas ocurrencias.
G cero o una ocurrencia.
9tro ej&
%ara buscar los que no tengan a , b , c. [^abc]
,l Punto
9tro metacaracter es el ,.- !ste significa cualquier car"cter puede servir. !j
source: "ac abc a c"
pattern: a.c
will produce the output
3 abc
7 a c
Cuantificadores -reedy
G es greedy, GG es reluctant, para cero o uno
T es greedy, TG, es reluctant, para cero o mas
S es greedy, SG !s reluctant, para uno o mas
6iferencia entre Ureedy y =elutanct
%or ej,
source: yyxxxyxx
pattern: .*xx
2on cuantificadores greedy devolvera
0 yyxxxyxx
A con reluctanct&
0 yyxx
4 xyxx
!l cuantificador greedy lee origen completo de datos, y luego trabaja 1acias atr"s,
desde la derec1a 1asta que encuentra el matc1.
Cuando metacaracteres y String colisionan'
2uando implemenmtamos regex en nuestro codigo es comun que el origen de datos y y
las expresiones esten almacenadas en Strings.
!l problema es que los metacaracteres y los String no se combinan muy bien.
%or ej, queremos 1acer una regex que mira digitos,
String pattern = "\d"; //error de compilacin
%ara que esto compile 1ay que 1acerlo&
String pattern = "\\d"; // a compilable metacharacter
La primer M le dice al compilador que lo proximo que viene debe ser tomado
literalmente y no como una secuencia de escape.
%ara el metacaracter ,.-
String p = "."; // regex sees this as the "." metacharacter
String p = "\."; // the compiler sees this as an ille1al Java escape sequence
String p = "\\."; // the compiler is happy, and regex sees a dot, not a
//metacharacter

Locali"an#o Datos $ia Patter %atc&in
La clase java.util.regex.%attern es usada para almacenar una representaci:n de una
expresi:n regular, por lo tanto ella puede ser reusada por instancias de la clase 0atc1er.
La clase 0atc1er es usada para invocar al motor de regex con la intencion de realizar
operaciones de matc1.
import java.util.regex.*;
class Regex {
public static void main(String [] args) {
Pattern p = Pattern.compile(args[0]);
Matcher m = p.matcher(args[1]);
boolean b = false;
System.out.println("Pattern is " + m.pattern());
while(b = m.find()) {
System.out.println(m.start() + " " + m.group());
}
}
}
% java Regex "\d\w" "ab4 56_7ab"
&roduces the output
Pattern is \d\w
4 56
7 7a
=ecordar que si queremos usar la expresi:n contenida en un string se debe usar \\d\\w
5otar que no estamos usando ne( para crear un %attern, en la 3%8 no son especificados
constructores.
Day que usar el metodo estatico compile)* que recibe un string con la expresi:n regex
para crear una instancia de un %attern.
%ara crear un 0atc1er se lo 1ace con el metodo %attern.matc1er)* que toma un string
representando el origen de datos.
!l metodo find)* retorna true si se realiza un matc1.
!l metodo start)* retorna la posici:n inicial del matc1. Se debe llamar despu?s que se
1izo un find)*.
!l metodo group retorna el String que representa el actual matc1. Se debe llamar
despu?s que se 1izo un find)*.
Bus+ueda usando la clase Scanner
La clae java.util.Scanner es principalmente pensada para to4enizar datos, ella pueda ser
usada para buscar.
0ientras que la clase Scanner no provee informaci:n de localizacion, o funcionalidad
de buscar y remplazar. Se puede usar para aplicar expresiones regex al source de datos.
import java.util.*;
class ScanIn {
public static void main(String[] args) {
System.out.print("input: ");
System.out.flush();
try {
Scanner s = new Scanner(System.in);
String token;
do {
token = s.findInLine(args[0]);
System.out.println("found " + token);
} while (token != null);
} catch (Exception e) { System.out.println("scan exc"); }
}
}
#he in"ocation and input
java ScanIn "\d\d"
input: 1b2c335f456
produce the following%
found 33
found 45
found null

Token!n"
To4enizing es el proceso de tomar grndes piezas fuentes de datos, dividirlas en
pequeHas piezas y almacenarlas a estas en variables.
3lgunas clases que proveen capacidad de to4enizin son String )usando split)** y
Scanner.
!o.ens y (elimitadores
Los to4en son las actuales piezas de datos, y los delimitadores son las expresiones que
separan los to4ens entre si.
source: "ab,cd5b,6x,z4"
0f we say that our delimiter is a comma then our four tokens would !e
ab
cd5b
6x
z4
!n general cuando se 1aec to4enizing los delimitadores se descartan.
!o.eni%ing con String'split/0
!ste metodo toma una expresi:n regex como argumento y retorna un array de S(ing
con los to4ens.
import java.util.*;
class SplitTest {
public static void main(String[] args) {
String[] tokens = args[0].split(args[1]);
System.out.println("count " + tokens.length);
for(String s : tokens)
System.out.println(">" + s + "<");
}
}
% java SplitTest "ab5 ccc 45 @" "\d"
produces
count 4
>ab<
> ccc <
><
> @<
5ota& Si tienes que crear un string conteniendo un doble ,- o 1 recuerda que tienes que
agregar un car2cter de escape primero System.out.println("\" \\");
!o.eni%ing con Scanner

3demsa de las posibilidaes provistas por split)*, ofrece las siguientes&
Scanners pueden ser construidos usando files, streams o strings como source.
!l to4enizing es realizado dentro de un loop, para poder salir cuando se quiera.
Los to4ens pueden ser convertidos a sus apropiados primitivos automaticamente.
!l delimitador por default que usa Scanne7r es el espacio en blanco.
import java.util.Scanner;
class ScanNext {
public static void main(String [] args) {
boolean b2, b;
int i;
String s, hits = " ";
Scanner s1 = new Scanner(args[0]);
Scanner s2 = new Scanner(args[0]);
while(b = s1.hasNext()) {
s = s1.next(); hits += "s";
}
while(b = s2.hasNext()) {
if (s2.hasNextInt()) {
i = s2.nextInt(); hits += "i";
} else if (s2.hasNextBoolean()) {
b2 = s2.nextBoolean(); hits += "b";
} else {
s2.next(); hits += "s2";
}
}
System.out.println("hits " + hits);
}
}
0f this program is in"oked with
% java ScanNext "1 true 34 hi"
it produces
hits ssssibis2
!l metodo 1as5extxxx)* testea el valor del proximo to4en, no el del actual, y no
realiza movimiento 1acia el proximo to4eng.
!l metodo nextVxx)*, toma el proximo to4en y se mueve 1acia el siguiente to4en.
La clase Scanner posee los metotods nextVxx)* para cada tipo primitivo excepto c1ar.
La clase Scanner tiene el metotod use6elimiter)*, que permite setear el delimitador que
se desee.
Formatean#o con 'rint()* y (ormat)*
!stos metodos fueron agregados a la clase java.io.%rintStream en java 7. Se comportan
exactamente de la misma manera.
6etr"s de escena el metotod format)* usa la clae java.util.;ormatter)*, se puede usar la
clase ;ormater directamente.
printf("format string", argument(s));
!l format string puede contener informaci:n normal literal string que no es asociada con
ningun argumento, y argumentos especificos para formatear datos.
Los datos de formato empiezan con el signo ,W-.
System.out.printf("%2$d + %1$d", 123, 456);
#his produces
456 + 123
!structura
%[arg_index$][flags][width][.precision]conversion char
Los valores con XY son opcionales, Los unicos elementos requeridos son el W y el
car"cter de conversi:n.
3rgZindex& n integer seguido directamente por [, indica cual argumento debe ser
impreso en esta posici:n.
;lags&
"-" 'ustifica a la i3quierda el argumento
"+" 0ncluye un signo (+ o -) con el argumento
"+ Rellena el argumento con ceros4
"" 5se locale6specific grouping separators (i4e4 the comma in ,78-./)
"(" 9ierra numeros negati"os en par:ntesis4
>idt1& !ste valor indica el numero minimo de caracteres a imprimir.
%recision& %or ej cuando se formatea un punto flotante indica la cantidad de digitos a
imprimir despu?s del punto decimal.
9on"ersi;n% <l tipo de argumento a ser formateado
I b !oolean
I c char
I d integer
I f floating point
I s string
E
int i1 = -123;
int i2 = 12345;
System.out.printf(">%1$(7d< \n", i1);
System.out.printf(">%0,7d< \n", i2);
System.out.format(">%+-7d< \n", i2);
System.out.printf(">%2$b + %1$5d< \n", i1, false);
#his produces%
> (123)<
>012,345<
>+12345 <
>false + -123<
L DHJM<IM@ KN@ LD IJ >JI>N@?<I @G MDJ @L@>DAD><?J S @G
><>M@ ?@ >JIO@LDI L@ G@O<IM<< NI< NIMDH@@R>@MDJI
System.out.format("%d", 12.3);
#his produces something like
Exception in thread "main" java.util.IllegalFormatConversionException:
d != java.lang.Double