collection Java (1) - explication détaillée de la structure des données : http://www.php.cn/java-article-354226.html
Un framework fait référence à un ensemble de classes. Il existe de nombreuses superclasses et interfaces dans l'ensemble. De nombreux mécanismes, fonctions et stratégies avancés sont implémentés dans ces superclasses. Les utilisateurs du framework peuvent créer des sous-classes pour implémenter et étendre des superclasses sans recréer ces mécanismes de base. Dans le travail quotidien, les technologies que nous utilisons sont essentiellement des frameworks. Lorsque nous utilisons ces packages et appelons ces fonctions, nous utiliserons l'idée de ce framework. Après avoir analysé la structure des données de la collection dans Collection (1), nous continuerons aujourd'hui à discuter du cadre de la collection.
| 基本 | 类型 | 实现接口 | 说明 |
|---|---|---|---|
| List | 链表LinkedList | Deque,List,Queue | 通过存放前后结点的引用，实现双向链表 |
| 数组列表ArrayList | List,RandomAccess | 数据传入动态数组中，自动扩充数组大小 | |
| Set | 散列集HashSet | Set | 哈希法存储数据，无序但查找时效率高 |
| 树集TreeSet | NavigableSet,Set,SortedSet | 按照一定方法排序，输出有顺序的集合 | |
| Queue | 优先级队列PriorityQueue | Queue | 按照堆排序的方法排序的队列树 |
| 双端队列ArrayDeque | Deque, Queue | 可以在两端添加和删除，不能操作中间的队列 | |
| Map | 散列表HashMap | Map | 用哈希法存放的，键值映射的表 |
| 树表TreeMap | Map,NavigableMap,SortedMap | 将键按照一定方法排序的表 | |
| 注：前六种（不包括Map）都实现了Collection和Iterator接口，因为篇幅限制没有写出。 | |||
Dans la bibliothèque de classes de collection, nous en avons utilisé une très grande proportion pour construire des interfaces pour les classes d'implémentation, alors à quoi servent ces interfaces ? Si on écrivait directement les méthodes dans l'interface dans la classe d'implémentation, cela n'aurait-il pas le même effet ? La situation réelle est loin d’être aussi simple qu’on le pense. De nombreuses choses complexes nous obligent à opérer via ces interfaces. Par exemple, nous appelons des objets de types d'interface publique de certaines classes objets de vue . Les types de ces objets ne sont pas des classes d’implémentation spécifiques, mais des interfaces publiques de certaines classes d’implémentation. Les vues ont de nombreuses fonctions, les principales sont les suivantes :
Nous pouvons utiliser des méthodes pour convertir des tableaux ordinaires enveloppés dans un objet de vue. de type Liste. Le type de cet objet de vue est List, ce qui peut sembler étrange, car List est une interface et ne peut pas être instanciée. Mais c'est l'avantage de l'objet view.Cet objet view peut être affecté à n'importe quelle classe de collection qui implémente l'interface List via certaines méthodes, telles que l'ArrayList commune, LinkedList, etc., afin que nous puissions envelopper une classe ordinaire dans un classe de collecte.
package SetViews;import java.util.Arrays;import java.util.Collections;import java.util.LinkedList;/**
*
* @author QuinnNorris
* 视图是一个轻量级的集包装器，下面有两个例子
*/public class Views {
/**
* @param args
*/
public static void main(String[] args) { // TODO Auto-generated method stub
//-----------------------例1----------------------
int[] arr = new int[10]; //创建一个普通的int数组
Arrays.asList(arr); //通过asList方法，我们将一个普通的数组转换成List类型的视图对象。
//-----------------------例2-----------------------
List<String> ll = new LinkedList<>();
//创建一个LinkedList对象ll。
ll.addAll(Collections.nCopies(10, "ok"));
//nCopies是Collections类的静态方法，可以将“ok”复制10次，并返回一个List类型的视图对象。
//在这里我们不可以直接把Collections.nCopies的类型强转成LinkedList，因为语法不能上转下
//我们通过addAll方法将这个内容填充到LinkedList对象ll中。
ll.set(2, "no"); //我们看看它是否能正常工作，我们试着将第三个链表中的String换成no。
//请注意，链表最好不要使用get和set方法，这里只是为了实验。
for(String s : ll){
System.out.println(s);
} //输出结果第三个是no，其他全是ok，没有任何问题。
}
}C'est l'un des grands avantages de la vue. Il s'agit d'un wrapper de tableau léger qui enveloppe le tableau dans un objet de classe dans la bibliothèque de classes de collection. De même, nous pouvons envelopper ces paires clé-valeur et les données qui doivent être stockées dans l'ensemble via la vue et les transmettre à la classe correspondante. Par conséquent, nous appelons la fonction de cette vue un wrapper d’ensemble léger.
Vous pouvez créer des vues de sous-gammes pour de nombreuses collections. Ces sous-gammes sont une référence à l'original. collection. Si la modification de ces sous-plages affectera la collection d’origine. Si nous ne voulons avoir aucun impact, nous devons utiliser d'autres méthodes comme addAll pour copier. Dans une liste, la méthode de division de la plage d’exemples est simple.
package SetViews;import java.util.ArrayList;import java.util.Collections;import java.util.List;/**
*
* @author QuinnNorris
* 在列表中分例子范围，并进行操作
*/public class SubViews {
/**
* @param args
*/
public static void main(String[] args) { // TODO Auto-generated method stub
List<Integer> al = new ArrayList<>(); //创建ArrayList对象al
al.addAll(Collections.nCopies(15, 1)); //在al中设置15个1
List subal = al.subList(5, 10);
//subList取出从第6个元素到第10个元素作为一个子范围，返回一个视图对象，我们将它存放到subal中。
subal.set(0, 0); //第6个数字改成0
for(Integer i :al)
System.out.println(i); //除了第6个数字为0其他全为1
subal.clear();//清除子范围
for(Integer i :al)
System.out.print(i); //al列表中只有10个1，中间的五个被清除了
}
}En plus de cela, dans d'autres ensembles triés et tables de mappage, nous pouvons créer des sous-plages en utilisant l'ordre de tri au lieu de la position des éléments. Ces méthodes sont déclarées dans SortedSet et SortedMap.
SortedSet
headSet (E vers Élément)
Renvoie une vue partielle de cet ensemble dont les éléments sont strictement plus petits que toElement.SortedSet
sous-ensemble (E fromElement, E toElement)
Renvoie une vue partielle de cet ensemble avec des éléments de fromElement (inclus) à toElement (exclusif).SortedSet
tailSet(E fromElement)
Renvoie une vue partielle de cet ensemble dont les éléments sont supérieurs ou égaux à fromElement.
Les trois méthodes ci-dessus sont des méthodes déclarées dans SortedSet, qui sont disponibles dans TreeSet. De la même manière, si tous les Sets de la méthode sont remplacés par Maps, nous pouvons utiliser ces trois méthodes similaires dans TreeMap. Il convient de noter que toutes les opérations dans Map sont effectuées à l'aide de clés et non de valeurs.
Dans la vraie vie, si vous passez votre objet de collection dans la méthode de votre collègue, il s'avère qu'il se trompe Votre objet a été modifié , ce qui va certainement vous ennuyer. Alors, comment résoudre ce genre de problème et rendre notre structure de données plus sécurisée ? Dans la vue, nous pouvons utiliser une vue non modifiable pour verrouiller nos objets. Si une tentative est faite de modifier la collection, une exception sera levée et la collection sera restaurée à son état non modifié.
Dans la classe Collections, nous proposons plusieurs méthodes pour obtenir des vues non modifiables :
unmodifiableCollection ： 返回指定 collection 的不可修改视图（下同）。 unmodifiableList unmodifiableMap unmodifiableSet unmodifiableSortedMap unmodifiableSortedSetCopier après la connexion
Ci-dessus Ces méthodes sont très simples et clairement, regardons un exemple concret pour voir comment fonctionnent ces méthodes.
package SetViews;import java.util.ArrayList;import java.util.Collections;import java.util.List;/**
*
* @author QuinnNorris
* 不可修改的安全视图举例
*/public class UnmodifaiableViews {
//这个是调用列表的方法
private static void changeList(List<String> al) {
al.set(0, "change"); //error Exception in thread "main" java.lang.UnsupportedOperationException
} public static void main(String[] args) { // TODO Auto-generated method stub
List<String> al = new ArrayList<>(); //创建ArrayList对象al
al.addAll(Collections.nCopies(10, "final")); //前十个元素填充“final”字符串
changeList(al); //先直接调用changeList方法，没问题
changeList(Collections.unmodifiableList(al));
//报错，说明在changeList中对al进行了修改，被阻止了，而且抛出了异常
}
}Non modifiable ne signifie pas que l'objet collection ne peut plus être modifié, mais qu'il ne peut pas être modifié lors de l'application des méthodes statiques de Collections. Mais cela pose un problème implicite, car après avoir utilisé une méthode statique, son type devient un type de vue, ce qui empêche l'utilisation de certaines méthodes plus détaillées. Par exemple, une fois qu'un objet ArrrayList est empaqueté par Collections.unmodifiableList(), son type devient List et certaines méthodes spécifiques à ArrayList ne peuvent pas être utilisées.
Le multithread est très courant dans notre travail quotidien. Si une collection est accessible par plusieurs threads, il faut s'assurer que la collection le sera. ne pas être détruit accidentellement. Je ne veux pas trop discuter de la question du multi-threading ici. Dans la bibliothèque de classes de collection, les concepteurs ont utilisé le mécanisme d'affichage pour garantir la sécurité des threads des collections régulières. Par exemple, la méthode statique synchroniséeMap de la classe Collections peut transformer l'objet de la classe d'implémentation Map passé en paramètre en une Map thread-safe.
Map<String,Integer> map = Collections.synchronizedMap(new HashMap<String,Integer>());
Il existe de nombreuses méthodes similaires, qui sont similaires à la vue non modifiable du troisième point, je n'en parlerai donc pas ici.
有的时候，我们在使用类似ArrayList等数据结构时并不使用泛型，从而会导致一些难以发现的类型错误。这个时候，如果我们使用了视图机制，用一种方法来不断地检查我们的代码就可以直接判断出错误的原因。
package SetViews;import java.util.ArrayList;import java.util.Collections;import java.util.Date;import java.util.List;/**
*
* @author QuinnNorris
* 动态类型安全视图是如何避免错误的发生举例
*/public class CheckViews {
/**
* @param args
*/
public static void main(String[] args) { // TODO Auto-generated method stub
//--------------------发生错误的例子-----------------------
ArrayList<String> al = new ArrayList<>(); //创建ArrayList对象al
ArrayList errList = al; //声明一个没有泛型的ArrayList，并把al赋值给它
errList.add(new Date()); //这个列表本应该是String类型的，但是现在增加一个Date类型数据在编译运行时都不报错。
//只有当对内部的数据进行操作时，编译器才有可能发现这个错误并抛出异常
//-----------------动态类型安全视图机制----------------------
List<String> safeAl = Collections.checkedList(al, String.class);
//调用Collections的静态方法checkedList，第一个参数是列表名，第二个参数是类型
//这个方法返回一个List视图对象，如果要进行错误的操作，会抛出异常
List errSafeAl = safeAl; //再用无泛型的列表去引用检查视图的对象，因为al原本是ArrayList
errSafeAl.add(new Date()); //现在运行时会报错，Attempt to insert class java.util.Date element into collection
//with element type class java.lang.String
}
}视图是个好机制，它为我们提供了很多方便快捷的转换，安全等方面的操作，让我们对整个集合类库的构架有了个初步的理解。那么谈完了宏观的概念，我们来看一下实际操作中集合框架的一些细节的特性和机制。
集合就是许许多多的数据在一起构成的。在实际应用中，处理这些海量的数据让我们非常的头痛，而且一旦需要操作的复杂一些，几遍for循环的时空复杂度直接以次方形式增长，这是我们绝对不想看到的。为了方便集合类中数据的操作，集合框架提供类一种叫做批操作的概念。
package SetViews;import java.util.HashSet;import java.util.Set;/**
*
* @author QuinnNorris
* 批操作查找两个集合的交集
*/public class BulkViews {
/**
* @param args
*/
public static void main(String[] args) { // TODO Auto-generated method stub
Set<String> setA = new HashSet<>();
Set<String> setB = new HashSet<>(); //创建集合A和集合B这是我们要比较的两个集合
Set<String> result = new HashSet<>(setA); //声明集合result存放结果，先用集合A来实例化这个集合
result.retainAll(setB); //调用retainAll方法，将B中与A相同的所有元素留下，达到查找交集的目的
}
}这是一个比较简单的例子，它省略了for循环，而是采用这种批操作的概念来完成交集的查找。但是方法毕竟有限，我们能处理的问题还是在少数，如果真的想广泛的运用批操作，那么结合视图机制是必须的。因为视图机制可以在一定程度上，可以非常简单的进行类型的转换，通过子视图等方法在复杂度较低的情况下达到自己的目的。
由于java平台API中的大部分内容都是在集合框架创建之前设计的，所以，有的时候的确需要在传统的数组和现代的集合之间进行转换。我们可以通过asList方法和toArray方法来解决这个问题。
package SetViews;import java.util.Arrays;import java.util.HashSet;/**
*
* @author QuinnNorris
* 集合与数组之间的转换
*/public class TypeChange {
/**
* @param args
*/
public static void main(String[] args) { // TODO Auto-generated method stub
//---------------------数组转集合---------------------------
String[] values = {"a","b"}; //创建一个普通数组
HashSet<String> hsValues = new HashSet<>(Arrays.asList(values));
//通过Arrays类中静态方法asList，将普通数组转换成List类型的视图对象并实例化
//---------------------集合转数组---------------------------
HashSet<String> hsValue = new HashSet<>(); //创建一个集合
Object[] objValues = hsValue.toArray();
//如果调用无参toArray方法，则返回一个Object数组，此时不能类型强转否则出错
String[] strValues = hsValue.toArray(new String[0]);
//有参数的toArray方法如果参数数组的长度小于所需长度的话，重新分配一个能放得下大小的数组
//我们通过有参数的toArray方法巧妙的将集合对象转换成相应类型的
}
}集合框架并没有把Map作为一个集合来看待，然而，我们可以获得映射表的视图，这个视图是一组实现了Collection接口的对象。大家都知道，Collection和Map是两个不相干的接口，如今Map的视图是Collection的对象，无疑是更加方便了我们的操作。Map接口为我们提供了三个方法，这三个方法返回三个不同的视图：
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
