26. Raw type should not be used

Raw type refers to a generic type declared without a type parameter. For example, for List , something like List is called a raw type.
When using raw type, errors that could be detected at compile time if the generic type is declared with clear type parameters will not be detected until run time.

package tryAny.effectiveJava;

import java.util.Arrays;
import java.util.Collection;
import java.util.Iterator;

public class GenericsTest1 {

    public static void main(String[] args) {
        final Collection stamps = Arrays.asList(new Stamp(), new Stamp(), "");
        //The following code will detect it as a compile error.
        // final Collection<Stamp> stamps = Arrays.asList(new Stamp(), new Stamp(), "");
        for (Iterator i = stamps.iterator(); i.hasNext();) {
            Stamp stamp = (Stamp) i.next(); //Send an error when casting the third element. Only known at run time.
            System.out.println("cast success");
        }
    }

    static class Stamp {

    }
}

You should not use raw types like List, but you may use generic types like List
that allow arbitrary types. Roughly speaking, the difference between the two is that the former is not generically adapted, while the latter clearly shows that the compiler allows any type. For example, you can put a List
in a List type, but you can't put it in a List
.
```
package tryAny.effectiveJava;

import java.util.ArrayList;
import java.util.List;

public class GenericsTest2 {
    public static void main(String[] args) {
        List<String> strings = new ArrayList<>();
        unsafeAdd(strings, Integer.valueOf(42));
        String s = strings.get(0); // Has compiler-generated cast
    }

    private static void unsafeAdd(List list, Object o) {
        //The following code will cause a compile error.
        // private static void unsafeAdd(List<Object> list, Object o) {
        list.add(o);
    }

}
```
- You may want to use the raw type if you don't care what the element type is, but you should use the **? ** Wildcard. These differences are also in type safety.
```
package tryAny.effectiveJava;

import java.util.Set;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class GenericsTest3 {

    public static void main(String[] args) {
        Set<?> s1 = Stream.of("2", "b", 1).collect(Collectors.toSet());
        Set s2 = Stream.of("2", "c", 1).collect(Collectors.toSet());

        // s1.add("c"); //This code will result in a compilation error
        s2.add("b");

        System.out.println(numElementsInCommon(s1, s2));
    }

    // Use of raw type for unknown element type - don't do this!
    static int numElementsInCommon(Set<?> s1, Set<?> s2) {
        int result = 0;
        for (Object o1 : s1)
            if (s2.contains(o1))
                result++;
        return result;
    }
}
```
- There are a few exceptions to the rule that raw types should not be used.
- You cannot specify a generic type with a type parameter in a class literal. That is, List.class and String []. Class are allowed, but List and List <?> Are not allowed.
- instanceof cannot be used for generic types that use type parameters (except Unbounded wildcard type), so check with raw type at that time.
```
// Legitimate use of raw type - instanceof operator
if (o instanceof Set) {       // Raw type
    Set<?> s = (Set<?>) o;    // Wildcard type
    ...
}
```
Recommended Posts
Item 26: Don't use raw types

Item 41: Use marker interfaces to define types

Don't use magic numbers ...

Item 52: Use overloading judiciously

Item 53: Use varargs judiciously

Item 45: Use streams judiciously

Item 29: Favor generic types

Item 83: Use lazy initialization judiciously

Item 66: Use native methods judiciously

Don't use `get ()` ~ Defeated Optional

Item 59: Know and use the libraries

Item 40: Consistently use the Override annotation

Item 26: Don't use raw types

26. Raw type should not be used