Java Array Generic

Arrays in Java are basic data structures used to store and manipulate collections of objects of the same type. The limitation of arrays in Java, however, is that they inherently cannot store objects. This limitation can be overcome by using a normal setting. Java introduced generics in Java 5 (also known as Java SE 5) to provide compile time type protection for collections. The concept of generics allows us to define classes, interfaces, and methods that can operate on a variety of data types while maintaining type safety. Generics enable us to create parameterized types, which are classes or interfaces that can be used with different data types. When it comes to arrays, generics allow you to create arrays that can store any type of element. We can use the type parameter feature of generics to do this. Here is an example of how to create a generic array in Java:

public class GenericArray<T> {
    private T[] array;
public GenericArray(int size) {
        // Create an array of type T using type erasure
        array = (T[]) new Object[size];
    }
 public void set(int index, T value) {
        array[index] = value;
    }
public T get(int index) {
        return array[index];
    }
public static void main(String[] args) {
        GenericArray<String> stringArray = new GenericArray<>(5);
        stringArray.set(0, "Hello");
        stringArray.set(1, "World");
        String str = stringArray.get(0) + " " + stringArray.get(1);
        System.out.println(str);  // Output: Hello World
        GenericArray<Integer> intArray = new GenericArray<>(3);
        intArray.set(0, 10);
        intArray.set(1, 20);
        intArray.set(2, 30);
        int sum = intArray.get(0) + intArray.get(1) + intArray.get(2);
        System.out.println(sum);  // Output: 60
    }
}

Output:

Hello World
60

Explanation:

The GenericArray<String> object stringArray is created with size 5 .
The set() method is used to set the values at indexes 0 and 1 of the stringArray with the strings "Hello" and "World".
The get() method retrieves the value from indices 0 and 1 of the stringArray.
The concatenated string str variable is assigned "Hello" and "World".
The str value is printed, resulting in: Hello World.
The GenericArray<Integer> object intArray is created with size 3 .
The set() method is used to set values at indices 0, 1, and 2 of an intArray of 10, 20, and 30 integers, respectively.
The get() method retrieves the values of indices 0, 1, and 2 of the intArray.
The values are summed and assigned to all variables.
The cumulative value is printed, producing the result: 60 .

Array Creation and Type Deletion:

If we are creating a generic array, you will get a warning about unchecked or unsafe functions due to type deletion. Type erasure is the process in Java where type parameters are replaced with their upper bounds or deleted entirely to ensure compatibility with pre-generics code. In the example code given earlier, the line (T[]) throws another unsigned Object[size]. Compiling this code can cause a runtime error if the array is incorrectly typed.

Limitations of generic arrays:

Generic arrays in Java have a few limitations due to type erasure. One important limitation is that you cannot create arrays of concrete generic types directly. For example, the following code will generate a compile-time error:

To overcome this limitation, we can write a program Objects and cast them into generic types as shown in the previous example.

Wildcard and restricted type parameters:

When working with normal arrays, you can also use wildcard and bounded type parameters. Wildcards allow you to work with unknown types or create more flexible generic arrays. For example, we can define a generic array that accepts any subtype of a particular class or interface:

public class GenericArray<T extends Number> {
    // ...
}

Generic array advantages:

Java provides a variety of utility classes and methods for working with arrays, including generic arrays. The java.util.Arrays class provides several static methods for modifying and searching arrays. These methods can also be used in normal arrays. For example, the sort() method can be used to sort a generic array in ascending order.

GenericArray<Integer> intArray = new GenericArray<>(5);
// Add elements to intArray...
Arrays.sort(intArray.getArray());

Generic arrays in Java enable flexible and reusable data structures that can handle a variety of types. However, due to type erasure, it is important to be careful when working with generic arrays to avoid runtime errors, and to ensure proper type checking.

Next TopicJava Program to Demonstrate the Lazy Initialization Non-Thread-Safe

← prev next →