Théorie 2.2: structures en Java

Théorie 2.2: structures en Java #

NOTE:

  • on va voir les paramètres de types plus en détail à l’étape 3


  • Le JDK Java contient plusieurs structures de données déjà codées

  • Dans ce cours, on va se concentrer sur les deux principales:

    • List<E>: une liste
    • Map<K,V>: un dictionnaire (mappage)

  • À partir de maintenant, vous devriez:

    • presque toujours utiliser une List<Integer> et jamais un tableau int[]
    • presque toujours utiliser les structures fournies dans le JDK Java

  • Exception: pour des raisons pédagogiques

    • p.ex. pour comprendre comment coder une liste

  • Exception: dans des cas bien précis où on a besoin de notre propre structure de données

    • p.ex. liste d’objets 2d conçue pour détection de collision

List<E>: liste en Java #

  • Exemple d’utilisation:
// interface                        implantation
   List<String> listeChaines  = new ArrayList<>(); 
   List<Double> listeReels    = new LinkedList<>(); 


listeChaines.add("sdf");        // ajoute à la fin
listeChaines.add("34g");
listeChaines.add("j554");
listeChaines.add(9,"asdf");     // nouvel élément
listeChaines.set(9,"asdf");     // change la valeur

String chaine = listeChaines.get(2);
  • Extrait de l’interface:
public interface List<E extends Object> extends Collection<E>{

    boolean    add(E e);           // ajoute à la fin
    void       add(int i, E e);    // insère une nouvelle valeur à la position i
    void       set(int i, E e);    // modifie la valeur à la position i
    E          get(int i);         // obtenir la valeur à la position i
    void       clear();            // vide la liste
    int        size();             // taille de la liste
    boolean    isEmpty();          // si vide
    boolean    contains(Object o); // si la liste contient la valeur o
    int        indexOf(Object o);  // indice de la valeur o


    //...
}

Implantations de List<E> #

  • List<E> est une interface

  • Le JDK Java fournit différentes implantations, p.ex:

    • ArrayList<E>
    • LinkedList<E>

  • Pour l’instant, on va utiliser ArrayList<E>

  • Quelle est la différence?

    • à utiliser: aucune (c’est la même interface)
    • en terme d’efficacité? à coder?
      • on va en parler à l’étape 4

Map<K,V>: mappage en Java #

  • Les clés d’un mappage peuvent être de n’importe quel type

    • contrairement à notre Dictionnaire où les clés étaients toujours des chaînes

  • Il y a deux paramètres de types:

    • K: le type des clés
    • V: le type des valeurs

  • IMPORTANT: une clé est associée à une seule valeur

  • Exemple d’utilisation:

// interface                          implantation
   Map<String, Object>     objetJson  = new HashMap<>(); 
   Map<Integer, String>    parDA      = new TreeMap<>(); 
   Map<StudentId, Billet>  rendezVous = new LinkedHashMap<>(); 

objetJson.put("attr01", true);
objetJson.put("attr02", null);
objetJson.put("attr03", 123.4);

Object valeur01 = objetJson.get("attr01");

parDA.put(421235, "Amina");
parDA.put(413354, "Bénison");
parDA.put(565624, "Carlos");
parDA.put(645143, "Delpine");

String nomEtudiant = parDA.get(413354);

StudentId id = new StudentId(645143);

rendezVous.put(id, new rendezVous());
rendezVous.get(id);

  • NOTE: on utilise la notation <P1, P2> quand il y a plusieurs paramètres de type

  • Extrait de l’interface:

public interface Map<K extends Object, V extends Object> {

    V          put(K c, V v);           // associe la valeur v à la clé c
    V          get(K c);                // obtenir la valeur associée à la clé c
    void       clear();                 // vide le map
    int        size();                  // taille du map
    boolean    isEmpty();               // si vide
    boolean    containsKey(Object c);   // si le map contient la clé c
    boolean    containsValue(Object v); // si le map contient la valeur v

    //...
}

Implantations de Map<K,V> #

  • Le JDK Java fournit différentes implantations, p.ex:

    • HashMap<K,V>
    • TreeMap<K,V>
    • LinkedHashMap<K,V>

  • Quelle est la différence?

    • à utiliser: presqu’aucune (*)
    • à coder? en terme d’efficacité?
      • on en parle à l’étape 5

  • (*) LinkedHashMap est un cas spécial:

    • en plus d’implanter l’interface Map<K,V>, on ajoute la promesse suivante:
      • il est possible d’accéder aux clés dans l’ordre où elles ont été insérées

Encoder des données JSON en Java #

  • Une liste JSON est représenté en Java par List<Object>

  • Un objet JSON est représenté en Java par Map<String, Object>

  • Par exemple:

{
  "_C": "MesDonneesJson",
  "racine": {
    "vehicules": [
      {
        "nombreDeRoues": 2,
        "type": "mobilette",
        "etat": {
          "besoinChangementHuile": false,
          "kilometrage": 14.45
        }
      },
      {
        "nombreDeRoues": 4,
        "type": "camion",
        "etat": {
          "besoinChangementHuile": true,
          "kilometrage": 13344.5
        }
      }
    ]
  }
}

public class MesDonneesJava extends DonneesJava {

    @Override
    public void initialiser(){

        Map<String, Object> laRacine = new HashMap<>();
        this.setRacine(laRacine);

        List<Object> lesVehicules = new ArrayList<>();
        laRacine.put("vehicules", lesVehicules);

        Map<String, Object> vehicule01 = new HashMap<>();
        lesVehicules.add(vehicule01);

        vehicule01.put("nombreDeRoues", 2);
        vehicule01.put("type", "mobilette");

        Map<String, Object> etat01 = new HashMap<>();
        vehicule01.put("etat", etat01);

        etat01.put("kilometrage",14.45);
        etat01.put("besoinChangementHuile",false);

        Map<String, Object> vehicule02 = new HashMap<>();
        lesVehicules.add(vehicule02);

        vehicule02.put("nombreDeRoues", 4);
        vehicule02.put("type", "camion");

        Map<String, Object> etat02 = new HashMap<>();
        vehicule02.put("etat", etat02);

        etat02.put("kilometrage",13344.5);
        etat02.put("besoinChangementHuile",true);
    }
}
Creative Commons License Creative Commons Attribution Creative Commons ShareAlike