黑马程序员————Java基础之集合框架工具类

-----------android培训、java培训、java学习型技术博客、期待与您交流！------------ 

Collections

Collections:

集合框架工具类。里面定义的都是静态方法。大部分方法都是都是用于对List集合的操作，如查找，比较等。

常用方法：

1、查找

        Tmax(Collection<? extends T> coll);根据集合的自然顺序，获取coll集合中的最大元素

        Tmax(Collection<? extends T> coll,Comparator<? super T> comp);根据指定比较器comp的顺序，获取coll集合中的最大元素

        intbinarySearch(Lsit<? extends Comparable<? super T>> list,Tkey);二分法搜索list集合中的指定对象

2、替换

        voidfill(List<? super T> list, T obj);将list集合中的全部元素替换成指定对象obj

        booleanreplaceAll(List<T> lsit,T oldVal,T newVal);用newVal替换集合中的oldVal值

        void swap(Listlist,int i,int j);在指定列表的指定位置处交换元素

3排序：

        void shuffle(List<?> list);使用默认随机源对list集合中的元素进行随机排序

        void sort(Lsit<T> list);根据自然顺序对list集合中的元素进行排序

        voidsort(List<T> lsit,Comparator<? super T> c);根据指定比较器c的排序方式对list集合进行排序

4、反转

        reverse(List<?> list);反转list集合中元素的顺序

        Comparator reverseOrder();返回一个比较器，强行逆转了实现Comparable接口的对象的自然顺序

        ComparatorreverseOrder(Comparator<T> cmp);返回一个比较器，强行逆转了指定比较器的顺序

5、同步的集合

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

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

与Collection的区别：

.Collection是java.util下的集合接口，是集合类的上级接口。Collection提供了对集合对象，进行基本操作的通用接口方法，它在Java类库中有很多具体的实现。

 Collection的意义在于为各种具体的集合提供最大化的统一操作方式。Collections是一个包装类，有关于集合操作的一系列静态方法，实现对各类集合的搜索，排序，线程安全化等操作。

Arrays

Arrays：

用于操作数组的工具类；里面都是静态方法。可以通过asList方法把数组变成List集合。

把数组变成list集合有什么好处？

可以使用集合的思想和方法来操作数组中的元素。

常用方法：

1：Lsit<T> asList(T... a);将数组转换为集合。

注意：将数组变成集合，不可以使用集合的增删方法。 因为数组的长度是固定。

如果数组中的元素都是对象。那么变成集合时，数组中的元素就直接转成集合中的元素。

如果数组中的元素都是基本数据类型，那么会将该数组作为集合中的元素存在。

2： boolean equals()：比较两个数组是否相同。

3： String toString()：可以接收各种数组类型参数，并返回指定数组内容的字符串表现形式。

下面通过一段代码演示以下Arrays常见方法的使用：

import java.util.*;
class  ArraysDemo
{
	public static void main(String[] args) 
	{
		int[] arr = {2,4,5};

	    System.out.println(Arrays.toString(arr));//数组转换成字符串输出

		String[] arr = {"abc","cc","kkkk"};
		
		List<String> list = Arrays.asList(arr);//把arr数组转换成List集合
		sop("contains:"+list.contains("cc"));//利用List集合的方法判断cc这个元素是否存在

	}

	
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}

}

集合变数组：

Collection接口中的toArray方法可以把集合转换成数组。

1,指定类型的数组到底要定义多长呢？

  当指定类型的数组长度小于了集合的size，那么该方法内部会创建一个新的数组。长度为集合的size。

  当指定类型的数组长度大于了集合的size，就不会新创建了数组。而是使用传递进来的数组。所以创建一个刚刚好的数组最优。
  

  2,为什么要将集合变数组？

  为了限定对元素的操作。不需要进行增删了。

 例如以下代码：

import java.util.*;
class  CollectionToArray
{
	public static void main(String[] args) 
	{
		ArrayList<String> al = new ArrayList<String>();

		al.add("abc1");
		al.add("abc2");
		al.add("abc3");
		
		String[] arr = al.toArray(new String[al.size()]);

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

高级For循环：

格式：for(数据类型 变量名  :   被遍历的Collection集合或数组)

对集合进行遍历。只能获取集合元素。但是不能对集合进行操作。

迭代器除了遍历，还可以进行remove集合中元素的动作。如果是用ListIterator，还可以在遍历过程中对集合进行增删改查的动作。

传统for和高级for有什么区别呢？

高级for有一个局限性。必须有被遍历的目标。

建议在遍历数组的时候，还是希望是用传统for。因为传统for可以定义脚标。

下面用一段代码演示一下高级for的运用：

import java.util.*;

class ForEachDemo 
{
	public static void main(String[] args) 
	{		
		ArrayList<String> al = new ArrayList<String>();

		al.add("abc1");
		al.add("abc2");
		al.add("abc3");

		for(String s : al)
		{
			System.out.println(s);
		}

		int[] arr = {3,5,1};

		for(int x=0; x<arr.length; x++)
		{
			System.out.println(arr[x]);
		}
		for(int i : arr)
		{
			System.out.println("i:"+i);
		}

		HashMap<Integer,String> hm = new HashMap<Integer,String>();

		hm.put(1,"a");
		hm.put(2,"b");
		hm.put(3,"c");

		Set<Integer> keySet = hm.keySet();

		for(Integer i : keySet)
		{
			System.out.println(i+"::"+hm.get(i));
		}

		for(Map.Entry<Integer,String> me : hm.entrySet())
		{
			System.out.println(me.getKey()+"------"+me.getValue());
		}

	}
}

JDK1.5性特性：可变参数

可变参数。其实就是上一种数组参数的简写形式。不用每一次都手动的建立数组对象。 只要将要操作的元素作为参数传递即可。 隐式将这些参数封装成了数组。

什么时候定义可变参数呢？

如果定义一个方法在参数列表中传入多个参数，但是参数个数不确定，那么每次都要复写该方法。这时可以用数组作为形式参数。但是在传入时，每次都需要定义一个数组对象，作为实际参数。这时，就可以在定义方法时把参数定义成可变参数。

注意：可变参数一定要定义在参数列表最后面。

下面用一段代码演示一下可变参数的运用：

class  A
{
	public static void main(String[] args) 
	{
		int[] arr = {3,4};
		int[] arr1 = {2,3,4,5};
		
		show("haha",arr);
		show("haha",arr1);
	}
	public static void show(String str,int... arr)
	{
		System.out.println(arr.length);
	}
}

静态导入：

    格式：例如Arrays类

               import static  Array.*；导入了Arrays这个类中所有的静态成员。

   导入时没加static导入的是类，加上static导入的全是某一个类中所以的静态成员。这样写在调用该类的静态方法时可以不用再写类名。

   例如：Arrays.sort(数组);就可以直接写sort(数组);

   当类名重名时，需要指定具体的包名。

   当方法重名是，指定具备所属的对象或者类。

下面用一段代码演示一下可变参数的运用：

import java.util.*;
import static  java.util.Arrays.*;//导入的是Arrays这个类中的所有静态成员。
import static java.util.Collections.*;
import static  java.lang.System.*;//导入了System类中所有静态成员。

class  StaticImport 
{
	public static void main(String[] args) 
	{

		out.println("haha");
		int[] arr = {3,1,5};

		sort(arr);
		int index = binarySearch(arr,1);
		out.println(Arrays.toString(arr));
		System.out.println("Index="+index);

		ArrayList al = new ArrayList();
		al.add(1);
		al.add(3);
		al.add(2);

		out.println(al);

		sort(al);
		out.println(al);
	}
}