Überprüfungshinweise zum Java Collections Framework

Überblick

Eine Überprüfung des Collections Framework. Da ich hauptsächlich den Teil überprüft habe, der im Java 8-Stream hinzugefügt wurde, ist der Inhalt ziemlich voreingenommen.

Umgebung

Referenz

Der Beispielcode in diesem Artikel verwendet die folgende Klasse, enum.

Im Beispielcode verwendete Klasse


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

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

  // getter/Setter weggelassen

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

}

Aufzählung im Beispielcode


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

Eine Utility-Klasse, die Sammlungen verarbeitet.

Fügen Sie der Sammlung ein Element hinzu

Fügen Sie der im ersten Argument übergebenen Sammlung eine beliebige Anzahl von Elementen hinzu, die im zweiten Argument übergeben wurden.

addAll


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

Fügen Sie der Liste ein Element hinzu

Beispiel


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

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

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

Fügen Sie Set ein Element hinzu

Beispiel


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

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

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

Sortierliste

Die im ersten Argument übergebene Liste wird nach dem im zweiten Argument übergebenen Komparator sortiert.

sort


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

Ganzzahl sortieren

Beispiel


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

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

// Integer.Sortieren Sie nach dem Ergebnis von compareTo
Collections.sort(lists, Integer::compareTo);

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

String sortieren

Beispiel


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

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

//Sortieren nach natürlicher Reihenfolge der Zeichenfolgen
Collections.sort(lists, Comparator.naturalOrder());

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

//Sortieren Sie in umgekehrter Reihenfolge der natürlichen Reihenfolge der Zeichenfolgen
Collections.sort(lists, Comparator.reverseOrder());

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

//Nach Stringlänge sortieren
Collections.sort(lists, Comparator.comparing(String::length));

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

Beispiel


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.Numerisch nach ID sortieren
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 verfügt auch über eine Sortiermethode, sodass Sie die folgenden Schritte ausführen können, ohne Sammlungen zu verwenden.

Beispiel


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

Leere unveränderliche Sammlung, gibt Karte zurück

List

Die Implementierungsklasse von List ist "java.util.Collections.EmptyList", und "UnsupportedOperationException" wird ausgelöst, wenn sich die Anzahl der Elemente ändert (add, addAll-Methode usw.).

emptyList


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

Beispiel


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

Set

Die Implementierungsklasse von Set ist "java.util.Collections.EmptySet", und "UnsupportedOperationException" wird ausgelöst, wenn sich die Anzahl der Elemente ändert (add, addAll-Methode usw.).

emptySet


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

Beispiel


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

Map

Die Implementierungsklasse von Map ist "java.util.Collections.EmptyMap", und "UnsupportedOperationException" wird ausgelöst, wenn sich die Anzahl der Elemente ändert (put, putAll-Methode usw.).

emptyMap


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

Beispiel


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

Gibt eine Karte zurück, eine unveränderliche Sammlung mit nur einem Element

List

Die Implementierungsklasse für List ist java.util.Collections.SingletonList, die eine Liste mit nur den als Argumente übergebenen Elementen zurückgibt. Wenn Sie die Anzahl der Elemente ändern (Methoden hinzufügen, hinzufügen, entfernen, löschen usw.) oder die Elemente ändern (Methoden setzen, alle ersetzen usw.), wird eine UnsupportedOperationException ausgelöst.

singletonList


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

Beispiel


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

Set

Die Implementierungsklasse für Set ist java.util.Collections.SingletonSet, die ein Set mit nur den als Argumente übergebenen Elementen zurückgibt. Wenn Sie die Anzahl der Elemente ändern (Methode hinzufügen, entfernen, löschen usw.), wird eine UnsupportedOperationException ausgelöst.

singleton


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

Beispiel


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

Map

Die Map-Implementierungsklasse ist java.util.Collections.SingletonMap, die eine Map zurückgibt, bei der nur der Schlüssel / Wert als Argument übergeben wird. Wenn Sie die Anzahl der Elemente ändern (Methoden setzen, entfernen, löschen usw.) oder die Elemente ändern (ersetzen, alle Methoden ersetzen usw.), wird eine UnsupportedOperationException ausgelöst.

singletonMap


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

Beispiel


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

Unveränderliche Sammlung, Rückgabekarte

Collection

Die Implementierungsklasse ist "java.util.Collections.UnmodizableCollection", die eine unveränderliche Sammlung der als Argument übergebenen Sammlung zurückgibt. Wenn Sie die Anzahl der Elemente ändern (Methode hinzufügen, entfernen, löschen usw.), wird eine UnsupportedOperationException ausgelöst.

unmodifiableCollection


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

Beispiel


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

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

unmodifiable.add("rubellite");
//→ Wirf UnsupportedOperationException aus

List

Die Implementierungsklasse für List ist "java.util.Collections.UnmodizableRandomAccessList", die eine unveränderliche Auflistung der als Argument übergebenen Liste zurückgibt. Wenn Sie die Anzahl der Elemente ändern (Methoden hinzufügen, hinzufügen, entfernen, löschen usw.) oder die Elemente ändern (Methoden setzen, alle ersetzen usw.), wird eine UnsupportedOperationException ausgelöst.

unmodifiableList


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

Beispiel


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

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

unmodifiedLists.add("rubellite");
//→ Wirf UnsupportedOperationException aus

Set

Die Implementierungsklasse für Set ist "java.util.Collections.UnmodizableSet", die eine unveränderliche Auflistung des als Argument übergebenen Sets zurückgibt. Wenn Sie die Anzahl der Elemente ändern (Methode hinzufügen, entfernen, löschen usw.), wird eine UnsupportedOperationException ausgelöst.

unmodifiableSet


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

Beispiel


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

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

unmodifiedSets.add("rubellite");
//→ Wirf UnsupportedOperationException aus

Map

Die Implementierungsklasse von Map ist java.util.Collections.UnmodizableMap, die die unveränderliche Map der Map zurückgibt, die als Argument übergeben wurde. Wenn Sie die Anzahl der Elemente ändern (Methoden setzen, entfernen, löschen usw.) oder die Elemente ändern (ersetzen, alle Methoden ersetzen usw.), wird eine UnsupportedOperationException ausgelöst.

unmodifiableMap


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

Beispiel


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");
//→ Wirf UnsupportedOperationException aus

Arrays

Eine Utility-Klasse zum Bearbeiten von Arrays.

Liste aus einem Array generieren

Die Implementierungsklasse von List ist java.util.Arrays.ArrayList, die eine Liste aus dem als Argument übergebenen Array erstellt und zurückgibt. Wenn Sie die Anzahl der Elemente ändern (Methode hinzufügen, entfernen usw.), wird eine UnsupportedOperationException ausgelöst. Sie können die Elemente ändern (set, replaceAll-Methode usw.).

asList


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

Beispiel


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

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

Beispiel


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

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

//Aktualisieren Sie die Elemente in Großbuchstaben
lists.replaceAll(String::toUpperCase);

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

Aktualisieren Sie Elemente eines Arrays

Einführungsversion Java 1.8 </ font>

Aktualisieren Sie jedes Element des im ersten Argument übergebenen Arrays mit dem Operationsergebnis der im zweiten Argument übergebenen Funktion.

setAll


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

Beispiel


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

Erstellen Sie einen Stream aus einem Array

Einführungsversion Java 1.8 </ font>

Erstellen Sie einen Stream aus dem an das Argument übergebenen Array.

stream


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

Beispiel


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

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

Überprüfen Sie, ob die beiden Sequenzen gleichwertig sind

Überprüfen Sie, ob die beiden im Argument übergebenen Arrays äquivalent sind (jedes Element ist in derselben Reihenfolge äquivalent).

equals


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

Beispiel


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

//Wenn die Anordnung der Elemente nicht dieselbe ist, wird sie nicht als gleichwertig beurteilt
System.out.println(Arrays.equals(arrays1, arrays3));
// → false

Überprüfen Sie, ob zwei mehrdimensionale Arrays gleichwertig sind

Überprüft, ob die beiden im Argument übergebenen Arrays gleichwertig sind. Für mehrdimensionale Arrays.

deepEquals


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

Beispiel


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

Gibt eine Zeichenfolgendarstellung eines Arrays zurück

Gibt die Zeichenfolgendarstellung des im Argument übergebenen Arrays zurück. Wenn das Array null ist, wird die Zeichenfolge "null" zurückgegeben.

toString


public static String toString(Object[] a)

Beispiel


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'}]

** Wenn null **

Wenn das Array null ist, wird NullPointerException nicht ausgelöst und die Zeichenfolge "null" wird gedruckt.

Beispiel


Employee[] employees = null;

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

Gibt eine Zeichenfolgendarstellung eines mehrdimensionalen Arrays zurück

Gibt die Zeichenfolgendarstellung des im Argument übergebenen Arrays zurück. Für mehrdimensionale Arrays. Wenn das Array null ist, wird die Zeichenfolge "null" zurückgegeben.

deepToString


public static String deepToString(Object[] a)

Beispiel


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'}]]

** Wenn null **

Wenn das Array null ist, wird NullPointerException nicht ausgelöst und die Zeichenfolge "null" wird gedruckt.

Beispiel


Employee[][] employees = null;

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

Collection

removeIf

Einführungsversion Java 1.8 </ font>

Entfernt Elemente aus der Sammlung, die den im Argument übergebenen Filterkriterien entsprechen.

removeIf


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

Beispiel


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"Löschen Sie Elemente, die auf enden
fruits.removeIf(name -> name.endsWith("berry"));

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

retainAll

Lässt die gleichen Elemente wie die Sammlungselemente, die Sie im Argument übergeben. Entfernen Sie die nicht übereinstimmenden Elemente aus der Sammlung.

retainAll


boolean retainAll(Collection<?> c)

Beispiel


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

Einführungsversion Java 1.8 </ font>

Generieren Sie einen Stream aus der Sammlung.

stream


default Stream<E> stream()

Beispiel


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

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

toArray

Generieren Sie ein Array aus der Sammlung.

toArray


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

Beispiel


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

//Von der Liste zum Array
String[] arrays = lists.toArray(new String[0]);

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

List

add

Fügen Sie das durch das zweite Argument angegebene Element an die Position des durch das erste Argument angegebenen Index hinzu.

add


void add(int index, E element)

Beispiel


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

// index=Element an Position 3 hinzufügen
lists.add(3, "Darryl");

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

Zum Anfang der Liste hinzufügen


lists.add(0, "Darryl");

Am Ende der Liste hinzufügen


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

addAll

Fügen Sie die durch das zweite Argument angegebenen Elemente der Auflistung zur Position des durch das erste Argument angegebenen Index hinzu.

addAll


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

Beispiel


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

Ersetzt das im ersten Argument angegebene Indexelement durch das im zweiten Argument angegebene Element.

set


E set(int index, E element)

Beispiel


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

Einführungsversion Java 1.8 </ font>

Das Operationsergebnis des an das Argument übergebenen Operators wird auf jedes Element angewendet und durch das Ergebnis ersetzt.

replaceAll


default void replaceAll(UnaryOperator<E> operator)

Beispiel


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

Löscht das durch das Argument angegebene Indexelement aus der Auflistung.

remove


E remove(int index)

Beispiel


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"> Einführungsversion Java 1.8 </ font>

 Sortieren Sie die Liste mit dem Komparator, den Sie als Argument übergeben.


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

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


#### **`Beispiel`**
```java

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

// String.Sortieren Sie nach dem Ergebnis von compareTo
lists.sort(String::compareTo);

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


#### **`Beispiel`**
```java

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

//Nach Stringlänge sortieren.
lists.sort(Comparator.comparing(String::length));

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


#### **`Beispiel`**
```java

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

//String-Länge+ String.Sortieren Sie nach dem Ergebnis von 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)

## Generieren Sie eine neue ArrayList aus der Sammlung

 Generieren Sie eine ArrayList aus der Sammlung, die an die Konstruktorargumente übergeben wird.


#### **`Konstrukteur`**
```text

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

 ** Auf ArrayList setzen **


#### **`Beispiel`**
```java

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

//Generieren Sie ArrayList aus Set
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)

 Es gibt keine eindeutige Methode für die Set-Schnittstelle, daher werde ich sie weglassen.

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

## Generieren Sie ein neues HashSet aus der Sammlung

 Generieren Sie ein HashSet aus der Sammlung, die an die Konstruktorargumente übergeben wird.


#### **`Konstrukteur`**
```text

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

 ** Liste zu HashSet **


#### **`Beispiel`**
```java

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

//Generieren Sie HashSet aus List
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"> Einführungsversion Java 1.5 </ font>

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

 Erzeugt ein EnumSet, das aus allen Enumeratoren der in den Argumenten übergebenen Aufzählungsnamen besteht.


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

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


#### **`Beispiel`**
```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-)

 Generieren Sie ein EnumSet aus der als Argument übergebenen Sammlung.


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

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


#### **`Beispiel`**
```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]
```


#### **`Beispiel`**
```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-)

 Erzeugt ein leeres EnumSet des an das Argument übergebenen Aufzählungstyps.


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

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


#### **`Beispiel`**
```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-)

 Erzeugt ein EnumSet, das aus Enumeratoren besteht, die als Argumente übergeben werden sollen.


#### **`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)
```


#### **`Beispiel`**
```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)

 > [Warum erbt Map nicht von Collection? ](https://docs.oracle.com/javase/jp/8/docs/technotes/guides/collections/designfaq.html#a14)
 > Dies ist beabsichtigt. Ich denke, das Mapping ist keine Sammlung und die Sammlung ist kein Mapping. Daher ist es für Map wenig sinnvoll, die Collection-Oberfläche zu erben und umgekehrt.

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

 <font color = "blue"> Einführungsversion Java 1.8 </ font>

 Die im zweiten Argument übergebene Funktion wird auf den Wert angewendet, der dem im ersten Argument angegebenen Schlüssel zugeordnet ist. Der Schlüsselwert wird mit dem Berechnungsergebnis aktualisiert und zurückgegeben.
 Wenn der Schlüssel nicht zugeordnet ist, wird der Wert als null berechnet.
 Wenn die Funktion null zurückgibt, wird der Eintrag gelöscht.


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

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


#### **`Beispiel`**
```java

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

//Funktionen, die mit oder ohne Zuordnung ausgeführt werden
BiFunction<String, String, String> remapping = (key, val) -> {
  if (val == null) {
    //Dieses Beispiel gibt eine Zeichenfolge zurück.
    //Beispielsweise können Sie eine Verarbeitung ausführen, z. B. das Suchen des Werts aus der Datenbank mit dem Schlüssel.
    return "UNKNOWN";
  }
  return val.toUpperCase();
};

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

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

//Auf null abgebildet
value = maps.compute("rubellite", remapping);

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

//Nicht zugeordnet
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"> Einführungsversion Java 1.8 </ font>

 Wenn der Wert nicht dem im ersten Argument angegebenen Schlüssel zugeordnet ist (oder null zugeordnet ist), wird das Berechnungsergebnis der im zweiten Argument übergebenen Funktion als Schlüsselwert aktualisiert und zurückgegeben.
 Wenn dem Schlüssel ein Wert zugeordnet ist, wird die Zuordnung nicht aktualisiert und der Schlüsselwert wird zurückgegeben.
 Wenn die Funktion null zurückgibt, wird der Eintrag nicht gespeichert.


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

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


#### **`Beispiel`**
```java

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

//Funktion, die ausgeführt wird, wenn dem Schlüssel kein Wert ungleich Null zugeordnet ist
Function<String, String> mapping = (key) -> {
  //Dieses Beispiel gibt eine Zeichenfolge zurück.
  //Beispielsweise können Sie eine Verarbeitung ausführen, z. B. das Suchen des Werts aus der Datenbank mit dem Schlüssel.
  return "UNKNOWN";
};

//Die Funktion wird nicht ausgeführt, da sie zugeordnet ist
String value = maps.computeIfAbsent("ruby", mapping);

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

//Da es auf null abgebildet ist, führt es die Funktion aus und gibt das Ergebnis zurück.
value = maps.computeIfAbsent("rubellite", mapping);

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

//Nicht zugeordnet, führen Sie die Funktion aus und geben Sie das Ergebnis zurück
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"> Einführungsversion Java 1.8 </ font>

 Wenn dem im ersten Argument angegebenen Schlüssel ein anderer Wert als null zugeordnet wird, wird die im zweiten Argument übergebene Funktion angewendet, der Schlüsselwert mit dem Berechnungsergebnis aktualisiert und zurückgegeben.
 Wenn dem Schlüssel kein Wert zugeordnet ist, wird die Funktion nicht ausgeführt und die Zuordnung wird nicht aktualisiert.
 Wenn die Funktion null zurückgibt, wird der Eintrag gelöscht.


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

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


#### **`Beispiel`**
```java

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

//Funktion, die ausgeführt wird, wenn dem Schlüssel ein Wert ungleich Null zugeordnet ist
BiFunction<String, String, String> remapping = (key, val) -> {
  return val.toUpperCase();
};

//Da es zugeordnet ist, führt es die Funktion aus und gibt das Ergebnis zurück.
String value = maps.computeIfPresent("ruby", remapping);

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

//Die Funktion wird nicht ausgeführt, da sie null zugeordnet ist
value = maps.computeIfPresent("rubellite", remapping);

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

//Die Funktion wird nicht ausgeführt, da sie nicht zugeordnet ist
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"> Einführungsversion Java 1.8 </ font>

 Führt die als Argument für jeden Eintrag in der Karte übergebene Funktion aus.


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

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


#### **`Beispiel`**
```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"> Einführungsversion Java 1.8 </ font>

 Ordnet den im zweiten Argument übergebenen Wert zu, wenn der Wert nicht dem im ersten Argument angegebenen Schlüssel zugeordnet ist (oder null zugeordnet ist).
 Wenn der Schlüssel zugeordnet ist, ersetzen Sie den Wert durch das Berechnungsergebnis der im dritten Argument übergebenen Funktion. Wenn die Funktion null zurückgibt, löschen Sie den Eintrag.


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

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


#### **`Beispiel`**
```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"> Einführungsversion Java 1.8 </ font>

 Wenn der im ersten Argument angegebene Wert nicht zugeordnet ist (oder null zugeordnet ist), wird der Schlüsselwert mit dem im zweiten Argument übergebenen Wert aktualisiert.
 Wenn bereits ein Wert ungleich Null zugeordnet ist, wird die Zuordnung nicht aktualisiert.


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

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


#### **`Beispiel`**
```java

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

//Aktualisieren, wenn es null zugeordnet ist
String value = maps.putIfAbsent("rubellite", "BEETS");

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

//Wird nicht aktualisiert, wenn zugeordnet
value = maps.putIfAbsent("ruby", "TOMATO");

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

//Wenn es nicht zugeordnet ist, wird es mit einem Argument zugeordnet
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"> Einführungsversion Java 1.8 </ font>

 Wenn der im zweiten Argument angegebene Wert dem im ersten Argument angegebenen Schlüssel zugeordnet wird (einschließlich des Falls, in dem der Wert null ist), wird der Eintrag gelöscht.


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

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


#### **`Beispiel`**
```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"> Einführungsversion Java 1.8 </ font>

 Wenn der im ersten Argument angegebene Schlüssel zugeordnet ist (einschließlich des Falls, in dem der Wert null ist), ersetzen Sie ihn durch den im zweiten Argument übergebenen Wert.
 Aktualisiert die Karte nicht, wenn der Schlüssel nicht zugeordnet ist.


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

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


#### **`Beispiel`**
```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"> Einführungsversion Java 1.8 </ font>

 Ersetzen Sie den Wert durch das Operationsergebnis der an das Argument übergebenen Funktion.


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

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


#### **`Beispiel`**
```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)

## Generieren Sie eine neue HashMap aus Map

 Generieren Sie eine neue HashMap aus der Map, die Sie an die Konstruktorargumente übergeben.


#### **`Konstrukteur`**
```text

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

 ** Zu HashMap zuordnen **


#### **`Beispiel`**
```java

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

//Generieren Sie eine neue 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"> Einführungsversion Java 1.5 </ font>

## Generieren Sie eine neue EnumMap aus Map

 Generieren Sie eine neue EnumMap aus der Map, die Sie an die Konstruktorargumente übergeben.


#### **`Konstrukteur`**
```text

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


#### **`Beispiel`**
```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}
```

## Set aus EnumMap generieren


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

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


#### **`Beispiel`**
```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 in Java 9 hinzugefügt](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)

 Es gibt keine Ergänzungen.

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

 equals

 Die folgenden Methoden wurden hinzugefügt.

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

 compare

 Einige Vergleichsmethoden wurden hinzugefügt, wie z.

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

 compareUnsigned

 Einige compareUnsigned-Methoden wurden hinzugefügt, z.

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

 mismatch

 Einige Nichtübereinstimmungsmethoden wurden hinzugefügt, wie z.

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

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

 Es gibt keine Ergänzungen.

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

 of

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

 von e1 bis 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)

 Es gibt keine Ergänzungen.

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

 of

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

 von e1 bis 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)

 Es gibt keine Ergänzungen.

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

 Es gibt keine Ergänzungen.

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

 of

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

 Von k1, v1 bis 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)

 Es gibt keine Ergänzungen.

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

 Es gibt keine Ergänzungen.


# [API in Java 10 hinzugefügt](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)

 Es gibt keine Ergänzungen.

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

 Es gibt keine Ergänzungen.

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

 Es gibt keine Ergänzungen.

 [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)

 Es gibt keine Ergänzungen.

 [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)

 Es gibt keine Ergänzungen.

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

 Es gibt keine Ergänzungen.

 [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)

 Es gibt keine Ergänzungen.

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

 Es gibt keine Ergänzungen.


# Andere Überprüfungsnotizen

 * [Java NIO2-Überprüfungsnotiz](https://qiita.com/rubytomato@github/items/6880eab7d9c76524d112)
 * 15. August 2017
 * [Überprüfungsnotiz für die Klasse java.util.Objects](https://qiita.com/rubytomato@github/items/ba38877ed5a00dd24f16)
 * 25. August 2017
 * [Überprüfungshinweis für das Paket java.time.temporal](https://qiita.com/rubytomato@github/items/e9325dd46aa11f1b8e2e)
 * 30. Januar 2018
 * [Überprüfungsnotiz für die Klasse java.util.Optional](https://qiita.com/rubytomato@github/items/92ac7944c830e54aa03d)
 * 22. März 2018

Recommended Posts