黑马程序员java基础之集合工具类

------- android培训、java培训、期待与您交流！ ----------

集合中的两个工具类Collections和Arrays，是对集合进行操作的CC

Collections的方法：

sort(List list)方法可以对List集合进行自然排序，

sort(List list ,Comparator com)方法可以按照自己定义的比较器进行排序

max(List list)方法获取最大值

binarySearch(List list，key)方法使用二分法查找指定元素，当该元素不存在集合中时，返回:(-插入点-1);注意此方法需要集合有序

fill(List list，key)方法将集合中所有元素替换成指定元素

replaceAll(List list,oldkey,newkey)方法将某一元素置换成另一元素

reverse(List list) 方法将集合元素反转

reverseOrder()方法返回一个比较器，强行逆转实现了comparable接口的对象，还可以传入一个比较器，强行逆转排序

shuffle(List)方法对集合中的元素重新进行随机排序

import java.util.*;
class CollectionsDemo
{
	public static void main(String[] args)
	{
		replaceDemo();
	}

	public static void binarySearchDemo()
	{
		List<String> list=new ArrayList<String>();	//新建一个List集合
		
		//向集合中添加元素
		list.add("abcd");
		list.add("aaa");
		list.add("z");
		list.add("kkkkk");
		list.add("qq");

		Collections.sort(list);		//使用sort方法，对集合进行自然排序
		System.out.println(list);

		//int index=Collections.binarySearch(list,"e");	//获取指定键的索引位置
		int index=BinarySearch(list,"aaaa");	//调用自定义binarySearch()方法
		System.out.println(index);
	
	}
	public static void replaceDemo()
	{
		List<String> list=new ArrayList<String>();	//新建一个List集合
		
		//向集合中添加元素
		list.add("abcd");
		list.add("aaa");
		list.add("z");
		list.add("kkkkk");
		list.add("qq");
		
		System.out.println(list);
		Collections.replaceAll(list,"aaa","bbb");	//将集合中原来的某个元素替换
		System.out.println(list);

		Collections.reverse(list);	//反转集合中的元素
		System.out.println(list);
	}
	public static void fillDemo()
	{
		List<String> list=new ArrayList<String>();	//新建一个List集合
		
		//向集合中添加元素
		list.add("abcd");
		list.add("aaa");
		list.add("z");
		list.add("kkkkk");
		list.add("qq");
		
		System.out.println(list);
		Collections.fill(list,"bbb");	//将集合中所有元素替换成“bbb”
		System.out.println(list);
	}
	public static int BinarySearch(List<String> list,String key)	//binarySearch的原理
	{
		int max,min,mid;
		max=list.size()-1;
		min=0;
		while(min<=max)
		{
			mid=(max+min) >>1;	//右移一位相当于:/2
		
			String t=list.get(mid);	//获取mid角标位的集合中的值
			int num=t.compareTo(key);	//将中间角标位的值与要查找的值比较
		
			if(num>0)
				max=mid-1;
			else if(num<0)
				min=mid+1;
			else
				return mid;
		}
		return -min-1;
	}
	public static void maxDemo()	//获取最大值方法
	{
		List<String> list=new ArrayList<String>();	//新建一个List集合
		
		//向集合中添加元素
		list.add("abcd");
		list.add("aaa");
		list.add("z");
		list.add("kkkkk");
		list.add("qq");

		Collections.sort(list);		//使用sort方法，对集合进行自然排序
		System.out.println(list);

		String max=Collections.max(list);	//使用Collections中的获取最大值方法
		System.out.println(max);
		
	}
	public static void sortDemo()	//sort排序方法
	{
		List<String> list=new ArrayList<String>();	//新建一个List集合
		
		//向集合中添加元素
		list.add("abcd");
		list.add("aaa");
		list.add("z");
		list.add("kkkkk");
		list.add("qq");

		System.out.println(list);

		//Collections.sort(list);		//使用sort方法，对集合进行自然排序

		String max=Collections.max(list);	//使用Collections中的获取最大值方法
		System.out.println(max);
		
		Collections.sort(list,new StrLenComparator());		//传入比较器，使用sort方法，按照比较器指定的方法进行排序
		System.out.println(list);
	}
}

class StrLenComparator implements Comparator<String>
{
	public int compare(String s1,String s2)
	{
		if(s1.length()>s2.length())
			return 1;
		if(s1.length()<s2.length())
			return -1;
		return s1.compareTo(s2);
		
	}
}

替换和反转功能执行结果：

import java.util.*;
class CollectionsDemo2
{
	public static void main(String[] args)
	{
		shuffleDemo();
	}
	public static void orderDemo()
	{
		TreeSet<String> ts=new TreeSet<String>(Collections.reverseOrder(new StrComparator()));	//新建一个集合，使用reverOrder()强行逆转原来的比较器，逆向排序
		
		//添加元素
		ts.add("abcd");
		ts.add("eft");
		ts.add("adkg");
		ts.add("s");

		Iterator<String> it=ts.iterator();	//使用迭代器，遍历集合中元素
		while(it.hasNext())
		{
			System.out.println(it.next());
		}
	}

	public static void shuffleDemo()
	{
		List<String> list=new ArrayList<String>();	//新建一个集合
		
		//添加元素
		list.add("abcd");
		list.add("eft");
		list.add("adkg");
		list.add("s");

		System.out.println(list);
		Collections.shuffle(list);	//该方法可以将集合中元素随机排序
		System.out.println(list);
	}
}

class StrComparator implements Comparator<String>	//构造字符串比较器
{
	public int compare(String s1,String s2)
	{
		return s1.compareTo(s2);	//使用String类的compareTo比较方法
	}
}

shuffle方法对集合元素随机排序执行结果：

Arrays:用于操作数组的工具类，里面都是静态方法

asList(arr)方法将数组变成list集合

将数组变成集合的好处：可以使用集合的方法操作数组中的元素；contains(),IndexOf();subList()

import java.util.*;
class ArraysDemo
{
	public static void main(String[] args)
	{
		Integer[] arr={2,3,4};
		List list=Arrays.asList(arr);	//将数组转为集合中的元素
		System.out.println(list);	
		/*
		String[] arr={"abc","ade","bd","cc","kkk"};
		List<String> list=Arrays.asList(arr);	//将数组转为List集合

		list.add("dgsad");
		System.out.println(list);
		System.out.println(list.contains("cc"));	//判断元素是否存在
		*/
	}
}

注意：不能使用集合的增删方法，因为数组的长度固定。如果进行增删，会发生UnsupportedOperationException异常

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

将集合变数组，使用Collection集合中的toArray方法

·· 当指定类型的数组长度小于集合的长度，那么该方法内部会自动创建一个新的数组，长度为集合长度，当数组长度大于集合长度，就不会新建数组，使用传进来的数组，没有有效元素的位置会返回null

import java.util.*;

class toArray
{
   public static void main(String[] args)
   {
      ArrayList<String> al=new ArrayList<String>();	//构造一个集合
	
	//添加元素
      al.add("java1");
      al.add("java2");
      al.add("java3");
     String[] arr=new String[al.size()];	//创建一个数组，长度为集合的长度

     String[] str= al.toArray(arr);	//将集合转为数组

     System.out.println(Arrays.toString(str));	//返回数组元素的字符串打印
    }
}

将集合变数组的好处：限定对元素的操作，不需要进行增删了

增强for循环

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

import java.util.*;
class ForEachDemo
{
   public static void main(String[] args)
   {
      ArrayList<String> al=new  ArrayList<String>();	//新建数组
	//添加元素
       al.add("ndibnih");
       al.add("ndiih");
       al.add("nih");

      for(String s:al)
      {
	s="kkk";
          
       }

	System.out.println(al);
   }
}

发现在循环内修改元素无效，所以高级for循环只能获取集合中的元素，不能对集合进行操作

而迭代器除了可以遍历元素，还可以remove()集合中的元素；如果是ListLiterator，还可以对集合进行增删改查的操作

传统for和高级for循环的区别：高级for循环必须有被遍历的目标

可变参数：实际上就是数组参数的间歇形式，不用每一次都手动建立数组对象，隐示将参数封装为数组

import java.util.*;
class ParamMethodDemo
{
	public static void main(String[] args)
	{
		show(2,4,6,6);
		show(1,3);		
	}
	
	public static void show(int... arr)<span style="white-space:pre">	</span>//注意可变参数的形式
	{
		System.out.println(arr.length);
	}
}

打印结果”

注意：使用可变参数一定要定义在参数列表最后面,如上面的例子show(String str,int...arr)

静态导入

import java.util.*;
import static java.util.Arrays.*;	//导入Arrays中所有的静态成员

import static java.lang.System.*;	//导入Systm中所有静态成员
class StaticImport 
{
	public static void main(String[] args)
	{
		int[] arr={3,2,5};
		
		sort(arr);	//原型是Arrays.sort(arr),静态导入后就可以省略Arrays.

		int index=binarySearch(arr,2);	//此处也是调用Arrays的二分查找法，省略了Arrays.

		System.out.println(Arrays.toString(arr));	//此处是为了表明用的是Arrays的toString方法，所以不能省略
		out.println(index);	//已静态导入，不用再写System.
	}
}

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