Einführung in Java-Sammlungen class

Einführung in die Java Collections-Klasse

2024-07-12

Javasjava.util.CollectionsKlassen bieten eine Reihe statischer Methoden zum Bearbeiten oder Zurückgeben von Sammlungen (z. B. Listen, Mengen und Karten).Collections Class ist eine Dienstprogrammklasse, die dazu dient, praktische Algorithmen und Operationen für Sammlungen bereitzustellen.Das Folgende ist das PaarCollectionsEine Einführung in Klassen und ihre häufig verwendeten Methoden.

Zusammenfassung gängiger Methoden

Sortieren：sort(List<T> list)、sort(List<T> list, Comparator<? super T> c)
Finden：binarySearch(List<? extends Comparable<? super T>> list, T key)、binarySearch(List<? extends T> list, T key, Comparator<? super T> c)
umkehren：reverse(List<?> list)
drehen：rotate(List<?> list, int distance)
Füllung：fill(List<? super T> list, T obj)
Kopieren：copy(List<? super T> dest, List<? extends T> src)
min. und max：min(Collection<? extends T> coll)、max(Collection<? extends T> coll)
Sammlung synchronisieren：synchronizedList(List<T> list)、synchronizedSet(Set<T> s)、synchronizedMap(Map<K, V> m)
unveränderliche Sammlung：unmodifiableList(List<? extends T> list)、unmodifiableSet(Set<? extends T> s)、unmodifiableMap(Map<? extends K, ? extends V> m)

Sortieren

sort(List<T> list): Sortieren Sie die Liste in aufsteigender Reihenfolge, die Elemente in der Liste müssen implementiert seinComparableSchnittstelle.


List<Integer> numbers = Arrays.asList(5, 3, 1, 4, 2);
Collections.sort(numbers); // 排序后，numbers为 [1, 2, 3, 4, 5]

sort(List<T> list, Comparator<? super T> c): Sortiert die Liste nach dem angegebenen Komparator.


List<String> names = Arrays.asList("Charlie", "Alice", "Bob");
 
// 根据字符串长度排序
Collections.sort(names, (s1, s2) -> s1.length() - s2.length());

Hinweis: Collections.sort(names, (s1, s2) -> s1.length() - s2.length()) (s1, s2) -> s1.length() - s2.length() Dies ist ein Lambda-Ausdruck Wird verwendet, um die Vergleichsmethode der Comparator-Schnittstelle zu implementieren.

Finden

binarySearch(List<? extends Comparable<? super T>> list, T key) : Verwenden Sie die binäre Suche, um ein Element in der Liste zu finden und den Index zurückzugeben. Die Liste muss sortiert sein.


List<Integer> sortedNumbers = Arrays.asList(1, 2, 3, 4, 5);
int index = Collections.binarySearch(sortedNumbers, 3); // 返回索引 2

binarySearch(List<? extends T> list, T key, Comparator<? super T> c): Verwenden Sie die binäre Suche, um ein Element in der Liste des angegebenen Komparators zu finden.


List<String> sortedNames = Arrays.asList("Alice", "Bob", "Charlie");
int index = Collections.binarySearch(sortedNames, "Bob", String::compareTo); // 返回索引 1

Maximal- und Minimalwerte

max(Collection<? extends T> coll): Gibt das größte Element in der Sammlung zurück.


List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
int max = Collections.max(numbers); // 返回 5

min(Collection<? extends T> coll): Gibt das kleinste Element in der Menge zurück.

int min = Collections.min(numbers); // 返回 1

Umgekehrte Reihenfolge

reverse(List<?> list): Elemente in der Liste umkehren.


List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
Collections.reverse(numbers); // 反转后，numbers为 [5, 4, 3, 2, 1]

Randomisierung

shuffle(List<?> list): Liste nach dem Zufallsprinzip mischen.

Collections.shuffle(numbers); // numbers的元素顺序将被随机打乱

Füllung

fill(List<? super T> list, T obj): Ersetzen Sie alle Elemente in der Liste durch das angegebene Element.


List<String> list = new ArrayList<>(Arrays.asList("a", "b", "c"));
Collections.fill(list, "z"); // list 现在是 ["z", "z", "z"]

Kopieren

copy(List<? super T> dest, List<? extends T> src): Kopiert alle Elemente in der Quellliste in die Zielliste.


List<String> dest = Arrays.asList(new String[3]);
List<String> src = Arrays.asList("a", "b", "c");
Collections.copy(dest, src); // dest 现在是 ["a", "b", "c"]

unveränderliche Sammlung

unmodifiableList(List<? extends T> list): Gibt eine nicht änderbare Ansicht zurück.


List<String> list = Arrays.asList("a", "b", "c");
List<String> unmodifiableList = Collections.unmodifiableList(list);
// unmodifiableList.add("d"); // 会抛出 UnsupportedOperationException

Sammlung synchronisieren

synchronizedList(List<T> list): Gibt eine threadsichere Liste zurück.


List<String> list = new ArrayList<>();
List<String> syncList = Collections.synchronizedList(list);

Beispielzusammenfassung

Hier ist ein umfassendes BeispielCollectionsEinige gängige Klassenmethoden:


import java.util.*;
 
public class CollectionsExample {
    public static void main(String[] args) {
        List<Integer> numbers = new ArrayList<>(Arrays.asList(5, 3, 1, 4, 2));
 
        // 排序
        Collections.sort(numbers);
        System.out.println("排序后: " + numbers);
 
        // 反转
        Collections.reverse(numbers);
        System.out.println("反转后: " + numbers);
 
        // 随机打乱
        Collections.shuffle(numbers);
        System.out.println("随机打乱后: " + numbers);
 
        // 查找最大和最小值
        int max = Collections.max(numbers);
        int min = Collections.min(numbers);
        System.out.println("最大值: " + max + ", 最小值: " + min);
 
        // 二分搜索
        Collections.sort(numbers);
        int index = Collections.binarySearch(numbers, 3);
        System.out.println("元素 3 的索引: " + index);
 
        // 同步集合
        List<String> syncList = Collections.synchronizedList(new ArrayList<>());
        syncList.add("a");
        syncList.add("b");
        System.out.println("同步集合: " + syncList);
    }
}

durch die NutzungCollectionsDiese von der Klasse bereitgestellten Methoden können problemlos verschiedene Vorgänge an der Sammlung ausführen und so die Lesbarkeit und Wartbarkeit des Codes verbessern.

beziehen auf:

Sammlungen (Java SE 17 und JDK 17)

Technologieaustausch