Generic Method in Java Example

The object-oriented programming language Java has a number of capabilities that help developers build adaptable, reusable, and scalable applications. Generics, a potent tool that enables programmers to construct classes, methods, and interfaces that function with many types of data, is one of the fundamental components of the Java programming language. In this section, we'll discuss about Java's generics and give a Generic method example.

Generics in Java

Java provides generics as a mechanism of parameterizing types in a class or function. It enables programmers to construct a class or method that can operate on any data type, such as strings, integers, or objects, without being aware of the precise type of the data at compile time. With less code duplication and better efficiency, this feature aids in the development of adaptable, reusable code that can be utilised with many data types.

The syntax for declaring a Generic class in Java is as follows:

class ClassName<T> {
   // class implementation
}

Here, T is a placeholder for the type of data that will be used at runtime. The placeholder T can be replaced with any valid Java identifier, such as E, K, V, etc.

Similarly, the syntax for declaring a Generic method in Java is as follows:

public <T> void methodName(T parameter) {
   // method implementation
}

Here, the <T> before the return type of the method indicates that the method is Generic and can work with any type of data. The parameter T can be replaced with any valid Java identifier.

Example of a Generic method in Java

Let's consider an example of a Generic method that takes an array of any type and returns the maximum value from the array. Here's the code for the method:

public static <T extends Comparable<T>> T findMax(T[] arr) {
   T max = arr[0];
   for (int i = 1; i < arr.length; i++) {
      if (arr[i].compareTo(max) > 0) {
         max = arr[i];
      }
   }
   return max;
}

The findMax method in this code is a generic method that accepts an array of type T and returns the array's maximum value. To compare the values in the array, the method utilises the Comparable interface.

The syntax T extends ComparableT>> before the method's return type denotes that the method is Generic and can operate on any type of data that implements the Comparable interface. The extends keyword is used to declare that the type T must be a subtype of ComparableT>.

To use this method, we can create an array of any type, such as Integer, Double, or String, and pass it as an argument to the findMax method. Here's an example of how to use the method with an array of Integer values:

Integer[] arr = {3, 5, 1, 8, 6};
Integer max = findMax(arr);
System.out.println("Maximum value in the array is: " + max);

In this code, we create an array of Integer values and pass it as an argument to the findMax method. The method returns the maximum value from the array, which is then printed to the console.

GenericMethodExample.java

public class GenericMethodExample {
    public static void main(String[] args) {
        Integer[] intArr = {3, 5, 1, 8, 6};
        Double[] doubleArr = {3.2, 5.5, 1.1, 8.7, 6.9};
        String[] stringArr = {"apple", "banana", "orange", "pear", "grape"};
        Integer maxInt = findMax(intArr);
        Double maxDouble = findMax(doubleArr);
        String maxString = findMax(stringArr);
        System.out.println("Maximum value in the Integer array is: " + maxInt);
        System.out.println("Maximum value in the Double array is: " + maxDouble);
        System.out.println("Maximum value in the String array is: " + maxString);
    }
    public static <T extends Comparable<T>> T findMax(T[] arr) {
        T max = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if (arr[i].compareTo(max) > 0) {
                max = arr[i];
            }
        }
        return max;
    }
}

Output:

Maximum value in the Integer array is: 8
Maximum value in the Double array is: 8.7
Maximum value in the String array is: pear

First, in this code, three arrays of different types-Integer, Double, and String-are created. The maximum value is then saved in a variable of the appropriate type after each array receives a call to the findMax function.

The maximum value for each array is then printed to the console. As you can see, the use of Generics allows the findMax method to function with all three kinds of arrays.

Conclusion

Java has a useful feature called generics that enables programmers to write adaptable, reusable code that can handle various kinds of data. By removing the need to write several versions of the same code for different data types, generic classes and methods assist in reducing code redundancy and enhancing efficiency.

Next TopicGetting a Range of Dates in Java

← prev next →