JAVA 数组（三）

数组（三）

数组里面存着相同数据类型的多个元素。

数组的定义

//格式1
数组类型[] 数组名

//格式2
数组类型 数组名[]

数组的初始化

就是在内存中，为数组容器开辟空间，并将数据存入容器的过程
方式

• 静态初始化
• 动态初始化

静态初始化

在声明数组的同时，为数组元素赋初值。

完整格式

数据类型[] 数组名 = new 数据类型[]{元素1,元素2……};

简化格式

数组类型[] 数组名 = {元素1,元素2……};

两种格式的范例

public class Test{
    public static void main(String[] args){
        int[] arr1=new int[]{1,2,3};
        int[] arr2={1,2,3};

        double[] arr3=new double[]{1.0,2.0,30};
        double[] arr4={1.0,2.0,3.0};

        String[] arr5=new String[]{"abc","efa","sdf"};
        String[] arr6={"abc","efa","sdf"};
    }
}

动态初始化

创建时，自己制定数组长度，由虚拟机给出默认的初始化值。
默认初始化值:

• 整数类型:0
• 小数类型:0.0
• 字符类型:空格
• 布尔类型:false
• 引用数据类型:null

格式:

数组类型[] 数组名 = new 数组类型[数组长度];

静态0和动态初始化的区别

静态初始化：手动指定数组元素，系统会根据元素个数算出数组长度。
动态初始化：只确定元素个数，不确定元素值。

数组的地址值

数组的地址值表示数组在内存的位置

public class Test{
    public static void main(String[] args){
        int[] arr1={1,2,3};
        double[] arr2={1.0,2.0,3.0};
        System.out.println(arr1);
        System.out.println(arr2);
    }
}
/*
[I@14ae5a5
[D@7f31245a
*/
//解释地址值
//[表示当前是一个数组
//D表示数组元素是double类型；I表示数组元素是int类型
//@间隔符号，固定
//14ae5a5和7f31245a，数组地址，以十六进制体现

访问数组元素

获取数组的元素

格式：

数组名[索引];//索引又称为下标，角标，从0开始

范例：

public class Test{
    public static void main(String[] args){
        int[] arr={1,2,3,4,5};
        //获取一个元素，索引为0
        //直接打印
        System.out.println(arr[0]);
        //赋值给变量，再打印
        int i=arr[0];
        System.out.println(i);
    }
}
/*
1
1
*/

给数组元素赋值

格式:

数组名[索引]=具体数据/变量;

原本的数据会被覆盖
范例：

public class Test{
    public static void main(String[] args){
        int[] arr={1,2,3,4,5};
        System.out.println(arr[0]);
        arr[0]=10;
        System.out.println(arr[0]);
    }
}
/*
1
10
*/

数组遍历

数组变量将数组所有元素取出进行操作。
获取数组的长度属性:
数组名.length

扩展

//idea提供自动生成数组的遍历

public class Test{
    public static void main(String[] args){
        int[] arr={1,2,3,4,5,6,7,8,9};
        //输入数组名.fori，并回车，会自动生成遍历循环
        //比如：
        //arr.fori
        //自动生成以下代码
        for (int i = 0; i < arr.length; i++) {
            
        }
    }
}

范例

遍历数组打印

public class Test{
    public static void main(String[] args){
        int[] arr={1,2,3,4,5,6,7,8,9};
        for(int i=0;i<arr.length;i++){
            System.out.println(arr[i]);
        }
    }
}
/*
1
2
3
4
5
6
7
8
9
*/

遍历数组求和

public class Test{
    public static void main(String[] args){
        int[] arr={1,2,3,4,5,6,7,8,9,10};
        int sum=0;
        for(int i=0;i<arr.length;i++){
            sum+=arr[i];
        }
        System.out.println("sum="+sum);
    }
}
/*
sum=55
*/

数组范例

求最值

//求最大值最小值并打印
public class Test{
    public static void main(String[] args){
        int[] arr={34,67,152,45,42};
        int max=arr[0];
        int min=arr[0];
        for(int i=1;i<arr.length;i++){
            if(arr[i]>max){
                max=arr[i];
            }
            if(arr[i]<min){
                min=arr[i];
            }
        }
        System.out.println("最大值"+max);
        System.out.println("最小值"+min);
    }
}
/*
最大值152
最小值34
*/

数组逆序

public class Test{
    public static void main(String[] args){
        int[] arr={1,2,3,4,5,6,7,8,9,10};
        System.out.println("逆序前：");
        for(int i=0;i<arr.length;i++)
        {
            System.out.print(arr[i]+"\t");
        }
        for(int i=0,j=arr.length-1;i<j;i++,j--){
            int t=arr[i];
            arr[i]=arr[j];
            arr[j]=t;
        }

        System.out.println("\n逆序后：");
        for(int i=0;i<arr.length;i++)
        {
            System.out.print(arr[i]+"\t");
        }
    }
}
/*
逆序前：
1	2	3	4	5	6	7	8	9	10
逆序后：
10	9	8	7	6	5	4	3	2	1
*/

数组打乱

import java.util.Random;
public class Test{
    public static void main(String[] args){
        int[] arr={1,2,3,4,5,6,7,8,9,10};
        System.out.println("打乱前：");
        for(int i=0;i<arr.length;i++)
        {
            System.out.print(arr[i]+"\t");
        }
        Random r=new Random();
        for(int i=0;i<arr.length;i++){
            int j=r.nextInt(arr.length);
            int t=arr[i];
            arr[i]=arr[j];
            arr[j]=t;
        }
        System.out.println("\n打乱后：");
        for(int i=0;i<arr.length;i++)
        {
            System.out.print(arr[i]+"\t");
        }
    }
}
/*
打乱前：
1	2	3	4	5	6	7	8	9	10	
打乱后：
3	4	8	10	7	1	9	5	6	2	
*/

数组的内存分配

数组名指向的是数组的地址。
Java内存分配

• 栈：方法运行时使用的内存，比如main方法运行，进入方法栈中执行
• 堆：存储对象或数组，new来创建的，都存储在堆内存
• 本地方法栈：JVM使用操作系统功能时使用
• 方法区（从JDK8开始，取消方法区，新增元空间）：存储可运行的class文件
• 寄存器：给CPU使用

new来创建的，一定在堆中开辟了一个小空间。若是new了多次，堆中有多个小空间，每个小空间中都有各自的数据。
当两个数组指向同一小空间时，其中一数组对小空间的值发生改变，则其他数组再次访问时就是修改之后的结果了。

数据常见问题

• ArrayIndexOutOfBoundsException：索引越界异常，当访问了数组中不存在的数据，便会发生该异常
• NullPointerException：空指针异常，当引用数据类型的变量，被赋值成null后，就代表堆内存的连接被切断了，若继续访问堆内存数据，就会出现空指针异常

二维数组

二维数组是一种容器，该容器用于存储一维数组。
若要操作的多组数据，属于同一组数据，可考虑用二维数组。

静态初始化

//完整格式：
//数据类型[][] 数组名=new 数据类型[][]{{元素1，元素2,...},{元素1，元素2,...},...}；
int[][] arr1=new int[][]{{11,12},{21,22}};

//简化格式：
//数据类型[][] 数组名={{元素1，元素2,...},{元素1，元素2,...},...}；
int[][] arr2={{11,12},{21,22}};

注：二维数组在存储一维数组时，存储的是一维数组的地址值。

int[][] arr={{11,12},{21,22}};
System.out.println(arr);
System.out.println(arr[0]);
System.out.println(arr[1]);

/*
[[I@4eec7777
[I@3b07d329
[I@41629346
*/

访问格式：
数组名[m][n]:

• m指定访问哪一个一维数组
• n访问一维数组中的哪一个元素

遍历数组:

int[][] arr={{11,12},{21,22}};
for (int i = 0; i < arr.length; i++) {
    for (int j = 0; j < arr[i].length; j++) {
        System.out.println(arr[i][j]);
    }
}

动态初始化

//格式：
//数据类型[][] 数组名=new 数据类型[i][j];
int[][] arr=new int[2][3];
int[] arr1={11,12,13};
int[] arr2={21,22,23};
//可将提前创建好的一维数组存入二维数组
arr[0]=arr1;
arr[1]=arr2;
for (int i = 0; i < arr.length; i++) {
    for (int j = 0; j < arr[0].length; j++) {
        System.out.println(arr[i][j]);
    }
}
}