title: Java Networking: Explain InputStream and OutputStream in Socket
body: <p>I have created a server by using <code>ServerSocket</code>. After that, I have created Client using <code>Socket</code>, and connect to this server.</p>
  
  <p>After that, I do "some stuff" with InputStream and OutputStream is taken from Socket Object. But, I don't really understand inputStream and outputStream so much. Here is my simple code :</p>
  
  <pre><code>private Socket sock = null;
  private InputStream sockInput = null;
  private OutputStream sockOutput = null;
  
  ...
              String msg = "Hello World";
              byte[] buffer = null;
  
              try {
                  sockOutput.write(msg.getBytes(), 0, test.length());
                  sockOutput.write("Hello StackOverFlow".getBytes(), 0, test.length());
                  buffer = new byte[test.length()];
                  sockInput.read(buffer, 0, test.length());
                  System.out.println(new String(buffer));
                  sockInput.read(buffer, 0, test.length());
                  System.out.println(new String(buffer));
              } catch (IOException e1) {
                  e1.printStackTrace();
                  }
  </code></pre>
  
  <p>The result will be : "Hello World" and "Hello StackOverFlow".</p>
  
  <p>Here is server side code :</p>
  
  <pre><code>private int serverPort = 0;
      private ServerSocket serverSock = null;
  
      public VerySimpleServer(int serverPort) {
          this.serverPort = serverPort;
  
          try {
              serverSock = new ServerSocket(this.serverPort);
          }
          catch (IOException e){
              e.printStackTrace(System.err);
          }
      }
  
      // All this method does is wait for some bytes from the
      // connection, read them, then write them back again, until the
      // socket is closed from the other side.
      public void handleConnection(InputStream sockInput, OutputStream sockOutput) {
          while(true) {
              byte[] buf=new byte[1024];
              int bytes_read = 0;
              try {
                  // This call to read() will wait forever, until the
                  // program on the other side either sends some data,
                  // or closes the socket.
                  bytes_read = sockInput.read(buf, 0, buf.length);
  
                  // If the socket is closed, sockInput.read() will return -1.
                  if(bytes_read &lt; 0) {
                      System.err.println("Server: Tried to read from socket, read() returned &lt; 0,  Closing socket.");
                      return;
                  }
                  System.err.println("Server: Received "+bytes_read
                                     +" bytes, sending them back to client, data="
                                     +(new String(buf, 0, bytes_read)));
                  sockOutput.write(buf, 0, bytes_read);
                  // This call to flush() is optional - we're saying go
                  // ahead and send the data now instead of buffering
                  // it.
                  sockOutput.flush();
              }
              catch (Exception e){
                  System.err.println("Exception reading from/writing to socket, e="+e);
                  e.printStackTrace(System.err);
                  return;
              }
          }
  
      }
  
      public void waitForConnections() {
          Socket sock = null;
          InputStream sockInput = null;
          OutputStream sockOutput = null;
          while (true) {
              try {
                  // This method call, accept(), blocks and waits
                  // (forever if necessary) until some other program
                  // opens a socket connection to our server.  When some
                  // other program opens a connection to our server,
                  // accept() creates a new socket to represent that
                  // connection and returns.
                  sock = serverSock.accept();
                  System.err.println("Server : Have accepted new socket.");
  
                  // From this point on, no new socket connections can
                  // be made to our server until we call accept() again.
  
                  sockInput = sock.getInputStream();
                  sockOutput = sock.getOutputStream();
              }
              catch (IOException e){
                  e.printStackTrace(System.err);
              }
  
              // Do something with the socket - read bytes from the
              // socket and write them back to the socket until the
              // other side closes the connection.
              handleConnection(sockInput, sockOutput);
  
              // Now we close the socket.
              try {
                  System.err.println("Closing socket.");
                  sock.close();
              }
              catch (Exception e){
                  System.err.println("Exception while closing socket.");
                  e.printStackTrace(System.err);
              }
  
              System.err.println("Finished with socket, waiting for next connection.");
          }
      }
  
      public static void main(String argv[]) {
          int port = 54321;
          VerySimpleServer server = new VerySimpleServer(port);
          server.waitForConnections();
      }
  </code></pre>
  
  <p>My question is :</p>
  
  <ol>
  <li><p>When I use <code>sockOutput.write</code> and I can get back those message back by <code>sockInput.read</code>. So, those message has been saved, right? If this true, does it saved on Server I have created or just saved in some other thing such as <code>Socket Object</code>.</p></li>
  <li><p>If I have written to socket String A1, A2,... An so I will receive A1, A2, ... An String respectively, right?</p></li>
  </ol>