关于java数组的部分习题

1.1 数组转字符串

        代码eg：

               

        Java 中提供了 java.util.Arrays 包, 其中包含了一些操作数组的常用方法.我们使用toString方法就能快速的将数组变为字符串。

1.2 数组拷贝

import java.util.Arrays;
public static void func(){
// newArr和arr引用的是同一个数组
// 因此newArr修改空间中内容之后，arr也可以看到修改的结果
int[] arr = {1,2,3,4,5,6};
int[] newArr = arr;
newArr[0] = 10;
System.out.println("newArr: " + Arrays.toString(arr));
// 使用Arrays中copyOf方法完成数组的拷贝：
// copyOf方法在进行数组拷贝时，创建了一个新的数组
// arr和newArr引用的不是同一个数组
arr[0] = 1;
newArr = Arrays.copyOf(arr, arr.length);
System.out.println("newArr: " + Arrays.toString(newArr));
// 因为arr修改其引用数组中内容时，对newArr没有任何影响
arr[0] = 10;
System.out.println("arr: " + Arrays.toString(arr));
System.out.println("newArr: " + Arrays.toString(newArr));
// 拷贝某个范围.
int[] newArr2 = Arrays.copyOfRange(arr, 2, 4);
System.out.println("newArr2: " + Arrays.toString(newArr2));
}

        数组当中存储的是基本类型数据时，不论怎么拷贝基本都不会出现什么问题，但如果存储的是引用数据类 型，拷贝时需要考虑深浅拷贝的问题

1.3 求数组中元素的平均值

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

        代码eg：

        

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

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

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

        代码eg： 

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

    public static int binarySearch(int[] arr,int purpose){

        int left = 0;
        int right = arr.length-1;
       while (left <= right){
           int mid = (int)((left+right)/2);
           if (purpose>mid){
               left = mid+1;
           } else if (purpose<mid) {
               right =mid-1;
           }else {
               return mid;
           }
       }
       return -1;
    }
}

 1.6 数组排序(冒泡排序)

        算法思路：（ 假设排升序：）

        1. 将数组中相邻元素从前往后依次进行比较，如果前一个元素比后一个元素大，则交换，一趟下来后最大元素 就在数组的末尾

        2. 依次从上上述过程，直到数组中所有的元素都排列好

        代码eg：

import java.util.Arrays;
public class bubbleSort {
    public static void main(String[] args) {
        int[] arr = {12,34,45,67,78,89,9,7};
        bubbleSort(arr);
        System.out.println(Arrays.toString(arr));
    }

    public static void bubbleSort(int[] arr ){
        for (int i = 0; i < arr.length; i++) {
            for (int j = 1; j < arr.length-i; j++) {
                //arr.length-i目的是确认每一轮比较后的最后一个数字是当轮比较出的最大值
                //且比较核心是下标为j的数字
                if (arr[j-1] > arr[j]){
                    int temp = arr[j-1];
                    arr[j-1] = arr[j];
                    arr[j] = temp;
                }
            }
        }
    }
}

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

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

1 .7 数组逆序

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

        思路： 设定两个下标, 分别指向第一个元素和最后一个元素. 交换两个位置的元素. 然后让前一个下标自增, 后一个下标自减, 循环继续即可.

        代码eg：

import java.util.Arrays;
import java.util.Spliterator;

public class Reversr {
    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5,6,7,8,9,10};
        reverse(arr);
        System.out.println(Arrays.toString(arr));
    }
    public static void reverse(int[] arr ){
        int j = arr.length-1;
        for (int i = 0; i < arr.length-1; i++) {
            if (i < j){
                int temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;
                j--;
            }
        }
    }
}

ps：综上所述，以上是我对数组部分简单习题的理解，欢迎个位前辈来提出异议和讨论。