一、数组案例：数组求最值

• 数组元素求最大值

讯享网

• 需求：挑出颜值最高的美女
• 思路：
  • 首先，这个业务属于一开始就能确定元素值的，所以使用静态化数组来存放这些颜值元素
  • 然后，需要定义一个最大值变量，记录第一位上场美女颜值，用于与后一位上场美女的颜值进行比较
  • 再然后，使用for循环遍历：一个一个的把美女的颜值访问
  • 之后，使用if进行判断：后一位上场美女的颜值 是否大于 第一位上场美女的颜值，是就把第一位淘汰，把最大值变量的值替换成后一位上场美女的颜值；不是就没有资格比较，有请下一位
• 分析需求：
  1. 定义一个int类型的静态初始化数组，存放美女的颜值
  2. 在循环外定义一个最大值变量，用于记录最大值，变量建议默认存储数组中第一个元素值作为参照，因为要进行元素比较，所以默认值不能是 0
  3. 使用for循环来遍历每个美女的颜值
  4. 在循环内，使用if判断：每次遍历到的颜值 是否大于 记录的最大值，是则替换最大值；不是就不进入if判断，有请下一位
  5. 将最高颜值输出到控制台

package com.app.traverse; public class ArrayTest3 { 
    public static void main(String[] args) { 
    // 目标：通过数组案例：数组求最值，更深的掌握数组的应用 以及 遍历的灵活运用 /* - 需求：挑出颜值最高的美女，颜值：15,9000,10000,20000,9500,-5 - 思路： - 首先，这个业务属于一开始就能确定元素值的，所以使用静态化数组来存放这些颜值元素 - 然后，需要定义一个最大值变量，记录第一位上场美女颜值，用于与下一位上场美女的颜值进行比较 - 再然后，使用for循环遍历：一个一个的把美女的颜值访问 - 之后，使用if进行比较：下一位上场美女的颜值 是否大于 第一位上场美女的颜值， 是就把第一位淘汰，替换成下一位上场美女的颜值， 不是就没有比较的必要，直接下一位上来比较 - 具体实现： 1. 定义一个int类型的数组，存放美女的颜值 2. 在循环外定义一个最大值变量，用于记录最大值， 变量建议默认存储数组中第一个元素值作为参照，因为要进行元素比较，所以默认值不能是 0 3. 使用for循环来遍历每个美女的颜值 4. 在循环内，使用if判断： 每次遍历到的颜值 是否大于 记录的最大值， 是则替换最大值， 不是就不进入if判断，没有判断的必要，所以有请下一位 5. 将最高颜值输出到控制台 */ // 1. 定义一个int类型的数组，存放美女的颜值 int[] faceValue = { 
   15, 9000, 10000, 20000, 9500, -5}; // 0 1 2 3 4 5 // 2. 在循环外定义一个最大值变量，用于记录最大值， // 变量建议默认存储数组中第一个元素值作为参照，因为要进行元素比较，所以默认值不能是 0 int max = faceValue[0]; // 3. 使用for循环来遍历每个美女的颜值 // 因为最大值选择了第一个美女，如果 i = 0，就会 第一个美女 和 第一个美女 作比较，不符合实际，显得多此一举 // 所以，i = 1，就会 第二个美女 和 第一个美女 作比较，符合实际，显得更专业，优雅 for (int i = 1; i < faceValue.length; i++) { 
    // 4. 在循环内，使用if判断： if (faceValue[i] > max){ 
    // 每次遍历到的颜值 是否大于 记录的最大值， // 是则替换最大值，不是就不进入if判断，没有判断的必要，所以有请下一位 max = faceValue[i]; } } // 5.挑出最高颜值的美女后输出 System.out.println("最高颜值：" + max); } } 

讯享网输出结果： 最高颜值：20000 

数组求最值总结

1、数组元素求最大值如何实现的？

• 首先，看业务一开始给不给确定元素值，给就用静态初始化数组，不给就用动态初始化数组，后期赋值
• 1.定义一个数组存放元素值
• 2.定义一个最大值变量，用于记录最大值（该变量建议存储数组中的第一个元素作为参照，方便与后面的每一位元素进行比较）
• 3.使用for循环遍历数组中的每一个元素值
• 3-1.在循环内使用if判断：后面的每一位元素 是否大于 记录最大值，如果是，就替换最大值为该元素；如果不是，就不进入if判读，进行下一轮循环比较，直到数组中所有元素比完，循环才结束
• 4.输出最大值

二、数组案例：猜数字游戏

• 需求：开发一个幸运小游戏，游戏规则如下：
  • 游戏后台随机生成1~20之间的5个数（无所谓是否重复），然后让大家来猜数字：
    • 未猜中提示：“未命中”，并继续猜测
    • 猜中提示：“运气不错，猜中了”，并输出该数据第一次出现的位置，且输出全部5个数据，最终结束本游戏。
• 分析：
  • 首先可以确定的是，这个业务属于开始不能确定元素值，所以使用动态初始化数组来存储这些幸运数，后期再赋值
  • 1、定义一个动态初始化数组，用于存储5个1-20之间的随机幸运数
  • 2、使用for循环，动态的生成5个1-20之间的随机幸运数
  • 3、在for循环外，创建随机数Random对象类，用于生成随机幸运数
  • (3-1) 在for循环内，调用随机数功能生成5个1-20之间的随机幸运数，并赋值给动态初始化数组
  • 4、先输入 OUT: ——> 为后面结束整个死循环做铺垫
  • 5、使用while循环，定义一个死循环，用于让大家可以不断的猜幸运数，猜中就结束死循环，猜不中继续猜
  • 6、在死循环外，创建键盘录入Scanner对象类，用于让大家猜幸运数
  • (6-1) 在死循环内，提示大家开始猜幸运数(1-20)，定义一个变量用于接收大家猜的幸运数——>用于后面与数组中正确的幸运数作比较
  • (6-2) 在死循环内，使用for循环遍历——>将数组中全部正确的幸运数都访问一遍，用于后面与大家猜的幸运数作比较
  • (6-3) 在死循环内的for循环内，使用if判断：大家猜的幸运数 是否 在数组中。在则提示：“运气不错，猜中了！”，并输出该幸运数第一次出现的位置(索引)，并且使用 break OUT; ——>用于结束整个死循环。
  • 7、在for循环外，假如：大家猜的幸运数 不在 数组中，则提示：“未命中！”
  • 8、游戏结束后，使用for循环遍历，输出数组中所有正确的幸运数

package com.app.traverse; // 1.导入包：Scanner键盘输入、Random随机数 ————>在创建这两个对象类时会自动导包 import java.util.Random; import java.util.Scanner; public class ArrayTest4 { 
    public static void main(String[] args) { 
    // 目标：通过数组案例：猜数字游戏，更深入的结合数组来解决开发业务问题 /* 一、需求：开发一个幸运小游戏，游戏规则如下： - 游戏后台随机生成1~20之间的5个数（无所谓是否重复），然后让大家来猜数字： - 未猜中提示：“未命中”，并继续猜测 - 猜中提示：“运气不错，猜中了”，并输出该数据第一次出现的位置，且输出全部5个数据，最终结束本游戏。 */ // 1、定义一个动态初始化数组，用于存储5个1-20之间的随机幸运数 int[] luckyNumber = new int[5]; // [0,0,0,0,0] // 索引 0 1 2 3 4 // 3、在for循环外，创建随机数Random对象类，用于生成随机幸运数 Random rd = new Random(); // 2、使用for循环，动态的生成5个1-20之间的随机幸运数 for (int i = 0; i < luckyNumber.length; i++) { 
    // (3-1) 在for循环内，调用随机数功能生成5个1-20之间的随机幸运数，并赋值给动态初始化数组 // i = 0 1 2 3 4 luckyNumber[i] = rd.nextInt(1,21); } // 6、在死循环外，创建键盘录入Scanner对象类，用于让大家猜幸运数 Scanner sc = new Scanner(System.in); // 4、先输入 OUT: ——> 为后面结束整个死循环做铺垫 OUT: // 5、使用while循环，定义一个死循环，用于让大家可以不断的猜幸运数，猜中就结束死循环，猜不中继续猜 while (true) { 
    // (6-1) 在死循环内，提示大家开始猜幸运数(1-20)， // 定义一个变量用于接收大家猜的幸运数——>用于后面与数组中正确的幸运数作比较 System.out.println("请您开始猜5个幸运数(1-20)："); int guessNumber = sc.nextInt(); // (6-2) 在死循环内，使用for循环遍历——>将数组中全部正确的幸运数都访问一遍， // 用于后面与大家猜的幸运数作比较 for (int i = 0; i < luckyNumber.length; i++) { 
    // (6-3) 在死循环的for循环内，使用if判断：大家猜的幸运数 是否 在数组中 if (guessNumber == luckyNumber[i]) { 
    // 在则提示："运气不错，猜中了！"，并输出该幸运数第一次出现的位置(索引)， System.out.println("运气不错！猜中了！快去换领奖品吧~~"); System.out.println("您猜中的幸运数第一次出现的位置是：" + i); // 并且使用 break OUT; ——>用于结束整个死循环 break OUT; } } // 7、在for循环外，假如：大家猜的幸运数 不在 数组中，则提示："未命中！" System.out.println("未猜中！继续加油~~"); } // 8、游戏结束后，使用for循环遍历，输出数组中所有正确的幸运数 System.out.println("\n全部随机幸运数："); for (int i = 0; i < luckyNumber.length; i++) { 
    System.out.print(luckyNumber[i] + "\t"); } } } 

讯享网输出结果： 请您开始猜5个幸运数(1-20)： 1 未猜中！继续加油~~ 请您开始猜5个幸运数(1-20)： 2 未猜中！继续加油~~ 请您开始猜5个幸运数(1-20)： 3 未猜中！继续加油~~ 请您开始猜5个幸运数(1-20)： 4 未猜中！继续加油~~ 请您开始猜5个幸运数(1-20)： 5 运气不错！猜中了！快去换领奖品吧~~ 您猜中的幸运数第一次出现的位置是：3 全部随机幸运数： 13 12 19 5 9 

猜数字游戏总结

1、猜数字游戏的实现步骤？

• 首先，先看一开始能不能确定元素值，不能则使用动态初始化数组，后期赋值；能则使用静态初始化数组
• 1.定义一个动态初始化数组，后期动态赋值
• 2.使用for循环遍历，用于动态赋值给数组
• 3.在for循环外，创建Random随机数对象，用于生成随机数
• 3-1.在循环内，调用随机数功能生成随机数，赋值给数组
• 4.使用OUT: ——>用于为后面结束整个死循环做铺垫
• 5.使用while循环定义一个死循环，让大家猜数字
• 6.在死循环外，创建Scanner键盘录入对象类，用于让大家猜数
• 6-1.在死循环内，提示：让大家开始猜数，并定义一个变量用于接收大家猜的数
• 6-2.在死循环内，使用for循环遍历数组中的随机数
• 6-3.在死循环内的for循环内，使用if判断：大家猜的数 是否 在数组中，在则提示：“恭喜猜中了！”，并输出猜中的数的第一次出现的索引位置，并使用 break OUT; ——>用于结束整个死循环(结束猜数字游戏)
• 7.在死循环内，for循环外，假如：大家猜的数 不在 数组中，则提示：“未猜中！继续加油~~”，继续猜数
• 8.当结束猜数字游戏后，使用for循环遍历整个数组的随机数，输出出来

三、数组案例：随机排名

• 需求：
  • 某公司开发部5名开发人员，要进行项目进展汇报演讲，现在采取随机排名后进行汇报。
  • 请先依次录入5名员工的工号，然后展示出一组随机的排名顺序

• 分析：
  • 首先，这个业务属于一开始就能确定元素值，虽然说可以用静态初始化数组，但是还是推荐用动态初始化数组，因为比较灵活，静态的话，写死了，非常不方便
  • 1.定义一个动态初始化数组，长度为5，用于存储5名员工的工号，后期赋值
  • 2.定义一个for循环，循环5次，依次录入一个工号存入对应的位置
  • 3.在for循环外，创建Scanner键盘录入对象类，用于录入员工工号
  • (3-1) 在for循环内，提示：录入工号，并定义一个变量来存放录入的员工工号
  • (3-2) 将录入的工号赋值给数组
  • 4.定义一个循环，遍历数组的每一个员工的工号
  • 5.在循环外，创建Random随机数对象类，用于生成一个随机索引 与 员工的工号 进行位置交换
  • (5-1) 在循环内，调用随机数功能生成1个1-5之间的随机索引位置，用一个变量存放起来
  • (5-2) 在循环内，进行员工工号的交换操作：

    (1) 先用临时变量将 随机索引位置的B员工工号存起来； (2) 再将当前A员工工号 赋值到 随机索引的位置； (3) 最后再将临时变量里的B员工工号 赋值到 A员工工号的索引位置； (4) 形成位置交换，达成随机排名 

  • 思路：

    讯享网(1) 首先不能直接将 A员工工号 直接赋值给 随机的索引位置的B员工工号，不然随机的索引位置的B员工工号就会被覆盖掉，那就不是交换了，而是谋杀； (2) 需要用一个临时变量将 随机的索引位置的B员工工号存放起来，相当于拷贝一份，然后在 将A员工工号 赋值给 随机的索引位置后，再将 B员工工号 赋值给 A员工工号，形成了工号交换操作。 

  • 如果这里大家看不明白上面思路的话，请看下图：
    
    
  • 6.在for循环完成交换后，使用for循环遍历数组，展示出一组随机排名的顺序工号

package com.app.demo; // 导包：创建对象类时，IDEA工具会自动导入 import java.util.Random; import java.util.Scanner; public class Test4 { 
    public static void main(String[] args) { 
    // 目标：通过数组案例：随机排名，更深入的结合数组来解决开发业务中的问题 /* 一、需求： - 某公司开发部5名开发人员，要进行项目进展汇报演讲，现在采取随机排名后进行汇报。 - 请先依次录入5名员工的工号，然后展示出一组随机的排名顺序 22 33 35 13 88 ————> 13 35 88 33 22 */ // 1.定义一个动态初始化数组，长度为5，用于直接存储5名员工的工号，后期赋值 int[] staffIds = new int[5]; // 3.在for循环外，创建Scanner键盘录入对象类，用于录入员工工号 Scanner sc = new Scanner(System.in); // 在循环外定义一个计数器，用于记录员工数量（用于最终结果输出的美观感） int count = 0; // 2.定义一个for循环，循环5次，依次录入一个工号存入对应的位置 for (int i = 0; i < staffIds.length; i++) { 
    // (3-1) 在for循环内，提示：录入工号，并定义一个变量来存放录入的员工工号 System.out.println("请录入第" + (i+1) + "个员工的工号："); int staffId = sc.nextInt(); // (3-2)将录入的工号赋值给数组 staffIds[i] = staffId; // 累加员工数量 count++; } // 以下是本次案例的重点： // 5.在循环外，创建Random随机数对象类，用于生成一个随机索引 与 员工的工号 进行位置交换 Random rd = new Random(); // 4.定义一个循环，遍历数组的每一个员工的工号 for (int i = 0; i < staffIds.length; i++) { 
    // (5-1) 在循环内，调用随机数功能生成1个 1-5之间 的随机索引位置，用一个变量存放起来 int index = rd.nextInt(staffIds.length); // (5-2) 在循环内，进行员工工号的交换操作： // 当前A员工工号：staffIds[i] // 随机索引位置的B员工工号：staffIds[index] // 先用临时变量将 随机索引位置的B员工工号存起来； int temp = staffIds[index]; // 再将当前A员工工号 赋值到 随机索引的位置 staffIds[index] = staffIds[i]; // 最后再把 B员工工号 赋值给 A员工工号的索引位置 staffIds[i] = temp; } // 6.在for循环完成交换后，使用for循环遍历数组，展示出一组随机排名的顺序工号 System.out.println("\n" + count + "名员工的工号随机排名顺序："); for (int i = 0; i < staffIds.length; i++) { 
    System.out.print(staffIds[i] + "\t"); } } } 

讯享网输出结果： 请录入第1个员工的工号： 22 请录入第2个员工的工号： 33 请录入第3个员工的工号： 35 请录入第4个员工的工号： 13 请录入第5个员工的工号： 88 开发部5名员工的工号随机排名顺序： 88 33 22 35 13 

随机交换排名的其他使用场景：比如斗地主洗牌

随机排名总结

1、如何实现随机排名？

• 1、先定义一个动态初始化的数组，用于存储录入的数据

  

  // 1 int[] codes = new int[5]; 

• 2、使用循环遍历数组，动态的将数据录入数组中

  讯享网// 1 int[] codes = new int[5]; // 2 for (int i = 0; i < codes.length; i++) { 
        } 

• 3、在循环前，创建Scanner键盘录入对象类，用于录入数据

  // 1 int[] codes = new int[5]; // 3 Scanner sc = new Scanner(System.in); // 2 for (int i = 0; i < codes.length; i++) { 
        } 

• (3-1) 在循环内，提示：开始录入数据，用一个变量接收这个录入的数据

  讯享网// 1 int[] codes = new int[5]; // 3 Scanner sc = new Scanner(System.in); // 2 for (int i = 0; i < codes.length; i++) { 
        // (3-1) System.out.println("请录入第" + (i+1) + "个员工的工号："); int code = sc.nextInt(); } 

• (3-2) 在循环内，将每一次录入的数据，赋值给数组

  // 1 int[] codes = new int[5]; // 3 Scanner sc = new Scanner(System.in); // 2 for (int i = 0; i < codes.length; i++) { 
        // (3-1) System.out.println("请录入第" + (i+1) + "个员工的工号："); int code = sc.nextInt(); // (3-2) codes[i] = code; } 

• 4、使用循环遍历数组，用于 与 随机得到的一个索引位置 进行位置交换

  讯享网// 1 int[] codes = new int[5]; // 3 Scanner sc = new Scanner(System.in); // 2 for (int i = 0; i < codes.length; i++) { 
        // (3-1) System.out.println("请录入第" + (i+1) + "个员工的工号："); int code = sc.nextInt(); // (3-2) codes[i] = code; } // 4 for (int i = 0; i < codes.length; i++) { 
        } 

• 5、在循环前，创建Random随机数对象类，用于随机得到一个索引位置

  // 1 int[] codes = new int[5]; // 3 Scanner sc = new Scanner(System.in); // 2 for (int i = 0; i < codes.length; i++) { 
        // (3-1) System.out.println("请录入第" + (i+1) + "个员工的工号："); int code = sc.nextInt(); // (3-2) codes[i] = code; } // 5 Random rd = new Random(); // 4 for (int i = 0; i < codes.length; i++) { 
        } 

• (5-1) 在循环内，调用随机数功能随机得到1个 小于数组长度的 索引位置，用一个变量接收这个随机得到的索引位置

  讯享网// 1 int[] codes = new int[5]; // 3 Scanner sc = new Scanner(System.in); // 2 for (int i = 0; i < codes.length; i++) { 
        // (3-1) System.out.println("请录入第" + (i+1) + "个员工的工号："); int code = sc.nextInt(); // (3-2) codes[i] = code; } // 5 Random rd = new Random(); // 4 for (int i = 0; i < codes.length; i++) { 
        // (5-1) int index = rd.nextInt(codes.length); } 

• (5-2) 在循环内，将 随机得到的索引位置 用一个临时变量存储起来

  // 1 int[] codes = new int[5]; // 3 Scanner sc = new Scanner(System.in); // 2 for (int i = 0; i < codes.length; i++) { 
        // (3-1) System.out.println("请录入第" + (i+1) + "个员工的工号："); int code = sc.nextInt(); // (3-2) codes[i] = code; } // 5 Random rd = new Random(); // 4 for (int i = 0; i < codes.length; i++) { 
        // (5-1) int index = rd.nextInt(codes.length); // (5-2) int temp = codes[index]; } 

• (5-3) 在循环内，将 每一次从数组中遍历出来的数据 赋值到 随机得到的索引位置

  讯享网// 1 int[] codes = new int[5]; // 3 Scanner sc = new Scanner(System.in); // 2 for (int i = 0; i < codes.length; i++) { 
        // (3-1) System.out.println("请录入第" + (i+1) + "个员工的工号："); int code = sc.nextInt(); // (3-2) codes[i] = code; } // 5 Random rd = new Random(); // 4 for (int i = 0; i < codes.length; i++) { 
        // (5-1) int index = rd.nextInt(codes.length); // (5-2) int temp = codes[index]; // (5-3) codes[index] = codes[i] } 

• (5-4) 在循环内，将 临时变量里存储的随机得到的索引位置 赋值到 每一次从数组中遍历出来的数据的索引位置

  // 1 int[] codes = new int[5]; // 3 Scanner sc = new Scanner(System.in); // 2 for (int i = 0; i < codes.length; i++) { 
        // (3-1) System.out.println("请录入第" + (i+1) + "个员工的工号："); int code = sc.nextInt(); // (3-2) codes[i] = code; } // 5 Random rd = new Random(); // 4 for (int i = 0; i < codes.length; i++) { 
        // (5-1) int index = rd.nextInt(codes.length); // (5-2) int temp = codes[index]; // (5-3) codes[index] = codes[i] // (5-4) codes[i] = temp; } 

• 6、在这些数据完成交换后，在循环后，使用for循环重新遍历一遍数组，输出随机排名的顺序

  讯享网// 1 int[] codes = new int[5]; // 3 Scanner sc = new Scanner(System.in); // 2 for (int i = 0; i < codes.length; i++) { 
        // (3-1) System.out.println("请录入第" + (i+1) + "个员工的工号："); int code = sc.nextInt(); // (3-2) codes[i] = code; } // 5 Random rd = new Random(); // 4 for (int i = 0; i < codes.length; i++) { 
        // (5-1) int index = rd.nextInt(codes.length); // (5-2) int temp = codes[index]; // (5-3) codes[index] = codes[i] // (5-4) codes[i] = temp; } // 6 System.out.println("员工工号的随机排名顺序："); for (int i = 0; i < codes.length; i++) { 
        System.out.print(codes[i] + "\t"); } 

四、数组案例：数组排序

• 就是对数组中的元素，进行升序(由小到大) 或者 降序(由大到小) 的操作。

1、数组排序的技术

• 冒泡排序
• 选择排序
• 快速排序
• 插入排序
• …

2、数组搜索相关的技术

• 二分搜索
• 分块查找
• 哈希表查找
• …

3、目前重点讲冒泡排序

• 预预热，其他的后面再学，毕竟这是属于算法的，得慢慢来

4、冒泡排序的思想

• 每次从数组中找出最大值放在数组的后面去

5、冒泡排序的原理

6、实现冒泡排序的关键步骤分析

• 确定总共需要做几轮：数组的长度 - 1（因为，假如一个数组里有4个数据，那我4-1，做3轮，做完3轮，剩下的最后1个数据是不是已经是最小的了？所以，总共需要做：数组长度-1 轮）
• 每轮比较几次：

  i(轮数) 次数 次数规律：数组长度 - i - 1 0 3 4-0-1 = 3次 1 2 4-1-1 = 2次 2 1 4-2-1 = 1次 

• 一、需求：
  • 将 5 2 3 1，使用冒泡排序来完成升序
• 二、分析：
  • 1.定义一个静态初始化数组，存储这些数据
  • 2.定义一个外部循环控制比较的轮数：确定总共需要做几轮：数组的长度 - 1
  • 3.定义一个内部循环控制比较的次数——>占位，确定总共需要做几次：数组长度 - 轮数 - 1
  • (3-1) 在内部循环内，使用if判断：当前占位的数据 是否 大于后一个位置的数据 若较大 ，则进行位置交换

    讯享网（1）先用临时变量将后一个位置的数据存起来，以免被 当前占位的数据 覆盖掉； （2）将 当前占位的数据 赋值到 后一个位置，java中赋值都是从右往左； （3）将 后一个位置的数据 赋值到 当前占位的数据的位置 

  • 4、将排序后的数组进行遍历后输出

  package com.app.demo; public class Test5 { 
        public static void main(String[] args) { 
        // 目标：学会使用冒泡排序对数据进行升序排序 /* - 需求： 将 5 2 3 1，使用冒泡排序来完成升序 */ // 1.定义一个静态初始化数组，存储这些数据 int[] numbers = { 
       5, 2, 3, 1}; // 索引 0 1 2 3 // 排序前，用于输出后，做对比 System.out.print("排序前："); for (int i = 0; i < numbers.length; i++) { 
        System.out.print(numbers[i] + " "); } // 以下是冒泡排序的重点： // 2.定义一个外部循环控制比较的轮数: 确定总共需要做几轮：数组的长度 - 1 for (int i = 0; i < numbers.length -1; i++) { 
        // 3.定义一个内部循环控制比较的次数——>占位，确定总共需要做几次: 数组长度 - 轮数 - 1 for (int j = 0; j < numbers.length - i - 1; j++) { 
        // (3-1) 在内部循环内，使用if判断： if (numbers[j] > numbers[j+1]) { 
        // 当前占位的数据 是否 大于后一个位置的数据 若较大， // 则进行位置交换 // 先用临时变量将后一个位置的数据存起来，以免被 当前占位的数据 覆盖掉 int temp = numbers[j+1]; // 将 当前占位的数据 赋值到 后一个位置，java中赋值都是从右往左 numbers[j+1] = numbers[j]; // 将 后一个位置的数据 赋值到 当前占位的数据的位置 numbers[j] = temp; } } } // 4.将排序后的数组进行遍历后输出 System.out.print("\n排序后："); for (int i = 0; i < numbers.length; i++) { 
        System.out.print(numbers[i] + " "); } /* 冒泡排序的重点执行流程： 数组数据： 5 2 3 1 -------------------------------- 索引： 0 1 2 3 1.开始进入外部for循环——>负责控制轮数： 第一轮: i = 0, 因此 i < (4-1=3), 为true，进入下一层代码... 第一次比较: j = 0, 因此 j < (4-i-1) 等价于 j < (4-0-1), 为true, 开始进入if判断... 判断: j = 0, 因此当前 0 索引位置的数据是: 5, 与后一位数据 j+1(等价于: 0+1 = 1), 因此 1 索引 位置的数据是: 2; 所以: 5>2, 此次比较的最大值是: 5, 为true, 5 和 2 正在交换位置... 因此数组数据变成: 2 5 3 1, 进入j++... 索引: 0 1 2 3 ---------------------------------------------------------------------------------------- 第二次比较: j = 1, 因此 j < (4-i-1) 等价于 j < (4-0-1), 为true, 开始进入if判断... 判断: j = 1, 因此当前 1 索引位置的数据是: 5, 与后一位数据 j+1(等价于: 1+1 = 2), 因此 2 索引 位置的数据是: 3; 所以: 5>3, 此次比较的最大值是: 5, 为true, 5 和 3 正在交换位置... 因此数组数据变成: 2 3 5 1, 进入j++... 索引: 0 1 2 3 ---------------------------------------------------------------------------------------- 第三次比较: j = 2, 因此 j < (4-i-1) 等价于 j < (4-0-1), 为true, 开始进入if判断... 判断: j = 2, 因此当前 2 索引位置的数据是: 5, 与后一位数据 j+1(等价于: 2+1 = 3), 因此 3 索引 位置的数据是: 1; 所以: 5>1, 此次比较的最大值是: 5, 为true, 5 和 1 正在交换位置... 因此数组数据变成: 2 3 1 5, 进入j++... 索引: 0 1 2 3 ---------------------------------------------------------------------------------------- 第四次比较: j = 3, 因此不符合 j < (4-i-1) 等价于 j < (4-0-1=3), 为false, 不进入if判断，正在进入 第二轮... ------------------------------------------------------------------------------------------- 第二轮: i = 1, 因此 i < (4-1=3), 为true，进入下一层代码... 第一次比较: j = 0, 因此 j < (4-i-1) 等价于 j < (4-0-1), 为true, 开始进入if判断... 判断: j = 0, 因此当前 0 索引位置的数据是: 2, 与后一位数据 j+1(等价于: 0+1 = 1), 因此 1 索引 位置的数据是: 3; 所以: 2<3, 此次比较为false, 位置不变, 正在进入下一次比较... 因此数组数据变成: 2 3 1 5, 进入j++... 索引: 0 1 2 3 ---------------------------------------------------------------------------------------- 第二次比较: j = 1, 因此 j < (4-i-1) 等价于 j < (4-0-1), 为true, 开始进入if判断... 判断: j = 1, 因此当前 1 索引位置的数据是: 3, 与后一位数据 j+1(等价于: 1+1 = 2), 因此 2 索引 位置的数据是: 1; 所以: 3>1, 此次比较的最大值是: 3, 为true, 3 和 1 正在交换位置... 因此数组数据变成: 2 1 3 5, 进入j++... 索引: 0 1 2 3 ---------------------------------------------------------------------------------------- 第三次比较: j = 2, 因此 j < (4-i-1) 等价于 j < (4-0-1), 为true, 开始进入if判断... 判断: j = 2, 因此当前 2 索引位置的数据是: 3, 与后一位数据 j+1(等价于: 2+1 = 3), 因此 3 索引 位置的数据是: 5; 所以: 3<5, 此次比较为false, 位置不变, 正在进入下一次比较... 因此数组数据变成: 2 1 3 5, 进入j++... 索引: 0 1 2 3 ---------------------------------------------------------------------------------------- 第四次比较: j = 3, 因此不符合 j < (4-i-1) 等价于 j < (4-0-1=3), 为false, 不进入if判断，正在进入 第三轮... ------------------------------------------------------------------------------------------- 第三轮: i = 2, 因此 i < (4-1=3), 为true，进入下一层代码... 第一次比较: j = 0, 因此 j < (4-i-1) 等价于 j < (4-0-1), 为true, 开始进入if判断... 判断: j = 0, 因此当前 0 索引位置的数据是: 2, 与后一位数据 j+1(等价于: 0+1 = 1), 因此 1 索引 位置的数据是: 1; 所以: 2>1, 此次比较的最大值是: 2, 为true, 2 和 1 正在交换位置... 因此数组数据变成: 1 2 3 5, 进入j++... 索引: 0 1 2 3 ---------------------------------------------------------------------------------------- 第二次比较: j = 1, 因此 j < (4-i-1) 等价于 j < (4-0-1), 为true, 开始进入if判断... 判断: j = 1, 因此当前 1 索引位置的数据是: 2, 与后一位数据 j+1(等价于: 1+1 = 2), 因此 2 索引 位置的数据是: 3; 所以: 2<3, 此次比较为false, 位置不变, 正在进入下一次比较... 因此数组数据变成: 1 2 3 5, 进入j++... 索引: 0 1 2 3 ---------------------------------------------------------------------------------------- 第三次比较: j = 2, 因此 j < (4-i-1) 等价于 j < (4-0-1), 为true, 开始进入if判断... 判断: j = 2, 因此当前 2 索引位置的数据是: 3, 与后一位数据 j+1(等价于: 2+1 = 3), 因此 3 索引 位置的数据是: 5; 所以: 3<5, 此次比较为false, 位置不变, 正在进入下一次比较... 因此数组数据变成: 1 2 3 5, 进入j++... 索引: 0 1 2 3 ---------------------------------------------------------------------------------------- 第四次比较: j = 3, 因此不符合 j < (4-i-1) 等价于 j < (4-0-1=3), 为false, 不进入if判断，正在进入 第四轮... -------------------------------------------------------------------------------------------- 第四轮: i = 3, 因此不符合 i < (4-1=3), 为false, 循环结束。 因此数组最终排序: 1 2 3 5; 索引: 0 1 2 3 */ } } 

  讯享网输出结果: 排序前：5 2 3 1 排序后：1 2 3 5 

数组排序总结

1、冒泡排序的思想

• 从头开始，两两比较，把较大的元素与较小的元素进行交换
• 每轮把当前最大的一个元素存入到数组当前的末尾

2、冒泡排序的实现步骤

• 定义一个外部循环控制总共需要冒泡几轮：数组长度 - 1
• 定义一个内部循环控制每轮依次往后比较几个位置：数组长度 - 轮数 - 1
• 在内部循环内，定义一个if判断：当前位置的数据 > 后一个位置的数据，则两者交换，否则进入下一次比较