Archivos y Búsqueda Secuencial

Profesora Lillian Bras

Archivos de Entrada y Salida

En muchas ocasiones es necesario mantener los datos en memoria secundaria para uso futuro y para esto existen los archivos.

Un archivo puede ser creado para escribir en él o para leer de él y decimos que son archivos de entrada o de salida según sea el caso(input /output files).

En general existen dos tipos de archivos: archivos binarios y archivos de texto (Por el momento estaremos usando los de texto.)

En terminos generales para utilizar archivos debemos: Abrir el archivo Crear una variable(nombre lógico) que represente el archivo

físico y establecer una asociación entre ambos Cerrar el archivo al terminar de usarlo

Archivo de Salida(Output File): Para abrir el archivo para output(escribir en él), se

tiene que crear una instancia de la clase PrintWriter;en otras palabras, crear un objeto tipo PrintWriter.

PrintWriter outputFile = new PrintWriter("StudentData.txt");

Aquí se coloca el nombre físico con su extensión entre comillas.

Cuidado: si el archivo ya existe, lo borra y se

reemplaza con lo que se escriba.

La clase PrintWriter Para usar la clase PrintWriter es necesario incluir la

siguiente instrucción al comienzo del código fuente:

import java.io.*;

La clase PrintWriter permite que se escriba a un archivo usando los métodos print y println, que usted ya conoce.

Los métodos println y print funcionan con los archivos igual que para la pantalla. println: coloca un caracter correspondiente a un

cambio de línea después de los datos escritos print: escribe los datos sin ningún cambio de línea.

Pasos importantes al usar archivo de salida

PrintWriter outputFile = new PrintWriter("Names.txt");

outputFile.println("Chris");outputFile.println("Kathryn");outputFile.println("Jean");

outputFile.close();

Abrir archivo

Escribir al archivo

Cerrar archivo

Nota:No olvide que necesita la instrucción import java.io.* para poder usar la clase PrintWriter

Ejemplo con clase PrintWriter

import java.util.Scanner; // Needed for Scanner classimport java.io.*; // Needed for File I/O classes

/** This program writes data to a file*/

public class FileWriteDemo{ public static void main(String[] args) throws IOException {

String friendName; // Friend's name int numFriends; // Number of friends

// Create a Scanner object for keyboard input. Scanner keyboard = new Scanner(System.in); // Get the number of friends. System.out.print("How many friends do you have? "); numFriends = keyboard.nextInt();

// Consume the remaining newline character. keyboard.nextLine();

Continúa

Continuación del ejemplo con la clase PrintWriter…

// Open the file. PrintWriter outputFile = new PrintWriter(“myData.txt”);

// Get data and write it to the file. for (int i = 1; i <= numFriends; i++) { // Get the name of a friend. System.out.print("Enter the name of friend " + "number " + i + ": "); friendName = keyboard.nextLine();

// Write data to the file. outputFile.println(friendName); }

// Close the file. outputFile.close(); System.out.println("Data written to the file."); }}

Para entrar el nombre del Archivo por el teclado…

public static void main(String[] args) throws IOException { String filename; // File name String friendName; // Friend's name int numFriends; // Number of friends

// Create a Scanner object for keyboard input. Scanner keyboard = new Scanner(System.in);

// Get the filename. System.out.print("Enter the filename: "); filename = keyboard.nextLine();

// Get the number of friends. System.out.print("How many friends do you have? "); numFriends = keyboard.nextInt();

// Consume the remaining newline character. keyboard.nextLine(); // Open the file. PrintWriter outputFile = new PrintWriter(filename);

// Rest of theprogram is the same…

Pseudocódigo para el ejercicio del registro de notas

Abrir archivoFor( sec=1 To cantSecciones) Obtener sección Escribir seccion en el archivo de salida Obtener cantidad de estudiantes en esa seccion For( est = 1 To cantEstudiantes) Obtener datos del estudiante: nombre y tres notas Calcular el promedio Mostrar nombre y promedio

Escribir nombre y promedio al archivo de salida EndFor Escribir línea en blanco al archivo EndForCerrar Archivo

Archivos de entrada(Input File) Para leer de un archivo que ya fue creado se

utiliza la clase File y la clase Scanner.

File myFile = new File("Customers.txt");Scanner inputFile = new Scanner(myFile);

Aquí se coloca el nombre del archivo físico

Aqui se escribe el nombre lógico declarado en la instrucción

anterior

Nombre lógico del archivo

Flujograma del ciclo para leer de un archivo

Abrir archivo

Hay algún dato por leer? Leer dato/s

Y Procesar dato/s

True

False

Para leer de un archivo

Para leer de un archivo podemos usar un for (si sabemos la cantidad de líneas y que datos por línea) o utilizamos el caracter que marca el final del archivo (eof) con un ciclo while

En Java, para detectar el final del archivo, se usa el método hasNext() de la clase Scanner. Este método devuelve true si existe algo mas por leerse que no sea el “eof”.

El siguiente segmento en Java, demuestra como usar hasNext(), en un ciclo while, para leer de un archivo:// Open the file.

Scanner keyboard = new Scanner(System.in);System.out.print("Enter the filename: ");String filename = keyboard.nextLine();

File file = new File(filename);Scanner inputFile = new Scanner(file);// Read until the end of the file.while (inputFile.hasNext()){ String friendName = inputFile.nextLine(); System.out.println(friendName);}inputFile.close();// close the file when done.

Instrucciones antes del ciclo del código anterior…

Scanner keyboard = new Scanner(System.in);System.out.print("Enter the filename: ");String filename = keyboard.nextLine();File myFile = new File(filename);Scanner inputFile = new Scanner(myFile);

En las líneas anteriores: Se crea un objeto (keyboard) de la clase Scanner para leer

del teclado Se le solicita al usuario que entre el nombre del archivo Se declara una variable tipo String para recoger el nombre

del archivo del teclado Se crea un objeto tipo File para representar el archivo

(myFile) Se crea un objeto tipo Scanner para leer del

archivo(inputFile)

Ciclo de lectura en código anterior…

// Read until the end of the file. while (inputFile.hasNext()){ String firiendName= inputFile.nextLine(); System.out.println(friendName); }inputFile.close();// close the file when done.

inputFile.hasNext() verifica si lo próximo a leerse es el marcador eof. Si lo es devuelve falso y si no, es porque hay un dato para leer, y devuelve cierto, en cuyo caso entra al ciclo.

Esta instrucción lee una línea del archivo y la guarda en str. (Note que se usa el nombre de la variable (inputFile), que se declaró tipo Scanner, en vez del acostunmbrado nombre keyboard)

Se muestra lo que se leyó del archivo Se cierra el archivo al salir del ciclo

Ejemplo para leer nombres…

import java.util.Scanner; // Needed for the Scanner classimport java.io.*; // Needed for the File class// este archivo se creo con el con el primer ejemplo visto en esta presentaciónpublic class FileReadDemo{ public static void main(String[] args) throws IOException { // Create a Scanner object for keyboard input. Scanner keyboard = new Scanner(System.in);

// Get the filename. System.out.print("Enter the filename: "); String filename = keyboard.nextLine();

// Open the file. File file = new File(filename); Scanner inputFile = new Scanner(file);

// Read lines from the file until no more are left. while (inputFile.hasNext()) { // Read the next name. String friendName = inputFile.nextLine();

// Display the last name read. System.out.println(friendName); }

// Close the file. inputFile.close(); }}

Verificacando si el archivo de entrada existe…

Si tratamos de abrir y leer de un archivo que no existe tendremos un error en etapa de ejecución muy poco deseable.

Para evitar que el programa interrumpa abruptamente la ejecución porque el archivo no existe o no lo encuentre, debemos incluir un if que verifique dicha situación.

La siguiente instrucción se usa para verificar la no-existencia del archivo:

if( ! inputFile.exists() ){

System.out.println(“Error! File not found.”); System.exit(0); }

El método .exixts() devuelve falso si el archivo no existe, por eso la necesidad del operador de negación(!).

(De esta forma podemos usar un if sin else.) Note la instrucción de System.exit(0) que se incluye dentro del bloque

para que, de no existir el archivo, termine el programa después del mensaje.

Ejemplo que verifica existencia de archivo de entrada(Autor:Profesor Antonio Huertas)

import java.io.*;import java.text.DecimalFormat;import java.util.Scanner;/*This program reads the data of a list of employees from a file and computes the salary for each one. */

public class EmployeeFileReadApp3 {

public static void main(String[] args) throws IOException {// Define symbolic constants final int STD_WORKING_WEEK = 40;final double OVERTIME_RATE = 1.5;// Declare variables for employee data and number of employees

String id, firstName, lastName;double payRate, salary;

int hoursWorked, overtime; int numEmployees = 0;// Create a reference to a decimal format

DecimalFormat formatter = new DecimalFormat("$#,##0.00");

// Create a reference to the employee file and check whether it existsFile employeeFile = new File("employees.txt");if (! employeeFile.exists()) {

System.out.println("File does not exist!");System.exit(0);}

// Open employee file for reading (input) Scanner inputFile = new Scanner(employeeFile);// While there is data in input file...while (inputFile.hasNext()) { // Read employee data from input file

id = inputFile.next();firstName = inputFile.next();lastName = inputFile.next();payRate = inputFile.nextDouble();hoursWorked = inputFile.nextInt();

System.out.println("Data has been read from employee file.");

// Increment number of employees readnumEmployees++;

// Compute salaryif (hoursWorked <= STD_WORKING_WEEK)

salary = payRate * hoursWorked;else {

overtime = hoursWorked - STD_WORKING_WEEK; salary = (payRate * STD_WORKING_WEEK) +(payRate * overtime * OVERTIME_RATE);

}// Display employee data and salary

System.out.println("Employee #" + numEmployees + ":"); System.out.println("\tId: " + id); System.out.println("\tName: " + firstName + " " + lastName); System.out.println("\tPay Rate: " + formatter.format(payRate)); System.out.println("\tHours Worked: " + hoursWorked); System.out.println("\tSalary: " + formatter.format(salary)); System.out.println();

}System.out.println("There are " + numEmployees + " employees."); // Close input fileinputFile.close();}}

Búsqueda Secuencial o Lineal

La búsqueda de un dato en una lista es una tarea que necesitamos llevar a cabo en muchas ocasiones.

Si necesitamos buscar un dato en una lista donde los datos no están ordenados, es necesario revisar un dato tras otro en secuencia hasta tanto lo encontremos o se terminen los datos.

No importa si los datos están almacenados en un archivo de memoria secundaria, son entrados por algún equipo de entrada, o están en un arreglo de memoria primaria, el algoritmo que se utiliza para hacer la búsqueda secuencial es basicamente el mismo.

Algoritmo general de Búsqueda Secuencial

1.Obtener dato ha ser buscado : searchItem2. Inicializar variable lógica en falso: found = falso3. While ( there is more data and search item has not been found)

get item from listIf( item = searchItem)then display item found = trueEnd If

End While 4. If Not found then display(“Item not found”)

End if

Pseudocódigo Búsqueda Secuencial en archivo

1. Open file2. found = false3. Get searchItem4. While (more data in file and not found)

read data from file If (data = searchItem )

then found = true display info

End If End While5. If ( not found) then display (“That item is not in the file”) End If6. Close file

Ejemplo Búsqueda Secuencial en Java …

import java.io.*;import java.util.Scanner;/*This program reads the data of a list of students from a file to perform a linear search. Prof. Lillian Bras */

public class SequentialSearchApp{

public static void main(String[] args) throws IOException {

// Declare variables String id,;double average;char grade;

// Create a reference to the student file and check whether it exists

File studentFile = new File(“studentData.txt");if (! studentFile.exists()) {System.out.println("File does not exist!");System.exit(0);}

// Open student file for reading (input) Scanner inputFile = new Scanner(studentFile);

Ejemplo en Java…

// Create a Scanner object for keyboard input. Scanner keyboard = new Scanner(System.in);

// Get SearchId from userSystem.out.print("Enter the Student’s Id you are looking for ");

String searchId= keyboard.nextLine();

// Initialize logic variable found boolean found = false;

// While there is data in input file item has not been found... while (inputFile.hasNext() && !found) {

// Read student data from input fileid = inputFile.next();average = inputFile.nextDouble();grade = inputFile.next(). charAt(0);// compare id’sif (id.equals(searchId){ found = true; System.out.println(“Average: ” + average); System.out.println(“Grade: ” + grade);}

}If(!found)

System.out.println(“Student not in file.”); // Close input file

inputFile.close();}

}

Recuerde: Si lo que tenemos es un grupo de datos relacionados

entre sí como: id de estudiante, nombre de estudiante, promedio de estudiante

y nota de estudiante

la búsqueda se hace por uno de ellos siempre y cuando este no se repita (sea único en la lista).

Casi siempre la búsqueda se hace por seguro social o algún número de identificación que sea único.

En un archivo de texto para llegar a un dato es necesario leer todo lo que está antes aunque no se vaya a utilizar.

Necesitamos conocer que tipos de datos y en que orden están en el archivo para poder leer adecuadamente cada uno de ellos. Recuerde que su programa dirige la computadora en el proceso de lectura.