Java_数组练习答案

填空题

1) 数组的元素通过 下标 来访问，数组Array的长度为 。

2) 数组复制时，“=”将一个数组的 引用 传递给另一个数组。

3) 没有显式引用变量的数组称为 匿名 数组。

4) JVM将数组存储在 堆 （堆或栈）中。

5) 数组的二分查找法运用的前提条件是数组已经 排序 。

6) 矩阵或表格一般用 二 维数组表示。

7) 如果把二维数组看成一维数组，那么数组的元素是 一维 数组。

8) Java中数组的下标的数据类型是 整型 。

9) 不用下标变量就可以访问数组的方法是 foreach循环 。

10) 数组最小的下标是0.。

11) array copy()的最后一个参数指明复制元素的个数。

12) 向方法传递数组参数时，传递的是数组的引用。

13) 线性查找法的平均查找长度为n*(n-1)/2。

14) 数组初始化包括数组声明、创建和初始化。

15) 数组下标访问超出索引范围时抛出arrayIndexOutOfBoundsException异常

16) 浮点型数组的默认值是。

17) 对象型数组的默认值是null。

18) 对象类型的数组虽然被默认初始化，但是并没有调用其构造函数。

19) 二维数组的行的长度可以不同。

20) 数组创建后其大小不能改变。

选择题

1.下面错误的初始化语句是_D__

A) char str[]="hello";

B) char str[100]="hello";

C) char str[]={'h','e','l','l','o'};

D) char str[]={'hello'};

2． 定义了一维int型数组a[10]后，下面错误的引用是_B___

A) a[0]=1;

B) a[10]=2;

C) a[0]=5*2;

D) a[1]=a[2]*a[0];

3． 下面的二维数组初始化语句中，错误的是__B___

A) float b[2][2]={0.1,0.2,0.3,0.4};

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

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

D) float a[2][2]={0};

4． 引用数组元素时，数组下标可以是__D___

A) 整型常量 B) 整型变量 C) 整型表达式 D) 以上均可

5． 定义了int型二维数组a[6][7]后，数组元素a[3][4]前的数组元素个数为__B___

A) 24 B) 25 C) 18 D) 17

6． 下列初始化字符数组的语句中，错误的是__C___

A) char str[5]="hello";

B) char str[]={'h','e','l','l','o','0'};

C) char str[5]={"hi"};

D) char str[100]="";

7． 数组在Java中储存在C中

A) 栈 B) 队列 C) 堆 D) 链表

8． 下面程序的运行结果是__C___

main()

{

int x=30;

Int[] numbers=new int[x];

X=60;

rintln();

}

A) 60 B) 20 C) 30 D) 50

9、下面 不是创建数组的正确语句C

A）float f[][]=new float[6][6]; B）float f[]=new float[6];

C）float f[][]=new float[][6]; D）float [][]f=new float[6][];

10.下面不是数组复制方法的是（C）

A 用循环语句逐个复制数组 B 用方法arraycopy

C用“=”进行复制 D 用clone方法

11.数组a的第三个元素表示D

A a(3) B a[3]

Ca(2) D a[2]

12. 当访问无效的数组下标时，会发生B

A中止程序 B 抛出异常

C系统崩溃 D 直接跳过

13.使用arraycopy()方法将数组a复制到b正确的是A

A arraycopy(a,0,b,0,) B arraycopy(a,0,b,0,)

C arraycopy(b,0,a,0,) D arraycopy(a,1,b,1,)

14. 关于数组默认值，错误的是B

Achar--'"u0000' B Boolean--true

Cfloat- D int-- 0

15. 关于数组作为方法的参数时，向方法传递的是A

A数组的引用 B 数组的栈地址

C数组自身 D 数组的元素

16. 关于数组复制，下列说法错误的是C

A“=”可以实现数组复制

B运用循环语句进行数组复制必须两个数组长度相同

C arraycopy()方法没有给目标数组分配内存空间

D 数组复制是数组引用的传递

17. 下列语句会造成数组new int[10]越界是D

A a[0]+=9; B a[9]=10;

C—a[9] D for(int i=0;i<=10;i++) a[i]++;

18. main方法是java Application 程序执行的入口点。关于main方法放入方法以下合法的是B

A public static void main();

B public static void main(String[]args)

C public static int main(String[] arg)

D public void main(String arg[])

19. 如定义对象 StringBuffer ch = new StringBuffer(“Shanghai”) 则ch．length()=( B )

A．７ Ｂ．８ Ｃ．９ Ｄ．２３

20. 执行完代码“int[]x=new int[25];”后以下（A）说明正确的

A.x[24]为0 Bx[24]未定义 C x[25]为0 D。x[0]为空

21. 关于char类型的数组，说法正确的是B

A其数组的默认值是’A’ B 可以仅通过数组名来访问数组

C数组不能转换为字符串 D 可以存储整型数值

22. 对于数组a[10]，下列表示错误的是B

A a[0] B a(0)

Ca[9] D a[1]

23. 下列数组声明，下列表示错误的是D

A int[] a B int a[]

Cint[][] a Dint[]a[]

是非题

1.下标用于指出数组中某个元素位置的数字。（ F ）

2.把数组中元素按某种顺序排列的过程叫做查找。（ T ）

3.确定数组中是否含有某个关键字的过程叫做排序。（ F ）

4.一个数组可以存放许多不同类型的数值。（ F ）

5.数组的下标通常是float型。（ F ）

6.数组的某个元素被传递给一个方法并被该方法修改，当被调用方法执行完毕时，这个元素中含有修改过的数值。（ F ）

7.数组可以声明为任何数据类型。（ T ）

8.数组由具有一名字和相同类型的一组连续内存单元构成。（ T ）

9.在数组声明中可以用等号及一个逗号分隔的初始值表初始化数组元素，该数组大小只能由用户来决定。（ F ）

10.将一个数组传递给一个方法，必须加在数组名后加方括号。（ F ）

语言中的数组元素下标总是从0开始，下标可以是整数或整型表达式。（ T ）

12.下面这条语句正确吗？（ F ）

double[] myList;

myList = {1.9, 2.9, 3.5, 4.6};

13. Java中数组的元素可以是简单数据类型的量，也可以是某一类的对象。( T )

14. 数组中有length()这个方法，如()表示数组array中元素的个数（ F ）

15.下面这条语句正确吗?( F )

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

16.数组声明后其大小固定。( F )

17.设有整型数组的定义：int a[]=new int[8]; ，则的值为7。（F）

18. 数组一旦创建，其大小不能再改变。（ T ）

19.用任何方式创建数组时，都必须指定数组的长度。（ F ）

20.声明数组时，要指定数组长度，以便为数组分配内存。（ F ）

简答题

1. 如何声明和创建一个一维数组？

答：声明数组：数据类型 [] 数组名 或 数据类型 数组名[]

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

2. 如何访问数组的元素？

答：数组的元素通过下标来访问，数组的下标是基于0的，它们从0开始到-1结束。

3.数组下标的类型是什么？最小的下标是什么？一维数组a的第三个元素如何表示？

答：数组下标的类型是整型，最小的下标是0，数组a的第三个元素表示为a[2]。

4.数组越界访问会发生什么错误？怎样避免该错误？

答：越界访问数组会发生编译错误，它引出一个运行错误ArrayIndexOutOfBoundsException。为避免错误的发生，在使用时应确保下标不超过数组长度减1.

5.给方法传递数组参数与传递基本数据类型变量的值有何不同？

答：对于基本数据类型参数，传递的是实参的值；

对于数组类型的参数，参数值是数组的引用，给方法传递的是这个引用。

6.复制数组有哪些方法？

答：复制数组有3种方法：

（1）用循环语句分别复制数组的每一个元素；

（2）使用System类中的静态方法arraycopy；

（3）使用clone方法复制数组。

7.数组创建后，其元素被赋予的默认值有哪些？

答：数值型基本数据类型默认值为

0，char型为‘u0000’，boolean为false。

8. 如何声明和创建一个二维数组？

答：声明数组：数据类型[][] 数组名

创建数组：数组名 = new 数据类型[元素个数][元素个数]

9.声明数组变量会为数组分配内存空间吗？为什么？

答：不会。数组变量不是基本数据类型变量，数组变量包含一个数组的引用，不同于声明基本类型变量，声明数组变量并不给数组分配任何空间。

10.一个二维数组的行可以有不同的长度吗？如果可以，试创建一个此类型的数组。

答：可以。

创建的数组如下：

int[][] triangleArray = new int[5][]

triangleArray[0] = new int[5];

triangleArray[1] = new int[4];

triangleArray[2] = new int[3];

triangleArray[3] = new int[2];

triangleArray[4] = new int[1];

程序题

1.有一个整数数组，其中存放着序列1，3，5，7，9，11，13，15，17，19。请将该序列倒序存放并输出。

程序代码：

1) public class Test {

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

3) int a[] = {1,3,5,7,9,11,13,15,17,19};

4) int t;

5) n("数组的初始状态为:");

6) for (int i=0; i < ; i++)

7) (" " + a[i]);

8) n();

9)

10) for (int i=0; i < /2; i++) {

11) t = a[i];

12) a[i] = a[-i-1];

13) a[-i-1]=t;

14) }

15)

16) n("数组逆序存放后的状态为:");

17) for (int i=0; i < ; i++)

18) (" " + a[i]);

19) }

20) }

2.编写一个程序，提示用户输入学生数量、姓名和他们的成绩，并按照成绩的降序来打印学生的姓名。

程序代码：

1) import nPane;

2)

3) public class exercise16 {

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

5) String numberString =

6) putDialog("Enter the number of students");

7) int numberOfStudents = nt(numberString);

8)

9) String[] names = new String[numberOfStudents];

10) double[] scores = new double[numberOfStudents];

11)

12) for (int i = 0; i < ; i++) {

13) names[i] = putDialog("Enter a student name");

14) scores[i] = ouble(

15) putDialog("Enter a student score"));

16) }

17)

18) for (int i = - 1; i >= 1; i--) {

19) double currentMax = scores[0];

20) int currentMaxIndex = 0;

21)

22) for (int j = 1; j <= i; j++) {

23) if (currentMax < scores[j]) {

24) currentMax = scores[j];

25) currentMaxIndex = j;

26) }

27) }

28)

29) if (currentMaxIndex != i) {

30) scores[currentMaxIndex] = scores[i];

31) scores[i] = currentMax;

32) String temp = names[currentMaxIndex];

33) names[currentMaxIndex] = names[i];

34) names[i] = temp;

35) }

36) }

37)

38) for (int i = - 1; i >= 0; i--) {

39) n(names[i] + "t" + scores[i]);

40) }

41) }

42) }

8.编写一个程序，生成0-9之间的100个随机整数并且显示每一个数的个数。

程序代码：

1) public class exercise7 {

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

3) int[] numbers = new int[100];

4) int[] counts = new int[10];

5)

6) int k;

7) for (int i = 0; i < 100; i++)

8) {

9) numbers[i] = (int)(() * 10);

10) counts[numbers[i]]++;

11) }

12)

13) n("the 100 numbers is :");

14) for(int i = 1; i <= ; i++)

15) {

16) if (i % 10 != 0)

17) (numbers[i-1] + " ");

18) else

19) n(numbers[i-1]);

20) }

21)

22) n("the counts of each number is :");

23) for(int i = 1; i <= ; i++)

24) (counts[i-1] + " ");

25) }

26) }

3.编写一个程序，求出整数数组中最小元素的下标。如果这样的元素个数大于1，则返回下标最小的数的下标。

程序代码：

1) public class MinIndex {

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

3) int[] list = {1, 2, 4, 5, 10, 100, 2, -22};

4)

5) n("The min is " + minIndex(list));

6) }

7)

8) public static int minIndex(int[] list) {

9) int min = list[0];

10) int minIndex = 0;

11)

12) for (int i = 1; i < ; i++)

13) if (min > list[i]) {

14) min = list[i];

15) minIndex = i;

16) }

17)

18) return minIndex;

19) }

4. 现在有如下的一个数组：

int oldArr[]={1,3,4,5,0,0,6,6,0,5,4,7,6,7,0,5} ;

要求将以上数组中值为0的项去掉，将不为0的值存入一个新的数组，生成的新数组为：

int newArr[]={1,3,4,5,6,6,5,4,7,6,7,5} ;

思路：生活中的问题解决 = 程序中的解决；

1、 确定出不为0的个数，这样可以开辟新数组；

2、 从旧的数组之中，取出内容，并将其赋给新开辟的数组；

public class MyDemo {

public static void main(String args[]){

int oldArr [] = {1,3,4,5,0,0,6,6,0,5,4,7,6,7,0,5} ;

int newArr [] = new int[count(oldArr)] ; // 新数组

fun(oldArr,newArr) ;

print(newArr) ;

}

public static void fun(int src[],int data[]){

int foot = 0 ; // 控制新数组的脚标，data

for(int x = 0 ; x < ; x++){

if(src[x] != 0){

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

}

}

}

public static int count(int temp[]){

int num = 0 ;

for(int x = 0 ; x < ; x++){

if(temp[x] != 0){

num ++ ; // 统计个数

}

}

return num ;

}

public static void print(int temp[]){

for(int x = 0 ; x< ; x++){

(temp[x] + "、") ;

}

}

}

5. 现在给出两个数组：

• 数组A：“1，7，9，11，13，15，17，19：；

• 数组b：“2，4，6，8，10”

两个数组合并为数组c，按升序排列。

public class MyDemo {

public static void main(String args[]){

int data1 [] = new int[] {1,7,9,11,13,17,19} ;

int data2 [] = new int[] {2,4,6,8,10} ;

int newArr [] = concat(data1,data2) ;

(newArr) ;

print(newArr) ;

}

public static int[] concat(int src1[],int src2[]){

int len = + ; // 新数组的大小

int arr[] = new int[len] ; // 新数组

opy(src1,0,arr,0,) ; // 拷贝第一个数组

opy(src2,0,arr,,) ; // 拷贝第二个数组

return arr ;

}

public static void print(int temp[]){

for(int x = 0 ; x< ; x++){

(temp[x] + "、") ;

}

}

}