Как я могу оптимизировать два похожих метода?

Question

Java 7 не поддерживает лямбда-выражения. Как я могу оптимизировать два аналогичных метода «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); 
    } 
} 

Answer 1

Меньше кода? Вы можете заменить эти методы следующими способами:

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

Хотя это предполагает, что T реализует сравнимые. Как Мендоса Луиджи указывает: вы можете также реализовать компаратор и использовать его с помощью другой формы мин/макс, если он не делает:

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

Answer 2

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

Answer 3

Я думаю, что ваше использование рекурсии не очень эффективно. Этот тип рекурсии и использование большого количества памяти стека. Также каждая итерация вызовет дополнительное создание 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 
} 

и наоборот.