Foros aprenderaprogramar.com
Didáctica y divulgación de la programación

No hay de qué. Encantado de ayudar.

Si no logras completar el programa o te queda alguna pregunta pendiente, no dudes en publicarla por aquí.

Un saludo.

mmmh, tu método para guardar partida, el principal fallo que tiene es que estás usando clases Reader(BufferedReader, InputStreamReader,... )

Es decir, son clases para "leer", y tu lo que quieres es "escribir".

Si quieres guardar el contenido de la matriz tablero como texto plano, puedes usar BufferedWriter.

Sin embargo, puedes guardarlo directamente como un archivo de bytes. La ventaja es que es más cómodo y rápido de programar, son muy poquitas líneas.
La "desventaja", es que el archivo donde se guarda no será legible a ojos humanos. Pero en un caso como este, supongo que esto no importa, pues el propósito es que el programa pueda cargar y guardar partidas, no obtener un fichero que se pueda leer.


Para ello puedes usar la clase ObjectOutputStream.
Lo que hace es coger un objeto (en Java, una matriz es un objeto) y tal cuál está en ese momento en memoria RAM, lo traspasa a un archivo de bytes.

No es necesario recorrer la matriz  e ir guardando el valor de cada uno de sus elementos, no...
Se coge la matriz entera y se guarda como código binario.

El método podría ser tan sencillo como este:
public void guardarPartida(){
try {
ObjectOutputStream escritor = new ObjectOutputStream(new FileOutputStream("d:/partida3Raya.bin"));
//Escribimos la matriz tal cuál está en memoria RAM, como archivo binario
escritor.writeObject(tablero);
escritor.close();
} catch (FileNotFoundException e) {
System.out.println("No se encuentra fichero: partida3Raya.bin");
} catch (IOException e) {
System.out.println("Problema de acceso a fichero: partida3Raya.bin");
}
}
Luego, para recuperar los datos del archivo y pasarlos a la matriz tablero, usaríamos la clase opuesta, la ObjectInputStream.
Al leer el archivo nos retorna un Object (un objeto), el cuál para poder asignarlo como matriz tablero, habrá que hacer un casting a int[][]

public void cargarPartida(){
try {
ObjectInputStream lector = new ObjectInputStream(new FileInputStream("d:/partida3Raya.bin"));
//Leemos los bytes del archivo y nos retornará un Object, al que haremos casting a matriz int[]
tablero = (int[][]) lector.readObject();
lector.close();
} catch (FileNotFoundException e) {
System.out.println("No se encuentra fichero: partida3Raya.bin");
} catch (IOException e) {
System.out.println("Problema de acceso a fichero: partida3Raya.bin");
} catch (ClassNotFoundException e) {
System.out.println("Los datos obtenidos no permiten recuperar la partida");
}

}

Bien, ambos métodos deberían funcionar.
Pero ahora se te presenta otro problema. 
¿Cómo puede el usuario, en mitad de una partida, salirse de ella para regresar al menú y ordenar que se guarde la partida?

A ver si se te ocurre como solucionarlo.

Un saludo.

Mmhh, esta vez el código va bien encaminado, aunque no del todo.

La comprobación inicial para ver si existe o no el fichero está bien.
Pero luego estas líneas:

if (System.IO.File.Exists(nombre))
                   {
                    Console.WriteLine("el nombre existe");
                   }
                else
                {
                    Console.WriteLine("eel nombre no existe");
                }Aquí no estás comprobando si el nombre existe dentro del archivo, que es lo que se pide.

Estás comprobando si existe un archivo cuya ruta sea igual al nombre, y no es eso lo que hay que lograr.

Una vez has comprobado que el archivo sí existe, entonces hay que leer las líneas de ese archivo y comprobar si alguna línea contiene el nombre.

Es decir, imagina que el archivo de texto seleccionado, contiene una lista de nombres con sus teléfonos:

Nombre: sara pelaez -- Telefono: 656789034
Nombre: laura juan -- Telefono: 690872311
Nombre: alfredo timoneda -- Telefono: 650812093
Nombre: eva llanes -- Telefono: 633908070
Nombre: lidia guarque -- Telefono: 654120987
Nombre: sandra cevallos -- Telefono: 621109082
Nombre: jorge morales -- Telefono: 656231050

Y como nombre a buscar nos indican: jorge morales

Pues hay que leer esas líneas y comprobar si alguna contiene la cadena "jorge morales".
Si la tiene, podemos mostrar la línea completa.

Si no la tuviera, habrá que informar de que no existe ese nombre.


Mira, te explico la lógica que yo he seguido y luego pongo el código completo al final.

* Primero pido el nombre a buscar
* Luego pido el nombre de fichero. Esta petición la hago dentro de un bucle de forma que se va a repetir hasta que:
- me indique una ruta de un fichero que si existe
- o bien teclee la cadena "fin" para terminar el programa, sin hacer ninguna búsqueda

*A continuación, si NO ha introducido "fin" y el bucle anterior ha terminado, es que entonces SÍ tengo un ruta de fichero válida.
Pues entonces inicializo un StreamReader y comienzo a leer líneas dentro de otro bucle.
Este bucle se repite hasta que:
- No queden líneas por leer en el fichero
- Encuentre el nombre que se busque. Esto lo controlo con una variable bool, si encuentro el nombre, le daré valor true a esta variable y entonces el bucle terminará, sin seguir leyendo más líneas.

* Por cada línea leída, compruebo si contiene el nombre indicado. ¿Cómo?
Pues cuando leo una línea, esta se guarda en un String. Este String, tiene un método llamado Contains() al cuál le puedo pasar una cadena de texto y me dice si ese String contiene esa cadena o no (true o false)
Así que le paso el nombre a buscar y si retorna true, indico en pantalla que se ha encontrado el nombre y muestro la línea completa.
A la variable bool le doy valor true, y así el bucle sabe que ya puede terminar.

* Por último, compruebo de nuevo el valor de esta variable bool.
Si su valor al final del programa es false, significa que el bucle ha terminado sin haber encontrado el nombre que se busca, así que lanzo un mensaje final avisando de que no existe ese nombre.

Este es el código. Fíjate también que solo necesito dos "using ...." al principio.
En tus códigos pones varios using innecesarios como estos:
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
Aquí mi código. Insisto en que lo repases y si algo no lo entiendes, pregúntalo.
No te conformes con tener una solución, asegúrate de que la comprendes.

using System;
using System.IO;

namespace BuscaNombreFichero
{
    class Program
    {
        static void Main(string[] args)
        {
            String linea, nombre, fichero;
            bool encontrado = false;

            Console.WriteLine("Nombre a buscar: ");
            nombre = Console.ReadLine();

            //Con el bucle repito la solicitud de archivo hasta que exista o hasta que el usuario elija "fin"
            do
            {
                Console.WriteLine("Fichero donde hacer busqueda(escriba 'fin' para terminar): ");
                fichero = Console.ReadLine();
                if (!fichero.Equals("fin"))
                {
                    if (!File.Exists(fichero))
                        Console.WriteLine("No se encuentra ese fichero...\n");
                }
            } while (!fichero.Equals("fin") && !File.Exists(fichero));


            if (!fichero.Equals("fin")) //El siguiente código solo se ejecuta si NO se ha introducido "fin"
            {
                StreamReader lector = new StreamReader(fichero);

                //Leemos mientras hayan lineas, o hasta que se encuentre el nombre buscado
                while ((linea = lector.ReadLine()) != null && !encontrado)
                {
                    //Comprobamos si esta linea contiene el nombre
                    if (linea.Contains(nombre))
                    {
                        Console.Write("El nombre ha sido encontrado en la linea: ");
                        Console.ForegroundColor = ConsoleColor.Yellow;
                        Console.WriteLine(linea);
                        Console.ResetColor();
                        encontrado = true; //Esto pone fin al bucle
                    }
                }

                lector.Close();
                if (!encontrado)
                    Console.WriteLine("No se ha encontrado el nombre en el fichero.");
            }
        }
    }
}


Para poder guardar la factura, podria hacer el mismo codigo que para guardar clientes y productos?

Sí, aunque si lo quieres guardar también como texto plano.... va a resultar bastante más complicado.
¿Por qué?
Porque la clase Factura tiene algunos atributos que son objetos "complejos".

Cuando se trata de un String, un int, double.... no hay problema para escribirlos como texto.
Lo único a tener en cuenta, es que al leerlos habrá que convertir a int, a double o lo que sea..

Pero que pasa cuando nos encontramos con atributos más complicados.

Hay un atributo que es el Cliente
    /**
     * El client de la factura
     */
    private Client client = null;
   
Para guardar esto como texto, se puede desglosar sus atributos para luego reconstruirlo.
Aunque se podría optimizar guardando como texto solo el id de cliente, y luego al leer el archivo de texto para reconstruir las Facturas, buscar el cliente a través del id

También hay un atributo que es LocalDateTime

    /**
     * Data de creació de la factura
     */
    private LocalDateTime dataFactura = null;
¿Cómo escribes eso en una línea de texto?
Se puede hacer, extraer dia, mes y año(que son valores int) y escribirlos como texto plano.
Luego al leer, con ese dia, mes y año se puede reconstruir el objeto LocalDateTime.

Pero esto ya exige escribir más código y desarrollar una línea de texto más compleja.


Y espera, ahora viene lo mejor, hay un atributo que es un array de objetos ProducteFactura
    /**
     * Array amb els productes de la factura
     */
    private ProducteFactura[] producteFactures = null;
¿Cómo guardas ese array en texto plano? 

Pufff.... se puede guardar desglosando los atributos correspondientes a cada objeto ProducteFactures.
Y luego al leer, reconstruir esos objetos y con ellos, reconstruir el array.
De nuevo esto exige un código más complejo.

Pero es que hay un problema añadido.
Las líneas de texto que usamos para guardar Productos o Clientes.., tienen un número de atributos fijos, así que todas las líneas van a tener la misma cantidad de valores.
Así cuando hacemos split(), ya sabemos de antemano cuántos elementos nos va a devolver y en el código ya sabemos a que atributo corresponde cada elemento obtenido mediante split().

Pero en este caso, resulta que cada objeto Factura, su array de ProducteFactura puede tener distintas longitudes.
Una Factura puede que solo tenga dos productos facturados, otra puede que tenga cinco, otra puede tener diez....

Es decir, que cada línea de texto plano que representa una Factura, el método split() nos va a retornar distintas cantidades de elementos.
Porque cada Factura tendrá un número distinto de elementos facturados.

Aquí ya no solo se va a requerir más código, si no más ingenio para encontrar una forma de crear una línea con toda esa cantidad de datos y que luego sepamos leerla bien para reconstruir los datos.

Tal vez se podría cambiar la estrategia de "una línea por objeto".
Es decir, hasta ahora hacíamos una línea de texto por cada Producto, otra por cada Cliente...

En el caso de las Facturas, se podría usar varias líneas por cada Factura.
La primera línea, todos los atributos menos el array.
Y al final de la línea un número que nos diga cuantas líneas de las que vienen a continuación, corresponde a los elementos del array.

Algo parecido a esto:

0001 -- 22/03/2021 -- 21.0 -- Efectivo -- 0045 -- 3
-- Datos de un objeto ProducteFacture
-- Datos de un objeto ProducteFacture
-- Datos de un objeto ProducteFacture
0002 -- 12/01/2021 -- 16.0 -- Visa -- 0023 -- 2
-- Datos de un objeto ProducteFacture
-- Datos de un objeto ProducteFacture

Como ves, resulta bastante más complejo y trabajoso guardar las Facturas como texto plano.
Pero se puede.

En cambio si serializamos para guardar en un archivo de bytes, no hay problema, no importa lo complejos que sean los objetos que queremos guardar.

Por cierto, ahora que me fijo, la clase ProducteFacture tiene atributos redundantes.
Podría bastar con que solo guardase referencia del producto y cantidad.
Lo que es el nombre, precio y descripción... ya lo tiene la clase Producte y esos datos se podrían obtener consultando al array de Productes a través de la referencia.
 

Ese error parece como que alguna línea leída, al hacer split(),no ha proporcionado un array de cuatro elementos, si no de tres. (el error dice que length es 3)
Entonces, al intentar obtener el valor que estaría en la posición [3] del array que retorna el split() se produce ese error de "índice fuera de limites" (out of bounds), porque no existe dicha posición.

Comprueba que las líneas que se escriben en el archivo de texto de clientes, tienen 4 valores, ya que los Clientes tienen cuatro atributos.

Si a caso has decidido guardar solo tres atributos, porque por ejemplo no estás guardando el idCliente, entonces cambia el código para luego solo recoger los elementos de las posiciones [ 0 ], [1] y [2].

Respecto al primer ejercicio.

Esta línea de código:
String[] words= line.Split(' '); Eso lo que hace es dividir la línea en palabras, cada palabra queda insertada en el array llamado words.
Pero luego no haces con ese array. De todos modos, el enunciado del ejercicio no te dice que busques palabras.

Esta otra línea:
count = count + char.Length;
Directamente no compila... char.Length  no es nada. Se estaría llamando a la propiedad Length de la clase char, pero es que no tiene dicha propiedad..

Lo que necesitas son dos String.
Uno para leer línea a línea el archivo de texto.
El otro String, para guardar la línea mayor.
Cada vez que se lee una línea se comparan la longitud de la línea leída con la que tengamos guardada como línea mayor (estas si tienen la propiedad .Length)
Si la línea recién leída es más larga, pasa a ser guardada como línea mayor y se sigue comparando con las siguientes líneas.

Además usaremos dos int.
Uno para contar las líneas leídas y el otro para guardar la posición de las línea que se va guardando como mayor.

Luego, lo que no se nos pide es que una vez tengamos finalmente la mayor línea de todas, calculemos cuantas vocales tiene.

Esto, para que el código quede mejor estructurado, es mejor usar un método que reciba la línea y retorne un int con la cantidad de vocales encontradas.
Para buscar vocales en la línea, lo que haremos será transformar el String que contiene la línea, en un array de char.
Recorremos el array, carácter a carácter, y comprobamos si es una vocal. Para esto podemos usar un switch, donde si el caracter es 'a', 'e', 'i', 'o', 'u'... pues incrementamos un contador.
Finalmente se retorna este contador, que indica las vocales encontradas.

Este podría ser el código:

        static void Main(string[] args)
        {
            String linea, lineaMayor = "";
            int contadorLinea = 0, posicionLineaMayor = 0;
            System.IO.StreamReader file = new System.IO.StreamReader(@"d:\curso.txt");

            while ((linea = file.ReadLine()) != null)
            {
                contadorLinea++; //Contamos línea leída

                //Comparamos tamaño linea actual, con la linea Mayor encontrada hasta ahora
                if (linea.Length > lineaMayor.Length)
                {
                    //Es mayor, esta linea pasa a ser la linea mayor y guardamos su posicion
                    lineaMayor = linea;
                    posicionLineaMayor = contadorLinea;
                }

            }
            file.Close();
            //Ya tenemos la mayor línea y su posicion, mostramos resultados
            Console.WriteLine("Mayor linea encontrada:\n" + lineaMayor);
            Console.WriteLine("\t\n*****************************\n");
            Console.WriteLine("Posicion:" + posicionLineaMayor);
            Console.WriteLine("Cantidad de vocales: " + cuentaVocales(lineaMayor));

        }

        static int cuentaVocales(String linea)
        {
            int vocales = 0;

            //Convertimos la linea String a un array de caracteres (todos en minúscula)
            char[] caracteres = linea.ToLower().ToCharArray();

            //Repasamos cada caracter con un bucle y buscamos vocales con un switch
            for (int i = 0; i < caracteres.Length; i++)
            {
                switch(caracteres[i])
                {
                    case 'a':
                    case 'e':
                    case 'i':
                    case 'o':
                    case 'u':
                        vocales++;
                        break;
                }
            }

            return vocales;
        }
Si ejecutamos el código, parece funcionar correctamente:

Mayor linea encontrada:
¿Por qué se obliga en C a añadir archivos de cabecera incluso para funciones básicas del lenguaje? Posiblemente porque cuando se creó C se hizo teniendo muy en cuenta la eficiencia y el evitar sobrecargar el computador ocupando memoria inútilmente. Imagínate que eres el cliente de un restaurante ("el cliente del compilador") y que vas a pedir un menú. El dueño del restaurante no prepara todos los platos posibles y los pone a tu disposición, sino que espera a que tú le digas los platos que deseas y son únicamente esos los que prepara. De esta forma ahorra espacio y esfuerzo. En nuestro caso, en lugar de cargar en memoria y poner a tu disposición todas las posibles funciones del lenguaje, el compilador sólo carga y pone a disposición aquellas funciones que declaramos que vamos a usar. De este modo se gana en eficiencia.

*****************************

Posicion:135
Cantidad de vocales: 300

Al guardar el archivo en disco, no se puede leer un carajo... porque NO es un archivo de texto.
Es un archivo de bytes, lo que guardamos es una copia del "lenguaje máquina" tal cuál está en la memoria RAM.

Por eso en el programa lo puse para que se guardase con extensión .bin (binary code).
Se le puede poner cualquier extensión, sus datos internos son los mismos. Pero si le ponemos .txt, se puede dar a entender que es un archivo de texto. Y no lo es.


La ventaja de guardar los datos como bytes, es que el código para hacer esto es muy sencillo.
Básicamente necesitamos una instrucción para escribir, y otra para leer. Punto pelota.

La desventaja, que si luego queremos poder leer su contenido abriéndolo como un archivo de texto, nos vamos a encontrar un galimatías.


Se puede guardar también como archivo de texto plano, es decir, un verdadero y genuino .txt

El proceso es muy parecido, pero implica hacer más (muchas más) operaciones extra, además de decidir cómo nos conviene que se escriban los datos.
Porque según como los escribamos, luego será más fácil o más difícil leerlos.
Me explico:

Un Producto tiene cuatro atributos: referencia(int),  nombre(String), precio(double) y descripcion(String)

Supongamos que tenemos 5 Productos registrados en un ArrayList y queremos guardarlos en un archivo de texto plano.
Tendremos que recorrer el ArrayList con un bucle para obtener los tres atributos de cada Producto y escribirlos en el archivo de texto (esto como decía, ya supone realizar varias instrucciones de más comparado con antes).

Si simplemente vamos escribiendo en el archivo de texto, según vamos obteniendo valores de atributos, tendremos un archivo de texto como este:

1Coca-Cola1.25Bebida refrescante azucarada2Coca-Cola Light1.30Bebida refrescante ligera en azucares3Coca-Cola Zero1.30Bebida refrescante sin azucar4Fanta Limon1.25Bebida refrescante sabor limon5Fanta Naranja1.25Bebida refrescante sabor naranja

Vale, ahora si tenemos texto que entiende un humano, pero esta todo apelotonado en una sola línea.
No solo es feo a nuestros ojos, esto es lo de menos.
El auténtico problema es que luego para recuperar los datos en nuestro programa, tenemos que saber que palabras y números corresponden a cada atributo, para podre reconstruir los objetos Producto que habíamos guardado de la sesión anterior.

¿Entiendes por donde voy?
Antes, serializando todo en un archivo de bytes, era muy sencillo porque los objetos Producto se guardan tal cuál estaban en memoria RAM. Luego al leerlos no hay que reconstruir nada, porque permanecen "construidos" en el archivo de bytes.

Esto no es posible hacerlo en el archivo de texto plano, aquí solo podemos guardar los valores de los atributos de los productos, pero no los objetos Producto tal cual.
Y luego, hay que recuperar esos valores y separarlos, y utilizarlos para volver a construir otra vez los Productos (habrá que hacer otra vez new Producto() para cada uno y agregarlos otra vez al array de Producte[] )

Así que para facilitar esta tarea, primero hay que decidir una forma más adecuada para escribir los valores en el txt.
Lo habitual es hacer una línea para cada Producto.

1Coca-Cola1.25Bebida refrescante azucarada
2Coca-Cola Light1.30Bebida refrescante ligera en azucares
3Coca-Cola Zero1.30Bebida refrescante sin azucar
4Fanta Limon1.25Bebida refrescante sabor limon
5Fanta Naranja1.25Bebida refrescante sabor naranja

Bien, ahora ya sabemos donde comienza y termina cada Producto. Cada línea es un Producto.
Pero no sabemos bien donde comienzan y terminan cada valor de los atributos.
Tenemos que decidir alguna forma óptima de separarlos.
Así después, leeremos las líneas una por una. Y cada línea la partiremos en trozos allá donde detectemos lo que separa un valor de otro.
¿Y con qué separamos un valor de otro?

No podemos usar espacios en blanco, porque por ejemplo los nombres de producto o el texto de la descripción contienen espacios en blanco. Así que esto no nos va a servir para saber con certeza donde comienza un valor y termina otro

Podemos usar una coma para separar cada valor

1,Coca-Cola,1.25,Bebida refrescante azucarada
2,Coca-Cola Light,1.30,Bebida refrescante ligera en azucares
3,Coca-Cola Zero,1.30,Bebida refrescante sin azucar
4,Fanta Limon,1.25,Bebida refrescante sabor limon
5,Fanta Naranja,1.25,Bebida refrescante sabor naranja

Esta solución puede servir, si estamos seguros de que ni el nombre ni la descripción van a tener comas.
Sin embargo es arriesgado no solo por esos atributos, si no también por el precio. Yo lo he puesto con punto decimal, pero en realidad, cuando se guarde en archivo es posible que se guarden con coma decimal, esto puede variar según el sistema operativo y la configuración regional del usuario.
De hecho, luego al leer los datos, el que corresponde al precio habrá que parsearlo a double porque al leer del txt lo vamos a obtener como String, pero el atributo es un double.
Y habrá que controlar que no nos llegue con coma decimal, porque entonces el parseo a double fallará...solo es posible parsear a double si el texto leído tiene un punto decimal, no coma decimal.

Así que por todo esto, mejor usar otro símbolo para separar los productos. Para curarnos en salud, lo mejor es usar un conjunto de símbolos, por ejemplo dos guiones seguidos con espacio en blanco a cada lado.

1 -- Coca-Cola -- 1.25 -- Bebida refrescante azucarada
2 -- Coca-Cola Light -- 1.30 -- Bebida refrescante ligera en azucares
3 -- Coca-Cola Zero -- 1.30 -- Bebida refrescante sin azucar
4 -- Fanta Limon -- 1.25 -- Bebida refrescante sabor limon
5 -- Fanta Naranja -- 1.25 -- Bebida refrescante sabor naranja

Así se lee mejor a simple vista, y lo mejor de todo es que luego raro sería que ocurriesen errores al trocear las líneas correctamente en cuatro valores, uno para cada atributo.

Disculpa si me extiendo mucho con la explicación, pero es para que quede claro que guardar los valores como texto plano, supone ciertas complicaciones.

Ahora veremos como resolver todo esto con código Java.
De nuevo trabajaremos con los Productos y usaremos métodos específicos para guardar como texto plano, sin quitar lo que habíamos hecho antes. Así tendremos las dos versiones para practicar.

Lo primero que haremos, para facilitar las cosas, es crear un método en la clase Producto que nos construya una línea de texto con los atributos, tal y como queremos que se guarden en el archivo txt.
Algo parecido a lo que hacemos con el método toString(), pero este lo usaremos para escribir el Producto en una línea de texto.

Dicho método, puede ser como este:
    public String toTxt() {
    return String.format("%d -- %s -- %.2f -- %s", refProducte, nom, preu, descripcio);
    }Eso ya nos devuelve una línea de texto, con los atributos separados por los dobles guiones.
También conviene reiniciar a 0 el contador interno de Productos creados que tiene la clase Producte.
Este contador se usa para establecer el atributo de la referencia cuando creamos un Producto nuevo. Como al leer líneas de texto, vamos a crear Productos nuevos (con valores guardados de antes) para evitar inconsistencias con las referencias, es mejor que comience desde 0 otra vez.
Así que le añadimos también este método a la clase Producte (ha de ser estatico):
    public static void resetTotalProductes() {
    totalDeProductes = 0;
    }Esto no lo tuvimos en cuenta la vez anterior, y creo que también habría sido importante hacerlo.


Bien, pues ahora en la clase principal, añadimos nuevo método para guardar productos, esta vez en un archivo de texto plano.
Para esto usaremos la clase BufferedWriter, que a su vez necesita un FileWriter, que a su vez necesita un File.
El proceso es parecido a la forma anterior, pero fíjate que antes escribíamos tal cual el array de Productos.
Ahora, hay que recorrer el array y a cada Producto, pedirle que nos retorne la línea de texto, que será lo que guardaremos en el archivo.

private static void guardarProductesTXT() {

File fitxerProductes = new File("productes.txt");

if (!fitxerProductes.exists()) {
try {
fitxerProductes.createNewFile();
} catch (IOException e) {
System.out.println("\n-- ERROR. No s'ha pogut crear: " + fitxerProductes.getAbsolutePath());
return; //Posem fi a l'operació. No es pot guardar en aquesta ubicació.
}
}

try {
BufferedWriter bw = new BufferedWriter(new FileWriter(fitxerProductes));
//Per cada Producte de l'array, escriurem una linia
for (int i = 0; i < comptadorDeProductes; i++) {
bw.write(productes[i].toTxt());
bw.newLine(); //Fen una nova linia per al següent producte
}
bw.close();
} catch (IOException e) {
System.out.println("\n-- ERROR. No es pot accedir a fitxer: " + fitxerProductes.getAbsolutePath());
}

}
Y ahora otro método para el proceso opuesto, leer las líneas de texto, separar los valores, parsear a int la referencia, parsear a double el precio, y crear nuevos Productos mediante estos valores.
Para leer usaremos la clase BufferedReader, que a su vez necesita un FileReader, que a su vez necesita un File...

Las líneas que vamos a leer las recibimos como String, y String tiene el método split() con el que podemos ordenar que "trocee" la línea allá donde encuentre los dobles guiones que hemos usado para separar los valores.
Al trocear la linea, vamos a recibir un array que contiene cada "trozo" obtenido. Estos "trozos" son los valores de los atributos, que usaremos para reconstruir los Productos.
El primer "trozo" (posicion 0 del array que nos da split()) es la referencia, pero como este valor se autoasigna de forma interna con el contador que tiene la clase Producte, no lo usaremos para nada.
Por eso antes hicimos el método para resetear este contador.

Con el resto de trozos, crearemos un Producto, lo añadimos al array, y pasamos a la siguiente línea.
public static void recuperarProductesTXT() {

File fitxerProductes = new File("productes.txt");

if (!fitxerProductes.exists())
System.out.println("No hi ha productes guardats per recuperar.");
else {
try {
//Reiniciem l'array actual de Productes. Si tenía Productes, ¡¡s'esborrarán!!
productes = new Producte[MAXIM_PRODUCTES];
comptadorDeProductes = 0;
//També el comptador intern de la clase Producte
Producte.resetTotalProductes();

//Declarem el Reader
BufferedReader br = new BufferedReader(new FileReader(fitxerProductes));
//Obtenim primera linia
String linia = br.readLine();
do {
//Dividim linia per separar valors de atributs
String[] atributs = linia.split(" -- ");
//Reconstruim producte, alguns valors requereixen ser parsejats.
//atributs[0] es la referencia, pero aquest valor s'encarrega el comptador intern de Producte
String nom = atributs[1];
//El preu segurament tindrà coma decimal. Cal canviar-lo per un punt decimal.
atributs[2] = atributs[2].replaceAll(",", ".");
double preu = Double.parseDouble(atributs[2]);
String descrip = atributs[3];
productes[comptadorDeProductes] = new Producte(nom, preu, descrip);
comptadorDeProductes++;

//Producte reconstruir, llegim linia següent
linia = br.readLine();
}while (linia != null); //Repetim procés fins que no quedin linies
//Ja no quedan linies, procés finalitzat
br.close();

} catch (FileNotFoundException e) {
System.out.println("\n-- ERROR. No es troba fitxer: " + fitxerProductes.getAbsolutePath());
} catch (IOException e) {
System.out.println("\n-- ERROR. No es pot accedir a fitxer: " + fitxerProductes.getAbsolutePath());
}
}

}
Importante comprender que cada vez que recuperamos Productos, ya sea del archivo binario o de texto, los posibles Productos creados en ese momento en el array de Productos se borrarán.


Y bueno, ya por último, para poder escoger una forma u otra tanto para guardar como para leer, he cambiado el método menu() añadiendo una variable char para que el usuario elija como quiere hacerlo.
Marco en negrita los cambios:

   public static void menu(){
      Scanner sc = new Scanner(System.in);
      boolean sortir = false;
      char opcioArxiu = ' ';
      do{
         System.out.println("***** Gestió de factures *****");
         System.out.println("Dades emissor: " + Emissor.getString());
         System.out.println();
         System.out.println("--- Menú d'usuari ---");
         System.out.println("\t1) Crear nova factura");
         System.out.println("\t2) Visualitzar totes les factures");
         System.out.println("\t3) Cercar factura");
         System.out.println("\t4) Eliminar factura");
         System.out.println("\t5) Crear client");
         System.out.println("\t6) Visualitzar client");
         System.out.println("\t7) Crear producte");
         System.out.println("\t8) Visualitzar producte");
         System.out.println("\t9) Canviar emissor");
         System.out.println("\t10) Guardar emissor");
         System.out.println("\t11) Guardar productes");
         System.out.println("\t12) Guardar clients");
         System.out.println("\t13) Guardar factures");
         System.out.println("\t14) Recuperar productes");
         System.out.println("\t15) Sortir");
         System.out.print("La teva opció:");
         int opcio = 0;
         try{
            opcio = sc.nextInt();
         }catch(InputMismatchException ex){
            System.out.print("Entrada no vàlida. No és un número");
         }finally{
            sc.nextLine();
         }
         try{
            switch(opcio){
            case 1: crearNovaFactura();
            break;
            case 2: visualitzarFactures();
            break;
            case 3: cercarFactura();
            break;
            case 4: eliminarFactura();
            break;
            case 5: crearClient();
            break;
            case 6: visualitzarClients();
            break;
            case 7: crearProducte();
            break;
            case 8: visualitzarProductes();
            break;
            case 9: canviarEmissor();
            break;
            case 10: guardarEmissor();
            break;
            case 11:
               System.out.println("[ b ] - Desar com arxiu de bytes");
               System.out.println("[ t ] - Desar com arxiu de text");
               System.out.print("Opcio: ");
               opcioArxiu = sc.nextLine().toLowerCase().charAt(0);
               if (opcioArxiu == 'b')
                  guardarProductes();
               else
                  guardarProductesTXT();
               break;
            case 12: guardarClients();
            break;
            case 13: guardarFactures();
            break;
            case 14:
               System.out.println("[ b ] - Recuperar de l'arxiu de bytes");
               System.out.println("[ t ] - Recuperar de l'arxiu de text");
               System.out.print("Opcio: ");
               opcioArxiu = sc.nextLine().toLowerCase().charAt(0);
               if (opcioArxiu == 'b')
                  recuperarProductes();
               else
                  recuperarProductesTXT();
               break;
            case 15: sortir = true;
            break;
            default:
               System.out.println("Opció no vàlida!");
            }
         }catch(Exception ex){
            System.out.println("S'ha produit un error:");
            System.out.println(ex.getMessage());
         }
      }while(!sortir);
   }

Y ya está, ahora se pueda guardar y recuperar de un archivo de texto plano. Archivo que si lo abrimos con el bloc de notas, ahora si lo puede leer un humano.

Como has visto, este proceso requiere de más pasos, pero bueno, tampoco es muy distinto de la forma anterior.


Revísalo bien y pregunta si algo no lo entiendes. Un saludo.

- Cuando el programa no reconoce una palabra (veo los cursos y veo que por defecto a ell@s sí se las reconocen), y no sé si es que tengo algo mal configurado (está en inglés, y me cuesta un poco), pero me marca error.

Sobre esto, habría que ver un caso concreto para ver de que se trata.

Algunas instrucciones Java, para poder usarlas, hay que "importar" la clase a la que pertenecen.
Pero si estás comenzando por lo básico, no creo que te estés encontrando todavía con instrucciones que requieran ser importadas.
Aunque no tardarás mucho, pues importar clases es lo más habitual.

De todos modos, cuando esto ocurre, los IDE's como IntelliJ son capaces de añadir por sí solos la línea de código necesaria para importar las clases necesarias.


Pero como digo, habría que ver caso por caso, para ver cuál es el problema real.

Un saludo

Bienvenido.

Espero que encuentres aquí lo que buscas. Cualquier duda que te vaya surgiendo en tu aprendizaje, tienes este foro a tu disposición para compartirla.

Un saludo.

Vale. Está muy bien estructurado el programa, así que va a ser fácil hacer lo que se pide.

Vamos a ver por ejemplo, como guardar los Productos.

Lo primero es implementar la interfaz Serializable a la clase Producte.
Una vez implementada, es probable que el IDE lance un warning pidiendo que también agreguemos un "serial" identificador e incluso nos ofrecerá hacerlo el automáticamente.
Puedes ponérselo, aunque en este caso es algo irrelevante, así que yo normalmente no lo pongo y para que el warning desaparezca uso la etiqueta @SupressWarnings() para indicarle al compilador que no me lance ninguna advertencia por ese motivo.

@SuppressWarnings("serial")
public class Producte implements Serializable{
Y ya está, eso es lo único que hay que cambiar en la clase Producte.

Ahora nos vamos al programa principal.
Ahí ya tienes declarado un método para guardar productos, ahora vamos a definirlo.
Lo que vamos a hacer consiste en transformar el array de productos, que está en memoria RAM, en un archivo de bytes (serializar) para poder guardarlo en disco.

Para esto se usa la clase ObjectOutputStream, quien a su vez requiere de un objeto FileOuputStream, quien a su vez nos va a pedir un objeto File (un fichero).

La lógica a seguir es crear primero el File, dándole el nombre con el que queremos que se guarde en disco. Podemos indicarle solo nombre, o una ruta completa.
Si solo damos nombre, se guardará en la carpeta de proyecto de este programa.

Acto seguido, preguntamos si NO existe, en cuyo caso lo crearemos.
Este acto de creación podría fallar, por ejemplo porque intentamos escribir en una ruta donde el S.O. no nos da permisos de escritura.
Con try catch capturamos esta posible excepción y si ocurre, anunciamos al usuario que no es posible guardar datos.

Si todo sale bien, pasamos a crear el ObjectOutputStream, de quién invocaremos el método writeObject() y le pasaremos el array que queremos guardar en disco, el de productos en este caso.
Todo este proceso también va a requerir de try catch por las posibles excepciones que puedan ocurrir.

Y ya está, tras esos pasos, si todo ha ido bien tendremos un archivo en disco con los datos del array en forma de bytes.

El método quedaría así:

  private static void guardarProductes() {
   
    File fitxerProductes = new File("productes.bin");
   
    if (!fitxerProductes.exists()) {
try {
fitxerProductes.createNewFile();
} catch (IOException e) {
System.out.println("\n-- ERROR. No s'ha pogut crear: " + fitxerProductes.getAbsolutePath());
return; //Posem fi a l'operació. No es pot guardar en aquesta ubicació.
}
    }
   
    try {
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(fitxerProductes));
oos.writeObject(productes); //Guardem array productes
oos.close();
System.out.println("\nProductes guardats correctament\n");
} catch (FileNotFoundException e) {
System.out.println("\n-- ERROR. No es troba fitxer: " + fitxerProductes.getAbsolutePath());
} catch (IOException e) {
System.out.println("\n-- ERROR. No es pot accedir a fitxer: " + fitxerProductes.getAbsolutePath());
}
    }
Bien, podemos guardar productos.
Ahora vamos a querer recuperar esa copia guardada cuando queramos.

Para esto usamos la clase ObjectInputStream, junto con FileInputStream.
Hacen lo contrario de la anterior:
- Output --> salida/escritura
- Input--> entrada/lectura

De nuevo comenzamos creando un objeto File y preguntamos si existe o no.
Si no existe, pues entonces no hay nada que recuperar, así que lo anunciamos y se acabó.

Si existe, entonces creamos el ObjectInputStream e invocamos el método readObject().

Este método lo que hace es leer los bytes del objeto File al que está asociado y los retorna en forma de Object.

Este Object se lo vamos a asignar al array de productos, pero para que lo acepte será necesario hacer un casting a Producte[].

Si todo va bien, ya tendremos recuperado el array de productos. Aunque aún queda una cosa pendiente. El programa está usando un "contador de productos" para saber cuantos productos hay registrados, y en que posición del array debe ir registrando los nuevos productos, etc...

Tras recuperar el array que estaba guardado en disco, este contador necesita ser actualizado, pues su valor ya no se corresponde con el nuevo array.
Si por ejemplo nada más comenzar el programa recuperamos un array que tiene 20 productos, el contador en cambio nos va a decir que tiene 0 productos.

Esto hay que solucionarlo, y para ello he creado un segundo método que lo que hace es recibir un array de cualquier clase (así se puede usar también para los array de facturas, clientes..) y lo recorrer hasta encontrar la primera posición con valor null. Y retorna ese número de posición, que ha de ser el que le asignemos al contador para que tenga un valor correcto.

Este es el método para recuperar los datos guardados en disco:

    private static void recuperarProductes() {
   
    File fitxerProductes = new File("productes.bin");
   
    if (!fitxerProductes.exists())
    System.out.println("No hi ha productes guardats per recuperar.");
    else {
    try {
ObjectInputStream ois = new ObjectInputStream(new FileInputStream(fitxerProductes));
//Recuperem array productes
productes = (Producte[]) ois.readObject(); //Fem casting de Object a Producte[]
//Actualitzem comptador de productes
comptadorDeProductes = calculaComptador(productes);
ois.close();
System.out.println("\nProductes recuperats correctament\n");
} catch (FileNotFoundException e) {
System.out.println("\n-- ERROR. No es troba fitxer: " + fitxerProductes.getAbsolutePath());
} catch (IOException e) {
System.out.println("\n-- ERROR. No es pot accedir a fitxer: " + fitxerProductes.getAbsolutePath());
} catch (ClassNotFoundException e) {
System.out.println("\n-- ERROR. Les dades no es corresponen amb dades de Producte");
}
    }
   
    }
Y este es el método que acepta arrays de cualquier clase (por eso el argumento lo recoge como Object[] ) y retorna el valor correcto para los contadores:
    private static int calculaComptador(Object[] array) {
    int comptador = 0;
   
    for (int i = 0; i < array.length; i++)
    if (array[i] == null) { //Busquem la primera posició buida per determinar el comptador.
    comptador = i;
    break;
    }
   
    return comptador;
    }
Y listo, ya puedes probar a guardar y recuperar productos. En el menú, eso sí, tendrás que añadir nuevas opciones para recuperar y actualizar el switch

    public static void menu(){
        Scanner sc = new Scanner(System.in);
        boolean sortir = false;
        do{
            System.out.println("***** Gestió de factures *****");
            System.out.println("Dades emissor: " + Emissor.getString());
            System.out.println();
            System.out.println("--- Menú d'usuari ---");
            System.out.println("\t1) Crear nova factura");
            System.out.println("\t2) Visualitzar totes les factures");
            System.out.println("\t3) Cercar factura");
            System.out.println("\t4) Eliminar factura");
            System.out.println("\t5) Crear client");
            System.out.println("\t6) Visualitzar client");
            System.out.println("\t7) Crear producte");
            System.out.println("\t8) Visualitzar producte");
            System.out.println("\t9) Canviar emissor");
            System.out.println("\t10) Guardar emissor");
            System.out.println("\t11) Guardar productes");
            System.out.println("\t12) Guardar clients");
            System.out.println("\t13) Guardar factures");
            System.out.println("\t14) Recuperar productes");
            System.out.println("\t15) Sortir");
            System.out.print("La teva opció:");
            int opcio = 0;
            try{
                opcio = sc.nextInt();
            }catch(InputMismatchException ex){
                System.out.print("Entrada no vàlida. No és un número");
            }finally{
                sc.nextLine();
            }
            try{
                switch(opcio){
                    case 1: crearNovaFactura();
                            break;
                    case 2: visualitzarFactures();
                            break;
                    case 3: cercarFactura();
                            break;
                    case 4: eliminarFactura();
                            break;
                    case 5: crearClient();
                            break;
                    case 6: visualitzarClients();
                            break;
                    case 7: crearProducte();
                            break;
                    case 8: visualitzarProductes();
                            break;
                    case 9: canviarEmissor();
                            break;
                    case 10: guardarEmissor();
                            break;
                    case 11: guardarProductes();
                            break;
                    case 12: guardarClients();
                            break;
                    case 13: guardarFactures();
                            break;
                    case 14:
                       recuperarProductes();
                       break;
                    case 15: sortir = true;
                            break;
                    default:
                        System.out.println("Opció no vàlida!");
                }
            }catch(Exception ex){
                System.out.println("S'ha produit un error:");
                System.out.println(ex.getMessage());
            }
        }while(!sortir); 
    }

Siguiendo este ejemplo, tú mismo puedes escribir los restantes métodos para guardar clientes y facturas. Recuerda implementarles la interfaz Serializable a sus correspondientes clases.


Lo que no tengo claro es lo del Emisor, ¿también se ha de guardar? Pero no tienes ningún array con emisores.
Puedes guardarlo, ObjectOutputStream guardará cualquier objeto que le indiques (si implementa Serializable).
Pero como no usas ningún array, tu programa solo trabaja con un único Emisor (se puede cambiar sus atributos, pero siempre es uno) pues eso es lo que se guardará.

No tiene mucho sentido guardar simplemente un Emisor, revisa el enunciado de tu ejercicio a ver si realmente hay que guardarlo, o si bien lo que pasa es que está faltando un array de Emisores.

Pregunta cualquier duda que surja.
Un saludo.