import java8.util.function.Consumer; //导入依赖的package包/类
@Override
public boolean tryAdvance(Consumer<? super T> action) {
    Objects.requireNonNull(action);

    if (sliceOrigin >= fence)
        return false;

    while (sliceOrigin > index) {
        s.tryAdvance(e -> {});
        index++;
    }

    if (index >= fence)
        return false;

    index++;
    return s.tryAdvance(action);
}
 

import java8.util.function.Consumer; //导入依赖的package包/类
@Override
public void forEachRemaining(Consumer<? super T> action) {
    Objects.requireNonNull(action);

    if (sliceOrigin >= fence)
        return;

    if (index >= fence)
        return;

    if (index >= sliceOrigin && (index + s.estimateSize()) <= sliceFence) {
        // The spliterator is contained within the slice
        s.forEachRemaining(action);
        index = fence;
    } else {
        // The spliterator intersects with the slice
        while (sliceOrigin > index) {
            s.tryAdvance(e -> {});
            index++;
        }
        // Traverse elements up to the fence
        for (;index < fence; index++) {
            s.tryAdvance(action);
        }
    }
}
 

import java8.util.function.Consumer; //导入依赖的package包/类
public void forEachRemaining(Consumer<? super E> action) {
    Objects.requireNonNull(action);
    List<E> lst = list;
    int hi = getFence();
    int i = index;
    index = hi;
    try {
        for (; i < hi; ++i) {
            action.accept(lst.get(i));
        }
    } catch (IndexOutOfBoundsException e) {
        // action must have modified the list
        throw new ConcurrentModificationException();
    }
    checkAbsListModCount(alist, expectedModCount);
}
 

import java8.util.function.Consumer; //导入依赖的package包/类
@Override
public boolean tryAdvance(Consumer<? super Element> action) {
    if (current < elements.size()) {
        action.accept(elements.get(current));
        current++;
        return true;
    } else {
        return false;
    }
}
 

import java8.util.function.Consumer; //导入依赖的package包/类
public <T> CompletableFuture<T> find(final Class<T> entityType, String id) {
    final CompletableFuture<T> promise = new CompletableFuture<>();

    final EntityDefinition entityDef;
    try {
        entityDef = entityDefinitionManager.getDefinition(entityType);
    } catch (Exception e) {
        promise.completeExceptionally(e);
        return promise;
    }

    String path = StringUtils.path(entityDef.getReference(), id);
    connection.read(StringUtils.path(rootPath, path))
            .thenAccept(new Consumer<Data>() {
                @Override
                public void accept(Data entityData) {
                    promise.complete(entityParser.deserialize(entityType, entityData));
                }
            })
            .exceptionally(new Function<Throwable, Void>() {
                @Override
                public Void apply(Throwable throwable) {
                    promise.completeExceptionally(throwable);
                    return null;
                }
            });

    return promise;
}
 

import java8.util.function.Consumer; //导入依赖的package包/类
public <T> CompletableFuture<List<T>> query(final Criteria<T> criteria) {
    final CompletableFuture<List<T>> promise = new CompletableFuture<>();

    final Class<T> entityType = criteria.getEntityType();
    EntityDefinition entityDef;
    try {
        entityDef = entityDefinitionManager.getDefinition(entityType);
    } catch (DefinitionException e) {
        promise.completeExceptionally(e);
        return promise;
    }

    connection.query(StringUtils.path(rootPath, entityDef.getReference()), criteria)
            .thenAccept(new Consumer<Data>() {
                @Override
                public void accept(Data data) {
                    List<T> results = new ArrayList<T>();
                    for (Data entityData : data.getChildren()) {
                        T entity = entityParser.deserialize(entityType, entityData);
                        // Filter
                        if (criteria.match(entity)) {
                            results.add(entity);
                        }
                    }
                    promise.complete(results);
                }
            })
            .exceptionally(new Function<Throwable, Void>() {
                @Override
                public Void apply(Throwable throwable) {
                    promise.completeExceptionally(throwable);
                    return null;
                }
            });

    return promise;
}
 

import java8.util.function.Consumer; //导入依赖的package包/类
private void refreshBalance() {
    if (walletService == null) {
        return;
    }
    //TODO: this may be called twice
    refreshConnectionIcons();
    final Coin coinBalance = walletService.getBalance();

    CompletableFuture<Coin> future = CompletableFuture.supplyAsync(new Supplier<Coin>() {
        @Override
        public Coin get() {
            try {
                Coin virtualBalance = walletService.virtualBalance();
                return coinBalance.add(virtualBalance);
            } catch (final Exception e) {
                Snackbar snackbar = Snackbar.make(getView(), e.getMessage(), Snackbar.LENGTH_LONG);
                snackbar.show();
                e.printStackTrace();
            }
            return Coin.ZERO;
        }
    });

    future.thenAccept(new Consumer<Coin>() {
        @Override
        public void accept(Coin coin) {
            Fiat fiatBalance = walletService.getExchangeRate().coinToFiat(coin);
            refreshBalance(coin, fiatBalance);
        }
    });







}
 

import java8.util.function.Consumer; //导入依赖的package包/类
@Override
@SuppressWarnings("unchecked")
public boolean tryAdvance(Consumer<? super E> action) {
    Objects.requireNonNull(action);
    int i;
    if (getFence() > (i = index)) {
        index = i + 1;
        action.accept((E) array[i]);
        if (expectedModCount != getModCount(list)) {
            throw new ConcurrentModificationException();
        }
        return true;
    }
    return false;
}
 

import java8.util.function.Consumer; //导入依赖的package包/类
@Override
public void forEachRemaining(Consumer<? super T> action) {
    Objects.requireNonNull(action);
    Iterator<? extends T> i;
    if ((i = it) == null) {
        i = it = collection.iterator();
        est = collection.size();
    }
    Iterators.forEachRemaining(i, action);
}
 

import java8.util.function.Consumer; //导入依赖的package包/类
@Override
@SuppressWarnings("unchecked")
public boolean tryAdvance(Consumer<? super E> action) {
    Objects.requireNonNull(action);
    if (getFence() > index && index >= 0) {
        action.accept((E) array[index++]);
        return true;
    }
    return false;
}
 

import java8.util.function.Consumer; //导入依赖的package包/类
@Override
public boolean tryAdvance(Consumer<? super T> consumer) {
    boolean hasNext;
    if (beforeSplit) {
        hasNext = aSpliterator.tryAdvance(consumer);
        if (!hasNext) {
            beforeSplit = false;
            hasNext = bSpliterator.tryAdvance(consumer);
        }
    }
    else
        hasNext = bSpliterator.tryAdvance(consumer);
    return hasNext;
}
 

import java8.util.function.Consumer; //导入依赖的package包/类
public IntSource(T b, Function<? super T, Spliterator.OfInt> toSpliterator,
                 Consumer<T> updater, boolean bindOnCharacteristics) {
    this.b = b;
    this.toSpliterator = toSpliterator;
    this.updater = updater;
    this.bindOnCharacteristics = bindOnCharacteristics;
}
 

import java8.util.function.Consumer; //导入依赖的package包/类
@Override
public boolean tryAdvance(Consumer<? super T> action) {
    Objects.requireNonNull(action);
    if (index >= 0 && index < fence) {
        @SuppressWarnings("unchecked") T e = (T) array[index++];
        action.accept(e);
        return true;
    }
    return false;
}
 

import java8.util.function.Consumer; //导入依赖的package包/类
@Override
public boolean tryAdvance(Consumer<? super E> action) {
    Objects.requireNonNull(action);
    int hi = getFence(), i = index;
    if (i < hi) {
        index = i + 1;
        @SuppressWarnings("unchecked") E e = (E) getData(list)[i];
        action.accept(e);
        if (expectedModCount != getModCount(list)) {
            throw new ConcurrentModificationException();
        }
        return true;
    }
    return false;
}
 

import java8.util.function.Consumer; //导入依赖的package包/类
@Override
public boolean tryAdvance(Consumer<? super E> action) {
    Objects.requireNonNull(action);
    if (!exhausted) {
        E e = null;
        ReentrantLock lock = queueLock;
        lock.lock();
        try {
            Object p;
            if ((p = current) != null || (p = getQueueFirst(queue)) != null)
                do {
                    e = getNodeItem(p);
                    p = succ(p);
                } while (e == null && p != null);
            if ((current = p) == null)
                exhausted = true;
        } finally {
            // checkInvariants();
            lock.unlock();
        }
        if (e != null) {
            action.accept(e);
            return true;
        }
    }
    return false;
}
 

import java8.util.function.Consumer; //导入依赖的package包/类
@Override
public void forEach(Consumer<? super E_OUT> action) {
    if (!isParallel()) {
        sourceStageSpliterator().forEachRemaining(action);
    }
    else {
        super.forEach(action);
    }
}
 

import java8.util.function.Consumer; //导入依赖的package包/类
@Override
public void forEach(Consumer<? super Integer> consumer) {
    if (consumer instanceof IntConsumer) {
        forEach((IntConsumer) consumer);
    }
    else {
        ((Spliterator<Integer>) spliterator()).forEachRemaining(consumer);
    }
}
 

import java8.util.function.Consumer; //导入依赖的package包/类
/**
 * {@inheritDoc}
 *
 * @param consumer A {@code Consumer} that is to be invoked with each
 *        element in this {@code Node}.  If this is an
 *        {@code DoubleConsumer}, it is cast to {@code DoubleConsumer}
 *        so the elements may be processed without boxing.
 */
static void forEach(Node.OfDouble this_, Consumer<? super Double> consumer) {
    if (consumer instanceof DoubleConsumer) {
        this_.forEach((DoubleConsumer) consumer);
    }
    else {
        this_.spliterator().forEachRemaining(consumer);
    }
}
 

import java8.util.function.Consumer; //导入依赖的package包/类
@Override
public void forEachRemaining(Consumer<? super Map.Entry<K, V>> action) {
    Objects.requireNonNull(action);
    int i, hi, mc;
    HashMap<K, V> m = map;
    Object[] tab = getTable(m);
    if ((hi = fence) < 0) {
        mc = expectedModCount = getModCount(m);
        hi = fence = (tab == null) ? 0 : tab.length;
    } else {
        mc = expectedModCount;
    }
    if (tab != null && tab.length >= hi && (i = index) >= 0
            && (i < (index = hi) || current != null)) {
        Object p = current;
        current = null;
        do {
            if (p == null) {
                p = tab[i++];
            } else {
                action.accept((Map.Entry<K, V>) p);
                p = getNextNode(p);
            }
        } while (p != null || i < hi);
        if (mc != getModCount(m)) {
            throw new ConcurrentModificationException();
        }
    }
}
 

import java8.util.function.Consumer; //导入依赖的package包/类
void testRecursiveDecomposition(
    BiConsumer<Integer[], Consumer<Integer>> action) {
    int n = ThreadLocalRandom.current().nextInt(8);
    Integer[] a = new Integer[n];
    for (int i = 0; i < n; i++) a[i] = i + 1;
    AtomicInteger ai = new AtomicInteger(0);
    action.accept(a, ai::addAndGet);
    assertEquals(n * (n + 1) / 2, ai.get());
}