数组的定义及使用.docx

数组的定义及使用.docx

《数组的定义及使用.docx》由会员分享，可在线阅读，更多相关《数组的定义及使用.docx（28页珍藏版）》请在冰豆网上搜索。

数组的定义及使用

2、知识点

2.1、上次课程的主要知识点

1、类与对象的组成以及加强；

2、简单Java类开发。

2.2、本次预计讲解的知识点

1、数组的基本定义；

2、数组的使用；

3、数组与方法间的互操作；

4、数组有关的操作类库支持。

3、具体内容（★★★★☆）

所有的开发之中都一定要使用到数组，但是数组没有讲解的这么复杂。

之所以本次要讲解的比较多，主要是为了防止笔试中出现的问题。

3.1、数组的基本概念

数组指的是一组相关变量的集合。

如果说现在要求你定义100个整型变量，那么按照最原始的方式则肯定这样定义：

inti1;

inti2;

...

inti100;

这种操作可以实现要求，但是这些变量的关联实在是太麻烦了。

为此在开发之中可以利用数组来解决这一问题。

在Java中数组属于引用数据类型，既然是引用数据类型就牵扯到内存的关系。

对于数组的定义语法有以下两种形式：

·声明并开辟数组：

数据类型数组名称[]=new数据类型[长度]；

数据类型[]数组名称=new数据类型[长度]；

·分步完成：

|-声明数组：

数据类型数组名称[]=null；数据类型[]数组名称=null；

|-开辟数组：

数组名称=new数据类型[长度]；

当数组开辟空间之后那么就可以采用“数组[索引]”的形式进行数组的访问，但是需要注意的是，如果现在数组的长度为3，那么索引的范围：

0~2（一共3个元素）。

如果操作中超过了数组的允许索引范围，则程序在运行过程之中会出现“ArrayIndexOutOfBoundsException”（数组索引超出绑定异常，数组越界）。

以上的操作属于数组的动态初始化，动态初始化的特点，是数组开辟空间之后，数组中每个元素的内容都是其对应数据类型的默认值。

范例：

定义数组

publicclassArrayDemo{//程序必须有类

publicstaticvoidmain（Stringargs[]）{

intdata[]=newint[3];//开辟了一个data数组，长度为3

System.out.println（data[0]）;

System.out.println（data[1]）;

System.out.println（data[2]）;

}

}

范例：

数组的赋值操作

publicclassArrayDemo{//程序必须有类

publicstaticvoidmain（Stringargs[]）{

intdata[]=newint[3];//开辟了一个data数组，长度为3

data[0]=10;//为数组赋值

data[1]=20;

data[2]=30;

System.out.println（data[0]）;

System.out.println（data[1]）;

System.out.println（data[2]）;

}

}

但是现在数组本身是一种顺序式的结构，所以在进行数组内容输出的时候，往往可以采用循环的方式完成。

由于数组的长度是固定的，所以只要是进行数组的输出那么都会考虑使用for循环，这里面就牵扯到了一个数组长度的取得，在Java中可以使用“数组对象.length”属性取得。

范例：

数组输出

publicclassArrayDemo{//程序必须有类

publicstaticvoidmain（Stringargs[]）{

intdata[]=newint[3];//开辟了一个data数组，长度为3

System.out.println（data.length）;

data[0]=10;//为数组赋值

data[1]=20;

data[2]=30;

for（intx=0;x

System.out.print（data[x]+"、"）;

}

}

}

3.2、数组的引用分析

引用数据类型的分析过程几乎都是一样的，所以数组的引用分析其本质也是一样的，与对象的流程是相同的，以下面的代码为例。

publicclassArrayDemo{//程序必须有类

publicstaticvoidmain（Stringargs[]）{

intdata[]=newint[3];//开辟了一个data数组，长度为3

System.out.println（data.length）;

data[0]=10;//为数组赋值

data[1]=20;

data[2]=30;

for（intx=0;x

System.out.print（data[x]+"、"）;

}

}

}

以上的流程与普通对象本质上是没有什么区别的，唯一的区别是在于普通的类对象是保存属性，利用属性名称来操作，但是数组保存的是一组内容，利用索引来操作。

那么既然此关系可以弄明白，所谓的分步的操作也就一样的过程。

范例：

分步实例化数组对象

publicclassArrayDemo{//程序必须有类

publicstaticvoidmain（Stringargs[]）{

intdata[]=null;//只有声明的时候加上“[]”

data=newint[3];//开辟了一个data数组，长度为3

System.out.println（data.length）;

data[0]=10;//为数组赋值

data[1]=20;

data[2]=30;

for（intx=0;x

System.out.print（data[x]+"、"）;

}

}

}

那么现在如果此关系可以明白的话，就意味着可以进行数组的引用操作了。

引用的本质同一块堆内存空间被不同的栈内存所指向。

范例：

数组的引用操作

publicclassArrayDemo{//程序必须有类

publicstaticvoidmain（Stringargs[]）{

intdata[]=newint[3];//开辟了一个data数组，长度为3

data[0]=10;//为数组赋值

data[1]=20;

data[2]=30;

inttemp[]=data;//引用操作

temp[0]=100;//修改数据

for（intx=0;x

System.out.print（data[x]+"、"）;

}

}

}

还是通过内存关系图来进行操作描述。

3.3、数组的静态初始化

以上是针对于数组的动态初始化操作讲解的，动态初始化操作的特点在于其只能够在开辟数组空间之后进行数组内容的赋值，如果现在希望数组开辟之后就可以存在明确的内容，那么则可以使用数组的静态初始化，而语法有如下两种：

第一种：

简化型

数据类型数组名称[]={值,值,...};

数据类型[]数组名称={值,值,...};

第二种：

完全型（推荐使用）

数据类型数组名称[]=new数据类型[]{值,值,...};

数据类型[]数组名称=new数据类型[]{值,值,...};

范例：

使用数组的静态初始化

publicclassArrayDemo{//程序必须有类

publicstaticvoidmain（Stringargs[]）{

intdata[]=newint[]{10,20,30};//数组的静态初始化

for（intx=0;x

System.out.print（data[x]+"、"）;

}

}

}

范例：

判断某一个数字是否在数组中存在？

最简单的做法是进行for循环操作，一次与每一个数组中的内容进行相等比较。

publicclassArrayDemo{//程序必须有类

publicstaticvoidmain（Stringargs[]）{

intsdata=11;//要查找的数据

booleanflag=false;//保存查找结果，如果找到了修改为true

intdata[]=newint[]{10,20,30,11,22,33};

for（intx=0;x

if（data[x]==sdata）{//现在已经查找到了内容

flag=true;

break;//退出循环

}

}

if（flag）{

System.out.println（"该数据已经查找到！

"）;

}else{

System.out.println（"该数据没有查找到！

"）;

}

}

}

但是严格来讲现在这样的代码性能并不好，因为它需要将数组中的每一个元素都进行判断。

面试题：

请解释什么叫二分查找法（折半查找法）

二分查找法的重要支持：

数组中的数据必须是有序的。

publicclassArrayDemo{//程序必须有类

publicstaticvoidmain（Stringargs[]）{

intsdata=161;

intdata[]=newint[]{10,20,30,40,50,60};

System.out.println（search（sdata,data））;

}

publicstaticbooleansearch（intsdate,int[]data）{

System.out.print（java.util.Arrays.toString（data）+"len="）;

if（data.length==1）{

returnsdate==data[0];

}else{

intlen=data.length/2;//012=1、01=1

System.out.println（len+"，"+（sdate==data[len]））;

if（sdate>data[len]）{//右边，取出新的数组数据

int[]temp=null;

if（data.length%2==0）{

temp=newint[len];

}else{

temp=newint[len+1];

}

intfoot=0;

for（intx=len;x

temp[foot++]=data[x];

}

returnsearch（sdate,temp）;

}elseif（sdate

int[]temp=newint[len];

for（intx=0;x

temp[x]=data[x];

}

returnsearch（sdate,temp）;

}else{//等于

returnsearch（sdate,newint[]{data[len]}）;

}

}

}

}

这种代码只是一个娱乐。

3.4、二维数组（理解）

在开发之中，之前使用的数组只有一个索引下标，所以可以简单将其理解为是一个一维数组。

一维数组的特点是可以根据一个索引号确定内容，好比如下形式：

索引号

0

1

2

3

4

5

数据

90

212

7

78

67

67

二维数组实际上与数据表的形式是完全相同的，有行和列组成，那么要想确认一个数据，必须有行和列的编号，所以二维数组的组成如下：

行索引、列索引

列索引0

列索引1

列索引2

列索引3

列索引4

行索引0

5

34

3

4

7

行索引1

34

734

2

34

6

行索引2

6

86

987

34

4

现在要想确定987这个数据，那么就需要行索引为2，列索引也为2才可以定位到。

对于二维数组的定义有两种语法结构：

·动态初始化：

数据类型数组名称[][]=new数据类型[行个数][列个数];

·静态初始化：

数据类型数组名称[][]=new数据类型[][]{

{数据,数据,数据},

{数据,数据,数据},...};

实际上可以发现，二维数组的本质就是在数组里面继续嵌套了其他的数组。

范例：

观察二维数组使用

publicclassArrayDemo{//程序必须有类

publicstaticvoidmain（Stringargs[]）{

intdata[][]=newint[][]{

{1,2},{4,5,6},{7,8,9,10}

};

for（intx=0;x

for（inty=0;y

System.out.print（data[x][y]+"、"）;

}

System.out.println（）;

}

}

}

面试题：

实现二维数组转置

publicclassArrayDemo{//程序必须有类

publicstaticvoidmain（Stringargs[]）{

intdata[][]=newint[][]{

{1,2,3},{4,5,6},{7,8,9}

};

for（intx=0;x

for（inty=0;y<=x;y++）{

if（x!

=y）{//交换

inttemp=data[x][y];

data[x][y]=data[y][x];

data[y][x]=temp;

}

}

}

for（intx=0;x

for（inty=0;y

System.out.print（data[x][y]+"、"）;

}

System.out.println（）;

}

}

}

这些都属于对于数组的逻辑控制，本身只能够作为扩充你大脑思维使用的东西，对实际的开发帮助不大。

3.5、数组与方法

在数组与方法进行传递的操作过程之中，实际上就属于引用传递。

在数组与方法间的操作中，主要考虑两种形式：

方法接收数组，另外一种就是方法返回数组。

不管是接收还是返回，最终操作的一定是一个堆内存的使用。

范例：

利用方法来接收数组

publicclassArrayDemo{//程序必须有类

publicstaticvoidmain（Stringargs[]）{

int[]data=newint[]{1,3,5,7,9};//是一个数组

printArray（data）;

}

publicstaticvoidprintArray（inttemp[]）{//接收一个数组

for（intx=0;x

System.out.print（temp[x]+"、"）;

}

System.out.println（）;//换行

}

}

整个的操作过程与数组的引用接收是完全一样的。

但是这个时候的代码只是针对于当前的数组内容进行了简单的输出，于是下面可以进一步的加强，例如：

设置一个方法，在此方法之中实现数据的乘2操作。

范例：

方法里面修改数组内容

publicclassArrayDemo{//程序必须有类

publicstaticvoidmain（Stringargs[]）{

int[]data=newint[]{1,3,5,7,9};//是一个数组

inc（data）;//intarr[]=data;

printArray（data）;

}

publicstaticvoidinc（intarr[]）{//负责数组内容的改变

for（intx=0;x

arr[x]=arr[x]*2;//数组中的每个元素乘后保存

}

}

publicstaticvoidprintArray（inttemp[]）{//接收一个数组

for（intx=0;x

System.out.print（temp[x]+"、"）;

}

System.out.println（）;//换行

}

}

在大部分情况下，如果某一个方法可以接收的数据类型是引用数据类型，那么往往都不需要设置返回值。

范例：

数据排序操作（理解）

面对数组中发现可以保存有多个数据，但是在很多时候（例如：

二分查找法）那么必须针对于数组中的数据进行排序，所以这个时候就需要进行一些复杂的处理。

通过分析可以发现，排序并不是一次完成的，而是需要多次，也就是说至少需要“数组长度-1”次。

publicclassArrayDemo{//程序必须有类

publicstaticvoidmain（Stringargs[]）{

intdata[]=newint[]{89,10,20,1,0,2,8,3,90,67,9,7};

for（intx=0;x

for（inty=0;y

if（data[y]>data[y+1]）{

inttemp=data[y];

data[y]=data[y+1];

data[y+1]=temp;

}

}

System.out.print（"第"+x+"次排序：

"）;

printArray（data）;

}

}

publicstaticvoidprintArray（inttemp[]）{//接收一个数组

for（intx=0;x

System.out.print（temp[x]+"、"）;

}

System.out.println（）;//换行

}

}

此时的确是已经实现了排序操作的要求，但非常遗憾的是，这个代码里面主方法的代码太多了。

主方法本身就是一个日后程序调用的客户端，所以在客户端的操作代码中不应该编写过多的复杂操作，应该将代码进行简化处理。

面试题：

请编写一个数组排序操作

publicclassArrayDemo{//程序必须有类

publicstaticvoidmain（Stringargs[]）{

intdata[]=newint[]{89,10,20,1,0,2,8,3,90,67,9,7};

sort（data）;//客户端调用越简单越好

printArray（data）;

}

publicstaticvoidsort（intarr[]）{//单独完成了一个数组的排序操作

for（intx=0;x

for（inty=0;y

if（arr[y]>arr[y+1]）{

inttemp=arr[y];

arr[y]=arr[y+1];

arr[y+1]=temp;

}

}

}

}

publicstaticvoidprintArray（inttemp[]）{//接收一个数组

for（intx=0;x

System.out.print（temp[x]+"、"）;

}

System.out.println（）;//换行

}

}

范例：

数组的反转操作

就是将一个数组实现首位交换，但是交换的实现方式有两种。

第一种实现思路：

定义一个新的数组，而后将原始数组的内容进行逆序输出，随后改变原始数组的引用。

publicclassArrayDemo{//程序必须有类

publicstaticvoidmain（Stringargs[]）{

intdata[]=newint[]{