数组的遍历与排序

  1. package test;
  2. import java.util.Arrays;
  3. import java.util.Comparator;
  4. public class Main {
  5. public static void main(String[] args) {
  6. Integer[] integers = {1, 20, 90};
  7. //遍历数组
  8. // for(int i = 0; i < integers.length; i++) {
  9. // System.out.println(integers[i]);
  10. // }
  11. //直接使用Arrays.toString方法,显示数组
  12. System.out.println(Arrays.toString(integers));//[1, 20, 90]
  13. //演示 sort方法的使用
  14. Integer arr[] = {1, -1, 7, 0, 89};
  15. //进行排序
  16. //1. 可以直接使用冒泡排序 , 也可以直接使用Arrays提供的sort方法排序
  17. //2. 因为数组是引用类型,所以通过sort排序后,会直接影响到 实参 arr
  18. //3. sort重载的,也可以通过传入一个接口 Comparator 实现定制排序
  19. //4. 调用 定制排序 时,传入两个参数 :
  20. // (1) 排序的数组 arr
  21. // (2) 实现了Comparator接口的匿名内部类 , 要求实现 compare方法
  22. //5. 先演示效果,再解释
  23. //6. 这里体现了接口编程的方式 , 看看源码,就明白
  24. // 源码分析
  25. //(1) Arrays.sort(arr, new Comparator()
  26. //(2) 最终到 TimSort类的 private static <T> void binarySort(T[] a, int lo, int hi, int start,
  27. // Comparator<? super T> c)()
  28. //(3) 执行到 binarySort方法的代码, 会根据动态绑定机制 c.compare()执行我们传入的
  29. // 匿名内部类的 compare ()
  30. // while (left < right) {
  31. // int mid = (left + right) >>> 1;
  32. // if (c.compare(pivot, a[mid]) < 0)
  33. // right = mid;
  34. // else
  35. // left = mid + 1;
  36. // }
  37. //(4) new Comparator() {
  38. // @Override
  39. // public int compare(Object o1, Object o2) {
  40. // Integer i1 = (Integer) o1;
  41. // Integer i2 = (Integer) o2;
  42. // return i2 - i1;
  43. // }
  44. // }
  45. //(5) public int compare(Object o1, Object o2) 返回的值>0 还是 <0
  46. // 会影响整个排序结果, 这就充分体现了 接口编程+动态绑定+匿名内部类的综合使用
  47. //Arrays.sort(arr); // 默认排序方法->从小到大排序
  48. //定制排序
  49. Arrays.sort(arr, new Comparator() {
  50. @Override
  51. public int compare(Object o1, Object o2) {
  52. Integer i1 = (Integer) o1;
  53. Integer i2 = (Integer) o2;
  54. return i2 - i1;//从大到小排序
  55. //return i1 - i2;//从小到大排序
  56. }
  57. });
  58. System.out.println("===排序后===");
  59. System.out.println(Arrays.toString(arr));//[89, 7, 1, 0, -1]
  60. }
  61. }

image.png

自定义排序理解

  1. package test;
  2. import java.util.Arrays;
  3. import java.util.Comparator;
  4. public class Main {
  5. public static void main(String[] args) {
  6. int[] arr = {1, -1, 8, 0, 20};
  7. //bubble01(arr);
  8. bubble02(arr, new Comparator() {
  9. @Override
  10. public int compare(Object o1, Object o2) {
  11. int i1 = (Integer) o1;
  12. int i2 = (Integer) o2;
  13. return i1 - i2;//从小到大排序
  14. // return i2 - i1;//从大到小排序
  15. }
  16. });
  17. System.out.println("==定制排序后的情况==");
  18. System.out.println(Arrays.toString(arr));
  19. }
  20. //使用冒泡完成排序(传统方式)
  21. public static void bubble01(int[] arr) {
  22. int temp = 0;
  23. for (int i = 0; i < arr.length - 1; i++) {
  24. for (int j = 0; j < arr.length - 1 - i; j++) {
  25. //从小到大
  26. if (arr[j] > arr[j + 1]) {
  27. temp = arr[j];
  28. arr[j] = arr[j + 1];
  29. arr[j + 1] = temp;
  30. }
  31. }
  32. }
  33. }
  34. //结合冒泡 + 定制
  35. public static void bubble02(int[] arr, Comparator c) {
  36. int temp = 0;
  37. for (int i = 0; i < arr.length - 1; i++) {
  38. for (int j = 0; j < arr.length - 1 - i; j++) {
  39. //数组排序由 c.compare(arr[j], arr[j + 1])返回的值决定
  40. if (c.compare(arr[j], arr[j + 1]) > 0) {
  41. temp = arr[j];
  42. arr[j] = arr[j + 1];
  43. arr[j + 1] = temp;
  44. }
  45. }
  46. }
  47. }
  48. }

image.png