Java——数组的定义与使用

数组的定义与使用

1.数组的基本概念

（1）数组的动态初始化：

数组首先先开辟内存空间，而后再使用索引进行内容的设置，这种定义数组的方式称为动态初始化

数组是引用数据类型，存在有内存分配问题。在使用前一定要开辟空间（实例化），否则就会产生NullPoninterException

数组的动态初始化（声明并开辟数组） 数据类型[ ] 数组名 = new 数据类型[数组长度]

数组的分步初始化： 数据类型[ ] 数组名 = null； 数组名 = new 数据类型[数组长度]

当数组开辟空间之后，就可以采用如下方式对数组进行操作：

1.数组可以通过索引完成，即“数组名[索引]”；

注意：数组索引从0开始，所以索引的范围为：0——（数组长度-1）如果访问的值超过数组长度，会产生    “java.lang.ArrayIndexOutOfBoundsException”异常。

2.当数组动态初始化开辟空间后，数组中每个元素都是该数据类型的默认值。

3.数组是一个有序的集合操作，所以对于数组的内容操作往往采用循环操作（for循环）。

4.Java中可采用 数组名.length 来获取数组长度。

public class Test7 {

public static void main(String[] args){

int[] demon = new int[4];//开辟一个长度为10的整型数组

System.out.println(demon.length);//求数组的长度

demon[0] = 0;//数组的第一个元素

demon[1] = 1;

demon[2] = 2;

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

System.out.print(" ");

System.out.print(demon[i]);//打印数组的元素

}

}

}

运次结果：10

0 1 2 0

（2）数组的动态初始化：

数组在定义的同时可以设置内容，则称为数组的静态初始化。

数据类型[] 数组名 = {值1……}

数据类型[] 数组名 = new 数据类型[] {值……}（推荐使用）

public class Test7 {

//数组静态初始化（简化格式）

public static void main(String[] args){

int[] demon1 ={2,3,5,6,9,11};

System.out.println(demon1.length);

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

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

}

}

}

运行结果：6

2

3

5

6

9

public class Test7 {

//数组静态初始化（完成格式）**推荐使用

public static void main(String[] args){

System.out.println(new int[]{1,2,3,4,5}.length);//匿名数组

}

}

运行结果：5

2.数组的引用传递

数组作为引用数据类型，也一定存在引用传递。

public class Test7 {

public static void main(String[] args) {

int[] demon = null ;

demon = new int[4] ;

demon[0] = 0 ; // 数组第一个元素

demon[1] = 1 ; // 数组第二个元素

demon[2] = 2 ; // 数组第三个元素

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

System.out.println(demon[i]) ; // 通过循环控制索引下标更改

}

}

}

通过上述例子，我们来探讨内存分配的问题：

引用传递空间：同一块堆内存可被多个栈内存所指向。如下例：内存分析见下。

public class Test7 {

public static void main(String[] args) {

int[] demon = new int[4] ;

int[] temp = null;

System.out.println(demon.length);

demon[0] = 0 ; // 数组第一个元素

demon[1] = 1 ; // 数组第二个元素

demon[2] = 2 ; // 数组第三个元素

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

System.out.println(demon[i]) ; // 通过循环控制索引下标更改

}

temp = demon;

temp[0] = 20;

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

}

}

运行结果：4

0

1

2

0

20

内存分析图：

数组最大的缺陷：长度固定。

3.二维数组

二维数组（数组的数组）：二维数组本质上指的就是一个行列的集合。换言之，如果要获得一个数据，既需要行索引，也需要列索引。

要获取二维数组中的元素：数组名[行索引][列索引]

二维数组的初始化：

动态初始化： 数据类型[][] 数组名 = new 数据类型[行个数][列个数]

静态初始化： 数据类型[][] 数组名 = new 数据类型[][]{{值……}，……{值……}}

public class Test7 {

//二维数组

//数组并不是等列数组

public static void main(String[] args){

int[][] demon3 = new int[][]{{1,3},{5,7,9},{2,4}};

//打印二维数组要使用双重循环

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

for(int j =0;j<demon3[i].length;j++){

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

}

}

}

}

4.数组和方法的互操作

数组是引用数据类型，所有引用数据类型都可以为其设置多个栈内存所指向；所以在进行对数组的操作时，可以通过其他方式处理。

（1）方法接收数组

（2）方法返回数组

（3）方法修改数组

public class Test7 {

//数组与方法的互操作

public static void main(String[] args){

int[] demon = receive();

changeDouble(demon);

printArray(demon);//等价于 int[] temp =demon;

}

//方法接收数组组

public static int[] receive(){

return new int[]{1,27,18,21};//匿名数组

}

//方法返回数组

public static void printArray(int[] temp){

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

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

}

}

//方法改变数组

public static void changeDouble(int[] arr){

for(int j = 0;j<arr.length;j++){

arr[j] *=2;//每个数组元素扩大两倍

}

}

}

运行结果：2

54

36

42

内存分析图如下：

5.Java对数组的支持

1.对数组进行排序：

只要是基本数据类型的数组，sort方法都可以进行排序处理(升序处理)。

数组排序 ： java.util.Arrays.sort(数组名称)

package test;

public class Test7 {

//java对数组的支持

public  static void main(String[] args){

int[] demon5 = new int[]{20,8,4,92,1};

char[] demon6 = new char[]{'c','D','a','g','A'};

java.util.Arrays.sort(demon5);//对整型数组排序

java.util.Arrays.sort(demon6);//对字符型数组排序

printArray(demon5);

printArray(demon6);

}

public static void printArray(int[] temp){

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

System.out.print(temp[i]);

System.out.print(" ");

}

}

public static void printArray(char[] temp){

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

System.out.print(temp[i]);

System.out.print(" ");

}

}

}

运行结果：1 4 8 20 92 A D a c g

 

2.实现数组的拷贝：

数组拷贝：指的是将一个数组的部分内容替换掉另一个数组的部分内容（必须是连续的）。

System.arraycopy(源数组名称，源数组开始点，目标数组名称，目标数组开始点，拷贝长度)

public class Test7 {

//实现数组的拷贝

//实现将demon2的2-4个元素拷贝至demon1的6-8个元素位置处

public static void main(String[] args){

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

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

System.arraycopy(demon2,1,demon1,5,3);

printArray(demon1);

}

public static void printArray(int[] temp){

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

System.out.print(temp[i]);

System.out.print(" ");

}

}

}

6.数组案例

给出以下数组，要求可以统计出该数组的最大值、最小值、平均值、总和。

0	1	2	3	4	5	6	7	8
1	4	3	4	55	77	6	9	8

（1）简单的实现方法实现

public class Test7 {

       

       public static void main(String[] args){

int[] demon = new int[]{1,4,3,4,55,77,6,9,8};

int max = demon[0];

int min = demon[0];

int sum = demon[0];

double avg = 0.0;

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

sum += demon[i];

if(demon[i] > max){

max = demon[i];

}

if(demon[i] < min){

min = demon[i];

}

}

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

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

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

System.out.println("avg= "+(1.0*sum/demon.length));

}

}

运行结果：

max= 77

min= 1

sum= 167

avg= 18.555555555555557

由上述代码可以看出：主函数中代码量大，代码比较凌乱；主方法相当于客户端调用，代码应越简单越越好。

（2）使用方法与数组互操作实现

//数组排序(数组与方法互操作)

public class Test7 {

       public static void main(String[] args){

int[] demon = new int[]{1,4,3,4,55,77,6,9,8};

maxValue(demon);

minValue(demon);

sumAndAvg(demon);

}

//求最大值

public static void maxValue(int[] temp){

int max = temp[0];

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

if(temp[i] > max){

max = temp[i];

}

}

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

}

//求最小值

public static void minValue(int[] temp){

int min = temp[0];

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

if(temp[i] < min){

min = temp[i];

}

}

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

}

//求平均值和总和

public static void sumAndAvg(int[] temp){

int sum = temp[0] ;

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

sum += temp[i];

}

double avg = 1.0*sum/temp.length;

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

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

}

}

运行结果：

max= 77

min= 1

sum= 167

avg= 18.555555555555557

使用如上方式使得逻辑比较清晰，主函数中代码量减少。

7.对象数组

可以看出前面所定义的都是基本数组，对象数组往往是以引用数据类型为主的定义；对象数组中保存的内容要比普通类型多；如：接口、类。

（1）对象数组的动态初始化

类名称[ ] 对象数组名 =  new 类名称[长度]

//对象数组的动态初始化

class Person{

private String name;

private int age;

public Person(String name, int age){//构造方法

this.name = name;

this.age = age;

}

public void getPrint(){

System.out.println("姓名： "+this.name+" 年龄： "+this.age);

}

}

public class Test7 {

public static void main(String[] args){

Person[] per = new Person[3];

per[0] = new Person("张三",16);

per[1] = new Person("李四",18);

per[2] = new Person("王五",20);

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

per[i].getPrint();

}

}

}

运行结果：

姓名： 张三 年龄： 16

姓名： 李四 年龄： 18

姓名： 王五 年龄： 20

（2）对象数组的静态初始化

类名称[ ] 对象数组名 =  new 类名称[]{new 类名称（）…… }

class Person{

private String name;

private int age;

public Person(String name, int age){//构造方法

this.name = name;

this.age = age;

}

public void getPrint(){

System.out.println("姓名： "+this.name+" 年龄： "+this.age);

}

}

//静态初始化

public class Test7 {

public static void main(String[] args){

Person[] per = new Person[]{

new Person("张三",16),

new Person("李四",18),

new Person("王五",20)};

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

per[i].getPrint();

}

}

}

运行结果：

姓名： 张三 年龄： 16

姓名： 李四 年龄： 18

姓名： 王五 年龄： 20

运行结果：1 3 5 7 9 2 4