【小白学Java】Test04》》》数组练习题

最新推荐文章于 2022-10-24 20:56:59 发布

北慕辰

最新推荐文章于 2022-10-24 20:56:59 发布

阅读量2.4k

点赞数 5

分类专栏：小白学Java 学习题库文章标签： java

本文链接：https://blog.csdn.net/dazuo_001/article/details/118445037

版权

小白学Java 同时被 2 个专栏收录

43 篇文章 24 订阅

订阅专栏

学习题库

10 篇文章 8 订阅

订阅专栏

一、填空题

1.数组会在内存中开辟一块___连续_____的空间，每个空间相当于之前的一个变量，称为数组的元素。数组的长度一经确定，就无法再改变。

2.要获取一个数组的长度，可以通过__.length_____属性来获取，但获取的只是为数组分配的空间的数量，而不是数组中实际已经存放的元素的个数。

3.__声明数组 __仅仅是给出了数组名字和元素的数据类型，要想真正的使用数组还必须使用new关键字为它分配内存空间。

4.创建数组后，系统会给每一个数组元素一个默认的值，如String类型元素的默认值是__ null___。

5.在Java中有二维数组int [ ] [ ] array={{1,2,3},{4,5}} ，可以使用____array[0].length_______得到二维数组中第二维中第一个数组的长度。

二、选择题

在Java中，以下程序段能正确为数组赋值的是（ AD ）。（选择二项）

A int a[]={1,2,3,4};
B. int b[4]={1,2,3,4};
C. int c[];c={1,2,3,4};
D. int d[];d=new int[]{1,2,3,4};
数组元素的索引可以是（D ）。（选择一项）

A 整型常量
B. 整型变量
C. 整型表达式
D. 以上都可以
已知表达式int [] m={0,1,2,3,4,5,6};下面（ B ）表达式的值与数组最大下标数相等。（选择一项）

A m.length()
B. m.length-1
C. m.length()+1
D. m.length+1
在Java中，以下定义数组的语句正确的是（ CD ）。（选择二项）

A int t[10]=new int[ ];
B. char [ ]a=”hello”;
C. String [ ] s=new String [10];
D. double[ ] d [ ]=new double [4][ ];
在Java中,下面代码的输出结果为（ A）。（选择一项）
public static void main(String[] args) {
int[] arrA = { 12, 22, 8, 49, 3 };
int k = 0; int len = arrA.length;
for (int i = 0; i < len; i++) {
for (int j = i + 1; j < len; j++) {
if (arrA[i] > arrA[j]) {
k = arrA[i];
arrA[i] = arrA[j];
arrA[j] = k;
}
}
}
for (int i = 0; i < arrA.length; i++) {
System.out.print(arrA[i]);
if (i < arrA.length - 1) {
System.out.print("，");
}
}
}

A 3，8，12，22，49
B. 12，22，8，49，3
C. 49，22，12，8，3
D. 编译错误
分析下面的Java源程序，编译后的运行结果是（B ）。（选择一项）
import java.util.*;
public class Test {
public static void main(String[ ] args) {
int [ ] numbers=new int[ ]{1,2,3};
System.out.println(Arrays.binarySearch(numbers, 2));
}
}
输出
A 输出：0
B. 输出：1
C. 输出：2
D. 输出：3
以下选项中关于Java中方法的可变参数的说法正确的是（ AC ）。（选择二项）

A 可变参数是JDK1.5增加的内容，用来表示方法的形参
B. 一个方法可以没有可变参数，可以有1个或者多个可变参数
C. 可变参数可以被当作数组参数来处理
D. 可变参数对应的实参可以1个，2个，多个，但不能0个（可以为0个），还可以是一个数组
分析下面的Java程序，编译运行后的输出结果是（ B ）。（选择一项）
public class Example {
String str = new String(“good”);
char[] ch = { ‘a’, ‘b’, ‘c’ };
public static void main(String args[]) {
Example ex = new Example( );
ex.change(ex.str, ex.ch);
System.out.print(ex.str + “and”);
System.out.print(ex.ch);
}
public void change(String str, char ch[]) {
str = “test ok”;
ch[0] = ‘g’;
}
}

A goodandabc
B. goodandgbc
C. test okandabc
D. test okandgbc
以下选项中能够正确创建一个数组的是（ AD ）。（选择二项）

A. float []f[] = new float[6][6];
B. float f[][] = new float[][];
C. float [6][]f = new float[6][6];
D. float [][]f = new float[6][];

三、判断题

1.数组可以声明为任何数据类型，包括任何基本数据类型和引用数据类型。（ T ）

2.数组的长度是确定的，数组一旦被创建，它的大小就是不可以改变的。但是其元素类型可以是不同类型，允许出现混合类型。（ F ）

3.声明数组并分配空间后，数组的每个元素将会赋予初始值。（ T ）

4.创建数组后，系统会给每个数组元素一个默认值，如double型元素的默认值是0.0。（ T ）

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

6.Java允许创建不规则数组，即Java多维数组中各行的列数可以不同。（ T ）

7.对于数组int[][] t={{1,2,3},{4,5,6}}来说，t.length等于3，t[0].length等于2（ F）

四、简答题

1.数组的特点。

答：数组是可以保存一组数据的一种数据结构，它本身也会占用一个内存地址，因此数组是引用类型,一个数组中只能保存一种类型的数据，可以保存基本类型，也可以保存Object。一个int,一个String是不能同时保存在一个数组内的(如果是对象型数组，注意存放的每一个对象都必须被实例化)。数组的长度规定好即固定，无论其保存的数据是否填满数组，数组一旦定义好就不可以修改长度，如果要修改就必须重新定义一个新数组或者引用其他的数组，因此数组的灵活性较差，数组拥有边界检查，尝试获取不在数组范围内的值时，会抛出ArrayIndexOutOfBoundsException异常

2.数组的优缺点

答：优点：使用方便，查询效率比链表高，内存唯一连续的区域缺点：大小固定，不适合动态存储，不方便动态添加

3.冒泡排序的算法。

答：按照从小到大或者从大到小的顺序进行交换,这样一趟过去后,最大或最小的数字被交换到了最后一位,然后再从头开始进行两两比较交换,直到倒数第二位时结束

五、编码题

1.数组查找操作：定义一个长度为10 的一维字符串数组，在每一个元素存放一个单词；然后运行时从命令行输入一个单词，程序判断数组是否包含有这个单词，包含这个单词就打印出“Yes”，不包含就打印出“No”。

    String[] strArr = new String[10];
	strArr[0] = "java";		
	strArr[1] = "python";
	strArr[2] = "hive";		
	strArr[3] = "android";
	strArr[4] = "javascript";		
	strArr[5] = "scala";
	strArr[6] = "c#";
	strArr[7] = "c++";
	strArr[8] = "hadoop";
	strArr[9] = "mysql";
	Scanner scanner = new Scanner(System.in);
	System.out.print("请输入需要查找的计算机编程语言:");
	String inputStr = scanner.next();
	boolean flag = false;
	for (String string : strArr) {
		if (string.equals(inputStr)) {
			flag = true;
		}
	}
	if (flag) {
		System.out.println("YES");
	} else {
		System.out.println("NO");
	}

运行结果：
在这里插入图片描述

2.获取数组最大值和最小值操作：利用Java的Math类的random()方法，编写函数得到0到n之间的随机数，n是参数。并找出产生50个这样的随机数中最大的、最小的数，并统计其中>=60的有多少个。
提示：使用 int num=(int)(n*Math.random());获取随机数

  public static void main(String[] args) {
        //创建一个长度为50的，每个元素在0-100之间的数组
        int[] arr = getArray(100);
        //遍历数组
        printArr(arr);
        //获取最大值和最小值
        int min = getMin(arr);
        int max = getMax(arr);
        System.out.println("\n");
        System.out.println("数组中最大值：" + max + "\n数组中最小值：" + min);
        //统计其中大于等于60的元素个数
        int count = count(arr,60);
        System.out.println("数组中大于或等于60的数有:" + count + " 个");
    }

    //**************方法声明实现**********
    //遍历数组
    private static void printArr(int[] arr) {
        System.out.println("输出数组元素");
        for(int i=0;i<arr.length;i++){
            if(i%10 ==0){
                System.out.println();
            }
            System.out.print(arr[i]+"\t");
        }
    }
    //获取数组最大值
    private static int getMax(int[] arr) {
        int max = arr[0];
        for(int i=1;i<arr.length;i++){
            if(max<arr[i]){
                max = arr[i];
            }
        }
        return max;
    }
    //获取数组最小值
    private static int getMin(int[] arr) {
        int min = arr[0];
        for(int i=0;i<arr.length;i++){
            if(min>arr[i]){
                min = arr[i];
            }
        }
        return min;
    }
    // 创建数组 并且初始化50个数据
    public static int[] getArray(int n) {
        int arr[] = new int[50];
        for (int i = 0; i < 50; i++) {
            arr[i] = (int) (n * Math.random());
        }
        return arr;
    }
    // 统计数组中大于等于60的数量的方法 思路：使用一个int值计数
    public static int count(int[] arr,int elem) {
        int count = 0;
        for (int i : arr) {
            if (i >= elem) {
                count++;
            }
        }
        return count;
    }

在这里插入图片描述

3.数组逆序操作：定义长度为10的数组，将数组元素对调，并输出对调前后的结果。

思考：
把0索引和arr.length-1的元素交换，把1索引和arr.length-2的元素交换……
只要交换到arr.length/2的时候即可。

public static void main(String[] args) {
    //定义一个数组，并进行静态初始化。
    int[] arr = {10,85,55,54,76,32,90,34,22,80};
    //逆序前
    System.out.println("逆序前：");
    printArr(arr);
    //逆序后
    System.out.println("逆序后：");
    reverseArr(arr);
    printArr(arr);
}
public static void reverseArr(int[] arr) {
    for(int x=0; x<arr.length/2; x++) {
        int temp = arr[x];
        arr[x] = arr[arr.length-1-x];
        arr[arr.length-1-x] = temp;
    }
}
//遍历数组
public static void printArr(int[] arr) {
    System.out.print("[");
    for(int x=0; x<arr.length; x++) {
        if(x == arr.length-1) { //这是最后一个元素
            System.out.println(arr[x]+"]");
        }else {
            System.out.print(arr[x]+", ");
        }
    }
}

在这里插入图片描述

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}

思考：
确定出不为0的个数，这样可以开辟新数组；
从旧的数组之中，取出内容，并将其赋给新开辟的数组。

 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[] = selectArr(oldArr);
      System.out.println("新数组为：\n");
      for (int i : newArr) {
          System.out.print(i+" ");
      }
  }
  // 去掉数组中值为0的元素的方法
  public static int[] selectArr(int[] arr) {
      // 1.计算数组中元素不为0的个数
      int count = 0;
      for (int i : arr) {
          if (i != 0) {
              count++;
          }
      }
      // 2.创建一个新数组,长度为count
      int newArr[] = new int[count];
      // 3.复制不为0的元素到新数组中
      int size = 0;
      for (int i : arr) {//数组遍历
          if (i != 0) {
              newArr[size++] = i;
          }
      }
      return newArr;
  }

在这里插入图片描述

5.二分法查找操作：使用二分法查找有序数组中元素。找到返回索引，不存在输出-1。

分析：二分法查找的前提是数组有序。
假如有一组数为3，12，24，36，55，68，75，88要查给定的值24.可设三个变量front，mid，end分别指向数据的上界，中间和下界，mid=（front+end）/2.　　
1)开始令front=0（指向3），end=7（指向88），则mid=3（指向36）。因为mid>x，故应在前半段中查找。
2)令新的end=mid-1=2，而front=0不变，则新的mid=1。此时x>mid，故确定应在后半段中查找。
3)令新的front=mid+1=2，而end=2不变，则新mid=2，此时a[mid]=x，查找成功。
4)如要查找的数不是数列中的数，例如x=25，当第三次判断时，x>a[mid]，按以上规律，令front=mid+1，即front=3，出现front>end的情况，表示查找不成功。

public static void main(String[] args) {		
		int[] array = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
		System.out.println(searchLoop(array, 9));
	}
	/**
	 * 循环二分查找，返回第一次出现该值的位置 
	 * @param array 已排序的数组
	 * @param findValue   需要找的值
	 * @return 值在数组中的位置，从0开始。找不到返回-1
	 */
	public static int searchLoop(int[] array, int findValue) {
		// 如果数组为空，直接返回-1，即查找失败
		if (array == null) {
			return -1;
		}
		// 起始位置
		int start = 0;
		// 结束位置
		int end = array.length - 1;
		while (start <= end) {			
			// 中间位置
			int middle = (start + end) / 2;
			// 中值
			int middleValue = array[middle];
			if (findValue == middleValue) {
				// 等于中值直接返回
				return middle;
			} else if (findValue < middleValue) {
				// 小于中值时在中值前面找
				end = middle - 1;
			} else {
				// 大于中值在中值后面找
				start = middle + 1;
			}
		}
		// 返回-1，即查找失败
		return -1;
	}

6.二维数组遍历求和操作：
用二重循环求出二维数组b所有元素的和：
int[][] b={{12},{21,25},{31,32,35}}

 public static void main(String[] args) {
		int sum=0;
		int[][] b={{12},{21,25},{31,32,35}};
		for(int i=0;i<b.length;i++){
			for(int j=0;j<b[i].length;j++){
				sum += b[i][j];
			}
		}
		System.out.println(sum);
	}

六、进阶题

1.生成一百个随机数，放入数组，然后排序输出。

public static void main(String[] args) {
		//1.生成100个随机数的数组
		int []arr = createArr();
		//2.从小到大排序 
		arr = sortArr(arr);
		//3.打印
		printArr(arr);
	}
	//生成100个随机数的方法
	public static int[] createArr(){
		int []arr = new int[100];
		for(int i=0;i<arr.length;i++){
			arr[i]= (int) (100*Math.random());
		}
		return arr;
	}
	//对数组进行排序的方法
	public static int[] sortArr(int arr[]){
		int temp;
		for (int i = 0; i < arr.length; i++) {
			for (int j = 0; j <= i; j++) {
				if (arr[i] < arr[j]) {
					temp = arr[i];
					arr[i] = arr[j];
					arr[j] = temp;
				}
			}
		}
		return arr;
	}
	//数组遍历输出打印的方法
	public static void printArr(int []arr){
		for(int i:arr){
			System.out.println(i);
		}
	}

2.输入某年某月某日，判断这一天是这一年的第几天？

分析：以3月5日为例，先把前两个月的加起来，然后再加上5天即本年第几天，特殊情况，闰年且输入月份大于3需考虑多加一天。可定义数组存储1-12月各月天数。

  public static void main(String[] args) {
        Scanner scanner1 = new Scanner(System.in);
        System.out.print("今年是第几年：\t");
        int year = scanner1.nextInt();
        System.out.print("今天是第几月：\t");
        int month = scanner1.nextInt();
        System.out.print("今天是第几日：\t");
        int day = scanner1.nextInt();
        int daynum = 0; // 天数
        //一年365天
        int[] month1 = new int[] { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31,30, 31 };
        //闰年366天
        if (year % 400 == 0 && year % 100 != 0 || year % 100 == 0) {
            month1 = new int[] { 31, 29, 31, 30, 31, 30, 31, 31, 30, 31,30, 31 }; // 闰年里的每个月的天数
        }
        //判断这一天是第几天
        for (int index = 1; index <= month; index++) {
            if (index == 1) {
                daynum = day;
            } else {
                daynum += month1[index - 2];
            }
        }
        System.out.println("这一天是这一年的第" + daynum + "天！");
    }

在这里插入图片描述

3.现在给出两个数组：
数组A：1，7，9，11，13，15，17，19；
数组b：2，4，6，8，10
两个数组合并为数组c，按升序排列。
要求：使用Arrays类的方法快速实现。

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);
      System.out.println("合并后的数组为：\n");
      print(newArr);
      Arrays.sort(newArr);
      System.out.println("排序后的数组为：\n");
      print(newArr);
  }
  public static int[] concat(int src1[], int src2[]) {
      int len = src1.length + src2.length; // 新数组的大小
      int arr[] = new int[len]; // new新数组
      //方法1：
		/*int count = 0;
		for (int i : src1) {
			arr[count++] = i;
		}
		for (int i : src2) {
			arr[count++] = i;
		}*/
      // 方法2：可以通过系统的方法拷贝数组
      System.arraycopy(src1, 0, arr, 0, src1.length); // 拷贝第一个数组
      System.arraycopy(src2,0,arr,src1.length, src2.length); //拷贝第二个数组
      return arr;
  }
  public static void print(int[] temp) {
      for (int x = 0; x < temp.length; x++) {
          System.out.print(temp[x] + "、");
      }
      System.out.println();
  }

在这里插入图片描述

北慕辰

关注

5
点赞
踩
8

收藏

觉得还不错? 一键收藏
打赏
8
评论
【小白学Java】Test04》》》数组练习题

一、填空题1.数组会在内存中开辟一块___连续_____的空间，每个空间相当于之前的一个变量，称为数组的元素。数组的长度一经确定，就无法再改变。2.要获取一个数组的长度，可以通过__.length_____属性来获取，但获取的只是为数组分配的空间的数量，而不是数组中实际已经存放的元素的个数。3.__声明数组 __仅仅是给出了数组名字和元素的数据类型，要想真正的使用数组还必须使用new关键字为它分配内存空间。4.创建数组后，系统会给每一个数组元素一个默认的值，如String类型元素的默认值是__ nu
复制链接

扫一扫