java用数组定义数组_Java——数组的定义与使用

数组的定义与使用

1.数组的基本概念

(1)数组的动态初始化：

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

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

数组的动态初始化(声明并开辟数组)

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

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

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

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

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

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

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

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

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

publicclassTest7 {

publicstaticvoidmain(String[]args){

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

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

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

demon[1] = 1;

demon[2] = 2;

for(inti= 0;i

System.out.print(" ");

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

}

}

}

运次结果：10

0 1 2 0

(2)数组的动态初始化：

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

数据类型[] 数组名 = {值1……}数据类型[] 数组名 = new 数据类型[] {值……}(推荐使用)

publicclassTest7 {

//数组静态初始化(简化格式)

publicstaticvoidmain(String[]args){

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

System.out.println(demon1.length);

for(inti= 0;i

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

}

}

}

运行结果：6

2

3

5

6

9

publicclassTest7 {

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

publicstaticvoidmain(String[]args){

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

}

}

运行结果：5

2.数组的引用传递

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

publicclassTest7 {

publicstaticvoidmain(String[]args) {

int[]demon=null;

demon=newint[4] ;

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

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

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

for(inti= 0;i

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

}

}

}

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

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

publicclassTest7 {

publicstaticvoidmain(String[]args) {

int[]demon=newint[4] ;

int[]temp=null;

System.out.println(demon.length);

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

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

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

for(inti= 0;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 数据类型[][]{{值……}，……{值……}}

publicclassTest7 {

//二维数组

//数组并不是等列数组

publicstaticvoidmain(String[]args){

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

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

for(inti= 0;i

for(intj=0;j

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

}

}

}

}

4.数组和方法的互操作

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

(1)方法接收数组

(2)方法返回数组

(3)方法修改数组

publicclassTest7 {

//数组与方法的互操作

publicstaticvoidmain(String[]args){

int[]demon=receive();

changeDouble(demon);

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

}

//方法接收数组组

publicstaticint[] receive(){

returnnewint[]{1,27,18,21};//匿名数组

}

//方法返回数组

publicstaticvoidprintArray(int[]temp){

for(inti= 0;i

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

}

}

//方法改变数组

publicstaticvoidchangeDouble(int[]arr){

for(intj= 0;j

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

}

}

}

运行结果：2

54

36

42

内存分析图如下：

5.Java对数组的支持

1.对数组进行排序：

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

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

packagetest;

publicclassTest7{

//java对数组的支持

publicstaticvoidmain(String[]args){

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

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

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

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

printArray(demon5);

printArray(demon6);

}

publicstaticvoidprintArray(int[]temp){

for(inti= 0;i

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

System.out.print(" ");

}

}

publicstaticvoidprintArray(char[]temp){

for(inti= 0;i

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

System.out.print(" ");

}

}

}

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

2.实现数组的拷贝：

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

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

publicclassTest7 {

//实现数组的拷贝

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

publicstaticvoidmain(String[]args){

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

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

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

printArray(demon1);

}

publicstaticvoidprintArray(int[]temp){

for(inti= 0;i

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

System.out.print(" ");

}

}

}

6.数组案例

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

012345678

14345577698

(1)简单的实现方法实现

publicclassTest7 {

publicstaticvoidmain(String[]args){

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

intmax=demon[0];

intmin=demon[0];

intsum=demon[0];

doubleavg= 0.0;

for(inti= 1;i

sum+=demon[i];

if(demon[i] >max){

max=demon[i];

}

if(demon[i]

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)使用方法与数组互操作实现

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

publicclassTest7 {

publicstaticvoidmain(String[]args){

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

maxValue(demon);

minValue(demon);

sumAndAvg(demon);

}

//求最大值

publicstaticvoidmaxValue(int[]temp){

intmax=temp[0];

for(inti= 1;i

if(temp[i] >max){

max=temp[i];

}

}

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

}

//求最小值

publicstaticvoidminValue(int[]temp){

intmin=temp[0];

for(inti= 1;i

if(temp[i]

min=temp[i];

}

}

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

}

//求平均值和总和

publicstaticvoidsumAndAvg(int[]temp){

intsum=temp[0] ;

for(inti= 1;i

sum+=temp[i];

}

doubleavg= 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类名称[长度]

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

classPerson{

privateStringname;

privateintage;

publicPerson(Stringname,intage){//构造方法

this.name=name;

this.age=age;

}

publicvoidgetPrint(){

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

}

}

publicclassTest7 {

publicstaticvoidmain(String[]args){

Person[]per=newPerson[3];

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

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

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

for(inti= 0;i

per[i].getPrint();

}

}

}

运行结果：

姓名： 张三 年龄： 16

姓名： 李四 年龄： 18

姓名： 王五 年龄： 20

(2)对象数组的静态初始化

类名称[ ]对象数组名=  new类名称[]{new类名称()……}

classPerson{

privateStringname;

privateintage;

publicPerson(Stringname,intage){//构造方法

this.name=name;

this.age=age;

}

publicvoidgetPrint(){

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

}

}

//静态初始化

publicclassTest7 {

publicstaticvoidmain(String[]args){

Person[]per=newPerson[]{

newPerson("张三",16),

newPerson("李四",18),

newPerson("王五",20)};

for(inti= 0;i

per[i].getPrint();

}

}

}

运行结果：

姓名： 张三 年龄： 16

姓名： 李四 年龄： 18

姓名： 王五 年龄： 20

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