Min (Apache Beam 2.49.0)

java.lang.Object
- org.apache.beam.sdk.transforms.Min

```
public class Min
extends java.lang.Object
```
PTransforms for computing the minimum of the elements in a PCollection, or the minimum of the values associated with each key in a PCollection of KVs.
Example 1: get the minimum of a PCollection of Doubles.
```
 PCollection<Double> input = ...;
 PCollection<Double> min = input.apply(Min.doublesGlobally());
 
```
Example 2: calculate the minimum of the Integers associated with each unique key (which is of type String).
```
 PCollection<KV<String, Integer>> input = ...;
 PCollection<KV<String, Integer>> minPerKey = input
     .apply(Min.<String>integersPerKey());
 
```

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static Combine.Globally<java.lang.Double,java.lang.Double>`	`doublesGlobally()` Returns a `PTransform` that takes an input `PCollection<Double>` and returns a `PCollection<Double>` whose contents is the minimum of the input `PCollection`'s elements, or `Double.POSITIVE_INFINITY` if there are no elements.
`static <K> Combine.PerKey<K,java.lang.Double,java.lang.Double>`	`doublesPerKey()` Returns a `PTransform` that takes an input `PCollection<KV<K, Double>>` and returns a `PCollection<KV<K, Double>>` that contains an output element mapping each distinct key in the input `PCollection` to the minimum of the values associated with that key in the input `PCollection`.
`static <T extends java.lang.Comparable<? super T>> Combine.Globally<T,T>`	`globally()` Returns a `PTransform` that takes an input `PCollection<T>` and returns a `PCollection<T>` whose contents is the minimum according to the natural ordering of `T` of the input `PCollection`'s elements, or `null` if there are no elements.
`static <T,ComparatorT extends java.util.Comparator<? super T> & java.io.Serializable> Combine.Globally<T,T>`	`globally(ComparatorT comparator)` Returns a `PTransform` that takes an input `PCollection<T>` and returns a `PCollection<T>` whose contents is the minimum of the input `PCollection`'s elements, or `null` if there are no elements.
`static Combine.Globally<java.lang.Integer,java.lang.Integer>`	`integersGlobally()` Returns a `PTransform` that takes an input `PCollection<Integer>` and returns a `PCollection<Integer>` whose contents is a single value that is the minimum of the input `PCollection`'s elements, or `Integer.MAX_VALUE` if there are no elements.
`static <K> Combine.PerKey<K,java.lang.Integer,java.lang.Integer>`	`integersPerKey()` Returns a `PTransform` that takes an input `PCollection<KV<K, Integer>>` and returns a `PCollection<KV<K, Integer>>` that contains an output element mapping each distinct key in the input `PCollection` to the minimum of the values associated with that key in the input `PCollection`.
`static Combine.Globally<java.lang.Long,java.lang.Long>`	`longsGlobally()` Returns a `PTransform` that takes an input `PCollection<Long>` and returns a `PCollection<Long>` whose contents is the minimum of the input `PCollection`'s elements, or `Long.MAX_VALUE` if there are no elements.
`static <K> Combine.PerKey<K,java.lang.Long,java.lang.Long>`	`longsPerKey()` Returns a `PTransform` that takes an input `PCollection<KV<K, Long>>` and returns a `PCollection<KV<K, Long>>` that contains an output element mapping each distinct key in the input `PCollection` to the minimum of the values associated with that key in the input `PCollection`.
`static <T extends java.lang.Comparable<? super T>> Combine.BinaryCombineFn<T>`	`naturalOrder()`
`static <T extends java.lang.Comparable<? super T>> Combine.BinaryCombineFn<T>`	`naturalOrder(T identity)`
`static <T,ComparatorT extends java.util.Comparator<? super T> & java.io.Serializable> Combine.BinaryCombineFn<T>`	`of(ComparatorT comparator)` A `CombineFn` that computes the minimum of a collection of elements of type `T` using an arbitrary `Comparator`, useful as an argument to `Combine.globally(org.apache.beam.sdk.transforms.SerializableFunction<java.lang.Iterable<V>, V>)` or `Combine.perKey(org.apache.beam.sdk.transforms.SerializableFunction<java.lang.Iterable<V>, V>)`.
`static <T,ComparatorT extends java.util.Comparator<? super T> & java.io.Serializable> Combine.BinaryCombineFn<T>`	`of(T identity, ComparatorT comparator)` A `CombineFn` that computes the minimum of a collection of elements of type `T` using an arbitrary `Comparator` and an `identity`, useful as an argument to `Combine.globally(org.apache.beam.sdk.transforms.SerializableFunction<java.lang.Iterable<V>, V>)` or `Combine.perKey(org.apache.beam.sdk.transforms.SerializableFunction<java.lang.Iterable<V>, V>)`.
`static Combine.BinaryCombineDoubleFn`	`ofDoubles()` A `CombineFn` that computes the minimum of a collection of `Double`s, useful as an argument to `Combine.globally(org.apache.beam.sdk.transforms.SerializableFunction<java.lang.Iterable<V>, V>)` or `Combine.perKey(org.apache.beam.sdk.transforms.SerializableFunction<java.lang.Iterable<V>, V>)`.
`static Combine.BinaryCombineIntegerFn`	`ofIntegers()` A `CombineFn` that computes the minimum of a collection of `Integer`s, useful as an argument to `Combine.globally(org.apache.beam.sdk.transforms.SerializableFunction<java.lang.Iterable<V>, V>)` or `Combine.perKey(org.apache.beam.sdk.transforms.SerializableFunction<java.lang.Iterable<V>, V>)`.
`static Combine.BinaryCombineLongFn`	`ofLongs()` A `CombineFn` that computes the minimum of a collection of `Long`s, useful as an argument to `Combine.globally(org.apache.beam.sdk.transforms.SerializableFunction<java.lang.Iterable<V>, V>)` or `Combine.perKey(org.apache.beam.sdk.transforms.SerializableFunction<java.lang.Iterable<V>, V>)`.
`static <K,T extends java.lang.Comparable<? super T>> Combine.PerKey<K,T,T>`	`perKey()` Returns a `PTransform` that takes an input `PCollection<KV<K, T>>` and returns a `PCollection<KV<K, T>>` that contains an output element mapping each distinct key in the input `PCollection` to the minimum according to the natural ordering of `T` of the values associated with that key in the input `PCollection`.
`static <K,T,ComparatorT extends java.util.Comparator<? super T> & java.io.Serializable> Combine.PerKey<K,T,T>`	`perKey(ComparatorT comparator)` Returns a `PTransform` that takes an input `PCollection<KV<K, T>>` and returns a `PCollection<KV<K, T>>` that contains one output element per key mapping each to the minimum of the values associated with that key in the input `PCollection`.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Method Detail
  - integersGlobally
```
public static Combine.Globally<java.lang.Integer,java.lang.Integer> integersGlobally()
```
    Returns a PTransform that takes an input PCollection<Integer> and returns a PCollection<Integer> whose contents is a single value that is the minimum of the input PCollection's elements, or Integer.MAX_VALUE if there are no elements.
  - integersPerKey
```
public static <K> Combine.PerKey<K,java.lang.Integer,java.lang.Integer> integersPerKey()
```
    Returns a PTransform that takes an input PCollection<KV<K, Integer>> and returns a PCollection<KV<K, Integer>> that contains an output element mapping each distinct key in the input PCollection to the minimum of the values associated with that key in the input PCollection.
    See Combine.PerKey for how this affects timestamps and windowing.
  - longsGlobally
```
public static Combine.Globally<java.lang.Long,java.lang.Long> longsGlobally()
```
    Returns a PTransform that takes an input PCollection<Long> and returns a PCollection<Long> whose contents is the minimum of the input PCollection's elements, or Long.MAX_VALUE if there are no elements.
  - longsPerKey
```
public static <K> Combine.PerKey<K,java.lang.Long,java.lang.Long> longsPerKey()
```
    Returns a PTransform that takes an input PCollection<KV<K, Long>> and returns a PCollection<KV<K, Long>> that contains an output element mapping each distinct key in the input PCollection to the minimum of the values associated with that key in the input PCollection.
    See Combine.PerKey for how this affects timestamps and windowing.
  - doublesGlobally
```
public static Combine.Globally<java.lang.Double,java.lang.Double> doublesGlobally()
```
    Returns a PTransform that takes an input PCollection<Double> and returns a PCollection<Double> whose contents is the minimum of the input PCollection's elements, or Double.POSITIVE_INFINITY if there are no elements.
  - doublesPerKey
```
public static <K> Combine.PerKey<K,java.lang.Double,java.lang.Double> doublesPerKey()
```
    Returns a PTransform that takes an input PCollection<KV<K, Double>> and returns a PCollection<KV<K, Double>> that contains an output element mapping each distinct key in the input PCollection to the minimum of the values associated with that key in the input PCollection.
    See Combine.PerKey for how this affects timestamps and windowing.
  - ofIntegers
```
public static Combine.BinaryCombineIntegerFn ofIntegers()
```
    A CombineFn that computes the minimum of a collection of Integers, useful as an argument to Combine.globally(org.apache.beam.sdk.transforms.SerializableFunction<java.lang.Iterable<V>, V>) or Combine.perKey(org.apache.beam.sdk.transforms.SerializableFunction<java.lang.Iterable<V>, V>).
  - ofLongs
```
public static Combine.BinaryCombineLongFn ofLongs()
```
    A CombineFn that computes the minimum of a collection of Longs, useful as an argument to Combine.globally(org.apache.beam.sdk.transforms.SerializableFunction<java.lang.Iterable<V>, V>) or Combine.perKey(org.apache.beam.sdk.transforms.SerializableFunction<java.lang.Iterable<V>, V>).
  - ofDoubles
```
public static Combine.BinaryCombineDoubleFn ofDoubles()
```
    A CombineFn that computes the minimum of a collection of Doubles, useful as an argument to Combine.globally(org.apache.beam.sdk.transforms.SerializableFunction<java.lang.Iterable<V>, V>) or Combine.perKey(org.apache.beam.sdk.transforms.SerializableFunction<java.lang.Iterable<V>, V>).
  - of
```
public static <T,ComparatorT extends java.util.Comparator<? super T> & java.io.Serializable> Combine.BinaryCombineFn<T> of(T identity,
                                                                                                                           ComparatorT comparator)
```
    A CombineFn that computes the minimum of a collection of elements of type T using an arbitrary Comparator and an identity, useful as an argument to Combine.globally(org.apache.beam.sdk.transforms.SerializableFunction<java.lang.Iterable<V>, V>) or Combine.perKey(org.apache.beam.sdk.transforms.SerializableFunction<java.lang.Iterable<V>, V>).
    
    Type Parameters:
    
    T - the type of the values being compared
  - of
```
public static <T,ComparatorT extends java.util.Comparator<? super T> & java.io.Serializable> Combine.BinaryCombineFn<T> of(ComparatorT comparator)
```
    A CombineFn that computes the minimum of a collection of elements of type T using an arbitrary Comparator, useful as an argument to Combine.globally(org.apache.beam.sdk.transforms.SerializableFunction<java.lang.Iterable<V>, V>) or Combine.perKey(org.apache.beam.sdk.transforms.SerializableFunction<java.lang.Iterable<V>, V>).
    
    Type Parameters:
    
    T - the type of the values being compared
  - naturalOrder
```
public static <T extends java.lang.Comparable<? super T>> Combine.BinaryCombineFn<T> naturalOrder(T identity)
```
  - naturalOrder
```
public static <T extends java.lang.Comparable<? super T>> Combine.BinaryCombineFn<T> naturalOrder()
```
  - globally
```
public static <T extends java.lang.Comparable<? super T>> Combine.Globally<T,T> globally()
```
    Returns a PTransform that takes an input PCollection<T> and returns a PCollection<T> whose contents is the minimum according to the natural ordering of T of the input PCollection's elements, or null if there are no elements.
  - perKey
```
public static <K,T extends java.lang.Comparable<? super T>> Combine.PerKey<K,T,T> perKey()
```
    Returns a PTransform that takes an input PCollection<KV<K, T>> and returns a PCollection<KV<K, T>> that contains an output element mapping each distinct key in the input PCollection to the minimum according to the natural ordering of T of the values associated with that key in the input PCollection.
    See Combine.PerKey for how this affects timestamps and windowing.
  - globally
```
public static <T,ComparatorT extends java.util.Comparator<? super T> & java.io.Serializable> Combine.Globally<T,T> globally(ComparatorT comparator)
```
    Returns a PTransform that takes an input PCollection<T> and returns a PCollection<T> whose contents is the minimum of the input PCollection's elements, or null if there are no elements.
  - perKey
```
public static <K,T,ComparatorT extends java.util.Comparator<? super T> & java.io.Serializable> Combine.PerKey<K,T,T> perKey(ComparatorT comparator)
```
    Returns a PTransform that takes an input PCollection<KV<K, T>> and returns a PCollection<KV<K, T>> that contains one output element per key mapping each to the minimum of the values associated with that key in the input PCollection.
    See Combine.PerKey for how this affects timestamps and windowing.

Class Min

Method Summary

Methods inherited from class java.lang.Object

Method Detail

integersGlobally

integersPerKey

longsGlobally

longsPerKey

doublesGlobally

doublesPerKey

ofIntegers

ofLongs

ofDoubles

of

of

naturalOrder

naturalOrder

globally

perKey

globally

perKey