java排序简单总结和推荐使用套路（数据排序，结构体排序）

了解int和Integer的区别

• int是Java的基本数据类型，用于表示整数值。
• Integer是int的包装类，它是一个对象，可以包含一个int值并提供一些额外的功能。
  Java集合框架中的集合类（如List、Set、Map）只能存储对象，不能存储基本类型。因此，如果要在集合中存储int值，需要使用Integer对象。

举个例子，若想比较list某两个元素值是否相等，不能用==，它是比较基本类型的，要用equals

List<Integer> list = new ArrayList<>();
list.add(1);
list.add(2);
// 若想比较list某两个元素值是否相等，不能用==，它是比较基本类型的，要用equals
list.get(0) == list.get(1) // ×
list.get(0).equals(list.get(1)) // √
1
2
3
4
5
6

int与Integer的相互转换
Integer.valueOf(int) 和 int.intValue()

//简单转换
// int ---> Integer   Integer.valueOf(int)
int[] intArray = {1, 2, 3, 4, 5};
Integer[] integerArray = new Integer[intArray.length];
for (int i = 0; i < intArray.length; i++) {
    integerArray[i] = Integer.valueOf(intArray[i]);
}

// Integer ---> int   int.intValue()
Integer[] integerArray = {1, 2, 3, 4, 5};
int[] intArray = new int[integerArray.length];
for (int i = 0; i < integerArray.length; i++) {
    intArray[i] = integerArray[i].intValue();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

对普通数据排序

使用Array升序

对于基本类型int、long等的排序，Arrays.sort()只能实现升序。（默认升序）

int[] arr={5,1,3,5,4};
Arrays.sort(arr); // 升序 
1
2

使用Array降序

要实现降序，则arr必须是对象类型： Integer等
可以采用多种降序方法：Comparator、lambda、Collections等

Integer[] arr = { 5, 4, 7, 9, 2, 12, 54, 21, 1 };
Arrays.sort(arr, new Comparator<Integer>() { // Comparator降序
	public int compare(Integer o1, Integer o2) {
		return o2-o1;
	}
});
Arrays.sort(arr, (x, y) -> y - x); // lambda降序
Arrays.sort(arr, Collections.reverseOrder());  // Collections降序
1
2
3
4
5
6
7
8

使用List升序

跟Array类似，不过是采用Collections的sort进行升序。（默认升序）

List<Integer> list = new ArrayList<>();
list.add(1); 
list.add(3);
Collections.sort(list); // 升序
1
2
3
4

使用List降序

也是可以采用Comparator和lambda进行降序。

Collections.sort(list, new Comparator<Integer>() {  // Comparator降序
	public int compare(Integer o1, Integer o2) { 
		 return o2-o1; 
	}
});
Collections.sort(list, (x, y) -> y - x); // lambda降序
1
2
3
4
5
6

对结构类型变量排序

在定义结构体类时，继承Comparable即可，可自行定义各个属性的排序优先级和升降序关系。

public static class Node implements Comparable<Node> {
	int x, y;
	public Node(int x, int y) { // 构造函数
		this.x = x;
		this.y = y;
	}
	public int compareTo(Node o) {
		if (this.x == o.x) {
			return this.y - o.y; // 其次按y升序排序
		} else {
			return this.x - o.x; // 优先按x升序排序
			// o.x - this.x 降序
		}
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

使用Array排序

若是用array类型存储的结构体，直接使用Arrays.sort()，但是与排序普通数据不同，需要添加排序范围，不然会报错，形如Arrays.sort (arr, 0 , arr.length);

int len = 3;
Node[] nodes2 = new Node[len];
nodes2[0] = new Node(1, 3);
nodes2[1] = new Node(2, 2);
nodes2[2] = new Node(3, 2);
Arrays.sort(nodes2, 0, len);
for (Node n : nodes2) {
	System.out.println(n.x + " " + n.y);
}
1
2
3
4
5
6
7
8
9

使用list排序

List<Node> nodes = new ArrayList<>();
nodes.add(new Node(1,3));
nodes.add(new Node(2,2));
Collections.sort(nodes);
for (Node n : nodes) {
	System.out.println(n.x + " " + n.y);
}
1
2
3
4
5
6
7

总结

排序方法很多，在写算法时记住常用的简易的方法即可。
推荐：

• 对于普通数据：arr={1,5,6,4,3}; list=[1,5,6,4,3]
  - 用Array：升序Arrays.sort(arr) ，降序Arrays.sort(arr, (x,y) -> y-x);
  - 用List：升序Collections.sort(list) , 降序Collections.sort(list, (x, y) -> y-x);
• 对于结构体数据：
  - 定义结构体类的同时定义Comparable接口
  - 用Array: 升降序Arrays.sort (nodes, 0 , nodes.length)
  - 用List：升降序Collections.sort(nodes)