Shulou(Shulou.com)06/03 Report--

This article introduces the relevant knowledge of "how to master Java generics". In the operation of actual cases, many people will encounter such a dilemma, so let the editor lead you to learn how to deal with these situations. I hope you can read it carefully and be able to achieve something!

Why use generics?

Imagine a scenario where we want to create a list with Java to store the Integer; code that might be written like this:

List list = new LinkedList (); list.add (new Integer (1)); Integer I = list.iterator () .next ()

Surprisingly, the compiler prompts for the last line. It does not know what type of data is returned. Therefore, the compiler prompts for explicit conversion:

Integer I = (Integer) list.iterator.next ()

There is no convention to guarantee that the return type of the list is an integer. The defined list can contain any object. All we know is that we retrieve the list by checking the context. When looking at a type, it can only guarantee that it is an Object, so you need to cast explicitly to ensure that the type is safe.

This conversion can be noisy, and we know that the data types in this list are integers. If you convert it, it will also mess up our code. If the programmer makes an error in the explicit conversion, it may cause a type-related run-time error to be thrown.

It will be easier if programmers can express their intention to use a particular type, and the compiler can ensure the correctness of that type.

This is the core idea behind generics.

Let's change the first line of the previous code snippet to:

List list = new LinkedList ()

By adding a diamond operator that contains types, we narrow the specialization of this list to the Integer type, which specifies the type that will be saved in the list. The compiler can enforce this type at compile time.

In smaller programs, this looks like a trivial addition. But in larger programs, this can add significant robustness and make the program easier to read.

Generic method

Generic methods are methods written with a single method declaration and can be called with different types of parameters. The compiler will ensure that the types used are correct. Here are some properties of generic methods:

A generic method has a type parameter (the diamond operator of the package type) before the return type declared by the method.

Type parameters can be bounded (boundaries will be explained later in this article)

Generic methods can have different type parameters, which are separated by commas in the method signature

The method body of the generic method is the same as the ordinary method.

An example of defining a generic method that converts an array to a list:

Public List fromArrayToList (T [] a) {return Arrays.stream (a) .duration (Collectors.toList ());}

In the previous example, the method declaration indicates that the method will handle the generic type T. You need to do this even if the method returns void. As mentioned above, methods can handle multiple generic types, in which case all generic types must be added to the method declaration, for example, if we want to modify the above method to handle types T and G, it should be written as follows:

Public static List fromArrayToList (T [] a, Function mapperFunction) {return Arrays.stream (a) .map (mapperFunction) .duration (Collectors.toList ());}

We are passing a function that converts an array with T-type elements to a list containing G-type elements. For example, convert Integer to its String representation:

@ Test public void givenArrayOfIntegers_thanListOfStringReturnedOK () {Integer [] intArray = {1,2,3,4,5}; List stringList = Generics.fromArrayToList (intArray, Object::toString); assertThat (stringList, hasItems ("1", "2", "3", "4", "5");}

Oracle recommends that you use uppercase letters to represent generic types, and choose more descriptive letters to represent formal types, such as T for type, K for key, and V for value in the Java collection.

Generic boundary

As mentioned earlier, type parameters can be bounded. Boundedness means "limits", and we can limit the types of methods that are acceptable.

For example, you can specify that a method accepts a type and all of its subclasses (upper limit) or all its superclasses (lower bound) of a type.

To declare an upper bound type, we use the keyword extends after the type, followed by the upper bound to be used. For example:

Public List fromArrayToList (T [] a) {.}

The keyword extends is used here to indicate the upper limit of the type T extension class, or to implement the upper limit of the interface.

Multiple boundaries

Types can also have multiple upper bounds, as follows:

If one of the types of T extensions is a class (that is, Number), it must be placed first in the bounds list. Otherwise, it will result in compile-time errors.

Use wildcards

Wildcards use question marks in Java "?" Indicates that they are used to refer to an unknown type. Wildcards are particularly useful when using generics and can be used as parameter types, but the first thing to consider is an important comment.

It is well known that Object is the supertype of all Java classes, but the collection of Object is not the supertype of any collection. (it may be a little roundabout, please taste it carefully.)

For example, List is not a supertype of List, and assigning a variable of type List to a variable of type List will cause a compiler error.

This is to prevent conflicts that may occur when heterogeneous types are added to the same collection.

The same rules apply to any collection of types and their subtypes. Look at this example:

Public static void paintAllBuildings (List buildings) {buildings.forEach (Building::paint);}

If we imagine a subtype Building, instance House, then we cannot use this method with the House list, even if House is a subtype of Building. If you need to use this method with a type build and all its subtypes, bounded wildcards can do the following:

Public static void paintAllBuildings (List

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.