数组复习3.2

最新推荐文章于 2025-05-28 10:48:32 发布

励志成小牛

最新推荐文章于 2025-05-28 10:48:32 发布

阅读量106

点赞数

文章标签：算法数据结构排序算法

本文链接：https://blog.youkuaiyun.com/weixin_46973700/article/details/129362918

版权

本文介绍了Java中的数组概念，包括如何声明、创建和初始化数组，如静态和动态初始化。文章还展示了数组的使用，包括计算数组元素总和、查找最大元素以及冒泡排序。此外，还讨论了二维数组和稀疏数组的应用，特别是当数组中存在大量零值或相同值时的优化存储策略。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

数组的复习

package com.Array;

public class Demo01 {
    //变量的名字  变量的名字 = 变量的值;
    //数组类型
    //使用new操作符来创建数组，语法:dataType[] array = new dataType[arraySize];
    public static void main(String[] args){
        int[] nums;//1.声明一个数组
        nums = new int[10];//2.这里面可以存放10个int类型的数字，创建一个数组
        //也可以这样自定义:int[] nums = new int[10];
        //3.给数组元素赋值
        nums[0] = 1;
        nums[1] = 2;
        nums[2] = 3;
        nums[3] = 4;
        nums[4] = 5;
        nums[5] = 6;
        nums[6] = 7;
        nums[7] = 8;
        nums[8] = 9;
        nums[9] = 10;
        System.out.println(nums[9]);
        //计算所有元素的和
        int sum = 0;
        for(int i = 0;i < nums.length;i++){
            sum += nums[i];
        }
        System.out.println("总和为:" + sum);//输出结果为总和：55
    }
}

声明并且创建：int[] num = new int[10];//声明和创建写在一起了

1、数组初始化分析：

如果代码中出现这个错误：ArrayIndexOutOfBoundsException

分析：数组下标越界，比如一共有十个数组，取得是第十一个数组，不存在第十一个，所以出现这个错误

三种初始化状态：

1、静态初始化

int[] a = {1,2,3};

Man[] mans = {new Man(1,1),new Man(2,2)};

2、动态初始化

int[] a = new int[2];

a[0] = 1;

a[1] = 2;

package com.Array;

public class Demo01 {
    //变量的名字  变量的名字 = 变量的值;
    //数组类型
    //使用new操作符来创建数组，语法:dataType[] array = new dataType[arraySize];
    public static void main(String[] args){
        //静态初始化
        int[] a = {1,2,3,4};
        System.out.println(a[0]);

        //动态初始化
        int[] b = new int[10];
        b[0] = 14;
        System.out.println(b[0]);
        System.out.println(b[1]);//没有被初始化的数组的值都是0
    }
}

3、数组的使用：

1）、低阶版本数组的使用

package com.Array;

public class Demo01 {
    public static void main(String[] args){
        int[] arrays = {1,2,3,4,5};

        //打印全部的数组元素
        for(int i = 0;i < arrays.length;i++){
            System.out.println(arrays[i]);
        }
        int sum = 0;
        for (int i = 0;i < arrays.length;i++){
            sum = sum + arrays[i];
        }
        System.out.println("sum="+sum);//输出结果为15

        //查找最大元素
        int max = arrays[0];
        for (int i = 0;i < arrays.length;i++){
            if(arrays[i]>max){
                max = arrays[i];
            }
        }
        System.out.println("max="+max);//输出结果为5
    }
}

2）、高阶版本数组的使用

package com.Array;

public class Demo01 {
    public static void main(String[] args){
        int[] arrays = {1,2,3};
        //printArray(arrays);

        int[] reverse = reverse(arrays);
        printArray(reverse);//输出结果为3、2、1

    }

    //打印数组元素
    public static void printArray(int[] arrays){
        for (int i = 0;i < arrays.length;i++){
            System.out.println(arrays[i]+"");
        }
    }

    //反转数组
    public static int[] reverse(int[] arrays){
        int[] result = new int[arrays.length];

        //反转的操作
        for (int i = 0,j = result.length-1;i < arrays.length;i++,j--){
            result[j] = arrays[i];
        }
        return result;
    }
}

4、二维数组的是使用

package com.Array;

public class Demo02 {
    public static void main(String[] args){
        int[][] array = {{1,2},{2,3},{3,4}};
        //printArray(array[0]);//输出的是1、2
        //System.out.println(array[2][0]);
        //System.out.println(array[0][1]);
        for (int i = 0;i < array.length;i++){
            for (int j = 0;j <array[i].length;j++){
                System.out.println(array[i][j]);//输出结果为1、2、2、3、3、4
            }
        }
    }
    /*
    public static void printArray(int[] arrays){
        for (int i = 0;i < arrays.length;i++){
            System.out.println(arrays[i]+"");
        }
    }//一维数组的输出
    */
}

5、数组工具类Arrays类

Arrays.toString(a) 的作用是打印数组元素，以字符串的形式表现出来

Arrays.sort(a); 的作用是对数组进行排序，升序

Arrays.fill(a,2,4,0); 的作用是数组填充,a代表数组，2到4指第二个数到第四个数，0指填充的元素是0

package com.Array;

import java.util.Arrays;

public class Demo02 {
    public static void main(String[] args){
        int[] a = {1,2,45,78,14,25,74,95};
        //System.out.println(a);
        System.out.println(Arrays.toString(a));//打印数组元素,输出结果为[1, 2, 45, 78, 14, 25, 74, 95]
        //printArray(a);

        Arrays.sort(a);//对数组进行排序，升序
        Arrays.fill(a,2,4,0);//数组填充,a代表数组，2到4指第二个数到第四个数，0指填充的元素是0
    }

    public static void printArray(int[] a){//模仿工具类Arrays.toString(a)写的代码
        for (int i = 0;i < a.length;i++){
            if(i == 0){
                System.out.print("["+a[0]+",");
            } else if (i == a.length-1) {
                System.out.print(a[a.length-1]+"]");
            }else {
                System.out.print(a[i]+",");
            }
        }
    }
}

6、冒泡排序

package com.Array;

import java.util.Arrays;

public class Demo02 {
    public static void main(String[] args){

        //冒泡排序
        int[] a = {1,5,4,7,9,24,51,10,3};
        int[] sort = sort(a);
        System.out.println(Arrays.toString(a));
    }

    public static int[] sort(int[] array){
        int temp = 0;
        boolean flag = false;
        //外层循环，判断我们要走多少次
        for(int i = 0;i < array.length-1;i++){
            //内层循环，比较判断两个数，若第一个比第二个数大则交换位置
            for(int j = 0;j < array.length-i-1;j++){
                if (array[j+1] > array[j]){
                    temp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = temp;
                    flag = true;
                }
            }
            if (flag == false){
                break;
            }
        }
        return array;
    }
}

7、稀疏数组

当一个数组大部分都是0或者为同一数值时，可以用稀疏数组来保存该数组

package com.Array;

public class Demo03 {
    public static void main(String[] args){
        //1、创建一个二维数组11*11  0：没有棋子  1：黑棋  2：白棋
        int[][] array1 = new int[11][11];
        array1[1][2] = 1;
        array1[2][3] = 1;
        //输出原始数组
        System.out.println("输出原始数组：");
        for (int[] ints : array1) {//第一个循环打印一行数组元素
            for (int anInt : ints) {//第二个循环打印一行的每一列元素
                System.out.println(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];//sum代表的是行数，3代表的是列数
        array2[0][0] = 11;
        array2[0][1] = 11;
        array2[0][2] = sum;

        //遍历二维数组，将非零的值存放在稀疏数组中
        int count = 0;
        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];
                }
            }
        }
        //输出数组
        for (int i = 0;i < array2.length;i++){
            System.out.println(array2[i][0]+"\t"
            +array2[i][1]+"\t"
            +array2[i][2]+"\t");
        }


    }
}