尚学堂 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("
==============排序前====================");
        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("
==============排序后====================");
        for(int score : scores) {
            System.out.print(score + " ");
        }

        System.out.println("
======================================");
        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("
==============排序前====================");
        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("
==============排序后====================");
        for(int score : scores) {
            System.out.print(score + " ");
        }

        System.out.println("
======================================");
        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("
==============排序前====================");
        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("
==============排序后====================");
        for(int score : scores) {
            System.out.print(score + " ");
        }

        System.out.println("
======================================");
        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();
        }

    }

}