Table of Contents

1. Introduction to Generic Methods
2. Syntax and Structure
3. Type Inference
4. Bounded Type Parameters
5. Generic Methods vs Generic Classes
6. Common Use Cases
7. Wildcards in Generic Methods
8. Method Overloading with Generics
9. Best Practices
10. Complete Examples

Introduction to Generic Methods

Generic methods are methods that introduce their own type parameters. This is similar to declaring a generic type, but the type parameter's scope is limited to the method where it is declared.

Key Characteristics:

• Can be defined in both generic and non-generic classes
• Type parameter scope is limited to the method
• Support type inference (compiler can often determine the type)
• Can have multiple type parameters
• Can use bounded type parameters

Syntax and Structure

Basic Syntax:

public <T> returnType methodName(T parameter) {
// method body
}

Simple Examples:

public class GenericMethodExamples {
// Basic generic method
public static <T> void printArray(T[] array) {
for (T element : array) {
System.out.print(element + " ");
}
System.out.println();
}
// Generic method returning generic type
public static <T> T getFirstElement(T[] array) {
if (array == null || array.length == 0) {
return null;
}
return array[0];
}
// Generic method with multiple type parameters
public static <T, U> void printPair(T first, U second) {
System.out.println("First: " + first + ", Second: " + second);
}
// Generic method in non-generic class
public <E> int countOccurrences(E[] array, E target) {
int count = 0;
for (E element : array) {
if (element.equals(target)) {
count++;
}
}
return count;
}
public static void main(String[] args) {
// Using generic methods with different types
Integer[] intArray = {1, 2, 3, 4, 5};
String[] strArray = {"A", "B", "C", "D"};
Double[] doubleArray = {1.1, 2.2, 3.3};
System.out.print("Integer array: ");
printArray(intArray);
System.out.print("String array: ");
printArray(strArray);
System.out.print("Double array: ");
printArray(doubleArray);
// Using multiple type parameters
printPair("Hello", 42);
printPair(3.14, "Pi");
// Getting first element
System.out.println("First string: " + getFirstElement(strArray));
System.out.println("First integer: " + getFirstElement(intArray));
// Instance method usage
GenericMethodExamples instance = new GenericMethodExamples();
String[] words = {"apple", "banana", "apple", "cherry", "apple"};
System.out.println("Occurrences of 'apple': " + 
instance.countOccurrences(words, "apple"));
}
}

Output:

Integer array: 1 2 3 4 5 
String array: A B C D 
Double array: 1.1 2.2 3.3 
First: Hello, Second: 42
First: 3.14, Second: Pi
First string: A
First integer: 1
Occurrences of 'apple': 3

Type Inference

The Java compiler can infer the type parameter based on the method arguments and context.

Type Inference Examples:

import java.util.*;
public class TypeInferenceExamples {
// Generic method with type inference
public static <T> T identity(T input) {
return input;
}
// Method that uses type inference from parameters
public static <T> void addToList(List<T> list, T element) {
list.add(element);
}
// Method with return type inference
public static <T> T createDefault(Class<T> clazz) throws Exception {
return clazz.getDeclaredConstructor().newInstance();
}
// Complex type inference
public static <T> List<T> filter(List<T> list, Predicate<T> predicate) {
List<T> result = new ArrayList<>();
for (T item : list) {
if (predicate.test(item)) {
result.add(item);
}
}
return result;
}
public static void main(String[] args) throws Exception {
// Type inference in action
// 1. Explicit type specification (rarely needed)
String explicit = TypeInferenceExamples.<String>identity("Hello");
System.out.println("Explicit: " + explicit);
// 2. Type inference (common usage)
String inferred = identity("World");
System.out.println("Inferred: " + inferred);
// 3. Type inference with collections
List<String> stringList = new ArrayList<>();
addToList(stringList, "Apple");    // T inferred as String
addToList(stringList, "Banana");   // T inferred as String
System.out.println("String list: " + stringList);
List<Integer> intList = new ArrayList<>();
addToList(intList, 1);             // T inferred as Integer
addToList(intList, 2);             // T inferred as Integer
System.out.println("Integer list: " + intList);
// 4. Type inference with return type
String defaultString = createDefault(String.class);
System.out.println("Default string: '" + defaultString + "'");
// 5. Complex type inference with predicates
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
List<Integer> evenNumbers = filter(numbers, n -> n % 2 == 0);
System.out.println("Even numbers: " + evenNumbers);
List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David");
List<String> longNames = filter(names, name -> name.length() > 4);
System.out.println("Long names: " + longNames);
}
}
// Functional interface for filtering
interface Predicate<T> {
boolean test(T t);
}

Output:

Explicit: Hello
Inferred: World
String list: [Apple, Banana]
Integer list: [1, 2]
Default string: ''
Even numbers: [2, 4, 6, 8, 10]
Long names: [Alice, Charlie, David]

Bounded Type Parameters

Upper Bounded Type Parameters:

import java.util.*;
public class BoundedGenericMethods {
// Upper bounded type parameter - only accepts Number and subclasses
public static <T extends Number> double sum(List<T> numbers) {
double total = 0.0;
for (T number : numbers) {
total += number.doubleValue();
}
return total;
}
// Upper bounded with interface
public static <T extends Comparable<T>> T findMax(T[] array) {
if (array == null || array.length == 0) {
return null;
}
T max = array[0];
for (T element : array) {
if (element.compareTo(max) > 0) {
max = element;
}
}
return max;
}
// Multiple bounds
public static <T extends Number & Comparable<T>> T findMaxNumber(T[] array) {
if (array == null || array.length == 0) {
return null;
}
T max = array[0];
for (T element : array) {
if (element.compareTo(max) > 0) {
max = element;
}
}
return max;
}
// Bounded type with custom interface
public static <T extends Drawable> void drawAll(List<T> drawables) {
for (T drawable : drawables) {
drawable.draw();
}
}
public static void main(String[] args) {
// Test with Number types
List<Integer> integers = Arrays.asList(1, 2, 3, 4, 5);
List<Double> doubles = Arrays.asList(1.1, 2.2, 3.3);
System.out.println("Sum of integers: " + sum(integers));
System.out.println("Sum of doubles: " + sum(doubles));
// Test with Comparable types
Integer[] intArray = {5, 2, 8, 1, 9};
String[] strArray = {"apple", "zebra", "banana", "cherry"};
System.out.println("Max integer: " + findMax(intArray));
System.out.println("Max string: " + findMax(strArray));
// Test with multiple bounds
Integer[] numbers = {10, 5, 20, 15, 25};
System.out.println("Max number: " + findMaxNumber(numbers));
// Test with custom interface
List<Circle> circles = Arrays.asList(new Circle(), new Circle());
List<Rectangle> rectangles = Arrays.asList(new Rectangle(), new Rectangle());
System.out.println("Drawing circles:");
drawAll(circles);
System.out.println("Drawing rectangles:");
drawAll(rectangles);
}
}
// Custom interface and implementations
interface Drawable {
void draw();
}
class Circle implements Drawable {
@Override
public void draw() {
System.out.println("Drawing a circle");
}
}
class Rectangle implements Drawable {
@Override
public void draw() {
System.out.println("Drawing a rectangle");
}
}

Output:

Sum of integers: 15.0
Sum of doubles: 6.6
Max integer: 9
Max string: zebra
Max number: 25
Drawing circles:
Drawing a circle
Drawing a circle
Drawing rectangles:
Drawing a rectangle
Drawing a rectangle

Generic Methods vs Generic Classes

Comparison:

Aspect	Generic Methods	Generic Classes
Scope	Method level	Class level
Type Parameters	Declared in method	Declared in class
Usage	Can be in any class	Only in generic classes
Flexibility	Different types per call	Same type for all instances
Inference	Compiler can infer types	Types must be specified

Examples Showing Difference:

// Generic class
class GenericClass<T> {
private T value;
public GenericClass(T value) {
this.value = value;
}
public T getValue() {
return value;
}
// Generic method in generic class
public <U> void printBoth(U otherValue) {
System.out.println("Class type: " + value);
System.out.println("Method type: " + otherValue);
}
// Method using class type parameter
public void setValue(T newValue) {
this.value = newValue;
}
}
public class MethodVsClass {
// Generic method in non-generic class
public static <T> T processItem(T item) {
return item;
}
public static void main(String[] args) {
// Generic class usage - type is fixed per instance
GenericClass<String> stringContainer = new GenericClass<>("Hello");
GenericClass<Integer> intContainer = new GenericClass<>(42);
System.out.println("String container: " + stringContainer.getValue());
System.out.println("Integer container: " + intContainer.getValue());
// Generic method usage - different types per call
String result1 = processItem("Test");
Integer result2 = processItem(123);
Double result3 = processItem(45.67);
System.out.println("String result: " + result1);
System.out.println("Integer result: " + result2);
System.out.println("Double result: " + result3);
// Generic method in generic class
stringContainer.<Integer>printBoth(100);  // Different type than class
intContainer.<String>printBoth("World");  // Different type than class
}
}

Output:

String container: Hello
Integer container: 42
String result: Test
Integer result: 123
Double result: 45.67
Class type: Hello
Method type: 100
Class type: 42
Method type: World

Common Use Cases

1. Utility Methods:

import java.util.*;
public class GenericUtilityMethods {
// Swap elements in an array
public static <T> void swap(T[] array, int i, int j) {
T temp = array[i];
array[i] = array[j];
array[j] = temp;
}
// Reverse an array
public static <T> void reverse(T[] array) {
int left = 0;
int right = array.length - 1;
while (left < right) {
swap(array, left, right);
left++;
right--;
}
}
// Convert array to list
public static <T> List<T> arrayToList(T[] array) {
return new ArrayList<>(Arrays.asList(array));
}
// Check if array contains element
public static <T> boolean contains(T[] array, T element) {
for (T item : array) {
if (Objects.equals(item, element)) {
return true;
}
}
return false;
}
// Find index of element
public static <T> int indexOf(T[] array, T element) {
for (int i = 0; i < array.length; i++) {
if (Objects.equals(array[i], element)) {
return i;
}
}
return -1;
}
// Concatenate two arrays
public static <T> T[] concatenate(T[] first, T[] second) {
T[] result = Arrays.copyOf(first, first.length + second.length);
System.arraycopy(second, 0, result, first.length, second.length);
return result;
}
public static void main(String[] args) {
// Test swap
Integer[] numbers = {1, 2, 3, 4, 5};
System.out.println("Before swap: " + Arrays.toString(numbers));
swap(numbers, 1, 3);
System.out.println("After swap: " + Arrays.toString(numbers));
// Test reverse
String[] words = {"A", "B", "C", "D", "E"};
System.out.println("Before reverse: " + Arrays.toString(words));
reverse(words);
System.out.println("After reverse: " + Arrays.toString(words));
// Test arrayToList
Double[] doubles = {1.1, 2.2, 3.3};
List<Double> doubleList = arrayToList(doubles);
System.out.println("Array to list: " + doubleList);
// Test contains and indexOf
String[] fruits = {"apple", "banana", "cherry"};
System.out.println("Contains 'banana': " + contains(fruits, "banana"));
System.out.println("Index of 'cherry': " + indexOf(fruits, "cherry"));
// Test concatenate
Integer[] first = {1, 2, 3};
Integer[] second = {4, 5, 6};
Integer[] combined = concatenate(first, second);
System.out.println("Concatenated: " + Arrays.toString(combined));
}
}

Output:

Before swap: [1, 2, 3, 4, 5]
After swap: [1, 4, 3, 2, 5]
Before reverse: [A, B, C, D, E]
After reverse: [E, D, C, B, A]
Array to list: [1.1, 2.2, 3.3]
Contains 'banana': true
Index of 'cherry': 2
Concatenated: [1, 2, 3, 4, 5, 6]

2. Collection Utilities:

import java.util.*;
public class CollectionUtilities {
// Find maximum element in collection
public static <T extends Comparable<T>> T findMax(Collection<T> collection) {
if (collection.isEmpty()) {
throw new IllegalArgumentException("Collection is empty");
}
T max = null;
for (T element : collection) {
if (max == null || element.compareTo(max) > 0) {
max = element;
}
}
return max;
}
// Find minimum element in collection
public static <T extends Comparable<T>> T findMin(Collection<T> collection) {
if (collection.isEmpty()) {
throw new IllegalArgumentException("Collection is empty");
}
T min = null;
for (T element : collection) {
if (min == null || element.compareTo(min) < 0) {
min = element;
}
}
return min;
}
// Filter collection based on predicate
public static <T> List<T> filter(Collection<T> collection, Predicate<T> predicate) {
List<T> result = new ArrayList<>();
for (T element : collection) {
if (predicate.test(element)) {
result.add(element);
}
}
return result;
}
// Transform collection using function
public static <T, R> List<R> map(Collection<T> collection, Function<T, R> function) {
List<R> result = new ArrayList<>();
for (T element : collection) {
result.add(function.apply(element));
}
return result;
}
// Check if all elements satisfy predicate
public static <T> boolean allMatch(Collection<T> collection, Predicate<T> predicate) {
for (T element : collection) {
if (!predicate.test(element)) {
return false;
}
}
return true;
}
// Check if any element satisfies predicate
public static <T> boolean anyMatch(Collection<T> collection, Predicate<T> predicate) {
for (T element : collection) {
if (predicate.test(element)) {
return true;
}
}
return false;
}
public static void main(String[] args) {
List<Integer> numbers = Arrays.asList(5, 2, 8, 1, 9, 3, 7, 4, 6);
System.out.println("Numbers: " + numbers);
System.out.println("Max: " + findMax(numbers));
System.out.println("Min: " + findMin(numbers));
// Filter even numbers
List<Integer> evenNumbers = filter(numbers, n -> n % 2 == 0);
System.out.println("Even numbers: " + evenNumbers);
// Transform numbers to their squares
List<Integer> squares = map(numbers, n -> n * n);
System.out.println("Squares: " + squares);
// Check predicates
boolean allPositive = allMatch(numbers, n -> n > 0);
boolean hasEven = anyMatch(numbers, n -> n % 2 == 0);
System.out.println("All positive: " + allPositive);
System.out.println("Has even: " + hasEven);
// With strings
List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David", "Eve");
System.out.println("\nNames: " + names);
System.out.println("Max name: " + findMax(names));
System.out.println("Min name: " + findMin(names));
// Filter long names
List<String> longNames = filter(names, name -> name.length() > 4);
System.out.println("Long names: " + longNames);
// Transform to uppercase
List<String> upperCaseNames = map(names, String::toUpperCase);
System.out.println("Uppercase names: " + upperCaseNames);
}
}
// Functional interfaces
interface Predicate<T> {
boolean test(T t);
}
interface Function<T, R> {
R apply(T t);
}

Output:

Numbers: [5, 2, 8, 1, 9, 3, 7, 4, 6]
Max: 9
Min: 1
Even numbers: [2, 8, 4, 6]
Squares: [25, 4, 64, 1, 81, 9, 49, 16, 36]
All positive: true
Has even: true
Names: [Alice, Bob, Charlie, David, Eve]
Max name: Eve
Min name: Alice
Long names: [Alice, Charlie, David]
Uppercase names: [ALICE, BOB, CHARLIE, DAVID, EVE]

Wildcards in Generic Methods

Using Wildcards with Generic Methods:

import java.util.*;
public class WildcardGenericMethods {
// Upper bounded wildcard in generic method
public static double sumOfList(List<? extends Number> list) {
double sum = 0.0;
for (Number number : list) {
sum += number.doubleValue();
}
return sum;
}
// Lower bounded wildcard in generic method
public static void addNumbers(List<? super Integer> list) {
for (int i = 1; i <= 5; i++) {
list.add(i);
}
}
// Unbounded wildcard in generic method
public static void printList(List<?> list) {
for (Object element : list) {
System.out.print(element + " ");
}
System.out.println();
}
// Generic method with wildcard and type parameter
public static <T> void copy(List<? super T> dest, List<? extends T> src) {
for (T element : src) {
dest.add(element);
}
}
// Wildcard with bounded type parameter
public static <T extends Number> void processNumbers(List<T> numbers) {
double sum = 0.0;
for (T number : numbers) {
sum += number.doubleValue();
}
System.out.println("Sum: " + sum);
}
public static void main(String[] args) {
// Upper bounded wildcard
List<Integer> integers = Arrays.asList(1, 2, 3, 4, 5);
List<Double> doubles = Arrays.asList(1.1, 2.2, 3.3);
System.out.println("Sum of integers: " + sumOfList(integers));
System.out.println("Sum of doubles: " + sumOfList(doubles));
// Lower bounded wildcard
List<Number> numberList = new ArrayList<>();
List<Object> objectList = new ArrayList<>();
addNumbers(numberList);
addNumbers(objectList);
System.out.println("Number list: " + numberList);
System.out.println("Object list: " + objectList);
// Unbounded wildcard
List<String> strings = Arrays.asList("A", "B", "C");
List<Integer> numbers = Arrays.asList(1, 2, 3);
System.out.print("Strings: ");
printList(strings);
System.out.print("Numbers: ");
printList(numbers);
// Copy method
List<Number> destination = new ArrayList<>();
List<Integer> source = Arrays.asList(10, 20, 30);
copy(destination, source);
System.out.println("After copy: " + destination);
// Process numbers
processNumbers(integers);
processNumbers(doubles);
}
}

Output:

Sum of integers: 15.0
Sum of doubles: 6.6
Number list: [1, 2, 3, 4, 5]
Object list: [1, 2, 3, 4, 5]
Strings: A B C 
Numbers: 1 2 3 
After copy: [10, 20, 30]
Sum: 15.0
Sum: 6.6

Method Overloading with Generics

Overloading Generic Methods:

import java.util.*;
public class GenericMethodOverloading {
// Overloaded generic methods
// 1. Print single element
public static <T> void print(T element) {
System.out.println("Single: " + element);
}
// 2. Print array
public static <T> void print(T[] array) {
System.out.print("Array: ");
for (T element : array) {
System.out.print(element + " ");
}
System.out.println();
}
// 3. Print collection
public static <T> void print(Collection<T> collection) {
System.out.println("Collection: " + collection);
}
// 4. Print with custom message
public static <T> void print(String message, T element) {
System.out.println(message + ": " + element);
}
// 5. Print multiple elements
public static <T> void print(T first, T second) {
System.out.println("Two elements: " + first + ", " + second);
}
// 6. Varargs with generics
@SafeVarargs
public static <T> void printAll(T... elements) {
System.out.print("All: ");
for (T element : elements) {
System.out.print(element + " ");
}
System.out.println();
}
public static void main(String[] args) {
// Test overloaded methods
// Single element
print("Hello");
print(42);
print(3.14);
// Array
Integer[] intArray = {1, 2, 3};
String[] strArray = {"A", "B", "C"};
print(intArray);
print(strArray);
// Collection
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
Set<String> names = new HashSet<>(Arrays.asList("Alice", "Bob"));
print(numbers);
print(names);
// With message
print("The answer is", 42);
print("PI value", 3.14159);
// Two elements
print("Java", "Generics");
print(10, 20);
// Varargs
printAll(1, 2, 3, 4, 5);
printAll("A", "B", "C");
printAll(1.1, 2.2, 3.3);
}
}

Output:

Single: Hello
Single: 42
Single: 3.14
Array: 1 2 3 
Array: A B C 
Collection: [1, 2, 3, 4, 5]
Collection: [Alice, Bob]
The answer is: 42
PI value: 3.14159
Two elements: Java, Generics
Two elements: 10, 20
All: 1 2 3 4 5 
All: A B C 
All: 1.1 2.2 3.3

Best Practices

1. Use Descriptive Type Parameter Names:

// ✅ Good - descriptive names
public static <T> T getFirst(List<T> list) { ... }
public static <K, V> V getValue(Map<K, V> map, K key) { ... }
public static <E extends Comparable<E>> E findMax(Collection<E> collection) { ... }
// ❌ Avoid - unclear names
public static <X> X getFirst(List<X> list) { ... }

2. Prefer Type Inference:

List<String> names = Arrays.asList("Alice", "Bob");
// ✅ Good - let compiler infer type
String first = getFirst(names);
// ❌ Unnecessary - explicit type specification
String first = GenericMethods.<String>getFirst(names);

3. Use Bounds When Appropriate:

// ✅ Good - uses bounds for type safety
public static <T extends Comparable<T>> T findMax(T[] array) { ... }
// ❌ Bad - no bounds, might not have compareTo method
public static <T> T findMax(T[] array) { ... }

4. Avoid Raw Types:

// ✅ Good - uses generic types
public static <T> void processList(List<T> list) { ... }
// ❌ Bad - uses raw type
public static void processList(List list) { ... }

5. Use @SuppressWarnings Judiciously:

// Only when you're sure about type safety
@SuppressWarnings("unchecked")
public static <T> T[] createArray(int size) {
return (T[]) new Object[size];
}

Complete Examples

Complete Working Example:

import java.util.*;
import java.util.function.Function;
import java.util.function.Predicate;
public class GenericMethodsCompleteExample {
public static void main(String[] args) {
System.out.println("=== Generic Methods Complete Example ===\n");
// Example 1: Basic Generic Methods
basicGenericMethods();
// Example 2: Collection Utilities
collectionUtilities();
// Example 3: Mathematical Operations
mathematicalOperations();
// Example 4: Advanced - Generic Builders and Factories
advancedExamples();
}
public static void basicGenericMethods() {
System.out.println("1. Basic Generic Methods:");
// Identity method
String str = identity("Hello Generics");
Integer num = identity(42);
System.out.println("Identity string: " + str);
System.out.println("Identity integer: " + num);
// Print array
Integer[] numbers = {1, 2, 3, 4, 5};
String[] words = {"apple", "banana", "cherry"};
System.out.print("Numbers: ");
printArray(numbers);
System.out.print("Words: ");
printArray(words);
// Swap elements
System.out.println("Before swap: " + Arrays.toString(numbers));
swap(numbers, 0, 4);
System.out.println("After swap: " + Arrays.toString(numbers));
System.out.println();
}
public static void collectionUtilities() {
System.out.println("2. Collection Utilities:");
List<Integer> numbers = Arrays.asList(5, 2, 8, 1, 9, 3, 7, 4, 6);
List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David", "Eve");
// Filtering
List<Integer> evenNumbers = filter(numbers, n -> n % 2 == 0);
List<String> longNames = filter(names, name -> name.length() > 4);
System.out.println("Even numbers: " + evenNumbers);
System.out.println("Long names: " + longNames);
// Transformation
List<Integer> squares = map(numbers, n -> n * n);
List<String> upperCaseNames = map(names, String::toUpperCase);
System.out.println("Squares: " + squares);
System.out.println("Uppercase names: " + upperCaseNames);
// Finding max/min
System.out.println("Max number: " + findMax(numbers));
System.out.println("Min name: " + findMin(names));
System.out.println();
}
public static void mathematicalOperations() {
System.out.println("3. Mathematical Operations:");
List<Integer> integers = Arrays.asList(1, 2, 3, 4, 5);
List<Double> doubles = Arrays.asList(1.1, 2.2, 3.3, 4.4, 5.5);
// Sum of numbers
System.out.println("Sum of integers: " + sum(integers));
System.out.println("Sum of doubles: " + sum(doubles));
// Average
System.out.println("Average of integers: " + average(integers));
System.out.println("Average of doubles: " + average(doubles));
// Statistics
Integer[] intArray = {5, 2, 8, 1, 9, 3};
Double[] doubleArray = {5.5, 2.2, 8.8, 1.1, 9.9};
System.out.println("Max integer: " + findMax(intArray));
System.out.println("Max double: " + findMax(doubleArray));
System.out.println();
}
public static void advancedExamples() {
System.out.println("4. Advanced Examples:");
// Generic factory method
List<String> stringList = createEmptyArrayList();
List<Integer> intList = createEmptyArrayList();
stringList.add("Hello");
intList.add(42);
System.out.println("String list: " + stringList);
System.out.println("Integer list: " + intList);
// Generic builder pattern
Person person = buildPerson()
.withName("John Doe")
.withAge(30)
.withEmail("[email protected]")
.build();
System.out.println("Built person: " + person);
// Generic pair operations
Pair<String, Integer> nameAge = new Pair<>("Alice", 25);
Pair<Integer, String> idName = new Pair<>(101, "Bob");
System.out.println("Name-Age: " + nameAge);
System.out.println("ID-Name: " + idName);
System.out.println("Swapped: " + swapPair(nameAge));
}
// Basic generic methods
public static <T> T identity(T value) {
return value;
}
public static <T> void printArray(T[] array) {
for (T element : array) {
System.out.print(element + " ");
}
System.out.println();
}
public static <T> void swap(T[] array, int i, int j) {
T temp = array[i];
array[i] = array[j];
array[j] = temp;
}
// Collection utilities
public static <T> List<T> filter(List<T> list, Predicate<T> predicate) {
List<T> result = new ArrayList<>();
for (T item : list) {
if (predicate.test(item)) {
result.add(item);
}
}
return result;
}
public static <T, R> List<R> map(List<T> list, Function<T, R> function) {
List<R> result = new ArrayList<>();
for (T item : list) {
result.add(function.apply(item));
}
return result;
}
public static <T extends Comparable<T>> T findMax(List<T> list) {
if (list.isEmpty()) throw new IllegalArgumentException("List is empty");
return Collections.max(list);
}
public static <T extends Comparable<T>> T findMin(List<T> list) {
if (list.isEmpty()) throw new IllegalArgumentException("List is empty");
return Collections.min(list);
}
// Mathematical operations
public static <T extends Number> double sum(List<T> numbers) {
return numbers.stream().mapToDouble(Number::doubleValue).sum();
}
public static <T extends Number> double average(List<T> numbers) {
if (numbers.isEmpty()) return 0.0;
return sum(numbers) / numbers.size();
}
public static <T extends Comparable<T>> T findMax(T[] array) {
if (array.length == 0) throw new IllegalArgumentException("Array is empty");
T max = array[0];
for (T element : array) {
if (element.compareTo(max) > 0) {
max = element;
}
}
return max;
}
// Advanced methods
public static <T> ArrayList<T> createEmptyArrayList() {
return new ArrayList<>();
}
public static PersonBuilder buildPerson() {
return new PersonBuilder();
}
public static <K, V> Pair<V, K> swapPair(Pair<K, V> pair) {
return new Pair<>(pair.getValue(), pair.getKey());
}
}
// Supporting classes
class Person {
private String name;
private int age;
private String email;
private Person(String name, int age, String email) {
this.name = name;
this.age = age;
this.email = email;
}
@Override
public String toString() {
return String.format("Person{name='%s', age=%d, email='%s'}", name, age, email);
}
// Builder
static class PersonBuilder {
private String name;
private int age;
private String email;
public PersonBuilder withName(String name) {
this.name = name;
return this;
}
public PersonBuilder withAge(int age) {
this.age = age;
return this;
}
public PersonBuilder withEmail(String email) {
this.email = email;
return this;
}
public Person build() {
return new Person(name, age, email);
}
}
}
class Pair<K, V> {
private K key;
private V value;
public Pair(K key, V value) {
this.key = key;
this.value = value;
}
public K getKey() { return key; }
public V getValue() { return value; }
@Override
public String toString() {
return String.format("Pair{%s=%s}", key, value);
}
}

Expected Output:

=== Generic Methods Complete Example ===
1. Basic Generic Methods:
Identity string: Hello Generics
Identity integer: 42
Numbers: 1 2 3 4 5 
Words: apple banana cherry 
Before swap: [1, 2, 3, 4, 5]
After swap: [5, 2, 3, 4, 1]
2. Collection Utilities:
Even numbers: [2, 8, 4, 6]
Long names: [Alice, Charlie, David]
Squares: [25, 4, 64, 1, 81, 9, 49, 16, 36]
Uppercase names: [ALICE, BOB, CHARLIE, DAVID, EVE]
Max number: 9
Min name: Alice
3. Mathematical Operations:
Sum of integers: 15.0
Sum of doubles: 16.5
Average of integers: 3.0
Average of doubles: 3.3
Max integer: 9
Max double: 9.9
4. Advanced Examples:
String list: [Hello]
Integer list: [42]
Built person: Person{name='John Doe', age=30, email='[email protected]'}
Name-Age: Pair{Alice=25}
ID-Name: Pair{101=Bob}
Swapped: Pair{25=Alice}

Key Takeaways

1. Type Safety: Generic methods provide compile-time type checking
2. Code Reusability: Write once, use with different types
3. Type Inference: Compiler can often determine type parameters automatically
4. Bounded Types: Restrict types that can be used with extends and super
5. Wildcards: Provide flexibility in method parameters
6. Method Overloading: Generic methods can be overloaded like regular methods
7. Utility Methods: Perfect for creating reusable utility functions

Generic methods are essential for writing flexible, type-safe, and reusable code in Java, especially when working with collections and utility functions.