Java数组详解

数组详解

1、数组概述

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

　　每一个数据称作一个数组元素，每个数组元素可以通过一个下标来访问它们

 

2、数组声明和创建

　　①数组声明形式

dataType[] arrayRefVar;         //首选的方法
dataType arrayRefVar[];

　　②数组的创建

dataType[] arrayRefVar=new dataType[arraySize];

　　③数组元素是通过索引访问的，数组索引从0开始

 

3、内存分析及三种初始化方式

　　①Java内存

           

　　②定义数组时内存分配情况

　　　　　1.声明数组—int[] array=null；

　　　　　　在栈中存放变量，如图所示

　　　　　　　　　　　　

　　　　　　2.创建数组—array=new int[5]；

　　　　　　　在堆中开辟空间，如图所示

　　　　　　　　　　

　　　　　　　　3.给数组元素赋值

　　　　　　　　　array[0]=0;array[1]=1;array[2]=2;未赋值元素是默认值0

　　　　　　　　　　

　　③三种初始化方式

　　　　1.静态初始化

int[] array={1,2,3};
Man[] mans={new Man(1,1),new Man(2,2)};  //Man是类

　　　　2.动态初始化

int[] array=new int[2];
array[0]=1;
array[1]=2;

　　　　3.默认初始化

　　　　　　数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化

 

4、数组基本特点

　　①数组长度是确定的

　　②元素必须是相同类型

　　③数组中的元素可以是任何数据类型，包括基本类型和引用类型

　　④数组对象本身是保存在堆中的，数组也是对象

 

5、数组边界问题

　　①下标合法区间—[0，length-1]

　　②数组越界会报ArrayIndexOutOfBoundsException异常

 

6、数组的使用

　　①For—Each循环

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

　　②数组作方法入参

public static void printArray(int[] arrays){
        for(int i=0;i<arrays.length;i++){
            System.out.print(arrays[i]+" ");
        }
    }

　　③数组作为返回值

 public static int[] reverse(int[] arrays){
        int result[]=new int[arrays.length];
        int i=0;
        for(int j=arrays.length-1;j>=0;j--){
            result[i]=arrays[j];
            i++;
        }
        return result;
    }

 

7、多维数组

　　多维数组可以看成是数组的数组

　　例如：int[] [] nums=new int[3] [2];

　　

 

8、Arrays类

　　①数组的工具类java.util.Arrays，Arrays类中的方法都是static修饰的静态方法，在使用的时候可以直接使用类名进行调用

int a[]={1,2,3};
System.out.print(Arrays.toString(a));//输出数组元素

 

方法名	作用
toString(a)	输出数组元素
sort(a)	按升序对数组元素进行排序
equals(a1,a2)	比较数组元素是否相等
binarySearch(a,3)	查找指定元素索引值
fill(a,2)	给数组赋值

 

9、稀疏数组

　　①当一个数组中大部分元素为0，或者同一值的数组时，可以使用稀疏数组来保存该数组

　　②稀疏数组的处理方式是：

　　　　1.记录数组一共有几行几列，有多少个不同值

　　　　2.把具有不同值得元素和行列及值记录在一个小规模的数组中，从而缩小程序的规模

　　　　　　　　　　　　

public class Sparse {
    public static void main(String[] args) {
        //定义一个数组
        int array1[][]=new int[6][6];
        array1[0][2]=3;
        array1[3][3]=6;
        array1[5][5]=2;
        printArray(array1);
​
        System.out.println("===========================");
        //遍历数组获取非零个数
        int sum=0;
        for(int i=0;i<array1.length;i++){
            for(int j=0;j<array1[i].length;j++){
                if(array1[i][j]!=0){
                    sum++;
                }
            }
        }
​
        //定义一个稀疏数组
        int array2[][]=new int[sum+1][3];
        array2[0][0]=6;
        array2[0][1]=6;
        array2[0][2]=sum;
        int count=1;
        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]; //保存值
                    count++;
                }
            }
        }
        System.out.println("稀疏数组内容");
        printArray(array2);
​
        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];
        }
        printArray(array3);
​
    }
    public static void printArray(int[][] array){
        for(int i=0;i<array.length;i++){
            for(int j=0;j<array[i].length;j++){
                System.out.print(array[i][j]+" ");
            }
            System.out.print("\n");
        }
    }
}