Java_数组练习题目

一填空题

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

（Array.length）。

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

3)不用下标变量就可以访问数组的方法是数组名。

4)数组最小的下标是0 。

5)arraycopy()的最后一个参数指明复制元素的个数。

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

7)数组初始化包括数组的声明，创建，初始化。

8)数组下标访问超出索引范围时抛出数组越界异常

9)浮点型数组的默认值是0.0f 。

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

二选择题

1.下面错误的初始化语句是_A B 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[][]={{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]前的数组元素个数为__C__

A. 24

B. 25

C. 18

D. 17

6.下列初始化字符数组的语句中，正确的是_B___

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;

System.out.println(numbers.length);

}

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的第三个元素表示为

A. a(3)

B. a[3]

C.a(2)

D. a[2]

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

A. 中止程序

B. 抛出异常

C. 系统崩溃

D. 直接跳过

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

A. arraycopy(a,0,b,0,a.length)

B. arraycopy(a,0,b,0,b.length)

C.. arraycopy(b,0,a,0,a.length)

D. arraycopy(a,1,b,1,a.length)

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

A. char--'"u0000'

B. Boolean--true

C. float--0.0f

D. int—0

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

A. 数组的引用

B. 数组的栈地址

C. 数组自身

D. 数组的元素

16.关于数组复制，下列说法错误的是A 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. 7 B．8 C．9 D．23

20.执行完代码"int[] x=new int[25];"后以下( A )说明正确的

A. x[24]为0

B. x[24]未定义

C. x[25]为0

D. x[0]为空

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

A. 其数组的默认值是'A'

B. 可以仅通过数组名来访问数组

C. 数组不能转换为字符串

D. 可以存储整型数值

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

A. a[0]

B. a(0)

C. a[9]

D. a[1]

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

A. int[] a

B. int a[]

C. int[][] a

D. int[]a[]

三、是非题

1.下标用于指出数组中某个元素位置的数字。( √)

2.把数组中元素按某种顺序排列的过程叫做查找。( ×)

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

4.一个数组可以存放许多不同类型的数值。( ×)

5.数组的下标通常是float型。( ×)

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

7.数组可以声明为任何数据类型。( √)

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

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

10.将一个数组传递给一个方法，必须加在数组名后加方括号。( √)

11.Java语言中的数组元素下标总是从0开始，下标可以是整数或整型表达式。( √)

12.下面这条语句正确吗？( ×)

double[] myList;

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

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

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

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

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

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

17.设有整型数组的定义：int A.[]=new int[8]; ，则a.length的值为7。( ×)

18. 数组一旦创建，其大小不能再改变。( √)

19.用任何方式创建数组时，都必须指定数组的长度。( √)

20.声明数组时，要指定数组长度，以便为数组分配内存。( √)

四、简答题

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

int a1 [];

a1 = new int[7];

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

数组下标

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

整形0 a[2]

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

抛异常时刻记住数组的长度

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

System.arraycopy clone Array.copyOf

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

Int 默认0

String 默认null

Char 默认0对应的字符

Double 默认0.0d

Float 默认0.0f

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

Int a1[] = {{1,2,3},{4,5,6},{7,8,9}};

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

不会，数组变量不是基本数据类型变量，数组变量包含一个数组的引用，不同于声明基

本类型变量。

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

可以

Int a1[] = {{1,2,3},{4,5,6,7},{7,8,9}};

五、程序题

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

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

for (int i = 0; i < a2.length - 1; i++) {

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

if(a2[i] < a2[j]) {

int temp = a2[i];

a2[i] = a2[j];

a2[j] = temp;

}

}

}

for (int temp : a2) {

System.out.print(temp + "\t");

}

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

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

int a1 [] = {3,56,62,5,47,1,7,78,432,543};

int m = 0;

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

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

if(i != j && a1[i] < a1[j]) {

m++;

}

}

if(m == a1.length-1) {

System.out.println(i);

}

m = 0;

}

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} ;

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

int newArr[] = new int[12];

int j = 0;

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

if(oldArr[i] != 0) {

newArr[j] = oldArr[i];

j++;

}

}

for(int temp :newArr) {

System.out.println(temp);

}

5. 现在给出两个数组：

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

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

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

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

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

int c[];

c = new int[13];

System.arraycopy(a, 0, c, 0, a.length); System.arraycopy(b, 0, c, a.length, b.length); Arrays.sort(c);

for(int temp :c) {

System.out.println(temp);

}

Java_数组练习题目

一填空题 1)数组的元素通过数组下标来访问，数组Array的长度为元素的个数 （Array.length）。 2)Java中数组的下标的数据类型是整形。 3)不用下标变量就可以访问数组的方法是数组名。 4)数组最小的下标是0 。 5)arraycopy()的最后一个参数指明复制元素的个数。 6)向方法传递数组参数时，传递的是数组的引用。 7)数组初始化包括数组的声明，创建，初始化。 8)数组下标访问超出索引范围时抛出数组越界异常 9)浮点型数组的默认值是0.0f 。 10)对象型数组的默认值是null 。 二选择题 1.下面错误的初始化语句是_A B 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[][]={{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]前的数组元素个数为__C__ A. 24 B. 25 C. 18 D. 17 6.下列初始化字符数组的语句中，正确的是_B___ 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. 链表

Java-数组练习题目(汇编)

一填空题 1)数组的元素通过来访问，数组Array的长度为。 2)数组复制时，"="将一个数组的传递给另一个数组。 3)没有显式引用变量的数组称为数组。 4)JVM将数组存储在(堆或栈)中。 5)数组的二分查找法运用的前提条件是数组已经。 6)矩阵或表格一般用维数组表示。 7)如果把二维数组看成一维数组，那么数组的元素是数组。 8)Java中数组的下标的数据类型是。 9)不用下标变量就可以访问数组的方法是。 10)数组最小的下标是。 11)arraycopy()的最后一个参数指明。 12)向方法传递数组参数时，传递的是数组的。 13)线性查找法的平均查找长度为。 14)数组初始化包括。 15)数组下标访问超出索引范围时抛出异常 16)浮点型数组的默认值是。 17)对象型数组的默认值是。 18)对象类型的数组虽然被默认初始化，但是并没有构造函数。 19)二维数组的行的长度不同。 20)数组创建后其大小改变。 二选择题 1.下面错误的初始化语句是___ 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]后，下面错误的引用是___ A. a[0]=1; B. a[10]=2; C. a[0]=5*2; D. a[1]=a[2]*a[0]; 3.下面的二维数组初始化语句中，正确的是____ A. float b[2][2]={0.1,0.2,0.3,0.4}; B. int a[][]={{1,2},{3,4}}; C. int a[2][]= {{1,2},{3,4}}; D. float a[2][2]={0}; 4.引用数组元素时，数组下标可以是____ A. 整型常量 B. 整型变量 C. 整型表达式 D. 以上均可 5.定义了int型二维数组a[6][7]后，数组元素a[3][4]前的数组元素个数为____ A. 24 B. 25 C. 18 D. 17 6.下列初始化字符数组的语句中，正确的是____ 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中储存在中

Java数组练习题(带答案)

一填空题 1)数组的元素通过下标来访问，数组Array的长度为Array.length 。 2)数组复制时，"="将一个数组的引用传递给另一个数组。 3)JVM将数组存储在栈(堆或栈)中。 4)数组的二分查找法运用的前提条件是数组已经排序。 5)Java中数组的下标的数据类型是整型。 6)数组最小的下标是0 。 7)arraycopy()的最后一个参数指明复制元素的个数。 8)向方法传递数组参数时，传递的是数组的引用。 9)数组初始化包括数组的申明，创建和初始化。 10)数组下标访问超出索引范围时抛出数组越界异常 11)浮点型数组的默认值是0.0f 。 12)数组创建后其大小不能改变。 二选择题 1.下面错误的初始化语句是_ABD__ 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.下面的二维数组初始化语句中，正确的是____ A. float b[2][2]={0.1,0.2,0.3,0.4}; B. int a[][]={{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]前的数组元素个数为____ A. 24 B. 25 C. 18 D. 17 6.下列初始化字符数组的语句中，正确的是__B__ 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.下面程序的运行结果是____ main() { int a[][]={{1,2,3},{4,5,6}}; System.out.printf("%d", a[1][1]); } A. 3 B. 4 C. 5 D. 6 9.下面程序的运行结果是_C___ main() {

java第三章上机练习题

习题1. 数据类型转换应用 【案例简介】下例说明了整型、浮点型、字符串型之间的相互转换。 【案例目的】掌握Java中两个不兼容类型能够的数据格式之间的转换。 【技术要点】高精度到低精度的数据转换时候需要进行强制转换，低精度向高精度进行转换的时候的会自动进行，字符串到其他类型的转换需要用到特定的方法。 【代码分析】 public class Conversation { public static void main(String [] args) { String str = "123"; int j; byte b; int i=257; double d = 323.142; System.out.println("\nConversion of int to byte."); //i强制转换成byte型 System.out.println("i and b "+ i + " "+b); System.out.println("\nConversion of double to int."); //d强制转换成int型 System.out.println("d and i "+ d + " "+i); //d强制转换成byte型 System.out.println("d and b "+ d + " "+b); j=Integer.parseInt(str); //str转换成int型 System.out.println("j="+j); } } 【相关知识】 数据类型转换 （1）简单数据类型中各类型数据间的优先关系和相互转换 不同类型数据间的优先关系如下 低----------------------------------------------->高 byte->short->char-> int -> long -> float -> double 自动类型转换规则 整型，实型，字符型数据可以混合运算。运算中，不同类型的数据先转化为同一类型，然后进行运算，转换从低级到高级。 （2）强制类型转换 高级数据要转换成低级数据，需用到强制类型转换，如： int i; byte b=(byte)i; //把int型变量i强制转换为byte型 （3）其他转换 数字变为字符串 用如下方法转换相应类型的数字： Double.toString(double)； Float.toString(float);

Java数组练习题(带答案)

一填空题 1)数组得元素通过下标来访问，数组Array得长度为 Array、length 。 2)数组复制时，"="将一个数组得引用传递给另一个数组。 3)JVM将数组存储在栈 (堆或栈)中。 4)数组得二分查找法运用得前提条件就是数组已经排序。 5)Java中数组得下标得数据类型就是整型。 6)数组最小得下标就是 0 。 7)arraycopy()得最后一个参数指明复制元素得个数。 8)向方法传递数组参数时，传递得就是数组得引用。 9)数组初始化包括数组得申明，创建与初始化。 10)数组下标访问超出索引范围时抛出数组越界异常 11)浮点型数组得默认值就是 0、0f 。 12)数组创建后其大小不能改变。 二选择题 1.下面错误得初始化语句就是_ABD__ 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.下面得二维数组初始化语句中，正确得就是____ A、 float b[2][2]={0、1,0、2,0、3,0、4}; B、 int a[][]={{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]前得数组元素个数为____ A、 24 B、 25 C、 18 D、 17 6.下列初始化字符数组得语句中，正确得就是__B__ 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.下面程序得运行结果就是____ main() { int a[][]={{1,2,3},{4,5,6}}; System、out、printf("%d", a[1][1]); } A、 3 B、 4 C、 5 D、 6 9.下面程序得运行结果就是_C___

Java数组测习题(带答案)

精心整理一填空题 1)数组的元素通过下标来访问，数组Array的长度为Array.length。 2)数组复制时，"="将一个数组的引用传递给另一个数组。 3)JVM将数组存储在栈(堆或栈)中。 4)数组的二分查找法运用的前提条件是数组已经排序。 5)Java中数组的下标的数据类型是整型。 6)数组最小的下标是0。 7) 8) 9) 10) 11) 12) 1. 2. 3. 4. 5. 6. 7. 8.A. 9. 10. 11.A 12.C.charstr[5]={"hi"}; D.charstr[100]=""; 13.数组在Java中储存在C中 14.A.栈 B.队列 C.堆 D.链表 15.下面程序的运行结果是____ main(){ inta[][]={{1,2,3},{4,5,6}}; }

A.3 B.4 C.5 D.6 16.下面程序的运行结果是_C___ 17.m ain(){ intx=30; int[]numbers=newint[x]; x=60; (numbers.length); } A.60 B.20 C.30 D.50 18. 19.m 20.c 21.i 22.w 23. 24.A 25.C 26. A. C.用 27. 28. A. 29. 30. A.char--'"u0000' B.Boolean--true C.float--0.0f D.int--0 31.关于数组作为方法的参数时，向方法传递的是A A.数组的引用 B.数组的栈地址 C.数组自身 D.数组的元素 32.关于数组复制，下列说法错误的是AC A."="可以实现数组复制 B.运用循环语句进行数组复制必须两个数组长度相同 C.arraycopy()方法没有给目标数组分配内存空间 D.数组复制是数组引用的传递

java复习题及答案

编程题 1.将整型数组a赋值初值（含5个元素），并求出a中的最大元素和最小元素public class test { public static void main(String[] args) { int[] nums = { 2, 1, 4, 100, 88,}; <―灰色部分5个元素大家随意写，别写的一样的就行了for (int i = 0; i <= nums.length - 1; i++) { for (int j = i + 1; j <= nums.length - 1; j++) { if (nums[i] > nums[j]) { int temp = nums[i]; nums[i] = nums[j]; nums[j] = temp; } } } System.out.println("最小值为:" + nums[0] ) ; System.out.println("最大值为:" + nums[nums.length - 1]); } } 2．已知a是整型数组，编程求出a中的最大元素和最先元素 import java.util.ArrayList; import java.util.Collections; import java.util.List; public class Test{ public static void main(String[] args) { List list = new ArrayList(); for (int i = 0; i < 10; i++) { list.add((int) (Math.random() * 100)); } System.out.println(list); Collections.sort(list); System.out.println("最大值是:" + list.get(list.size() - 1)); System.out.println("最小值是:" + list.get(0)); } } 3.输入整数n，并计算从1到n的累加和 import java.util.Scanner; public class Test{ public static void main(String args[]){ Scanner scan = new Scanner(System.in); int count = 0;

java编程基础—数组练习

1、编写一个简单程序，要求数组长度为5，分别赋值10，20，30，40，50，在控制台输出该数组的值。（知识点：数组定义和创建、一维数组初始化）public class work01 { public static void main(String[] args) { // TODO Auto-generated method stub int arr[] = new int[]{10,20,30,40,50}; for(int i = 0;i<=arr.length;i++){ System.out.println(arr[i]); } } } 运行结果：

2、将一个字符数组的值（neusofteducation）拷贝到另一个字符数组中。（知识点：数组复制） public class work02 { public static void main(String[] args) { // TODO Auto-generated method stub char[] copyFrom = new char[]{'n','e','u','s','o','f','t','e', 'd','u','c','a','t','i','o','n'}; char[ ] copyTo = new char[16]; System.arraycopy(copyFrom, 0, copyTo, 0, 16); System.out.println(new String(copyTo)); } } 运行结果：

3、给定一个有9个整数（1,6,2,3,9,4,5,7,8）的数组，先排序，然后输出排序后的数组的值。（知识点：Arrays.sort排序、冒泡排序） public class work03 { public static void main(String[] args) { // TODO Auto-generated method stub int[ ] point = {1,6,2,3,9,4,5,7,8}; java.util.Arrays.sort( point ); for(int i=0;i

JAVA基础练习程序 数组冒泡排序

/* 数组排序 */ public class BubbleSort { public static void main(String[] args){ int[] arr = {1,25,36,21,24,12,39,87}; System.out.println("排序前："); String str = array2string(arr); System.out.println(str); bubblesort(arr); System.out.println("排序后："); String str2 = array2string(arr); System.out.println(str2); } /*冒泡排序*/ public static void bubblesort(int[] arr){ for(int x=0;x arr[y+1]){ swap(arr,y,y+1); } } } } //定义数组元素之间位置交换 public static void swap(int[] arr,int index1,int index2){ //定义临时变量 int temp = arr[index1]; arr[index1] = arr[index2]; arr[index2] = temp; } //定义字符串打印 public static String array2string(int[] arr){ String str = ""; for(int x=0;x

Java数组练习题(带答案)教学提纲

J a v a数组练习题(带 答案)

1)数组的元素通过下标来访问，数组Array的长度为 Array.length 。 2)数组复制时，"="将一个数组的引用传递给另一个数组。 3)JVM将数组存储在栈 (堆或栈)中。 4)数组的二分查找法运用的前提条件是数组已经排序。 5)Java中数组的下标的数据类型是整型。 6)数组最小的下标是 0 。 7)arraycopy()的最后一个参数指明复制元素的个数。 8)向方法传递数组参数时，传递的是数组的引用。 9)数组初始化包括数组的申明，创建和初始化。 10)数组下标访问超出索引范围时抛出数组越界异常 11)浮点型数组的默认值是 0.0f 。 12)数组创建后其大小不能改变。 二选择题 1.下面错误的初始化语句是_ABD__ 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__ 3. A. a[0]=1; B. a[10]=2; C. a[0]=5*2; D. a[1]=a[2]*a[0]; 4.下面的二维数组初始化语句中，正确的是____ 5. A. float b[2][2]={0.1,0.2,0.3,0.4}; B. int a[][]={{1,2},{3,4}}; 6. C. int a[2][]= {{1,2},{3,4}}; D. float a[2][2]={0}; 7.引用数组元素时，数组下标可以是_D___ 8. A. 整型常量 B. 整型变量 C. 整型表达式 D. 以上均 可 9.定义了int型二维数组a[6][7]后，数组元素a[3][4]前的数组元素个数为____ A. 24 B. 25 C. 18 D. 17 10.下列初始化字符数组的语句中，正确的是__B__ 11.A. char str[5]="hello"; B. char str[]={'h','e','l','l','o','\0'}; 12.C. char str[5]={"hi"}; D. char str[100]=""; 13.数组在Java中储存在 C 中 14.A. 栈 B. 队列 C. 堆D. 链表 15.下面程序的运行结果是____ main() { int a[][]={{1,2,3},{4,5,6}}; System.out.printf("%d", a[1][1]); } A. 3 B. 4 C. 5 D. 6 16.下面程序的运行结果是_C___

JAVA基本程序练习题(1,2)

JAVA基本程序练习题（一） 【程序1】 题目：有1、2、3、4个数字，能组成多少个互不相同且无重复数字的三位数？都是多少？ 程序分析：可填在百位、十位、个位的数字都是1、2、3、4。组成所有的排列后再去掉不满足条件的排列。 【程序2】 题目：企业发放的奖金根据利润提成。利润(I)低于或等于10万元时，奖金可提10%；利润高 于10万元，低于20万元时，低于10万元的部分按10%提成，高于10万元的部分，可可提成7.5%；20万到40万之间时，高于20万元的部分，可提成5%；40万到60万之间时高于40万元的部分，可提成3%；60万到100万之间时，高于60万元的部分，可提成1.5%，高于100万元时，超过100万元的部分按1%提成，从键盘输入当月利润I，求应发放奖金总数？ 程序分析：请利用数轴来分界，定位。注意定义时需把奖金定义成长整型。 【程序3】 题目：一个整数，它加上100后是一个完全平方数，再加上168又是一个完全平方数，请问该数是多少？ 程序分析：在10万以内判断，先将该数加上100后再开方，再将该数加上268后再开方，如果开方后的结果满足如下条件，即是结果。 【程序4】 题目：输入某年某月某日，判断这一天是这一年的第几天？ 程序分析：以3月5日为例，应该先把前两个月的加起来，然后再加上5天即本年的第几天，特殊情况，闰年且输入月份大于3时需考虑多加一天。 【程序5】 题目：输入三个整数x,y,z，请把这三个数由小到大输出。 程序分析：我们想办法把最小的数放到x上，先将x与y进行比较，如果x>y则将x与y的值进行交换，然后再用x与z进行比较，如果x>z则将x与z的值进行交换，这样能使x最小。【程序6】 题目：用*号输出字母C的图案。 程序分析：可先用'*'号在纸上写出字母C，再分行输出。 【程序8】 题目：输出9*9口诀。 程序分析：分行与列考虑，共9行9列，i控制行，j控制列。 【程序9】 题目：要求输出国际象棋棋盘。 程序分析：用i控制行，j来控制列，根据i+j的和的变化来控制输出黑方格，还是白方格。【程序11】 题目：古典问题：有一对兔子，从出生后第3个月起每个月都生一对兔子，小兔子长到第三个月后每个月又生一对兔子，假如兔子都不死，问每个月的兔子总数为多少？ 程序分析：兔子的规律为数列1,1,2,3,5,8,13,21.... 【程序12】 题目：判断101-200之间有多少个素数，并输出所有素数。 程序分析：判断素数的方法：用一个数分别去除2到sqrt(这个数)，如果能被整除， 则表明此数不是素数，反之是素数。

Java数组练习题(带答案)

一填空题 1)数组的元素通过下标来访问,数组Array的长度为Array、length 。 2)数组复制时,"="将一个数组的引用传递给另一个数组。 3)JVM将数组存储在栈(堆或栈)中。 4)数组的二分查找法运用的前提条件就是数组已经排序。 5)Java中数组的下标的数据类型就是整型。 6)数组最小的下标就是0 。 7)arraycopy()的最后一个参数指明复制元素的个数。 8)向方法传递数组参数时,传递的就是数组的引用。 9)数组初始化包括数组的申明,创建与初始化。 10)数组下标访问超出索引范围时抛出数组越界异常 11)浮点型数组的默认值就是0、0f 。 12)数组创建后其大小不能改变。 二选择题 1.下面错误的初始化语句就是_ABD__ 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.下面的二维数组初始化语句中,正确的就是____ A、float b[2][2]={0、1,0、2,0、3,0、4}; B、int a[][]={{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]前的数组元素个数为____ A、24 B、25 C、18 D、17 6.下列初始化字符数组的语句中,正确的就是__B__ 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.下面程序的运行结果就是____ main() { int a[][]={{1,2,3},{4,5,6}}; System、out、printf("%d", a[1][1]); } A、3 B、4 C、5 D、6 9.下面程序的运行结果就是_C___ main() {

java数组基础练习

有30个0~9之间的数字，分别统计0~9这10个数字分别出现了多少次Public class TestArray { int score[]={0,0,1,2,3,5,4,5,2,8,7,6,9,5,4,8,3,1,0,2,4,8,7,9,5,2,1,2,3,9}; int num0=0; int num1=0; int num2=0; int num3=0; int num4=0; int num5=0; int num6=0; int num7=0; int num8=0; int num9=0; for (int i=0;i

if (score[i]==7) { num7++; } if (score[i]==8) { num8++; } if (score[i]==0) { num0++; } } System.out.println("0出现的次数："+num0); System.out.println("1出现的次数："+num1); System.out.println("2出现的次数："+num2); System.out.println("3出现的次数："+num3); System.out.println("4出现的次数："+num4); System.out.println("5出现的次数："+num5); System.out.println("6出现的次数："+num6); System.out.println("7出现的次数："+num7); System.out.println("8出现的次数："+num8); System.out.println("9出现的次数："+num9); } 定义一个整型数组，保存10个数据，利用程序完成将最大值保存在数组中的第1个元素且原第一个数换到最大值的位置！ public class TestArray01 { public static void main(String agrs[]) { int score[]={55,45,5,44,2,6,56,15,4,12}; System.out.println("这10个数字："); print(score); System.out.println(""); System.out.println("改变后的数字："); add(score); } public static void add(int score[]) { int max=score[0]; int arr[]=new int[score.length]; for (int i=0;i

Java数组练习题(带答案)

. 一填空题 1) 数组的元素通过下标来访问，数组Array的长度为Array.length 。 2) 数组复制时，"="将一个数组的引用传递给另一个数组。 3) JVM将数组存储在栈(堆或栈)中。 4) 数组的二分查找法运用的前提条件是数组已 经排序。 5) Java中数组的下标的数据类型是整型。 6) 数组最小的下标是0 。 7) arraycopy()的最后一个参数指 明 复制元素的个 数。 8) 向方法传递数组参数时，传递的是数组的引用。 9) 数组初始化包括数组的申明，创建和初始化。 10 ) 数组下标访问超出索引范围时抛 出数组越界异常 11 ) 浮点型数组的默认值是0.0f 。 12 ) 数组创建后其大小不能改变。 二选择题 1.下面错误的初始化语句是_ABD__ A.charstr[]="hello"; B.charstr[100]="hello"; C.charstr[]={'h','e','l','l','o'}; D.charstr[]={'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.下面的二维数组初始化语句中，正确的是____ A.floatb[2][2]={0.1,0.2,0.3, 0.4}; B.inta[][]={{1,2},{3,4}}; C.inta[2][]={{1,2},{3,4}}; D.floata[2][2]={0}; 4.引用数组元素时，数组下标可以 是_D___ A.整型常量 B.整型变量 C.整型表达式 D.以上均可 5.定义了int型二维数组a[6][7] 后，数组元素a[3][4] 前的数组元素个数为____ A.24 B.25 C.18 D.17 6.下列初始化字符数组的语句中，正确的是__B__ A.charstr[5]="hello"; B.charstr[]={'h','e','l','l','o','\0'}; C.charstr[5]={"hi"}; D.charstr[100]=""; 7. 数组在Java中储存在 C 中 A.栈 B. 队列 C.堆 D.链表 8.下面程序的运行结果是____ main(){ inta[][]={{1,2,3},{4,5,6}} ;System.out.printf("%d",a[ 1][1]);

JAVA程序设计练习试题有包括答案.docx

《 JAVA 程序设计》练习题 一、单选择题 1、编译 Java Application 源程序文件将产生相应的字节码文件，这些字节码文件的扩展名 为 ( B) 。 A.java B. .class C.html D. .exe 2、设x = 1 , y = 2 , z = 3，则表达式y ＋＝ z－－ / ＋＋ x 的值是 ( A ) 。 A. 3 B. 3. 5 C. 4 D. 5 3、不允许作为类及类成员的访问控制符的是( C ) 。 A. public B. private C. static D. protected 4、为AB 类的一个无形式参数无返回值的方法method书写方法头，使得使用类名AB 作为前缀就可以调用它，该方法头的形式为(A ) 。 A. static void method( ) B. public void method( ) C. final void method( ) D. abstract void method( ) 二、填空题 1、开发与运行Java 程序需要经过的三个主要步骤为编辑源程序、 编译生成字节码和解释运行字节码。 2、在Java 的基本数据类型中，char 型采用Unicode编码方案，每个Unicode码占

用 2 字节内存空间，这样，无论是中文字符还是英文字符，都是占 用 2 字节内存空间。 3、设x = 2，则表达式( x + + )／3的值是0 。 4、若x = 5 ， y = 10，则x < y和x >= y的逻辑值分别为true和false。 5、抽象 (abstract)方法是一种仅有方法头，没有具体方法体和操作实现的方法，该 方法必须在抽象类之中定义。最终 (final)方法是不能被当前类的子类重新定义的方法。 6、创建一个名为MyPackage的包的语句是package MyPackage ;，

Java数组练习题(带答案)教学提纲

J a v a 数组练习题 ( 带 答案)

一填空题 1） 数组的元素通过下标来访问，数组Array 的长度为 Array.length 。 2） 数组复制时，"="将一个数组的 引用 传递给另一个数组。 3） JVM 将数组存储在 栈（堆或栈）中。 4） 数组的二分查找法运用的前提条件是数组已经排序 。 5） Java 中数组的下标的数据类型是整型。 6） 数组最小的下标是 0 0 7） arraycopy （）的最后一个参数指明复制元素的个数 。 8） 向方法传递数组参数时，传递的是数组的 引用° 9） 数组初始化包括 数组的申明，创建和初始化 。 10） 数组下标访问超出索引范围时抛出 数组越界 异常 11） 浮点型数组的默认值是 O.Of ° 12） 数组创建后其大小 不能 改变。 二选择题 1. 下面错误的初始化语句是_ABD__ A. char str[]="hello"; B. char str[100]="hello"; C. char str[]={'h','e',T,T,'o'}; D. char str[]={'hello'}; 2. 定义了一维int 型数组a[10]后，下面错误的引用是_B__ 3. A. a[0]=1; B. a[10]=2; C. a[0]=5*2; D. a[1]=a[2]*a[0]; 4. 下面的二维数组初始化语句中，正确的是 _____ 5. A. float b[2][2]={0.1,0.2,0.3,0.4}; B. int a[][]={{1,2},{3,4}}; 6. C. int a[2][]= {{1,2},{3,4}}; D. float a[2][2]={0}; 7. 引用数组元素时，数组下标可以是 _D___ 8. A.整型常量 B.整型变量 C.整型表达式 D.以上均 9. 定义了 int 型二维数组a[6][7]后，数组元素 A. 24 B. 25 C. 18 10. 下列初始化字符数组的语句中，正确的是 __B__ 11. A. char str[5]="hello"; B. char str[]={'h','e',T,T,'o','\0'}; 12. C. char str[5]={"hi"}; D. char str[100]=""; 13. 数组在Java 中储存在丄中 14. A.栈 B.队列 C.堆 D.链表 15. 下面程序的运行结果是 ____ mai n() { int a[][]={{1,2,3},{4,5,6}}; System.out.pri ntf("%d", a[1][1]); } a[3][4]前的数组元素个数为 D. 17

练习12 Java容器练习题

Java容器练习题 [] 选择题 1．在一个类中定义一个数组属性，自属性要包含5个成员，下列哪个定义是争取的？A：Array a=new Array(5); B：int[] a={1,2,3,4,5}; C：int[] array; E：int a[]=new int[5]; 答： 2．已经定义了int类型的数组变量m，下列哪个为m进行初始化的语句是正确的？ A：m={1,2,3,4}; B：m=[1,2,3,4]; C：m=new int[]{1,2,3,4}; D：m=new int[4]{1,2,3,4}; E：m=new int(1,2,3,4); 答： 3．下列关于数组的说法哪个是正确？ A：已经定义的数组可以保存任何类型的数据，包括对象，简单类型。 B：因为数组在定义并初始化后，也可以使用new 对其进行再初始化，因此数组的容量是可以改变的。 C：int类型的数组定义了一个int类型的变量，因此是一个简单类型的变量。 D：数组与类和接口一样，也是一种数据类型。 E：int类型数组是简单类型，String类型数组是对象类型。 答： 4．已经定义的一个数组变量m，取得它可以包含元素个数的表达式是： A：m.size B：m.size() C：m.length() D：m.length E：size(m) 答： 5．已经定义并初始化的一个数组，下列哪个说法是正确？ A：因为数组不像类那样使用class定义，因此数组对象没有父类。 B：虽然数组没有使用class定义，但它也有父类，它的父类就是定义数组的类型。 C：虽然数组没有使用class定义，但它也有父类，它的父类是https://www.wendangku.net/doc/2311329617.html,ng.Object。 D：int类型的数组没有父类。 E：String类型的数组有父类，父类类型是String 答： 6．已经定义了int类型的数组m，并初始化为m=new int[4], 下列哪个访问数组元素的语

java经典基础练习题及参考答案

1. 写一个函数，计算一个整数数组的平均值 import java.util.Random; public class javaSevenDayLianXi { public static void main(String[] args) { int arr[] = new int[10]; Random score = new Random(); float sum = 0.0f; System.out.print("这组数为:"); for (int i = 0; i < arr.length; i++) { arr[i] = score.nextInt(101); sum += arr[i]; System.out.print(arr[i] + " "); } System.out.println(); System.out.println("数组arr的平均值为："+ sum / arr.length); } } 2. 自定义一个整数数组a，读入一个整数n，如果n 在数组中存在，则输出n 的下标；如果不存在，则输出-1。 Scanner sca = new Scanner(System.in); int []a = {0,1,2,3,4,5,6,7,8,9}; System.out.print("请输入一个数："); int shuJu = sca.nextInt(); boolean bool = true; for(int i=0;i