Java集合框架(六)—— Collections工具类

  • 操作集合的工具类Collections

  Java提供了一个操作Set、List和Map等集合的工具类:Collections,该工具类里提供了大量方法对集合元素进行排序、查询和修改等操作,还提供了将集合对象设置为不可变、对集合对象实现同步控制等方法。

  • 排序操作

  Collections提供了如下几个方法对List集合元素进行排序:  

  1. static void reverse(List list);       //反转指定List集合元素的顺序。
  2. static void shuffle(List list);        //对list集合元素进行随机排序(shuffle方法模拟了"洗牌动作")。
  3. static void sort(List list);           //根据元素的自然顺序对指定List集合的元素按升序进行排序。
  4. static void sort(List list, Comparator c);    //根据指定Comparator产生的顺序对List集合的元素进行排序。
  5. static void swap(List list, int i, int j);        //将指定list集合中i处元素和j处元素进行交换。 
public class Test {
    public static void main(String[] args){
        List<Integer> list = new ArrayList<Integer>();
        list.add(2);
        list.add(1);
        list.add(4);
        list.add(9);
        list.add(13);
        list.add(11);
        list.add(12);
        //打印结果[2, 1, 4, 9, 13, 11, 12]
        System.out.println(list);
        //1.1反转指定List集合元素的顺序。
        Collections.reverse(list);
        //打印结果[12, 11, 13, 9, 4, 1, 2]
        System.out.println(list);
        //1.2对list集合进行随机排序
        Collections.shuffle(list);
        //打印结果随机
        System.out.println(list);
        //1.3对list集合进行自然排序(从小到大)
        Collections.sort(list);
        //打印结果为[1, 2, 4, 9, 11, 12, 13]
        System.out.println(list);
        //1.4对list集合进行自定义排序(这里做的倒序)
        Collections.sort(list, new Comparator<Integer>(){
            @Override
            public int compare(Integer o1, Integer o2) {
                if(o1 > o2){
                    return -1;
                }
                if(o1 < 02){
                    return 1;
                }
                return 0;
            }
        });
        //打印结果为[13, 12, 11, 9, 4, 2, 1]
        System.out.println(list);
        //1.5将下标为0和下标为3的元素位置交换
        Collections.swap(list, 0, 3);
        //打印结果为[9, 12, 11, 13, 4, 2, 1]
        System.out.println(list);
    }
}
  •  查找、替换操作

  Collections还提供了如下用于查找、替换集合元素的常用方法:

  1. static int binarySearch(List list, Object key);     //使用二分搜索法搜索指定List集合,以获得指定对象在List集合中的索引。如果要该方法可以正常工作,必须保证List中的元素已经处于有序状态。
  2. static Object max(Collection coll);      //根据元素的自然排序,返回给定集合中的最大元素。
  3. static Object max(Collection coll, Comparator comp);    //根据指定Comparator产生的顺序,返回给定集合的最大元素。
  4. static Object min(Collection coll);      //根据元素的自然排序,返回给定集合中的最小元素。 
  5. static Object min(Collection coll, Comparator comp);    //根据指定Comparator产生的顺序,返回给定集合的最小元素。
  6. static void fill(List list, Object obj);     //使用指定元素的obj替换指定List集合中所有元素。
  7. static int frequency(Collection c, Object o);    //返回指定元素中等于指定对象的元素数量。
  8. static int indexOfSubList(List source, List target);     //返回List对象在母List对象中第一次出现的位置索引;如果母List中没有出现这样的子list则返回-1。
  9. static int lastIndexOfSubList(List source, List  target);     //返回List对象在母List对象中最后一次出现的位置索引;如果母List中没有出现这样的子list则返回-1。
  10. static boolean replaceAll(List list, Object oldVal, Object newVal);    //使用一个新值newVal替换List对象所有旧值oldVal。
public class Test {
    public static void main(String[] args){
        List<Integer> list = new ArrayList<Integer>();
        list.add(2);
        list.add(1);
        list.add(4);
        list.add(9);
        list.add(13);
        list.add(11);
        list.add(12);
        
        //1.1根据元素的自然排序返回集合中的最大元素
        Integer max = Collections.max(list);
        //打印结果13
        System.out.println(max);
        //将集合进行自然排序
        Collections.sort(list);
        //打印结果[1, 2, 4, 9, 11, 12, 13]
        System.out.println(list);
        //1.2使用二分搜索法搜索指定List集合,以获得指定对象在List集合中的索引。如果要该方法可以正常工作,必须保证List中的元素已经处于有序状态。
        int binarySearch = Collections.binarySearch(list, 13);
        //打印结果6
        System.out.println(binarySearch);
        //1.3根据指定Comparator产生的顺序,返回给定集合的最大元素。
        Integer max2 = Collections.max(list, new Comparator<Integer>(){
            @Override
            public int compare(Integer o1, Integer o2) {
                if(o1 > o2) return -1;
                if(o1 < o2) return  1;
                return 0;
            }
        });
        //打印结果1
        System.out.println(max2);
        //1.4使用指定元素的111替换指定List集合中所有元素。
        Collections.fill(list, 111);
        //打印结果[111, 111, 111, 111, 111, 111, 111]
        System.out.println(list);
        //1.5返回指定元素中等于指定对象的元素数量
        int count = Collections.frequency(list, 111);
        //打印结果7
        System.out.println(count);
        
        //2.1重声明2个集合做试验
        List<Integer> list2 = new ArrayList<Integer>();
            list2.add(1);
            list2.add(2);
            list2.add(3);
            list2.add(4);
            list2.add(5);
            list2.add(6);
        List<Integer> list3 = new ArrayList<Integer>();
            list3.add(4);
            list3.add(5);    
        //2.2返回List对象在母List对象中第一次出现的位置索引;如果母List中没有出现这样的子list则返回-1。
        int indexOfSubList = Collections.indexOfSubList(list2, list);    
        //打印结果-1
        System.out.println(indexOfSubList);
        int indexOfSubList2 = Collections.indexOfSubList(list2, list3);    
        //打印结果3
        System.out.println(indexOfSubList2);    
        //2.4将list3集合中的4都替换成9
        Collections.replaceAll(list3, 4 , 9);
        //打印结果[9, 5]
        System.out.println(list3);
    }
}
  •  同步控制

Collections类中提供了多个synchronizedXxx方法,该方法返回指定集合对象对应的同步对象,从而可以解决多线程并发访问集合时的线程安全问题。

public class Test {
    public static void main(String[] args){
        Set<Integer> set = Collections.synchronizedSet(new HashSet<Integer>());
        List<Integer> list = Collections.synchronizedList(new ArrayList<Integer>());
        Map<Integer, String> map = Collections.synchronizedMap(new HashMap<Integer, String>());
    }
}
  • 设置不可变集合

  Collections提供了如下三个方法来返回一个不可变的集合:

  1. emptyXxx();   //返回一个空的、不可变的集合对象,此处的集合既可以是List,也可以是Set,还可以是Map。
  2. singletonXxx();     //返回一个包含指定对象(只有一个或一项元素)的、不可变的集合对象,此处的集合既可以是List,也可以是Set,还可以是Map。
  3. unmodifiableXxx();     //返回指定对象的不可变视图。此处的集合既可以是List,也可以是Set,还可以是Map。

  上面三类方法的参数是原来集合对象,返回值是该集合的"只读"版本。通过上面Collections提供三类方法,可以生成"只读"的Collection或Map。

public class Test {
    public static void main(String[] args){
        List<Integer> list = Collections.emptyList();
        Set<Integer> set = Collections.singleton(121);
        Map<Integer, String> tempMap = new HashMap<Integer, String>();
            tempMap.put(1, "one");
            tempMap.put(2, "two");
            tempMap.put(3, "three");
        Map<Integer, String> unMap = Collections.unmodifiableMap(tempMap);    
        //下面任意一行代码都将引发UnsupportedOperationException异常
        list.add(33);
        set.add(33);
        unMap.put(33,"four");
    }
}

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏一个会写诗的程序员的博客

《零基础 Java 开发 》 第五章 数组第五章 数组

数组是一个基础的数据结构,它用来存储一组相同类型的元素的集合。数组非常有用,例如Java提供的集合类ArrayList、HashMap等都是基于数组来实现的。

1313
来自专栏闻道于事

Java之集合的遍历与迭代器

集合的遍历 依次获取集合中的每一个元素 将集合转换成数组,遍历数组 //取出所有的学号, 迭代之后显示学号为1004-1009 Object[]...

3575
来自专栏深度学习之tensorflow实战篇

hive字符串函数

hive字符串函数 1. 字符串长度函数:length 语法: length(string A) 返回值: int 说明:返回字符串A的长度 举例:hive> ...

8277
来自专栏Kevin-ZhangCG

[ Java学习基础 ] Java的对象容器 -- 集合

2418
来自专栏编程

Kotlin学习之高阶函数和Lambda表达式的基础用法

Kotlin学习之高阶函数和Lambda表达式的基础用法 一、定义和调用高阶函数的写法 kotlin.collections._Arrays.kt中的mapTo...

1825
来自专栏浪淘沙

Java学习day09

2018.6.13 1.增强for循环 //第一个参数是 获得的数据 //第二个是 数组或集合

1173
来自专栏星汉技术

Scala中的集合类型

79410
来自专栏章鱼的慢慢技术路

数据结构与算法笔试面试题整理

b.对每一对相邻的元素做同样的工作,从开始的第一对一致到结尾的最后一对,经过这一步,最后的元素将是最大值;

3373
来自专栏Android开发指南

10.TreeSet、比较器

39110
来自专栏nnngu

数据结构02 线性表之顺序表

这篇文章主要总结线性表之顺序表的相关操作,主要分以下几个部分来总结。 1、线性表是什么?  2、线性表的两种存储结构?  3、顺序表的存储结构表示?   4、顺...

3186

扫码关注云+社区

领取腾讯云代金券