JAVA中数组的基本操作.

目录：1.数组中两个元素的位置交换。

           2.数组自身的反转。

           3.删除数组中指定下标的元素。

           4.数组指定下标插入指定元素。

           5.找出数组中最大值索引。

           6.找出数组的最小值索引。

           7.合并两个有序的数组。

           8.部分填充数组。（交互）：部分填充的数组是具有未用于存储数据的索引的数组。数组的大小在初始化时设置，之后无法更改。因此，我们初始化一个数组，其大小足以容纳需要存储的最大数据量。

---

//数组相关的基本操作

import java.util.Arrays;

public class Array {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5, 6,0,0,0};
        int[] arr02 = {7,8,9};
        //arraySwap(arr,2,3);
        //reverse(arr,6);
        //addElement(arr, 1,8);
        //maxIndex(arr);
        //minIndex(arr);
        System.out.println(Arrays.toString(merge(arr,arr02)));

    }

    //数组元素的交换

    /**
     * @param arr:传入的数组
     * @param index_1:要交换的元素中两个索引中的其中的第一个
     * @param index_2:要交换的元素中两个索引中的其中的第二个
     */

    public static void arraySwap(int[] arr, int index_1, int index_2) {
        //在Java中，交换数组的两个元素位置，必须通过引用来交换。
        int temp;//这里的temp起到上述作用。
        temp = arr[index_1];
        arr[index_1] = arr[index_2];
        arr[index_2] = temp;
        System.out.println(Arrays.toString(arr));
    }

    //数组的反转

    /**
     * @param arr:原数组
     * @param length:数组的长度
     */
    public static void reverse(int[] arr, int length) {
        int temp;//该引用起到交换的作用。
        //在原数组中交换元素的位置：第一个元素与最后一个元素交换，第二个元素与最后一个元素交换，依此类推，直到结束。
        //例如，在数组[1,2,3，...，n-2，n-1，n]中，我们可以将1和n进行交换，2和n-1进行交换，3和n-2进行交换。
        for (int i = 0; i < length / 2; i++) {
            temp = arr[i];
            arr[i] = arr[length - i - 1];
            arr[length - i - 1] = temp;
        }
        System.out.println(Arrays.toString(arr));
    }

    //删除数组中指定的元素
    /**
     *
     * @param arr:原数组
     * @param index:删除元素的索引
     */
    public static void delElement(int[] arr, int index) {
        //创建一个新数组，用于存放操作后的数组。
        int [] arrs = new int[arr.length-1];
        // 判断删除位置是否存在于数组中
        if (index < 0 || index >= arr.length) {
            System.out.println("输入的下标不存在,请检查");
        } else {
            // 要删除元素位置开始往后元素依次向前移一位
            for (int i = index; i < arr.length - 1; i++) {
                arr[i] = arr[i + 1];
            }
            //将操作后原数组中的元素拷贝到新的数组中。
            for (int j = 0;j < arr.length-1;j++){
                arrs[j] = arr[j];
            }
            System.out.println(Arrays.toString(arrs));
        }
    }
    //在数组的指定下标插入元素
    /**
     *
     * @param arr:原数组
     * @param index:数组元素的索引
     * @param ele:要插入的元素
     */
     public static void addElement(int[] arr,int index,int ele){
         //创建一个新的数组，用于存放插入数据后的完整数据
         int [] arrs = new int[arr.length+1];
         //将原数组中的元素一次放入新数组中
         for (int j = 0;j < arrs.length-1;j++){
             arrs[j] = arr[j];
         }
         //插入数据
         for (int i = arrs.length-1; i > index ; i--) {
             arrs[i] = arrs[i-1];
             if (i == index + 1){
                 arrs[index] = ele;
             }
         }
         System.out.println(Arrays.toString(arrs));
     }
    //找出数组中最大值的索引
    public static void maxIndex (int[] arr) {
        int maxIndex = 0;
        // i 可以从1开始,不需要maxIndex和自己再比较一次
        for (int i = 1; i < arr.length; i++) {
            if (arr[i] > arr[maxIndex]){
                maxIndex = i;
            }
        }
        System.out.printf("最大的数为 : %d 下标为 : %d", arr[maxIndex] , maxIndex);
    }
    //找出数组中最小值的索引
    public static void minIndex (int[] arr) {
        int minIndex = 0;
        // i 可以从1开始,不需要maxIndex和自己再比较一次
        for (int i = 1; i < arr.length; i++) {
            if (arr[i] < arr[minIndex]){
                minIndex = i;
            }
        }
        System.out.printf("最小的数为 : %d 下标为 : %d", arr[minIndex] , minIndex);
    }

    //合并两个有序数组(该方法效率不高。运用双指针算法解决(效率较高))
    public static int[] merge(int[]arr1,int[]arr2){
        for (int i = 0; i < arr2.length; i++) {
            arr1[6+i] = arr2[i];//arr1[6+i]从要拼接的索引开始，这里演示的索引为6.
        }
        return arr1;
    }
}

下面将实现部分填充数组。

import java.util.Scanner;

//部分填充数组

public class PartiallyFillArray {
    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        System.out.println("请开始填充数组，-1表示退出。");

        boolean done = false;//boolean标记，用于跳出循环，结束操作。
        int currentSize = 0;//数组现在的初始容量设置为0。
        final int LENGTH = 100;//数组的最大容量假设为100。
        int[] arr = new int[LENGTH];//创建容量为100的数组。

        while (!done && currentSize < LENGTH){
            int num = s.nextInt();
            if (num == -1){
                done = true;//跳出循环，结束操作。
            }
            else{
                arr[currentSize] = num;
                currentSize++;
            }
        }
        System.out.println("您填充的数组元素为:");
        for (int i = 0; i < currentSize; i++) {
            System.out.println(arr[i]+" ");
        }
    }
}