Java基础.数组排序（冒泡排序和选择排序）数组与遍历

int[] arr = {18, 14, 30, 79, 7, 68, 30, 59, 64, 75};
for (int i = 0; i < arr.length - 1; i++) {
    for (int j = 0; j < arr.length - 1 - i; j++) {
        int a = arr[j];
        int b = arr[j + 1];
        if (a > b) {
            arr[j] = b;
            arr[j + 1] = a;
            f = false;
        }
    }
}

优化的冒泡排序

int[] arr = {18, 14, 30, 79, 7, 68, 30, 59, 64, 75};
for (int i = 0; i < arr.length - 1; i++) {
    boolean f = true;
    for (int j = 0; j < arr.length - 1 - i; j++) {
        int a = arr[j];
        int b = arr[j + 1];
        if (a > b) {
            arr[j] = b;
            arr[j + 1] = a;
            f = false;
        }
    }
    if (f) {
        break;
    }
}

选择排序

外层循环：遍历数组的所有元素（除了最后一个元素）。
内层循环：从当前索引 i 开始，遍历数组剩余的部分，寻找最小值的索引。
交换操作：如果找到了比当前位置 i 更小的值，则记录该索引 x。在外层循环结束后，如果 x 不等于 i，则说明找到了一个更小的值，此时进行交换。

int[] arr = {18, 14, 30, 79, 7, 68, 30, 59, 64, 75};

for (int i = 0; i < arr.length - 1; i++) {
    int x = i;
    for (int j = i + 1; j < arr.length; j++) {
        if (arr[x] > arr[j]) {
            x = j;
        }
    }
    if (x != i) {
        int temp = arr[i];
        arr[i] = arr[x];
        arr[x] = temp;
    }
}

遍历

一、概念解释

在Java中，遍历指的是访问集合（如数组、List、Set、Map等）或其他数据结构中的每个元素的操作过程。它就像是对一组数据进行逐一查看、处理的过程。

二、目的和意义

数据处理

数据展示

数组基础

数组是一种数据结构，用于存储相同类型的多个数据项。它允许我们使用单一的变量名来引用一系列相关的值，这些值通常按照一定的顺序排列，并且可以通过索引来访问特定的位置。

数组的定义

数据类型：数组中的每一个元素都必须是相同的类型，可以是基本类型（如 int, double）或者是引用类型（如 String, 自定义的类）。
数组名：类似于普通变量的名字，它用于标识这个数组。
索引：索引是用来定位数组中每一个元素的位置，索引从0开始计数，直到数组长度减1为止。
数组长度：数组在创建时确定其大小，并且该大小在数组的生命期内不可改变。

如何使用数组

使用数组通常遵循以下步骤：

声明数组：声明数组时，需要指出数组将存储哪种类型的数据。

int[] numbers; // 声明一个整型数组
 String[] names; // 声明一个字符串数组

分配空间：分配空间时，告诉计算机需要多少个连续的空间来存储数据。

numbers = new int[5]; // 分配5个整数的空间
 names = new String[10]; // 分配10个字符串的空间

赋值：向数组中的元素赋值。
```
numbers[0] = 10;
 names[0] = "Alice";
```
处理数据：可以对数组中的数据进行任何必要的处理，例如遍历数组、计算总和或查找最大值等。
```
for (int i = 0; i < numbers.length; i++) {
    System.out.println(numbers[i]);
}
```

数组初始化

动态初始化：在创建数组时指定大小，之后再逐一赋值。
```
int[] nums = new int[5]; 
nums[0] = 1;
 nums[1] = 2;
 // ...
```

静态初始化：在创建数组的同时为其分配初始值。

int[] nums = new int[]{1, 2, 3, 4, 5}; // 指定大小并初始化 
int[] nums = {1, 2, 3, 4, 5}; // 直接初始化

数组长度

获取数组长度的方法是通过 .length 属性，这通常用于循环遍历数组中的所有元素。
```
int[] nums = new int[]{1, 2, 3};
 System.out.println(nums.length); // 输出3
```

案例

案例1：计算班级平均分

假设一个班级有30个学生的分数，如果使用单独的变量来存储每个学生的分数会非常麻烦。使用数组可以轻松解决这个问题。

int[] scores = new int[30]; //声明并分配空间
//假定已知分数，直接赋值
scores[0] = 95;
scores[1] = 89;
//...以此类推直到scores[29]

//计算平均分
int sum = 0;
for (int i = 0; i < scores.length; i++) {
    sum += scores[i];
}
double average = (double) sum / scores.length;
System.out.println("平均分为：" + average);

案例2：计算班级平均分

// 声明并分配空间
int[] studentScores = new int[30];
// 动态赋值（这里使用固定值作为示例）
studentScores[0] = 95;
studentScores[1] = 89;
// 假设其他元素也已赋值
// 计算总分
int totalScore = 0;
for (int i = 0; i < studentScores.length; i++) {
    totalScore += studentScores[i];
}
// 计算平均分
double averageScore = (double)totalScore / studentScores.length;
System.out.println("全班平均分为：" + averageScore);

案例3：记录运动成绩

// 创建一个数组来记录5次跳远的成绩
int[] jumpResults = {300, 310, 305, 320, 315};
// 输出每次的成绩
for (int i = 0; i < jumpResults.length; i++) {
    System.out.println("第" + (i + 1) + "次跳远成绩是：" + jumpResults[i]);
}

案例4：存储员工工资

// 创建一个数组来存储5位员工的工资
double[] salaries = {5000.0, 6000.0, 7000.0, 8000.0, 9000.0};
// 找出最高工资
double highestSalary = salaries[0];
for (int i = 1; i < salaries.length; i++) {
    if (salaries[i] > highestSalary) {
        highestSalary = salaries[i];
    }
}
System.out.println("最高工资为：" + highestSalary);

案例5：存储购物清单

// 创建一个数组来存储购物清单上的商品名称
String[] shoppingList = {"牛奶", "面包", "鸡蛋", "黄油"};
// 输出购物清单
for (int i = 0; i < shoppingList.length; i++) {
    System.out.println("购物清单上的第" + (i + 1) + "项是：" + shoppingList[i]);
}