目录
数组的基本概念
1.为什么要使用数组
在Java中定义一个学生的成绩，只需要 int score = 80；即可
那如果有
20
名同学成绩呢，需要创建
20
个变量吗？有
100
个学生的成绩那不得要创建100
个变量？
我们观察这些学生成绩发现：
所有成绩的类型都是相同的
，那
Java
中存在可以存储相同类型多个数据的类型吗？这就是本节要说明的数组。
2.什么是数组
数组：可以看成是
相同类型元素的一个集合
。在内存中是一段连续的空间。
1.
数组中存放的元素其类型相同(比如都是整型int）
2.
数组的空间是连在一起的
3.
每个空间有自己的编号，起始位置的编号为
0
，即数组的下标。
3 数组的创建及初始化
3.1
数组的创建
T[] 数组名 = new T[N];
T
：表示数组中存放元素的类型
T[ ]
：表示数组的类型
N
： 表示数组的长度
int[] array1 = new int[10]; // 创建一个可以容纳10个int类型元素的数组
double[] array2 = new double[5]; // 创建一个可以容纳5个double类型元素的数组
String[] array3 = new double[3]; // 创建一个可以容纳3个字符串元素的数组
3.2
数组的初始化
数组的初始化主要分为
动态初始化以及静态初始化
。
3.2.1.
动态初始化：在创建数组时，直接指定数组中元素的个数
int[] array = new int[10];
3.2.2.
静态初始化：在创建数组时不直接指定数据元素个数，而直接将具体的数据内容进行指定
语法格式： T[] 数组名称 = {data1, data2, data3, ..., datan};int[] array1 = new int[]{0,1,2,3,4,5,6,7,8,9};
double[] array2 = new double[]{1.0, 2.0, 3.0, 4.0, 5.0};
String[] array3 = new String[]{"hello", "Java", "!!!"};
注意：
静态初始化虽然没有指定数组的长度，编译器在编译时会根据
{ }
中元素个数来确定数组的长度。
静态初始化时
, { }
中数据类型必须与
[ ]
前数据类型一致。
静态初始化可以简写，省去后面的
new T [ ]
。
注意：虽然省去了new T[], 但是编译器编译代码时还是会还原
int[] array1 = {0,1,2,3,4,5,6,7,8,9};
double[] array2 = {1.0, 2.0, 3.0, 4.0, 5.0};
String[] array3 = {"hell", "Java", "!!!"};
数组也可以按照如下类似C语言
创建，但不推荐
/*
该种定义方式不太友好，容易造成数组的类型就是int的误解
[]如果在类型之后，就表示数组类型，因此int[]结合在一块写意思更清晰
*/
int arr[] = {1, 2, 3};
静态和动态初始化也可以分为两步，但是不能省略格式
int[] array1;
array1 = new int[10];
int[] array2;
array2 = new int[]{10, 20, 30};
// 注意省略格式不可以拆分, 否则编译失败
// int[] array3;
// array3 = {1, 2, 3};错误
如果没有对数组进行初始化，数组中元素有其默认值
如果数组中存储元素类型为基本类型，默认值为基本类型对应的默认值：
如果数组元素中存储的是引用类型，则默认值为null
4 数组的使用
4.1
数组中元素访问
数组在内存中是一段连续的空间，空间的编号都是从
0
开始的，依次递增，该编号称为数组的下标，数组可以通过
下标访问其任意位置的元素
。比如：
int[]array = new int[]{10, 20, 30, 40, 50};
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]);
// 也可以通过[]对数组中的元素进行修改
array[0] = 100;
System.out.println(array[0]);
注意：
数组是一段连续的内存空间，因此
支持随机访问，即通过下标访问快速访问数组中任意位置的元素
下标从
0
开始，介于
[0, N
）之间不包含
N
，
N
为元素个数，不能越界，否则会报出下标越界异常。
int[] array = {1, 2, 3};
System.out.println(array[3]); // 数组中只有3个元素，下标一次为：0 1 2，array[3]下标越界
// 执行结果
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 100
at Test.main(Test.java:4)
抛出了
java.lang.ArrayIndexOutOfBoundsException
异常
.
使用数组一定要下标谨防越界！
4.2
遍历数组
所谓
"
遍历
"
是指将数组中的所有元素都访问一遍
,
访问是指对数组中的元素进行某种操作
，比如：打印。
int[]array = new int[]{10, 20, 30, 40, 50};
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]);
上述代码可以起到对数组中元素遍历的目的，但是：
1.
如果数组中增加了一个元素，就需要增加一条打印语句
2.
如果输入中有
100
个元素，就需要写
100
个打印语句
3.
如果现在要把打印修改为给数组中每个元素加
1
，修改起来非常麻烦。
通过观察代码可以发现，对数组中每个元素的操作都是相同的，则可以使用循环来进行打印。
int[]array = new int[]{10, 20, 30, 40, 50};
for(int i = 0; i < 5; i++){
System.out.println(array[i]);
}4.3获得数组长度
在数组中可以通过
数组对象
.length
来获取数组的长度
int[]array = new int[]{10, 20, 30, 40, 50};
for(int i = 0; i < array.length; i++){
System.out.println(array[i]);
}
也可以使用
for-each
遍历数组
int[] array = {1, 2, 3};
for (int x : array) {
System.out.println(x);
}//1 2 3
for-each
是
for 循环的另外一种使用方式，可以看作是增强版的for语句循环
. 能够更方便的完成对数组的遍历
.
可以避免循环条件和更新语句写错
. 它可以减少代码量，但不是所有的foreach都可以代替for循环。
for（元素类型type 元素变量value ：遍历对象obj）{
引用x的java语句
}数组是引用类型
1.初始JVM的内存分布
内存是一段连续的存储空间，主要用来存储程序运行时数据的。比如：
程序运行时代码需要加载到内存
程序运行产生的中间数据要存放在内存
程序中的常量也要保存
有些数据可能需要长时间存储，而有些数据当方法运行结束后就要被销毁
如果对内存中存储的数据不加区分的随意存储，那对内存管理起来将会非常麻烦。
因此
JVM
也对所使用的内存按照功能的不同进行了划分：
1.程序计数器 (PC Register): 只是一个很小的空间 , 保存下一条执行的指令的地址2.虚拟机栈 (JVM Stack): 与方法调用相关的一些信息， 每个方法在执行时，都会先创建一个栈帧 ，栈帧中包含 ：局部变量表 、 操作数栈 、 动态链接 、 返回地址 以及其他的一些信息，保存的都是与方法执行时相关的一些信息。比如：局部变量。当方法运行结束后，栈帧就被销毁了，即栈帧中保存的数据也被销毁了 。3.本地方法栈 (Native Method Stack): 本地方法栈与虚拟机栈的作用类似 . 只不过 保存的内容是 Native 方法的局 部变量 . 在有些版本的 JVM 实现中 ( 例如 HotSpot), 本地方法栈和虚拟机栈是一起的。Native方法：JVM是一个基于C++实现的程序，在Java程序执行过程中，本质上也需要调用C++提供的一些函数进行与操作系统底层进行一些交互，因此在Java开发中也会调用到C++实现的函数。Native方法就是指这些C++实现的，再由Java调用的函数。4.堆 (Heap) : JVM 所管理的最大内存区域 . 使用 new 创建的对象都是在堆上保存 ( 例如前面的 new int[ ]{1, 2, 3} 堆是随着程序开始运行时而创建，随着程序的退出而销毁，堆中的数据只要还有在使用，就不会被销 毁 )5.方法区 (Method Area) : 用于 存储已被虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码等数 据 . 方法编译出的的字节码就是保存在这个区域6.运行时常量池（Runtime Constant Pool）： 方法区的一部分，存放字面量（字符串常量）与符号引用。从JDK1.7开始，运行时常量池在堆上。
现在我们只简单理解堆 和 虚拟机栈这两块空间，后序
JVM
中还会更详细介绍。
2.基本类型变量与引用类型变量的区别
基本数据类型创建的变量，称为基本变量，该变量空间中直接存放的是其所对应的值；
而引用数据类型创建的变量，一般称为对象的引用，其空间中存储的是对象所在空间的地址。
public static void func() {
int a = 10;
int b = 20;
int[] arr = new int[]{1,2,3};
}
在上述代码中，
a
、
b
、
arr
，都是函数内部的变量，因此其空间都在
main
方法对应的栈帧中分配。
a
、
b
是内置类型的变量，因此其空间中保存的就是给该变量初始化的值。
array
是数组类型的引用变量，其内部保存的内容可以简单理解成是数组在堆空间中的首地址
引用变量并不直接存储对象本身，可以简单理解成存储的是对象在堆中空间的起始地址。通过该
地址，引用变量便可以去操作对象
。有点类似
C
语言中的指针，但是
Java
中引用要比指针的操作更简单。
3.分析引用变量
public static void func() {
int[] array1 = new int[3];
array1[0] = 10;
array1[1] = 20;
array1[2] = 30;
//此时array1 = 10，20，30
int[] array2 = new int[]{1,2,3,4,5};
array2[0] = 100;
array2[1] = 200;
//此时array2 = 100，200，3，4，5
array1 = array2;//array1指向array2的地址，此时两数组相同
array1[2] = 300;
array1[3] = 400;
array2[4] = 500;
for (int i = 0; i < array2.length; i++) {
System.out.println(array2[i]);
}
}
//array2 = 100，200，300，4000，500
1.创建数组array1，没有给数组元素设置初始值，因此每个位置都是0
2.通过下标的方式将数组中每个元素修改成10、20、30
3.创建数组arra2，并将其中元素设置为1、2、3、4、5
4.通过下标方式将数组中前两个元素设置为100、200
1.array1 = array2，即让array1去引用array2引用的数组的空间，此时array1和array2实际是一个数组
2.通过array1将数组2和3号位置元素修改为300、400，此时array2也也能看到数组中修改的结果，因为array1和array2引用的是同一个数组
3.通过array2将数组4号位置元素修改为500，此时array1也能看到数组中修改的结果，因为array1和array2引用的是同一个数组
4.通过array2对数组中元素进行打印，输出100、200、300、400、500
4 认识 null
null
在
Java
中表示
"
空引用
" ,
也就是一个不指向对象的引用
.
int[] arr = null;
System.out.println(arr[0]);
// 执行结果
Exception in thread "main" java.lang.NullPointerException
at Test.main(Test.java:6)
null
的作用类似于
C
语言中的
NULL (
空指针
),
都是表示一个无效的内存位置
.
因此不能对这个内存进行任何读写操作.
一旦尝试读写
,
就会抛出
NullPointerException
注意: Java 中并没有约定 null 和 0 号地址的内存有任何关联
数组的应用场景
1 保存数据
public static void main(String[] args) {
int[] array = {1, 2, 3};
for(int i = 0; i < array.length; ++i){
System.out.println(array[i] + " ");
}
}2 作为函数的参数
2.1
参数传递基本数据类型
public static void main(String[] args) {
int num = 0;
func(num);
System.out.println("num = " + num);
}
public static void func(int x) {
x = 10;
System.out.println("x = " + x);
}
// 执行结果
x = 10
num = 0
发现在
func
方法中修改形参
x
的值
,
不影响实参的
num
值
.
2.2
参数传递数组类型
(
引用数据类型
public static void main(String[] args) {
int[] arr = {1, 2, 3};
func(arr);
System.out.println("arr[0] = " + arr[0]);
}
public static void func(int[] a) { //数组作为参数
a[0] = 10;
System.out.println("a[0] = " + a[0]);
}
// 执行结果
a[0] = 10
arr[0] = 10
发现在
func
方法内部修改数组的内容
,
方法外部的数组内容也发生改变
.
因为数组是引用类型，按照引用类型来进行传递，是可以修改其中存放的内容的。
总结
:
所谓的
"
引用
"
本质上只是存了一个地址
. Java
将数组设定成引用类型
,
这样的话后续进行数组参数传参
,
其实只是将数组的地址传入到函数形参中.
这样可以避免对整个数组的拷贝
(
数组可能比较长
,
那么拷贝开销就会很大
).
3 作为函数的返回值
实例：获取斐波那契数列的前
N
项
public class TestArray {
public static int[] fib(int n){ //注意返回值类型 int[]
if(n <= 0){
return null;
}
int[] array = new int[n];
array[0] = array[1] = 1;
for(int i = 2; i < n; ++i){
array[i] = array[i-1] + array[i-2];
}
return array;//返回数组
}
public static void main(String[] args) {
int[] array = fib(10);
for (int i = 0; i < array.length; i++) {
System.out.println(array[i]);
}
}
}实例：写一个方法，将数组中的每一个元素 *2
直接修改数组：
public class Main {
public static void print(int[] arr) {
for (int j : arr) {
System.out.println(j);
}
}
public static void transform(int[] arr){
for (int i=0;i<arr.length;i++){
arr[i] *= 2;
}
}
public static void main(String[] args) {
int[] arr = new int[]{1,2,3};
transform(arr);
print(arr);
}
}上述代码虽然可行，但改变了原数组。如果要求原数组不被改变，需要在方法内部创建一个新的数组，并由该方法返回。这个新数组相当于"中介" 只改变它的值。
public class Main {
public static int[] transform(int[] arr){
int[] arr2 = new int[arr.length];
//方法内创建新数组，只改变新数组的值 此时arr2 = {0，0，0}
//原数组的地址传过来之后 只是参考原数组的长度建立了一个新数组 并不会修改原数组的值
for (int i=0;i<arr.length;i++){
arr2[i] = arr[i] * 2;//给新数组赋值
}
return arr2;//将该数组返回
}
public static void print(int[] arr) {
for (int x: arr) {
System.out.print(x+" ");
}
}
public static void main(String[] args) {
int[] arr = new int[]{1,2,3};
int[] output = transform(arr); //返回的数组需由一个新数组接收
print(output);
System.out.println();
print(arr);//打印原数组 原数组的值不会改变
}
}
输出结果：
2 4 6
1 2 3由于数组是引用类型，返回的时候只是将数组的首地址返回给函数调用者，没有拷贝数组内容。
4 数组转字符串
利用包中提供的Arrays.toString()方法来直接实现：该方法可直接将数组转换为字符串
import java.util.Arrays;
public class Main {
public static void main(String[] args) {
int[] arr = {1,2,3,4,5};
String newArr = Arrays.toString(arr);//将arr数组转为字符串
System.out.println(newArr);
}
}
输出结果：
[1, 2, 3, 4, 5]Java中提供了java.util.Arrays包 其中包含了一些操作数组的常用方法
包：可以理解为程序提供的各种方法的集合。就像方便面的调料包，直接拿来使用，不用自己调味，提高了制作效率。程序开发的过程也不会从零开始，而是要站在巨人的肩膀上。编程过程中不是要把所有的细节都自己实现，已经有的大量标准库（JDK提供好的代码）和海量的第三方库（其他机构组织提供的代码）供我们直接使用。这些代码就放在一个一个的包中。在使用时需要先导入包。
我们也可以编写一个自己的方法 来实现数组转字符串：
public class Main {
public static void main(String[] args) {
int[] arr = {1,2,3,4,5};
System.out.println(toString(arr));
}
//注意返回字符串类型
public static String toString(int[] arr){
String ret = "{";
//利用字符串的拼接 把每个数组元素拼接起来
for (int i=0;i<arr.length;i++){
ret += arr[i];
if (i != arr.length-1){//如果没拼接到最后一个元素，则需要拼接一个逗号
ret += ",";
}
}
ret += "}";//循环结束，拼接到最后一个元素，此时再加上反括号即可
return ret;
}
}
输出结果：
{1,2,3,4,5}上面写的toString方法其实就是包中Arrays.toString()方法内部提供的代码。在编程中直接拿来使用即可。
5 数组的拷贝
import java.util.Arrays;
public static void main(String[] args){
// newArr和arr引用的是同一个数组
// 因此newArr修改空间中内容之后，arr也可以看到修改的结果
int[] arr = {1,2,3,4,5,6};
int[] newArr = arr;
newArr[0] = 10;
System.out.println("newArr: " + Arrays.toString(arr));
// 使用Arrays中copyOf方法完成数组的拷贝：
// copyOf方法在进行数组拷贝时，创建了一个新的数组
// arr和newArr引用的不是同一个数组
arr[0] = 1;
newArr = Arrays.copyOf(arr, arr.length);
System.out.println("newArr: " + Arrays.toString(newArr));
// 因为arr修改其引用数组中内容时，对newArr没有任何影响
arr[0] = 10;
System.out.println("arr: " + Arrays.toString(arr));
System.out.println("newArr: " + Arrays.toString(newArr));
// 拷贝某个范围.
int[] newArr2 = Arrays.copyOfRange(arr, 2, 4);//左闭右开 [2,4)
System.out.println("newArr2: " + Arrays.toString(newArr2));
}
输出结果：
newArr: [10, 2, 3, 4, 5, 6]
newArr: [1, 2, 3, 4, 5, 6]
arr: [10, 2, 3, 4, 5, 6]
newArr: [1, 2, 3, 4, 5, 6]
newArr2: [3, 4]相比于 newArr = arr 这样的赋值方式，copyOf 是将数组进行了 深拷贝 。即又创建了一个数组对象，拷贝原有数组中的所有元素到新数组中，因此修改原数组不影响新数组。
自己编写一个数组拷贝的方法：
import java.util.Arrays;
public class Main {
public static void main(String[] args) {
int[] arr = new int[]{1,2,3};
int[] arr2 = copyOf(arr);
arr[0] = 0;
System.out.println(Arrays.toString(arr));
System.out.println(Arrays.toString(arr2));
}
public static int[] copyOf(int[] arr){
int[] newArr = new int[arr.length];
for (int i=0;i<arr.length;i++){
newArr[i] = arr[i];
}
return newArr;
}
}
输出结果：
[0, 2, 3]
[1, 2, 3]
数组当中存储的是基本类型数据时，不论怎么拷贝基本都不会出现什么问题，但如果存储的是引用数据类型，拷贝时需要考虑深浅拷贝的问题，后续介绍。
二维数组
二维数组本质上也就是一维数组
,
只不过每个元素又是一个一维数组
数据类型[][] 数组名称 = new 数据类型 [行数][列数] { 初始化数据 };int[][] arr = {
{1, 2, 3, 4},
{5, 6, 7, 8},
{9, 10, 11, 12}
};
for (int row = 0; row < arr.length; row++) {
for (int col = 0; col < arr[row].length; col++) {
System.out.printf("%d\t", arr[row][col]);
}
System.out.println("");
}
// 执行结果
1 2 3 4
5 6 7 8
9 10 11 12
二维数组的用法和一维数组并没有明显差别
,
因此我们不再赘述
.
同理
,
还存在
"
三维数组
", "
四维数组
"
等更复杂的数组
,
只不过出现频率都很低
实例：使用嵌套for-each循环输出二维数组
for (int x[]:arr) {
for (int y:x) {
System.out.printf(%-2d,y);
System.out.println();
}
}
675
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
