I stored bytes within a string in Java
String header ="00110011000000011001000000000001001011000000000100000010000000000000000000000000000000000000000000000000000000000000000000000000";
Now i want to write that String to a file, but export that as a series of bits and not encoded as a text.
Writing to the file looks like this:
BufferedWriter writer = new BufferedWriter (new FileWriter("test.epd"));
writer.write(header);
How can I do this(The string in this prog will be longer --> around 8kB)
I would use BinaryCodec from commons apache commons-codec.
String headerb = "00110011000000011001000000000001001011000000000100000010000000000000000000000000000000000000000000000000000000000000000000000000";
BinaryCodec codec = new BinaryCodec();
//I have no idea why this method is not static.
//you may use BinaryCodec.fromAscii(ascii.toCharArray()) instead
byte[] bval = codec.toByteArray(headerb);
File file = new File("test.epd");
Files.write(bval, file );
//Test that when the file is read, we retrieve the same string
byte[] byteArray = Files.toByteArray(file);
String asciiString = BinaryCodec.toAsciiString(byteArray);
System.out.println(asciiString);
Related
I have 2 java classes. Let them be class A and class B.
Class A gets String input from user and stores the input as byte into the FILE, then Class B should read the file and display the Byte as String.
CLASS A:
File file = new File("C:\\FILE.txt");
file.createNewFile();
FileOutputStream fos = new FileOutputStream(file);
String fwrite = user_input_1+"\n"+user_input_2;
fos.write(fwrite.getBytes());
fos.flush();
fos.close();
In CLASS B, I wrote the code to read the file, but I don't know how to read the file content as bytes.
CLASS B:
fr = new FileReader(file);
br = new BufferedReader(fr);
arr = new ArrayList<String>();
int i = 0;
while((getF = br.readLine()) != null){
arr.add(getF);
}
String[] sarr = (String[]) arr.toArray(new String[0]);
The FILE.txt has the following lines
[B#3ce76a1
[B#36245605
I want both these lines to be converted into their respective string values and then display it. How to do it?
Are you forced to save using a String byte[] representation to save data? Take a look at object serialization (Object Serialization Tutorial), you don't have to worry about any low level line by line read or write methods.
Since you are writing a byte array through the FileOutputStream, the opposite operation would be to read the file using the FileInputStream, and construct the String from the byte array:
File file = new File("C:\\FILE.txt");
Long fileLength = file.length();
byte[] bytes = new byte[fileLength.intValue()]
try (FileInputStream fis = new FileInputStream(file)) {
fis.read(bytes);
}
String result = new String(bytes);
However, there are better ways of writing the String to a file.
You could write it using the FileWriter, and read using FileReader (possibly wrapping them by the corresponding BufferedReader/Writer), this will avoid creating intermediate byte array. Or better yet, use Apache Commons' IOUtils or Google's Guava libraries.
I need to encode/decode pdf file into Base64 format.
So I read file from disk into String(because I will receive file in String Base64 format in future);
String pdfString = IOUtils.toString(new FileInputStream(new
File("D:\\vrpStamped.pdf")));
byte[] encoded = Base64.encodeBase64(pdfString.getBytes());
byte[] newPdfArray = Base64.decodeBase64(encoded);
FileOutputStream imageOutFile = new FileOutputStream(
"D:\\1.pdf");
imageOutFile.write(newPdfArray);
imageOutFile.close();
imageOutFile.flush();
So my D:\\1.pdf doesnt opens in AdobeReader, but if I read file straight to byte array, using IOUtils.toByteArray(..) instead ,all works fine and my D:\\1.pdf file sucessfuly opens in Adobe Reader:
byte[] encoded = Base64.encodeBase64(IOUtils.toByteArray(new FileInputStream(new File("D:\\vrpStamped.pdf"))););
It seems to me thath IOUtils.toString(..) change something inside file content. So how can I convert file to String with not content breaking?
How to encode a pdf...
byte[] bytes = IOUtils.toByteArray(new FileInputStream(new File("/home/fschaetz/test.pdf")));
byte[] encoded = Base64.encode(bytes);
String str = new String(encoded);
...now do something with this encoded String, for example, send it via a Rest service.
And now, if you receive an encoded String, you can decode and save it like this...
byte[] decoded = Base64.decode(str.getBytes());
FileOutputStream output = new FileOutputStream(new File("/home/fschaetz/result.pdf"));
output.write(decoded);
output.close();
Works perfectly fine with all files, not limited to images or pdfs.
What your example is doing is...
Read the pdf into a String (which pretty much destroys the data, since you are reading binary data into a String)
Encode this spring (which is in all likelyhood not a valid representation of the original pdf anymore)
Decode it and save it to disk
I am trying to import xls sheet to DB, for that when i am uploading the file the uploaded file is in ByteBuffer Format, i have written a logic which reads as FileInputStream.
Now how do i convert this ByteBuffer to FileInputStream
Here is my Code
ByteBuffer fileBytes = (ByteBuffer) context.get("uploadedFile");
String encoding = System.getProperty("file.encoding");
String filename = Charset.forName(encoding).decode(fileBytes).toString();
filename = filename.replaceAll("\\r", "");
I tried Casting it using ByteArrayInputStream() but looks like it is not working!
Change your logic to use InputStream rather than FileInputStream. You don't care where the input comes from.
Use the following code:
ByteArrayInputStream bais = new ByteArrayInputStream(buffer.array(), buffer.position(), buffer.limit());
and pass bais to your existing method.
I'm getting a response XML from web service and one of the field contains a string that should be convertable to pdf file.
This is example string that I extract from xml response:
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
now I'm trying to convert it into proper pdf file like this:
byte[] bytes = THAT_LONG_STRING.getBytes();
BufferedOutputStream bos = null;
FileOutputStream fos = new FileOutputStream(new File("a.pdf");
bos = new BufferedOutputStream(fos);
bos.write(bytes);
bos.flush();
bos.close();
Sadly this does not work for me, output file is just file with that long string, pdf viewers cannot open it.
Any advices are welcome :)
Your string is in Base64 format. You should decode it to a byte array first, then write it to a file.
Just replace this line:
byte[] bytes = THAT_LONG_STRING.getBytes();
With this one (Apache Commons Codec required):
byte[] bytes = Base64.decodeBase64(THAT_LONG_STRING);
I have text file with string which code page is 1250. I want to save text into RandomAccessFile. When I read bytes from RandomAccessFile I get string with different character. Some solution...
If you're using writeUTF() then you should read its JavaDoc to learn that it always writes modified UTF-8.
If you want to use another encoding, then you'll have to "manually" do the encoding and somehow store the length of the byte[] as well.
For example:
RandomAccessFile raf = ...;
String writeThis = ...;
byte[] cp1250Data = writeThis.getBytes("cp1250");
raf.writeInt(cp1250Data.length);
raf.write(cp1250Data);
Reading would work similarly:
RandomAccessFile raf = ...;
int length = raf.readInt();
byte[] cp1250Data = new byte[length];
raf.readFully(cp1250Data);
String string = new String(cp1250Data, "cp1250");
This code will write and read a string using the 1250 code page. Of course, you will need to clean it, check exceptions and close streams properly before putting in prod :)
public static void main(String[] args) throws Exception {
File file = new File("/toto.txt");
String myString="This is a test";
OutputStreamWriter w = new OutputStreamWriter(new FileOutputStream(file), Charset.forName("windows-1250"));
w.write(myString);
w.flush();
CharBuffer b = CharBuffer.allocate((int)file.length());
new InputStreamReader(new FileInputStream(file), Charset.forName("windows-1250")).read(b);
System.out.println(b.toString());
}