Activitats

Completar el codi

L’objectiu d’aquesta activitat és repassar com inicialitzar i usar les diferents classes associades a fluxos d’entrada/sortida al java.

Corregiu el fragments de codi següents afegint una sola línia, o completant-la, on apareix ???:

OutputStream os = obtenirFluxSortida();
BufferedWriter bw = ???;
bw.write(“Escric un String.”,0,17);

File f = new File(ruta);
BufferedInputStream bis = new BufferedInputStream(new FileInputStream(f));
byte[] buffer = new byte[1024];
???
bis.read(buffer);
bis.reset(); //Es torna a començar

public class Tupla implements Serializable {
  ??? atribut1;
  private String atribut2;
 
  public Tupla (String i, String j) {
    atribut1 = i;
    atribut2 = j;
  }
 
  public String toString() {
    return atribut1 + “:” + atribut2;
  }
}
…
File f = new File(ruta);
Tupla t1 = new Tupla(100,200);
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(f));
oos.writeObject(t);
???
ObjectInputStream ois = new ObjectInputStream(new FileInputStream(f));
Tupla t2 = (Tupla)ois.readObject();
???
System.out.println(t2); //Surt per pantalla “null:200”.

//Es vol omplir tot el buffer amb dades
InputStream is = new FileInpuStream (ruta);
byte [] buffer = new byte[long];
int len = 0, inici = 0;
do {
  len = ???;
  inici += len;
} (while inici < buffer.length);

El corrector de termes automàtic

L’objectiu d’aquesta activitat és veure com es processen les dades que provenen de diferents fluxos per assolir una fita concreta.

Dueu a terme una aplicació per reemplaçar les aparicions de certes paraules per altres dins un conjunt de fitxers de text d’entrada, anomenat “Entrada.txt”, d’acord amb una llista predefinida en un fitxer anomenat “Corrector.txt”. En aquest darrer fitxer es desa el conjunt de termes que cal detectar i la nova paraula per la qual s’han de reemplaçar, com parelles de paraules separades per guió (terme-correcció), escrites en diferents línies. L’aplicació ha de llegir els fitxers i processar-los de manera que es generi nova versió, anomenada “Sortida.txt”, en què només apareguin els termes correctes d’acord amb la llista.

Ara bé, cal fer aquesta tasca amb la particularitat que, en tot moment, a memòria només es pot tenir un únic parell terme-traducció del fitxer “Corrector.txt”, i el fitxer de sortida s’ha d’anar generant a mesura que es van fent les traduccions. Mai no es pot disposar a memòria de tot el contingut de qualsevol dels tres fitxers.

Per exemple:

Entrada.txt: es desa en la cache.
Corrector.txt: cache-cau
Sortida.txt: es desa en la cau.

Es deixa total llibertat sobre quina ha de ser la interfície de l’aplicació. Per fer aquest exercici, no cal preocupar-se de detalls com processar els punts a final de frase o els apòstrofs.

Per exemple, a partir dels fitxers Entrada.txt i Corrector.txt:

Aquest algoritme encriptat requereix un tamany de cache massa gran.

algoritme-algorisme
encriptat-xifrat
tamany-mida
cache-cau

La sortida seria: “Aquest algorisme xifrat requereix una mida de cau massa gran.”

Fitxer Corrector.java

import java.io.*;
 
public class Corrector {
 
  public static void main (String[] args) {
    File entrada = new File ("Entrada.txt");
    File corrector = new File ("Corrector.txt");
    File sortida = new File ("Sortida.txt");
 
    try {
      BufferedReader rdEntrada = new BufferedReader(new FileReader(entrada));
      PrintWriter prSortida = new PrintWriter(new FileWriter(sortida));
 
      String lin = rdEntrada.readLine();
      while (lin != null) {
        //Separar una línia en paraules
        String[] paraules = lin.split(" ");
        boolean inici = true;
        for (int i = 0; i < paraules.length; i++) {
          //veure si cal escriure espai entre paraules.
          if (!inici) {
            prSortida.print(" ");
          }
          inici = false;
          String res = null;
          BufferedReader rdCorrector = new BufferedReader(new FileReader(corrector));
          String parell = rdCorrector.readLine();
          //Llegir termes correctors un a un i comparar amb la paraula actual.
          while (parell != null) {
            res = paraules[i];
            String[] corr = parell.split("-");
            if (corr[0].equalsIgnoreCase(res)) {
              res = corr[1];
              break;
            }
            parell = rdCorrector.readLine();
          }
          prSortida.print(res);
          rdCorrector.close();
        }
        prSortida.println();
        lin = rdEntrada.readLine();
      }
 
      rdEntrada.close();
      prSortida.close();
      System.out.println("Fitxer de sortida generat.");
 
    } catch (Exception ex) {
      System.out.println("Error processant fitxers: " + ex);
    }
  }
 
}

Persistència d'objectes per tipus primitius

L’objectiu d’aquesta activitat és veure com es pot escriure i recuperar, des d’un fitxer, un conjunt de tipus de dades bàsics. Concretament, el contingut d’un objecte sense recórrer al mecanisme de seriació.

Desenvolupeu una aplicació que emmagatzemi, en un fitxer binari, un conjunt d’instàncies de la classe següent i sigui capaç de recuperar-les. Per aconseguir-ho es pot usar lliurement qualsevol tipus de flux. L’única condició és que no es pot usar seriació, els atributs de cada instància s’han d’abocar i recuperar individualment sobre el fitxer.

Un exemple de solució, usant un programa de prova molt simple, és el que es mostra tot seguit. Cal tenir en compte que per saber quants objectes hi ha en un fixter, cal, o bé usar una marca de fi de fitxer, o bé indicar a priori quants elements hi ha (amb un valor enter). També, per evitar usar realment seriació, cal desar els atributs de tipus String (el nom), com una cadena de bytes. Atès que una cadena de text té mida variable, això vol dir que caldrà desar la mida de cada cadena de text per després poder-la recuperar satisfactòriament.

import java.io.*;
 
public class TipusProducte {
  private String nom;
  private int codiIdentificador;
  private double preu;
  private int estoc;
  private boolean aLaVenda;
 
  public TipusProducte(String n, int ci, double p, int e, boolean av) {
    nom = n;
    codiIdentificador = ci;
    preu = p;
    estoc = e;
    aLaVenda = av;
  }
 
  public String toString() {
    return nom + " (" + codiIdentificador + "): " + preu + ", " + estoc + ", " + aLaVenda;
  }
 
  public static void main (String[] args) {
    TipusProducte[] prods = {
      new TipusProducte("Producte 1", 1, 10.0,  4, true),
      new TipusProducte("Producte 2", 2, 15.0,  0, false),
      new TipusProducte("Producte 3", 3, 20.5,  15, true),
      new TipusProducte("Producte 4", 4, 9.0,   100, true),
      new TipusProducte("Producte 5", 5, 32.99, 1, false)
    };
 
    System.out.println("Productes originals");
    for (int i = 0; i < prods.length; i++) 
      System.out.println(prods[i]);
 
    File f = new File ("Fitxer.tp");
    //Escriptura
    try {
      DataOutputStream dos = new DataOutputStream(new FileOutputStream(f));
      dos.writeInt(prods.length);
      for (int i = 0; i < prods.length; i++) {
        byte[] b = prods[i].nom.getBytes();
        dos.writeInt(b.length);
        dos.write(b);
        dos.writeInt(prods[i].codiIdentificador);
        dos.writeDouble(prods[i].preu);
        dos.writeInt(prods[i].estoc);
        dos.writeBoolean(prods[i].aLaVenda);
      }
      dos.close();
      System.out.println("Fitxer generat: " + f.getName());
    } catch (Exception ex) {
      System.out.println("Error desant les dades: " + ex);
      f.delete();
    }
 
    //Lectura
    TipusProducte[] llegits = new TipusProducte[prods.length];
    if (f.exists()) {
      try {
        DataInputStream dis = new DataInputStream(new FileInputStream(f));
        int nprod = dis.readInt();
        llegits = new TipusProducte[nprod];
        for (int i = 0; i < llegits.length; i++) {
          int longNom = dis.readInt();
          byte[] b = new byte[longNom];
          dis.read(b);
          String n = new String(b);
          int c = dis.readInt();
          double p = dis.readDouble();
          int e = dis.readInt();
          boolean av = dis.readBoolean();
          llegits[i] = new TipusProducte(n, c, p, e, av);
        }
        dis.close();
        System.out.println("Lectura finalitzada: " + f.getName());
      } catch (Exception ex) {
        System.out.println("Error llegint les dades: " + ex);
      }
 
    }
 
    System.out.println("Productes llegits");
    for (int i = 0; i < llegits.length; i++)
      System.out.println(llegits[i]);
 
  }
 
}

Desar la partida

L’objectiu d’aquesta activitat és entendre com funciona el mecanisme de seriació del Java, de manera que és possible desar i restaurar el Model d’una aplicació de manera relativament simple.

Modifiqueu el codi font d’un joc del Buscamines, disponible al final d’aquest enunciat, de manera que el jugador pugui desar l’estat de la partida i reprendre-la en qualsevol moment. Per fer-ho, useu el mecanisme de seriació per defecte que proporciona el Java.

Codi ( 4.8 KB )

Per afegir aquesta funcionalitat és suficient de fer que tots els elements del programa implementin la interfície Serializable. Llavors, es pot gestionar la càrrega o desat de la partida (atribut “model” a la classe BuscaminesGUI) usant seriació d’objectes. Per exemple, es pot afegir un menú a la finestra per poder dur a terme aquestes accions. Ara bé, cal no oblidar-se, un cop carregat el model, d’actualitzar la interfície d’usuari cridant “actualitzarCasella”.

    //Menu carregar/Desar
    JMenuBar menu = new JMenuBar();
    JMenu estat = new JMenu("Partida");
    menu.add(estat);
    JMenuItem load = new JMenuItem("Carregar Partida");
    estat.add(load);
    load.addActionListener(new ActionListener() {
      public void actionPerformed(ActionEvent e) {
        JFileChooser gestorFitxers = new JFileChooser();
        gestorFitxers.showOpenDialog(null);
        File f = gestorFitxers.getSelectedFile();
        if (f != null) {
          try {
            ObjectInputStream ois = new ObjectInputStream (new FileInputStream(f));
            model = (Partida)ois.readObject();
            ois.close();
            //Actualitzar caselles
            for(int i = 0;i < caselles.length;i++) {
              for (int j = 0; j < caselles[i].length; j++) {
                Casella c = caselles[i][j];
                actualitzarCasella (c, model.obtenirPosicio(c.x,c.y));
              }
            }
          } catch (Exception ex) {
            JOptionPane.showMessageDialog(null,"Error obrint les dades.\n" + ex,"Obrir...",JOptionPane.ERROR_MESSAGE);
          }
        }
       }
    });
 
    JMenuItem save = new JMenuItem("Desar Partida");
    estat.add(save);
    save.addActionListener(new ActionListener() {
      public void actionPerformed(ActionEvent e) {
        JFileChooser gestorFitxers = new JFileChooser();
        gestorFitxers.showSaveDialog(null);
        File f = gestorFitxers.getSelectedFile();
        if (f != null) {
          try {
            ObjectOutputStream oos = new ObjectOutputStream (new FileOutputStream(f));
            oos.writeObject(model);
            oos.close();
          } catch (Exception ex) {
            JOptionPane.showMessageDialog(null,"Error desant les dades.\n" + ex,"Desar...",JOptionPane.ERROR_MESSAGE);
          }
        }
      }
    });
 
    this.setJMenuBar(menu);