数组作业（java）及答案

数组作业

• 填空题

1. 数组会在内存中开辟一块____连续____的空间，每个空间相当于之前的一个变量，称为数组的元素。数组的长度一经确定，就无法再改变。
2. 要获取一个数组的长度，可以通过___length____属性来获取，但获取的只是为数组分配的空间的数量，而不是数组中实际已经存放的元素的个数。
3. ___声明数组____仅仅是给出了数组名字和元素的数据类型，要想真正的使用数组还必须使用new关键字为它分配内存空间。
4. 创建数组后，系统会给每一个数组元素一个默认的值，如String类型元素的默认值是__ __null_____。
5. 在Java中有二维数组int [ ] [ ] array={{1,2,3},{4,5}} ，可以使_____  array[0].length______得到二维数组中第二维中第一个数组的长度。

• 选择题

• 判断题

1. 数组可以声明为任何数据类型，包括任何基本数据类型和引用数据类型。（   T   ）
2. 数组的长度是确定的，数组一旦被创建，它的大小就是不可以改变的。但是其元素类型可以是不同类型，允许出现混合类型。（  F  ）
3. 声明数组并分配空间后，数组的每个元素将会赋予初始值。（   T   ）
4. 创建数组后，系统会给每个数组元素一个默认值，如double型元素的默认值是0.0。（  T  ）
5. 数组的主要优点是按照索引查找某个元素效率高，同时按照元素值查询某个元素效率也很高，但是添加和删除元素需要大量移动元素，效率低下。（T）

数组的特点：查询快、增删慢   集合

      可以利用偏移地址来访问元素，效率高；可以利用折半方法查找元素，效率较高

查询快，增删慢

1. 数组的某个元素被传递给一个方法并被该方法修改，当被调用方法执行完毕时，这个元素中含有修改过的数值。（  T   ）
2. Java允许创建不规则数组，即Java多维数组中各行的列数可以不同。（  T  ）
3. 对于数组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”。

import java.util.Scanner;
public class Test1 {
    // 思路：遍历数组时当有值与输入字符串相同时使用一个boolean记录状态
    public static void main(String[] args) {
        String[] strArr = new String[10];
        strArr[0] = "wade";
        strArr[1] = "james";
        strArr[2] = "kobe";
        strArr[3] = "harden";
        strArr[4] = "durante";
        strArr[5] = "curry";
        strArr[6] = "paul";
        strArr[7] = "george";
        strArr[8] = "work";
        strArr[9] = "lowry";
        Scanner sc = new Scanner(System.in);
        System.out.print("请输入需要查找的NBA球星:");
        String inputStr = sc.next();
        boolean flag = false;
        for (int i = 0; i <= 9; i++) {
            if (strArr[i].equals(inputStr)) {
                flag = true;
            }
        }
        if (flag) {
            System.out.println("YES");
        } else {
            System.out.println("NO");
        }
    }
}

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

      思路：把0索引和arr.length-1的元素交换，把1索引和arr.length-2的元素交换…..

      只要交换到arr.length/2的时候即可。

public class Test2{
    public static void main(String[] args) {
        //定义一个数组，并进行静态初始化。
        int[] arr = {12,15,85,36,42,59,33,62,29,76};
        //逆序前
        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]+", ");
            }
        }
    }
}

3、合并数组操作：现有如下一个数组：   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的个数，这样可以开辟新数组；从旧的数组之中，取出内容，并将其赋给新开辟的数组。如果判断到0,就使用continue关键字。

public class Test3{
    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);
        for (int i =0;i<newArr.length;i++) {
            System.out.print(newArr[i]+" ");
        }
    }

    public static int[] selectArr(int[] arr) {
        // 1.计算数组中元素不为0的个数
        int count = 0;
        for (int i = 0;i<arr.length;i++) {
            if (arr[i] != 0) {
                count++;
            }
        }

        int newArr[] = new int[count];
        int size = 0;
        for (int i = 0;i<arr.length;i++) {
            if (arr[i] != 0) {
                newArr[size] = arr[i];
                size++;
            }
        }
        return newArr;
    }
}

4、二分法查找操作：使用二分法查找有序数组中元素。找到返回索引，不存在输出-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 class Test4 {
    public static void main(String[] args) {
        int[] array = {3,12,24,36,55,68,75,88};
        System.out.println(searchLoop(array, 24));
    }
    /**
     * 循环二分查找，返回第一次出现该值的位置
     * @param array 已排序的数组
     * @param findValue   需要找的值
     * @return 值在数组中的位置，从0开始。找不到返回-1
     */
    public static int searchLoop(int[] array, int findValue) {
        // 如果数组为空，直接返回-1，即查找失败
        if (array == null) {
            return -1;
        }
        // 起始位置
        int front = 0;
        // 结束位置
        int end = array.length - 1;
        while (front <= end) {
            // 中间位置
            int middle = (front + end) / 2;
            // 中值
            int middleValue = array[middle];
            if (findValue == middleValue) {
                // 等于中值直接返回
                return middle;
            } else if (findValue < middleValue) {
                // 小于中值时在中值前面找
                end = middle - 1;
            } else {
                // 大于中值在中值后面找
                front = middle + 1;
            }
        }
        // 返回-1，即查找失败
        return -1;
    }
}

5、二维数组遍历求和操作：用二重循环求出二维数组b所有元素的和：
     int[][] b={{11},{21,22},{31,32,33}}

public class Test5 {
    public static void main(String[] args) {
        int sum=0;
        int[][] b={{11},{21,22},{31,32,33}};
        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、题目：输入某年某月某日，判断这一天是这一年的第几天？

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

import java.util.Scanner;
public class Test6 {
    public static void main(String[] args) {
        Scanner scanner1 = new Scanner(System.in);
        System.out.print("输出今年是第几年");
        int year = scanner1.nextInt();
        System.out.print("输出今年是第几月");
        int month = scanner1.nextInt();
        System.out.print("输出今年是第几日");
        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 % 4 == 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 + "天！");
    }
}

2、使用二分法查找有序数组中元素。找到返回索引，不存在输出-1。使用递归实现

import java.util.Scanner;
public class Test7 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int[] array = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
        System.out.println(searchRecursive(array, 0, array.length - 1, n));
    }
    public static int searchRecursive(int[] array, int start, int end, int findValue) {
        // 如果数组为空，直接返回-1，即查找失败
        if (array == null) {
            return -1;
        }
        if (start <= end) {
            // 中间位置
            int middle = (start + end) / 1;
            // 中值
            int middleValue = array[middle];
            if (findValue == middleValue) {
                // 等于中值直接返回
                return middle;
            } else if (findValue < middleValue) {
                // 小于中值时在中值前面找
                return searchRecursive(array, start, middle - 1, findValue);
            } else {
                // 大于中值在中值后面找
                return searchRecursive(array, middle + 1, end, findValue);
            }
        } else {
            // 返回-1，即查找失败
            return -1;
        }
    }
}

3、 数组A：1，7，9，11，13，15，17，19；数组b：2，4，6，8，10   

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

public class Test8 {
    public static void main(String[] args) {
        int[] A = new int[]{1, 7, 9, 11, 13, 17, 19};
        int[] B = new int[]{2, 4, 6, 8, 10};
        int[] C = chongzu(A, B);
        BubbleSort(C);
        printArray(C);
    }
    public static int[] chongzu(int src1[], int src2[]) {
        int len = src1.length + src2.length; // 新数组的大小
        int arr[] = new int[len]; // 新数组
        for(int i = 0; i < src1.length; i ++) {
            arr[i]=src1[i];
        }
        for(int i1 = 0; i1 < src2.length; i1 ++) {
            arr[src1.length+i1]=src2[i1];
        }
        return arr;
    }

    public static void BubbleSort(int[] arr) {
        for (int i = 0; i < arr.length - 1; i++) {//外层循环控制排序趟数
            for (int j = 0; j < arr.length - i - 1; j++) {//内层循环控制每一趟排序多少次
                if (arr[j] > arr[j + 1]) {
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
    }


    public static void printArray(int[] arr){
        for(int i=0;i<arr.length;i++){
            if(i==0){
                System.out.print("["+arr[i]+",");
            }else if(i==arr.length-1){
                System.out.print(arr[i]+"]");
            }else {
                System.out.print(arr[i]+",");
            }
        }
    }
}

最后

以上就是结实短靴为你收集整理的数组作业（java）及答案的全部内容，希望文章能够帮你解决数组作业（java）及答案所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。