Final Presentation

🎤 Exposición: Manejo de Archivos en Java¶

🎯 1. Importancia del Manejo de Archivos en Programación (2 min)¶

El manejo de archivos es fundamental en la mayoría de los lenguajes de programación porque permite la persistencia de datos, la comunicación entre programas y la gestión eficiente de la información. A continuación, abordaremos su importancia, la razón de su funcionalidad y algunos puntos clave en Java.

Persistencia de Datos
- A diferencia de las variables en memoria, los archivos permiten almacenar información de manera permanente, incluso después de que el programa se cierre.
- Intercambio de Información
- Muchas aplicaciones dependen de archivos para comunicarse con otros sistemas, ya sea mediante logs, bases de datos o archivos de configuración.
- Procesamiento de Datos
- En ciencia de datos, seguridad informática y desarrollo web, es común manejar grandes volúmenes de información mediante archivos.

📌 2. Clases de manejo de archivos Java (4 min)¶

Java usa el paquete java.io para trabajar con archivos.

Lectura de Archivos (FileReader & FileWriter)¶

El uso de estas clases para la manipulación de archivos, se recomienda para archivos de texto pequeños, esto debido a que FileReader permite leer archivos carácter por carácter,

FileReader se utiliza para leer caracteres desde un archivo de texto. Es adecuado cuando se trabaja con datos en formato de texto plano (como .txt).

import java.io.FileReader;
import java.io.IOException;

public class FileReaderExample {
    public static void main(String[] args) {
        try (FileReader reader = new FileReader("archivo.txt")) {
            int character;
            while ((character = reader.read()) != -1) {
                System.out.print((char) character);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

FileWriter se utiliza para escribir caracteres en un archivo de texto. Si el archivo no existe, se crea automáticamente.

import java.io.FileWriter;
import java.io.IOException;

public class FileWriterExample {
    public static void main(String[] args) {
        try (FileWriter writer = new FileWriter("archivo.txt")) {
            writer.write("Hola, este es un ejemplo de FileWriter.");
            writer.write("\nOtra línea de texto.");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Uso de \(InputStream\) y \(OutputStream\) en Java¶

Son clases fundamentales para trabajar con flujos de bytes, y se utilizan generalmente para manejar archivos binarios (aunque también pueden leer y escribir texto codificado en ciertos formatos).

1. `InputStream`¶

InputStream es una clase abstracta que representa un flujo de entrada de bytes. La mayoría de las clases que la extienden se utilizan para leer datos de diversas fuentes (archivos, memoria, redes, etc.).

import java.io.FileInputStream;
import java.io.IOException;

public class FileInputStreamExample {
    public static void main(String[] args) {
        try (FileInputStream inputStream = new FileInputStream("archivo.bin")) {
            int byteData;
            while ((byteData = inputStream.read()) != -1) {
                System.out.print((char) byteData); // Convertir el byte a carácter para mostrar
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

2. `OutputStream`¶

OutputStream es una clase abstracta que representa un flujo de salida de bytes. Sus subclases permiten escribir datos en archivos, redes o memoria.

import java.io.FileOutputStream;
import java.io.IOException;

public class FileOutputStreamExample {
    public static void main(String[] args) {
        try (FileOutputStream outputStream = new FileOutputStream("archivo.bin")) {
            String data = "Este es un archivo binario.";
            outputStream.write(data.getBytes()); // Convertir el texto a bytes y escribir
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

¶

🚀 3. Manejo Eficiente de Archivos Grandes (5 min)¶

Cuando trabajamos con archivos grandes, es ineficiente cargarlos enteros en memoria.

Escritura en Archivos (BufferedReader & BufferedWriter)¶

A Diferencia de FileReader que también se usan para leer archivos la ventaja de usar BufferedReader y BufferedWriter es que permite la escritura y lectura de archivos agregando buffering, lo que permite reducir la cantidad de acceso al disco y mejora el rendimiento.

🚀 Ventajas principales¶

1️⃣ Mejor rendimiento en lectura y escritura de texto¶

En lugar de leer/escribir carácter por carácter, estas clases almacenan los datos en un buffer interno (por defecto 8 KB).
Disminuyen la cantidad de accesos al disco, lo que acelera la lectura y escritura.

2️⃣ Menos operaciones de entrada/salida (E/S)¶

Sin BufferedReader, FileReader.read() accede al archivo cada vez que se lee un carácter.
Con BufferedReader, los datos se leen en bloques, reduciendo el número de interacciones con el sistema de archivos.

3️⃣ Métodos convenientes como `readLine()`¶

BufferedReader permite leer líneas completas con readLine(), lo que es más eficiente que leer carácter por carácter con FileReader.

Ejemplo:

BufferedReader br = new BufferedReader(new FileReader("archivo.txt"));
String linea;
while ((linea = br.readLine()) != null) {
    System.out.println(linea);
}

4️⃣ Mejor manejo de memoria¶

Al reducir el número de accesos al disco, también disminuye el consumo de memoria y CPU.
Útil en archivos grandes, ya que evita cargar todo el archivo en la RAM de una sola vez.

5️⃣ Tamaño de buffer configurable¶

Puedes definir el tamaño del buffer para optimizar el rendimiento según el tamaño del archivo.

  BufferedReader br = new BufferedReader(new FileReader("archivo.txt"), 16384); // 16 KB buffer

6️⃣ Escritura eficiente con `BufferedWriter`¶

BufferedWriter agrupa múltiples operaciones de escritura antes de escribir al disco.

Uso del método flush() para forzar la escritura inmediata:

BufferedWriter bw = new BufferedWriter(new FileWriter("salida.txt"));
bw.write("Ejemplo de texto con BufferedWriter");
bw.newLine(); // Agrega una nueva línea
bw.flush(); // Asegura que los datos se escriban en el archivo
bw.close();

Ejemplo Completo¶

Lectura eficiente con BufferedReader

import java.io.*;

public class BufferedReaderExample {
    public static void main(String[] args) {
        try (BufferedReader br = new BufferedReader(new FileReader("archivo.txt"))) {
            String linea;
            while ((linea = br.readLine()) != null) {
                System.out.println(linea);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Escritura eficiente con BufferedWriter

import java.io.*;

public class BufferedWriterExample {
    public static void main(String[] args) {
        try (BufferedWriter bw = new BufferedWriter(new FileWriter("salida.txt"))) {
            bw.write("Primera línea");
            bw.newLine();
            bw.write("Segunda línea con BufferedWriter");
            bw.flush(); // Asegura que los datos se escriban
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

📌 Cuándo usarlos¶

✅ Cuando necesitas leer archivos de texto grandes línea por línea sin cargar todo en memoria.
✅ Si escribes grandes volúmenes de texto, evitando múltiples accesos al disco.
✅ Cuando necesitas manejar eficientemente buffers y mejorar el rendimiento.
✅ Si trabajas con archivos de configuración, logs, o archivos de texto extensos.

❌ No es necesario si el archivo es muy pequeño o si solo necesitas una lectura rápida de un par de líneas.

Escritura en Archivos (`BufferedInputStream` & `BufferedOutputStream`)¶

Estas clases son versiones mejoradas de FileInputStream y FileOutputStream, ya que agregan buffering, lo que reduce la cantidad de accesos al disco y mejora el rendimiento al leer y escribir archivos grandes.

🚀 Ventajas principales¶

🔄 Menos accesos al disco (Mejor rendimiento)
- Sin buffering, cada read() o write() accede directamente al archivo en disco.
- Con BufferedInputStream y BufferedOutputStream, se leen/escriben bloques completos en memoria antes de interactuar con el disco, lo que reduce la latencia y aumenta la velocidad.
- 📈 Lectura y escritura más eficiente
- En vez de leer/escribir byte por byte, trabajan con bloques de datos (por defecto 8 KB, pero puede ajustarse).
- Ideal para manejar archivos grandes, ya que disminuye la sobrecarga del sistema.
- 🔧 Mayor flexibilidad con tamaños de buffer personalizados
- Puedes especificar el tamaño del buffer al crear el flujo:
```
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("archivo.dat"), 16384); // 16 KB buffer
```
- Útil si necesitas optimizar la memoria en función del tamaño del archivo.
- ⚡ Reducción de operaciones de E/S costosas
- Al agrupar lecturas/escrituras en bloques grandes, minimizan las llamadas a syscalls (interacciones con el sistema operativo).
- Esto reduce la carga en el CPU y mejora la eficiencia en sistemas con discos lentos o redes remotas.
- 💾 Compatible con otros Streams
- Se pueden encadenar con otras clases de InputStream y OutputStream, como DataInputStream, ObjectInputStream, GZIPInputStream, etc.
- Ejemplo: Leer datos primitivos con buffering:
```
DataInputStream dis = new DataInputStream(new BufferedInputStream(new FileInputStream("datos.bin")));
```
🛠️ Mejora el rendimiento de compresión y descompresión
- En archivos comprimidos (.zip, .gzip), el buffering permite leer y escribir datos más rápido cuando se combinan con GZIPInputStream o ZipInputStream.

Ejemplo práctico¶

Lectura eficiente con `BufferedInputStream`¶

import java.io.*;

public class BufferedStreamExample {
    public static void main(String[] args) {
        try (BufferedInputStream bis = new BufferedInputStream(new FileInputStream("large_file.bin"))) {
            byte[] buffer = new byte[8192]; // 8 KB buffer
            int bytesRead;
            while ((bytesRead = bis.read(buffer)) != -1) {
                // Procesar los datos del buffer
            }
            System.out.println("Lectura completada con BufferedInputStream.");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Escritura eficiente con `BufferedOutputStream`¶

import java.io.*;

public class BufferedOutputStreamExample {
    public static void main(String[] args) {
        try (BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("output.bin"))) {
            byte[] data = "Texto de prueba".getBytes();
            bos.write(data);
            System.out.println("Escritura completada con BufferedOutputStream.");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

📌 Cuándo usarlos¶

✅ Si trabajas con archivos grandes, donde la eficiencia es clave.
✅ Si realizas múltiples lecturas/escrituras pequeñas en un archivo.
✅ Si el programa maneja archivos en red (para reducir tráfico innecesario).
✅ Cuando quieras mejorar el rendimiento sin cambiar la estructura del código.

❌ No es necesario si el archivo es muy pequeño o si se lee/escribe en una sola operación.

En resumen, BufferedInputStream y BufferedOutputStream optimizan el rendimiento al manejar archivos binarios, reduciendo accesos al disco y mejorando la eficiencia en operaciones de lectura/escritura. 🚀

🚀 4. Manejo de Archivos con `Files` (Java NIO)¶

Desde Java 7, la API Java NIO (New Input/Output) introdujo la clase Files en el paquete java.nio.file, que ofrece una manera más eficiente, flexible y segura de manejar archivos en comparación con java.io.

🚀 Ventajas de `Files` en Java NIO¶

1️⃣ Más rápido que java.io

Usa NIO (Non-blocking I/O), optimizando el acceso a archivos mediante buffers y canales.
Evita el uso de FileReader o BufferedReader para lectura y escritura de archivos.

2️⃣ Operaciones simplificadas

Métodos listos para leer, escribir, copiar, mover y eliminar archivos con una sola línea de código.

3️⃣ Soporte para Path y Paths

java.nio.file.Path permite manipular rutas de archivos de manera más eficiente que File.

4️⃣ Manejo seguro de archivos

Detecta errores con NoSuchFileException, DirectoryNotEmptyException, etc.
Permite ver permisos, atributos y modificar propiedades fácilmente.

📌 Operaciones Básicas con `Files`¶

📌 Lectura de Archivo usando \(readAllLines()\)¶

📄 1️⃣ Leer un archivo completo¶

import java.nio.file.*;
import java.io.IOException;
import java.util.List;

public class ReadFileExample {
    public static void main(String[] args) {
        try {
            Path path = Paths.get("archivo.txt");
            List<String> lines = Files.readAllLines(path); // Lee todas las líneas en una lista
            lines.forEach(System.out::println); // Imprime el contenido
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

📌 Ventaja: Más eficiente que BufferedReader.readLine() si necesitas todo el archivo en memoria.

Ventajas y Desventajas¶

Ventajas:
- Acceso inmediato a todos los datos:
  Devuelve una List<String> con todas las líneas del archivo, lo que facilita operaciones como búsquedas, ordenamientos o modificaciones en toda la colección de líneas.
- Simplicidad en el código:
  Es fácil de usar y resulta muy conveniente para archivos de tamaño moderado o pequeño, donde no hay problemas de memoria.
- Manipulación directa:
  Al tener todas las líneas en una lista, puedes iterar, modificar o acceder a cualquier elemento de forma aleatoria sin necesidad de volver a leer el archivo.
Desventajas:
- Carga completa en memoria:
  Lee todo el archivo de una vez, lo que puede generar problemas de rendimiento o incluso causar un OutOfMemoryError si el archivo es muy grande.
- Menor flexibilidad para procesamiento secuencial:
  Si sólo necesitas procesar el archivo línea por línea y descartar los datos ya procesados, esta opción no es la más eficiente, ya que carga innecesariamente el contenido completo en memoria.
📜 Uso de Files.lines()¶

El método Files.lines(Path path) devuelve un Stream, lo que significa que lee el archivo línea por línea, en lugar de cargar todo el archivo en memoria de una sola vez. Esto es ideal para manejar archivos grandes.

📌 Ejemplo: Leer un archivo línea por línea¶

import java.nio.file.*;
import java.io.IOException;
import java.util.stream.Stream;

public class FilesLinesExample {
    public static void main(String[] args) {
        Path path = Paths.get("archivo_grande.txt");

        try (Stream<String> lines = Files.lines(path)) {
            lines.forEach(System.out::println); // Procesa cada línea
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

✅ Ventajas de Files.lines():

No carga todo el archivo en memoria. Usa lazy loading (carga perezosa).
Es más eficiente para archivos grandes, ya que solo procesa una línea a la vez.
Compatible con operaciones funcionales de Streams (filter(), map(), collect(), etc.).

🔍 Ejemplo: Filtrar líneas que contienen una palabra clave¶

Si queremos filtrar solo las líneas que contienen una palabra específica, podemos usar filter():

import java.nio.file.*;
import java.io.IOException;
import java.util.stream.Stream;

public class FilterLinesExample {
    public static void main(String[] args) {
        Path path = Paths.get("archivo.txt");

        try (Stream<String> lines = Files.lines(path)) {
            lines.filter(line -> line.contains("error"))  // Filtra líneas que contengan "error"
                 .forEach(System.out::println); // Imprime solo esas líneas
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

📌 Ideal para analizar logs y extraer información relevante.

🔄 Ejemplo: Contar líneas de un archivo¶

Podemos contar cuántas líneas tiene el archivo sin cargarlo en memoria completamente:

import java.nio.file.*;
import java.io.IOException;
import java.util.stream.Stream;

public class CountLinesExample {
    public static void main(String[] args) {
        Path path = Paths.get("archivo.txt");

        try (Stream<String> lines = Files.lines(path)) {
            long count = lines.count(); // Cuenta las líneas
            System.out.println("Número de líneas: " + count);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

📌 Más eficiente que Files.readAllLines().size() porque no carga todas las líneas en una lista.

✍ Ejemplo: Transformar el contenido del archivo¶

Podemos aplicar una transformación a cada línea antes de imprimirla, por ejemplo, convertir todo a mayúsculas:

import java.nio.file.*;
import java.io.IOException;
import java.util.stream.Stream;

public class UppercaseLinesExample {
    public static void main(String[] args) {
        Path path = Paths.get("archivo.txt");

        try (Stream<String> lines = Files.lines(path)) {
            lines.map(String::toUpperCase) // Convierte cada línea a mayúsculas
                 .forEach(System.out::println);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

📌 Ventaja: Se pueden encadenar múltiples transformaciones sin afectar el rendimiento.

⚠ Consideraciones al usar `Files.lines()`¶

1️⃣ Recuerda cerrar el Stream

Se recomienda usar try-with-resources (try (...) {}) para evitar fugas de memoria.

2️⃣ No usar Files.lines() si necesitas todas las líneas en memoria

Para esto, es mejor Files.readAllLines(), que devuelve una List<String>.

3️⃣ Si el archivo es muy grande, evita count() en Streams sin filter()

lines.count() recorrerá todo el archivo, lo cual puede ser costoso si no lo necesitas.

Ventajas y Desventajas¶

Ventajas:
- Lectura perezosa (Lazy Loading):
  Lee el archivo línea por línea conforme se procesa el stream, sin cargar todo el contenido en memoria. Esto es ideal para archivos muy grandes.
- Uso de Streams:
  Permite aprovechar las operaciones funcionales (como filter(), map(), reduce(), etc.) que ofrece la API de Streams de Java, facilitando el procesamiento y la transformación de datos.
- Eficiencia en memoria:
  Al no cargar todo el archivo de una vez, se reduce el riesgo de agotar la memoria y se mejora el rendimiento para operaciones secuenciales.
Desventajas:
- Manejo de recursos:
  Es necesario asegurarse de cerrar el stream (usando try-with-resources, por ejemplo) para evitar fugas de recursos, ya que el stream mantiene abierta la conexión al archivo durante su procesamiento.
- Una sola pasada:
  Una vez consumido, el stream no se puede reutilizar. Si necesitas procesar el archivo varias veces, tendrás que volver a invocar Files.lines().
- Operaciones que requieren materialización completa:
  Si requieres acceder aleatoriamente a todas las líneas (por ejemplo, para ordenarlas o indexarlas), tendrás que convertir el stream a una colección, lo que implica cargar todo en memoria.

✍ 2️⃣ Escribir en un archivo¶

import java.nio.file.*;
import java.io.IOException;
import java.util.Arrays;

public class WriteFileExample {
    public static void main(String[] args) {
        try {
            Path path = Paths.get("output.txt");
            Files.write(path, Arrays.asList("Primera línea", "Segunda línea"), StandardOpenOption.CREATE);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

📌 Ventaja: Escribe directamente sin necesidad de BufferedWriter.

📑 3️⃣ Copiar un archivo¶

import java.nio.file.*;
import java.io.IOException;

public class CopyFileExample {
    public static void main(String[] args) {
        try {
            Path source = Paths.get("archivo.txt");
            Path destination = Paths.get("archivo_copia.txt");
            Files.copy(source, destination, StandardCopyOption.REPLACE_EXISTING);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

📌 Ventaja: No necesitas leer y escribir manualmente; Files.copy() lo hace por ti.

📂 4️⃣ Mover o renombrar un archivo¶

import java.nio.file.*;
import java.io.IOException;

public class MoveFileExample {
    public static void main(String[] args) {
        try {
            Path source = Paths.get("archivo.txt");
            Path destination = Paths.get("nueva_carpeta/archivo_movido.txt");
            Files.move(source, destination, StandardCopyOption.REPLACE_EXISTING);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

📌 Ventaja: Es más eficiente que copiar manualmente y eliminar el archivo original.

🗑 5️⃣ Eliminar un archivo¶

import java.nio.file.*;
import java.io.IOException;

public class DeleteFileExample {
    public static void main(String[] args) {
        try {
            Path path = Paths.get("archivo_a_eliminar.txt");
            Files.delete(path);
            System.out.println("Archivo eliminado");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

📌 Nota: Lanza una excepción si el archivo no existe. Usa Files.deleteIfExists(path); para evitar errores.

🔍 Manejo de Directorios con `Files`¶

📂 Listar archivos en un directorio¶

import java.nio.file.*;
import java.io.IOException;
import java.nio.file.attribute.BasicFileAttributes;

public class ListDirectoryExample {
    public static void main(String[] args) {
        try {
            Path dir = Paths.get("mi_directorio");
            Files.list(dir).forEach(System.out::println);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

📌 Ventaja: Alternativa moderna a File.listFiles(), permitiendo más flexibilidad.

📑 Obtener información de un archivo¶

import java.nio.file.*;
import java.io.IOException;
import java.nio.file.attribute.BasicFileAttributes;

public class FileAttributesExample {
    public static void main(String[] args) {
        try {
            Path path = Paths.get("archivo.txt");
            BasicFileAttributes attr = Files.readAttributes(path, BasicFileAttributes.class);

            System.out.println("Tamaño: " + attr.size());
            System.out.println("Creado en: " + attr.creationTime());
            System.out.println("Última modificación: " + attr.lastModifiedTime());
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

📌 Ventaja: Puedes acceder a información avanzada sin usar File.

🆚 Diferencias entre `Files` y `java.io`¶

Característica	`java.io` (`File`)	`java.nio.file.Files`
Acceso a archivos	Orientado a streaming (bloqueante)	Orientado a buffers y canales (más rápido)
Lectura/escritura	`FileReader`, `BufferedReader`, `FileWriter`	`Files.readAllLines()`, `Files.write()`
Copiar/mover archivos	Manualmente con `FileInputStream` y `FileOutputStream`	`Files.copy()`, `Files.move()`
Crear/eliminar archivos	`file.createNewFile()`, `file.delete()`	`Files.createFile()`, `Files.delete()`
Listar directorios	`File.listFiles()`	`Files.list()` con Streams
Seguridad	Menos control de excepciones	Más seguro con excepciones específicas (`NoSuchFileException`, etc.)
#### Resumen

Usa Files.lines() cuando:
- Trabajas con archivos grandes.
- Quieres procesar el contenido de forma secuencial y aprovechar operaciones funcionales.
- Deseas minimizar el uso de memoria mediante lectura perezosa.
- Usa Files.readAllLines() cuando:
- El tamaño del archivo es pequeño o moderado.
- Necesitas acceso aleatorio o realizar múltiples operaciones en el conjunto completo de líneas.
- Prefieres una solución simple y directa sin preocuparte por la gestión manual del stream.

En definitiva, la elección depende del tamaño del archivo y de las necesidades específicas de procesamiento en tu aplicación.

🎯 5. Buenas Prácticas en el Manejo de Archivos (3 min)¶

1️⃣ Siempre cerrar archivos después de usarlos (try-with-resources).
2️⃣ Usar buffering (BufferedReader, BufferedWriter) para mejorar el rendimiento.
3️⃣ Evitar leer archivos grandes en memoria (usar InputStream).
4️⃣ Manejar excepciones adecuadamente (IOException).
5️⃣ Preferir Files de java.nio.file para operaciones simples.

Interfaces Graficas de Usuario¶

Las Interfaces Gráficas de Usuario (GUI) en Java permiten crear aplicaciones visuales con botones, ventanas, formularios y otros elementos interactivos.

🎯 1. ¿Qué son las GUI en Java?¶

Son interfaces que permiten a los usuarios interactuar con una aplicación de forma visual, en lugar de solo usar la línea de comandos.

Principales tecnologías para GUI en Java¶

Java ofrece diferentes herramientas para desarrollar interfaces gráficas:
1️⃣ AWT (Abstract Window Toolkit) → Antiguo, basado en componentes nativos del sistema operativo.
2️⃣ Swing → Más avanzado, con componentes más personalizables.
3️⃣ JavaFX → Moderno, más potente, permite diseño avanzado con CSS y efectos gráficos.

🚀 2. Creación de una GUI con Swing¶

Swing es la tecnología más usada en Java para GUI. Sus componentes incluyen:

JFrame → Ventana principal
JButton → Botón
JLabel → Etiqueta de texto
JTextField → Campo de texto
JPanel → Contenedor de componentes

Ejemplo de una ventana simple con un botón:

import javax.swing.*;

public class MiVentana {
    public static void main(String[] args) {
        JFrame frame = new JFrame("Mi primera ventana");
        JButton button = new JButton("Haz clic aquí");

        frame.setSize(300, 200);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.add(button);
        frame.setVisible(true);
    }
}

✅ Crea una ventana de 300x200 px con un botón.
✅ setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); cierra la app al cerrar la ventana.

📌 3. Eventos en GUI con Java¶

1. Explicación de Eventos en Java GUI¶

Los eventos en una interfaz gráfica de usuario (GUI) son acciones que ocurren debido a la interacción del usuario, como hacer clic en un botón, presionar una tecla o mover el mouse. Java proporciona un modelo de manejo de eventos basado en oyentes (listeners), que permite responder a estas acciones de manera eficiente.

2. Tipos de Eventos¶

A continuación, se presentan algunos de los eventos más comunes en Java GUI:

Eventos de Acción¶

Se activan cuando el usuario interactúa con elementos como botones y menús.
Se manejan con ActionListener en Swing y setOnAction() en JavaFX.

Eventos de Teclado¶

Detectan cuando el usuario presiona, libera o mantiene presionada una tecla.
Se manejan con KeyListener en Swing y setOnKeyPressed() en JavaFX.

Eventos de Mouse¶

Incluyen clics, movimientos, entradas y salidas del puntero del mouse.
Se manejan con MouseListener en Swing y setOnMouseClicked() en JavaFX.

Eventos de Ventana¶

Capturan acciones como minimizar, maximizar y cerrar la ventana.
Se manejan con WindowListener en Swing y setOnCloseRequest() en JavaFX.

3. Comparación entre Swing y JavaFX¶

Característica	Swing	JavaFX
Antigüedad	Más antiguo	Más moderno
Soporte CSS	No	Sí
Animaciones avanzadas	Limitado	Integrado
Diseño de UI	Código en Java	FXML + Java

4. Código de Ejemplo¶

Ejemplo en Swing (Manejo de botón)¶

import javax.swing.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

public class EventoSwing {
    public static void main(String[] args) {
        JFrame frame = new JFrame("Ejemplo Swing");
        JButton button = new JButton("Click Me");

        button.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                System.out.println("Botón presionado");
            }
        });

        frame.add(button);
        frame.setSize(300, 200);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setVisible(true);
    }
}

Ejemplo en JavaFX (Manejo de botón)¶

import javafx.application.Application;
import javafx.scene.Scene;
import javafx.scene.control.Button;
import javafx.scene.layout.StackPane;
import javafx.stage.Stage;

public class EventoJavaFX extends Application {
    @Override
    public void start(Stage primaryStage) {
        Button button = new Button("Click Me");
        button.setOnAction(e -> System.out.println("Botón presionado"));

        StackPane root = new StackPane();
        root.getChildren().add(button);

        primaryStage.setScene(new Scene(root, 300, 200));
        primaryStage.setTitle("Ejemplo JavaFX");
        primaryStage.show();
    }

    public static void main(String[] args) {
        launch(args);
    }
}

5. Beneficios de JavaFX sobre Swing¶

Interfaz más moderna y estilizada.
Mejor rendimiento en gráficos avanzados.
Compatible con aplicaciones web y móviles.
Uso de FXML para separar la lógica de negocio del diseño.

Con este contenido, tu presentación estará bien estructurada y fácil de comprender. ¡Espero que te sea útil! 🚀

🎨 4. JavaFX: Una Alternativa Moderna¶

JavaFX es una evolución de Swing con soporte para gráficos avanzados y animaciones.
Ejemplo de ventana con JavaFX:

import javafx.application.Application;
import javafx.scene.Scene;
import javafx.scene.control.Button;
import javafx.scene.layout.StackPane;
import javafx.stage.Stage;

public class JavaFXEjemplo extends Application {
    @Override
    public void start(Stage primaryStage) {
        Button btn = new Button("Haz clic aquí");
        btn.setOnAction(e -> System.out.println("Botón presionado"));

        StackPane root = new StackPane();
        root.getChildren().add(btn);

        Scene scene = new Scene(root, 300, 200);
        primaryStage.setTitle("JavaFX");
        primaryStage.setScene(scene);
        primaryStage.show();
    }

    public static void main(String[] args) {
        launch(args);
    }
}

✅ start(Stage primaryStage) crea la ventana principal.
✅ setOnAction(e -> System.out.println(...)) maneja eventos de clic.

🎤 Conclusión y Cierre (Últimos 30s-1 min)¶

✅ El manejo de archivos en Java es fundamental para almacenar y procesar datos.
✅ Podemos optimizar el rendimiento usando buffering y lectura por bloques.
✅ Java ofrece herramientas modernas como Files en NIO para hacer el trabajo más fácil. ✅ Swing es fácil y rápido para interfaces básicas.
✅ JavaFX es más moderno y potente, ideal para interfaces avanzadas.
✅ Manejo de eventos es clave para interactividad.

🎯 Consejos para exponer:
✔ Explica con ejemplos sencillos y evita tecnicismos excesivos.
✔ Haz pausas para que la audiencia procese la información.
✔ Si puedes, muestra ejemplos en vivo o usa diapositivas con diagramas.

Final Presentation

🎤 Exposición: Manejo de Archivos en Java¶

🎯 1. Importancia del Manejo de Archivos en Programación (2 min)¶

📌 2. Clases de manejo de archivos Java (4 min)¶

Lectura de Archivos (FileReader & FileWriter)¶

Uso de \(InputStream\) y \(OutputStream\) en Java¶

1. InputStream¶

2. OutputStream¶

🚀 3. Manejo Eficiente de Archivos Grandes (5 min)¶

Escritura en Archivos (BufferedReader & BufferedWriter)¶

🚀 Ventajas principales¶

1️⃣ Mejor rendimiento en lectura y escritura de texto¶

2️⃣ Menos operaciones de entrada/salida (E/S)¶

3️⃣ Métodos convenientes como readLine()¶

4️⃣ Mejor manejo de memoria¶

5️⃣ Tamaño de buffer configurable¶

6️⃣ Escritura eficiente con BufferedWriter¶

Ejemplo Completo¶

📌 Cuándo usarlos¶

Escritura en Archivos (BufferedInputStream & BufferedOutputStream)¶

🚀 Ventajas principales¶

Ejemplo práctico¶

Lectura eficiente con BufferedInputStream¶

Escritura eficiente con BufferedOutputStream¶

📌 Cuándo usarlos¶

🚀 4. Manejo de Archivos con Files (Java NIO)¶

🚀 Ventajas de Files en Java NIO¶

📌 Operaciones Básicas con Files¶

📌 Lectura de Archivo usando \(readAllLines()\)¶

📄 1️⃣ Leer un archivo completo¶

Ventajas y Desventajas¶

📜 Uso de Files.lines()¶

📌 Ejemplo: Leer un archivo línea por línea¶

🔍 Ejemplo: Filtrar líneas que contienen una palabra clave¶

🔄 Ejemplo: Contar líneas de un archivo¶

✍ Ejemplo: Transformar el contenido del archivo¶

⚠ Consideraciones al usar Files.lines()¶

Ventajas y Desventajas¶

✍ 2️⃣ Escribir en un archivo¶

📑 3️⃣ Copiar un archivo¶

📂 4️⃣ Mover o renombrar un archivo¶

🗑 5️⃣ Eliminar un archivo¶

🔍 Manejo de Directorios con Files¶

📂 Listar archivos en un directorio¶

📑 Obtener información de un archivo¶

🆚 Diferencias entre Files y java.io¶

🎯 5. Buenas Prácticas en el Manejo de Archivos (3 min)¶

Interfaces Graficas de Usuario¶

🎯 1. ¿Qué son las GUI en Java?¶

** Principales tecnologías para GUI en Java**¶

🚀 2. Creación de una GUI con Swing¶

📌 3. Eventos en GUI con Java¶

1. Explicación de Eventos en Java GUI¶

2. Tipos de Eventos¶

Eventos de Acción¶

Eventos de Teclado¶

Eventos de Mouse¶

Eventos de Ventana¶

3. Comparación entre Swing y JavaFX¶

4. Código de Ejemplo¶

Ejemplo en Swing (Manejo de botón)¶

Ejemplo en JavaFX (Manejo de botón)¶

5. Beneficios de JavaFX sobre Swing¶

🎨 4. JavaFX: Una Alternativa Moderna¶

🎤 Conclusión y Cierre (Últimos 30s-1 min)¶

1. `InputStream`¶

2. `OutputStream`¶

3️⃣ Métodos convenientes como `readLine()`¶

6️⃣ Escritura eficiente con `BufferedWriter`¶

Escritura en Archivos (`BufferedInputStream` & `BufferedOutputStream`)¶

Lectura eficiente con `BufferedInputStream`¶

Escritura eficiente con `BufferedOutputStream`¶

🚀 4. Manejo de Archivos con `Files` (Java NIO)¶

🚀 Ventajas de `Files` en Java NIO¶

📌 Operaciones Básicas con `Files`¶

📜 Uso de `Files.lines()`¶

⚠ Consideraciones al usar `Files.lines()`¶

🔍 Manejo de Directorios con `Files`¶

🆚 Diferencias entre `Files` y `java.io`¶

Principales tecnologías para GUI en Java¶