JavaSE之数组与排序

概述

数组是一个容器，存放的是一组相同数据类型的数据。数组是定长的容器。在你创建数组的时候指定长度，
后期不可修改。因为数组存放的是相同数据类型，因此我们在定义数组的时候，一定要指定你存储的是什么类型

数组定义的格式

Java风格数组定义：

数据类型[] 变量名 = new 数据类型[数组长度]；

兼容C语言的风格：

数据类型 变量名[] = new 数据类型[数组长度]；

创建的时候指定初值：

数据类型[] 变量名 = new 数据类型[]{数据1，数据2，数据3，…}；

最后这种的简化格式：

数据类型[] 变量名 = {数据1，数据2，数据3，…}；

上面的都是一维数组，除此之外还有二维数组、三维数组、四维数组…，当然我们最常用的还是一维数组和二维数组、最多还会用个三维数组，至于更高维度的数组，很少会使用。二维数组就像一个表格，而三维数组则和魔方类型。

二维数组Java风格定义：

数据类型[][] 数组名 = new 数据类型[数组列长度][数组行长度]

三维数组Java风格定义：

数据类型[][][] 数组名 = new 数据类型[数组列长度][数组行长度][数组高度]

…

示例：

// Java风格
int[] intArr = new int[5];
// 兼容C的风格
double douArr[] = new double[5];
// 创建并初始化数组,下面的数组长度就被识别为5
boolean[] booleanArr = new boolean[]{false,true,true,false,true};
// 简化上述方式
boolean[] booleanSimpleArr = {false,true,true,false,true};

关于数据类型，使用任何数据类型都可以创建出一个该类型的数组。这里只给出了一维数组的例子，高维数组和一维数组定义方式相似，参照高维数组定义格式就行。

数组的下标

数组的下标也可以称为索引（index），在编程语言里，一说到下标都是从0开始的。

对于一个数组，下标的取值范围是[0,元素个数-1]，一旦你写的下标超出了规定的范围，就会出现程序的异常。

访问数组元素：给元素写值（赋值）、读元素的值。

无论写入还是读取，第一件事就找到你要操作的元素。

使用方式：数组名[下标]，示例：

String[] strings = {"First Str", "Second Str", "Third Str"};
System.out.println("数组第一个值: " + strings[0]);
System.out.println("数组第二个值: " + strings[1]);
System.out.println("数组第三个值: " + strings[2]);

练习示例

随机产生10个元素的整形数组，取值范围[10,85],求最大值及出现的位置（下标）

int[] array = new int[10];
Random random = new Random();
// 初始化最大值
int max = array[0];
// 定义一个变量用来存放最大值的下标
int maxIndex;
for(int i = 0; i <array.length; i++) {
    // 产生数组中每个位置的随机数
	array[i] = random.nextInt(85-10+1)+10;
    // 找出最大值
    if(max < array[i]) {
        max = array[i];
        maxIndex = i;
    }
}
System.out.println("最大值: " + max + ", 位置: " + maxIndex);

排序

冒泡排序

排序思想

相邻的两个数依次进行比较，如果前者大，则互换位置，一趟下来之后，最大值就放在了最后一位，

开始第二趟，依次比较相邻的2个数，如果前者大，交换，以此类推，如果对n个数排序，n-1趟能排出结果。

示例

int[] arr = {2, 3, 5, 6, 4, 11, 10};
for (int i = 0; i < arr.length - 1; i++) {
    //j<7-1-i意思是：当最大值已确定后，不再与之比较，只与它前边的数比较
    for (int j = 0; j < arr.length - 1 - i; j++) {
        if (arr[j] > arr[j + 1]) {
            // 通过第三方变量实现两者值的交换
            int temp = arr[j];
            arr[j] = arr[j + 1];
            arr[j + 1] = temp;
        }
    }
}
for (int i : arr) {
    System.out.print(i + " ");
}

选择排序

排序思想

假定本趟待排元素的第一个是最小值，记录这个值以及值的位置，拿这个记录的值，依次与第2~n的数进行比较，

一旦发现有比记录的值小的数更新记录的值以及位置，继续往后比，直到最后一个元素,然后与第一个元素交换。

示例

int[] arr = {3, 5, 6, 4, 11, 10};
for (int i = 0; i < arr.length - 1; i++) {
    // 假定第一个就是最小值
    int min = arr[i];
    int k = i;
    for (int j = i + 1; j < arr.length; j++) {
        // 如果有比min小的，重新赋值并记录下标
        if (arr[j] < min) {
            min = arr[j];
            k = j;
        }
    }
    // 如果下标不是最初的下标，则说明有比min小的数，交换两个数
    if (k != i) {
        min = arr[i];
        arr[i] = arr[k];
        arr[k] = min;
    }
}
for (int i : arr) {
    System.out.print(i + " ");
}

插入排序

排序思想

把一个待排元素与有序元素从后往前依次比较，如果待排元素小于某有序元素，二者交换，再与更小的元素比较，

如果大于更小的元素或者已经交换到最小位置，结束本趟比较，开启下一趟比较，比较方式同上。

示例

int[] arr = {3, 6, 4, 2, 11, 10, 5};
for (int i = 1; i < arr.length; i++) {
    int j = i;
    while (j > 0 && arr[j] < arr[j - 1]) {
        int temp = arr[j];
        arr[j] = arr[j - 1];
        arr[j - 1] = temp;
        j--;
    }
}
for (int i : arr) {
    System.out.print(i + " ");
}

排序总结

排序算法	思想	特点
冒泡排序	逐一比较相邻的两个数，大的放后边	每一趟找到待排序的最大值，放最后面
选择排序	记录最小值的下标，和第一待排序的互换	每一趟找到待排序的最小值，放前面
插入排序	待排序的插入到有序序列的适当位置	待排序的数依次与有序数从后往前比，插入相应的位置

练习

1. 随机产生一个4行5列的二维数组, [1, 90], 遍历数组, 求最大值

int[][] array = new int[4][5];
int max = array[0][0];
Random random = new Random();
for (int i = 0; i < array.length; i++) {
    for (int j = 0; j < 5; j++) {
        array[i][j] = random.nextInt(90) + 1;
        if (array[i][j] > max) {
            max = array[i][j];
        }
        System.out.print(array[i][j] + " ");
    }
    System.out.println();
}
System.out.println("该数组最大值: " + max);

2. 声明一个int型的数组，循环接收8个学生的成绩，计算这8个学生的总分及平均分、最高分和最低分。

int[] scores = new int[8];
int avg = 0, sum = 0;
Scanner scanner = new Scanner(System.in);
System.out.println("请将8个学生的成绩输入进来:");
for (int i = 0; i < scores.length; i++) {
    scores[i] = scanner.nextInt();
    sum += scores[i];
    avg = sum / scores.length;
}
int max = scores[0], min = scores[0];
for (int i = 0; i < scores.length; i++) {
    if (scores[i] > max) {
        max = scores[i];
    }
    if (scores[i] < min) {
        min = scores[i];
    }
}
System.out.println("最高分是: " + max);
System.out.println("最低分: " + min);
System.out.println("平均分: " + avg);
System.out.println("总分: " + sum);

3. 创建一个5行10列的数组,每个元素取值范围[30, 70] ,并对第5行按从小到大进行排序

// 初识化数组
int[][] array = new int[5][10];
Random random = new Random();
for (int i = 0; i < array.length; i++) {
    for (int j = 0; j < array[i].length; j++) {
        array[i][j] = random.nextInt(41) + 30;
    }
}
//方法一：将二维数组以固定某一行，转化为一维数组，进行排序
for (int i = 0; i < 9; i++) {
    for (int j = 0; j < 9 - i; j++) {
        if (array[4][j] > array[4][j + 1]) {
            int temp = array[4][j];
            array[4][j] = array[4][j + 1];
            array[4][j + 1] = temp;
        }
    }
}

System.out.print("第一种排序方式: ");
for (int i = 0; i < 10; i++) {
    System.out.print(array[4][i] + " ");
}
//方法二：将二维数组中所要排序的列重新赋给一个新的数组，再对新的数组进行排序
System.out.print("\n第二种排序方式: ");
int[] array1 = new int[10];
for (int i = 0; i < array.length; i++) {
    for (int j = 0; j < 10; j++) {
        if (i == 4) {
            array1[j] = array[i][j];
        }
    }
}
Arrays.sort(array1);
for (int i : array1) {
    System.out.print(i + " ");
}

----------------------------------------下一章节->JavaSE之方法----------------------------------

-------------------------------------返回->JavaSE系列<-目录-------------------------------------