Newsgroup: it.comp.java
Titolo: creare un file esadecimale a partire da una stringa

Salve a tutti,
è un pomeriggio che tento di creare un file esadecimale a partire da
una stringa, ma non sono soddisfatto del risultato ottenuto: infatti
ottengo sempre un file che, aperto con un text editor, risulta
chiaramente codifcato in ASCII (i caratterri numerici e le lettere
sono ben visibili e riconoscibili) mentre sappiamo tutti che un file
esadecimale -a meno che non sia aperto con un editor esadecimale- non
ha una "forma leggibile" perchè viene visualizzato con una serie di
tanti caratteri tutti uguali a forma di "rettangolini bianchi."
C'è qualcuno che può postarmi un link, una soluzione, una classe di
utilità
perchè io oggi non ho proprio trovato niente.
Grazie a tutti.


Grazie Davide per la risposta,
ma -osservando il comportamento di questo codice- non so come
interpretare le tue parole: (vedi note alla fine)
[da linea di comando]
(X COMPILARE)  javac Main.java
(X ESEGUIRE)    java Main
//package main;
/**
 * JDK 1.6.0_16-b01 ~ created with Eclipse "Galileo"
 * user: Giordano "mejoro" Fidilio
 * mail: 
dnaofw...@gmail.com
 * date: 31/ott/2010   12.57.33
 */
import java.io.*;
public class Main {
	// CAMPI
	// COSTRUTTORE
	public Main () throws FileNotFoundException, IOException {
String str = "ciao bella ciao bela ciao ciao ciao questa mattina";
int length = str.length();
int BYTES_DIMENSION = 128;
BufferedOutputStream os = new BufferedOutputStream(
    new FileOutputStream("output.bin")
);
//byte[] b = new byte[]{0xC, 0xA, 0xF, 0xE, 0xB, 0xA, 0xB, 0xE};
byte[] b = str.getBytes();
int size = BYTES_DIMENSION / 8; // TODO fare shift di 2 o 3 == / 8
(tanto x spacchio)
for (int i = 0; i < size; i++) {
    os.write(b);
    os.flush();
}
os.close();
	}
	// METODI
    /**
	 * @param args
	 */
	public static void main (String[] args) {
		long start = System.currentTimeMillis();
		/*
		OUTPUT:
		    Main.static
		    Main()
		    Test.static
		    Test()
		    Spent time : 0,0 seconds
		*/
		    try {
				new Main();
		    }
			catch (FileNotFoundException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		//
		long end = System.currentTimeMillis();
	    double time = (end - start) / 1000.0;
	    System.out.printf("Spent time : %.1f seconds%n", time);
	}
}
NOTE:
Allora se esguiamo questo codice, così come è scritto, otteniamo un
file "output.bin" che, se aperto con un editor (io uso PSPad) vi
leggiamo al suo interno il testo, chiaro e leggibile.
Ma facciamo una seconda prova:
commentiamo la riga "byte[] b = str.getBytes();" e de-commentiamo la
riga immediatamente sopra; ri-eseguiamo il codice e, aprendo il file
"output.bin", vediamo proprio che si tratta di una sequenza binaria (o
esadecimale ?)...
...ecco io vorrei proprio ottenere questo risultato.
Se solo potessi convertire ogni carattere della mia stringa nel valore
binario (o esadecimale... non ho capito bene quale sia tra i due)
allora avrei ottenuto proprio il mio obiettivo.
Se non hai un editor esadecimale, come PSPad, puoi eseguire le due
varianti e tra l'una e l'altra rinonima il file con estendione ".txt",
aprile con un editor, tipo notepad, e vederai che nel primo caso il
testo è leggibile,
nel secondo appaiono i "rettangolini bianchi".
Ciao

 vedi?
Tante belle paroline leggibili...
...credo di aver capito... vorrà dire che l'array
byte[] b = new byte[]{0xC, 0xA, 0xF, 0xE, 0xB, 0xA, 0xB, 0xE};
visualizzava i rettangoli perchè quest'ultimo byte non costituise una
parola,
0xC 0xA etc.. etc.. non sono lettere.
Ok
Grazie Davide