MACRO NEPAL
Java 22 Unnamed Variables & Patterns: Cleaner, More Readable Code
awiskar acharya
November 15, 2025
3:23 am

Java 22 introduces Unnamed Variables & Patterns, a feature designed to reduce clutter and improve code readability by allowing developers to explicitly mark variables and pattern components as unused. This is particularly useful in scenarios where you're forced to declare variables due to syntax requirements but don't actually need to use them.

What are Unnamed Variables & Patterns?

Unnamed variables are denoted by the underscore character _ and indicate that a variable is declared but intentionally not used. Unnamed patterns extend this concept to pattern matching, allowing you to ignore components in deconstruction patterns.

Key Benefits

  • Improved Readability: Clearly signals intentional non-use of variables
  • Reduced Clutter: Eliminates unused variable warnings and unnecessary names
  • Better Maintenance: Makes code intent clearer for other developers
  • Compiler Enforcement: Prevents accidental use of unnamed variables

Basic Unnamed Variables Usage

Example 1: Basic Unnamed Variables

public class UnnamedVariablesBasic {
public static void main(String[] args) {
// Traditional approach - unused variable causes warning
try {
int result = Integer.parseInt("123");
System.out.println("Parsed successfully");
// 'result' is declared but not used - IDE warning
} catch (NumberFormatException e) {
System.out.println("Parse failed");
}
// Java 22 - using unnamed variable
try {
int _ = Integer.parseInt("123"); // No warning - explicitly unused
System.out.println("Parsed successfully");
} catch (NumberFormatException e) {
System.out.println("Parse failed");
}
// Multiple unnamed variables
int _ = calculateValue();
String _ = fetchData();
System.out.println("Operations completed");
}
static int calculateValue() {
return 42;
}
static String fetchData() {
return "data";
}
}

Example 2: Enhanced For-Loops

import java.util.List;
public class UnnamedVariablesLoops {
public static void main(String[] args) {
List<String> items = List.of("apple", "banana", "cherry");
// Traditional - counter variable not used
int counter = 0;
for (String item : items) {
System.out.println("Processing...");
// counter++; // Forgot to increment - bug!
}
// Java 22 - explicitly ignore loop variable when only count matters
int count = 0;
for (String _ : items) {
count++;
}
System.out.println("Total items: " + count);
// Multiple loops with unnamed variables
processMultipleCollections();
}
static void processMultipleCollections() {
List<List<String>> nestedLists = List.of(
List.of("a", "b", "c"),
List.of("x", "y", "z")
);
// We only care about the number of inner lists, not their contents
for (List<String> _ : nestedLists) {
performOperation();
}
}
static void performOperation() {
System.out.println("Operation performed");
}
}

Unnamed Variables in Real-World Scenarios

Example 3: Exception Handling

import java.util.Optional;
public class UnnamedVariablesExceptions {
public static void main(String[] args) {
// Traditional exception handling with unused variable
try {
riskyOperation();
} catch (UnsupportedOperationException ex) {
// 'ex' is declared but not used
System.out.println("Operation not supported");
}
// Java 22 - explicitly ignore exception details
try {
riskyOperation();
} catch (UnsupportedOperationException _) {
System.out.println("Operation not supported");
}
// Multiple catch blocks with unnamed variables
try {
anotherRiskyOperation();
} catch (IllegalArgumentException _) {
System.out.println("Invalid argument");
} catch (UnsupportedOperationException _) {
System.out.println("Operation not supported");
}
// Optional handling
Optional<String> optionalValue = Optional.empty();
if (optionalValue.isEmpty()) {
String _ = optionalValue.orElse("default"); // Explicitly ignore
System.out.println("Using default value");
}
}
static void riskyOperation() {
throw new UnsupportedOperationException("Not implemented");
}
static void anotherRiskyOperation() {
// Simulate different exceptions
if (Math.random() > 0.5) {
throw new IllegalArgumentException("Bad argument");
} else {
throw new UnsupportedOperationException("Not supported");
}
}
}

Example 4: Collections and Streams

import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;
public class UnnamedVariablesCollections {
public static void main(String[] args) {
Map<String, Integer> scores = Map.of(
"Alice", 95,
"Bob", 87,
"Charlie", 92
);
// Traditional - entry variable not fully used
scores.forEach((name, score) -> {
System.out.println("Processing student...");
// Only using the action, not the key/value
});
// Java 22 - explicitly ignore both key and value
scores.forEach((_, _) -> {
System.out.println("Processing student record");
});
// Stream operations with unused elements
List<String> names = List.of("Alice", "Bob", "Charlie");
long count = names.stream()
.map(_ -> "Processed") // Ignore input element
.count();
System.out.println("Processed " + count + " items");
// More complex stream example
processWithSideEffects(names);
}
static void processWithSideEffects(List<String> items) {
// We want to execute a side effect for each item but don't need the item itself
items.stream()
.map(_ -> {
performSideEffect();
return null;
})
.collect(Collectors.toList());
}
static void performSideEffect() {
System.out.println("Side effect executed");
}
}

Unnamed Patterns in Pattern Matching

Example 5: Record Patterns with Unnamed Components

public class UnnamedPatterns {
// Sample records
record Point(int x, int y, String label) {}
record Rectangle(Point topLeft, Point bottomRight) {}
record Person(String name, int age, String email) {}
public static void main(String[] args) {
Point point = new Point(10, 20, "origin");
Rectangle rect = new Rectangle(new Point(0, 0, "tl"), new Point(100, 100, "br"));
Person person = new Person("John", 30, "[email protected]");
// Traditional record pattern - all components must be named
if (point instanceof Point(int x, int y, String label)) {
System.out.println("Point at (" + x + ", " + y + ")");
// 'label' is unused but we're forced to declare it
}
// Java 22 - unnamed pattern components
if (point instanceof Point(int x, int y, String _)) {
System.out.println("Point at (" + x + ", " + y + ")");
// No unused variable warning
}
// Nested patterns with unnamed components
if (rect instanceof Rectangle(Point(int x1, int y1, String _), 
Point(int x2, int y2, String _))) {
int width = x2 - x1;
int height = y2 - y1;
System.out.println("Rectangle size: " + width + "x" + height);
}
// Switch expressions with unnamed patterns
String result = switch (person) {
case Person(String name, int _, String _) when name.length() > 3 -> "Long name";
case Person(String _, int age, String _) when age > 25 -> "Adult";
case Person(String _, int _, String _) -> "Other";
};
System.out.println("Person category: " + result);
}
// Method using unnamed patterns
static String extractName(Person person) {
return switch (person) {
case Person(String name, int _, String _) -> name;
};
}
static int calculateArea(Rectangle rect) {
if (rect instanceof Rectangle(Point(int x1, int y1, String _), 
Point(int x2, int y2, String _))) {
return Math.abs(x2 - x1) * Math.abs(y2 - y1);
}
return 0;
}
}

Example 6: Advanced Pattern Matching Scenarios

import java.util.*;
public class AdvancedUnnamedPatterns {
// Complex nested records
record Address(String street, String city, String zip) {}
record Customer(String id, String name, Address address, List<Order> orders) {}
record Order(String orderId, double amount, Date orderDate) {}
public static void main(String[] args) {
Customer customer = new Customer(
"C123", 
"Alice", 
new Address("123 Main St", "Springfield", "12345"),
List.of(
new Order("O1", 99.99, new Date()),
new Order("O2", 149.99, new Date())
)
);
// Complex pattern with multiple unnamed components
if (customer instanceof Customer(String id, String name, 
Address(String _, String city, String _),
List<Order> _)) {
System.out.println("Customer " + name + " from " + city + " (ID: " + id + ")");
}
// Processing collections with unnamed patterns
processCustomers(List.of(customer));
// Switch with nested unnamed patterns
analyzeCustomer(customer);
}
static void processCustomers(List<Customer> customers) {
for (Customer customer : customers) {
// We only care about customer ID and order count, not order details
if (customer instanceof Customer(String id, String _, Address _, List<Order> orders)) {
System.out.println("Customer " + id + " has " + orders.size() + " orders");
}
}
}
static void analyzeCustomer(Customer customer) {
String analysis = switch (customer) {
case Customer(String id, String name, Address(_, String city, _), List<Order> orders) 
when orders.size() > 5 -> "Frequent buyer from " + city;
case Customer(String _, String _, Address(_, String city, _), List<Order> _) 
when city.equals("New York") -> "NYC customer";
case Customer(String _, String name, Address _, List<Order> _) 
when name.startsWith("A") -> "A-name customer";
case Customer(String _, String _, Address _, List<Order> _) -> "Regular customer";
};
System.out.println("Analysis: " + analysis);
}
// Method with multiple unnamed parameters in lambda
static void initializeSystem() {
List<Runnable> initializers = List.of(
() -> System.out.println("Initializing module A"),
() -> System.out.println("Initializing module B"),
() -> System.out.println("Initializing module C")
);
// We don't care about the index, just need to run each initializer
for (int i = 0; i < initializers.size(); i++) {
Runnable _ = initializers.get(i); // Explicitly ignore
initializers.get(i).run();
}
}
}

Best Practices and Guidelines

Example 7: Proper Usage Patterns

import java.util.concurrent.*;
public class UnnamedVariablesBestPractices {
public static void main(String[] args) throws Exception {
// ✅ GOOD: Clear intent with unnamed variables
goodPractices();
// ❌ BAD: Common pitfalls to avoid
badPractices();
// Mixed scenarios
mixedUsage();
}
static void goodPractices() {
// 1. Exception handling where exception details aren't needed
try {
TimeUnit.MILLISECONDS.sleep(100);
} catch (InterruptedException _) {
// We don't need the exception details, just handling the case
Thread.currentThread().interrupt();
}
// 2. Loop counters when only presence matters
List<String> items = List.of("a", "b", "c");
for (String _ : items) {
performBackgroundTask();
}
// 3. Method returns when we only care about side effects
String _ = System.setProperty("key", "value");
// 4. Pattern matching when only some components are needed
record Pair(String key, String value) {}
Pair pair = new Pair("name", "John");
if (pair instanceof Pair(String key, String _)) {
System.out.println("Key: " + key);
}
}
static void badPractices() {
// ❌ Don't use unnamed variables when the value is actually needed
List<String> names = List.of("Alice", "Bob");
// BAD: We actually need the names later
// for (String _ : names) {
//     System.out.println("Processing...");
// }
// System.out.println("First name: " + names.get(0)); // This would fail!
// GOOD: Use meaningful names when values are needed
for (String name : names) {
System.out.println("Processing: " + name);
}
// ❌ Don't overuse in simple cases where names are clear
int total = 10;
// int _ = total; // Overkill - just use the meaningful name
// ❌ Avoid in public API documentation examples
// Public examples should be clear and educational
}
static void mixedUsage() {
// Complex scenario with mixed named and unnamed variables
ExecutorService executor = Executors.newFixedThreadPool(2);
Future<String> future1 = executor.submit(() -> "Result1");
Future<String> future2 = executor.submit(() -> "Result2");
try {
// We only care if both complete successfully, not their individual results
String _ = future1.get(1, TimeUnit.SECONDS);
String _ = future2.get(1, TimeUnit.SECONDS);
System.out.println("Both tasks completed successfully");
} catch (TimeoutException _) {
System.out.println("Tasks timed out");
} catch (ExecutionException _) {
System.out.println("Task execution failed");
} catch (InterruptedException _) {
Thread.currentThread().interrupt();
} finally {
executor.shutdown();
}
}
static void performBackgroundTask() {
// Simulate background work
try {
Thread.sleep(50);
} catch (InterruptedException _) {
Thread.currentThread().interrupt();
}
}
}

Migration and Compatibility

Example 8: Gradual Adoption Strategy

public class UnnamedVariablesMigration {
// Existing code with unused variables
public static void oldStyleCode() {
// Before: Unused variables causing warnings
List<String> data = List.of("a", "b", "c");
@SuppressWarnings("unused")
int unusedCounter = 0; // Had to suppress warnings
for (String unusedItem : data) {
System.out.println("Processing...");
}
try {
int unusedResult = riskyCall();
System.out.println("Call succeeded");
} catch (Exception unusedEx) {
System.out.println("Call failed");
}
}
// Modernized code with unnamed variables
public static void newStyleCode() {
// After: Clean, intentional code
List<String> data = List.of("a", "b", "c");
int _ = 0; // No warning needed
for (String _ : data) {
System.out.println("Processing...");
}
try {
int _ = riskyCall();
System.out.println("Call succeeded");
} catch (Exception _) {
System.out.println("Call failed");
}
}
static int riskyCall() {
return 42;
}
// Mixed approach during migration
public static void gradualMigration() {
// Keep meaningful names where they add value
List<String> importantData = List.of("critical", "data", "points");
for (String item : importantData) {
processImportantItem(item); // We actually use the item
}
// Use unnamed for trivial cases
List<String> logEntries = readLogEntries();
for (String _ : logEntries) {
incrementCounter(); // Don't care about log content, just count
}
}
static void processImportantItem(String item) {
System.out.println("Processing: " + item);
}
static List<String> readLogEntries() {
return List.of("log1", "log2", "log3");
}
static void incrementCounter() {
// Counter implementation
}
}

Key Rules and Limitations

  1. Single Usage: Only one unnamed variable _ can be used in a scope
  2. No Reuse: Cannot reference unnamed variables after declaration
  3. Compiler Enforcement: Attempting to use _ after declaration causes compile-time error
  4. Not a Keyword: _ is not a reserved keyword, but has special meaning in variable declarations

Conclusion

Java 22's Unnamed Variables & Patterns provide significant benefits for writing cleaner, more intentional code:

  • ✅ Clear Intent: Explicitly marks unused variables as intentional
  • ✅ Reduced Noise: Eliminates unnecessary variable names and warnings
  • ✅ Better Patterns: Enhances pattern matching with selective component ignoring
  • ✅ Gradual Adoption: Can be adopted incrementally in existing codebases

This feature is particularly valuable in:

  • Exception handling blocks
  • Loop constructs where elements aren't used
  • Pattern matching deconstructions
  • API calls where return values are ignored
  • Test code with setup/teardown operations

By adopting unnamed variables and patterns, Java developers can write more maintainable code that clearly communicates intent while reducing visual clutter and potential bugs from accidentally unused variables.

Category : JAVA

Leave a Reply

Your email address will not be published. Required fields are marked *


Macro Nepal Helper