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):返回指定数组内容的字符串表示形式。

  1 public class ArraysDemo {
  2 
  3 	/**
  4 	 * @param args
  5 	 */
  6 	public static void main(String[] args) {
  7 
  8 //		String[] arr = new String[3];
  9 //		swap(arr,1,2);
 10 
 11 //		int[] arr = {45,23,78,11,99};		
 12 //		System.out.println(Arrays.toString(arr));
 13 
 14 
 15 
 16 		String[] strs = {"abc","haha","nba","zz"};
 17 
 18 //		boolean b = myContains(strs, "nba");
 19 //		System.out.println(b);
 20 
 21 
 22 		//发现集合中本身有这个方法。contains。
 23 		//将数组转成集合。就哦了,数组转成list集合,就是为了使用集合的方法操作数组中的元素。
 24 		List<String> list = Arrays.asList(strs);
 25 //		list.add("qq");//java.lang.UnsupportedOperationException//注意,不能使用集合的增删方法。不能改变长度。
 26 //		System.out.println(list.contains("nba"));
 27 
 28 
 29 		/*
 30 		 * 如果数组中都是引用数据类型,转成集合时,数组元素直接作为集合元素。
 31 		 * 如果数组中都是基本数据类型,会将数组对象作为集合中的元素。
 32 		 *
 33 		 */
 34 		int[] arr = {45,23,78,11,99};
 35 		List<int[]> list2 = Arrays.asList(arr);
 36 		System.out.println(list2.get(0));
 37 
 38 	}
 39 
 40 	/**
 41 	 *
 42 	 * @param arr
 43 	 * @param key
 44 	 * @return
 45 	 */
 46 	public static boolean myContains(String[] arr,String key){
 47 
 48 		for (int i = 0; i < arr.length; i++) {
 49 			String str = arr[i];
 50 
 51 			if(str.equals(key))
 52 				return true;
 53 
 54 		}
 55 		return false;
 56 
 57 	}
 58 
 59 	public static <T> void swap(T[] arr,int x,int y)
 60 	{
 61 		T temp = arr[x];
 62 		arr[x] = arr[y];
 63 		arr[y] = temp;
 64 	}
 65 
 66 }

  1 public class CollectionToArray {
  2 
  3 	/**
  4 	 * @param args
  5 	 */
  6 	public static void main(String[] args) {
  7 
  8 		//集合转成数组。Collection toArray
  9 
 10 
 11 		List<String> list = new ArrayList<String>();
 12 
 13 		list.add("abc");
 14 		list.add("haha");
 15 		/*
 16 		 * 传入的的数组长度,如果小于集合长度,方法中会创建一个新的长度和集合长度一致的数组。
 17 		 * 如果传入的数组长度大于等于集合长度,会使用传入的数组。所以建议长度定义为 集合的size();
 18 		 *
 19 		 *
 20 		 * 为什么要把集合转成数组。
 21 		 * 就是为了限定对元素的操作,比如增删。
 22 		 *
 23 		 */
 24 		String[] arr = list.toArray(new String[list.size()]);
 25 
 26 		System.out.println(Arrays.toString(arr));
 27 
 28 	}
 29 
 30 }

 

代码来自创智播客

2018-01-03

 

posted @ 2018-01-03 22:27 朱卫恒 阅读(...) 评论(...) 编辑 收藏