Get a {@link Collector} that calculates the <code>MIN()</code> function.
183755
public static <T extends Comparable<? super T>> Collector<T, ?, Optional<T>> min() {
        return minBy(t -> t, naturalOrder());
    }
1153214
public synchronized int getPoolMinimum(PoolInfo poolInfo, ResourceType type) {
    Integer min = (typePoolInfoToMin == null) ? null :
        typePoolInfoToMin.get(type, poolInfo);
    return min == null ? 0 : min;
  }
729271
public static <T, U extends Comparable<? super U>> Collector<T, ?, Optional<T>> minBy(Function<? super T, ? extends U> function) {
        return minBy(function, naturalOrder());
    }
664840
public static <T> Collector<T, ?, List<T>> last(final int n) {
        N.checkArgNotNegative(n, "n");

        final Supplier<Deque<T>> supplier = new Supplier<Deque<T>>() {
            @Override
            public Deque<T> get() {
                return n <= 1024 ? new ArrayDeque<T>(n) : new LinkedList<T>();
            }
        };

        final BiConsumer<Deque<T>, T> accumulator = new BiConsumer<Deque<T>, T>() {
            @Override
            public void accept(Deque<T> dqueue, T t) {
                if (n > 0) {
                    if (dqueue.size() >= n) {
                        dqueue.pollFirst();
                    }

                    dqueue.offerLast(t);
                }
            }
        };

        final BinaryOperator<Deque<T>> combiner = new BinaryOperator<Deque<T>>() {
            @Override
            public Deque<T> apply(Deque<T> a, Deque<T> b) {
                if (N.notNullOrEmpty(a) && N.notNullOrEmpty(b)) {
                    throw new UnsupportedOperationException("The 'first' and 'last' Collector only can be used in sequential stream");
                }

                while (b.size() < n && !a.isEmpty()) {
                    b.addFirst(a.pollLast());
                }

                return b;
            }
        };

        final Function<Deque<T>, List<T>> finisher = new Function<Deque<T>, List<T>>() {
            @Override
            public List<T> apply(Deque<T> dqueue) {
                return new ArrayList<>(dqueue);
            }
        };

        return new CollectorImpl<>(supplier, accumulator, combiner, finisher, CH_NOID);
    }
219387
public int min() {
    int min = Integer.MAX_VALUE;
    for (E key : map.keySet()) {
      min = Math.min(min, getIntCount(key));
    }
    return min;
  }
1364239
@Pure
	public static int min(int... values) {
		if (values == null || values.length == 0) {
			return 0;
		}
		int min = values[0];
		for (final int v : values) {
			if (v < min) {
				min = v;
			}
		}
		return min;
	}
431762
public static <T> Collector<T, ?, Optional<Long>> rank(T value, Comparator<? super T> comparator) {
        return rankBy(value, t -> t, comparator);
    }
395093
function MinFunction(win) { 
  var self = this, r;
  self.win = win;
  self.name = "min";
  self.type = "ordered_reverse";
  self.init = function() { r = null; };
  self.accumulate = function(v) { if (v == null) { return; } if (r == null) { r = v; return; } r = (v < r) ? v : r; };
  self.compensate = function(v) { r = self.win.min(); };
  self.emit = function()  { return r; };
  self.make = function(win) { return new MinFunction(win); };
}
770863
@SuppressWarnings({ "rawtypes", "unchecked" })
    public static <T, U> Collector<T, ?, Optional<U>> avg(Function<? super T, ? extends U> function) {
        return Collector.of(
            () -> (Sum<U>[]) new Sum[1],
            (s, v) -> {
                if (s[0] == null)
                    s[0] = Sum.create(function.apply(v));
                else
                    s[0].add(function.apply(v));
            },
            (s1, s2) -> {
                s1[0].add(s2[0]);
                return s1;
            },
            s -> s[0] == null ? Optional.empty() : Optional.of(s[0].avg())
        );
    }
1274154
public static <T> T min(T lhs, T rhs, Comparator<T> comparator) {
        return BinaryOperator.minBy(comparator).apply(lhs, rhs);
    }
348060
public static double min(DoubleTuple t)
    {
        return DoubleTupleFunctions.reduce(
            t, Double.POSITIVE_INFINITY, Math::min);
    }
1255212
public static <T, U> Collector<T, ?, Seq<U>> minAll(Function<? super T, ? extends U> function, Comparator<? super U> comparator) {
        return collectingAndThen(minAllBy(function, comparator), t -> t.map(function));
    }
724004
public BoundedAssertion getMin()
    {
    ICondition min = null;
    Iterator<ICondition> conditions = getConditions();
    for( int i = 0; i < 1; i++) min = conditions.next();
    return (BoundedAssertion) min;
    }
187208
public T min() {
        if (sum == 0)
            return null;
        int minCount = Integer.MAX_VALUE;
        int minIndex = -1;
        for (TIntIntIterator it = indexToCount.iterator(); it.hasNext(); ) {
            it.advance();
            if (it.value() < minCount) {
                minIndex = it.key();
                minCount = it.value();
            }
        }
        return objectIndices.lookup(minIndex);
    }
698438
public static <T extends Comparable<? super T>> Collector<T, ?, Seq<T>> maxAll() {
        return maxAllBy(t -> t, naturalOrder());
    }
120769
public final Object getMin()
    throws NoSuchElementException
  {
    PriorityQueueNode max = null;
    if (size == 0)
      throw new NoSuchElementException();
        
    max = elements[0];
    setElement(elements[--size], 0);
    heapify(0);

    return max.value;
  }
623436
function min(keySelector, comparer) {
  let itComparer = typeof comparer === 'function' ? comparer : util.defaultComparer;
  let itKeySelector = typeof keySelector === 'function' ? keySelector : (i) => i;

  let minimum = this.firstOrDefault();

  for (let item of this) {
    minimum = itComparer(itKeySelector(item), itKeySelector(minimum)) < 0 ? item : minimum;
  }

  return minimum;
}