【Java】学完数组你该会写的数组题目

前言：数组练习

1.数组转字符串

创建一个数组，像字符串一样输出数组。（提示：Arrays.toString（））

关于Arrays.toString（）：

Arrays.toString（）的作用是用来很方便地输出数组，而不用一个一个地输出数组中的元素。

这个方法是是用来将数组转换成String类型输出的，入参可以是long，float，double，int，boolean，byte，object型的数组。

参考代码：

//记得带上包
     import java.util.Arrays;
     public static void main(String[] args) {

        int[] arr = {1,2,3,4,5,6};
        String newArr = Arrays.toString(arr);
        System.out.println(newArr);
        // 执行结果
        //[1, 2, 3, 4, 5, 6]
    }

在这里使用到了Arrays.toString方法，使用这个方法后续打印数组就更方便一些，对于Java ，其中提供了 java.util.Arrays 包, 其中包含了一些操作数组的常用方法。这些都是JDK提供好的代码。

---

2.模仿实现Arrays.toString()

我们也可以模仿实现其功能。

模仿实现Arrays.toString()

参考代码：

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

---

3.数组拷贝

创建两个数组，将其中一个数组的内容拷贝到另一个数组。（提示：Arrays.copyOf()）

参考代码：

import java.util.Arrays;
public static void main(String[] args) {
        int[] arr = {1,2,3,4,5,6};
        int[] newArr = Arrays.copyOf(arr, arr.length);
         System.out.println("arr: " + Arrays.toString(arr));
        System.out.println("newArr: " + Arrays.toString(newArr));
       
        arr[0] = 10;
        System.out.println("arr: " + Arrays.toString(arr));
        System.out.println("newArr: " + Arrays.toString(newArr));

    }

对于上面的代码，其实前几行就可以实现这个拷贝， Arrays.copyOf同样是Arrays包中的一个方法。后面的代码是为了展示出来，对于拷贝后，两个数组是互不影响的。

有的人可能是直接newArr = arr，但这种属于浅拷贝。相比于 newArr = arr 这样的赋值，copyOf 是将数组进行了深拷贝，即又创建了一个数组对象，拷贝原有数组中的所有元素到新数组中。因此，修改原数组，不会影响到新数组。

//直接用newArr = arr
 public static void main(String[] args) {

        int[] arr = {1,2,3,4,5,6};
        int[] newArr = arr;
        //警告：局部变量' newArr '是多余的
        System.out.println("arr: " + Arrays.toString(arr));
        System.out.println("newArr2: " + Arrays.toString(newArr));

        arr[0]=5;
        System.out.println("arr: " + Arrays.toString(arr));
        System.out.println("newArr2: " + Arrays.toString(newArr));
        //arr改变newArr同样也改变，因为他们的引用都是指向同一处
    }

同时还有一个拷贝部分范围的方法：

 public static void main(String[] args) {
        
        int[] arr = {1,2,3,4,5,6};
        int[] newArr2 = Arrays.copyOfRange(arr, 2, 4);
        // 拷贝某个范围.
        System.out.println("arr: " + Arrays.toString(arr));
        System.out.println("newArr2: " + Arrays.toString(newArr2));

    }

---

4.实现自定义Arrays.copyOf()

实现自定义Arrays.copyOf()。

参考代码：

//自定义copyOf
public static int[] copyOf(int[] arr) {
        int[] ret = new int[arr.length];
        for (int i = 0; i < arr.length; i++) {
            ret[i] = arr[i];
        }
        return ret;
    }

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

5.找到数组中的最大元素

给定一个整型数组，找到数组中的最大元素。（最小也是同理）

参考代码：

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

类似于 “打擂台” 这样的过程，其中 max 变量作为 擂台, 比擂台上的元素大, 就替换上去, 否则就下一个对手。（你行你上）

---

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

给定一个整型数组, 求平均值

注意变量类型，这个没什么好说的加起来除就是了。

参考代码：

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

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

---

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

给定一个数组，再给定一个元素，找出该元素在数组中的位置。

参考代码：

   public static int find(int[] arr, int toFind) {
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] == toFind) {
                return i;
            }
        }
        return -1; // 表示没有找到
    }
    
    public static void main(String[] args) {
        int[] arr = {1,2,3,10,5,6};
        System.out.println(find(arr, 10));
    }

---

8.查找数组中指定元素(二分查找)

针对有序数组, 可以使用更高效的二分查找。

啥叫有序数组?
有序分为 “升序” 和 “降序”
如 1 2 3 4 , 依次递增即为升序.
如 4 3 2 1 , 依次递减即为降序

以升序数组为例，二分查找的思路是先取中间位置的元素，看要找的值比中间元素大还是小。如果小，就去左边找；否则就去右边找。这样截取的方法大大提高了效率。

参考代码：

//二分查找
    public static int binarySearch(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 {
             // 相等, 说明找到了
                return mid;
            }
        }
             // 循环结束, 说明没找到
        return -1;
    }

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

在每一次循环加上一个计算的count变量，针对一个长度为 10000 个元素的数组查找，二分查找计算出只需要循环 14 次就能完成查找。随着数组元素个数越多，二分的优势就越大。

---

9.检查数组的有序性

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

参考代码：

   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;
    }
    
    public static void main(String[] args) {
        int[] arr = {1,2,3,10,5,6};
        System.out.println(isSorted(arr));
    }

10.数组排序(冒泡排序)

给定一个数组，让数组升序 (降序) 排序。

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

参考代码：

//冒泡排序
   public static void bubbleSort(int[] arr) {
        for (int bound = 0; bound < arr.length; bound++) {
            for (int cur = arr.length - 1; cur > bound; cur--) {
                if (arr[cur - 1] > arr[cur]) {
                    int tmp = arr[cur - 1];
                    arr[cur - 1] = arr[cur];
                    arr[cur] = tmp;
                }
            }
        }
    }
    
    public static void main(String[] args) {
        int[] arr = {9, 5, 2, 7};
        bubbleSort(arr);
        System.out.println(Arrays.toString(arr));
    }

冒泡排序性能较低. Java 中内置了更高效的排序算法，没错，关于数组的，它又来了一个：Arrays.sort()。

public static void main(String[] args) {
     int[] arr = {9, 5, 2, 7};
     Arrays.sort(arr);
     System.out.println(Arrays.toString(arr));
}

---

11.数组逆序

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

参考代码：

 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--;
        }
    }
    
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4};
        reverse(arr);
        System.out.println(Arrays.toString(arr));
    }

---

12.数组数字排列

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

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

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

---

本篇学完数组你该会写的数组题目就到这里。