Java集合相关的常用工具类简介说明

转自:

Java集合相关的常用工具类简介说明

下文笔者将讲述java集合类中常用的工具类简介说明，如下所示

Java中的集合类既可以当做放其他数据的容器
 又可以当做常见的数据结构使用
Java中提供了很多好用的工具类来操作这些集合类

java常用工具类说明

JDK本身提供的工具类 
Guava提供的工具类 
Apache common-Collection提供的工具类

JDK提供的工具类

Arrays
Collections
Objects

Arrays是操作数组对象的工具类
Collections是操作集合对象的工具类
Objects是操作引用数据类型对象的工具类

Arrays的常用方法

普通排序

Arrays.sort(int[] a)
Arrays.sort(int[] a, int fromIndex, int toIndex)

并行排序:JDK1.8新增

Arrays.parallelSort(int[] a)
Arrays.parallelSort(int[] a, int fromIndex, int toIndex)

并行计算:
  JDK1.8新增
  支持函数式编程
   根据传入的方法进行一次计算 
Arrays.parallelPrefix(int[] array, IntBinaryOperator op)
Arrays.parallelPrefix(int[] array, int fromIndex, int toIndex, IntBinaryOperator op)

二分法查找
前提是该数组已经进行了排序

Arrays.binarySearch(int[] a, int key)
Arrays.binarySearch(int[] a, int fromIndex, int toIndex, int key)

判断两个数组是否相等

Arrays.equals(int[] a, int[] a2)

对数组进行填充

Arrays.fill(int[] a, int val)
Arrays.fill(int[] a, int fromIndex, int toIndex, int val)

复制数组

Arrays.copyOf(int[] original, int newLength)
    返回赋值后的数组，数组长度为newLength。
Arrays.copyOfRange(int[] original, int from, int to)

toString
将元素用","隔开
包裹在"[ ]"内

Arrays.toString(int[] a)
Arrays.deepToString(Object[] a)方法内部调用了a.toString()。

更改元素值
JDK1.8新增
支持函数式编程

setAll(int[] array, IntUnaryOperator generator)
setAll(long[] array, IntToLongFunction generator)
setAll(double[] array, IntToDoubleFunction generator)
setAll(T[] array, IntFunction<? extends T> generator)

数组转集合

Arrays.asList(T... a) 返回List<T>

生成并行遍历Spliterator
JDK1.8新增

Arrays.spliterator(int[] array)
Arrays.spliterator(int[] array, int startInclusive, int endExclusive)
int、long、double和实现了Spliterator接口的类具有该类型方法

生成Stream类
JDK1.8新增

Arrays.stream(int[] a)
Arrays.stream(int[] array, int startInclusive, int endExclusive)
int、long、double和实现了Stream接口的类具有该类型方法。

Collections的常用方法

排序

Collections.sort(List list) 
T或其父类需要实现Comparable接口
Collections.sort(List list, Comparator<? super T> c) 

Collections.sort()的源码
public static <T> void sort(List<T> list, Comparator<? super T> c) {
  list.sort(c);
}

List.sort()源码

default void sort(Comparator<? super E> c) {
	Object[] a = this.toArray();
	Arrays.sort(a, (Comparator) c); // 调用Arrays.sort()来进行排序
	ListIterator<E> i = this.listIterator();
	for (Object e : a) {
		i.next();
		i.set((E) e);
	}
}

注意事项:
Collections.sort()最终调用的是Arrays.sort()进行排序。

查到索引

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

顺序反转

Collections.reverse(List<?> list)

乱序 Collections.shuffle(List<?> list)

指定元素互换

Collections.swap(List<?> list, int i, int j)

填充

Collections.fill(List<? super T> list, T obj)

复制

Collections.copy(List<? super T> dest, List<? extends T> src)

求最大值最小值

Collections.min(Collection<? extends T> coll)
Collections.min(Collection<? extends T> coll, Comparator<? super T> comp)
Collections.max(Collection<? extends T> coll)
Collections.max(Collection<? extends T> coll, Comparator<? super T> comp)

转动元素

Collections.rotate(List<?> list, int distance)

distance可以接受负数
将list元素整体向后移动distance的距离
原来最后的distance个元素放到最前面(类似与一个圆圈转动)

替换元素

Collections.replaceAll(List list, T oldVal, T newVal)

子集合索引

Collections.indexOfSubList(List source, List target)
Collections.lastIndexOfSubList(List source, List target)
如果不是子集合，返回-1

转换为不可变集合

Collections.unmodifiableCollection(Collection<? extends T> c)
将集合转换为不可变集合read-only
装饰者模式
使用final修饰iterator
增删元素的方法throw new UnsupportedOperationException()

Collections.unmodifiableSet(Set<? extends T> s)
Collections.unmodifiableList(List<? extends T> list)
Collections.unmodifiableMap(Map<? extends K, ? extends V> m)

转换为同步集合

Collections.synchronizedCollection(Collection c)
Collections.synchronizedCollection(Collection c, Object mutex) 指定mutex对象作为同步锁，将集合转换为线程安全的同步集合。装饰着模式，方法内使用了 synchronized (mutex) { ... }保证线程安全
Collections.synchronizedSet(Set s)
Collections.Collections.synchronizedSet(Set s, Object mutex)
Collections.synchronizedList(List list)
Collections.synchronizedList(List list, Object mutex)
Collections.synchronizedMap(Map<K, V>)

元素受限制集合

Collections.checkedCollection(Collection c, Class type)
由于JDK1.5引入了泛型，采用该方法，保证运行期集合中增加的元素只能是指定的类型。同样是装饰着模式。
Collections.checkedQueue(Queue queue, Class type)
Collections.checkedSet(Set, Class)
Collections.checkedList(List, Class)
Collections.checkedMap(Map<K, V>, Class, Class)

生成空的不可变集合

Collections.emptyIterator()
Collections.emptyListIterator()
Collections.emptyEnumeration()
Collections.emptySet()
Collections.emptyList()
Collections.emptyMap()

只有1个元素的不可变集合

Collections.singleton(T)
Collections.singletonList(T)
Collections.singletonMap(K, V)

拥有n个相同元素的不可变集合

Collections.nCopies(int, T)

反序比较器

Collections.reverseOrder(Comparator)
返回一个Comparator，返回值与参数值是相反顺序的比较器

转换为枚举类型的API

Collections.enumeration(Collection)
返回Enumeration

将Enumeration转换为集合

Collections.list(Enumeration)
返回ArrayList

元素在集合中的个数

Collections.frequency(Collection<?>, Object)
返回int

两个元素是否有交集

Collections.disjoint(Collection, Collection)
返回boolean

增加元素

addAll(Collection<? super T> c, T... elements)
由于List接口拥有listItegertor()方法
与List相关的大部分操作内部会判断阀值
超过阀值则采用listIterator遍历
小于阀值则采用for循环索引遍历
不同的方法阀值不同

---

Objects类
Objects.equals(Object a, Object b)

  public static boolean equals(Object a, Object b) {
    return a == b || (a != null && a.equals(b));
  }

Guava工具类

集合接口	属于JDK还是*Guava*	对应的Guava工具类
Collection	JDK	Collections2：不要和java.util.Collections混淆
List	JDK	Lists
Set	JDK	Sets
SortedSet	JDK	Sets
Map	JDK	Maps
SortedMap	JDK	Maps
Queue	JDK	Queues
Multiset	Guava	Multisets
Multimap	Guava	Multimaps
BiMap	Guava	Maps
Table	Guava	Tables

Apache提供的Collection

Apache提供的集合工具类功能也非常强大
还提供了集合的求交集、并集和差集等功能