Este documento es el manual del alumno para un curso avanzado de programación en Java. Explica los objetivos del curso, los requisitos para tomarlo y los temas que cubrirá, incluyendo conexión a bases de datos, manejo de memoria, clases útiles como StringBuilder y ArrayList, y streaming. El manual está protegido por derechos de autor y es propiedad de Cédric Simon.

1. Curso de programación
(Versión 6, JDK 1.6.0)
Nivel avanzado
Manual del alumno
en Java
©Copyright Cédric Simon, 2009 Versión 2.0 Reproducción prohibida
SolucionJava.com
Ing. Cedric Simon – Tel: 2268 0974 – Cel: 8888 2387 – Email: c e d r i c@s o l u c i o n j a v a . c om – Web: www.solucionjava.com

2. Curso de programación en Java Pagina 2 / 15
1 Índice
1 Índice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
2 Introducción al curso . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
2.1 Objetivo de este curso . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
2.2 Manual del alumno . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
2.3 Ejercicios prácticos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
2.4 Requisitos para atender a este curso . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
2.5 Soporte despues del curso . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
3 Conexión a base de datos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
3.1 Objetivo del capitulo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
3.2 Driver ODBC . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
3.3 Driver JDBC . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
3.4 Conexión . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
3.5 Ejecución de instrucciones SQL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
3.6 Paquete SolucionJava . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
4 Reciclaje de memoria . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
5 Clases interesantes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
5.1 Clase StringBuilder . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
5.2 Clase ArrayList . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
6 Streaming . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
7 Variables de sistema . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
8 Compresión y empaquetado de aplicación . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
9 Threads . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
10 Ejercicios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
11 Esquema de la base de datos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
©Copyright Cédric Simon, 2009 Versión 2.0 Reproducción prohibida

3. Curso de programación en Java Pagina 3 / 15
2 Introducción al curso
2.1 Objetivo de este curso
En este curso vamos a ver unas opciones avanzadas del lenguaje Java. Esta base les va a servir por cualquier tipo de
aplicación que desea realizar: aplicación independiente, applet, pagina web en Java…
2.2 Manual del alumno
Este manual del alumno es una ayuda para el alumno, para tenga un recuerdo del curso. Este manual contiene un
resumen de las materias que se van a estudiar durante el curso, pero el alumno debería de tomar notas personales
para completas este manual.
2.3 Ejercicios prácticos
Para captar mejor la teoría, se harán muchos ejercicios con los alumnos, para probar la teoría y verificar la
integración de la materia.
También, el alumno podrá copiar sus códigos en un disquete al fin del curso para llevarse, con fin de seguir la práctica
en su hogar.
2.4 Requisitos para atender a este curso
Se requiere un conocimiento de base del lenguaje Java, y la programación orientado a objeto. también se neceista un
conocimiento de base del lenguaje SQL.
Si el alumno tiene dificultades en un u otro capitulo, el debe sentirse libre de pedir explicaciones adicionales al
profesor.
2.5 Soporte despues del curso
Si tienes preguntas sobre la materia del curso en tus ejercicios prácticos, puedes escribir tus preguntas a
cedric@solucionjava.com.
Para informaciones sobre otros cursos, visita el sitio web www.solucionjava.com.
©Copyright Cédric Simon, 2009 Versión 2.0 Reproducción prohibida

4. Curso de programación en Java Pagina 4 / 15
3 Conexión a base de datos
Cuando se desarrolla una aplicación, muchas veces se necesita conectar a una base de datos. Java permite conectarse
a las mayorías de las base de datos, por tanto que existe un driver ODBC o mejor, JDBC.
3.1 Objetivo del capitulo
Al fin de este capitulo, el alumno será capaz de crear una conexión a una base de datos y ejecutar instrucciones en la
base de datos. Este capitulo no es una iniciación al SQL ni al manejo de base de datos.
3.2 Driver ODBC
Un driver ODBC (Open Database Connectivity) permite utilizar un driver “genérico” para conectarse a une base de
datos. Así Java se conecta al driver ODBC, y el driver ODBC se conecta a la base de datos. Es el medio más fácil de
conectarse a una base de datos, pero es mucho menos eficiente que un driver JDBC.
3.3 Driver JDBC
Un driver ODBC (Java Database Connector) es un driver diseñado para conectarse a una base de datos. Este driver
es específico a una base de datos (y a veces a una cierta versión de una base de datos).
El driver JDBC se conecta directamente a la base de datos, y como él esta diseñado para esta base de datos, tiene
normalmente muchas más opciones, y menos restricciones, que el ODBC.
3.4 Conexión
Básicamente, hay primero que cargar el driver JDBC, luego hay que conectarse a la base de datos, y si logras eso,
puedes ejecutar tus consultas SQL.
Ejemplo:
import java.sql.DriverManager;
import java.sql.SQLException;
public class TestDb {
public static void main(String[] args) {
java.sql.Connection con = null;
try {
try {
System.out.println("Buscando el driver JDBC...");
Class.forName(
"com.mysql.jdbc.Driver"
// "org.postgresql.Driver"
// "oracle.jdbc.driver.OracleDriver"
// "com.microsoft.sqlserver.jdbc.SQLServerDriver"
// "org.firebirdsql.jdbc.FBDriver"
).newInstance();
System.out.println("...Encontró el driver JDBC");
} catch (Exception e) {
System.out.println("No pudo encontrar el driver JDBC !!!!");
e.printStackTrace(System.out);
return;
}
try {
System.out.println("Connectando a la base de datos...");
con = DriverManager
.getConnection("jdbc:mysql://localhost/curso?user=curso&password=123"
// "jdbc:postgresql://localhost/curso:5432","postgres","123"
// "jdbc:oracle:thin:@192.168.0.10:1521/XE","curso","123"
// "jdbc:sqlserver://192.168.0.100:1433/database=curso/user=curso/password=123"
// "jdbc:firebirdsql:127.0.0.1:C:/firebird/data/curso.gdb","curso","123"
);
System.out.println("...Connectado a la base de datos");
} catch (Exception e) {
System.out
.println("No pudo conectarse a la base de datos !!!!");
e.printStackTrace(System.out);
return;
}
©Copyright Cédric Simon, 2009 Versión 2.0 Reproducción prohibida

5. Curso de programación en Java Pagina 5 / 15
} finally {
System.out.println("Cerrando la conexion a la base de datos.");
try {
if (con != null)
con.close();
} catch (SQLException e) {
e.printStackTrace();
}
System.out.println("Fin");
}
}
}
3.5 Ejecución de instrucciones SQL
Para poder ejecutar instrucciones SQL en la base de datos, hay que ser conectado a la a base de datos.
Una vez conectado, hay que crear la instrucción, ejecutarla, y eventualmente recoger el resultado.
Dependiendo de si la instrucción debería de regresar datos, o no, se va utilizar una lista de resultados (ResultSet) o
solamente ejecutar la instrucción.
De Java se pueden también llamar a procedimientos y funciones de la base de datos.
Para evitar problemas con juegos de carácter o caracteres especiales, es mejor utilizar CallableStatement y
PreparedStatement.
Ejemplo:
import java.sql.*;
public class TestSql {
public static void main(String[] args) {
Connection con = null;
PreparedStatement ps = null;
Statement s = null;
ResultSet rs = null;
try {
try {
System.out.println("Buscando el driver JDBC...");
Class.forName("com.mysql.jdbc.Driver"
// "org.postgresql.Driver"
// "oracle.jdbc.driver.OracleDriver"
// "com.microsoft.sqlserver.jdbc.SQLServerDriver"
// "org.firebirdsql.jdbc.FBDriver"
).newInstance();
System.out.println("...Encontró el driver JDBC");
} catch (Exception e) {
System.out.println("No pudo encontrar el driver JDBC !!!!");
e.printStackTrace(System.out);
return;
}
try {
System.out.println("Connectando a la base de datos...");
con = DriverManager
.getConnection("jdbc:mysql://localhost/curso?user=curso&password=123"
// "jdbc:postgresql://localhost/curso:5432","postgres","123"
// "jdbc:oracle:thin:@192.168.0.10:1521/XE","curso","123"
// "jdbc:sqlserver://192.168.0.100:1433/database=curso/user=curso/password=123"
// "jdbc:firebirdsql:127.0.0.1:C:/firebird/data/curso.gdb","curso","123"
);
System.out.println("...Connectado a la base de datos");
} catch (Exception e) {
System.out
.println("No pudo conectarse a la base de datos !!!!");
e.printStackTrace(System.out);
return;
}
try {
System.out
.println("Lista de empleados con salario inferior a $30,000");
s = con.createStatement();
rs = s
.executeQuery("select concat(first_name,' ',last_name) as full_name from
employee where salary < 30000");
// "select first_name||' '||last_name as full_name from employee where salary < 30000");
while (rs.next()) {
System.out.println(rs.getString("full_name"));
©Copyright Cédric Simon, 2009 Versión 2.0 Reproducción prohibida

6. Curso de programación en Java Pagina 6 / 15
}
} catch (java.sql.SQLException e) {
System.out.println("Unable to step thru results of query");
showSQLException(e);
return;
}
try {
System.out
.println("===============================================");
System.out
.println("Lista de empleados con salario entre $30,000 y $40,000");
ps = con
.prepareStatement("select concat(first_name,' ',last_name) as full_name from
employee where salary between ? and ?");
// "select first_name||' '||last_name as full_name from employee where salary between ?
and ?");
ps.setInt(1, 30000);
ps.setInt(2, 40000);
rs = ps.executeQuery();
while (rs.next()) {
System.out.println(rs.getString("full_name"));
}
} catch (java.sql.SQLException e) {
System.out.println("Unable to submit a static SQL query.");
showSQLException(e);
return;
}
} finally {
System.out.println("Cerrando la conexion a la base de datos.");
try {
if (rs != null) {
rs.close();
}
} catch (java.sql.SQLException e) {
showSQLException(e);
}
try {
if (ps != null) {
ps.close();
}
} catch (java.sql.SQLException e) {
showSQLException(e);
}
try {
if (con != null) {
con.close();
}
} catch (java.sql.SQLException e) {
showSQLException(e);
}
System.out.println("Fin");
}
}
private static void showSQLException(java.sql.SQLException e) {
java.sql.SQLException next = e;
while (next != null) {
System.out.println(next.getMessage());
System.out.println("Error Code: " + next.getErrorCode());
System.out.println("SQL State: " + next.getSQLState());
next = next.getNextException();
}
}
}
3.6 Marco de trabajo de SolucionJava
El marco de trabajo de SolucionJava trae una clase que facilita la conexión a la base de datos.
Para usarla, crea una clase que extiende com.solucionjava.db.ConnectDB y sobreescribe el metodo
initConnectionVariables().
Ver la documentacion Java del API para mas información.
Todos los archivos relacionados al marco de trabajo de SolucionJava.com se pueden descargar desde
http://solucionjava.sourceforge.net .
©Copyright Cédric Simon, 2009 Versión 2.0 Reproducción prohibida

7. Curso de programación en Java Pagina 7 / 15
4 Reciclaje de memoria
Java tiene un manejo interno de la memoria, y periódicamente, recicla la memoria que no es más utilizada,
destruyendo los objetos sin referencia en la memoria. Este acción se llama “garbage collección”.
Como Java puede consumir bastante memoria, es importante de no crear objetos que no son necesarios, y de liberar
objetos que no son más necesarios.
Un método (System.gc();) permite también de preguntar a Java de empezar el reciclaje de la memoria, pero no es por
eso que el reciclaje será total ni siempre inmediato. Llamar a la recolección de basura tiene también un costo a nivel
de performancias (probar con ejemplo aquí abajo).
Para que un objeto sea candidato al reciclaje, el no debe estar ligado a nada utlizado. Para estar seguro que su objeto
sera candidato, es mejor meterlo a nulo (null) de manera explicita.
Si la recolección 'forzada' de memoria puede ayudar en casos de progaramas usando muchas memorias, esa manera
solo retardara un poco el problema, pero no lo resolver. Hay que investigar la fuente del uso de memoria y corregirlo,
mejor que utilizar la recolección forzada de memoria.
Para investigar la fuente del problema, es posible de conocer la memoria del JVM que queda disponible utilizando el
metodo freememory() del objeto Runtime. Ver en la documentación de Java para mas detalles.
Ejemplo (probar con System.gc() y sin):
public class TestMemory {
public static void main(String[] args) {
String test="";
Runtime rt = Runtime.getRuntime();
for (int i=0;i<1000;i++) {
System.out.println("Memoria total: "+rt.totalMemory()+" - Memoria libre: "+rt.freeMemory());
test+="ffffffffffffffffffffffffffffffffffffff";
System.gc();
}
}
}
©Copyright Cédric Simon, 2009 Versión 2.0 Reproducción prohibida

8. Curso de programación en Java Pagina 8 / 15
5 Clases interesantes
5.1 Clase StringBuilder
La clase StringBuilder permite de ahorar memoria en caso de una cadena de caracteres que mucho cambia en el
tiempo (concatenacion, reemplazo,...)
La clase String crea un nuevo objeto a cada modificación del objeto, StringBuilder no.
StringBuilder tiene menos metodos que String, pero tiene las principales. Ver la documentación de Java para mas
información.
5.2 Clase ArrayList
La clase ArrayList, del paquete java.util permite construir arreglos de tamaño dinamico, y de poder ordenar sus
valores. Los arreglos normales en Java tienen un tamaño definido al inicializar el arreglo, y no se puede cambiar sin
crear otro objeto. ArrayList permite manejar estos arreglos por los cuales el tamaño es dinamico. Hay que notar que
un arreglo normal Java es mucho mas rápido de recorrer que un ArrayList, pero el ArrayList tiene su uso cuando no
se conoce el tamaño maximum al inicializar el arreglo.
Ver la documentación de Java para mas información.
©Copyright Cédric Simon, 2009 Versión 2.0 Reproducción prohibida

9. Curso de programación en Java Pagina 9 / 15
6 Streaming
El “streaming” permite de crear un flujo de datos. Esto permite leer y/o archivos (textos, sonidos, imágenes,....). Es
también posible sacar el nombre, tamaño,... de un archivo.
El streaming es por ejemplo necesario para insertar o leer objetos muy grande en la base de datos (BLOB, CLOB,...),
o mostrar una imagen en JSP. Con el flujo se pueden manejar cualquier tipo de archivo binario.
Los streams pueden manejar entrada como salida de flujos.
Ejemplo 1: Listar archivos
import java.io.*;
public class TestArchivo
{
public static String leer()
{
InputStreamReader isr = new InputStreamReader(System.in);
BufferedReader br = new BufferedReader(isr);
try
{
return br.readLine();
}
catch(Exception e)
{}
return "";
}
public static void main (String[] args)
{
System.out.println("Indique nombre de subdirectorio");
System.out.println("Trayectoria absoluta, por ej: C:java");
String nomdir = leer();
File arch = new File(nomdir);
if (arch.exists())
if (arch.isDirectory())
{
System.out.println("Contenido de "+nomdir);
String arr[] = arch.list();
for(int j = 0; j < arr.length; j++)
{
File otro = new File(nomdir + ""+arr[j]);
if (otro.isDirectory())
System.out.println(arr[j]+ " <DIR>");
else
System.out.println(arr[j]);
}
}
else
System.out.println(nomdir+" no es un directorio");
else
System.out.println("No existe");
}
}
Ejemplo 2: Leer archivo via URL
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.URL;
import java.net.URLConnection;
public class LeerURL {
public LeerURL() {
// TODO Auto-generated constructor stub
}
public static void main(String[] args) {
if (args[0]==null)
System.out.println("Se espera un parametro al llamar al metodod main!");
URL miURL=null;
try {
miURL = new URL("http://192.168.0.10/"+args[0]);
URLConnection yc = miURL.openConnection();
BufferedReader in = new BufferedReader(
new InputStreamReader(
yc.getInputStream()));
String inputLine;
System.out.println("<h1>Leyendo archivo</h1><hr>");
// Leer archivo
while ((inputLine = in.readLine()) != null)
©Copyright Cédric Simon, 2009 Versión 2.0 Reproducción prohibida

10. Curso de programación en Java Pagina 10 / 15
{
try {
System.out.println(inputLine);
int lineSize=inputLine.length();
System.out.println(lineSize);
}
catch (Exception e1) {
in.close();
in=null;
e1.printStackTrace();
System.out.println("Error leyendo el archivo. "+e1);
break;
}
} // while
// System.System.out.println(inputLine);
in.close();
in=null;
}
catch(java.io.FileNotFoundException e1)
{
System.out.println("<hr><h1><font color=red>El archivo http://192.168.0.10/'"+args[0]);
}
catch (Exception e) {
System.out.println("Error: >"+e);
}
}
}
©Copyright Cédric Simon, 2009 Versión 2.0 Reproducción prohibida

11. Curso de programación en Java Pagina 11 / 15
7 Variables de sistema
En Java, es posible de recuperar ciertas variables de sistema. Ciertas variables estan constantes por un sistemo
operativo dado, otras se pueden definir o modificar al enceder la JVM utilizando la opcion -D<nombre>=<valor>.
Ejemlo:
import java.awt.GraphicsDevice;
import java.awt.GraphicsEnvironment;
import javax.swing.UIManager;
public class SystemProp {
public static void main(String[] args) {
try {
String msg = "Propriedades del sisteman";
msg = msg + "Version de Java: " +System.getProperty("java.vm.version") + "n";
msg = msg + "Vendor: " +
System.getProperty("java.vm.vendor") + " - Web:" +
System.getProperty("java.vendor.url") + "nn";
msg = msg + "Version de Windows: " +
System.getProperty("os.name") + " " +
System.getProperty("os.version") + " " +
System.getProperty("sun.os.patch.level") + "n";
msg = msg + "OS architectura: " +System.getProperty("os.arch") + "nn";
GraphicsEnvironment env =
GraphicsEnvironment.getLocalGraphicsEnvironment();
msg = msg + "Resolución de pantalla: " +
(int) env.getMaximumWindowBounds().getMaxX()+" x "+(int) env.getMaximumWindowBounds().getMaxY() + "n";
GraphicsDevice device = env.getDefaultScreenDevice();
int bytes = device.getAvailableAcceleratedMemory();
int mbytes = bytes /1048576;
msg = msg + "Memoria grafica: " +
mbytes + " MBnn";
msg = msg + "Look & Feel disponibles:n ";
UIManager.LookAndFeelInfo[] info = UIManager.
getInstalledLookAndFeels();
for (int i = 0; i < info.length; i++) {
// Get the name of the look and feel that is suitable for display to the user
String humanReadableName = info[i].getName();
String className = info[i].getClassName();
msg = msg + " "+humanReadableName + " - " + className+"n";
}
msg = msg + "n";
msg = msg + "Archivo del programa: " +System.getProperty("user.dir") + "nn";
msg = msg + "CPU: " +System.getProperty("sun.cpu.isalist") + "nn";
msg = msg + "Usuario: " +System.getProperty("user.name") + "n";
msg = msg + "Idioma: " +System.getProperty("user.language") + "n";
msg = msg + "Encoding: " +System.getProperty("sun.jnu.encoding") + "nn";
msg = msg + "Tempdir: " +System.getProperty("java.io.tmpdir") + "n";
msg = msg + "Java CLASS path: " +System.getProperty("java.class.path") + "nn";
msg = msg + "Java path: " +System.getProperty("sun.boot.class.path") + "nn";
msg = msg + "Java LIB path: " +System.getProperty("java.ext.dirs") + "nn";
msg = msg + "Windows path: " +
System.getProperty("java.library.path") + "nn";
System.out.println(msg);
} catch (Exception ex) {
System.out.println("Error in SystemProp() constructor" +
ex.getMessage());
}
}
}
©Copyright Cédric Simon, 2009 Versión 2.0 Reproducción prohibida

12. Curso de programación en Java Pagina 12 / 15
8 Compresión y empaquetado de aplicación
Para reducir el tamaño de una aplicación asi como juntar todos los archivos juntos, se puede crear un archivo Jar que
sera leido y descromprimido por Java.
El uso de un manifest permite indicar a Java cual es la clase que hay que utilizar para iniciar la aplicación, y
eventualmente indicar cuales otros paquetes JAR (drivers,...) hay que incluir en el classpath.
Los códigos Java estan casi siempre disptribuidos en archivos Jar (drivers, aplicaciones,...). El archivo Jar puede
contener otros archivos que los archivos Java, como imagenes, textos, sonidos,...
Existen progarmas (como por ejemplo Jsmooth) que esconden un archivo en un archivo EXE para correr bajo
Windows como una aplicación usual de windows.
Para iniciar la aplicación, se utiliza la option -jar de Java. Ejemplo: java -jar miArchivo.jar
Ejemplo de manifest.txt:
Manifest-Version: 1.0
Main-Class: prueba.Main
Created-By: Cedric Simon – www.SolutionJava.com
Class-Path: mysql-connector-java-5.1.5-bin.jar
Ejemplo:
jar -cmf manifest.txt prueba.jar prueba/*.* dbaccess/*.*
Este va a crear un archivo prueba.jar continiendo los archivos de la carpeta corriente mas los de las carpetas (paquetes) prueba
y dbaccess. El manifest.txt indica que la clase de arraque (que contiene el metodo main) es la clase Main del paquete prueba, y
hay que incluir el archivo mysql-connector-java-5.1.5-bin.jar (como mencionado aquí, se encuentra en la misma carpeta que
prueba.jar) en el classpath.
©Copyright Cédric Simon, 2009 Versión 2.0 Reproducción prohibida

13. Curso de programación en Java Pagina 13 / 15
9 Threads
Las “threads” son hilos de ejecución. Java por defecto trabaja con solo un hilo de ejecución, pero se puede crear varios
hilos de ejecución para ejecutar varias tareas el mismo tiempo.
Los threads o hilos de ejecución permiten organizar los recursos del ordenador de forma que
pueda haber varios programas actuando en paralelo. Un hilo de ejecución puede realizar cualquier tarea que pueda
realizar un programa normal y corriente. Bastará con indicar lo que tiene que hacer en el método run(), que es el que
define la actividad principal de las threads.
Los threads pueden ser daemon o no daemon. Son daemon aquellos hilos que realizan en
background (en un segundo plano) servicios generales, esto es, tareas que no forman parte de la esencia del programa
y que se están ejecutando mientras no finalice la aplicación. Un thread daemon podría ser por ejemplo aquél que está
comprobando permanentemente si el usuario pulsa un botón. Un programa de Java finaliza cuando sólo quedan
corriendo threads de tipo daemon. Por defecto, y si no se indica lo contrario, los threads son del tipo no daemon.
Java proporciona métodos para manejar cada hilo de ejecución. Estos métodos permiten entre otros de parar,
cancelar, reanudar hilos de ejecución, así como definir prioridades entre hilos. Ejemplos de métodos : wait(), sleep(),
notify(), suspend(), resume(), stop(),...
Ejemplo de Thread:
public class SimpleThread extends Thread {
// constructor
public SimpleThread (String str) {
super(str);
}
// redefinición del método run()
public void run() {
for(int i=0;i<10;i++)
System.out.println("Este es el thread : " + getName());
}}
public class TestThread {
public static void main(String[] args) { // metodo principal
SimpleThread miThread = new SimpleThread("Hilo de prueba");
miThread.start();
} // fin de metodo Main
} // fin de clase TestThread
Ejemplo de Runnable:
public class SimpleRunnable implements Runnable {
// se crea un nombre
String nameThread;
// constructor
public SimpleRunnable(String str) {
nameThread = str;
}
// definición del método run()
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println("Este es el thread: " + nameThread); }
}
}
public class TestRunnable {
public static void main(String[] args) { // metodo principal
TestRunnable miTest = new TestRunnable();
SimpleRunnable p = new SimpleRunnable("Hilo de prueba");
// se crea un objeto de la clase Thread pasándolo el objeto Runnable como argumento
Thread miThread = new Thread(p);
// se arranca el objeto de la clase Thread
miThread.start();
} // fin de metodo Main
}
©Copyright Cédric Simon, 2009 Versión 2.0 Reproducción prohibida

14. Curso de programación en Java Pagina 14 / 15
10Ejercicios
1) Conectarse a la base de datos y sacar una lista de los primeros 5 empleados.
2) Crear una clase que extiende com.solucionjava.db.ConnectDB y utilizarla de desde otra clase.
3) Probar el ejemplo de uso de memoria con y sin System.gc(). Comparar el uso de memoria utilizando StringBuilder
en ves de String.
4) Utilizar la clase ArrayList para crear una arreglo dinamico, y ordenar el arreglo.
5) Leer un archivo del disco de desde una clase Java
6) Pasar una variable al iniciar Java y leerla de desde una clase.
7) Crear un archivo Jar que continene una pequña aplicación y ejecutarla utilizando el archivo Jar.
©Copyright Cédric Simon, 2009 Versión 2.0 Reproducción prohibida

15. Curso de programación en Java Pagina 15 / 15
11Esquema de la base de datos
©Copyright Cédric Simon, 2009 Versión 2.0 Reproducción prohibida