一篇学会java数组（包含实例解析+算法实现，建议看后上手实操）

哈喽，大家好！我是Why，一名在读学生，目前刚刚开始进入自己的编程学习生涯。虽然学习起步较晚，但我坚信做了才有0或1的可能。学了一段时间以后也是选择在CSDN上分享自己的日常笔记，也希望能够在众多道友的大家庭中打成一片。
本文近万字，篇幅有点长，主要讲解java中的数组。如果大家读后觉得有用的话，还请大家多多支持博主：欢迎 ❤️点赞👍、收藏⭐、留言💬
✨✨✨个人主页：java-WangHY

🎯Array

1、Java中的数组是一种引用数据类型，故数组对象是在堆内存中，不属于基本数据类型，其父类是Object，是一种简单的数据结构

2、主观上讲，可以将数组认为是一个容器，它可以同时容纳多个元素，即一个数据的’集合’

3、数组中存储的元素可以是任意类型的，引用数据类型 && 基本数据类型

4、当数组中存储的是’java对象’的时候，相当于存储了该数据的’住址’（即其内存地址）,并不能直接将该类型的数据直接存储到数组当中去

5、数组一旦被创建，其长度不可变（Java），有些扩容算法的底层实际上是由一个大的数组(可以想象为容器)进行了替换，而不是真正的扩容

6、所有数组都具有的属性
length,用来获取其长度

7、数组的分类：
一维数组，二维数组，三维数组…多维数组

8、数组虽然可以存储任意类型的数据，但是java中要求
‘数组中的元素类型必须统一’，比如int类型的数组，不能存储char类型的数据、tudent类型的数组只能存储Student类型的数据。
就像家里的面缸里不能即装面又装水一样，存储的元素必须统一

9、数组在存储的时候，其’数组内的元素内存地址都是规则性连续排列的’，所以在创建数组的时候实际上就是在内存中开辟了一块很大的内存
这是数组很重要的特点。

10、数组中的每个元素都有下标，但是需要注意的是：
数组的元素下标都是从 0 开始的，逐一递增取值为【0 ~ 数组.length - 1】
‘下标是操作数组最重要的手段’

11、数组中有很多数据，但是数组都是以数组中的第一个元素的内存地址当做自己（整个数组对象）的内存地址
Array内存地址 = Array[0]内存地址

🌈怎么样去定义（声明）一个一维数组

定义/声明数组的时候，等于只创建了数组引用名，注意，这样并未在内存中开辟数组空间

数据类型[] 数组名;
int[] array1;
double[] array2;
boolean[] array3;
Object[] array4;

🤙数组的初始化

1、静态初始化
静态初始化语法格式：
数据类型[] 数组名称 = {数组内容 1,数组内容 2,数组内容 3…数组内容 n};
int[] array = {1, 2, 3, 4, 5};

2、动态初始化（有默认值）
动态初始化语法格式：
数据类型[] 数组名称 = new 数据类型[数组长度];
int[] array = new int[5]; // 初始化一个5个长度的int类型数组，每个元素默认值0
String[] names = new String[5]; // 初始化5个长度的String类型数组，每个元素默认值null。

3、不常用的初始化语法格式：
数据类型[] 数组名称 = new 数据类型[]{内容 1,内容 2,内容 3…内容 n};
int[] array = new int[]{1, 2, 3, 4, 5};

什么时候采用静态初始化方式，什么时候使用动态初始化方式呢？
当你创建数组的时候，确定数组中存储哪些具体的元素时，采用静态初始化方式。
当你创建数组的时候，不确定将来数组中存储哪些数据，你可以采用动态初始化的方式，预先分配内存空间。

📈数组的优缺点

💎优点

​ 查询检索效率高

原因：
1、数组内元素数据类型相同，占据的内存空间一样

2、数组内每个元素的内存地址在空间上的存储位置是连续的，故知道了一个元素的内存地址就很容易计算出其他的元素的内存地址

所以数组的检索效率几乎不受其大小的影响，因为都可以直接计算的，
知道了第一个元素存储的地址，知道了占用的内存空间大小，可以直接定位到指定下标的内存地址

💎缺点

​ 随机增删效率低，不能存储大量数据

原因：
1、由于数据中的元素的内存地址都是连续的，为了保证这个特点，在进行随机增删数组中的元素的时候
会涉及增删位置其后的元素整体前移或者后移的操作
但是，对于数组最后一个元素的操作，是没有效率影响的

2、不能存储大量的元素原因是很难在内存空间上找到一个特别大的连续内存空间

🌾一维数组实例

例子1

public class Test {
   
    public static void main(String[] args) {
   
        // 使用静态初始化的方式声明一个int类型的数组
        int[] a = {
   1,2,3,4,5};

        // 调用数组的length属性,打印数组的长度
        System.out.println("数组中元素的个数" + a.length);

        System.out.println("---------------我是一个分界线OvO-------------------");

        // 通过下标对数组中的元素进行存和取(下标从0开始)

        //读取操作
        System.out.println("数组a的第一个元素是--> " + a[0]);//1
        System.out.println("数组a的最后一个元素-->" + a[4]);//5
        //当数组的长度未知的时候，可以使用  数组名【数组名.length - 1】来获取最后一个元素，这个比较常用
        System.out.println("数组a的最后一个元素-->" + a[a.length - 1]);

        System.out.println("---------------我是一个分界线OvO-------------------");

        // 修改操作
        // 把第一个元素修改为1314
        a[0] = 1314;
        // 把最后一个元素修改为1024
        a[a.length - 1] = 1024;

        System.out.println("数组a的第一个元素是--> " + a[0]);//1
        System.out.println("数组a的最后一个元素-->" + a[4]);//5

        System.out.println("---------------我是一个分界线OvO-------------------");

        // 一维数组的遍历（即自始至终依次使用），实际上就是遍历下标
        //正序遍历
        for(int i = 0; i < a.length; i++){
   
            System.out.println("正序遍历输出-->" +a[i]);
        }

        System.out.println("---------------我是一个分界线OvO-------------------");

        // 逆序遍历到第1个元素
        for (int i = a.length - 1; i >= 0; i--) {
   
            System.out.println("倒序遍历输出-->" + a[i]);
        }
    }
}

例子2

public class Test {
   
    public static void main(String[] args) {
   
        // 采用动态初始化的方式声明(定义)一个一维数组
        // 创建长度为5的int数组，数组中每个元素的默认值是0
        int[] a = new int[5];
        // 遍历数组,此时数组中元素均为默认值
        for (int i = 0; i < a.length; i++) {
   
            System.out.println("a中下标为" + i + "的元素是-->" + a[i]);
        }

        System.out.println("--------------------------我是一个分界线OvO-------------------");

        //可以在遍历中赋值 1-5   然后输出赋值后的结果
        for (int i = 0; i < a.length; i++) {
   
            a[i] = i + 1;
            System.out.println("a中下标为" + i + "的元素是-->" + a[i]);
        }

        System.out.println("--------------------------我是一个分界线OvO-------------------");

        //动态初始化方式初始化一个Object类型的数组（很常用*****）
        //默认值是null
        Object[] objs = new Object[5];
        for (int i = 0; i < objs.length; i++) {
   
            //相当于 Object obj = objects[i];
            //System.out.println(obj);
            System.out.println(objs[i]);
        }

        System.out.println("--------------------------我是一个分界线OvO-------------------");

        //for循环遍历的另一种方法foreach
        for (Object obj : objs) {
   
            System.out.println(obj);
        }

        System.out.println("--------------------------我是一个分界线OvO-------------------");

        // 采用静态初始化的方式初始化一个Object类型的数组
        //注意静态的初始化的特点，已确定数组中药存储那些数据，故这些数据必须先存在
        Object o1 = new Object();
        Object o2 = new Object();
        Object o3 = new Object();

        //Object[] objects = {o1, o2, o3};
        Object[] objects = {
   new Object(), new Object(), new Object()};
    }
}

例子3

package com.blog;
// 将数组作为一个参数进行传递

public class Test {
   
    //不要忘记mai方法中的参数也是一个数组
    public static void main(String args[]) {
   
        //创建一个任意类型（引用数据类型）的数组
        Integer[] array1 = {
   1,2,3,4,5};
        printArrays(array1);

        System.out.println("----------俺是一个分界线QAQ-----------");

        String