Java数组的自然排列、数组倒置、随机排序的实现

选择排序

假设数组为int[] a = { 49, 38, 65, 97, 76, 13, 27 }，数组元素个数为7个。
第1轮比较：先是a[0]与a[1]比较，大于则先交换，再比较a[0]和a[2]…最后是a[0]与a[6]比较。总共比较6次。(此时a[0]已是数组中的最小值)
第2轮比较：先是a[1]与a[2]比较，大于则先交换，再比较a[1]和a[3]…最后是a[1]与a[6]比较。总共比较5次。
第3轮比较：先是a[2]与a[3]比较，大于则先交换，再比较a[2]和a[4]…最后是a[2]与a[6]比较。总共比较4次。
第4轮比较：先是a[3]与a[4]比较，大于则先交换，再比较a[3]和a[5]…最后是a[3]与a[6]比较。总共比较3次。
第5轮比较：先是a[4]与a[5]比较，大于则先交换，再比较a[4]和a[6]。总共比较2次。
第6轮比较：只用a[5]与a[6]比较，大于则先交换。总共比较1次。

public class ThroughArrays {
    public static void main(String[] args) {
        int[] a = { 49, 38, 65, 97, 76, 13, 27 };
        int[] b = selectSort(a);
        for (int i=0 ; i arr[j]) {
                    // 交换数据
                    int temp;
                    temp = arr[i];
                    arr[i] = arr[j];
                    arr[j] = temp;
                }
            }
        }
        return arr;
    }

}

输出结果：
13
27
38
49
65
76
97

冒泡排序

原理：依次比较相邻的两个数，将小数放在前面，大数放在后面。
首先比较第1个和第2个数，将小数放前，大数放后。然后比较第2个数和第3个数，将小数放前，大数放后，如此继续，直至比较最后两个数，将小数放前，大数放后。重复第一趟步骤，直至全部排序完成。第一次交换完成后，最后一个数为最大数，不再参与比较。

import java.util.Arrays;

public class BubbleSort {
    public static void BubbleSort(int[] arr) {
        int temp;//定义一个临时变量
        for(int i=0;i

自然升序排序

自然排序：java.lang.Comparable

Comparable 接口中只提供了一个方法： compareTo(Object obj) ，该方法的返回值是 int 。如果返回值为正数，则表示当前对象(调用该方法的对象)比 obj 对象“大”；反之“小”；如果为零的话，则表示两对象相等。

import java.util.Arrays;

public class mysort{
	public static void main(String [ ] args){
	int [ ] a = { 1 , 12 , 35 ,5 ,2 ,9};
	Arrays.sort(a);
	System.out.println(Arrays.toString(a) ); 
	}
}

自然降序排序

Java中sort实现降序排序
利用Collections的reverseOrder方法：Copyimport java.util.Arrays;

import java.util.Collections;

public class Main {
    public static void main(String[] args) {
        Integer[] arr = {9, 8, 7, 2, 3, 4, 1, 0, 6, 5};
        Arrays.sort(arr, Collections.reverseOrder());
        for (Integer x : arr) {
            System.out.print(x + " ");
        }
        System.out.println();
    }
}

利用Comparator接口复写compare方法：Copyimport java.util.Arrays;

import java.util.Comparator;

public class Main {
    public static void main(String[] args) {
        //注意，要想改变默认的排列顺序，不能使用基本类型（int,double, char）,而要使用它们对应的类
        Integer[] arr = {9, 8, 7, 2, 3, 4, 1, 0, 6, 5};
        //定义一个自定义类MyComparator的对象
        Comparator cmp = new MyComparator();
        Arrays.sort(arr, cmp);
        for (int x : arr) {
            System.out.print(x + " ");
        }
    }
}

//实现Comparator接口
class MyComparator implements Comparator {
    @Override //作用是检查下面的方法名是不是父类中所有的，也起到注释的作用
    public int compare(Integer a, Integer b) {
        return a > b ? -1 : 1;
    }
}

数组倒置

方法一：使用集合个工具类： Collections.reverse(ArrayList) 将数组进行反转

import java.util.ArrayList;import java.util.Collections;
public class Main {
   public static void main(String[] args) {
      ArrayList arrayList = new ArrayList();
      arrayList.add("A");
      arrayList.add("B");
      arrayList.add("C");
      arrayList.add("D");
      arrayList.add("E");
      System.out.println("反转前排序: " + arrayList);
      Collections.reverse(arrayList);
      System.out.println("反转后排序: " + arrayList);
   }
}

方法二：使用集合ArrayList实现反转：
方法三：直接使用数组实现反转，即，反转后数组的第一个元素等于源数组的最后一个元素：
方法二和方法三的实现代码如下：

package javatest2;
 
import java.util.ArrayList;
 
public class JavaTest2 {
 
 public static void main(String[] args) {
  String[] Array = { "a", "b", "c", "d", "e" };
  reverseArray1(Array);// 使用集合ArrayList实现反转
  for (int j = 0; j < Array.length; j++) {
   System.out.print(Array[j] + " ");
  }
 
  System.out.print("\n");
  String[] temp = reverseArray2(Array);// 直接使用数组实现反转
  for (int j = 0; j < temp.length; j++) {
   System.out.print(Array[j] + " ");
  }
 
 }
 
 /*
  * 函数：reverseArray1和reverseArray2 
  * 功能：实现 数组翻转
  * 例如：{'a','b','c','d'}变成{'d','c','b','a'}
  */
 private static void reverseArray1(String[] Array) {
  ArrayList array_list = new ArrayList();
  for (int i = 0; i < Array.length; i++) {
   array_list.add(Array[Array.length - i - 1]);
  }
  Array = array_list.toArray(Array);
 }
 
 private static String[] reverseArray2(String[] Array) {
  String[] new_array = new String[Array.length];
  for (int i = 0; i < Array.length; i++) {
   // 反转后数组的第一个元素等于源数组的最后一个元素：
   new_array[i] = Array[Array.length - i - 1];
  }
  return new_array;
 }
 
}

随机排序

方法一：Collections.shuffle(list)方法
引用Collectons类中的。Collections.shuffle(list)方法
Collectons类用于操作集合类，如list，set。提供的所有方法都是静态的。
Collectons类的几个常用方法：

Collections.sort(list);
 // 顺序排列 （对集合进行排序,默认按照升序排序，列表中所有元素必须实现Comparable接口）

      
Collections.shuffle(list); 
// 对集合中元素进行随机排序
      
Collections.reverse(list);
 // 倒序排列 （反转）

排序实例：

import java.util.Arrays;
import java.util.Collections;
import java.util.List;

public class demo {

  public static void main(String[] args) {

    String[] chars = new String[] { "a", "b", "c", "d", "e", "f", "g", "h",
    "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t",
    "u", "v", "w", "x", "y", "z",};

    List list = Arrays.asList(chars);//数组转化为list
    System.out.println("List容器中排列顺序：" + list);


    //打乱List容器的元素排列顺序
    Collections.shuffle(list);
    System.out.println("Shuffle方法调用后顺序：" + list);

    //再次打乱List容器的元素排列顺序
    Collections.shuffle(list);
    System.out.println("Shuffle方法调用后顺序：" + list);
    }
} 

输出结果：
List容器中排列顺序：[a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z]
Shuffle方法调用后顺序：[p, t, f, c, h, r, y, a, e, k, m, d, w, i, g, o, u, z, n, b, s, v, x, l, j, q]
Shuffle方法调用后顺序：[f, j, n, c, q, a, k, y, g, h, e, l, o, x, r, b, i, s, u, z, m, d, t, w, p, v]

方法二：Java random() 方法
random() 方法用于返回一个随机数，随机数范围为 0.0 =< Math.random < 1.0。
实例：

 public class RandomSortTest {
 private int[]arr = {1,2,3,4,5,6,7,8};
 private static final int SIZE = 8;
 Random random = new Random();
 @Test
 //重新排列
 public void sort(){
  printArr();
  for(int i=0;i

参考引用：

1. https://www.cnblogs.com/schiller-hu/p/8439179.html
2. https://www.cnblogs.com/youpeng/p/10546797.html
3. https://blog.csdn.net/guyuealian/article/details/51113133
4. https://blog.csdn.net/mingyuli/article/details/79586855
5. https://blog.csdn.net/a1017680279/article/details/72830298