Java 如何优化两种类似的方法？

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);
    }
}

package.com.example；
导入java.util.ArrayList；
导入java.util.List；
公共类极小值{
私有列表lst=null；
公共最小最大值（列表com）
{
this.lst=com；
}
公共对GetMinMaxOfList（）
{
返回GetMinMaxOfList（this.lst）；
}
私有对GetMinMaxOfList（列表）
{
if（list==null | | list.size（）==1）
返回null；
//Pair minMax=新的Pair（）；
T最小值，最大值；
if（list.size（）==2）
{
if（list.get（0）.compareTo（list.get（1））<0
{
min=list.get（0）；
max=list.get（1）；
返回新对（最小值、最大值）；
}
}
//T sentry=list.get（0）；
min=GetMinOfList（列表）；
max=GetMaxOfList（列表）；
返回新对（最小值、最大值）；
}
私人T GetMinOfList（列表列表）
{
T sentry=littleList.get（0）；
if（littleList.size（）==1）
返回哨兵；
List nextLittle=新阵列列表（1）；
对于（T:littleList）
{
如果（t.compareTo（哨兵）<0）
下一小部分添加（t）；
}
if（nextLittle.size（）==0）
返回哨兵；
返回GetMinOfList（nextLittle）；
}
私有T GetMaxOfList（列表lagerList）
{
T sentry=lagerList.get（0）；
if（lagerList.size（）==1）
返回哨兵；
List nextLarge=新阵列列表（1）；
for（T:lagerList）
{
如果（t.compareTo（哨兵）>0）
下一步增加（t）；
}
如果（nextLarge.size（）==0）
返回哨兵；
返回GetMaxOfList（nextLarge）；
}
}

代码少了吗？您可以使用以下方法替换这些方法：

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

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

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

---

更少的代码？您可以使用以下方法替换这些方法：

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

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

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

Java提供，您可以按如下方式实现它

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)
} 

私有对GetMinMaxOfList（列表）{
返回新的对（getMinOfList（list）、getMaxOfList（list））；
}
私人T getMinOfList（列表）{
return Collections.min（列表）
}
私有T getMaxOfList（列表）{
返回集合.max（列表）
} 

Java提供了一种可按如下方式实现的方法

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)
} 

私有对GetMinMaxOfList（列表）{
返回新的对（getMinOfList（list）、getMaxOfList（list））；
}
私人T getMinOfList（列表）{
return Collections.min（列表）
}
私有T getMaxOfList（列表）{
返回集合.max（列表）
} 

我认为您使用递归的效率不高。这种类型的递归会消耗大量堆栈内存。此外，每次迭代都会触发额外的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
}

private T GetMaxOfList（列表littleList）{
T=null；
对于（T元素：小列表）{
if（最小==null）{
最小=元素；
}else if（最小。与（元素）>0相比）{
最小=元素；
}
}
返回最小值
}

---

反之亦然。

我认为您使用递归的效率不高。这种类型的递归会消耗大量堆栈内存。此外，每次迭代都会触发额外的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
}

private T GetMaxOfList（列表littleList）{
T=null；
对于（T元素：小列表）{
if（最小==null）{
最小=元素；
}else if（最小。与（元素）>0相比）{
最小=元素；
}
}
返回最小值
}

---

反之亦然。

你所说的优化是指更好的性能还是更少的代码？哇。我从没想过我会看到一个O（n^2）递归的最小或最大函数。可能是@Aurand的复制品，以前从未接受过采访？我看过面试候选人的

O（n^3）

array反向算法。你说的优化是指性能更好还是代码更少？哇。我从没想过我会看到一个O（n^2）递归的最小或最大函数。可能是@Aurand的复制品，以前从未接受过采访？我看过面试候选人的

O（n^3）

数组反向算法。可能你还需要实现一个匿名

比较器。不过，这是完成任务的较小代码。可能您还需要实现一个匿名
比较器。不过，这是完成任务的较小代码。