Activitats

Compta paraules

L’objectiu d’aquesta activitat és aprendre a treballar amb cadenes de text llegides d’un fitxer orientat a caràcter.

Feu un programa anomenat ComptaParaulesFitxer que llegeixi un fitxer orientat a caràcter on hi ha tot de frases escrites en línies diferents. Per indicar el final del fitxer, hi ha una frase o només posa “fi”. Aquest programa ha de mostrar per pantalla el nombre de paraules que té cada frase, sense comptar la de “fi”. Les contraccions (l’, d’, etc.) compten com a part de la paraula associada.

Per exemple, a partir d’aquest fitxer:

Hi havia una vegada...
Perquè ho ha fet avui?
No està malament
Si tu ho dius hi aniré
Doncs d'acord
fi

La sortida per pantalla podria ser:

La línia 1 té 4 paraules.
La línia 2 té 5 paraules.
La línia 3 té 3 paraules.
La línia 4 té 6 paraules.
La línia 5 té 2 paraules.

package unitat6.apartat2.activitats;
 
import java.util.Scanner;
import java.io.File;
 
public class ComptaParaulesFitxer {
 
  public static void main (String[] args) {
    ComptaParaulesFitxer programa = new ComptaParaulesFitxer();
    programa.inici();
  }
 
  public void inici() {
    try {
      File f = new File("Document.txt");
      Scanner lector = new Scanner(f);
      boolean llegir = true;
      int numLinia = 1;
 
      while (llegir) {
        String text = lector.nextLine();
        if ("fi".equals(text)) {
          llegir = false;
        } else {
          //Es pot usar "split" per comptar les paraules
          String[] paraules = text.split(" ");
          int numPar = paraules.length;
          System.out.println("La línia " + numLinia + " té " + numPar + " paraules.");
          numLinia++;
        }
      }
      lector.close();
    } catch (Exception e) {
      System.out.println("Error llegint fitxer: " + e);
    }     
 
  }
}

La màquina d'escriure

L’objectiu d’aquesta activitat és veure com emmagatzemar dades llegides des del teclat en fitxers orientats a caràcter.

Feu un programa que funcioni com una màquina d’escriure. En iniciar la seva execució, ha de preguntar a l’usuari que escrigui, usant el teclat el nom d’un fitxer. Si aquest fitxer ja existeix, s’ha de demanar que posi un altre nom. Un cop s’ha escrit un nom correcte, el programa ha d’anar llegint tot el text que escrigui l’usuari i, cada cop que acaba d’introduir una línia, en prémer la tecla de retorn, desar-lo al fitxer. El programa acaba quan l’usuari escriu una línia de text en la qual només hi ha un punt (”.”). Aquest punt no s’escriu dins el fitxer resultant.

package unitat6.apartat2.activitats;
 
import java.util.Scanner;
import java.io.File;
import java.io.PrintStream;
 
public class MaquinaEscriure {
 
  public static void main (String[] args) {
    MaquinaEscriure programa = new MaquinaEscriure();
    programa.inici();
  }
 
  public void inici() {
    try {
      File fitxerSortida = preguntarFitxer();
      PrintStream escriptor = new PrintStream(fitxerSortida);
      Scanner lector = new Scanner(System.in);
 
      boolean llegir = true;
      while (llegir) {
        String text = lector.nextLine();
        if (".".equals(text)) {
          llegir = false;
        } else {
          escriptor.println(text);
        }
      }
 
      escriptor.close();
    } catch (Exception e) {
      System.out.println("Error escrivint fitxer: " + e);
    }
  }
 
  /** Pregunta a l'usuari el nom del fitxer.
   *
   * @return Ruta al fitxer a escriure
   */
  public File preguntarFitxer() {
    Scanner lector = new Scanner(System.in);
    boolean preguntar = true;
    File f = null;
    while (preguntar) {
      System.out.print("Escriu el nom del fitxer on escriure: ");
      String nomFitxer = lector.nextLine();
      f = new File(nomFitxer);
      if (f.exists()) {
        System.out.println("El fitxer ja existeix.");
      } else {
        preguntar = false;
      }
    }
    return f;
  }
}

Histogrames

L’objectiu d’aquesta activitat és veure com desar en un fitxer orientat a caràcter el resultat de fer operacions complexes sobre unes dades llegides des d’un altre fitxer.

Genereu un programa que, en iniciar-se, pregunti el nom d’un fitxer a l’usuari. El programa ha de comprovar que existeix. Aquest fitxer ha de contenir una seqüència de valors reals, entre 0 i 10, que representen un seguit de notes d’estudiants d’una aula. Per indicar el final de la seqüència, s’usa el valor -1 com a marca de fi. Podeu generar-lo prèviament vosaltres mateixos amb un editor de text.

El programa ha de llegir el contingut del fitxer i generar-ne un de nou anomenat “Histograma-nom del fitxer llegit”. Per exemple, si el fitxer amb les notes es diu, “NotesReals.txt”, el fitxer resultat s’anomenarà “Histograma-NotesReals.txt”. El contingut d’aquest fitxer ha de ser un histograma de les notes, comptant que:

Excel·lent = nota entre 10 i 9
Notable = nota entre 9 i 6.5
Aprovat = nota entre 6.5 i 5
Suspès = nota inferior a 5

Per exemple, si el fitxer “NotesReals.txt” conté:

10 8,5 4,5 3,75 6 7,5 8 9 2,5 9 5 6,5 -1

El fitxer resultant “Histograma-NotesReals.txt” contindria el següent:

Histograma del fitxer NotesReals.txt
------------
Suspès    :***
Aprovat   :**
Notable   :****
Excel·lent:***

package unitat6.apartat2.activitats;
 
import java.util.Scanner;
import java.io.File;
import java.io.PrintStream;
 
public class Histogrames {
 
  //Constant que tradueix <blau>índexs d'histograma</blau><nota blau>és correcta l'esmena? --- //[[cortegai@uoc.edu|Clara Ortega Illera]] 11/08/2011 17:43//</nota> a text
  private static final String[] textHistograma =
                       {"Suspès    ", "Aprovat   ", "Notable   ", "Excel·lent"};
 
  public static void main (String[] args) {
    Histogrames programa = new Histogrames();
    programa.inici();
  }
 
  public void inici() {
    File fitxerEntrada = preguntarFitxer();
    int[] histograma = crearHistograma(fitxerEntrada);
 
    String nomSortida = "Histograma-" + fitxerEntrada.getName();
    File fitxerSortida = new File (nomSortida);
    String titol = "Histograma del fitxer " + fitxerEntrada.getName();
    escriureHistograma(titol, histograma, fitxerSortida);
 
    System.out.println("Histograma escrit al fitxer " + fitxerSortida);
  }
 
  /** Pregunta a l'usuari el nom del fitxer.
   *
   * @return Ruta al fitxer a escriure
   */
  public File preguntarFitxer() {
    Scanner lector = new Scanner(System.in);
    boolean preguntar = true;
    File f = null;
    while (preguntar) {
      System.out.print("Escriu el nom del fitxer amb les dades: ");
      String nomFitxer = lector.nextLine();
      f = new File(nomFitxer);
      if (f.isFile()) {
        preguntar = false;
      } else {
        System.out.println("Aquest fitxer no existeix.");
      }
    }
    return f;
  }
 
  /** A partir d'un fitxer orientat a caràcter que conté reals, genera
   * l'histograma. El valor -1 indica el final de les dades.
   *
   * @param f Fitxer d'on llegir les dades
   * @return L'array de l'histograma.
   */
  public int[] crearHistograma(File f) {
    try {
      Scanner lector = new Scanner(f);
      int[] histograma = new int[4];
      boolean llegir = true;
 
      while (llegir) {
        double valor = lector.nextDouble();
        if (valor == -1) {
          llegir = false;
        } else {
          int index = indexHistograma(valor);
          if (index != -1) {
            histograma[index]++;
          }
        }
      }
 
      lector.close();
      return histograma;
    } catch (Exception e) {
     return null;
    }
  }
 
  /** Escriu un array que representa un histograma a un fitxer.
   *
   * @param titol Títol a la primera línia de l'histograma.
   * @param histograma array amb l'histograma (4 posicions)
   * @param f Fitxer destinació
   */
  public void escriureHistograma(String titol, int[] histograma, File f) {
    try {
      PrintStream escriptor = new PrintStream(f);
      escriptor.println(titol);
      escriptor.println("------------");
      for(int i = 0; i < histograma.length; i++) {
        escriptor.print(textHistograma[i] + ":");
        for (int j = 0; j < histograma[i]; j++) {
          escriptor.print("*");
        }
        escriptor.println();
      }
 
      escriptor.close();
    } catch (Exception e)  {
      System.out.println("Error escrivint resultat: " + f);
    }
  }
 
  /** A partir del valor d'una nota, diu a quin índex de l'histograma correspon.
   *
   * @param valor Valor de nota a comprovar.
   * @return Índex de l'histograma (0-3), o -1 si el valor no està entre 0 i 10.
   */
  public int indexHistograma(double valor) {
    if ((valor >= 9)&&(valor <= 10)) {
      return 3;
    } else if ((valor >= 6.5)&&(valor < 9)) {
      return 2;
    } else if ((valor >= 5)&&(valor < 6.5)) {
      return 1;
    } else  if ((valor >= 0)&&(valor < 5)) {
      return 0;
    }
    return -1;
  }
}

Cadenes de bytes

L’objectiu d’aquesta activitat és aprendre a tractar fitxers orientats a byte que contenen diferents tipus de dades.

1. Genereu un programa que, a partir d’una frase, la desi en un fitxer orientat a byte. Ara bé, si us fixeu en els continguts de la unitat, veureu que entre la llista de mètodes bàsics per escriure tipus de dades a un fitxer d’aquestes característiques no hi ha cap mètode que escrigui cadenes de text directament. Per tant, el que es farà és emmagatzemar cada paraula individualment com si fos una seqüència de bytes. Per cada paraula, cal escriure primer la seva mida en bytes, i llavors immediatament els bytes de què es composa. Per transformar una cadena de text a un array de bytes podeu usar el mètode getBytes() de la classe String.

Per exemple, si es vol tractar la frase “Hi havia una vegada una cadena de text”, el fitxer contindria consecutivament els valors següents, tots ells en format binari (aquí s’escriuen com a text perquè us sigui possible entendre-ho).

2 Hi 5 havia 3 una 6 vegada 3 una 6 cadena 2 de 4 text

2. Un cop fet, genereu un programa que sigui capaç de llegir el fitxer resultant i mostri per pantalla només les paraules amb un text que ocupi més de 3 bytes. Per exemple, a partir de la frase anterior, el programa mostraria:

havia
vegada
cadena
text

Per inicialitzar una cadena de text partint d’un array de bytes (en lloc d’un literal entre cometes dobles, com heu fet sempre fins ara) es pot usar un constructor especial d‘String, d’acord a la sentència següent:

String text = new String(arrayBytes);

package unitat6.apartat2.activitats;
 
import java.io.RandomAccessFile;
import java.io.File;
 
public class TractarCadenesBinari {
 
  public static void main (String[] args) {
    TractarCadenesBinari programa = new TractarCadenesBinari();
    programa.inici();
  }
 
  public void inici() {
    File fitxer = new File("CadenesText.bin");
 
    String text = "Hi havia una vegada una cadena de text";
    String[] paraules = text.split(" ");
 
    generarFitxer(fitxer, paraules);
    tractarFitxer(fitxer);
  }
 
  /** Genera un fitxer orientat a byte d'acord al format especificat. Si el
   * fitxer ja existia, se sobreescriu totalment.
   *
   * @param f Ruta del fitxer a generar
   * @param paraules Paraules que cal escriure
   */
  public void generarFitxer(File f, String[] paraules) {
    try {
      if (f.isFile()) {
        f.delete();
      }
      RandomAccessFile raf = new RandomAccessFile(f, "rw");
 
      for (int i = 0; i < paraules.length; i++) {
        byte[] bytes = paraules[i].getBytes();
        raf.writeInt(bytes.length);
        raf.writeBytes(paraules[i]);
      }
 
      raf.close();
    } catch (Exception e) {
      System.out.println("Error generant fitxer: " + e);
    }
  }
 
  /** Tracta el fitxer, de manera que es mostren per pantalla només les
   * paraules que ocupen més de tres bytes.
   *
   * @param f Ruta al fitxer que cal tractar
   */
  public void tractarFitxer(File f) {
    try {
      RandomAccessFile raf = new RandomAccessFile(f, "r");
 
      while (raf.getFilePointer() < raf.length()) {
        int numBytes = raf.readInt();
        if (numBytes > 3) {
          //Si ocupa més de tres bytes, es llegeix i es mostra
          byte[] bytes = new byte[numBytes];
          for (int i = 0; i < numBytes; i++) {
            bytes[i] = raf.readByte();
          }
          String paraula = new String(bytes);
          System.out.println(paraula);
        } else {
          //Si n'ocupa menys, se salta
          raf.skipBytes(numBytes);
        }
      }
 
      raf.close();
    } catch (Exception e) {
      System.out.println("Error tractant fitxer: " + e);
    }
  }
 
 
}

Copiar fitxers

L’objectiu d’aquesta activitat és aprendre a treballar amb dos fitxers orientats a byte alhora, l’un per llegir dades i l’altre per escriure’n.

Feu un programa anomenat CopiarFitxerBinari que realitzi una còpia d’un fitxer orientat a byte. El programa primer ha de demanar a l’usuari que introdueixi pel teclat els noms dels fitxers origen i destinació. Un cop fet, ha d’assegurar-se que l’origen existeix i que el destí no (no es vol sobreescriure’l). Finalment, ha de crear un fitxer amb el nom de la destinació que contingui exactament les mateixes dades que el fitxer origen, siguin quines siguin aquestes dades o el seu tipus.

Un cop heu realitzat el programa i veieu que funciona correctament, reflexioneu sobre la qüestió següent: funcionarà correctament si el fitxer origen és orientat a caràcter? Proveu-ho.

package unitat6.apartat2.activitats;
 
import java.util.Scanner;
import java.io.File;
import java.io.RandomAccessFile;
 
//Proveu-lo sobre un fitxer orientat a caràcter...
public class CopiarFitxerBinari {
 
  public static void main (String[] args) {
    CopiarFitxerBinari programa = new CopiarFitxerBinari();
    programa.inici();
  }
 
  public void inici() {
    //Es llegeix de teclat rutes origen i destinació
    Scanner teclat = new Scanner(System.in);
    System.out.print("Escriu el nom del fitxer origen: ");
    String origen = teclat.nextLine();
    File rutaOrigen = new File(origen);
 
    if (rutaOrigen.isFile()) {
 
      System.out.print("Escriu el nom del fitxer destinació: ");
      String desti = teclat.nextLine();
      File rutaDesti = new File(desti);
 
      if (rutaDesti.isFile()) {
        System.out.println("El fitxer destinació ja existeix.");
      } else {
        ferCopia(rutaOrigen, rutaDesti);
      }
    } else {
      System.out.println("El fitxer origen no existeix.");
    }
  }
 
  /** Copia un fitxer orientat a byte, a partir d'una ruta origen, a una de destinació.
   *
   * @param rutaOrigen Ruta del fitxer origen
   * @param rutaDesti Ruta del fitxer destinació
   */
  public void ferCopia(File rutaOrigen, File rutaDesti) {
    try {
      RandomAccessFile rafOrigen = new RandomAccessFile(rutaOrigen, "r");
      RandomAccessFile rafDesti = new RandomAccessFile(rutaDesti, "rw");
 
      long numBytes = rutaOrigen.length();
      for (int i = 0; i < numBytes; i++) {
        byte dada = rafOrigen.readByte();
        rafDesti.writeByte(dada);
      }
      rafDesti.setLength(numBytes);
 
      rafOrigen.close();
      rafDesti.close();
      System.out.println("Copia finalitzada correctament.");
    } catch (Exception e) {
      System.out.println("Error fent la còpia: " + e);
    }
  }
 
}

Respecte a la qüestió, sí que funcionarà. Si us pareu a pensar, un fitxer orientat a caràcter és exactament el mateix que un fitxer orientat a byte on totes les dades que conté són de tipus caràcter (char).

Actualització de dades

L’objectiu d’aquesta activitat és veure com treballar amb documents orientats a byte, de manera que s’hi puguin modificar les dades contingudes.

Feu un programa que serveixi com a editor de fitxers orientats a byte que contingui només enters. Aquest s’ha de comportar de la manera següent. En iniciar la seva execució, ha de preguntar a l’usuari quin fitxer vol editar, de manera que aquest pugui escriure el nom usant el teclat. Llavors, ha de mostrar el contingut del fitxer per pantalla, distribuït en files de 10 valors. No cal que formateu la sortida en columnes ben proporcionades. Si el fitxer no existia, se’n crea un de nou i, en aquest cas, no apareix cap valor, ja que el fitxer és buit.

Tot just després dels valors, el programa espera que l’usuari escrigui una comanda, d’entre les següents:

a valor: afegir aquest valor al final del fitxer.
d posició: esborrar el valor que hi ha en aquesta posició, comptant que el primer valor es considera en la posició 0. Ara hi ha un valor menys al fitxer.
x: el programa acaba.

Després d’executar cada comanda, menys la de sortir, es torna a mostrar el contingut del fitxer, de manera que es poden veure els canvis soferts.

Tot seguit es mostra un exemple de com podria ser l’execució del programa.

Escriu el nom del fitxer a editar: FitxerEnters.bin

-------------
Comanda: hfdsgjf
Comanda desconeguda.

-------------
Comanda: a 3

3 
-------------
Comanda: a 50

3 50 
-------------
Comanda: a 40

3 50 40 
-------------
Comanda: a 2

3 50 40 2 
-------------
Comanda: d 1

3 40 2 
-------------
Comanda: x

package unitat6.apartat2.activitats;
 
import java.io.RandomAccessFile;
import java.io.File;
import java.util.Scanner;
 
public class ActualitzacioDades {
 
  public static void main (String[] args) {
    ActualitzacioDades programa = new ActualitzacioDades();
    programa.inici();
  }
 
  public void inici() {
    try {
      //Es llegeix de teclat ruta del fitxer
      Scanner teclat = new Scanner(System.in);
      System.out.print("Escriu el nom del fitxer a editar: ");
      String origen = teclat.nextLine();
      File fitxer = new File(origen);
      RandomAccessFile raf = new RandomAccessFile(fitxer, "rw");
 
      boolean executar = true;
 
      while(executar) {
        mostrarFitxer(raf);
        System.out.println("\n-------------");
        System.out.print("Comanda: ");
        //Llegir comanda
        String comanda = teclat.next();
        if ("x". equals(comanda)) {
          executar = false;
        } else {
          if ("a".equals(comanda)&&teclat.hasNextInt()) {
            int valor = teclat.nextInt();
            afegirValor(raf,valor);
          } else if ("d".equals(comanda)&&teclat.hasNextInt()) {
            int posicio = teclat.nextInt();
            eliminarValor(raf,posicio);
          } else {
            System.out.println("Comanda desconeguda.");
          }
        }
      }
 
      raf.close();
 
    } catch (Exception e) {
      System.out.println("Error accedint al fitxer: " + e);
    }
  }
 
  /** Mostra el contingut del fitxer per pantalla, escrivint 10 valors
   * per fila. Fixeu-vos que un RandomAccessFile es pot passar com a paràmetre.
   *
   * @param raf Fitxer d'acces relatiu a mostrar
   */
  public void mostrarFitxer(RandomAccessFile raf) {
    try { 
      long numEnters = raf.length()/4;
      //Cal garantir que l'apuntador esta al principi
      raf.seek(0);
      for (long i = 0; i < numEnters; i++) {
        if (i%10 == 0) {
          System.out.println();    
        }
        int valor = raf.readInt();
        System.out.print(valor + " ");
      }
    } catch (Exception e) {
      System.out.println("Error llegint fitxer: " + e);    
    }  
  }
 
  /** A partir d'un fitxer d'enters, afegeix un valor al final.
   *
   * @param raf Fitxer a modificar
   * @param valor Valor a afegir
   */
  public void afegirValor(RandomAccessFile raf, int valor) {
    try {
      long fiFitxer = raf.length();
      raf.seek(fiFitxer);
      raf.writeInt(valor);
    } catch (Exception e) {
      System.out.println("Error modificant fitxer: " + e);
    }
  }
 
  /** A partir d'un fitxer d'enters, elimina un valor.
   *
   * @param raf Fitxer a modificar
   * @param posicio Posició a esborrar
   */
  public void eliminarValor(RandomAccessFile raf, int posicio) {
    try {
      if ((posicio >= raf.length()/4)||(posicio < 0)) {
        System.out.println("Aquesta posició no existeix.");
      } else {
        long midaFinal = raf.length() - 4;
        //Per esborrar un valor, cal desplaçar tots els posteriors a sobre
        //de l'anterior valor.
        long posMoure = (posicio + 1)*4;
        while (posMoure < raf.length()) {
          raf.seek(posMoure);
          int valor = raf.readInt();
          raf.seek(posMoure - 4);
          raf.writeInt(valor);
          posMoure = posMoure + 4;
        }
        //Queda el darrer valor repetit. Cal ajustar la nova mida del fitxer
        raf.setLength(midaFinal);
      }
    } catch (Exception e) {
      System.out.println("Error modificant fitxer: " + e);
    }
  }
 
}