Java数组的习题

　Puppet゜

已于 2023-07-03 21:33:44 修改

阅读量130

点赞数

分类专栏： # JavaSE练习文章标签： java 开发语言

于 2022-10-27 21:22:38 首次发布

本文链接：https://blog.csdn.net/weixin_52601264/article/details/127560273

版权

JavaSE练习专栏收录该内容

4 篇文章 0 订阅

订阅专栏

1、数组转字符串

JVM自带的方法：Arrays.toString()

   public static void transForm(int[] arr){
        String newArr = Arrays.toString(arr);
        System.out.println(newArr);
    }

自己实现的方法如下：

   public static String transFormArrays(int[] arr){
        //先写左侧括号[
        String ret = "[";
        //开始遍历数组
        for (int i = 0; i < arr.length; i++) {
            ret += arr[i];
            //除最后一个元素，其余数后面加","
            if (i != arr.length - 1){
                ret += ", ";
            }
        }
        ret += "]";
        return ret;
    }

2、数组拷贝

JVM自带的方法有两种，一种是全部拷贝：Arrays.copyOf()

另一种是部分拷贝：Arrays.copyOfRange()【左闭右开】

    public static void copy(int[] arr){
        int[] newArr = Arrays.copyOf(arr,arr.length);
        System.out.println("newArr:" + Arrays.toString(newArr));
        System.out.println("arr:" + Arrays.toString(arr));

        int[] newArr1 = Arrays.copyOfRange(arr,2,4);
        System.out.println("newArr1:" + Arrays.toString(newArr1));
    }

自己实现的方法如下：

a、全部拷贝

   public static int[] copyArrays(int[] arr){
        //新创建一个与arr大小完全相同的数组对象
        int[] ret = new int[arr.length];
        for (int i = 0; i < arr.length; i++) {
            ret[i] = arr[i];
        }
        return ret;
    }

b、部分拷贝

    public static int[] copyArraysRange(int[] arr,int startIndex,int endIndex){
        //新创建与需要拷贝范围大小完全一样的数组
        int[] ret = new int[endIndex - startIndex];
        for (int i = startIndex; i < endIndex; i++) {
            //从第一个需要拷贝的数是i-起始索引
            ret[i- startIndex] = arr[i];
        }
        return ret;
    }

3、找数组中最大元素

    public static int max(int[] arr){
        //先默认数组中的第一个数为最大数
        int max = arr[0];
        //从数组中的第二个数开始，与默认的最大值进行比较
        for (int i = 1; i < arr.length; i++) {
            //若此数大于最大值，则目前的最大值赋值为该数
            if (arr[i] > max){
                max = arr[i];
            }
        }
        return max;
    }

本题思路：首先默认第一个数位最大值，然后类似于“打擂台”的方式依次与后面的数进行比较，若后面的数大于该数，就替换最大值，否则就继续向后遍历。

4、求数组平均值

    public static double avg(int[] arr){
        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
            sum += arr[i];
        }
        //求平均值注意数据类型的转换
        return (double) sum / (double) arr.length;
    }

本题思路：先求和，再将和除以数组的长度。注意结果要用double来表示。

5、查找数组中指定元素的位置(顺序查找)

    public static int find(int[] arr,int toFind){
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] == toFind){
                System.out.print("该数的索引为：");
                return i;
            }
        }
        System.out.print("没有找到该数");
        return -1;
    }

本题思路：遍历数组依次与查找数比较，若找到相等的数返回该数索引，若没有找到返回-1。

6、查找数组中指定元素的位置（二分查找）

    public static int arraysSearch(int[] arr,int toFind){
        //先列出最左侧元素和最右侧元素
        int left = 0;
        int right = arr.length -1;
        while (left <= right){
            //找中间值的索引
            int mid = (left + right) / 2;
            //寻找值与中间值作对比
            if (toFind < arr[mid]){
                right = mid - 1;
            }else if (toFind > arr[mid]){
                left = mid + 1;
            }else {
                //while循环中考虑到的问题left = right
                //若相等就说明找到该数了，返回索引
                return mid;
            }
        }
        //循环结束，则说明没找到
        return -1;
    }

本题思路：将数组分成左右两半区，将中间值与被查找数进行比较，若被查找数小于中间值则将范围缩小为左半区，继续进行比较；若被查找数大于中间值则将范围缩小为右半区，继续进行比较；若相等就直接返回。

7、检查数组的有序性

    public static boolean isSorted(int[] arr){
        for (int i = 0; i < arr.length - 1; i++) {
            if (arr[i] > arr[i + 1]){
                return false;
            }
        }
        return true;
    }

本题思路：遍历数组依次判断当前数与后一位数的大小，若当前数大于后一位数交换两数。

8、数组排序（冒泡排序）

将整个数组分为两部分：

未排序数组：[0,1...arr.length-1] -> [0,1...arr.length-2] -> [0,1...arr.length-3]...

已排序数组：[ ] -> [arr.length-1] -> [arr.length-2,arr,length-1]...

每次将当前元素和下一个元素比较，若当前元素>下一个元素，两两交换。

每一次循环结束，都有一个元素在最终位置（内层循环）

    public static void bubbleSort(int[] arr){
        //外层表示未处理的数组
        for (int i = 0; i < arr.length - 1; i++) {
            //内存表示未排好的元素到排好的元素之前
            for (int j = 0; j < arr.length - 1 - i; j++) {
                //内层循环结束后，循环内的最后一个数一定是最大数
                //对前后两数进行比较，若前面的数大于后面的数，交换两数
                if (arr[j] > arr[j + 1]){
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
    }

本题思路：分内层循环和外层循环，外层循环表示未排序的数组，内层循环表示依次遍历从未排序的元素中找到最大值，并存放在未排序数组的最后一个。

9、数组逆序

    public static void reverse(int[] arr){
        //定义最左侧和最右侧数的索引
        int left = 0;
        int right =arr.length - 1;
        //排除left=right的因素，若两索引相等表示的是同一个数不用交换
        //当数组个数为奇数会出现此情况
        while (left < right){
            int temp = arr[left];
            arr[left] = arr[right];
            arr[right] = temp;
            left ++;
            right --;
        }
    }

本题思路：首先定义最左侧和最右侧的数分别为left和right，将left和right两两进行交换。

10、数组数字排序

给定一个数组，将所有的偶数放在前半部分，将所有的奇数放在后半部分。

奇数从前往后找，偶数从后往前找。

    public static void swapArrays(int[] arr){
        //首先假设第一个数为奇数，最后一个数位偶数
        int left = 0;
        int right = arr.length - 1;
        while (left < right){
            //判断偶数
            //若该数是奇数就停止循环
            while (left < right && arr[left] % 2 == 0){
               left ++;
            }
            //判断奇数
            //若该数是偶数就停止循环
            while (left < right && arr[right] % 2 != 0){
                right --;
            }
            //两个内层循环结束时，left指向奇数，right指向偶数
            //因为要将奇数放在后面，偶数放在前面，所以现在要交换位置
            int temp = arr[left];
            arr[left] = arr[right];
            arr[right] = temp;
        }
    }