在Java中抛出异常是否代价高昂

Question

我有一些生成迭代器的代码，并使用NoSuchElementException在迭代器的源耗尽时发出信号。当分析这段代码时，我发现99%的时间都花在了方法java.util.NoSuchElementException.<init>上。

我知道异常在c++中很昂贵，但直到现在我还认为它们在Java中没有那么糟糕。

使用异常进行流控制是不好的做法。这是一段时间以前我写的，所以我不记得为什么我这样做了…

在Java中抛出异常是一个昂贵的操作，就时间而言?

---

代码如下:

public abstract class SequenceIterator<E> implements Iterator<E>
{
    /** Caches the next lazily generated solution, when it has already been asked for by {@link #hasNext}. */
    private E nextSolution = null;
    /** Used to indicate that the sequence has been exhausted. */
    private boolean searchExhausted = false;
    /**
     * Generates the next element in the sequence.
     *
     * @return The next element from the sequence if one is available, or <tt>null</tt> if the sequence is complete.
     */
    public abstract E nextInSequence();
    /**
     * Checks if a sequnce has more elements, caching any generated as a result of the check.
     *
     * @return <tt>true</tt> if there are more elements, <tt>false</tt> if not.
     */
    public boolean hasNext()
    {
        boolean hasNext;
        try
        {
            nextInternal();
            hasNext = true;
        }
        catch (NoSuchElementException e)
        {
            // Exception noted so can be ignored, no such element means no more elements, so 'hasNext' is false.
            e = null;
            hasNext = false;
        }
        return hasNext;
    }
    /**
     * Gets the next element from the sequence if one is available. The difference between this method and
     * {@link #nextInSequence} is that this method consumes any cached solution, so subsequent calls advance onto
     * subsequent solutions.
     *
     * @return The next solution from the search space if one is available.
     *
     * @throws NoSuchElementException If no solutions are available.
     */
    public E next()
    {
        // Consume the next element in the sequence, if one is available.
        E result = nextInternal();
        nextSolution = null;
        return result;
    }
    /**
     * Removes from the underlying collection the last element returned by the iterator (optional operation). This
     * method can be called only once per call to <tt>next</tt>. The behavior of an iterator is unspecified if the
     * underlying collection is modified while the iteration is in progress in any way other than by calling this
     * method.
     *
     * @throws UnsupportedOperationException The <tt>remove</tt> operation is not generally supported by lazy sequences.
     */
    public void remove()
    {
        throw new UnsupportedOperationException("Lazy sequences, in general, do not support removal.");
    }
    /**
     * Gets the next element from the sequence, the cached one if one has already been generated, or creating and
     * caching a new one if not. If the cached element from a previous call has not been consumed, then subsequent calls
     * to this method will not advance the iterator.
     *
     * @return The next solution from the search space if one is available.
     *
     * @throws NoSuchElementException If no solutions are available.
     */
    private E nextInternal()
    {
        // Check if the search space is already known to be empty.
        if (searchExhausted)
        {
            throw new NoSuchElementException("Sequence exhausted.");
        }
        // Check if the next soluation has already been cached, because of a call to hasNext.
        if (nextSolution != null)
        {
            return nextSolution;
        }
        // Otherwise, generate the next solution, if possible.
        nextSolution = nextInSequence();
        // Check if the solution was null, which indicates that the search space is exhausted.
        if (nextSolution == null)
        {
            // Raise a no such element exception to signal the iterator cannot continue.
            throw new NoSuchElementException("Seqeuence exhausted.");
        }
        else
        {
            return nextSolution;
        }
    }
}

Answer 1

在流控制中使用异常是不好的做法，但是确实有我在某种程度上被迫做这件事的其他原因迭代器接口不提供返回特殊值的方法表示"no more values left"。

https://docs.oracle.com/javase/8/docs/api/java/util/Iterator.html hasNext——

在Java中抛出一个异常是一个代价昂贵的操作，就花了多少时间?

当然，特别是为异常创建堆栈跟踪是非常昂贵的。我不能100%确定这是否发生在构造函数中或当异常被抛出时，但以下答案表明它发生在构造函数中:https://stackoverflow.com/a/8024032/506855

在任何情况下，正如您自己提到的，如果可以避免，您不应该对控制流使用异常。我认为应该可以重构你提供的代码来避免这种情况。

Answer 2

前面已经提到异常不能替代控制流。但是你不需要使用异常，因为你可以在你的Iterator类中引入状态，它包含了所有必要的信息，用一个共同的辅助方法实现hasNext()和next()。

例如:

public abstract class SequenceIterator<E> implements Iterator<E> {
    private boolean searchExhausted = false;
    private E next;
    private boolean hasNext;
    private boolean nextInitialized;
    public abstract E nextInSequence();
    @Override public boolean hasNext() {
        if (!nextInitialized)
            initNext();
        return hasNext;
    }
    @Override public E next() {
        if (!nextInitialized)
            initNext();
        if (!hasNext())
            throw new NoSuchElementException();
        nextInitialized = false;
        return next;
    }
    private void initNext() {
        hasNext = false;
        nextInitialized = true;
        if (!searchExhausted) {
            next = nextInSequence();
            hasNext = next != null;
        }
    }
}