Java IntBinaryOperator类代码示例

import java.util.function.IntBinaryOperator; //导入依赖的package包/类
public void testIntMethods() {
    BinaryOperator<Integer> sum1 = Integer::sum;
    IntBinaryOperator sum2 = Integer::sum;
    BinaryOperator<Integer> max1 = Integer::max;
    IntBinaryOperator max2 = Integer::max;
    BinaryOperator<Integer> min1 = Integer::min;
    IntBinaryOperator min2 = Integer::min;
    Comparator<Integer> cmp = Integer::compare;

    int[] numbers = { -1, 0, 1, 100, Integer.MAX_VALUE, Integer.MIN_VALUE };
    for (int i : numbers) {
        for (int j : numbers) {
            assertEquals(i+j, (int) sum1.apply(i, j));
            assertEquals(i+j, sum2.applyAsInt(i, j));
            assertEquals(Math.max(i,j), (int) max1.apply(i, j));
            assertEquals(Math.max(i,j), max2.applyAsInt(i, j));
            assertEquals(Math.min(i,j), (int) min1.apply(i, j));
            assertEquals(Math.min(i,j), min2.applyAsInt(i, j));
            assertEquals(((Integer) i).compareTo(j), cmp.compare(i, j));
        }
    }
}
 

import java.util.function.IntBinaryOperator; //导入依赖的package包/类
public final void compute() {
    final ToIntBiFunction<? super K, ? super V> transformer;
    final IntBinaryOperator reducer;
    if ((transformer = this.transformer) != null &&
        (reducer = this.reducer) != null) {
        int r = this.basis;
        for (int i = baseIndex, f, h; batch > 0 &&
                 (h = ((f = baseLimit) + i) >>> 1) > i;) {
            addToPendingCount(1);
            (rights = new MapReduceMappingsToIntTask<K,V>
             (this, batch >>>= 1, baseLimit = h, f, tab,
              rights, transformer, r, reducer)).fork();
        }
        for (Node<K,V> p; (p = advance()) != null; )
            r = reducer.applyAsInt(r, transformer.applyAsInt(p.key, p.val));
        result = r;
        CountedCompleter<?> c;
        for (c = firstComplete(); c != null; c = c.nextComplete()) {
            @SuppressWarnings("unchecked")
            MapReduceMappingsToIntTask<K,V>
                t = (MapReduceMappingsToIntTask<K,V>)c,
                s = t.rights;
            while (s != null) {
                t.result = reducer.applyAsInt(t.result, s.result);
                s = t.rights = s.nextRight;
            }
        }
    }
}
 

import java.util.function.IntBinaryOperator; //导入依赖的package包/类
@NonNull
@Override
public MuVector4i map(@NonNull final Vector4i that, @NonNull final IntBinaryOperator operator) {
  this.x = operator.applyAsInt(this.x, that.x());
  this.y = operator.applyAsInt(this.y, that.y());
  this.z = operator.applyAsInt(this.z, that.z());
  this.w = operator.applyAsInt(this.w, that.w());
  return this;
}
 

import java.util.function.IntBinaryOperator; //导入依赖的package包/类
@NonNull
@Override
public MuVector3i map(@NonNull final Vector3i that, @NonNull final IntBinaryOperator operator) {
  this.x = operator.applyAsInt(this.x, that.x());
  this.y = operator.applyAsInt(this.y, that.y());
  this.z = operator.applyAsInt(this.z, that.z());
  return this;
}
 

import java.util.function.IntBinaryOperator; //导入依赖的package包/类
@NonNull
@Override
public MuVector2i map(@NonNull final Vector2i that, @NonNull final IntBinaryOperator operator) {
  this.x = operator.applyAsInt(this.x, that.x());
  this.y = operator.applyAsInt(this.y, that.y());
  return this;
}
 

import java.util.function.IntBinaryOperator; //导入依赖的package包/类
public int traverseGrid(IntBinaryOperator func) {
    AtomicInteger at = new AtomicInteger();
    traversalX.forEach(t_x -> {
        traversalY.forEach(t_y -> {
            at.addAndGet(func.applyAsInt(t_x, t_y));
        });
    });

    return at.get();
}
 

import java.util.function.IntBinaryOperator; //导入依赖的package包/类
private static BiFunction<Integer, Integer, Pair<Integer, Integer[]>> createEqOp(IntBinaryOperator simpleOp)
{
    return (x, y) ->
    {
        int res = simpleOp.applyAsInt(x, y);
        return Pair.of(x, new Integer[]{y, res});
    };
}
 

import java.util.function.IntBinaryOperator; //导入依赖的package包/类
public final int getAndAccumulate(int i, int x, IntBinaryOperator accumulatorFunction) {
    long offset = checkedByteOffset(i);
    int prev, next;
    do {
        prev = getRaw(offset);
        next = accumulatorFunction.applyAsInt(prev, x);
    } while (!compareAndSetRaw(offset, prev, next));
    return prev;
}
 

import java.util.function.IntBinaryOperator; //导入依赖的package包/类
public final int accumulateAndGet(int i, int x, IntBinaryOperator accumulatorFunction) {
    long offset = checkedByteOffset(i);
    int prev, next;
    do {
        prev = getRaw(offset);
        next = accumulatorFunction.applyAsInt(prev, x);
    } while (!compareAndSetRaw(offset, prev, next));
    return next;
}
 

import java.util.function.IntBinaryOperator; //导入依赖的package包/类
public final int getAndAccumulate(int x, IntBinaryOperator accumulatorFunction) {
    int prev, next;
    do {
        prev = value;
        next = accumulatorFunction.applyAsInt(prev, x);
    } while (!compareAndSet(prev, next));
    return prev;
}
 

import java.util.function.IntBinaryOperator; //导入依赖的package包/类
public final int accumulateAndGet(int x, IntBinaryOperator accumulatorFunction) {
    int prev, next;
    do {
        prev = value;
        next = accumulatorFunction.applyAsInt(prev, x);
    } while (!compareAndSet(prev, next));
    return next;
}
 

import java.util.function.IntBinaryOperator; //导入依赖的package包/类
private void bitStringArithmeticAlignedWords(IntBinaryOperator op, int sourceAddr, int destinationAddr, int length) {
    for (int i = 0; i < length; i++) {
        int src = bus.getWord(sourceAddr + i * Integer.BYTES);
        int dst = bus.getWord(destinationAddr + i * Integer.BYTES);
        bus.setWord(destinationAddr + i * Integer.BYTES, op.applyAsInt(src, dst));
    }
}
 

import java.util.function.IntBinaryOperator; //导入依赖的package包/类
/**
 * Constructs a {@code TerminalOp} that implements a functional reduce on
 * {@code int} values.
 *
 * @param identity the identity for the combining function
 * @param operator the combining function
 * @return a {@code TerminalOp} implementing the reduction
 */
public static TerminalOp<Integer, Integer>
makeInt(int identity, IntBinaryOperator operator) {
    Objects.requireNonNull(operator);
    class ReducingSink
            implements AccumulatingSink<Integer, Integer, ReducingSink>, Sink.OfInt {
        private int state;

        @Override
        public void begin(long size) {
            state = identity;
        }

        @Override
        public void accept(int t) {
            state = operator.applyAsInt(state, t);
        }

        @Override
        public Integer get() {
            return state;
        }

        @Override
        public void combine(ReducingSink other) {
            accept(other.state);
        }
    }
    return new ReduceOp<Integer, Integer, ReducingSink>(StreamShape.INT_VALUE) {
        @Override
        public ReducingSink makeSink() {
            return new ReducingSink();
        }
    };
}
 

import java.util.function.IntBinaryOperator; //导入依赖的package包/类
/** Root task constructor */
public IntCumulateTask(IntCumulateTask parent,
                       IntBinaryOperator function,
                       int[] array, int lo, int hi) {
    super(parent);
    this.function = function; this.array = array;
    this.lo = this.origin = lo; this.hi = this.fence = hi;
    int p;
    this.threshold =
            (p = (hi - lo) / (ForkJoinPool.getCommonPoolParallelism() << 3))
            <= MIN_PARTITION ? MIN_PARTITION : p;
}
 

import java.util.function.IntBinaryOperator; //导入依赖的package包/类
private static BinaryOperator<Vec3I> getBinaryOperator(IntBinaryOperator op) {
  return (a, b) -> {
    int x = op.applyAsInt(a.x, b.x);
    int y = op.applyAsInt(a.y, b.y);
    int z = op.applyAsInt(a.z, b.z);
    return new Vec3I(x, y, z);
  };
}