如何自定义工具类--＞一维和二维数组的搭配使用

咱们先看OneDimensionalArrayTools工具类：

package com.all.tools;

/*
 * Copyright (c) 2021. Lorem ipsum dolor sit amet, consectetur adipiscing elit.
 * Morbi non lorem porttitor neque feugiat blandit. Ut vitae ipsum eget quam lacinia accumsan.
 * Etiam sed turpis ac ipsum condimentum fringilla. Maecenas magna.
 * Proin dapibus sapien vel ante. Aliquam erat volutpat. Pellentesque sagittis ligula eget metus.
 * Vestibulum commodo. Ut rhoncus gravida arcu.
 */

import java.util.Random;

/**
 * @author Mark-Z
 * @version 1.0.1(一维int类型的数组工具完整版)
 * @date 2021-10-30
 */
public final class OneDimensionalArrayTools {
    static Random random;

    static {
        random = new Random();
    }

    private OneDimensionalArrayTools() {

    }

    /**
     * @param array 传入的数组地址
     * @return 将修改的数组的地址回传
     */
    //1.数组的随机赋值
    public static int[] assignment(int[] array) {
        for (int i = 0; i < array.length; i++) {
            array[i] = random.nextInt(30);
        }
        System.out.println("一维数组已完成随机赋值！！");
        return array;
    }

    //2.数组的反转
    public static String inversion(int[] array) {
        for (int i = 0; i < array.length / 2; i++) {
            int temp = array[i];
            array[i] = array[array.length - 1 - i];
            array[array.length - 1 - i] = temp;
        }
        return "一维数组已完成反转！！";
    }

    //3.数组的复制
    public static int[] copy(int[] array) {
        int[] array1 = new int[array.length];
        for (int i = 0; i < array.length; i++) {
            array1[i] = array[i];
        }
        System.out.println("一维数组已完成复制！！");
        return array1;
    }

    //4.数组的遍历
    public static String traverse(int[] array) {
        System.out.print("{");
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
            System.out.print(",");
        }
        System.out.print("}\t");
        return "一维数组已完成遍历！！";
    }

    //5.数组的排序(冒泡排序)
    public static int[] sequencing(int[] array) {
        for (int i = 0; i < array.length - 1; i++) {
            /*
            其中再次减i是保证下一大轮循环不去多余的比较
            提高for循环的运行效率
             */
            for (int j = 0; j < array.length - 1 - i; j++) {

                if (array[j] > array[j + 1]) {
                    int temp = array[j + 1];
                    array[j + 1] = array[j];
                    array[j] = temp;
                }
            }
        }
        return array;
    }

    //6.搜索数组中的元素
    public static int search(int[] array, int index) {
        for (int i = 0; i < array.length; i++) {
            if (index == array[i]) {
                return i;
            }
        }
        return -1;
    }

    //7.数组的元素最小值
    public static int getMin(int[] array) {
        int min = array[0];
        for (int i = 0; i < array.length; i++) {
            if (array[i] < min) {
                min = array[i];
            }
        }
        return min;
    }

    /*
    最小值和最大值都是通过循环更新的方式来求得的
     */
    //8.数组的元素最大值
    public static int getMax(int[] array) {
        int max = array[0];
        for (int i = 0; i < array.length; i++) {
            if (array[i] > max) {
                max = array[i];
            }
        }
        return max;
    }

    //9.数组元素的求和
    public static int getSummation(int[] array) {
        int sum = 0;
        for (int j = 0; j < array.length; j++) {
            sum += array[j];
        }
        return sum;
    }
}

然后是二维数组，在一维基础上扩展：

​
package com.all.tools;

/*
 * Copyright (c) 2021. Lorem ipsum dolor sit amet, consectetur adipiscing elit.
 * Morbi non lorem porttitor neque feugiat blandit. Ut vitae ipsum eget quam lacinia accumsan.
 * Etiam sed turpis ac ipsum condimentum fringilla. Maecenas magna.
 * Proin dapibus sapien vel ante. Aliquam erat volutpat. Pellentesque sagittis ligula eget metus.
 * Vestibulum commodo. Ut rhoncus gravida arcu.
 */

import java.util.Random;
import java.util.Scanner;

/**
 * @author Mark-Z
 * @version 1.0.0
 * @date 2021/11/4
 * @implNote 二维int类型的数组工具：<br>
 * --->实际上可以通过调用一维数组的各种功能来实现
 */
public final class TwoDimensionalArrayTools {
    static Random random = OneDimensionalArrayTools.random;
    static Scanner scanner = new Scanner(System.in);

    private TwoDimensionalArrayTools() {

    }

    /**
     * @param array 需要被随机赋值的数组
     * @return 回传随机赋值后的数组
     */
    //1.数组的随机赋值
    public static int[][] assignment(int[][] array) {
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                array[i][j] = random.nextInt(10);
            }
        }
        System.out.println("该二维数组赋值完成！！");
        return array;
    }

    /**
     * @param array 需要被遍历的数组
     * @return 回传遍历后的数组
     */
    //2.数组的遍历
    public static String traverse(int[][] array) {
        if (array != null) {
            for (int i = 0; i < array.length; i++) {
                System.out.print("{");
                for (int j = 0; j < array[i].length; j++) {
                    System.out.print(array[i][j]);
                    System.out.print(",");
                }
                System.out.print("}\t");
            }
            System.out.println("该二维数组遍历完成！！");
        } else {
            System.out.println("该数组不存在！！");
        }
        return "\n完成遍历";
    }

    //3.数组的复制

    /**
     * @param array1 被复制的数组(值不变)
     * @param array2 用来接受第一个参数的数据
     * @return 返回第二个参数的地址
     */
    public static int[][] copy(int[][] array1, int[][] array2) {
        for (int i = 0; i < array1.length; i++) {
            for (int j = 0; j < array1[i].length; j++) {
                array2[i][j] = array1[i][j];
            }
        }
        System.out.println("该二维数组复制完成！！");
        return array2;
    }

    /**
     * @param array 被反转的数组
     * @return 返回反转好的数组
     */
    //4.数组的反转
    public static String inversion(int[][] array) {
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length / 2; j++) {
                int temp = array[i][j];
                array[i][j] = array[i][array[i].length - 1 - j];
                array[i][array[i].length - 1 - j] = temp;
            }
        }
        return "该二维数组反转完成！！";
    }

    /**
     * @param array 被排序的数组
     * @return 返回排好序的数组
     */
    //5.数组的排序（冒泡排序：升序排列-->从小到大）
    //方式1：将该二维数组中的一维数组先抽出来排序，然后覆盖原先的地址
    //根据一维数组的个数来进行循环排序
    public static int[][] sequencing(int[][] array) {
        if (array.length == 0) {
            System.out.println("该二维数组为空!!!请传有效的数组，谢谢配合");
        } else {
            for (int i = 0; i < array.length; i++) {
                array[i] = OneDimensionalArrayTools.sequencing(array[i]);
            }
            System.out.println("该二维数组已完成排序！！");
        }
        return array;
    }
    //方式2：这种方法和上面一样，将已排序好的一维地址值覆盖原先的地址
    /*
        public static int[][] sequencing1(int[][] array) {
        for (int q = 0; q < array.length; q++) {

            for (int i = 0; i < array[q].length; i++) {

                for (int j = 0; j < array[q].length - 1 - i; j++) {

                    if (array[q][j] > array[q][j + 1]) {

                        int temp = array[q][j + 1];
                        array[q][j + 1] = array[q][j];
                        array[q][j] = temp;
                    }
                }
            }
            array[q]=array[q];
        }
        return array;
    }
     */

    /**
     * @param array 被搜索的数组
     * @param index 目标值
     */
    //6.搜索指定数组的目标值
    public static void search(int[][] array, int index) {
        int q = 0;
        for (int i = 0; i < array.length; i++) {
            if (OneDimensionalArrayTools.search(array[i], index) > 0 || OneDimensionalArrayTools.search(array[i], index) == 0) {
                int j = OneDimensionalArrayTools.search(array[i], index);
                if (q == 0) {
                    q++;
                    System.out.println("目标值：" + index +
                            "\t首次在该二维数组的第" + (i + 1) +
                            "个数组被找到！！ 且索引值为" + j);
                } else if (q > 0) {
                    q++;
                    System.out.println("目标值：" + index +
                            "\t第" + (q) + "次在该二维数组的第" + (i + 1) +
                            "个数组被找到！！ 且索引值为" + j);
                }
            }
        }
    }

    /**
     * @param array 被获取max和min的数组
     * @param index <br>
     *              1.输入-1为获取二维数组中所有的一维数组的max和min,<br>
     *              2.输入0及以上就是获取指定在二维数组中的一维数组的max和min.
     */
    //7.获取二维数组中的指定的数组的最大和最小值
    public static void getMaxAndMin(int[][] array, int index) {
        if (index < -1) {
            System.out.println("指令不明确！！请重新输入！！！");
        }
        if (index == -1) {
            for (int i = 0; i < array.length; i++) {
                int max = OneDimensionalArrayTools.getMax(array[i]);
                int min = OneDimensionalArrayTools.getMin(array[i]);
                System.out.println("该二维数组中，第" + (i + 1) + "个数组的最大值为：" + max + ",最小值为：" + min);
            }
            System.out.println("已完成获取！！！");
        } else if (index >= 0 && (index < array.length - 1)) {
            //取得指定数组的information
            int max = OneDimensionalArrayTools.getMax(array[index]);
            int min = OneDimensionalArrayTools.getMin(array[index]);
            System.out.println("该二维数组中，第" + (index + 1) + "个数组的最大值为：" + max + ",最小值为：" + min);
            System.out.println("已完成获取！！！");
        }
    }

    /**
     * @param array 被求和的二维数组
     * @param index <br>
     *              1.输入-1为获取二维数组中列出各一维数组元素的总和;<br>
     *              2.输入1为将所有二维数组中的一维数组的和相加;<br>
     *              3.输入0为获取指定在二维数组中的一维数组的总和--->需进行二次选择
     * @return 返回总和,如果是-99999则数字不在考虑范围
     */
    //8.二维数组中各一维数组的元素的求和
    public static int getSummation(int[][] array, int index) {
        int summation = 0;
        if (index < -1 || index > 1) {
            System.out.println("该指令不在考虑范围！！！");
            return -99999;
        } else {
            switch (index) {
                case -1 -> {
                    for (int i = 0; i < array.length; i++) {
                        summation = OneDimensionalArrayTools.getSummation(array[i]);
                    }
                    System.out.println("已完成求和！");
                    return summation;
                }
                case 0 -> {
                    System.out.print("请输入在该二维数组中需要被求和的数组(用下标来表示)： ");
                    int target = scanner.nextInt();
                    summation = OneDimensionalArrayTools.getSummation(array[target]);
                    System.out.println("已完成求和！");
                    return summation;
                }
                case 1 -> {
                    for (int i = 0; i < array.length; i++) {
                        summation +=OneDimensionalArrayTools.getSummation(array[i]);
                    }
                    System.out.println("已完成求和！");
                    return summation;
                }
                default -> throw new RuntimeException("指令不正确！！！");
            }
        }
    }
}


​

以上就是所有了。。。。。