From 791cfef0ecdb6e097f29c7b2d7367ecfe7c89a0f Mon Sep 17 00:00:00 2001 From: naitSirth Date: Tue, 22 Sep 2026 17:39:25 +0200 Subject: [PATCH] Actividad 1.1: tratamiento fichero paises --- .classpath | 10 ++ .gitignore | 2 + .project | 17 ++++ .settings/org.eclipse.core.resources.prefs | 2 + .settings/org.eclipse.jdt.core.prefs | 11 ++ src/org/palomafp/aadd/cgp/AppPrincipal.java | 106 ++++++++++++++++++++ 6 files changed, 148 insertions(+) create mode 100644 .classpath create mode 100644 .gitignore create mode 100644 .project create mode 100644 .settings/org.eclipse.core.resources.prefs create mode 100644 .settings/org.eclipse.jdt.core.prefs create mode 100644 src/org/palomafp/aadd/cgp/AppPrincipal.java diff --git a/.classpath b/.classpath new file mode 100644 index 0000000..463d5f9 --- /dev/null +++ b/.classpath @@ -0,0 +1,10 @@ + + + + + + + + + + diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..8938fea --- /dev/null +++ b/.gitignore @@ -0,0 +1,2 @@ +bin/ +*.class diff --git a/.project b/.project new file mode 100644 index 0000000..8819eb3 --- /dev/null +++ b/.project @@ -0,0 +1,17 @@ + + + Fichero_01 + + + + + + org.eclipse.jdt.core.javabuilder + + + + + + org.eclipse.jdt.core.javanature + + diff --git a/.settings/org.eclipse.core.resources.prefs b/.settings/org.eclipse.core.resources.prefs new file mode 100644 index 0000000..99f26c0 --- /dev/null +++ b/.settings/org.eclipse.core.resources.prefs @@ -0,0 +1,2 @@ +eclipse.preferences.version=1 +encoding/=UTF-8 diff --git a/.settings/org.eclipse.jdt.core.prefs b/.settings/org.eclipse.jdt.core.prefs new file mode 100644 index 0000000..9a7984b --- /dev/null +++ b/.settings/org.eclipse.jdt.core.prefs @@ -0,0 +1,11 @@ +eclipse.preferences.version=1 +org.eclipse.jdt.core.compiler.codegen.targetPlatform=21 +org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve +org.eclipse.jdt.core.compiler.compliance=21 +org.eclipse.jdt.core.compiler.debug.lineNumber=generate +org.eclipse.jdt.core.compiler.debug.localVariable=generate +org.eclipse.jdt.core.compiler.debug.sourceFile=generate +org.eclipse.jdt.core.compiler.problem.enablePreviewFeatures=disabled +org.eclipse.jdt.core.compiler.problem.reportPreviewFeatures=warning +org.eclipse.jdt.core.compiler.release=enabled +org.eclipse.jdt.core.compiler.source=21 diff --git a/src/org/palomafp/aadd/cgp/AppPrincipal.java b/src/org/palomafp/aadd/cgp/AppPrincipal.java new file mode 100644 index 0000000..4bcad76 --- /dev/null +++ b/src/org/palomafp/aadd/cgp/AppPrincipal.java @@ -0,0 +1,106 @@ +package org.palomafp.aadd.cgp; +import java.io.BufferedReader; +import java.io.FileReader; +import java.io.IOException; +import java.util.regex.Matcher; +import java.util.regex.Pattern; + +public class AppPrincipal { + // Ruta del fichero según la Nota 2 del enunciado (ajusta TuUsuario) + private static final String RUTA_FICHERO = + "C:\\Users\\chris\\aadd\\fic01\\informacion_paises.txt"; + + // Formato esperado de cada línea de datos: + // "01",1, "Angola", "Luanda" + // Grupo 1 -> código de continente ("01") + // Grupo 2 -> id del país (1) + // Grupo 3 -> nombre del país (Angola) + // Grupo 4 -> capital (Luanda) + private static final Pattern PATRON_LINEA = Pattern.compile( + "^\"(\\d+)\"\\s*,\\s*(\\d+)\\s*,\\s*\"([^\"]*)\"\\s*,\\s*\"([^\"]*)\"\\s*$" + ); + + public static void main(String[] args) { + try (BufferedReader br = new BufferedReader(new FileReader(RUTA_FICHERO))) { + String linea; + int numeroLinea = 0; + + while ((linea = br.readLine()) != null) { + numeroLinea++; + linea = linea.trim(); + + // Ignoramos líneas vacías y comentarios (empiezan por #) + if (linea.isEmpty() || linea.startsWith("#")) { + continue; + } + + Matcher m = PATRON_LINEA.matcher(linea); + if (m.matches()) { + String codigoContinente = m.group(1); + String idPais = m.group(2); + String nombrePais = m.group(3); + String capital = m.group(4); + + System.out.println(generarInsert(codigoContinente, idPais, nombrePais, capital)); + } else { + // Línea con datos que no encaja en el patrón esperado + System.err.println("Línea " + numeroLinea + " no reconocida, se omite: " + linea); + } + } + } catch (IOException e) { + System.err.println("Error al leer el fichero: " + e.getMessage()); + } + } + + /** + * Construye la sentencia INSERT a partir de los datos de un país. + */ + private static String generarInsert(String codigoContinente, String idPais, + String nombrePais, String capital) { + return String.format( + "INSERT INTO T_PAIS VALUES ('%s', %s, '%s', '%s');", + codigoContinente, idPais, nombrePais, capital + ); + } +} + +/* Como he puesto lo del Pattern y el Matcher que no lo hemos dado y lo acabo de aprender, dejo por aqui la explicacion + * + * Son las dos piezas del paquete java.util.regex que hacen que las expresiones regulares (regex) funcionen en Java. Van siempre juntas pero cada una tiene un papel distinto: + +Pattern = la plantilla de la regex, ya compilada. + +Es literalmente "el molde" que define qué forma tiene una línea válida. Se compila una sola vez, fuera del bucle (por eso es static final), porque compilar una regex tiene cierto coste y no tiene sentido rehacerlo en cada iteración: + +java +Pattern.compile("^\"(\\d+)\"\\s*,\\s*(\\d+)\\s*,\\s*\"([^\"]*)\"\\s*,\\s*\"([^\"]*)\"\\s*$") + +Un Pattern no sabe nada de ningún texto concreto todavía, solo sabe "así es como tiene que ser una línea válida". + +Matcher = el que de verdad aplica esa plantilla contra un texto concreto. + +Un Matcher se crea a partir del Pattern + una cadena concreta, y es el que hace el trabajo real: comprobar si esa cadena encaja, y si encaja, extraer los trozos capturados: + +java +Matcher m = PATRON_LINEA.matcher(linea); // "engancha" el patrón a ESTA línea concreta + +En tu programa se crea un Matcher nuevo en cada vuelta del bucle, porque cada línea es un texto distinto. + +Los métodos que usamos: + +m.matches() → devuelve true/false según si toda la línea encaja con el patrón de principio a fin (por eso el patrón lleva ^ al inicio y $ al final). +m.group(n) → devuelve el contenido capturado por el grupo n-ésimo (los trozos entre paréntesis (...) del patrón). El grupo 0 sería la línea entera; el 1, 2, 3, 4 son cada uno de los paréntesis en orden. + +Aplicado a tu línea "01",1, "Angola", "Luanda": + +Grupo Paréntesis en el patrón Captura +1 (\d+) (primero) 01 +2 (\d+) (segundo) 1 +3 ([^"]*) (primero) Angola +4 ([^"]*) (segundo) Luanda + +Y de ahí salen las cuatro variables que montan el INSERT. + +Un apunte extra: además de matches() existe find(), que busca el patrón en cualquier parte de la cadena (no exige que encaje entera), útil cuando buscas coincidencias dentro de un texto más largo en vez de validar la línea completa como aquí.*/ + +