org.jenetics.stat

Class MinMax<C>

java.lang.Object

org.jenetics.stat.MinMax<C>

All Implemented Interfaces:

Consumer<C>

public final class MinMax<C>
extends Object
implements Consumer<C>

This consumer class is used for calculating the min and max value according to the given Comparator.

This class is designed to work with (though does not require) streams. For example, you can compute minimum and maximum values with:

final Stream<Integer> stream = ... final MinMax<Integer> minMax = stream.collect( MinMax::of, MinMax::accept, MinMax::combine );

Implementation note: This implementation is not thread safe. However, it is safe to use on a parallel stream, because the parallel implementation of Stream.collect()provides the necessary partitioning, isolation, and merging of results for safe and efficient parallel execution.

Since:

3.0

Version:

3.0

Author:

Franz Wilhelmstötter

Method Summary

Modifier and Type	Method and Description
void	accept(C object) Accept the element for min-max calculation.
MinMax<C>	combine(MinMax<C> other) Combine two MinMax objects.
long	getCount() Returns the count of values recorded.
C	getMax() Return the current maximal object or null if no element has been accepted yet.
C	getMin() Return the current minimal object or null if no element has been accepted yet.
static <T> T	max(Comparator<? super T> comp, T a, T b) Return the maximum of two values, according the given comparator.
static <T> T	min(Comparator<? super T> comp, T a, T b) Return the minimum of two values, according the given comparator.
static <C extends Comparable<? super C>> MinMax<C>	of() Create a new MinMax consumer.
static <T> MinMax<T>	of(Comparator<? super T> comparator) Create a new MinMax consumer with the given Comparator.
static <C extends Comparable<? super C>> Collector<C,?,MinMax<C>>	toMinMax() Return a Collector which calculates the minimum and maximum value.
static <T> Collector<T,?,MinMax<T>>	toMinMax(Comparator<? super T> comparator) Return a Collector which calculates the minimum and maximum value.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface java.util.function.Consumer

andThen

Method Detail

accept

public void accept(C object)

Accept the element for min-max calculation.

Specified by:

accept in interface Consumer<C>

Parameters:

object - the element to use for min-max calculation

combine

public MinMax<C> combine(MinMax<C> other)

Combine two MinMax objects.

Parameters:

other - the other MinMax object to combine

Returns:

this

Throws:

NullPointerException - if the other object is null.

getMin

public C getMin()

Return the current minimal object or null if no element has been accepted yet.

Returns:

the current minimal object

getMax

public C getMax()

Return the current maximal object or null if no element has been accepted yet.

Returns:

the current maximal object

getCount

public long getCount()

Returns the count of values recorded.

Returns:

the count of recorded values

min

public static <T> T min(Comparator<? super T> comp,
                        T a,
                        T b)

Return the minimum of two values, according the given comparator. null values are allowed.

Type Parameters:

T - the type of the compared objects

Parameters:

comp - the comparator used for determining the min value

a - the first value to compare

b - the second value to compare

Returns:

the minimum value, or null if both values are null. If only one value is null, the non null values is returned.

max

public static <T> T max(Comparator<? super T> comp,
                        T a,
                        T b)

Return the maximum of two values, according the given comparator. null values are allowed.

Type Parameters:

T - the type of the compared objects

Parameters:

comp - the comparator used for determining the max value

a - the first value to compare

b - the second value to compare

Returns:

the maximum value, or null if both values are null. If only one value is null, the non null values is returned.

toMinMax

public static <T> Collector<T,?,MinMax<T>> toMinMax(Comparator<? super T> comparator)

Return a Collector which calculates the minimum and maximum value. The given comparator is used for comparing two objects.

final Comparator<SomeObject> comparator = ... final Stream<SomeObject> stream = ... final MinMax<SomeObject> moments = stream .collect(doubleMoments.toMinMax(comparator));

Type Parameters:

T - the type of the input elements

Parameters:

comparator - the Comparator to use

Returns:

a Collector implementing the min-max reduction

Throws:

NullPointerException - if the given mapper is null

toMinMax

public static <C extends Comparable<? super C>> Collector<C,?,MinMax<C>> toMinMax()

Return a Collector which calculates the minimum and maximum value. The reducing objects must be comparable.

final Stream<SomeObject> stream = ... final MinMax<SomeObject> moments = stream .collect(doubleMoments.toMinMax(comparator));

Type Parameters:

C - the type of the input elements

Returns:

a Collector implementing the min-max reduction

Throws:

NullPointerException - if the given mapper is null

of

public static <T> MinMax<T> of(Comparator<? super T> comparator)

Create a new MinMax consumer with the given Comparator.

Type Parameters:

T - the element type

Parameters:

comparator - the comparator used for comparing two elements

Returns:

a new MinMax consumer

Throws:

NullPointerException - if the comparator is null.

of

public static <C extends Comparable<? super C>> MinMax<C> of()

Create a new MinMax consumer.

Type Parameters:

C - the element type

Returns:

a new MinMax consumer