Notes de révision de Java Collections Framework

Aperçu

Une note de révision du cadre des collections. Depuis que j'ai examiné principalement la partie ajoutée dans le flux Java 8, le contenu est assez biaisé.

environnement

référence

L'exemple de code de cet article utilise la classe suivante, enum.

Classe utilisée dans l'exemple de code


public class Employee {
  private Long id;
  private String name;

  public Employee(Long id, String name) {
    this.id = id;
    this.name = name;
  }

  // getter/setter omis

 @Override
 public String toString() {
   return "Employee{" +
          "id=" + id +
          ", name='" + name + '\'' +
          '}';
  }

}

Énumération utilisée dans l'exemple de code


public enum DeepPurple {
  IanGillan("vocal"),
  SteveMorse("guitar"),
  RogerGlover("base"),
  IanPaice("drums"),
  DonAirey("keyboard");

  private String part;

  DeepPurple(String part) {
    this.part = part;
  }

  public String getPart() {
    return part;
  }
}

Collections

Une classe utilitaire qui opère sur les collections.

Ajouter un élément à la collection

Ajoutez n'importe quel nombre d'éléments passés dans le deuxième argument à la collection passée dans le premier argument.

addAll


@SafeVarargs
public static <T> boolean addAll(Collection<? super T> c, T... elements)

Ajouter un élément à la liste

Exemple


List<String> lists = new ArrayList<>();
lists.add("rubytomato");

Collections.addAll(lists,
  "garnetpepper",
  "spinelginger",
  "rubellitebeets"
);

System.out.println(lists);
// → [rubytomato, garnetpepper, spinelginger, rubellitebeets]

Ajouter un élément à définir

Exemple


Set<String> sets = new HashSet<>();
sets.add("rubytomato");

Collections.addAll(sets,
  "garnetpepper",
  "spinelginger",
  "rubellitebeets"
);

System.out.println(sets);
// → [rubytomato, spinelginger, rubellitebeet, garnetpepper]

Trier la liste

La liste passée dans le premier argument est triée par le comparateur passé dans le deuxième argument.

sort


public static <T> void sort(List<T> list, Comparator<? super T> c)

Trier un entier

Exemple


List<Integer> lists = Arrays.asList(5, 3, 1, 4, 2);

System.out.println(lists);
// → [5, 3, 1, 4, 2]

// Integer.Trier par résultat de compareTo
Collections.sort(lists, Integer::compareTo);

System.out.println(lists);
// → [1, 2, 3, 4, 5]

Trier la chaîne

Exemple


List<String> lists = Arrays.asList("bbbb", "ddd", "aaaaa", "c", "ee");

System.out.println(lists);
// → [bbbb, ddd, aaaaa, c, ee]

//Trier par ordre naturel des chaînes
Collections.sort(lists, Comparator.naturalOrder());

System.out.println(lists);
// → [aaaaa, bbbb, c, ddd, ee]

//Trier dans l'ordre inverse de l'ordre naturel des chaînes
Collections.sort(lists, Comparator.reverseOrder());

System.out.println(lists);
// → [ee, ddd, c, bbbb, aaaaa]

//Trier par longueur de chaîne
Collections.sort(lists, Comparator.comparing(String::length));

System.out.println(lists);
// → [c, ee, ddd, bbbb, aaaaa]

Exemple


Employee emp1 = new Employee(100L, "rubytomato");
Employee emp2 = new Employee(200L, "garnetpepper");
Employee emp3 = new Employee(300L, "spinelginger");
Employee emp4 = new Employee(400L, "rubellitebeets");

List<Employee> lists = Arrays.asList(emp4, emp3, emp2, emp1);

System.out.println(lists);
// → [Employee{id=400, name='rubellitebeets'}, Employee{id=300, name='spinelginger'}, Employee{id=200, name='garnetpepper'}, Employee{id=100, name='rubytomato'}]

// Employee.Trier numériquement par identifiant
Collections.sort(lists, Comparator.comparing(Employee::getId));

System.out.println(lists);
// → [Employee{id=100, name='rubytomato'}, Employee{id=200, name='garnetpepper'}, Employee{id=300, name='spinelginger'}, Employee{id=400, name='rubellitebeets'}]

List a également une méthode de tri, vous pouvez donc effectuer les opérations suivantes sans utiliser Collections.

Exemple


lists.sort(Comparator.comparing(Employee::getId));

Collection immuable vide, retourne la carte

List

La classe d'implémentation de List est java.util.Collections.EmptyList, et UnsupportedOperationException est levée lorsque le nombre d'éléments change (add, méthode addAll, etc.).

emptyList


public static final <T> List<T> emptyList()

Exemple


List<String> lists = Collections.emptyList();

Set

La classe d'implémentation de Set est java.util.Collections.EmptySet, et UnsupportedOperationException est levée lorsque le nombre d'éléments change (add, méthode addAll, etc.).

emptySet


public static final <T> Set<T> emptySet()

Exemple


Set<String> sets = Collections.emptySet();

Map

La classe d'implémentation Map est java.util.Collections.EmptyMap, et une exception UnsupportedOperationException est lancée lorsqu'une opération qui modifie le nombre d'éléments (put, méthode putAll, etc.) est effectuée.

emptyMap


public static final <K,V> Map<K,V> emptyMap()

Exemple


Map<Long, String> maps = Collections.emptyMap();

Renvoie une carte, une collection immuable avec un seul élément

List

La classe d'implémentation de List est java.util.Collections.SingletonList, qui renvoie une List avec uniquement les éléments passés en arguments. Si vous modifiez le nombre d'éléments (add, addAll, remove, clear méthodes, etc.) ou modifiez les éléments (méthodes set, replaceAll, etc.), une exception UnsupportedOperationException sera lancée.

singletonList


public static <T> List<T> singletonList(T o)

Exemple


List<String> list = Collections.singletonList("rubytomato");

Set

La classe d'implémentation pour Set est java.util.Collections.SingletonSet, qui renvoie un Set avec uniquement les éléments passés en arguments. Si vous modifiez le nombre d'éléments (méthode d'ajout, de suppression, d'effacement, etc.), une exception UnsupportedOperationException sera lancée.

singleton


public static <T> Set<T> singleton(T o)

Exemple


Set<String> set = Collections.singleton("rubytomato");

Map

La classe d'implémentation Map est java.util.Collections.SingletonMap, qui renvoie une Map avec uniquement la clé / valeur passée en argument. Si vous modifiez le nombre d'éléments (méthodes put, remove, clear, etc.) ou modifiez les éléments (méthodes replace, replaceAll, etc.), une exception UnsupportedOperationException sera lancée.

singletonMap


public static <K,V> Map<K,V> singletonMap(K key, V value)

Exemple


Map<Long, String> map = Collections.singletonMap(100L, "rubytomato");

Collection immuable, retour carte

Collection

La classe d'implémentation est java.util.Collections.UnmodifiableCollection, qui renvoie une collection immuable de la Collection passée en argument. Si vous modifiez le nombre d'éléments (méthode d'ajout, de suppression, d'effacement, etc.), une exception UnsupportedOperationException sera lancée.

unmodifiableCollection


public static <T> Collection<T> unmodifiableCollection(Collection<? extends T> c)

Exemple


List<String> lists = new ArrayList<>();
Collections.addAll(lists, "ruby", "garnet", "spinel");

Collection<String> unmodifiable = Collections.unmodifiableCollection(lists);

unmodifiable.add("rubellite");
//→ Lancer une exception d'opération non prise en charge

List

La classe d'implémentation de List est java.util.Collections.UnmodifiableRandomAccessList, qui retourne une collection immuable de la List passée en argument. Si vous modifiez le nombre d'éléments (add, addAll, remove, clear méthodes, etc.) ou modifiez les éléments (méthodes set, replaceAll, etc.), une exception UnsupportedOperationException sera lancée.

unmodifiableList


public static <T> List<T> unmodifiableList(List<? extends T> list)

Exemple


List<String> lists = new ArrayList<>();
Collections.addAll(lists, "ruby", "garnet", "spinel");

List<String> unmodifiedLists = Collections.unmodifiableList(lists);

unmodifiedLists.add("rubellite");
//→ Lancer une exception d'opération non prise en charge

Set

La classe d'implémentation pour Set est java.util.Collections.UnmodifiableSet, qui retourne une collection immuable de l'ensemble passée en argument. Si vous modifiez le nombre d'éléments (méthode d'ajout, de suppression, d'effacement, etc.), une exception UnsupportedOperationException sera lancée.

unmodifiableSet


public static <T> Set<T> unmodifiableSet(Set<? extends T> s)

Exemple


Set<String> sets = new HashSet<>();
Collections.addAll(sets, "ruby", "garnet", "spinel");

Set<String> unmodifiedSets = Collections.unmodifiableSet(sets);

unmodifiedSets.add("rubellite");
//→ Lancer une exception d'opération non prise en charge

Map

La classe d'implémentation de Map est java.util.Collections.UnmodifiableMap, qui retourne la carte immuable de la Map passée en argument. Si vous modifiez le nombre d'éléments (méthodes put, remove, clear, etc.) ou modifiez les éléments (méthodes replace, replaceAll, etc.), une exception UnsupportedOperationException sera lancée.

unmodifiableMap


public static <K,V> Map<K,V> unmodifiableMap(Map<? extends K,? extends V> m)

Exemple


Map<Long, String> maps = new HashMap<>();
maps.put(100L, "ruby");
maps.put(200L, "garnet");
maps.put(300L, "spinel");

Map<Long, String> unmodifiedMaps = Collections.unmodifiableMap(maps);

unmodifiedMaps.put(400L, "rubellite");
//→ Lancer une exception d'opération non prise en charge

Arrays

Une classe utilitaire pour manipuler des tableaux.

Générer une liste à partir d'un tableau

La classe d'implémentation de List est java.util.Arrays.ArrayList, qui crée et renvoie une List à partir du tableau passé en argument. Si vous modifiez le nombre d'éléments (méthode add, remove, etc.), une exception UnsupportedOperationException sera lancée. Vous pouvez modifier les éléments (méthode set, replaceAll, etc.).

asList


@SafeVarargs
public static <T> List<T> asList(T... a)

Exemple


String[] arrays = new String[] {"rubytomato", "garnetpepper", "spinelginger"};
List<String> lists = Arrays.asList(arrays);

System.out.println(lists);
// → [rubytomato, garnetpepper, spinelginger]

Exemple


List<String> lists = Arrays.asList("rubytomato", "garnetpepper", "spinelginger");

System.out.println(lists);
// → [rubytomato, garnetpepper, spinelginger]

//Mettre à jour les éléments en majuscules
lists.replaceAll(String::toUpperCase);

System.out.println(lists);
// → [RUBYTOMATO, GARNETPEPPER, SPINELGINGER]

Mettre à jour les éléments d'un tableau

Introduction à la version Java 1.8 </ font>

Mettez à jour chaque élément du tableau passé dans le premier argument avec le résultat de l'opération de la fonction passée dans le deuxième argument.

setAll


public static <T> void setAll(T[] array,
    IntFunction<? extends T> generator)

Exemple


String[] arrays = new String[] {"rubytomato", "garnetpepper", "spinelginger", "rubellitebeets"};

Arrays.stream(arrays).forEach(e -> { System.out.println(e +  " ID:" + System.identityHashCode(e));});
// → rubytomato ID:864237698
// → garnetpepper ID:537548559
// → spinelginger ID:380894366
// → rubellitebeets ID:237852351

Arrays.setAll(arrays, index -> {
  if (index % 2 == 0) {
    return arrays[index].toUpperCase();
  }
  return arrays[index];
});

Arrays.stream(arrays).forEach(e -> { System.out.println(e +  " ID:" + System.identityHashCode(e));});
// → RUBYTOMATO ID:1221555852
// → garnetpepper ID:537548559
// → SPINELGINGER ID:1509514333
// → rubellitebeets ID:237852351

Créer un flux à partir d'un tableau

Introduction à la version Java 1.8 </ font>

Créez un Stream à partir du tableau passé à l'argument.

stream


public static <T> Stream<T> stream(T[] array)

Exemple


String[] arrays = new String[] {"rubytomato", "garnetpepper", "spinelginger"};

Arrays.stream(arrays).forEach(System.out::println);
// → rubytomato
// → garnetpepper
// → spinelginger

Vérifiez si les deux séquences sont équivalentes

Vérifiez si les deux tableaux passés dans l'argument sont équivalents (chaque élément est équivalent dans la même séquence).

equals


public static boolean equals(Object[] a, Object[] a2)

Exemple


String[] arrays1 = new String[] {"ruby", "garnet", "spinel", "rubellite"};
String[] arrays2 = new String[] {"ruby", "garnet", "spinel", "rubellite"};
String[] arrays3 = new String[] {"garnet", "ruby", "spinel", "rubellite"};

System.out.println(arrays1.equals(arrays2));
// → false

System.out.println(Arrays.equals(arrays1, arrays2));
// → true

//Si la disposition des éléments n'est pas la même, elle ne sera pas jugée équivalente
System.out.println(Arrays.equals(arrays1, arrays3));
// → false

Vérifiez si deux tableaux multidimensionnels sont équivalents

Vérifie si les deux tableaux passés dans l'argument sont équivalents. Pour les tableaux multidimensionnels.

deepEquals


public static boolean deepEquals(Object[] a1, Object[] a2)

Exemple


String[][] arrays1 = new String[][] {
  {"ruby", "garnet"},
  {"spinel", "rubellite"}
};
String[][] arrays2 = new String[][] {
  {"ruby", "garnet"},
  {"spinel", "rubellite"}
};

System.out.println(Arrays.equals(arrays1, arrays2));
// → false

System.out.println(Arrays.deepEquals(arrays1, arrays2));
// → true

Renvoie une représentation sous forme de chaîne d'un tableau

Renvoie la représentation sous forme de chaîne du tableau passé dans l'argument. Si le tableau est nul, la chaîne «null» est renvoyée.

toString


public static String toString(Object[] a)

Exemple


Employee[] employees = new Employee[] {
  new Employee(100L, "rubytomato"),
  new Employee(200L, "garnetpepper"),
  new Employee(300L, "rubytomato"),
  new Employee(400L, "rubellitebeets")
};

System.out.println(employees.toString());
// → [Lcom.example.Employee;@51521cc1

System.out.println(Arrays.toString(employees));
// → [Employee{id=100, name='rubytomato'}, Employee{id=200, name='garnetpepper'}, Employee{id=300, name='rubytomato'}, Employee{id=400, name='rubellitebeets'}]

** Si nul **

Si le tableau est nul, NullPointerException n'est pas levé et la chaîne «null» est imprimée.

Exemple


Employee[] employees = null;

System.out.println(Arrays.toString(employees));
// → null

Renvoie une représentation sous forme de chaîne d'un tableau multidimensionnel

Renvoie la représentation sous forme de chaîne du tableau passé dans l'argument. Pour les tableaux multidimensionnels. Si le tableau est nul, la chaîne «null» est renvoyée.

deepToString


public static String deepToString(Object[] a)

Exemple


Employee[][] employees = new Employee[][] {
  {
    new Employee(100L, "rubytomato"),
    new Employee(200L, "garnetpepper")
  },
  {
    new Employee(300L, "spinelginger"),
    new Employee(400L, "rubellitebeets")
  }
;

System.out.println(Arrays.toString(employees));
// → [[Lcom.example.Employee;@1b4fb997, [Lcom.example.Employee;@deb6432]

System.out.println(Arrays.deepToString(employees));
// → [[Employee{id=100, name='rubytomato'}, Employee{id=200, name='garnetpepper'}], [Employee{id=300, name='spinelginger'}, Employee{id=400, name='rubellitebeets'}]]

** Si nul **

Si le tableau est nul, NullPointerException n'est pas levé et la chaîne «null» est imprimée.

Exemple


Employee[][] employees = null;

System.out.println(Arrays.deepToString(employees));
// → null

Collection

removeIf

Introduction à la version Java 1.8 </ font>

Supprime les éléments de la collection qui correspondent aux critères de filtre passés dans l'argument.

removeIf


default boolean removeIf(Predicate<? super E> filter)

Exemple


List<String> fruits = new ArrayList<>();
Collections.addAll(fruits, "chocolate vine", "fig tree", "blackcurrant", "bramble",
    "silverberry", "mulberry", "cranberry", "lingonberry", "pomegranate", "seaberry",
    "jujube", "japanese bush cherry", "bilberry", "redcurrant", "grape");

// "berry"Supprimer les éléments se terminant par
fruits.removeIf(name -> name.endsWith("berry"));

System.out.println(fruits);
// → [chocolate vine, fig tree, blackcurrant, bramble, pomegranate, jujube, japanese bush cherry, redcurrant, grape]

retainAll

Laisse les mêmes éléments que les éléments de collection que vous passez dans l'argument. Supprimez les éléments sans correspondance de la collection.

retainAll


boolean retainAll(Collection<?> c)

Exemple


List<String> jewels = new ArrayList<>();
Collections.addAll(jewels, "amber", "aquamarine", "citrine", "garnet", "rubellite", "ruby",
    "sapphire", "sinhalight", "spinel", "tanzanite", "tourmaline");

System.out.println(jewels);
// → [amber, aquamarine, citrine, garnet, rubellite, ruby, sapphire, sinhalight, spinel, tanzanite, tourmaline]

List<String> red = Arrays.asList("ruby", "rubellite", "spinel", "garnet");

boolean modified = jewels.retainAll(red);

System.out.println(modified);
// → true
System.out.println(jewels);
// → [garnet, rubellite, ruby, spinel]

stream

Introduction à la version Java 1.8 </ font>

Générez un flux à partir de la collection.

stream


default Stream<E> stream()

Exemple


List<String> lists = new ArrayList<>();
Collections.addAll(lists, "ruby", "garnet", "spinel");

lists.stream()
    .map(String::toUpperCase)
    .forEach(System.out::println);
// → RUBY
// → GARNET
// → SPINEL

toArray

Générez un tableau à partir de la collection.

toArray


<T> T[] toArray(T[] a)

Exemple


List<String> lists = new ArrayList<>();
Collections.addAll(lists, "ruby", "garnet", "spinel");

//De la liste à la matrice
String[] arrays = lists.toArray(new String[0]);

System.out.println(Arrays.toString(arrays));
// → [ruby, garnet, spinel]

List

add

Ajoutez l'élément spécifié par le deuxième argument à la position de l'index spécifié par le premier argument.

add


void add(int index, E element)

Exemple


List<String> lists = new ArrayList<>();
Collections.addAll(lists, "Louis", "Keith", "Charles", "Williams", "Michael", "Ronald");

// index=Ajouter un élément à la position 3
lists.add(3, "Darryl");

System.out.println(lists);
// → [Louis, Keith, Charles, Darryl, Williams, Michael, Ronald]

Ajouter en haut de la liste


lists.add(0, "Darryl");

Ajouter à la fin de la liste


lists.add(lists.size(), "Darryl");

addAll

Ajoutez l'élément de la collection spécifié par le deuxième argument à la position de l'index spécifié par le premier argument.

addAll


boolean addAll(int index, Collection<? extends E> c)

Exemple


List<String> lists = new ArrayList<>();
Collections.addAll(lists, "Louis", "Keith", "Charles", "Williams", "Michael", "Ronald");

System.out.println(lists);
// → [Louis, Keith, Charles, Williams, Michael, Ronald]

List<String> others = Arrays.asList("Darryl", "Ian", "Tony");
lists.addAll(3, others);

System.out.println(lists);
// → [Louis, Keith, Charles, Darryl, Ian, Tony, Williams, Michael, Ronald]

set

Remplace l'élément d'index spécifié dans le premier argument par l'élément spécifié dans le deuxième argument.

set


E set(int index, E element)

Exemple


List<String> lists = new ArrayList<>();
Collections.addAll(lists, "Louis", "Keith", "Charles", "Williams", "Michael", "Ronald");

String oldValue = lists.set(3, "Darryl");

System.out.println(oldValue);
// → Williams

System.out.println(lists);
// → [Louis, Keith, Charles, Darryl, Michael, Ronald]

replaceAll

Introduction à la version Java 1.8 </ font>

Le résultat de l'opération de l'opérateur passé à l'argument est appliqué à chaque élément et remplacé par le résultat.

replaceAll


default void replaceAll(UnaryOperator<E> operator)

Exemple


List<String> lists = new ArrayList<>();
Collections.addAll(lists, "Louis", "Keith", "Charles", "Williams", "Michael", "Ronald");

System.out.println(lists);
// → [Louis, Keith, Charles, Williams, Michael, Ronald]

lists.replaceAll(s -> String.join("", "[", s.toUpperCase(), "]"));

System.out.println(lists);
// → [[LOUIS], [KEITH], [CHARLES], [WILLIAMS], [MICHAEL], [RONALD]]

remove

Supprime l'élément d'index spécifié par l'argument de la collection.

remove


E remove(int index)

Exemple


List<String> lists = new ArrayList<>();
Collections.addAll(lists, "Louis", "Keith", "Charles", "Williams", "Michael", "Ronald");

String value = lists.remove(3);

System.out.println(value);
// → Williams

System.out.println(lists);
// → [Louis, Keith, Charles, Michael, Ronald]
```

 [sort](https://docs.oracle.com/javase/jp/8/docs/api/java/util/List.html#sort-java.util.Comparator-)

 <font color = "blue"> Introduction à la version Java 1.8 </ font>

 Triez la liste en utilisant le comparateur que vous passez en argument.


#### **`sort`**
```text

default void sort(Comparator<? super E> c)
```


#### **`Exemple`**
```java

List<String> lists = new ArrayList<>();
Collections.addAll(lists, "AAAA", "BBBB", "CCC", "DDD", "EE", "FFFFF", "AAAA", "BBB");

// String.Trier par résultat de compareTo
lists.sort(String::compareTo);

System.out.println(lists);
// → [AAAA, AAAA, BBB, BBBB, CCC, DDD, EE, FFFFF]
```


#### **`Exemple`**
```java

List<String> lists = new ArrayList<>();
Collections.addAll(lists, "AAAA", "BBBB", "CCC", "DDD", "EE", "FFFFF", "AAAA", "BBB");

//Trier par longueur de chaîne.
lists.sort(Comparator.comparing(String::length));

System.out.println(lists);
// → [EE, CCC, DDD, BBB, AAAA, BBBB, AAAA, FFFFF]
```


#### **`Exemple`**
```java

List<String> lists = new ArrayList<>();
Collections.addAll(lists, "AAAA", "BBBB", "CCC", "DDD", "EE", "FFFFF", "AAAA", "BBB");

//Longueur de chaine+ String.Trier par résultat de compareTo
lists.sort(Comparator.comparing(String::length)
    .thenComparing(String::compareTo));

System.out.println(lists);
// → [EE, BBB, CCC, DDD, AAAA, AAAA, BBBB, FFFFF]
```

 [ArrayList](https://docs.oracle.com/javase/jp/8/docs/api/java/util/ArrayList.html)

## Générer une nouvelle ArrayList à partir de la collection

 Générez une ArrayList à partir de la collection transmise aux arguments du constructeur.


#### **`constructeur`**
```text

public ArrayList(Collection<? extends E> c)
```

 ** Défini sur ArrayList **


#### **`Exemple`**
```java

Set<String> sets = new HashSet<>();
Collections.addAll(sets, "Louis", "Keith", "Charles", "Williams", "Michael", "Ronald");

//Générer ArrayList à partir de l'ensemble
List<String> lists = new ArrayList<>(sets);

System.out.println(lists);
// → [Charles, Keith, Williams, Ronald, Michael, Louis]
```

 [Set](https://docs.oracle.com/javase/jp/8/docs/api/java/util/Set.html)

 Il n'y a pas de méthode unique à l'interface Set, je vais donc l'omettre.

 [HashSet](https://docs.oracle.com/javase/jp/8/docs/api/java/util/HashSet.html)

## Générer un nouveau HashSet à partir de la collection

 Générez un HashSet à partir de la collection transmise aux arguments du constructeur.


#### **`constructeur`**
```text

public HashSet(Collection<? extends E> c)
```

 ** Liste à HashSet **


#### **`Exemple`**
```java

List<String> lists = new ArrayList<>();
Collections.addAll(lists, "Louis", "Keith", "Charles", "Williams", "Michael", "Ronald");

//Générer un HashSet à partir de la liste
Set<String> sets = new HashSet<>(lists);

System.out.println(sets);
// → [Charles, Keith, Williams, Ronald, Michael, Louis]
```

 [EnumSet](https://docs.oracle.com/javase/jp/8/docs/api/java/util/EnumSet.html)

 <font color = "green"> Version d'introduction Java 1.5 </ font>

 [allOf](https://docs.oracle.com/javase/jp/8/docs/api/java/util/EnumSet.html#allOf-java.lang.Class-)

 Génère un EnumSet composé de tous les énumérateurs des noms d'énumération passés dans les arguments.


#### **`allOf`**
```text

public static <E extends Enum<E>> EnumSet<E> allOf(Class<E> elementType)
```


#### **`Exemple`**
```java

EnumSet<DeepPurple> enums = EnumSet.allOf(DeepPurple.class);

System.out.println(enums);
// → [IanGillan, SteveMorse, RogerGlover, IanPaice, DonAirey]
```

 [copyOf](https://docs.oracle.com/javase/jp/8/docs/api/java/util/EnumSet.html#copyOf-java.util.Collection-)

 Générez un EnumSet à partir de la collection passé en argument.


#### **`copyOf`**
```text

public static <E extends Enum<E>> EnumSet<E> copyOf(Collection<E> c)
```


#### **`Exemple`**
```java

Set<DeepPurple> sets = new HashSet<>();
Collections.addAll(sets, DeepPurple.IanGillan, DeepPurple.IanPaice);

EnumSet<DeepPurple> enums = EnumSet.copyOf(sets);

System.out.println(enums);
// → [IanGillan, IanPaice]
```


#### **`Exemple`**
```java

List<DeepPurple> lists = new ArrayList<>();
Collections.addAll(lists, DeepPurple.IanGillan, DeepPurple.IanPaice);

EnumSet<DeepPurple> enums = EnumSet.copyOf(lists);

System.out.println(enums);
// → [IanGillan, IanPaice]
```

 [noneOf](https://docs.oracle.com/javase/jp/8/docs/api/java/util/EnumSet.html#noneOf-java.lang.Class-)

 Génère un EnumSet vide du type d'énumération passé à l'argument.


#### **`noneOf`**
```text

public static <E extends Enum<E>> EnumSet<E> noneOf(Class<E> elementType)
```


#### **`Exemple`**
```java

EnumSet<DeepPurple> enums = EnumSet.noneOf(DeepPurple.class);

System.out.println(enums);
// → []
```

 [of](https://docs.oracle.com/javase/jp/8/docs/api/java/util/EnumSet.html#of-E-)

 Génère un EnumSet composé d'énumérateurs à passer en arguments.


#### **`of`**
```text

public static <E extends Enum<E>> EnumSet<E> of(E e)
public static <E extends Enum<E>> EnumSet<E> of(E e1, E e2)
public static <E extends Enum<E>> EnumSet<E> of(E e1, E e2, E e3)
public static <E extends Enum<E>> EnumSet<E> of(E e1, E e2, E e3, E e4)
public static <E extends Enum<E>> EnumSet<E> of(E e1, E e2, E e3, E e4, E e5)
```


#### **`of`**
```text

@SafeVarargs
public static <E extends Enum<E>> EnumSet<E> of(E first, E... rest)
```


#### **`Exemple`**
```java

EnumSet<DeepPurple> enums = EnumSet.of(DeepPurple.RogerGlover, DeepPurple.DonAirey, DeepPurple.SteveMorse);

System.out.println(enums);
// → [SteveMorse, RogerGlover, DonAirey]
```

 [Map](https://docs.oracle.com/javase/jp/8/docs/api/java/util/Map.html)

 > [Pourquoi Map n'hérite pas de Collection? ](https://docs.oracle.com/javase/jp/8/docs/technotes/guides/collections/designfaq.html#a14)
 > C'est par conception. Je pense que la cartographie n'est pas une collection et la collection n'est pas une cartographie. Par conséquent, il est peu logique que Map hérite de l'interface Collection et vice versa.

 [compute](https://docs.oracle.com/javase/jp/8/docs/api/java/util/Map.html#compute-K-java.util.function.BiFunction-)

 <font color = "blue"> Introduction à la version Java 1.8 </ font>

 La fonction passée dans le deuxième argument est appliquée à la valeur mappée à la clé spécifiée dans le premier argument, la valeur de la clé est mise à jour avec le résultat du calcul et elle est renvoyée.
 Si la clé n'est pas mappée, la valeur est calculée comme nulle.
 Si la fonction renvoie null, l'entrée sera supprimée.


#### **`compute`**
```text

default V compute(K key,
    BiFunction<? super K,? super V,? extends V> remappingFunction)
```


#### **`Exemple`**
```java

Map<String, String> maps = new HashMap<>();
maps.put("ruby", "tomato");
maps.put("garnet", "pepper");
maps.put("spinel", "ginger");
maps.put("rubellite", null);

//Fonctions exécutées avec ou sans mappage
BiFunction<String, String, String> remapping = (key, val) -> {
  if (val == null) {
    //Cet exemple renvoie une chaîne,
    //Par exemple, vous pouvez exécuter un traitement tel que la recherche de la valeur dans le DB avec clé.
    return "UNKNOWN";
  }
  return val.toUpperCase();
};

//Mappé
String value = maps.compute("ruby", remapping);

System.out.println(value);
// → TOMATO

//Mappé à null
value = maps.compute("rubellite", remapping);

System.out.println(value);
// → UNKNOWN

//Non mappé
value = maps.compute("sapphire", remapping);

System.out.println(value);
// → UNKNOWN

System.out.println(maps);
// → {spinel=ginger, rubellite=UNKNOWN, garnet=pepper, sapphire=UNKNOWN, ruby=TOMATO}
```

 [computeIfAbsent](https://docs.oracle.com/javase/jp/8/docs/api/java/util/Map.html#computeIfAbsent-K-java.util.function.Function-)

 <font color = "blue"> Introduction à la version Java 1.8 </ font>

 Si la valeur n'est pas mappée (ou null est mappée) à la clé spécifiée dans le premier argument, le résultat du calcul de la fonction passée dans le deuxième argument est mis à jour en tant que valeur de clé et renvoyé.
 Si la clé a une valeur mappée, la carte ne sera pas mise à jour et la valeur de clé sera renvoyée.
 Si la fonction renvoie null, l'entrée ne sera pas enregistrée.


#### **`computeIfAbsent`**
```text

default V computeIfAbsent(K key,
    Function<? super K,? extends V> mappingFunction)
```


#### **`Exemple`**
```java

Map<String, String> maps = new HashMap<>();
maps.put("ruby", "tomato");
maps.put("garnet", "pepper");
maps.put("spinel", "ginger");
maps.put("rubellite", null);

//Fonction exécutée lorsqu'une valeur non nulle n'est pas mappée à la clé
Function<String, String> mapping = (key) -> {
  //Cet exemple renvoie une chaîne,
  //Par exemple, vous pouvez exécuter un traitement tel que la recherche de la valeur dans le DB avec clé.
  return "UNKNOWN";
};

//La fonction n'est pas exécutée car elle est mappée
String value = maps.computeIfAbsent("ruby", mapping);

System.out.println(value);
// → tomato

//Puisqu'il est mappé à null, il exécute la fonction et renvoie le résultat.
value = maps.computeIfAbsent("rubellite", mapping);

System.out.println(value);
// → UNKNOWN

//Non mappé, alors exécutez la fonction et renvoyez le résultat
value = maps.computeIfAbsent("sapphire", mapping);

System.out.println(value);
// → UNKNOWN

System.out.println(maps);
// → {spinel=ginger, rubellite=UNKNOWN, garnet=pepper, sapphire=UNKNOWN, ruby=tomato}
```

 [computeIfPresent](https://docs.oracle.com/javase/jp/8/docs/api/java/util/Map.html#computeIfPresent-K-java.util.function.BiFunction-)

 <font color = "blue"> Introduction à la version Java 1.8 </ font>

 Si une valeur autre que null est mappée à la clé spécifiée dans le premier argument, la fonction passée dans le second argument est appliquée, la valeur de clé est mise à jour avec le résultat du calcul et elle est renvoyée.
 Si aucune valeur n'est mappée à la clé, la fonction ne sera pas exécutée et la carte ne sera pas mise à jour.
 Si la fonction renvoie null, l'entrée sera supprimée.


#### **`computeIfPresent`**
```text

default V computeIfPresent(K key,
    BiFunction<? super K,? super V,? extends V> remappingFunction)
```


#### **`Exemple`**
```java

Map<String, String> maps = new HashMap<>();
maps.put("ruby", "tomato");
maps.put("garnet", "pepper");
maps.put("spinel", "ginger");
maps.put("rubellite", null);

//Fonction exécutée lorsqu'une valeur non nulle est mappée à la clé
BiFunction<String, String, String> remapping = (key, val) -> {
  return val.toUpperCase();
};

//Puisqu'il est mappé, il exécute la fonction et renvoie le résultat.
String value = maps.computeIfPresent("ruby", remapping);

System.out.println(value);
// → TOMATO

//La fonction n'est pas exécutée car elle est mappée à null
value = maps.computeIfPresent("rubellite", remapping);

System.out.println(value);
// → null

//La fonction n'est pas exécutée car elle n'est pas mappée
value = maps.computeIfPresent("sapphire", remapping);

System.out.println(value);
// → null

System.out.println(maps);
// → {spinel=ginger, rubellite=null, garnet=pepper, ruby=TOMATO}
```

 [forEach](https://docs.oracle.com/javase/jp/8/docs/api/java/util/Map.html#forEach-java.util.function.BiConsumer-)

 <font color = "blue"> Introduction à la version Java 1.8 </ font>

 Exécute la fonction transmise comme argument pour chaque entrée de la carte.


#### **`forEach`**
```text

default void forEach(BiConsumer<? super K,? super V> action)
```


#### **`Exemple`**
```java

Map<String, String> maps = new HashMap<>();
maps.put("ruby", "tomato");
maps.put("garnet", "pepper");
maps.put("spinel", "ginger");
maps.put("rubellite", "beets");

maps.forEach((key, val) -> {
  System.out.println("key=" + key + ", value=" + val);
});
// → key=spinel, value=ginger
// → key=rubellite, value=beets
// → key=garnet, value=pepper
// → key=ruby, value=tomato
```

 [merge](https://docs.oracle.com/javase/jp/8/docs/api/java/util/Map.html#merge-K-V-java.util.function.BiFunction-)

 <font color = "blue"> Introduction à la version Java 1.8 </ font>

 Mappe la valeur passée dans le deuxième argument lorsque la valeur n'est pas mappée (ou null est mappée) à la clé spécifiée dans le premier argument.
 Si la clé est mappée, remplacez la valeur par le résultat du calcul de la fonction passée dans le troisième argument. Si la fonction renvoie null, supprimez l'entrée.


#### **`merge`**
```text

default V merge(K key, V value,
    BiFunction<? super V,? super V,? extends V> remappingFunction)
```


#### **`Exemple`**
```java

Map<String, String> maps = new HashMap<>();
maps.put("ruby", "tomato");
maps.put("garnet", "pepper");
maps.put("spinel", "ginger");
maps.put("rubellite", null);

Map<String, String> otherMaps = new HashMap<>();
otherMaps.put("rubellite", "BEETS");
otherMaps.put("ruby", "TOMATO");
otherMaps.put("sapphire", "SPINACH");

otherMaps.forEach((key, value) -> {
  maps.merge(key, value, (oldVal, newVal) -> {
    return oldVal + " -> " + newVal;
  });
});

System.out.println(maps);
// → {spinel=ginger, rubellite=BEETS, garnet=pepper, sapphire=SPINACH, ruby=tomato -> TOMATO}
```

 [putIfAbsent](https://docs.oracle.com/javase/jp/8/docs/api/java/util/Map.html#putIfAbsent-K-V-)

 <font color = "blue"> Introduction à la version Java 1.8 </ font>

 Si la valeur spécifiée dans le premier argument n'est pas mappée (ou si null est mappée), la valeur de clé est mise à jour avec la valeur transmise dans le deuxième argument.
 Si une valeur non nulle est déjà mappée, la carte ne sera pas mise à jour.


#### **`putIfAbsent`**
```text

default V putIfAbsent(K key, V value)
```


#### **`Exemple`**
```java

Map<String, String> maps = new HashMap<>();
maps.put("ruby", "tomato");
maps.put("garnet", "pepper");
maps.put("spinel", "ginger");
maps.put("rubellite", null);

//Mettre à jour si mappé à null
String value = maps.putIfAbsent("rubellite", "BEETS");

System.out.println(value);
// → null

//Ne se met pas à jour s'il est mappé
value = maps.putIfAbsent("ruby", "TOMATO");

System.out.println(value);
// → tomato

//S'il n'est pas mappé, il sera mappé avec un argument
value = maps.putIfAbsent("sapphire", "SPINACH");

System.out.println(value);
// → null

System.out.println(maps);
// → {spinel=ginger, rubellite=BEETS, garnet=pepper, ruby=tomato, sapphire=SPINACH}
```

 [remove](https://docs.oracle.com/javase/jp/8/docs/api/java/util/Map.html#remove-java.lang.Object-java.lang.Object-)

 <font color = "blue"> Introduction à la version Java 1.8 </ font>

 Si la valeur spécifiée dans le deuxième argument est mappée à la clé spécifiée dans le premier argument (y compris le cas où la valeur est nulle), cette entrée est supprimée.


#### **`remove`**
```text

default boolean remove(Object key, Object value)
```


#### **`Exemple`**
```java

Map<String, String> maps = new HashMap<>();
maps.put("ruby", "tomato");
maps.put("garnet", "pepper");
maps.put("spinel", "ginger");
maps.put("rubellite", "beets");
maps.put("sapphire", null);

boolean modified = maps.remove("ruby", "TOMATO");

System.out.println(modified);
// → false

modified = maps.remove("ruby", "tomato");

System.out.println(modified);
// → true

modified = maps.remove("sapphire", null);

System.out.println(modified);
// → true

System.out.println(maps);
// → {spinel=ginger, rubellite=beets, garnet=pepper}
```

 [replace](https://docs.oracle.com/javase/jp/8/docs/api/java/util/Map.html#replace-K-V-)

 <font color = "blue"> Introduction à la version Java 1.8 </ font>

 Si la clé spécifiée dans le premier argument est mappée (y compris le cas où la valeur est nulle), remplacez-la par la valeur passée dans le deuxième argument.
 Ne met pas à jour la carte si la clé n'est pas mappée.


#### **`replace`**
```text

default V replace(K key, V value)
```


#### **`Exemple`**
```java

Map<String, String> maps = new HashMap<>();
maps.put("ruby", "tomato");
maps.put("garnet", "pepper");
maps.put("spinel", "ginger");
maps.put("rubellite", "beets");

String oldValue = maps.replace("ruby", "TOMATO");

System.out.println(oldValue);
// → tomato

oldValue = maps.replace("sapphire", "spinach");

System.out.println(oldValue);
// → null

System.out.println(maps);
// → {spinel=ginger, rubellite=beets, garnet=pepper, ruby=TOMATO}
```

 [replaceAll](https://docs.oracle.com/javase/jp/8/docs/api/java/util/Map.html#replaceAll-java.util.function.BiFunction-)

 <font color = "blue"> Introduction à la version Java 1.8 </ font>

 Remplacez la valeur par le résultat de l'opération de la fonction passée à l'argument.


#### **`replaceAll`**
```text

default void replaceAll(BiFunction<? super K,? super V,? extends V> function)
```


#### **`Exemple`**
```java

Map<String, String> maps = new HashMap<>();
maps.put("ruby", "tomato");
maps.put("garnet", "pepper");
maps.put("spinel", "ginger");
maps.put("rubellite", "beets");
maps.put("sapphire", null);

maps.replaceAll((key, value) -> {
  if (value == null) {
    return "UNKNOWN";
  }
  return value.toUpperCase();
});

System.out.println(maps);
// → {spinel=GINGER, rubellite=BEETS, garnet=PEPPER, ruby=TOMATO, sapphire=UNKNOWN}
```

 [HashMap](https://docs.oracle.com/javase/jp/8/docs/api/java/util/HashMap.html)

## Générer un nouveau HashMap à partir de Map

 Générez un nouveau HashMap à partir de la carte que vous passez aux arguments du constructeur.


#### **`constructeur`**
```text

public HashMap(Map<? extends K,? extends V> m)
```

 ** Carte vers HashMap **


#### **`Exemple`**
```java

Map<String, String> maps = new HashMap<>();
maps.put("ruby", "tomato");
maps.put("garnet", "pepper");
maps.put("spinel", "ginger");

//Générer un nouveau HashMap
Map<String, String> newMaps = new HashMap<>(maps);
newMaps.put("rubellite", "beets");

System.out.println(maps);
// → {spinel=ginger, garnet=pepper, ruby=tomato}

System.out.println(newMaps);
// → {spinel=ginger, garnet=pepper, ruby=tomato, rubellite=beets}
```

 [EnumMap](https://docs.oracle.com/javase/jp/8/docs/api/java/util/EnumMap.html)

 <font color = "green"> Version d'introduction Java 1.5 </ font>

## Générer une nouvelle EnumMap à partir de Map

 Générez un nouvel EnumMap à partir de la carte que vous passez aux arguments du constructeur.


#### **`constructeur`**
```text

public EnumMap(Map<K,? extends V> m)
```


#### **`Exemple`**
```java

Map<DeepPurple, LocalDate> maps = new HashMap<>();
maps.put(DeepPurple.IanGillan, LocalDate.of(1945, 8, 19));
maps.put(DeepPurple.SteveMorse, LocalDate.of(1954, 7, 28));
maps.put(DeepPurple.RogerGlover, LocalDate.of(1945, 11, 30));
maps.put(DeepPurple.IanPaice, LocalDate.of(1948, 6, 29));
maps.put(DeepPurple.DonAirey, LocalDate.of(1948, 6, 21));

EnumMap<DeepPurple, LocalDate> enums = new EnumMap<>(maps);

System.out.println(enums);
// → {IanGillan=1945-08-19, SteveMorse=1954-07-28, RogerGlover=1945-11-30, IanPaice=1948-06-29, DonAirey=1948-06-21}
```

## Générer un ensemble depuis EnumMap


#### **`entrySet`**
```text

public Set<Map.Entry<K,V>> entrySet()
```


#### **`Exemple`**
```java

EnumMap<DeepPurple, LocalDate> enums = new EnumMap<>(DeepPurple.class);
enums.put(DeepPurple.IanGillan, LocalDate.of(1945, 8, 19));
enums.put(DeepPurple.SteveMorse, LocalDate.of(1954, 7, 28));
enums.put(DeepPurple.RogerGlover, LocalDate.of(1945, 11, 30));
enums.put(DeepPurple.IanPaice, LocalDate.of(1948, 6, 29));
enums.put(DeepPurple.DonAirey, LocalDate.of(1948, 6, 21));

Set<Map.Entry<DeepPurple, LocalDate>> sets = enums.entrySet();

System.out.println(sets);
// → [IanGillan=1945-08-19, SteveMorse=1954-07-28, RogerGlover=1945-11-30, IanPaice=1948-06-29, DonAirey=1948-06-21]
```

# [API ajoutée dans Java 9](https://docs.oracle.com/javase/jp/9/docs/api/java/util/package-summary.html)

 [Collections](https://docs.oracle.com/javase/jp/9/docs/api/java/util/Collections.html)

 Il n'y a pas d'ajouts.

 [Arrays](https://docs.oracle.com/javase/jp/9/docs/api/java/util/Arrays.html)

 equals

 Les méthodes d'égalité suivantes ont été ajoutées.

```text
public static boolean equals​(int[] a, int aFromIndex, int aToIndex,
                             int[] b, int bFromIndex, int bToIndex)
```

 compare

 Certaines méthodes de comparaison ont été ajoutées, telles que:

```text
public static int compare​(int[] a,
                          int[] b)
```

 compareUnsigned

 Certaines méthodes compareUnsigned ont été ajoutées, telles que:

```text
public static int compareUnsigned​(int[] a,
                                  int[] b)
```

 mismatch

 Certaines méthodes d'incompatibilité ont été ajoutées, telles que:

```text
public static int mismatch​(int[] a,
                           int[] b)
```

 [Collection](https://docs.oracle.com/javase/jp/9/docs/api/java/util/Collection.html)

 Il n'y a pas d'ajouts.

 [List](https://docs.oracle.com/javase/jp/9/docs/api/java/util/List.html)

 of

```text
static <E> List<E> of​()
```

 de e1 à e10

```text
static <E> List<E> of​(E e1)

static <E> List<E> of​(E e1, E e2, E e3, E e4, E e5, E e6, E e7, E e8, E e9, E e10)
```

```text
@SafeVarargs
static <E> List<E> of​(E... elements)
```

 [ArrayList](https://docs.oracle.com/javase/jp/9/docs/api/java/util/ArrayList.html)

 Il n'y a pas d'ajouts.

 [Set](https://docs.oracle.com/javase/jp/9/docs/api/java/util/Set.html)

 of

```text
static <E> Set<E> of​()
```

 de e1 à e10

```text
static <E> Set<E> of​(E e1)

static <E> Set<E> of​(E e1, E e2, E e3, E e4, E e5, E e6, E e7, E e8, E e9, E e10)
```

```text
@SafeVarargs
static <E> Set<E> of​(E... elements)
```

 [HashSet](https://docs.oracle.com/javase/jp/9/docs/api/java/util/HashSet.html)

 Il n'y a pas d'ajouts.

 [EnumSet](https://docs.oracle.com/javase/jp/9/docs/api/java/util/EnumSet.html)

 Il n'y a pas d'ajouts.

 [Map](https://docs.oracle.com/javase/jp/9/docs/api/java/util/Map.html)

 of

```text
static <K,V> Map<K,V> of​()
```

 De k1, v1 à k10, v10

```text
static <K,V> Map<K,V> of​(K k1, V v1)

static <K,V> Map<K,V> of​(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5,
                         K k6, V v6, K k7, V v7, K k8, V v8, K k9, V v9, K k10, V v10)
```

 ofEntries

```text
@SafeVarargs
static <K,V> Map<K,V> ofEntries​(Map.Entry<? extends K,? extends V>... entries)
```

 entry

```text
static <K,V> Map.Entry<K,V> entry​(K k, V v)
```

 [HashMap](https://docs.oracle.com/javase/jp/9/docs/api/java/util/HashMap.html)

 Il n'y a pas d'ajouts.

 [EnumMap](https://docs.oracle.com/javase/jp/9/docs/api/java/util/EnumMap.html)

 Il n'y a pas d'ajouts.


# [API ajoutée dans Java 10](https://docs.oracle.com/javase/jp/10/docs/api/java/util/package-summary.html)

 [Collections](https://docs.oracle.com/javase/jp/10/docs/api/java/util/Collections.html)

 Il n'y a pas d'ajouts.

 [Arrays](https://docs.oracle.com/javase/jp/10/docs/api/java/util/Arrays.html)

 Il n'y a pas d'ajouts.

 [Collection](https://docs.oracle.com/javase/jp/10/docs/api/java/util/Collection.html)

 Il n'y a pas d'ajouts.

 [List](https://docs.oracle.com/javase/jp/10/docs/api/java/util/List.html)

 copyOf

```text
static <E> List<E> copyOf​(Collection<? extends E> coll)
```

 [ArrayList](https://docs.oracle.com/javase/jp/10/docs/api/java/util/ArrayList.html)

 Il n'y a pas d'ajouts.

 [Set](https://docs.oracle.com/javase/jp/10/docs/api/java/util/Set.html)

 copyOf

```text
static <E> Set<E> copyOf​(Collection<? extends E> coll)
```

 [HashSet](https://docs.oracle.com/javase/jp/10/docs/api/java/util/HashSet.html)

 Il n'y a pas d'ajouts.

 [EnumSet](https://docs.oracle.com/javase/jp/10/docs/api/java/util/EnumSet.html)

 Il n'y a pas d'ajouts.

 [Map](https://docs.oracle.com/javase/jp/10/docs/api/java/util/Map.html)

 copyOf

```text
static <K,V> Map<K,V> copyOf​(Map<? extends K,? extends V> map)
```

 [HashMap](https://docs.oracle.com/javase/jp/10/docs/api/java/util/HashMap.html)

 Il n'y a pas d'ajouts.

 [EnumMap](https://docs.oracle.com/javase/jp/10/docs/api/java/util/EnumMap.html)

 Il n'y a pas d'ajouts.


# Autres notes d'examen

 * [Note de révision Java NIO2](https://qiita.com/[email protected]/items/6880eab7d9c76524d112)
 * 15 août 2017
 * [Note de révision pour la classe java.util.Objects](https://qiita.com/[email protected]/items/ba38877ed5a00dd24f16)
 * 25 août 2017
 * [Note de révision pour le package java.time.temporal](https://qiita.com/[email protected]/items/e9325dd46aa11f1b8e2e)
 * 30 janvier 2018
 * [Note de révision pour la classe java.util.Optional](https://qiita.com/[email protected]/items/92ac7944c830e54aa03d)
 * 22 mars 2018

Recommended Posts