java-冒泡排序 选择排序 二维数组

二维数组及其应用
二维数组：二维数组其实就是一个元素为一维数组的数组。
二维数组也分动态初始化和静态初始化两种。
动态初始化：
（一）指定有多少个长度相同的一维数组
数据类型[][] 变量名 = new 数据类型[m][n];
m表示这个二维数组有多少个一维数组
n表示每一个一维数组的元素个数
根据动态初始化（一）可以完成如下需求：
需求：请定义一个二维数组,二维数组有三个一维数组,每个一维数组有两个元素。
1.打印二维数组名称
2.打印每一个一维数组
3.不给元素赋值打印元素
4.赋值后打印元素

package com.stu04;
    //需求：请定义一个二维数组,二维数组有三个一维数组,每个一维数组有两个元素。
public class ArrStu01 {
    public static void main(String[] args) {
        //动态初始化方式一（指定有多少个长度相同的一维数组）：
        //数据类型[][] 变量名 = new 数据类型[m][n];
        int[][] arr=new int[3][2];
        /*1.打印二维数组名称
        2.打印每一个一维数组*/
        System.out.println(arr);
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);
        //3.不给元素赋值打印元素
        System.out.println(arr[1][0]);
        /*4.赋值后打印元素*/
        arr[2][1]=8;
        System.out.println(arr[2][1]);  
    }
}

编译运行后结果为：
[[I@40dea6bc
[I@5994a1e9
[I@2d11f5f1
[I@7629b854
0
8
有其对应的相关图解如下：

（二）：指定二维数组中有多少个一维数组，每一个一维数组的长度不固定
数据类型[][] 变量名 = new 数据类型[m][];
注意：
m这个数据必须给出，后面的数据可以不给
需求：定义一个有3个一维数组的二维数组
1.给这个二维数组的每一个一维数组的元素赋值2.打印二维数组的名称
3.打印二维数组中每一个一维数组的名称
4.打印二维数组中的每一个一位数组中的元素

public class ArrayArrayDemo2 {
    public static void main(String[] args) {
        //需求：定义一个有3个一维数组的二维数组,每一个一维数组的长度不固定
        int[][] arr = new int[3][];
        //3.打印二维数组中每一个一维数组的名称
        System.out.println(arr[0]);//null
        System.out.println(arr[1]);//null
        System.out.println(arr[2]);//null
        //1.给这个二维数组的每一个一维数组的元素赋值
        //arr[0] = {1,2,3};//在这里无法使用一维数组的静态初始化给二维数组中的每一个元素赋值
        //第一个一维数组有两个元素
        arr[0] = new int[2];
        arr[0][0] = 10;
        arr[0][1] = 20;
        //第二个一维数组，长度为3
        arr[1] = new int[3];
        arr[1][0] = 2;
        arr[1][1] = 3;
        arr[1][2] = 4;
        //第三个一维数组，长度为2
        arr[2] = new int[2];
        arr[2][0] = 4;
        arr[2][1] = 5;
        //2.打印二维数组的名称
        System.out.println(arr);//[[I@7f39ebdb
        //3.打印二维数组中每一个一维数组的名称
        System.out.println(arr[0]);//[I@4ec4d412
        System.out.println(arr[1]);//[I@5c3f1224
        System.out.println(arr[2]);//[I@30c028cc
        //4.打印二维数组中的每一个一位数组中的元素（手动打印几个即可）
        System.out.println(arr[0][0]);
        System.out.println(arr[2][0]);
    }
}

编译运行后结果为：
null
null
null
[[I@40dea6bc
[I@5994a1e9
[I@2d11f5f1
[I@7629b854
10
4
对应的内存图解为：

静态初始化：
数据类型[][] 变量名 = new 数据类型[][]{{元素…},{元素…},{元素…}};
简化格式：
数据类型[][] 变量名 = {{元素…},{元素…},{元素…}};
需求：定义一个里面有3个长度不一样的一维数组的二维数组

public class ArrayArrayDemo4 {
    public static void main(String[] args) {
        //定义一个三个长度不意义样的一位数组的二维数组，并遍历
        int[][] arr = {{1,2},{3,4,5},{6,7,8,9,0}};
        //利用for循环遍历二维数组
        for (int i = 0; i < arr.length; i++) {
            //拿到每一个一维数组之后，遍历一位数组中的每一个元素
            for (int j = 0; j < arr[i].length; j++) {
                System.out.print(arr[i][j]);
            }
            System.out.println();
        }   
    }
}

编译运行结果如下：
12
345
67890
再做一个深入的需求：
二维数组的求和：
公司年销售额求和
某公司按照季度和月份统计的数据如下：单位(万元)
第一季度：22,66,44
第二季度：77,33,88
第三季度：25,45,65
第四季度：11,66,99

package com.stu04;
public class ArrStu02 {
    public static void main(String[] args) {
        int[][] arr={{22,66,44},{77,33,88},{25,45,65},{11,66,99}};
        int sum=0;
        for(int i=0;ifor(int j=0;jout.println(sum);
    }
}

最后求得结果为：
641
冒泡排序与选择排序
冒泡排序基本概念是：
相邻的两个元素进行比较，小的放前面，大的放后面
画图讲解冒泡排序，int[] arr = { 24, 69, 80, 57, 13 };

相应的代码实现如下：

package com.stu05;
import java.util.Arrays;
/*冒泡排序基本概念是：
相邻的两个元素进行比较，小的放前面，大的放后面*/
public class SortStu01 {
    public static void main(String[] args) {
        int[] arr={ 24, 69, 80, 57, 13 };
        for(int i=0;i1;i++){
            for(int j=0;j1-i;j++){
                if(arr[j]>arr[j+1]){
                    int temp=arr[j];
                    arr[j]=arr[j+1];
                    arr[j]=temp;
                }
            }
        }
        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr));   
    }
}

编译运行结果：
[13, 24, 57, 69, 80]
选择排序概念：
选择排序：
从0索引开始，依次和后面的每一个元素进行比较
第一次比较完毕，最小值出现在了最小索引处
第二次比较完毕，次小值出现在了次小索引处
…
完毕后，就排序了。
画图讲解选择排序规则
相应的代码实现如下：

package com.stu05;
import java.util.Arrays;
//运用选择排序int[] arr = { 24, 69, 80, 57, 13 };进行排序
public class SortStu02 {
    public static void main(String[] args) {
        int[] arr = { 24, 69, 80, 57, 13 };
        for(int i=0;ifor(int j=i+1;jif(arr[i]>arr[j]){
                    int temp=arr[i];
                    arr[i]=arr[j];
                    arr[j]=temp;
                }
            }
        }
        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr));
    }
}

编译运行结果为：
[13, 24, 57, 69, 80]