Java InetAddress

Every connection in this part needed an address — a host and a port. java.net.InetAddress is the class that represents the host part: an IP address, optionally paired with a hostname. It is also the gateway to DNS (the Domain Name System), turning a name like example.com into the numeric address the network actually routes to. This final Networking chapter covers creating, resolving, and inspecting addresses. The same InetAddress instances you build here are what you hand to a Socket, a ServerSocket, or a DatagramSocket to actually connect.

No public constructor — use factory methods

You never write new InetAddress(...). Instead:

InetAddress a = InetAddress.getByName("example.com");   // DNS lookup (or parse a literal)
InetAddress b = InetAddress.getByName("93.184.216.34"); // numeric literal: no DNS
InetAddress[] all = InetAddress.getAllByName("example.com"); // every address for a host
InetAddress lo = InetAddress.getLoopbackAddress();      // 127.0.0.1 / ::1, never fails
InetAddress me = InetAddress.getLocalHost();            // this machine's address
InetAddress c = InetAddress.getByAddress(new byte[]{10,0,0,1}); // from raw bytes

Key distinction: getByName with a hostname performs a DNS query (which can be slow or throw UnknownHostException offline); with a numeric literal it just parses, no network. getByAddress builds an address from raw bytes with no lookup at all.

When would I reach for this? Any time you need to resolve a name before connecting, validate or classify an address (loopback, private, multicast), or hold onto a cached address to skip repeated DNS lookups in a hot path. A higher-level helper like the URL class resolves hosts for you behind the scenes; InetAddress is the layer you drop to when you need the address itself.

IPv4 and IPv6

InetAddress is the common supertype; concrete instances are Inet4Address (32-bit, 93.184.216.34) or Inet6Address (128-bit, ::1). getAddress() returns the raw bytes (4 or 16), and getHostAddress() returns the canonical text form. Code should treat both families uniformly through the InetAddress type.

Inspecting an address

Useful predicates classify an address without any network call: isLoopbackAddress(), isSiteLocalAddress() (private ranges like 10.x / 192.168.x), isMulticastAddress(), isAnyLocalAddress() (the wildcard 0.0.0.0), and isReachable(timeout) (an actual ping-style probe — the one method here that does hit the network).

A worked example: building and classifying addresses

This program creates addresses several ways — loopback, an IPv4 literal, raw bytes, an IPv6 literal — and inspects each with the classification predicates. It deliberately uses literals and loopback so it runs offline; the one DNS-dependent call (getLocalHost) is guarded.

What to take from the run:

• Addresses were created without a constructor — every instance came from a factory: getLoopbackAddress, getByName, getByAddress. That design lets the JVM cache lookups and return the right subclass (Inet4Address vs Inet6Address) for you.
• getByName("93.184.216.34") and getByName("::1") did no DNS query because the arguments were numeric literals — the method just parsed them. The same call with a hostname would have hit DNS, which is the slow, fail-on-offline path; knowing which inputs trigger a lookup matters for performance.
• The raw byte count distinguished the families: the IPv4 address reported 4 bytes, the IPv6 address 16, and instanceof Inet6Address confirmed the concrete type. Code that handles addresses generically works through the InetAddress supertype and rarely needs to branch on the family.
• The classification predicates answered structural questions with no network: the loopback address tested true for isLoopbackAddress(), and the 10.0.0.1 built from bytes tested true for isSiteLocalAddress() (a private range). These checks are pure arithmetic on the address bytes.
• getLocalHost() was wrapped in a try/catch because it can fail with UnknownHostException when the machine's own name is not resolvable. Address resolution is fundamentally a network/DNS operation that can fail, so robust code always anticipates the unresolved case — the same caution every chapter in this part applied to the network itself.

Practice