chap12-Collections

《java collections》学习笔记

Collections 是 java collections framework中最特殊的两个类之一(另外一个Arrays后续会讲到)。
它提供了一系列的static方法

初始化集合

Empty Collections

Collections中定义了三个常量来表示空集合,不允许向集合中条件添加或删除元素。

public static final Set EMPTY_SET = new EmptySet<>();
public static final List EMPTY_LIST = new EmptyList<>();
public static final Map EMPTY_MAP = new EmptyMap<>();

EmptyList

private static class EmptyList<E>
        extends AbstractList<E>
        implements RandomAccess, Serializable {
        //略..

        public int size() {return 0;}
        public boolean isEmpty() {return true;}

        public boolean contains(Object obj) {return false;}
        public boolean containsAll(Collection<?> c) { return c.isEmpty(); }

        public Object[] toArray() { return new Object[0]; }

        public <T> T[] toArray(T[] a) {
            if (a.length > 0)
                a[0] = null;
            return a;
        }
        
        //get 则抛出越界异常
        public E get(int index) {
            throw new IndexOutOfBoundsException("Index: "+index);
        }

        public boolean equals(Object o) {
            return (o instanceof List) && ((List<?>)o).isEmpty();
        }

        public int hashCode() { return 1; }
      
        //略.....
    }

继承自AbstractList,自身没有实现add,remove等方法，故只能调用父类AbstractList的实现

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

public E remove(int index) {
    throw new UnsupportedOperationException();
}

所以执行如下代码，会抛出异常

@Test
public void empty(){
    List list = Collections.EMPTY_LIST;
    list.add("x"); //抛出异常
}

EmptySet,EmptyMap也是同理，这里不再赘述。

Singleton Collections

同 Empty Collections,唯一的不同是，集合中有且只有一个元素. 任何尝试向集合中添加或删除元素的操作都会抛出UnsupportedOperationException

public static <T> Set<T> singleton(T o) {
    return new SingletonSet<>(o);
}

public static <T> List<T> singletonList(T o) {
    return new SingletonList<>(o);
}

public static <K,V> Map<K,V> singletonMap(K key, V value) {
    return new SingletonMap<>(key, value);
}

SingletonList

private static class SingletonList<E>
    extends AbstractList<E>
    implements RandomAccess, Serializable {

    private final E element;

    SingletonList(E obj)                {element = obj;}

    public Iterator<E> iterator() {
        return singletonIterator(element);
    }

    public int size()                   {return 1;}

    public boolean contains(Object obj) {return eq(obj, element);}
    
    //如果index != 0 .直接抛出异常
    public E get(int index) {
        if (index != 0)
          throw new IndexOutOfBoundsException("Index: "+index+", Size: 1");
        return element;
    }
    
    //略...
}

---

---

Wrapped Collections

Read−Only Collections

为了确保集合不被修改，可以使用如下的方法：

public static <T> Collection<T> unmodifiableCollection(Collection<? extends T> c) {}

public static <T> Set<T> unmodifiableSet(Set<? extends T> s) {}
public static <T> NavigableSet<T> unmodifiableNavigableSet(NavigableSet<T> s) {}
public static <T> SortedSet<T> unmodifiableSortedSet(SortedSet<T> s){}

public static <T> List<T> unmodifiableList(List<? extends T> list) {}

public static <K,V> Map<K,V> unmodifiableMap(Map<? extends K, ? extends V> m){}
public static <K,V> SortedMap<K,V> unmodifiableSortedMap{}
public static <K,V> NavigableMap<K,V> unmodifiableNavigableMap{}

注意
如下操作是可以成功执行的。

@Test
public void unmodify(){
    List<Date> list = Collections.unmodifiableList(Arrays.asList(new Date()));
    System.out.println(	list.get(0));
    list.get(0).setYear(100); //1900+100 = 2000
    System.out.println(list.get(0)); // 2000 xxx...
}

Thread−Safe Collections

public static <T> Collection<T> synchronizedCollection(Collection<T> c)
//可以指定“锁” mutex
//非public方法
static <T> Collection<T> synchronizedCollection(Collection<T> c, Object mutex)

public static <T> Set<T> synchronizedSet(Set<T> s)
public static <T> SortedSet<T> synchronizedSortedSet(SortedSet<T> s)
public static <T> NavigableSet<T> synchronizedNavigableSet(NavigableSet<T> s)


public static <T> List<T> synchronizedList(List<T> list)
static <T> List<T> synchronizedList(List<T> list, Object mutex) //可以指定“锁” mutex

public static <K,V> SortedMap<K,V> synchronizedSortedMap(SortedMap<K,V> m) 
public static <K,V> NavigableMap<K,V> synchronizedNavigableMap(NavigableMap<K,V> m)

Sorting

sorting

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

reverse

//逆序
public static void reverse(List<?> list) {};

ReverseComparator

public static <T> Comparator<T> reverseOrder() {
	return (Comparator<T>) ReverseComparator.REVERSE_ORDER;
}

private static class ReverseComparator
    implements Comparator<Comparable<Object>>, Serializable {

    static final ReverseComparator REVERSE_ORDER
        = new ReverseComparator();

    public int compare(Comparable<Object> c1, Comparable<Object> c2) {
        return c2.compareTo(c1); //注意  c2.compareTo(c1) ; 逆序
    }
}

Searching

Binary Searching - 二分查找

使用二分搜索法搜索指定列表，以获得指定对象。

• 在调用binarySearch()前,List必须是已经升序排序过的(sorted).如果没有对列表进行排序，则结果是不确定的。
• 如果列表包含多个等于指定对象的元素，则无法保证找到的是哪一个。

//list已经使用`列表元素`的对列表进行`升序`排序
public static <T> int binarySearch(List<? extends Comparable<? super T>> list, T key) { }

//list已经使用`Comparator`的对列表进行`升序`排序
public static <T> int binarySearch(List<? extends T> list, T key, Comparator<? super T> c) { }

max(),min()

public static <T extends Object & Comparable<? super T>> T min(Collection<? extends T> coll)
public static <T> T min(Collection<? extends T> coll, Comparator<? super T> comp)

public static <T extends Object & Comparable<? super T>> T max(Collection<? extends T> coll)
public static <T> T max(Collection<? extends T> coll, Comparator<? super T> comp)

通用操作

copy

将所有元素从一个列表复制到另一个列表。执行此操作后，目标列表中每个已复制元素的索引将等同于源列表中该元素的索引。
目标列表的长度至少必须等于源列表。如果目标列表更长一些，也不会影响目标列表中的其余元素.如果小于，则会抛出抛出IndexOutOfBoundsException异常

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

demo

	@Test
	public void copy(){
		List src = new ArrayList(Arrays.asList("a", "b", "c"));
		List dest = new ArrayList(Arrays.asList("4", "5", "6","7"));

		Collections.copy(dest, src);
		System.out.println(src); //[a, b, c]
		System.out.println(dest); //[a, b, c, 7]

		Collections.copy(src, dest); //src长度 小于dest长度,抛出IndexOutOfBoundsException异常

	}

fill

使用指定元素替换指定列表中的所有元素。
完成fill之后，list所有元素的引用都指向同一个元素.

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

nCopies

返回由指定对象的n个副本组成的新的不可变列表。

//n 不能为负数
public static <T> List<T> nCopies(int n, T o)；

使用demo

List list = new LinkedList(Collections.nCopies(10, null));