Discussion :

[ZoliveR]

Bonjour!

J'ai parcouru le tuto sur les collections mais j'ai un petit doute...
Je ne sais pas si on peut faire "amstramgram" sur le type de collection à choisir pour certains.

Je sais que pour Map il s'agit d'une paire d'éléments, je sais que Set c'est un seul élément et qu'il n'autorise pas de doublons, et que List autorise les doublons..

J'ai un jeu comme exercice à implémenter (jeu de bataille) et le prof a choisi Queue comme type de Collection pour l'objet Carte, mais qu'est ce qui fait que j'utiliserais Queue et pas LinkedList ou ArrayList? Qu'est ce qui pourraient les différencier dans le choix de leur utilisation?

Petite autre question en passant, j'ai vu plein d'images sur la hierarchie des collections, mais dans Eclipse je ne vois pas de SortedSet ou SortedMap...

List ArrayList, LinkedList, Vector
Map HashTable, HashMap (> LinkedHashMap), SortedMap > NavigableMap > TreeMap
Set HashSet (> LinkedHashSet), SortedSet > NavigableSet > TreeSet
Queue LinkedList, PriorityQueue

Concernant les Generics, j'ai vu à plusieurs endroits des "conventions"

Conventions*: <E>lement (collections) <K>ey et <V>alue (ensembles) <N>umber
<T>ype <S>econd <U>3ème <V>4ème
Je n'ai pas vraiment compris pourquoi ces conventions*? Quand les utiliser au lieu de <String>*?

Je vois par exemple dans l'exercice Queue<Carte> ce qui correspond à la classe Carte.
Mais les conventions je ne comprends pas

Merci pour votre réponse et pour le temps consacré

[eulbobo]

J'ai un jeu comme exercice à implémenter (jeu de bataille) et le prof a choisi Queue comme type de Collection pour l'objet Carte, mais qu'est ce qui fait que j'utiliserais Queue et pas LinkedList ou ArrayList? Qu'est ce qui pourraient les différencier dans le choix de leur utilisation?

Queue est une interface (si tu parles bien de java.util.Queue), donc tu peux utiliser n'importe quelle implémentation de Queue (LinkedList, PriorityQueue, et toutes les BlockingQueue)

Petite autre question en passant, j'ai vu plein d'images sur la hierarchie des collections, mais dans Eclipse je ne vois pas de SortedSet ou SortedMap...

TreeSet est un SortedSet...
TreeMap est un SortedMap...
Ce sont deux interfaces là aussi, avec plusieurs implémentations différentes en fonction des résultats attendus (mais avec des fonctions identiques)

Concernant les Generics, j'ai vu à plusieurs endroits des "conventions"

Conventions*: <E>lement (collections) <K>ey et <V>alue (ensembles) <N>umber
<T>ype <S>econd <U>3ème <V>4ème
Je n'ai pas vraiment compris pourquoi ces conventions*? Quand les utiliser au lieu de <String>*?

En fait, ce qu'on note en <T>, <E>, etc... sont des "marqueurs" pour indiquer grossièrement ce qui sera utilisé comme type générique par la classe.
Du coup, pour une liste, c'est une liste d'éléments, du coup la convention est de la déclarer en tant que List<E>
Mais on aurait aussi pu la déclarer en List<Abracadabra>, ça aurait eu le même résultat (si Abracadabra n'est pas une classe existante)
Ces conventions sont là pour quand tu veux toi même créer des classes avec des opérateurs génériques.

Cette convention d'utiliser une seule lettre dans la déclaration est pour permettre de ne pas confondre un type générique avec une classe existante.
Parce que si ton interface était déclarée en tant que

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

public interface Map<Key,Value> {...

Et que à côté tu avais les classes Key et Value, ça pourrait porter à confusion !

Donc par convention, quand on crée une classe qui pourra utiliser un type générique, c'est une seule lettre en majuscule. Quand on utilise une classe qui possède des types génériques, on précise la classe utilisée.

Quand tu notes Queue<Carte>, tu indiques que tu vas utiliser une Queue qui ne contiendra QUE des cartes (ou des éléments qui ont Carte en superclasse).

[eulbobo]

Petite classe de démonstration (a noter que ce qu'il y a dans le public static void main pourrait être utilisé n'importe où ailleurs)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
 
public class MyUselessClass<Abracadabra> {
 
	protected Abracadabra myMagicalVar;
 
	public Abracadabra getValue() {
		return myMagicalVar;
	}
 
	public void setValue(Abracadabra value) {
		this.myMagicalVar = value;
	}
 
	public static void main(String[] args){
		MyUselessClass<String> myStr = new MyUselessClass<String>();
		myStr.setValue("String value");
 
		MyUselessClass<List<List<String>>> myLilist = new MyUselessClass<>();
		myLilist.setValue(new ArrayList<List<String>>());
 
		MyUselessClass<Number> myNumber = new MyUselessClass<>();
		myNumber.setValue(42);
		myNumber.setValue(4.2);
	}
}

Du coup, tu comprends que quand on déclare une classe utilisant un type générique, on préfère mettre des noms le plus court possible
Version avec un nom court (et je mets T parce que j'aime bien mettre T même si ici ma classe contient un élément et non un type, et que du coup je devrais mettre E si on voulait être parfait dans les conventions de nommage) :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
 
public class MyUselessClass<T> {
 
	protected T myMagicalVar;
 
	public T getValue() {
		return myMagicalVar;
	}
 
	public void setValue(T value) {
		this.myMagicalVar = value;
	}
 
	public static void main(String[] args){
		MyUselessClass<String> myStr = new MyUselessClass<String>();
		myStr.setValue("String value");
 
		MyUselessClass<List<List<String>>> myLilist = new MyUselessClass<>();
		myLilist.setValue(new ArrayList<List<String>>());
 
		MyUselessClass<Number> myNumber = new MyUselessClass<>();
		myNumber.setValue(42);
		myNumber.setValue(4.2);
	}
}

[adiGuba]

Salut,

Je sais que pour Map il s'agit d'une paire d'éléments, je sais que Set c'est un seul élément et qu'il n'autorise pas de doublons, et que List autorise les doublons..

Les Lists correspondent aussi et surtout à des éléments ordonnés et indexés, ce qui n'est pas forcément le cas des autres collections qui n'ont pas forcément de notion d'ordre...

J'ai un jeu comme exercice à implémenter (jeu de bataille) et le prof a choisi Queue comme type de Collection pour l'objet Carte, mais qu'est ce qui fait que j'utiliserais Queue et pas LinkedList ou ArrayList? Qu'est ce qui pourraient les différencier dans le choix de leur utilisation?

Attention déjà tu mélanges l'interface (Queue) avec les implémentations (LinkedList, ArrayList).

Pour faire ton choix tu dois d'abord choisir l'interface qui représente le mieux ton besoin.
Set représente des éléments uniques. De primes abord cela pourrait correspondre pour un jeu de carte... mais ne fait c'est inutile puisque tes données (les cartes) sont déjà unique.
De plus comme les Set n'ont pas forcément d'ordre, ce qui peut être gênant.

List représente des éléments ordonnées et indexés, et cela pourrait tout à fait suffire à ton besoin en effet. Même si l'index n'est pas vraiment utile (en toute logique tu n'as pas à accéder à la nième carte, mais uniquement à la première carte du paquet).

Du coup les Queue représente vraiment ce dont tu as besoin puisqu'il y a bien la notion d'ordre et de quoi manipuler la première carte.
Ca semble tout adapté.

Petite autre question en passant, j'ai vu plein d'images sur la hierarchie des collections, mais dans Eclipse je ne vois pas de SortedSet ou SortedMap...

Ben pourtant tu les indiques dans ton listing : TreeMap et TreeSet.

Je n'ai pas vraiment compris pourquoi ces conventions*? Quand les utiliser au lieu de <String>*?

Je vois par exemple dans l'exercice Queue<Carte> ce qui correspond à la classe Carte.
Mais les conventions je ne comprends pas

La différence c'est que dans le premier cas on ne connait pas le type exact (il sera défini à l'utilisation).
Par convention on utilise une lettre majuscule pour représenter ce type, afin d'éviter les confusions :

• Queue<E> une queue d'élément où "E" sera remplacé par un vrai type à l'utilisation.
• Queue<Element> une queue d'objet de type Element.

a++

[ZoliveR]

Merci pour vos réponses, je viens de comprendre car en fait je voyais les collections dans quelques Mindmap et je pensais qu'on pouvait trouver par exemple dans Map à la fois SortedSet, NavigableSet et TreeSet alors que seul existe réellement TreeSet (c'est un exemple)

C'est difficile d'être exhaustif quand les informations sont parcellaires (on a des infos mais on se rend compte que ça "colle" pas dans Eclipse

Quand j'essaie un truc du genre Queue<String> bla = new Queue<String>();

Eclipse me dit que le 2ème Queue ne marche pas. Je recherche un maximum d'infos sur le net et certaines méthodes ne collent pas dans Eclipse (mais je fais avec ce que j'ai)
Ce serait tellement plus simple si je pouvais trouver sur un même site "voilà, dans List vous avez... dans Set vous avez... " je cherche à être le plus exhaustif possible.



Quant aux conventions, si on utilise <E> alors on doit renommer sa classe en <E>? Moi je comprends pas, ce que je vois c'est que je peux utiliser comme type: un type primitif, ou un objet. Donc <String>, <Integer>, <Double>, <Float>, <Boolean>, ... ou pour le cas où je développe des classes avec objet, <Personne>, <Voiture>, <Joueur> <Carte>, <Banque>...

Donc le <E>, <T>, <K>, ... me rend un peu perplexe...
Je vais quand même pas commencer à mettre "List<E> bla = newArrayList<E>(); " si E n'existe pas dans ma classe...

Merci en tout cas pour tout

[eulbobo]

Je vais quand même pas commencer à mettre "List<E> bla = newArrayList<E>(); " si E n'existe pas dans ma classe...

Si tu déclares ta classe en tant que :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
 
public class MaClasse<E>{
     public void myFunction(){
          List<E> bla = newArrayList<E>(); // Legal !
     }
}

Ton E "existe" comme un type d'objet non défini (générique). Tu ne sais pas ce que c'est quand tu programmes.

Si tu ne déclares pas ton type générique

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
 
public class MaClasse{
     public void myFunction(){
          List<E> bla = newArrayList<E>(); // Compilation Error ! E inconnu !
     }
}

Derrière, tu peux définir toi même aussi à la création de ta classe des éléments à partir de classes génériques :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
 
public class MaClasse implements Comparable<String>{
 
     public int compareTo(String o) { // le type String vient de la définition de Comparable<String>
		return 0;
     }
}

Et rendre toi même ta liste générique

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
 
public class MaClasse<E> implements Comparable<String>{
 
     public void myFunction(){
          List<E> bla = newArrayList<E>(); // Legal !
     }
 
     public int compareTo(String o) { // le type String vient de la définition de Comparable<String>
		return 0;
     }
}

Bref, les types génériques, il faut les déclarer dans les classes (public class MaClasse<K>) ou dans les méthodes

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
 
public <T> T doThings(T element){
                System.out.println(element);
                // faire plein de choses avec l'élément passé en paramètre
		return element;
	}

Cette méthode déclare un type générique <T>, renvoie le type générique T, et on doit lui passer un objet de type T en paramètre.
A l'usage, ça donne :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
 
String str = doThings("string");
Integer integ = doThings(12);
Object obj = doThings("string"); // String est un object, donc ça marche, mais ça n'a aucun intérêt ici)

[joel.drigo]

Salut,

Merci pour vos réponses, je viens de comprendre car en fait je voyais les collections dans quelques Mindmap et je pensais qu'on pouvait trouver par exemple dans Map à la fois SortedSet, NavigableSet et TreeSet alors que seul existe réellement TreeSet (c'est un exemple)

C'est difficile d'être exhaustif quand les informations sont parcellaires (on a des infos mais on se rend compte que ça "colle" pas dans Eclipse

Quand j'essaie un truc du genre Queue<String> bla = new Queue<String>();
Eclipse me dit que le 2ème Queue ne marche pas. Je recherche un maximum d'infos sur le net et certaines méthodes ne collent pas dans Eclipse (mais je fais avec ce que j'ai)

Eclipse ne de dit pas que la 2ème Queue ne marche pas, mais que Queue est une interface, et qu'on ne peut pas instancier une interface. C'est la base du langage. Une interface définit des méthodes : on implémente une interface dans une classe, ce qui signifie : 1) que les méthodes de l'interface doivent être implémentées dans la classe 2) qu'on peut utiliser une instance de la classe typée par l'interface.

Ce serait tellement plus simple si je pouvais trouver sur un même site "voilà, dans List vous avez... dans Set vous avez... " je cherche à être le plus exhaustif possible.

Toutes ces informations sont dans la javadoc. Elle est exhaustive. Dans Eclipse, une vue permet de la voir directement (en sélectionnant l'interface), sinon il y a la vue outline aussi qui permet de voir les , et d'autres (Package Explorer par exemple).

Quant aux conventions, si on utilise <E> alors on doit renommer sa classe en <E>? Moi je comprends pas, ce que je vois c'est que je peux utiliser comme type: un type primitif, ou un objet. Donc <String>, <Integer>, <Double>, <Float>, <Boolean>, ... ou pour le cas où je développe des classes avec objet, <Personne>, <Voiture>, <Joueur> <Carte>, <Banque>...

Donc le <E>, <T>, <K>, ... me rend un peu perplexe...
Je vais quand même pas commencer à mettre "List<E> bla = newArrayList<E>(); " si E n'existe pas dans ma classe...

Merci en tout cas pour tout

Tu dois considérer 2 cas :

• La définition de classe
• L'utilisation de classe

Quand on utilise une classe, qu'on instancie par exemple une classe pour mettre sa référence dans une variable, on indique le vrai type, ou une expression qui signifie "un type quelqu'onque qui étend un type déterminé", par exemple.

Quand tu écris

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

Map<String, Integer> map = new HashMap<>();

Tu dis je créer une variable map, de type Map, dont les clefs sont des String et les valeurs associées des Integer, et la classe concrète qui implémente l'interface Map pour cette instance est la classe HashMap. Ici, depuis, Java 7, on peut omettre les types entre < et > pour la classe concrète car le compilateur sait que ça ne peut être celles qu'on a indiquée pour le type de la variable. On aurait pu écrire :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

Map<String, Integer> map = new HashMap<String, Integer>();

Par contre, quand on définit une classe paramétrée, on le fait justement parce qu'on ne veut pas forcément imposer un type déterminé.

Par exemple, prenons cet exemple tout simple :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class MaClasse [
 
    private String valeur;
 
    public void setValeur(String valeur) {
         this.valeur=valeur;
    }
 
    public String getValeur() {
         return valeur;
    }
 
 
}

Ici on impose que valeur soit du type String.

Maintenant, si on veut que valeur soit de n'importe quel type, on va faire :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
public class MaClasse<T> [
 
    private T valeur;
 
    public void setValeur(T valeur) {
         this.valeur=valeur;
    }
 
    public T getValeur() {
         return valeur;
    }
 
}

Le <T> déclare le paramètre : comme pour un paramètre de méthode, on lui donne un nom. Peu importe ce nom à la base. Maintenant il y a des conventions usuelles pour qu'on estime au premier coup d'oeil le sens du paramètre, c'est tout.
A partir du moment ou le paramètre est déclaré dans la classe, on peut l'utiliser dans la classe, pour définir ses méthodes et attributs, on l'utilise en utilisant son nom. Ici T.
On aurait pu faire :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
public class MaClasse<LACLASSEDELATTRIBUTVALEUR> [
 
    private LACLASSEDELATTRIBUTVALEUR valeur;
 
    public void setValeur(LACLASSEDELATTRIBUTVALEUR valeur) {
         this.valeur=valeur;
    }
 
    public LACLASSEDELATTRIBUTVALEUR getValeur() {
         return valeur;
    }
 
}

Ici LACLASSEDELATTRIBUTVALEUR (ou T dans le cas précédent) représente n'importe quelle classe : on ne sait pas par avance laquelle, donc on ne peut pas mettre String, ou Integer ou quoique ce soit. On ne sait pas, mais on veut que ça n'importe quelle classe.

Mais quand on va utiliser la classe, par contre, on va dire pour quelle type on l'instancie : on va donner une valeur au paramètre.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
MaClasse<String> maVariable1 = new MaClasse<>();
maVariable1.setValeur("toto");
MaClasse<JFrame> maVariable2 = new MaClasse<>();
maVariable2.setValeur(new JFrame());
MaClasse<Map<String, Integer>> maVariable3 = new MaClasse<>();
maVariable3.setValeur(new HashMap<String, Integer>());

[thelvin]

Ce serait tellement plus simple si je pouvais trouver sur un même site "voilà, dans List vous avez... dans Set vous avez... " je cherche à être le plus exhaustif possible.

On appelle ça la JavaDoc.

La page pour List.

La page pour Set.

C'est pas compliqué.
Par contre il y a beaucoup de choses, c'est sûr. Java fournissant des outils pour la programmation concurrente, qui ne te concerne pas pour l'instant.
Il faut essayer intuitivement de ne regarder que les collections dans java.util et pas dans les sous-package, en se disant que celles-là on les découvrira plus tard.

[ZoliveR]

Merci pour toutes vos réponses, je vais essayer de lire ça à tête reposée et de comprendre.
J'ai un examen dans 3 semaines mais je n'ai plus la pression des notes, par contre j'ai envie de réussir. Mais Java peut être si complexe! Alors quand j'ai vu qu'il y avait plusieurs sous-langages en Java, j'ai failli m'arracher le peu de cheveux que j'avais. Je mets résolu.