JAVA中对集合排序_java 一个集合按照另外一个集合顺序

JAVA中对集合排序

1.集合排序的基本概念

集合排序，它可以使用集合的工具类java.util.Collections

其定义了很多静态方法，用于操作集合，其中sort方法是对list集合进行自然排序（从小到大）。

public class Collections_sort {
	public static void main(String[] args) {
		//随机生成生成10个100内的整数存储在list集合中
		List<Integer> list=new ArrayList<Integer>();
		for(int i=0;i<10;i++){
			int a=(int)(Math.random()*100);
			list.add(a);
		}
		System.out.println(list);
		
		//进行集合排序
		Collections.sort(list);
		System.out.println("排序后的"+list);
	}

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

执行结果：

[25, 41, 87, 9, 33, 43, 94, 78, 92, 32]
排序后的[9, 25, 32, 33, 41, 43, 78, 87, 92, 94]

2.对对象进行排序

sort方法要求集合元素必须实现Comparable接口，
Collections的sort方法具有侵入性，所谓侵入性是指当我们使用某个功能时，该功能要求我们修改代码，修改的越多侵入性越强，一旦不需要该功能，这个改动就没有意思了，在实际并发中是不推荐使用的。

1.首先对自定义的类实现comparable接口

实现comparable接口，要求必须重写该方法，那么他的意思是定义当前对象与参数。

• 对象的大小关系：
• 返回值不关注当前的取值，只关注取值的范围
• 当返回值>0，当前对象this大于参数对象
• 当返回值<0，当前对象this小于参数对象
• 当返回值=0，当前对象this等于参数对象

public class Pointer implements Comparable<Pointer>{
	private int x;
	private int 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 "Pointer [x=" + x + ", y=" + y + "]";
	}
	public Pointer(int x, int y) {
		super();
		this.x = x;
		this.y = y;
	}
	
	public int compareTo(Pointer o) {
		int len=this.x*this.x+this.y*this.y;
		int olen=o.x*o.x+o.y*o.y;
		return len-olen;
	}
	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + x;
		result = prime * result + y;
		return result;
	}
	
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Pointer other = (Pointer) obj;
		if (x != other.x)
			return false;
		if (y != other.y)
			return false;
		return true;
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54

2.对Pointer对象进行排序

public class Collections_sort2 {
	public static void main(String[] args) {
		List<Pointer> list=new ArrayList<Pointer>();
		list.add(new Pointer(2,3));
		list.add(new Pointer(1,4));
		list.add(new Pointer(0,5));
		list.add(new Pointer(8,9));
		list.add(new Pointer(7,6));
		list.add(new Pointer(1,5));
		list.add(new Pointer(6,8));
		System.out.println(list);

		Collections.sort(list);
		
		System.out.println("排序后的list为"+list);
		
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

执行结果：

[Pointer [x=2, y=3], Pointer [x=1, y=4], Pointer [x=0, y=5], Pointer [x=8, y=9], Pointer [x=7, y=6], Pointer [x=1, y=5], Pointer [x=6, y=8]]
排序后的list为[Pointer [x=2, y=3], Pointer [x=1, y=4], Pointer [x=0, y=5], Pointer [x=1, y=5], Pointer [x=7, y=6], Pointer [x=6, y=8], Pointer [x=8, y=9]]

结果分析：

对对象的排序后的顺序取决于自定义类重写后compareTo(Pointer o)方法，我们可以按照自己的意愿对这个比较方法自行定义，缺点就是侵入性强。

3.比较器

推荐的集合排序方式： 当遇到排序自定义类型元素或者集合元素自身的比较规则不满足时都建议使用下面的方式排序，该sort方法要求额外传来一个比较器，并按照比较器规则比较集合元素并进行排序，因此该排序方法不要求集合元素实现comparable接口。

public class Collections_sort3 {
	public static void main(String[] args) {
		List<String> list=new ArrayList<String>();
		list.add("小马");
		list.add("小超超");
		list.add("小陈泽与");
		list.add("沃德四级啊");
		
		
Comparator<String> cp=new Comparator<String>() {
			
		public int compare(String o1, String o2) {
				int a=o1.length();
				int b=o2.length();
				return a-b;
			}
		};
		Collections.sort(list, cp);
		System.out.println("排序后的结果："+list);
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

执行结果：

排序后的结果：[小马, 小超超, 小陈泽与, 沃德四级啊]

结果分析：

比较器使用更加简便，不用实现comparable接口，更能满足使用者的需求。

4.利用比较器对对象排序

public class Collections_sort4 {
	public static void main(String[] args) {
		List<Pointer> list=new ArrayList<Pointer>();
		list.add(new Pointer(2,3));
		list.add(new Pointer(1,4));
		list.add(new Pointer(0,5));
		list.add(new Pointer(8,9));
		list.add(new Pointer(7,6));
		list.add(new Pointer(1,5));
		list.add(new Pointer(6,8));
		
		//使用Comparator比较器对集合排序
		Comparator<Pointer> oop=new Comparator<Pointer>() {
			public int compare(Pointer o1, Pointer o2) {
				int a=o1.getX()+o1.getY();
				int b=o2.getX()+o2.getY();
				return a-b;
			}
		};
		Collections.sort(list, oop);
		System.out.println("排序后的list是"+list);
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

执行结果：

排序后的list是[Pointer [x=2, y=3], Pointer [x=1, y=4], Pointer [x=0, y=5], Pointer [x=1, y=5], Pointer [x=7, y=6], Pointer [x=6, y=8], Pointer [x=8, y=9]]