Java之Collections使用

短命女 2024-04-17 23:25 67阅读 0赞

### 文章目录 ###

*   *   *   *  一、查询操作
             *   *  1.查找元素
                 *  2.集合中最大/最小元素
                 *  3.集合中的是否存在子集合
                 *  4.集合中是否有相同的元素，没有返回true
                 *  5.返回元素在集合中出现的次数
             *  二、修改集合结构
             *   *  1.对集合的元素排序
                 *  2.反转集合元素顺序
                 *  3.打乱集合顺序
                 *  4.交换集合两个元素的顺序
                 *  5.以指定元素填充集合
                 *  6.集合元素移动
                 *  7.以元素a替换集合所有的元素b
                 *  8.添加指定元素到指定集合末尾
                 *  9.替换集合的前n个元素
             *  三、返回新的集合/视图
             *   *  1.返回指定集合的不可修改视图
                 *  2.返回由指定集合为参数的同步(线程安全)集合 //todo 等待更新
                 *  3.返回指定集合的动态类型安全视图(debug)
                 *  4.返回不可变空集合与迭代器(代码优化)
                 *  5.返回一个不可变长度为1的集合，该集合只包含指定的对象。
                 *  6.返回由n个同一对象组成的不可变列表。(nnCopies)
                 *  7.返回一个反序的比较器
                 *  8.返回指定集合上的枚举
                 *  9.返回一个数组列表，其中包含由指定枚举返回的元素
                 *  10.提供了一个和Map实现相对应的Set实现
                 *  11.返回一个后进先出的队列视图

Collections提供了哪些操作呢?

#### 一、查询操作 ####

##### 1.查找元素 #####

binarySearch(List<? extends Comparable<? super T>> list, T key)
    binarySearch(List<? extends T> list, T key, Comparator<? super T> c)

看方法名就知道它是用的**二分查找**。

注意:

**集合中元素是没有经过排序，那么结果是未知的**。  
**另外，排序的元素必须实现排序接口(Comparable)或者比较器接口(Comparator)。**

List<String> str = new ArrayList<String>();
    str.add("b");
    str.add("c");
    str.add("a");
    
    System.out.println(Collections.binarySearch(str, "a")); //返回-1, 即没有找到

现在调整一下顺序：

str.add("b");
    str.add("a");
    str.add("c");
    
    System.out.println(Collections.binarySearch(str, "a")); //返回1

##### 2.集合中最大/最小元素 #####

// 查找元素最大值
     <T extends Object & Comparable<? super T>> T max(Collection<? extends T> coll)
                                            <T> T max(Collection<? extends T> coll, Comparator<? super T> comp)
    
    // 查找元素最小值
    <T extends Object & Comparable<? super T>> T min(Collection<? extends T> coll)
    <T> T min(Collection<? extends T> coll, Comparator<? super T> comp)

注意:

**排序的元素要实现排序接口(Comparable)或者比较器接口(Comparator)哦**

\\ 基本类型
    str.add("b");
    str.add("a");
    str.add("c");
    
    System.out.println(Collections.max(str)); //c
    System.out.println(Collections.min(str)); //a

\\ 自定义类
    public class Person implements Comparable<Person>{ //实现Comparable接口
    
        private String name;
        private int age;
    
        public Person(String name, int age) {
            this.name = name;
            this.age = age;
        }
    
        public String getName() {
            return name;
        }
        public void setName(String name) {
            this.name = name;
        }
        public int getAge() {
            return age;
        }
        public void setAge(int age) {
            this.age = age;
        }
    
        @Override
        public int compareTo(Person person){ //实现compareTo方法
            return this.age - person.age;
        }
    }

Person p1 = new Person("Zzzz", 40);
    Person p2 = new Person("Kkkk", 30);
    Person p3 = new Person("Mmmm", 50);
    
    ArrayList<Person> al = new ArrayList<Person>();
    al.add(p1);
    al.add(p2);
    al.add(p3);
    
    System.out.println(Collections.max(al).getName()); //Mmmm
    System.out.println(Collections.min(al).getName()); //Kkkk

##### 3.集合中的是否存在子集合 #####

static int indexOfSubList(List<?> source, List<?> target) //子集合是首次出现的索引
    static int lastIndexOfSubList(List<?> source, List<?> target) //子集合最后一次出现的索引

根据源码解释，它使用的是**暴力匹配**的方式。

##### 4.集合中是否有相同的元素，没有返回true #####

boolean disjoint(Collection<?> c1, Collection<?> c2)

Source code ~

//关键实现
    for (Object e : iterate) {
        if (contains.contains(e)) {
            // Found a common element. Collections are not disjoint.
             return false;
         }
     }

##### 5.返回元素在集合中出现的次数 #####

int frequency(Collection<?> c, Object o)

Source code ~

int result = 0;
    if (o == null) {
        for (Object e : c)
            if (e == null)
                result++;
    } else {
        for (Object e : c)
            if (o.equals(e))
                result++;
    }
    return result;

#### 二、修改集合结构 ####

##### 1.对集合的元素排序 #####

<T extends Comparable<? super T>> void sort(List<T> list)
                                  <T> void sort(List<T> list, Comparator<? super T> c)

Note:

排序的元素**是否实现排序接口(Comparable)或者比较器接口(Comparator)**

##### 2.反转集合元素顺序 #####

static void reverse(List<?> list)

它的源码主要展示了当集合的元素**小于**REVERSE\_THRESHOLD 时使用**随机访问**，在**大于**REVERSE\_THRESHOLD时使用**迭代器**访问。

public static void reverse(List<?> list) {
     int size = list.size();
     if (size < REVERSE_THRESHOLD || list instanceof RandomAccess) {
         for (int i=0, mid=size>>1, j=size-1; i<mid; i++, j--)
             swap(list, i, j);
     } else {
         ListIterator fwd = list.listIterator();
         ListIterator rev = list.listIterator(size);
         for (int i=0, mid=list.size()>>1; i<mid; i++) {
             Object tmp = fwd.next();
             fwd.set(rev.previous());
             rev.set(tmp);
         }
     }

##### 3.打乱集合顺序 #####

static void shuffle(List<?> list)
    static void shuffle(List<?> list, Random rnd)

[—>关于Collections.shuffle()方法][Collections.shuffle]

##### 4.交换集合两个元素的顺序 #####

直接看源码吧~

public static void swap(List<?> list, int i, int j) {
            final List l = list;
            l.set(i, l.set(j, l.get(i)));
        }

##### 5.以指定元素填充集合 #####

static <T> void fill(List<? super T> list, T obj)

ArrayList<String> strList = new ArrayList<String>();
    strList.add("b");
    strList.add("c");
    strList.add("d");
    forList(strList); //封装了foreach的方法  
    
    Collections.fill(strList, "z");
    forList(strList); //封装了foreach的方法  
    
    输出:
    b c d
    z z z

##### 6.集合元素移动 #####

void rotate(List<?> list, int distance)

ArrayList<String> strList = new ArrayList<String>();
    strList.add("b");
    strList.add("c");
    strList.add("d");
    
    Collections.rotate(strList, 1); //所有元素向右移动一个位置
    forList(strList); //封装了foreach的方法  
    
    Collections.rotate(strList, -2); // 所有元素向左移动两个位置
    forList(strList); //封装了foreach的方法  
    
    输出：
    d b c
    c d b

##### 7.以元素a替换集合所有的元素b #####

static <T> boolean replaceAll(List<T> list, T oldVal, T newVal)

ArrayList<String> strList = new ArrayList<String>();
    strList.add("b");
    strList.add("c");
    strList.add("d");
    strList.add("c");
    
    Collections.replaceAll(strList, "c", "z");
    forList(strList); //封装了foreach的方法  
    
    输出:
    b z d z

##### 8.添加指定元素到指定集合末尾 #####

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

ArrayList<String> strList = new ArrayList<String>();
    strList.add("b");
    
    Collections.addAll(strList, "c", "z");
    forList(strList);//封装了foreach的方法  
    
    输出:
    b c z

**源码~**

public static <T> boolean addAll(Collection<? super T> c, T... elements) {
    	boolean result = false;
    	for (T element : elements)
    	    result |= c.add(element);
    	return result;
        }

**|= 与 += 的形式是一样的，"|"差不多是逻辑或的意思，只要有一方为真结果就为真。**  
[——>Java中布尔类型操作&=，|=与^=的使用][Java]

##### 9.替换集合的前n个元素 #####

static <T> void copy(List<? super T> dest, List<? extends T> src)

List<String> strList = new ArrayList<String>();
    strList.add("b");
    strList.add("c");
    strList.add("d");
    
    List<String> copyList = new ArrayList<String>();
    Collections.copy(copyList, strList); // 将集合元素复制到一个空集合
    forList(copyList); //封装了foreach的方法
    
    输出:java.lang.IndexOutOfBoundsException: Source does not fit in dest

Why?

让我们看看导致这一问题的源码：

if (srcSize > dest.size())
       throw new IndexOutOfBoundsException("Source does not fit in dest");

**也就是说并不能将原集合(srcList)元素直接复制到一个空集合(destList)，使用条件 destList.siz() >= srcList.size()**

// 修改一下copyList
    List<String> copyList = new ArrayList<String>();
    copyList.add("e");
    copyList.add("e");
    copyList.add("e");
    copyList.add("e");
    
    Collections.copy(copyList, strList);
    forList(copyList);
    输出:
    b c d e // 替换了前3个元素

That means, 使用该方法会**将目标集合前src.size()个元素替换为原集合的元素**。

// 源码
    for (int i=0; i<srcSize; i++)
        dest.set(i, src.get(i));

**Note:** 要复制集合元素到一个空集合, 可以考虑使用

// 集合继承自Collection的
    addAll(Collection<? extends E> c);
    
    // Collections
    static <T> boolean addAll(Collection<? super T> c, T... elements) // T...elements 可变参数

tip:
    从Java 5版本开始，方法的参数如果是相同类型的变量列表（称为可变参数），则可以使用一种特殊的语法，比如：
    public void find(String ... elements) {
        // Some implementation here
    }
    
    编译器会转换可变参数为对应类型的一个数组

#### 三、返回新的集合/视图 ####

##### 1.返回指定集合的不可修改视图 #####

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

// 示例
     List<String> strList = new ArrayList<String>();
     strList.add("b");
     strList.add("c");
     strList.add("d");
    
     List<String> unMoList =Collections.unmodifiableList(strList);
     unMoList.add("d");
     
     输出：
     java.lang.UnsupportedOperationException

部分源码展示:

public E set(int index, E element) {
                throw new UnsupportedOperationException();
    }
    public void add(int index, E element) {
        throw new UnsupportedOperationException();
    }
    public E remove(int index) {
        throw new UnsupportedOperationException();
    }

可以看到，**涉及到修改集合结构的操作是不被允许的.** 类似的视图还有 **unmodifiableMap, unmodifiableSet…**

参考资料:  
[由Collections.unmodifiableList引发的重构][Collections.unmodifiableList]

##### 2.返回由指定集合为参数的同步(线程安全)集合 //todo 等待更新 #####

这个涉及到**线程安全和并发**，是我的姿势盲区。等我GET到以后，我会回来更新的~

涉及到的视图有**synchronizedList\*, synchronizedMap(Map<K,V> m), synchronizedSet(Set s)…**

##### 3.返回指定集合的动态类型安全视图(debug) #####

Collection<E> checkedCollection(Collection<E> c, Class<E> type)

根据源码解释，这个方法可以**用于检测将错误类型的元素插入集合时引发的ClassCastException。这个错误一般发生在传递引用的时候。**

{@code
        Collection<String> c = new HashSet<String>();
     }
    may be replaced temporarily by this one:
     {@code
         Collection<String> c = Collections.checkedCollection(
             new HashSet<String>(), String.class);
     }

// 示例
    List<Integer> list = new ArrayList<Integer>();
    list.add(3);
    
    List obj = list; //传递引用
    // 编译时不会报错
    obj.add("dd"); 
    
    int num = 0;
    for(Integer a : list ){
        num += a;
    }
    
    输出:
    java.lang.ClassCastException: java.lang.String cannot be cast to java.lang.Integer
    at test.Test.main(Test.java:32)

Now 我们修改一下

// 修改创建list部分
    List<Integer> list = Collections.checkedList(new ArrayList<Integer>(), Integer.class);
    
    运行结果:
    java.lang.ClassCastException: Attempt to insert class java.lang.String element into collection with element type class java.lang.Integer
    ...
    at test.Test.main(Test.java:29)

对比运行结果可以知道该方法**能够发现最开始发生错误的地方。Of cource, 修改错误后要把集合初始化的地方改回去**

其它集合类型也有对应的方法检查:  
**checkedMap(Map<K, V> m,Class keyType,Class valueType) , checkedSet(Set s, Class type)…**

##### 4.返回不可变空集合与迭代器(代码优化) #####

static final <T> List<T> emptyList()
    static final <T> Set<T> emptySet()
    static final <K,V> Map<K,V> emptyMap()

**参考资料:**  
[—>Collections.emptyList（）与高并发][Collections.emptyList]  
[—>不可变空集合与迭代器(Immutable empty collections and iterators)][Immutable empty collections and iterators]

##### 5.返回一个不可变长度为1的集合，该集合只包含指定的对象。 #####

// Returns an immutable list containing only the specified object.
    static <T> List<T> singletonList(T o)
    static <T> Set<T> singleton(T o)
    static <K,V> Map<K,V> singletonMap(K key, V value)

调用size()方法只会返回1

public int size(){return 1;}

我查了资料后发现有一个使用场景是, 当你调用的方法需要的参数是一个集合, 但是只用到一个元素时。**Like:**

// 示例:从集合中删除空元素
    List<String> strList = new ArrayList<String>();
    strList.add("b");
    strList.add(null);
    strList.add("d");
    forList(strList); // 封装foreach的方法
    
    System.out.println("=======");
    
    strList.removeAll(Collections.singleton(null)); 
    forList(strList);
    }
    
    输出:
    b null d 
    =======
    b d

##### 6.返回由n个同一对象组成的不可变列表。(nnCopies) #####

public static <T> List<T> nCopies(int n, T o)

List<String> s = Collections.nCopies(4, "Zzz");
    forList(s); // 封装foreach的方法
    
    输出:
    Zzz 
    Zzz 
    Zzz 
    Zzz

这方法有啥用啊?(尼克杨问号脸)

源码注释提供:

this method is useful in combination with the <tt>List.addAll</tt> method to grow lists.

##### 7.返回一个反序的比较器 #####

<T> Comparator<T> reverseOrder()
    static <T> Comparator<T> reverseOrder(Comparator<T> cmp)

没啥好说的, 应该是**为了配合sort方法**使用排序的。

##### 8.返回指定集合上的枚举 #####

static <T> Enumeration<T> enumeration(final Collection<T> c)

相当于早期版本的Iterator吧, 来段代码感受下:

List<String> strList = new ArrayList<String>();
    strList.add("b");
    strList.add(null);
    strList.add("d");
    
    Enumeration<String> en = Collections.enumeration(strList);
    while(en.hasMoreElements()){
        String str = en.nextElement();
        System.out.println(str);
    }
    
    输出：
    b
    null
    d

**参考资料:**  
[关于Enumeration和Iterator的区别][Enumeration_Iterator]

##### 9.返回一个数组列表，其中包含由指定枚举返回的元素 #####

static <T> ArrayList<T> list(Enumeration<T> e)

##### 10.提供了一个和Map实现相对应的Set实现 #####

static <E> Set<E> newSetFromMap(Map<E, Boolean> map)

**参考资料:**  
[Collections.newSetFromMap使用场景][Collections.newSetFromMap]

##### 11.返回一个后进先出的队列视图 #####

public static <T> Queue<T> asLifoQueue(Deque<T> deque) {
         return new AsLIFOQueue<>(deque);
     }

// 示例
    Deque<String> deque = new ArrayDeque<String>();
    deque.offer("b");
    deque.offer("c");
    
    Queue<String> queue = Collections.asLifoQueue(deque);
    queue.offer("d");
    queue.offer("a");
    
    forList(queue); //封装foreach的方法
    
    输出:
    a 
    d 
    b 
    c

可以看到, 在**调用方法之后**添加的元素才有后进先出的特点, 参数deque的元素顺序在新的队列中没有变。

[Collections.shuffle]: https://blog.csdn.net/qq_35893120/article/details/82492775
[Java]: https://blog.csdn.net/zjpp2580369/article/details/83472871
[Collections.unmodifiableList]: https://www.cnblogs.com/persist-confident/p/4516741.html
[Collections.emptyList]: https://blog.csdn.net/laladebon/article/details/82867159
[Immutable empty collections and iterators]: https://blog.csdn.net/zch1990s/article/details/80732844
[Enumeration_Iterator]: https://zhidao.baidu.com/question/67763752.html
[Collections.newSetFromMap]: http://www.manongjc.com/article/51725.html