Einführung in die Java Collections Framework-Architektur

1. Überblick über Sets<br>

1) Das Konzept von Sets

Sets im wirklichen Leben: viele Dinge zusammengefügt .

Menge in der Mathematik: eine Population von Dingen mit gemeinsamen Eigenschaften.

Die Collection-Klasse in Java: ist eine Tool-Klasse, ähnlich einem Container, die eine beliebige Anzahl von Objekten mit gemeinsamen Eigenschaften speichert.

2) Die Rolle von Mengen

Wenn es innerhalb einer Klasse mehrere Eigenschaften desselben Typs gibt und ihre Funktionen und Bedeutungen gleich sind. Beispielsweise kann ein Student mehrere Kurse auswählen. Für einen Studentenkurs ist der XX-Kurs ein Attribut von ihm, und es gibt normalerweise mehr als einen XX-Kurs. In solchen Situationen wäre es zu umständlich, für jeden Kurs ein Attribut zu definieren. Hier müssen wir das Konzept der Mengen verwenden.

 

Zusammenfassend haben die Funktionen von Sets die folgenden Punkte:

1. Innerhalb In der Klasse sind die Daten organisiert.

2. Suchen Sie einfach und schnell nach großen Mengen an Artikeln.

3. Einige Sammlungsschnittstellen bieten eine Reihe geordneter Elemente, und verwandte Elemente können in der Mitte der Sequenz schnell eingefügt oder gelöscht werden.

4. Einige Sammlungsschnittstellen bieten Zuordnungsbeziehungen, und Sie können das entsprechende eindeutige Objekt schnell über den Schlüssel finden. Dieser Schlüssel kann von beliebiger Art sein.

3) Vergleich von Mengen und Arrays

Es ist ersichtlich, dass Mengen und Arrays ähnliche Funktionen haben. Sie legen beide eine Reihe von Daten in einem Container ab, aber warum Verwenden wir innerhalb von Klassen Mengen anstelle von Arrays?

1. Die Länge des Arrays ist fest und die Länge der Sammlung ist variabel. Der Vorteil einer Sammlung besteht darin, dass die Länge der Sammlung mit dem darin enthaltenen Inhalt wächst, während die Länge des Arrays bereits definiert ist.

2. Arrays können nur über Indizes auf Elemente zugreifen, und der Typ ist festgelegt (Array-Indizes können nur Ganzzahlen sein), während einige -Sammlungen die zugeordneten spezifischen Elemente über jeden Objekttyp finden können (Schlüsselwort kann beliebiger Art sein).

---

2. Java Collection Framework-Architektur

Werfen wir einen kurzen Blick auf das Java Collection Framework: (Es gibt viele Schnittstellen und Klassen, die nicht aufgeführt sind (Hier werden nur häufig verwendete Schnittstellen und Klassen aufgeführt.)

Wie in der Abbildung gezeigt, ist die Architektur des JAVA-Sammlungsframeworks: Sammlung und Karte die beiden Stammschnittstellen.

Sammlungsschnittstelle: Speichert intern unabhängige Objekte. Enthält:

1. Listenschnittstelle: Sequenz, die Elemente geordnet und wiederholbar speichert. Implementierungsklasse: ArrayList, Array-Sequenz; Implementierungsklasse: LinkedList, verknüpfte Liste.

2. Warteschlangenschnittstelle:

Warteschlange, die Elemente geordnet und wiederholbar speichert. Implementierungsklasse: LinkedList, verknüpfte Liste. 3. Set-Schnittstelle:

Set

, Elemente speichern ungeordnet und nicht wiederholbar. Implementierungsklasse: HashSet, Hash-Set.

Map-Schnittstelle:

verwendet intern eine Zuordnung von (beliebiger Typ) zum Speichern von Daten. Diese Zuordnung ist die Entry-Klasse (intern von Map). Klasse) Instanz. Beinhaltet: Implementierungsklasse: HashMap, Hash-Tabelle. Collection-Schnittstelle ist die übergeordnete Schnittstelle der List-, Set- und Queue-Schnittstellen. Die Collection-Schnittstelle definiert Methoden, die zum Bedienen von List, Set und Queue verwendet werden können – Hinzufügen, Löschen, Ändern und Abfragen. (Die spezifischen Methoden der Collection-Schnittstelle finden Sie in der API und werden daher hier nicht aufgeführt.)

Unter diesen sind ArrayList, HashSet und HashMap die drei am häufigsten verwendeten Implementierungsklassen Ich werde diese drei Implementierungen einzeln vorstellen.

In diesem Artikel stellen wir zunächst die Verwendung von ArrayList vor.

3. ArrayList-Implementierungsklasse

---

<br>

Listenschnittstelle und ihre Implementierungsklasse – ArrayList

List kann die Einfügeposition jedes Elements genau steuern oder ein Element an einer bestimmten Position löschen;

List verfügt über eine Add()-Einfügemethode und eine get()-Erfassungsmethode; >

ArrayList – Array-Sequenz, eine wichtige Implementierungsklasse von List

Die unterste Ebene von

ArrayList wird durch array implementiert, woher auch der Name stammt.

Wie nutzt man diese Sammlungen? Lassen Sie uns ein kleines Beispiel verwenden und ein kleines Programm schreiben, um zu lernen, wie man Sets intuitiver verwendet. (Die Beispiele in den folgenden Artikeln basieren ebenfalls darauf)

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

Programmfunktion - Kursauswahlfunktion für Studenten simulieren

1. Kurse auswählen (Kurse zur Sammlung hinzufügen)

2. Ausgewählten Kurs löschen (Elemente aus der Sammlung entfernen)

3. Ausgewählte Kurse anzeigen

4. Ändern der gewählte Kurs ;>>>>>>>>>>>>>>>>>>>>>>>> ;> ;>>

Das Folgende ist ein Codeausschnitt des Programms, da es zum Testen verwendet wird, um die Verwendung von Sammlungen einzuführen. Achten Sie daher bitte nicht auf die Details Der Code wird Schritt für Schritt verbessert. 1) Schülerklasse und Kursklasse erstellen

2) Alternativkursklasse erstellen

 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 }

Hinweis:

 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 }

List ist eine Schnittstelle und kann daher nicht direkt im Konstruktor instanziiert werden, sondern wird über ArrayList() instanziiert! ! !

Beispiel: public List courseToSelect = new ArrayList();

Set und Map sind ähnlich und können nicht direkt instanziiert werden. Sie müssen die entsprechende Instanziierungsklasse verwenden, z. B. HashSet (), HashMap();

3) Kurse zu den Alternativkursen hinzufügen (Elemente hinzufügen) Es gibt insgesamt 4 Methoden, um Elemente in die Liste unter Liste einzufügen:

1.add(element);

2.add(index,element);

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

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

Das folgende Codebeispiel:

 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 }

Hinweis:

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(对象数组名))添加

1. Wenn das Objekt in der Sammlung gespeichert wird, ist beim Herausnehmen eine Konvertierung des Objekttyps erforderlich. (

Generika werden später verwendet, um dieses Problem zu lösen

)

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

2. Die zur Liste hinzugefügte Position (Index) liegt zwischen [0, Länge]; 0 bedeutet Einfügen am Anfang der Warteschlange und Länge bedeutet Einfügen am Ende der Warteschlange.

3. Wenn die zur Liste hinzugefügte Länge größer als die aktuelle Länge ist, tritt im System eine Ausnahme auf, d. h. eine Ausnahme außerhalb der Grenzen in der Tabelle unterhalb des Arrays, wie zum Beispiel:

4) Alternatives Entfernen und Drucken von Kursen

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

Die folgenden drei Methoden werden verwendet, um Elemente aus der Liste zu entfernen:

-----for-Schleife-----

-----Iterator-----

Iterator ist eine Schnittstelle, die davon abhängt, ob Sammlungen vorhanden sind.

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 }

-----für jeden (zu verwenden empfohlen

)-----

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

5) Alternative Kursänderung

Verwenden Sie set (Index, Objektelement), um das Element zu ändern, Index repräsentiert die Indexposition und Element repräsentiert das neue Objekt.

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

6) Alternative Kurselemente löschen

Liste hat Remove(Index), Remove(Objektwert) und RemoveAll(Arrays.asList(Objektarray-Name) )-Methode zum Löschen des Werts des Elements im Container (Verwendung ähnlich wie beim Hinzufügen).

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

Course ist eine Informationskursklasse mit ID- und Namensattributen; courseToSelect ist ein Sequenzcontainerobjekt einer Liste.

注意：

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         }

Hinweis: Sie können nur foreach oder iterator verwenden, um jedes Element im Set zu durchlaufen, und Sie können die Methode get() nicht wie List verwenden. Da es ungeordnet ist, werden die Ausgabeergebnisse jedes Mal etwas anders sein.

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

Zusammenfassung:

1. Set wird nicht wie die set()-Methode in List geändert, da List geordnet ist und die Position angegeben werden kann Die Menge ist ungeordnet und kann durch Schleifendurchlauf geändert werden.

2. Beim Abfragen und Durchlaufen kann Set nicht mit der Methode get () abgerufen werden, da die Index-ID nicht in der ungeordneten Reihenfolge angegeben ist. Sie können jedoch foreach und den Iterator zum Durchlaufen verwenden, die Reihenfolge ist jedoch möglich Jedes Mal, wenn es durchquert wird, ist es anders. Es wird immer noch durch Unordnung verursacht.

3. size(), add(), addAll(), remove(), removeAll() in Set ähneln List.

4. Set kann auch Null hinzufügen (aber nur eine Null kann hinzugefügt werden, da sie nicht wiederholt wird);