JavaSE学习笔记（三）——数组

目录

1. 数组的概述

2. 数组声明及创建

        声明数组：

        创建数组：

        java内存分析：

        数组的四个基本特点：

3.数组使用

4.二维数组

5.稀疏数组

---

1. 数组的概述

•  数组是相同类型数据的有序集合

      概念理解：数组描述的是相同类型、按照一定的先后次序排列组合而成的的若干数据，其中，每一个数据称作一个数组元素，每个数组元素可以通过一个下标来访问。

2. 数组声明及创建

        声明数组：

        dataType[]     array;        //java风格，首选

         dataType      array[];        //c、c++风格

        创建数组：

dataType[]     array     =       new     dataType[arraySize];

        tips:1.数组元素是通过下标索引来访问的，数组下标索引从0开始

                2.可以通过array.length这一属性来获取数组长度

        java内存分析：

        举个例子：在声明数组时，会在栈中压入array这个引用类型变量，来存放array在堆里的具体地址；在创建数组时，会往堆里面开辟一个内存空间（这就是array指向的内存地址空间），存放对应的int[]对象，然后再是给int类型的变量逐一赋值。

        数组的四个基本特点：

1.   数组的长度是确定的，数组一旦被创建，那么它的大小就不可更改。
2.   数组的元素必须是相同类型的，不允许出现混合类型。
3.   数组中的元素可以是基本数据类型也可以是引用类型。
4.   数组变量属于引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量，而Java中对象是在堆中的，因此数组无论保存原始类型还是其它对象类型，数组对象本身是在堆中的。

3.数组使用

        1.for循环

        2.for-each循环

        3.数组作方法入参

        4.数组作返回值

package array;

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

        //for-each循环，没有下标
        for (int array : arrays) {
            System.out.println(array);
        }

        //将数组作为返回值
        int[] reverse= reverse1(arrays);
        printArray(reverse);
        
        reverse2(arrays);
        printArray(arrays);
    }

    //数组作方法入参，打印数组元素
    public static void printArray(int[] arrays) {
        for (int i = 0; i < arrays.length ; i++) {
            System.out.print(arrays[i]+"\t");
        }
        System.out.println();
    }

    //反转数组1  新定义一个数组来存储反转的值
    public static int[] reverse1(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;
    }

    //反转数组2  直接在现有的数组上进行反转
    public static int[] reverse2(int[] arrays)
    {
        int start=0;
        int end=arrays.length-1;
        while (start<end)
        {
            int temp=arrays[start];
            arrays[start]=arrays[end];
            arrays[end]=temp;
            start++;
            end--;
        }
        return arrays;
    }
}

4.二维数组

        二维数组就是一个特殊的一维数组，其中每个元素都是一个一维数组，俗称套娃。

        

 

5.稀疏数组

 

package array;
//稀疏数组
//       row   col  value
//[0]   11      11      2
//[1]   1       2       1
//[2]   2       3       2
public class Demo02 {
    public static void main(String[] args) {
        //创建一个二维数组 11*11   0：没有棋子  1：黑棋  2：白棋
        int[][] array1=new int[11][11];
        array1[1][2]=1;
        array1[2][3]=2;
        //输出原始数组
        System.out.println("输出原始数组：");

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

        //转化为稀疏数组

        //1.获取有效值的个数
        int sum=0;
        for (int i = 0; i < array1.length; i++) {
            for (int j = 0; j < array1[0].length; 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;

        //遍历二维数组，将非零的值，存放到稀疏数组中
        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)
                {
                    array2[++count][0]=i;
                    array2[count][1]=j;
                    array2[count][2]=array1[i][j];
                }
            }
        }

        //打印稀疏数组
        for (int i = 0; i < array2.length; i++) {
            for (int j = 0; j < 3; j++) {
                System.out.print(array2[i][j]+"\t");
            }
            System.out.println();
        }

        System.out.println("==============");
        System.out.println("还原稀疏数组");

        //读取稀疏数组
        int[][] array3=new int[array2[0][0]][array2[0][1]];
        for (int i = 1; i < array2.length; i++) {
            array3[array2[i][0]][array2[i][1]]=array2[i][2];
        }

        for(int[] ints : array3)
        {
            for(int anInt : ints)
            {
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }
    }
}