How to stream a String array as a Byte Array over HTTP so that the recipent can create a file out of it at his side?

So I have this string array at the server side, where each item in the array is basically one line in the final output file. I don't want to create this final output file at the server side but instead i would like to stream this string array as a byte array so that the response body can be written at the client side and it should create the respective file in the streamed format.

I have tried the below code:

String[] convert = MyClass.myMethodWhichGenerateTheStringArray();

final ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
final ObjectOutputStream objectOutputStream = new ObjectOutputStream(byteArrayOutputStream);

objectOutputStream.writeBytes("\n");
for(String s: convert)
{
    objectOutputStream.writeBytes(s + "\n");
}
objectOutputStream.flush();
objectOutputStream.close();

final byte[] byteArray = byteArrayOutputStream.toByteArray();
return request.createResponseBuilder(HttpStatus.OK).body(byteArray).build();

I am seeing some random characters when I read the created file as shown below:

At the client side all i do is this:

import requests

url = "http://localhost:8081/api/MyFunction"

payload = "{\n    \"fileName\": \"ABCD\",\n    \"fileUrl\": \"https://dahfafj\",\n    \"inputFormat\": \"A\",\n    \"outputFormat\": \"B\"\n}"
headers = {
  'Content-Type': 'application/json'
}

response = requests.request("POST", url, headers=headers, data = payload)

file = open("resp_text.srt", "wb")
file.write(response.text.encode('utf8'))
file.close()

Is my approach right? What should I be doing to fix the garbage characters being printed in the file?

You're all over the place on this.

ObjectOutputStream - don't use this

OOS and OIS are (primarily) for java serialization, which you don't want (SOURCE: The current team in charge of java lament how sucky it is rather a lot), and you don't need here either. Stop using this; you do not need OOS to send byte arrays. Just plain jane OutputStream is all you want here.

charsets

Whenever you convert strings to bytes or vice versa, there is always a charset involved. If you don't specify one, you get 'platform default', which is a nice way of saying 'always exactly the wrong thing'. So, you know - your tests pass, at production time when millions of dollars are on the line, it will fail. Always explicitly specify the charset you wanted. Unless the API says that a specific, hardcoded charset is always used (for example, the new Files API hardcodes UTF-8, so those 'charset less' methods such as Files.readAllLines are okay. But most java API calls that turn chars to bytes or vice versa default to platform default which you never want!).

Note that on the python side you did learn this lesson and are specifying UTF-8. You failed to this on the java side.

Separators

You say you want to 'send each element in the string array'. What is your protocol? Just send one string after another, with zero ways to know when 'the next one in line' is happening? Do you want a newline character in between? Should that be windows style newline (\r\n or mac/unix/network style \n?).

From your code it looks like you want \n separators.

Let's put it together:

String[] convert = MyClass.myMethodWhichGenerateTheStringArray();

var bytes = new ByteArrayOutputStream();
var out = new OutputStreamWriter(bytes, StandardCharsets.UTF_8);

out.write("\n");
for(String s : convert) {
    out.write(s);
    out.write("\n");
}
out.close();
request.createResponseBuilder(HttpStatus.OK).body(bytes.toByteArray()).build();

or, rewriting a few things to make it shorter:

String[] convert = MyClass.myMethodWhichGenerateTheStringArray();
byte[] data = ("\n" + String.join("\n", convert)).getBytes(StandardCharsets.UTF_8);
request.createResponseBuilder(HttpStatus.OK).body(data).build();