JAVA——数组_9、采用动态创建数组的方式,在键盘上输入10个学生的单科成绩(必须含有不及格

关于数组

数组的声明和创建

//数组声明创建
//先声明，才可使用
public class ArrayDemo01 {
    //变量的类型     变量的名字   =   变量的值
    //数组的类型     数组的名字   =   数组的值
    public static void main(String[] args) {
        int[] nums;//1.声明一个数组类型 名；
        //↑此时数组并不存在，创建了↓才存在
        //2.创建一个数组（new）；这里可存放10个int类型的数字
        nums=new int[10];
        //熟练后可这样写,声明和创建写一起↓
        //    ↓     动态初始化       ↓
        // * int[] nums=new int[10];
        //对比：静态初始化：创建+赋值
        //int[] nums={1,2,3,4}
        //3.赋值给数组
        nums[0]=1;
        nums[1]=20;
        nums[2]=50;
        nums[3]=80;
        nums[4]=100;
        
        //巩固：计算数组里的和
        int sum=0;
        // * 获取数组的长度:nums.length（数组名字.长度）
        // * ”数组遍历”
        for (int i=0;i<nums.length;i++){
            sum=sum+nums[i];
        }
        System.out.println(sum);
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

冒泡排序

import java.util.Arrays;

//冒泡排序
//1.比较的数组中，相邻的的两个元素，第一个比第二个大则交换
//2.每次比较都产生一个最大或最小的数字
//3.下一轮则可以少一次排序
//4.依次循环，直到结束
public class ArrayDemo04 {
    public static void main(String[] args) {
    int [] a={55,45,32,7,5,6,99,8};//静态初始化
    int [] sort=sort(a);//调用我们自己的方法后返回一个 排序后 的数组
                    //打印数组元素（Arrays.toString）
        System.out.println(Arrays.toString(sort));
    }
    //方法↓  ↓可调用        ↓名字   返回一个int[] 方法
     public static int[] sort(int[] array){
            // 新建临时变量
         int temp=0;
         //外层循环，判断走多少 轮
            for (int i = 0; i <array.length-1; i++) {
                //内层循环，比较两个数大小进行交换 此以升序为例
                //第一层循环i表示排序的轮数，第二层循环j表示比较的 次 数
                //            ↓ -i是因为每次比较都出现最大或最小
                for (int j=0;j<array.length-1-i;j++){
                    if(array[j+1]>array[j]){
                        temp=array[j];
                        array[j]=array[j+1];
                        array[j+1]=temp;
                    }
                }
            }
            return array;
        }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

难理解的稀疏数组

public class ArrayDemo05 {
    public static void main(String[] args) {
        int[][] array1=new int[11][11];
        array1[1][2]=1;
        array1[2][3]=2;
        System.out.println("输出原始的数组:");

        //for each循环
        for (int[] ints:array1){
            for (int anInt:ints) {
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }

        //转换为稀疏数组保存
        //获取有效值的个数
        int sum=0;
        for (int i=0;i<11;i++){
            for (int j=0;j<11;j++){
                if(array1[i][j]!=0){
                    sum++;
                }
            }
        }
        System.out.println("有效值的个数:"+sum);

        //2.创建一个稀疏数组        行   列
        int[][] array2=new int[sum+1][3];

        array2[0][0]=11;
        array2[0][1]=11;
        array2[0][2]=sum;

        /*          行   列   值
        [0]←         11  11   sum
        [1]←         1   2     1
        [2]←         2   3     2
         ↑打印时不显示，此为方便理解
         */

        //遍历二维数组，将非零的值，存放稀疏数组中
        int count=0;
        //                    ↓length指数组的行数
        for (int i=0;i<array1.length;i++){
            for (int j=0;j<array1[i].length;j++){
                if(array1[i][j]!=0){
                    count++;//第[]个
                    array2[count][0]=i;//行
                    array2[count][1]=j;//列
                    array2[count][2]=array1[i][j];//数值
                }
            }
        }

        //输出稀疏数组
        System.out.println("稀疏数组");
        //                      ↓length指数组的行数
        for (int i =0;i<array2.length;i++){
            System.out.println(array2[i][0]+"\t"
                        +array2[i][1]+"\t"
                        +array2[i][2]+"\t");
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66