1.Arrays和List中sort方法的区别
Arrays和List都有sort方法，首先说他们两个的区别，从包名就可以看出来，一个是针对数组的，一个是针对List集合的。其中，List集合的实现类所有实现类：AbstractList，AbstractSequentialList，ArrayList，AttributeList，CopyOnWriteArrayList，LinkedList，RoleList，RoleUnresolvedList，Stack，Vector
1.Arrays中sort方法的用法
我们从数据手册中可以看到，sort()方法大致可以分为三类
1、基本类型排序
- Arrays.sort(int[] a)
- Arrays.sort(int[] a, int fromIndex, int toIndex)
这个包括byte、char、double、float、int、long和short，这些基本类型，只能按照从小到大的排序顺序，从大到小排序需要通过泛型排序，并且要求数组是包装类型
是包装类。
也可以对指定范围内的部分数组排序，也就是对数组a的下标从fromIndex到toIndex-1的元素排序，注意：下标为toIndex的元素不参与排序！
例如:
1
2
3
4
5
6
7
8
9
10
11
12
| import java.util.Arrays;
public class SortTest {
public static void main(String[] args) {
int[] arr = {1,4,6,8,5,5,7,8,9,6,4,4,33};
Arrays.sort(arr);
for (int i : arr) {
System.out.print(i+",");
}
}
}
|
2、包装类类型排序
- Arrays.sort(Object[] a)
- Arrays.sort(Object[] a, int fromIndex, int toIndex)
这个Object包括了Byte、Character、Double、Float、Integer、Long和Short，这些包装类，按照从小到大的排序顺序，并且容许自定义Object类排序，但这个要指定排序顺序。
1
2
3
4
5
6
7
8
9
10
11
| import java.util.Arrays;
public class SortTest {
public static void main(String[] args) {
Integer[] arr = {1,4,6,8,5,5,7,8,9,6,4,4,33};
Arrays.sort(arr);
for (int i : arr) {
System.out.print(i+",");
}
}
}
|
3、泛型排序
- static void sort(T[] a, Comparator<? super T> c)
- public static void sort(T[] a,int fromIndex, int toIndex, Comparator<? super T> c)
注意，上面1和2中排列顺序只能是从小到大，并且可以是包装类，也可以是基本类型，但是，如果要自定义排序规则，比如从大到小，就要使用这种方式，这种方式只能放入包装类型。
1
2
3
4
5
6
7
8
9
10
11
12
| import java.util.Arrays;
public class SortTest {
public static void main(String[] args) {
Integer[] arr = {1,4,6,8,5,5,7,8,9,6,4,4,33};
Arrays.sort(arr,(o1,o2)->o2-o1);
for (int i : arr) {
System.out.print(i+",");
}
}
}
|
2.List中sort方法的用法
我们可以看到，List的sort方法和Arrays第三种泛型排序是一样的，自定义Comparator比较器
1
2
3
4
5
6
7
8
9
| import java.util.*;
public class SortTest {
public static void main(String[] args) {
List<Integer> list = new ArrayList<>();
list.add(1);list.add(13);list.add(21);list.add(11);list.add(5);
list.sort( (o1, o2) -> o2-o1 );
System.out.println(list);
}
}
|
这样写不熟悉Lambda表达式的同学可能不太明白，这样写可能就明白了
1
2
3
4
5
6
7
8
9
10
11
12
13
14
| import java.util.*;
public class SortTest {
public static void main(String[] args) {
List<Integer> list = new ArrayList<>();
list.add(1);list.add(13);list.add(21);list.add(11);list.add(5);
list.sort(new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
return o2-o1;
}
});
System.out.println(list);
}
}
|
如果想要重复利用这个排序，不采用匿名内部类定义的形式话
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
| import java.util.*;
public class SortTest {
public static void main(String[] args) {
List<Integer> list = new ArrayList<>();
list.add(1);list.add(13);list.add(21);list.add(11);list.add(5);
Comparator myCom = new MyComparator();
list.sort(myCom);
System.out.println(list);
}
}
class MyComparator implements Comparator<Integer>{
@Override
public int compare(Integer o1, Integer o2) {
return o2-o1;
}
}
|
2.对基本数组类型降序排序
我把它总结为以下三种方式：
- 先升序排序，然后把数组元素交换，这种做法最简单，但只适用一维数组降序排序
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
| import java.util.*;
public class SortTest {
public static void main(String[] args) {
int[] arr = {1,15,7,4,3,87,3};
Arrays.sort(arr);
for (int i = 0; i < arr.length/2; i++) {
int temp = arr[i];
arr[i] = arr[arr.length - 1 - i];
arr[arr.length - 1 - i] = temp;
}
for (int i : arr) {
System.out.print(i+",");
}
}
}
|
- 采用stream流的方式把他转化成Integer数组
1
2
3
4
5
6
7
8
9
10
11
12
| import java.util.*;
public class SortTest {
public static void main(String[] args) {
int[] arr = {1,15,7,4,3,87,3};
Integer[] integerArr = Arrays.stream(arr).boxed().toArray(Integer[]::new);
Arrays.sort(integerArr,((o1, o2) -> o2-o1));
for (int i : integerArr) {
System.out.print(i+",");
}
}
}
|
微信
支付宝
