liste

Une collection avec l'ordre des éléments comme un tableau
- ArrayList
- LinkedList
Vector (utilisez ArrayList de préférence)

ArrayList

Les éléments peuvent être ajoutés ou supprimés plus tard
cf: Array n'est pas possible
La lecture et l'écriture (accès aléatoire) de la valeur par valeur d'index sont accessibles dans un certain temps quelle que soit la position **
** L'insertion et la suppression fréquentes des valeurs sont lentes **
La réaffectation de la mémoire se produit automatiquement lorsque la zone de mémoire réservée au moment de l'insertion est dépassée.
→ ** Si le nombre d'éléments est attendu à l'avance, déclarons la taille **
var data = new ArrayList <String> (30);


import java.util.ArrayList;
import java.util.Arrays;
public class Main {
  public static void main(String[] args) {
    var list = new ArrayList<Integer>(Arrays.asList(10, 15, 30, 60));
    var list2 = new ArrayList<Integer>(Arrays.asList(1, 5, 3, 6));
    var list3 = new ArrayList<Integer>(Arrays.asList(1, 2, 3));

    for (var i : list) {
      System.out.println(i / 5); //2,3,6,12
    }
    //Nombre d'éléments
    System.out.println(list.size()); //4
    //Obtenir le 0e élément
    System.out.println(list.get(0)); //10
    //Contient-il l'élément spécifié?
    System.out.println(list.contains(30)); //true
    //Trouver un emplacement
    System.out.println(list.indexOf(30));  //2
    //Rechercher une position par derrière
    System.out.println(list.lastIndexOf(30)); //2
    //La liste est-elle vide?
    System.out.println(list.isEmpty());    //false
    //Supprimer le 0e élément
    System.out.println(list.remove(0));   //10
    System.out.println(list);             //[15, 30, 60]
    //Insérer une collection
    list.addAll(list2);
    System.out.println(list); //[15, 30, 60, 1, 5, 3, 6]
    //Supprimer tous les éléments de la collection
    list.removeAll(list3);
    System.out.println(list); //[15, 30, 60, 5, 6]
    //0ème ensemble d'éléments
    list.set(0, 100);
    var data = list.toArray();
    System.out.println(Arrays.toString(data)); //[100, 30, 60, 5, 6]
  }
}

LinkedList

** Éléments de référence avec liens bidirectionnels **
Ne convient pas à la lecture et à l'écriture d'éléments par valeur d'index
L'insertion / suppression d'éléments est rapide
Pas besoin de déplacer les éléments, seulement le remplacement des liens avant et arrière
** Insérez les éléments les uns après les autres, accédez à la liste dans l'ordre **: ** LinkedList **
** Obtenir ou réécrire des éléments existants **: ** ArrayList **

import java.util.Arrays;
import java.util.LinkedList;

public class Main {
  public static void main(String[] args) {

    var list = new LinkedList<String>(Arrays.asList("丑", "Tora", "U"));
    list.addFirst("Enfant");
    list.addLast("Tatsu");
    System.out.println(list); //[Enfant,丑,Tora,U,Tatsu]
    System.out.println(list.getFirst()); //Enfant
    System.out.println(list.getLast()); //Tatsu
    System.out.println(list.removeFirst()); //Enfant
    System.out.println(list.removeLast()); //Tatsu
    System.out.println(list); //[丑,Tora,U]
  } 
}

ensemble

Les éléments ne peuvent pas être dupliqués. Utilisé si vous êtes intéressé par l'inclusion d'éléments
- HashSet
- LinkedHashSet
- TreeSet

HashSet

Ne gère pas la commande

import java.util.Arrays;
import java.util.HashSet;

public class Main {
  public static void main(String[] args) {
    //Ignorer les éléments en double
    var hs = new HashSet<Integer>(Arrays.asList(1, 20, 30, 10, 30, 60, 15));
    var hs2 = new HashSet<Integer>(Arrays.asList(10 ,20 ,99));

    //System.out.println(hs);
    System.out.println(hs.size()); //6
    System.out.println(hs.isEmpty()); //false
    //Contient-il un élément spécifié?
    System.out.println(hs.contains(1)); //true  
    //Inclut-il tous les éléments spécifiés?
    System.out.println(hs.containsAll(hs2)); //false
    //Supprimer l'élément spécifié
    System.out.println(hs.remove(1)); //true 
    System.out.println(hs); //[20, 10, 60, 30, 15]
    //Si l'élément spécifié n'est pas inclus dans l'ensemble, ajoutez tout (ensemble de somme)
    hs.addAll(hs2);
    System.out.println(hs); //[99, 20, 10, 60, 30, 15]
    //Supprimer tous les non-éléments de la collection (ensemble de produits)
    hs.retainAll(hs2);
    System.out.println(hs); //[99, 20, 10]
    
    var hs3 = new HashSet<Integer>(Arrays.asList(1, 10 , 20));
    //Supprimer tous les éléments spécifiés(Jeu de différences)
    hs.removeAll(hs3);
    System.out.println(hs);  //[99]
  }
}

TreeSet

Ensemble trié
Les éléments supplémentaires sont triés automatiquement

import java.util.Arrays;
import java.util.TreeSet;

public class Main {
  public static void main(String[] args) {
    var ts = new TreeSet<Integer>(Arrays.asList(1, 20, 30, 10, 60, 15));
    System.out.println(ts); //[1, 10, 15, 20, 30, 60]
    //Trier dans l'ordre inverse
    System.out.println(ts.descendingSet()); //[60, 30, 20, 15, 10, 1]
    //Obtenez le plus petit au-dessus de l'élément spécifié
    System.out.println(ts.ceiling(15));     //15
    //Obtenez le plus grand plus petit que l'élément spécifié
    System.out.println(ts.lower(15));       //10
    //Obtenez plus que les éléments spécifiés
    System.out.println(ts.tailSet(15));     //[15, 20, 30, 60]
    //Obtenez les plus petits que l'élément spécifié, y compris ceux qui sont égaux dans le deuxième argument true
    System.out.println(ts.headSet(30, true)); //[1, 10, 15, 20, 30]
  }
}

carte

Gérez avec des paires clé / valeur uniques
Accéder aux informations par clé au lieu d'index
N'hérite pas de l'interface de collection (la carte ne peut pas être transmise à l'extension telle quelle)
- HashMap
- IdentityHashMap
- WeakHashMap
- LinkedHashMap
- TreeMap
HashTable (HashMap a la priorité)

HashMap

La commande des clés n'est pas garantie
Gérer les objets avec une table de hachage interne
** La valeur de hachage est un entier arbitraire calculé en fonction de la valeur de l'objet **
Les objets égaux ont des valeurs de hachage égales
Note 1: ** Implémentation de la méthode hashCode **
Méthode pour trouver la valeur de hachage d'un objet
** Les objets avec la même valeur retournent la même valeur de hachage **
** Correctement distribué pour éviter la duplication **
Remarque 2: ** Taille de la table de hachage **
** Suffisamment grand pour le nombre d'éléments à stocker **
La réaffectation de la table de hachage se produit lorsque les éléments dépassent une certaine taille
- var data = new HashMap<String,String>(30, 0.8F)

import java.util.HashMap;
import java.util.Map;


public class Main {
  public static void main(String[] args) {
    var map = new HashMap<String, String>(Map.of("Cat", "Chat",
      "Dog", "Inu", "Bird", "Tori"));
    //La clé spécifiée est-elle incluse?
    System.out.println(map.containsKey("Dog")); //true
    //Si la valeur spécifiée est incluse
    System.out.println(map.containsValue("Chat")); //true
    //La carte est-elle vide?
    System.out.println(map.isEmpty()); //false
    //Obtenez toutes les clés
    for (var key : map.keySet()) {
      System.out.println(key); //Dog Bird Cat
    }
    //Obtenez toutes les valeurs
    for (var value : map.values()) {
      System.out.println(value); //Chat Inutori
    }
    //Changer la valeur de la clé spécifiée en valeur
    map.replace("Cat", "neko");
    //Valeur de clé spécifiée/valeur(old)Valeur(new)changer en
    map.replace("Bird", "Tori", "tori");
    //Obtenez tous les éléments
    for (var entry : map.entrySet()) {
      System.out.println(entry.getKey() + ":" + entry.getValue()); //Dog:Oiseau Inu:tori Cat:neko
    }
  }
}

IdentityHashMap

IdentityHashMap ** Juger la clé par identité (== opérateur) **
cf: Le HashMap standard est ** jugé par égalité (méthode égale) **

//Dans le cas de HashMap, si la valeur est la même, elle sera écrasée et une seule entrée sera enregistrée.
//Pour IdentityHashMap, key1,Puisque 2 est un objet différent, il est considéré comme une clé différente.
import java.util.HashMap;
import java.util.IdentityHashMap;
public class Main {
  public static void main(String[] args) {
    var key1 = Integer.valueOf(256);
    var key2 = Integer.valueOf(256);

    //var data = new HashMap<Integer, String>() {
    var data = new IdentityHashMap<Integer, String>() {
      {
        put(key1, "Hoge");
        put(key2, "Foo");
      }
    };  
    //System.out.println(data); //{256=Foo} 
    System.out.println(data);   //{256=Foo, 256=Hoge}
  }
}

WeakHashMap

Gérer les clés avec ** références faibles **
Si la clé n'est pas référencée en dehors de la carte actuelle, elle sera soumise au garbage collection.
cf: Standard HashMap est ** référence forte **
Non éligible pour le ramasse-miettes tant que la carte contient la clé

TreeMap

Commande de garantie
Gérer les clés avec ** Arbre rouge-noir **
** Nœud ** (nœud)
Jusqu'à 2 nœuds enfants par nœud
Nœud enfant gauche <Nœud actuel <Nœud enfant droit
Enfin ajouté à l'endroit qui satisfait la relation de grandeur du nœud

//Les clés peuvent être triées par ordre lexical
import java.util.Map;
import java.util.TreeMap;

public class Main {
  public static void main(String[] args) {
    var data = new TreeMap<String, String>(Map.of("Cat", "Chat",
        "Dog", "Inu", "Bird", "Tori"));
    for (var key : data.keySet()) {
      System.out.println(key); //Bird Cat Dog
    }
  }
}

Ordre des clés

Selon le standard TreeMap, les chaînes de caractères sont triées par dictionnaire et les nombres sont triés par taille.
Personnalisable avec le style lambda

//Trier par longueur de clé
import java.util.TreeMap;
// import java.util.Comparator;

public class Main {
  public static void main(String[] args) {
    var data = new TreeMap<String, String>(
        (x, y) -> x.length() - y.length()
      );
//Pour les cours anonymes
//    var data = new TreeMap<String, String>(new Comparator<String>(){
//      @Override
//      public int compare(String x, String y) {
//        return x.length() - y.length();
//      }
//    });

      data.put("Cat", "Chat");
      data.put("Shiba inu", "Shiba Inu");
      data.put("Bird", "Tori");
      System.out.println(data); //{Cat=Chat, Bird=Tori, Shiba inu=Shiba Inu}
  }
}

Trier le tableau / la liste

** méthode de tri **

//Trier par longueur de chaîne dans l'ordre croissant
import java.util.ArrayList;
import java.util.Arrays;

public class Main {
  public static void main(String[] args) {  

    var data = new String[] { "Cat", "Shiba inu", "Bird", "Poodle" };
    Arrays.sort(data, (x, y) -> x.length() - y.length());
    System.out.println(Arrays.toString(data)); //[Cat, Bird, Poodle, Shiba inu]

    var list = new ArrayList<String>(Arrays.asList("Cat", "Shiba inu", "Bird", "Poodle"));
    list.sort((x, y) -> x.length() - y.length());
    System.out.println(list); //[Cat, Bird, Poodle, Shiba inu]
  }
}

Recherche floue

** Obtenez une clé proche de cette clé avec l'interface NavigateMap **

import java.util.TreeMap;

public class Main {
  public static void main(String[] args) {
    var data = new TreeMap<String, String>() {
      {
        put("nekko", "Nekko");
        put("nezumi", "Souris");
        put("night", "Nuit");
        put("nature", "La nature");
      }
    };

    var key = "neko";

    if (data.containsKey(key)) {
      System.out.println(key + "Est" + data.get(key) + "est.");
    } else {
      System.out.print("Le mot que vous recherchez");
      //Obtenez la plus grande entrée avec une clé plus petite que la clé spécifiée
      System.out.print(data.lowerKey(key) + "Ou");
      //Obtenez la plus petite entrée avec une clé plus grande que la clé spécifiée
      System.out.print(data.higherKey(key));
      System.out.println("Vraiment?");
    }
  }
}

LinkedHashMap

Gérer les clés avec la liste de liens

import java.util.LinkedHashMap;

public class Main {
  public static void main(String[] args) {
    //Troisième argument=vrai est l'ordre d'accès
    //Troisième argument=false est l'ordre d'insertion
    var data = new LinkedHashMap<String, String>(10, 0.7f, false) {
      {
        put("aaa", "AIUEO");
        put("bbb", "Kakikukeko");
        put("ccc", "SA Shi Su Se So");
        put("ddd", "TA Chi Tsu Te à");
      }
    };
    System.out.println(data.get("ccc"));
    System.out.println(data.get("aaa"));
    System.out.println(data.get("bbb"));
    System.out.println(data.get("ddd"));
    //true
    System.out.println(data); //{ccc=SA Shi Su Se So, aaa=AIUEO, bbb=Kakikukeko, ddd=TA Chi Tsu Te à}
    //false
    //System.out.println(data); //{aaa=AIUEO, bbb=Kakikukeko, ccc=SA Shi Su Se So, ddd=TA Chi Tsu Te à}
  }
}

Pile / file d'attente

Spécialisé dans la saisie et la suppression de valeurs des deux extrémités de la liste
** Pile **: dernier entré, premier sorti (LIFO: dernier entré, premier sorti / FILO: premier entré, dernier sorti)
Extrait de la dernière opération (Annuler l'opération, etc.)
** File d'attente **: premier entré, premier sorti (FIFO)
Extrait du premier élément (** queue **)
** Interface Deque **: les deux extrémités de la file d'attente
Vous pouvez ajouter / récupérer des éléments depuis le début / la fin de la liste
- ArrayDeque
- LinkedList
- Stack

ArrayDeque

À l'intérieur se trouve ** un tableau circulaire **
Stockez les éléments dans n'importe quelle plage (tête ~ queue) dans le tableau
Insertion / suppression d'un élément ** Déplace uniquement la position de début / fin sans changer l'élément **
Si la position de fin dépasse la fin du tableau en raison de l'insertion ** Cycle jusqu'au début du tableau **
Accès rapide au premier élément
Deque est une sous-interface de Queue, donc la méthode Queue peut également être utilisée

import java.util.ArrayDeque;

public class Main {
  public static void main(String[] args) {
    //empiler
    var data = new ArrayDeque<Integer>();
    data.addLast(10);
    data.addLast(15);
    data.addLast(30);

    System.out.println(data); //[10, 15, 30]
    System.out.println(data.removeLast()); //30
    System.out.println(data); //[10, 15]
    //queue
    var data2 = new ArrayDeque<Integer>(); 
    data2.addLast(10);
    data2.addLast(15);
    data2.addLast(30);

    System.out.println(data2); //[10, 15, 30]
    System.out.println(data2.removeFirst()); //10
    System.out.println(data2); //[15, 30]
  }
}

[Java] Collection-List / Set / Map / Stack / Queue

liste

ensemble

carte

Ordre des clés

Trier le tableau / la liste

Recherche floue

Pile / file d'attente