Partage de technologie

한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina

Javajava.util.CollectionsLes classes fournissent un ensemble de méthodes statiques pour manipuler ou renvoyer des collections (telles que des listes, des ensembles et des cartes).Collections Class est une classe utilitaire conçue pour fournir des algorithmes et des opérations pratiques sur les collections.Voici la paireCollectionsUne introduction aux cours et à leurs méthodes couramment utilisées.

Résumé des méthodes courantes

• trier：sort(List<T> list)、sort(List<T> list, Comparator<? super T> c)
• Trouver：binarySearch(List<? extends Comparable<? super T>> list, T key)、binarySearch(List<? extends T> list, T key, Comparator<? super T> c)
• inverse：reverse(List<?> list)
• tourner：rotate(List<?> list, int distance)
• remplissage：fill(List<? super T> list, T obj)
• copie：copy(List<? super T> dest, List<? extends T> src)
• min et max：min(Collection<? extends T> coll)、max(Collection<? extends T> coll)
• synchroniser la collection：synchronizedList(List<T> list)、synchronizedSet(Set<T> s)、synchronizedMap(Map<K, V> m)
• collection immuable：unmodifiableList(List<? extends T> list)、unmodifiableSet(Set<? extends T> s)、unmodifiableMap(Map<? extends K, ? extends V> m)

trier

• sort(List<T> list): Trier la liste par ordre croissant, les éléments de la liste doivent implémenterComparableinterface.

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): Trie la liste en fonction du comparateur spécifié.

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

Remarque : Collections.sort(names, (s1, s2) -> s1.length() - s2.length()) (s1, s2) -> s1.length() - s2.length() Il s'agit d'une expression Lambda utilisé pour implémenter la méthode de comparaison de l'interface Comparator.

Trouver

• binarySearch(List<? extends Comparable<? super T>> list, T key) : Utilisez la recherche binaire pour trouver un élément dans la liste et renvoyer l'index. La liste doit être triée.

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): Utilisez la recherche binaire pour trouver un élément dans la liste du comparateur spécifié.

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

valeurs maximales et minimales

• max(Collection<? extends T> coll): Renvoie le plus grand élément de la collection.

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

• min(Collection<? extends T> coll): Renvoie le plus petit élément de l'ensemble.

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

Ordre inverse

• reverse(List<?> list): Inverse les éléments de la liste.

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

randomisation

• shuffle(List<?> list): Mélangez la liste au hasard.

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

remplissage

• fill(List<? super T> list, T obj): Remplacez tous les éléments de la liste par l'élément spécifié.

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

copie

• copy(List<? super T> dest, List<? extends T> src): Copie tous les éléments de la liste source vers la liste cible.

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

collection immuable

• unmodifiableList(List<? extends T> list): Renvoie une vue non modifiable.

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

synchroniser la collection

• synchronizedList(List<T> list): renvoie une liste thread-safe.

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

Exemple de résumé

Voici un exemple complet montrantCollectionsQuelques méthodes courantes de cours :

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);
    }
}

en utilisantCollectionsCes méthodes fournies par la classe peuvent facilement effectuer diverses opérations sur la collection, améliorant ainsi la lisibilité et la maintenabilité du code.

faire référence à:

Collections (Java SE 17 et JDK 17)