集合工具类Collections

在java中，为了更方便的操作集合，java中定义了一个集合工具类Collections，该类中封装了各种操作集合的方法，全部都是静态，也就是说可以直接类名调用

下面讲几个比较常见的方法：

1，排序(集合肯定是List类型的，因为排序需要下标)：

（1）sort(List<T> list)//T类型中必须具备比较性，即T类要实现Comparable接口，并在重写compareTo方法

//以年龄为首要条件排序
import java.util.*;
class Student implements Comparable<Student>
{
	public int age;
	public String name;
	public Student(int age,String name)
	{
		this.age=age;
		this.name=name;
	}
	public int compareTo(Student s)
	{
		if(this.age>s.age)
			return 1;
		else if(this.age<s.age)
			return -1;
		else
			return this.name.compareTo(s.name);
	}
}
class CollectionsDemo 
{
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
	public static void main(String[] args) 
	{
		ArrayList<Student> arr=new ArrayList<Student>();
		arr.add(new Student(10,"zhangsan"));
		arr.add(new Student(20,"wanwu"));
		arr.add(new Student(30,"zhangsan"));
		arr.add(new Student(10,"lisi"));
		arr.add(new Student(15,"haha"));
		Iterator<Student> it1=arr.iterator();
		while(it1.hasNext())
		{
			Student s=it1.next();
			sop(s.name+"..."+s.age);
		}
		sop("=========================");
		Collections.sort(arr);
		Iterator<Student> it2=arr.iterator();
		while(it2.hasNext())
		{
			Student s=it2.next();
			sop(s.name+"..."+s.age);
		}
	}
}

（2）sort(List<T> list ,Comparator c)//T类型可以不具备比较性，但是要传入比较器

//以年龄为首要条件排序
import java.util.*;
class MyComparator implements Comparator<Student>
{
	public int compare(Student s1,Student s2)
	{
		if(s1.age>s2.age)
			return 1;
		else if(s1.age<s2.age)
			return -1;
		else
			return s1.name.compareTo(s2.name);
	}
}
class Student
{
	public int age;
	public String name;
	public Student(int age,String name)
	{
		this.age=age;
		this.name=name;
	}
}
class CollectionsDemo 
{
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
	public static void main(String[] args) 
	{
		ArrayList<Student> arr=new ArrayList<Student>();
		arr.add(new Student(10,"zhangsan"));
		arr.add(new Student(20,"wanwu"));
		arr.add(new Student(30,"zhangsan"));
		arr.add(new Student(10,"lisi"));
		arr.add(new Student(15,"haha"));
		Iterator<Student> it1=arr.iterator();
		while(it1.hasNext())
		{
			Student s=it1.next();
			sop(s.name+"..."+s.age);
		}
		sop("=========================");
		Collections.sort(arr,new MyComparator());
		Iterator<Student> it2=arr.iterator();
		while(it2.hasNext())
		{
			Student s=it2.next();
			sop(s.name+"..."+s.age);
		}
	}
}

结果一模一样

2，获取最值

（1）max(List<T> list)//T要有比较性

（2）max(List<T> list ,Comparator c)//T可以不具备比较性，但要传入比较器

其实，max的原理就是先用sort排序，然后再取集合中的最后一个元素

3，查找元素

（1）int binarySearch(List<T> list,T t)//T要具有比较性，该方法是通过二分查找元素，返回t对象的下标，如果无此对象，返回值为-（该对象应该插入的下标）-1

（2）int binarySearch(List<T> list,T t,Comparator c)//同理，T可以不具备比较性，但要传入比较器

以第二种为例：

//以年龄为首要条件排序
import java.util.*;
class MyComparator implements Comparator<Student>
{
	public int compare(Student s1,Student s2)
	{
		if(s1.age>s2.age)
			return 1;
		else if(s1.age<s2.age)
			return -1;
		else
			return s1.name.compareTo(s2.name);
	}
}
class Student
{
	public int age;
	public String name;
	public Student(int age,String name)
	{
		this.age=age;
		this.name=name;
	}
}
class CollectionsDemo 
{
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
	public static void main(String[] args) 
	{
		ArrayList<Student> arr=new ArrayList<Student>();
		Student t1=new Student(10,"zhangsan");
		Student t2=new Student(20,"wanwu");
		Student t3=new Student(30,"zhangsan");
		Student t4=new Student(15,"heh");//注意，集合并没有加入t4
		arr.add(t1);
		arr.add(t2);
		arr.add(t3);
		Iterator<Student> it1=arr.iterator();
		while(it1.hasNext())
		{
			Student s=it1.next();
			sop(s.name+"..."+s.age);
		}
		sop("=========================");
		Collections.sort(arr,new MyComparator());
		Iterator<Student> it2=arr.iterator();
		while(it2.hasNext())
		{
			Student s=it2.next();
			sop(s.name+"..."+s.age);
		}
		sop("t1's index = "+Collections.binarySearch(arr,t1,new MyComparator()));
		sop("t4's index = "+Collections.binarySearch(arr,t4,new MyComparator()));
	}
}

注意t4，t4如果要加入集合，那么它下标就为1，所以返回值为-1-1=-2

4，替换

（1）fill(List<T> list,T t)//把集合中所有元素替换成t

（2）replaceAll(List<T> list,T old,T new)//吧集合中所有的old对象替换成new对象

（3）swap(List<T> list,int i,int j)//把下标为i的元素和下标为j的元素位置调换

5，反转

（1）reverse(List<T> list)//把集合中的元素顺序反转

（2）reverseOrder(Comparator c)//返回一个比较器，其效果正好与传入的比较器相反

6，关于多线程的安全

（1）synchronizedList(List<T> list)//使传入的list集合变为线程同步

（1）synchronizedMap(Map<T> map)//使传入的map集合变为线程同步

（1）synchronizedSet(Set<T> set)//使传入的set集合变为线程同步