1. Aperçu des décors<br>

1) Le concept des décors

Les décors dans la vraie vie : beaucoup de choses mises ensemble .

Ensemble en mathématiques : une population de choses ayant des propriétés communes.

La classe collection en Java : est une classe d'outils, comme un conteneur, qui stocke un nombre quelconque d'objets avec des propriétés communes.

2) Le rôle des ensembles

S'il existe plusieurs propriétés du même type à l'intérieur d'une classe, et que leurs fonctions et significations sont les mêmes. Par exemple, un étudiant peut choisir plusieurs cours. Pour une classe d'étudiant, XX cours est un attribut de lui, et il y a généralement plus d'un XX cours. Pour des situations comme celle-ci, il serait trop fastidieux de définir un attribut pour chaque cours. Nous devons ici utiliser la notion d'ensembles.

Pour résumer, les fonctions des ensembles ont les points suivants :

1. Au sein la classe, les données sont organisées.

2. Recherchez de grandes quantités d'articles simplement et rapidement.

3. Certaines interfaces de collection fournissent une série d'éléments ordonnés, et les éléments associés peuvent être rapidement insérés ou supprimés au milieu de la séquence.

4. Certaines interfaces de collection fournissent des relations de mappage, et vous pouvez trouver rapidement l'objet unique correspondant grâce à la clé, et cette clé peut être de n'importe quel type.

3) Comparaison des ensembles et des tableaux

On peut voir que les ensembles et les tableaux ont des fonctions similaires. Ils mettent tous deux une série de données dans un conteneur, mais pourquoi. utilisons-nous des ensembles au lieu de tableaux à l’intérieur des classes ?

1. La longueur du tableau est fixe et la longueur de la collection est variable. L'avantage d'une collection est que la longueur de la collection s'étend avec le contenu à l'intérieur, tandis que la longueur du tableau est déjà définie.

2. Les tableaux ne peuvent accéder aux éléments que via des indices, et le type est fixe (les indices du tableau ne peuvent être que des entiers), tandis que certaines collections peuvent trouver les éléments spécifiques mappés via n'importe quel type d'objet. (le mot-clé clé peut être de n’importe quel type).

2. Architecture du framework de collection Java

Jetons un bref coup d'œil au framework de collection Java : (Il existe de nombreuses interfaces et classes non répertoriées , seules les interfaces et classes couramment utilisées sont répertoriées ici)

Comme le montre la figure, l'architecture du framework de collection JAVA : Collection et Map sont les deux interfaces racine.

Interface de collection : Stocke en interne des objets indépendants. Contient :

1. Interface de liste : Séquence, qui stocke les éléments de manière ordonnée et répétable. Classe d'implémentation : ArrayList, séquence de tableau ; Classe d'implémentation : LinkedList, liste chaînée.

Queue, qui stocke les éléments de manière ordonnée et reproductible. Classe d'implémentation : LinkedList, liste chaînée. 3. Interface Set :

, stockage des éléments non ordonnés et non répétables. Classe d'implémentation : HashSet, jeu de hachage.

utilise en interne un mappage de (n'importe quel type) pour stocker des données. Ce mappage est la classe Entry (interne de Map. classe) instance. Comprend : Classe d'implémentation : HashMap, table de hachage. L'interface de collection est l'interface parent des interfaces List, Set et Queue. L'interface de collection définit les méthodes qui peuvent être utilisées pour faire fonctionner List, Set et Queue - ajouter, supprimer, modifier et interroger. (Les méthodes spécifiques de l'interface Collection peuvent être trouvées en vérifiant l'API, elles ne seront donc pas répertoriées ici.)

Parmi elles, ArrayList, HashSet et HashMap sont les trois classes d'implémentation les plus couramment utilisées. présentera ces trois implémentations une par une.

<br>

List peut contrôler avec précision la position d'insertion de chaque élément, ou supprimer un élément à une certaine position ;

List a une méthode d'insertion add() et une méthode d'acquisition get() ; >

ArrayList est implémentée par array, qui est également à l'origine de son nom.

Alors comment utiliser ces collections ? Utilisons un petit exemple et écrivons un petit programme pour apprendre à utiliser les ensembles de manière plus intuitive. (Les exemples des articles suivants sont également basés sur cela)

>>>>>>>>>>>>> > ;>>>>>>>>>>>>>>>>>>>>>>>> > ;>>>

Fonction de programme - simuler la fonction de sélection de cours des étudiants

1. Choisir des cours (ajouter des cours à la collection)

2. Supprimer un cours sélectionné (supprimer des éléments de la collection)

3. Afficher les cours sélectionnés

4. Modifier le cours sélectionné

>>>>>>>>>>>>>> ;> ;>>>>>>>>>>>>>>>>>>>>>>>> ;> ;>>

Ce qui suit est un extrait de code du programme, car il est utilisé à des fins de tests pour introduire l'utilisation des collections, veuillez donc ne pas prêter attention aux détails , le code sera amélioré étape par étape .

1) Créer une classe d'élève et une classe de cours

 1 /** 2  * 学生类 3  * @author hysum 4  * 5  */ 6 public class Student implements { 7     private String name;//学生姓名 8     private String id;//学生id 9     private Set courses;//所选课程的set集合10     11     public Student(){}12     public Student(String id,String name){13         this.id=id;14         this.name=name;15         this.courses=new HashSet();//初始化集合16     }17     public String getName() {18         return name;19     }20     public void setName(String name) {21         this.name = name;22     }23     public String getId() {24         return id;25     }26     public void setId(String id) {27         this.id = id;28     }29     public Set getCourses() {30         return courses;31     }32     public void setCourses(Set courses) {33         this.courses = courses;34     }

 1 /** 2  * 课程类 3  * @author hysum 4  * 5  */ 6 public class Course { 7 private String id;//课程id 8     private String name;//课程名称 9     10     public Course(){11         12     }13     public Course(String name){14         this.name=name;15     }16     public String getId() {17         return id;18     }19     public void setId(String id) {20         this.id = id;21     }22     public String getName() {23         return name;24     }25     public void setName(String name) {26         this.name = name;27     }28     public Course(String id,String name){29         this.id=id;30         this.name=name;31     }32 }

2) Créer une classe de cours alternative

 1 /** 2  * 备选课程类 3  * 
 4  * @author hysum 5  * 6  */ 7 public class ListCourse { 8 private List CoresesToSelect;// 备选课程 9     private Student stu;10     private static Scanner in;11     {12         in = new Scanner(System.in);13     }14     public ListCourse() {15         this.CoresesToSelect = new ArrayList();// 初始化List集合16     }17        public List getCoresesToSelect() {18         return CoresesToSelect;19     }20 21     public void setCoresesToSelect(List coresesToSelect) {22         CoresesToSelect = coresesToSelect;23     }   26 }

Remarque :

List est une interface, elle ne peut donc pas être instanciée directement dans le constructeur, mais est instanciée via ArrayList() ! ! !

Exemple : public List coursesToSelect = new ArrayList();

Set et Map sont similaires et ne peuvent pas être instanciés directement. Vous devez utiliser la classe d'instanciation correspondante telle que HashSet. (), HashMap();

3) Ajouter des cours aux cours alternatifs

(Ajouter des éléments) Il existe un total de 4 méthodes pour insérer des éléments dans la liste sous Liste :

1.add(element);

2.add(index,element);

3.addAll(Arrays.asList(object array name));

4.addAll(index,Arrays.asList(object array name));

L'exemple de code suivant :

 1 /* 2  * 添加备选课程 3  */ 4 public void AddCourse() { 5         Course cr1=new Course("1","数据结构");//创建课程对象 6     this.CoresesToSelect.add(cr1);//用add(element)添加  7         Course temp=(Course)this.CoresesToSelect.get(0);//用get方法取出，注意类型转换 8     System.out.println("添加了课程："+temp.getId()+" "+temp.getName()); 9         10         Course cr2=new Course("2","C语言");//创建课程对象11     this.CoresesToSelect.add(0,cr2);//用add(index,element)添加 12     temp=(Course)this.CoresesToSelect.get(0);13         System.out.println("添加了课程："+temp.getId()+" "+temp.getName());  
14 }

1 Course[] course = { new Course("1", "数据结构"), new Course("2", "C语言"), new Course("3", "汇编语言"),2                 new Course("4", "离散数学") };3         this.CoresesToSelect.addAll(Arrays.asList(course));//用addAll(Arrays.asList(对象数组名))添加

Remarque :

1. Lorsque des objets sont stockés dans la collection, ils deviennent des types d'objets. Une conversion de type est requise lors de leur retrait. (Nous utiliserons des génériques pour résoudre ce problème plus tard)

Exemple : Course temp = (Course)coursesToSelect.get(0);

2. La position (index) ajoutée à la liste est comprise entre [0, longueur] ; 0 signifie une insertion en tête de la file d'attente et une longueur signifie une insertion à la fin de la file d'attente.

3. Si la longueur ajoutée à la liste est supérieure à sa longueur actuelle, une exception se produira dans le système, c'est-à-dire une exception hors limites dans le tableau sous le tableau, telle que :

1 Course cr2=new Course("2","C语言");//创建课程对象2 this.CoresesToSelect.add(2,cr2);//用add方法添加,超出集合现有长度 temp=(Course)

4) Suppression et impression des cours alternatifs

Les trois méthodes suivantes sont utilisées pour supprimer des éléments de la Liste :

-----for Loop-----

1 public void testGet(){2 int size=CoursesToSelect.size();3 for(int i=0;i<size;i++){4 Course cr=(Course) CoursesToSelect.get(i);5 System.out.println("取出的课程："+cr.getId()+":"+cr.getName());6 }7 }

-----Itérateur-----

Iterator est une interface qui dépend de l'existence de collections.

1 Iterator it=CourseToSelect.iterator();2 while(it.hasNext()){3 Course cr=(Course) it.next();4 System.out.println("课程:" + cr.id + ":" + cr.name);5 }

-----pour chacun (utilisation recommandée)-----

1 for(Object obj:CoursesToSelect){//遍历集合中的每一个元素，作为每一个Object变量2 Course cr=(Course) obj;3 System.out.println("课程:" + cr.id + ":" + cr.name);4 }

5) Modification de cours alternative

Utilisez set (index, élément Object) pour modifier l'élément, l'index représente la position de l'index et l'élément représente le nouvel objet.

1     /*2      * 修改备选课程3      */4     public void Modify(int index, Course c) {// 传入要修改的参数5         this.CoresesToSelect.set(index, c);6     }

6) Supprimer les éléments de cours alternatifs

La liste contient Remove(index), Remove(object value) et RemoveAll(Arrays.asList(object array name) ) méthode pour supprimer la valeur d’un élément dans le conteneur (l’utilisation est similaire à add).

Course est une classe de cours d'information avec des attributs id et name ; courseToSelect est un objet conteneur de séquence de liste.

 1     /* 2      * 删除备选课程，跟添加方法类似 3      */ 4     public void Remove(int index) {// 通过索引位置删除 5         this.CoresesToSelect.remove(index); 6     } 7  8     public void Remove(Course c) {// 通过课程对象删除 9         this.CoresesToSelect.remove(c);10 11     }12 13     public void Remove(Course[] c) {// 通过集合对象删除14         this.CoresesToSelect.removeAll(Arrays.asList(c));15 16     }

注意：

1.remove(index);删除位置要大于0并且小于List(序列容器)的长度。如果要删除全部可以用for循环嵌套此方法。

2.remove(object);先要获得删除的值，用法是先定义一个信息变量通过get()来存放要删除的值,然后用remove(删除的对象值);

3.removeAll(Arrays.asList());要删除指定的多个位置 Arrays.asLIst(对象数组名);作用是把数组转换为集合。用法是先创建信息对象数组存放删除元素的值，然后再用removeAll(Arrays.asList(对象数组名))方法,删除集合数组的元素。

四、应用泛型管理课程

在上面的几个例子中，小伙伴是否发现对于集合的取出和遍历都要将Object对象进行强制转换后才能使用，每次这样做不仅增加了编程难度还使代码特别繁琐，这里我们可以利用泛型来帮助我们更加方便地使用java集合。

首先，我们要知道没有使用泛型的话，集合中的元素,可以是任意类型的对象(对象的引用)，如果把某个对象放入集合,则会忽略他的类型把他当做Object处理。

那么我们就在刚才的例子里往备选课程类里的CoresesToSelect的List集合添加一些奇怪的东西会发什么有趣的事呢？

1 　　　/*2      * 往List中添加一些奇怪的东西3      */4      public void testType(){5      System.out.println("能否往List中添加一些奇怪的东西呢?");6      this.CoresesToSelect.add("我不是课程，我是字符串！");7      }

当调用取出课程方法取出该元素时，运行时出错：

这是因为取出该元素时String类型不能强制转换为Course类型，那有什么办法来避免集合中被添加不希望添加的类型呢？

泛型则是规定了某个集合只可以存放特定类型的对象，会在编译期间进行类型检查，可以直接指定类型获取的集合元素。

泛型：指规定了某个集合只能存放特定类型的对象。

语法：ArrayList<String> array=new ArrayList<String>();  //规定array中只能存放String类型的对象

那么，了解了泛型之后，上面的例子里都可以加上泛型了，修改如下（只列出修改的部分）：（自行对比）

1 private Set<Course> courses;//所选课程的set集合2 this.courses=new HashSet<Course>();//初始化集合3 public Set<Course> getCourses() {4         return courses;5     }6     public void setCourses(Set<Course> courses) {7         this.courses = courses;8     }

 1 private List<Course> CoresesToSelect;// 备选课程 2 public ListCourse() { 3         this.CoresesToSelect = new ArrayList<Course>();// 初始化List集合 4     } 5 public List<Course> getCoresesToSelect() { 6         return CoresesToSelect; 7     } 8  9     public void setCoresesToSelect(List<Course> coresesToSelect) {10         CoresesToSelect = coresesToSelect;11     }

foreach循环的修改：

1 for (Course obj : CoresesToSelect) {        
2     System.out.println("添加了课程：" + obj.getId() + " " + obj.getName());4 }

<br>

运用了泛型的话，用foreach语句时 存储变量应该为泛型的类型。for(Course a:courseToSelect),不必再用Object取出再强转，因为已经规定容器里装的都是Course类型。

使用泛型要注意：

1.泛型集合中，不能添加泛型规定的类型和其子类以外的对象，否则会报错！

2.泛型中可以添加规定的类型的子类型的对象。如：

1 public void testChild() {2         ChildCourse ccr = new ChildCourse();3         ccr.id = "3";4         ccr.name = "我是子类型的课程对象实例~~";5         courses.add(ccr);6 }

3.不能直接添加基本类型（int,float等）的对象，如果要添加，需要使用其包装类。如：

1 public void testBasicType() {2 List<Integer> list = new ArrayList<Integer>();3 list.add(1);4 System.out.println("基本类型必须使用包装类作为泛型！" + list.get(0));5 }

五、通过Set集合管理课程

Set集合和List一样是Collection接口的子接口。它的方法跟List类似，但有稍许不同，因为Set集合是无序且不重复的。

1）添加学生选课的课程

add方法跟ArrayList一样

 1 li.stu=new Student("1","小明"); 2         System.out.println("欢迎"+li.stu.getName()+"同学选择课程"); 3         for(int i=0;i<3;i++){//循环三次添加选课 4             System.out.println("请选第"+(i+1)+"门课程："); 5             String Id=in.next(); 6             for(Course c:li.getCoresesToSelect()){ 7                 if(c.getId().equals(Id)){ 8                     li.stu.getCourses().add(c); 9                 }10             }11             12         }

注意：Set 中添加某个对象，无论添加多少次，最终只会保留一个该对象（的引用）。同时，保留的是第一次添加的那一个。Set集合是无序的不可重复的。

2）打印输出学生选的课程

1 //输出学生选的课程2         for(Course c:li.stu.getCourses()){3             System.out.println(c.getId()+" "+c.getName());4 5         }

Remarque : Vous ne pouvez utiliser que foreach ou iterator pour parcourir chaque élément de l'ensemble, et vous ne pouvez pas utiliser la méthode get() comme List. Comme il n'est pas ordonné, les résultats de sortie seront légèrement différents à chaque fois.

>>>>>>>>>>>>>>>>

Résumé :

1. Set n'est pas modifié comme la méthode set() dans List, car List est ordonné et la position peut être spécifiée, et. L'ensemble n'est pas ordonné et peut être modifié par parcours de boucle.

2. Lors de l'interrogation et du parcours, Set ne peut pas être obtenu à l'aide de la méthode get() car l'ID d'index n'est pas spécifié dans l'ordre non ordonné, mais vous pouvez utiliser foreach et iterator pour parcourir, mais l'ordre peut être différent à chaque fois qu'on le traverse. C'est toujours causé par le désordre.

3. size(), add(), addAll(), Remove(), RemoveAll() dans Set sont similaires à List.

4. Set peut également ajouter null (mais un seul null peut être ajouté car il n'est pas répété