Home / Questions / 331240
Accepted
x3k
Asked: 2020-02-22 02:27:37 +0800 CST 2020-02-22 02:27:37 +0800 CST

How to store different types of objects in the same container/list?

  • 772

I have different classes:

class Gato{...}
class Perro{...}
class Pulpo{...}

I would like to store the different objects in the same container or list to treat them later:

Gato gato = new Gato("Garfield");
Perro perro = new Perro("Tobi");
Pulpo pulpo = new Pulpo("Paul");

But obviously I can't do it in a list tipada:

ArrayList <Gato> listaContenedor = new ArrayList<Gato>();
listaContenedor.add(gato);
listaContenedor.add(perro); //Perro cannot be converted to Gato

How could I store them in the same container/list?

java

3 Answers

  1. Best Answer

    Don't use Objectdefault .

    If you have any base types that they inherit from, especially if it's an interface , create a list with that base type:

    interface Animal {
}

class Perro implements Animal {
}

class Gato implements Animal {
}

class Pulpo implements Animal {
}
// y así con todas

    You can make a list with all of them and share behavior:

    List<Animal> animales = new ArrayList<>();
animales.add(gato);
animales.add(perro);
animales.add(pulpo);

    And if you want to give them common behavior, add the method to the interface:

    interface Animal {
   public void hacerSonido();
}

class Perro implements Animal {

    @Overrride
    public void hacerSonido() {
        System.out.println("Guau");
    }
}

class Gato implements Animal {

    @Overrride
    public void hacerSonido() {
        System.out.println("Miau");
    }
}

class Pulpo implements Animal {

    @Overrride
    public void hacerSonido() {
        System.out.println("Glub glub");
    }
}

    And access that behavior from your list:

    animales.forEach(Animal::hacerSonido); // imprime Guau, Miau y Glub glub

    Honestly, if you're using Object as a base class for a container, you should check your domain architecture because it's an indicator that there's something wrong going on.

    • 7

  2. JSON

    To use them JSONyou will need to put it in the dependencies (objects JSONare very common so they are never too much in a project) and import it wherever you use it.

    You can store them in objects JSON. With this you can create different structures that will be better for you in one case or another.

    JSONofJSONs

    JSONArrayofJSONs

    ...

    In this example I see a clearer one JSONin JSONswhich the JSONparent can be treated as the container and create one JSONfor each object so you can then treat them as different objects.

    JSONObject jsonContenedor = new JSONObject();

JSONObject jsonGato = new JSONObject();
JSONObject jsonPerro = new JSONObject();
JSONObject jsonPulpo = new JSONObject();

//Pones los atributos de cada objeto en el JSON
jsonGato.put("nombre", "Garfield");
...

//Almacenar los jsons en el contenedor
jsonContenedor.put("gato", jsonGato);
jsonContenedor.put("perro", jsonPerro);
jsonContenedor.put("pulpo", jsonPulpo);

    Then to retrieve it:

    JSONObject gato = jsonContenedor.getJSONObject("gato");
String nombreGato = gato.getString("nombre");

    List <Object>

    The simplest but not the most recommended . It can cause problems if you don't know the origin of the list's data, as can be seen in this case . Why does List contains return false? . Or if you intend to expand the logic of the list in the future and add other types of objects, you would have to change all the code of how you treated the list.

    The simplest thing would be to put them in a list of Objetos:

    ArrayList<Object> listaContenedor = new ArrayList<Object>();
listaContenedor.add(gato);
listaContenedor.add(perro);
listaContenedor.add(pulpo);

    And to collect them by casting them to their respective types:

    Gato gato = (Gato)listaContenedor.get(0);
Perro perro = (Perro)listaContenedor.get(1);
Pulpo pulpo = (Pulpo)listaContenedor.get(2);

    You can also create the list without "typing":

    ArrayList listaContenedor = new ArrayList();

    Doc: java.util.ArrayList

    • 3

  3. The classic container, which many frameworks call a "context" is a Map. In a Mapyou can save objects under a search key or tag. For convenience, the tag can be a String, so a Mapdefined as Map<String, Object>allows you to store any object under a given string:

    Map<String,Object> miContenedor = new HashMap<>();

miContenedor.put("mi-gato", new Gato("Gaturro"));
miContenedor.put("mi-perro", new Perro("Max"));
miContenedor.put("otro-perro", new Perro("Fido"));

    then, I could get them back to Max with miContenedor.get("mi-perro").

    As with other collections, since the object to be retrieved is a Objectfrom the point of view of the Map, in order to retrieve it as a dog, it must be cast.

    Perro miPerro = (Perro) miContenedor.get("mi-perro")

    Mapalso provides methods to get:

    • one Setof the map entries ( Set<Map.Entry<K,V>>) that becomes a collection with the pairs key (labels), value (stored object) that are inside the map.
    • un Setthe keys ( Set<K>) -labels-
    • a collection of the stored objects ( Collection<V>)

    which allows you to iterate and work with the stored values ​​in different ways depending on what you need to do.

    And there are different implementations that I would highlight for you to investigate: TreeMap, LinkedHashMap, and HashMap.

    Here is the api documentation .

    • 1