Collections集合工具的总结

最新推荐文章于 2023-06-01 16:15:30 发布

没有BUG吧?

最新推荐文章于 2023-06-01 16:15:30 发布

阅读量216

点赞数

分类专栏： java 文章标签： java 集合工具类 Collections

本文链接：https://blog.csdn.net/a137771035/article/details/88905146

版权

java 专栏收录该内容

6 篇文章 0 订阅

订阅专栏

Collections是一个操作List,Set和Map集合的工具类:

增加元素：

static <T> boolean addAll(Collection<? super T> c, T... elements) 将所有指定的元素添加到指定的集合。

List<Integer> list = new ArrayList<>();
Collections.addAll(list,3,5,2,5,6,9,10,-1,6);//9个元素

对List集合进行排序:

void reverse(List list) 反序

void shuffle(List list) 乱序

void sort(List list) 按照元素的自然顺序进行排序

void sort(List list,Comparator) 按照比较器定义的规则进行排序

void swap(List list,int i,int j) 将list集合中第i个和第j个元素互换

void rotate(list,int distance) 当distance为正数时,将list集合的后distance个元素整体移到前面.当distance为负数时,将list集合的前distance个元素整体移到后面.不会改变集合的大小

/**
 * Collections集合工具对list集合的排序方法测试
 */
private static void method1() {
    List<Integer> list = new ArrayList<>();
    Collections.addAll(list,3,5,2,5,6,9,10,-1,6);//9个元素
    Collections.sort(list);
    System.out.println(list);//[-1, 2, 3, 5, 5, 6, 6, 9, 10]
    Collections.sort(list,(i,j)->{
        return j-i;//从大到小排序
    });
    System.out.println(list);//[10, 9, 6, 6, 5, 5, 3, 2, -1]
    Collections.swap(list,0,1);
    System.out.println(list);//[9, 10, 6, 6, 5, 5, 3, 2, -1]
    Collections.rotate(list,8);
    System.out.println(list);//[10, 6, 6, 5, 5, 3, 2, -1, 9]
}

查找元素:

static <T> int binarySearch(List<? extends Comparable<? super T>> list, T key) 使用二叉搜索算法搜索指定对象的指定列表。

static <T> int binarySearch(List<? extends T> list, T key, Comparator<? super T> c) 使用二叉搜索算法搜索指定对象的指定列表。 Comparator为null，则按照自然顺序进行排序

static <T extends Object & Comparable<? super T>>T max(Collection<? extends T> coll) 根据其元素的自然顺序返回给定集合的最大元素。

static <T> T max(Collection<? extends T> coll, Comparator<? super T> comp) 根据指定的比较器定义的顺序返回给定集合的最大元素。

static <T extends Object & Comparable<? super T>>T min(Collection<? extends T> coll) 根据其元素的自然顺序返回给定集合的最小元素。

static <T> T min(Collection<? extends T> coll, Comparator<? super T> comp) 根据指定的比较器引发的顺序返回给定集合的最小元素。

static int frequency(Collection<?> c, Object o) 返回指定集合中与指定对象相等的元素数。

static int indexOfSubList(List<?> source, List<?> target) 返回指定源列表中指定目标列表的第一次出现的起始位置，如果没有此类事件，则返回-1。

static int lastIndexOfSubList(List<?> source, List<?> target) 返回指定源列表中指定目标列表的最后一次出现的起始位置，如果没有此类事件则返回-1。

替换：

static <T> boolean replaceAll(List<T> list, T oldVal, T newVal) 将列表中一个指定值的所有出现替换为另一个。

static <T> void fill(List<? super T> list, T obj) 用指定的元素代替指定列表的所有元素。

/**
 * Collections对集合元素的查找和替换
 */
private static void method2() {
    List<String> list = new ArrayList<>();
    Collections.addAll(list,"a","aa","aa","a","aaa","a","aaaa","aaa","aaaaa");
    System.out.println(Collections.binarySearch(list,"a"));//0,未排序,不保证搜索的结果
    System.out.println();
    Collections.sort(list);//自然排序后搜索
    System.out.println(list);//[a, a, a, aa, aa, aaa, aaa, aaaa, aaaaa]
    System.out.println(Collections.binarySearch(list,"a"));//1
    System.out.println(Collections.binarySearch(list,"a",(s1,s2)->{
        return s2.length()-s1.length();
    }));//-10 搜索不到
    System.out.println(Collections.binarySearch(list,"a",null));//1
    System.out.println(Collections.max(list));//aaaaa
    Comparator<String> comparator = (s1, s2)->{ return s2.length()-s1.length();};
    System.out.println(Collections.max(list,comparator));//a
    //自定义排序后搜索
    Collections.sort(list,comparator);
    System.out.println(list);//[aaaaa, aaaa, aaa, aaa, aa, aa, a, a, a]
    System.out.println(Collections.binarySearch(list,"a"));//-1 搜索不到
    System.out.println(Collections.binarySearch(list,"a",comparator));//6
    System.out.println(Collections.max(list));//aaaaa
    System.out.println(Collections.max(list,(s1,s2)->{//aaaaa
        return s1.length()-s2.length();
    }));
    System.out.println(Collections.max(list,comparator));//a

    System.out.println(Collections.frequency(list,"a"));//3,出现了3次
    List<String> list2 = new ArrayList<>();
    Collections.addAll(list2,"aaaa","aaa");
    System.out.println(Collections.indexOfSubList(list,list2));//1
    list2.clear();
    Collections.addAll(list2,"aaaa","aa");
    System.out.println(Collections.indexOfSubList(list,list2));//-1,两个集合中元素的顺序要一致才认为是子集合

    Collections.replaceAll(list,"a","b");
    System.out.println(list);//[aaaaa, aaaa, aaa, aaa, aa, aa, b, b, b]
    Collections.fill(list,"zz");
    System.out.println(list);//[zz, zz, zz, zz, zz, zz, zz, zz, zz]
}

线程安全：

Collections提供了synchoronizedXxx方法，这些方法可以将对应的集合包装成线程同步的集合,从而解决线程安全问题.

ArrayList,LinkedList,ArrayDeque,HashSet,LinkedHashSet,TreeSet,HashMap,LinkedHashMap,TreeMap都是线程不安全的.如果有多个线程访问线程不安全的集合,并且有一个以上的线程要修改该结合,那么就存在线程安全问题.Collections的同步方法就是用来解决这个问题的.

static <T> Collection<T> synchronizedCollection(Collection<T> c) 返回由指定集合支持的同步（线程安全）集合。

static <T> List<T> synchronizedList(List<T> list) 返回由指定列表支持的同步（线程安全）列表。

static <T> Set<T> synchronizedSet(Set<T> s) 返回由指定集合支持的同步（线程安全）集。

static <K,V> Map<K,V> synchronizedMap(Map<K,V> m) 返回由指定地图支持的同步（线程安全）映射。

static <T> SortedSet<T> synchronizedSortedSet(SortedSet<T> s) 返回由指定的排序集支持的同步（线程安全）排序集。

static <K,V> SortedMap<K,V> synchronizedSortedMap(SortedMap<K,V> m) 返回由指定的排序映射支持的同步（线程安全）排序映射。

static <T> NavigableSet<T> synchronizedNavigableSet(NavigableSet<T> s) 返回由指定的可导航集支持的同步（线程安全）可导航集。

static <K,V> NavigableMap<K,V> synchronizedNavigableMap(NavigableMap<K,V> m) 返回由指定的可导航地图支持的同步（线程安全）可导航地图。

/**
 * 同步方法
 */
private static void mehtod3() {
    List list = Collections.synchronizedList(new ArrayList<>());
    Collection queue = Collections.synchronizedCollection(new ArrayDeque<>());
    Set set = Collections.synchronizedSet(new HashSet());
    SortedSet sset = Collections.synchronizedSortedSet(new TreeSet<>());
    Map map = Collections.synchronizedMap(new HashMap<>());
    SortedMap smap = Collections.synchronizedSortedMap(new TreeMap<>());
}

设置不可变集合:

0个元素

static <T> List<T> emptyList() 返回空列表（immutable）。

static <T> ListIterator<T> emptyListIterator() 返回没有元素的列表迭代器。

static <K,V> Map<K,V> emptyMap() 返回空的地图（不可变）。

static <K,V> NavigableMap<K,V> emptyNavigableMap() 返回空导航地图（不可变）。

static <E> NavigableSet<E> emptyNavigableSet() 返回一个空导航集（immutable）。

static <T> Set<T> emptySet() 返回一个空集（immutable）。

static <K,V> SortedMap<K,V> emptySortedMap() 返回空的排序映射（immutable）。

static <E> SortedSet<E> emptySortedSet() 返回一个空的排序集（immutable）。

1个元素

static <T> Set<T> singleton(T o) 返回一个只包含指定对象的不可变集。

static <T> List<T> singletonList(T o) 返回一个只包含指定对象的不可变列表。

static <K,V> Map<K,V> singletonMap(K key, V value) 返回一个不可变的地图，只将指定的键映射到指定的值。

多个个元素

static <T> Collection<T> unmodifiableCollection(Collection<? extends T> c) 返回指定集合的不可修改视图。

static <T> List<T> unmodifiableList(List<? extends T> list) 返回指定列表的不可修改视图。

static <T> Set<T> unmodifiableSet(Set<? extends T> s) 返回指定集合的不可修改视图。

static <K,V> Map<K,V> unmodifiableMap(Map<? extends K,? extends V> m) 返回指定地图的不可修改视图。

static <K,V> NavigableMap<K,V> unmodifiableNavigableMap(NavigableMap<K,? extends V> m) 返回指定可导航地图的不可修改视图。

static <T> NavigableSet<T> unmodifiableNavigableSet(NavigableSet<T> s) 返回指定的可导航集合的不可修改的视图。

static <K,V> SortedMap<K,V> unmodifiableSortedMap(SortedMap<K,? extends V> m) 返回指定排序映射的不可修改视图。

static <T> SortedSet<T> unmodifiableSortedSet(SortedSet<T> s) 返回指定排序集的不可修改视图。

更改不可变集合,会出不支持操作异常

没有BUG吧?

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Collections集合工具的总结

Collections是一个操作List,Set和Map集合的工具类:增加元素：static <T> boolean addAll(Collection<? super T> c, T... elements) 将所有指定的元素添加到指定的集合。List<Integer> list = new ArrayList<>();Collec...
复制链接

扫一扫