【Java】 学习-数组基础题练习

【Java】-数组基础题练习

---

前言

主要内容：数组基础问题练习

---

提示：以下是本篇文章正文内容，下面案例可供参考

数组练习

例1.数组转字符串（遍历数组方法之一）

import java.util.Arrays;

public class Test1 {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5, 6, 7, 8};
        System.out.println(Arrays.toString(arr));
    }
}
//执行结果
[1, 2, 3, 4, 5, 6, 7, 8]

Java 中提供了 java.util.Arrays 包, 其中包含了一些操作数组的常用方法.

什么是包？
程序开发不是从零开始, 而是要站在巨人的肩膀上.
像我们很多程序写的过程中不必把所有的细节都自己实现, 已经有大量的标准库( JDK提供好的代码)和海量的第三方库(其他机构组织提供的代码)供我们直接使用. 这些代码就放在一个一个的 “包” 之中. 所谓的包就相当于卖面条的超市. 只不过, 超市的面条只有寥寥几种, 而我们可以使用的 “包” , 有成千上万.

例2.实现一个自己版本的数组转字符串

public class Num14 {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5, 6};
        System.out.println(toString(arr));
    }
    private static String toString(int[] arr) {
        String ret = "[";
        for (int i = 0; i < arr.length; ++i) {
            ret += arr[i];	// 借助 String += 进行拼接字符串
            if (i != arr.length - 1) {
                ret += ",";	// 除了最后一个元素之外, 其他元素后面都要加上 ", " 
            }
        }
        ret += "]";
        return ret;
    }
}
//执行结果
[1,2,3,4,5,6]

例3.数组拷贝（利用Java 中提供的 java.util.Arrays包实现）

import java.util.Arrays;

public class Num13 {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5, 6, 7, 8};
        int[] newArr = Arrays.copyOf(arr, arr.length);
        System.out.println("newArr:"+Arrays.toString(newArr));

        arr[0]=10;
        System.out.println("arr:"+Arrays.toString(arr));
        System.out.println("newArr:"+Arrays.toString(newArr));
        //拷贝某个范围
        int[] newArr2=Arrays.copyOfRange(arr,1,3);
        System.out.println("newArr2:"+Arrays.toString(newArr2));
    }
}
//执行结果
newArr:[1, 2, 3, 4, 5, 6, 7, 8]
arr:[10, 2, 3, 4, 5, 6, 7, 8]
newArr:[1, 2, 3, 4, 5, 6, 7, 8]
newArr2:[2, 3]

注意： 相比于 newArr = arr 这样的赋值, copyOf 是将数组进行了 深拷贝, 即又创建了一个数组对象, 拷贝原有数组中的所有元素到新数组中. 因此, 修改原数组, 不会影响到新数组.

例4.实现一个自己版本的数组拷贝

public class Num13 {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5, 6, 7, 8};
        System.out.println("arr:"+toString(arr));
        System.out.println("newArr:"+toString(copyOf(arr)));
    }

    private static int[] copyOf(int[] arr) {
        int[] newArr = new int[arr.length];
        for (int i = 0; i < arr.length; ++i) {
            newArr[i] = arr[i];
        }
        return newArr;
    }

    private static String toString(int[] arr) {
        String ret = "[";
        for (int i = 0; i < arr.length; ++i) {
            ret += arr[i];
            if (i != arr.length - 1) {
                ret += ",";
            }
        }
        ret += "]";
        return ret;
    }
}
//执行结果
arr:[1,2,3,4,5,6,7,8]
newArr:[1,2,3,4,5,6,7,8]

例5.给定一个整型数组, 找到其中的最大元素 (找最小元素同理)

public class Num15 {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5, 6};
        System.out.println(max(arr));
    }

    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;
    }
}
//执行结果
6

例6.求数组中元素的平均值

public class Num16 {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5, 6,7,8};
        System.out.println(avg(arr));
    }

    public static double avg(int[] arr) {
        int sum = 0;
        for (int x : arr) {
            sum += x;
        }
        return (double) sum / (double) arr.length;
    }
}
//执行结果
4.5

例7.查找数组中指定元素(顺序查找)

public class Mum18 {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 10, 5, 6};
        System.out.println(find(arr, 5));
        System.out.println(find(arr, 4));
    }

    public static int find(int[] arr, int toFind) {
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] == toFind) {
                return i;
            }
        }
        return -1; // 表示没有找到
    }
}
//执行结果
4
-1

例8.查找数组中指定元素并返回索引值(二分查找)

▪️ 针对有序数组（元素值按递增或递减顺序排列）, 可以使用更高效的二分查找.
▪️以升序数组为例, 二分查找的思路是先取中间位置的元素, 看要找的值比中间元素大还是小. 如果小, 就去左边找; 否则就去右边找.

public class Num12 {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 6, 7, 8};
        find(arr, 4);
        find(arr, 5);
    }

    private static void find(int[] arr, int key) {
        int low = 0;
        int high = arr.length;
        while (low < high - 1) {
            int mid = (low + high) / 2;
            if (arr[mid] > key) {
                high = mid; //去左区间找
            } else if (arr[mid] < key) {
                low = mid;  //去右区间找
            } else {
                //找到
                System.out.println(key + "对应的索引为" + mid);
                return;
            }
        }
        System.out.println("数组中没有找到" + key);
    }
}
//执行结果
4对应的索引为3
数组中没有找到5

例9.感受二分查找的效率

public class Num18 {
    static int count = 0; // 创建一个成员变量, 记录二分查找循环次数

    public static void main(String[] args) {
        int[] arr = makeBigArray();
        int ret = binarySearch(arr, 9999);
        System.out.println("ret = " + ret + "， count = " + count);
    }

    //创建一个有10000个元素的数组
    public static int[] makeBigArray() {
        int[] arr = new int[10000];
        for (int i = 0; i < 10000; i++) {
            arr[i] = i;
        }
        return arr;
    }

    //二分查找元素
    public static int binarySearch(int[] arr, int toFind) {
        int left = 0;
        int right = arr.length - 1;
        while (left <= right) {
            count++;    // 使用一个变量记录循环执行次数
            int mid = (left + right) / 2;
            if (toFind < arr[mid]) {
                // 去左侧区间找
                right = mid - 1;
            } else if (toFind > arr[mid]) {
                // 去右侧区间找
                left = mid + 1;
            } else {
                // 相等, 说明找到了
                return mid;
            }
        }
        // 循环结束, 说明没找到
        return -1;
    }
}
//执行结果
ret = 9999， count = 14

针对一个长度为 10000 个元素的数组查找, 二分查找只需要循环 14 次就能完成查找. 随着数组元素个数越多, 二分的优势就越大.

例10.给定一个整型数组, 判断是否该数组是有序的(升序)

public class Num11 {
    public static void main(String[] args) {
        int[] arr1 = {1,2,3,4,5,6,7};
        System.out.println(order(arr1));
        int[] arr2 = {7,6,5,4,3,2,1};
        System.out.println(order(arr2));
    }

    private static boolean order(int[] arr) {
        for (int i = 0; i < arr.length - 1; ++i) {
            if (arr[i] > arr[i + 1]) {
                return false;
            }
        }
        return true;
    }
}
//执行结果
true
false

例11.数组排序(冒泡排序)

算法思路
每次尝试找到当前待排序区间中最小(或最大)的元素, 放到数组最前面(或最后面).

import java.util.Arrays;

public class Num10 {
    public static void main(String[] args) {
        int[] arr = {1, 5, 3, 9, 2, 8, 4, 6};
        bub(arr);
        System.out.println(Arrays.toString(arr));
    }

    private static void bub(int[] arr) {
        // [0, i) 构成了一个前闭后开区间, 表示已排序区间
        // [i, length) 构成了一个前闭后开区间, 表示待排序区间
        // 每循环一次, 就找到一个合适大小的元素, 已排序区间就增大1.
        for (int i = 0; i < arr.length; i++) {
            for (int cur = arr.length - 1; cur > i; cur--) {
                if (arr[cur - 1] > arr[cur]) {
                    int tmp = arr[cur - 1];
                    arr[cur - 1] = arr[cur];
                    arr[cur] = tmp;
                }
            }
        }
    }
}
//执行结果
[1, 2, 3, 4, 5, 6, 8, 9]

冒泡排序性能较低. Java 中内置了更高效的排序算法

import java.util.Arrays;

public class Num10 {
    public static void main(String[] args) {
        int[] arr = {2,6,4,3,5,9};
        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr));
    }
}
//执行结果
[2, 3, 4, 5, 6, 9]

例12.数组逆序

给定一个数组, 将里面的元素逆序排列.

基本思路
设定两个下标分别指向第一个元素和最后一个元素.
前一个下标从左往右走, 后一个下标从右往左走，每走一步前后元素交换一次值，依次循环即可.

import java.util.Arrays;

public class Num20 {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4};
        reverse(arr);
        System.out.println(Arrays.toString(arr));
    }

    public static void reverse(int[] arr) {
        int left = 0;
        int right = arr.length - 1;
        while (left < right) {
            //首尾元素交换值
            int tmp = arr[left];
            arr[left] = arr[right];
            arr[right] = tmp;
            left++;
            right--;
        }
    }
}
//执行结果
[4, 3, 2, 1]

例13.数组数字排列

给定一个整型数组, 将所有的偶数放在前半部分, 将所有的奇数放在数组后半部分

基本思路
设定两个下标分别指向第一个元素和最后一个元素.
用前一个下标从左往右找到第一个奇数, 用后一个下标从右往左找到第一个偶数, 然后交换两个位置的元素. 依次循环即可.

import java.util.Arrays;

public class Num21 {

    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5, 6};
        transform(arr);
        System.out.println(Arrays.toString(arr));
    }

    public static void transform(int[] arr) {
        int left = 0;
        int right = arr.length - 1;
        while (left < right) {
            // 该循环结束, left 就指向了一个奇数
            while (left < right && arr[left] % 2 == 0) {
                left++;
            }
            // 该循环结束, right 就指向了一个偶数
            while (left < right && arr[right] % 2 != 0) {
                right--;
            }
            // 交换两个位置的元素
            int tmp = arr[left];
            arr[left] = arr[right];
            arr[right] = tmp;
        }
    }
}
//执行结果
[6, 2, 4, 3, 5, 1]

---

总结

学习笔记，如内容有任何不妥，恳请大佬指正！（所有内容仅供参考）