一、Java 数组的使用

一、数组的使用 Java

要求

请开发一个类包含如下功能的静态方法：

1.1打印一个整型数组。
1.2将一个整型数组反序排列。
1.3求一个整型数组元素中的最大值。
1.4将一个整型数组每一个元素向前（向标号小的方向）移动一个位置，第一个元素移到最后一个位置。
1.5求一个整型数组各元素之和。
1.6编写一个方法，其功能是对一个整型数组升序排列（请采用冒泡算法）。
1.7用选择法对若干个数排序（由大到小）。
1.8用插入法对若干个数排序（由大到小）。
1.9用折半查找法在一组排好序(递增有序或递减有序)的值中查找某个数据。
1.10求一个整型数组元素中最接近其平均值的整数。
1.11实现一个数组复制方法，参数为:源数组、起始下标、复制长度，返回值为新数组

代码如下

import java.util.*;

public class Array {
    private int length;
    private int[] a;

    private Array(int[] a) {
        this.a = a;
        this.length = a.length;
    }

    //打印一个整型数组
    private void Printarray() {
        if (a == null || a.length == 0) {
            System.out.println("输入的数组不合法！");
        }
        for (int i : a) {
            System.out.print(i + " ");
        }
        System.out.println();
    }

    //将一个整型数组反序排列
    private void Reversearrangement(int[] a) {
        if (a == null || a.length == 0) {
            System.out.println("输入的数组不合法！");
        }
        for (int i = a.length - 1; i >= 0; i--) {
            System.out.print(a[i] + " ");
        }
        System.out.println();
    }

    //求一个整型数组元素中的最大值,最小值
    private void Arraymax(int[] a) {
        if (a == null || a.length == 0) {
            System.out.println("输入的数组不合法！");
        }
        int max, min;
        max = min = a[0];
        for (int i = 0; i < a.length; i++) {
            if (a[i] > max) {
                max = a[i];
            }
            if (a[i] < min) {
                min = a[i];
            }
        }
        System.out.println("最大值为：" + max + "  最小值为：" + min);
    }

    //将一个整型数组每一个元素向前（向标号小的方向）移动一个位置，第一个元素移到最后一个位置
    private void Arraymove(int[] a) {
        if (a == null || a.length == 0) {
            System.out.println("输入的数组不合法！");
        }
        int j = a[0];
        for (int i = 0; i < a.length - 1; i++) {
            a[i] = a[i + 1];
        }
        for (int i = 0; i < a.length; i++) {
            a[length - 1] = j;
            System.out.print(a[i] + " ");
        }
        System.out.println();
    }

    //求一个整型数组各元素之和
    private int Arraysum(int[] a) {
        if (a == null || a.length == 0) {
            System.out.println("输入的数组不合法！");
        }
        int i, sum = 0;
        for (i = 0; i < a.length; i++) {
            sum = sum + a[i];
        }
        return sum;
    }

    //编写一个方法，其功能是对一个整型数组升序排列（请采用冒泡算法）
    private void Bubblesort(int[] a) {
        if (a == null || a.length == 0) {
            System.out.println("输入的数组不合法！");
        }
        for (int i = 0; i < a.length - 1; i++)
            for (int j = 0; j < a.length - 1 - i; j++)
                if (a[j] > a[j + 1]) {
                    int x = a[j];
                    a[j] = a[j + 1];
                    a[j + 1] = x;
                }
        for (int i : a) {
            System.out.print(i + " ");
        }
        System.out.println();
    }

    //用选择法对若干个数排序（由大到小）
    private void Selectsort(int[] a) {
        if (a == null || a.length == 0) {
            System.out.println("输入的数组不合法！");
        }
        int i, j, t;
        for (i = 0; i < a.length - 1; i++) {
            for (j = i + 1; j < a.length; j++) {
                if (a[i] < a[j]) {
                    t = a[i];
                    a[i] = a[j];
                    a[j] = t;
                }
            }
        }
        for (i = 0; i < a.length; i++) {
            System.out.print(a[i] + " ");
        }
        System.out.println();
    }

    //用插入法对若干个数排序（由小到大）
    private void Insertsort(int[] a) {
        if (a == null || a.length == 0) {
            System.out.println("输入的数组不合法！");
        }
        for (int i = 0; i < a.length - 1; i++) {
            int j = a[i + 1];
            int k = i;
            while (k >= 0 && j < a[k]) {
                a[k + 1] = a[k];
                k--;
            }
            a[k + 1] = j;
        }
        for (int i = 0; i < a.length; i++) {
            System.out.print(a[i] + " ");
        }
        System.out.println();
    }

    //用折半查找法在一组排好序(递增有序或递减有序)的值中查找某个数据
    private int HalfSearch(int[] a, int m) {
        if (a == null || a.length == 0) {
            System.out.println("输入的数组不合法！");
        }
        int i, j, k;
        j = 0;
        k = a.length - 1;
        while (j <= k) {
            i = (j + k) / 2;
            if (m < a[i])
                k = i - 1;
            else if (m > a[i])
                j = i + 1;
            else
                return i;
        }
        return -1;
    }

    //求一个整型数组元素中最接近其平均值的整数
    private int Closeaverage(int[] a) {
        if (a == null || a.length == 0) {
            System.out.println("输入的数组不合法！");
        }
        int i, sum = 0;
        for (i = 0; i < a.length; i++) {
            sum = sum + a[i];
        }
        int y = sum / a.length;
        if (a == null) {
            return -1;
        }
        if (a.length == 1) {
            return a[0];
        }
        int k = -1;
        for (int j = 0; j < a.length; j++) {
            if (a[j] > y) {
                k = j;
                break;
            } else if (a[j] == y) {
                return y;
            }
        }
        int z;
        if (k == -1) {
            return a[a.length - 1];
        } else if (k == 0) {
            return a[0];
        } else {
            z = y - a[k - 1] < a[k] - y ? a[k - 1] : a[k];
        }
        return z;
    }

    //实现一个数组复制方法，参数为:源数组、起始下标、复制长度，返回值为新数组
    private int[] Copyarray(int[] a, int e, int f) {
        if (a == null || a.length == 0) {
            System.out.println("输入的数组不合法！");
        }
        if (e < 0 || e > a.length - 1) {
            System.out.println("输入的起始位置不合法！");
        }
        if (f < 1 || f > a.length - e) {
            System.out.println("输入的复制长度不合法！");
        }
        int[] arr = new int[f];
        for (int i = 0, j = e; i < arr.length; i++, j++) {
            arr[i] = a[j];
        }
        return arr;
    }
    
    //主函数
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        System.out.print("请输入你想定义的数组长度：");
        int n = input.nextInt();
        int[] a = new int[n];
        System.out.print("请输入与定义的数组长度相等的正整数(若输入的数超过，则只会取与数组长度相等的数)：");
        Array ll = new Array(a);
        for (int i = 0; i < a.length; i++) {
            a[i] = input.nextInt();
        }
        System.out.print("打印出的数组为：");
        ll.Printarray();
        System.out.print("数组的反序排列为：");
        ll.Reversearrangement(a);
        System.out.print("整型数组元素中的");
        ll.Arraymax(a);
        System.out.print("数组移动后的新数组为：");
        ll.Arraymove(a);
        System.out.print("数组中的元素之和为：");
        int b = ll.Arraysum(a);
        System.out.print(b + "\n");
        System.out.print("冒泡排序的结果为(升序)：");
        ll.Bubblesort(a);
        System.out.print("选择排序的结果为(降序)：");
        ll.Selectsort(a);
        System.out.print("插入排序的结果为(升序)：");
        ll.Insertsort(a);
        System.out.print("请输入你想要查找的数字：");
        int c = input.nextInt();
        System.out.print("查找的数字的位置为(不在数组的元素输出的位置为-1)：");
        int d = ll.HalfSearch(a, c);
        System.out.print(d);
        System.out.println();
        System.out.print("距离平均值最近的数为：");
        int e = ll.Closeaverage(a);
        System.out.print(e);
        System.out.println();
        System.out.print("请输入你想要复制的起始位置：");
        int f = input.nextInt();
        System.out.print("请输入你想要复制的长度：");
        int g = input.nextInt();
        System.out.print("复制完成的数组为：");
        int arr [] =  ll.Copyarray(a, f,g);
        System.out.print(Arrays.toString(arr));
    }

}

运行结果

示例：

请输入你想定义的数组长度：5
请输入与定义的数组长度相等的正整数(若输入的数超过，则只会取与数组长度相等的数)：1 3 0 5 9
打印出的数组为：1 3 0 5 9 
数组的反序排列为：9 5 0 3 1 
整型数组元素中的最大值为：9  最小值为：0
数组移动后的新数组为：3 0 5 9 1 
数组中的元素之和为：18
冒泡排序的结果为(升序)：0 1 3 5 9 
选择排序的结果为(降序)：9 5 3 1 0 
插入排序的结果为(升序)：0 1 3 5 9 
请输入你想要查找的数字：3
查找的数字的位置为(不在数组的元素输出的位置为-1)：2
距离平均值最近的数为：3
请输入你想要复制的起始位置：2
请输入你想要复制的长度：2
复制完成的数组为：[3, 5]