java.util.function.LongToDoubleFunction Java Examples

@Override
public final DoubleStream mapToDouble(LongToDoubleFunction mapper) {
    Objects.requireNonNull(mapper);
    return new DoublePipeline.StatelessOp<Long>(this, StreamShape.LONG_VALUE,
                                                StreamOpFlag.NOT_SORTED | StreamOpFlag.NOT_DISTINCT) {
        @Override
        Sink<Long> opWrapSink(int flags, Sink<Double> sink) {
            return new Sink.ChainedLong<Double>(sink) {
                @Override
                public void accept(long t) {
                    downstream.accept(mapper.applyAsDouble(t));
                }
            };
        }
    };
}
 

@Override
public final DoubleStream mapToDouble(LongToDoubleFunction mapper) {
    Objects.requireNonNull(mapper);
    return new DoublePipeline.StatelessOp<Long>(this, StreamShape.LONG_VALUE,
                                                StreamOpFlag.NOT_SORTED | StreamOpFlag.NOT_DISTINCT) {
        @Override
        Sink<Long> opWrapSink(int flags, Sink<Double> sink) {
            return new Sink.ChainedLong<Double>(sink) {
                @Override
                public void accept(long t) {
                    downstream.accept(mapper.applyAsDouble(t));
                }
            };
        }
    };
}
 

@Override
public final DoubleStream mapToDouble(LongToDoubleFunction mapper) {
    Objects.requireNonNull(mapper);
    return new DoublePipeline.StatelessOp<Long>(this, StreamShape.LONG_VALUE,
                                                StreamOpFlag.NOT_SORTED | StreamOpFlag.NOT_DISTINCT) {
        @Override
        Sink<Long> opWrapSink(int flags, Sink<Double> sink) {
            return new Sink.ChainedLong<Double>(sink) {
                @Override
                public void accept(long t) {
                    downstream.accept(mapper.applyAsDouble(t));
                }
            };
        }
    };
}
 

@Override
public final DoubleStream mapToDouble(LongToDoubleFunction mapper) {
    Objects.requireNonNull(mapper);
    return new DoublePipeline.StatelessOp<Long>(this, StreamShape.LONG_VALUE,
                                                StreamOpFlag.NOT_SORTED | StreamOpFlag.NOT_DISTINCT) {
        @Override
        Sink<Long> opWrapSink(int flags, Sink<Double> sink) {
            return new Sink.ChainedLong<Double>(sink) {
                @Override
                public void accept(long t) {
                    downstream.accept(mapper.applyAsDouble(t));
                }
            };
        }
    };
}
 

@Override
public final DoubleStream mapToDouble(LongToDoubleFunction mapper) {
    Objects.requireNonNull(mapper);
    return new DoublePipeline.StatelessOp<Long>(this, StreamShape.LONG_VALUE,
                                                StreamOpFlag.NOT_SORTED | StreamOpFlag.NOT_DISTINCT) {
        @Override
        Sink<Long> opWrapSink(int flags, Sink<Double> sink) {
            return new Sink.ChainedLong<Double>(sink) {
                @Override
                public void accept(long t) {
                    downstream.accept(mapper.applyAsDouble(t));
                }
            };
        }
    };
}
 

@Override
public final DoubleStream mapToDouble(LongToDoubleFunction mapper) {
    Objects.requireNonNull(mapper);
    return new DoublePipeline.StatelessOp<Long>(this, StreamShape.LONG_VALUE,
                                                StreamOpFlag.NOT_SORTED | StreamOpFlag.NOT_DISTINCT) {
        @Override
        Sink<Long> opWrapSink(int flags, Sink<Double> sink) {
            return new Sink.ChainedLong<Double>(sink) {
                @Override
                public void accept(long t) {
                    downstream.accept(mapper.applyAsDouble(t));
                }
            };
        }
    };
}
 

@Override
public final DoubleStream mapToDouble(LongToDoubleFunction mapper) {
    Objects.requireNonNull(mapper);
    return new DoublePipeline.StatelessOp<Long>(this, StreamShape.LONG_VALUE,
                                                StreamOpFlag.NOT_SORTED | StreamOpFlag.NOT_DISTINCT) {
        @Override
        Sink<Long> opWrapSink(int flags, Sink<Double> sink) {
            return new Sink.ChainedLong<Double>(sink) {
                @Override
                public void accept(long t) {
                    downstream.accept(mapper.applyAsDouble(t));
                }
            };
        }
    };
}
 

@Override
public final DoubleStream mapToDouble(LongToDoubleFunction mapper) {
    Objects.requireNonNull(mapper);
    return new DoublePipeline.StatelessOp<Long>(this, StreamShape.LONG_VALUE,
                                                StreamOpFlag.NOT_SORTED | StreamOpFlag.NOT_DISTINCT) {
        @Override
        Sink<Long> opWrapSink(int flags, Sink<Double> sink) {
            return new Sink.ChainedLong<Double>(sink) {
                @Override
                public void accept(long t) {
                    downstream.accept(mapper.applyAsDouble(t));
                }
            };
        }
    };
}
 

@Override
public final DoubleStream mapToDouble(LongToDoubleFunction mapper) {
    Objects.requireNonNull(mapper);
    return new DoublePipeline.StatelessOp<Long>(this, StreamShape.LONG_VALUE,
                                                StreamOpFlag.NOT_SORTED | StreamOpFlag.NOT_DISTINCT) {
        @Override
        Sink<Long> opWrapSink(int flags, Sink<Double> sink) {
            return new Sink.ChainedLong<Double>(sink) {
                @Override
                public void accept(long t) {
                    downstream.accept(mapper.applyAsDouble(t));
                }
            };
        }
    };
}
 

@Override
public final DoubleStream mapToDouble(LongToDoubleFunction mapper) {
    Objects.requireNonNull(mapper);
    return new DoublePipeline.StatelessOp<Long>(this, StreamShape.LONG_VALUE,
                                                StreamOpFlag.NOT_SORTED | StreamOpFlag.NOT_DISTINCT) {
        @Override
        Sink<Long> opWrapSink(int flags, Sink<Double> sink) {
            return new Sink.ChainedLong<Double>(sink) {
                @Override
                public void accept(long t) {
                    downstream.accept(mapper.applyAsDouble(t));
                }
            };
        }
    };
}
 

@Override
public final DoubleStream mapToDouble(LongToDoubleFunction mapper) {
    Objects.requireNonNull(mapper);
    return new DoublePipeline.StatelessOp<Long>(this, StreamShape.LONG_VALUE,
                                                StreamOpFlag.NOT_SORTED | StreamOpFlag.NOT_DISTINCT) {
        @Override
        Sink<Long> opWrapSink(int flags, Sink<Double> sink) {
            return new Sink.ChainedLong<Double>(sink) {
                @Override
                public void accept(long t) {
                    downstream.accept(mapper.applyAsDouble(t));
                }
            };
        }
    };
}
 

@Override
public final DoubleStream mapToDouble(LongToDoubleFunction mapper) {
    Objects.requireNonNull(mapper);
    return new DoublePipeline.StatelessOp<Long>(this, StreamShape.LONG_VALUE,
                                                StreamOpFlag.NOT_SORTED | StreamOpFlag.NOT_DISTINCT) {
        @Override
        Sink<Long> opWrapSink(int flags, Sink<Double> sink) {
            return new Sink.ChainedLong<Double>(sink) {
                @Override
                public void accept(long t) {
                    downstream.accept(mapper.applyAsDouble(t));
                }
            };
        }
    };
}
 

@Override
public final DoubleStream mapToDouble(LongToDoubleFunction mapper) {
    Objects.requireNonNull(mapper);
    return new DoublePipeline.StatelessOp<Long>(this, StreamShape.LONG_VALUE,
                                                StreamOpFlag.NOT_SORTED | StreamOpFlag.NOT_DISTINCT) {
        @Override
        Sink<Long> opWrapSink(int flags, Sink<Double> sink) {
            return new Sink.ChainedLong<Double>(sink) {
                @Override
                public void accept(long t) {
                    downstream.accept(mapper.applyAsDouble(t));
                }
            };
        }
    };
}
 

@Override
public final DoubleStream mapToDouble(LongToDoubleFunction mapper) {
    Objects.requireNonNull(mapper);
    return new DoublePipeline.StatelessOp<Long>(this, StreamShape.LONG_VALUE,
                                                StreamOpFlag.NOT_SORTED | StreamOpFlag.NOT_DISTINCT) {
        @Override
        Sink<Long> opWrapSink(int flags, Sink<Double> sink) {
            return new Sink.ChainedLong<Double>(sink) {
                @Override
                public void accept(long t) {
                    downstream.accept(mapper.applyAsDouble(t));
                }
            };
        }
    };
}
 

@Override
public final DoubleStream mapToDouble(LongToDoubleFunction mapper) {
    Objects.requireNonNull(mapper);
    return new DoublePipeline.StatelessOp<Long>(this, StreamShape.LONG_VALUE,
                                                StreamOpFlag.NOT_SORTED | StreamOpFlag.NOT_DISTINCT) {
        @Override
        Sink<Long> opWrapSink(int flags, Sink<Double> sink) {
            return new Sink.ChainedLong<Double>(sink) {
                @Override
                public void accept(long t) {
                    downstream.accept(mapper.applyAsDouble(t));
                }
            };
        }
    };
}
 

@Override
public final DoubleStream mapToDouble(LongToDoubleFunction mapper) {
    Objects.requireNonNull(mapper);
    return new DoublePipeline.StatelessOp<Long>(this, StreamShape.LONG_VALUE,
                                                StreamOpFlag.NOT_SORTED | StreamOpFlag.NOT_DISTINCT) {
        @Override
        Sink<Long> opWrapSink(int flags, Sink<Double> sink) {
            return new Sink.ChainedLong<Double>(sink) {
                @Override
                public void accept(long t) {
                    downstream.accept(mapper.applyAsDouble(t));
                }
            };
        }
    };
}
 

@Override
public final DoubleStream mapToDouble(LongToDoubleFunction mapper) {
    Objects.requireNonNull(mapper);
    return new DoublePipeline.StatelessOp<Long>(this, StreamShape.LONG_VALUE,
                                                StreamOpFlag.NOT_SORTED | StreamOpFlag.NOT_DISTINCT) {
        @Override
        public Sink<Long> opWrapSink(int flags, Sink<Double> sink) {
            return new Sink.ChainedLong<Double>(sink) {
                @Override
                public void accept(long t) {
                    downstream.accept(mapper.applyAsDouble(t));
                }
            };
        }
    };
}
 

@Override
public final DoubleStream mapToDouble(LongToDoubleFunction mapper) {
    Objects.requireNonNull(mapper);
    return new DoublePipeline.StatelessOp<Long>(this, StreamShape.LONG_VALUE,
                                                StreamOpFlag.NOT_SORTED | StreamOpFlag.NOT_DISTINCT) {
        @Override
        Sink<Long> opWrapSink(int flags, Sink<Double> sink) {
            return new Sink.ChainedLong<Double>(sink) {
                @Override
                public void accept(long t) {
                    downstream.accept(mapper.applyAsDouble(t));
                }
            };
        }
    };
}
 

@Override
public final DoubleStream mapToDouble(LongToDoubleFunction mapper) {
    Objects.requireNonNull(mapper);
    return new DoublePipeline.StatelessOp<Long>(this, StreamShape.LONG_VALUE,
                                                StreamOpFlag.NOT_SORTED | StreamOpFlag.NOT_DISTINCT) {
        @Override
        Sink<Long> opWrapSink(int flags, Sink<Double> sink) {
            return new Sink.ChainedLong<Double>(sink) {
                @Override
                public void accept(long t) {
                    downstream.accept(mapper.applyAsDouble(t));
                }
            };
        }
    };
}
 

@Override
public DoubleStreamEx mapToDouble(LongToDoubleFunction mapper) {
    return new DoubleStreamEx(stream().mapToDouble(mapper), context);
}
 

private FieldValuesSource(String field, LongToDoubleFunction decoder) {
  this.field = field;
  this.decoder = decoder;
}
 

private Measurement newMeasurement(Id mid, LongToDoubleFunction getAndSet) {
  double delta = getAndSet.applyAsDouble(0);
  long timestamp = clock.wallTime();
  return new Measurement(mid, timestamp, delta);
}
 

private Measurement newMeasurement(Id mid, LongToDoubleFunction getAndSet) {
  double delta = getAndSet.applyAsDouble(0);
  long timestamp = clock.wallTime();
  return new Measurement(mid, timestamp, delta);
}
 

@Override
public DoubleStream mapToDouble(LongToDoubleFunction mapper) {
    return s.mapToDouble(mapper);
}
 

/**
 * Returns the maximum element of this stream according to the provided key
 * extractor function.
 *
 * <p>
 * This is a terminal operation.
 *
 * @param keyExtractor a non-interfering, stateless function
 * @return an {@code OptionalLong} describing the first element of this
 *         stream for which the highest value was returned by key extractor,
 *         or an empty {@code OptionalLong} if the stream is empty
 * @since 0.1.2
 */
public OptionalLong maxByDouble(LongToDoubleFunction keyExtractor) {
    return collect(PrimitiveBox::new, (box, l) -> {
        double key = keyExtractor.applyAsDouble(l);
        if (!box.b || Double.compare(box.d, key) < 0) {
            box.b = true;
            box.d = key;
            box.l = l;
        }
    }, PrimitiveBox.MAX_DOUBLE).asLong();
}
 

/**
 * Returns the minimum element of this stream according to the provided key
 * extractor function.
 *
 * <p>
 * This is a terminal operation.
 *
 * @param keyExtractor a non-interfering, stateless function
 * @return an {@code OptionalLong} describing the first element of this
 *         stream for which the lowest value was returned by key extractor,
 *         or an empty {@code OptionalLong} if the stream is empty
 * @since 0.1.2
 */
public OptionalLong minByDouble(LongToDoubleFunction keyExtractor) {
    return collect(PrimitiveBox::new, (box, l) -> {
        double key = keyExtractor.applyAsDouble(l);
        if (!box.b || Double.compare(box.d, key) > 0) {
            box.b = true;
            box.d = key;
            box.l = l;
        }
    }, PrimitiveBox.MIN_DOUBLE).asLong();
}
 

/**
 * Returns a {@code DoubleStream} consisting of the results of applying the
 * given function to the elements of this stream.
 *
 * <p>This is an <a href="package-summary.html#StreamOps">intermediate
 * operation</a>.
 *
 * @param mapper a <a href="package-summary.html#NonInterference">non-interfering</a>,
 *               <a href="package-summary.html#Statelessness">stateless</a>
 *               function to apply to each element
 * @return the new stream
 */
DoubleStream mapToDouble(LongToDoubleFunction mapper);
 

/**
 * Returns a {@code DoubleStream} consisting of the results of applying the
 * given function to the elements of this stream.
 *
 * <p>This is an <a href="package-summary.html#StreamOps">intermediate
 * operation</a>.
 *
 * @param mapper a <a href="package-summary.html#NonInterference">non-interfering</a>,
 *               <a href="package-summary.html#Statelessness">stateless</a>
 *               function to apply to each element
 * @return the new stream
 */
DoubleStream mapToDouble(LongToDoubleFunction mapper);
 

/**
 * Returns a {@code DoubleStream} consisting of the results of applying the
 * given function to the elements of this stream.
 *
 * <p>This is an <a href="package-summary.html#StreamOps">intermediate
 * operation</a>.
 *
 * @param mapper a <a href="package-summary.html#NonInterference">non-interfering</a>,
 *               <a href="package-summary.html#Statelessness">stateless</a>
 *               function to apply to each element
 * @return the new stream
 */
DoubleStream mapToDouble(LongToDoubleFunction mapper);
 

/**
 * Returns a {@code DoubleStream} consisting of the results of applying the
 * given function to the elements of this stream.
 *
 * <p>This is an <a href="package-summary.html#StreamOps">intermediate
 * operation</a>.
 *
 * @param mapper a <a href="package-summary.html#NonInterference">non-interfering</a>,
 *               <a href="package-summary.html#Statelessness">stateless</a>
 *               function to apply to each element
 * @return the new stream
 */
DoubleStream mapToDouble(LongToDoubleFunction mapper);