数组的定义

数组是相同类型数据的集合 比如全是int 或者全是 string

数组描述是相同类型的数据，他们按照一定的先后次序排序

（先后次序排序，取决于你输入的时候怎么排序）

其中，每一个数据称作一个数组元素，每个数据元素可以通过一个下吧来访问。

数组元素是从0开始的，假如数组有10个数字，他最高的下标是9

俗称 从零开始的数组访问

数组声明和 创建

首先必须声明数组变量，才能在程序中使用数组。下面是声明数组变量的语法：

dataType[] arrayRefVar; //首选的方法

或

dataType[] arrayRefVar[];//效果相同，但不是首选语法

一个是在类型后面加中括号一个是在变量名后面加中括号

package array;

public class ArrayDay01 {

//变量的类型 变量的名字 = 变量的值

//数组类型

public static void main(String[] args) {

int[] nums; //定义 //首选的方法

int nums2 []; //这2种都是可以的 //效果相同，但不是首选方法

//加一个中括号，就可以代表这是int类型的数组了

//为什么会有2种，是因为int nums2[]是c++类型的，早期是为了让c++的人快速掌握Java。 所以平时就用int[] nums;类型的就可以了

nums = new int[10];//这里面可以存放10个int类型的数字

}

看一下上面的代码，可以知道int[] nums 和int nums[] 的区别在哪里

如果没有数组的话，我们要定义一个数值，就要int x

int x1 int x2 这样，很麻烦，要写很多代码

比如图中的框框是一个内存，我们定义了一个int x=1 ，那么这个空间就是等于1了， 而那个空间的名称就叫做x

这个空间就是int类型，里面就是数字1 ，但是只能放一个。

要是想要定义10个，就要复制10个，非常麻烦

数组的意思

int[] nums = new int[10]

//int[] nums 数组的意思

//new int[10] **是新建一个int类型的组，新建了一个空间，空间里面开了10个数值 ** new 是 新 的意思

然后这个空间的名称叫做nums

这个空间里面被开辟了10个空间 ，空间数量多少 取决于new int[10] 的中括号里面的数值为多少，则空间数量为多少

里面所有的类型都是int类型的

里面的空间，分别对应1-10

然后每个空间都有一个编号也就是所谓的下标

下标是从0开始的

0-9是位置编号，1-10是里面的值

我们要取值的话，就是 nums 下的第0号元素。

相当于原来是一个数，现在是一组数，

但是这一组的同一个名字，所以他里面的类型必须都相同

Java语言使用new操作符来创建组，语法如下

dataType[] arrayRefVar = new dataType[]

//dataType[] arrayRefVar 我们的数组

//dataType[] 为类型

//arrayRefVar 为名称

//new dataType[] 就是新建一个类型为dataType的组

就跟int[] nums = new int[];

这样 int[] nums 是变量 和 名称

new int[] 是创建一个类型为int 类型的组

示列

package array;

public class ArrayDay01 {

//变量的类型 变量的名字 = 变量的值

//数组类型

public static void main(String[] args) {

int[] nums; //声明一个数组

nums = new int[10];//创建一个数组，里面可以存放10个int类型的数字

//给数组元素中赋值

nums[0] = 1;

nums[1] = 2;

nums[2] = 3;

nums[3] = 4;

nums[4] = 5;

nums[5] = 6;

nums[6] = 7;

nums[7] = 8;

nums[8] = 9;

nums[9] = 10;

System.out.println(nums[0]);

}

}

运行一下， 得出1

我们吧0改成9 运行一下，得出10

如果我们吧

nums[9] = 10;

给删掉话，再次运行就会得出一个默认值0

当然也可以

int[] nums = new int[]

//数据类型+上一个中括号代表他是数组

//名称

//在new一个int类型的数组，（中括号里面）再给他分配一个初始的大小

//数组必须给他一个初始值，不然特没有特定的值，万一无线创下去就乱套了

//数组的长度是确定的，一旦创建，它的大小就是不可以更改的

这样，我们吧声明和长度写在一起了

获取数组的长度 语法

arrays.length

​ arrays为数组的名称

length 是获取长度

求数组的全部值的和

package array;

public class ArrayDay01 {

//变量的类型 变量的名字 = 变量的值

//数组类型

public static void main(String[] args) {

int[] nums; //声明一个数组

nums = new int[10];//创建一个数组，里面可以存放10个int类型的数字

//给数组元素中赋值

nums[0] = 1;

nums[1] = 2;

nums[2] = 3;

nums[3] = 4;

nums[4] = 5;

nums[5] = 6;

nums[6] = 7;

nums[7] = 8;

nums[8] = 9;

nums[9] = 10;

//计算所有元素的和

int sum = 0;

//获取数组长度： arrays.length

for (int i = 0;i

sum = sum +nums[i];

}

System.out.println("总和为："+sum);

}

}

如图

内存分析

Java内存分析

理解

声明一个nums，这个时候在堆里面还是没有东西的。 但是在栈（zhan）里面会压过一个东西，叫做nums.

我们现在只是声明了一个数组，这个数组是空的，他只有一个名字，这个名字并没有什么实际作用

2.第二部创建数组

nums = new int [10]

new一个int ，产生了 new这个事件

看上面的图片，new关键词都会放在堆里面

于是乎，在做完这个第二部的时候栈里面的nums

在堆里面做了一件事情

他开辟了一个空间，这个空间就是int类型

里面被分成了10个小块，因为初始的大小为10

声明的时候，这个数组并不存在，只有我们通过new关键词去创建的时候，这个数组才存在，当我们给里面赋值的时候，这里面才有值，没有赋值的话，里面就是默认值

加入我们只有10个元素，那我要是获取第11个元素会怎么样呢？

//给数组元素中赋值

nums[0] = 1;

nums[1] = 2;

nums[2] = 3;

nums[3] = 4;

nums[4] = 5;

nums[5] = 6;

nums[6] = 7;

nums[7] = 8;

nums[8] = 9;

nums[9] = 10;

System.out.println(nums[10]);

就会看到一个错误

java.lang.ArrayIndexOutOfBoundsException

array 数组的意思

IndexOutOfBounds 数组下标越界了

就是说，我们数组只有10个，你却取第11个，

第11个，可能在外面，也有可能不存在，所以是拿不到的

所以就会异常

不过一般来说，我们都是把声明和创建写在一块

int[] nums =new int[10];

数组的三种初始化

静态初始化

int[] a ={1,2,3};

Man[] mans = {new Man(1,1),new Man(2,2)}

动态初始化

int[] a = new int[2];

a[0] = 1;

a[1] = 2;

数组的默认初始化

数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化。

静态初始化

int[] a = {1,2,3,4,5,6,7,8};

System.out.println(a[0]);

我个人理解是

静态初始化

int[] 这是数组的一个类型

a = 名称

我们之前呢？ 是new int[] new了一个int让它初始化

我们也可以直接给他初始化，一个{}括号就代表这是一个数组

所有花括号括起来的都是一个数组

然后我们在往数组里面放元素了。放多少个，它的空间就是多大 ，一旦定义之后就不可以改变了

a就是固定那么多

创建的时候顺便赋值

我们输出一下 a[0] 发现等于1

动态初始化

int[] b = new int[10];

b[0] = 10;

b[1] = 10;

b[2] = 10;

b[3] = 10;

b[4] = 10;

System.out.println(b[0]);

System.out.println(b[1]);

System.out.println(b[2]);

System.out.println(b[3]);

System.out.println(b[4]);

int[] b = new int[10];

int[] b = new int[10]；

前面的叫声明，后面的叫初始化，给他创建空间

但是空间创建完之后，里面现在的所有值都是零

我们要给他去手动赋值

动态初始化：默认初始化

数组在没有被赋值的时候默认是0，String类型是null 空的意思

int[] b = new int[10];

b[0] = 10;

System.out.println(b[0]);

System.out.println(b[1]);

我们运行b[0]和b[1]

发现

一个为10 一个为0

没有被初始化的空间，默认值是0

数组的四个基本特点

长度是确定的。数组一旦被创建，它的大小计算不可以改变的。如果说需要改变大小，那么只能重新创建

其中元素的类型必须是相同的类型，不允许出现混合类型

比如里面定义的是int类型，那么就不能出现String类型

数组中的元素可以是任何数据类型，包括基本类型和引用类型。

数组变量属于引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量。

数组本身就是对象，Java中对象是在堆中的，因此数组无论保持原始类型还是其他对象类型，数组对象本身是在堆中的

只要使用new关键词，new出来的，以及数组，都是在堆中的

不管是原始类型还是其他对象类型的，所有东西都是保存在堆中的

数组边界

下标的合法区间：[0，lenght-1]，如果越界就会报错;

就比如说，我们的数组长度为10，

但是真正的下标数值为[0,10-1]

就是[0，9]

public stativ void main(String[] args){

int[] a = new int [2];

System.out.println(a[2]);

}

上图中的代码，一旦运行就会出现

ArrayIndexOutOfBoundsException:数组下标越界异常！

出现这个错误的时候，就要回去看看，什么地方越界了

示范

package array;

public class ArrayDay02 {

public static void main(String[] args) {

//静态初始化 创建+赋值

int[] a = {1,2,3,4,5,6,7,8};

for(int i = 0; i

System.out.println(a[i]);

}

a.length 的意思是

a为我们数组的名称

length为 数组的长度

System.our.println(a[i])；

我们输出一下

就会发现全部都运行出来了

我们在i

for(int i = 0; i<=a.length; i++){

System.out.println(a[i]);

}

再次运行就会发现

越界了

i<=8 的时候 i=8 ，但是数组里面没有int [8]的数组

所以显示越界了

数组边界小结

数组是相同数据类型的有序集合

数组也是对象。因为他是new出来的，数组元素相当于对象的成员变量

数组的长度是确定的，不可以变的，想改变的话，必须重新创建一个

如果越界就会报出 ArrayIndexOutOfBounds

数组使用

For-Each 循环

数组作方法入参

数组作返回值

package array;

public class ArrasyDay03 {

public static void main(String[] args) {

int[] arrays = {1,2,3,4,5};

//打印全部的数组元素

for(int i = 0 ; i< arrays.length ;i++) {

System.out.println(arrays[i]);

}

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

//计算所有元素的和

int sum = 0;

for (int k = 0 ; k

sum = sum + arrays [k] ;

}

System.out.println("sum :" +sum); System.out.println("=====================");

//查找最大元素

int max = arrays[0];

for (int i = 1; i < arrays.length; i++) {

if (arrays[i]>max){

max = arrays[i];

}

}

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

}

}

分别是打印数组、求和还有最大元素的写法

For-Each 循环 刚刚我们用的都是普通的for循环

​

public static void main(String[] args) {

int[] arrays = {1,2,3,4,5};

//JDK1.5以上版本 省略了下标 // 用于打印输出

for (int array : arrays) {

// arrays 代表一个数组

System.out.println(array);

}

我们输入arrays.for 就是自动变成 上面的方法理解就好

for(int array ： arrays)

// int array 是类型+名称

//arrays 是数组的名称

//： 是类似于==的意思

然后我们在输出一下，这样子的for循环是直接吧arrays里面的数值

一个一个打印出来，是比较简单的一种操作

但是还是建议使用这种类型的

for(int i = 0 ; i

System.out.println(arrays[i]+" ")

}

数组作方法入参 数组作返回值

打印数组元素

.public static void main(String[] args){

printArray(reverse);

}

public static void printArray(int[] arrays) {

//static 是为了后面方便调用， 就是类变量

//printArray 是方法名称

//int[] arrays 是int类型 arrays名称的数组

for(int i = 0 ;i < arrays.length;i++){

// arrays.langth arrays是数组名称

//langth 是长度的意思， 合在一起就是arrays这个数组的长度有多长

System.out.print(arrays[i]+" ");

//print 是运行完之后不换行

}

输出一下，就是

反转数组

package array;

public class ArrasyDay04 {

public static void main(String[] args) {

int[] arrays = {1,2,3,4,5};

int[] reverse = reverse(arrays);

printArray(reverse);

}

//反转数组

public static int[] reverse(int[] arrays){

int[] result = new int[arrays.length];

//反转的操作

for (int i = 0, j=result.length-1; i < arrays.length ; i++,j--) {

result[j] = arrays[i];

}

return result;

}

}

第一步

public static int[] reverse(int[] arrays){

//public static 是修饰符

//int[] 为返回的数据类型 返回一个数组

//reverse 是方法名称 reverse ： 反转

//传递的是数组参数 int[] arrays arrays名称的数组类型

//

}

第二部

public static int[] reverse(int[] arrays){

int[] result = new int[arrays.length];

}

声明并创建一个数组，数值为arrays.length 意思是 arrays数组的长度

这样可以保证，是同一个结果

第三部 反转操作

public static int[] reverse(int[] arrays){

int[] result = new int[arrays.length];

//反转操作

for(int i = 0,j=result.length-1;i< arrays.length;i++,j--){

//j=result.length-1 是因为有个下标是0

result[j] = arrays[i];

//result[j] 因为上面 int[arrays.length]; 也就是说他是5

//所以j=result.length-1 = 4 (这是下标)

//而arrats[i] 是从1开始 ，然后递增 到4

//所以j=4 i=1

//j 是下标符 i是数值

//所以4=1 3=2 2=3 1=4 0=5

//然后排序就是5,4,3,2,1

}

return result;

}

result[j] 因为上面 int[arrays.length]; 也就是说他是5

所以j=result.length-1 = 4 (这是下标)

而arrats[i] 是从1开始 ，然后递增 到4

所以j=4 i=1

j 是下标符 i是数值

所以4=1 3=2 2=3 1=4 0=5

然后排序就是5,4,3,2,1

然后再return返回result的值

然后我们在输出一下

public class ArrasyDay04 {

public static void main(String[] args) {

int[] arrays = {1,2,3,4,5};

int[] reverse = reverse(arrays);

printArray(reverse);

输入reverse(arrays);

就会返回一个结果，这个结果就是已经被反转过的数组

int[] reverse = reverse(arrays);

然后再输出printArray(revers);

运行一下