0

Java 7 不支持 lambda 表达式。如何优化两个类似的方法“GetMinOfList”和“GetMaxOfList”？

package com.example;

import java.util.ArrayList;
import java.util.List;

public class MinMax<T extends Comparable<T>> {

    private List<T> lst = null;
    public MinMax(List<T> com)
    {
        this.lst = com;
    }

    public Pair<T, T> GetMinMaxOfList()
    {
        return GetMinMaxOfList(this.lst);
    }

    private Pair<T, T> GetMinMaxOfList(List<T> list)
    {
        if(list == null || list.size() == 1)
            return null;
        //Pair<T, T>  minMax = new Pair<T, T>();
        T min, max;
        if(list.size() == 2)
        {
            if(list.get(0).compareTo(list.get(1)) < 0)
            {
                min = list.get(0);
                max = list.get(1);
                return new Pair<T,T>(min, max);
            }
        }
        //T sentry = list.get(0);
        min = GetMinOfList(list);
        max = GetMaxOfList(list);
        return new Pair<T, T>(min, max);
    }

    private T GetMinOfList(List<T> littleList)
    {
        T sentry = littleList.get(0);
        if(littleList.size() == 1)
            return sentry;

        List<T> nextLittle = new ArrayList<T>(1);
        for(T t: littleList)
        {
            if(t.compareTo(sentry) < 0)
                nextLittle.add(t);
        }
        if(nextLittle.size() == 0)
            return sentry;
        return GetMinOfList(nextLittle);
    }

    private T GetMaxOfList(List<T> lagerList)
    {
        T sentry = lagerList.get(0);
        if(lagerList.size() == 1)
            return sentry;

        List<T> nextLarge = new ArrayList<T>(1);
        for(T t: lagerList)
        {
            if(t.compareTo(sentry) > 0)
                nextLarge.add(t);
        }
        if(nextLarge.size() == 0)
            return sentry;
        return GetMaxOfList(nextLarge);
    }
}
4

3 回答 3

4

代码少？您可以将这些方法替换为：

 min = Collections.min(list); 
 max = Collections.max(list);

尽管假设 T 实现了 Comparable。正如 Luiggi Mendoza 指出的那样：您还可以实现一个比较器并通过其他形式的 min/max 使用它，如果它没有：

 min = Collections.min(list, comparator); 
 max = Collections.max(list, comparator);
于 2013-09-26T03:36:22.063 回答
1

Java 提供Collections.min(Comparables)和Collections.max(Comparables)，您可以按如下方式实现它们。

private Pair<T, T> GetMinMaxOfList(List<T> list) {

        return new Pair<T, T>(getMinOfList(list), getMaxOfList(list));
}


private T getMinOfList(List<T> list) {
      return Collections.min(list)
}


private T getMaxOfList(List<T> list) {
      return Collections.max(list)
}
于 2013-09-26T03:37:27.473 回答
1

我认为您对递归的使用不是很有效。这种类型的递归会占用大量的堆栈内存。此外，每次迭代都会触发额外的 ArrayList 创建。如果下一个元素大于/小于，请尝试简单地遍历给定列表并设置一个局部变量，具体取决于您所在的函数

private T GetMaxOfList(List<T> littleList){
    T smallest = null;
    for(T element : littleList){
        if(smallest == null){
            smallest = element;
        } else if (smallest.compareTo(element) > 0) {
            smallest = element;
        }
    }
    return smallest
}

反之亦然。

于 2013-09-26T03:39:47.210 回答