Java集合整理之集合工具类---Collections

一、集合工具类---Collections

        集合框架提供了一个工具类，Collections，此类型中封装了很多对集合操作的方法，比如排序，查询，修改等。

        想要使用排序功能，必须实现一个接口，Comparable或者Comparator接口。

二、Collections的使用

    （1）排序，sort()方法。sort()是一个静态方法，可以对指定集合进行排序，可以自定义排序规则，默认为自然排序（升序）。

List<Character> chs = new ArrayList<Character>();
//随机10个字符添加进集合中
for(int i=0;i<10;i++) {
	int num = (int)(Math.random()*26);
	chs.add((char)(num+65));
}
System.out.println(chs);
//调用工具类中的sort方法，进行自然排序(升序)
/*
 * void sort(List<T> list)
 */
Collections.sort(chs);
System.out.println(chs);

        输出结果：

        

    这只是对一些自然的元素进行排序，当集合元素是一个类时，再使用这样的方式进行排序，就得不到想要的结果了。

    创建一个Point类，提供构造器，get/set方法并重写toString()方法。

public class Point {
	private int x;
	private int y;
	
	public Point() {}
	public Point(int x, int y) {
		super();
		this.x = x;
		this.y = y;
	}
	public int getX() {
		return x;
	}
	public void setX(int x) {
		this.x = x;
	}
	public int getY() {
		return y;
	}
	public void setY(int y) {
		this.y = y;
	}
	@Override
	public String toString() {
		return "("+x+","+y+")";
	}
}

    此时如果想对类进行排序，则类必须要实现一个接口，不然编译器会报错。

    让Point类实现Comparable<T>接口，并重写comparaTo()方法。

public class Point implements Comparable<Point>{

        ......

	@Override
	public int compareTo(Point o) {
		return this.x-o.x;
	}
}

    comparaTo()方法，是排序的规则，返回值是int类型的值，作用是将类中的元素两两比较，如果当前对象的属性值-给定对象的属性值>0的话，则当前元素往后移，反之，则向前移，若相等，则不进行移动。

    在这里，是按照 x 的值进行升序排序，所以直接 return this.x-o.x; 就可以了。

    创建3个实例，添加到集合list中，并调用sort进行排序。

public static void main(String[] args) {
	Point  p1 = new Point(1,3);
	Point  p2 = new Point(5,4);
	Point  p3 = new Point(2,2);
	
	List<Point> list = new ArrayList<Point>();
	list.add(p1);
	list.add(p2);
	list.add(p3);
	
	System.out.println("排序前："+list);
	Collections.sort(list);
	System.out.println("排序后："+list);
}

        输出结果：

        

    如果想要降序排序，只需要修改comparaTo()方法的返回值为 return o.x-this.x; 即可。

@Override
public int compareTo(Point o) {
	return o.x-this.x;
}

        输出结果：

        

    使用这种方式进行排序，需要在创建类时就写好对应的方法，在大多数时候，可能只是临时使用排序功能，在这种情况下，可以使用比较器，Comparator<T>，因为只需要使用一次，所以这里用匿名内部类的形式来调用，这个接口需要重写compara()方法，排序规则和comparaTo()类似。

Collections.sort(list, new Comparator<Point>() {
	@Override
	public int compare(Point o1, Point o2) {
		return o1.getX()-o2.getX();
	}	
});

    输出一下排序前后的结果。

        输出结果：

        

    （2）反转集合，reverse()方法，反转指定集合中的元素。

    创建一个新的集合，并赋值。

List<String> list = new ArrayList<String>();
for(char i='A';i<='G';i++) {
	list.add(i+"");
}
/*
 * 如果自定义的类型作为元素添加到集合中,
 * 那么类型需要重写toString()才能正常输出元素，否则将输出元素的地址信息
 */
System.out.println(list);

        输出结果：

        

    调用reverse()方法。

/*
 * 工具类的 void reverse(List list);
 * 静态方法。
 */	
Collections.reverse(list);
System.out.println(list);

        输出结果：

        

    （3）随机排序，shuffle()方法，对集合中的元素进行随机排序(混洗)。

/*
 * shuffle(List list):
 * 对集合元素进行随机排序(混洗)
 */
Collections.shuffle(list);
System.out.println(list);

        输出结果：

        

    （4）交换元素，swap()方法，交换集合中指定索引的两个元素。

/*
 * 将第二个元素与最后一个元素进行交换
 * void swap(list,index1,index2)
 */
Collections.swap(list, 1, list.size()-1);
System.out.println(list);

        输出结果：

        

    （5）寻找最大值，max()方法，使用自然排序，找到元素中的最大值，并不会影响到原集合中的元素。

/*
 *  Object max(list):使用自然排序,找到最大值
 */
String max = Collections.max(list);
System.out.println(max);

        输出结果：

        

    （6）寻找最小值，min()方法，同max类似，找到元素中的最小值。

/*
 * 找到集合中的最小值
 * Object min(list)
 */
String min = Collections.min(list);
System.out.println(min);

        输出结果：

        

    （7）查看元素出现次数，frequency()方法，返回指定元素在集合中出现的次数。

/*
 * int frequency(list,obj);
 * 返回obj在list集合中出现的次数。
 */
int count = Collections.frequency(list, "G");
System.out.println(count);

        输出结果：

        

    （8）替换元素，replaceAll()，使用新值替换旧值。

/*
 * 使用新值替换旧值
 * boolean replaceAll(List list,Object oldVal,Object newVal)
 */
boolean flag = Collections.replaceAll(list, "G", "H");
System.out.println("flag:"+flag);
System.out.println(list);

        输出结果：