java.util.function.ToIntFunction Java Examples

@Override
public Mono<Double> getAveAge() {
	ToIntFunction<Employee> sizeEmpArr = (e) -> {
		System.out.println("flux:toIntFunction task executor: " + Thread.currentThread().getName());
		System.out.println("flux:toIntFunction task executor login: " + SecurityContextHolder.getContext().getAuthentication().getPrincipal());
		return e.getAge();
	};
	Callable<Double> task = () ->{
		System.out.println("flux:callable task executor: " + Thread.currentThread().getName());
		System.out.println("flux:callable task executor login: " + SecurityContextHolder.getContext().getAuthentication().getPrincipal());
		return employeeDaoImpl.getEmployees().stream()
		.mapToInt(sizeEmpArr)
		.average()
		.getAsDouble();
	};

	Mono<Double> aveAge= Mono.fromCallable(task);
	return aveAge;
}
 

@Override
public final IntStream mapToInt(ToIntFunction<? super P_OUT> mapper) {
    Objects.requireNonNull(mapper);
    return new IntPipeline.StatelessOp<P_OUT>(this, StreamShape.REFERENCE,
                                          StreamOpFlag.NOT_SORTED | StreamOpFlag.NOT_DISTINCT) {
        @Override
        Sink<P_OUT> opWrapSink(int flags, Sink<Integer> sink) {
            return new Sink.ChainedReference<P_OUT, Integer>(sink) {
                @Override
                public void accept(P_OUT u) {
                    downstream.accept(mapper.applyAsInt(u));
                }
            };
        }
    };
}
 

private static int testApacheServer(List<MethodInvocationFilter> filters)
        throws Exception
{
    ScribeService scribeService = new ScribeService();
    TProcessor processor = new scribe.Processor<>(scribeService);

    int invocationCount = 0;
    for (boolean secure : ImmutableList.of(true, false)) {
        for (Transport transport : Transport.values()) {
            for (Protocol protocol : Protocol.values()) {
                invocationCount += testApacheServer(secure, transport, protocol, processor, ImmutableList.<ToIntFunction<HostAndPort>>builder()
                        .addAll(legacyApacheThriftTestClients(filters, transport, protocol, secure))
                        .addAll(driftNettyTestClients(filters, transport, protocol, secure))
                        .addAll(apacheThriftTestClients(filters, transport, protocol, secure))
                        .build());
            }
        }
    }

    assertEquals(scribeService.getMessages(), newArrayList(concat(nCopies(invocationCount, MESSAGES))));

    return invocationCount;
}
 

private static int testServerMethodInvoker(ServerMethodInvoker methodInvoker, boolean assumeClientsSupportOutOfOrderResponses, List<ToIntFunction<HostAndPort>> clients)
{
    DriftNettyServerConfig config = new DriftNettyServerConfig()
            .setAssumeClientsSupportOutOfOrderResponses(assumeClientsSupportOutOfOrderResponses);
    TestingPooledByteBufAllocator testingAllocator = new TestingPooledByteBufAllocator();
    ServerTransport serverTransport = new DriftNettyServerTransportFactory(config, testingAllocator).createServerTransport(methodInvoker);
    try {
        serverTransport.start();

        HostAndPort address = HostAndPort.fromParts("localhost", ((DriftNettyServerTransport) serverTransport).getPort());

        int sum = 0;
        for (ToIntFunction<HostAndPort> client : clients) {
            sum += client.applyAsInt(address);
        }
        return sum;
    }
    finally {
        serverTransport.shutdown();
        testingAllocator.close();
    }
}
 

public ShapeKey(
		final T shapeId,
		final int scaleIndex,
		final int simplificationIterations,
		final double smoothingLambda,
		final int smoothingIterations,
		final double minLabelRatio,
		final long[] min,
		final long[] max,
		final ToIntFunction<T> shapeIdHashCode,
		final BiPredicate<T, Object> shapeIdEquals)
{
	this.shapeId = shapeId;
	this.scaleIndex = scaleIndex;
	this.simplificationIterations = simplificationIterations;
	this.smoothingLambda = smoothingLambda;
	this.smoothingIterations = smoothingIterations;
	this.minLabelRatio = minLabelRatio;
	this.min = min;
	this.max = max;
	this.shapeIdHashCode = shapeIdHashCode;
	this.shapeIdEquals = shapeIdEquals;
}
 

protected RefTestData(String name,
                      I state,
                      Function<I, Stream<T>> streamFn,
                      Function<I, Stream<T>> parStreamFn,
                      Function<I, Spliterator<T>> splitrFn,
                      ToIntFunction<I> sizeFn) {
    super(name, StreamShape.REFERENCE, state, streamFn, parStreamFn, splitrFn, sizeFn);
}
 

protected IntTestData(String name,
                      I state,
                      Function<I, IntStream> streamFn,
                      Function<I, IntStream> parStreamFn,
                      Function<I, Spliterator.OfInt> splitrFn,
                      ToIntFunction<I> sizeFn) {
    super(name, StreamShape.INT_VALUE, state, streamFn, parStreamFn, splitrFn, sizeFn);
}
 

public double getParallelAverageAge(){
    ToIntFunction<Employee> sizeEmpArr = (e) -> {
    	System.out.println("Thread: " + Thread.currentThread().getName());
    	return e.getAge();
    };
	return employeeDaoImpl.getEmployees().parallelStream().mapToInt(sizeEmpArr).average().getAsDouble();
}
 

public double getSequentialAverageAge(){
   ToIntFunction<Employee> sizeEmpArr = (e) -> {
    System.out.println("Thread: " + Thread.currentThread().getName());
    	return e.getAge();
   };
   return employeeDaoImpl.getEmployees().stream().mapToInt(sizeEmpArr).average().getAsDouble();
}
 

protected IntTestData(String name,
                      I state,
                      Function<I, IntStream> streamFn,
                      Function<I, IntStream> parStreamFn,
                      Function<I, Spliterator.OfInt> splitrFn,
                      ToIntFunction<I> sizeFn) {
    super(name, StreamShape.INT_VALUE, state, streamFn, parStreamFn, splitrFn, sizeFn);
}
 

@Override
public ToIntFunction<ConnectorSplit> getSplitBucketFunction(ConnectorTransactionHandle transactionHandle, ConnectorSession session, ConnectorPartitioningHandle partitioningHandle)
{
    try (ThreadContextClassLoader ignored = new ThreadContextClassLoader(classLoader)) {
        return delegate.getSplitBucketFunction(transactionHandle, session, partitioningHandle);
    }
}
 

protected LongTestData(String name,
                       I state,
                       Function<I, LongStream> streamFn,
                       Function<I, LongStream> parStreamFn,
                       Function<I, Spliterator.OfLong> splitrFn,
                       ToIntFunction<I> sizeFn) {
    super(name, StreamShape.LONG_VALUE, state, streamFn, parStreamFn, splitrFn, sizeFn);
}
 

protected RefTestData(String name,
                      I state,
                      Function<I, Stream<T>> streamFn,
                      Function<I, Stream<T>> parStreamFn,
                      Function<I, Spliterator<T>> splitrFn,
                      ToIntFunction<I> sizeFn) {
    super(name, StreamShape.REFERENCE, state, streamFn, parStreamFn, splitrFn, sizeFn);
}
 

protected IntTestData(String name,
                      I state,
                      Function<I, IntStream> streamFn,
                      Function<I, IntStream> parStreamFn,
                      Function<I, Spliterator.OfInt> splitrFn,
                      ToIntFunction<I> sizeFn) {
    super(name, StreamShape.INT_VALUE, state, streamFn, parStreamFn, splitrFn, sizeFn);
}
 

protected LongTestData(String name,
                       I state,
                       Function<I, LongStream> streamFn,
                       Function<I, LongStream> parStreamFn,
                       Function<I, Spliterator.OfLong> splitrFn,
                       ToIntFunction<I> sizeFn) {
    super(name, StreamShape.LONG_VALUE, state, streamFn, parStreamFn, splitrFn, sizeFn);
}
 

@Override
public ToIntFunction<ConnectorSplit> getSplitBucketFunction(
        ConnectorTransactionHandle transactionHandle,
        ConnectorSession session,
        ConnectorPartitioningHandle partitioningHandle)
{
    return value -> {
        throw new PrestoException(NOT_SUPPORTED, "Black hole connector does not supported distributed reads");
    };
}
 

protected DoubleTestData(String name,
                         I state,
                         Function<I, DoubleStream> streamFn,
                         Function<I, DoubleStream> parStreamFn,
                         Function<I, Spliterator.OfDouble> splitrFn,
                         ToIntFunction<I> sizeFn) {
    super(name, StreamShape.DOUBLE_VALUE, state, streamFn, parStreamFn, splitrFn, sizeFn);
}
 

AbstractTestData(String name,
                 StreamShape shape,
                 T_STATE state,
                 Function<T_STATE, S> streamFn,
                 Function<T_STATE, S> parStreamFn,
                 Function<T_STATE, T_SPLITR> splitrFn,
                 ToIntFunction<T_STATE> sizeFn) {
    this.name = name;
    this.shape = shape;
    this.state = state;
    this.streamFn = streamFn;
    this.parStreamFn = parStreamFn;
    this.splitrFn = splitrFn;
    this.sizeFn = sizeFn;
}
 

protected LongTestData(String name,
                       I state,
                       Function<I, LongStream> streamFn,
                       Function<I, LongStream> parStreamFn,
                       Function<I, Spliterator.OfLong> splitrFn,
                       ToIntFunction<I> sizeFn) {
    super(name, StreamShape.LONG_VALUE, state, streamFn, parStreamFn, splitrFn, sizeFn);
}
 

@Test
public void create() throws ExecutionException, InterruptedException {
    TerminalStage<Integer, Integer> terminal = factory.create(null,
            () -> Collectors.summingInt((ToIntFunction<Integer>) value -> value));

    List<Integer> list = new ArrayList<>();
    Flowable<Integer> flowable = Flowable.fromArray(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
            .doOnNext(list::add)
            .subscribeOn(Schedulers.computation());
    CompletionStage<Integer> stage = terminal.apply(flowable);
    Integer result = stage.toCompletableFuture().get();

    assertThat(result).isEqualTo(1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10);
    assertThat(list).hasSize(10);
}
 

AbstractTestData(String name,
                 StreamShape shape,
                 T_STATE state,
                 Function<T_STATE, S> streamFn,
                 Function<T_STATE, S> parStreamFn,
                 Function<T_STATE, T_SPLITR> splitrFn,
                 ToIntFunction<T_STATE> sizeFn) {
    this.name = name;
    this.shape = shape;
    this.state = state;
    this.streamFn = streamFn;
    this.parStreamFn = parStreamFn;
    this.splitrFn = splitrFn;
    this.sizeFn = sizeFn;
}
 

protected IntTestData(String name,
                      I state,
                      Function<I, IntStream> streamFn,
                      Function<I, IntStream> parStreamFn,
                      Function<I, Spliterator.OfInt> splitrFn,
                      ToIntFunction<I> sizeFn) {
    super(name, StreamShape.INT_VALUE, state, streamFn, parStreamFn, splitrFn, sizeFn);
}
 

public void testIntComparator() {
    Thing[] things = new Thing[intValues.length];
    for (int i=0; i<intValues.length; i++)
        things[i] = new Thing(intValues[i], 0L, 0.0, null);
    Comparator<Thing> comp = Comparator.comparingInt(new ToIntFunction<Thing>() {
        @Override
        public int applyAsInt(Thing thing) {
            return thing.getIntField();
        }
    });

    assertComparisons(things, comp, comparisons);
}
 

@Override
public DataFrame<R, C> mapToInts(ToIntFunction<DataFrameValue<R, C>> mapper) {
    final Array<R> rowKeys = rows().keyArray();
    final Array<C> colKeys = cols().keyArray();
    final XDataFrame<R,C> result = (XDataFrame<R,C>)DataFrame.ofInts(rowKeys, colKeys);
    this.forEachValue(v -> {
        final int value = mapper.applyAsInt(v);
        final int rowOrdinal = v.rowOrdinal();
        final int colOrdinal = v.colOrdinal();
        result.content().setInt(rowOrdinal, colOrdinal, value);
    });
    return result;
}
 

@Override
public MinimalSourceStateSerializer createSerializer(
		final Supplier<String> projectDirectory,
		final ToIntFunction<SourceState<?, ?>> stateToIndex)
{
	return new MinimalSourceStateSerializer(stateToIndex);
}
 

public void testIntComparator() {
    Thing[] things = new Thing[intValues.length];
    for (int i=0; i<intValues.length; i++)
        things[i] = new Thing(intValues[i], 0L, 0.0, null);
    Comparator<Thing> comp = Comparator.comparingInt(new ToIntFunction<Thing>() {
        @Override
        public int applyAsInt(Thing thing) {
            return thing.getIntField();
        }
    });

    assertComparisons(things, comp, comparisons);
}
 

public void testIntComparator() {
    Thing[] things = new Thing[intValues.length];
    for (int i=0; i<intValues.length; i++)
        things[i] = new Thing(intValues[i], 0L, 0.0, null);
    Comparator<Thing> comp = Comparator.comparingInt(new ToIntFunction<Thing>() {
        @Override
        public int applyAsInt(Thing thing) {
            return thing.getIntField();
        }
    });

    assertComparisons(things, comp, comparisons);
}
 

protected DoubleTestData(String name,
                         I state,
                         Function<I, DoubleStream> streamFn,
                         Function<I, DoubleStream> parStreamFn,
                         Function<I, Spliterator.OfDouble> splitrFn,
                         ToIntFunction<I> sizeFn) {
    super(name, StreamShape.DOUBLE_VALUE, state, streamFn, parStreamFn, splitrFn, sizeFn);
}
 

protected IntTestData(String name,
                      I state,
                      Function<I, IntStream> streamFn,
                      Function<I, IntStream> parStreamFn,
                      Function<I, Spliterator.OfInt> splitrFn,
                      ToIntFunction<I> sizeFn) {
    super(name, StreamShape.INT_VALUE, state, streamFn, parStreamFn, splitrFn, sizeFn);
}
 

public static void squareRootAndRemainder() {
    ToIntFunction<BigInteger> g = (n) -> {
        int failCount = 0;
        BigInteger n2 = n.pow(2);

        // square root of n^2 -> n
        BigInteger[] actual = n2.sqrtAndRemainder();
        failCount += checkResult(n, actual[0], "sqrtAndRemainder()[0]");
        failCount += checkResult(BigInteger.ZERO, actual[1],
            "sqrtAndRemainder()[1]");

        // square root of n^2 + 1 -> n
        BigInteger n2up = n2.add(BigInteger.ONE);
        actual = n2up.sqrtAndRemainder();
        failCount += checkResult(n, actual[0], "sqrtAndRemainder()[0]");
        failCount += checkResult(BigInteger.ONE, actual[1],
            "sqrtAndRemainder()[1]");

        // square root of (n + 1)^2 - 1 -> n
        BigInteger up =
            n.add(BigInteger.ONE).pow(2).subtract(BigInteger.ONE);
        actual = up.sqrtAndRemainder();
        failCount += checkResult(n, actual[0], "sqrtAndRemainder()[0]");
        BigInteger r = up.subtract(n2);
        failCount += checkResult(r, actual[1], "sqrtAndRemainder()[1]");

        return failCount;
    };

    IntStream bits = random.ints(SIZE, 3, Short.MAX_VALUE);
    report("sqrtAndRemainder", bits.mapToObj(x ->
        BigInteger.valueOf(x)).collect(Collectors.summingInt(g)));
}