Decoding base64 data and not able to download as a file - java

Am getting base64 encoded data as String format. Am trying to decode the base64 and want to download as a file. I have commented the below few lines of code, where am getting error out of those line.
Am not sure how to decode the data.
String contentByte=null;
for (SearchHit contenthit : contentSearchHits) {
Map<String, Object> sourceAsMap = contenthit.getSourceAsMap();
fileName=sourceAsMap.get("Name").toString();
System.out.println("FileName ::::"+fileName);
contentByte = sourceAsMap.get("resume").toString();
}
System.out.println("Bytes --->"+contentByte);
File file = File.createTempFile("Testing",".pdf", new File("D:/") );
file.deleteOnExit();
BufferedWriter out = new BufferedWriter(new FileWriter(file));
out.write(Base64.getDecoder().decode(contentByte)); //getting error on this line
Please find the below compilation error am getting.
The method write(int) in the type BufferedWriter is not applicable for the arguments (byte[])
Am using Java 8 version


Writers are used for writing characters, not bytes. To write bytes, you should use some flavor of OutputStream. See Writer or OutputStream?
But if all you want is to write a byte array to a file, Files class provides a Files.write method that does just that:
byte[] bytes = Base64.getDecoder().decode(contentByte);
Files.write(file.toPath(), bytes);


import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.util.Base64;
public class Example {
public static void main(String[] args) {
String contentByte="Simple text send from server";
byte[] bytes =
Base64.getEncoder().encode(contentByte.getBytes(StandardCharsets.UTF_8));
//Data received by you at server end(base64 encoded data as string)
contentByte = new String(bytes);
System.out.println(new String(bytes));
BufferedWriter out = null;
System.out.println("Bytes --->"+contentByte);
try {
File file = File.createTempFile("Testing",".pdf", new File("/tmp/") );
// file.deleteOnExit(); // this line will remove file and your data will not going to save to file. So remove this line.
out = new BufferedWriter(new FileWriter(file));
byte[] decodedImg =
Base64.getDecoder().decode(contentByte.getBytes(StandardCharsets.UTF_8));
out.write(new String(decodedImg)); //getting error on this line
}catch (Exception e)
{
e.printStackTrace();
}finally {
if(out!=null)
{
try {
out.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
Might above solution with help you.

Related

Convert mp4 to bytes and bytes to mp4 in java for android [duplicate]

I've found many ways of converting a file to a byte array and writing byte array to a file on storage.
What I want is to convert java.io.File to a byte array and then convert a byte array back to a java.io.File.
I don't want to write it out to storage like the following:
//convert array of bytes into file
FileOutputStream fileOuputStream = new FileOutputStream("C:\\testing2.txt");
fileOuputStream.write(bFile);
fileOuputStream.close();
I want to somehow do the following:
File myFile = ConvertfromByteArray(bytes);

Otherwise Try this :
Converting File To Bytes
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
public class Temp {
public static void main(String[] args) {
File file = new File("c:/EventItemBroker.java");
byte[] b = new byte[(int) file.length()];
try {
FileInputStream fileInputStream = new FileInputStream(file);
fileInputStream.read(b);
for (int i = 0; i < b.length; i++) {
System.out.print((char)b[i]);
}
} catch (FileNotFoundException e) {
System.out.println("File Not Found.");
e.printStackTrace();
}
catch (IOException e1) {
System.out.println("Error Reading The File.");
e1.printStackTrace();
}
}
}
Converting Bytes to File
public class WriteByteArrayToFile {
public static void main(String[] args) {
String strFilePath = "Your path";
try {
FileOutputStream fos = new FileOutputStream(strFilePath);
String strContent = "Write File using Java ";
fos.write(strContent.getBytes());
fos.close();
}
catch(FileNotFoundException ex) {
System.out.println("FileNotFoundException : " + ex);
}
catch(IOException ioe) {
System.out.println("IOException : " + ioe);
}
}
}

I think you misunderstood what the java.io.File class really represents. It is just a representation of the file on your system, i.e. its name, its path etc.
Did you even look at the Javadoc for the java.io.File class? Have a look here
If you check the fields it has or the methods or constructor arguments, you immediately get the hint that all it is, is a representation of the URL/path.
Oracle provides quite an extensive tutorial in their Java File I/O tutorial, with the latest NIO.2 functionality too.
With NIO.2 you can read it in one line using java.nio.file.Files.readAllBytes().
Similarly you can use java.nio.file.Files.write() to write all bytes in your byte array.
UPDATE
Since the question is tagged Android, the more conventional way is to wrap the FileInputStream in a BufferedInputStream and then wrap that in a ByteArrayInputStream.
That will allow you to read the contents in a byte[]. Similarly the counterparts to them exist for the OutputStream.

You can't do this. A File is just an abstract way to refer to a file in the file system. It doesn't contain any of the file contents itself.
If you're trying to create an in-memory file that can be referred to using a File object, you aren't going to be able to do that, either, as explained in this thread, this thread, and many other places..

Apache FileUtil gives very handy methods to do the conversion
try {
File file = new File(imagefilePath);
byte[] byteArray = new byte[file.length()]();
byteArray = FileUtils.readFileToByteArray(file);
}catch(Exception e){
e.printStackTrace();
}

There is no such functionality but you can use a temporary file by File.createTempFile().
File temp = File.createTempFile(prefix, suffix);
// tell system to delete it when vm terminates.
temp.deleteOnExit();

You cannot do it for File, which is primarily an intelligent file path. Can you refactor your code so that it declares the variables, and passes around arguments, with type OutputStream instead of FileOutputStream? If so, see classes java.io.ByteArrayOutputStream and java.io.ByteArrayInputStream
OutputStream outStream = new ByteArrayOutputStream();
outStream.write(whatever);
outStream.close();
byte[] data = outStream.toByteArray();
InputStream inStream = new ByteArrayInputStream(data);
...

1- Traditional way
The traditional conversion way is through using read() method of InputStream as the following:
public static byte[] convertUsingTraditionalWay(File file)
{
byte[] fileBytes = new byte[(int) file.length()];
try(FileInputStream inputStream = new FileInputStream(file))
{
inputStream.read(fileBytes);
}
catch (Exception ex)
{
ex.printStackTrace();
}
return fileBytes;
}
2- Java NIO
With Java 7, you can do the conversion using Files utility class of nio package:
public static byte[] convertUsingJavaNIO(File file)
{
byte[] fileBytes = null;
try
{
fileBytes = Files.readAllBytes(file.toPath());
}
catch (Exception ex)
{
ex.printStackTrace();
}
return fileBytes;
}
3- Apache Commons IO
Besides JDK, you can do the conversion using Apache Commons IO library in 2 ways:
3.1. IOUtils.toByteArray()
public static byte[] convertUsingIOUtils(File file)
{
byte[] fileBytes = null;
try(FileInputStream inputStream = new FileInputStream(file))
{
fileBytes = IOUtils.toByteArray(inputStream);
}
catch (Exception ex)
{
ex.printStackTrace();
}
return fileBytes;
}
3.2. FileUtils.readFileToByteArray()
public static byte[] convertUsingFileUtils(File file)
{
byte[] fileBytes = null;
try
{
fileBytes = FileUtils.readFileToByteArray(file);
}
catch(Exception ex)
{
ex.printStackTrace();
}
return fileBytes;
}

Server side
#RequestMapping("/download")
public byte[] download() throws Exception {
File f = new File("C:\\WorkSpace\\Text\\myDoc.txt");
byte[] byteArray = new byte[(int) f.length()];
byteArray = FileUtils.readFileToByteArray(f);
return byteArray;
}
Client side
private ResponseEntity<byte[]> getDownload(){
URI end = URI.create(your url which server has exposed i.e. bla
bla/download);
return rest.getForEntity(end,byte[].class);
}
public static void main(String[] args) throws Exception {
byte[] byteArray = new TestClient().getDownload().getBody();
FileOutputStream fos = new
FileOutputStream("C:\\WorkSpace\\testClient\\abc.txt");
fos.write(byteArray);
fos.close();
System.out.println("file written successfully..");
}

//The file that you wanna convert into byte[]
File file=new File("/storage/0CE2-EA3D/DCIM/Camera/VID_20190822_205931.mp4");
FileInputStream fileInputStream=new FileInputStream(file);
byte[] data=new byte[(int) file.length()];
BufferedInputStream bufferedInputStream=new BufferedInputStream(fileInputStream);
bufferedInputStream.read(data,0,data.length);
//Now the bytes of the file are contain in the "byte[] data"
/*If you want to convert these bytes into a file, you have to write these bytes to a
certain location, then it will make a new file at that location if same named file is
not available at that location*/
FileOutputStream fileOutputStream =new FileOutputStream(Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_DOWNLOADS).toString()+"/Video.mp4");
fileOutputStream.write(data);
/* It will write or make a new file named Video.mp4 in the "Download" directory of
the External Storage */

How to convert byte data to readable text in Java

I'm new to java and need some understanding on below.
private static void decompressGzipFile(String gzipFile, String newFile) {
try {
FileInputStream fis = new FileInputStream(gzipFile);
GZIPInputStream gis = new GZIPInputStream(fis);
FileOutputStream fos = new FileOutputStream(newFile);
byte[] buffer = new byte[1024];
int len;
while((len = gis.read(buffer)) != -1){
fos.write(buffer, 0, len);
}
//close resources
System.out.println("Decompression is successful");
fos.close();
gis.close();
} catch (IOException e) {
e.printStackTrace();
}
I have some data in compressed GZIP file which is in
í?]o£F ?s?_1RoZ?Öó?¹Ã?d¬ÅÆ[1]?U.?¦Q?8²?Dù÷=?íÄÃÌ ?VUUÎM´d Î?÷|Ì?Í?7ÉöaõÇjûzö³
?9 ??Á¤?? ?? fs?c?;î&Äq?3?Ú?>ÙËv·Ü t¶Y¯w¦uM¿ÿ?Z²?Æò?
________________________________________
[hº~Biþ?F
________________________________________
ÎÁ?bâ??OÃÙ[1]Yã0ó'Q?¬?x?¡ ?â
This is byte data and how can I convert this to string format or readable format in java?
I tried using GZip Uncompressor to read this file but that give me the same file as output but I want the data to be in human readable format. I tried using GZIPInputStream and base64inputStream but that gives incorrect data type. I'm not sure if this is really byte data or how to read this data? any suggestions please help

FileOutputStream bydefault writes data into files using encoding.
If you want to skip encoding , use BufferedReader
import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.zip.GZIPInputStream;
public class ZipFileReader{
public static void main(String[] args) throws IOException {
GZIPInputStream zipFile = new GZIPInputStream(new FileInputStream("C:/Users/HimanshuSharma2/Downloads/phayes-geoPHP-1.2-20-g6855624.tar.gz"));
BufferedReader br = new BufferedReader(new InputStreamReader(zipFile));
String content;
while ((content = br.readLine()) != null)
System.out.println(content);
}
}
checked on sample file from this link: https://github.com/phayes/geoPHP/tarball/master
and finally write this string into file.

Java converting UTF-8 Text to ASCII produces weird output

I'm trying to convert the content of a plain text file (UTF-8) into ASCII (ISO-8859-15) to write it to an output file. I've written a few lines of code (see below) which read the content of the file, write it to an array of bytes, decode it with the UTF-8 charset, encode it with the ISO-8859-15 Charset and write the result to a file. This works just fine, except for a question mark (Hx: 3F) that suddenly appears at the very beginning of the output file.
import java.io.*;
import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.nio.charset.Charset;
public class Main {
public static void main(String[] args) {
/* Read / write the file to a byte array */
File input = new File("input.txt");
byte[] bytes = new byte[(int) input.length()];
try (FileInputStream fileInput = new FileInputStream(input)){
fileInput.read(bytes);
} catch(IOException e) {
if(e instanceof FileNotFoundException) {
System.err.println("File not found.");
} else {
e.printStackTrace();
}
}
/* Getting the charsets */
Charset utf8charset = Charset.forName("UTF-8");
Charset iso885915charset = Charset.forName("ISO-8859-15");
/* Wrapping the bytes from the file into a buffer */
ByteBuffer inputBuffer = ByteBuffer.wrap(bytes);
/* Encoding the text file from UTF-8 */
CharBuffer data = utf8charset.decode(inputBuffer);
/* Decoding the text file to ISO-8859-15 and writing it to an array*/
ByteBuffer outputBuffer = iso885915charset.encode(data);
byte[] outputData = outputBuffer.array();
System.out.println(new String(outputData));
File output = new File("output.txt");
/* Writing the output to a file */
try(BufferedOutputStream out = new BufferedOutputStream(new FileOutputStream(output))) {
out.write(outputData);
out.close();
} catch(IOException e) {
e.printStackTrace();
}
}
}
Input file:
ABC
DEF
GHI
Output file:
?ABC
DEF
GHI
If you have an idea, what might be the cause of this weird behavior, please let me know. Also, if there is anything weird about my code in general, please point it out to me, since I'm not very experienced in the use of Java yet.
Thanks :)

Is it possible to convert a zip file to binary file to load into BLOB

I have to upload a zip file into BLOB using informatica, for this task, I am using java transformation. Using the following code, I was able to upload all the flat files and retrieve them from the database table in correct format.
This code is not working for zip files. Can you please suggest me on how to convert a zip file into a binary file so that it can be inserted into BLOB?
byte bytes[] = null;
File f1 = new File(TARGETFILE);
try (FileInputStream fis = new FileInputStream(f1)) {
try (ByteArrayOutputStream baos = new ByteArrayOutputStream()) {
byte[] buffer = new byte[1024];
int read = -1;
while ((read = fis.read(buffer)) != -1) {
baos.write(buffer, 0, read);
    }
bytes = baos.toByteArray();
FILE_CONTENT=bytes;
FILE_SIZE=Double.toString(f1.length()/1024*1024);
}
catch(Exception e1) {
}
}
catch (IOException exp) {
exp.printStackTrace();
}

A very simple version, just converts the data to a hex print. Using these parts you should be able to get to binary no problem. Just save the conversion to memory rather then print the string.
package test;
import java.io.BufferedInputStream;
import java.io.DataInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.util.Arrays;
/**
*
* #author User
*/
public class Test {
/**
* #param args the command line arguments
*/
public static void main(String[] args) {
File file = new File("C:\\Users\\User\\Downloads\\ltc1298-arduino-library-master.zip");
byte[] bytes = new byte[(int)file.length()];
try {
DataInputStream dataInputStream = new DataInputStream(new BufferedInputStream(new FileInputStream("C:\\Users\\User\\Downloads\\ltc1298-arduino-library-master.zip")));
dataInputStream.readFully(bytes);
System.out.println(String.format(Arrays.toString(bytes)));
for (byte b : bytes) {
System.out.format("0x%x ", b);
}
dataInputStream.close();
}
catch (Exception e) {
System.out.println("Error");
e.printStackTrace();
}
}
}

Why doesn't Base64 Encoding of a byte[] in Java work?

import java.io.*;
import java.nio.*;
import java.util.Base64;
import java.util.UUID;
import java.io.UnsupportedEncodingException;
public class Abc {
public static String readFileAsString(String filePath) throws IOException {
DataInputStream dis = new DataInputStream(new FileInputStream(filePath));
try {
long len = new java.io.File(filePath).length();
if (len > Integer.MAX_VALUE) throw new IOException("File " + filePath + " too large")
byte[] bytes = new byte[(int) len];
dis.readFully(bytes);
String ans = new String(bytes, "UTF-8");
return ans;
} finally {
dis.close();
}
}
public static void main(String args[]) throws IOException {
String base64encodedString = null;
FileOutputStream stream = new FileOutputStream("C:\\Users\\EMP142738\\Desktop\\New folder\\Readhjbdsdsefd.pdf");
String filePath = new String("C:\\Users\\EMP142738\\Desktop\\New folder\\Readers Quick Ref Card.pdf");
try {
base64encodedString = java.util.Base64.getUrlEncoder().encodeToString(new Abc().readFileAsString(filePath).getBytes("utf-8"));
} catch (IOException e) {
e.printStackTrace();
}
try {
byte[] base64decodedBytes = java.util.Base64.getUrlDecoder().decode(base64encodedString);
stream.write(base64decodedBytes);
} catch(IOException e){
e.printStackTrace();}
finally {
stream.close();
}//catch (FileNotFoundException e) {
// e.printStackTrace();
}
}
I'm trying to encode and decode a PDF file using Base64. What I'm doing is converting a PDF(Binary File) to a ByteArray, then returning the ByteArray as a string. I'm then encoding this string in Base64, using java.util.Base64. When I try to backtrack through the process, I'm able to convert a PDF(Binary File) but the File is corrupted/damaged. Also, the output file after the entire process ( Encode- Decode) is significantly larger than the input file. I expected that both of them would be of the same size. What am I doing wrong here?
Edit 1( 7/13/16):
In the main method, I modified the code as per Jim's suggestion.
I tried using Base64.encode(byte[] src) after reading the documentation of the same. However it keeps giving the error "cannot find symbol Base64.encode(byte[])". But I've used the encodetoString method from the same Class( java.util.Base64.Encoder). I'm unable to understand the issue here.
Here's the modified main method used after returning a byte[] from the readFileAsString method.
public void main(String args[]) throws IOException {
String filePath = new String("C:\\Users\\EMP142738\\Desktop\\New folder\\Readers Quick Ref Card.pdf");
byte[] src = new Abc().readFileAsString(filePath);
byte[] destination = Base64.encode(src);
}

The problem is in your flow
byte[] -> String -> base64 string
You need to omit the conversion to String and go directly:
byte[] -> base64 string
Converting to String will corrupt a binary stream as it involves a decode operation from the input character set to 16-bit Unicode characters.

Categories

Resources