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.
Related
I am writing a csv file in a very old java application so i can not use all the new Java 8 streams.
Writer writer = new OutputStreamWriter(new FileOutputStream("file.csv"));
writer.append("data,");
writer.append("data,");
...
Then I need to transform the writer object into a ByteArrayInputStream.
How can i do it ?
Thanks in advance.
Best regards.
This depends on what you are trying to do.
If you are writing a bunch of data to the file and THEN reading the file you will want to use a FileInputStream in place of your ByteArrayInputStream.
If you want to write a bunch of data to a byte array then you should take a look at using a ByteArrayOutputStream. If you then need to read the byte array as a ByteArrayInputStream you can pass the ByteArrayOutputStream into the input stream like what is shown below. Keep in mind this only works for writing and THEN reading. You can not use this like a buffer.
//Create output stream
ByteArrayOutputStream out = new ByteArrayOutputStream();
//Create Writer
Writer writer = new OutputStreamWriter(out);
//Write stuff
...
//Close writer
writer.close();
//Create input stream using the byte array from out as input.
ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
Short answer: you can't.
A ByteArrayInputStream is just not assignable from a OutputStreamWriter.
Since you're probably after write, you can just read the file back to a byte[] and then construct a ByteArrayInputStream with it:
File file = new File("S:\\Test.java");
FileInputStream fis = new FileInputStream(file);
byte[] content = new byte[(int) file.length()];
fis.read(content,0,content.length);
ByteArrayInputStream bais = new ByteArrayInputStream(content);
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'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);
To process some images in my android application I currently use code like this:
FileOutputStream fileOuputStream = new FileOutputStream(imgpath);
[..DO SOME STUFF..]
Bitmap data = BitmapFactory.decodeByteArray(bFile, 0, bFile.length, options);
data.compress(Bitmap.CompressFormat.JPEG, 90, fileOuputStream);
[..DO SOME STUFF..]
File file = new File(imgpath);
FileInputStream imageInFile = new FileInputStream(file);
byte imageData[] = new byte[(int) file.length()];
imageInFile.read(imageData);
[..DO SOME STUFF..]
file.delete();
//NOTE: The code is all in the same method
the problem is that passing my image from one part of the code to another using this method creates a temporary file.
I was looking for a way to read / write the file data using a memory variable, something like "generic stream" in which store data in order to replace use of "FileInputStream " and "FileOutputStream " and do not write temporary file.
If you are able to use an InputStream or OutputStream you can use ByteArrayInputStream or ByteArrayOutputStream for in memory handling of the data.
If you have two thread you can also use PipedInputStream and PipedOutputStream together to communicate between the threads.
You could write your data to a ByteArrayOutputStream and use the byte array of that stream:
ByteArrayOutputStream out = new ByteArrayOutputStream();
data.compress(Bitmap.CompressFormat.JPEG, 90, out);
// now take the bytes out of your Stream
byte[] imgData = out.toByteArray();
I have a file that can be any thing like ZIP, RAR, txt, CSV, doc etc. I would like to create a ByteArrayInputStream from it.
I'm using it to upload a file to FTP through FTPClient from Apache Commons Net.
Does anybody know how to do it?
For example:
String data = "hdfhdfhdfhd";
ByteArrayInputStream in = new ByteArrayInputStream(data.getBytes());
My code:
public static ByteArrayInputStream retrieveByteArrayInputStream(File file) {
ByteArrayInputStream in;
return in;
}
Use the FileUtils#readFileToByteArray(File) from Apache Commons IO, and then create the ByteArrayInputStream using the ByteArrayInputStream(byte[]) constructor.
public static ByteArrayInputStream retrieveByteArrayInputStream(File file) {
return new ByteArrayInputStream(FileUtils.readFileToByteArray(file));
}
The general idea is that a File would yield a FileInputStream and a byte[] a ByteArrayInputStream. Both implement InputStream so they should be compatible with any method that uses InputStream as a parameter.
Putting all of the file contents in a ByteArrayInputStream can be done of course:
read in the full file into a byte[]; Java version >= 7 contains a convenience method called readAllBytes to read all data from a file;
create a ByteArrayInputStream around the file content, which is now in memory.
Note that this may not be optimal solution for very large files - all the file will stored in memory at the same point in time. Using the right stream for the job is important.
A ByteArrayInputStream is an InputStream wrapper around a byte array. This means you'll have to fully read the file into a byte[], and then use one of the ByteArrayInputStream constructors.
Can you give any more details of what you are doing with the ByteArrayInputStream? Its likely there are better ways around what you are trying to achieve.
Edit:
If you are using Apache FTPClient to upload, you just need an InputStream. You can do this;
String remote = "whatever";
InputStream is = new FileInputStream(new File("your file"));
ftpClient.storeFile(remote, is);
You should of course remember to close the input stream once you have finished with it.
This isn't exactly what you are asking, but is a fast way of reading files in bytes.
File file = new File(yourFileName);
RandomAccessFile ra = new RandomAccessFile(yourFileName, "rw"):
byte[] b = new byte[(int)file.length()];
try {
ra.read(b);
} catch(Exception e) {
e.printStackTrace();
}
//Then iterate through b
This piece of code comes handy:
private static byte[] readContentIntoByteArray(File file)
{
FileInputStream fileInputStream = null;
byte[] bFile = new byte[(int) file.length()];
try
{
//convert file into array of bytes
fileInputStream = new FileInputStream(file);
fileInputStream.read(bFile);
fileInputStream.close();
}
catch (Exception e)
{
e.printStackTrace();
}
return bFile;
}
Reference: http://howtodoinjava.com/2014/11/04/how-to-read-file-content-into-byte-array-in-java/