目录
一、 一维数组的基本概念
1.1. 什么是数组
1.2. 数组的创建及初始化
1.3. 数组的使用
二、数组是引用类型
2.1. 初始JVM的内存分布
2.2. 基本类型变量与引用类型变量
2.3. 引用变量的理解
2.4. null
三、数组的应用场景
3.1. 作为函数的参数
3.2. 作为函数的返回值
一、 一维数组的基本概念
1.1. 什么是数组
当我们需要存储多个类型相同的变量时，如果一个一个去创建会很麻烦 ，此时我们就可以使用数组去简化这类问题。数组：可以看成是相同类型元素的一个集合。在内存中是一段连续的空间，地址是连续存放的。每个空间有自己的编号，第一个位置的编号为0，即数组的下标。
1.2. 数组的创建及初始化
（一）数组的创建规则:
数据类型 [] = new 数据类型[N]，其中N表示数组的长度。
int[] array1=new int[10];//表示一个可容纳10个int型的数组 double[] array2=new double[20];//表示一个可容纳20个double型的数组 String[] array3=new String[30];//表示一个可容纳30个String性的数组（二）数组的初始化
数组的初始化主要分为动态初始化以及静态初始化。
（1）动态初始化：在创建数组时，直接指定数组中元素的个数
int[] array=new int[10]（2） 静态初始化：在创建数组时不直接指定数据元素个数，而直接将具体的数据内容进行指定
int[] array4 = new int[]{0,1,2,3,4,5,6,7,8,9}; double[] array5 = new double[]{1.0, 2.0, 3.0, 4.0, 5.0}; String[] array6 = new String[]{"hell", "Java", "!!!"};注意：1.静态初始化虽然没有指定数组的长度，编译器在编译时会根据{}中元素个数来确定数组的长度 2.静态初始化时, {}中数据类型必须与[]前数据类型一致 3.静态初始化可以简写，省去后面的new T[]。
如果没有对数组进行初始化，数组中元素有其默认值。如果数组中存储元素类型为基类类型，默认值为基类类型对应的默认值。
| 类型 | 默认值 |
| byte | 0 |
| short | 0 |
| int | 0 |
| long | 0 |
| float | 0.0f |
| double | 0.0 |
| char | /u000 |
| boolean | false |
| String | null |
在这里我们只演示boolean和String类型的默认值，代码如下，对此代码进行调试，运行最后一行时，我们就可以看到boolean的默认值为false
public static void main(String[] args) { boolean[] array=new boolean[3];//默认值为false System.out.println("====="); String[] str=new String[3]; }
1.3. 数组的使用
（1）数组元素的访问
数组是一段连续的内存空间，因此支持随机访问，即通过下标访问快速访问数组中任意位置的元素 ，即我们可以通过下标来进行打印、修改，并且不能越界访问，否则会出现如下报错。
int[] arrays=new int[]{1,2,3,4}; arrays[2]=10; System.out.println(arrays[1]);//打印元素 System.out.println(arrays[2]);//修改元素 System.out.println(arrays[4]);//越界访问
（2）遍历数组：将所有元素都访问一遍。
如果我们一个一个打印，或者对里面的元素进行修改，会非常麻烦。此时我们可以使用for循环来解决。
int[] arrays = new int[]{1,2,3,4,5,6}; for(int i=0;i<=5;i++){ System.out.println(arrays[i]); }我们来对此代码进行调试，当运行到“System.out.println(arrays[i]);”时，就会产生如下图所示。
虽然for循环可以帮助我们解决上面提到的问题，但是我们无法获取数组的长度。那我们就可以通过下面的代码来进行实现。
int[] arrays = new int[]{1,2,3,4}; for(int i=0;i< arrays.length;i++){ System.out.print(arrays[i]); } System.out.println(); for (int x:arrays) { System.out.println(x); }第一种是for循环，原理不必多说；第二种是for-each，原理是遍历数组，将数组中的元素赋值给x，但这种方法无法获取数组元素的下标，也无法对下标进行运算。
当然还有第三种打印方式，是由Java官方提供操作数组的工具，代码如下：
import java.lang.reflect.Array;import java.util.Arrays;public class Main { public static void main(String[] args) { int[] arrays=new int[]{1,2,3,4,5}; String ret=Arrays.toString(arrays); System.out.println(ret); }}Array需要导入一个Arrays的包，我们可以查看一下toString的源码，是String类型的，所以使用String ret来接收一下，直接打印ret就可以了。 下图为打印结果。
二、数组是引用类型
2.1. 初始JVM的内存分布
我们经常说数组是引用变量，数组里的元素是如何储存在数组里的呢？要想搞清楚这两个问题，那我们首先需要了解JVM的内存分布。
我们可以把JVM理解为一个大房子，房子分为客厅、厨房、卧室、厕所。同样，JVM也可以划分出多个内存空间，如下图所示。设想一下，如果我们的房子非常乱，找起东西来就会很麻烦。如果对内存中存储的数据不加区分的随意存储，那对内存管理起来将会非常麻烦。
2.2. 基本类型变量与引用类型变量
基本数据类型创建的变量，称为基本变量，该变量空间中直接存放的是其所对应的值；而引用数据类型创建的变量，一般称为对象的引用，其空间中存储的是对象所在空间的地址。 好，我们来看下面一组代码：
public static void main(String[] args){ int a = 1; int[] arrays = {1,2,3,4,5};arrays就是一个局部类型的引用变量，数组里的元素会在堆上有一个地址，arrays这个变量就会在栈上存这个地址；a也是main方法里的局部变量，它只会在栈上开辟内存空间，就不会在堆上。所以引用变量并不直接存储对象本身，可以简单理解成存储的是对象在堆中空间的起始地址。通过该 地址，引用变量便可以去操作对象。
2.3. 引用变量的理解
看下面一组代码：
public static void main(String[] args) { int[] array1 = new int[3]; array1[0] = 10; array1[1] = 20; array1[2] = 30; int[] array2 = new int[]{1,2,3,4,5}; array2[0] = 100; array2[1] = 200; array1 = array2;//重点，必须理解 array1[2] = 300; array1[3] = 400; array2[4] = 500; for (int i = 0; i < array2.length; i++) { System.out.println(array2[i]); } }
array1=array2，相当于我们把array2的地址赋给了array1，则array1就不能存原来的地址，这样就会造成两块引用同时指向一个空间，相当于通过array1去修改并访问array2，所以说打印出来的值则为100、200、300、400、500。那array1之前所指向的内存空间呢？答案是被回收掉了。
2.4. null
null 的作用类似于 C 语言中的 NULL (空指针), 都是表示一个无效的内存位置.。因此不能对这个内存进行任何读写操作。 一旦尝试读写, 就会抛出 NullPointerException，说明某个引用为空，访问了一个空的引用。
public class Main { public static void main(String[] args) { int[] array1 = {1,2,3}; System.out.println(array1);//打印结果是16进制的地址 int[] array2 = null;//array2属于引用类型，默认值不能为0// array引用不指向任何对象 System.out.println(array2.length);//null不指向任何对象，运行就会显示空指针异常 }}博主还留下了两个问题给你去思考：1、引用可以指向引用吗？ 2、一个引用可以指向多个对象吗？好，第一个问题：array1=array2，上面我们提到了，array1指向的是array2所指向的对象。第二个问题：一个引用只能指向一个对象，比如 int a=10，不能说a在栈上存储了10个数据吗。
三、数组的应用场景
3.1. 作为函数的参数
public class Main { public static void print(int[] array){ for (int i = 0; i < array.length; i++) { System.out.print(array[i]); } System.out.println(); } public static void main(String[] args) { int[] array={1,2,3}; print(array); }}
虽然两个引用都指向了同一个对象，但两个引用的作用域不一样，上面的array是形参，下面的array是实参 ，打印出来的结果就是1 2 3。在这种情况下，我们修改形参的值, 不影响实参的值。那如果我们来看下面一组代码，参数传数组类型呢？
两个方法都是传递引用类型，第一个方法改变了形参的地址，形参的指向被改变了；而第二个方法中，形参修改了指向对象的内容。
public class Main { public static void func1(int[] array){ array =new int[]{10,20,30,40,50}; } public static void func2(int[] array){ array[0]=10; } public static void main(String[] args) { int[] array={1,2,3}; func1(array); print(array); main1(args);//在main方法中，我们调用main1，就可以同时运行main和main1 } public static void main1(String[] args) { int[] array={1,2,3}; func2(array); print(array); }
3.2. 作为函数的返回值
我们都知道调用方法时，只能返回一个值，那我们可以使用数组来进行多个返回值的接收，代码如下：利用ret来接收，并返回给array。
import java.util.Arrays;public class Main { public static int[] test(){ int[] ret=new int[2]; ret[0]=10; ret[1]=20; return ret; } public static void main(String[] args) { int[] array=test(); System.out.println(Arrays.toString(array)); }}