Java集合-Collections类详解

Collections则是集合类的一个工具类/帮助类，其中提供了一系列静态方法，用于对集合中元素进行排序、搜索以及线程安全等各种操作。

1.排序

Java中的Collections类中有sort方法有两种参数列表：


1) sort(List<T> list)

2) sort(List<T> list, Comparator<? super T> c)

对于第一种情况，使用元素的默认排序，比如1,5,6,2,就会排序成1,2,5,6；再如a,c,b,d就会排序成a,b,c,d。第二种方法多了一个Comparator接口作为参数，重写该接口的compare方法就相当于告诉sort方法根据什么来进行排序。

测试代码如下：


package com.trs.container;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

import com.trs.entity.Person;

public class TestCollections {
	public static void main(String[] args) {
		List<String> list1 = new ArrayList<String>();
		list1.add("ccc");
		list1.add("bbb");
		list1.add("aaa");
		list1.add("ddd");
		Collections.sort(list1);
		System.out.println(list1);
		List<Person> list2 = new ArrayList<Person>();
		list2.add(new Person(25,"Andy",9500,"Writer"));
		list2.add(new Person(27,"Rose",8500,"Saler"));
		list2.add(new Person(21,"Jack",8800,"Singer"));
		//重写Comrarator接口
		Collections.sort(list2,new Comparator<Object>(){
			@Override
			public int compare(Object o1, Object o2) {
				Person p1 = (Person)o1;
				Person p2 = (Person)o2;
				//按照薪水排序
				return p1.getSalary()-p2.getSalary()==0?0:p1.getSalary()-p2.getSalary()>0?1:-1;
			}
		});
		System.out.println(list2);
		
		Collections.sort(list2,new Comparator<Object>(){
			@Override
			public int compare(Object o1, Object o2) {
				Person p1 = (Person)o1;
				Person p2 = (Person)o2;
				//按照年龄排序
				return p1.getAge()-p2.getAge()==0?0:p1.getAge()-p2.getAge()>0?1:-1;
			}
		});
		System.out.println(list2);
		
		
	}
}

Person类：

public class Person {
	private int age;
	private String name;
	private double salary;
	private String job;
	public Person(int age, String name, double salary, String job) {
		super();
		this.age = age;
		this.name = name;
		this.salary = salary;
		this.job = job;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public double getSalary() {
		return salary;
	}
	public void setSalary(double salary) {
		this.salary = salary;
	}
	public String getJob() {
		return job;
	}
	public void setJob(String job) {
		this.job = job;
	}
	
	public String toString(){
		return "[name:"+name+",age:"+age+",job:"+job+",salary:"+salary+"]";
	}

	
}

运行结果：







二、二分法查找

(1)binarySearch(List<? extends Comparator<? super T>> list, T key)


(2)binarySearch(List<? extends T> list, T key, Comparator<? super T> c)

方法用于搜索指定列表，使用二进制搜索算法来指定对象

其中：

  list:表示要搜索的列表

  key:表示要搜索的键

注意：使用二分法查找之前必须先排序后查找，如果没有对列表进行排序，则结果是不明确的。第一种方法是使用默认的排序，第二种方法是使用自定义的比较器进行排序。

List<String> list1 = new ArrayList<String>();
list1.add("ccc");
list1.add("bbb");
list1.add("aaa");
list1.add("ddd");
Collections.sort(list1);//必须先排序，否则返回值不明确，会返回-1
int i = Collections.binarySearch(list1, "ddd");
System.out.println("i:"+i);//i:3




三、混排

(1)shuffle(List<?> list) 使用默认随机源对列表进行置换，所有置换发生的可能性都是大致相等的。


(2)shuffle<List<?> list, Random rnd) 使用指定的随机源对指定列表进行置换，所有置换发生的可能性都是大致相等的，假定随机源是公平的。


混排所做的正好与 sort 相反: 它打乱在一个 List中可能有的任何排列的踪迹。也就是说，基于随机源的输入重排该 List,这样的排列具有相同的可能性（假设随机源是公正的）。这个算法在实现一个碰运气的游戏中是非常有用的。例如，它可被用来混排代表一副牌的Card 对象的一个 List 。通俗的说，就像洗牌一样。

注意：如果给定一个整型数组，用Arrays.asList()方法将其转化为一个集合类，有两种途径：

1）用List<Integer> list=ArrayList(Arrays.asList(ia)),用shuffle()打乱不会改变底层数组的顺序。

2）用List<Integer> list=Arrays.aslist(ia),然后用shuffle()打乱会改变底层数组的顺序。代码例子如下：

import java.util.*;  
  
public class Modify {  
    public static void main(String[] args){  
        Random rand=new Random(47);  
        Integer[] ia={0,1,2,3,4,5,6,7,8,9};  
        List<Integer> list=new ArrayList<Integer>(Arrays.asList(ia));  
        System.out.println("Before shufflig: "+list);  
        Collections.shuffle(list,rand);  
        System.out.println("After shuffling: "+list);  
        System.out.println("array: "+Arrays.toString(ia));  
        List<Integer> list1=Arrays.asList(ia);  
        System.out.println("Before shuffling: "+list1);  
        Collections.shuffle(list1,rand);  
        System.out.println("After shuffling: "+list1);  
        System.out.println("array: "+Arrays.toString(ia));  
          
    }  
}  

四、反转

(1)reverse(List<?> list)

使用Reverse方法可以根据元素的自然顺序 对指定列表按降序进行排序。

List<Integer> list3 = new ArrayList<Integer>();
list3.add(1);
list3.add(4);
list3.add(2);
list3.add(8);
System.out.println(list3.toString());//1,4,2,8
Collections.reverse(list3);
System.out.println(list3.toString());//8,2,4,1