Java数组基础与操作-优快云博客

这篇博客介绍了Java中的数组，包括数组的概念、特点、定义格式、内存图解析、数组元素的访问与赋值、异常处理（如数组索引越界和空指针异常）、数组长度的获取、数组遍历、数组中的最值计算、数组反转以及如何将数组作为方法参数和返回值使用。同时还提及了冒泡排序作为扩展内容。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

2019年7月13日星期六
17时54分5秒

第14节数组

目录
1_1_14_01_数组的概念	2
1_1_14_02_数组的定义格式一_动态	2
1_1_14_03_数组的定义格式二_静态	3
1_1_14_04_数组的定义格式三_省略的	4
1_1_14_05_访问数组元素进行获取	5
1_1_14_06_访问数组元素进行赋值	6
1_1_14_07_Java中的内存划分	7
1_1_14_08_一个数组的内存图	7
1_1_14_09_两个数组的内存图	8
1_1_14_10_两个引用指向同一个数组的内存图	10
1_1_14_11_常见问题_数组索引越界异常	11
1_1_14_12_常见问题_空指针异常	14
1_1_14_13_获取数组的长度	16
1_1_14_14_数组的遍历输出	17
1_1_14_15_求出数组中的最值(比武招亲)	19
1_1_14_16_数组元素反转	21
1_1_14_17_数组作为方法参数_传递地	25
1_1_14_18_数组作为方法返回值_返回	26
扩展: 冒泡排序	27

1_1_14_01_数组的概念
数组: 是一种容器,可以同时存放多个数据值

数组的特点:
1. 数组是一种引用数据类型
2. 数组当中的多个数据,类型必须统一
3. 数组的长度在程序运行期间不可改变

1_1_14_02_数组的定义格式一_动态

        package cn.itcast.day05.demo01;
        
        /*
        数组: 是一种容器,可以同时存放多个数据值
        
        数组的特点:
        1. 数组是一种引用数据类型
        2. 数组当中的多个数据,类型必须统一
        3. 数组的长度在程序运行期间不可改变
        
        数组的初始化: 在内存当中创建一个数组,并且向其中赋予一些默认值。
        
        两种常见的初始化方式:
        1. 动态初始化(指定长度)
        2. 静态初始化(指定内容)
        
        动态初始化数组的格式;
        数据类型[] 数组名称 = new 数据类型[数组长度];
        
        解析含义:
        左侧数据类型: 也就是数组当中保存的数据,全部是统一的什么类型
        左侧的中括号: 代表我是一个数组
        左侧数组名称: 给数组取一个名字
        右侧的new: 代表参加数组的动作
        右侧数据类型: 必须和左边的数据类型保存一致
        右侧中括号的长度: 也就是数组当中,到底可以保存多少个数据,是一个int数字
        
         */
        public class Demo01Array {
        
            public static void main(String[] args) {
                
                // 创建一个数组,里面可以存放300个int数据
                // 格式: 数据类型[] 数组名称 = new 数据类型[数组长度];
                int[]  = new int[300];
        
                // 创建一个数组: 能存放10个double类型的数据
                double[] arrayB = new double[10];
        
                // 创建一个数组,能存放5个字符串
                String[] arrayC = new String[5];
                
            }
            
        }
    
    **1_1_14_03_数组的定义格式二_静态**
    package cn.itcast.day05.demo01;
    
    /*
    动态初始化: 在创建数组的时候,直接指定数组当中的数据元素个数。
    静态初始化: 在创建数组的时候,不直接指定数据个数多少,而是直接将具体的数据内容进行指定
    
    静态初始化基本格式:
    数据类型[] 数组名称 = new 数据类型[] { 元素1, 元素2, ... };
    
    注意事项:
    虽然静态初始化没有直接告诉长度,但是根据大括号里面的元素具体内容,也可以自动推算出来长度
     */
    public class Demo02Array {
    
        public static void main(String[] args) {
            // 直接创建一个数组,里面装的全都是int数字,具体为: 5、15、25
            int[] arrayA = new int[] { 5, 15, 25 };
    
            // 创建一个数组,用来装字符串: "Hello"、"World"、"java"
            String[] arrayB = new String[]{ "Hello", "World", "java" };
    
        }
    
    }
**1_1_14_04_数组的定义格式三_省略的**
package cn.itcast.day05.demo01;

/*
使用静态初始化数组的时候,格式还可以省略一下。

标准格式:
数据类型[] 数组名称 = new 数组类型[]{ 元素1, 元素2, ...};

省略格式:
数据类型[] 数组名称 = { 元素1, 元素2, ...};

注意事项:
1. 静态初始化没有直接指定长度,当是仍然会自动推算得到长度。
2. 静态初始化标准格式可以拆分为两个步骤。
3. 动态初始化也可以拆分为两个步骤。
4. 静态初始化一旦使用省略格式,就不能拆分成为两个步骤了

使用建议:
如果不确定数组当中的具体内容,用动态初始化,否则,已经确定了具体的内容,用静态初始化。
 */
public class Demo03Array {

    public static void main(String[] args) {
        // 省略格式的静态初始化
        int[] arrayA = { 10, 20, 30 };

        // 静态初始化的标准格式,可以拆分为两个步骤
        int[] arrayB;
        arrayB = new int[] { 11, 21, 31 };

        // 动态初始化也可以拆分为两个步骤
        int[] arrayC;
        arrayC = new int[5];

        // 静态初始化的省略格式,不能拆分成为两个步骤。
//        int arrayD;
//        arrayD = { 10, 20, 30 };

    }

}

1_1_14_05_访问数组元素进行获取

package cn.itcast.day05.demo01;

/*
直接打印数组名称,得到的是数组对应的: 内存地址哈希值。
二进制: 01
十进制: 0123456789
16进制: 0123456789abcdef

访问数组元素的格式: 数组名称[索引值]
索引值: 就是一个int数字,代表数组当中元素的编号。
【注意】索引值从0开始,一直到"数组的长度-1"为止。
 */
public class Demo04ArrayUse {

    public static void main(String[] args) {
        // 静态初始化的省略格式
        int[] array = { 10, 20, 30 };

        System.out.println(array); // [I@75412c2f [(数组)I(int)@()75412c2f(十六进制)

        // 直接打印数组当中的元素
        System.out.println(array[0]); // 第0号元素是: 10
        System.out.println(array[1]); // 20
        System.out.println(array[2]); // 30
        System.out.println("=============");

        // 也可以将数组当中的某一个单个元素,赋值交给变量
        int num = array[1];
        System.out.println(num); // 20

    }

}

1_1_14_06_访问数组元素进行赋值

package cn.itcast.day05.demo01;

/*
使用动态初始化数组的时候,其中的元素将会自动拥有一个默认值。规则如下:
如果是整数类型,那么默认为0;
如果是浮点类型,那么默认为0.0;
如果是字符类型,那么默认为'\u0000'(打印看不见);
如果是布尔类型,那么默认为false;
如果是引用类型,那么默认为null。

注意事项:
静态初始化其实也有默认值的过程,只不过系统自动马上将默认值替换成为大括号当中的具体数值。


 */
public class Demo05ArrayUse {

    public static void main(String[] args) {
        // 动态初始化一个数组
        int[] array = new int[3];

        System.out.println(array); // 内存地址哈希值
        System.out.println(array[0]); // 0
        System.out.println(array[1]); // 0
        System.out.println(array[2]); // 0
        System.out.println("=============");

        // 将数据123赋值交给数组array当中的1号元素
        array[1] = 123;
        System.out.println(array[0]); // 0
        System.out.println(array[1]); // 123
        System.out.println(array[2]); // 0

    }

}

1_1_14_07_Java中的内存划分
在这里插入图片描述
1_1_14_08_一个数组的内存图

1_1_14_09_两个数组的内存图

1_1_14_10_两个引用指向同一个数组的内存图

1_1_14_11_常见问题_数组索引越界异常

在这里插入图片描述
– array数组并没有索引3

– 报错

package cn.itcast.day05.demo03;

/*
数组的索引编号从0开始,一直到"数组的长度-1"为止。

如果访问数组元素的时候,索引编号并不存在,那么将会发生
数组索引越界异常
ArrayIndexOutOfBoundsException

原因: 索引编号写错了。
解决: 修改成为存在的正确索引编号。
 */
public class Demo01ArrayIndex {

    public static void main(String[] args) {
        int[] ayyay = { 15, 25, 35 };

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

        // 错误!
        // 并不存在3号元素,所以发生异常
        System.out.println(ayyay[3]);
    }

}

1_1_14_12_常见问题_空指针异常
在这里插入图片描述

package cn.itcast.day05.demo03;

/*
所有的引用类型变量,都可以赋值为一个null值。但是代表其中三名都没有。

数组必须进行new初始化才能使用其中的元素。
如果只是赋值了一个null,没有进行new创建。
那么将会发生:
空指针异常 NullPointerException

原因: 忘了new
解决: 补上new
 */
public class Demo02ArrayNull {

    public static void main(String[] args) {
        int[] array = null;
//        array = new int[3];
        System.out.println(array[0]);
    }

}

1_1_14_13_获取数组的长度

package cn.itcast.day05.demo03;

/*
如何获取数组的长度,格式:
数组名称.length

这将会得到一个int数字,代表数组的长度。

数组一旦创建,程序运行期间,长度不可改变。
 */
public class Demo03ArrayLength {

    public static void main(String[] args) {
        int[] arrayA = new int[3];

        int[] arrayB = { 10, 20 , 30, 50 }; // 如果太多就不好算了
        int len = arrayB.length;
        System.out.println("arrayB数组的长度是: " + len);
        System.out.println("===================");

        int[] arrayC = new int[3];
        System.out.println(arrayC.length); // 3
        arrayC = new int[5];
        System.out.println(arrayC.length); // 5
    }

}

在这里插入图片描述

1_1_14_14_数组的遍历输出

在这里插入图片描述

package cn.itcast.day05.demo03;

/*
循环遍历数组,说的就是对数组当中的每一个元素进行逐一、挨个儿处理。默认的处理方式就是打印输出
 */
public class Demo04Array {

    public static void main(String[] args) {
        int[] array = { 15, 25, 30, 40, 50 };

        // 首先使用原始方式
        System.out.println(array[0]); // 15
        System.out.println(array[1]); // 25
        System.out.println(array[2]); // 30
        System.out.println(array[3]); // 40
        System.out.println(array[4]); // 50
        System.out.println("==============");

        // 循环遍历数组
        // 使用循环,次数其实就是数组的长度
        // BUG: 数组改变了会报错
        for (int i = 0; i < 5; i++) {
            System.out.println(array[i]);
        }
        System.out.println("==============");

        // 通用循环遍历数组
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }

    }

}

1_1_14_15_求出数组中的最值(比武招亲)
在这里插入图片描述

package cn.itcast.day05.demo03;

public class Demo05ArrayMax {

    public static void main(String[] args) {
        int[] array = { 5, 15, 30, 20, 10000 };

        // 求出最大值
        int max = array[0]; // 比武擂台 战5渣上台
        for (int i = 1; i < array.length; i++) {
            // 如果当前元素,比台上的(max)更大,则换人
            if (array[i] > max) {
                max = array[i];
            }
        }
        // 谁最后最厉害,就能在max当中留下谁的战斗力
        System.out.println("最大值: " + max);

    }

}

求出最小值:
在这里插入图片描述
1_1_14_16_数组元素反转

package cn.itcast.day05.demo03;

/*
reverse 反转

数组元素的反转:
本来的样子: [3, 2, 3, 4]
之后的样子: [4, 3, 2, 3]

要求不能使用新数组,就用原来的唯一一个数组。
 */
public class Demo07ArrayReverse {

    public static void main(String[] args) {
        int[] array = { 10, 220, 30, 420, 50 };

        // 遍历打印数组本来的样子
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
        System.out.println("============");

        /*
        初始化语句: int min = 0, max = array.length-1
        条件判断: min < max
        步进表达式: min++, max--
        循环体: 用第三个变量倒手

         */
        for(int min = 0, max = array.length - 1; min < max; min++, max--){
            int temp = array[min];
            array[min] = array[max];
            array[max] = temp;
        }

        // 再次遍历打印数组后来的样子
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
        System.out.println("============");



    }

}

1_1_14_17_数组作为方法参数_传递地

package cn.itcast.day05.demo04;

/*
数组可以作为方法的参数。
当调用方法的时候,向方法的小括号进行传参,
传递进去的其实是数组的地址值(内存地址哈希码 16进制)。
 */
public class Demo01ArrayParam {

    public static void main(String[] args) {
        int[] array = { 10, 20, 30, 40, 50 };
/*

        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }

        System.out.println("aaa");

        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }

        System.out.println("bbb");

        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }

        缺点: 代码重复
*/
        // 优化
        printArray(array);
        System.out.println("===aaa===");
        printArray(array);
        System.out.println("===bbb===");
        printArray(array);

    }

    /*
    三要素
    返回值类型: 只是进行打印而已,不需要进行计算,也没有结果,用void
    方法名称: printArray
    参数列表: 必须给我数组,我才能打印其中的元素。int[] array
     */

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

}

1_1_14_18_数组作为方法返回值_返回

package cn.itcast.day05.demo04;

/*
一个方法可以有0、1、多个参数; 但是只能有0或者1个返回值,不能有多个返回值。
如果希望一个方法当中产生了多个结果数据进行返回,怎么办?
解决方案: 使用一个数组作为返回值类型即可。

如何数据类型都能作为方法的参数类型,或者返回值类型。

数组作为方法的参数,传递进去的其实是数组的地址值.
数组作为方法的返回值,返回的其实也是数组的地址值。
 */
public class Demo02ArrayReturn {

    public static void main(String[] args) {
        int[] result = calculate(10, 20, 30);

        System.out.println("main方法接收到的返回值数组是: ");
        System.out.println(result); // 地址值

        System.out.println("总和: " + result[0]);
        System.out.println("平均数: " + result[1]);
    }

    public static int[] calculate(int a, int b, int c){
        int sum = a + b + c; // 总和
        int avg = sum / 3; // 平均数
        // 两个结果都希望进行返回

        // 需要一个数组,也就是一个塑料兜,数组可以保存多个结果
        // 错误 = return sum, avg;
       /*
       int[] array = new int[2];
        array[0] = sum; // 总和
        array[1] = avg; // 平均数
        */

        int[] array = { sum, avg };
        System.out.println("calculate方法内部数组是: ");
        System.out.println(array); // 地址值
        return array;

    }

}

扩展: 冒泡排序
在这里插入图片描述

package cn.itcast.day05.demo05;

/*
冒泡排序:
冒泡排序的基本思想就是：从无序序列头部开始，进行两两比较，
根据大小交换位置，直到最后将最大（小）的数据元素交换到了无序队列的队尾，
从而成为有序序列的一部分；下一次继续这个过程，直到所有数据元素都排好序。

算法的核心在于每次通过两两比较交换位置，选出剩余无序序列里最大（小）的数据元素放到队尾。

1、比较相邻的元素。如果第一个比第二个大（小），就交换他们两个。
2、对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大（小）的数。
3、针对所有的元素重复以上的步骤，除了最后已经选出的元素（有序）。
4、持续每次对越来越少的元素（无序元素）重复上面的步骤，直到没有任何一对数字需要比较，则序列最终有序。

 */
public class Demo01Array {

    public static void main(String[] args) {
        int[] array = {1, 20, 30, 10, 1000};
        int[] arraySort = sort(array);
        for (int i = 0; i < arraySort.length; i++) {
            System.out.println(arraySort[i]);
        }
    }

    /*
    三要素
    返回值类型: int[]
    方法名称: sort
    参数列表: int[] array
     */
    public static int[] sort(int[] array) {
        // 元素反转的次数
        for (int i = 0; i < array.length - 1; i++) {
            // 元素反转的范围
            for (int j = 0; j < array.length - i - 1; j++) {
                // 左元素 比较 右元素(始终比左元素多一个序列)
                if(array[j] < array[j + 1]){
                    // 元素反转
                    int temp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = temp;
                }
            }
        }

        return array;
    }
    
}