Java中级——返回两个变量

需求

实现用于同时返回数组最大值和最小值的类

实现1

MinMax有两个方法，分别获取数组的最大值和最小值

class MinMax {

    public static int getMin(int[] array) {
        int min = Integer.MAX_VALUE;
        for (int i : array) {
            if (i < min) {
                min = i;
            }
        }
        return min;
    }

    public static int getMax(int[] array) {
        int max = Integer.MIN_VALUE;
        for (int i : array) {
            if (i > max) {
                max = i;
            }
        }
        return max;
    }
}

调用过程

int[] array = new int[]{1, 2, 3};
System.out.println(MinMax.getMin(array) + MinMax.getMax(array));

• problem1：当要同时找到最小值和最大值时，需要对数组循环两遍

实现2

只需循环一遍即可获取最大值和最小值

class MinMax {

    private int min = Integer.MAX_VALUE;
    private int max = Integer.MIN_VALUE;

    public void getMixAndMax(int[] array) {

        for (int i : array) {
            if (i < min) {
                min = i;
            }
            if (i > max) {
                max = i;
            }
        }
    }

    public int getMin() {
        return min;
    }

    public int getMax() {
        return max;
    }
}

调用过程

int[] array = new int[]{1, 2, 3};
MinMax minMax = new MinMax();
minMax.getMixAndMax(array);
System.out.println(minMax.getMin() + minMax.getMax());

• problem1：min和max需从局部变量升为域，其生命周期变大
• problem2：需要额外的get方法返回min和max的值，因为一个方法不能有两个返回值
• problem3：失去了静态调用

实现3

在2的基础上，解决problem3，加上static避免创建对象

class MinMax {

    private static int min = Integer.MAX_VALUE;
    private static int max = Integer.MIN_VALUE;

    public static void getMixAndMax(int[] array) {

        for (int i : array) {
            if (i < min) {
                min = i;
            }
            if (i > max) {
                max = i;
            }
        }
    }

    public static int getMin() {
        return min;
    }

    public static int getMax() {
        return max;
    }
}

调用过程

int[] array = new int[]{1, 2, 3};
MinMax.getMixAndMax(array);
System.out.println(MinMax.getMin() + MinMax.getMax());

不但没解决problem1和2，反而新增问题

• problem1：虽然实现了getMixAndMax()的静态调用，但静态方法只能调用静态域，min和max需从域升为静态域，其生命周期再次变大
• problem2：为了不创建对象仍能返回静态域min和max，get方法从普通方法升为静态方法
• problem3：用户可能在getMin()和getMax()前未调用getMixAndMax()排序，导致得到错误的原始值

实现4（最佳实现1）

为了解决上述所有问题，引进泛型类Pair实现返回两个变量，将min和max的维护转移到Pair类，同时Pair以后还可被其他数据类型使用

class Pair<T> {
    private T min;
    private T max;

    public Pair(T min, T max) {
        this.min = min;
        this.max = max;
    }

    public T getMin() {
        return min;
    }

    public T getMax() {
        return max;
    }
}

class MinMax {

    public static Pair<Integer> getMixAndMax(int[] array) {
        int min = Integer.MAX_VALUE;
        int max = Integer.MIN_VALUE;
        for (int i : array) {
            if (i < min) {
                min = i;
            }
            if (i > max) {
                max = i;
            }
        }
        return new Pair<Integer>(min, max);
    }
}

调用过程

int[] array = new int[]{1, 2, 3};
Pair<Integer> pair = MinMax.getMixAndMax(array);
System.out.println(pair.getMin() + pair.getMax());

实现5（最佳实现2）

若Pair类只在某一数据类型中使用，避免类过多，可让其成为MinMax的内部类，因为内部类对象是在静态方法中构造的，故需让其成为静态内部类

class MinMax {
    public static class Pair {
        private int min;
        private int max;

        public Pair(int min, int max) {
            this.min = min;
            this.max = max;
        }

        public int getMin() {
            return min;
        }

        public int getMax() {
            return max;
        }
    }

    public static Pair getMixAndMax(int[] array) {
        int min = Integer.MAX_VALUE;
        int max = Integer.MIN_VALUE;
        for (int i : array) {
            if (i < min) {
                min = i;
            }
            if (i > max) {
                max = i;
            }
        }
        return new Pair(min, max);
    }
}

调用过程

int[] array = new int[]{1, 2, 3};
MinMax.Pair pair = MinMax.getMixAndMax(array);
System.out.println(pair.getMin() + pair.getMax());