1. Collections工具类

Collections类概述

针对集合操作 的工具类，里面的方法都是静态的，可以对集合进行排序、二分查找、反转、混排等。

Collection和Collections的区别

Collection:是单列集合的顶层接口，有子接口List和Set。Collections:是针对集合操作的工具类，有对集合进行排序和二分查找等方法

Collections常用方法

  • public static <T> void sort(List<T> list)

使用sort方法可以根据元素的自然顺序 对指定列表按升序进行排序。列表中的所有元素都必须实现 Comparable 接口。此列表内的所有元素都必须是使用指定比较器可相互比较的

  • public static <T> int binarySearch(List<?> list,T key)

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

  • public static <T> T max(Collection<?> coll)

根据元素的自然顺序，返回给定 collection 的最大元素。

  • public static void reverse(List<?> list)

反转指定列表中元素的顺序。

  • public static void shuffle(List<?> list)

混排算法所做的正好与 sort 相反: 它打乱在一个 List 中可能有的任何排列的踪迹。也就是说，基于随机源的输入重排该 List, 这样的排列具有相同的可能性（假设随机源是公正的）。这个算法在实现一个碰运气的游戏中是非常有用的。例如，它可被用来混排代表一副牌的 Card 对象的一个 List 。另外，在生成测试案例时，它也是十分有用的。

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

使用指定元素替换指定列表中的所有元素。

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

将所有元素从一个列表复制到另一个列表。用两个参数，一个目标 List 和一个源 List, 将源的元素拷贝到目标，并覆盖它的内容。目标 List 至少与源一样长。如果它更长，则在目标 List 中的剩余元素不受影响。

  • 集合线程安全化

List<T> synchronizedList(List<T> list);//返回支持的同步（线程安全的）List集合

Map<K,V> synchronizedMap(Map<K,V> m)：返回支持的同步（线程安全的）Map集合

  1. package cn.itcast_01;
  3. import java.util.Collections;
  4. import java.util.List;
  5. import java.util.ArrayList;
  7. /*
  8.  * Collections:是针对集合进行操作的工具类，都是静态方法。
  9.  * 
  10.  * 面试题：
  11.  * Collection和Collections的区别?
  12.  * Collection:是单列集合的顶层接口，有子接口List和Set。
  13.  * Collections:是针对集合操作的工具类，有对集合进行排序和二分查找的方法
  14.  * 
  15.  * 要知道的方法
  16.  * public static <T> void sort(List<T> list)：排序 默认情况下是自然顺序。
  17.  * public static <T> int binarySearch(List<?> list,T key):二分查找
  18.  * public static <T> T max(Collection<?> coll):最大值
  19.  * public static void reverse(List<?> list):反转
  20.  * public static void shuffle(List<?> list):随机置换
  21.  */
  22. public class CollectionsDemo {
  23.     public static void main(String[] args) {
  24.         // 创建集合对象
  25.         List<Integer> list = new ArrayList<Integer>();
  27.         // 添加元素
  28.         list.add(30);
  29.         list.add(20);
  30.         list.add(50);
  31.         list.add(10);
  32.         list.add(40);
  34.         System.out.println("list:" + list);
  36.         // public static <T> void sort(List<T> list)：排序 默认情况下是自然顺序。
  37.         // Collections.sort(list);
  38.         // System.out.println("list:" + list);
  39.         // [10, 20, 30, 40, 50]
  41.         // public static <T> int binarySearch(List<?> list,T key):二分查找
  42.         // System.out
  43.         // .println("binarySearch:" + Collections.binarySearch(list, 30));
  44.         // System.out.println("binarySearch:"
  45.         // + Collections.binarySearch(list, 300));
  47.         // public static <T> T max(Collection<?> coll):最大值
  48.         // System.out.println("max:"+Collections.max(list));
  50.         // public static void reverse(List<?> list):反转
  51.         // Collections.reverse(list);
  52.         // System.out.println("list:" + list);
  54.         //public static void shuffle(List<?> list):随机置换
  55.         Collections.shuffle(list);
  56.         System.out.println("list:" + list);
  57.     }
  58. }

运行结果：

集合工具类 - 图1

2. Arrays工具类

概述

此类包含用来操作数组（比如排序和搜索）的各种方法。此类还包含一个允许将数组作为列表来查看的静态工厂。

常用方法

Array是Java特有的数组。在你知道所要处理数据元素个数的情况下非常好用。java.util.Arrays 包含了许多处理数据的实用方法：

方法声明 功能描述
Arrays.asList() 可以从 Array 转换成 List。可以作为其他集合类型构造器的参数
Arrays.binarySearch() 在一个已排序的或者其中一段中快速查找
Arrays.copyOf() 如果你想扩大数组容量又不想改变它的内容的时候可以使用这个方法
Arrays.copyOfRange() 可以复制整个数组或其中的一部分
Arrays.deepEquals()
Arrays.deepHashCode()		 Arrays.equals/hashCode的高级版本，支持子数组的操作
Arrays.equals() 如果你想要比较两个数组是否相等，应该调用这个方法而不是数组对象中的 equals方法（数组对象中没有重写equals()方法，所以这个方法之比较引用而不比较内容）。这个方法集合了Java 5的自动装箱和无参变量的特性，来实现将一个变量快速地传给 equals()方法——所以这个方法在比较了对象的类型之后是直接传值进去比较的
Arrays.fill() 用一个给定的值填充整个数组或其中的一部分
Arrays.hashCode() 用来根据数组的内容计算其哈希值（数组对象的hashCode()不可用）。这个方法集合了Java 5的自动装箱和无参变量的特性，来实现将一个变量快速地传给 Arrays.hashcode方法——只是传值进去，不是对象
Arrays.sort() 对整个数组或者数组的一部分进行排序。也可以使用此方法用给定的比较器对对象数组进行排序
Arrays.toString() 打印数组的内容

如果想要复制整个数组或其中一部分到另一个数组，可以调用 System.arraycopy()方法。此方法从源数组中指定的位置复制指定个数的元素到目标数组里。这无疑是一个简便的方法。（有时候用 ByteBuffer bulk复制会更快。可以参考这篇文章）.

最后，所有的集合都可以用T[] Collection.toArray( T[] a ) 这个方法复制到数组中。通常会用这样的方式调用：

  1. return coll.toArray( new T[ coll.size() ] );

这个方法会分配足够大的数组来储存所有的集合，这样 toArray() 在返回值时就不必再分配空间了。

集合与数组的转换

(1) 将数组转换为集合

Lsit<T> asList(T… a);//返回一个受指定数组支持的固定大小的列表。

把数组变成List集合的好处：可以使用集合的思想和方法来操作数组中的元素。如：contains，get，indexOf，subList等方法。

PS:

  • 将数组转换成集合，不可使用集合的增删方法，因为数组的长度是固定的。如果进行增删操作，则会产生UnsupportedOperationException的编译异常。
  • 如果数组中的元素都是对象，则变成集合时，数组中的元素就直接转为集合中的元素。
  • 如果数组中的元素都是基本数据类型，那么会将该数组作为集合中的元素存在。

(2) 集合转数组

查找

int binarySearch()：使用二分搜索法来搜索指定的 byte 型数组，以获得指定的值

判断

boolean equals(Object[] a, Object[] a2)：判断指定的两个数组是否相等

排序

void sort()：对指定的数组按数字升序进行排序。

复制

<T> T[] copyOf(T[] original, int newLength)
复制指定的数组，截取或用 null 填充（如有必要），以使副本具有指定的长度。

填充

void fill(Object[] a, Object val) 将指定的 Object 引用分配给指定 Object 数组的每个元素。

其他方法

  • toString(Object[] a)：返回指定数组内容的字符串表示形式。
  • int hashCode(Object[] a) 基于指定数组的内容返回哈希码。
  1. package com.heima.test;
  3. import java.util.ArrayList;
  4. import java.util.Arrays;
  5. import java.util.List;
  7. public class Test {
  8.     public static void main(String[] args) {
  9.         System.out.println("1、将数组转成集合");
  10.         System.out.println("-------------------");
  11.         // asList()将数组转换为集合
  12.         List<Integer> list = Arrays.asList(87, 67, 65, 544);
  13.         for (Integer i : list) {
  14.             System.out.println(i);
  15.         }
  16.         System.out.println("2、二分查找");
  17.         System.out.println("-------------------");
  19.         // binarySearch()二分查找
  20.         int[] a = { 23, 45, 67, 8, 32, 45, 6, 7, 85, 54, 3, 432 };
  21.         int index = Arrays.binarySearch(a, 45);
  22.         System.out.println(index);
  24.         System.out.println("3、排序");
  25.         System.out.println("-------------------");
  27.         // sort()排序
  28.         System.out.println("排序前：" + Arrays.toString(a));
  29.         Arrays.sort(a);
  30.         System.out.println("排序后：" + Arrays.toString(a));
  32.         System.out.println("4、集合转成数组");
  33.         System.out.println("-------------------");
  35.         // toArray()集合转成数组
  36.         ArrayList<String> al = new ArrayList<String>();
  37.         al.add("java");
  38.         al.add("javase");
  39.         al.add("php");
  40.         al.add("ruby");
  41.         al.add("android");
  43.         String[] str = al.toArray(new String[al.size()]);
  44.         System.out.println(Arrays.toString(str));
  45.     }
  46. }

运行结果：
集合工具类 - 图2

3. System.arraycopy()

  1. public static native void arraycopy(Object src,  int  srcPos,  
  2.                                         Object dest, int destPos,  
  3.                                         int length);
  • src - 源数组
  • srcPos - 源数组中的起始位置
  • dest - 目标数组
  • destPos - 目标数据中的起始位置
  • length - 要复制的数组元素的数量