1. SCJP 6
Clase 10 – Strings, I/O
Ezequiel Aranda
Sun Microsystems Campus
Ambassador

2. Disclaimer & Acknowledgments
>!Even though Ezequiel Aranda is a full-time employee of Sun
Microsystems, the contents here are created as his own
personal endeavor and thus does not reflect any official
stance of Sun Microsystems.
>!Sun Microsystems is not responsible for any inaccuracies in
the contents.
>!This slides are Licensed under a Creative Commons
Attribution – Noncommercial – Share Alike 3.0
>!http://creativecommons.org/licenses/by-nc-sa/3.0/

3. AGENDA
>! trings
S
>! tringBuilder y
S
StringBuffer
>! anejo del sistema
M
de archivos

4. String
>! l concepto clave del String es entender que,
E
una vez creado un objeto de este tipo, no
puede ser modificado.
>! ntonces, ¿qué es lo que realmente sucede
E
cuando modificamos un String?

5. Creando un String
String s = "abcdef";
>! rea un nuevo objeto de la clase String con el
C
valor “abcdef”, y se lo asigna a la referencia
‘s’.
String s2 = s;
>! signa el mismo string a la referencia s2.
A

6. Modificando un String
s = s.concat(" more stuff");
>! concat” añade un literal al final del String…
“
>! Pero, ¿No habíamos
…
dicho que los Strings
eran inmutables?

7. Modificando un String (II)
>! n realidad, el objeto String es inmutable,
E
pero la referencia no lo es.
>! or lo tanto, lo que sucede es lo siguiente:
P
>! a JVM crea un nuevo String y le da el valor que
L
resulta de concatenar “abcdef” y “ more stuff”.
>! uego, actualiza ‘s’ para referenciar al nuevo
L
String.
>! bservaciones
O
>! écnicamente, ahora hay 3 Strings: “abcdef,” “
T
more stuff” y “abcdef more stuff”.
>!s2’ aún hace referencia a “abcdef”.
‘

8. Pregunta
String s1 = "spring ";
String s2 = s1 + "summer ";
s1.concat("fall ");
s2.concat(s1);
s1 += "winter ";
System.out.println(s1 + " " + s2);
>! Qué imprime?
¿
>! Cuántos objetos se crearon?
¿

9. Strings y Memoria
>!Para que el manejo de memoria sea más eficiente,
la JVM reserva una porción de memoria conocida
como “String Pool”.
>!La regla es la siguiente:
cuando el compilador
encuentra un literal, se
fija en el pool a ver si
hay alguno que
coincida, si es así la
referencia es dirigida al
literal existente, y no se
crea un nuevo literal.

10. Strings y Memoria (II)
>! sto es lo que hace a la inmutabilidad una
E
buena idea.
>! i una de varias referencias al mismo String
S
pudiese modificarlo, sería desastroso.
>! ero… ¿Qué pasa si alguien sobrescribe la
P
funcionalidad de la clase String? ¿Podría
causar problemas en el pool?

11. Pero… ¿Qué pasa si alguien
sobrescribe la funcionalidad
de la clase String? ¿Podría
causar problemas en el
pool?
>! ada, porque la clase String es final.
N

12. Métodos importantes de la clase
String
Método Tipo de retorno Descripción
!"#$%&'()&*()+,-. !"#$ Retorna el carácter ubicado en la posición index
Retorna el String que resulta de concatenar el
!/)!#&'0&$()1*2. String
String utilizado para invocar el método y s.
,34#5261)/$,7#2,' Retorna true si el contenido de ambos strings es
boolean
0&$()1*2. igual, ignorando mayusculas/ minusculas
La longitud del String usado para invocar el
5,)1&"'. int
método
$,85#!,'!"#$*/5+9* Retorna un String resultado de reemplazar el
String
!"#$*),:. carácter “old” por el carácter “new”

13. Métodos importantes de la clase
String (II)
Método Tipo de retorno Descripción
24;2&$()1'()&*#.*
Retorna una subcadena que va desde la
substring (int a, String
posición ‘a’ hasta la posición ‘b’
int b)
Retorna un String cuyo valor es el del utilizado
&/</:,$7#2,'. String para invocar el método, pero con todas las
mayúsculas intercambiadas por minúsculas .
&/0&$()1'. String El valor del String.
Funciona igual que toLowerCase, pero
&/=88,$7#2,'. String
intercambiando minúsculas por mayúsculas.
Retorna un String cuyo valor es el del utilizado
&$(>'. String para invocar el método pero sin espacios al
principio o al final de la cadena.

14. StringBuffer y StringBuilder
>! eben utilizarse cuando debemos hacer
D
muchas modificaciones en un String.
>! i modificamos muchas veces una gran cantidad
S
de Strings terminaremos con un pool gigante de
Strings abandonados.
>! n uso común de StringBuffer es la
U
manipulación de archivos:
>! ratamos al archivo como un gran bloque de
T
datos, los cerramos y luego podemos reutilizar el
buffer para el siguiente archivo.

15. ¿StringBuffer o StringBuilder?
>! on exactamente iguales, con la excepción de
S
que StringBuffer es thread safe mientras que
StringBuilder no lo es.
>! omo siempre, es recomendable, por razones
C
de rendimiento, usar la clase que no es
thread safe salvo que nos encontremos en un
entorno multi hilo.

16. Usando StringBuffer/Builder
>! tilizando Strings:
U
String x = "abc";
x = x.concat("def");
>! tilizando StringBuffer/Builder
U
StringBuffer x= new StringBuffer("abc");
x.append("def");
>! n ambos casos, si imprimimos el valor de x,
E
el mismo será “abcdef”, pero en el caso del
String, hemos abandonado en el pool al
String “abc” original.

17. Métodos importantes de
StringBuffer/Builder
Método Tipo de retorno Descripción
Retorna el StringB que resulta de concatenar el
#88,)+*'0&$()1*2. StringBuffer/Builder StringB utilizado para invocar el método y el
String s.
Retorna un StringB que resulta de eliminar del
+,5,&,'()&*#9*()&*;. StringBuffer/Builder invocante la subcadena delimitada por ‘a’ (0
based) y ‘b’ (1 based).
Retorna un StringB que resulta de insertar en el
()2,$&'()&*#9*0&$()1*
StringBuffer/Builder invocante la subcadena ‘b’ a partir de la
;.
posición ‘a’.
Retorna un StringB que resulta de invertir el
$,?,$2,'. StringBuffer/Builder
invocante.
&/0&$()1'. String Retorna el valor del StringB invocante
Nota: si bien estos métodos “retornan” un StringB, en realidad
modifican el invocante y retornan una referencia al mismo.

18. Clases para el manejo de archivos
>! ile: representación abstracta de un
F
pathname. Se usa para realizar operaciones
como crear, buscar y borrar archivos y
directorios.
>! ileReader: utilizada para leer archivos de
F
caracteres. En general se utilizan wrappers
más específicos.
>! ufferedReader: un wrapper de FileReader
B
que utiliza buffers para aumentar la
eficiencia.

19. Clases para el manejo de archivos (II)
>! ileWriter: la contraparte de FileReader, al
F
igual que con esta última, en general se
utilizan wrappers más versátiles y eficientes.
>! ufferedWriter: la contraparte de
B
BufferedReader para escrituras. Provee
escritura por líneas.
>! rintWriter: Un writer con varios métodos que
P
lo vuelven muy flexible y versátil.

20. Creando un archivo utilizando File
class Writer1 {
public static void main(String [] args) {
try {
boolean newFile = false;
File file = new File ("fileWrite1.txt"); //un
objeto File
System.out.println(file.exists()); // ¿existe el
archivo?
newFile = file.createNewFile(); // lo creamos
System.out.println(newFile);
System.out.println(file.exists()); // ¿ahora si?
}
catch(IOException e) { }
}
}

21. Creando un archivo utilizando File (II)
>! rimera ejecución:
P
>! xists retorna false.
e
>! reateNewFile retorna true.
c
>! l segundo exists retorna true.
E
>! egunda ejecución:
S
>! xists retorna true.
e
>! reateNewFile retorna false.
c
>! l segundo exists retorna true.
E

22. Usando FileWriter y FileReader
class Writer2 {
public static void main(String [] args) {
char[] in = new char[50];
// para almacenar el input
int size = 0;
try {
File file = new File("fileWrite2.txt”);
// creamos un objeto file
FileWriter fw = new FileWriter(file);
// y un objeto FileWriter
fw.write("howdynfolksn");
// escribimos algunos caracteres
fw.flush(); // flush
fw.close(); // close

23. Usando FileWriter y FileReader (II)
FileReader fr = new FileReader(file);
// creamos un objeto FileReader
size = fr.read(in);
// Leemos el archivo completo
System.out.print(size + " ");
// cantidad de bytes que leimos
for(char c : in)
// imprimimos el array
System.out.print(c);
fr.close(); // cerramos el archivo
}
catch(IOException e) { }
}
}

24. Parte de java.io necesaria para el examen SCJP
Extiende Argumentos clave de los
Clase Métodos clave
de constructores
!$,#&,@,:A(5,'.**
+,5,&,'.**
,-(2&2'.**
File, String
(2B($,!&/$C'.**
File Object String
(2A(5,'.**
Strin, String
5(2&'.**
>D+($'.**
$,)#>,E/'.*
close()
File
FileWriter Writer flush()
String
write()
close()
flush()
BufferedWriter Writer Writer
newLine()
write()

25. Parte de java.io necesaria para el examen SCJP (II)
Extiende Argumentos clave de
Clase Métodos clave
de los constructores
!5/2,'.**
File (java 5)
F42"'.**
String (java 5)
PrintWriter Writer G/$>#&'.H9*8$()I'.H**
OutputStream
8$()&'.9*8$()&5)'.**
Writer
:$(&,'.
File
FileReader Reader read()
String
read()
BufferedReader Reader Reader
readLine()

26. Trabajando con archivos y directorios
>!File file = new File("foo");
>! i “foo” no existe, no se crea hasta que lo
S
ordenemos con createNewFile().
>! i “foo” existe, el objeto file ahora se refiere a
S
dicho archivo.
>! i, en cambio, queremos crear un archivo:
S
>!File file = new File("foo");
file.createNewFile();
>!File file = new File("foo");
PrintWriter pw = new PrintWriter(file);

27. Trabajando con archivos y directorios (II)
>! l caso de los directorios es similar:
E
File myDir = new File("mydir");
myDir.mkdir();
File myFile = new File(myDir, "myFile.txt");
myFile.createNewFile();
>! i bien creando un writer podemos crear un
S
archivo sin necesidad de llamar a
createNewFile(), los directorios nunca se
crean sin un mkdir().

28. Trabajando con archivos y directorios (III)
// creamos un directorio
File delDir = new File("deldir");
delDir.mkdir();
// agregamos un archivo al directorio
File delFile1 = new File(delDir, "delFile1.txt");
delFile1.createNewFile();
// agregamos otro archivo al directorio
File delFile2 = new File(delDir, "delFile2.txt");
delFile2.createNewFile();
// borramos delFile1
delFile1.delete();

29. Trabajando con archivos y directorios (IV)
// intentamos borrar el directorio
System.out.println(“delDir is” + delDir.delete());
// creamos un nuevo objeto
File newName = new File(delDir, "newName.txt");
// renombramos el archivo
delFile2.renameTo(newName);
// de la misma forma, renombramos el directorio
File newDir = new File("newDir");
delDir.renameTo(newDir);

30. Trabajando con archivos y directorios (V)
>! e lo anterior, podemos observar que:
D
>! elete() no borra un directorio si no está vacío.
d
>! enameTo() debe recibir un objeto File valido del
r
cual tomará el nombre.
>! enameTo() puede renombrar un directorio si no
r
está vacío.

31. Buscar archivos
>! sumiendo que tenemos un directorio
A
llamado “searchThis”, podemos iterar a
través del mismo en busca de un archivo con:
String[] files = new String[100];
File search = new File("searchThis");
files = search.list();
for(String fn : files)
System.out.println("found " + fn);

32. Preguntas