Java Collection & Collections 区别

向右看齐 2023-03-03 04:58 17阅读 0赞

## 一，Collection ##

Collection是一个Util 集合接口，自身继承了迭代类Iterator，提供了一系列的集合操作方法。对List,Set提供统一化的操作。

public interface Collection<E> extends Iterable<E> {
        // Query Operations
    ....

Collection    
├List    
│├LinkedList    
│├ArrayList    
│└Vector    
│　└Stack    
└Set

## 二，Collections ##

Collections是一个Util 包装类，提供了一系列集合操作的静态方法。从构造方法私有化上来看，它无法被实例化，某种意义上而言它是一个工具类的存在。

// Suppresses default constructor, ensuring non-instantiability.
        private Collections() {
        }

## 三、提供的常用的部分静态方法 ##

A、排序方法：

@SuppressWarnings("unchecked")
        public static <T extends Comparable<? super T>> void sort(List<T> list) {
            list.sort(null);
        }

B、二进制比较

public static <T>
        int binarySearch(List<? extends Comparable<? super T>> list, T key) {
            if (list instanceof RandomAccess || list.size()<BINARYSEARCH_THRESHOLD)
                return Collections.indexedBinarySearch(list, key);
            else
                return Collections.iteratorBinarySearch(list, key);
        }

C、元素的交换

@SuppressWarnings({"rawtypes", "unchecked"})
        public static void swap(List<?> list, int i, int j) {
            // instead of using a raw type here, it's possible to capture
            // the wildcard but it will require a call to a supplementary
            // private method
            final List l = list;
            l.set(i, l.set(j, l.get(i)));
        }

D、返回不可操作的Collection集合

public static <T> Collection<T> unmodifiableCollection(Collection<? extends T> c) {
            return new UnmodifiableCollection<>(c);
        }
    
        /**
         * @serial include
         */
        static class UnmodifiableCollection<E> implements Collection<E>, Serializable {
            private static final long serialVersionUID = 1820017752578914078L;
    
            final Collection<? extends E> c;
    
            UnmodifiableCollection(Collection<? extends E> c) {
                if (c==null)
                    throw new NullPointerException();
                this.c = c;
            }
    
            public int size()                   {return c.size();}
            public boolean isEmpty()            {return c.isEmpty();}
            public boolean contains(Object o)   {return c.contains(o);}
            public Object[] toArray()           {return c.toArray();}
            public <T> T[] toArray(T[] a)       {return c.toArray(a);}
            public String toString()            {return c.toString();}
    
            public Iterator<E> iterator() {
                return new Iterator<E>() {
                    private final Iterator<? extends E> i = c.iterator();
    
                    public boolean hasNext() {return i.hasNext();}
                    public E next()          {return i.next();}
                    public void remove() {
                        throw new UnsupportedOperationException();
                    }
                    @Override
                    public void forEachRemaining(Consumer<? super E> action) {
                        // Use backing collection version
                        i.forEachRemaining(action);
                    }
                };
            }