{"id":1022,"date":"2023-08-24T01:37:23","date_gmt":"2023-08-24T01:37:23","guid":{"rendered":"https:\/\/www.w3computing.com\/articles\/?p=1022"},"modified":"2023-08-24T01:37:27","modified_gmt":"2023-08-24T01:37:27","slug":"java-generics-basic-advanced","status":"publish","type":"post","link":"https:\/\/www.w3computing.com\/articles\/java-generics-basic-advanced\/","title":{"rendered":"Mastering Java Generics: From Basic to Advanced"},"content":{"rendered":"\n

Introduction<\/h2>\n\n\n\n

Java has undergone numerous evolutions since its inception in the mid-’90s. Its adaptability and commitment to improvement have been some of the pivotal reasons for its widespread adoption. One such significant improvement was the introduction of Generics in Java 5.0.<\/p>\n\n\n\n

Brief History and Need for Java Generics<\/h3>\n\n\n\n

Before the arrival of Generics, Java developers often used the collections (like ArrayList<\/code> or HashMap<\/code>) to store and manage objects. However, these collections had a drawback: they could hold any type of object. This lack of type-safety meant that runtime type-casting was common, leading to potential runtime errors due to incorrect casting.<\/p>\n\n\n\n

Imagine pouring a mix of liquids\u2014water, juice, milk\u2014into the same container. When you need a glass of milk, you’d have to carefully pick through the mix to ensure you only get milk, and even then, there\u2019s a risk of contamination. This was the world of Java without Generics.<\/p>\n\n\n\n

Enter Generics in Java 5.0. The addition allowed developers to provide a type parameter to collections, ensuring type safety. Using our previous analogy, it was like having labeled containers for each liquid. If you wanted a glass of milk, you\u2019d go to the milk container. This ensured not only ease but also safety, as the risk of contamination reduced drastically.<\/p>\n\n\n\n

Generics brought about a type-safe environment, reducing the need for runtime type checking and casts, leading to more robust and maintainable code.<\/p>\n\n\n\n

Overview of the Tutorial<\/h3>\n\n\n\n

As we progress in this tutorial, we will go deep into Java Generics. From understanding the basic concepts of Generic Classes, Methods, and Interfaces, we will explore advanced topics like Bounded Type Parameters, Wildcards, and Type Erasure. Each section will be accompanied by practical code examples, ensuring that you not only grasp the theoretical knowledge but also the practical application of Generics in real-world scenarios.<\/p>\n\n\n\n

Why Use Generics?<\/h2>\n\n\n\n

The introduction of Generics in Java was not just a sophisticated language feature meant to impress developers. It was introduced as a solution to real-world challenges Java developers faced in their coding journey. Let’s break down the core reasons for using Generics.<\/p>\n\n\n\n

Code Safety with Type Checks<\/h3>\n\n\n\n

Without Generics, Java collections stored objects of the type Object<\/code>. This meant that a developer could inadvertently insert an unwanted type into a collection, leading to potential issues later on.<\/p>\n\n\n\n

With Generics, we can specify the exact type of elements a collection can hold. This is done at compile-time, ensuring that any violations of this rule are flagged immediately. For instance:<\/p>\n\n\n

List<String> names = new<\/span> ArrayList<>();\r\nnames.add(\"John\"<\/span>);   \/\/ Allowed<\/span>\r\nnames.add(123<\/span>);      \/\/ Compile-time error<\/span><\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
In the above code, trying to add an integer to a list declared to hold strings results in a compile-time error. This immediate feedback means developers can address issues before the code even runs.<\/p>\n\n\n\n
Reduction of Runtime Errors and Casts<\/h3>\n\n\n\n
Prior to Generics, retrieving data from collections often required casting. If you made an error in casting, it would result in a runtime exception:<\/p>\n\n\n
List names = new<\/span> ArrayList();\r\nnames.add(\"John\"<\/span>);\r\nString name = (String) names.get(0<\/span>);   \/\/ Requires casting<\/span>\r\nInteger num = (Integer) names.get(0<\/span>);  \/\/ Runtime exception<\/span><\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
With Generics, the need for casting is eliminated because the compiler knows the type of elements in the collection:<\/p>\n\n\n
List<String<\/span>> names = new<\/span> ArrayList<>();\r\nnames.add(\"John\"<\/span>);\r\nString<\/span> name = names.get(0<\/span>);  \/\/ No casting required<\/span><\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
This not only reduces the risk of ClassCastException<\/code> at runtime but also makes the code cleaner.<\/p>\n\n\n\n
More Readable and Maintainable Code<\/h3>\n\n\n\n
Code clarity is essential for maintainability. With Generics, by merely looking at the code, a developer can instantly understand the type of data structures and their elements, leading to quicker comprehension of the code’s function.<\/p>\n\n\n\n
Consider two method signatures:<\/p>\n\n\n
public<\/span> void<\/span> processData<\/span>(List data)<\/span> <\/span>{...}\r\npublic<\/span> void<\/span> processData<\/span>(List<Student> data)<\/span> <\/span>{...}<\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
The latter, with Generics, immediately conveys that the method is designed to process a list of Student<\/code> objects, making the code more self-explanatory.<\/p>\n\n\n\n
Moreover, as projects grow, ensuring that data structures are used consistently becomes paramount. Generics assists in enforcing this consistency, making the codebase more maintainable in the long run.<\/p>\n\n\n\n
Basic Concepts of Generics<\/h2>\n\n\n\n
Generic Classes<\/h3>\n\n\n\n
Generic classes allow you to define a class with one or more type parameters. These type parameters act as placeholders that are later replaced with actual types when an object of the generic class is created. Let’s dive into understanding them better.<\/p>\n\n\n\n
Code Example: Creating a Simple Generic Class<\/h4>\n\n\n\n
Consider a scenario where you want a class to hold a pair of objects, but you don\u2019t want to restrict the types of objects that can be paired. Here’s how you can achieve this using a generic class:<\/p>\n\n\n
public<\/span> class<\/span> Pair<\/span><T1<\/span>, T2<\/span>> <\/span>{\r\n    private<\/span> T1 first;\r\n    private<\/span> T2 second;\r\n\r\n    public<\/span> Pair<\/span>(T1 first, T2 second)<\/span> <\/span>{\r\n        this<\/span>.first = first;\r\n        this<\/span>.second = second;\r\n    }\r\n\r\n    public<\/span> T1 getFirst<\/span>()<\/span> <\/span>{\r\n        return<\/span> first;\r\n    }\r\n\r\n    public<\/span> T2 getSecond<\/span>()<\/span> <\/span>{\r\n        return<\/span> second;\r\n    }\r\n\r\n    public<\/span> void<\/span> setFirst<\/span>(T1 first)<\/span> <\/span>{\r\n        this<\/span>.first = first;\r\n    }\r\n\r\n    public<\/span> void<\/span> setSecond<\/span>(T2 second)<\/span> <\/span>{\r\n        this<\/span>.second = second;\r\n    }\r\n}\r\n\r\n\/\/ Usage:<\/span>\r\nPair<String, Integer> nameAndAge = new<\/span> Pair<>(\"John\"<\/span>, 25<\/span>);\r\nString name = nameAndAge.getFirst();\r\nInteger age = nameAndAge.getSecond();<\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
In the above code, Pair<\/code> is a generic class with two type parameters: T1<\/code> and T2<\/code>. When creating an instance of Pair<\/code>, you specify the types for T1<\/code> and T2<\/code>, which in this case are String<\/code> and Integer<\/code>, respectively.<\/p>\n\n\n\n
Advantages of Using Generic Classes<\/h4>\n\n\n\n
    \n
  1. Type Safety<\/strong>: The primary advantage of generic classes is type safety. As seen in the Pair<\/code> example, once the types are set for the object, any attempt to use the wrong types will result in a compile-time error. This can save developers from runtime exceptions and potential bugs.<\/li>\n\n\n\n
  2. Reusability<\/strong>: One of the significant benefits of generic classes is code reusability. Rather than creating separate classes for each type, you can define a single generic class that works with different types.<\/li>\n\n\n\n
  3. Elimination of Casts<\/strong>: Without generics, you’d have to use casting when retrieving objects from classes that hold general object types. With generic classes, the need for casting is eliminated, making the code cleaner and safer.<\/li>\n\n\n\n
  4. Self-Documenting<\/strong>: When you look at a generic class’s usage in code, you instantly understand what types it operates upon. For example, Pair<String, Integer><\/code> immediately tells you that the Pair<\/code> object holds a String<\/code> and an Integer<\/code>.<\/li>\n<\/ol>\n\n\n\n
    Generic Methods<\/h3>\n\n\n\n
    While generic classes allow you to abstract a whole class with a type parameter, sometimes, you might only need to make a single method generic, irrespective of the class. This is where generic methods come in.<\/p>\n\n\n\n
    Code Example: Writing a Generic Method<\/h4>\n\n\n\n
    Let’s consider you want to write a utility method that swaps the positions of two elements in an array. Here’s how you can create such a method using generics:<\/p>\n\n\n
    public<\/span> class<\/span> Utility<\/span> <\/span>{\r\n\r\n    public<\/span> static<\/span> <T> void<\/span> swap<\/span>(T[] array, int<\/span> pos1, int<\/span> pos2)<\/span> <\/span>{\r\n        if<\/span> (pos1 < 0<\/span> || pos1 >= array.length || pos2 < 0<\/span> || pos2 >= array.length) {\r\n            throw<\/span> new<\/span> IllegalArgumentException(\"Position out of bounds!\"<\/span>);\r\n        }\r\n        \r\n        T temp = array[pos1];\r\n        array[pos1] = array[pos2];\r\n        array[pos2] = temp;\r\n    }\r\n}<\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
    In the method signature, <T><\/code> indicates that swap<\/code> is a generic method. It operates on an array of any type T<\/code>. The method then swaps the elements at the specified positions. Note that this method can work for arrays of any object type, like Integer<\/code>, String<\/code>, or custom objects.<\/p>\n\n\n\n
    How to Call a Generic Method<\/h4>\n\n\n\n
    While Java’s compiler is often smart enough to infer the type arguments when calling a generic method (this is known as type inference), you can also explicitly provide the type if required. Here’s how:<\/p>\n\n\n\n
    Using Type Inference<\/h3>\n\n\n\n
    Given the earlier swap<\/code> method, if you have an Integer<\/code> array and you want to swap two elements, you simply call:<\/p>\n\n\n
    Integer[] numbers = {1<\/span>, 2<\/span>, 3<\/span>, 4<\/span>, 5<\/span>};\r\nUtility.swap(numbers, 1<\/span>, 3<\/span>); \/\/ swaps the numbers at positions 1 and 3<\/span><\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
    The compiler will infer the type T<\/code> to be Integer<\/code>.<\/p>\n\n\n\n
    Explicitly Providing the Type<\/h4>\n\n\n\n
    Although not necessary in many cases, you can provide the type explicitly using the diamond (<><\/code>) operator:<\/p>\n\n\n
    String[] words = {\"apple\"<\/span>, \"banana\"<\/span>, \"cherry\"<\/span>};\r\nUtility.<String>swap(words, 0<\/span>, 2<\/span>); \/\/ swaps \"apple\" and \"cherry\"<\/span>\r<\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
    Here, we’re explicitly telling the compiler that we’re calling the swap<\/code> method with type String<\/code>.<\/p>\n\n\n\n
    Generic Interfaces<\/h4>\n\n\n\n
    Just like classes and methods, interfaces in Java can also be generic. This means you can specify one or more type parameters when declaring an interface. This can be particularly useful when designing APIs that need flexibility across a range of types.<\/p>\n\n\n\n
    Code Example: Implementing a Generic Interface<\/h4>\n\n\n\n
    Let’s create a simple generic interface named Comparator<\/code>, which determines the ordering between two objects of the same type:<\/p>\n\n\n
    \/\/ Generic interface<\/span>\r\npublic<\/span> interface<\/span> Comparator<\/span><T<\/span>> <\/span>{\r\n    \/**\r\n     * Compares two objects and returns:\r\n     * - A negative integer if obj1 is less than obj2\r\n     * - Zero if obj1 is equal to obj2\r\n     * - A positive integer if obj1 is greater than obj2\r\n     *\/<\/span>\r\n    int<\/span> compare<\/span>(T obj1, T obj2)<\/span><\/span>;\r\n}<\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
    Now, let’s implement this interface for a Person<\/code> class, where the comparison is based on their age:<\/p>\n\n\n
    public<\/span> class<\/span> Person<\/span> <\/span>{\r\n    private<\/span> String name;\r\n    private<\/span> int<\/span> age;\r\n\r\n    public<\/span> Person<\/span>(String name, int<\/span> age)<\/span> <\/span>{\r\n        this<\/span>.name = name;\r\n        this<\/span>.age = age;\r\n    }\r\n\r\n    public<\/span> int<\/span> getAge<\/span>()<\/span> <\/span>{\r\n        return<\/span> age;\r\n    }\r\n    \r\n    \/\/ More methods for Person class...<\/span>\r\n}\r\n\r\npublic<\/span> class<\/span> PersonAgeComparator<\/span> implements<\/span> Comparator<\/span><Person<\/span>> <\/span>{\r\n\r\n    @Override<\/span>\r\n    public<\/span> int<\/span> compare<\/span>(Person p1, Person p2)<\/span> <\/span>{\r\n        return<\/span> Integer.compare(p1.getAge(), p2.getAge());\r\n    }\r\n}\r<\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
    In the example above, the Comparator<\/code> interface is generic, allowing for the comparison of any two objects of the same type. By implementing this interface in PersonAgeComparator<\/code>, we provide a specific comparison strategy for Person<\/code> objects based on their age.<\/p>\n\n\n\n
    You could further implement more comparators for the Person<\/code> class, perhaps based on name, height, or any other attribute, without altering the original Comparator<\/code> interface definition.<\/p>\n\n\n\n
    Bounded Type Parameters<\/h2>\n\n\n\n
    Upper Bounded Wildcards (extends<\/code> keyword)<\/h3>\n\n\n\n
    In Java generics, wildcards enable more flexibility in using generic types, especially when dealing with inheritance and interfaces. The keyword extends<\/code> is employed not only for classes but for interfaces as well, providing an upper bound to the wildcard.<\/p>\n\n\n\n
    Upper Bounded Wildcards specify a bound for the unknown type, allowing it to accept types that are a subtype of the specified bound.<\/p>\n\n\n\n
    Code Example: Limiting Types with Upper Bounds<\/h4>\n\n\n\n
    Suppose you have a series of number classes like Integer<\/code>, Double<\/code>, etc., and you want a method that computes the sum of a list of any of these numeric types:<\/p>\n\n\n
    public<\/span> static<\/span> <T extends Number> double<\/span> sumOfList<\/span>(List<T> list)<\/span> <\/span>{\r\n    double<\/span> sum = 0.0<\/span>;\r\n    for<\/span> (T num : list) {\r\n        sum += num.doubleValue();\r\n    }\r\n    return<\/span> sum;\r\n}<\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
    The Number<\/code> class is a part of Java’s standard library, and classes like Integer<\/code>, Double<\/code>, Float<\/code>, etc., are all subclasses of Number<\/code>. This method takes a list of any subtype of Number<\/code> and calculates the sum.<\/p>\n\n\n\n
    Usage:<\/p>\n\n\n
    List<Integer> intList = Arrays.asList(1<\/span>, 2<\/span>, 3<\/span>, 4<\/span>, 5<\/span>);\r\nSystem.out.println(sumOfList(intList));  \/\/ Outputs: 15.0<\/span>\r\n\r\nList<Double> doubleList = Arrays.asList(1.1<\/span>, 2.2<\/span>, 3.3<\/span>);\r\nSystem.out.println(sumOfList(doubleList));  \/\/ Outputs: 6.6<\/span><\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
    In the above method, the <T extends Number><\/code> syntax signifies that the method accepts lists of any type T<\/code>, as long as T<\/code> is a subtype of Number<\/code> (i.e., either Number<\/code> itself or a subclass of Number<\/code>).<\/p>\n\n\n\n
    By using an upper bounded wildcard, we’ve limited the kind of lists the sumOfList<\/code> method can accept, ensuring type safety, while still allowing a certain degree of flexibility.<\/p>\n\n\n\n
    Lower Bounded Wildcards (super<\/code> keyword)<\/h3>\n\n\n\n
    While the upper bounded wildcard restricts unknown types to a particular type or a subtype of that type, the lower bounded wildcard does the opposite. It restricts the unknown type to be a particular type or a super type<\/strong> of that type.<\/p>\n\n\n\n
    Lower Bounded Wildcards come into play when you want to ensure that an object is an instance of a certain class or its parent classes. The super<\/code> keyword is used for setting the lower bound.<\/p>\n\n\n\n
    Code Example: Using Lower Bounds<\/h4>\n\n\n\n
    Consider you have a method that inserts elements into a list, and you want this method to accept lists of a type or its super types. Here’s a scenario with a simple class hierarchy:<\/p>\n\n\n
    class<\/span> Animal<\/span> <\/span>{}\r\nclass<\/span> Bird<\/span> extends<\/span> Animal<\/span> <\/span>{}\r\nclass<\/span> Sparrow<\/span> extends<\/span> Bird<\/span> <\/span>{}\r\n\r\npublic<\/span> static<\/span> <T> void<\/span> addBirds<\/span>(List<? super<\/span> Bird> list)<\/span> <\/span>{\r\n    list.add(new<\/span> Bird());\r\n    list.add(new<\/span> Sparrow());\r\n}<\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
    The addBirds<\/code> method is defined to accept a list of any type that is a super type of Bird<\/code> (including Bird<\/code> itself). This means you can pass in a List<Bird><\/code>, List<Animal><\/code>, but not a List<Sparrow><\/code>.<\/p>\n\n\n\n
    Usage:<\/p>\n\n\n
    List<Animal> animalList = new<\/span> ArrayList<>();\r\naddBirds(animalList);\r\n\/\/ animalList now contains instances of Bird and Sparrow<\/span>\r\n\r\nList<Bird> birdList = new<\/span> ArrayList<>();\r\naddBirds(birdList);\r\n\/\/ birdList also contains instances of Bird and Sparrow<\/span>\r\n\r\nList<Sparrow> sparrowList = new<\/span> ArrayList<>();\r\n\/\/ addBirds(sparrowList);  \/\/ Compile-time error!<\/span><\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
    In the above example, the lower bounded wildcard ? super Bird<\/code> ensures that the list passed to addBirds<\/code> can safely hold instances of Bird<\/code> and any subclass of Bird<\/code> (like Sparrow<\/code>). This enforces type safety in such a way that you can’t accidentally insert a Bird<\/code> into a list that is designed to hold only specific subtypes of Bird<\/code>.<\/p>\n\n\n\n
    Multiple Bounds<\/h3>\n\n\n\n
    In Java, type parameters can be bounded by multiple constraints. This allows for a type parameter to be restricted to subtypes of multiple types. The syntax for multiple bounds involves using the extends<\/code> keyword followed by the type bounds separated by &<\/code>.<\/p>\n\n\n\n
    Multiple Bounds come into play when you want a generic type to adhere to multiple type constraints. This is especially useful when combining class and interface constraints.<\/p>\n\n\n\n
    Code Example: Combining Bounds<\/h4>\n\n\n\n
    Suppose you want a generic method to sort elements based on their natural ordering (Comparable<\/code>) and at the same time, you want to ensure that they are serializable. Here’s how you can do this:<\/p>\n\n\n
    public<\/span> class<\/span> Utils<\/span> <\/span>{\r\n\r\n    public<\/span> static<\/span> <T extends Comparable<T> & Serializable> void<\/span> sortAndSave<\/span>(List<T> list, File file)<\/span> <\/span>{\r\n        Collections.sort(list);\r\n        \r\n        try<\/span> (ObjectOutputStream out = new<\/span> ObjectOutputStream(new<\/span> FileOutputStream(file))) {\r\n            for<\/span> (T item : list) {\r\n                out.writeObject(item);\r\n            }\r\n        } catch<\/span> (IOException e) {\r\n            e.printStackTrace();\r\n        }\r\n    }\r\n}<\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
    In this example, the method sortAndSave<\/code> has a type parameter T<\/code> that extends both Comparable<T><\/code> and Serializable<\/code>. This ensures:<\/p>\n\n\n\n
      \n
    1. You can sort the list since T<\/code> is Comparable<\/code>.<\/li>\n\n\n\n
    2. You can serialize each item in the list to a file since T<\/code> is Serializable<\/code>.<\/li>\n<\/ol>\n\n\n\n
      Usage:<\/p>\n\n\n
      List<String> names = Arrays.asList(\"Alice\"<\/span>, \"Bob\"<\/span>, \"Charlie\"<\/span>);\r\nFile file = new<\/span> File(\"sortedNames.dat\"<\/span>);\r\nUtils.sortAndSave(names, file);  \/\/ This works since String implements Comparable and Serializable<\/span><\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
      In the case of multiple bounds, if one of the bounds is a class, it must be specified first. This is important to note since Java doesn’t support multiple class inheritance, but a class can implement multiple interfaces.<\/p>\n\n\n\n
      Wildcards in Generics<\/h2>\n\n\n\n
      The Unbounded Wildcard (?<\/code> keyword)<\/h3>\n\n\n\n
      In Java generics, the unbounded wildcard (?<\/code>) is a type argument that stands for an unknown type. It’s especially useful when you need to work with generic objects but don’t know or don’t care about their actual type.<\/p>\n\n\n\n
      The Unbounded Wildcard is denoted by the ?<\/strong><\/code> symbol and means that the type is unknown. It provides maximum flexibility but can also restrict certain operations since you don’t know the type of objects contained within the generic structure.<\/p>\n\n\n\n
      Code Example: Working with Raw Types<\/h4>\n\n\n\n
      Consider you want to create a method that prints out the elements of any list, regardless of the list’s type:<\/p>\n\n\n
      public<\/span> static<\/span> void<\/span> printList<\/span>(List<?> list)<\/span> <\/span>{\r\n    for<\/span> (Object obj : list) {\r\n        System.out.println(obj);\r\n    }\r\n}<\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
      Here, List<?><\/code> denotes a list of an unknown type. It can be a List<String><\/code>, List<Integer><\/code>, or a List<\/code> of any other type.<\/p>\n\n\n\n
      Usage:<\/p>\n\n\n
      List<String> names = Arrays.asList(\"Alice\"<\/span>, \"Bob\"<\/span>, \"Charlie\"<\/span>);\r\nprintList(names);  \/\/ Outputs: Alice, Bob, Charlie<\/span>\r\n\r\nList<Integer> numbers = Arrays.asList(1<\/span>, 2<\/span>, 3<\/span>, 4<\/span>, 5<\/span>);\r\nprintList(numbers);  \/\/ Outputs: 1, 2, 3, 4, 5<\/span><\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
      While the unbounded wildcard provides flexibility, there are limitations. For instance, you can’t add elements to the list within the printList<\/code> method because the type is unknown. The only exception is null<\/code>, which is a member of every type:<\/p>\n\n\n
      public<\/span> static<\/span> void<\/span> addNull<\/span>(List<?> list)<\/span> <\/span>{\r\n    list.add(null<\/span>);  \/\/ This is valid<\/span>\r\n    \/\/ list.add(new Object());  \/\/ This would be a compile-time error<\/span>\r\n}<\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
      Comparing Bounded and Unbounded Wildcards<\/h3>\n\n\n\n
      Both bounded and unbounded wildcards offer flexibility in dealing with generics in Java. However, they serve different purposes and are best suited for different scenarios. Let’s dissect the differences and delve into practical scenarios where each might be the preferred choice.<\/p>\n\n\n\n
      Bounded Wildcards:<\/h4>\n\n\n\n
        \n
      1. Purpose<\/strong>: Bounded wildcards (both upper and lower bounded) are used when you have some knowledge about the type parameter and want to restrict it to a certain range of types.<\/li>\n\n\n\n
      2. Advantages<\/strong>:\n
          \n
        • Ensures type safety by constraining the type parameter.<\/li>\n\n\n\n
        • Provides flexibility within the specified bounds.<\/li>\n<\/ul>\n<\/li>\n\n\n\n
        • Practical Scenarios<\/strong>:\n
            \n
          • Upper Bounded Wildcards (extends<\/code>)<\/strong>: When you need to read items from a structure and use methods defined in the upper bound. For instance, reading numbers from a list and performing arithmetic operations.<\/li>\n\n\n\n
          • Lower Bounded Wildcards (super<\/code>)<\/strong>: Useful when you need to insert items into a structure. For example, when inserting elements into a list where you want to ensure that the list can hold the type of element you’re inserting.<\/li>\n<\/ul>\n<\/li>\n<\/ol>\n\n\n\n
            Unbounded Wildcards:<\/h4>\n\n\n\n
              \n
            1. Purpose<\/strong>: The unbounded wildcard denotes an unknown type. It’s typically used when you want to work with objects in a generic way without needing specifics about their type.<\/li>\n\n\n\n
            2. Advantages<\/strong>:\n
                \n
              • Maximizes flexibility as it can represent any type.<\/li>\n\n\n\n
              • Bridges the gap between generic and non-generic code.<\/li>\n<\/ul>\n<\/li>\n\n\n\n
              • Practical Scenarios<\/strong>:\n
                  \n
                • General-purpose methods<\/strong>: Useful for methods that can work with any type, like printing elements of a list or clearing its contents.<\/li>\n\n\n\n
                • Interacting with raw types<\/strong>: In legacy code, you might come across raw types. Unbounded wildcards can help smooth interactions between raw types and generic methods.<\/li>\n\n\n\n
                • When type specifics don’t matter<\/strong>: For instance, if you just want to count the number of items, reset a collection, or test if an item exists in a collection.<\/li>\n<\/ul>\n<\/li>\n<\/ol>\n\n\n\n
                  Choosing One Over the Other:<\/h4>\n\n\n\n
                    \n
                  1. For Read-Only Operations<\/strong>:\n
                      \n
                    • Use an upper bounded wildcard<\/strong> if you are reading items from a structure and need to invoke methods defined in its upper bound.<\/li>\n\n\n\n
                    • Use an unbounded wildcard<\/strong> if you’re reading items but don’t care about their specific type.<\/li>\n<\/ul>\n<\/li>\n\n\n\n
                    • For Write Operations<\/strong>:\n
                        \n
                      • Use a lower bounded wildcard<\/strong> if you’re inserting items and want to ensure type safety.<\/li>\n\n\n\n
                      • Generally, avoid using unbounded wildcards for writes, as you don’t have information about the type.<\/li>\n<\/ul>\n<\/li>\n\n\n\n
                      • For Maximum Flexibility<\/strong>: An unbounded wildcard provides the most flexibility but comes at the cost of losing type-specific operations.<\/li>\n<\/ol>\n\n\n\n
                        In essence, the choice between bounded and unbounded wildcards boils down to your specific needs. If type safety within certain constraints is paramount, bounded wildcards are your best bet. For operations that are truly type-agnostic, unbounded wildcards shine. Always ensure you maintain a balance between flexibility and type safety, choosing the wildcard that aligns best with the operations you intend to perform.<\/p>\n\n\n\n
                        Generic Erasure<\/strong><\/p>\n\n\n\n
                        One of the fundamental aspects of Java generics that often surprises newcomers is the concept of type erasure. In essence, generics are a compile-time construct, meaning that most generic type information is removed when the code is translated to bytecode.<\/p>\n\n\n\n
                        Understanding Type Erasure in Java:<\/h3>\n\n\n\n
                        Java generics were introduced in Java 5 to improve type safety and to provide more robust type checking at compile time. However, the designers wanted to ensure backward compatibility with existing non-generic code. To achieve this, they introduced generics in such a way that the bytecode remains the same whether you’re using raw types or generics. This is facilitated through a mechanism called type erasure<\/strong>.<\/p>\n\n\n\n
                        During the compilation process:<\/p>\n\n\n\n
                          \n
                        1. The compiler checks the code for correct use of generics and inserts type casts where necessary.<\/li>\n\n\n\n
                        2. It then removes (or “erases”) all the generic type information, replacing it with raw types.<\/li>\n<\/ol>\n\n\n\n
                          Code Examples: Before and After Type Erasure<\/h3>\n\n\n\n
                          Before Type Erasure<\/strong>:<\/p>\n\n\n
                          public<\/span> class<\/span> Box<\/span><T<\/span>> <\/span>{\r\n    private<\/span> T value;\r\n\r\n    public<\/span> Box<\/span>(T value)<\/span> <\/span>{\r\n        this<\/span>.value = value;\r\n    }\r\n\r\n    public<\/span> T getValue<\/span>()<\/span> <\/span>{\r\n        return<\/span> value;\r\n    }\r\n}<\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
                          After Type Erasure<\/strong>:<\/p>\n\n\n
                          public<\/span> class<\/span> Box<\/span> <\/span>{\r\n    private<\/span> Object value;\r\n\r\n    public<\/span> Box<\/span>(Object value)<\/span> <\/span>{\r\n        this<\/span>.value = value;\r\n    }\r\n\r\n    public<\/span> Object getValue<\/span>()<\/span> <\/span>{\r\n        return<\/span> value;\r\n    }\r\n}<\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
                          Notice how the generic type T<\/code> has been replaced with Object<\/code> post type erasure.<\/p>\n\n\n\n
                          Limitations and Implications of Type Erasure:<\/h3>\n\n\n\n
                          No Runtime Type Information<\/strong>: Because of type erasure, generic type information is unavailable at runtime. This means that you cannot use reflection to find out the actual type argument of a generic type.<\/p>\n\n\n
                          List<String> strings = new<\/span> ArrayList<>();\r\nif<\/span> (strings instanceof<\/span> List<String>) {  \/\/ Compile-time error<\/span>\r\n    \/\/ Cannot perform instanceof check with parameterized types.<\/span>\r\n}<\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
                          Cannot Create Instances of Type Parameters<\/strong>: You can’t instantiate an object of a type parameter since it’s erased at runtime.<\/p>\n\n\n
                          public<\/span> <T> void<\/span> createInstance<\/span>()<\/span> <\/span>{\r\n    T obj = new<\/span> T();  \/\/ Compile-time error<\/span>\r\n}<\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
                          Limitations with Overloaded Methods<\/strong>: Overloading methods based on generic types can lead to issues because of type erasure. After erasure, overloaded methods can have the same raw type, leading to a compile-time error.<\/p>\n\n\n
                          public<\/span> void<\/span> process<\/span>(List<String> list)<\/span> <\/span>{ ... }\r\npublic<\/span> void<\/span> process<\/span>(List<Integer> list)<\/span> <\/span>{ ... }  \/\/ Compile-time error due to type erasure<\/span>\r<\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
                          Casts Are Inserted<\/strong>: The compiler inserts casts in the bytecode where needed. This means that even though you’re not explicitly casting objects in your generic code, casts are present in the bytecode.<\/p>\n\n\n\n
                          Backward Compatibility<\/strong>: One of the major benefits of type erasure is that it ensures backward compatibility. Non-generic code written before Java 5 can work seamlessly with generic code.<\/p>\n\n\n\n
                          While type erasure has its set of limitations and implications, it’s a necessary compromise to introduce strong type checking with generics while preserving backward compatibility. Being aware of how type erasure operates can prevent potential pitfalls when working with generics in Java.<\/p>\n\n\n\n
                          Advanced Techniques with Generics<\/h2>\n\n\n\n
                          Recursive Type Bounds<\/h3>\n\n\n\n
                          Recursive type bounds provide the capability for a type to be defined in terms of itself. This is particularly useful in scenarios where a type parameter in a generic class or method is bound by another type that is parameterized by the first type.<\/p>\n\n\n\n
                          Implementing a Self-Comparable Interface:<\/h4>\n\n\n\n
                          Imagine a scenario where you’re building a framework for entities that can compare themselves to objects of their own type. Here’s how recursive type bounds come into play:<\/p>\n\n\n\n
                          Self-Comparable Interface<\/strong>:<\/p>\n\n\n
                          public<\/span> interface<\/span> SelfComparable<\/span><T<\/span> extends<\/span> SelfComparable<\/span><T<\/span>>> <\/span>{\r\n    int<\/span> compareTo<\/span>(T other)<\/span><\/span>;\r\n}<\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
                          In the SelfComparable<\/code> interface, T<\/code> is a type parameter that extends SelfComparable<T><\/code>. This effectively ensures that any type which claims to be SelfComparable<\/code> must compare itself to its own type.<\/p>\n\n\n\n
                          Implementing the Self-Comparable Interface<\/strong>:<\/p>\n\n\n\n
                          Now, let’s create a Person<\/code> class that implements this interface:<\/p>\n\n\n
                          public<\/span> class<\/span> Person<\/span> implements<\/span> SelfComparable<\/span><Person<\/span>> <\/span>{\r\n    private<\/span> final<\/span> String name;\r\n    private<\/span> final<\/span> int<\/span> age;\r\n\r\n    public<\/span> Person<\/span>(String name, int<\/span> age)<\/span> <\/span>{\r\n        this<\/span>.name = name;\r\n        this<\/span>.age = age;\r\n    }\r\n\r\n    @Override<\/span>\r\n    public<\/span> int<\/span> compareTo<\/span>(Person other)<\/span> <\/span>{\r\n        return<\/span> Integer.compare(this<\/span>.age, other.age);\r\n    }\r\n}<\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
                          In the Person<\/code> class, we’ve implemented the SelfComparable<\/code> interface specifying Person<\/code> as the type parameter. The compareTo<\/code> method is then implemented to compare Person<\/code> objects based on their age.<\/p>\n\n\n\n
                          Usage:<\/p>\n\n\n
                          Person alice = new<\/span> Person(\"Alice\"<\/span>, 25<\/span>);\r\nPerson bob = new<\/span> Person(\"Bob\"<\/span>, 30<\/span>);\r\n\r\nint<\/span> comparisonResult = alice.compareTo(bob);<\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
                          The recursive type bound T extends SelfComparable<T><\/code> ensures a contract that any class implementing SelfComparable<\/code> will compare itself to instances of its own type, providing type safety. It’s a powerful technique, especially in library and framework design, to impose certain restrictions on type parameters.<\/p>\n\n\n\n
                          Generic Type Inference<\/h3>\n\n\n\n
                          Java’s type inference mechanism allows you to invoke a generic method without explicitly specifying the type parameter. The Java compiler will infer the type argument based on the context in which the method is called. This makes code more concise and readable.<\/p>\n\n\n\n
                          Leveraging Type Inference in Java:<\/h4>\n\n\n\n
                          Utility Method:<\/h5>\n\n\n\n
                          Let’s create a utility method that determines the middle item in an array:<\/p>\n\n\n
                          public<\/span> class<\/span> Utils<\/span> <\/span>{\r\n    public<\/span> static<\/span> <T> T middle<\/span>(T[] array)<\/span> <\/span>{\r\n        return<\/span> array[array.length \/ 2<\/span>];\r\n    }\r\n}<\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
                          Using Explicit Type Argument:<\/h5>\n\n\n\n
                          Traditionally, before type inference became widely used, you would have to specify the type argument when invoking this method:<\/p>\n\n\n
                          String[] names = {\"Alice\"<\/span>, \"Bob\"<\/span>, \"Charlie\"<\/span>, \"David\"<\/span>, \"Eve\"<\/span>};\r\nString middleName = Utils.<String>middle(names);\r\nSystem.out.println(middleName);  \/\/ Outputs: Charlie<\/span><\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
                          Leveraging Type Inference:<\/h5>\n\n\n\n
                          With type inference, the Java compiler is smart enough to infer the type argument from the context. This means you can omit the type argument:<\/p>\n\n\n
                          String middleNameInferred = Utils.middle(names);\r\nSystem.out.println(middleNameInferred);  \/\/ Outputs: Charlie<\/span><\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
                          Inference in Java 7+:<\/h5>\n\n\n\n
                          Starting from Java 7, the diamond operator (<><\/code>) was introduced to further leverage type inference during the instantiation of generic classes:<\/p>\n\n\n
                          List<String> list = new<\/span> ArrayList<>();  \/\/ No need to specify \"String\" in the diamond<\/span>\r<\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
                          Here, the compiler infers the type argument String<\/code> from the variable’s type (List<String><\/code>).<\/p>\n\n\n\n
                          Generic type inference is one of the features that contributes to the elegance and readability of Java code. The compiler’s capability to infer types from the context reduces redundancy and keeps the code concise. Always make use of type inference when possible to make your code more readable.<\/p>\n\n\n\n
                          Generic Factories<\/h3>\n\n\n\n
                          Factories are a key design pattern in object-oriented programming, allowing for the encapsulation of object creation. When combined with generics, factory patterns become even more powerful, as they can produce objects of a generic type based on the provided type argument. This ensures type safety while retaining the flexibility that factories offer.<\/p>\n\n\n\n
                          Factory Patterns with Generics:<\/h4>\n\n\n\n
                          Generic Factory Interface:<\/h5>\n\n\n\n
                          Let’s begin by creating a generic interface for our factory:<\/p>\n\n\n
                          public<\/span> interface<\/span> Factory<\/span><T<\/span>> <\/span>{\r\n    T create<\/span>()<\/span><\/span>;\r\n}<\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
                          Concrete Implementations:<\/h5>\n\n\n\n
                          Next, we’ll make concrete implementations of this factory for different types:<\/p>\n\n\n
                          public<\/span> class<\/span> Car<\/span> <\/span>{\r\n    \/\/ Some attributes and methods for Car<\/span>\r\n}\r\n\r\npublic<\/span> class<\/span> CarFactory<\/span> implements<\/span> Factory<\/span><Car<\/span>> <\/span>{\r\n    @Override<\/span>\r\n    public<\/span> Car create<\/span>()<\/span> <\/span>{\r\n        return<\/span> new<\/span> Car();\r\n    }\r\n}\r\n\r\npublic<\/span> class<\/span> Bike<\/span> <\/span>{\r\n    \/\/ Some attributes and methods for Bike<\/span>\r\n}\r\n\r\npublic<\/span> class<\/span> BikeFactory<\/span> implements<\/span> Factory<\/span><Bike<\/span>> <\/span>{\r\n    @Override<\/span>\r\n    public<\/span> Bike create<\/span>()<\/span> <\/span>{\r\n        return<\/span> new<\/span> Bike();\r\n    }\r\n}<\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
                          Using the Factory:<\/h5>\n\n\n\n
                          With the factories in place, you can create objects of Car<\/code> and Bike<\/code> using their respective factory classes:<\/p>\n\n\n
                          Factory<Car> carFactory = new<\/span> CarFactory();\r\nCar car = carFactory.create();\r\n\r\nFactory<Bike> bikeFactory = new<\/span> BikeFactory();\r\nBike bike = bikeFactory.create();<\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
                          Generic Factory Utility:<\/h5>\n\n\n\n
                          We can further leverage generics to create a factory utility class that can produce any object given its class type:<\/p>\n\n\n
                          public<\/span> class<\/span> GenericFactory<\/span><T<\/span>> implements<\/span> Factory<\/span><T<\/span>> <\/span>{\r\n    private<\/span> Class<T> clazz;\r\n\r\n    public<\/span> GenericFactory<\/span>(Class<T> clazz)<\/span> <\/span>{\r\n        this<\/span>.clazz = clazz;\r\n    }\r\n\r\n    @Override<\/span>\r\n    public<\/span> T create<\/span>()<\/span> <\/span>{\r\n        try<\/span> {\r\n            return<\/span> clazz.newInstance();\r\n        } catch<\/span> (InstantiationException | IllegalAccessException e) {\r\n            throw<\/span> new<\/span> RuntimeException(\"Could not instantiate object\"<\/span>, e);\r\n        }\r\n    }\r\n}<\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
                          Using the Generic Factory Utility:<\/h5>\n\n\n
                          Factory<Car> genericCarFactory = new<\/span> GenericFactory<>(Car.class<\/span>)<\/span>;\r\nCar anotherCar = genericCarFactory.create();\r\n\r\nFactory<Bike> genericBikeFactory = new<\/span> GenericFactory<>(Bike.class<\/span>)<\/span>;\r\nBike anotherBike = genericBikeFactory.create();<\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
                          With generic factories, we’ve combined the type-safety and flexibility of generics with the encapsulation and control of the factory pattern. This pattern becomes particularly useful in scenarios where the exact type to instantiate might vary, such as plugin architectures or dependency injection frameworks.<\/p>\n\n\n\n
                          Common Pitfalls and Best Practices<\/h2>\n\n\n\n
                          When working with generics in Java, while the advantages are many, there are certain pitfalls developers need to be wary of. Alongside these pitfalls, it’s essential to be aware of best practices that can ensure robust and maintainable code.<\/p>\n\n\n\n
                          Mixing Raw Types and Generics<\/h3>\n\n\n\n
                          Pitfall<\/strong>: One common mistake is using raw types (e.g., List<\/code> instead of List<String><\/code>) in the codebase that uses generics. This defeats the purpose of generics and risks introducing ClassCastException at runtime.<\/p>\n\n\n\n
                          Best Practice<\/strong>:<\/p>\n\n\n\n
                            \n
                          • Always specify type parameters when using generic classes or methods, even if it means using wildcard (?<\/code>).<\/li>\n\n\n\n
                          • Do not ignore or suppress unchecked warnings. They’re an indicator that you might be using raw types or making other unsafe operations.<\/li>\n<\/ul>\n\n\n\n
                            Example<\/strong>:<\/p>\n\n\n
                            List rawList = new<\/span> ArrayList();\r\nrawList.add(\"test\"<\/span>);\r\nInteger num = (Integer) rawList.get(0<\/span>);  \/\/ Throws ClassCastException at runtime<\/span>\r<\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
                            Avoiding Overuse of Generics<\/h3>\n\n\n\n
                            Pitfall<\/strong>: Overusing generics or creating overly complicated generic types can make the code hard to read and maintain.<\/p>\n\n\n\n
                            Best Practice<\/strong>:<\/p>\n\n\n\n
                              \n
                            • Use generics where it provides a clear benefit in type safety or code reuse.<\/li>\n\n\n\n
                            • Avoid creating deeply nested or overly complicated generic types.<\/li>\n<\/ul>\n\n\n\n
                              Example of Overcomplication<\/strong>:<\/p>\n\n\n
                              \/\/ Overly complex generic type<\/span>\npublic<\/span> class<\/span> Node<\/span><T<\/span>, U<\/span> extends<\/span> Comparable<\/span><U<\/span>>, V<\/span> extends<\/span> Serializable<\/span> & Runnable<\/span>> <\/span>{ ... }<\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
                              7.3 Tips for Writing Robust Generic Code<\/h3>\n\n\n\n
                              Favor Generic Methods<\/strong>: Even if you’re not writing a generic class, consider using generic methods if they provide type safety and flexibility.<\/p>\n\n\n
                              public<\/span> static<\/span> <T> void<\/span> printArray<\/span>(T[] arr)<\/span> <\/span>{\r\n    for<\/span> (T item : arr) {\r\n        System.out.println(item);\r\n    }\r\n}<\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
                              Use Bounded Wildcards for Flexibility<\/strong>: If you’re writing methods that do not depend on the actual type parameter, but only need to ensure some level of type compatibility, use bounded wildcards (? extends<\/code> or ? super<\/code>).<\/p>\n\n\n
                              public<\/span> void<\/span> copyData<\/span>(List<? extends Number> src, List<? super<\/span> Number> dest)<\/span> <\/span>{\r\n    dest.addAll(src);\r\n}<\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
                              Avoid Mutable Static Fields with Generic Types<\/strong>: This can introduce type safety issues, especially when dealing with raw types.<\/p>\n\n\n\n
                              Be Aware of Type Erasure<\/strong>: Understand that generic type information is erased at runtime. Avoid scenarios where runtime type information is crucial.<\/p>\n\n\n\n
                              Always Document Your Code<\/strong>: If you’re writing a generic class or method that will be used by others, provide clear JavaDoc comments explaining how the generics work and any constraints on the type parameters.<\/p>\n\n\n\n
                              Generic’s Limitations and Workarounds<\/h2>\n\n\n\n
                              Cannot Instantiate Generic Types with Primitive Types<\/h3>\n\n\n\n
                              In Java, generics work with reference types, not primitive types. This means you cannot directly use primitive types (int<\/code>, char<\/code>, boolean<\/code>, etc.) as generic type arguments. Instead, you need to use the corresponding wrapper classes (Integer<\/code>, Character<\/code>, Boolean<\/code>, etc.).<\/p>\n\n\n\n
                              Using Wrappers Instead of Primitives:<\/h4>\n\n\n\n
                              Example of Incorrect Usage<\/strong>:<\/p>\n\n\n
                              \/\/ The following code will produce a compile-time error<\/span>\r\n\/\/ List<int> numbers = new ArrayList<int>();<\/span>\r<\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
                              The above example attempts to use the primitive type int<\/code> as a type argument for the List<\/code> interface, which will result in a compilation error.<\/p>\n\n\n\n
                              Corrected Version using Wrapper Classes<\/strong>:<\/p>\n\n\n
                              \/\/ Use the Integer wrapper class instead of the int primitive type<\/span>\r\nList<Integer> numbers = new<\/span> ArrayList<>();\r\nnumbers.add(1<\/span>);\r\nnumbers.add(2<\/span>);\r\nnumbers.add(3<\/span>);\r\n\r\nfor<\/span> (Integer num : numbers) {\r\n    System.out.println(num);\r\n}\r<\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
                              In the corrected version, we use the Integer<\/code> wrapper class, allowing us to store integers in our generic List<\/code>. The Java compiler and the Java Virtual Machine (JVM) handle the conversion between the primitive int<\/code> type and its wrapper class Integer<\/code> using a feature known as autoboxing and unboxing.<\/p>\n\n\n\n
                              Benefit of Using Wrapper Classes:<\/h4>\n\n\n\n
                                \n
                              • Allows the use of primitive values in generic data structures and methods.<\/li>\n\n\n\n
                              • Provides a range of utility methods (like Integer.parseInt(...)<\/code>) that aren’t available with the primitive counterparts.<\/li>\n<\/ul>\n\n\n\n
                                Points to Consider:<\/h4>\n\n\n\n
                                  \n
                                • Wrapper classes use more memory than primitive types, so there’s a trade-off between memory usage and the benefits of using generics.<\/li>\n\n\n\n
                                • Autoboxing and unboxing introduce a minor performance overhead compared to using primitives directly.<\/li>\n<\/ul>\n\n\n\n
                                  When working with generics in Java, always remember that primitive types cannot be used as type arguments. Using the corresponding wrapper classes ensures type safety and allows you to leverage the full power of Java’s generics.<\/p>\n\n\n\n
                                  Static Fields and Methods in Generics<\/h3>\n\n\n\n
                                  In Java, static fields and methods are associated with a class, not with any particular instance of the class. When it comes to generics, this poses a problem, because type parameters are linked with instances, not with the class itself. As such, the class doesn’t “know” about the specific generic type until an instance is created.<\/p>\n\n\n\n
                                  Why static fields of type parameter aren’t allowed<\/h4>\n\n\n\n
                                  Type Erasure<\/strong>: Generics in Java use type erasure to implement generic behavior. This means that at runtime, the JVM doesn’t actually know about the generic types \u2014 a List<String><\/code> and a List<Integer><\/code> are just List<\/code> objects as far as the bytecode is concerned. This makes it impossible for static fields to “remember” their generic type, as there’s no type information available at runtime.<\/p>\n\n\n\n
                                  Shared Among All Instances<\/strong>: Static fields are shared among all instances of a class, regardless of their type parameters. If static fields could be parameterized with type arguments, it would lead to ambiguity. Consider the following:<\/p>\n\n\n
                                  public<\/span> class<\/span> Container<\/span><T<\/span>> <\/span>{\r\n    \/\/ Hypothetically, if this were allowed...<\/span>\r\n    public<\/span> static<\/span> T data;\r\n}\r\n\r\nContainer<String> stringContainer;\r\nContainer<Integer> integerContainer;<\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
                                  How would Java handle Container.data<\/code>? Is it a String? An Integer? This ambiguity makes it impossible for static fields to be parameterized by type.<\/p>\n\n\n\n
                                  No Instance-Specific Information<\/strong>: Since static context doesn’t have access to instance-specific information, there’s no way to ensure the type safety of a generic type parameter. This would break the primary goal of generics, which is to ensure type safety at compile time.<\/p>\n\n\n\n
                                  Workarounds<\/h4>\n\n\n\n
                                  Even though you can’t have static fields of a generic type, you can have static methods that use generic types. However, the generic type parameter for these static methods is typically defined within the method signature itself and is independent of the class’s type parameter.<\/p>\n\n\n\n
                                  For example:<\/p>\n\n\n
                                  public<\/span> class<\/span> Utility<\/span> <\/span>{\r\n    public<\/span> static<\/span> <T> void<\/span> print<\/span>(T item)<\/span> <\/span>{\r\n        System.out.println(item);\r\n    }\r\n}<\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
                                  In the above example, the method print<\/code> is a generic method that accepts any type of argument and prints it. The type parameter <T><\/code> is specified and scoped only for that method.<\/p>\n\n\n\n
                                  In essence, while Java’s generic system provides a strong mechanism for type-safe operations at the instance level, certain static features remain inherently non-generic due to the way the language and runtime environment are designed.<\/p>\n\n\n\n
                                  Exception Handling with Generics<\/h3>\n\n\n\n
                                  In Java, exceptions have their own type hierarchy and are used to handle and indicate various types of exceptional conditions that might occur during the execution of the program. However, when it comes to generics, there are some constraints and limitations that need to be understood, particularly when we consider the combination of generics with exceptions.<\/p>\n\n\n\n
                                  Challenges with Generic Exceptions:<\/h4>\n\n\n\n
                                  Generic Exception Classes Are Not Allowed<\/strong>: Java does not allow you to directly create a generic exception class. This is because of the type erasure mechanism, which removes generic type information at runtime. If Java allowed generic exceptions, the runtime system wouldn’t be able to differentiate between different types of the generic exception.<\/p>\n\n\n
                                  \/\/ This will result in a compile-time error<\/span>\r\npublic<\/span> class<\/span> GenericException<\/span><T<\/span>> extends<\/span> Exception<\/span> <\/span>{ }<\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
                                  Casting Generic Types Can Lead to Hidden RuntimeExceptions<\/strong>: If you try to work around the aforementioned limitation by casting, you risk introducing runtime exceptions like ClassCastException<\/code>, which somewhat defeats the purpose of generics in providing compile-time type safety.<\/p>\n\n\n\n
                                  Workaround:<\/h4>\n\n\n\n
                                  Though you can’t create generic exception classes, you can still create generic methods that throw exceptions. Moreover, you can use generic information in the construction of an exception message or in exception handling logic:<\/p>\n\n\n
                                  public<\/span> class<\/span> ExceptionUtils<\/span> <\/span>{\r\n    \r\n    public<\/span> static<\/span> <T extends Exception> void<\/span> handleException<\/span>(T exception, String additionalMessage)<\/span> throws<\/span> T <\/span>{\r\n        System.err.println(\"Handled exception of type: \"<\/span> + exception.getClass().getName());\r\n        System.err.println(\"Message: \"<\/span> + exception.getMessage());\r\n        System.err.println(\"Additional Info: \"<\/span> + additionalMessage);\r\n        \r\n        throw<\/span> exception;\r\n    }\r\n    \r\n    public<\/span> static<\/span> void<\/span> main<\/span>(String[] args)<\/span> <\/span>{\r\n        try<\/span> {\r\n            ExceptionUtils.handleException(new<\/span> IOException(\"File not found\"<\/span>), \"Please check the file path.\"<\/span>);\r\n        } catch<\/span> (IOException e) {\r\n            \/\/ Handle the IOException<\/span>\r\n        }\r\n    }\r\n}<\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
                                  In the above code, we have a utility method handleException<\/code> that can handle exceptions of any type derived from Exception<\/code>. It logs some details and then re-throws the exception, allowing it to be caught by appropriate catch blocks in the calling code.<\/p>\n\n\n\n
                                  While generics offer a lot of flexibility and type safety in many areas of Java programming, exception handling remains an area where generics have inherent limitations. However, with a deep understanding of Java’s type system, developers can still find ways to achieve the desired functionality with a bit of creativity.<\/p>\n\n\n\n
                                  Practical Applications of Generics<\/h2>\n\n\n\n
                                  Generics in Java Collections Framework<\/h3>\n\n\n\n
                                  The Java Collections Framework is a suite of interfaces and classes that provide a unified architecture for representing and manipulating collections. With the introduction of generics in Java 5, the Collections Framework was re-engineered to incorporate generics, which enhanced type safety and reduced runtime errors.<\/p>\n\n\n\n
                                  Let’s explore how generics are used in some of the core components of the Collections Framework:<\/p>\n\n\n\n
                                  ArrayList:<\/h4>\n\n\n\n
                                  An ArrayList<\/code> is a resizable array that implements the List<\/code> interface. It allows you to store elements in a linear fashion and provides random access to them.<\/p>\n\n\n\n
                                  Without Generics<\/strong>:<\/p>\n\n\n
                                  ArrayList list = new<\/span> ArrayList();\r\nlist.add(\"test\"<\/span>);\r\nlist.add(123<\/span>);  \/\/ This is valid, but can lead to runtime errors later<\/span><\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
                                  With Generics<\/strong>:<\/p>\n\n\n
                                  ArrayList<String> list = new<\/span> ArrayList<>();\r\nlist.add(\"test\"<\/span>);\r\n\/\/ list.add(123);  \/\/ This will give a compile-time error, which is what we want<\/span><\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
                                  HashMap:<\/h4>\n\n\n\n
                                  A HashMap<\/code> is an implementation of the Map<\/code> interface, which maps keys to values. It allows constant-time performance for basic operations (get and put), assuming the hash function disperses the elements properly.<\/p>\n\n\n\n
                                  Without Generics<\/strong>:<\/p>\n\n\n
                                  HashMap map = new<\/span> HashMap();\r\nmap.put(\"key\"<\/span>, \"value\"<\/span>);\r\nString value = (String) map.get(\"key\"<\/span>);  \/\/ Casting required<\/span><\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
                                  With Generics<\/strong>:<\/p>\n\n\n
                                  HashMap<String, String> map = new<\/span> HashMap<>();\r\nmap.put(\"key\"<\/span>, \"value\"<\/span>);\r\nString value = map.get(\"key\"<\/span>);  \/\/ No casting required<\/span><\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
                                  HashSet:<\/h4>\n\n\n\n
                                  A HashSet<\/code> is a collection that does not allow duplicate elements. It implements the Set<\/code> interface and is backed by a HashMap<\/code> instance.<\/p>\n\n\n\n
                                  Without Generics<\/strong>:<\/p>\n\n\n
                                  HashSet set = new<\/span> HashSet();\r\nset.add(\"element\"<\/span>);\r\n\/\/ set.add(123);  \/\/ Can add any type, but can lead to issues later<\/span><\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
                                  With Generics<\/strong>:<\/p>\n\n\n
                                  HashSet<String> set = new<\/span> HashSet<>();\r\nset.add(\"element\"<\/span>);\r\n\/\/ set.add(123);  \/\/ Compile-time error<\/span><\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
                                  Best Practices:<\/h4>\n\n\n\n
                                    \n
                                  1. Always Specify Type Arguments<\/strong>: While it’s possible to create raw types (i.e., without specifying type arguments), doing so is discouraged because you’ll lose the benefits of type safety.<\/li>\n\n\n\n
                                  2. Use Diamond Operator<\/strong>: Starting from Java 7, you can use the diamond operator (<><\/code>) while creating an instance, and the compiler will infer the type arguments from the context.<\/li>\n\n\n\n
                                  3. Avoid Using Raw Types<\/strong>: Using raw types in new code is considered bad practice. It can lead to issues that manifest as runtime errors instead of compile-time errors.<\/li>\n<\/ol>\n\n\n\n
                                    Designing Generic Algorithms<\/h3>\n\n\n\n
                                    Designing generic algorithms means writing methods or algorithms that can work across different data types while maintaining type safety. This allows the same algorithm to be reused across various data structures or data types without requiring a specific implementation for each type.<\/p>\n\n\n\n
                                    Let’s dive into how we can implement a generic sorting algorithm, specifically the Bubble Sort, as it’s easy to understand and implement.<\/p>\n\n\n\n
                                    Generic Bubble Sort:<\/h4>\n\n\n\n
                                    Bubble Sort is a simple sorting algorithm that works by repeatedly stepping through the list, comparing each pair of adjacent items, and swapping them if they are in the wrong order. The pass through the list is repeated until no swaps are needed, which indicates the list is sorted.<\/p>\n\n\n
                                    public<\/span> class<\/span> GenericBubbleSort<\/span> <\/span>{\r\n\r\n    public<\/span> static<\/span> <T extends Comparable<T>> void<\/span> sort<\/span>(T[] array)<\/span> <\/span>{\r\n        int<\/span> n = array.length;\r\n        boolean<\/span> swapped;\r\n\r\n        for<\/span> (int<\/span> i = 0<\/span>; i < n - 1<\/span>; i++) {\r\n            swapped = false<\/span>;\r\n            for<\/span> (int<\/span> j = 0<\/span>; j < n - i - 1<\/span>; j++) {\r\n                if<\/span> (array[j].compareTo(array[j + 1<\/span>]) > 0<\/span>) {\r\n                    \/\/ swap array[j] and array[j+1]<\/span>\r\n                    T temp = array[j];\r\n                    array[j] = array[j + 1<\/span>];\r\n                    array[j + 1<\/span>] = temp;\r\n\r\n                    swapped = true<\/span>;\r\n                }\r\n            }\r\n\r\n            \/\/ If no two elements were swapped in inner loop, the array is sorted<\/span>\r\n            if<\/span> (!swapped) break<\/span>;\r\n        }\r\n    }\r\n\r\n    public<\/span> static<\/span> void<\/span> main<\/span>(String[] args)<\/span> <\/span>{\r\n        Integer[] numbers = {64<\/span>, 34<\/span>, 25<\/span>, 12<\/span>, 22<\/span>, 11<\/span>, 90<\/span>};\r\n        sort(numbers);\r\n        System.out.println(Arrays.toString(numbers));\r\n\r\n        String[] words = {\"apple\"<\/span>, \"banana\"<\/span>, \"cherry\"<\/span>, \"date\"<\/span>, \"elderberry\"<\/span>};\r\n        sort(words);\r\n        System.out.println(Arrays.toString(words));\r\n    }\r\n}<\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
                                    Points to Note<\/strong>:<\/p>\n\n\n\n
                                      \n
                                    • The generic method sort<\/code> uses a type parameter T<\/code> which extends Comparable<T><\/code>. This means the type T<\/code> must be comparable with other objects of its own type. The compareTo<\/code> method is a part of the Comparable<\/code> interface, and many Java built-in types like String<\/code>, Integer<\/code>, etc., already implement this interface.<\/li>\n\n\n\n
                                    • The algorithm will work for any array of a type that implements Comparable<\/code>, be it strings, integers, custom objects, etc.<\/li>\n<\/ul>\n\n\n\n
                                      Advantages:<\/h4>\n\n\n\n
                                        \n
                                      1. Reusability<\/strong>: The same generic method can be used to sort arrays of different types.<\/li>\n\n\n\n
                                      2. Type Safety<\/strong>: The compiler checks for type compatibility at compile-time, reducing runtime errors.<\/li>\n\n\n\n
                                      3. Code Reduction<\/strong>: No need to write separate sorting methods for each data type.<\/li>\n<\/ol>\n\n\n\n
                                        Using Generics in Custom Data Structures<\/h3>\n\n\n\n
                                        Using generics in custom data structures enables them to store any data type while ensuring compile-time type safety. It also ensures reusability and maintainability of the code. Let’s look at how we can build a generic LinkedList in Java.<\/p>\n\n\n\n
                                        Generic LinkedList:<\/h4>\n\n\n\n
                                        A LinkedList consists of nodes, where each node contains data and a reference (or link) to the next node in the sequence. Here, we’ll implement a singly linked list.<\/p>\n\n\n
                                        public<\/span> class<\/span> GenericLinkedList<\/span><T<\/span>> <\/span>{\r\n    \r\n    \/\/ Node inner class<\/span>\r\n    private<\/span> class<\/span> Node<\/span> <\/span>{\r\n        T data;\r\n        Node next;\r\n\r\n        Node(T data) {\r\n            this<\/span>.data = data;\r\n            this<\/span>.next = null<\/span>;\r\n        }\r\n    }\r\n\r\n    private<\/span> Node head = null<\/span>;\r\n\r\n    \/\/ Method to add a new node at the end<\/span>\r\n    public<\/span> void<\/span> add<\/span>(T data)<\/span> <\/span>{\r\n        Node newNode = new<\/span> Node(data);\r\n        if<\/span> (head == null<\/span>) {\r\n            head = newNode;\r\n            return<\/span>;\r\n        }\r\n\r\n        Node current = head;\r\n        while<\/span> (current.next != null<\/span>) {\r\n            current = current.next;\r\n        }\r\n        current.next = newNode;\r\n    }\r\n\r\n    \/\/ Method to print the linked list<\/span>\r\n    public<\/span> void<\/span> printList<\/span>()<\/span> <\/span>{\r\n        Node current = head;\r\n        while<\/span> (current != null<\/span>) {\r\n            System.out.print(current.data + \" -> \"<\/span>);\r\n            current = current.next;\r\n        }\r\n        System.out.println(\"null\"<\/span>);\r\n    }\r\n\r\n    public<\/span> static<\/span> void<\/span> main<\/span>(String[] args)<\/span> <\/span>{\r\n        GenericLinkedList<String> stringList = new<\/span> GenericLinkedList<>();\r\n        stringList.add(\"Node1\"<\/span>);\r\n        stringList.add(\"Node2\"<\/span>);\r\n        stringList.printList();\r\n\r\n        GenericLinkedList<Integer> intList = new<\/span> GenericLinkedList<>();\r\n        intList.add(1<\/span>);\r\n        intList.add(2<\/span>);\r\n        intList.add(3<\/span>);\r\n        intList.printList();\r\n    }\r\n}<\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
                                        Points to Note<\/strong>:<\/p>\n\n\n\n
                                          \n
                                        1. The GenericLinkedList<\/code> class has a type parameter T<\/code>, which means the linked list can store data of any type.<\/li>\n\n\n\n
                                        2. The inner Node<\/code> class also uses the type parameter T<\/code> to define the data type of each node.<\/li>\n\n\n\n
                                        3. The add<\/code> method allows adding nodes of type T<\/code> to the list.<\/li>\n\n\n\n
                                        4. The printList<\/code> method prints the data of each node in the list.<\/li>\n<\/ol>\n\n\n\n
                                          Advantages:<\/h4>\n\n\n\n
                                            \n
                                          1. Flexibility<\/strong>: You can create linked lists of any data type without needing separate implementations.<\/li>\n\n\n\n
                                          2. Type Safety<\/strong>: Using generics ensures that the data type of the linked list is checked at compile time, preventing potential type mismatches or casting issues at runtime.<\/li>\n\n\n\n
                                          3. Cleaner Code<\/strong>: The use of generics results in cleaner and more understandable code, as it abstracts away type-specific details.<\/li>\n<\/ol>\n\n\n\n
                                            Similarly, you can extend this concept to build other generic data structures like Trees, Stacks, Queues, etc. Incorporating generics makes custom data structures more versatile and adaptable to various application needs.<\/p>\n\n\n\n
                                            As we wrap up, it’s crucial to realize the transformative impact generics can bring to your Java projects. By incorporating generics, you’re not only ensuring type-safety but also significantly enhancing code reusability and maintainability. Java Generics empowers developers to write more generic, type-safe, and efficient code that stands the test of evolving requirements and growing codebases.<\/p>\n","protected":false},"excerpt":{"rendered":"
                                            Introduction Java has undergone numerous evolutions since its inception in the mid-’90s. Its adaptability and commitment to improvement have been some of the pivotal reasons for its widespread adoption. One such significant improvement was the introduction of Generics in Java 5.0. Brief History and Need for Java Generics Before the arrival of Generics, Java developers […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_genesis_hide_title":false,"_genesis_hide_breadcrumbs":false,"_genesis_hide_singular_image":false,"_genesis_hide_footer_widgets":false,"_genesis_custom_body_class":"","_genesis_custom_post_class":"","_genesis_layout":"","_jetpack_memberships_contains_paid_content":false,"footnotes":""},"categories":[5,4],"tags":[],"class_list":["post-1022","post","type-post","status-publish","format-standard","category-java","category-programming-languages","entry"],"yoast_head":"\nMastering Java Generics: From Basic to Advanced<\/title>\n<meta name=\"description\" content=\"The addition of Generics in Java allowed developers to provide a type parameter to collections, ensuring type safety.\" \/>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/www.w3computing.com\/articles\/java-generics-basic-advanced\/\" \/>\n<meta property=\"og:locale\" content=\"en_US\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Mastering Java Generics: From Basic to Advanced\" \/>\n<meta property=\"og:description\" content=\"The addition of Generics in Java allowed developers to provide a type parameter to collections, ensuring type safety.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/www.w3computing.com\/articles\/java-generics-basic-advanced\/\" \/>\n<meta property=\"article:published_time\" content=\"2023-08-24T01:37:23+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2023-08-24T01:37:27+00:00\" \/>\n<meta name=\"author\" content=\"w3compadmin\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:label1\" content=\"Written by\" \/>\n\t<meta name=\"twitter:data1\" content=\"w3compadmin\" \/>\n\t<meta name=\"twitter:label2\" content=\"Est. reading time\" \/>\n\t<meta name=\"twitter:data2\" content=\"24 minutes\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\\\/\\\/schema.org\",\"@graph\":[{\"@type\":\"TechArticle\",\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/java-generics-basic-advanced\\\/#article\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/java-generics-basic-advanced\\\/\"},\"author\":{\"name\":\"w3compadmin\",\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/#\\\/schema\\\/person\\\/a550b3e20d78bb4f79b7c6b7b53f0561\"},\"headline\":\"Mastering Java Generics: From Basic to Advanced\",\"datePublished\":\"2023-08-24T01:37:23+00:00\",\"dateModified\":\"2023-08-24T01:37:27+00:00\",\"mainEntityOfPage\":{\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/java-generics-basic-advanced\\\/\"},\"wordCount\":5342,\"commentCount\":0,\"articleSection\":[\"Java\",\"Programming Languages\"],\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"CommentAction\",\"name\":\"Comment\",\"target\":[\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/java-generics-basic-advanced\\\/#respond\"]}]},{\"@type\":\"WebPage\",\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/java-generics-basic-advanced\\\/\",\"url\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/java-generics-basic-advanced\\\/\",\"name\":\"Mastering Java Generics: From Basic to Advanced\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/#website\"},\"datePublished\":\"2023-08-24T01:37:23+00:00\",\"dateModified\":\"2023-08-24T01:37:27+00:00\",\"author\":{\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/#\\\/schema\\\/person\\\/a550b3e20d78bb4f79b7c6b7b53f0561\"},\"description\":\"The addition of Generics in Java allowed developers to provide a type parameter to collections, ensuring type safety.\",\"breadcrumb\":{\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/java-generics-basic-advanced\\\/#breadcrumb\"},\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/java-generics-basic-advanced\\\/\"]}]},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/java-generics-basic-advanced\\\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Articles Home\",\"item\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Programming Languages\",\"item\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/programming-languages\\\/\"},{\"@type\":\"ListItem\",\"position\":3,\"name\":\"Mastering Java Generics: From Basic to Advanced\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/#website\",\"url\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/\",\"name\":\"Developer Articles Hub\",\"description\":\"\",\"alternateName\":\"Developer Articles\",\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"en-US\"},{\"@type\":\"Person\",\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/#\\\/schema\\\/person\\\/a550b3e20d78bb4f79b7c6b7b53f0561\",\"name\":\"w3compadmin\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/wp-content\\\/litespeed\\\/avatar\\\/bd481d404e42caa2763662a3bfe825f8.jpg?ver=1780141266\",\"url\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/wp-content\\\/litespeed\\\/avatar\\\/bd481d404e42caa2763662a3bfe825f8.jpg?ver=1780141266\",\"contentUrl\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/wp-content\\\/litespeed\\\/avatar\\\/bd481d404e42caa2763662a3bfe825f8.jpg?ver=1780141266\",\"caption\":\"w3compadmin\"},\"sameAs\":[\"http:\\\/\\\/w3computing.com\\\/articles\"]}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"Mastering Java Generics: From Basic to Advanced","description":"The addition of Generics in Java allowed developers to provide a type parameter to collections, ensuring type safety.","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/www.w3computing.com\/articles\/java-generics-basic-advanced\/","og_locale":"en_US","og_type":"article","og_title":"Mastering Java Generics: From Basic to Advanced","og_description":"The addition of Generics in Java allowed developers to provide a type parameter to collections, ensuring type safety.","og_url":"https:\/\/www.w3computing.com\/articles\/java-generics-basic-advanced\/","article_published_time":"2023-08-24T01:37:23+00:00","article_modified_time":"2023-08-24T01:37:27+00:00","author":"w3compadmin","twitter_card":"summary_large_image","twitter_misc":{"Written by":"w3compadmin","Est. reading time":"24 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"TechArticle","@id":"https:\/\/www.w3computing.com\/articles\/java-generics-basic-advanced\/#article","isPartOf":{"@id":"https:\/\/www.w3computing.com\/articles\/java-generics-basic-advanced\/"},"author":{"name":"w3compadmin","@id":"https:\/\/www.w3computing.com\/articles\/#\/schema\/person\/a550b3e20d78bb4f79b7c6b7b53f0561"},"headline":"Mastering Java Generics: From Basic to Advanced","datePublished":"2023-08-24T01:37:23+00:00","dateModified":"2023-08-24T01:37:27+00:00","mainEntityOfPage":{"@id":"https:\/\/www.w3computing.com\/articles\/java-generics-basic-advanced\/"},"wordCount":5342,"commentCount":0,"articleSection":["Java","Programming Languages"],"inLanguage":"en-US","potentialAction":[{"@type":"CommentAction","name":"Comment","target":["https:\/\/www.w3computing.com\/articles\/java-generics-basic-advanced\/#respond"]}]},{"@type":"WebPage","@id":"https:\/\/www.w3computing.com\/articles\/java-generics-basic-advanced\/","url":"https:\/\/www.w3computing.com\/articles\/java-generics-basic-advanced\/","name":"Mastering Java Generics: From Basic to Advanced","isPartOf":{"@id":"https:\/\/www.w3computing.com\/articles\/#website"},"datePublished":"2023-08-24T01:37:23+00:00","dateModified":"2023-08-24T01:37:27+00:00","author":{"@id":"https:\/\/www.w3computing.com\/articles\/#\/schema\/person\/a550b3e20d78bb4f79b7c6b7b53f0561"},"description":"The addition of Generics in Java allowed developers to provide a type parameter to collections, ensuring type safety.","breadcrumb":{"@id":"https:\/\/www.w3computing.com\/articles\/java-generics-basic-advanced\/#breadcrumb"},"inLanguage":"en-US","potentialAction":[{"@type":"ReadAction","target":["https:\/\/www.w3computing.com\/articles\/java-generics-basic-advanced\/"]}]},{"@type":"BreadcrumbList","@id":"https:\/\/www.w3computing.com\/articles\/java-generics-basic-advanced\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Articles Home","item":"https:\/\/www.w3computing.com\/articles\/"},{"@type":"ListItem","position":2,"name":"Programming Languages","item":"https:\/\/www.w3computing.com\/articles\/programming-languages\/"},{"@type":"ListItem","position":3,"name":"Mastering Java Generics: From Basic to Advanced"}]},{"@type":"WebSite","@id":"https:\/\/www.w3computing.com\/articles\/#website","url":"https:\/\/www.w3computing.com\/articles\/","name":"Developer Articles Hub","description":"","alternateName":"Developer Articles","potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/www.w3computing.com\/articles\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"en-US"},{"@type":"Person","@id":"https:\/\/www.w3computing.com\/articles\/#\/schema\/person\/a550b3e20d78bb4f79b7c6b7b53f0561","name":"w3compadmin","image":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/www.w3computing.com\/articles\/wp-content\/litespeed\/avatar\/bd481d404e42caa2763662a3bfe825f8.jpg?ver=1780141266","url":"https:\/\/www.w3computing.com\/articles\/wp-content\/litespeed\/avatar\/bd481d404e42caa2763662a3bfe825f8.jpg?ver=1780141266","contentUrl":"https:\/\/www.w3computing.com\/articles\/wp-content\/litespeed\/avatar\/bd481d404e42caa2763662a3bfe825f8.jpg?ver=1780141266","caption":"w3compadmin"},"sameAs":["http:\/\/w3computing.com\/articles"]}]}},"featured_image_src":null,"featured_image_src_square":null,"author_info":{"display_name":"w3compadmin","author_link":"https:\/\/www.w3computing.com\/articles\/author\/w3compadmin\/"},"jetpack_featured_media_url":"","jetpack_sharing_enabled":true,"_links":{"self":[{"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/posts\/1022","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/comments?post=1022"}],"version-history":[{"count":31,"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/posts\/1022\/revisions"}],"predecessor-version":[{"id":1053,"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/posts\/1022\/revisions\/1053"}],"wp:attachment":[{"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/media?parent=1022"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/categories?post=1022"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/tags?post=1022"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}