How are collections defined?

Before we start: Actually, your examples should be

Set<Object, Object> set = new HashSet<Object, Object>(); 

or, as of Java 7, also works

Set<Object, Object> set = new HashSet<>();

Otherwise, you are assigning an expression that does not have generics defined (an unbound value ) to one that does, and it shows you a warning.

On the crux of the question, it has nothing to do with generics per se. It could also be done before generics were defined (in Java 5), ​​and of course it still can be done with any class as long as the variable it is assigned to is a supertype of the assigned expression. Trivial example Object obj = new Integer(1).

What you do here is define the type of a variable. The general rule is that you should choose as the class of the reference the most generic class (= higher in the hierarchy) that you can work with.

For example, you want to have a reference that behaves like a list (you can add elements and retrieve them based on their position). Do

Object miLista = new ArrayList<String>();

doesn't make much sense, because the class Objectdoesn't define a method to add objects to the collection; if you do you miLista.add("Hola");have a compile error.

Thus, it is more practical for you to define the variable/reference as List miLista, since that way you can already invoke the method addof the implementation of your Listchoice.

And why not ArrayList miLista<String> = new ArrayList<>();? Well, because you unnecessarily restrict the type of values ​​you can assign. If all you're going to use are methods defined on the interface List, using a reference ArrayListwill unnecessarily restrict your code to that implementation. A very clear example is in the parameters of the methods, imagine that you have a method to duplicate the last element of the list:

 public void duplicar(List<Object> lista) {
    if (!lista.isEmpty()) {
       Object obj = lista.get(lista.size() - 1);
       lista.add(obj)
    }
 }

 public void duplicar(ArrayList<Object> lista) {
    if (!lista.isEmpty()) {
       Object obj = lista.get(lista.size() - 1);
       lista.add(obj)
    }
 }

The first version can be used with any implementation of List, while the second version can only be used if you have one ArrayListor create one ArrayListfrom your list

What is the difference in creating and defining these classes, for example:

HashMap<Object, Object> mapa = new HashMap<Object, Object>();

or this way:

Map<Object, Object> mapa = new HashMap<Object, Object>();

In the first construction you are declaring a map object of type HashMapand defining map as an object that is an instance of the class HashMap. In the second construction you are declaring an object of type Mapand defining map as an object that is an instance of the class HashMap. The second construct follows a pattern known as 'programming against the interface': Mapit is an interface , therefore it defines a set of methods that classes that implement this interface must complete. The class HashMapimplements the interface Map, and therefore agrees to implement all the methods that the interface Mapdefines.

By virtue of inheritance in Java, a class Athat extends or implements a class or interface Bimplies that an object of the class A is an object of the class B. Let's look at an example:

public interface Animal {
    public void nutrirse();
    public void reproducirse();
    public void moverse();
}

The interface Animaldefines three methods that anything that can be said to be an animal could do: feed, reproduce, or move. Any class that implements the interface Animalmust implement these methods, for example a dog:

public class Dog implements Animal {
    public void nutrirse() {
        //Atragantarse con croquetas para perros
    }
    public void reproducirse() {
        //Encontrar otro perro o perra para poder aparearse
    }
    public void moverse() {
        //Correr rápidamente mientras bate la cola
    }
}

or a cat:

public class Cat implements Animal {
    public void nutrirse() {
        //Comer moderadamente y con elegancia dejando la mitad de la comida en el plato
    }
    public void reproducirse() {
        //Encontrar otro gato o gata para poder aparearse haciendo intensos ruidos
    }
    public void moverse() {
        //Caminar con elegancia mientras maulla
    }
}

Both classes implement the interface Animalbecause they fill in the definitions of the methods that the interface forces them to have. It is clear that each of these implements the methods in a different way (because not all animals behave in the same way). Thanks to this it is possible to do things like:

Animal snoopy = new Dog(); //un Dog es un Animal
Animal bolaDeNieve = new Cat(); //Un Cat es un Animal

By doing this we are programming against the interface, both snoopyas bolaDeNievethey are defined as interfaces but declared as their specialized classes. On the other hand it is obvious that we can also do:

Dog scooby = new Dog();
Cat garfield = new Cat();

but we can't do

Animal engendro = new Animal();

because we cannot declare objects of type interface. What is the advantage of programming against interface? a well-known one is the use of polymorphism, suppose we have a veterinarian that treats dogs and cats and we have several animals:

Dog perro1 = new Dog();
Dog perro2 = new Dog();
Cat gato1 = new Cat();
Cat gato2 = new Cat();

When the animals arrive at the vet, they are anesthetized to be able to operate on them, by virtue of polymorphism we can create a method called anestesiarPerrothat receives a dog and anesthetizes it:

public void anestesiarPerro(Dog dog) {
    //Procedimiento para anestesiar
    dog.moverse(); //Porque se debe trasladar a la sala de cirugía
    //Más procedimientos para anestesiar
}

Or anesthetize a cat:

public void anestesiarGato(Cat cat) {
    //Procedimiento para anestesiar
    cat.moverse(); //Porque se debe trasladar a la sala de cirugía
    //Más procedimientos para anestesiar
}

Since the method is generic, we can use polymorphism to receive the interface Animaland call the method anestesiarwith an object of any subtype of Animalboth present ( Cat, Dog) and future (tomorrow the vet can anesthetize birds Bird):

public void anestesiarAnimal(Animal animal) {
    //Procedimiento para anestesiar
    animal.moverse(); //Ya que se pasa un objeto que es un `Animal` se tiene la seguridad que implementa el método `moverse`
    //Más procedimientos para anestesiar
}

There are many more applications that benefit from programming against the interface, for example making use of a design pattern known as inversion of control and allowing the Liskov substitution principle to be applied . Going back to the aforementioned example, defining mapaas Mapand not as HashMapallows this object to be used in methods that receive the most general class possible (interface), guaranteeing flexibility in the code.

In the same way:

HashSet<Object, Object> mapa = new HashSet<Object, Object>();

or this way:

Set<Object, Object> mapa = new HashSet<Object, Object>();

or this way:

ArrayList<Object> lista = new ArrayList<Object>();  

or this way:

List<Object> lista = new ArrayList<Object>(); 

As much Listas Setthey are interfaces and ArrayListand HashSetimplementations of these interfaces. Since the most general (interfaces over implementations) is preferred, it is always advisable to define these objects with the type of the interface and declare them with the implementation subtype of the interface.

On the other hand:

Map<Object, Object> mapa = new HashMap<>();

is identical to

Map<Object, Object> mapa = new HashMap<Object, Object>();

since Java 7 the diamond operator (<>) is a language feature that allows the compiler to guess what data type the generic object should have on the right side of the a partir de la información del tipo de dato genérico a la izquierda de la asignación. Si te das cuenta, declaras un objetoMap cuyas llaves son de tipoObject y valores de tipoObject , por lo tanto, al usar el operador<>` assignment without any data type generic, the compiler assumes that the generic data type is the same as the one indicated in the variable definition, an example:

List<Dog> perros = new ArrayList<Dog>();

create an array of Dog. Note the redundancy when declaring the generic data type Dogin List<Dog>and in ArrayList<Dog. Using the diamond operator is equivalent:

List<Dog> perros = new ArrayList<>();

Since from it List<Dog>is possible to intuit that the generic data type of ArrayList<>is ArrayList<Dog>. I point out again that this is only possible since Java 7. In Java 5 and 6 it is mandatory to write the data type of the generic both to the left and to the right of the declaration or assignment of a generic. This operator ultimately only works as syntactic sugar to reduce the verbosity of the language.