Java数组

1.1 数组的概念

数组：是一种容器，可以存放多个数据值。

数组的特点：

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

1.2 数组的定义格式

数组的初始化（创建数组）： 在内存当中创建一个数组，并且向其中赋予一些默认值。

两种常见的初始化方式：
1.动态初始化（指定数组的长度）：在创建数组的时候，直接指定数组当中的元素个数。
2.静态初始化（指定内容）：在创建数组的时候，不直接指定数据个数多少，而是直接将具体的数据内容进行指定。

1.2.1 动态初始化数组:

格式： 数据类型[] 数组名称 = new 数据类型[数组长度];

解析含义:
左侧数据类型:也就是数组当中保存的数据,这些数据全都是统一的类型。
左侧的中括号：代表我是一个数组。
左侧数组名称：给数组取的名字。
右侧new：代表创建数组的动作。
右侧的数据类型：必须和左边的数据类型保持一致。
右侧中括号的长度：也就是数组当中到底可以存多少个数据，他是一个int数字。

1.2.2 静态初始化数组：

基本格式： 数据类型[] 数组名称 = new 数据类型[]{ 元素1, 元素2 , … };

注意事项：
虽然静态初始化没有直接告诉长度，但是根据大括号里的元素内容，也可以自动推算出来长度。
使用静态初始化数组的时候，格式还可以省略一下。

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

1.2.3 注意事项

1.静态初始化标准格式可以拆分成为两个步骤。
2.动态初始化也可以拆分成为两个格式。
3.静态初始化一旦使用省略格式就不能拆分成为两个步骤。

 //静态初始化标准格式拆分成为两个步骤
        int[] arrayF;
        arrayF = new int[]{5,10,15};
        //动态初始化也可以拆分成为两个格式
        int[] arrayG;
        arrayG = new int[5];
        //静态初始化一旦使用省略格式就不能拆分成为两个步骤。
//        int[] arrayH;
//        arrayH = {5,10,15};

使用建议：如果不确定数组当中的具体内容，用动态初始化；否则，如果已经确定了具体的内容，用静态初始化。

1.3 访问数据元素进行获取

直接打印数据名称，得到的是数组对应的，内存地址哈希值。

访问数组元素的格式： 数组名称[索引值]
索引值：就是一个int数字，代表数组当中元素的编号。
【注意】：索引值从0开始，一直到数组元素-1为止。

1.4 访问数组元素进行赋值

使用动态初始化数组的时候，其中的元素将会自动拥有一个默认值，规则如下：
如果是整数类型，那么默认为0；
如果是浮点类型，那么默认为0.0；
如果是字符类型，那么默认为’\u0000’；
如果是布尔类型，那么默认为false；
如果是引用类型，那么默认为null；

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

1.5 常见问题

1.5.1 数组索引越界异常(ArrayIndexOutOfBoundsException)

数组的索引从0开始，一直到“数组长度的-1”为止。（如果越界会报错：ArrayIndexOutOfBoundsException）
如果访问数据元素的时候，索引编号并不存在，那么就会发生数组索引越界异常(ArrayIndexOutOfBoundsException)

原因：索引编号写错了。
解决：修改成为存在的正确索引编号。

1.5.2 空指针异常(NullPointerException)

所有的引用类型变量，都可以赋值为一个null值，但是代表其中什么都没有。
数组必须进行new初始化才能使用其中的元素。如果只是赋值了一个null，没有进行new创建，那么将会发生空指针异常。（NullPointerException）

原因：忘了new
解决：补上new

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

1.6 获取数组的长度

格式： 数组名称.length
这将会得到一个int数字，代表数组的长度。

数组一旦创建，程序运行期间，长度不可改变。

//数组一旦创建，程序运行期间，长度不可改变。
        int[] arrayB = new int[3];
        System.out.println(arrayB.length);//3
//之所以输出5是因为下边新new了一个数组将新数组的地址赋值给了arrayB，代替了上面的数组，并不是长度被改变了
        arrayB = new int[5];
        System.out.println(arrayB.length);//5

1.7 数组的遍历输出

package javademo.array;
/*
遍历数组，说的是对数组当中的每一个元素进行逐一、挨个处理。默认的处理方式就是打印输出
 */
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("==========================");

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

1.8 数组元素的反转

1.数组元素的反转：其实就是对称位置的元素交换。
2.通常遍历数组用的是一个索引：int i=0；现在表示对称位置需要两个索引：int min = 0;int max =array.length-1;
3.交换两个变量的值：定义一个变量，用来交换两个值。
4.什么时候停止交换：当’min == max’或者’min>max’，即当 ‘min<max’ 则进行交换。

public class ArrayReverse {
    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("=======================");
        /*
        初始化语句：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]);//打印输出交换后的数组
        }
    }
}

1.9 数组作为方法参数传递

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

1.10 数组作为方法返回值返回

一个方法可以有0，1，多个参数，但是只能由0，1个返回值，不能有多个返回值
如果希望一个方法当中产生了多个结果进行返回，使用一个数组作为返回值即可。

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

数组作为方法的参数，传递进去的其实是数组的地址值。
数组作为方法的返回值，返回的其实也是数组的地址值。

1.11 二维数组

应用场景： 当我们需要把数据分组管理的时候需要用到二维数组。

二维数组的静态初始化格式： 数据类型[][] [] [] 数组名 = new 数据类型 [] [] {{元素1，元素2},{元素1，元素2}};
简化: 数据类型[] [] 数组名 = {{元素1，元素2},{元素1，元素2}};

package javademo.array;
//格式化代码:CTRL+ALT+L
public class TwoDimensionDemo1 {
    public static void main(String[] args){
    int[][] arr1 = new int[][]{{11, 22}, {33, 44,55}};
    int[][] arr2={{11, 22}, {33, 44,55}};
    //更加可读的写法:
    //以后建议这样定义，把每一个一维数组单独写成一行
    int[][] arr3 = {
            {11, 22},
            {33, 44, 55}

    };
    //获取元素：
        System.out.println(arr3[0]);//获取二维数组中的第一个一维数组(获取的是一个地址值:[I@4eec7777)

        System.out.println(arr3[0][0]);//获取第一个一维数组中0索引的元素
        System.out.println(arr3[1][2]);//打印数字55

        //arr[i][j]
        //i:二维数组的索引，获取出来的是里面的一维数组（地址）
        //j:表示一维数组中的索引，获取出来的是真正的元素
        
          for (int i = 0; i < arr3.length; i++) {
            //i:表示二维数组中的每一个索引
            //arr[i]:表示二维数组中的每一个元素（一维数组）
            for (int j = 0; j < arr3[i].length; j++) {
                //j:表示一维数组中的每一个元素
                System.out.println(arr3[i][j]);
            }
        }
        //每个一维数组单独一行
        //外循环：遍历二维数组，得到里面的每一个一维数组
        for (int i = 0; i < arr3.length; i++) {
            //i:表示二维数组中的每一个索引
            //arr[i]:表示二维数组中的每一个元素（一维数组）
            //内循环：遍历一维数组，得到里面的每一个元素
            for (int j = 0; j < arr3[i].length; j++) {
                //j:表示一维数组中的每一个元素
                System.out.print(arr3[i][j]+" ");
            }
            System.out.println();
        }
      
            
            
    }
}

二维数组的动态初始化格式： 数据类型[][] [] [] 数组名 = new 数据类型 [m] [n] ;
m表示这个二维数组可以放多少个一维数组
n表示每一个一维数组可以存放多少个元素