尚学堂 JAVA DAY11 概念总结

1.冒泡排序算法 《升序排列》

思路1：
数组长度为n,那么要对数组进行n-1次遍历;

step 1---从数组的第一个数开始，两两比较，如果第一个数 > 第二个数，将二者进行交换；
之后拿第二个数与第三个数进行比较，若 第二个数 > 第三个数，将二者进行交换；
依此类推，直到 第n-2个数 和 第n-1个数比较完。

此时，该数组中最大的数将排在数组的最后一个位置。

step 2---重复step1,直到遍历完整个数组。

 public class NewArray {
     public static void main(String[] args) {
         //声明并定义一个无序的数组
         int[] scores = new int[15];
         for(int i = 0; i < scores.length; i++) {
             scores[i] = (int)(Math.random() * 101);
         } 

         //排序前 打印数组
         System.out.println("\n==============排序前====================");
         for(int score : scores) {
             System.out.print(score + " ");
         }

         //排序进行时 升序排列
         int temp = 0;
         int counter = 0;
         for(int j = 0; j < scores.length - 1; j++) {
             for(int i = 0; i < scores.length - 1; i++) {
                 if(scores[i] > scores[i+1]) {
                     temp = scores[i];
                     scores[i] = scores[i+1];
                     scores[i+1] = temp;
                 }
             }
                 counter++;
         }

         //排序后 打印数组
         System.out.println("\n==============排序后====================");
         for(int score : scores) {
             System.out.print(score + " ");
         }

         System.out.println("\n======================================");
         System.out.println("共进行了" + counter + "次比较");
     }
 }

思路2：
数组长度为n,那么要对数组进行n-1次遍历；

step 1---从数组的第一个数开始，两两比较，交换，直到数组元素的（索引 == 数组长度 - 1 - 第i次）遍历数组结束。

step 2---重复step1，直到数组遍历结束。

public class NewArray {
    public static void main(String[] args) {
        //声明并定义一个无序的数组
        int[] scores = new int[15];
        for(int i = 0; i < scores.length; i++) {
            scores[i] = (int)(Math.random() * 101);
        } 

        //排序前 打印数组
        System.out.println("\n==============排序前====================");
        for(int score : scores) {
            System.out.print(score + " ");
        }

        //排序进行时 升序排列

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

        //排序后 打印数组
        System.out.println("\n==============排序后====================");
        for(int score : scores) {
            System.out.print(score + " ");
        }

        System.out.println("\n======================================");
        System.out.println("共进行了" + counter + "次比较");
    }
}

思路3：
数组长度为n,那么要对数组进行n-1次遍历；

step 1---从数组的第一个数开始，两两比较，交换，直到数组元素的（索引 == 数组长度 - 1 - 第i次）遍历数组结束。

step 2---重复step1，直到数组中没有发生元素的交换为止。

 public class NewArray {
     public static void main(String[] args) {
         //声明并定义一个无序的数组
         int[] scores = new int[15];
         for(int i = 0; i < scores.length; i++) {
             scores[i] = (int)(Math.random() * 101);
         } 

         //排序前 打印数组
         System.out.println("\n==============排序前====================");
         for(int score : scores) {
             System.out.print(score + " ");
         }

         //排序进行时 升序排列
         int temp = 0;
         int counter = 0;
         boolean hasChanged = false;
         for(int j = 0; j < scores.length - 1; j++) {
             //每一次遍历开始都认为数列无序，数据未发生过交换
             hasChanged = false;
             for(int i = 0; i < scores.length - 1 - j; i++) {
                 if(scores[i] > scores[i+1]) {
                     //只要发生了交换，标志位置为true,表示还需进行下一次比较
                     hasChanged = true;
                     temp = scores[i];
                     scores[i] = scores[i+1];
                     scores[i+1] = temp;
                 }
             }
             counter++;
             if(!hasChanged){
                 break;
             }
         }

         //排序后 打印数组
         System.out.println("\n==============排序后====================");
         for(int score : scores) {
             System.out.print(score + " ");
         }

         System.out.println("\n======================================");
         System.out.println("共进行了" + counter + "次比较");
     }
 }

 2.方法的重载
     一个类中可以存在 [方法名相同、功能相同、参数不同（形参类型、形参数量）的 多个方法]。 这叫方法的重载。
     如：
         Arrays.sort(int[] arr);
         Arrays.sort(float[] arr);
         Arrays.sort(byte[] arr);
         Arrays.sort(double[] arr);
         ...
     顺便学习了Arrays类的使用，以及API文档的查阅
 import java.util.Arrays;

 public class TestArraysClass {
     public static void main(String[] args) {
         //声明并定义一个无序的数组
         int[] scores = new int[15];
         for(int i = 0; i < scores.length; i++) {
             scores[i] = (int)(Math.random() * 101);
         } 

         //输出数组
         System.out.println(Arrays.toString(scores));

         //将数组排序
         Arrays.sort(scores);

         //输出数组
         System.out.println(Arrays.toString(scores));

         //查询某个元素
         System.out.println(Arrays.binarySearch(scores,4));

         //复制一个数组
         int[] newScores = Arrays.copyOf(scores,0);

         //打印新数组
         System.out.println(Arrays.toString(newScores));

     }
 }

3.可变参数
1)格式：
方法头(类型 ... 参数变量名) {
方法实体
}
2)特点：(要背)
a.只能作为方法的形参；
b.JDK1.5之后提供；
c.可接受八种基本数据类型和数组类型数据；
d.可以接受0个、1个和多个实参；
e.可变参数只能是最后一个参数；
f.定义了可变参数的方法后，不可定义数组为形参的方法；
g.重载的方法包括可变参数 和 确定数量参数的方法时，会优先调用确定数量参数的方法，而
忽略可变参数的方法。

4.main方法如何接收实参？
格式：
java 类名 参数1 参数2 参数3...

5.二维数组
1) 声明格式：
类型[][] 数组名; 或
类型 数组名[][];
2) 分配空间：
new 类型[长度][长度]; ---将二维数组的第一维和第二维都分配空间，使这都有默认值。
或
new 类型[长度][];---仅给二维数组的第一维分配空间，其默认值为null；
3) 动态初始化
数组名[][] = ...;
4) 静态初始化
是将上述三步合而为一。
类型[][] 数组名 = new 类型[][]{{},{},{}...};
或
类型[][] 数组名 = {{},{},{}...};

 public class TwoDArray{

     public static void main(String[] args) {

         //int[][] scores = new int[][]{{80,90,78},{90,80},{0,70}};
         int[][] scores = {{80,90,78},{90,80},{0,70}};

         /*scores[0] = new int[4];
         scores[1] = new int[3];
         scores[2] = new int[2];

         scores[0][0] = 80;
         scores[0][1] = 79;
         scores[0][2] = 78;

         scores[1][0] = 90;
         scores[1][1] = 80;

         scores[2][1] = 70;    */

         for(int i = 0; i < scores.length; i++) {
             for(int j = 0; j < scores[i].length; j++) {
                 System.out.print(scores[i][j] + " ");
             }
             System.out.println();
         }

     }

 }