Java Array Generic

Creating Generic Array in Java

A collection of comparable sorts of data is kept in an array. In Java, making a generic array is challenging. The type information of an array's items is used at runtime to allocate memory. However, because of type erasing, this information is not accessible in the case of generics.

Generic classes, methods, and other constructs can be declared in Java and are type-independent. Java, however, prohibits the Array from being generic. This is because arrays in Java contain data on their constituent parts, which is utilized to allocate memory at runtime.

Generics look for type information at compile time, and no information is accessible at runtime.

Because arrays are covariant, the type information is verified at runtime. It implies that we can link an array of child types to a parent type (like String[] to Object[]).

String[] Arrayofstring = new String[24];
Object[] Arrayofobject = Arrayofstring; //No Error

There will be no compile-time errors returned by the code above. Without the concern of compilation issues, we can add more items to the aforementioned Array. But for arrays, type verification is done at runtime for each element. ArrayStoreExceptions are thrown if any errors are discovered during runtime.

Program.java

public class Program
{
	public static void main(String[] args)
	{
		String[] Arrayofstring = new String[24];
		Object[] Arrayofobject = Arrayofstring; //No Error
		Arrayofobject[0] = new Object();
		Arrayofobject[1] = new Exception();
	}
}

Output:

Instead of using generic arrays, it is advised to utilize Collection Frameworks like the List. However, we can build a generic array if we know something about the type at compile time. Let's examine the Java process for making a generic array.

Creating a Generic Array Using Object Array

We may make a generic class with an Object array to resemble a generic array. We will employ the get() and set() methods in this class. An explicit cast will be used in the get() function.

GenericArrayJava.java

import java.util.Arrays;
class GenericArrayJava<T>
{
	private Object[] Arrayofgeneric;
	GenericArrayJava(int size)
	{
		Arrayofgeneric = new Object[size];
	}	
	public T get(int index)
	{
		return (T) Arrayofgeneric[index];
	}	
	public void set(int index, T element)
	{
		Arrayofgeneric[index] = element;
	}	
	@Override
    public String toString()
	{
        return Arrays.toString(Arrayofgeneric);
    }
}
public class Demo
{
	public static void main(String[] args)
	{
		GenericArrayJava<String> Arrayofstring = new GenericArrayJava(3);
		Arrayofstring.set(0, "seven");
		Arrayofstring.set(1, "twelve");
		Arrayofstring.set(2, "twenty four");		
		GenericArrayJava<Integer> Arrayofinteger = new GenericArrayJava(3);
		Arrayofinteger.set(0, 21);
		Arrayofinteger.set(1, 12);
		Arrayofinteger.set(2, 32);		
		GenericArrayJava<Double> Arrayofdouble = new GenericArrayJava(3);
		Arrayofdouble.set(0, 21.0);
		Arrayofdouble.set(1, 12.0);
		Arrayofdouble.set(2, 32.0);		
		System.out.println("Array of Integer: " + Arrayofinteger);
		System.out.println("Array of String: " + Arrayofstring);
		System.out.println("Array of Double: " + Arrayofdouble);
	}
}

Output:

If we don't provide consumers direct access to the object array and instead utilize the get() and set() functions, the preceding strategy works just great. It should be noted that even the ArrayList stores its elements in an object array. ArrayLists cannot directly access this object array.

Creating a Generic Array Using Reflection

This method is identical to that described in the previous part. The only distinction is that the type information will be provided by the function Object(), and our Array will then be initialized using the Array.newInstance() function. The following illustrates the whole implementation.

GenericArrayJava.java

import java.lang.reflect.Array;
import java.util.Arrays;
class GenericArrayJava<T>
{
	private T[] Arrayofgeneric;
	
	GenericArrayJava(Class<T> classType, int size)
	{
		Arrayofgeneric = (T[]) Array.newInstance(classType, size);
	}	
	public T get(int index)
	{
		return Arrayofgeneric[index];
	}	
	public void set(int index, T element)
	{
		Arrayofgeneric[index] = element;
	}	
	@Override
    public String toString()
	{
        return Arrays.toString(Arrayofgeneric);
    }
}
public class Demo
{
	public static void main(String[] args)
	{
		GenericArrayJava<String> Arrayofstring = new GenericArrayJava(String.class, 3);
		Arrayofstring.set(0, "seven");
		Arrayofstring.set(1, "twelve");
		Arrayofstring.set(2, "twenty four");
		
		GenericArrayJava<Integer> Arrayofinteger = new GenericArrayJava(Integer.class, 3);
		Arrayofinteger.set(0, 21);
		Arrayofinteger.set(1, 12);
		Arrayofinteger.set(2, 32);
		
		GenericArrayJava<Double> Arrayofdouble = new GenericArrayJava(Double.class, 3);
		Arrayofdouble.set(0, 21.0);
		Arrayofdouble.set(1, 12.0);
		Arrayofdouble.set(2, 32.0);
		
		System.out.println("Array of Integer: " + Arrayofinteger);
		System.out.println("Array of String: " + Arrayofstring);
		System.out.println("Array of Double: " + Arrayofdouble);
	}
}

Output:

Conclusion

Generic classes can be used to implement generic arrays in Java. We can allow the user to interact with this generic Array using an Object array and the proper methods. The ArrayList class likewise employs the idea of an object array. We can also have the user supply the type information to the function Object() using the Array.newInstance() function. Generic methods of other Collections, like the LinkedList, take a similar tack. It is often advised to utilize array lists or linked lists rather than building our generic lists.