Java容器---Arrays & Collections工具类

---

1.Array & Arrays 与Collection & Collections区别

(1)Collection": 是一个接口，与其子类共同组成一个Collection集合框架；

Collections: 是一个类，一个服务于集合的工具类, 提供一系列静态方法实现对各种集合的搜索、排序、线程安全化等操作。

(2)Array:         提供了动态创建和访问 Java 数组的方法；

Arrays:        用于操作数组的工具类，里面都是操作数组的静态方法。其中一个比较重要的方法：asList() 将数组转化为List集合。

---

2.Collections常用方法(参见API)

(1)public static <T extends Comparable<? super T>> void sort(List<T> list)

根据元素的自然顺序进行排列

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

根据指定比较器的顺序对指定列表进行排序

  1 import java.util.ArrayList;
  2 import java.util.Collections;
  3 import java.util.Comparator;
  4 import java.util.List;
  5
  6 /**
  7  * sort方法演示：
  8  *
  9  */
 10 public class SortDemo
 11 {
 12 	public static void main(String[] args)
 13 	{
 14 		List<String> al = new ArrayList<String>();
 15
 16 		al.add("013");
 17 		al.add("03");
 18 		al.add("002");
 19 		System.out.println(al);
 20
 21 		Collections.sort(al);
 22 		System.out.println(al);
 23
 24 		Collections.sort(al,new LenCompare());
 25 		System.out.println(al);
 26 	}
 27 }
 28
 29 //定义一个比较器，按照长度排序
 30 class LenCompare implements Comparator<String>
 31 {
 32 	public int compare(String s1,String s2)
 33 	{
 34 		if (s1.length()>s2.length())
 35 			return 1;
 36 		if (s1.length()<s2.length())
 37 			return -1;
 38 		return s1.compareTo(s2);
 39 	}
 40 }
 41 

(3)public static <T> int binarySearch(List<? extends Comparable<? super T>> list ,T key): 二分法查找

使用二分搜索法搜索指定列表，以获得指定对象。在进行此调用之前，必须根据列表元素的自然顺序对列表进行升序排序

(4)public static <T> int binarySearch(List<? extends T> list, T key, Comparator<? super T> c)

使用二分搜索法搜索指定列表，以获得指定对象。在进行此调用之前，必须根据指定的比较器对列表进行升序排序.

(5)public static void reverse(List<?> list)：反转指定列表中元素的顺序

(6)public static void swap(List<?> list, int i, int j):在指定列表的指定位置处交换元素

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

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

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

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

(9)public static <T extends Object & Comparable<? super T>> T min(Collection<? exten  ds T> coll)

根据元素的自然顺序 返回给定 collection 的最小元素.

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

根据指定比较器产生的顺序，返回给定 collection 的最小元素。

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

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

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

使用另一个值替换列表中出现的所有某一指定值。

---

3.Arrays常用方法(参见API)

(1)public static <T> List<T> asList(T... a)

返回一个受指定数组支持的固定大小的列表。此方法同 Collection.toArray() 一起，充当了基于数组的 API 与基于 collection 的 API 之间的桥梁。返回的列表是可序列化的，并且实现了 RandomAccess。

(2)public static void sort(long/char/int/double/byte/Object[] a)

对指定的类型数组按数字升序进行排序。该排序算法是一个经过调优的快速排序法。

(3)public static void sort(long/char/int/double/byte/Object[] a, int fromIndex, int toIndex)

对指定类型数组的指定范围按数字升序进行排序。排序的范围从索引 fromIndex（包括）一直到索引 toIndex（不包括）。（如果 fromIndex==toIndex，则排序范围为空。）

(4)public static <T> void sort(T[] a, int fromIndex, int toIndex, Comparator<? super T> c)

根据指定比较器产生的顺序对指定对象数组的指定范围进行排序。

(5)public static int binarySearch(类型[] a, long key)

使用二分搜索法来搜索指定的类型数组，以获得指定的值。必须在进行此调用之前对数组进行排序（通过 sort(long[]) 方法）。如果没有对数组进行排序，则结果是不确定的。如果数组包含多个带有指定值的元素，则无法保证找到的是哪一个。

(6)public static boolean equals(类型[] a, long[] a2)

如果两个指定的类型数组彼此相等，则返回 true。如果两个数组包含相同数量的元素，并且两个数组中的所有相应元素对都是相等的，则认为这两个数组是相等的。换句话说，如果两个数组以相同顺序包含相同的元素，则两个数组是相等的。此外，如果两个数组引用都为     null，则认为它们是相等的。

(7)public static void fill(类型[] a, long val)

将指定的类型值分配给指定 long 型数组的每个元素。

(8)public static int hashCode(类型[] a)：基于指定数组的内容返回hashcode

(9)public static String toString(类型[] a)：返回指定数组内容的字符串表示形式。

 public class ArraysDemo {

 	/**
 	 * @param args
 	 */
 	public static void main(String[] args) {

 //		String[] arr = new String[3];
 //		swap(arr,1,2);

 //		int[] arr = {45,23,78,11,99};
 //		System.out.println(Arrays.toString(arr));

 		String[] strs = {"abc","haha","nba","zz"};

 //		boolean b = myContains(strs, "nba");
 //		System.out.println(b);

 		//发现集合中本身有这个方法。contains。
 		//将数组转成集合。就哦了，数组转成list集合，就是为了使用集合的方法操作数组中的元素。
 		List<String> list = Arrays.asList(strs);
 //		list.add("qq");//java.lang.UnsupportedOperationException//注意，不能使用集合的增删方法。不能改变长度。
 //		System.out.println(list.contains("nba"));

 		/*
 		 * 如果数组中都是引用数据类型，转成集合时，数组元素直接作为集合元素。
 		 * 如果数组中都是基本数据类型，会将数组对象作为集合中的元素。
 		 *
 		 */
 		int[] arr = {45,23,78,11,99};
 		List<int[]> list2 = Arrays.asList(arr);
 		System.out.println(list2.get(0));

 	}

 	/**
 	 *
 	 * @param arr
 	 * @param key
 	 * @return
 	 */
 	public static boolean myContains(String[] arr,String key){

 		for (int i = 0; i < arr.length; i++) {
 			String str = arr[i];

 			if(str.equals(key))
 				return true;

 		}
 		return false;

 	}

 	public static <T> void swap(T[] arr,int x,int y)
 	{
 		T temp = arr[x];
 		arr[x] = arr[y];
 		arr[y] = temp;
 	}

 }

---

 public class CollectionToArray {

 	/**
 	 * @param args
 	 */
 	public static void main(String[] args) {

 		//集合转成数组。Collection toArray

 		List<String> list = new ArrayList<String>();

 		list.add("abc");
 		list.add("haha");
 		/*
 		 * 传入的的数组长度，如果小于集合长度，方法中会创建一个新的长度和集合长度一致的数组。
 		 * 如果传入的数组长度大于等于集合长度，会使用传入的数组。所以建议长度定义为 集合的size();
 		 *
 		 *
 		 * 为什么要把集合转成数组。
 		 * 就是为了限定对元素的操作，比如增删。
 		 *
 		 */
 		String[] arr = list.toArray(new String[list.size()]);

 		System.out.println(Arrays.toString(arr));

 	}

 }

代码来自创智播客

2018-01-03