Explication détaillée du cadre de collecte Java

1. Présentation du framework de collection Java

java SE comprend le framework de collection java (java Collection Framework, appelé JCF), qui est composé d'un ensemble de classes et d'interfaces. stocker les données stockées dans L'objectif est de fournir un cadre commun pour le traitement des collections d'objets et de réduire la quantité de codage requise par les programmeurs lors du traitement de différentes collections d'objets.

Certaines différences dans les classes de collection, en plus de savoir si elles prennent en charge les opérations répétées sur les éléments, incluent si les éléments sont ordonnés et si des éléments nuls peuvent être ajoutés. Sur la base de ces trois différences, le framework de collection Java divise les méthodes de stockage des objets en trois types, qui sont :

Set (set) : les objets dans le conteneur d'objets n'ont pas d'ordre et ne peuvent pas être répétés.

Liste : les objets dans le conteneur d'objets sont triés selon l'ordre d'index et il peut y avoir des objets en double.

Carte : les éléments du conteneur d'objets contiennent une paire de mappages "objet clé-objet valeur", où l'objet clé ne peut pas être répété et l'objet valeur peut être répété.

Afin de prendre en charge les opérations de tri d'objets et d'accès traversant, le framework de collection Java fournit plusieurs interfaces :

L'interface SortedSet fournit des fonctions de tournage pour les conteneurs de type Set.

L'interface SortedMap permet de trier les objets clés pour les conteneurs de type Map.

Les interfaces Comparable et comparateur permettent de trier les objets de la collection.

2. Interface de collection et interface d'itérateur

L'interface de collection définit certaines méthodes de base communes aux objets de collection

L'interface d'itérateur est une interface pour parcourir les collections.

1.Interface Liste

L'interface Liste hérite de l'interface Collection Elle a les caractéristiques suivantes :

Les éléments de la Liste sont dans. ordre de.

La liste autorise généralement les éléments en double.

Les classes d'implémentation de liste prennent généralement en charge les éléments nuls.

Les éléments du conteneur d'objets List sont accessibles par index.

Les classes d'implémentation les plus couramment utilisées de l'interface List sont la classe ArrayList et la classe LinkedList.

1).ArrayList

Exemple de programme :

package lei;
  import java.util.ArrayList;
  import java.util.List;
  public class Test {
    public static void main(String[] args) {     
      List list = new ArrayList<>();
      list.add(1);
      list.add("zhangsan");
      list.add(false);
      list.add(&#39;a&#39;);
      list.add(0, "lisi");
      list.add(1);
      list.remove(1);
      list.remove(2);
      list.set(0, "wangwu");
      for (int i = 0; i < list.size(); i++) {
        System.out.println(list.get(i));
      }
    }
  }

La méthode equals() définie par la classe Object compare uniquement l'objet passé à la méthode avec l'objet appelant la méthode True sera renvoyée uniquement lorsqu'il s'agit du même objet. Vous pouvez traiter deux objets avec le même état comme le même objet en remplaçant la méthode equals().

2).LinkedList

Exemple de programme :

package lei;
  import java.util.LinkedList;
  import java.util.List;
  public class Test2 {
      public static void main(String[] args) {
       LinkedList l=new LinkedList<>();
      l.add("zhangsan");
      l.add("lisi");
      l.addFirst(1);
      l.addLast(4);
      System.out.println(l.getFirst());
      System.out.println(l.getLast());
      l.removeFirst();
      l.removeLast();
      for (int i = 0; i < l.size(); i++) {
        System.out.println(l.get(i));  
      }  
    }
  }

Sélection de LinkedList et ArrayList

If list Si vous avez besoin d'un accès rapide, mais que vous n'insérez et ne supprimez pas fréquemment d'éléments, il est préférable de choisir ArrayList ; si vous devez effectuer des opérations d'insertion et de suppression fréquentes sur la liste, vous devez choisir LinkedList ;

Interface 2.set

L'interface set hérite de l'interface Collection et hérite également de toutes les méthodes de l'interface Collection. L'interface set présente les caractéristiques suivantes :

Les conteneurs de type set ne peuvent pas contenir d'éléments en double. Lors de l'ajout d'un élément au conteneur, il est nécessaire de comparer si le contenu de l'élément est dupliqué, donc l'objet ajouté au conteneur d'objets de type Set doit remplacer la méthode equals().

Les éléments peuvent être en ordre ou non.

Étant donné que les éléments peuvent ne pas être dans l'ordre, les éléments de l'ensemble ne sont pas accessibles en fonction des indices.

Les classes HashSet et TreeSet sont les plus couramment utilisées pour implémenter l'interface Set.

1).Hashset

La classe Hashset est une implémentation d'interface Set basée sur l'algorithme de hachage Elle présente principalement les caractéristiques suivantes :

Lors du parcours d'un Hashset, les éléments. dedans Il n'y a pas d'ordre.

Les éléments en double ne sont pas autorisés dans Hashset. Les éléments en double font ici référence à deux objets qui ont le même code de hachage et renvoient vrai lorsqu'ils sont comparés à l'aide de la méthode equals().

est autorisé à contenir des éléments nuls.

Si la classe que nous écrivons redéfinit la méthode égal, alors cette classe doit également redéfinir la méthode hashCode() et garantir que lorsque le résultat de la comparaison de deux objets utilisant la méthode égal est vrai, le hashCode des deux Les valeurs de retour de la méthode objets () sont égales.

Exemple de programme :

package lei;
  import java.util.HashSet;
  import java.util.Set;
  public class Test4 {
      public static void main(String[] args) {
      Set<String> set=new HashSet<String>();
      set.add("zhangsan");
      set.add("lisi");
      for(String s:set){
        System.out.println(s);
      }
    }
  }

2).TreeSet

La classe TreeSet implémente non seulement l'interface Set, mais implémente également l'interface SortedSet, garantissant ainsi que les objets dans l'ensemble, suivez un certain ordre de tri. Lorsqu'un objet est ajouté à la collection TreeSet, il sera inséré dans la séquence ordonnée d'objets. Cependant, ce tri n'est pas trié selon l'ordre dans lequel les objets sont ajoutés, mais selon un certain algorithme.

TreeSet trie les éléments selon leur ordre naturel, ou selon le Comparator fourni lors de la création du Set. TreeSet prend en charge deux méthodes de tri : le tri naturel et le tri personnalisé.

3.Interface cartographique

Map(映射)接口是java集合框架中不同于Collection接口的另一个重要接口，它对应的是在一种从键(Key)到值(Value)的对应关系的集合。Map类型的对象容器里面保存着两组对象，一组对象用于保存Map里的Key，另外一组用于保存Value。Key和Value可以升级任何引用类型的数据。Key不能重复，但是Value可以重复。

1).HashMap  

HashMap是基于哈希算法的Map接口的实现。HashMap将它的键保存在哈希表中进行维护，键是唯一的。但是，HashMap并不保证键以特定顺序排列，特别是不保证顺序永久不变。 

HashMap类实现了Map接口，从而具有Map接口的所有方法。

package day1228;
  import java.util.*;
  public class HashMapDemo {
    public static void main(String[] args) {
      // 创建一个新的HashMap
      Map<String, String> map = new HashMap<String, String>();
      map.put("a1", "xiao");
      map.put("b2", "xiaol");
      map.put("a4", "xiaosd");
      map.put("b1", "12a");
      map.put("a3", "1");
      // 使用iterator遍历 键和值
      System.out.println("之前的Map值是：");
      Set<String> keys = map.keySet();
      for (Iterator<String> i = keys.iterator(); i.hasNext();) {
        String key = i.next();
        String value = map.get(key);
        System.out.println(key + "=" + value);
      }
      // 删除键为"a4"的值
      System.out.println("\n删除键值为a4的元素");
      map.remove("a4");
      // //使用iterator遍历 键和值
      System.out.println("\n之后的Map值：");
      keys = map.keySet();
      for (Iterator<String> i = keys.iterator(); i.hasNext();) {
        String key = i.next();
        String value = map.get(key);
        System.out.println(key + "=" + value);
      }
    }
  }

2).TreeMap

TreeMap类是基于红黑树算法的Map接口实现。TreeMap中键的存放方式与TreeSet相似，它将键存放在树中，键的顺序按照自然顺序或者自定义顺序两种方式排列。 

程序实例：

package day1228;
  import java.util.*;
  public class TreeMapDemo {
    public static void main(String[] args) {
      //创建一个新的TreeMap
      Map<Integer, String> map = new TreeMap<Integer, String>();
      map.put(1, "one");
      map.put(2, "two");
      map.put(3, "three");
      map.put(4, "four");
      map.put(5, "five");
      //使用iterator显示键和值
      System.out.println("之前的map值为：");
      Set<Integer> keys=map.keySet();
      for(Object key:keys){
        String value=map.get(key);
        System.out.println(key+"="+value);
      }
      //删除键为3的值
      System.out.println("\n删除键值为3的元素");
      map.remove(3);
      //使用iterator显示键和值
      System.out.println("\n之后的值Map为：");
      for(Object key:keys){
        String value=map.get(key);
        System.out.println(key+"="+value);
      }
    }
  }

以上就是本文的全部内容，希望本文的内容对大家的学习或者工作能带来一定的帮助，同时也希望多多支持PHP中文网！

更多Explication détaillée du cadre de collecte Java相关文章请关注PHP中文网！