【Java基础阶段】数组

前言

本系列记录Java从入门开始的知识点，数组：数组概述；数组声明创建；数组使用；多维数组；Arrays类；稀疏数组。

文章目录

• 前言
• 一、数组声明创建
• • 1、声明数组
  • 2、计算数组和
  • 3、初始化方法
  • 4、数组的四个基本特点
• 二、数组的使用
• • 1、查找最大元素
  • 2、forEach增强循环
  • 3、反转数组
• 三、多维数组
• 四、Arrays类
• • 1、toString和fill例子
  • 2、冒泡排序
• 五、稀疏数组

---

一、数组声明创建 1、声明数组

public class ArrayDemo01 {
    public static void main(String[] args) {
        int[] nums;  //首选方法
        int nums2[];   //效果相同
    }
}

2、计算数组和

public class ArrayDemo01 {
    public static void main(String[] args) {
        int[] nums;  //首选方法，声明数组，没给空间
        int nums2[];   //效果相同

        nums  = new int[10];//存放10个int数字，给了空间

        for (int i = 0; i < 10; i++) {
            nums[i] = i;
        }

        int sum = 0;
        for (int i = 0; i < nums.length; i++) {
            sum += nums[i];
        }
        System.out.println(sum);
    }
}

3、初始化方法

public class ArrayDemo02 {
    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[2]);
    }
}

4、数组的四个基本特点

1. 数组长度是确定的，大小不能改变；
2. 数组元素类型必须的相同的，不允许出现混合类型；
3. 数组中的元素可以是任何数据类型，包括基本类型和引用类型；
4. 数组变量属于引用类型，数据也可以看作对象，数组中每个元素相当于该对象的成员变量；
5. 数组本身就是对象，Java中对象是存在堆中的。

二、数组的使用 1、查找最大元素

public class ArrayDemo03 {
    public static void main(String[] args) {
        int[] arrays = {1,2,3,4,5,6};
        int max = arrays[0];
        for(int i=0;i < arrays.length;i++){
            max = arrays[i] > max?arrays[i]:max;
        }
        System.out.println(max);
    }
}

2、forEach增强循环

public class ArrayDemo04 {
    public static void main(String[] args) {
        int[] arrays = {1,2,3,4,5,6};
        for (int array : arrays) {
            System.out.println(array);
        }
    }
}

3、反转数组

public class ArrayDemo04 {
    public static void main(String[] args) {
        int[] arrays = {1,2,3,4,5,6};
        printArray(reverse(arrays));
    }
    //反转数组
    public static int[] reverse(int[] arrays){
        int[] newArrays = new int[arrays.length];
        for (int i = 0; i < arrays.length; i++) {
            newArrays[arrays.length-1-i] = arrays[i];
        }
        return newArrays;
    }
    //打印数组
    public static void printArray(int[] arrays){
        for (int array : arrays) {
            System.out.print(array);
        }
    }
}

三、多维数组

public class ArrayDemo05 {
    public static void main(String[] args) {
        int[][] arrays = {{1,2},{2,3},{4,5},{5,6}};
        for (int[] array : arrays) {
            for (int i : array) {
                System.out.print(i);
            }
            System.out.println();
        }
    }
}

四、Arrays类 1、toString和fill例子

public class ArrayDemo06 {
    public static void main(String[] args) {
        int[] a = {4,58,6,32,5,96,88,53,84,24};
        System.out.println(Arrays.toString(a));
        Arrays.fill(a,0);
        System.out.println(Arrays.toString(a));
    }
}

2、冒泡排序

1. 比较数组中两个相邻的元素，如果第一个数比第二个数大，就交换两个数，最后把最大的冒到最后边。
2. 两层循环，外层是冒泡轮数，里层依次比较

五、稀疏数组

public class ArrayDemo08 {
    public static void main(String[] args) {
        int[][] array1 = new int[11][11];
        array1[1][2] = 1;
        array1[2][3] = 1;

        int sum = 0;
        for (int[] ints : array1) {
            for (int anInt : ints) {
                if(anInt != 0){
                    sum++;
                }
            }
        }
        int[][] newArray = new int[sum+1][3];
        newArray[0][0] = array1.length;
        newArray[0][1] = array1[0].length;
        newArray[0][2] = sum;
        int p = 1;
        for (int i = 0; i < array1.length; i++) {
            for (int j = 0; j < array1[0].length; j++) {
                if(array1[i][j] != 0){
                    newArray[p][0] = i;
                    newArray[p][1] = j;
                    newArray[p][2] = array1[i][j];
                    p++;
                }
            }
        }
        for (int[] ints : newArray) {
            System.out.println(Arrays.toString(ints));
        }
    }

原数组：

稀疏数组：