Why do we have to use exact DataOutputStream to transfer textual data?

Question

I have a client-server application where the client is:

public static void main(String args[]) throws Exception{
        Socket s = new Socket("localhost", 12345);
        BufferedReader r = new BufferedReader(new InputStreamReader(s.getInputStream()));
        System.out.println(r.readLine());
        s.close();
    }

and the server:

public static void main(String args[]) throws Exception{
    @SuppressWarnings("resource")
    ServerSocket server = new ServerSocket(12345);
    Socket client = server.accept();
    OutputStream out = client.getOutputStream();
    //DataOutputStream dout = new DataOutputStream(out);
    BufferedWriter writer = new BufferedWriter(new PrintWriter(out));
    writer.write("String on client's behalf"); //Prints null on the client side. Why?
    out.flush();
    out.close();
    client.close();
}

But if we write the following:

public static void main(String args[]) throws Exception{
    @SuppressWarnings("resource")
    ServerSocket server = new ServerSocket(12345);
    Socket client = server.accept();
    OutputStream out = client.getOutputStream();
    DataOutputStream dout = new DataOutputStream(out);
    BufferedWriter writer = new BufferedWriter(new PrintWriter(dout));
    writer.write("String on client's behalf"); //Prints exact what I expected.
    dout.flush();
    dout.close();
    client.close();
}

I can't get the point of that differences. What the javadoc says is

This abstract class is the superclass of all classes representing an output stream of bytes. An output stream accepts output bytes and sends them to some sink.

Well, I just used a subclass of the abstract class to transfer data from the server. What's wrong?

Answer 1

A BufferedWriter stores anything you write to it in a buffer. It writes it to the underlying stream when the buffer is full, or when it is flushed or closed.

Your code writes to the BufferedWriter. It doesn't write enough to fill the buffer, and it never flushes or closes the BufferedWriter, so the BufferedWriter never writes the buffered data to the underlying stream (the PrintWriter).

Then you close out, before anything has been written to out.

If you change out.close() to writer.close() in your first code snippet, it works.

This is one reason it is important to close streams. If you close writer, it will flush the buffer and close the PrintWriter (which will close out). Note that closing a stream flushes it - you don't need to call flush separately.

I have no idea why your second code snippet supposedly works. My best guess is that that is not the exact code you tried.