需求
实现用于同时返回数组最大值和最小值的类
实现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());