Java数组（一）内存分析、初始化状态、数组越界、多维数组

Java数组（一）

目录

什么是数组

  1. 数组是最简单的数据结构

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

  3. 数组描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成

  4. 其中，每一个数据称作一个数组元素，每个数组元素可以通过一个下标（索引）来访问它们

  5. 数组的下标（索引）是从0开始的

    例如int类型数组a：

    int a[]={2,4,5,7}//定义了4个空间，空间里放了4个数据

    则数组a中存入了4个值：

    第一个值a[0]=2;//下标为0，元素为2

    第二个值a[1]=4;//下标为1，元素为4

    第三个值a[2]=5;

    第四个值a[3]=7;

  6. 数组是定义了一个一定空间的

数组的特点

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

数组的声明和创建

数组声明的两种方式 ：

注：//dataType代表数据类型，arrayRefVar代表变量名

  • dataType[] arrayRefVar；//首选方法（推荐方法）

    public class ArrayDemo01 {
    public static void main(String[] args) {
        int[] a;//声明数组a
    }
}

  • dataType arrayRefVar[]；//效果相同，但不是首选方法，这是当初为了让C和C++程序员适应才加入的

    public class ArrayDemo01 {
    public static void main(String[] args) {
        int b[];//声明数组b
    }
}
数组的创建：

注：//arraySize代表了在数组中创建的空间个数

dataType[] arrayRefVar = new dataType[arraySize];

public class ArrayDemo01 {
    public static void main(String[] args) {
        int[] a;//定义数组a
        a = new int[5];//在数组a中创建5个空间（能放5个元素）
        int b[];//定义数组b
        b=new int[10];//在数组b中创建10个空间（能放10个元素）
    }
}

public class ArrayDemo01 {
    public static void main(String[] args) {
        int[] a = new int[5];//定义数组a并在数组a中创建5个空间（能放5个元素）
        int b[] = new int[10];//定义数组b并在数组b中创建10个空间（能放10个元素）
    }
}

  1. 获取数组的长度：

    array.length //array代表数组名

    public class ArrayDemo01 {
    public static void main(String[] args) {
        int[] a;//定义
        a = new int[5];//创建空间
        //为数组a赋值（数组下标从0开始）
        a[0] = 1;
        a[1] = 3;
        a[2] = 2;
        a[3] = 6;
        a[4] = 7;
        //取值
        //输出第四个（下标为3）的值
        System.out.println(a[3]);
        //输出数组a的长度
        System.out.println("数组a的长度为："+a.length);
        //输出全部的值
        System.out.println("输出全部值：");
        for (int i=0;i<a.length;i++){
            System.out.println("a["+i+"]="+a[i]);
        }
    }
}
//输出：
第四个值a[3]=6
数组a的长度为：5
输出全部值：
a[0]=1
a[1]=3
a[2]=2
a[3]=6
a[4]=7

Java内存分析

堆
  1. 存放new的对象和数组
  2. 可以被所有的线程共享，不会存放别的对象引用
栈
  1. 存放基本变量类型（会包含这个基本类型的具体数值）
  2. 引用对象的变量（会存放这个引用在堆里面的具体地址）
方法区
  1. 可以被所有的线程共享
  2. 包含了所有的class和static变量
堆、栈、方法区举例
//声明数组
int[] array = null;//将array放入栈中
//创建数组
array = new int[10];//由栈中的array在堆里面开辟了空间，空间分成10个小块（只能放int类型，且只能放10个元素）
//给数组中元素赋值
array[0]=1//在空间中放入元素值

数组的三种初始化状态

静态初始化
//方式一
int[] a = {1,2,3};
//方式二
Man[] mans = {new Man(1,1),new Man(2,2)};//Man是引用类型
动态初始化
int[] a = new int[2];
a[0] = 1;
a[1] = 2;

int[] a;
a = new int[2];
a[0] = 1;
a[1] = 2;
默认初始化

  1. 动态初始化包含默认初始化

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

  3. 举例：

    int[] a;
a = new int[2];
//没有赋值时，由于a是int[]类型的数组，里面的元素均是int类型，且实例变量中int的默认值为0，所以数组a中没有被赋值的空间均默认是0

数组越界

  1. 创建一个数组a[x]，数组长度是x，则数组的合法区间为[0,x-1]

    举例：定义了a[10],则只能在数组a中放入10个元素，且只能在下标0和9之间存放（包括a[0]和a[9]），越界就会报错（ArrayIndexOutOfBoundsException）

  2. 举例：

    public class ArrayDemo02 {
    public static void main(String[] args) {
        int[] a = new int[10];//下标0到9的10个空间
        a[10] = 9;//只能在0到9下标存储，a[10]越界了
        a[11] = 1;//只能在0到9下标存储，a[11]越界了
    }
}
//输出：
    报错ArrayIndexOutOfBoundsException

    public class ArrayDemo02 {
    public static void main(String[] args) {
        int[] a = new int[10];//下标0到9的10个空间
        a[8] = 9;//只能在0到9下标存储，a[8]没越界
        System.out.println(a[8]);
    }
}
//输出：
    9

数组的使用

普通For循环使用
public class ArrayDemo03 {
    public static void main(String[] args) {
        int[] array = {1,2,3,4,5};
        for (int i=0;i<array.length;i++){
            System.out.println(array[i]);
        }
        System.out.println("================");
    }
}
//输出：
1
2
3
4
5
================
For-Each循环
public class ArrayDemo04 {
    public static void main(String[] args) {
        int[] array = {1,2,3,4,5};
        //在For-Each循环中，i自动遍历array数组中的每一个元素
        for (int i : array) {
            System.out.println(i);
        }
    }
}
//输出：
1
2
3
4
5
数组作方法入参
public class ArrayDemo05 {
    public static void main(String[] args) {
        int[] x = {1,2,3,4};
        s1(x);
    }
    //方法，将数组传入
    public static void s1(int[] a){
        for (int i : a) {
            System.out.println(i);
        }
    }
}
//输出：
1
2
3
4
数组作返回值
public class ArrayDemo06 {
    public static void main(String[] args) {
        int[] x;//定义int[]类型的数组
        //s2方法里返回数组类型和接收（被赋值）的数组类型要一致
        x=s2(2,5,6);//通过s2方法将int[]类型的数组返回给int[]类型的数组x
        //通过For-Each输出数组中的元素
        for (int i : x) {
            System.out.println(i);
        }
    }
    //写出一个返回类型为int数组的方法
    public static int[] s2(int a,int b,int c){
        int[] array;
        array = new int[3];
        array[0]=a;
        array[1]=b;
        array[2]=c;
        return array;//返回数组array
    }
}
//输出：
2
5
6

多维数组

  • 多维数组就是数组的数组，比如二维数组就是特殊的一维数组
二维数组
二维数组定义
//a[x][y]数组，相当于先创建了一个a[x]一维数组，a[x]数组中的每个元素又创建了一个数组，类似于a[0][y],a[1][y].....

int[][] array;
array = new int[4][3];//创建了一个二维数组相当于先创建了一个array[4]数组，而其中每个元素占5个空间（每个元素又是一个一维数组）

若将一维数组看作是一个一维列表，则二维数组可以看成是一个二维列表

举例：

public class ArrayDemo03 {
    public static void main(String[] args) {
        int[] array = {1,2,3,4,5};
        for (int i=0;i<array.length;i++){
            System.out.print(array[i]+" ");
        }
    }
}
//输出：
1 2 3 4 5

存入array中的5个数据可以看作：

i=0 i=1 i=2 i=3 i=4
a[i] 1 2 3 4 5 
public class ArrayDemo07 {
    public static void main(String[] args) {
        int[][] a;
        a = new int[2][3];
        a[0][0]=1;
        a[0][1]=2;
        a[0][2]=5;
        a[1][0]=3;
        a[1][1]=4;
        a[1][2]=2;
        //相当于a[0]={1,2,5},a[1]={3,4,2}
        for (int[] ints : a) {
            //相当于ints[0]={1,2,5}(第一次遍历),ints[1]={3,4,2}（第二次遍历）
            for(int i=0;i<ints.length;i++){
                System.out.print(ints[i]+" ");
            }
            System.out.println("");
        }
    }
}
//输出：
1 2 5 
3 4 2

存入a中的6个数据可以看作：

a[x] [y] y=0 y=1 y=2
x=0 1 2 5
x=1 3 4 2

相当于：

  • a[0]=
  • a[1]=
posted @ 2022-01-18 18:31  史小鹏  阅读(105)  评论(0)    收藏  举报