4 数组篇

数组的概念

数组时相同类型数据的有序集合
数组描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成
数组中每一个数据称作数组元素，每个数组元素可以通过一个下标来访问它

数组声明创建

声明数组变量语法：

dataType[] arraysRefVar; //首选

dataType arraysRefVar[]; //知道就行

创建数组语法:

在我们声明数组之后可以用 arraysReVar = new dataType[arraysSize];

在我们声明数组之前可以用 dataType[] arraysReVar= new dataType[arrsysSize];

获取数组长度：

arrays.length

package com.fan.Arrays;

public class Demo01 {
    public static void main(String[] args) {
        //声明一个数组
        int[] num1;
        //创建一个数组
        num1 = new int[10];
        //声明并创建一个数组
        int[] num2 = new int[10];
        //给数组中元素赋值
        num1[0] = 1;
        num1[1] = 2;
        num1[2] = 3;
        num1[3] = 4;
        num1[4] = 5;
        num1[5] = 6;
        num1[6] = 7;
        num1[7] = 8;
        num1[8] = 9;
        num1[9] = 10;
        //计算所有元素和
        int sum = 0;
        for (int i = 0; i < num1.length; i++) {
            sum+= num1[i];
        }
        System.out.println("数组1的所有元素和为："+sum);
    }
}

三种初始化

package com.fan.Arrays;

public class Demo02 {
    public static void main(String[] args) {
        //静态初始化 声明+赋值
        int[] a = {1,2,3,4,5};
        System.out.println(a[0]);

        //动态初始化: 包含默认初始化
        int[] b = new int[10];
        b[0] = 10;
        System.out.println(b[0]);

        //默认初始化
        int[] c = new int[10];
        System.out.println(c[0]);
    }
}

数组的四个基本特点

长度确定
其内元素必须是相同类型
其内元素可以是任何数据类型
数组变量属于引用类型

数组对象本身是在堆中的

数组的边界

ArrayIndexOutOfBoundsException : 数组下标越界异常！

数组使用

package com.fan.Arrays;

public class Demo03 {
    public static void main(String[] args) {
        //For循环
        int[] a = {1,2,3,4,5};
        //遍历所有元素
        for (int i = 0; i < a.length; i++) {
            System.out.print(a[i]+"\t");
        }
        System.out.println("\n"+"________________________");
        for (int x:a){
            System.out.print(x+"\t");
        }
        System.out.println("\n"+"________________________");
        //计算数组元素之和
        int sum = 0;
        for (int i = 0; i < a.length; i++) {
            sum += a[i];
        }
        System.out.println("\n"+sum);
        System.out.println("\n"+"________________________");
        //查找最大元素
        int max = a[0];
        for (int i = 1; i < a.length; i++) {
            if (a[i] > max){
                max = a[i];
            }
        }
        System.out.println(max);
    }
}

package com.fan.Arrays;

public class Demo04 {
    public static void main(String[] args) {
        //数组作方法入参and作返回值
        int[] a = {1,2,3,4,5};
        ite(a);
        System.out.println("_________________");
        int[] reverse = reverse(a);
        ite(reverse);
    }
    //反转数组
    public static int[] reverse (int[] arrays){
        int[] result = new int[arrays.length];
        for (int i = 0, j = arrays.length-1; i < arrays.length; i++,j--) {
            result[j] = arrays[i];
        }
        return result;
    }
    //遍历数组
    public static void ite (int[] arrays){
        for (int i = 0; i < arrays.length; i++) {
            System.out.println(arrays[i]);
        }
    }
}

多维数组

package com.fan.Arrays;

public class Demo05 {
    public static void main(String[] args) {
        //声明并创建一个多维数组 //静态初始化
        int[][] arrays1= {{0,1},{1,2},{2,3},{3,4}};
        //动态初始化
        int[][] arrays2= [4][2]; //大小和arrays1一致 为4行2列
        //输出该数组的某个元素
        System.out.println(arrays1[0][0]);
        System.out.println(arrays1[1][1]);
        System.out.println(arrays1[2][0]);
        System.out.println(arrays1[3][1]);
        System.out.println("-------------------");

        //遍历该数组
        for (int i = 0; i < arrays1.length; i++) {
            for (int j = 0; j < arrays1[i].length; j++) {
                System.out.println(arrays1[i][j]);
            }
        }
    }
}

Arrays类

数组的工具类java.util.Arrays

package com.fan.Arrays;

import java.util.Arrays;

public class Demo06 {
    public static void main(String[] args) {
        int[] a = {1,2,3,4,5,999,0,888,666,1314,521};
        //输出数组
        System.out.println(Arrays.toString(a));
        //排序并输出数组
        Arrays.sort(a);
        System.out.println(Arrays.toString(a));
        //填充数组 输出填充后的数组
        Arrays.fill(a,0);
        System.out.println(Arrays.toString(a));
        //替换部分数组的数组 并输出
        Arrays.fill(a,2,4,6);
        System.out.println(Arrays.toString(a));
    }
}

冒泡排序

package com.fan.Arrays;

import java.util.Arrays;

public class Demo07 {
    public static void main(String[] args) {
        int[] a = {2,4,7,9,1,5,6,2,8,5,33,5,1,44};
        int[] a1 = sort(a);
        System.out.println(Arrays.toString(a1));
    }
    public static int[] sort (int[] array){ //冒泡排序
        //定义一个空容器
        int temp = 0;
        //外部循环
        for (int i = 0; i < array.length-1; i++) {
            //内部循环
            for (int j = 0; j < array.length-1-i; j++) {
                //相邻两数比较大小
                if (array[j] > array[j+1]){
                    //相邻两数互换位置
                    temp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = temp;
                }
            }

        }
        //返回array
        return array;
    }
}

稀疏数组

package com.fan.Arrays;

public class Demo08 {
    public static void main(String[] args) {
        //创建原数组
        int[][] a = new int[11][11];
        a[1][2] = 1;
        a[2][3] = 2;
        //遍历原数组（增强for循环）
        for (int[] ints : a) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }
        System.out.println("-------------------");
        //开始搭建稀疏数组
        int sum = 0;
        //读取有效值的个数
        for (int i = 0; i < a.length; i++) { //原数组的行数
            for (int j = 0; j < a[i].length; j++) { //原数组的列数
                if (a[i][j] != 0){
                   sum++; //记录有效值的个数
                }
            }
        }
        //创建稀疏数组
        int[][] a1 = new int[sum+1][3];
        //给稀疏数组的题头赋值
        a1[0][0] = a.length;
        a1[0][1] = a[0].length;
        a1[0][2] = sum;
        //读取有效值坐标和有效值并存入稀疏数组中
        int count = 0;
        for (int i = 0; i < a.length; i++) { //原数组的行数
            for (int j = 0; j < a[i].length; j++) { //原数组的列数
                if (a[i][j] != 0){
                    count++; //记录有效值的个数
                    a1[count][0] = i; //横坐标
                    a1[count][1] = j; //纵坐标
                    a1[count][2] = a[i][j]; //有效值
                }
            }
        }
        //遍历稀疏数组（增强for循环）
        for (int[] ints : a1) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }
        System.out.println("-------------------");
        //还原原数组
        int[][] a2 = new int[a1[0][0]][a1[0][1]]; //从稀疏数组中读取到原数组的大小
        for (int i = 1; i <= a1[0][2]; i++) {
            a2[a1[i][0]][a1[i][1]] = a1[i][2]; //从稀疏数组中读取到原数组的有效值及坐标
        }
        //遍历原数组（普通for循环）
        for (int i = 0; i < a2.length; i++) {
            for (int j = 0; j < a2[i].length; j++) {
                System.out.print(a2[i][j]+"\t");
            }
            System.out.println();
        }
    }
}

posted @ 2026-01-27 23:02 Shadow001 阅读(3) 评论(0) 收藏举报

刷新页面返回顶部

Shadow001