java file

[Pro7on]

come si legge il contenuto di un file txt e come si scrive?

[^TiGeRShArK^]

File.open("c:\\ciao.txt", "r") do |file|
    while(line = file.gets)
        puts line
    end
end

In ruby
In java devi scrivere un fottio di cose in +...
Di solito devi istanziare un FileReader e usare quello se non ricordo male


(Pubblicità occulta RULEZ )

[andbin]

Originariamente inviato da Pro7on

come si legge il contenuto di un file txt e come si scrive?

Con le varie classi dedicate all'I/O e presenti nel package java.io.

Quali classi usare dipende da che tipo di file devi gestire: binario, testuale e in quest'ultimo caso se ti serve leggere a "righe", a singoli caratteri o blocchi di caratteri. O anche se devi poter specificare un charset particolare.

[PGI-Bis]

Do la soluzione al caso "voglio leggere tutto il contenuto di un file come se fosse testo". Il metodo readFully qui proposto richiede come argomenti due stringhe. La prima è il nome del file, la seconda è il nome della codifica. Ad esempio:

String testo = null;
try {
    testo = readFully("c:\\ciao.txt", "ASCII");
} catch(IOException ex) {
    throw new RuntimeException(ex);
}

Il metodo è:

/** Legge tutto il contenuto del file fileName, interpretandone i byte come
testo codificato in charsetName (ASCII, UTF-8, ISO-8859-1 eccetera) */
public String readFully(String fileName, String charsetName) throws IOException {
	
	/* Questo canale sarà usato per estrarre i byte dal file "fileName" */
	FileChannel fileChannel = null;
	
	/* Un ByteBuffer è un pacchetto di byte di dimensioni prefissate. I
	canali leggono e scrivono dati tramite dei ByteBuffer */
	ByteBuffer buffer = null;
	
	/* Tenta di aprire un canale sul file e di leggerne il contenuto */
	try {
		
		/* Uno dei modi per aprire un canale su un file è passare
		attraverso un FileInputStream. Prima creiamo il FileInputStream
		sul file "fileName" ... */
		FileInputStream fileInputStream = new FileInputStream(fileName);
		
		/* ...poi chiediamo a quel fileInputStream di aprire un canale
		sullo stesso file */
		fileChannel = fileInputStream.getChannel();
		
		/* Il metodo size() di un FileChannel restituisce il numero di
		byte contenuti nel file a cui punta. Questo numero è anche la
		quantità di byte che noi dovremo leggere per poter dire di avere
		tutti quanti i dati contenuti nel file */
		long byteToRead = fileChannel.size();
		
		/* Creiamo il pacchetto di byte che il canale userà per trasferire
		i dati dal disco fisso. Il nostro pacchetto di byte è grande tanto
		quanto il file. */
		buffer = ByteBuffer.allocate((int)byteToRead);
		
		/* Il metodo hasRemaining() di un ByteBuffer restituisce true se
		la posizione del cursore è minore del numero di byte che il buffer
		può contenere. Il metodo fileChannel.read(ByteBuffer) trasferisce
		un numero imprecisato di byte dal file al buffer. Il ciclo while
		ci consente di continuare a leggere il file fintantochè il buffer non
		risulti "pieno". Poichè il nostro buffer ha le stesse dimensioni del
		file, il fatto che esso risulti pieno significa che tutti i byte
		contenuti nel file sono stati trasferiti in "memoria". */
		while(buffer.hasRemaining()) {
			fileChannel.read(buffer);
		}
	} finally {
		/* La clausola finally garantisce che a meno di calamità naturali
		il canale aperto sul file venga sempre chiuso */
		if(fileChannel != null) {
			fileChannel.close();
		}
	}
	/* Riavvolge il buffer di byte per renderne possibile la lettura. */
	buffer.flip();
	
	/* Crea un charset, destinato a tradurre i byte in caratteri */
	Charset charset = Charset.forName(charsetName);
	
	/* Il Charset legge il buffer di byte e lo trasforma in buffer di
	caratteri */
	CharBuffer decodedBuffer = charset.decode(buffer);
	
	/* Il metodo toString di un CharBuffer restituisce i caratteri del
	CharBuffer come una stringa java */
	String contents = decodedBuffer.toString();
	
	/* Restituisce il testo come stringa */
	return contents;
}

C'è una precondizione alla praticabilità di questo approccio: che il numero di byte contenuti nel file siano meno di Integer.MAX_VALUE. (2 miliardi e rotti, che è poi un gigabyte e qualcosa).

Rispettata questa precondizione, il metodo funziona a patto che la quantità di memoria disponibile alla JVM sia sufficiente a trasferire per intero il contenuto del file. Detto papale papale, se hai 64 megabyte di RAM e tenti di leggere un file da 500 megabyte il metodo rilascerà una OutOfMemoryException.

Vale naturalmente quanto detto da andbin. Che il nome del file finisca in txt non significa che quel file contenga del testo. Ma se lo contiene e non è eccessivamente grande, allora puoi usare il metodo proposto.