classe scanner per leggere da file

[stregone_giallo_rosso]

Salve ho un file di questo tipo:
costruttore
modello
versione
anno
***accessori***
vetri
fari
____
_____
***accessori***

devo scrivere un metodo per leggere le linee dal file, il problema che le linee di accessori possono variere e non posso considerarla come un unica linea e quindi un met tipo getAcc(), come faccio a leggere solo le linee che sono nel file che possono variare

[PGI-Bis]

Devi avere un marcatore determinabile dai dati presenti nel file. Ad esempio nel testo del file che hai incollato si potrebbe dire che la prima linea contenente la stringa "***Accessori***" indichi la sezione del documento a partire dalla quale il lettore troverà gli accessori. L'elenco di accessori continua finchè il lettore non trovi una seconda linea contenente la stessa stringa.

La lettura degli accessori diventerebbe:

leggi il file linea per linea finchè non trovi la stringa "***Accessori***"
da qui in poi ogni linea rappresenta un accessorio a meno che non contenga di nuovo la stringa "***Accessori***". Se contiene la stringa "***Accessori***" allora non ci sono più accessori da leggere.

Il metodo getAccessory() potrebbe quindi essere:

se non esistono più accessori {
    return null o throw exception.
}
se non l'hai già fatto {
    cerca la prima linea che contiene la stringa ***Accessori***
}
String nome = leggiLinea();
se nome contiene ***Accessori*** non esistono più accessori, nome = null;

return nome;

[stregone_giallo_rosso]

ok, ma poi come faccio a leggerle dal file insieme :
public static Auto read (Scanner in){
if(!hasNext()) return null;
return new Auto (cost,mod,vers,anno,???)
mi puoi scrivere il codice

[PGI-Bis]

Posso scriverti UN codice. IL codice potrebbe essere diverso.

Supponendo che questo sia il file di testo che contiene le informazioni da tradurre in un'Automobile:

fiat
punto
base
2006
***accessori***
vetri
volante
pedali
sedili
***accessori***

La lettura potrebbe essere:

import java.util.*;
import java.io.*;

public class Main {
	public static void main(String[] args) {
		File inputFile = new File(args[0]);
		Auto auto = null;
		try {
			auto = new Auto(new LettoreDatiAutomobile().leggiDati(inputFile));
		} catch(IOException ex) {
			System.err.println("Errore durante la lettura del file " + inputFile);
		}
		if(auto != null) {
			System.out.println("Costruttore: " + auto.getCostruttore());
			System.out.println("Modello: " + auto.getModello());
			System.out.println("Versione: " + auto.getVersione());
			System.out.println("Anno: " + auto.getAnno());
			System.out.println("Lista Accessori:");
			for(String s : auto.getAccessori()) {
				System.out.println("\t" + s);
			}
		}
	}
}

/** Questo oggetto traduce le informazioni contenute in un file di testo in
un pacchetto di dati per l'inizializzazione di un'auto */
class LettoreDatiAutomobile {
	private final String MARCATORE_ACCESSORI = "***accessori***";

	public DatiInizializzazioneAuto leggiDati(File file) throws IOException {
		DatiInizializzazioneAuto dati = new DatiInizializzazioneAuto();
		Scanner scanner = null;
		/* tenta di leggere */
		try {
			scanner = new Scanner(file);
			/* legge le prime quattro righe */
			caricaIntestazione(scanner, dati);
			/* legge il resto se presente e corrispondente ad un elenco
			di accessori */
			caricaAccessori(scanner, dati);
		} finally {
			/* cascasse il mondo, se lo scanner è stato aperto allora sarà
			anche chiuso */
			if(scanner != null) {
				scanner.close();
			}
		}
		return dati;
	}
	
	private void caricaIntestazione(Scanner input, DatiInizializzazioneAuto dati) throws IOException {
		dati.setCostruttore(input.nextLine());
		dati.setModello(input.nextLine());
		dati.setVersione(input.nextLine());
		dati.setAnno(input.nextLine());
	}
	
	private void caricaAccessori(Scanner input, DatiInizializzazioneAuto dati) throws IOException {
		/* Se la linea corrente vale ***accessori*** */
		if(input.hasNextLine() && input.nextLine().equals(MARCATORE_ACCESSORI)) {
			/* per ogni linea successiva */
			while(input.hasNextLine()) {
				String linea = input.nextLine();
				
				/* se quella linea vale ***accessori*** esce dal ciclo di lettura */
				if(linea.equals(MARCATORE_ACCESSORI)) {
					break;
				} else {
					
					/* altrimenti carica quella linea nei dati come accessorio */
					dati.aggiungiAccessorio(linea);
				}
			}
		}
	}
}

/** Pacchetto di dati usato per l'inizializzazione di un Auto. */
class DatiInizializzazioneAuto {
	private String costruttore;
	private String modello;
	private String versione;
	private String anno;
	private LinkedList<String> accessori = new LinkedList<String>();
	
	public void setCostruttore(String costruttore) {
		this.costruttore = costruttore;
	}
	
	public String getCostruttore() {
		return costruttore;
	}
	
	public void setModello(String modello) {
		this.modello = modello;
	}
	
	public String getModello() {
		return modello;
	}
	
	public void setVersione(String versione) {
		this.versione = versione;
	}
	
	public String getVersione() {
		return versione;
	}
	
	public void setAnno(String anno) {
		this.anno = anno;
	}
	
	public String getAnno() {
		return anno;
	}
	
	public void aggiungiAccessorio(String accessorio) {
		accessori.add(accessorio);
	}
	
	public Collection<String> getAccessori() {
		return accessori;
	}
}


/** Questa classe rappresenta un'automobile. */
class Auto {
	private String costruttore;
	private String modello;
	private String versione;
	private String anno;
	private ArrayList<String> accessori;
	
	/** Le istanze di Auto sono inizializzate usando un pacchetto di informazioni
	di tipo DatiInitializzazioneAuto. */
	public Auto(DatiInizializzazioneAuto dati) {
		costruttore = dati.getCostruttore();
		modello = dati.getModello();
		versione = dati.getVersione();
		anno = dati.getAnno();
		accessori = new ArrayList<String>(dati.getAccessori());
	}
	
	public String getCostruttore() {
		return costruttore;
	}
	
	public String getModello() {
		return modello;
	}
	
	public String getVersione() {
		return versione;
	}
	
	public String getAnno() {
		return anno;
	}
	
	public Collection<String> getAccessori() {
		return accessori;
	}
}

Il procedimento usato è il seguente.

Si crea un DatiInizializzazioneAuto. Ai apre il file e si legge linea per linea. Per ogni linea, in base ad una convenzione implicita di formato, si immette nel DatiInizializzazioneAuto il corrispondente valore. Ad esempio la prima riga è il nome del costruttore, dunque lo leggo e lo passo al DatiInizializzazioneAuto usando il suo metodo setCostruttore(String).

Una volta completata la lettura del file, il pacchetto di informazioni, costruito in modo incrementale, cioè un pezzo alla volta, viene usato per la costruzione di un oggetto Auto.

Tutto qui.

[stregone_giallo_rosso]

Grazie! sei un grande!!!!
Ci sentiamo presto.

[stregone_giallo_rosso]

scuasami riusciresti a farlo con in interfaccia grafica

[PGI-Bis]

Una tra il miliardo di possibili rappresentazioni è quella contenuta qui di seguito.

Come prima, si tratta di un'unica unità di compilazione, di nome Main.java. Significa che se copi tutto quanto in un file di nome Main.java, compili ed esegui puoi provare il programma. Lo faccio per brevità: non è una buona idea in generale.

import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import java.util.*;
import java.io.*;
import java.beans.*;

public class Main {
	public static void main(String[] args) {
		SwingUtilities.invokeLater(new Runnable() { public void run() {
			new InterfacciaGrafica().show();
		}});
	}
}

/** Dichiarazione delle capacità di un elemento dell'interfaccia grafica.
Serve per "mettere in comunicazione" i vari pezzi. */
interface ElementoInterfacciaGrafica {
	void setInterfacciaGrafica(InterfacciaGrafica ig);
}

/** Gestisce la finestra principale del programma e permette ai diversi
elementi di dialogare tra loro. */
class InterfacciaGrafica {
	private JFrame finestra = new JFrame("Auto");
	private PannelloAutomobile pannelloAutomobile = new PannelloAutomobile();
	private BarraDeiComandi barraDeiComandi = new BarraDeiComandi();
	
	public PannelloAutomobile getPannelloAutomobile() {
		return pannelloAutomobile;
	}
	
	public BarraDeiComandi getBarraDeiComandi() {
		return barraDeiComandi;
	}
	
	public void setComponent(Component c, Object constraints) {
		finestra.add(c, constraints);
	}
	
	public void show() {
		if(finestra.isVisible() == false) {
			pannelloAutomobile.setInterfacciaGrafica(this);
			barraDeiComandi.setInterfacciaGrafica(this);
			finestra.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
			finestra.pack();
			finestra.setVisible(true);
		}
	}
}

/** Visualizza e gestisce i pulsanti dell'interfaccia (quelli in alto) */
class BarraDeiComandi implements ElementoInterfacciaGrafica {
	private InterfacciaGrafica interfacciaGrafica;
	private JFileChooser fileChooser = new JFileChooser();
	private JButton pulsanteCaricaDati = new JButton("Carica dati");
	private JPanel contenitore = new JPanel(new FlowLayout(FlowLayout.LEFT));
	
	public BarraDeiComandi() {
		contenitore.add(pulsanteCaricaDati);
		pulsanteCaricaDati.addActionListener(new ActionListener() {
			public void actionPerformed(ActionEvent e) {
				scegliFile();
			}
		});
	}
	
	public void setInterfacciaGrafica(InterfacciaGrafica g) {
		interfacciaGrafica = g;
		interfacciaGrafica.setComponent(contenitore, BorderLayout.NORTH);
	}
	
	private void scegliFile() {
		Component parent = JOptionPane.getFrameForComponent(contenitore);
		int risposta = fileChooser.showOpenDialog(parent);
		if(risposta == JFileChooser.APPROVE_OPTION) {
			File fileScelto = fileChooser.getSelectedFile();
			if(fileScelto != null && fileScelto.canRead() && fileScelto.exists()) {
				caricaDati(fileScelto);
			} else {
				JOptionPane.showMessageDialog(
					parent,
					"Il file scelto non esiste o non può essere letto");
			}
		}
	}
	
	private void caricaDati(File file) {
		try {
			DatiInizializzazioneAuto dati = new LettoreDatiAutomobile().leggiDati(file);
			Auto auto = new Auto(dati);
			interfacciaGrafica.getPannelloAutomobile().setAuto(auto);
		} catch(Exception ex) {
			Component parent = JOptionPane.getFrameForComponent(contenitore);
			JOptionPane.showMessageDialog(parent,
				"Errore durante il caricamento dei dati.");
			ex.printStackTrace();
		}
	}
}

/** Pannello che presenta i dati di un'automobile */
class PannelloAutomobile implements ElementoInterfacciaGrafica {
	private InterfacciaGrafica interfacciaGrafica;
	private JTextField campoCostruttore = new JTextField(10);
	private JTextField campoModello = new JTextField(10);
	private JTextField campoVersione = new JTextField(10);
	private JTextField campoAnno = new JTextField(10);
	private DefaultListModel modelloListaAccessori = new DefaultListModel();
	private JList listaAccessori = new JList(modelloListaAccessori);
	private JScrollPane contenitoreListaAccessori = new JScrollPane(listaAccessori);
	private Auto auto;
	private JPanel pannello = new JPanel(new GridBagLayout());
	
	public PannelloAutomobile() {
		JLabel etichettaIntestazione = new JLabel("Dati auto");
		JLabel etichettaCostruttore = new JLabel("Costruttore");
		JLabel etichettaModello = new JLabel("Modello");
		JLabel etichettaVersione = new JLabel("Versione");
		JLabel etichettaAnno = new JLabel("Anno");
		JLabel etichettaAccessori = new JLabel("Accessori");
		
		GridBagConstraints lim = new GridBagConstraints();
		lim.insets = new Insets(4, 4, 4, 4);

		lim.weightx = 0;
		lim.gridx = 0;
		lim.gridy = 0;
		lim.gridwidth = 2;
		lim.fill = GridBagConstraints.NONE;
		pannello.add(etichettaIntestazione, lim);
		
		lim.fill = GridBagConstraints.HORIZONTAL;
		
		lim.weightx = 0;
		lim.gridx = 0;
		lim.gridy = 1;
		lim.gridwidth = 1;
		pannello.add(etichettaCostruttore, lim);
		
		lim.weightx = 1;
		lim.gridx = 1;
		lim.gridy = 1;
		pannello.add(campoCostruttore, lim);
		
		lim.weightx = 0;
		lim.gridx = 0;
		lim.gridy = 2;
		pannello.add(etichettaModello, lim);
		
		lim.gridx = 1;
		lim.gridy = 2;
		pannello.add(campoModello, lim);
		
		lim.gridx = 0;
		lim.gridy = 3;
		pannello.add(etichettaVersione, lim);
		
		lim.gridx = 1;
		lim.gridy = 3;
		pannello.add(campoVersione, lim);
		
		lim.gridx = 0;
		lim.gridy = 4;
		pannello.add(etichettaAnno, lim);
		
		lim.gridx = 1;
		lim.gridy = 4;
		pannello.add(campoAnno, lim);
		
		lim.gridx = 0;
		lim.gridy = 5;
		lim.gridwidth = 2;
		lim.fill = GridBagConstraints.NONE;
		pannello.add(etichettaAccessori, lim);
		
		lim.gridx = 0;
		lim.gridy = 6;
		lim.weighty = 1;
		lim.gridwidth = 2;
		lim.fill = GridBagConstraints.BOTH;
		pannello.add(contenitoreListaAccessori, lim);
		
		pannello.setBorder(BorderFactory.createEtchedBorder());
		
		pannello.addPropertyChangeListener(new PropertyChangeListener() {
			public void propertyChange(PropertyChangeEvent e) {
				if(e.getPropertyName().equals("ancestor")) {
					congelaLarghezzaCampiDiTesto();
				}
			}
		});
	}
	
	private void congelaLarghezzaCampiDiTesto() {
		setSizeFor(campoCostruttore, campoCostruttore.getPreferredSize());
		setSizeFor(campoModello, campoModello.getPreferredSize());
		setSizeFor(campoVersione, campoVersione.getPreferredSize());
		setSizeFor(campoAnno, campoAnno.getPreferredSize());
	}
	
	private void setSizeFor(Component c, Dimension size) {
		c.setMinimumSize(size);
		c.setMaximumSize(size);
		c.setPreferredSize(size);
	}
	
	public void setInterfacciaGrafica(InterfacciaGrafica g) {
		interfacciaGrafica = g;
		interfacciaGrafica.setComponent(pannello, BorderLayout.CENTER);
	}
	
	public void setAuto(Auto auto) {
		this.auto = auto;
		acquisisciDati();
	}
	
	private void azzeraCampi() {
		campoCostruttore.setText("");
		campoModello.setText("");
		campoVersione.setText("");
		campoAnno.setText("");
		modelloListaAccessori.clear();
	}
	
	private void acquisisciDati() {
		if(auto == null) {
			azzeraCampi();
		} else {
			campoCostruttore.setText(auto.getCostruttore());
			campoModello.setText(auto.getModello());
			campoVersione.setText(auto.getVersione());
			campoAnno.setText(auto.getAnno());
			modelloListaAccessori.clear();
			for(String accessorio : auto.getAccessori()) {
				modelloListaAccessori.addElement(accessorio);
			}
		}
	}
}



/** Questo oggetto traduce le informazioni contenute in un file di testo in
un pacchetto di dati per l'inizializzazione di un'auto */
class LettoreDatiAutomobile {
	private final String MARCATORE_ACCESSORI = "***accessori***";

	public DatiInizializzazioneAuto leggiDati(File file) throws IOException {
		DatiInizializzazioneAuto dati = new DatiInizializzazioneAuto();
		Scanner scanner = null;
		/* tenta di leggere */
		try {
			scanner = new Scanner(file);
			/* legge le prime quattro righe */
			caricaIntestazione(scanner, dati);
			/* legge il resto se presente e corrispondente ad un elenco
			di accessori */
			caricaAccessori(scanner, dati);
		} finally {
			/* cascasse il mondo, se lo scanner è stato aperto allora sarà
			anche chiuso */
			if(scanner != null) {
				scanner.close();
			}
		}
		return dati;
	}
	
	private void caricaIntestazione(Scanner input, DatiInizializzazioneAuto dati) throws IOException {
		dati.setCostruttore(input.nextLine());
		dati.setModello(input.nextLine());
		dati.setVersione(input.nextLine());
		dati.setAnno(input.nextLine());
	}
	
	private void caricaAccessori(Scanner input, DatiInizializzazioneAuto dati) throws IOException {
		/* Se la linea corrente vale ***accessori*** */
		if(input.hasNextLine() && input.nextLine().equals(MARCATORE_ACCESSORI)) {
			/* per ogni linea successiva */
			while(input.hasNextLine()) {
				String linea = input.nextLine();
				
				/* se quella linea vale ***accessori*** esce dal ciclo di lettura */
				if(linea.equals(MARCATORE_ACCESSORI)) {
					break;
				} else {
					
					/* altrimenti carica quella linea nei dati come accessorio */
					dati.aggiungiAccessorio(linea);
				}
			}
		}
	}
}

/** Pacchetto di dati usato per l'inizializzazione di un Auto. */
class DatiInizializzazioneAuto {
	private String costruttore;
	private String modello;
	private String versione;
	private String anno;
	private LinkedList<String> accessori = new LinkedList<String>();
	
	public void setCostruttore(String costruttore) {
		this.costruttore = costruttore;
	}
	
	public String getCostruttore() {
		return costruttore;
	}
	
	public void setModello(String modello) {
		this.modello = modello;
	}
	
	public String getModello() {
		return modello;
	}
	
	public void setVersione(String versione) {
		this.versione = versione;
	}
	
	public String getVersione() {
		return versione;
	}
	
	public void setAnno(String anno) {
		this.anno = anno;
	}
	
	public String getAnno() {
		return anno;
	}
	
	public void aggiungiAccessorio(String accessorio) {
		accessori.add(accessorio);
	}
	
	public Collection<String> getAccessori() {
		return accessori;
	}
}


/** Questa classe rappresenta un'automobile. */
class Auto {
	private String costruttore;
	private String modello;
	private String versione;
	private String anno;
	private ArrayList<String> accessori;
	
	/** Le istanze di Auto sono inizializzate usando un pacchetto di informazioni
	di tipo DatiInitializzazioneAuto. */
	public Auto(DatiInizializzazioneAuto dati) {
		costruttore = dati.getCostruttore();
		modello = dati.getModello();
		versione = dati.getVersione();
		anno = dati.getAnno();
		accessori = new ArrayList<String>(dati.getAccessori());
	}
	
	public String getCostruttore() {
		return costruttore;
	}
	
	public String getModello() {
		return modello;
	}
	
	public String getVersione() {
		return versione;
	}
	
	public String getAnno() {
		return anno;
	}
	
	public Collection<String> getAccessori() {
		return accessori;
	}
}

C'è tutto il codice dell'altra volta, uguale, più quattro new entry.

ElementoInterfacciaGrafica
InterfacciaGrafica
BarraDeiComandi
PannelloAutomobile

Premendo il pulsante in alto si apre la finestra standard per la selezione di un file. Scegliendo un file che contiene i dati di un'automobile vengono riempiti i campi del pannello centrale.

[stregone_giallo_rosso]

ok grazie, scusami pero il programma mi kiede :
dato un costruttore restituire l'elenco dei modelli
selezionato uno dei modelli listati rest l'elenco delle auto
selezinata un auto mostri la scheda completa
sempre con l'interfaccia grafica

[PGI-Bis]

Mi sto divertendo come un "rigazzino" a farlo .

Quando finisco ti mando i sorgenti. O tutto il progetto, se usi NetBeans.

[stregone_giallo_rosso]

no uso eclipse, è per l'esame di programmazione all'uni!!!!!!!!

[stregone_giallo_rosso]

per evitare troppo codice getAccessori() lo potrei inserire nella classe auto nel metodo statico read:

public static Auto read (Scanner in){
if(!hasNext()) return null;
return new Auto (cost,mod,vers,anno,???)

in modo che dopo posso caricate gli oggetti Auto in un unico arraylist per fare il confronto dopo???
se è si puoi farmi un esempio perchè non riesco
thanks

[PGI-Bis]

Originariamente inviato da stregone_giallo_rosso

no uso eclipse, è per l'esame di programmazione all'uni!!!!!!!!

Ah, ok. Niente codice.

La questione dell'array list dipende da come sono conservate le automobili nel file.

Se esistono N file, ognuno con una sola automobile è un paio di maniche.

Se un unico file contiene tutte le automobili, è un'altra camicia.

Nel secondo caso puoi sfruttare la progressività di Scanner. Puoi creare un oggetto DatiAutomobile che si inizializza usando uno Scanner. Una cosa dello pseudo-tipo:

class DatiInizializzazioneAuto {
    public DatiInizializzazioneAuto(Scanner scanner) {
        this.costruttore = scanner.nextLine();
        this.modello = scanner.nextLine();
        this.versione = scanner.nextLine();
        this.anno = scanner.nextLine();
        String linea;
        scanner.nextLine(); //salta la prima linea ***accessori***
        while(!(linea = scanner.nextLine()).equals("***accessori***")) {
                listaAccessori.add(linea);
        }

Con questa roba qui e uno Scanner aperto su un file nel formato già citato, la creazione dell'elenco di automobile diventa:

while(scanner.hasNextLine()) {
    DatiInizializzazioneAuto dati = new DatiInizializzazioneAuto(scanner);
    Auto auto = new Auto(dati);
    listaAuto.add(auto); //listaAuto è un ArrayList<Auto>
}

Il codice sorgente del tuo programma deve essere una rappresentazione diretta e fedele del sistema che vuoi creare, per come tu l'hai inteso.

Evitare di scrivere troppo codice è l'assillo del programmatore-fruttivendolo. Qui non si vende un tanto al kilo: ci vogliono le linee che ci vogliono.

[stregone_giallo_rosso]

si è contenuto tutto in un unico file

[stregone_giallo_rosso]

Originariamente inviato da stregone_giallo_rosso

ok grazie, scusami pero il programma mi kiede :
dato un costruttore restituire l'elenco dei modelli
selezionato uno dei modelli listati rest l'elenco delle auto
selezinata un auto mostri la scheda completa
sempre con l'interfaccia grafica

se non ti dispiace puoi scrivermi il codice , il file è uno, in cui sono contenute tutte le auto. (il mio metodo statico quindi non va bene??? )

[PGI-Bis]

Originariamente inviato da stregone_giallo_rosso

è per l'esame di programmazione all'uni!!!!!!!!

Non posso. Ma è facile, basta che metti insieme quelle due cose di cui abbiamo parlato.

[stregone_giallo_rosso]

é quello che non riesco a fare, ti prego aiutami... il metodo statico è giusto o no?

[PGI-Bis]

Non è una questione di cattiveria.

Io potrei anche dirti che il metodo statico non va bene perchè è statico. Ma le valutazioni che devi fare tu dipendono dal grado di preparazione che si presume tu abbia dopo aver seguito il corso di cui sosterrai l'esame.

Se non fosse statico, avresti comunque il problema della molteplicità di accessori.

La soluzione al caricamento di un numero indeterminato di accessori l'abbiamo vista. Non è che "DatiInizializzazioneAuto" io l'abbia messo perchè mi piace scrivere doppio Ha una particolarità che è quella di consentire la definizione incrementale (un po' alla volta) del proprio stato.

Non vedo questa capacità in Auto: un'automobile gli accessori ce li ha non ce li ha dall'inizio. Per questo separo l'inizializzazione "un po' per volta" usando un DatiInizializzazioneAuto per... inizializzare un'Auto.

Ma anche qui dovrei per onestà far notare che se tu porti un esercizio in cui mostri un caso di inizializzazione incrementale e il tuo prof ti dice: uh che bello, spiegamelo un po', che facciamo? Me lo passi al telefono?

[stregone_giallo_rosso]

lo so comprendo perfettamente, però almeno fammi vedere come si fa, perchè non riesco proprio,io cerco di capire quello che scrivi non lo copio soltanto

[stregone_giallo_rosso]

Originariamente inviato da PGI-Bis

Ah, ok. Niente codice.

La questione dell'array list dipende da come sono conservate le automobili nel file.

Se esistono N file, ognuno con una sola automobile è un paio di maniche.

Se un unico file contiene tutte le automobili, è un'altra camicia.

Nel secondo caso puoi sfruttare la progressività di Scanner. Puoi creare un oggetto DatiAutomobile che si inizializza usando uno Scanner. Una cosa dello pseudo-tipo:

class DatiInizializzazioneAuto {
    public DatiInizializzazioneAuto(Scanner scanner) {
        this.costruttore = scanner.nextLine();
        this.modello = scanner.nextLine();
        this.versione = scanner.nextLine();
        this.anno = scanner.nextLine();
        String linea;
        scanner.nextLine(); //salta la prima linea ***accessori***
        while(!(linea = scanner.nextLine()).equals("***accessori***")) {
                listaAccessori.add(linea);
        }

Con questa roba qui e uno Scanner aperto su un file nel formato già citato, la creazione dell'elenco di automobile diventa:

while(scanner.hasNextLine()) {
    DatiInizializzazioneAuto dati = new DatiInizializzazioneAuto(scanner);
    Auto auto = new Auto(dati);
    listaAuto.add(auto); //listaAuto è un ArrayList<Auto>
}

Il codice sorgente del tuo programma deve essere una rappresentazione diretta e fedele del sistema che vuoi creare, per come tu l'hai inteso.

Evitare di scrivere troppo codice è l'assillo del programmatore-fruttivendolo. Qui non si vende un tanto al kilo: ci vogliono le linee che ci vogliono.

Facendo in questo modo la classe auto è sempre questa:
[code]

/** Questa classe rappresenta un'automobile. */
class Auto {
private String costruttore;
private String modello;
private String versione;
private String anno;
private ArrayList<String> accessori;

/** Le istanze di Auto sono inizializzate usando un pacchetto di informazioni
di tipo DatiInitializzazioneAuto. */
public Auto(DatiInizializzazioneAuto dati) {
costruttore = dati.getCostruttore();
modello = dati.getModello();
versione = dati.getVersione();
anno = dati.getAnno();
accessori = new ArrayList<String>(dati.getAccessori());
}

public String getCostruttore() {
return costruttore;
}

public String getModello() {
return modello;
}

public String getVersione() {
return versione;
}

public String getAnno() {
return anno;
}

public Collection<String> getAccessori() {
return accessori;
}

[\CODE]

MENTRE I METODI DELLA CLASSE DATIINIZIALIZZAZIONE AUTO CON L'ASTERISCO NON SERVONO + GIUSTO?
[code]
class DatiInizializzazioneAuto {
private String costruttore;
private String modello;
private String versione;
private String anno;
***private LinkedList<String> accessori = new LinkedList<String>();***

***public void setCostruttore(String costruttore) {***
this.costruttore = costruttore;
}

public String getCostruttore() {
return costruttore;
}

***public void setModello(String modello) {***
this.modello = modello;
}

public String getModello() {
return modello;
}

**public void setVersione(String versione) {**
this.versione = versione;
}

public String getVersione() {
return versione;
}

**public void setAnno(String anno) {**
this.anno = anno;
}

**public String getAnno() {**
return anno;
}

**public void aggiungiAccessorio(String accessorio) {**
accessori.add(accessorio);
}

**public Collection<String> getAccessori() {
return accessori;****
}
}

[\CODE]

[PGI-Bis]

Direi di no. DatiInizializzazioneAuto e Auto non perdono pezzi. Devi solo aggiungere a DatiInizializzazioneAuto il costruttore:

public DatiInizializzazioneAuto(Scanner scanner) {
    this.costruttore = scanner.nextLine();
    this.modello = scanner.nextLine();
    this.versione = scanner.nextLine();
    this.anno = scanner.nextLine();
    scanner.nextLine();
    String line;
    while(!(line = scanner.nextLine()).equals("***accessori***")) {
        accessori.add(scanner.nextLine());
    }
}

Ora che succede. Succede che se crei uno Scanner sul file che contiene i dati delle automobili, nel formato:

costruttore
modello
versione
anno
***accessori***
zero o più linee
***accessori***
costruttore
modello
versione
anno
***accessori***
zero o più linee
***accessori***
eccetera...

puoi estrarre i dati delle singole automobili, nella classe che dovrà contenere le automobili, probabilmente un DAO, semplicemente dicendo:

ArrayList<Auto> autoNelFile = new ArrayList<Auto>();
while(scanner.hasNextLine()) {
    DatiInizializzazioneAuto dati = new DatiInizializzazioneAuto(scanner);
    autoNelFile.add(new Auto(dati));
}

Potresti anche eliminare DatiInizializzazioneAuto e trasferire la creazione tramite Scanner in Auto ma così facendo trasferiresti in Auto un procedimento di inizializzazione meramente eventuale. Nel senso che se i dati venissero da un database anzichè da un file dovresti poi, per coerenza, aggiungere ad Auto un secondo costruttore che usi non uno Scanner ma una Connection o simili. Sotto questo profilo, DatiInizializzazioneAuto ci permette di separare la concreta procedura di inizializzazione dello stato di un'Auto dal possesso di uno stato iniziale.

Ripeto, la classe Auto non subisce modifiche. La classe DatiInizializzazioneAuto vede l'aggiunta di un nuovo costruttore che prende uno Scanner. Questo costruttore viene aggiunto non perchè sia tecnicamente necessario, poche cose lo sono, ma per evitare di dover scrivere all'interno del ciclo while su riferito quelle dieci linee di codice che concretamente estraggono i dati dal file.