Java Socket Basics

Su Suriya Ravichandran Updated 18 Nov 2026
14 min read ·Lesson 207 of 306

A Java socket is one end of a two-way connection between two programs over a network. The java.net.Socket class opens a TCP connection to a server, and then you read and write data through ordinary input and output streams, just like reading a file.

Sockets sit underneath almost every network protocol: HTTP, database drivers, mail servers and chat apps all use them. In this lesson you will connect a Java socket to a server, send and receive text, detect a closed connection, set timeouts and socket options, and finally build a reusable client for a small key-value protocol.


How a Java Socket Connection Works

A TCP connection is identified by four values: the client's IP address and port, and the server's IP address and port. The server waits on a known port. The client connects to it, and the operating system gives the client a free ephemeral port for its side.

StepClient side (Socket)Server side (ServerSocket)
1Listens on a port, for example 8093
2new Socket("localhost", 8093) connectsaccept() returns a new Socket
3Writes to getOutputStream()Reads from its getInputStream()
4Reads from getInputStream()Writes to its getOutputStream()
5close() ends the connectionSees end of stream, closes its socket

Once connected, both sides are equal: each has a Socket with an input stream and an output stream. TCP guarantees that bytes arrive complete and in order, as described in Java networking basics.

Common Socket methodPurpose
Socket(host, port)Create and connect in one step
connect(SocketAddress, timeout)Connect with a timeout (after new Socket())
getInputStream() / getOutputStream()Streams for reading and writing bytes
setSoTimeout(ms)Maximum time a read may block
getInetAddress(), getPort()The remote address and port
getLocalPort()The local (ephemeral) port
shutdownOutput()Tell the other side you are done sending
close()Close the connection and both streams

A Local Server for the Examples

A socket needs something to connect to. Save this TextServer.java next to the examples. It listens on localhost:8093 and understands one command per line:

CommandReply
HELLO nameHi name!
UPPER textThe text in upper case
SET key valueOK (stores the value)
GET keyThe value, or NOT_FOUND
SLOWWaits 2 seconds, then replies
QUITBYE, then closes the connection
// FILE: TextServer.java
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;
import java.nio.charset.StandardCharsets;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

// A small line-based TCP server on localhost:8093 used by the examples
public class TextServer {
    private static final Map<String, String> STORE = new ConcurrentHashMap<>();

    public static ServerSocket start() throws IOException {
        ServerSocket server = new ServerSocket(8093, 50, InetAddress.getLoopbackAddress());
        Thread.ofVirtual().start(() -> {
            while (!server.isClosed()) {
                try {
                    Socket client = server.accept();
                    Thread.ofVirtual().start(() -> handle(client));
                } catch (IOException e) {
                    return; // server was closed
                }
            }
        });
        return server;
    }

    private static void handle(Socket socket) {
        try (socket;
             BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream(), StandardCharsets.UTF_8));
             PrintWriter out = new PrintWriter(socket.getOutputStream(), true, StandardCharsets.UTF_8)) {
            String line;
            while ((line = in.readLine()) != null) {
                String[] parts = line.split(" ", 3);
                switch (parts[0].toUpperCase()) {
                    case "HELLO" -> out.println("Hi " + parts[1] + "!");
                    case "UPPER" -> out.println(line.substring(6).toUpperCase());
                    case "SET" -> { STORE.put(parts[1], parts[2]); out.println("OK"); }
                    case "GET" -> out.println(STORE.getOrDefault(parts[1], "NOT_FOUND"));
                    case "SLOW" -> { Thread.sleep(2000); out.println("finally done"); }
                    case "QUIT" -> { out.println("BYE"); return; }
                    default -> out.println("ERROR unknown command: " + parts[0]);
                }
            }
        } catch (IOException | InterruptedException | ArrayIndexOutOfBoundsException e) {
            // client went away or sent a bad line; just close the connection
        }
    }
}

The server uses ServerSocket and a virtual thread per client. You do not need to understand it yet; the next lesson, Java ServerSocket, explains how it works. Here we focus on the client side.


Connecting a Java Socket to a Server

The constructor new Socket(host, port) looks up the host, opens the TCP connection and returns a connected socket. To send text, wrap the output stream in a PrintWriter; to read text, wrap the input stream in a BufferedReader.

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.nio.charset.StandardCharsets;

public class FirstSocket {
    public static void main(String[] args) throws Exception {
        ServerSocket server = TextServer.start();

        // Connect to the server: host name + port number
        try (Socket socket = new Socket("localhost", 8093);
             PrintWriter out = new PrintWriter(socket.getOutputStream(), true, StandardCharsets.UTF_8);
             BufferedReader in = new BufferedReader(
                     new InputStreamReader(socket.getInputStream(), StandardCharsets.UTF_8))) {

            System.out.println("Connected:   " + socket.isConnected());
            System.out.println("Remote:      " + socket.getInetAddress().getHostAddress() + ":" + socket.getPort());
            System.out.println("Local port:  " + (socket.getLocalPort() > 0 ? "picked by the OS" : "none"));

            out.println("HELLO Priya");                 // send one line
            System.out.println("Server says: " + in.readLine()); // read one line
        } finally {
            server.close();
        }
    }
}

Output:

Connected:   true
Remote:      127.0.0.1:8093
Local port:  picked by the OS
Server says: Hi Priya!

How it works:

  • new Socket("localhost", 8093) blocks until the connection is open, then returns. If no server is listening, it throws ConnectException.
  • new PrintWriter(stream, true, UTF_8) turns on auto-flush, so every println() is sent at once. Without it, the text could sit in a buffer and the server would wait forever.
  • in.readLine() blocks until a full line (ending in \n) arrives from the server.
  • The local port is chosen by the operating system and changes on every run, which is why the example only checks that it exists.
  • Try-with-resources closes the reader, the writer and the socket. Closing any of the socket's streams also closes the socket.

Note: Always pass a charset such as StandardCharsets.UTF_8 when you turn socket bytes into text. Otherwise Java uses the platform default, and the client and server may disagree about characters like ₹ or é.


Sending and Receiving Many Messages

A socket connection stays open until one side closes it, so you can exchange many messages over the same connection. A simple protocol decides who speaks when; here, each request line gets exactly one reply line.

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.nio.charset.StandardCharsets;
import java.util.List;

public class Conversation {
    public static void main(String[] args) throws Exception {
        ServerSocket server = TextServer.start();
        List<String> commands = List.of("UPPER java sockets", "SET city Chennai", "GET city", "GET country", "PING");

        try (Socket socket = new Socket("localhost", 8093);
             PrintWriter out = new PrintWriter(socket.getOutputStream(), true, StandardCharsets.UTF_8);
             BufferedReader in = new BufferedReader(
                     new InputStreamReader(socket.getInputStream(), StandardCharsets.UTF_8))) {

            // One request line, one response line, over the same connection
            for (String command : commands) {
                out.println(command);
                System.out.printf("%-20s -> %s%n", command, in.readLine());
            }
        } finally {
            server.close();
        }
    }
}

Output:

UPPER java sockets   -> JAVA SOCKETS
SET city Chennai     -> OK
GET city             -> Chennai
GET country          -> NOT_FOUND
PING                 -> ERROR unknown command: PING

How it works:

  • All five commands travel over one TCP connection. Opening a new connection for every message would be much slower.
  • Because the protocol is "one line in, one line out", the client always knows to call readLine() once after each println().
  • SET and GET share server state, so GET city returns the value stored by the previous command.
  • The server answers unknown commands with an ERROR line instead of closing the connection.

Note: TCP is a stream of bytes, not a stream of messages. One println() on one side may arrive in several pieces on the other. Line-based reading with readLine() puts the pieces back together; for binary data, use a length prefix with DataOutputStream.writeInt() before each message.


Detecting When the Server Closes the Connection

When the other side closes its connection, your next read reaches the end of stream. For a BufferedReader, readLine() returns null; for a raw InputStream, read() returns -1. This is how you know the conversation is over.

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.nio.charset.StandardCharsets;

public class EndOfStream {
    public static void main(String[] args) throws Exception {
        ServerSocket server = TextServer.start();

        try (Socket socket = new Socket("localhost", 8093);
             PrintWriter out = new PrintWriter(socket.getOutputStream(), true, StandardCharsets.UTF_8);
             BufferedReader in = new BufferedReader(
                     new InputStreamReader(socket.getInputStream(), StandardCharsets.UTF_8))) {

            out.println("QUIT");

            // Keep reading until the server closes its side of the connection
            String line;
            int count = 0;
            while ((line = in.readLine()) != null) {
                System.out.println("Received: " + line);
                count++;
            }
            System.out.println("readLine() returned null after " + count + " line(s): server closed the connection");
            System.out.println("Our socket closed? " + socket.isClosed());
        } finally {
            server.close();
        }
    }
}

Output:

Received: BYE
readLine() returned null after 1 line(s): server closed the connection
Our socket closed? false

How it works:

  • After QUIT, the server sends BYE and closes its socket.
  • The while ((line = in.readLine()) != null) loop is the standard way to read until the end of stream.
  • socket.isClosed() is still false. It only reports whether your side was closed by calling close(). It cannot tell you that the remote side went away; only a read returning null or -1 (or a write failing) does that.

Socket Timeouts: Connect and Read

By default, both connecting and reading can block forever. A server that is down, slow or unreachable could freeze your program. Java gives you two separate timeouts:

TimeoutHow to set itException when it expires
Connect timeoutsocket.connect(address, ms)SocketTimeoutException ("Connect timed out")
Read timeoutsocket.setSoTimeout(ms)SocketTimeoutException ("Read timed out")

If the target host is reachable but no program listens on the port, the OS rejects the connection at once with ConnectException: Connection refused.

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.ConnectException;
import java.net.InetSocketAddress;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.SocketTimeoutException;
import java.nio.charset.StandardCharsets;

public class Timeouts {
    public static void main(String[] args) throws Exception {
        // 1. Nobody listens on port 8099: the connection is refused
        try (Socket socket = new Socket()) {
            socket.connect(new InetSocketAddress("localhost", 8099), 2000); // 2 s connect timeout
        } catch (ConnectException e) {
            System.out.println("Connect failed: " + e.getMessage());
        }

        // 2. The server is slow: the read times out
        ServerSocket server = TextServer.start();
        try (Socket socket = new Socket()) {
            socket.connect(new InetSocketAddress("localhost", 8093), 2000);
            socket.setSoTimeout(500); // wait at most 500 ms for each read

            PrintWriter out = new PrintWriter(socket.getOutputStream(), true, StandardCharsets.UTF_8);
            BufferedReader in = new BufferedReader(
                    new InputStreamReader(socket.getInputStream(), StandardCharsets.UTF_8));

            out.println("SLOW");
            long start = System.nanoTime();
            try {
                System.out.println(in.readLine());
            } catch (SocketTimeoutException e) {
                long waited = (System.nanoTime() - start) / 1_000_000;
                System.out.println("Read failed: " + e.getMessage() + " (after about " + (waited / 100 * 100) + " ms)");
            }
        } catch (IOException e) {
            System.out.println("Unexpected: " + e);
        } finally {
            server.close();
        }
    }
}

Output:

Connect failed: Connection refused
Read failed: Read timed out (after about 500 ms)

How it works:

  • new Socket() creates an unconnected socket. connect(address, 2000) then connects with a 2-second limit. Use this form instead of new Socket(host, port) whenever the server might be unreachable.
  • Port 8099 has no listener, so the connection is refused immediately rather than timing out.
  • setSoTimeout(500) limits every blocking read to 500 ms. The SLOW command takes 2 seconds, so readLine() throws SocketTimeoutException.
  • After a read timeout the socket is still open. You may retry the read, or close the socket and give up.

Java Socket Options

Socket options tune how the connection behaves. Most must be set before connect() to affect the connection setup.

OptionMethodEffect
TCP_NODELAYsetTcpNoDelay(true)Send small writes immediately (turns off Nagle's algorithm); good for interactive protocols
SO_KEEPALIVEsetKeepAlive(true)The OS periodically checks idle connections and reports dead ones
SO_TIMEOUTsetSoTimeout(ms)Read timeout, as shown above
SO_RCVBUF / SO_SNDBUFsetReceiveBufferSize(n) / setSendBufferSize(n)Hints for OS buffer sizes
SO_LINGERsetSoLinger(true, seconds)How long close() waits to send unsent data
import java.net.InetSocketAddress;
import java.net.ServerSocket;
import java.net.Socket;

public class SocketOptions {
    public static void main(String[] args) throws Exception {
        ServerSocket server = TextServer.start();

        try (Socket socket = new Socket()) {
            // Options set before connect() apply to the new connection
            socket.setTcpNoDelay(true);   // send small writes immediately
            socket.setKeepAlive(true);    // let the OS probe idle connections
            socket.setSoTimeout(3000);    // read timeout in milliseconds

            socket.connect(new InetSocketAddress("localhost", 8093), 2000);

            System.out.println("TCP_NODELAY:  " + socket.getTcpNoDelay());
            System.out.println("SO_KEEPALIVE: " + socket.getKeepAlive());
            System.out.println("SO_TIMEOUT:   " + socket.getSoTimeout() + " ms");
            System.out.println("Bound:        " + socket.isBound());

            socket.shutdownOutput(); // "I am done sending" (half-close)
            System.out.println("Output shut down? " + socket.isOutputShutdown());
        } finally {
            server.close();
        }
    }
}

Output:

TCP_NODELAY:  true
SO_KEEPALIVE: true
SO_TIMEOUT:   3000 ms
Bound:        true
Output shut down? true

How it works:

  • The options are applied to the unconnected socket and read back after connect().
  • isBound() is true because the OS assigned a local address and port during connect().
  • shutdownOutput() is a half-close: it sends end of stream to the server, but you can still read the server's remaining replies. This is useful when the server reads "until the client stops sending" before it answers.

Real-World Example: A Key-Value Store Client

Real applications hide socket details behind a small client class, the way a database driver does. This KeyValueClient opens one connection, sets timeouts, sends commands with a private call() method, turns protocol errors into exceptions and says QUIT before closing.

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.InetSocketAddress;
import java.net.ServerSocket;
import java.net.Socket;
import java.nio.charset.StandardCharsets;
import java.util.Optional;

// A reusable client for the line-based key-value protocol of TextServer
public class KeyValueClient implements AutoCloseable {
    private final Socket socket;
    private final PrintWriter out;
    private final BufferedReader in;

    public KeyValueClient(String host, int port) throws IOException {
        socket = new Socket();
        socket.connect(new InetSocketAddress(host, port), 2000);
        socket.setSoTimeout(3000);
        out = new PrintWriter(socket.getOutputStream(), true, StandardCharsets.UTF_8);
        in = new BufferedReader(new InputStreamReader(socket.getInputStream(), StandardCharsets.UTF_8));
    }

    // Send one command and return the one-line reply
    private String call(String command) throws IOException {
        if (command.contains("\n")) throw new IllegalArgumentException("Commands must be one line");
        out.println(command);
        String reply = in.readLine();
        if (reply == null) throw new IOException("Server closed the connection");
        if (reply.startsWith("ERROR")) throw new IOException(reply);
        return reply;
    }

    public void set(String key, String value) throws IOException {
        if (key.contains(" ")) throw new IllegalArgumentException("Keys cannot contain spaces: " + key);
        call("SET " + key + " " + value);
    }

    public Optional<String> get(String key) throws IOException {
        String reply = call("GET " + key);
        return reply.equals("NOT_FOUND") ? Optional.empty() : Optional.of(reply);
    }

    @Override
    public void close() throws IOException {
        try {
            if (!socket.isClosed()) call("QUIT"); // polite goodbye
        } catch (IOException ignored) {
            // the server may already be gone
        } finally {
            socket.close();
        }
    }

    public static void main(String[] args) throws Exception {
        ServerSocket server = TextServer.start();
        try {
            // First connection stores some settings
            try (KeyValueClient kv = new KeyValueClient("localhost", 8093)) {
                kv.set("user:42:name", "Asha Rao");
                kv.set("user:42:plan", "premium");
                System.out.println("Saved two values");
            }

            // A second, separate connection reads them back
            try (KeyValueClient kv = new KeyValueClient("localhost", 8093)) {
                System.out.println("Name:  " + kv.get("user:42:name").orElse("(none)"));
                System.out.println("Plan:  " + kv.get("user:42:plan").orElse("(none)"));
                System.out.println("Email: " + kv.get("user:42:email").orElse("(none)"));
                kv.set("bad key", "x");
            } catch (IllegalArgumentException e) {
                System.out.println("Rejected: " + e.getMessage());
            }
        } finally {
            server.close();
        }

        // The server is stopped now, so connecting fails cleanly
        try (KeyValueClient kv = new KeyValueClient("localhost", 8093)) {
            kv.get("anything");
        } catch (IOException e) {
            System.out.println("Server down: " + e.getClass().getSimpleName() + " - " + e.getMessage());
        }
    }
}

Output:

Saved two values
Name:  Asha Rao
Plan:  premium
Email: (none)
Rejected: Keys cannot contain spaces: bad key

How it works:

  1. Safe connection setup. The constructor connects with a 2-second connect timeout and a 3-second read timeout, so a dead server can never freeze the caller.
  2. One place for the protocol. call() sends a line and reads exactly one reply. It turns a null reply (closed connection) and an ERROR reply into IOExceptions, so set() and get() stay short.
  3. Input checks before sending. A key with a space would break the SET key value format, so set() rejects it with IllegalArgumentException before anything is written to the socket.
  4. Clear return types. get() returns Optional<String>, so "no value" (NOT_FOUND) is visible in the method's type instead of being a magic string.
  5. Polite shutdown. close() sends QUIT when the socket is still open, ignores errors from a server that is already gone, and always closes the socket in finally.
  6. State lives on the server. The second connection reads values stored by the first, because the data is kept by the server, not by the socket.
  7. Failure is reported, not hidden. When the server is stopped, the constructor throws ConnectException: Connection refused, which the caller catches and reports.

The same structure (connect with timeouts, one method per command, end-of-stream checks and a clean close()) applies to any TCP protocol you implement in Java. For connectionless UDP messaging, see Java DatagramSocket.

0 Comments

Reviewed before they appear

No comments yet.

Java
Java Introduction Java Features Java Syntax Java Comments Java Statements Java Output Java Variables Java Data Types Java Type Casting Java Operators Java Strings Java Numbers Java Math Java Booleans Java User Input Java Conditions Java If Else Java Switch Java While Loop Java For Loop Java Break Java Continue Java Arrays Java Methods Java Parameters Java Return Values Java Scope Java Recursion Install Java Install JDK Java IDEs Java JDK Java JRE Java JVM Java Compiler Java File Compile Java Run Java JShell Basics Java Packages Java OOP Java Classes Java Objects Class Methods Constructors Constructor Overload this Keyword static Keyword final Keyword Encapsulation Inheritance Polymorphism Abstraction Access Modifiers super Keyword Method Overload Method Override Instanceof Operator Nested Classes Inner Classes Anonymous Classes Enums Records Array Basics Array Length Loop Arrays Multidimensional Arrays Array Copy Array Sorting Array Search ArrayList LinkedList HashSet TreeSet HashMap TreeMap Queue Interface Deque Interface Stack Class Iterator List Interface Set Interface Map Interface Collections Class Comparable Comparator Generics Basics Generic Classes Generic Methods Wildcards String Basics String Length String Methods String Concatenation String Compare String Search String Replace String Split String Format StringBuilder StringBuffer Text Blocks Regular Expressions Number Types Integer Class Float Class Double Class BigInteger BigDecimal Math Class Random Numbers Number Format Date Basics LocalDate LocalTime LocalDateTime ZonedDateTime Date Formatting Date Parsing Period Class Duration Class Java Instant Class Java Exception Basics Java try...catch Java Multiple Catch Blocks Java finally Block Java throw Keyword Java throws Keyword Java Checked Exceptions Java Unchecked Exceptions Java Custom Exceptions Java try-with-resources Java Exception Chaining Java File Basics Java Create Files Java Read Files Java Write Files Java Delete Files Java File Paths Java File Class Java BufferedReader Java BufferedWriter Java FileInputStream Java FileOutputStream Java Object Streams Java Directory Handling Java NIO Basics Java Files API Java Input Java Scanner Class Java Console Input Java PrintStream Java InputStream Java OutputStream Java Reader Class Java Writer Class Java Buffered Streams Java Data Streams Java Generics Introduction Java Generic Types Java Generic Methods Java Bounded Types Java Wildcards Java Type Erasure Java Generic Interfaces Java Generic Collections Java Lambda Basics Java Lambda Syntax Java Functional Interfaces Java Method References Java Stream API Java Stream Creation Java Stream Filter Java Stream Map Java Stream Reduce Java Stream Sort Java Stream Collect Java Collectors Class Java Optional Class Java Parallel Streams Java Threads: Thread Basics Create a Thread in Java Java Thread Class Java Runnable Interface Java Thread States Java Thread Sleep Java Thread Join Java Thread Priority Java Synchronization Java Thread Safety Java Race Conditions Java Deadlocks Java Executor Service Java Thread Pools Java Callable Interface Java Future Interface Java CompletableFuture Java Concurrent Collections Java Atomic Classes Java Virtual Threads Java Networking Basics Java URL Class Java URI Class Java HttpClient Java HTTP Requests Java HTTP Responses Java Socket Basics Java ServerSocket Java DatagramSocket Java WebSocket Basics Java JDBC Basics Java JDBC Setup Java Database Connection Java JDBC Connection Interface Java JDBC Statement Java PreparedStatement Java ResultSet Java JDBC CRUD Operations Java JDBC Transactions Java JDBC Batch Update Java Connection Pooling with HikariCP Java JPA Basics: Entities, EntityManager and JPQL Java Hibernate Basics: SessionFactory, Session and HQL Package in Java: Basics Explained with Examples Create Package in Java: Step-by-Step Guide with Examples Import Package in Java: The import Statement Explained Access Control in Java: Packages, Classes and Members JAR File in Java: Create, Run and Inspect JAR Files Java Modules: Introduction to the Java Module System module-info in Java: Every Module Directive Explained Java Module Path: How --module-path Finds Your Modules Java Classpath: How -cp and CLASSPATH Find Your Classes Java Annotations: Basics of @ Metadata in Java Java Built-in Annotations: @Override, @Deprecated and More Java Custom Annotations: Create Your Own @interface Java Annotation Targets: @Target and ElementType Explained Java Reflection API: Inspect and Use Classes at Runtime Java Class Metadata: Names, Modifiers, Hierarchy and Generic Java Dynamic Objects: Create Objects Dynamically With Reflec Java Dynamic Proxy: Intercept Method Calls With Proxy and In Java Security Java Secure Coding Java Password Hashing Java Input Validation Java Cryptography Basics Java KeyStore Basics Java TLS Basics Java SecureRandom Java JUnit Basics Java JUnit Test Methods JUnit Assertions JUnit Test Fixtures JUnit Parameterized Tests Mockito in Java Java Mock Objects Java Integration Testing Java Code Coverage Maven in Java Create a Maven Project in Java Maven Dependencies Maven Plugins Gradle in Java Gradle Build Gradle Dependencies Build Executable JAR in Java Build WAR File in Java HTTP Basics in Java Java Servlet Basics Servlet Lifecycle in Java HttpServletRequest in Java HttpServletResponse in Java JSP in Java JSTL in JSP REST API in Java JSON in Java Java Web Application Spring Framework Basics Spring Boot Tutorial Spring MVC Spring Data JPA Spring Security Spring Boot REST API Jakarta EE Basics Java Deployment JAR Deployment Java WAR Deployment Run Java as a Service Docker Java: Dockerize a Java Application Java Environment Variables and Configuration Java Logging Basics Java Production Setup Java JVM Options Java JVM Monitoring Java Hello World App Java Calculator App Java Number Guess Game Java Student Manager Java Library System Java Bank App Java Todo App Java File Manager Java Quiz App Java REST API Project Java Chat Server Java Employee Manager Java E-commerce API
Ask about this post
AI Ask about this post

Ask questions about Java Socket Basics and get answers drawn from it.

Signed-in readers only.