java数组-静态/动态初始化-Arrays类

数组

数组定义

数组（array）是一种用于存储多个相同类型数据的存储模型。
数组的定义格式：

格式1：
数据类型[] 变量名
范例：int[] arr
//读——定义了一个int类型的数组，数组名是arr。

格式2：
数据类型 变量名[]
范例：int arr[]
//读——定义了一个int类型的变量，变量名是arr数组。
两者在使用的时候没有区别，但在读的时候有区别。

备注2022/8/11
二维数组的定义：

格式一：
元素的数据类型[][] 数组的名字 = new 元素的数据类型[二维数组的长度][一维数组的长度];

格式二：
元素的数据类型 数组的名字[][] = new 元素的数据类型[二维数组的长度][一维数组的长度];

int[][] arr = new int[3][]; == 表示定义一个数组长度是3的二维数组。

Java原生类
原生类 = Java数据类型中的基本数据类型，但数组属于引用数据类型。

数组初始化之动态初始化

java中的数组必须先初始化，然后才能使用；
初始化：为数组中的数组元素分配内存空间，并为每个数组元素赋值。

数组初始化方式：动态初始化、静态初始化。

动态初始化

动态初始化：初始化时只指定数组长度，由系统为数组元素分配初始值。

格式：

数据类型[] 变量名 = new 数据类型[数组长度];
案例：int[] arr = new int[3];
//解释：
左边：
	int：说明数组中的元素类型是int类型；
	[]：说明是一个数组；
	arr：这是数组的名称；
右边：
	new：为数组申请内存空间；
	int：说明数组中的元素类型是int类型；
	[]：说明这是一个数组；
	3：数组长度，其实就是数组中元素的个数；

数组元素访问

数组元素访问方式：

数组变量访问方式：数组名

数组内部保存数据的访问方式：数组名[索引]

索引是数组中数据的编号方式。

• 作用：
  索引用于访问数组中的数据，数组名[索引] 等同于 变量名，是一种特殊的变量名。
• 特征：
  ①索引从0开始；②索引是连续的；③索引逐一增加，每次加1。

package com.itheima;

public class Demo16 {
    public static void main(String[] args) {
        int[] arr = new int[3];//新建数组
        System.out.println("输出数组名："+arr);//数组名：[I@1b6d3586 这个是数组元素的地址。
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);
    }
}

内存分配

java中内存分配：java程序在运行时，需要在内存中分配空间。为了提高运算效率，就对空间进行不同区域的划分，因为每一片区域都有特定的处理数据方式和内存管理方式。

数组在初始化时，会为存储空间添加默认值。
整数：默认值0；浮点数：默认值0.0；布尔值：默认值false；字符：默认值是空字符；引用数据类型：默认值是null。

java内存分为栈内存、堆内存。

内存名	栈内存	堆内存
说明	存储局部变量	存储new出来的内容（实体、对象）
内存消失	定义在方法中的变量，使用完毕，立即消失	每一个new出来的内容都有一个地址值，使用完毕，会在垃圾回收器空闲时被回收

单个数组的内存图

public class Demo16{
    public static void main(String[] args) {
        int[] arr = new int[3];
        System.out.println(arr);//[I@1b6d3586
        System.out.println(arr[0]);//0
        System.out.println(arr[1]);//0
        System.out.println(arr[2]);//0

        arr[0] = 100;
        arr[2] = 200;
        System.out.println(arr);//[I@1b6d3586
        System.out.println(arr[0]);//100
        System.out.println(arr[1]);//0
        System.out.println(arr[2]);//200
    }
}

多个数组的内存图

理解：
多个数组的内存区域地址不是连续的。

public class Demo16{
    public static void main(String[] args) {
        int[] arr = new int[2];
        int[] arr1 = new int[3];

        System.out.println(arr);
        System.out.println(arr[0]);
        System.out.println(arr[1]);

        System.out.println(arr1);
        System.out.println(arr1[0]);
        System.out.println(arr1[1]);
        System.out.println(arr1[2]);

        arr[0] = 100;
        arr1[0] = 200;
        arr1[2] = 300;

        System.out.println(arr);
        System.out.println(arr[0]);
        System.out.println(arr[1]);

        System.out.println(arr1);
        System.out.println(arr1[0]);
        System.out.println(arr1[1]);
        System.out.println(arr1[2]);

    }
}

多个数组指向相同内存图

理解：
两个数组的内存区域地址相同，修改其中一个数组的元素，另一个数组访问的时候也会改变。

public class Demo16{
    public static void main(String[] args){
        int[] arr = new int[3];
        arr[0] = 100;
        arr[1] = 200;
        arr[2] = 300;
        System.out.println(arr);//I@1b6d3586
        System.out.println(arr[0]);//100
        System.out.println(arr[1]);//200
        System.out.println(arr[2]);//300

        int[] arr2 = arr;
        arr2[0] = 101;
        arr2[1] = 201;
        arr2[2] = 301;
        System.out.println(arr2);//I@1b6d3586
        System.out.println(arr2[0]);//101
        System.out.println(arr2[1]);//201
        System.out.println(arr2[2]);//301
        System.out.println("-------");
        System.out.println(arr);//I@1b6d3586
        System.out.println(arr[0]);//101
        System.out.println(arr[1]);//201
        System.out.println(arr[2]);//301
    }
}

数组初始化之静态初始化

静态初始化：初始化时指定每个数组元素的初始值，由系统决定数组长度。

格式：
数组类型[] 变量名 = new 数据类型[]{数据1，数据2，数据3.....}

简化格式：
数据类型[] 变量名 = {数据1，数据2，数据3，...}

数组操作的两个常见小问题

索引越界：访问了数组中不存在的索引对应的元素，造成索引越界问题；
运行后，结果界面出现：ArrayIndexOutOfBoundsException

空指针异常：访问的数组已经不再指向堆内存的数据，造成空指针异常；
null：空值，引用数据类型的默认值，表示不指向任何有效对象。
运行后，结果界面出现：NullPointerException

public class Demo16{
    public static void main(String[] args) {
        //索引越界
        int[] arr = new int[3];
        System.out.println(arr[3]);
        //报错出现：ArrayIndexOutOfBoundsException

        //空指针异常
        arr = null;
        System.out.println(arr[0]);
        //报错出现：NullPointerException
    }
}

数组常见操作

数组遍历

for循环

获取数组元素数量——格式：数组名.length

遍历通用格式：

int[] 数组名 = {};
# 数组的静态初始化

int[] 数组名 = new int[n];
# 数组的动态初始化，其中n就是元素个数

for(int i = 0; i< 数组名.length;i++){
	arr[i]//访问数组中的元素。
}

案例：

public class Demo16{
    public static void main(String[] args) {
        int[] arr = {11,22,33,44,55};
        for(int i = 0; i< arr.length ;i++){
            System.out.println(arr[i]);
            //输出：11,22,33,44,55
        }
    }
}

foreach/增强for循环

• 概述
  java5之后，Java提供了一种更简洁的循环：foreach循环（增强for循环），这种循环遍历数组和集合更加简洁。
  无须获得数组和集合长度，无须根据索引（下标）来访问数组元素，foreach循环自动遍历数组和集合的每一个元素。

• 语法格式：

for(元素类型 元素名：数组/集合名){
	操作（元素名）
}

• 注意：
  foreach 语句为数组或对象集合中的每个元素重复一个嵌入语句组。
  foreach 语句用于循环访问集合以获取所需信息，但不要用于更改集合内容以避免产生不可预知的副作用。

• 案例：

public class ForEachDemo{
	public static void main(String[] args){
	
        int[] arr = {1,2,3};
        System.out.println("一维数组");
        // 可以使用foreach方式遍历
        for(int arri:arr){
            System.out.println(arri);
        }
        
        int[][] arr2 = {{1,2,3},{4,5,6}};
        System.out.println("二维数组");
        // 报错 不能使用foreach方式遍历
        for(String arri:arr2){
            System.out.println(arri);
        }
    }
}

常用方法

方法名	说明
int 数组名.length	返回数组的长度

Arrays工具类中toString静态方法遍历

• 概述
  利用Arrays工具类中的toString静态方法可以将一维数组转化为字符串形式并输出。

• toString和deeptoString的区别：

Arrays.toString(数组)	数组中有数组时，不会打印数组中的内容， 只会以地址的形式打印出来
Array.deepToString（数组）	数组中还有数组的情况，会打印数组

• 案例：

// 自己直接写的
public class Demoxhj{
	public static void main(String[] args){
		int arr[][] = {{1,2,3},{4,5,6},{7,8,9}};
		System.out.println("arr:"+Arrays.toString(arr));
		int b[][] = {{0,7,1,3},{0,5,0,7}};
		System.out.println("b:"+Arrays.deepToString(b));
	}
}

运行结果：
arr:[[I@75412c2f, [I@282ba1e, [I@13b6d03]
b:[[0, 7, 1, 3], [0, 5, 0, 7]]

获取最值

最大值案例

public class Demo16{
    public static void main(String[] args) {//注释内容是思路
        //定义数组
        int[] arr = {12,45,98,73,60};
        //定义变量用于保存最大值，初始值设置为数组的第一个元素，为了不引入外部元素。
        int max = arr[0];
        //与数组中其余元素逐个比较，每次将较大的值赋值给max
        for(int i = 1 ;i <arr.length;i++){
            if(max < arr[i]){
                max = arr[i];
            }
        }
        //循环结束后打印输出最大值变量。
        System.out.println("最大值是："+max);//输出 最大值是：98
    }
}

Arrays

概述

• 软件包是 java.util 使用的时候需要导包
• 该类包含用于操作数组的各种方法（如排序和搜索）
• Arrays也有无参构造方法，但其中的成员都是用static修饰的，可以直接使用（Arrays.成员）对Arrays中的成员进行访问。为防止使用者通过创建对象的方式对成员进行访问，所以Arrays的无参构造方法采用修饰符private修饰。
• 工具类的设计思想：构造方法用private修饰，防止外部通过类创建对象对成员进行访问；成员用public static 修饰，方便通过类名.成员调用成员。

常用方法

方法名	说明
public static String toString（int[] arr）	返回指定数组的内容的字符串形式
public static void sort（int[] arr）	按照数字顺序排列指定的数组（从小到大）
static int[] copyOfRange(int[] original , int from , int to)	将指定数组的指定范围复制到新数组中
static boolean equals（数组1，数组2）	比较数组元素是否相等
public static < T> List < T > asList(T…a)	返回由指定数组支持的固定大小的列表 返回值类型是List< T >