Java数组详解

数组

概念

数组是一种容器，可以同时存放多个数据值，数组中存储的数据叫做元素

数组的特点：

1、数组是一种引用数据类型

2、数组当中的多个数据，类型必须统一

3、数组的长度在程序运行期间不可改变

注意：

数组有定长特性，长度一旦指定，不可更改。

数组的初始化

在内存中创建一个数组，并且向其中赋予一些默认值

两种常见的初始化方式：

1、动态初始化（指定长度），在创建数组的时候，直接指定数组当中的数据元素的个数

2、静态初始化（指定内容），在创建数组的时候，不直接指定数据个数多少，而是直接将具体的数据内容进行指定。

动态初始化数组

在动态初始化数组的时候，其中的元素会有默认值

整数类型 默认值为0

浮点数类型 默认值为0.0

字符型类型 默认值为’\u0000’

布尔类型 默认值为false

引用类型 默认值为null

其实静态初始化也有默认值的过程，只不过系统自动马上将默认值替换成为了大括号中的具体数值

package cn.itcast.day05.demo01;

public class Demo01Array {

    public static void main(String[] args){

//        定义数组，存储3个元素
       int[] arr = new int[3];
//       数组索引进行赋值
        arr[0] = 5;
        arr[1] = 6;
        arr[2] = 7;

//        输出数组中的元素
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);

        System.out.println("==============");

//        定义数组arr2，将arr的地址赋值给arr2
        int[] arr2 = arr;
        arr2[1] = 9;

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

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

//输出的结果为
5
6
7
==============
5   arr2
9   arr2
7   arr2
9

静态初始化数组

package cn.itcast.day05.demo01;

public class Demo01Array {

    public static void main(String[] args){
        
        int[] arr = new int[]{1,2,3,4,5};
        
        String[] arrayB = new String[]{"Hello","World","Java"};
        
        System.out.println(arr.length);
        
    }
}

静态初始化和动态初始化的省略格式

package cn.itcast.day05.demo01;

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};
    }
}

如果不确定数组的内容，使用动态初始化，如果确定了数组的内容，则使用静态初始化

Java内存划分

Java中一个数组的内存图

遍历数组

遍历数组：就是对数组中的元素进行逐一、挨个输出

package cn.itcast.day05.demo03;

public class Demo04Array {

    public static void main(String[] args) {

        int[] array = new int[]{10,20,30,40,50,60};

//        使用原始方式
        System.out.println(array[0]);
        System.out.println(array[1]);
        System.out.println(array[2]);
        System.out.println(array[3]);
        System.out.println(array[4]);
        System.out.println(array[5]);

//        使用循环，次数是数组的长度
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);

        }

    }
}

数组元素反转

要求：不能使用新数组，只能使用原来的数组

package cn.itcast.day05.demo03;

public class Demo07ArrayReverse {

    public static void main(String[] args) {

        int[] array = new int[]{10,20,30,40,50,60};

        /*
        * 循环中定义变量min=0最小索引
        * max=array.length-1最大索引
        * 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]);
        }
    }
}

数组作为方法参数

数组可以作为方法的参数

当调用方法的时候，向方法的小括号进行传参，传递进去的其实是数组的地址值

package cn.itcast.day05.demo04;

public class Demo01ArrayParam {

    public static void main(String[] args) {

        int[] array = new int[]{10,20,30,40,50};
        System.out.println(array);
        System.out.println("==============AAA=========");
        printArray(array);//传递进去的就是array中保存的地址值

        System.out.println("=============BBB=========");
        printArray(array);
    }

//    三要素：返回值类型，方法名称，参数列表
    public static void printArray(int[] array){

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

数组作为返回值

与数组作为方法参数相同，数组作为方法的返回值时，返回的是地址

package cn.itcast.day05.demo04;

public class Demo02ArrayReturn {

    public static void main(String[] args) {
        int[] result = calculate(10,20,30);
        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;

//        两个结果都希望返回
//        需要一个数组，也就是一个塑料兜，数组中可以保存多个结果
        /*
        int[] array = new int[2];
        array[0] = sum;
        array[1] = avg;
        */

        int[] array = new int[]{sum, avg};

        return array;

    }
}

数组工具类

java.util.Arrays是一个与数组相关的工具类，里面提供了大量的静态方法，用来实现数组常见的操作

sort

public static void sort(byte[] a)
    
    对指定的 byte 型数组按数字升序进行排序。
参数：
a - 要排序的数组

toString

public static String toString(Object[] a)

    返回指定数组内容的字符串表示形式。如果数组包含作为元素的其他数组，则通过从 Object 中继承的 Object.toString() 方法将它们转换为字符串，这描述了它们的标识，而不是它们的内容。 
此方法返回的值等于 Arrays.asList(a).toString() 返回的值，除非 a 为 null，在这种情况下返回 "null"。 
参数：
a - 返回其字符串表示形式的数组 
返回：
a 的字符串表示形式

具体实例

package cn.itcast.day08.demo04;

import java.util.ArrayList;
import java.util.Arrays;

public class Demo01Arrays {

    public static void main(String[] args) {
        int[] intArray = {10,20,30};
//        将int[]数组按照默认格式变成字符串
        String intStr = Arrays.toString(intArray);
        System.out.println(intStr);//[10, 20, 30]

        int[] array1 = new int[]{19,3,20,6,2};
        Arrays.sort(array1);
        System.out.println(Arrays.toString(array1));//[2, 3, 6, 19, 20]

    }
}

当然，出一维数组外，还有二维数组，三维数组等

数组中常见的异常有数组索引越界异常，空指针异常等等

还是建议大家多看一些Arrays类中的源码