Join Regular Classroom : Visit ClassroomTech

JAVA – codewindow.in

/ Programming in JAVA / By

Related Topics

JAVA Programming

ArrayList<String>[] arrayOfLists = (ArrayList<String>[]) new ArrayList[10];

This code creates an array of ArrayList<String> objects with a length of 10. The cast to (ArrayList<String>[]) is necessary because Java does not allow the creation of an array of a generic type.

Accessing elements in a generic array is done in the same way as accessing elements in a regular array:

arrayOfLists[0] = new ArrayList<String>();
arrayOfLists[0].add("Hello");
String s = arrayOfLists[0].get(0);

In this example, we create a new ArrayList<String> object and assign it to the first element of the arrayOfLists array. We then add a string to the list and retrieve it using the get method.

It is important to note that using generic arrays can lead to runtime errors if not used carefully. It is recommended to use collections instead of arrays in most cases when working with generics.

List list = new ArrayList();  // raw type
List<String> list2 = new ArrayList<>();  // parameterized type

In the first line, the List is a raw type because it is used without any type arguments. This means that the compiler will not be able to perform any type checking on the elements of the list at compile-time, which can lead to errors at runtime.

In contrast, in the second line, the List<String> is a parameterized type because it is used with the type argument String. This allows the compiler to perform type checking on the elements of the list at compile-time, which can help to catch errors before the code is run.

Raw types are discouraged in Java because they can lead to runtime errors and make the code more difficult to read and maintain. In addition, the use of raw types can prevent the compiler from detecting potential errors, which can lead to bugs in the code. Therefore, it is recommended to use parameterized types whenever possible.

import java.util.*;

public class Example {
    public static void main(String[] args) {
        // Creating a List of strings
        List<String> stringList = new ArrayList<>();
        stringList.add("hello");
        stringList.add("world");
        stringList.add("!");

        // Creating a Set of integers
        Set<Integer> intSet = new HashSet<>();
        intSet.add(1);
        intSet.add(2);
        intSet.add(3);

        // Creating a Map of strings to integers
        Map<String, Integer> stringIntMap = new HashMap<>();
        stringIntMap.put("one", 1);
        stringIntMap.put("two", 2);
        stringIntMap.put("three", 3);

        // Iterating over the List and printing each element
        for (String s : stringList) {
            System.out.println(s);
        }

        // Iterating over the Set and printing each element
        for (int i : intSet) {
            System.out.println(i);
        }

        // Iterating over the Map and printing each key-value pair
        for (Map.Entry<String, Integer> entry : stringIntMap.entrySet()) {
            System.out.println(entry.getKey() + " : " + entry.getValue());
        }
    }
}

In this example, we’re using three different generic collections: List, Set, and Map. We’re able to declare the type of elements stored in each collection by using angle brackets and specifying the type parameter. This allows the compiler to perform type checking at compile time, which can help prevent type errors at runtime.

In addition to improved type safety, generic collections offer several other advantages over non-generic collections. For example:

  • They provide compile-time type checking, which can help catch errors early in the development process.

  • They eliminate the need for casting, which can improve code readability and reduce the risk of runtime errors.

  • They make it easier to write reusable code, since generic collections can work with a wide range of types.

Overall, generic collections are an important feature of Java that can help developers write more robust, flexible, and maintainable code.

class ContainerException<T> extends Exception {
    private T value;
    public ContainerException(T value) {
        this.value = value;
    }
    public T getValue() {
        return value;
    }
}

In this example, ContainerException is a generic exception that takes a type parameter T. The exception constructor takes a value of type T and stores it in a private field. The getValue method returns the value that caused the exception.

To throw a generic exception, you can create a new instance of the exception and throw it as you would with any other exception. For example:

public class Container<T> {
    private T value;
    public Container(T value) {
        this.value = value;
    }
    public void setValue(T value) throws ContainerException<T> {
        if (value == null) {
            throw new ContainerException<T>(value);
        }
        this.value = value;
    }
}

In this example, Container is a generic class that takes a type parameter T. The setValue method takes a value of type T and throws a ContainerException if the value is null.

The purpose of the Throwable class in Java is to provide a base class for all exceptions and errors. It is a generic class that takes a type parameter T. However, the Throwable class is not typically used as a generic class directly, but rather as a base class for custom exception classes.

      

Click here For Latest Job Openings
Telegram Facebook Linkedin Instagram

Click to Join:

Join Telegram
Study Material
Join Facebook
Join LinkedIn

Popular Category

Job Information
Quiz Assessment
TCS Mock Test
Data Structure / Algo
Interview Experience
Tech Mahindra

Topics for You

Go through our study material. Your Job is awaiting.

Study Material
Recent Posts
Categories