黑马程序员 Java基础<八>---> 集合-工具类

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

第一节  Util 工具类

工具类的Collections和Arrays中的方法全是静态的，下面主要总结几个比较重要的方法。
一、Collections工具类：
在Collections工具类中很多方法是用于对List集合进行操作的，如比较，查找，随机排序等等
1、集合的各种方法：

1）查找：

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

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

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

2）替换：

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

      boolean replaceAll(List<T> lsit,T oldVal,T newVal)     --->   使用newVal替换list集合中的oldVal值

3）排序：

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

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

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

4）反转

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

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

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

示例：

	......
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
	//定义比较器
	class StrLenCom implements Comparator<String>
	{
		public int compare(String s1,String s2)
		{
			int n = new Integer(s1.length()).compareTo(new Integer(s2.length()));
			if (n == 0)
				return s1.compareTo(s2);
			return n;
		}
	}
	......
		List<String> list = new ArrayList<String>();
		list.add("abd");
		list.add("cd");
		list.add("f");
		list.add("yyyy");
		list.add("abd");
		//打印原集合
		sop(list);
		sop("--------------排序-------------------");
		//随机排序：
		Collections.shuffle(list);
		sop("随机排序：" + list);
		//对元素排序，存入的对象必须具备比较性
		Collections.sort(list);
		//打印新集合
		sop("自然排序后的集合元素：" + list);
		//按指定比较器顺序排序
		Collections.sort(list,new StrLenCom());
		sop("长度排序：" + list);
		sop("------------获取最大元素-----------------");
		//获取最大元素
		String max = Collections.max(list);
		sop("max = " + max);
		sop("--------------查找--------------------");
		int index = Collections.binarySearch(list,"acd");
		sop("二分法查找值:" + index);
		int ex = half(list,"acd");
		sop("二分法查找值:" + ex);
		Collections.sort(list,new StrLenCom());
		sop("排序后的集合元素：" + list);
		int x = half2(list,"acd",new StrLenCom());
		sop("二分法查找值:" + x);
		sop("---------------替换-反转----------------");
		//反转
		Collections.reverse(list);
		sop("反转后：" + list);
		//替换
		Collections.fill(list,"pp");
		sop("替换后:" + list);
	......

创建部分替换方法：

	//替换部分字符
	public static void fillPart(List<String> list,int start,int end,String str)
	{
		List<String> li = new ArrayList<String>();
		for(int i=start;i<end;i++)
		{
			li.add(list.get(i));
			list.remove(list.get(i));
		}
		sop(list);
		Collections.fill(li,str);
		list.addAll(start,li);
	}
}

二、Arrays工具类：

1、Lsit<T> asList(T... a)    --->    将数组转换为集合

注意：将数组转换成集合，不可使用集合的增删方法，因为数组的长度是固定的，如果进行增删操作，则会产生UnsupportedOperationException的编译异常。

a.如果数组中的元素都是对象，则变成集合时，数组中的元素就直接转为集合中的元素

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

2、binarySearch()：查找方法，fill()：替换方法，sort()：排序方法等

特点：可对数组元素进行相应操作，可以接受除boolean之外的其他各种基本数据类型及有序的引用类型数组的参数，且还可以对指定元素的范围，并可根据指定比较器进行相应的操作

如：sort(T[] a,Comparator<? super T> c) 

        fill(int[]a,int from,int to)等

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

4、集合转为数组

      void toString(String[] s)  --->  将集合转为指定数组s，并可通过Arrays.toString(s)获取数组s中的元素

1）指定类型的数组定义的长度：

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

b.当指定类型的数组长度大于了集合的size，就不会创建数组，而是使用传递进来的数组，并且多出的元素的值为null

2）为何将集合转为数组：为了限定对集合中元素的操作，如增删，因为想对创建的集合不做增删方面的操作。

示例：

	......
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
	......
	int[] arr = {5,8,6};
	sop("toString : int[]转为集合：" + Arrays.toString(arr));
	
	String[] sarr = {"ac","eg","nse","gui"};
	List<String> list = Arrays.asList(sarr);
	sop("asList--String对象数组转集合：" + list);

	List<int[]> li = Arrays.asList(arr);
	sop("asList--int[]转集合:" + li);
	Integer[] iarr = {5,8,6};
	List<Integer> lis = Arrays.asList(iarr);
	sop("asList--Integer[]转集合:" + lis);
	......

集合转数组：

		ArrayList<String> as = new ArrayList<String>();
		as.add("01");
		as.add("02");
		as.add("03");
		sop("原集合" + as);
		String[] s = new String[as.size()];
		as.toArray(s);
		sop("新数组" + Arrays.toString(s));

第二节  小知识点

一、增强for循环

1、格式：

      for(数据类型 变量名 : 被遍历的集合（Collection）或数组){执行语句}

2、说明：

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

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

3、传统for循环和增强for循环区别：

      增强for循环有局限性。必须有被遍历的目标；而传统for循环有索引。所以建议在遍历数组时，使用传统for循环。

示例：

import java.util.*;
class ForEachDemo
{
	//打印方法
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}

	//测试
	public static void main(String[] args) 
	{
		//创建集合
		ArrayList<String> as = new ArrayList<String>();
		as.add("01-a");
		as.add("02-b");
		as.add("03-c");
		System.out.println("原集合" + as);
		//增强for循环取出元素
		for (String s : as)
		{
			System.out.println(s);
		}
		System.out.println("-------------------------");
		//创建HashMap集合
		HashMap<Integer,String> hm = new HashMap<Integer,String>();
		hm.put(1,"a");
		hm.put(2,"b");
		hm.put(3,"c");
		hm.put(4,"d");
		System.out.println("hm原集合：" + hm);
		//增强for循环的两种方式测试
		//keySet方法
		sop("keySet方法:|--");
		for(Integer i : hm.keySet())
		{
			sop(i + ":-" + hm.get(i));			
		}
		//entrySet方法
		sop("entrySet方法--");
		for(Map.Entry<Integer,String> me : hm.entrySet())
		{
			sop(me.getKey() + "-->" + me.getValue());
		}
	}
}

二、可变参数：

如果在参数列表中传入多个参数，个数不确定，每次都要复写该方法，可变参数的出现就可以省去复写的麻烦，而直接对数组进行操作

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

示例：

	......
	//1.5版本前写法
	public static void show(int a,int b)
	{
		System.out.println(a + " :" + b);
	}
	//1.5新特性，可加入更多的值
	public static void show(int... arr)
	{
		System.out.println(arr.length);//结果为数组arr的长度
		System.out.println(arr);//arr的地址值
	}
	public static void print(String... s)
	{
		//遍历字符串数组s
		for(String str : s)
		{
			System.out.print(str);
		}
		System.out.println();
	}
	
	......

三、静态导入：

        静态导入，是将类中的所有静态成员导入进来，但需要注意的是，当导入的两个类中有同名成员时，需要在成员前加上相应的类名。

        当类名重名时，需要制定具体的包名；当方法名重名时，制定具体所属的对象或类。

1、import static java.util.Arrays.*;       ---> 写入的是Arrays类中的所有静态成员。

2、import static java.lang.System.*;  ---> 导入了System类中的所有静态成员

import java.util.*;
import static java.util.Arrays.*;//导入的是Arrays类中的所有静态成员
import static java.lang.System.*;//导入的是System类中的所有静态成员
class Demo
{
	public static void main(String [] args)
	{
		int[] arr = {2,7,6,3};
		sort(arr);
		out.println(Arrays.toString(arr));//此处不可省略Arrays，原因见下

	}
}