Ver o código fonte de «Almacenando Información en Java (Ficheiros)»

= Soporte, Organización e Acceso =
== Os Soportes ==
Un sistema informático xestiona a información almacenada na súa memoria RAM en formato binario, sendo procesada pola CPU para producir información nova que é almacenada de volta na memoria RAM do sistema. A memoria RAM é volátil, polo que si desconectamos o equipo a información almacenada se perde. Polo tanto é necesario almacenar a información binaria en algún tipo de '''soporte''' de información permanente.

{{boxinfo|Se entende por ''soporte'' calquera dispositivo que almacena información. Poden ser soportes volátiles (como a RAM) ou permanentes (como un SSD ou unha cinta magnética)}}

Os soportes de almacenamento permanente máis utilizados son os soportes magnéticos, que nos últimos anos están sendo substituídos polas memorias SSD. En canto ao xeito en que permiten almacenar e recuperar a información, podemos clasificar os soportes de almacenamento en:
* '''Soportes Secuenciais''': A información se almacena unha detrás de outra segundo vai chegando, non é posible retroceder nin avanzar a unha posición de escritura concreta sin pasar por enriba de información previa. Entre estes tipos de soporte podemos destacar as cintas magnéticas.
* '''Soportes de Acceso Aleatorio''': Permiten acceder a posicións concretas do soporte de xeito directo para realizar operacións de lectura e escritura. De este tipo de soportes podemos destacar os Discos Magnéticos (HDD) ou as memorias de estado sólido (SDD).

Os dispositivos máis comúns de almacenamento utilizados polos programas son soportes de acceso aleatorio, principalmente HDD e SDD. O xeito de organizar a información en estes tipos de soporte é similar. Dende o punto de vista da programación o concepto máis importante é o de '''bloque físico'''.

{{boxinfo|Un bloque físico é a cantidade de información mínima que se lee ou escribe no soporte de información. Por exemplo, si utilizamos un bloque físico de 4K isto quere dicir que a información se intercambia entre o disco e a RAM en "anacos" de 4K}}

=== O Sistema de Arquivos ===
Os soportes nos dan a posibilidade de almacenar información, pero para poder gardala e recuperala de un xeito eficiente necesitamos organizala dun xeito "comprensible". O xeito en que se organiza a información nun soporte para poder acceder á mesma con facilidade se coñece como ''sistema de arquivos''.

Sistemas de arquivos de uso común son FAT32, VFAT, NTFS, EXT4, ZFS, BTRFS ... etc, cada un de eles con diferentes características e limitacións. Sen embargo, teñen algo en común: Almacenan a información en '''Ficheiros''' (ou Arquivos) e a organizan en '''Directorios''' (ou "carpetas"),

{{boxinfo|O concepto de ''carpeta'' non é máis que unha metáfora para referirnos a un lugar no que agrupamos un conxunto de arquivos, e se coñece así porque nas contornas gráficas de usuario se representan coa icona dunha carpeta. O concepto se denomina  realmente ''directorio''}}

Un ''arquivo'' é o lugar onde almacenamos información en formato binario pertencente a un "concepto" concreto. Por exemplo podemos ter información dunha factura, un documento de texto, un vídeo ou unha fotografía. Podemos distinguir entre dous tipos de arquivos diferentes:
* '''arquivos de texto''': Nos arquivos de texto a información binaria almacenada (nun arquivo informático e nos sistemas informáticos '''toda''' a información está sempre en binario, e decir representando únicamente valores 0 e valores 1) se interpreta como caracteres. Estes caracteres poden ser interpretados segundo varias codificacións (ISO, UTF-8, UTF-16) e algúns deles teñen un significado "especial" (como o salto de liña). Para interpretar correctamente un arquivo de texto é necesario coñecer que codificación de caracteres utiliza.
*'''arquivos binarios''': Nos arquivos binarios a información non ten unha interpretación concreta. Son arquivos que conteñen bits que poden representar absolutamente calquera cousa: Un programa, unha canción, unha fotografía, .... etc. O modo en que se almacena a información se coñece como "formato" do arquivo. Formatos comúns son: class, EXE, PDF, MP4, AVI, MP3, OGG, DOC, MKV, .... etc. Habitualmente para que unha persoa recoñeza de inmediato o tipo de arquivo (o seu formato) se utiliza unha "extensión" para o nome do arquivo que consiste nun punto seguido de 3 letras. Os programas poden ter en conta esa extensión ou non facelo.

Os sistemas de arquivos organizan os arquivos en distintos directorios formando unha árbore na que o raíz ou inicio é o directorio  '''/'''  ('''\''' en Windows). A partir de ahí se van creando directorios e subdirectorios formando unha árbore do tamaño que se desexe. En todos os directorios existen dous directorios "especiais". O directorio '''.''' que representa a posición actual, e o directorio '''..''' que representa o directorio anterior ao actual. 

Para referirnos a un directorio ou arquivo do sistema concreto necesitamos especificar o seu '''camiño''' ou '''ruta''' (''path''). O '''path''' pode ser:
* '''Relativo''': Se van listando os directorios polos que  necesitamos pasar ata alcanzar o destino '''contando dende a nosa posición actual'''. Se separará un directorio de outro utilizando o caracter '''/''' si utilizamos un sistema UNIX/Linux ou '''\''' si utilizamos un sistema Windows.
* '''Absoluto''': Se van listando os directorios polos que necesitamos pasar ata alcanzar o destino contando dende o raíz (e polo tanto o path absoluto sempre comeza por '''/''' ou por '''\''' si estamos en Windows).

{{boxinfo|En Windows existe un concepto que non se utiliza nos sistemas Linux/Unix, que é o concepto de "unidade". Baixo Windows o espazo de almacenamento está distribuído en unha ou varias unidades que se nomean cunha letra. Para crear o ''path'' é necesario antepoñer a letra da unidade seguida de dous puntos: Por exemplo ''C:\Documentos\Java\Titorial.doc'' sería o camiño ao ficheiro ''Titorial.doc'' dende a carpeta raíz (path absoluto) da unidade C:. Nos sistemas UNIX/Linux non se utiliza o concepto de "unidade", polo que o camiño sería ''/Documentos/Java/Titorial.doc''}}

{{boxinfo|Tamén é importante o concepto de '''URI''' ''(Uniform Resource Identifier)'' e de '''URL''' ''(Uniform Resource Locator)''. Unha URI identifica un recurso de xeito que o podemos distinguir de outros recursos. Un camiño a un ficheiro, por exemplo, é unha URI. Existen dous tipos de URI: 
*''URN'': Os URN son "persistentes" no sentido que sempre identificarán o mesmo recurso.
*''URL'': Os URL non son necesariamente "persistentes" e ademáis de identificar un recurso proporcionan información sobre como acceder ao mesmo normalmente indicando o protocolo de acceso antes do identificador (file://, http:// ftp://) }}

=== Uso do sistema de arquivos en Java: A clase File ===
A clase [https://docs.oracle.com/javase/10/docs/api/java/io/File.html File] do API de Java nos permite todas as accións posibles sobre un sistema de arquivos, as principais son:
* Crear un Arquivo: '''createNewFile'''
* Crear unha Carpeta: '''mkdir''' / '''mkdirs'''
* Determinar si un arquivo ou carpeta existe: '''exists'''
* Eliminar un Arquivo ou Carpeta: '''delete'''
* Listar os arquivos dunha carpeta: '''list'''
* Renomear un arquivo ou unha carpeta: '''renameTo'''
* Obter atributos dun arquivo: '''isDirectory''', '''isFile''', '''isHidden''', '''length''', '''lastModified''', '''canExecute''', '''canRead''', '''canWrite'''

;<span style='color:blue'>EXERCICIO</span>: <span style='color:darkgray'>Escribir un programa Java que amose un prompt '''path a carpeta actual >''' e nos permita movernos mediante o comando '''cd''', crear directorios co comando '''md''', crear arquivos co comando '''create''' listar os arquivos mediante o comando '''ls''', renomear arquivos co comando '''ren''' e eliminar arquivos co comando '''rm'''. Tamén debe permitir obter o tamaño e a data de modificación dun arquivo ou directorio co comando '''info'''</span>

== A organización: Campos, Rexistros e Bloques ==
Cando almacenamos información dentro dun arquivo o modo de recuperala depende de varios factores, sendo os máis importantes o tipo de soporte no que se almacena a información (secuencial ou directo) e como se organiza a información dentro do propio ficheiro. A información que se almacena nun arquivo se divide habitualmente en '''rexistros'''. Un '''rexistro''' é un bloque de información con unha relación moi forte entre sí. Podemos comparalo ao conxunto de atributos de unha clase. Por exemplo si almacenamos nun ficheiro os nomes e notas dunha serie de alumnos o rexistro estaría composto do nome do alumno e da súa nota.

Cada unha das distintas informacións que compoñen o rexistro se coñece como '''campo'''. Facendo un símil, si consideramos que un rexistro é similar a un obxecto, un campo ten relación cun atributo.

Cando almacenamos datos nun ficheiro, os organizamos en modo de rexistros, que están compostos de campos.

Un '''bloque''' é o conxunto de rexistros que lemos ou escribimos de unha soa vez. Un bloque pode ser un único rexistro ou máis de un. O óptimo é que o tamaño do bloque coincida co tamaño do ''bloque físico'' que utilice o soporte.

{{boxinfo|Non en todos os ficheiros ten sentido falar de rexistros e campos. Por exemplo nun vídeo en formato mp4 ou un arquivo de música mp3 o concepto de "rexistro" e "campo" é moito menos claro. Nos ficheiros de texto en todo caso poderíamos falar de ''liñas'' e non de rexistros}}

Dependendo como sexan os rexistros podemos distinguir entre:
* '''Ficheiros con rexistro de lonxitude fixa:''' Todos os rexistros teñen o mesmo tamaño. Isto permite unha xestión máis simple e efectiva  dos datos xa que podemos coñecer con antelación onde comeza cada rexistro almacenado no ficheiro.
* '''Ficheiros con rexistro de lonxitude variable:''' Cada rexistro pode ocupar un número distinto de bytes. Isto complica a xestión e o acceso directo a un rexistro concreto, pero aforra espazo no disco.

Dependendo do tipo de soporte que utilicemos podemos '''organizar''' a información de varios xeitos:
* '''Organización Secuencial''': E o xeito de organizar a información mais simple. <u>Se pode levar a cabo sobre soportes secuenciais ou directos</u>. Os datos se escriben secuencialmente, un detrás de outro segundo van chegando.
* '''Organización Directa''': Os rexistros se almacenan nunha posición concreta derivada a partir do seu contido (hashing). <u>É necesario un soporte de acceso directo</u> e permite recuperar rapidamente o rexistro desexado. O problema principal desta organización é o potencial tamaño do arquivo (o ficheiro é tan grande como a posición do último rexistro) e a posibles colisións (cando a distintos rexistros se lles asigna a mesma posición)
* '''Organización Indexada''': Se trata de gardar os <u>datos nun soporte de acceso directo</u> e crear un índice no que se asocia cada rexistro (normalmente mediante un valor único dun campo do rexistro denominado "chave primaria") coa posición en que está gravado permitindo localizar moi rápido a posición do rexistro buscado. O índice pode organizarse de varios modos, sendo o máis común a organización secuencial ou de acceso aleatorio en forma de [https://es.wikipedia.org/wiki/%C3%81rbol_B%2B arbore B+] 

{{boxinfo|Nos soportes directos é posible establecer outro tipo de organizacións complexas para facilitar a inserción e borrado de información, [https://es.wikipedia.org/wiki/Lista_enlazada como poden ser as listas enlazadas e dobremente enlazadas] ou as árbores }}

== O acceso ==
Cando falamos de '''acceso''' nos referimos ao xeito de recuperar e xestionar a información almacenada. Do mesmo modo que a organización está limitada polo tipo de soporte, o modo en que podemos acceder a información depende directamente de como estea organizada.

O xeito de realización das operacións típicas sobre os datos (inserción, actualización e borrado) depende tamén de como estean organizados os datos.

Para acceder os datos nun ficheiro (leer ou escribir) é necesario '''abrir''' o arquivo. A operación de apertura consiste en crear as estruturas en memoria para realizar o acceso ao dispositivo físico, sendo de particular importancia a '''caché do ficheiro''' e o '''punteiro do ficheiro'''. A caché do ficheiro permite acelerar as operacións facendo que a modificación se realice na memoria RAM (máis rápida) sendo volcada logo en segundo plano ao dispositivo (máis lento). O punteiro do ficheiro indica en todo momento o punto do ficheiro no que se vai a operar. Cada operación de lectura ou escritura fai que ese punteiro se actualice a nova posición automáticamente.

Si queremos non perder datos é necesario '''pechar''' o ficheiro cando xa non operemos máis con él. O peche asegura que os datos da caché se reflexen no dispositivo evitando así perdas accidentais de datos además de liberar todos os recursos ocupados polo acceso ao ficheiro.

{{boxinfo|E moi importante asegurarse que todos os ficheiros que se abren se pechan. E común para eso utilizar a cláusula '''finally''' nun bloque '''try''' ou o uso de ''try with resources'' }}

En canto o acceso, podemos falar de:
* '''Acceso Secuencial''': Sempre é posible acceder ós datos de xeito secuencial. O acceso secuencial consiste en ir lendo datos secuencialmente, dende a posición actual ata rematar todos os datos. Non é posible avanzar nin retroceder.<br>
:As distintas operacións están limitadas por este modo de acceso:
:*Para ler un rexistro concreto é necesario ler os anteriores
:*Eliminar/borrar información é moi complexo e costoso, xa que é necesario leer todos os datos anteriores ao punto de modificación.
:*So é posible engadir nova información ao final do arquivo. Insertar información noutro punto precisa da creación dun novo arquivo.
* '''Acceso Directo''': So é posible acceder mediante acceso directo si a información está organizada de xeito directo, o que implica que a posición de cada rexistro se calcula a partir da información almacenada. Si non é así, dado que o soporte ten que ser obrigatoriamente de acceso directo sigue sendo posible acceder directamente a rexistros arbitrarios si coñecemos a súa posición (si os rexistros son de lonxitude fixa coñeceremos a posición de comezo de cada rexistro), isto se coñece como '''acceso aleatorio'''.
* '''Acceso Indexado''': Dispoñemos dun "índice" (que pode estar organizado de diversos modos) que nos indica a posición de cada rexistro en función dun valor de campo especial que coñecemos como "chave"

{{boxinfo|A eliminación de información dun arquivo '''non é posible'''. Para "borrar" información é necesaria a creación dun novo arquivo omitindo a información a eliminar, o que resulta unha operación moi custosa en termos de rendimento. Para evitar esto se recurre a ''marcar'' o rexistro como eliminado mediante un valor ''especial'' nun dos seus campos ou reservando ao principio de cada rexistro un área de información sobre o contido do rexistro (''metadatos'') onde ademais de indicar si o rexistro é válido ou non podemos subministrar outra información como o número de bytes que ocupa o rexistro. Este sistema cando o volume de borrados é moi alto fai que o arquivo ocupe demasiado espazo de xeito innecesario, polo que se recurre a ''desfragmentación'' do arquivo creando un novo arquivo que omite os rexistros borrados. Unha boa estratexia na inserción de novos rexistros (aproveitando o espazo dos rexistros borrados) tamén reduce este problema.
A organización en forma de lista tamén facilita a inserción e borrado. Por exemplo, mantendo unha lista de rexistros válidos e unha lista de rexistros borrados}}

=== Serialización, A interface Serializable ===
Os ficheiros almacenan bytes, é dicir, secuencias de 0 e 1. Sen embargo, a información que almacenamos e recuperamos é "mais complexa", como liñas de facturas, ventas anuais, clientes, vehículos, contas bancarias.... etc.
Como sabemos, a información que almacenamos en ficheiros a organizamos en rexistros (ou liñas si son ficheiros de texto), e os rexistros están a súa vez divididos en campos. Polo tanto, é necesario un medio de convertir esa información (atributos dun obxecto) a bytes e viceversa. Eses procesos se coñecen como '''serialización''' e '''deserializacion''' respectivamente.

Mentres que serializar os tipos de datos primitivos (byte, short, int, long, float, double, boolean, char) e as súas clases correspondentes (Byte,Short,Integer,Long,Float,Double,Boolean,Char) é simple (xa que o número de bytes que ocupan é fixo e coñecido) a serialización de clases máis complexas non é tan simple. Para solucionar este "problema" Java proporciona unha interface implementada na maioría das clases do API denominada '''Serializable'''.

A interface ''Serializable'' non define ningún método, simplemente "activa" os seguintes métodos da clase Object e que podemos sobrepoñer para variar o seu comportamento:

<source lang='java' style='font-size:80%'>
private void writeObject(java.io.ObjectOutputStream out) throws IOException
private void readObject(java.io.ObjectInputStream in) throws IOException, ClassNotFoundException;
private void readObjectNoData() throws ObjectStreamException;
</source>

'''Os fluxos de bytes ''(Streams)'' se verán nun tema posterior'''

{{boxinfo|Calquera clase que ''implements Serializable'' pode convertir os seus obxectos nun ''fluxo'' de bytes e viceversa (a partir dun fluxo de bytes reconstruír o obxecto). Para que un obxecto se poda serializar correctamente, todos os seus atributos deben ser Serializable}}

{{boxinfo|A clase ''String'' dispon dun método '''byte[] getBytes()''' que permite obter o array de byte que conforma o String e dun constructor '''String(byte[] data)''' que permite crear un String a partir dun array de bytes que o representa}}

=== A clase RandomAccessFile ===
A clase do API Java '''''RandomAccessFile''''' permite almacenar información nun ficheiro de acceso aleatorio no disco. Cando creamos un obxecto de este tipo se creará a estrutura na memoria necesaria para ler e escribir información no disco e o buffer de memoria correspondente. <u>O almacenamento se realizará sobre un soporte de acceso aleatorio, pero para poder acceder de xeito directo aos datos é precisa tamén unha organización que o permita</u>

{{boxinfo|Un concepto fundamental para a correcta xestión dos RandomAccessFile é o ''Punteiro do Ficheiro''. O punteiro do ficheiro indica en todo momento a posición do ficheiro na que se levará a cabo a seguinte operación de lectura ou escritura, e se actualiza de xeito automático segundo lemos ou escribimos. RandomAccessFile nos proporciona métodos para coñecer o valor deste punteiro e para "movelo" á posición que desexemos. }}

Algúns métodos que nos proporcionará esta clase son:
<source lang='java' style='font-size:80%'>
 long length();  // Devolve o número de bytes que ocupa o ficheiro
 long getFilePointer(); // Indica a posición actual do punteiro do ficheiro
 void seek(long pos); // Coloca o punteiro do ficheiro na posición pos
 void close(); // Pecha o RandomAccessFile liberando todos os recursos ocupados e volcando o buffer a disco
</source>

Ver [https://docs.oracle.com/javase/10/docs/api/java/io/RandomAccessFile.html#skipBytes(int) RandomAccessFile na documentación de Java]

{{boxinfo|''RandomAccessFile'' implementa ''Closeable'' o que permite o uso de [https://docs.oracle.com/javase/tutorial/essential/exceptions/tryResourceClose.html try with resources] para asegurar o correcto peche do ficheiro}}

== ORM (Object Relational Mapping ==
Si empregamos unha base de datos relacional para almacenar os obxectos os atributos se almacenarían como campos en táboas da base de datos, correspondendo habitualmente cada clase a unha táboa específica. Habitualmente se empregan librarías de clases deseñadas para xestionar o almacenamento e recuperación de datos de xeito automático denominadas sistemas '''ORM (''Object-Relational Mapping'')'''.

Un ''ORM'' é un conxunto de clases que permiten almacenar e recuperar obxectos nunha base de datos relacional de xeito transparente e simple evitando a dependencia de sistemas de bases de datos concretos e incluso sen necesidade de uso das linguaxes de consulta do xestor da base de datos (como ''SQL''). O ORM se encarga de almacenar os atributos dos obxectos nas táboas cando “gardamos un obxecto” e de ler os atributos e reconstruír o obxecto cando “lemos un obxecto”. Un dos ORM máis empregados en Java é '''Hibernate'''. ''Hibernate'' pode facer uso de annotations (instruccións de preprocesamento que comezan por @) para asociar clases co almacenamento relacional e xestionar a carga e descarga de obxectos de xeito transparente.
<source lang='java' style='font-size:80%'>
import javax.persistence.*;

@Entity
@Table(name = "EMPLOYEE")
public class Employee {
  @Id @GeneratedValue
  @Column(name = "id")
  private int id;

  @Column(name = "first_name")
  private String firstName;

  @Column(name = "last_name")
  private String lastName;

  @Column(name = "salary")
  private int salary;

  public Employee() {}
.... getters y setters ...
</source>
[https://www.journaldev.com/2882/hibernate-tutorial-for-beginners podes ver aquí máis información sobre Hibernate]

Sen embargo non é imprescindible o uso de ORM para almacenar e recuperar información dunha base de datos relacional, pode facerse mediante unha serie de clases que nos proporcionan unha API de acceso á base de datos dende Java, como '''JDBC (''Java DataBase Connectivity'')'''.
Si as necesidades de almacenamento e recuperación non son tan complexas, tamén se pode facer uso de simples ficheiros no noso sistema de almacenamento principal. O almacenamento de datos en ficheiros pode facerse en ficheiros secuenciais facendo uso de ''Streams'' de datos ou en ficheiros de acceso aleatorio mediante ''RandomAccessFile''.

;<span style="color:blue; font-weight:bold; font-size:110%;">EXERCICIO</span>: Precisamos de dous ficheiros de datos ''Traballadores.dat'' que almacena o nif, nomes e apelidos dos traballadores da empresa, e "Salarios.dat" que almacena o salario de cada un de eles nun número double. Se pide:

1.- Escribir un programa que visualice e leve a cabo un menú coas seguintes opcións:
::1.- Listar Traballadores  --> Visualizará na pantalla todos os traballadores indicando DNI, nome e apelidos.
::2.- Borrar Traballador    --> "Eliminará" o traballador
::3.- Engadir Traballador   --> Se solicitará o DNI, nome, apelidos e salario e se engadirá aos ficheiros ''Traballadores.dat'' e ''Salarios.dat''
::4.- Modificar Salario --> Se solicitará o DNI, e si o traballador existe, se visualizarán os seus datos e se pedirá o novo salario actualizando o ficheiro ''Salarios.dat'' 
::5.- Ver Salario --> Solicitará o DNI e visualizará nome, apelidos e salario consultando o ficheiro ''Salarios.dat''
::6.- Sair

'''NOTA:''' ''A clase Traballador NON almacena o salario, se debe consultar/modificar no ficheiro ''Salarios.dat''. O ''Borrado'' se realizará mediante unha "marca" no rexistro que nos indicará si é válido ou non é válido. Cando gardamos un traballador lle asignaremos un número que vai a corresponder coa posición ordinal do seu salario no ficheiro de Salarios.dat (1,2,3... etc)

;<span style="color:blue; font-weight:bold; font-size:110%;">EXERCICIO</span>: Un periódico quere crear unha páxina web na que salga a portada, de xeito que cando o usuario faga click no titular se visualice todo o corpo da noticia. Para facer iso, se crea un ficheiro "News.dat" organizado secuencialmente que contén o titular, a entradilla e a posición no ficheiro NewsDetails.dat no que está o corpo principal da noticia. Se pide escribir un programa que visualice o seguinte menú:

::1.- Engadir Noticia ---> Se solicitará titular, entradilla e corpo
::2.- Ver Noticias  ---> Se visualizarán as noticias e as entradillas, permitindo elixir unha de elas. Cando se elixa, se visualizarán os detalles da mesma
::3.- Saír


;<span style="color:blue; font-weight:bold; font-size:110%;">EXERCICIO</span>: Imos crear unha organización en forma de lista enlazada mediante un ficheiro de acceso directo que nos optimice a inserción e borrado de rexistros, e un índice organizado secuencialmente que nos vai a permitir localizar directamente un rexistro concreto a partir do valor dun campo do rexistro (chave primaria).

:A organización do ficheiro de datos será a seguinte:

{| class="wikitable"
|-
| Posicion Primeiro Rexistro Datos (Long) || Posición Último Rexistro Datos (Long) || Posición Primeiro Rexistro Borrados (Long) || Posición Ultimo Rexistro Borrados (Long) || Datos || Datos || ...
|}

: Cada Dato se almacenarán do seguinte xeito

{| class="wikitable"
|-
| Lonxitude(integer) || Posición seguinte (Long) || Posición anterior (Long)  || Rexistro Datos || ....
|}

: A organización do ficheiro índice será a seguinte:

{| class="wikitable"
|-
| Dirty (byte) || Lonxitude (int) || Chave || Posicion(Long) || Lonxitude (int) || Chave || Posicion(Long) | ....
|}

Como non coñecemos os datos específicos a gardar e recuperar (dependerá da clase do obxecto que queramos gardar), definimos unha interface coa funcionalidade que necesitamos. Será posible almacenar en ficheiros organizados de este xeito calquera obxecto que implemente a interface Rexistrable:

<source lang='java' style='font-size:80%'>
public interface Rexistrable<K> {
     boolean isDeleted(); // Nos indica si este elemento Rexistrable está marcado como borrado ou non
     K getKey(); // Devolve o valor de chave primaria do Rexistrable
     void readRecord(RandomAccessFile f) throws LinkedFileError;  // Lee na posición actual do RandomAccessFile e garda a información nos atributos do obxecto
     void writeRecord() throws LinkedFileError; // Almacena os valores dos atributos do obxecto na posición actual do RandomAccessFile
}
</source>