/** * Returns the minimum value in an array. * * @param numbers Array of numbers * @return minimum value in an array */ public static OptionalInt arrayMin(int[] numbers) { return Arrays.stream(numbers).min(); }
private static int min(int... numbers) { return Arrays.stream(numbers) .min().orElse(Integer.MAX_VALUE); }
/** * @return The priority that this region should have in the compaction queue */ public int getCompactPriority() { return stores.values().stream().mapToInt(HStore::getCompactPriority).min() .orElse(Store.NO_PRIORITY); }
public static int min(int... nums) { if(nums.length == 0) return Integer.MIN_VALUE; return Arrays.stream(nums).min().getAsInt(); }
public static IntPair maximize_unsorted(int[] numbers) { OptionalInt min = IntStream.of(numbers).min(); OptionalInt max = IntStream.of(numbers).max(); return new IntPair(min.getAsInt(), max.getAsInt()); }
@Benchmark public int serial_lazy_intstream_jdk() { return this.integersJDK.stream().mapToInt(Integer::intValue).min().getAsInt(); }
@Benchmark public int parallel_lazy_intstream_jdk() { return this.integersJDK.parallelStream().mapToInt(Integer::intValue).min().getAsInt(); }
@Override public OptionalInt execute() { try (final IntStream stream = buildPrevious()) { return stream.min(); } } }
/** * Aggregates the contents of n strings into a single list of tuples. * * @param inputs A list of strings. * @return A list of strings if none of the strings in the input is null or empty. * An empty list otherwise. */ public static List<String> zip(String... inputs) { if (inputs.length == 0) { return Collections.emptyList(); } OptionalInt min = Arrays.stream(inputs).mapToInt(str -> str == null ? 0 : str.length()).min(); if (!min.isPresent()) { return Collections.emptyList(); } return IntStream.range(0, min.getAsInt()) .mapToObj(elementIndex -> Arrays.stream(inputs) .map(input -> String.valueOf(input.charAt(elementIndex))) .collect(joining())) .collect(toList()); }
@Benchmark public int serial_lazy_intstream_streams_gsc() { return this.integersGSC.stream().mapToInt(Integer::intValue).min().getAsInt(); }
@Benchmark public int parallel_lazy_intstream_streams_gsc() { return this.integersGSC.parallelStream().mapToInt(Integer::intValue).min().getAsInt(); }
default OptionalInt min(IntPipeline pipeline) { requireNonNull(pipeline); return optimize(pipeline).getAsIntStream().min(); }
int min = statement.getClauses().stream() .flatMapToInt(clause -> Arrays.stream(clause.getConditions())) .min().orElse(0); int max = statement.getClauses().stream() .flatMapToInt(clause -> Arrays.stream(clause.getConditions()))
/** * Returns the minimum value in an array. * * @param numbers Array of numbers * @return minimum value in an array */ public static OptionalInt arrayMin(int[] numbers) { return Arrays.stream(numbers).min(); }
int tag = ranges.stream().mapToInt(range -> range.lower).min().orElse(0); header.setInt(CLASS_TAG, tag); header.setInt(CLASS_CANARY, RuntimeClass.computeCanary(occupiedSize, tag));
import java.util.Arrays; public class Test { public static void main(String[] args){ int[] tab = {12, 1, 21, 8}; int min = Arrays.stream(tab).min().getAsInt(); int max = Arrays.stream(tab).max().getAsInt(); System.out.println("Min = " + min); System.out.println("Max = " + max) } }
AttrStore(List<Shard> shards, int total) { assert shards.stream() .mapToInt(Shard::size) .sum() == total; if (shards.size() > 1) { assert shards.subList(0, shards.size() - 1) .stream() .mapToInt(Shard::size) .min() .equals(OptionalInt.of(Shard.SHARD_SIZE)); assert shards.subList(0, shards.size() - 1) .stream() .mapToInt(Shard::size) .max() .equals(OptionalInt.of(Shard.SHARD_SIZE)); } this.shards = ImmutableList.copyOf(shards); this.totalSize = total; }
/** Extracts the maximum sdk (exclusive) supported by the targeting. */ public static int getMaxSdk(SdkVersionTargeting sdkVersionTargeting) { int minSdk = getMinSdk(sdkVersionTargeting); int alternativeMinSdk = sdkVersionTargeting .getAlternativesList() .stream() .mapToInt(alternativeSdk -> alternativeSdk.getMin().getValue()) .filter(sdkValue -> minSdk < sdkValue) .min() .orElse(Integer.MAX_VALUE); return alternativeMinSdk; } }
.peek(it -> hostPriority.put(it.get(1, String.class), it.get(0, Integer.class))) .mapToInt(it -> it.get(0, Integer.class)) .min().orElse(defaultPriroty);
int minx = sources.stream().mapToInt(it -> it.posx).min().getAsInt(); int maxx = sources.stream().mapToInt(it -> it.posx + it.image.getWidth()).max().getAsInt(); int miny = sources.stream().mapToInt(it -> it.posy).min().getAsInt(); int maxy = sources.stream().mapToInt(it -> it.posy + it.image.getHeight()).max().getAsInt(); int width = maxx - minx;